opfs-worker 0.1.1 → 0.2.0

package/dist/raw.js

@@ -0,0 +1,821 @@
+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 S extends o {
+  constructor() {
+    super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
+  }
+}
+class y extends o {
+  constructor() {
+    super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
+  }
+}
+class g extends o {
+  constructor(e, t) {
+    super(e, "INVALID_PATH", t);
+  }
+}
+class m extends o {
+  constructor(e) {
+    super(`File not found: ${e}`, "FILE_NOT_FOUND", e);
+  }
+}
+function A(a, e = "utf-8") {
+  switch (e) {
+    case "utf8":
+    case "utf-8":
+      return new TextEncoder().encode(a);
+    case "utf16le":
+    case "ucs2":
+    case "ucs-2":
+      return I(a);
+    case "ascii":
+      return $(a);
+    case "latin1":
+      return v(a);
+    case "binary":
+      return Uint8Array.from(a, (t) => t.charCodeAt(0));
+    case "base64":
+      return Uint8Array.from(atob(a), (t) => t.charCodeAt(0));
+    case "hex":
+      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(a);
+  }
+}
+function D(a, e = "utf-8") {
+  switch (e) {
+    case "utf8":
+    case "utf-8":
+      return new TextDecoder().decode(a);
+    case "utf16le":
+    case "ucs2":
+    case "ucs-2":
+      return T(a);
+    case "latin1":
+      return String.fromCharCode(...a);
+    case "binary":
+      return String.fromCharCode(...a);
+    case "ascii":
+      return String.fromCharCode(...a.map((t) => t & 127));
+    case "base64":
+      return btoa(String.fromCharCode(...a));
+    case "hex":
+      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(a);
+  }
+}
+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(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 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 $(a) {
+  const e = new Uint8Array(a.length);
+  for (let t = 0; t < a.length; t++)
+    e[t] = a.charCodeAt(t) & 127;
+  return e;
+}
+function N() {
+  if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
+    throw new S();
+}
+function f(a) {
+  return Array.isArray(a) ? a : a.split("/").filter(Boolean);
+}
+function p(a) {
+  return typeof a == "string" ? a ?? "/" : `/${a.join("/")}`;
+}
+function H(a, e = "utf-8") {
+  return typeof a == "string" ? A(a, e) : a instanceof Uint8Array ? a : new Uint8Array(a);
+}
+async function x(a) {
+  const e = await a.createSyncAccessHandle();
+  try {
+    const t = e.getSize(), r = new Uint8Array(t);
+    return e.read(r, { at: 0 }), r;
+  } finally {
+    e.close();
+  }
+}
+async function F(a, e, t, r = {}) {
+  let n = null;
+  try {
+    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 s = r.append ? "append" : "write";
+    throw new o(`Failed to ${s} file`, `${s.toUpperCase()}_FAILED`);
+  } finally {
+    if (n)
+      try {
+        n.close();
+      } catch {
+      }
+  }
+}
+async function O(a, e = "SHA-1") {
+  try {
+    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;
+  }
+}
+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
+   * 
+   * This method sets up the root directory for all subsequent operations.
+   * It must be called before any other file system operations.
+   * 
+   * @param root - The root path for the file system (default: '/')
+   * @returns Promise that resolves to true if initialization was successful
+   * @throws {OPFSError} If initialization fails
+   * 
+   * @example
+   * ```typescript
+   * const fs = new OPFSFileSystem();
+   * const success = await fs.init('/my-app');
+   * ```
+   */
+  async mount(e = "/", t, r) {
+    try {
+      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");
+    }
+  }
+  /**
+   * 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(e, t = !1, r = this.root) {
+    if (!r)
+      throw new y();
+    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;
+  }
+  /**
+   * 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(e, t = !1, r = this.root) {
+    if (!r)
+      throw new y();
+    const n = f(e);
+    if (n.length === 0)
+      throw new g("Path must not be empty", Array.isArray(e) ? e.join("/") : e);
+    const i = n.pop();
+    return (await this.getDirectoryHandle(n, t, r)).getFileHandle(i, { create: t });
+  }
+  /**
+   * Recursively list all files and directories with their stats
+   * 
+   * Traverses the entire file system starting from the root and returns
+   * a Map containing all paths and their corresponding file statistics.
+   * 
+   * @param options - Options for indexing
+   * @param options.includeHash - Whether to calculate file hash (default: false)
+   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
+   * @returns Promise that resolves to a Map of path => FileStat
+   * @throws {OPFSError} If the indexing operation fails
+   * 
+   * @example
+   * ```typescript
+   * // Basic index without hash
+   * const index = await fs.index();
+   * 
+   * // Index with file hash
+   * const indexWithHash = await fs.index({ 
+   *   includeHash: true,
+   *   hashAlgorithm: 'SHA-1'
+   * });
+   * 
+   * // Iterate through all files and directories
+   * for (const [path, stat] of index) {
+   *   console.log(`${path}: ${stat.isFile ? 'file' : 'directory'} (${stat.size} bytes)`);
+   *   if (stat.hash) console.log(`  Hash: ${stat.hash}`);
+   * }
+   * 
+   * // Get specific file stats
+   * 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(e) {
+    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 l = await this.stat(c, e);
+          t.set(c, l), l.isDirectory && await r(c);
+        } catch (l) {
+          console.warn(`Skipping broken entry: ${c}`, l);
+        }
+      }
+    };
+    return t.set("/", {
+      kind: "directory",
+      size: 0,
+      mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      isFile: !1,
+      isDirectory: !0
+    }), await r("/"), t;
+  }
+  async readFile(e, t = "utf-8") {
+    try {
+      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);
+    }
+  }
+  /**
+   * Write data to a file
+   * 
+   * Creates or overwrites a file with the specified data. If the file already
+   * exists, it will be truncated before writing.
+   * 
+   * @param path - The path to the file to write
+   * @param data - The data to write to the file (string, Uint8Array, or ArrayBuffer)
+   * @param encoding - The encoding to use when writing string data (default: 'utf-8')
+   * @returns Promise that resolves when the write operation is complete
+   * @throws {OPFSError} If writing the file fails
+   * 
+   * @example
+   * ```typescript
+   * // Write text data
+   * await fs.writeFile('/config/settings.json', JSON.stringify({ theme: 'dark' }));
+   * 
+   * // Write binary data
+   * const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
+   * await fs.writeFile('/data/binary.dat', binaryData);
+   * 
+   * // Write with specific encoding
+   * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');
+   * ```
+   */
+  async writeFile(e, t, r) {
+    const n = await this.getFileHandle(e, !0);
+    await F(n, t, r, { truncate: !0 });
+  }
+  /**
+   * Append data to a file
+   * 
+   * Adds data to the end of an existing file. If the file doesn't exist,
+   * it will be created.
+   * 
+   * @param path - The path to the file to append to
+   * @param data - The data to append to the file (string, Uint8Array, or ArrayBuffer)
+   * @param encoding - The encoding to use when appending string data (default: 'utf-8')
+   * @returns Promise that resolves when the append operation is complete
+   * @throws {OPFSError} If appending to the file fails
+   * 
+   * @example
+   * ```typescript
+   * // Append text to a log file
+   * await fs.appendFile('/logs/app.log', `[${new Date().toISOString()}] User logged in\n`);
+   * 
+   * // Append binary data
+   * const additionalData = new Uint8Array([6, 7, 8]);
+   * await fs.appendFile('/data/binary.dat', additionalData);
+   * ```
+   */
+  async appendFile(e, t, r) {
+    const n = await this.getFileHandle(e, !0);
+    await F(n, t, r, { append: !0 });
+  }
+  /**
+   * 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(e, t) {
+    if (!this.root)
+      throw new y();
+    const r = t?.recursive ?? !1, n = f(e);
+    let i = this.root;
+    for (let s = 0; s < n.length; s++) {
+      const c = n[s];
+      try {
+        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"
+        ) : l.name === "TypeMismatchError" ? new o(`Path segment is not a directory: ${c}`, "ENOTDIR") : new o("Failed to create directory", "MKDIR_FAILED");
+      }
+    }
+  }
+  /**
+   * Get file or directory stats
+   * 
+   * Retrieves metadata about a file or directory, including size, modification time,
+   * type information, and optionally file hashes.
+   * 
+   * @param path - The path to the file or directory
+   * @param options - Options for stat operation
+   * @param options.includeHash - Whether to calculate file hash (default: false, only for files)
+   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
+   * @returns Promise that resolves to file/directory statistics
+   * @throws {OPFSError} If the file or directory does not exist or cannot be accessed
+   * 
+   * @example
+   * ```typescript
+   * // Basic stats
+   * const stats = await fs.stat('/config/settings.json');
+   * console.log(`File size: ${stats.size} bytes`);
+   * console.log(`Is file: ${stats.isFile}`);
+   * console.log(`Modified: ${stats.mtime}`);
+   * 
+   * // Stats with hash (SHA-1 is fastest)
+   * const statsWithHash = await fs.stat('/config/settings.json', { 
+   *   includeHash: true,
+   *   hashAlgorithm: 'SHA-1'
+   * });
+   * console.log(`Hash: ${statsWithHash.hash}`);
+   * ```
+   */
+  async stat(e, t) {
+    const r = f(e), n = r.pop(), i = await this.getDirectoryHandle(r, !1), s = t?.includeHash ?? !1, c = t?.hashAlgorithm ?? "SHA-1";
+    try {
+      const h = await (await i.getFileHandle(n, { create: !1 })).getFile(), w = {
+        kind: "file",
+        size: h.size,
+        mtime: new Date(h.lastModified).toISOString(),
+        ctime: new Date(h.lastModified).toISOString(),
+        isFile: !0,
+        isDirectory: !1
+      };
+      if (s)
+        try {
+          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 w;
+    } catch (l) {
+      if (l.name !== "TypeMismatchError" && l.name !== "NotFoundError")
+        throw new o("Failed to stat (file)", "STAT_FAILED");
+    }
+    try {
+      return await i.getDirectoryHandle(n, { 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 (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 r = t?.withFileTypes ?? !1, n = await this.getDirectoryHandle(e, !1);
+    if (r) {
+      const i = [];
+      for await (const [s, c] of n.entries()) {
+        const l = c.kind === "file";
+        i.push({
+          name: s,
+          kind: c.kind,
+          isFile: l,
+          isDirectory: !l
+        });
+      }
+      return i;
+    } else {
+      const i = [];
+      for await (const [s] of n.entries())
+        i.push(s);
+      return i;
+    }
+  }
+  /**
+   * 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(e) {
+    const t = f(e), r = t.pop();
+    let n = null;
+    try {
+      n = await this.getDirectoryHandle(t, !1);
+    } catch (i) {
+      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (n = null), i;
+    }
+    if (!n || !r)
+      return !1;
+    try {
+      return await n.getFileHandle(r, { create: !1 }), !0;
+    } catch (i) {
+      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
+        throw i;
+    }
+    try {
+      return await n.getDirectoryHandle(r, { 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(e = "/") {
+    try {
+      const t = await this.readdir(e, { withFileTypes: !0 });
+      for (const r of t) {
+        const n = `${e === "/" ? "" : e}/${r.name}`;
+        await this.remove(n, { recursive: !0 });
+      }
+    } catch (t) {
+      throw t instanceof o ? t : new o(`Failed to clear directory: ${e}`, "CLEAR_FAILED");
+    }
+  }
+  /**
+   * 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(e, t) {
+    const r = t?.recursive ?? !1, n = t?.force ?? !1, i = f(e), s = i.pop();
+    if (!s)
+      throw new g("Invalid path", e);
+    const c = await this.getDirectoryHandle(i, !1);
+    try {
+      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");
+    }
+  }
+  /**
+   * 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(e) {
+    try {
+      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
+            r.push(s);
+      const n = p(r);
+      if (!await this.exists(n))
+        throw new m(n);
+      return n;
+    } catch (t) {
+      throw t instanceof o ? t : new o(`Failed to resolve path: ${e}`, "REALPATH_FAILED");
+    }
+  }
+  /**
+   * Rename a file or directory
+   * 
+   * Changes the name of a file or directory. If the target path already exists,
+   * it will be replaced.
+   * 
+   * @param oldPath - The current path of the file or directory
+   * @param newPath - The new path for the file or directory
+   * @returns Promise that resolves when the rename operation is complete
+   * @throws {OPFSError} If the rename operation fails
+   * 
+   * @example
+   * ```typescript
+   * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
+   * ```
+   */
+  async rename(e, t) {
+    try {
+      if (!await this.exists(e))
+        throw new m(e);
+      await this.copy(e, t, { recursive: !0 }), await this.remove(e, { recursive: !0 });
+    } catch (r) {
+      throw r instanceof o ? r : new o(`Failed to rename from ${e} to ${t}`, "RENAME_FAILED");
+    }
+  }
+  /**
+   * 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.force - 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.cp('/source/file.txt', '/dest/file.txt');
+   * 
+   * // Copy a directory and all its contents
+   * await fs.cp('/source/dir', '/dest/dir', { recursive: true });
+   * 
+   * // Copy without overwriting existing files
+   * await fs.cp('/source', '/dest', { recursive: true, force: false });
+   * ```
+   */
+  async copy(e, t, r) {
+    try {
+      const n = r?.recursive ?? !1, i = r?.force ?? !0;
+      if (!await this.exists(e))
+        throw new o(`Source does not exist: ${e}`, "ENOENT");
+      if (await this.exists(t) && !i)
+        throw new o(`Destination already exists: ${t}`, "EEXIST");
+      if ((await this.stat(e)).isFile) {
+        const h = await this.readFile(e, "binary");
+        await this.writeFile(t, h);
+      } else {
+        if (!n)
+          throw new o(`Cannot copy directory without recursive option: ${e}`, "EISDIR");
+        await this.mkdir(t, { recursive: !0 });
+        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);
+        }
+      }
+    };
+    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;
+      }
+    }
+  }
+  /**
+   * Synchronize the file system with external data
+   * 
+   * Syncs the file system with an array of entries containing paths and data.
+   * This is useful for importing data from external sources or syncing with remote data.
+   * 
+   * @param entries - Array of [path, data] tuples to sync
+   * @param options - Options for synchronization
+   * @param options.cleanBefore - Whether to clear the file system before syncing (default: false)
+   * @returns Promise that resolves when synchronization is complete
+   * @throws {OPFSError} If the synchronization fails
+   * 
+   * @example
+   * ```typescript
+   * // Sync with external data
+   * const entries: [string, string | Uint8Array | Blob][] = [
+   *   ['/config.json', JSON.stringify({ theme: 'dark' })],
+   *   ['/data/binary.dat', new Uint8Array([1, 2, 3, 4])],
+   *   ['/upload.txt', new Blob(['file content'], { type: 'text/plain' })]
+   * ];
+   * 
+   * // Sync without clearing existing files
+   * await fs.sync(entries);
+   * 
+   * // Clean file system and then sync
+   * await fs.sync(entries, { cleanBefore: true });
+   * ```
+   */
+  async sync(e, t) {
+    try {
+      (t?.cleanBefore ?? !1) && await this.clear("/");
+      for (const [n, i] of e) {
+        const s = n.startsWith("/") ? n : `/${n}`;
+        let c;
+        if (i instanceof Blob) {
+          const l = await i.arrayBuffer();
+          c = new Uint8Array(l);
+        } else
+          c = i;
+        await this.writeFile(s, c);
+      }
+    } catch (r) {
+      throw r instanceof o ? r : new o("Failed to sync file system", "SYNC_FAILED");
+    }
+  }
+}
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && E(new U());
+export {
+  U as OPFSWorker
+};
+//# sourceMappingURL=raw.js.map