sandbox-fs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,418 @@
+# sandbox-fs
+
+A read-only virtual file system for Node.js that maps Unix-style virtual paths to a real directory root. Provides a secure sandbox environment where write operations are blocked and real filesystem paths are hidden from error messages.
+
+## Features
+
+- 🔒 **Read-only**: All write operations return `EACCES` (access denied)
+- 🌍 **Cross-platform**: Works with both Windows and Unix paths as root
+- 🔀 **Unix-style virtual paths**: All virtual paths use forward slashes (`/`)
+- 🚫 **Path traversal protection**: Prevents escaping the VFS root with `..`
+- 🎭 **Error filtering**: Real paths in error messages are replaced with virtual paths
+- 📦 **Full fs API**: Compatible with Node.js `fs` module (both callback and promise APIs)
+- 🛤️ **Path module**: Virtual `path` module with fixed CWD of `/`
+- 🧹 **Resource cleanup**: Proper cleanup of file descriptors and streams
+
+## Installation
+
+```bash
+npm install sandbox-fs
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+
+## Quick Start
+
+```typescript
+import { VirtualFileSystem } from 'sandbox-fs';
+
+// Create a VFS instance with a real directory as root
+const vfs = new VirtualFileSystem({ root: '/opt/data' });
+
+// Get fs and path modules
+const fs = vfs.createNodeFSModule();
+const path = vfs.createNodePathModule();
+
+// Read files using virtual paths
+// Virtual path: /config.json
+// Real path: /opt/data/config.json
+const config = fs.readFileSync('/config.json', 'utf8');
+
+// Write operations are denied
+try {
+  fs.writeFileSync('/output.txt', 'data');
+} catch (err) {
+  console.log(err.code); // 'EACCES'
+}
+
+// Path operations use virtual CWD of '/'
+console.log(path.resolve('.')); // '/'
+console.log(path.resolve('foo/bar.txt')); // '/foo/bar.txt'
+
+// Clean up when done
+vfs.close();
+```
+
+## API Reference
+
+### `VirtualFileSystem`
+
+The main class for creating a virtual file system instance.
+
+#### Constructor
+
+```typescript
+new VirtualFileSystem(options: VFSOptions)
+```
+
+Creates a new VFS instance.
+
+**Parameters:**
+- `options.root` (string): The real filesystem path to use as the VFS root. Can be a Windows path (`C:\data`) or Unix path (`/opt/data`).
+
+**Throws:**
+- Error if the root path doesn't exist or is not a directory
+
+**Example:**
+```typescript
+// Unix
+const vfs = new VirtualFileSystem({ root: '/opt/data' });
+
+// Windows
+const vfs = new VirtualFileSystem({ root: 'C:\\data' });
+```
+
+#### `toRealPath(virtualPath: string): string`
+
+Converts a virtual path to a real filesystem path.
+
+**Parameters:**
+- `virtualPath` (string): Virtual path starting with `/` (Unix-style)
+
+**Returns:** Real filesystem path (platform-native)
+
+**Throws:**
+- Error if path traversal is detected (e.g., `/../etc/passwd`)
+
+**Example:**
+```typescript
+const vfs = new VirtualFileSystem({ root: 'C:\\data' });
+vfs.toRealPath('/foo/bar.txt'); // Returns: 'C:\data\foo\bar.txt'
+```
+
+#### `toVirtualPath(realPath: string): string`
+
+Converts a real filesystem path to a virtual path.
+
+**Parameters:**
+- `realPath` (string): Real filesystem path (platform-native)
+
+**Returns:** Virtual path starting with `/` (Unix-style)
+
+**Throws:**
+- Error if real path is outside the VFS root
+
+**Example:**
+```typescript
+const vfs = new VirtualFileSystem({ root: 'C:\\data' });
+vfs.toVirtualPath('C:\\data\\foo\\bar.txt'); // Returns: '/foo/bar.txt'
+```
+
+#### `createNodeFSModule(): any`
+
+Creates a Node.js `fs`-compatible module.
+
+**Returns:** An object compatible with the Node.js `fs` module
+
+The returned object includes:
+- **Callback API**: `readFile()`, `stat()`, `readdir()`, etc.
+- **Promise API**: `fs.promises.readFile()`, `fs.promises.stat()`, etc.
+- **Sync API**: `readFileSync()`, `statSync()`, `readdirSync()`, etc.
+- **Stream API**: `createReadStream()` (write streams throw EACCES)
+- **Constants**: `fs.constants`
+
+**Behavior:**
+- ✅ **Read operations**: Work normally (readFile, stat, readdir, open, createReadStream, etc.)
+- ❌ **Write operations**: Throw `EACCES` (writeFile, mkdir, unlink, etc.)
+- ❌ **Symlink operations**: Throw `EACCES` (symlink, link, readlink)
+- 🔒 **Error filtering**: All error messages replace real paths with virtual paths
+
+**Example:**
+```typescript
+const fs = vfs.createNodeFSModule();
+
+// Callback API
+fs.readFile('/file.txt', 'utf8', (err, data) => {
+  if (err) throw err;
+  console.log(data);
+});
+
+// Promise API
+const data = await fs.promises.readFile('/file.txt', 'utf8');
+
+// Sync API
+const data = fs.readFileSync('/file.txt', 'utf8');
+
+// Stream API
+const stream = fs.createReadStream('/large-file.txt');
+stream.on('data', chunk => console.log(chunk));
+```
+
+#### `createNodePathModule(): any`
+
+Creates a Node.js `path`-compatible module.
+
+**Returns:** An object compatible with the Node.js `path` module
+
+The returned object includes all `path` methods operating in virtual path space:
+- `resolve()`, `join()`, `normalize()`, `relative()`
+- `dirname()`, `basename()`, `extname()`
+- `parse()`, `format()`, `isAbsolute()`
+- `sep`, `delimiter`, `posix`, `win32`
+
+**Behavior:**
+- All paths use Unix-style forward slashes (`/`)
+- Virtual CWD is always `/`
+- `path.sep` is always `/`
+- `path.delimiter` is always `:`
+- Both `path.posix` and `path.win32` reference the same virtual implementation
+
+**Example:**
+```typescript
+const path = vfs.createNodePathModule();
+
+path.resolve('.');                // Returns: '/'
+path.resolve('foo/bar.txt');      // Returns: '/foo/bar.txt'
+path.join('/foo', 'bar');         // Returns: '/foo/bar'
+path.dirname('/foo/bar.txt');     // Returns: '/foo'
+path.basename('/foo/bar.txt');    // Returns: 'bar.txt'
+path.sep;                          // Returns: '/'
+```
+
+#### `close(): void`
+
+Closes the VFS and releases all resources.
+
+This method:
+- Closes all tracked file descriptors
+- Destroys all active streams
+- Marks the VFS as closed
+- Causes all subsequent fs operations to throw `EBADF`
+
+**Example:**
+```typescript
+const vfs = new VirtualFileSystem({ root: '/opt/data' });
+const fs = vfs.createNodeFSModule();
+
+const fd = fs.openSync('/file.txt', 'r');
+
+vfs.close(); // Closes fd and all other resources
+
+// All operations now throw EBADF
+fs.readFileSync('/file.txt'); // Throws: EBADF (bad file descriptor)
+```
+
+#### `closed` (getter)
+
+**Returns:** `boolean` - Whether the VFS has been closed
+
+```typescript
+if (!vfs.closed) {
+  vfs.close();
+}
+```
+
+## Security Features
+
+### Path Traversal Protection
+
+The VFS validates all paths to prevent escaping the root directory:
+
+```typescript
+const vfs = new VirtualFileSystem({ root: '/opt/data' });
+const fs = vfs.createNodeFSModule();
+
+// These throw errors:
+fs.readFileSync('/../etc/passwd');      // Error: Path traversal detected
+fs.readFileSync('/foo/../../etc/passwd'); // Error: Path traversal detected
+```
+
+### Error Message Filtering
+
+Real filesystem paths are automatically filtered from error messages:
+
+```typescript
+const vfs = new VirtualFileSystem({ root: '/opt/data' });
+const fs = vfs.createNodeFSModule();
+
+try {
+  fs.readFileSync('/nonexistent.txt');
+} catch (err) {
+  // Real error: ENOENT: no such file or directory, open '/opt/data/nonexistent.txt'
+  // Filtered error: ENOENT: no such file or directory, open '/nonexistent.txt'
+  console.log(err.message); // Real path is replaced with virtual path
+}
+```
+
+### Read-Only Enforcement
+
+All write operations return `EACCES`:
+
+```typescript
+const fs = vfs.createNodeFSModule();
+
+// All of these throw EACCES:
+fs.writeFileSync('/file.txt', 'data');
+fs.appendFileSync('/file.txt', 'data');
+fs.mkdirSync('/newdir');
+fs.unlinkSync('/file.txt');
+fs.rmdirSync('/dir');
+fs.renameSync('/old.txt', '/new.txt');
+fs.chmodSync('/file.txt', 0o644);
+fs.createWriteStream('/file.txt'); // Throws immediately
+```
+
+### Symlink Blocking
+
+All symlink operations return `EACCES`:
+
+```typescript
+const fs = vfs.createNodeFSModule();
+
+// All of these throw EACCES:
+fs.symlinkSync('/target', '/link');
+fs.linkSync('/existing', '/new');
+fs.readlinkSync('/symlink');
+
+// stat/lstat also throw EACCES if the target is a symlink
+const stats = fs.statSync('/symlink'); // Throws EACCES
+```
+
+## Platform Support
+
+### Windows
+- VFS root can be a Windows path: `C:\data`, `D:\projects`, etc.
+- Virtual paths always use forward slashes: `/foo/bar.txt`
+- UNC paths are supported: `\\server\share`
+
+### Unix/Linux/macOS
+- VFS root is a standard Unix path: `/opt/data`, `/home/user/sandbox`, etc.
+- Virtual paths use forward slashes: `/foo/bar.txt`
+
+## Advanced Usage
+
+### AbortSignal Support
+
+Many fs methods support `AbortSignal` for cancellation:
+
+```typescript
+const controller = new AbortController();
+const fs = vfs.createNodeFSModule();
+
+// Cancel operation after 1 second
+setTimeout(() => controller.abort(), 1000);
+
+try {
+  const data = await fs.promises.readFile('/large-file.txt', {
+    signal: controller.signal
+  });
+} catch (err) {
+  if (err.name === 'AbortError') {
+    console.log('Operation cancelled');
+  }
+}
+```
+
+### File Descriptor Tracking
+
+The VFS tracks all open file descriptors:
+
+```typescript
+const fs = vfs.createNodeFSModule();
+
+const fd = fs.openSync('/file.txt', 'r');
+const buffer = Buffer.alloc(100);
+
+// Read using the file descriptor
+fs.readSync(fd, buffer, 0, 100, 0);
+
+// VFS tracks the FD and ensures it's valid
+fs.closeSync(fd);
+
+// After close, the FD is invalid
+fs.readSync(fd, buffer, 0, 100, 0); // Throws EBADF
+```
+
+### Stream Path Override
+
+Streams have their `path` property overridden to return virtual paths:
+
+```typescript
+const fs = vfs.createNodeFSModule();
+const stream = fs.createReadStream('/data.txt');
+
+console.log(stream.path); // '/data.txt' (virtual path)
+// Real path is hidden
+```
+
+### Working with Newer Node.js APIs
+
+The VFS supports newer Node.js APIs (when available):
+
+```typescript
+const fs = vfs.createNodeFSModule();
+
+// glob (Node.js 22+)
+if (fs.promises.glob) {
+  for await (const file of fs.promises.glob('**/*.txt')) {
+    console.log(file); // Virtual paths
+  }
+}
+
+// statfs (Node.js 19+)
+if (fs.promises.statfs) {
+  const stats = await fs.promises.statfs('/');
+  console.log(stats);
+}
+
+// openAsBlob (Node.js 19+)
+if (fs.openAsBlob) {
+  const blob = await fs.openAsBlob('/file.txt');
+}
+```
+
+## TypeScript Support
+
+Full TypeScript support with type definitions:
+
+```typescript
+import { VirtualFileSystem, VFSOptions } from 'sandbox-fs';
+
+const options: VFSOptions = { root: '/opt/data' };
+const vfs: VirtualFileSystem = new VirtualFileSystem(options);
+
+const fs = vfs.createNodeFSModule();
+const path = vfs.createNodePathModule();
+
+// Full type inference for fs and path modules
+const content: string = fs.readFileSync('/file.txt', 'utf8');
+const resolved: string = path.resolve('foo', 'bar');
+```
+
+## Limitations
+
+1. **Read-only**: Write operations are not supported and will throw `EACCES`
+2. **Symlinks**: Symlink operations and reading symlink targets throw `EACCES`
+3. **Virtual CWD**: The path module always uses `/` as the current working directory
+4. **Performance**: Path conversion adds minimal overhead to each operation
+5. **Node.js version**: Newer APIs (glob, statfs) require recent Node.js versions
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues or pull requests.

package/dist/FSModule.d.ts

@@ -0,0 +1,153 @@
+import * as fs from 'fs';
+import type { PathMapper } from './PathMapper';
+import type { ResourceTracker } from './ResourceTracker';
+/**
+ * Create a Node.js fs-compatible module
+ */
+export declare function createFSModule(pathMapper: PathMapper, resourceTracker: ResourceTracker): {
+    promises: {
+        readFile: (virtualPath: string, options?: any) => Promise<Buffer | string>;
+        readdir: (virtualPath: string, options?: any) => Promise<string[] | Buffer[] | fs.Dirent[]>;
+        stat: (virtualPath: string, options?: any) => Promise<fs.Stats>;
+        lstat: (virtualPath: string, options?: any) => Promise<fs.Stats>;
+        access: (virtualPath: string, mode?: number) => Promise<void>;
+        realpath: (virtualPath: string, options?: any) => Promise<string | Buffer>;
+        open: (virtualPath: string, flags?: string | number, mode?: number) => Promise<number>;
+        read: (fd: number, buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null) => Promise<{
+            bytesRead: number;
+            buffer: NodeJS.ArrayBufferView;
+        }>;
+        close: (fd: number) => Promise<void>;
+        fstat: (fd: number, options?: any) => Promise<fs.Stats>;
+        opendir: (virtualPath: string, options?: any) => Promise<import("./wrappers/VirtualDir").VirtualDir>;
+        exists: (virtualPath: string) => Promise<boolean>;
+        writeFile: (path: string, data: any, options?: any) => Promise<void>;
+        appendFile: (path: string, data: any, options?: any) => Promise<void>;
+        mkdir: (path: string, options?: any) => Promise<void | string>;
+        rmdir: (path: string, options?: any) => Promise<void>;
+        rm: (path: string, options?: any) => Promise<void>;
+        unlink: (path: string) => Promise<void>;
+        rename: (oldPath: string, newPath: string) => Promise<void>;
+        copyFile: (src: string, dest: string, mode?: number) => Promise<void>;
+        truncate: (path: string, len?: number) => Promise<void>;
+        ftruncate: (fd: number, len?: number) => Promise<void>;
+        chmod: (path: string, mode: string | number) => Promise<void>;
+        fchmod: (fd: number, mode: string | number) => Promise<void>;
+        lchmod: (path: string, mode: string | number) => Promise<void>;
+        chown: (path: string, uid: number, gid: number) => Promise<void>;
+        fchown: (fd: number, uid: number, gid: number) => Promise<void>;
+        lchown: (path: string, uid: number, gid: number) => Promise<void>;
+        utimes: (path: string, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
+        futimes: (fd: number, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
+        lutimes: (path: string, atime: string | number | Date, mtime: string | number | Date) => Promise<void>;
+        write: (fd: number, buffer: any, offset?: any, length?: any, position?: any) => Promise<any>;
+        writev: (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => Promise<any>;
+        fsync: (fd: number) => Promise<void>;
+        fdatasync: (fd: number) => Promise<void>;
+        symlink: (target: string, path: string, type?: string) => Promise<void>;
+        link: (existingPath: string, newPath: string) => Promise<void>;
+        readlink: (path: string, options?: any) => Promise<string | Buffer>;
+        glob: (pattern: string, options?: any) => AsyncIterableIterator<string>;
+        statfs: (virtualPath: string, options?: any) => Promise<fs.StatsFsBase<any>>;
+        cp: (source: string, destination: string, options?: any) => Promise<void>;
+        openAsBlob: (virtualPath: string, options?: any) => Promise<Blob>;
+        readv: (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => Promise<number>;
+    };
+    constants: typeof fs.constants;
+    Stats: typeof fs.Stats;
+    Dirent: typeof fs.Dirent;
+    ReadStream: typeof fs.ReadStream;
+    WriteStream: typeof fs.WriteStream;
+    watch: (virtualPath: string, options?: any) => fs.FSWatcher;
+    watchFile: (virtualPath: string, options: any, listener?: any) => void;
+    unwatchFile: (virtualPath: string, listener?: any) => void;
+    createReadStream: (virtualPath: string, options?: any) => fs.ReadStream;
+    createWriteStream: (path: string, options?: any) => never;
+    readFileSync: (path: string, options?: any) => NonSharedBuffer;
+    readdirSync: (path: string, options?: any) => string[];
+    statSync: (path: string, options?: any) => fs.Stats;
+    lstatSync: (path: string, options?: any) => fs.Stats;
+    accessSync: (path: string, mode?: number) => void;
+    realpathSync: (path: string, options?: any) => string;
+    openSync: (path: string, flags?: string | number, mode?: number) => number;
+    readSync: (fd: number, buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null) => number;
+    closeSync: (fd: number) => void;
+    fstatSync: (fd: number, options?: any) => fs.Stats;
+    opendirSync: (path: string, options?: any) => any;
+    existsSync: (path: string) => boolean;
+    writeFileSync: (path: string) => never;
+    appendFileSync: (path: string) => never;
+    mkdirSync: (path: string) => never;
+    rmdirSync: (path: string) => never;
+    rmSync: (path: string) => never;
+    unlinkSync: (path: string) => never;
+    renameSync: (oldPath: string) => never;
+    copyFileSync: (src: string, dest: string) => never;
+    truncateSync: (path: string) => never;
+    ftruncateSync: (fd: number) => never;
+    chmodSync: (path: string) => never;
+    fchmodSync: (fd: number) => never;
+    lchmodSync: (path: string) => never;
+    chownSync: (path: string) => never;
+    fchownSync: (fd: number) => never;
+    lchownSync: (path: string) => never;
+    utimesSync: (path: string) => never;
+    futimesSync: (fd: number) => never;
+    lutimesSync: (path: string) => never;
+    writeSync: (fd: number) => never;
+    writevSync: (fd: number) => never;
+    fsyncSync: (fd: number) => never;
+    fdatasyncSync: (fd: number) => never;
+    symlinkSync: (target: string, path: string) => never;
+    linkSync: (existingPath: string, newPath: string) => never;
+    readlinkSync: (path: string) => never;
+    cpSync: (source: string, destination: string) => never;
+    statfsSync: (path: string, options?: any) => fs.StatsFs;
+    readvSync: (fd: number, buffers: NodeJS.ArrayBufferView[], position?: number) => any;
+    readFile: (virtualPath: string, options: any, args_2: (err: Error | null, result?: string | Buffer<ArrayBufferLike> | undefined) => void) => void;
+    readdir: (virtualPath: string, options: any, args_2: (err: Error | null, result?: string[] | Buffer<ArrayBufferLike>[] | fs.Dirent<string>[] | undefined) => void) => void;
+    stat: (virtualPath: string, options: any, args_2: (err: Error | null, result?: fs.Stats | undefined) => void) => void;
+    lstat: (virtualPath: string, options: any, args_2: (err: Error | null, result?: fs.Stats | undefined) => void) => void;
+    access: (virtualPath: string, mode: number | undefined, args_2: (err: Error | null) => void) => void;
+    realpath: (virtualPath: string, options: any, args_2: (err: Error | null, result?: string | Buffer<ArrayBufferLike> | undefined) => void) => void;
+    open: (virtualPath: string, flags: string | number | undefined, mode: number | undefined, args_3: (err: Error | null, result?: number | undefined) => void) => void;
+    read: (fd: number, buffer: NodeJS.ArrayBufferView<ArrayBufferLike>, offset: number, length: number, position: number | null, args_5: (err: Error | null, result?: {
+        bytesRead: number;
+        buffer: NodeJS.ArrayBufferView;
+    } | undefined) => void) => void;
+    close: (fd: number, args_1: (err: Error | null) => void) => void;
+    fstat: (fd: number, options: any, args_2: (err: Error | null, result?: fs.Stats | undefined) => void) => void;
+    opendir: (virtualPath: string, options: any, args_2: (err: Error | null, result?: import("./wrappers/VirtualDir").VirtualDir | undefined) => void) => void;
+    exists: (path: string, callback: (exists: boolean) => void) => void;
+    writeFile: (path: string, data: any, options: any, args_3: (err: Error | null) => void) => void;
+    appendFile: (path: string, data: any, options: any, args_3: (err: Error | null) => void) => void;
+    mkdir: (path: string, options: any, args_2: (err: Error | null, result?: string | void | undefined) => void) => void;
+    rmdir: (path: string, options: any, args_2: (err: Error | null) => void) => void;
+    rm: (path: string, options: any, args_2: (err: Error | null) => void) => void;
+    unlink: (path: string, args_1: (err: Error | null) => void) => void;
+    rename: (oldPath: string, newPath: string, args_2: (err: Error | null) => void) => void;
+    copyFile: (src: string, dest: string, mode: number | undefined, args_3: (err: Error | null) => void) => void;
+    truncate: (path: string, len: number | undefined, args_2: (err: Error | null) => void) => void;
+    ftruncate: (fd: number, len: number | undefined, args_2: (err: Error | null) => void) => void;
+    chmod: (path: string, mode: string | number, args_2: (err: Error | null) => void) => void;
+    fchmod: (fd: number, mode: string | number, args_2: (err: Error | null) => void) => void;
+    lchmod: (path: string, mode: string | number, args_2: (err: Error | null) => void) => void;
+    chown: (path: string, uid: number, gid: number, args_3: (err: Error | null) => void) => void;
+    fchown: (fd: number, uid: number, gid: number, args_3: (err: Error | null) => void) => void;
+    lchown: (path: string, uid: number, gid: number, args_3: (err: Error | null) => void) => void;
+    utimes: (path: string, atime: string | number | Date, mtime: string | number | Date, args_3: (err: Error | null) => void) => void;
+    futimes: (fd: number, atime: string | number | Date, mtime: string | number | Date, args_3: (err: Error | null) => void) => void;
+    lutimes: (path: string, atime: string | number | Date, mtime: string | number | Date, args_3: (err: Error | null) => void) => void;
+    write: (fd: number, buffer: any, offset: any, length: any, position: any, args_5: (err: Error | null, result?: any) => void) => void;
+    writev: (fd: number, buffers: NodeJS.ArrayBufferView<ArrayBufferLike>[], position: number | undefined, args_3: (err: Error | null, result?: any) => void) => void;
+    fsync: (fd: number, args_1: (err: Error | null) => void) => void;
+    fdatasync: (fd: number, args_1: (err: Error | null) => void) => void;
+    symlink: (target: string, path: string, type: string | undefined, args_3: (err: Error | null) => void) => void;
+    link: (existingPath: string, newPath: string, args_2: (err: Error | null) => void) => void;
+    readlink: (path: string, options: any, args_2: (err: Error | null, result?: string | Buffer<ArrayBufferLike> | undefined) => void) => void;
+    statfs: (virtualPath: string, options: any, args_2: (err: Error | null, result?: fs.StatsFsBase<any> | undefined) => void) => void;
+    cp: (source: string, destination: string, options: any, args_3: (err: Error | null) => void) => void;
+    openAsBlob: (virtualPath: string, options: any, args_2: (err: Error | null, result?: Blob | undefined) => void) => void;
+    readv: (fd: number, buffers: NodeJS.ArrayBufferView<ArrayBufferLike>[], position: number | undefined, args_3: (err: Error | null, result?: number | undefined) => void) => void;
+};
+//# sourceMappingURL=FSModule.d.ts.map

package/dist/FSModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FSModule.d.ts","sourceRoot":"","sources":["../src/FSModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AASzD;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAgH9D,MAAM,YAAY,GAAG;wBAUtB,MAAM,YAAY,GAAG;qBAUxB,MAAM,YAAY,GAAG;sBAmBpB,MAAM,YAAY,GAAG;uBAmBpB,MAAM,SAAS,MAAM;yBAUnB,MAAM,YAAY,GAAG;qBAYzB,MAAM,UAAU,MAAM,GAAG,MAAM,SAAS,MAAM;mBA8BhD,MAAM,UAAU,MAAM,CAAC,eAAe,UAAU,MAAM,UAAU,MAAM,YAAY,MAAM,GAAG,IAAI;oBAY9F,MAAM;oBAMN,MAAM,YAAY,GAAG;wBAYjB,MAAM,YAAY,GAAG;uBAWtB,MAAM;0BAWH,MAAM;2BAOL,MAAM;sBAOX,MAAM;sBAON,MAAM;mBAOT,MAAM;uBAOF,MAAM;0BAOH,MAAM;wBAOR,MAAM,QAAQ,MAAM;yBAOnB,MAAM;wBAOP,MAAM;sBAMR,MAAM;qBAOP,MAAM;uBAMJ,MAAM;sBAOP,MAAM;qBAOP,MAAM;uBAMJ,MAAM;uBAON,MAAM;sBAOP,MAAM;wBAMJ,MAAM;oBAOV,MAAM;qBAML,MAAM;oBAMP,MAAM;wBAMF,MAAM;0BAQJ,MAAM,QAAQ,MAAM;6BAOjB,MAAM,WAAW,MAAM;yBAO3B,MAAM;qBASV,MAAM,eAAe,MAAM;uBAQzB,MAAM,YAAY,GAAG;oBAaxB,MAAM,WAAW,MAAM,CAAC,eAAe,EAAE,aAAa,MAAM;;;;;;;;;;;;;;;mBApZ7D,MAAM,YAAY,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8c7D"}