opfs-worker 2.0.0 → 2.1.0

package/src/{OPFSFacade.ts → facade/OPFSFacade.ts}

@@ -1,5 +1,6 @@
-import { createOPFSWorker } from './createOPFSWorker';
-import { decodeBuffer, encodeString, isBinaryFileExtension } from './utils/encoder';
+import { proxy, transfer } from 'comlink';
+
+import { decodeBuffer, encodeString, isBinaryFileExtension } from '../utils/encoder';
 
 import type {
     BinaryEncoding,
@@ -7,13 +8,13 @@ import type {
     Encoding,
     FileOpenOptions,
     FileStat,
+    OPFSApi,
     OPFSOptions,
     PathLike,
-    RemoteOPFSWorker,
     RenameOptions,
     StringEncoding,
     WatchOptions
-} from './types';
+} from '../types';
 
 /**
  * Utility function to convert a PathLike to a string path
@@ -27,22 +28,37 @@ function normalizePath(path: PathLike): string {
     return path;
 }
 
+/** Backend the facade talks to: an fs implementation plus its cleanup. */
+export interface OPFSBackend {
+    fs: OPFSApi;
+    /** Underlying Worker / SharedWorker when the backend lives off-thread */
+    worker?: Worker | SharedWorker;
+    dispose: () => void;
+}
+
 /**
- * Mode 1: Node-like facade with encoding helpers and string/binary auto-detection,
- * built on top of the raw worker API from {@link createOPFSWorker}.
+ * Node-like facade with encoding helpers and string/binary auto-detection.
  *
- * Use {@link createOPFS} to create one.
+ * Transport-agnostic: works over any {@link OPFSBackend} — a Comlink proxy to
+ * a worker (`createOPFSDedicated`) or an in-process instance (`createOPFSAsync`).
+ *
+ * Escape hatch: {@link backend} is the raw bytes API; {@link worker} is the
+ * browser Worker / SharedWorker when one was created (undefined for async).
  */
 export class OPFSFacade {
-    #fs: RemoteOPFSWorker;
+    #fs: OPFSApi;
     #dispose: () => void;
+    /** Raw backend (`OPFSApi`) — bytes in / bytes out, no encoding helpers */
+    readonly backend: OPFSApi;
+    /** Dedicated Worker or SharedWorker, if this facade was created with one */
+    readonly worker: Worker | SharedWorker | undefined;
     promises: OPFSFacade = this;
 
-    constructor(options?: OPFSOptions) {
-        const raw = createOPFSWorker(options);
-
-        this.#fs = raw.fs;
-        this.#dispose = raw.dispose;
+    constructor(backend: OPFSBackend) {
+        this.#fs = backend.fs;
+        this.backend = backend.fs;
+        this.worker = backend.worker;
+        this.#dispose = backend.dispose;
     }
 
     /**
@@ -120,12 +136,40 @@ export class OPFSFacade {
         return (encoding === 'binary') ? buffer : decodeBuffer(buffer, encoding);
     }
 
+    /**
+     * Normalize writable data into a Uint8Array.
+     *
+     * Accepts strings (encoded via `encoding`, auto-detected from the file
+     * extension when omitted), raw binary (`Uint8Array` / `ArrayBuffer`), and
+     * `Blob`/`File` sources (read via `arrayBuffer()`).
+     */
+    async #toBuffer(
+        path: string,
+        data: string | Uint8Array | ArrayBuffer | Blob,
+        encoding?: Encoding
+    ): Promise<Uint8Array> {
+        if (data instanceof Blob) {
+            return new Uint8Array(await data.arrayBuffer());
+        }
+
+        // If no encoding specified, auto-detect based on file extension
+        if (!encoding) {
+            encoding = (typeof data !== 'string' || isBinaryFileExtension(path)) ? 'binary' : 'utf-8';
+        }
+
+        if (typeof data === 'string') {
+            return encodeString(data, encoding);
+        }
+
+        return data instanceof Uint8Array ? data : new Uint8Array(data);
+    }
+
     /**
      * Write data to a file
      */
     async writeFile(
         path: PathLike,
-        data: string | Uint8Array | ArrayBuffer,
+        data: string | Uint8Array | ArrayBuffer | Blob,
         options?: { encoding?: Encoding } | Encoding
     ): Promise<void> {
         const normalizedPath = normalizePath(path);
@@ -139,15 +183,7 @@ export class OPFSFacade {
             encoding = options.encoding;
         }
 
-        // If no encoding specified, auto-detect based on file extension
-        if (!encoding) {
-            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';
-        }
-
-        // Convert data to Uint8Array
-        const buffer = typeof data === 'string'
-            ? encodeString(data, encoding)
-            : (data instanceof Uint8Array ? data : new Uint8Array(data));
+        const buffer = await this.#toBuffer(normalizedPath, data, encoding);
 
         return this.#fs.writeFile(normalizedPath, buffer);
     }
@@ -157,24 +193,37 @@ export class OPFSFacade {
      */
     async appendFile(
         path: PathLike,
-        data: string | Uint8Array | ArrayBuffer,
+        data: string | Uint8Array | ArrayBuffer | Blob,
         encoding?: Encoding
     ): Promise<void> {
         const normalizedPath = normalizePath(path);
 
-        // If no encoding specified, auto-detect based on file extension
-        if (!encoding) {
-            encoding = (typeof data !== 'string' || isBinaryFileExtension(normalizedPath)) ? 'binary' : 'utf-8';
-        }
-
-        // Convert data to Uint8Array
-        const buffer = typeof data === 'string'
-            ? encodeString(data, encoding)
-            : (data instanceof Uint8Array ? data : new Uint8Array(data));
+        const buffer = await this.#toBuffer(normalizedPath, data, encoding);
 
         return this.#fs.appendFile(normalizedPath, buffer);
     }
 
+    /**
+     * Create or overwrite a file from a byte stream without buffering the
+     * complete source in memory.
+     *
+     * Returns the total number of bytes written.
+     */
+    async importStream(
+        path: PathLike,
+        source: ReadableStream<Uint8Array> | Blob,
+        options?: { onProgress?: (bytesWritten: number) => void }
+    ): Promise<number> {
+        const normalizedPath = normalizePath(path);
+        const stream = source instanceof Blob ? source.stream() : source;
+        const transferredStream = transfer(stream, [stream]) as unknown as ReadableStream<Uint8Array>;
+        const onProgress = options?.onProgress
+            ? proxy((bytesWritten: number) => options.onProgress!(bytesWritten))
+            : undefined;
+
+        return this.#fs.writeStream(normalizedPath, transferredStream, onProgress);
+    }
+
     /**
      * Create a directory
      */
@@ -432,29 +481,9 @@ export class OPFSFacade {
     }
 
     /**
-     * Dispose of resources, detach the worker and clean up the file system instance
+     * Dispose of resources, detach the backend and clean up the file system instance
      */
     dispose() {
         this.#dispose();
     }
 }
-
-/**
- * Mode 1: start an inlined worker and get a Node-like `fs` API on top of it.
- *
- * For the raw worker API without the facade, use {@link createOPFSWorker}.
- * To use the worker class inside your own worker, see `opfs-worker/pure`.
- */
-export function createOPFS(options?: OPFSOptions): OPFSFacade {
-    return new OPFSFacade(options);
-}
-
-/**
- * @deprecated Use {@link createOPFS}. Kept for 1.x compatibility — still returns the facade.
- */
-export const createWorker = createOPFS;
-
-/**
- * @deprecated Use {@link OPFSFacade}.
- */
-export { OPFSFacade as OPFSFileSystem };

package/src/facade/createOPFSAsync.ts

@@ -0,0 +1,22 @@
+import { OPFSFacade } from './OPFSFacade';
+import { OPFSAsync } from '../core/OPFSAsync';
+
+import type { OPFSOptions } from '../types';
+
+/**
+ * Async mode: Node-like `fs` API over the promise-based File System API,
+ * without any worker.
+ *
+ * Prefer importing from `opfs-worker/async` when you care about bundle size
+ * (avoids the inlined dedicated worker). Importing from `opfs-worker` works too.
+ *
+ * Writing requires `FileSystemFileHandle.createWritable()` — Chrome, Firefox,
+ * Safari 26+. File descriptors (`open`/`read`/`write`/...) are not supported
+ * and throw `OperationNotSupportedError` — use `createOPFSDedicated` from `opfs-worker`
+ * or `opfs-worker/sync` for positional I/O.
+ */
+export function createOPFSAsync(options?: OPFSOptions): OPFSFacade {
+    const fs = new OPFSAsync(options);
+
+    return new OPFSFacade({ fs, dispose: () => fs.dispose() });
+}

package/src/facade/createOPFSDedicated.ts

@@ -0,0 +1,23 @@
+import { OPFSFacade } from './OPFSFacade';
+import { createDedicatedWorker } from '../worker/createDedicatedWorker';
+
+import type { DedicatedWorkerOptions } from '../worker/createDedicatedWorker';
+
+/**
+ * Dedicated mode: start a dedicated worker and get a Node-like `fs` API
+ * backed by `OPFSSync`.
+ *
+ * Prefer importing from `opfs-worker/sync` when you only need the worker backend
+ * (avoids pulling `OPFSAsync` into the graph). Importing from `opfs-worker` works too.
+ *
+ * By default uses an inlined worker. Pass `url` / `worker` to load
+ * `opfs-worker/dedicated.worker.js` instead (see {@link DedicatedWorkerOptions}).
+ *
+ * Need the raw bytes API or the Worker instance? Use `fs.backend` / `fs.worker`.
+ * For the workerless async backend, use {@link createOPFSAsync}.
+ */
+export function createOPFSDedicated(options?: DedicatedWorkerOptions): OPFSFacade {
+    const { fs, worker, dispose } = createDedicatedWorker(options);
+
+    return new OPFSFacade({ fs, worker, dispose });
+}

package/src/facade/createOPFSShared.ts

@@ -0,0 +1,30 @@
+import { OPFSFacade } from './OPFSFacade';
+import { createSharedWorker } from '../worker/createSharedWorker';
+
+import type { SharedWorkerOptions } from '../worker/createSharedWorker';
+
+/**
+ * Shared mode: Node-like `fs` API over a SharedWorker running one `OPFSAsync`
+ * instance for every tab — writes are serialized across tabs by per-path locks,
+ * watch events reach all tabs via `BroadcastChannel`.
+ *
+ * Uses the async backend (sync access handles are unavailable in SharedWorker):
+ * writing requires `createWritable()` (Chrome, Firefox, Safari 26+), and file
+ * descriptors throw `OperationNotSupportedError`.
+ *
+ * Need the raw bytes API or the SharedWorker? Use `fs.backend` / `fs.worker`.
+ *
+ * @example
+ * ```typescript
+ * // Vite: pass the worker url explicitly
+ * import workerUrl from 'opfs-worker/shared.worker.js?url';
+ * import { createOPFSShared } from 'opfs-worker/sharedworker';
+ *
+ * const fs = createOPFSShared({ root: '/my-app', url: workerUrl });
+ * ```
+ */
+export function createOPFSShared(options?: SharedWorkerOptions): OPFSFacade {
+    const { fs, worker, dispose } = createSharedWorker(options);
+
+    return new OPFSFacade({ fs, worker, dispose });
+}

package/src/index.async.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export * from './utils/errors';
+export * from './utils/helpers';
+export * from './utils/encoder';
+
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSAsync } from './core/OPFSAsync';
+export { OPFSFacade } from './facade/OPFSFacade';
+export type { OPFSBackend } from './facade/OPFSFacade';
+
+export { createOPFSAsync } from './facade/createOPFSAsync';

