opfs-worker 1.2.0 → 1.2.1

package/dist/facade.d.ts

@@ -1,4 +1,4 @@
-import type { DirentData, Encoding, FileOpenOptions, FileStat, OPFSOptions, RenameOptions, WatchOptions } from './types';
+import type { DirentData, Encoding, FileOpenOptions, FileStat, OPFSOptions, PathLike, RenameOptions, WatchOptions } from './types';
 /**
  * Facade class that provides a clean interface for communicating with the OPFS worker
  * while hiding Comlink implementation details.
@@ -17,73 +17,73 @@ export declare class OPFSFileSystem {
     /**
      * Read a file from the file system
      */
-    readFile(path: string, encoding: 'binary'): Promise<Uint8Array>;
-    readFile(path: string, encoding: Encoding): Promise<string>;
-    readFile(path: string, encoding?: Encoding | 'binary'): Promise<string | Uint8Array>;
+    readFile(path: PathLike, encoding: 'binary'): Promise<Uint8Array>;
+    readFile(path: PathLike, encoding: Encoding): Promise<string>;
+    readFile(path: PathLike, encoding?: Encoding | 'binary'): Promise<string | Uint8Array>;
     /**
      * Write data to a file
      */
-    writeFile(path: string, data: string | Uint8Array | ArrayBuffer, encoding?: Encoding): Promise<void>;
+    writeFile(path: PathLike, data: string | Uint8Array | ArrayBuffer, encoding?: Encoding): Promise<void>;
     /**
      * Append data to a file
      */
-    appendFile(path: string, data: string | Uint8Array | ArrayBuffer, encoding?: Encoding): Promise<void>;
+    appendFile(path: PathLike, data: string | Uint8Array | ArrayBuffer, encoding?: Encoding): Promise<void>;
     /**
      * Create a directory
      */
