opfs-worker 0.1.2 → 0.2.0

package/dist/raw.js

@@ -1,146 +1,146 @@
-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";
+import { expose as E } from "comlink";
+class o extends Error {
+  constructor(e, t, r) {
+    super(e), this.code = t, this.path = r, this.name = "OPFSError";
   }
 }
-class A extends s {
+class S extends o {
   constructor() {
     super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
   }
 }
-class y extends s {
+class y extends o {
   constructor() {
     super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
   }
 }
-class g extends s {
+class g extends o {
   constructor(e, t) {
     super(e, "INVALID_PATH", t);
   }
 }
-class m extends s {
+class m extends o {
   constructor(e) {
     super(`File not found: ${e}`, "FILE_NOT_FOUND", e);
   }
 }
-function S(r, e = "utf-8") {
+function A(a, e = "utf-8") {
   switch (e) {
     case "utf8":
     case "utf-8":
-      return new TextEncoder().encode(r);
+      return new TextEncoder().encode(a);
     case "utf16le":
     case "ucs2":
     case "ucs-2":
-      return I(r);
+      return I(a);
     case "ascii":
-      return H(r);
+      return $(a);
     case "latin1":
-      return N(r);
+      return v(a);
     case "binary":
-      return Uint8Array.from(r, (t) => t.charCodeAt(0));
+      return Uint8Array.from(a, (t) => t.charCodeAt(0));
     case "base64":
-      return Uint8Array.from(atob(r), (t) => t.charCodeAt(0));
+      return Uint8Array.from(atob(a), (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)));
+      if (!/^[\da-f]+$/i.test(a) || a.length % 2 !== 0)
+        throw new o("Invalid hex string", "INVALID_HEX_FORMAT");
+      return Uint8Array.from(a.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);
+      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(a);
   }
 }
-function D(r, e = "utf-8") {
+function D(a, e = "utf-8") {
   switch (e) {
     case "utf8":
     case "utf-8":
-      return new TextDecoder().decode(r);
+      return new TextDecoder().decode(a);
     case "utf16le":
     case "ucs2":
     case "ucs-2":
-      return T(r);
+      return T(a);
     case "latin1":
-      return String.fromCharCode(...r);
+      return String.fromCharCode(...a);
     case "binary":
-      return String.fromCharCode(...r);
+      return String.fromCharCode(...a);
     case "ascii":
-      return String.fromCharCode(...r.map((t) => t & 127));
+      return String.fromCharCode(...a.map((t) => t & 127));
     case "base64":
-      return btoa(String.fromCharCode(...r));
+      return btoa(String.fromCharCode(...a));
     case "hex":
-      return Array.from(r).map((t) => t.toString(16).padStart(2, "0")).join("");
+      return Array.from(a).map((t) => t.toString(16).padStart(2, "0")).join("");
     default:
-      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(r);
+      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(a);
   }
 }
-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;
+function I(a) {
+  const e = new Uint8Array(a.length * 2);
+  for (let t = 0; t < a.length; t++) {
+    const r = a.charCodeAt(t);
+    e[t * 2] = r & 255, e[t * 2 + 1] = r >> 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);
+function T(a) {
+  a.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), a = a.slice(0, a.length - 1));
+  const e = new Uint16Array(a.buffer, a.byteOffset, a.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;
+function v(a) {
+  const e = new Uint8Array(a.length);
+  for (let t = 0; t < a.length; t++)
+    e[t] = a.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;
+function $(a) {
+  const e = new Uint8Array(a.length);
+  for (let t = 0; t < a.length; t++)
+    e[t] = a.charCodeAt(t) & 127;
   return e;
 }
-function $() {
+function N() {
   if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
-    throw new A();
+    throw new S();
 }
-function u(r) {
-  return Array.isArray(r) ? r : r.split("/").filter(Boolean);
+function f(a) {
+  return Array.isArray(a) ? a : a.split("/").filter(Boolean);
 }
-function F(r) {
-  return typeof r == "string" ? r ?? "/" : `/${r.join("/")}`;
+function p(a) {
+  return typeof a == "string" ? a ?? "/" : `/${a.join("/")}`;
 }
-function O(r, e = "utf-8") {
-  return typeof r == "string" ? S(r, e) : r instanceof Uint8Array ? r : new Uint8Array(r);
+function H(a, e = "utf-8") {
+  return typeof a == "string" ? A(a, e) : a instanceof Uint8Array ? a : new Uint8Array(a);
 }
-async function x(r) {
-  const e = await r.createSyncAccessHandle();
+async function x(a) {
+  const e = await a.createSyncAccessHandle();
   try {
-    const t = e.getSize(), n = new Uint8Array(t);
-    return e.read(n, { at: 0 }), n;
+    const t = e.getSize(), r = new Uint8Array(t);
+    return e.read(r, { at: 0 }), r;
   } finally {
     e.close();
   }
 }
-async function E(r, e, t, n = {}) {
-  let o = null;
+async function F(a, e, t, r = {}) {
+  let n = 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();
+    n = await a.createSyncAccessHandle();
+    const i = H(e, t), s = r.append ? n.getSize() : 0;
+    n.write(i, { at: s }), r.truncate && !r.append && n.truncate(i.byteLength), n.flush();
   } catch (i) {
     console.error(i);
-    const a = n.append ? "append" : "write";
-    throw new s(`Failed to ${a} file`, `${a.toUpperCase()}_FAILED`);
+    const s = r.append ? "append" : "write";
+    throw new o(`Failed to ${s} file`, `${s.toUpperCase()}_FAILED`);
   } finally {
-    if (o)
+    if (n)
       try {
-        o.close();
+        n.close();
       } catch {
       }
   }
 }
-async function v(r, e = "SHA-1") {
+async function O(a, 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("");
+    const t = new Uint8Array(a), r = await crypto.subtle.digest(e, t);
+    return Array.from(new Uint8Array(r)).map((i) => i.toString(16).padStart(2, "0")).join("");
   } catch (t) {
     throw console.warn(`Failed to calculate ${e} hash:`, t), t;
   }
@@ -148,13 +148,23 @@ async function v(r, e = "SHA-1") {
 class U {
   /** 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() {
-    $();
+    N();
   }
   /**
    * Initialize the file system within a given directory
@@ -172,12 +182,12 @@ class U {
    * const success = await fs.init('/my-app');
    * ```
    */
-  async mount(e = "/") {
+  async mount(e = "/", t, r) {
     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 n = await navigator.storage.getDirectory();
+      return this.root = await this.getDirectoryHandle(e, !0, n), t && (this.watchCallback = t, r?.watchInterval && (this.watchInterval = r.watchInterval)), !0;
+    } catch (n) {
+      throw console.error(n), new o("Failed to initialize OPFS", "INIT_FAILED");
     }
   }
   /**
@@ -198,13 +208,13 @@ class U {
    * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
    * ```
    */
-  async getDirectoryHandle(e, t = !1, n = this.root) {
-    if (!n)
+  async getDirectoryHandle(e, t = !1, r = this.root) {
+    if (!r)
       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 });
+    const n = Array.isArray(e) ? e : f(e);
+    let i = r;
+    for (const s of n)
+      i = await i.getDirectoryHandle(s, { create: t });
     return i;
   }
   /**
@@ -226,14 +236,14 @@ class U {
    * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
    * ```
    */
-  async getFileHandle(e, t = !1, n = this.root) {
-    if (!n)
+  async getFileHandle(e, t = !1, r = this.root) {
+    if (!r)
       throw new y();
-    const o = u(e);
-    if (o.length === 0)
+    const n = f(e);
+    if (n.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 });
+    const i = n.pop();
+    return (await this.getDirectoryHandle(n, t, r)).getFileHandle(i, { create: t });
   }
   /**
    * Recursively list all files and directories with their stats
@@ -273,15 +283,15 @@ 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}`;
+    const t = /* @__PURE__ */ new Map(), r = async (n) => {
+      const i = await this.readdir(n, { withFileTypes: !0 });
+      for (const s of i) {
+        const c = `${n === "/" ? "" : n}/${s.name}`;
         try {
-          const c = await this.stat(l, e);
-          t.set(l, c), c.isDirectory && await n(l);
-        } catch (c) {
-          console.warn(`Skipping broken entry: ${l}`, c);
+          const l = await this.stat(c, e);
+          t.set(c, l), l.isDirectory && await r(c);
+        } catch (l) {
+          console.warn(`Skipping broken entry: ${c}`, l);
         }
       }
     };
@@ -292,14 +302,14 @@ class U {
       ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
       isFile: !1,
       isDirectory: !0
-    }), await n("/"), t;
+    }), await r("/"), t;
   }
   async readFile(e, t = "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 r = await this.getFileHandle(e, !1), n = await x(r);
+      return t === "binary" ? n : D(n, t);
+    } catch (r) {
+      throw console.error(r), new m(e);
     }
   }
   /**
@@ -327,9 +337,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(e, t, r) {
+    const n = await this.getFileHandle(e, !0);
+    await F(n, t, r, { truncate: !0 });
   }
   /**
    * Append data to a file
@@ -353,9 +363,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(e, t, r) {
+    const n = await this.getFileHandle(e, !0);
+    await F(n, t, r, { append: !0 });
   }
   /**
    * Create a directory
@@ -381,17 +391,17 @@ class U {
   async mkdir(e, t) {
     if (!this.root)
       throw new y();
-    const n = t?.recursive ?? !1, o = u(e);
+    const r = t?.recursive ?? !1, n = f(e);
     let i = this.root;
-    for (let a = 0; a < o.length; a++) {
-      const l = o[a];
+    for (let s = 0; s < n.length; s++) {
+      const c = n[s];
       try {
-        i = await i.getDirectoryHandle(l, { create: n || a === o.length - 1 });
-      } catch (c) {
-        throw c.name === "NotFoundError" ? new s(
-          `Parent directory does not exist: ${F(o.slice(0, a + 1))}`,
+        i = await i.getDirectoryHandle(c, { create: r || s === n.length - 1 });
+      } catch (l) {
+        throw l.name === "NotFoundError" ? new o(
+          `Parent directory does not exist: ${p(n.slice(0, s + 1))}`,
           "ENOENT"
-        ) : c.name === "TypeMismatchError" ? new s(`Path segment is not a directory: ${l}`, "ENOTDIR") : new s("Failed to create directory", "MKDIR_FAILED");
+        ) : l.name === "TypeMismatchError" ? new o(`Path segment is not a directory: ${c}`, "ENOTDIR") : new o("Failed to create directory", "MKDIR_FAILED");
       }
     }
   }
@@ -425,30 +435,30 @@ class U {
    * ```
    */
   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";
+    const r = f(e), n = r.pop(), i = await this.getDirectoryHandle(r, !1), s = t?.includeHash ?? !1, c = t?.hashAlgorithm ?? "SHA-1";
     try {
-      const f = await (await i.getFileHandle(o, { create: !1 })).getFile(), h = {
+      const h = await (await i.getFileHandle(n, { create: !1 })).getFile(), w = {
         kind: "file",
-        size: f.size,
-        mtime: new Date(f.lastModified).toISOString(),
-        ctime: new Date(f.lastModified).toISOString(),
+        size: h.size,
+        mtime: new Date(h.lastModified).toISOString(),
+        ctime: new Date(h.lastModified).toISOString(),
         isFile: !0,
         isDirectory: !1
       };
-      if (a)
+      if (s)
         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 u = new Uint8Array(await h.arrayBuffer()), d = await O(u, c);
+          w.hash = d;
+        } catch (u) {
+          console.warn(`Failed to calculate hash for ${e}:`, u);
         }
-      return h;
-    } catch (c) {
-      if (c.name !== "TypeMismatchError" && c.name !== "NotFoundError")
-        throw new s("Failed to stat (file)", "STAT_FAILED");
+      return w;
+    } catch (l) {
+      if (l.name !== "TypeMismatchError" && l.name !== "NotFoundError")
+        throw new o("Failed to stat (file)", "STAT_FAILED");
     }
     try {
-      return await i.getDirectoryHandle(o, { create: !1 }), {
+      return await i.getDirectoryHandle(n, { create: !1 }), {
         kind: "directory",
         size: 0,
         mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
@@ -457,28 +467,28 @@ class U {
         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 (l) {
+      throw l.name === "NotFoundError" ? new o(`No such file or directory: ${e}`, "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) {
+    const r = t?.withFileTypes ?? !1, n = await this.getDirectoryHandle(e, !1);
+    if (r) {
       const i = [];
-      for await (const [a, l] of o.entries()) {
-        const c = l.kind === "file";
+      for await (const [s, c] of n.entries()) {
+        const l = c.kind === "file";
         i.push({
-          name: a,
-          kind: l.kind,
-          isFile: c,
-          isDirectory: !c
+          name: s,
+          kind: c.kind,
+          isFile: l,
+          isDirectory: !l
         });
       }
       return i;
     } else {
       const i = [];
-      for await (const [a] of o.entries())
-        i.push(a);
+      for await (const [s] of n.entries())
+        i.push(s);
       return i;
     }
   }
@@ -497,23 +507,23 @@ class U {
    * ```
    */
   async exists(e) {
-    const t = u(e), n = t.pop();
-    let o = null;
+    const t = f(e), r = t.pop();
+    let n = null;
     try {
-      o = await this.getDirectoryHandle(t, !1);
+      n = await this.getDirectoryHandle(t, !1);
     } catch (i) {
-      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (o = null), i;
+      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
     }
-    if (!o || !n)
+    if (!n || !r)
       return !1;
     try {
-      return await o.getFileHandle(n, { create: !1 }), !0;
+      return await n.getFileHandle(r, { create: !1 }), !0;
     } catch (i) {
       if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
         throw i;
     }
     try {
-      return await o.getDirectoryHandle(n, { create: !1 }), !0;
+      return await n.getDirectoryHandle(r, { create: !1 }), !0;
     } catch (i) {
       if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
         throw i;
@@ -542,12 +552,12 @@ class U {
   async clear(e = "/") {
     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 });
+      for (const r of t) {
+        const n = `${e === "/" ? "" : e}/${r.name}`;
+        await this.remove(n, { recursive: !0 });
       }
     } catch (t) {
-      throw t instanceof s ? t : new s(`Failed to clear directory: ${e}`, "CLEAR_FAILED");
+      throw t instanceof o ? t : new o(`Failed to clear directory: ${e}`, "CLEAR_FAILED");
     }
   }
   /**
@@ -575,17 +585,17 @@ class U {
    * ```
    */
   async remove(e, t) {
-    const n = t?.recursive ?? !1, o = t?.force ?? !1, i = u(e), a = i.pop();
-    if (!a)
+    const r = t?.recursive ?? !1, n = t?.force ?? !1, i = f(e), s = i.pop();
+    if (!s)
       throw new g("Invalid path", e);
-    const l = await this.getDirectoryHandle(i, !1);
+    const c = await this.getDirectoryHandle(i, !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 c.removeEntry(s, { recursive: r });
+    } catch (l) {
+      if (l.name === "NotFoundError") {
+        if (!n)
+          throw new o(`No such file or directory: ${e}`, "ENOENT");
+      } else throw l.name === "InvalidModificationError" ? new o(`Directory not empty: ${e}. Use recursive option to force removal.`, "ENOTEMPTY") : l.name === "TypeMismatchError" && !r ? new o(`Cannot remove directory without recursive option: ${e}`, "EISDIR") : new o(`Failed to remove path: ${e}`, "RM_FAILED");
     }
   }
   /**
@@ -608,21 +618,21 @@ class U {
    */
   async realpath(e) {
     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();
+      const t = f(e), r = [];
+      for (const s of t)
+        if (!(s === "." || s === ""))
+          if (s === "..") {
+            if (r.length === 0)
+              throw new o("Path escapes root", "EINVAL");
+            r.length > 0 && r.pop();
           } else
-            n.push(a);
-      const o = F(n);
-      if (!await this.exists(o))
-        throw new m(o);
-      return o;
+            r.push(s);
+      const n = p(r);
+      if (!await this.exists(n))
+        throw new m(n);
+      return n;
     } catch (t) {
-      throw t instanceof s ? t : new s(`Failed to resolve path: ${e}`, "REALPATH_FAILED");
+      throw t instanceof o ? t : new o(`Failed to resolve path: ${e}`, "REALPATH_FAILED");
     }
   }
   /**
@@ -646,8 +656,8 @@ class U {
       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");
+    } catch (r) {
+      throw r instanceof o ? r : new o(`Failed to rename from ${e} to ${t}`, "RENAME_FAILED");
     }
   }
   /**
@@ -675,28 +685,87 @@ class U {
    * await fs.cp('/source', '/dest', { recursive: true, force: false });
    * ```
    */
-  async copy(e, t, n) {
+  async copy(e, t, r) {
     try {
-      const o = n?.recursive ?? !1, i = n?.force ?? !0;
+      const n = r?.recursive ?? !1, i = r?.force ?? !0;
       if (!await this.exists(e))
-        throw new s(`Source does not exist: ${e}`, "ENOENT");
+        throw new o(`Source does not exist: ${e}`, "ENOENT");
       if (await this.exists(t) && !i)
-        throw new s(`Destination already exists: ${t}`, "EEXIST");
+        throw new o(`Destination already exists: ${t}`, "EEXIST");
       if ((await this.stat(e)).isFile) {
-        const f = await this.readFile(e, "binary");
-        await this.writeFile(t, f);
+        const h = await this.readFile(e, "binary");
+        await this.writeFile(t, h);
       } else {
-        if (!o)
-          throw new s(`Cannot copy directory without recursive option: ${e}`, "EISDIR");
+        if (!n)
+          throw new o(`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 });
+        const h = await this.readdir(e, { withFileTypes: !0 });
+        for (const w of h) {
+          const u = `${e}/${w.name}`, d = `${t}/${w.name}`;
+          await this.copy(u, d, { recursive: !0, force: i });
+        }
+      }
+    } catch (n) {
+      throw n instanceof o ? n : new o(`Failed to copy from ${e} to ${t}`, "CP_FAILED");
+    }
+  }
+  /**
+   * Start watching a file or directory for changes
+   */
+  async watch(e) {
+    const t = e.startsWith("/") ? e : `/${e}`, r = await this.buildSnapshot(t);
+    this.watchers.set(t, r), this.watchTimer || (this.watchTimer = setInterval(() => {
+      this.scanWatches();
+    }, this.watchInterval));
+  }
+  /**
+   * Stop watching a previously watched path
+   */
+  unwatch(e) {
+    const t = e.startsWith("/") ? e : `/${e}`;
+    this.watchers.delete(t), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
+  }
+  async buildSnapshot(e) {
+    const t = /* @__PURE__ */ new Map(), r = async (n) => {
+      const i = await this.stat(n);
+      if (t.set(n, i), i.isDirectory) {
+        const s = await this.readdir(n, { withFileTypes: !0 });
+        for (const c of s) {
+          const l = `${n === "/" ? "" : n}/${c.name}`;
+          await r(l);
         }
       }
-    } catch (o) {
-      throw o instanceof s ? o : new s(`Failed to copy from ${e} to ${t}`, "CP_FAILED");
+    };
+    return await r(e), t;
+  }
+  async scanWatches() {
+    if (!this.scanning) {
+      this.scanning = !0;
+      try {
+        await Promise.all(
+          [...this.watchers.entries()].map(async ([e, t]) => {
+            let r;
+            try {
+              r = await this.buildSnapshot(e);
+            } catch {
+              r = /* @__PURE__ */ new Map();
+            }
+            const n = [];
+            for (const [i, s] of r) {
+              const c = t.get(i);
+              c ? (c.mtime !== s.mtime || c.size !== s.size) && n.push({ path: i, type: "change" }) : n.push({ path: i, type: "create" });
+            }
+            for (const i of t.keys())
+              r.has(i) || n.push({ path: i, type: "delete" });
+            if (n.length && this.watchCallback)
+              for (const i of n)
+                this.watchCallback(i);
+            this.watchers.set(e, r);
+          })
+        );
+      } finally {
+        this.scanning = !1;
+      }
     }
   }
   /**
@@ -730,22 +799,22 @@ class U {
   async sync(e, t) {
     try {
       (t?.cleanBefore ?? !1) && await this.clear("/");
-      for (const [o, i] of e) {
-        const a = o.startsWith("/") ? o : `/${o}`;
-        let l;
+      for (const [n, i] of e) {
+        const s = n.startsWith("/") ? n : `/${n}`;
+        let c;
         if (i instanceof Blob) {
-          const c = await i.arrayBuffer();
-          l = new Uint8Array(c);
+          const l = await i.arrayBuffer();
+          c = new Uint8Array(l);
         } else
-          l = i;
-        await this.writeFile(a, l);
+          c = i;
+        await this.writeFile(s, c);
       }
-    } catch (n) {
-      throw n instanceof s ? n : new s("Failed to sync file system", "SYNC_FAILED");
+    } catch (r) {
+      throw r instanceof o ? r : new o("Failed to sync file system", "SYNC_FAILED");
     }
   }
 }
-p(new U());
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && E(new U());
 export {
   U as OPFSWorker
 };