package/src/index.pure.ts

@@ -3,5 +3,6 @@ export * from './utils/errors';
 export * from './utils/helpers';
 export * from './utils/encoder';
 
-// Explicit re-export shadows the type-only `OPFSWorker` coming from './types'
-export { OPFSWorker } from './OPFSWorker';
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSSync } from './core/OPFSSync';
+export { OPFSAsync } from './core/OPFSAsync';

package/src/index.sharedworker.ts

@@ -0,0 +1,12 @@
+export * from './types';
+export * from './utils/errors';
+export * from './utils/helpers';
+export * from './utils/encoder';
+
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSAsync } from './core/OPFSAsync';
+export { OPFSFacade } from './facade/OPFSFacade';
+export type { OPFSBackend } from './facade/OPFSFacade';
+
+export { createOPFSShared } from './facade/createOPFSShared';
+export type { SharedWorkerOptions } from './worker/createSharedWorker';

package/src/index.sync.ts

@@ -0,0 +1,12 @@
+export * from './types';
+export * from './utils/errors';
+export * from './utils/helpers';
+export * from './utils/encoder';
+
+export { BaseOPFS } from './core/BaseOPFS';
+export { OPFSSync } from './core/OPFSSync';
+export { OPFSFacade } from './facade/OPFSFacade';
+export type { OPFSBackend } from './facade/OPFSFacade';
+
+export { createOPFSDedicated } from './facade/createOPFSDedicated';
+export type { DedicatedWorkerOptions } from './worker/createDedicatedWorker';