-    mkdir(path: string, options?: {
+    mkdir(path: PathLike, options?: {
         recursive?: boolean;
     }): Promise<void>;
     /**
      * Get file or directory statistics
      */
-    stat(path: string): Promise<FileStat>;
+    stat(path: PathLike): Promise<FileStat>;
     /**
      * Read a directory's contents
      */
-    readDir(path: string): Promise<DirentData[]>;
+    readDir(path: PathLike): Promise<DirentData[]>;
     /**
      * Check if a file or directory exists
      */
-    exists(path: string): Promise<boolean>;
+    exists(path: PathLike): Promise<boolean>;
     /**
      * Clear all contents of a directory without removing the directory itself
      */
-    clear(path?: string): Promise<void>;
+    clear(path?: PathLike): Promise<void>;
     /**
      * Remove files and directories
      */
-    remove(path: string, options?: {
+    remove(path: PathLike, options?: {
         recursive?: boolean;
         force?: boolean;
     }): Promise<void>;
     /**
      * Resolve a path to an absolute path
      */
-    realpath(path: string): Promise<string>;
+    realpath(path: PathLike): Promise<string>;
     /**
      * Rename a file or directory
      */
-    rename(oldPath: string, newPath: string, options?: RenameOptions): Promise<void>;
+    rename(oldPath: PathLike, newPath: PathLike, options?: RenameOptions): Promise<void>;
     /**
      * Copy files and directories
      */
-    copy(source: string, destination: string, options?: {
+    copy(source: PathLike, destination: PathLike, options?: {
         recursive?: boolean;
         overwrite?: boolean;
     }): Promise<void>;
     /**
      * Start watching a file or directory for changes
      */
-    watch(path: string, options?: WatchOptions): () => void;
+    watch(path: PathLike, options?: WatchOptions): () => void;
     /**
      * Stop watching a previously watched path
      */
-    unwatch(path: string): void;
+    unwatch(path: PathLike): void;
     /**
      * Open a file and return a file descriptor
      */
-    open(path: string, options?: FileOpenOptions): Promise<number>;
+    open(path: PathLike, options?: FileOpenOptions): Promise<number>;
     /**
      * Close a file descriptor
      */
@@ -122,20 +122,20 @@ export declare class OPFSFileSystem {
     /**
      * Synchronize the file system with external data
      */
-    sync(entries: [string, string | Uint8Array | Blob][], options?: {
+    sync(entries: [PathLike, string | Uint8Array | Blob][], options?: {
         cleanBefore?: boolean;
     }): Promise<void>;
     /**
      * Read a file as text with automatic encoding detection
      */
-    readText(path: string, encoding?: Encoding): Promise<string>;
+    readText(path: PathLike, encoding?: Encoding): Promise<string>;
     /**
      * Write text to a file with specified encoding
      */
-    writeText(path: string, text: string, encoding?: Encoding): Promise<void>;
+    writeText(path: PathLike, text: string, encoding?: Encoding): Promise<void>;
     /**
      * Append text to a file with specified encoding
      */
-    appendText(path: string, text: string, encoding?: Encoding): Promise<void>;
+    appendText(path: PathLike, text: string, encoding?: Encoding): Promise<void>;
 }
 //# sourceMappingURL=facade.d.ts.map

package/dist/facade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["../src/facade.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"facade.d.ts","sourceRoot":"","sources":["../src/facade.ts"],"names":[],"mappings":"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"}

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("comlink"),e=require("./helpers-TAynP0fb.cjs"),c=`/**
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("comlink"),e=require("./helpers-TAynP0fb.cjs"),l=`/**
  * @license
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
@@ -2342,5 +2342,5 @@ class es {
 }
 typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && K(new es());
 //# sourceMappingURL=worker-CLvhwwfc.js.map
-`,h=typeof self<"u"&&self.Blob&&new Blob(["URL.revokeObjectURL(import.meta.url);",c],{type:"text/javascript;charset=utf-8"});function d(s){let n;try{if(n=h&&(self.URL||self.webkitURL).createObjectURL(h),!n)throw"";const t=new Worker(n,{type:"module",name:s?.name});return t.addEventListener("error",()=>{(self.URL||self.webkitURL).revokeObjectURL(n)}),t}catch{return new Worker("data:text/javascript;charset=utf-8,"+encodeURIComponent(c),{type:"module",name:s?.name})}}class l{#n;constructor(n){const t=f.wrap(new d);this.#n=t,n&&(n.broadcastChannel&&n.broadcastChannel instanceof BroadcastChannel&&(n.broadcastChannel=n.broadcastChannel.name),this.setOptions(n))}async setOptions(n){return this.#n.setOptions(n)}async index(){return this.#n.index()}async readFile(n,t){const r=await this.#n.readFile(n);return t||(t=e.isBinaryFileExtension(n)?"binary":"utf-8"),t==="binary"?r:e.decodeBuffer(r,t)}async writeFile(n,t,r){r||(r=typeof t!="string"||e.isBinaryFileExtension(n)?"binary":"utf-8");const i=typeof t=="string"?e.encodeString(t,r):t instanceof Uint8Array?t:new Uint8Array(t);return this.#n.writeFile(n,i)}async appendFile(n,t,r){r||(r=typeof t!="string"||e.isBinaryFileExtension(n)?"binary":"utf-8");const i=typeof t=="string"?e.encodeString(t,r):t instanceof Uint8Array?t:new Uint8Array(t);return this.#n.appendFile(n,i)}async mkdir(n,t){return this.#n.mkdir(n,t)}async stat(n){return this.#n.stat(n)}async readDir(n){return this.#n.readDir(n)}async exists(n){return this.#n.exists(n)}async clear(n){return this.#n.clear(n)}async remove(n,t){return this.#n.remove(n,t)}async realpath(n){return this.#n.realpath(n)}async rename(n,t,r){return this.#n.rename(n,t,r)}async copy(n,t,r){return this.#n.copy(n,t,r)}watch(n,t){return this.#n.watch(n,t),()=>this.unwatch(n)}unwatch(n){this.#n.unwatch(n)}async open(n,t){return this.#n.open(n,t)}async close(n){return this.#n.close(n)}async read(n,t,r,i,o){const{bytesRead:a,buffer:p}=await this.#n.read(n,new Uint8Array(i),0,i,o);return a>0&&t.set(p.subarray(0,a),r),{bytesRead:a,buffer:t}}async write(n,t,r,i,o,a){return this.#n.write(n,t,r,i,o,a)}async fstat(n){return this.#n.fstat(n)}async ftruncate(n,t){return this.#n.ftruncate(n,t)}async fsync(n){return this.#n.fsync(n)}dispose(){this.#n.dispose()}async sync(n,t){return this.#n.sync(n,t)}async readText(n,t="utf-8"){const r=await this.#n.readFile(n);return e.decodeBuffer(r,t)}async writeText(n,t,r="utf-8"){const i=e.encodeString(t,r);return this.#n.writeFile(n,i)}async appendText(n,t,r="utf-8"){const i=e.encodeString(t,r);return this.#n.appendFile(n,i)}}function u(s){return new l(s)}exports.BINARY_FILE_EXTENSIONS=e.BINARY_FILE_EXTENSIONS;exports.DirectoryNotFoundError=e.DirectoryNotFoundError;exports.FileNotFoundError=e.FileNotFoundError;exports.OPFSError=e.OPFSError;exports.OPFSNotMountedError=e.OPFSNotMountedError;exports.OPFSNotSupportedError=e.OPFSNotSupportedError;exports.PathError=e.PathError;exports.PermissionError=e.PermissionError;exports.StorageError=e.StorageError;exports.TimeoutError=e.TimeoutError;exports.basename=e.basename;exports.buffersEqual=e.buffersEqual;exports.calculateFileHash=e.calculateFileHash;exports.calculateReadLength=e.calculateReadLength;exports.checkOPFSSupport=e.checkOPFSSupport;exports.convertBlobToUint8Array=e.convertBlobToUint8Array;exports.createBuffer=e.createBuffer;exports.createFDError=e.createFDError;exports.createSyncHandleSafe=e.createSyncHandleSafe;exports.decodeBuffer=e.decodeBuffer;exports.dirname=e.dirname;exports.encodeString=e.encodeString;exports.extname=e.extname;exports.isBinaryFileExtension=e.isBinaryFileExtension;exports.isPathExcluded=e.isPathExcluded;exports.joinPath=e.joinPath;exports.mapDomError=e.mapDomError;exports.matchMinimatch=e.matchMinimatch;exports.normalizeMinimatch=e.normalizeMinimatch;exports.normalizePath=e.normalizePath;exports.removeEntry=e.removeEntry;exports.resolvePath=e.resolvePath;exports.safeCloseSyncHandle=e.safeCloseSyncHandle;exports.splitPath=e.splitPath;exports.validateReadWriteArgs=e.validateReadWriteArgs;exports.withLock=e.withLock;exports.OPFSFileSystem=l;exports.createWorker=u;
+`,c=typeof self<"u"&&self.Blob&&new Blob(["URL.revokeObjectURL(import.meta.url);",l],{type:"text/javascript;charset=utf-8"});function u(o){let n;try{if(n=c&&(self.URL||self.webkitURL).createObjectURL(c),!n)throw"";const t=new Worker(n,{type:"module",name:o?.name});return t.addEventListener("error",()=>{(self.URL||self.webkitURL).revokeObjectURL(n)}),t}catch{return new Worker("data:text/javascript;charset=utf-8,"+encodeURIComponent(l),{type:"module",name:o?.name})}}function s(o){return o instanceof URL?o.pathname:o}class p{#n;constructor(n){const t=d.wrap(new u);this.#n=t,n&&(n.broadcastChannel&&n.broadcastChannel instanceof BroadcastChannel&&(n.broadcastChannel=n.broadcastChannel.name),this.setOptions(n))}async setOptions(n){return this.#n.setOptions(n)}async index(){return this.#n.index()}async readFile(n,t){const r=s(n),i=await this.#n.readFile(r);return t||(t=e.isBinaryFileExtension(r)?"binary":"utf-8"),t==="binary"?i:e.decodeBuffer(i,t)}async writeFile(n,t,r){const i=s(n);r||(r=typeof t!="string"||e.isBinaryFileExtension(i)?"binary":"utf-8");const a=typeof t=="string"?e.encodeString(t,r):t instanceof Uint8Array?t:new Uint8Array(t);return this.#n.writeFile(i,a)}async appendFile(n,t,r){const i=s(n);r||(r=typeof t!="string"||e.isBinaryFileExtension(i)?"binary":"utf-8");const a=typeof t=="string"?e.encodeString(t,r):t instanceof Uint8Array?t:new Uint8Array(t);return this.#n.appendFile(i,a)}async mkdir(n,t){const r=s(n);return this.#n.mkdir(r,t)}async stat(n){const t=s(n);return this.#n.stat(t)}async readDir(n){const t=s(n);return this.#n.readDir(t)}async exists(n){const t=s(n);return this.#n.exists(t)}async clear(n){const t=n?s(n):void 0;return this.#n.clear(t)}async remove(n,t){const r=s(n);return this.#n.remove(r,t)}async realpath(n){const t=s(n);return this.#n.realpath(t)}async rename(n,t,r){const i=s(n),a=s(t);return this.#n.rename(i,a,r)}async copy(n,t,r){const i=s(n),a=s(t);return this.#n.copy(i,a,r)}watch(n,t){const r=s(n);return this.#n.watch(r,t),()=>this.unwatch(r)}unwatch(n){const t=s(n);this.#n.unwatch(t)}async open(n,t){const r=s(n);return this.#n.open(r,t)}async close(n){return this.#n.close(n)}async read(n,t,r,i,a){const{bytesRead:h,buffer:f}=await this.#n.read(n,new Uint8Array(i),0,i,a);return h>0&&t.set(f.subarray(0,h),r),{bytesRead:h,buffer:t}}async write(n,t,r,i,a,h){return this.#n.write(n,t,r,i,a,h)}async fstat(n){return this.#n.fstat(n)}async ftruncate(n,t){return this.#n.ftruncate(n,t)}async fsync(n){return this.#n.fsync(n)}dispose(){this.#n.dispose()}async sync(n,t){const r=n.map(([i,a])=>[s(i),a]);return this.#n.sync(r,t)}async readText(n,t="utf-8"){const r=s(n),i=await this.#n.readFile(r);return e.decodeBuffer(i,t)}async writeText(n,t,r="utf-8"){const i=s(n),a=e.encodeString(t,r);return this.#n.writeFile(i,a)}async appendText(n,t,r="utf-8"){const i=s(n),a=e.encodeString(t,r);return this.#n.appendFile(i,a)}}function m(o){return new p(o)}exports.BINARY_FILE_EXTENSIONS=e.BINARY_FILE_EXTENSIONS;exports.DirectoryNotFoundError=e.DirectoryNotFoundError;exports.FileNotFoundError=e.FileNotFoundError;exports.OPFSError=e.OPFSError;exports.OPFSNotMountedError=e.OPFSNotMountedError;exports.OPFSNotSupportedError=e.OPFSNotSupportedError;exports.PathError=e.PathError;exports.PermissionError=e.PermissionError;exports.StorageError=e.StorageError;exports.TimeoutError=e.TimeoutError;exports.basename=e.basename;exports.buffersEqual=e.buffersEqual;exports.calculateFileHash=e.calculateFileHash;exports.calculateReadLength=e.calculateReadLength;exports.checkOPFSSupport=e.checkOPFSSupport;exports.convertBlobToUint8Array=e.convertBlobToUint8Array;exports.createBuffer=e.createBuffer;exports.createFDError=e.createFDError;exports.createSyncHandleSafe=e.createSyncHandleSafe;exports.decodeBuffer=e.decodeBuffer;exports.dirname=e.dirname;exports.encodeString=e.encodeString;exports.extname=e.extname;exports.isBinaryFileExtension=e.isBinaryFileExtension;exports.isPathExcluded=e.isPathExcluded;exports.joinPath=e.joinPath;exports.mapDomError=e.mapDomError;exports.matchMinimatch=e.matchMinimatch;exports.normalizeMinimatch=e.normalizeMinimatch;exports.normalizePath=e.normalizePath;exports.removeEntry=e.removeEntry;exports.resolvePath=e.resolvePath;exports.safeCloseSyncHandle=e.safeCloseSyncHandle;exports.splitPath=e.splitPath;exports.validateReadWriteArgs=e.validateReadWriteArgs;exports.withLock=e.withLock;exports.OPFSFileSystem=p;exports.createWorker=m;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../src/facade.ts","../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';\nimport WorkerCtor from './worker?worker&inline';\n\nimport type {\n    DirentData,\n    Encoding,\n    FileOpenOptions,\n    FileStat,\n    OPFSOptions,\n    RemoteOPFSWorker,\n    RenameOptions,\n    WatchOptions\n} from './types';\n\n/**\n * Facade class that provides a clean interface for communicating with the OPFS worker\n * while hiding Comlink implementation details.\n */\nexport class OPFSFileSystem {\n    #worker: RemoteOPFSWorker;\n\n    constructor(options?: OPFSOptions) {\n        const wrapped = wrap<RemoteOPFSWorker>(new WorkerCtor());\n\n        this.#worker = wrapped;\n\n        // Set up options if provided\n        if (options) {\n            // We can't pass a BroadcastChannel instance to the worker, so we need to convert it to a string first\n            if (options.broadcastChannel && options.broadcastChannel instanceof BroadcastChannel) {\n                options.broadcastChannel = options.broadcastChannel.name;\n            }\n\n            // Initialize options asynchronously\n            void this.setOptions(options);\n        }\n    }\n\n    /**\n     * Update configuration options\n     */\n    async setOptions(options: OPFSOptions) {\n        return this.#worker.setOptions(options);\n    }\n\n    /**\n     * Get a complete index of all files and directories in the file system\n     */\n    async index(): Promise<Map<string, FileStat>> {\n        return this.#worker.index();\n    }\n\n    /**\n     * Read a file from the file system\n     */\n    async readFile(path: string, encoding: 'binary'): Promise<Uint8Array>;\n    async readFile(path: string, encoding: Encoding): Promise<string>;\n    async readFile(path: string, encoding?: Encoding | 'binary'): Promise<string | Uint8Array>;\n    async readFile(\n        path: string,\n        encoding?: any\n    ): Promise<string | Uint8Array> {\n        // Get binary data from worker\n        const buffer = await this.#worker.readFile(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = isBinaryFileExtension(path) ? 'binary' : 'utf-8';\n        }\n\n        // Return binary data or decode to string\n        return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write data to a file\n     */\n    async writeFile(\n        path: string,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(path)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.writeFile(path, buffer);\n    }\n\n    /**\n     * Append data to a file\n     */\n    async appendFile(\n        path: string,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(path)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.appendFile(path, buffer);\n    }\n\n    /**\n     * Create a directory\n     */\n    async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {\n        return this.#worker.mkdir(path, options);\n    }\n\n    /**\n     * Get file or directory statistics\n     */\n    async stat(path: string): Promise<FileStat> {\n        return this.#worker.stat(path);\n    }\n\n    /**\n     * Read a directory's contents\n     */\n    async readDir(path: string): Promise<DirentData[]> {\n        return this.#worker.readDir(path);\n    }\n\n    /**\n     * Check if a file or directory exists\n     */\n    async exists(path: string): Promise<boolean> {\n        return this.#worker.exists(path);\n    }\n\n    /**\n     * Clear all contents of a directory without removing the directory itself\n     */\n    async clear(path?: string): Promise<void> {\n        return this.#worker.clear(path);\n    }\n\n    /**\n     * Remove files and directories\n     */\n    async remove(path: string, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        return this.#worker.remove(path, options);\n    }\n\n    /**\n     * Resolve a path to an absolute path\n     */\n    async realpath(path: string): Promise<string> {\n        return this.#worker.realpath(path);\n    }\n\n    /**\n     * Rename a file or directory\n     */\n    async rename(oldPath: string, newPath: string, options?: RenameOptions): Promise<void> {\n        return this.#worker.rename(oldPath, newPath, options);\n    }\n\n    /**\n     * Copy files and directories\n     */\n    async copy(source: string, destination: string, options?: { recursive?: boolean; overwrite?: boolean }): Promise<void> {\n        return this.#worker.copy(source, destination, options);\n    }\n\n    /**\n     * Start watching a file or directory for changes\n     */\n    watch(path: string, options?: WatchOptions): () => void {\n        void this.#worker.watch(path, options);\n\n        return () => this.unwatch(path);\n    }\n\n    /**\n     * Stop watching a previously watched path\n     */\n    unwatch(path: string) {\n        void this.#worker.unwatch(path);\n    }\n\n    /**\n     * Open a file and return a file descriptor\n     */\n    async open(path: string, options?: FileOpenOptions): Promise<number> {\n        return this.#worker.open(path, options);\n    }\n\n    /**\n     * Close a file descriptor\n     */\n    async close(fd: number): Promise<void> {\n        return this.#worker.close(fd);\n    }\n\n    /**\n     * Read data from a file descriptor\n     * \n     * This method requires special handling due to Comlink transfer requirements.\n     * The buffer is transferred to the worker and back, so the original buffer\n     * becomes unusable after the call.\n     */\n    async read(\n        fd: number,\n        buffer: Uint8Array,\n        offset: number,\n        length: number,\n        position?: number | null | undefined\n    ): Promise<{ bytesRead: number; buffer: Uint8Array }> {\n        const { bytesRead, buffer: transferred } = await this.#worker.read(\n            fd,\n            // Temp buffer to preserve the original buffer\n            new Uint8Array(length),\n            0,\n            length,\n            position\n        );\n\n        // Copy the data from the transferred buffer to the original buffer\n        if (bytesRead > 0) {\n            buffer.set(transferred.subarray(0, bytesRead), offset);\n        }\n\n        return { bytesRead, buffer };\n    }\n\n    /**\n     * Write data to a file descriptor\n     */\n    async write(\n        fd: number,\n        buffer: Uint8Array,\n        offset?: number,\n        length?: number,\n        position?: number | null | undefined,\n        emitEvent?: boolean\n    ): Promise<number> {\n        return this.#worker.write(fd, buffer, offset, length, position, emitEvent);\n    }\n\n    /**\n     * Get file status information by file descriptor\n     */\n    async fstat(fd: number): Promise<FileStat> {\n        return this.#worker.fstat(fd);\n    }\n\n    /**\n     * Truncate file to specified size\n     */\n    async ftruncate(fd: number, size?: number): Promise<void> {\n        return this.#worker.ftruncate(fd, size);\n    }\n\n    /**\n     * Synchronize file data to storage (fsync equivalent)\n     */\n    async fsync(fd: number): Promise<void> {\n        return this.#worker.fsync(fd);\n    }\n\n    /**\n     * Dispose of resources and clean up the file system instance\n     */\n    dispose() {\n        void this.#worker.dispose();\n    }\n\n    /**\n     * Synchronize the file system with external data\n     */\n    async sync(entries: [string, string | Uint8Array | Blob][], options?: { cleanBefore?: boolean }): Promise<void> {\n        return this.#worker.sync(entries, options);\n    }\n\n    /**\n     * Read a file as text with automatic encoding detection\n     */\n    async readText(path: string, encoding: Encoding = 'utf-8'): Promise<string> {\n        const buffer = await this.#worker.readFile(path);\n\n        return decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write text to a file with specified encoding\n     */\n    async writeText(path: string, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.writeFile(path, buffer);\n    }\n\n    /**\n     * Append text to a file with specified encoding\n     */\n    async appendText(path: string, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.appendFile(path, buffer);\n    }\n}\n","import { OPFSFileSystem } from './facade';\n\nimport type { OPFSOptions } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\nexport * from './facade';\n\n/**\n * Creates a new file system instance with inline worker\n * @param options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    options?: OPFSOptions\n): OPFSFileSystem {\n    return new OPFSFileSystem(options);\n}\n"],"names":["OPFSFileSystem","#worker","options","wrapped","wrap","WorkerCtor","path","encoding","buffer","isBinaryFileExtension","decodeBuffer","data","encodeString","oldPath","newPath","source","destination","fd","offset","length","position","bytesRead","transferred","emitEvent","size","entries","text","createWorker"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAoBO,MAAMA,CAAe,CACxBC,GAEA,YAAYC,EAAuB,CAC/B,MAAMC,EA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"}
+{"version":3,"file":"index.cjs","sources":["../src/facade.ts","../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';\nimport WorkerCtor from './worker?worker&inline';\n\nimport type {\n    DirentData,\n    Encoding,\n    FileOpenOptions,\n    FileStat,\n    OPFSOptions,\n    PathLike,\n    RemoteOPFSWorker,\n    RenameOptions,\n    WatchOptions\n} from './types';\n\n/**\n * Utility function to convert a PathLike to a string path\n * If it's a URI, extracts the pathname; otherwise returns the string as-is\n */\nfunction normalizePath(path: PathLike): string {\n    if (path instanceof URL) {\n        return path.pathname;\n    }\n\n    return path;\n}\n\n/**\n * Facade class that provides a clean interface for communicating with the OPFS worker\n * while hiding Comlink implementation details.\n */\nexport class OPFSFileSystem {\n    #worker: RemoteOPFSWorker;\n\n    constructor(options?: OPFSOptions) {\n        const wrapped = wrap<RemoteOPFSWorker>(new WorkerCtor());\n\n        this.#worker = wrapped;\n\n        // Set up options if provided\n        if (options) {\n            // We can't pass a BroadcastChannel instance to the worker, so we need to convert it to a string first\n            if (options.broadcastChannel && options.broadcastChannel instanceof BroadcastChannel) {\n                options.broadcastChannel = options.broadcastChannel.name;\n            }\n\n            // Initialize options asynchronously\n            void this.setOptions(options);\n        }\n    }\n\n    /**\n     * Update configuration options\n     */\n    async setOptions(options: OPFSOptions) {\n        return this.#worker.setOptions(options);\n    }\n\n    /**\n     * Get a complete index of all files and directories in the file system\n     */\n    async index(): Promise<Map<string, FileStat>> {\n        return this.#worker.index();\n    }\n\n    /**\n     * Read a file from the file system\n     */\n    async readFile(path: PathLike, encoding: 'binary'): Promise<Uint8Array>;\n    async readFile(path: PathLike, encoding: Encoding): Promise<string>;\n    async readFile(path: PathLike, encoding?: Encoding | 'binary'): Promise<string | Uint8Array>;\n    async readFile(\n        path: PathLike,\n        encoding?: any\n    ): Promise<string | Uint8Array> {\n        const normalizedPath = normalizePath(path);\n        // Get binary data from worker\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = isBinaryFileExtension(normalizedPath) ? 'binary' : 'utf-8';\n        }\n\n        // Return binary data or decode to string\n        return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write data to a file\n     */\n    async writeFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append data to a file\n     */\n    async appendFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Create a directory\n     */\n    async mkdir(path: PathLike, options?: { recursive?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.mkdir(normalizedPath, options);\n    }\n\n    /**\n     * Get file or directory statistics\n     */\n    async stat(path: PathLike): Promise<FileStat> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.stat(normalizedPath);\n    }\n\n    /**\n     * Read a directory's contents\n     */\n    async readDir(path: PathLike): Promise<DirentData[]> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.readDir(normalizedPath);\n    }\n\n    /**\n     * Check if a file or directory exists\n     */\n    async exists(path: PathLike): Promise<boolean> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.exists(normalizedPath);\n    }\n\n    /**\n     * Clear all contents of a directory without removing the directory itself\n     */\n    async clear(path?: PathLike): Promise<void> {\n        const normalizedPath = path ? normalizePath(path) : undefined;\n\n        return this.#worker.clear(normalizedPath);\n    }\n\n    /**\n     * Remove files and directories\n     */\n    async remove(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.remove(normalizedPath, options);\n    }\n\n    /**\n     * Resolve a path to an absolute path\n     */\n    async realpath(path: PathLike): Promise<string> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.realpath(normalizedPath);\n    }\n\n    /**\n     * Rename a file or directory\n     */\n    async rename(oldPath: PathLike, newPath: PathLike, options?: RenameOptions): Promise<void> {\n        const normalizedOldPath = normalizePath(oldPath);\n        const normalizedNewPath = normalizePath(newPath);\n\n        return this.#worker.rename(normalizedOldPath, normalizedNewPath, options);\n    }\n\n    /**\n     * Copy files and directories\n     */\n    async copy(source: PathLike, destination: PathLike, options?: { recursive?: boolean; overwrite?: boolean }): Promise<void> {\n        const normalizedSource = normalizePath(source);\n        const normalizedDestination = normalizePath(destination);\n\n        return this.#worker.copy(normalizedSource, normalizedDestination, options);\n    }\n\n    /**\n     * Start watching a file or directory for changes\n     */\n    watch(path: PathLike, options?: WatchOptions): () => void {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.watch(normalizedPath, options);\n\n        return () => this.unwatch(normalizedPath);\n    }\n\n    /**\n     * Stop watching a previously watched path\n     */\n    unwatch(path: PathLike) {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.unwatch(normalizedPath);\n    }\n\n    /**\n     * Open a file and return a file descriptor\n     */\n    async open(path: PathLike, options?: FileOpenOptions): Promise<number> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.open(normalizedPath, options);\n    }\n\n    /**\n     * Close a file descriptor\n     */\n    async close(fd: number): Promise<void> {\n        return this.#worker.close(fd);\n    }\n\n    /**\n     * Read data from a file descriptor\n     * \n     * This method requires special handling due to Comlink transfer requirements.\n     * The buffer is transferred to the worker and back, so the original buffer\n     * becomes unusable after the call.\n     */\n    async read(\n        fd: number,\n        buffer: Uint8Array,\n        offset: number,\n        length: number,\n        position?: number | null | undefined\n    ): Promise<{ bytesRead: number; buffer: Uint8Array }> {\n        const { bytesRead, buffer: transferred } = await this.#worker.read(\n            fd,\n            // Temp buffer to preserve the original buffer\n            new Uint8Array(length),\n            0,\n            length,\n            position\n        );\n\n        // Copy the data from the transferred buffer to the original buffer\n        if (bytesRead > 0) {\n            buffer.set(transferred.subarray(0, bytesRead), offset);\n        }\n\n        return { bytesRead, buffer };\n    }\n\n    /**\n     * Write data to a file descriptor\n     */\n    async write(\n        fd: number,\n        buffer: Uint8Array,\n        offset?: number,\n        length?: number,\n        position?: number | null | undefined,\n        emitEvent?: boolean\n    ): Promise<number> {\n        return this.#worker.write(fd, buffer, offset, length, position, emitEvent);\n    }\n\n    /**\n     * Get file status information by file descriptor\n     */\n    async fstat(fd: number): Promise<FileStat> {\n        return this.#worker.fstat(fd);\n    }\n\n    /**\n     * Truncate file to specified size\n     */\n    async ftruncate(fd: number, size?: number): Promise<void> {\n        return this.#worker.ftruncate(fd, size);\n    }\n\n    /**\n     * Synchronize file data to storage (fsync equivalent)\n     */\n    async fsync(fd: number): Promise<void> {\n        return this.#worker.fsync(fd);\n    }\n\n    /**\n     * Dispose of resources and clean up the file system instance\n     */\n    dispose() {\n        void this.#worker.dispose();\n    }\n\n    /**\n     * Synchronize the file system with external data\n     */\n    async sync(entries: [PathLike, string | Uint8Array | Blob][], options?: { cleanBefore?: boolean }): Promise<void> {\n        const normalizedEntries = entries.map(([path, data]) => [normalizePath(path), data] as [string, string | Uint8Array | Blob]);\n\n        return this.#worker.sync(normalizedEntries, options);\n    }\n\n    /**\n     * Read a file as text with automatic encoding detection\n     */\n    async readText(path: PathLike, encoding: Encoding = 'utf-8'): Promise<string> {\n        const normalizedPath = normalizePath(path);\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        return decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write text to a file with specified encoding\n     */\n    async writeText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append text to a file with specified encoding\n     */\n    async appendText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n}\n","import { OPFSFileSystem } from './facade';\n\nimport type { OPFSOptions } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\nexport * from './facade';\n\n/**\n * Creates a new file system instance with inline worker\n * @param options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    options?: OPFSOptions\n): OPFSFileSystem {\n    return new OPFSFileSystem(options);\n}\n"],"names":["normalizePath","path","OPFSFileSystem","#worker","options","wrapped","wrap","WorkerCtor","encoding","normalizedPath","buffer","isBinaryFileExtension","decodeBuffer","data","encodeString","oldPath","newPath","normalizedOldPath","normalizedNewPath","source","destination","normalizedSource","normalizedDestination","fd","offset","length","position","bytesRead","transferred","emitEvent","size","entries","normalizedEntries","text","createWorker"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAqBA,SAASA,EAAcC,EAAwB,CAC3C,OAAIA,aAAgB,IACTA,EAAK,SA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"}

package/dist/index.js

@@ -1,7 +1,7 @@
-import { wrap as d } from "comlink";
-import { i as h, d as c, e as a } from "./helpers-CkNHswLp.js";
-import { E, D as x, F as S, O as F, b as P, a as O, P as A, c as T, S as I, T as $, h as R, v as C, u as _, B as N, g as D, x as k, t as M, f as L, C as j, k as W, q as z, p as U, j as H, m as B, o as G, l as q, n as V, y as Y, r as X, A as Z, s as J, z as K, w as Q } from "./helpers-CkNHswLp.js";
-const p = `/**
+import { wrap as u } from "comlink";
+import { i as c, d as l, e as h } from "./helpers-CkNHswLp.js";
+import { E as x, D as S, F as P, O as F, b as O, a as A, P as T, c as I, S as R, T as $, h as C, v as _, u as N, B as D, g as z, x as k, t as M, f as L, C as j, k as W, q as U, p as H, j as B, m as G, o as q, l as V, n as Y, y as X, r as Z, A as J, s as K, z as Q, w as nn } from "./helpers-CkNHswLp.js";
+const f = `/**
  * @license
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
@@ -2345,32 +2345,35 @@ class es {
 }
 typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && K(new es());
 //# sourceMappingURL=worker-CLvhwwfc.js.map
-`, l = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", p], { type: "text/javascript;charset=utf-8" });
-function u(s) {
+`, p = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", f], { type: "text/javascript;charset=utf-8" });
+function m(a) {
   let n;
   try {
-    if (n = l && (self.URL || self.webkitURL).createObjectURL(l), !n) throw "";
+    if (n = p && (self.URL || self.webkitURL).createObjectURL(p), !n) throw "";
     const t = new Worker(n, {
       type: "module",
-      name: s?.name
+      name: a?.name
     });
     return t.addEventListener("error", () => {
       (self.URL || self.webkitURL).revokeObjectURL(n);
     }), t;
   } catch {
     return new Worker(
-      "data:text/javascript;charset=utf-8," + encodeURIComponent(p),
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(f),
       {
         type: "module",
-        name: s?.name
+        name: a?.name
       }
     );
   }
 }
+function s(a) {
+  return a instanceof URL ? a.pathname : a;
+}
 class w {
   #n;
   constructor(n) {
-    const t = d(new u());
+    const t = u(new m());
     this.#n = t, n && (n.broadcastChannel && n.broadcastChannel instanceof BroadcastChannel && (n.broadcastChannel = n.broadcastChannel.name), this.setOptions(n));
   }
   /**
@@ -2386,96 +2389,110 @@ class w {
     return this.#n.index();
   }
   async readFile(n, t) {
-    const e = await this.#n.readFile(n);
-    return t || (t = h(n) ? "binary" : "utf-8"), t === "binary" ? e : c(e, t);
+    const e = s(n), r = await this.#n.readFile(e);
+    return t || (t = c(e) ? "binary" : "utf-8"), t === "binary" ? r : l(r, t);
   }
   /**
    * Write data to a file
    */
   async writeFile(n, t, e) {
-    e || (e = typeof t != "string" || h(n) ? "binary" : "utf-8");
-    const r = typeof t == "string" ? a(t, e) : t instanceof Uint8Array ? t : new Uint8Array(t);
-    return this.#n.writeFile(n, r);
+    const r = s(n);
+    e || (e = typeof t != "string" || c(r) ? "binary" : "utf-8");
+    const i = typeof t == "string" ? h(t, e) : t instanceof Uint8Array ? t : new Uint8Array(t);
+    return this.#n.writeFile(r, i);
   }
   /**
    * Append data to a file
    */
   async appendFile(n, t, e) {
-    e || (e = typeof t != "string" || h(n) ? "binary" : "utf-8");
-    const r = typeof t == "string" ? a(t, e) : t instanceof Uint8Array ? t : new Uint8Array(t);
-    return this.#n.appendFile(n, r);
+    const r = s(n);
+    e || (e = typeof t != "string" || c(r) ? "binary" : "utf-8");
+    const i = typeof t == "string" ? h(t, e) : t instanceof Uint8Array ? t : new Uint8Array(t);
+    return this.#n.appendFile(r, i);
   }
   /**
    * Create a directory
    */
   async mkdir(n, t) {
-    return this.#n.mkdir(n, t);
+    const e = s(n);
+    return this.#n.mkdir(e, t);
   }
   /**
    * Get file or directory statistics
    */
   async stat(n) {
-    return this.#n.stat(n);
+    const t = s(n);
+    return this.#n.stat(t);
   }
   /**
    * Read a directory's contents
    */
   async readDir(n) {
-    return this.#n.readDir(n);
+    const t = s(n);
+    return this.#n.readDir(t);
   }
   /**
    * Check if a file or directory exists
    */
   async exists(n) {
-    return this.#n.exists(n);
+    const t = s(n);
+    return this.#n.exists(t);
   }
   /**
    * Clear all contents of a directory without removing the directory itself
    */
   async clear(n) {
-    return this.#n.clear(n);
+    const t = n ? s(n) : void 0;
+    return this.#n.clear(t);
   }
   /**
    * Remove files and directories
    */
   async remove(n, t) {
-    return this.#n.remove(n, t);
+    const e = s(n);
+    return this.#n.remove(e, t);
   }
   /**
    * Resolve a path to an absolute path
    */
   async realpath(n) {
-    return this.#n.realpath(n);
+    const t = s(n);
+    return this.#n.realpath(t);
   }
   /**
    * Rename a file or directory
    */
   async rename(n, t, e) {
-    return this.#n.rename(n, t, e);
+    const r = s(n), i = s(t);
+    return this.#n.rename(r, i, e);
   }
   /**
    * Copy files and directories
    */
   async copy(n, t, e) {
-    return this.#n.copy(n, t, e);
+    const r = s(n), i = s(t);
+    return this.#n.copy(r, i, e);
   }
   /**
    * Start watching a file or directory for changes
    */
   watch(n, t) {
-    return this.#n.watch(n, t), () => this.unwatch(n);
+    const e = s(n);
+    return this.#n.watch(e, t), () => this.unwatch(e);
   }
   /**
    * Stop watching a previously watched path
    */
   unwatch(n) {
-    this.#n.unwatch(n);
+    const t = s(n);
+    this.#n.unwatch(t);
   }
   /**
    * Open a file and return a file descriptor
    */
   async open(n, t) {
-    return this.#n.open(n, t);
+    const e = s(n);
+    return this.#n.open(e, t);
   }
   /**
    * Close a file descriptor
@@ -2490,22 +2507,22 @@ class w {
    * The buffer is transferred to the worker and back, so the original buffer
    * becomes unusable after the call.
    */
-  async read(n, t, e, r, o) {
-    const { bytesRead: i, buffer: f } = await this.#n.read(
+  async read(n, t, e, r, i) {
+    const { bytesRead: o, buffer: d } = await this.#n.read(
       n,
       // Temp buffer to preserve the original buffer
       new Uint8Array(r),
       0,
       r,
-      o
+      i
     );
-    return i > 0 && t.set(f.subarray(0, i), e), { bytesRead: i, buffer: t };
+    return o > 0 && t.set(d.subarray(0, o), e), { bytesRead: o, buffer: t };
   }
   /**
    * Write data to a file descriptor
    */
-  async write(n, t, e, r, o, i) {
-    return this.#n.write(n, t, e, r, o, i);
+  async write(n, t, e, r, i, o) {
+    return this.#n.write(n, t, e, r, i, o);
   }
   /**
    * Get file status information by file descriptor
@@ -2535,71 +2552,72 @@ class w {
    * Synchronize the file system with external data
    */
   async sync(n, t) {
-    return this.#n.sync(n, t);
+    const e = n.map(([r, i]) => [s(r), i]);
+    return this.#n.sync(e, t);
   }
   /**
    * Read a file as text with automatic encoding detection
    */
   async readText(n, t = "utf-8") {
-    const e = await this.#n.readFile(n);
-    return c(e, t);
+    const e = s(n), r = await this.#n.readFile(e);
+    return l(r, t);
   }
   /**
    * Write text to a file with specified encoding
    */
   async writeText(n, t, e = "utf-8") {
-    const r = a(t, e);
-    return this.#n.writeFile(n, r);
+    const r = s(n), i = h(t, e);
+    return this.#n.writeFile(r, i);
   }
   /**
    * Append text to a file with specified encoding
    */
   async appendText(n, t, e = "utf-8") {
-    const r = a(t, e);
-    return this.#n.appendFile(n, r);
+    const r = s(n), i = h(t, e);
+    return this.#n.appendFile(r, i);
   }
 }
-function g(s) {
-  return new w(s);
+function b(a) {
+  return new w(a);
 }
 export {
-  E as BINARY_FILE_EXTENSIONS,
-  x as DirectoryNotFoundError,
-  S as FileNotFoundError,
+  x as BINARY_FILE_EXTENSIONS,
+  S as DirectoryNotFoundError,
+  P as FileNotFoundError,
   F as OPFSError,
   w as OPFSFileSystem,
-  P as OPFSNotMountedError,
-  O as OPFSNotSupportedError,
-  A as PathError,
-  T as PermissionError,
-  I as StorageError,
+  O as OPFSNotMountedError,
+  A as OPFSNotSupportedError,
+  T as PathError,
+  I as PermissionError,
+  R as StorageError,
   $ as TimeoutError,
-  R as basename,
-  C as buffersEqual,
-  _ as calculateFileHash,
-  N as calculateReadLength,
-  D as checkOPFSSupport,
+  C as basename,
+  _ as buffersEqual,
+  N as calculateFileHash,
+  D as calculateReadLength,
+  z as checkOPFSSupport,
   k as convertBlobToUint8Array,
   M as createBuffer,
   L as createFDError,
   j as createSyncHandleSafe,
-  g as createWorker,
-  c as decodeBuffer,
+  b as createWorker,
+  l as decodeBuffer,
   W as dirname,
-  a as encodeString,
-  z as extname,
-  h as isBinaryFileExtension,
-  U as isPathExcluded,
-  H as joinPath,
-  B as mapDomError,
-  G as matchMinimatch,
-  q as normalizeMinimatch,
-  V as normalizePath,
-  Y as removeEntry,
-  X as resolvePath,
-  Z as safeCloseSyncHandle,
-  J as splitPath,
-  K as validateReadWriteArgs,
-  Q as withLock
+  h as encodeString,
+  U as extname,
+  c as isBinaryFileExtension,
+  H as isPathExcluded,
+  B as joinPath,
+  G as mapDomError,
+  q as matchMinimatch,
+  V as normalizeMinimatch,
+  Y as normalizePath,
+  X as removeEntry,
+  Z as resolvePath,
+  J as safeCloseSyncHandle,
+  K as splitPath,
+  Q as validateReadWriteArgs,
+  nn as withLock
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/facade.ts","../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';\nimport WorkerCtor from './worker?worker&inline';\n\nimport type {\n    DirentData,\n    Encoding,\n    FileOpenOptions,\n    FileStat,\n    OPFSOptions,\n    RemoteOPFSWorker,\n    RenameOptions,\n    WatchOptions\n} from './types';\n\n/**\n * Facade class that provides a clean interface for communicating with the OPFS worker\n * while hiding Comlink implementation details.\n */\nexport class OPFSFileSystem {\n    #worker: RemoteOPFSWorker;\n\n    constructor(options?: OPFSOptions) {\n        const wrapped = wrap<RemoteOPFSWorker>(new WorkerCtor());\n\n        this.#worker = wrapped;\n\n        // Set up options if provided\n        if (options) {\n            // We can't pass a BroadcastChannel instance to the worker, so we need to convert it to a string first\n            if (options.broadcastChannel && options.broadcastChannel instanceof BroadcastChannel) {\n                options.broadcastChannel = options.broadcastChannel.name;\n            }\n\n            // Initialize options asynchronously\n            void this.setOptions(options);\n        }\n    }\n\n    /**\n     * Update configuration options\n     */\n    async setOptions(options: OPFSOptions) {\n        return this.#worker.setOptions(options);\n    }\n\n    /**\n     * Get a complete index of all files and directories in the file system\n     */\n    async index(): Promise<Map<string, FileStat>> {\n        return this.#worker.index();\n    }\n\n    /**\n     * Read a file from the file system\n     */\n    async readFile(path: string, encoding: 'binary'): Promise<Uint8Array>;\n    async readFile(path: string, encoding: Encoding): Promise<string>;\n    async readFile(path: string, encoding?: Encoding | 'binary'): Promise<string | Uint8Array>;\n    async readFile(\n        path: string,\n        encoding?: any\n    ): Promise<string | Uint8Array> {\n        // Get binary data from worker\n        const buffer = await this.#worker.readFile(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = isBinaryFileExtension(path) ? 'binary' : 'utf-8';\n        }\n\n        // Return binary data or decode to string\n        return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write data to a file\n     */\n    async writeFile(\n        path: string,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(path)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.writeFile(path, buffer);\n    }\n\n    /**\n     * Append data to a file\n     */\n    async appendFile(\n        path: string,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(path)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.appendFile(path, buffer);\n    }\n\n    /**\n     * Create a directory\n     */\n    async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {\n        return this.#worker.mkdir(path, options);\n    }\n\n    /**\n     * Get file or directory statistics\n     */\n    async stat(path: string): Promise<FileStat> {\n        return this.#worker.stat(path);\n    }\n\n    /**\n     * Read a directory's contents\n     */\n    async readDir(path: string): Promise<DirentData[]> {\n        return this.#worker.readDir(path);\n    }\n\n    /**\n     * Check if a file or directory exists\n     */\n    async exists(path: string): Promise<boolean> {\n        return this.#worker.exists(path);\n    }\n\n    /**\n     * Clear all contents of a directory without removing the directory itself\n     */\n    async clear(path?: string): Promise<void> {\n        return this.#worker.clear(path);\n    }\n\n    /**\n     * Remove files and directories\n     */\n    async remove(path: string, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        return this.#worker.remove(path, options);\n    }\n\n    /**\n     * Resolve a path to an absolute path\n     */\n    async realpath(path: string): Promise<string> {\n        return this.#worker.realpath(path);\n    }\n\n    /**\n     * Rename a file or directory\n     */\n    async rename(oldPath: string, newPath: string, options?: RenameOptions): Promise<void> {\n        return this.#worker.rename(oldPath, newPath, options);\n    }\n\n    /**\n     * Copy files and directories\n     */\n    async copy(source: string, destination: string, options?: { recursive?: boolean; overwrite?: boolean }): Promise<void> {\n        return this.#worker.copy(source, destination, options);\n    }\n\n    /**\n     * Start watching a file or directory for changes\n     */\n    watch(path: string, options?: WatchOptions): () => void {\n        void this.#worker.watch(path, options);\n\n        return () => this.unwatch(path);\n    }\n\n    /**\n     * Stop watching a previously watched path\n     */\n    unwatch(path: string) {\n        void this.#worker.unwatch(path);\n    }\n\n    /**\n     * Open a file and return a file descriptor\n     */\n    async open(path: string, options?: FileOpenOptions): Promise<number> {\n        return this.#worker.open(path, options);\n    }\n\n    /**\n     * Close a file descriptor\n     */\n    async close(fd: number): Promise<void> {\n        return this.#worker.close(fd);\n    }\n\n    /**\n     * Read data from a file descriptor\n     * \n     * This method requires special handling due to Comlink transfer requirements.\n     * The buffer is transferred to the worker and back, so the original buffer\n     * becomes unusable after the call.\n     */\n    async read(\n        fd: number,\n        buffer: Uint8Array,\n        offset: number,\n        length: number,\n        position?: number | null | undefined\n    ): Promise<{ bytesRead: number; buffer: Uint8Array }> {\n        const { bytesRead, buffer: transferred } = await this.#worker.read(\n            fd,\n            // Temp buffer to preserve the original buffer\n            new Uint8Array(length),\n            0,\n            length,\n            position\n        );\n\n        // Copy the data from the transferred buffer to the original buffer\n        if (bytesRead > 0) {\n            buffer.set(transferred.subarray(0, bytesRead), offset);\n        }\n\n        return { bytesRead, buffer };\n    }\n\n    /**\n     * Write data to a file descriptor\n     */\n    async write(\n        fd: number,\n        buffer: Uint8Array,\n        offset?: number,\n        length?: number,\n        position?: number | null | undefined,\n        emitEvent?: boolean\n    ): Promise<number> {\n        return this.#worker.write(fd, buffer, offset, length, position, emitEvent);\n    }\n\n    /**\n     * Get file status information by file descriptor\n     */\n    async fstat(fd: number): Promise<FileStat> {\n        return this.#worker.fstat(fd);\n    }\n\n    /**\n     * Truncate file to specified size\n     */\n    async ftruncate(fd: number, size?: number): Promise<void> {\n        return this.#worker.ftruncate(fd, size);\n    }\n\n    /**\n     * Synchronize file data to storage (fsync equivalent)\n     */\n    async fsync(fd: number): Promise<void> {\n        return this.#worker.fsync(fd);\n    }\n\n    /**\n     * Dispose of resources and clean up the file system instance\n     */\n    dispose() {\n        void this.#worker.dispose();\n    }\n\n    /**\n     * Synchronize the file system with external data\n     */\n    async sync(entries: [string, string | Uint8Array | Blob][], options?: { cleanBefore?: boolean }): Promise<void> {\n        return this.#worker.sync(entries, options);\n    }\n\n    /**\n     * Read a file as text with automatic encoding detection\n     */\n    async readText(path: string, encoding: Encoding = 'utf-8'): Promise<string> {\n        const buffer = await this.#worker.readFile(path);\n\n        return decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write text to a file with specified encoding\n     */\n    async writeText(path: string, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.writeFile(path, buffer);\n    }\n\n    /**\n     * Append text to a file with specified encoding\n     */\n    async appendText(path: string, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.appendFile(path, buffer);\n    }\n}\n","import { OPFSFileSystem } from './facade';\n\nimport type { OPFSOptions } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\nexport * from './facade';\n\n/**\n * Creates a new file system instance with inline worker\n * @param options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    options?: OPFSOptions\n): OPFSFileSystem {\n    return new OPFSFileSystem(options);\n}\n"],"names":["OPFSFileSystem","#worker","options","wrapped","wrap","WorkerCtor","path","encoding","buffer","isBinaryFileExtension","decodeBuffer","data","encodeString","oldPath","newPath","source","destination","fd","offset","length","position","bytesRead","transferred","emitEvent","size","entries","text","createWorker"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBO,MAAMA,EAAe;AAAA,EACxBC;AA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"}
+{"version":3,"file":"index.js","sources":["../src/facade.ts","../src/index.ts"],"sourcesContent":["import { wrap } from 'comlink';\n\nimport { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';\nimport WorkerCtor from './worker?worker&inline';\n\nimport type {\n    DirentData,\n    Encoding,\n    FileOpenOptions,\n    FileStat,\n    OPFSOptions,\n    PathLike,\n    RemoteOPFSWorker,\n    RenameOptions,\n    WatchOptions\n} from './types';\n\n/**\n * Utility function to convert a PathLike to a string path\n * If it's a URI, extracts the pathname; otherwise returns the string as-is\n */\nfunction normalizePath(path: PathLike): string {\n    if (path instanceof URL) {\n        return path.pathname;\n    }\n\n    return path;\n}\n\n/**\n * Facade class that provides a clean interface for communicating with the OPFS worker\n * while hiding Comlink implementation details.\n */\nexport class OPFSFileSystem {\n    #worker: RemoteOPFSWorker;\n\n    constructor(options?: OPFSOptions) {\n        const wrapped = wrap<RemoteOPFSWorker>(new WorkerCtor());\n\n        this.#worker = wrapped;\n\n        // Set up options if provided\n        if (options) {\n            // We can't pass a BroadcastChannel instance to the worker, so we need to convert it to a string first\n            if (options.broadcastChannel && options.broadcastChannel instanceof BroadcastChannel) {\n                options.broadcastChannel = options.broadcastChannel.name;\n            }\n\n            // Initialize options asynchronously\n            void this.setOptions(options);\n        }\n    }\n\n    /**\n     * Update configuration options\n     */\n    async setOptions(options: OPFSOptions) {\n        return this.#worker.setOptions(options);\n    }\n\n    /**\n     * Get a complete index of all files and directories in the file system\n     */\n    async index(): Promise<Map<string, FileStat>> {\n        return this.#worker.index();\n    }\n\n    /**\n     * Read a file from the file system\n     */\n    async readFile(path: PathLike, encoding: 'binary'): Promise<Uint8Array>;\n    async readFile(path: PathLike, encoding: Encoding): Promise<string>;\n    async readFile(path: PathLike, encoding?: Encoding | 'binary'): Promise<string | Uint8Array>;\n    async readFile(\n        path: PathLike,\n        encoding?: any\n    ): Promise<string | Uint8Array> {\n        const normalizedPath = normalizePath(path);\n        // Get binary data from worker\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = isBinaryFileExtension(normalizedPath) ? 'binary' : 'utf-8';\n        }\n\n        // Return binary data or decode to string\n        return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write data to a file\n     */\n    async writeFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append data to a file\n     */\n    async appendFile(\n        path: PathLike,\n        data: string | Uint8Array | ArrayBuffer,\n        encoding?: Encoding\n    ): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        // If no encoding specified, auto-detect based on file extension\n        if (!encoding) {\n            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';\n        }\n\n        // Convert data to Uint8Array\n        const buffer = typeof data === 'string'\n            ? encodeString(data, encoding)\n            : (data instanceof Uint8Array ? data : new Uint8Array(data));\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Create a directory\n     */\n    async mkdir(path: PathLike, options?: { recursive?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.mkdir(normalizedPath, options);\n    }\n\n    /**\n     * Get file or directory statistics\n     */\n    async stat(path: PathLike): Promise<FileStat> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.stat(normalizedPath);\n    }\n\n    /**\n     * Read a directory's contents\n     */\n    async readDir(path: PathLike): Promise<DirentData[]> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.readDir(normalizedPath);\n    }\n\n    /**\n     * Check if a file or directory exists\n     */\n    async exists(path: PathLike): Promise<boolean> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.exists(normalizedPath);\n    }\n\n    /**\n     * Clear all contents of a directory without removing the directory itself\n     */\n    async clear(path?: PathLike): Promise<void> {\n        const normalizedPath = path ? normalizePath(path) : undefined;\n\n        return this.#worker.clear(normalizedPath);\n    }\n\n    /**\n     * Remove files and directories\n     */\n    async remove(path: PathLike, options?: { recursive?: boolean; force?: boolean }): Promise<void> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.remove(normalizedPath, options);\n    }\n\n    /**\n     * Resolve a path to an absolute path\n     */\n    async realpath(path: PathLike): Promise<string> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.realpath(normalizedPath);\n    }\n\n    /**\n     * Rename a file or directory\n     */\n    async rename(oldPath: PathLike, newPath: PathLike, options?: RenameOptions): Promise<void> {\n        const normalizedOldPath = normalizePath(oldPath);\n        const normalizedNewPath = normalizePath(newPath);\n\n        return this.#worker.rename(normalizedOldPath, normalizedNewPath, options);\n    }\n\n    /**\n     * Copy files and directories\n     */\n    async copy(source: PathLike, destination: PathLike, options?: { recursive?: boolean; overwrite?: boolean }): Promise<void> {\n        const normalizedSource = normalizePath(source);\n        const normalizedDestination = normalizePath(destination);\n\n        return this.#worker.copy(normalizedSource, normalizedDestination, options);\n    }\n\n    /**\n     * Start watching a file or directory for changes\n     */\n    watch(path: PathLike, options?: WatchOptions): () => void {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.watch(normalizedPath, options);\n\n        return () => this.unwatch(normalizedPath);\n    }\n\n    /**\n     * Stop watching a previously watched path\n     */\n    unwatch(path: PathLike) {\n        const normalizedPath = normalizePath(path);\n\n        void this.#worker.unwatch(normalizedPath);\n    }\n\n    /**\n     * Open a file and return a file descriptor\n     */\n    async open(path: PathLike, options?: FileOpenOptions): Promise<number> {\n        const normalizedPath = normalizePath(path);\n\n        return this.#worker.open(normalizedPath, options);\n    }\n\n    /**\n     * Close a file descriptor\n     */\n    async close(fd: number): Promise<void> {\n        return this.#worker.close(fd);\n    }\n\n    /**\n     * Read data from a file descriptor\n     * \n     * This method requires special handling due to Comlink transfer requirements.\n     * The buffer is transferred to the worker and back, so the original buffer\n     * becomes unusable after the call.\n     */\n    async read(\n        fd: number,\n        buffer: Uint8Array,\n        offset: number,\n        length: number,\n        position?: number | null | undefined\n    ): Promise<{ bytesRead: number; buffer: Uint8Array }> {\n        const { bytesRead, buffer: transferred } = await this.#worker.read(\n            fd,\n            // Temp buffer to preserve the original buffer\n            new Uint8Array(length),\n            0,\n            length,\n            position\n        );\n\n        // Copy the data from the transferred buffer to the original buffer\n        if (bytesRead > 0) {\n            buffer.set(transferred.subarray(0, bytesRead), offset);\n        }\n\n        return { bytesRead, buffer };\n    }\n\n    /**\n     * Write data to a file descriptor\n     */\n    async write(\n        fd: number,\n        buffer: Uint8Array,\n        offset?: number,\n        length?: number,\n        position?: number | null | undefined,\n        emitEvent?: boolean\n    ): Promise<number> {\n        return this.#worker.write(fd, buffer, offset, length, position, emitEvent);\n    }\n\n    /**\n     * Get file status information by file descriptor\n     */\n    async fstat(fd: number): Promise<FileStat> {\n        return this.#worker.fstat(fd);\n    }\n\n    /**\n     * Truncate file to specified size\n     */\n    async ftruncate(fd: number, size?: number): Promise<void> {\n        return this.#worker.ftruncate(fd, size);\n    }\n\n    /**\n     * Synchronize file data to storage (fsync equivalent)\n     */\n    async fsync(fd: number): Promise<void> {\n        return this.#worker.fsync(fd);\n    }\n\n    /**\n     * Dispose of resources and clean up the file system instance\n     */\n    dispose() {\n        void this.#worker.dispose();\n    }\n\n    /**\n     * Synchronize the file system with external data\n     */\n    async sync(entries: [PathLike, string | Uint8Array | Blob][], options?: { cleanBefore?: boolean }): Promise<void> {\n        const normalizedEntries = entries.map(([path, data]) => [normalizePath(path), data] as [string, string | Uint8Array | Blob]);\n\n        return this.#worker.sync(normalizedEntries, options);\n    }\n\n    /**\n     * Read a file as text with automatic encoding detection\n     */\n    async readText(path: PathLike, encoding: Encoding = 'utf-8'): Promise<string> {\n        const normalizedPath = normalizePath(path);\n        const buffer = await this.#worker.readFile(normalizedPath);\n\n        return decodeBuffer(buffer, encoding);\n    }\n\n    /**\n     * Write text to a file with specified encoding\n     */\n    async writeText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.writeFile(normalizedPath, buffer);\n    }\n\n    /**\n     * Append text to a file with specified encoding\n     */\n    async appendText(path: PathLike, text: string, encoding: Encoding = 'utf-8'): Promise<void> {\n        const normalizedPath = normalizePath(path);\n        const buffer = encodeString(text, encoding);\n\n        return this.#worker.appendFile(normalizedPath, buffer);\n    }\n}\n","import { OPFSFileSystem } from './facade';\n\nimport type { OPFSOptions } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\nexport * from './facade';\n\n/**\n * Creates a new file system instance with inline worker\n * @param options - Optional configuration options\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    options?: OPFSOptions\n): OPFSFileSystem {\n    return new OPFSFileSystem(options);\n}\n"],"names":["normalizePath","path","OPFSFileSystem","#worker","options","wrapped","wrap","WorkerCtor","encoding","normalizedPath","buffer","isBinaryFileExtension","decodeBuffer","data","encodeString","oldPath","newPath","normalizedOldPath","normalizedNewPath","source","destination","normalizedSource","normalizedDestination","fd","offset","length","position","bytesRead","transferred","emitEvent","size","entries","normalizedEntries","text","createWorker"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,SAASA,EAAcC,GAAwB;AAC3C,S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"}

package/dist/types.d.ts

@@ -1,5 +1,9 @@
 import type { OPFSWorker } from './worker';
 import type { Remote } from 'comlink';
+/**
+ * Type for paths that can be either a string or URI
+ */
+export type PathLike = string | URL;
 export type Kind = 'file' | 'directory';
 export type Encoding = 'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'utf-16le' | 'ucs2' | 'ucs-2' | 'base64' | 'latin1' | 'hex' | 'binary';
 export interface FileStat {

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,WAAW,CAAC;AAExC,MAAM,MAAM,QAAQ,GAAG,OAAO,GAC1B,MAAM,GACN,OAAO,GACP,SAAS,GACT,UAAU,GACV,MAAM,GACN,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,KAAK,GACL,QAAQ,CAAC;AAEb,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;IACtC,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,YAAY,EAAE,UAAU,EAAE,CAAC;AAC3B,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAElD,MAAM,WAAW,WAAW;IACxB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,aAAa,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,aAAa;IAC1B,2DAA2D;IAC3D,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IACzB,mDAAmD;IACnD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACrB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,GAAG,CAAC;AAEpC,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,WAAW,CAAC;AAExC,MAAM,MAAM,QAAQ,GAAG,OAAO,GAC1B,MAAM,GACN,OAAO,GACP,SAAS,GACT,UAAU,GACV,MAAM,GACN,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,KAAK,GACL,QAAQ,CAAC;AAEb,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;IACtC,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,YAAY,EAAE,UAAU,EAAE,CAAC;AAC3B,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;AAElD,MAAM,WAAW,WAAW;IACxB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,aAAa,CAAC,EAAE,IAAI,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAAC;CACvD;AAED,MAAM,WAAW,aAAa;IAC1B,2DAA2D;IAC3D,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IACzB,mDAAmD;IACnD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,eAAe;IAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACrB"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "opfs-worker",
-    "version": "1.2.0",
+    "version": "1.2.1",
     "description": "A robust TypeScript library for working with Origin Private File System (OPFS) through Web Workers",
     "type": "module",
     "main": "dist/index.js",