@zenfs/core 0.2.3 → 0.3.1

package/dist/file.d.ts

@@ -1,5 +1,5 @@
+import type { FileSystem } from './filesystem.js';
 import { Stats, type FileType } from './stats.js';
-import { FileSystem, type SyncFileSystem } from './filesystem.js';
 declare global {
     interface ArrayBuffer {
         readonly resizable: boolean;
@@ -419,7 +419,7 @@ export declare abstract class PreloadFile<T extends FileSystem> extends File {
 /**
  * For synchronous file systems
  */
-export declare class SyncFile<FS extends SyncFileSystem> extends PreloadFile<FS> {
+export declare class SyncFile<FS extends FileSystem> extends PreloadFile<FS> {
     constructor(_fs: FS, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     sync(): Promise<void>;
     syncSync(): void;

package/dist/file.js

@@ -1,7 +1,7 @@
 import { ApiError, ErrorCode } from './ApiError.js';
-import { Stats } from './stats.js';
-import { O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC, O_APPEND, O_SYNC, S_IFMT } from './emulation/constants.js';
+import { O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_SYNC, O_TRUNC, O_WRONLY, S_IFMT } from './emulation/constants.js';
 import { size_max } from './inode.js';
+import { Stats } from './stats.js';
 export var ActionType;
 (function (ActionType) {
     // Indicates that the code should not do anything.

package/dist/filesystem.d.ts

@@ -46,7 +46,6 @@ export interface FileSystemMetadata {
  * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
  */
 export declare abstract class FileSystem {
-    static get Name(): string;
     get metadata(): FileSystemMetadata;
     constructor(options?: object);
     abstract ready(): Promise<this>;
@@ -155,11 +154,12 @@ export declare abstract class FileSystem {
     abstract syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }
 /**
- * Implements the asynchronous API in terms of the synchronous API.
+ * @internal
  */
-export declare abstract class SyncFileSystem extends FileSystem {
+declare abstract class SyncFileSystem extends FileSystem {
     get metadata(): FileSystemMetadata;
     ready(): Promise<this>;
+    exists(path: string, cred: Cred): Promise<boolean>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
     createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
@@ -171,20 +171,18 @@ export declare abstract class SyncFileSystem extends FileSystem {
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
 }
-export declare abstract class ReadonlySyncFileSystem extends SyncFileSystem {
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
-    unlinkSync(path: string, cred: Cred): void;
-    rmdirSync(path: string, cred: Cred): void;
-    mkdirSync(path: string, mode: number, cred: Cred): void;
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}
-export declare abstract class AsyncFileSystem extends FileSystem {
+/**
+ * Implements the asynchronous API in terms of the synchronous API.
+ */
+export declare function Sync<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => SyncFileSystem) & T;
+/**
+ * @internal
+ */
+declare abstract class AsyncFileSystem {
+    get metadata(): FileSystemMetadata;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
     createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
-    openSync(path: string, flags: FileFlag, mode: number, cred: Cred): File;
     openFileSync(path: string, flag: FileFlag, cred: Cred): File;
     unlinkSync(path: string, cred: Cred): void;
     rmdirSync(path: string, cred: Cred): void;
@@ -193,12 +191,26 @@ export declare abstract class AsyncFileSystem extends FileSystem {
     linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }
-export declare abstract class ReadonlyAsyncFileSystem extends AsyncFileSystem {
+export declare function Async<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => AsyncFileSystem) & T;
+/**
+ * @internal
+ */
+declare abstract class ReadonlyFileSystem {
+    get metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    renameSync(oldPath: string, newPath: string, cred: Cred): void;
     createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
     unlink(path: string, cred: Cred): Promise<void>;
+    unlinkSync(path: string, cred: Cred): void;
     rmdir(path: string, cred: Cred): Promise<void>;
+    rmdirSync(path: string, cred: Cred): void;
     mkdir(path: string, mode: number, cred: Cred): Promise<void>;
+    mkdirSync(path: string, mode: number, cred: Cred): void;
     link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
+    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }
+export declare function Readonly<T extends abstract new (...args: any[]) => FileSystem>(FS: T): (abstract new (...args: any[]) => ReadonlyFileSystem) & T;
+export {};

package/dist/filesystem.js

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// disable no-unused-vars since BaseFileSystem uses them a lot
 import { ApiError, ErrorCode } from './ApiError.js';
 /**
  * Structure for a filesystem. All ZenFS FileSystems must implement this.
@@ -12,9 +10,6 @@ import { ApiError, ErrorCode } from './ApiError.js';
  * - All arguments are present. Any optional arguments at the Node API level have been passed in with their default values.
  */
 export class FileSystem {
-    static get Name() {
-        return this.name;
-    }
     get metadata() {
         return {
             name: this.constructor.name,
@@ -25,6 +20,7 @@ export class FileSystem {
             freeSpace: 0,
         };
     }
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
     constructor(options) {
         // unused
     }
@@ -56,122 +52,141 @@ export class FileSystem {
 /**
  * Implements the asynchronous API in terms of the synchronous API.
  */
-export class SyncFileSystem extends FileSystem {
-    get metadata() {
-        return { ...super.metadata, synchronous: true };
-    }
-    async ready() {
-        return this;
-    }
-    async rename(oldPath, newPath, cred) {
-        return this.renameSync(oldPath, newPath, cred);
-    }
-    async stat(path, cred) {
-        return this.statSync(path, cred);
-    }
-    async createFile(path, flag, mode, cred) {
-        return this.createFileSync(path, flag, mode, cred);
-    }
-    async openFile(path, flag, cred) {
-        return this.openFileSync(path, flag, cred);
-    }
-    async unlink(path, cred) {
-        return this.unlinkSync(path, cred);
-    }
-    async rmdir(path, cred) {
-        return this.rmdirSync(path, cred);
-    }
-    async mkdir(path, mode, cred) {
-        return this.mkdirSync(path, mode, cred);
-    }
-    async readdir(path, cred) {
-        return this.readdirSync(path, cred);
-    }
-    async link(srcpath, dstpath, cred) {
-        return this.linkSync(srcpath, dstpath, cred);
-    }
-    async sync(path, data, stats) {
-        return this.syncSync(path, data, stats);
-    }
-}
-export class ReadonlySyncFileSystem extends SyncFileSystem {
-    renameSync(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    createFileSync(path, flag, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    unlinkSync(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    rmdirSync(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    mkdirSync(path, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    linkSync(srcpath, dstpath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    syncSync(path, data, stats) {
-        throw new ApiError(ErrorCode.EROFS);
+export function Sync(FS) {
+    /**
+     * Implements the asynchronous API in terms of the synchronous API.
+     */
+    class _SyncFileSystem extends FS {
+        get metadata() {
+            return { ...super.metadata, synchronous: true };
+        }
+        async ready() {
+            return this;
+        }
+        async exists(path, cred) {
+            return this.existsSync(path, cred);
+        }
+        async rename(oldPath, newPath, cred) {
+            return this.renameSync(oldPath, newPath, cred);
+        }
+        async stat(path, cred) {
+            return this.statSync(path, cred);
+        }
+        async createFile(path, flag, mode, cred) {
+            return this.createFileSync(path, flag, mode, cred);
+        }
+        async openFile(path, flag, cred) {
+            return this.openFileSync(path, flag, cred);
+        }
+        async unlink(path, cred) {
+            return this.unlinkSync(path, cred);
+        }
+        async rmdir(path, cred) {
+            return this.rmdirSync(path, cred);
+        }
+        async mkdir(path, mode, cred) {
+            return this.mkdirSync(path, mode, cred);
+        }
+        async readdir(path, cred) {
+            return this.readdirSync(path, cred);
+        }
+        async link(srcpath, dstpath, cred) {
+            return this.linkSync(srcpath, dstpath, cred);
+        }
+        async sync(path, data, stats) {
+            return this.syncSync(path, data, stats);
+        }
     }
+    return _SyncFileSystem;
 }
-export class AsyncFileSystem extends FileSystem {
-    renameSync(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    statSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    createFileSync(path, flag, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    openSync(path, flags, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    openFileSync(path, flag, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    unlinkSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    rmdirSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    mkdirSync(path, mode, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    readdirSync(path, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    linkSync(srcpath, dstpath, cred) {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    }
-    syncSync(path, data, stats) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+export function Async(FS) {
+    class _AsyncFileSystem extends FS {
+        get metadata() {
+            return { ...super.metadata, synchronous: false };
+        }
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        renameSync(oldPath, newPath, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        statSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        createFileSync(path, flag, mode, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        openFileSync(path, flag, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        unlinkSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        rmdirSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        mkdirSync(path, mode, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        readdirSync(path, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        linkSync(srcpath, dstpath, cred) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
+        syncSync(path, data, stats) {
+            throw new ApiError(ErrorCode.ENOTSUP);
+        }
     }
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+    return _AsyncFileSystem;
 }
-export class ReadonlyAsyncFileSystem extends AsyncFileSystem {
-    async rename(oldPath, newPath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async createFile(path, flag, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async unlink(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async rmdir(path, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async mkdir(path, mode, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async link(srcpath, dstpath, cred) {
-        throw new ApiError(ErrorCode.EROFS);
-    }
-    async sync(path, data, stats) {
-        throw new ApiError(ErrorCode.EROFS);
+export function Readonly(FS) {
+    class _ReadonlyFileSystem extends FS {
+        get metadata() {
+            return { ...super.metadata, readonly: true };
+        }
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        async rename(oldPath, newPath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        renameSync(oldPath, newPath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async createFile(path, flag, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        createFileSync(path, flag, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async unlink(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        unlinkSync(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async rmdir(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        rmdirSync(path, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async mkdir(path, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        mkdirSync(path, mode, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async link(srcpath, dstpath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        linkSync(srcpath, dstpath, cred) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        async sync(path, data, stats) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
+        syncSync(path, data, stats) {
+            throw new ApiError(ErrorCode.EROFS);
+        }
     }
+    return _ReadonlyFileSystem;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenfs/core",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "A filesystem in your browser",
   "main": "dist/index.js",
   "types": "dist",

package/readme.md

@@ -4,14 +4,16 @@ ZenFS is an in-browser file system that emulates the [Node JS file system API](h
 
 ## Backends
 
-ZenFS is highly extensible, and includes many builtin filesystem backends:
+ZenFS is highly extensible, and includes a few built-in backends:
 
 -   `InMemory`: Stores files in-memory. It is a temporary file store that clears when the user navigates away.
 -   `Overlay`: Mount a read-only file system as read-write by overlaying a writable file system on top of it. Like Docker's overlayfs, it will only write changed files to the writable file system.
 -   `AsyncMirror`: Use an asynchronous backend synchronously. Invaluable for Emscripten; let your Emscripten applications write to larger file stores with no additional effort!
-    -   `AsyncMirror` loads the entire contents of the async file system into a synchronous backend during construction. It performs operations synchronous file system and then queues them to be mirrored onto the asynchronous backend.
 
-More backends can be defined by separate libraries, so long as they extend they implement `ZenFS.FileSystem`. Multiple backends can be active at once at different locations in the directory hierarchy.
+> [!NOTE]
+> When constructed, `AsyncMirror` loads the entire contents of the async file system into a synchronous backend. It performs operations on the synchronous file system and then queues them to be mirrored onto the asynchronous backend.
+
+More backends can be defined by separate libraries, as long as they implement `FileSystem`.
 
 ZenFS supports a number of other backends (many are provided as seperate packages under `@zenfs`).
 
@@ -25,7 +27,8 @@ npm install @zenfs/core
 
 ## Usage
 
-> 🛈 The examples are written in ESM. If you are using CJS, you can `require` the package. If running in a browser you can add a script tag to your HTML pointing to the `browser.min.js` and use ZenFS via the global `ZenFS` object.
+> [!NOTE]
+> The examples are written in ESM. If you are using CJS, you can `require` the package. If running in a browser you can add a script tag to your HTML pointing to the `browser.min.js` and use ZenFS via the global `ZenFS` object.
 
 ```js
 import fs from '@zenfs/core';
@@ -36,27 +39,15 @@ const contents = fs.readFileSync('/test.txt', 'utf-8');
 console.log(contents);
 ```
 
-#### Using different backends
+#### Using different and/or different backends
 
-A `InMemory` backend is created by default. If you would like to use a different one, you must configure ZenFS. It is recommended to do so using the `configure` function. Here is an example using the `Storage` backend from `@zenfs/dom`:
+A single `InMemory` backend is created by default, mounted on `/`.
 
-```js
-import { configure, fs } from '@zenfs/core';
-import { StorageStore } from '@zenfs/dom';
+You can configure ZenFS to use a different backend and mount multiple backends. It is strongly recommended to do so using the `configure` function.
 
-await configure({ backend: StorageStore });
+You can use multiple backends by passing an object to `configure` which maps paths to file systems.
 
-if (!fs.existsSync('/test.txt')) {
-	fs.writeFileSync('/test.txt', 'This will persist across reloads!');
-}
-
-const contents = fs.readFileSync('/test.txt', 'utf-8');
-console.log(contents);
-```
-
-#### Using multiple backends
-
-You can use multiple backends by passing an object to `configure` which maps paths to file systems. The following example mounts a zip file to `/zip`, in-memory storage to `/tmp`, and IndexedDB storage to `/home` (note that `/` has the default in-memory backend):
+The following example mounts a zip file to `/zip`, in-memory storage to `/tmp`, and IndexedDB to `/home`. Note that `/` has the default in-memory backend.
 
 ```js
 import { configure } from '@zenfs/core';
@@ -66,16 +57,32 @@ import { Zip } from '@zenfs/zip';
 const zipData = await (await fetch('mydata.zip')).arrayBuffer();
 
 await configure({
-	'/mnt/zip': {
-		backend: Zip,
-		zipData: zipData,
-	},
+	'/mnt/zip': { backend: Zip, zipData },
 	'/tmp': 'InMemory',
 	'/home': IndexedDB,
 };
 ```
 
-#### FS Promises API
+> [!TIP]
+> When configuring a mount point, you can pass in 1. A string that maps to a built-in backend 2. A `Backend` object, if the backend has no required options 3. An object that has a `backend` property which is a `Backend` or a string that maps to a built-in backend and the options accepted by the backend
+
+Here is an example that mounts the `Storage` backend from `@zenfs/dom` on `/`:
+
+```js
+import { configure, fs } from '@zenfs/core';
+import { Storage } from '@zenfs/dom';
+
+await configure({ backend: Storage });
+
+if (!fs.existsSync('/test.txt')) {
+	fs.writeFileSync('/test.txt', 'This will persist across reloads!');
+}
+
+const contents = fs.readFileSync('/test.txt', 'utf-8');
+console.log(contents);
+```
+
+#### FS Promises
 
 The FS promises API is exposed as `promises`.
 
@@ -91,11 +98,15 @@ if (!exists) {
 }
 ```
 
-ZenFS does _not_ provide a seperate public import for importing promises in its built form. If you are using ESM, you can import promises functions from `dist/emulation/promises`, though this may change at any time and is not recommended.
+> [!NOTE]
+> You can import the promises API using `promises`, or using `fs.promises` on the exported `fs`.
+
+> [!IMPORTANT]
+> ZenFS does _not_ provide a seperate public import for importing promises like `fs/promises`. If you are using ESM, you can import promises functions like `fs/promises` from the `dist/emulation/promises.ts` file, though this may change at any time and is **not recommended**.
 
 #### Using asynchronous backends synchronously
 
-You may have noticed that attempting to use a synchronous function on an asynchronous backend (e.g. IndexedDB) results in a "not supplied" error (`ENOTSUP`). If you wish to use an asynchronous backend synchronously you need to wrap it in an `AsyncMirror`:
+You may have noticed that attempting to use a synchronous function on an asynchronous backend (e.g. `IndexedDB`) results in a "not supplied" error (`ENOTSUP`). If you would like to use an asynchronous backend synchronously you need to wrap it in an `AsyncMirror`:
 
 ```js
 import { configure, fs } from '@zenfs/core';
@@ -109,55 +120,23 @@ await configure({
 	},
 });
 
-fs.writeFileSync('/persistant.txt', 'My persistant data'); // This fails if you configure with only IndexedDB
+fs.writeFileSync('/persistant.txt', 'My persistant data');
 ```
 
-### Advanced usage
+#### Mounting and unmounting, creating backends
 
-#### Creating backends
+If you would like to create backends without configure (e.g. to do something dynamic at runtime), you may do so by importing the backend and calling `createBackend` with it.
 
-If you would like to create backends without configure, you may do so by importing the backend and calling `createBackend` with it. You can import the backend directly or with `backends`:
-
-```js
-import { configure, backends, InMemory } from '@zenfs/core';
-
-console.log(backends.InMemory === InMemory); // they are the same
-
-const internalInMemoryFS = await createBackend(InMemory);
-```
-
-> ⚠ Instances of backends follow the **_internal_** ZenFS API. You should never use a backend's methods unless you are extending a backend.
-
-```js
-import { configure, InMemory } from '@zenfs/core';
-
-const internalInMemoryFS = new InMemory();
-await internalInMemoryFS.ready();
-```
-
-#### Mounting
-
-If you would like to mount and unmount backends, you can do so using the `mount` and `umount` functions:
-
-```js
-import { fs, InMemory } from '@zenfs/core';
-
-const internalInMemoryFS = await createBackend(InMemory); // create an FS instance
-
-fs.mount('/tmp', internalInMemoryFS); // mount
-
-fs.umount('/tmp'); // unmount /tmp
-```
-
-This could be used in the "multiple backends" example like so:
+You can then mount and unmount the backend instance by using `mount` and `umount`.
 
 ```js
+import { configure, createBackend } from '@zenfs/core';
 import { IndexedDB  } from '@zenfs/dom';
 import { Zip } from '@zenfs/zip';
 
 await configure({
 	'/tmp': 'InMemory',
-	'/home': 'IndexedDB',
+	'/home': IndexedDB,
 };
 
 fs.mkdirSync('/mnt');
@@ -171,6 +150,9 @@ fs.mount('/mnt/zip', zipFs);
 fs.umount('/mnt/zip'); // finished using the zip
 ```
 
+> [!WARNING]
+> Instances of backends follow the **internal** ZenFS API. You should never use a backend's methods unless you are extending a backend.
+
 ## Using with bundlers
 
 ZenFS exports a drop-in for Node's `fs` module (up to the version of `@types/node` in package.json), so you can use it for your bundler of preference using the default export.
@@ -185,7 +167,3 @@ ZenFS exports a drop-in for Node's `fs` module (up to the version of `@types/nod
 ### Testing
 
 Run unit tests with `npm test`.
-
-### License
-
-ZenFS is licensed under the MIT License.

package/dist/backends/FolderAdapter.d.ts

@@ -1,52 +0,0 @@
-import { BaseFileSystem, type FileSystem } from '../filesystem.js';
-import { type BackendOptions } from './backend.js';
-export declare namespace FolderAdapter {
-    /**
-     * Configuration options for a FolderAdapter file system.
-     */
-    interface Options {
-        folder: string;
-        wrapped: FileSystem;
-    }
-}
-/**
- * The FolderAdapter file system wraps a file system, and scopes all interactions to a subfolder of that file system.
- *
- * Example: Given a file system `foo` with folder `bar` and file `bar/baz`...
- *
- * ```javascript
- * ZenFS.configure({
- *   fs: "FolderAdapter",
- *   options: {
- *     folder: "bar",
- *     wrapped: foo
- *   }
- * }, function(e) {
- *   var fs = ZenFS.BFSRequire('fs');
- *   fs.readdirSync('/'); // ['baz']
- * });
- * ```
- */
-export declare class FolderAdapter extends BaseFileSystem {
-    static readonly Name = "FolderAdapter";
-    static Create: any;
-    static readonly Options: BackendOptions;
-    static isAvailable(): boolean;
-    _wrapped: FileSystem;
-    _folder: string;
-    constructor({ folder, wrapped }: FolderAdapter.Options);
-    get metadata(): {
-        supportsLinks: boolean;
-        name: string;
-        readonly: boolean;
-        synchronous: boolean;
-        supportsProperties: boolean;
-        totalSpace: number;
-        freeSpace: number;
-    };
-    /**
-     * Initialize the file system. Ensures that the wrapped file system
-     * has the given folder.
-     */
-    private _initialize;
-}