opfs-worker 0.1.2 → 0.2.1

package/dist/raw.js

@@ -1,160 +1,25 @@
 import { expose as p } from "comlink";
-class s extends Error {
-  constructor(e, t, n) {
-    super(e), this.code = t, this.path = n, this.name = "OPFSError";
-  }
-}
-class A extends s {
-  constructor() {
-    super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
-  }
-}
-class y extends s {
-  constructor() {
-    super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
-  }
-}
-class g extends s {
-  constructor(e, t) {
-    super(e, "INVALID_PATH", t);
-  }
-}
-class m extends s {
-  constructor(e) {
-    super(`File not found: ${e}`, "FILE_NOT_FOUND", e);
-  }
-}
-function S(r, e = "utf-8") {
-  switch (e) {
-    case "utf8":
-    case "utf-8":
-      return new TextEncoder().encode(r);
-    case "utf16le":
-    case "ucs2":
-    case "ucs-2":
-      return I(r);
-    case "ascii":
-      return H(r);
-    case "latin1":
-      return N(r);
-    case "binary":
-      return Uint8Array.from(r, (t) => t.charCodeAt(0));
-    case "base64":
-      return Uint8Array.from(atob(r), (t) => t.charCodeAt(0));
-    case "hex":
-      if (!/^[\da-f]+$/i.test(r) || r.length % 2 !== 0)
-        throw new s("Invalid hex string", "INVALID_HEX_FORMAT");
-      return Uint8Array.from(r.match(/.{1,2}/g).map((t) => parseInt(t, 16)));
-    default:
-      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(r);
-  }
-}
-function D(r, e = "utf-8") {
-  switch (e) {
-    case "utf8":
-    case "utf-8":
-      return new TextDecoder().decode(r);
-    case "utf16le":
-    case "ucs2":
-    case "ucs-2":
-      return T(r);
-    case "latin1":
-      return String.fromCharCode(...r);
-    case "binary":
-      return String.fromCharCode(...r);
-    case "ascii":
-      return String.fromCharCode(...r.map((t) => t & 127));
-    case "base64":
-      return btoa(String.fromCharCode(...r));
-    case "hex":
-      return Array.from(r).map((t) => t.toString(16).padStart(2, "0")).join("");
-    default:
-      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(r);
-  }
-}
-function I(r) {
-  const e = new Uint8Array(r.length * 2);
-  for (let t = 0; t < r.length; t++) {
-    const n = r.charCodeAt(t);
-    e[t * 2] = n & 255, e[t * 2 + 1] = n >> 8;
-  }
-  return e;
-}
-function T(r) {
-  r.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), r = r.slice(0, r.length - 1));
-  const e = new Uint16Array(r.buffer, r.byteOffset, r.byteLength / 2);
-  return String.fromCharCode(...e);
-}
-function N(r) {
-  const e = new Uint8Array(r.length);
-  for (let t = 0; t < r.length; t++)
-    e[t] = r.charCodeAt(t) & 255;
-  return e;
-}
-function H(r) {
-  const e = new Uint8Array(r.length);
-  for (let t = 0; t < r.length; t++)
-    e[t] = r.charCodeAt(t) & 127;
-  return e;
-}
-function $() {
-  if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
-    throw new A();
-}
-function u(r) {
-  return Array.isArray(r) ? r : r.split("/").filter(Boolean);
-}
-function F(r) {
-  return typeof r == "string" ? r ?? "/" : `/${r.join("/")}`;
-}
-function O(r, e = "utf-8") {
-  return typeof r == "string" ? S(r, e) : r instanceof Uint8Array ? r : new Uint8Array(r);
-}
-async function x(r) {
-  const e = await r.createSyncAccessHandle();
-  try {
-    const t = e.getSize(), n = new Uint8Array(t);
-    return e.read(n, { at: 0 }), n;
-  } finally {
-    e.close();
-  }
-}
-async function E(r, e, t, n = {}) {
-  let o = null;
-  try {
-    o = await r.createSyncAccessHandle();
-    const i = O(e, t), a = n.append ? o.getSize() : 0;
-    o.write(i, { at: a }), n.truncate && !n.append && o.truncate(i.byteLength), o.flush();
-  } catch (i) {
-    console.error(i);
-    const a = n.append ? "append" : "write";
-    throw new s(`Failed to ${a} file`, `${a.toUpperCase()}_FAILED`);
-  } finally {
-    if (o)
-      try {
-        o.close();
-      } catch {
-      }
-  }
-}
-async function v(r, e = "SHA-1") {
-  try {
-    const t = new Uint8Array(r), n = await crypto.subtle.digest(e, t);
-    return Array.from(new Uint8Array(n)).map((i) => i.toString(16).padStart(2, "0")).join("");
-  } catch (t) {
-    throw console.warn(`Failed to calculate ${e} hash:`, t), t;
-  }
-}
-class U {
+import { d as v, O as o, b as f, s as y, P as E, i as I, o as S, F as d, w as g, j as T, e as u, f as m, k as H, r as $, n as F, l as A } from "./helpers-Co-qCBmA.js";
+class N {
   /** Root directory handle for the file system */
   root = null;
+  /** Watch event callback */
+  watchCallback = null;
+  /** Map of watched paths to their last known state */
+  watchers = /* @__PURE__ */ new Map();
+  /** Interval handle for polling watched paths */
+  watchTimer = null;
+  /** Polling interval in milliseconds */
+  watchInterval = 1e3;
+  /** Flag to avoid concurrent scans */
+  scanning = !1;
   /**
    * Creates a new OPFSFileSystem instance
    * 
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
   constructor() {
-    $();
+    v();
   }
   /**
    * Initialize the file system within a given directory
@@ -172,12 +37,12 @@ class U {
    * const success = await fs.init('/my-app');
    * ```
    */
-  async mount(e = "/") {
+  async mount(t = "/", e, a) {
     try {
-      const t = await navigator.storage.getDirectory();
-      return this.root = await this.getDirectoryHandle(e, !0, t), !0;
-    } catch (t) {
-      throw console.error(t), new s("Failed to initialize OPFS", "INIT_FAILED");
+      const r = await navigator.storage.getDirectory();
+      return this.root = await this.getDirectoryHandle(t, !0, r), e && (this.watchCallback = e, a?.watchInterval && (this.watchInterval = a.watchInterval)), !0;
+    } catch (r) {
+      throw console.error(r), new o("Failed to initialize OPFS", "INIT_FAILED");
     }
   }
   /**
@@ -198,13 +63,13 @@ class U {
    * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
    * ```
    */
-  async getDirectoryHandle(e, t = !1, n = this.root) {
-    if (!n)
-      throw new y();
-    const o = Array.isArray(e) ? e : u(e);
-    let i = n;
-    for (const a of o)
-      i = await i.getDirectoryHandle(a, { create: t });
+  async getDirectoryHandle(t, e = !1, a = this.root) {
+    if (!a)
+      throw new f();
+    const r = Array.isArray(t) ? t : y(t);
+    let i = a;
+    for (const n of r)
+      i = await i.getDirectoryHandle(n, { create: e });
     return i;
   }
   /**
@@ -226,14 +91,14 @@ class U {
    * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
    * ```
    */
-  async getFileHandle(e, t = !1, n = this.root) {
-    if (!n)
-      throw new y();
-    const o = u(e);
-    if (o.length === 0)
-      throw new g("Path must not be empty", Array.isArray(e) ? e.join("/") : e);
-    const i = o.pop();
-    return (await this.getDirectoryHandle(o, t, n)).getFileHandle(i, { create: t });
+  async getFileHandle(t, e = !1, a = this.root) {
+    if (!a)
+      throw new f();
+    const r = y(t);
+    if (r.length === 0)
+      throw new E("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+    const i = r.pop();
+    return (await this.getDirectoryHandle(r, e, a)).getFileHandle(i, { create: e });
   }
   /**
    * Recursively list all files and directories with their stats
@@ -272,34 +137,34 @@ class U {
    * }
    * ```
    */
-  async index(e) {
-    const t = /* @__PURE__ */ new Map(), n = async (o) => {
-      const i = await this.readdir(o, { withFileTypes: !0 });
-      for (const a of i) {
-        const l = `${o === "/" ? "" : o}/${a.name}`;
+  async index(t) {
+    const e = /* @__PURE__ */ new Map(), a = async (r) => {
+      const i = await this.readdir(r, { withFileTypes: !0 });
+      for (const n of i) {
+        const s = `${r === "/" ? "" : r}/${n.name}`;
         try {
-          const c = await this.stat(l, e);
-          t.set(l, c), c.isDirectory && await n(l);
+          const c = await this.stat(s, t);
+          e.set(s, c), c.isDirectory && await a(s);
         } catch (c) {
-          console.warn(`Skipping broken entry: ${l}`, c);
+          console.warn(`Skipping broken entry: ${s}`, c);
         }
       }
     };
-    return t.set("/", {
+    return e.set("/", {
       kind: "directory",
       size: 0,
       mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
       ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
       isFile: !1,
       isDirectory: !0
-    }), await n("/"), t;
+    }), await a("/"), e;
   }
-  async readFile(e, t = "utf-8") {
+  async readFile(t, e = "utf-8") {
     try {
-      const n = await this.getFileHandle(e, !1), o = await x(n);
-      return t === "binary" ? o : D(o, t);
-    } catch (n) {
-      throw console.error(n), new m(e);
+      const a = await this.getFileHandle(t, !1), r = await I(a);
+      return e === "binary" ? r : S(r, e);
+    } catch (a) {
+      throw console.error(a), new d(t);
     }
   }
   /**
@@ -327,9 +192,9 @@ class U {
    * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');
    * ```
    */
-  async writeFile(e, t, n) {
-    const o = await this.getFileHandle(e, !0);
-    await E(o, t, n, { truncate: !0 });
+  async writeFile(t, e, a) {
+    const r = await this.getFileHandle(t, !0);
+    await g(r, e, a, { truncate: !0 });
   }
   /**
    * Append data to a file
@@ -353,9 +218,9 @@ class U {
    * await fs.appendFile('/data/binary.dat', additionalData);
    * ```
    */
-  async appendFile(e, t, n) {
-    const o = await this.getFileHandle(e, !0);
-    await E(o, t, n, { append: !0 });
+  async appendFile(t, e, a) {
+    const r = await this.getFileHandle(t, !0);
+    await g(r, e, a, { append: !0 });
   }
   /**
    * Create a directory
@@ -378,20 +243,20 @@ class U {
    * await fs.mkdir('/users/john/documents/projects', { recursive: true });
    * ```
    */
-  async mkdir(e, t) {
+  async mkdir(t, e) {
     if (!this.root)
-      throw new y();
-    const n = t?.recursive ?? !1, o = u(e);
+      throw new f();
+    const a = e?.recursive ?? !1, r = y(t);
     let i = this.root;
-    for (let a = 0; a < o.length; a++) {
-      const l = o[a];
+    for (let n = 0; n < r.length; n++) {
+      const s = r[n];
       try {
-        i = await i.getDirectoryHandle(l, { create: n || a === o.length - 1 });
+        i = await i.getDirectoryHandle(s, { create: a || n === r.length - 1 });
       } catch (c) {
-        throw c.name === "NotFoundError" ? new s(
-          `Parent directory does not exist: ${F(o.slice(0, a + 1))}`,
+        throw c.name === "NotFoundError" ? new o(
+          `Parent directory does not exist: ${T(r.slice(0, n + 1))}`,
           "ENOENT"
-        ) : c.name === "TypeMismatchError" ? new s(`Path segment is not a directory: ${l}`, "ENOTDIR") : new s("Failed to create directory", "MKDIR_FAILED");
+        ) : c.name === "TypeMismatchError" ? new o(`Path segment is not a directory: ${s}`, "ENOTDIR") : new o("Failed to create directory", "MKDIR_FAILED");
       }
     }
   }
@@ -424,52 +289,51 @@ class U {
    * console.log(`Hash: ${statsWithHash.hash}`);
    * ```
    */
-  async stat(e, t) {
-    const n = u(e), o = n.pop(), i = await this.getDirectoryHandle(n, !1), a = t?.includeHash ?? !1, l = t?.hashAlgorithm ?? "SHA-1";
+  async stat(t, e) {
+    const a = u(t), r = await this.getDirectoryHandle(m(t), !1), i = e?.includeHash ?? !1, n = e?.hashAlgorithm ?? "SHA-1";
     try {
-      const f = await (await i.getFileHandle(o, { create: !1 })).getFile(), h = {
+      const c = await (await r.getFileHandle(a, { create: !1 })).getFile(), l = {
         kind: "file",
-        size: f.size,
-        mtime: new Date(f.lastModified).toISOString(),
-        ctime: new Date(f.lastModified).toISOString(),
+        size: c.size,
+        mtime: new Date(c.lastModified).toISOString(),
+        ctime: new Date(c.lastModified).toISOString(),
         isFile: !0,
         isDirectory: !1
       };
-      if (a)
+      if (i)
         try {
-          const w = new Uint8Array(await f.arrayBuffer()), d = await v(w, l);
-          h.hash = d;
-        } catch (w) {
-          console.warn(`Failed to calculate hash for ${e}:`, w);
+          const h = new Uint8Array(await c.arrayBuffer()), w = await H(h, n);
+          l.hash = w;
+        } catch (h) {
+          console.warn(`Failed to calculate hash for ${t}:`, h);
         }
-      return h;
-    } catch (c) {
-      if (c.name !== "TypeMismatchError" && c.name !== "NotFoundError")
-        throw new s("Failed to stat (file)", "STAT_FAILED");
+      return l;
+    } catch (s) {
+      if (s.name !== "TypeMismatchError" && s.name !== "NotFoundError")
+        throw new o("Failed to stat (file)", "STAT_FAILED");
     }
     try {
-      return await i.getDirectoryHandle(o, { create: !1 }), {
+      return await r.getDirectoryHandle(a, { create: !1 }), {
         kind: "directory",
         size: 0,
         mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
         ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
         isFile: !1,
         isDirectory: !0
-        // Directories don't have hashes
       };
-    } catch (c) {
-      throw c.name === "NotFoundError" ? new s(`No such file or directory: ${e}`, "ENOENT") : new s("Failed to stat (directory)", "STAT_FAILED");
+    } catch (s) {
+      throw s.name === "NotFoundError" ? new o(`No such file or directory: ${t}`, "ENOENT") : new o("Failed to stat (directory)", "STAT_FAILED");
     }
   }
-  async readdir(e, t) {
-    const n = t?.withFileTypes ?? !1, o = await this.getDirectoryHandle(e, !1);
-    if (n) {
+  async readdir(t, e) {
+    const a = e?.withFileTypes ?? !1, r = await this.getDirectoryHandle(t, !1);
+    if (a) {
       const i = [];
-      for await (const [a, l] of o.entries()) {
-        const c = l.kind === "file";
+      for await (const [n, s] of r.entries()) {
+        const c = s.kind === "file";
         i.push({
-          name: a,
-          kind: l.kind,
+          name: n,
+          kind: s.kind,
           isFile: c,
           isDirectory: !c
         });
@@ -477,8 +341,8 @@ class U {
       return i;
     } else {
       const i = [];
-      for await (const [a] of o.entries())
-        i.push(a);
+      for await (const [n] of r.entries())
+        i.push(n);
       return i;
     }
   }
@@ -496,27 +360,27 @@ class U {
    * console.log(`File exists: ${exists}`);
    * ```
    */
-  async exists(e) {
-    const t = u(e), n = t.pop();
-    let o = null;
+  async exists(t) {
+    const e = u(t);
+    let a = null;
     try {
-      o = await this.getDirectoryHandle(t, !1);
-    } catch (i) {
-      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (o = null), i;
+      a = await this.getDirectoryHandle(m(t), !1);
+    } catch (r) {
+      throw (r.name === "NotFoundError" || r.name === "TypeMismatchError") && (a = null), r;
     }
-    if (!o || !n)
+    if (!a || !e)
       return !1;
     try {
-      return await o.getFileHandle(n, { create: !1 }), !0;
-    } catch (i) {
-      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
-        throw i;
+      return await a.getFileHandle(e, { create: !1 }), !0;
+    } catch (r) {
+      if (r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+        throw r;
     }
     try {
-      return await o.getDirectoryHandle(n, { create: !1 }), !0;
-    } catch (i) {
-      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
-        throw i;
+      return await a.getDirectoryHandle(e, { create: !1 }), !0;
+    } catch (r) {
+      if (r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+        throw r;
     }
     return !1;
   }
@@ -539,15 +403,15 @@ class U {
    * await fs.clear('/data');
    * ```
    */
-  async clear(e = "/") {
+  async clear(t = "/") {
     try {
-      const t = await this.readdir(e, { withFileTypes: !0 });
-      for (const n of t) {
-        const o = `${e === "/" ? "" : e}/${n.name}`;
-        await this.remove(o, { recursive: !0 });
+      const e = await this.readdir(t, { withFileTypes: !0 });
+      for (const a of e) {
+        const r = `${t === "/" ? "" : t}/${a.name}`;
+        await this.remove(r, { recursive: !0 });
       }
-    } catch (t) {
-      throw t instanceof s ? t : new s(`Failed to clear directory: ${e}`, "CLEAR_FAILED");
+    } catch (e) {
+      throw e instanceof o ? e : new o(`Failed to clear directory: ${t}`, "CLEAR_FAILED");
     }
   }
   /**
@@ -574,18 +438,18 @@ class U {
    * await fs.rm('/maybe/exists', { force: true });
    * ```
    */
-  async remove(e, t) {
-    const n = t?.recursive ?? !1, o = t?.force ?? !1, i = u(e), a = i.pop();
-    if (!a)
-      throw new g("Invalid path", e);
-    const l = await this.getDirectoryHandle(i, !1);
+  async remove(t, e) {
+    const a = e?.recursive ?? !1, r = e?.force ?? !1, i = u(t);
+    if (!i)
+      throw new E("Invalid path", t);
+    const n = await this.getDirectoryHandle(m(t), !1);
     try {
-      await l.removeEntry(a, { recursive: n });
-    } catch (c) {
-      if (c.name === "NotFoundError") {
-        if (!o)
-          throw new s(`No such file or directory: ${e}`, "ENOENT");
-      } else throw c.name === "InvalidModificationError" ? new s(`Directory not empty: ${e}. Use recursive option to force removal.`, "ENOTEMPTY") : c.name === "TypeMismatchError" && !n ? new s(`Cannot remove directory without recursive option: ${e}`, "EISDIR") : new s(`Failed to remove path: ${e}`, "RM_FAILED");
+      await n.removeEntry(i, { recursive: a });
+    } catch (s) {
+      if (s.name === "NotFoundError") {
+        if (!r)
+          throw new o(`No such file or directory: ${t}`, "ENOENT");
+      } else throw s.name === "InvalidModificationError" ? new o(`Directory not empty: ${t}. Use recursive option to force removal.`, "ENOTEMPTY") : s.name === "TypeMismatchError" && !a ? new o(`Cannot remove directory without recursive option: ${t}`, "EISDIR") : new o(`Failed to remove path: ${t}`, "RM_FAILED");
     }
   }
   /**
@@ -606,23 +470,14 @@ class U {
    * console.log(absolute); // '/data/file.txt'
    * ```
    */
-  async realpath(e) {
+  async realpath(t) {
     try {
-      const t = u(e), n = [];
-      for (const a of t)
-        if (!(a === "." || a === ""))
-          if (a === "..") {
-            if (n.length === 0)
-              throw new s("Path escapes root", "EINVAL");
-            n.length > 0 && n.pop();
-          } else
-            n.push(a);
-      const o = F(n);
-      if (!await this.exists(o))
-        throw new m(o);
-      return o;
-    } catch (t) {
-      throw t instanceof s ? t : new s(`Failed to resolve path: ${e}`, "REALPATH_FAILED");
+      const e = $(t);
+      if (!await this.exists(e))
+        throw new d(e);
+      return e;
+    } catch (e) {
+      throw e instanceof o ? e : new o(`Failed to resolve path: ${t}`, "REALPATH_FAILED");
     }
   }
   /**
@@ -641,13 +496,13 @@ class U {
    * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
    * ```
    */
-  async rename(e, t) {
+  async rename(t, e) {
     try {
-      if (!await this.exists(e))
-        throw new m(e);
-      await this.copy(e, t, { recursive: !0 }), await this.remove(e, { recursive: !0 });
-    } catch (n) {
-      throw n instanceof s ? n : new s(`Failed to rename from ${e} to ${t}`, "RENAME_FAILED");
+      if (!await this.exists(t))
+        throw new d(t);
+      await this.copy(t, e, { recursive: !0 }), await this.remove(t, { recursive: !0 });
+    } catch (a) {
+      throw a instanceof o ? a : new o(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED");
     }
   }
   /**
@@ -675,28 +530,87 @@ class U {
    * await fs.cp('/source', '/dest', { recursive: true, force: false });
    * ```
    */
-  async copy(e, t, n) {
+  async copy(t, e, a) {
     try {
-      const o = n?.recursive ?? !1, i = n?.force ?? !0;
-      if (!await this.exists(e))
-        throw new s(`Source does not exist: ${e}`, "ENOENT");
-      if (await this.exists(t) && !i)
-        throw new s(`Destination already exists: ${t}`, "EEXIST");
-      if ((await this.stat(e)).isFile) {
-        const f = await this.readFile(e, "binary");
-        await this.writeFile(t, f);
+      const r = a?.recursive ?? !1, i = a?.force ?? !0;
+      if (!await this.exists(t))
+        throw new o(`Source does not exist: ${t}`, "ENOENT");
+      if (await this.exists(e) && !i)
+        throw new o(`Destination already exists: ${e}`, "EEXIST");
+      if ((await this.stat(t)).isFile) {
+        const l = await this.readFile(t, "binary");
+        await this.writeFile(e, l);
       } else {
-        if (!o)
-          throw new s(`Cannot copy directory without recursive option: ${e}`, "EISDIR");
-        await this.mkdir(t, { recursive: !0 });
-        const f = await this.readdir(e, { withFileTypes: !0 });
-        for (const h of f) {
-          const w = `${e}/${h.name}`, d = `${t}/${h.name}`;
-          await this.copy(w, d, { recursive: !0, force: i });
+        if (!r)
+          throw new o(`Cannot copy directory without recursive option: ${t}`, "EISDIR");
+        await this.mkdir(e, { recursive: !0 });
+        const l = await this.readdir(t, { withFileTypes: !0 });
+        for (const h of l) {
+          const w = `${t}/${h.name}`, D = `${e}/${h.name}`;
+          await this.copy(w, D, { recursive: !0, force: i });
+        }
+      }
+    } catch (r) {
+      throw r instanceof o ? r : new o(`Failed to copy from ${t} to ${e}`, "CP_FAILED");
+    }
+  }
+  /**
+   * Start watching a file or directory for changes
+   */
+  async watch(t) {
+    const e = F(t), a = await this.buildSnapshot(e);
+    this.watchers.set(e, a), this.watchTimer || (this.watchTimer = setInterval(() => {
+      this.scanWatches();
+    }, this.watchInterval));
+  }
+  /**
+   * Stop watching a previously watched path
+   */
+  unwatch(t) {
+    const e = F(t);
+    this.watchers.delete(e), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
+  }
+  async buildSnapshot(t) {
+    const e = /* @__PURE__ */ new Map(), a = async (r) => {
+      const i = await this.stat(r);
+      if (e.set(r, i), i.isDirectory) {
+        const n = await this.readdir(r, { withFileTypes: !0 });
+        for (const s of n) {
+          const c = `${r === "/" ? "" : r}/${s.name}`;
+          await a(c);
         }
       }
-    } catch (o) {
-      throw o instanceof s ? o : new s(`Failed to copy from ${e} to ${t}`, "CP_FAILED");
+    };
+    return await a(t), e;
+  }
+  async scanWatches() {
+    if (!this.scanning) {
+      this.scanning = !0;
+      try {
+        await Promise.all(
+          [...this.watchers.entries()].map(async ([t, e]) => {
+            let a;
+            try {
+              a = await this.buildSnapshot(t);
+            } catch {
+              a = /* @__PURE__ */ new Map();
+            }
+            const r = [];
+            for (const [i, n] of a) {
+              const s = e.get(i);
+              s ? (s.mtime !== n.mtime || s.size !== n.size) && r.push({ path: i, type: "change" }) : r.push({ path: i, type: "create" });
+            }
+            for (const i of e.keys())
+              a.has(i) || r.push({ path: i, type: "delete" });
+            if (r.length && this.watchCallback)
+              for (const i of r)
+                this.watchCallback(i);
+            this.watchers.set(t, a);
+          })
+        );
+      } finally {
+        this.scanning = !1;
+      }
     }
   }
   /**
@@ -727,26 +641,21 @@ class U {
    * await fs.sync(entries, { cleanBefore: true });
    * ```
    */
-  async sync(e, t) {
+  async sync(t, e) {
     try {
-      (t?.cleanBefore ?? !1) && await this.clear("/");
-      for (const [o, i] of e) {
-        const a = o.startsWith("/") ? o : `/${o}`;
-        let l;
-        if (i instanceof Blob) {
-          const c = await i.arrayBuffer();
-          l = new Uint8Array(c);
-        } else
-          l = i;
-        await this.writeFile(a, l);
+      (e?.cleanBefore ?? !1) && await this.clear("/");
+      for (const [r, i] of t) {
+        const n = F(r);
+        let s;
+        i instanceof Blob ? s = await A(i) : s = i, await this.writeFile(n, s);
       }
-    } catch (n) {
-      throw n instanceof s ? n : new s("Failed to sync file system", "SYNC_FAILED");
+    } catch (a) {
+      throw a instanceof o ? a : new o("Failed to sync file system", "SYNC_FAILED");
     }
   }
 }
-p(new U());
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && p(new N());
 export {
-  U as OPFSWorker
+  N as OPFSWorker
 };
 //# sourceMappingURL=raw.js.map