opfs-worker 1.0.1 → 1.2.0

package/dist/raw.js

@@ -1,6 +1,6 @@
-import { expose as v } from "comlink";
-import { m as h, d as p, O as o, n as u, s as w, P as S, i as d, o as b, y as C, F as f, p as g, j as x, e as F, f as m, q as A, v as I, r as H, g as $, u as O } from "./helpers-CTCvNFs1.js";
-class T {
+import { expose as x, transfer as u } from "comlink";
+import { O as o, o as m, g as A, n as g, s as F, P as C, w as d, F as D, j as b, h as E, k as p, u as H, y as $, r as v, l as T, C as O, A as S, z as I, B as N, f, x as P } from "./helpers-CkNHswLp.js";
+class _ {
   /** Root directory handle for the file system */
   root;
   /** Map of watched paths and options */
@@ -14,9 +14,23 @@ class T {
     root: "/",
     namespace: "",
     maxFileSize: 50 * 1024 * 1024,
-    hashAlgorithm: null,
+    hashAlgorithm: !1,
     broadcastChannel: "opfs-worker"
   };
+  /** Map of open file descriptors to their metadata */
+  openFiles = /* @__PURE__ */ new Map();
+  /** Next available file descriptor number */
+  nextFd = 1;
+  /**
+   * Get file info by descriptor with validation
+   * @private
+   */
+  _getFileDescriptor(t) {
+    const e = this.openFiles.get(t);
+    if (!e)
+      throw new o(`Invalid file descriptor: ${t}`, "EBADF");
+    return e;
+  }
   /**
    * Notify about internal changes to the file system
    * 
@@ -30,7 +44,7 @@ class T {
     if (!this.options.broadcastChannel)
       return;
     const e = t.path;
-    if (![...this.watchers.values()].some((r) => h(e, r.pattern) && r.include.some((s) => s && h(e, s)) && !r.exclude.some((s) => s && h(e, s))))
+    if (![...this.watchers.values()].some((r) => m(e, r.pattern) && r.include.some((s) => s && m(e, s)) && !r.exclude.some((s) => s && m(e, s))))
       return;
     let i;
     if (this.options.hashAlgorithm)
@@ -62,7 +76,7 @@ class T {
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
   constructor(t) {
-    p(), t && this.setOptions(t);
+    A(), t && this.setOptions(t);
   }
   /**
    * Initialize the file system within a given directory
@@ -109,7 +123,7 @@ class T {
    * @param options.broadcastChannel - Custom name for the broadcast channel
    */
   async setOptions(t) {
-    t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel), t.namespace && (this.options.namespace = t.namespace), t.root !== void 0 && (this.options.root = u(t.root), this.options.namespace || (this.options.namespace = `opfs-worker:${this.options.root}`), await this.mount());
+    t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel), t.namespace && (this.options.namespace = t.namespace), t.root !== void 0 && (this.options.root = g(t.root), this.options.namespace || (this.options.namespace = `opfs-worker:${this.options.root}`), await this.mount());
   }
   /**
    * Get a directory handle from a path
@@ -130,7 +144,7 @@ class T {
    * ```
    */
   async getDirectoryHandle(t, e = !1, a = this.root) {
-    const i = Array.isArray(t) ? t : w(t);
+    const i = Array.isArray(t) ? t : F(t);
     let r = a;
     for (const s of i)
       r = await r.getDirectoryHandle(s, { create: e });
@@ -156,9 +170,9 @@ class T {
    * ```
    */
   async getFileHandle(t, e = !1, a = this.root) {
-    const i = w(t);
+    const i = F(t);
     if (i.length === 0)
-      throw new S("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+      throw new C("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
     const r = i.pop();
     return (await this.getDirectoryHandle(i, e, a)).getFileHandle(r, { create: e });
   }
@@ -203,71 +217,111 @@ class T {
       isDirectory: !0
     }), await e("/"), t;
   }
-  async readFile(t, e) {
-    await this.mount(), e || (e = d(t) ? "binary" : "utf-8");
+  /**
+   * Read a file from the file system
+   * 
+   * Reads the contents of a file and returns it as binary data.
+   * 
+   * @param path - The path to the file to read
+   * @returns Promise that resolves to the file contents as Uint8Array
+   * @throws {FileNotFoundError} If the file does not exist
+   * @throws {OPFSError} If reading the file fails
+   * 
+   * @example
+   * ```typescript
+   * // Read as binary data
+   * const content = await fs.readFile('/config/settings.json');
+   * 
+   * // Read binary file
+   * const binaryData = await fs.readFile('/images/logo.png');
+   * ```
+   */
+  async readFile(t) {
+    await this.mount();
     try {
-      const a = await this.getFileHandle(t, !1, this.root), i = await b(a, t);
-      return e === "binary" ? i : C(i, e);
-    } catch (a) {
-      throw new f(t, a);
+      return await d(t, "shared", async () => {
+        const e = await this.open(t);
+        try {
+          const { size: a } = await this.fstat(e), i = new Uint8Array(a);
+          return a > 0 && await this.read(e, i, 0, a, 0), u(i, [i.buffer]);
+        } finally {
+          await this.close(e);
+        }
+      });
+    } catch (e) {
+      throw new D(t, e);
     }
   }
   /**
    * Write data to a file
    * 
-   * Creates or overwrites a file with the specified data. If the file already
+   * Creates or overwrites a file with the specified binary 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')
+   * @param data - The binary data to write to the file (Uint8Array or ArrayBuffer)
    * @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');
+   * // Write from ArrayBuffer
+   * const arrayBuffer = new ArrayBuffer(10);
+   * await fs.writeFile('/data/buffer.dat', arrayBuffer);
    * ```
    */
-  async writeFile(t, e, a) {
+  async writeFile(t, e) {
     await this.mount();
-    const i = await this.exists(t), r = await this.getFileHandle(t, !0);
-    a || (a = typeof e != "string" || d(t) ? "binary" : "utf-8"), await g(r, e, a, t), i ? await this.notifyChange({ path: t, type: "changed", isDirectory: !1 }) : await this.notifyChange({ path: t, type: "added", isDirectory: !1 });
+    const a = e instanceof Uint8Array ? e : new Uint8Array(e);
+    await d(t, "exclusive", async () => {
+      const i = await this.exists(t), r = await this.open(t, { create: !0, truncate: !0 });
+      try {
+        await this.write(r, a, 0, a.length, null, !1), await this.fsync(r);
+      } finally {
+        await this.close(r);
+      }
+      await this.notifyChange({ path: t, type: i ? "changed" : "added", isDirectory: !1 });
+    });
   }
   /**
    * Append data to a file
    * 
-   * Adds data to the end of an existing file. If the file doesn't exist,
+   * Adds binary 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')
+   * @param data - The binary data to append to the file (Uint8Array or ArrayBuffer)
    * @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);
+   * 
+   * // Append from ArrayBuffer
+   * const arrayBuffer = new ArrayBuffer(5);
+   * await fs.appendFile('/data/buffer.dat', arrayBuffer);
    * ```
    */
-  async appendFile(t, e, a) {
+  async appendFile(t, e) {
     await this.mount();
-    const i = await this.getFileHandle(t, !0);
-    a || (a = typeof e != "string" || d(t) ? "binary" : "utf-8"), await g(i, e, a, t, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    const a = e instanceof Uint8Array ? e : new Uint8Array(e);
+    await d(t, "exclusive", async () => {
+      const i = await this.open(t, { create: !0 });
+      try {
+        const { size: r } = await this.fstat(i);
+        await this.write(i, a, 0, a.length, r, !1), await this.fsync(i);
+      } finally {
+        await this.close(i);
+      }
+      await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    });
   }
   /**
    * Create a directory
@@ -292,7 +346,7 @@ class T {
    */
   async mkdir(t, e) {
     await this.mount();
-    const a = e?.recursive ?? !1, i = w(t);
+    const a = e?.recursive ?? !1, i = F(t);
     let r = this.root;
     for (let s = 0; s < i.length; s++) {
       const n = i[s];
@@ -300,7 +354,7 @@ class T {
         r = await r.getDirectoryHandle(n, { create: a || s === i.length - 1 });
       } catch (c) {
         throw c.name === "NotFoundError" ? new o(
-          `Parent directory does not exist: ${x(i.slice(0, s + 1))}`,
+          `Parent directory does not exist: ${b(i.slice(0, s + 1))}`,
           "ENOENT",
           void 0,
           c
@@ -341,7 +395,7 @@ class T {
         isFile: !1,
         isDirectory: !0
       };
-    const e = F(t), a = await this.getDirectoryHandle(m(t), !1), i = this.options.hashAlgorithm !== null;
+    const e = E(t), a = await this.getDirectoryHandle(p(t), !1), i = this.options.hashAlgorithm !== null;
     try {
       const s = await (await a.getFileHandle(e, { create: !1 })).getFile(), n = {
         kind: "file",
@@ -353,7 +407,7 @@ class T {
       };
       if (i && this.options.hashAlgorithm)
         try {
-          const c = await A(s, this.options.hashAlgorithm, this.options.maxFileSize);
+          const c = await H(s, this.options.hashAlgorithm, this.options.maxFileSize);
           n.hash = c;
         } catch (c) {
           console.warn(`Failed to calculate hash for ${t}:`, c);
@@ -425,10 +479,10 @@ class T {
   async exists(t) {
     if (await this.mount(), t === "/")
       return !0;
-    const e = F(t);
+    const e = E(t);
     let a = null;
     try {
-      a = await this.getDirectoryHandle(m(t), !1);
+      a = await this.getDirectoryHandle(p(t), !1);
     } catch (i) {
       if (a = null, i.name !== "NotFoundError" && i.name !== "TypeMismatchError")
         throw i;
@@ -508,8 +562,8 @@ class T {
   async remove(t, e) {
     if (await this.mount(), t === "/")
       throw new o("Cannot remove root directory", "EROOT");
-    const { recursive: a = !1, force: i = !1 } = e || {}, r = await this.getDirectoryHandle(m(t), !1);
-    await I(r, t, { recursive: a, force: i }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
+    const { recursive: a = !1, force: i = !1 } = e || {}, r = await this.getDirectoryHandle(p(t), !1), s = await this.stat(t);
+    await $(r, t, { recursive: a, force: i }), await this.notifyChange({ path: t, type: "removed", isDirectory: s.isDirectory });
   }
   /**
    * Resolve a path to an absolute path
@@ -532,9 +586,9 @@ class T {
   async realpath(t) {
     await this.mount();
     try {
-      const e = H(t);
+      const e = v(t);
       if (!await this.exists(e))
-        throw new f(e);
+        throw new D(e);
       return e;
     } catch (e) {
       throw e instanceof o ? e : new o(`Failed to resolve path: ${t}`, "REALPATH_FAILED", void 0, e);
@@ -565,12 +619,10 @@ class T {
   async rename(t, e, a) {
     await this.mount();
     try {
-      const i = a?.overwrite ?? !1;
-      if (!await this.exists(t))
-        throw new f(t);
+      const i = a?.overwrite ?? !1, r = await this.stat(t);
       if (await this.exists(e) && !i)
         throw new o(`Destination already exists: ${e}`, "EEXIST", void 0);
-      await this.copy(t, e, { recursive: !0, overwrite: i }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 }), await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
+      await this.copy(t, e, { recursive: !0, overwrite: i }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: r.isDirectory }), await this.notifyChange({ path: e, type: "added", isDirectory: r.isDirectory });
     } catch (i) {
       throw i instanceof o ? i : new o(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED", void 0, i);
     }
@@ -609,16 +661,16 @@ class T {
       if (await this.exists(e) && !r)
         throw new o(`Destination already exists: ${e}`, "EEXIST", void 0);
       if ((await this.stat(t)).isFile) {
-        const l = await this.readFile(t, "binary");
+        const l = await this.readFile(t);
         await this.writeFile(e, l);
       } else {
         if (!i)
           throw new o(`Cannot copy directory without recursive option: ${t}`, "EISDIR", void 0);
         await this.mkdir(e, { recursive: !0 });
         const l = await this.readDir(t);
-        for (const y of l) {
-          const D = `${t}/${y.name}`, E = `${e}/${y.name}`;
-          await this.copy(D, E, { recursive: !0, overwrite: r });
+        for (const h of l) {
+          const w = `${t}/${h.name}`, y = `${e}/${h.name}`;
+          await this.copy(w, y, { recursive: !0, overwrite: r });
         }
       }
     } catch (i) {
@@ -654,7 +706,7 @@ class T {
     if (!this.options.broadcastChannel)
       throw new o("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.", "ENOENT");
     const a = {
-      pattern: $(t, e?.recursive ?? !0),
+      pattern: T(t, e?.recursive ?? !0),
       include: Array.isArray(e?.include) ? e.include : [e?.include ?? "**"],
       exclude: Array.isArray(e?.exclude) ? e.exclude : [e?.exclude ?? ""]
     };
@@ -666,6 +718,223 @@ class T {
   unwatch(t) {
     this.watchers.delete(t);
   }
+  /**
+   * Open a file and return a file descriptor
+   * 
+   * @param path - The path to the file to open
+   * @param options - Options for opening the file
+   * @param options.create - Whether to create the file if it doesn't exist (default: false)
+   * @param options.exclusive - If true and create is true, fails if file already exists (default: false)
+   *                            Note: This is best-effort in OPFS, not fully atomic due to browser limitations
+   * @param options.truncate - Whether to truncate the file to zero length (default: false)
+   * @returns Promise that resolves to a file descriptor number
+   * @throws {OPFSError} If opening the file fails
+   * 
+   * @example
+   * ```typescript
+   * // Open existing file for reading
+   * const fd = await fs.open('/data/config.json');
+   * 
+   * // Create new file for writing
+   * const fd = await fs.open('/data/new.txt', { create: true });
+   * 
+   * // Create file exclusively (fails if exists)
+   * const fd = await fs.open('/data/unique.txt', { create: true, exclusive: true });
+   * 
+   * // Open and truncate file
+   * const fd = await fs.open('/data/log.txt', { create: true, truncate: true });
+   * ```
+   */
+  async open(t, e) {
+    await this.mount();
+    const { create: a = !1, exclusive: i = !1, truncate: r = !1 } = e || {}, s = g(v(t));
+    try {
+      return a && i ? await d(s, "exclusive", async () => {
+        if (await this.exists(s))
+          throw new o(`File already exists: ${s}`, "EEXIST", s);
+        return this._openFile(s, a, r);
+      }) : await this._openFile(s, a, r);
+    } catch (n) {
+      throw n instanceof o ? n : new o(`Failed to open file: ${s}`, "OPEN_FAILED", s, n);
+    }
+  }
+  /**
+   * Internal method to open a file (without locking)
+   * @private
+   */
+  async _openFile(t, e, a) {
+    const i = await this.getFileHandle(t, e);
+    try {
+      await i.getFile();
+    } catch (n) {
+      throw n.name === "TypeMismatchError" ? new o(`Is a directory: ${t}`, "EISDIR", t) : n;
+    }
+    const r = await O(i, t);
+    a && (r.truncate(0), r.flush());
+    const s = this.nextFd++;
+    return this.openFiles.set(s, {
+      path: t,
+      fileHandle: i,
+      syncHandle: r,
+      position: 0
+    }), s;
+  }
+  /**
+   * Close a file descriptor
+   * 
+   * @param fd - The file descriptor to close
+   * @returns Promise that resolves when the file descriptor is closed
+   * @throws {OPFSError} If the file descriptor is invalid or closing fails
+   * 
+   * @example
+   * ```typescript
+   * const fd = await fs.open('/data/file.txt');
+   * // ... use the file descriptor ...
+   * await fs.close(fd);
+   * ```
+   */
+  async close(t) {
+    const e = this._getFileDescriptor(t);
+    S(t, e.syncHandle, e.path), this.openFiles.delete(t);
+  }
+  /**
+   * Read data from a file descriptor
+   * 
+   * @param fd - The file descriptor to read from
+   * @param buffer - The buffer to read data into
+   * @param offset - The offset in the buffer to start writing at
+   * @param length - The number of bytes to read
+   * @param position - The position in the file to read from (null for current position)
+   * @returns Promise that resolves to the number of bytes read and the modified buffer
+   * @throws {OPFSError} If the file descriptor is invalid or reading fails
+   * 
+   * @note This method uses Comlink.transfer() to efficiently pass the buffer as a Transferable Object,
+   *       ensuring zero-copy performance across Web Worker boundaries.
+   * 
+   * @example
+   * ```typescript
+   * const fd = await fs.open('/data/file.txt');
+   * const buffer = new Uint8Array(1024);
+   * const { bytesRead, buffer: modifiedBuffer } = await fs.read(fd, buffer, 0, 1024, null);
+   * console.log(`Read ${bytesRead} bytes`);
+   * // Use modifiedBuffer which contains the actual data
+   * await fs.close(fd);
+   * ```
+   */
+  async read(t, e, a, i, r) {
+    const s = this._getFileDescriptor(t);
+    I(e.length, a, i, r);
+    try {
+      const n = r ?? s.position, c = s.syncHandle.getSize(), { isEOF: l, actualLength: h } = N(n, i, c);
+      if (l)
+        return u({ bytesRead: 0, buffer: e }, [e.buffer]);
+      const w = e.subarray(a, a + h), y = s.syncHandle.read(w, { at: n });
+      return r == null && (s.position = n + y), u({ bytesRead: y, buffer: e }, [e.buffer]);
+    } catch (n) {
+      throw f("read", t, s.path, n);
+    }
+  }
+  /**
+   * Write data to a file descriptor
+   * 
+   * @param fd - The file descriptor to write to
+   * @param buffer - The buffer containing data to write
+   * @param offset - The offset in the buffer to start reading from (default: 0)
+   * @param length - The number of bytes to write (default: entire buffer)
+   * @param position - The position in the file to write to (null/undefined for current position)
+   * @param emitEvent - Whether to emit a change event (default: true)
+   * @returns Promise that resolves to the number of bytes written
+   * @throws {OPFSError} If the file descriptor is invalid or writing fails
+   *
+   * @example
+   * ```typescript
+   * const fd = await fs.open('/data/file.txt', { create: true });
+   * const data = new TextEncoder().encode('Hello, World!');
+   * const bytesWritten = await fs.write(fd, data, 0, data.length, null);
+   * console.log(`Wrote ${bytesWritten} bytes`);
+   * await fs.close(fd);
+   * ```
+   */
+  async write(t, e, a = 0, i, r, s = !0) {
+    const n = this._getFileDescriptor(t), c = i ?? e.length - a;
+    I(e.length, a, c, r);
+    try {
+      const l = r ?? n.position, h = e.subarray(a, a + c), w = n.syncHandle.write(h, { at: l });
+      return (r == null || r === n.position) && (n.position = l + w), s && await this.notifyChange({ path: n.path, type: "changed", isDirectory: !1 }), w;
+    } catch (l) {
+      throw f("write", t, n.path, l);
+    }
+  }
+  /**
+   * Get file status information by file descriptor
+   * 
+   * @param fd - The file descriptor
+   * @returns Promise that resolves to FileStat object
+   * @throws {OPFSError} If the file descriptor is invalid
+   * 
+   * @example
+   * ```typescript
+   * const fd = await fs.open('/data/file.txt');
+   * const stats = await fs.fstat(fd);
+   * console.log(`File size: ${stats.size} bytes`);
+   * console.log(`Last modified: ${stats.mtime}`);
+   * 
+   * // If hashing is enabled, hash will be included
+   * if (stats.hash) {
+   *   console.log(`Hash: ${stats.hash}`);
+   * }
+   * ```
+   */
+  async fstat(t) {
+    const e = this._getFileDescriptor(t);
+    return this.stat(e.path);
+  }
+  /**
+   * Truncate file to specified size
+   * 
+   * @param fd - The file descriptor
+   * @param size - The new size of the file (default: 0)
+   * @returns Promise that resolves when truncation is complete
+   * @throws {OPFSError} If the file descriptor is invalid or truncation fails
+   * 
+   * @example
+   * ```typescript
+   * const fd = await fs.open('/data/file.txt', { create: true });
+   * await fs.truncate(fd, 100); // Truncate to 100 bytes
+   * ```
+   */
+  async ftruncate(t, e = 0) {
+    const a = this._getFileDescriptor(t);
+    if (e < 0 || !Number.isInteger(e))
+      throw new o("Invalid size", "EINVAL");
+    try {
+      a.syncHandle.truncate(e), a.syncHandle.flush(), a.position > e && (a.position = e), await this.notifyChange({ path: a.path, type: "changed", isDirectory: !1 });
+    } catch (i) {
+      throw f("truncate", t, a.path, i);
+    }
+  }
+  /**
+   * Synchronize file data to storage (fsync equivalent)
+   * 
+   * @param fd - The file descriptor
+   * @returns Promise that resolves when synchronization is complete
+   * @throws {OPFSError} If the file descriptor is invalid or sync fails
+   * 
+   * @example
+   * ```typescript
+   * const fd = await fs.open('/data/file.txt', { create: true });
+   * await fs.write(fd, data);
+   * await fs.fsync(fd); // Ensure data is written to storage
+   * ```
+   */
+  async fsync(t) {
+    const e = this._getFileDescriptor(t);
+    try {
+      e.syncHandle.flush();
+    } catch (a) {
+      throw f("sync", t, e.path, a);
+    }
+  }
   /**
    * Dispose of resources and clean up the file system instance
    * 
@@ -674,6 +943,9 @@ class T {
    */
   dispose() {
     this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchers.clear();
+    for (const [t, e] of this.openFiles)
+      S(t, e.syncHandle, e.path);
+    this.openFiles.clear(), this.nextFd = 1;
   }
   /**
    * Synchronize the file system with external data
@@ -708,17 +980,17 @@ class T {
     try {
       (e?.cleanBefore ?? !1) && await this.clear("/");
       for (const [i, r] of t) {
-        const s = u(i);
+        const s = g(i);
         let n;
-        r instanceof Blob ? n = await O(r) : n = r, await this.writeFile(s, n);
+        r instanceof Blob ? n = await P(r) : typeof r == "string" ? n = new TextEncoder().encode(r) : n = r, await this.writeFile(s, n);
       }
     } catch (a) {
       throw a instanceof o ? a : new o("Failed to sync file system", "SYNC_FAILED", void 0, a);
     }
   }
 }
-typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && v(new T());
+typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && x(new _());
 export {
-  T as OPFSWorker
+  _ as OPFSWorker
 };
 //# sourceMappingURL=raw.js.map