opfs-worker 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,752 +1,26 @@
-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";
-  }
+/**
+ * Main export for OPFS Worker library
+ *
+ * This is the main entry point for the library, providing both the inline worker
+ * functionality and all the necessary types and interfaces.
+ *
+ * @example
+ * ```typescript
+ * import { createWorker, type OPFSWorker } from 'opfs-worker';
+ *
+ * const fs = await createWorker();
+ * await fs.mount('/my-app');
+ * await fs.writeFile('/test.txt', 'Hello World');
+ * ```
+ */
+import { wrap } from 'comlink';
+import WorkerCtor from './worker?worker&inline';
+// Export all types
+export * from './types';
+/**
+ * Creates a new file system instance with inline worker
+ * @returns Promise resolving to the file system interface
+ */
+export function createWorker() {
+    return wrap(new WorkerCtor());
 }
-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 {
-  /** Root directory handle for the file system */
-  root = null;
-  /**
-   * Creates a new OPFSFileSystem instance
-   * 
-   * @throws {OPFSError} If OPFS is not supported in the current browser
-   */
-  constructor() {
-    $();
-  }
-  /**
-   * 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 = "/") {
-    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");
-    }
-  }
-  /**
-   * 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, 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 });
-    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, 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 });
-  }
-  /**
-   * 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(), n = async (o) => {
-      const i = await this.readdir(o, { withFileTypes: !0 });
-      for (const a of i) {
-        const l = `${o === "/" ? "" : o}/${a.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);
-        }
-      }
-    };
-    return t.set("/", {
-      kind: "directory",
-      size: 0,
-      mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
-      ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
-      isFile: !1,
-      isDirectory: !0
-    }), await n("/"), 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);
-    }
-  }
-  /**
-   * 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, n) {
-    const o = await this.getFileHandle(e, !0);
-    await E(o, t, n, { 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, n) {
-    const o = await this.getFileHandle(e, !0);
-    await E(o, t, n, { 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 n = t?.recursive ?? !1, o = u(e);
-    let i = this.root;
-    for (let a = 0; a < o.length; a++) {
-      const l = o[a];
-      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))}`,
-          "ENOENT"
-        ) : c.name === "TypeMismatchError" ? new s(`Path segment is not a directory: ${l}`, "ENOTDIR") : new s("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 n = u(e), o = n.pop(), i = await this.getDirectoryHandle(n, !1), a = t?.includeHash ?? !1, l = t?.hashAlgorithm ?? "SHA-1";
-    try {
-      const f = await (await i.getFileHandle(o, { create: !1 })).getFile(), h = {
-        kind: "file",
-        size: f.size,
-        mtime: new Date(f.lastModified).toISOString(),
-        ctime: new Date(f.lastModified).toISOString(),
-        isFile: !0,
-        isDirectory: !1
-      };
-      if (a)
-        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);
-        }
-      return h;
-    } catch (c) {
-      if (c.name !== "TypeMismatchError" && c.name !== "NotFoundError")
-        throw new s("Failed to stat (file)", "STAT_FAILED");
-    }
-    try {
-      return await i.getDirectoryHandle(o, { 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");
-    }
-  }
-  async readdir(e, t) {
-    const n = t?.withFileTypes ?? !1, o = await this.getDirectoryHandle(e, !1);
-    if (n) {
-      const i = [];
-      for await (const [a, l] of o.entries()) {
-        const c = l.kind === "file";
-        i.push({
-          name: a,
-          kind: l.kind,
-          isFile: c,
-          isDirectory: !c
-        });
-      }
-      return i;
-    } else {
-      const i = [];
-      for await (const [a] of o.entries())
-        i.push(a);
-      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 = u(e), n = t.pop();
-    let o = null;
-    try {
-      o = await this.getDirectoryHandle(t, !1);
-    } catch (i) {
-      throw (i.name === "NotFoundError" || i.name === "TypeMismatchError") && (o = null), i;
-    }
-    if (!o || !n)
-      return !1;
-    try {
-      return await o.getFileHandle(n, { create: !1 }), !0;
-    } catch (i) {
-      if (i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
-        throw i;
-    }
-    try {
-      return await o.getDirectoryHandle(n, { 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 n of t) {
-        const o = `${e === "/" ? "" : e}/${n.name}`;
-        await this.remove(o, { recursive: !0 });
-      }
-    } catch (t) {
-      throw t instanceof s ? t : new s(`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 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);
-    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");
-    }
-  }
-  /**
-   * 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 = 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");
-    }
-  }
-  /**
-   * 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 (n) {
-      throw n instanceof s ? n : new s(`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, n) {
-    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);
-      } 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 });
-        }
-      }
-    } catch (o) {
-      throw o instanceof s ? o : new s(`Failed to copy from ${e} to ${t}`, "CP_FAILED");
-    }
-  }
-  /**
-   * 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 [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);
-      }
-    } catch (n) {
-      throw n instanceof s ? n : new s("Failed to sync file system", "SYNC_FAILED");
-    }
-  }
-}
-p(new U());
-export {
-  U as OPFSWorker
-};
-//# sourceMappingURL=index.js.map