package/src/index.ts

@@ -4,12 +4,41 @@ export * from './utils/helpers';
 export * from './utils/encoder';
 
 export {
+    BaseOPFS,
     OPFSFacade,
-    OPFSFileSystem,
-    createOPFS,
-    // 1.x aliases
-    createWorker,
-} from './OPFSFacade';
-
-export { createOPFSWorker } from './createOPFSWorker';
-export type { RawWorker } from './createOPFSWorker';
+    OPFSSync,
+    createOPFSDedicated,
+} from './index.sync';
+
+export type {
+    DedicatedWorkerOptions,
+    OPFSBackend,
+} from './index.sync';
+
+export {
+    OPFSAsync,
+    createOPFSAsync,
+} from './index.async';
+
+export {
+    createOPFSShared,
+} from './index.sharedworker';
+
+export type {
+    SharedWorkerOptions,
+} from './index.sharedworker';
+
+/**
+ * Kept as a short alias for a default Sync backend
+ */
+export { createOPFSDedicated as createOPFS } from './index.sync';
+
+/**
+ * @deprecated Use {@link createOPFSDedicated}. Kept for 1.x → 2.x migration.
+ */
+export { createOPFSDedicated as createWorker } from './index.sync';
+
+/**
+ * @deprecated Use {@link OPFSFacade}. Kept for 1.x → 2.x migration.
+ */
+export { OPFSFacade as OPFSFileSystem } from './index.sync';

package/src/types.ts

@@ -1,5 +1,4 @@
-import type { OPFSWorker } from './OPFSWorker';
-import type { Remote } from 'comlink';
+import type { OPFSSync } from './core/OPFSSync';
 
 /**
  * Type for paths that can be either a string or URI
@@ -56,8 +55,13 @@ export interface WatchEvent {
     hash?: string;
 }
 
-export type { OPFSWorker };
-export type RemoteOPFSWorker = Remote<OPFSWorker>;
+export type { OPFSSync };
+
+/**
+ * Promise-based fs API surface shared by all backends: a Comlink proxy to
+ * `OPFSSync` in a worker, or an in-process `OPFSAsync` instance.
+ */
+export type OPFSApi = { [K in keyof OPFSSync]: OPFSSync[K] };
 
 export interface OPFSOptions {
     /** Root path for the file system (default: '/') */

package/src/worker/createDedicatedWorker.ts

@@ -0,0 +1,74 @@
+import { wrap } from 'comlink';
+
+import WorkerCtor from './dedicated.worker?worker&inline';
+
+import type { OPFSOptions, OPFSSync } from '../types';
+import type { Remote } from 'comlink';
+
+const InlineWorker = WorkerCtor as new (options?: WorkerOptions) => Worker;
+
+type RemoteOPFSSync = Remote<OPFSSync>;
+
+export interface DedicatedWorkerOptions extends OPFSOptions {
+    /**
+     * URL of the worker script, e.g. `import url from 'opfs-worker/dedicated.worker.js?url'` (Vite).
+     *
+     * Defaults to the inlined worker (no URL needed). Pass an explicit url when you
+     * prefer the self-contained file (strict CSP without `blob:`, or DIY hosting).
+     */
+    url?: string | URL;
+    /** Bring your own Worker instance (overrides `url`) */
+    worker?: Worker;
+}
+
+export interface RawWorker {
+    /** Comlink proxy to `OPFSSync` (bytes in / bytes out) */
+    fs: RemoteOPFSSync;
+    /** Underlying browser Worker */
+    worker: Worker;
+    /** Calls worker `dispose()` then `terminate()` */
+    dispose: () => void;
+}
+
+/** A `BroadcastChannel` instance can't cross the wire — send its name instead. */
+function applyWorkerOptions(fs: Pick<RemoteOPFSSync, 'setOptions'>, options?: OPFSOptions): void {
+    if (!options) {
+        return;
+    }
+
+    if (options.broadcastChannel instanceof BroadcastChannel) {
+        options.broadcastChannel = options.broadcastChannel.name;
+    }
+
+    void fs.setOptions(options);
+}
+
+/**
+ * Internal helper: spawn a dedicated worker and wrap `OPFSSync` with Comlink.
+ * Prefer {@link createOPFSDedicated}; access the proxy / Worker via
+ * `facade.backend` / `facade.worker`.
+ */
+export function createDedicatedWorker(options: DedicatedWorkerOptions = {}): RawWorker {
+    const { url, worker: providedWorker, ...fsOptions } = options;
+
+    const worker = providedWorker
+      ?? (url ? new Worker(url, { type: 'module' }) : new InlineWorker());
+    const fs = wrap<RemoteOPFSSync>(worker);
+
+    applyWorkerOptions(fs, fsOptions);
+
+    return {
+        fs,
+        worker,
+        dispose() {
+            void (async() => {
+                try {
+                    await fs.dispose();
+                }
+                finally {
+                    worker.terminate();
+                }
+            })();
+        },
+    };
+}

package/src/worker/createSharedWorker.ts

@@ -0,0 +1,67 @@
+import { wrap } from 'comlink';
+
+import type { OPFSAsync } from '../core/OPFSAsync';
+import type { OPFSOptions } from '../types';
+import type { Remote } from 'comlink';
+
+type RemoteOPFSAsync = Remote<OPFSAsync>;
+
+export interface SharedWorkerOptions extends OPFSOptions {
+    /**
+     * URL of the worker script, e.g. `import url from 'opfs-worker/shared.worker.js?url'` (Vite).
+     *
+     * Defaults to `new URL('./shared.worker.js', import.meta.url)`, which works when
+     * `opfs-worker` is served as-is (CDN, unbundled deps). When your bundler inlines
+     * the package into app chunks, pass the url explicitly.
+     */
+    url?: string | URL;
+    /** Bring your own SharedWorker instance (overrides `url`) */
+    worker?: SharedWorker;
+    /** Worker name — tabs with the same script URL + name share one instance (default: 'opfs-worker') */
+    name?: string;
+}
+
+export interface RawSharedWorker {
+    /** Comlink proxy to the `OPFSAsync` instance shared by all connected tabs */
+    fs: RemoteOPFSAsync;
+    /** Underlying browser SharedWorker */
+    worker: SharedWorker;
+    /** Closes this tab's port; the worker keeps running for other tabs */
+    dispose: () => void;
+}
+
+/**
+ * Internal helper: connect to the SharedWorker and wrap `OPFSAsync` with Comlink.
+ * Prefer {@link createOPFSShared}; access the proxy / SharedWorker via
+ * `facade.backend` / `facade.worker`.
+ *
+ * Note: `OPFSOptions` are applied via `setOptions()` on the shared instance, so
+ * they affect every connected tab — use the same options in all tabs.
+ */
+export function createSharedWorker(options: SharedWorkerOptions = {}): RawSharedWorker {
+    const { url, worker: providedWorker, name = 'opfs-worker', ...fsOptions } = options;
+
+    const worker = providedWorker ?? new SharedWorker(
+        url ?? new URL('./shared.worker.js', import.meta.url),
+        { type: 'module', name }
+    );
+
+    const fs = wrap<RemoteOPFSAsync>(worker.port);
+
+    if (Object.keys(fsOptions).length > 0) {
+        // A BroadcastChannel instance can't cross the wire — send its name instead
+        if (fsOptions.broadcastChannel instanceof BroadcastChannel) {
+            fsOptions.broadcastChannel = fsOptions.broadcastChannel.name;
+        }
+
+        void fs.setOptions(fsOptions);
+    }
+
+    return {
+        fs,
+        worker,
+        dispose() {
+            worker.port.close();
+        },
+    };
+}

package/src/worker/dedicated.worker.ts

@@ -0,0 +1,13 @@
+import { expose } from 'comlink';
+
+import { OPFSSync } from '../core/OPFSSync';
+
+/**
+ * Dedicated worker entry.
+ *
+ * Built two ways:
+ * - Inlined into `createOPFSDedicated` via `?worker&inline` (default path)
+ * - Self-contained `dist/dedicated.worker.js` → `opfs-worker/dedicated.worker.js`
+ *   for DIY `new Worker(url, { type: 'module' })` + Comlink wrap
+ */
+expose(new OPFSSync());

package/src/worker/shared.worker.ts

@@ -0,0 +1,17 @@
+import { expose } from 'comlink';
+
+import { OPFSAsync } from '../core/OPFSAsync';
+
+/**
+ * Shared worker entry — built self-contained (comlink bundled in) to
+ * `dist/shared.worker.js`, exposed as `opfs-worker/shared.worker.js`.
+ *
+ * One `OPFSAsync` instance serves every connected tab, so per-path locks
+ * naturally serialize writes across tabs. Sync access handles are not
+ * available in a SharedWorker, hence the async backend.
+ */
+const fs = new OPFSAsync();
+
+(globalThis as unknown as { onconnect: (event: MessageEvent) => void }).onconnect = (event: MessageEvent) => {
+    expose(fs, event.ports[0]);
+};

package/dist/OPFSFacade.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OPFSFacade.d.ts","sourceRoot":"","sources":["../src/OPFSFacade.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACR,cAAc,EACd,UAAU,EACV,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,WAAW,EACX,QAAQ,EAER,aAAa,EACb,cAAc,EACd,YAAY,EACf,MAAM,SAAS,CAAC;AAcjB;;;;;GAKG;AACH,qBAAa,UAAU;;IAGnB,QAAQ,EAAE,UAAU,CAAQ;gBAEhB,OAAO,CAAC,EAAE,WAAW;IAOjC;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,IAAI;IAQzD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,QAAQ;IAMtB;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,WAAW;IAIrC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAI7C;;OAEG;IAEG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAEnE,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC;IAEvE,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAEhF,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAEpF,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,UAAU,CAAC;IA6B5D;;OAEG;IACG,SAAS,CACX,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,EACvC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;KAAE,GAAG,QAAQ,GAC7C,OAAO,CAAC,IAAI,CAAC;IAyBhB;;OAEG;IACG,UAAU,CACZ,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,EACvC,QAAQ,CAAC,EAAE,QAAQ,GACpB,OAAO,CAAC,IAAI,CAAC;IAgBhB;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBnF;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAM7C;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAMpD;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAM9C;;OAEG;IACG,KAAK,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3C;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM/F;;OAEG;IACG,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3C;;OAEG;IACG,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3F;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1C;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAIxE;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAI9C;;OAEG;IACG,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1D;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAM/C;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAO1F;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO1H;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAMtE;;OAEG;IACG,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC;;;;;;OAMG;IACG,IAAI,CACN,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACrC,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,UAAU,CAAA;KAAE,CAAC;IAkBrD;;OAEG;IACG,KAAK,CACP,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,UAAU,EAClB,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,SAAS,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,MAAM,CAAC;IAIlB;;OAEG;IACG,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAI1C;;OAEG;IACG,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzD;;OAEG;IACG,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC;;OAEG;IACG,WAAW,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnF;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,GAAE,QAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAO7E;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,QAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO1F;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,QAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAO3F;;OAEG;IACH,OAAO;CAGV;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,UAAU,CAE5D;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,mBAAa,CAAC;AAEvC;;GAEG;AACH,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,CAAC"}

package/dist/OPFSWorker.d.ts.map

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