memfs 4.0.0 → 4.1.0

package/lib/fsa-to-node/__tests__/util.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/fsa-to-node/__tests__/util.test.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util");
+describe('pathToLocation()', () => {
+    test('handles an empty string', () => {
+        expect((0, util_1.pathToLocation)('')).toStrictEqual([[], '']);
+    });
+    test('handles a single slash', () => {
+        expect((0, util_1.pathToLocation)('/')).toStrictEqual([[], '']);
+    });
+    test('no path, just filename', () => {
+        expect((0, util_1.pathToLocation)('scary.exe')).toStrictEqual([[], 'scary.exe']);
+    });
+    test('multiple steps in the path', () => {
+        expect((0, util_1.pathToLocation)('/gg/wp/hf/gl.txt')).toStrictEqual([['gg', 'wp', 'hf'], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('gg/wp/hf/gl.txt')).toStrictEqual([['gg', 'wp', 'hf'], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('/wp/hf/gl.txt')).toStrictEqual([['wp', 'hf'], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('wp/hf/gl.txt')).toStrictEqual([['wp', 'hf'], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('/hf/gl.txt')).toStrictEqual([['hf'], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('hf/gl.txt')).toStrictEqual([['hf'], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('/gl.txt')).toStrictEqual([[], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('gl.txt')).toStrictEqual([[], 'gl.txt']);
+    });
+    test('handles double slashes', () => {
+        expect((0, util_1.pathToLocation)('/gg/wp//hf/gl.txt')).toStrictEqual([['gg', 'wp', '', 'hf'], 'gl.txt']);
+        expect((0, util_1.pathToLocation)('//gl.txt')).toStrictEqual([[''], 'gl.txt']);
+    });
+});

package/lib/fsa-to-node/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const enum FsaToNodeConstants {
+    Separator = "/"
+}

package/lib/fsa-to-node/constants.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/fsa-to-node/index.d.ts

@@ -0,0 +1,2 @@
+export { FsaNodeFs } from './FsaNodeFs';
+export { FsaNodeSyncAdapterWorker } from './worker/FsaNodeSyncAdapterWorker';

package/lib/fsa-to-node/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeSyncAdapterWorker = exports.FsaNodeFs = void 0;
+var FsaNodeFs_1 = require("./FsaNodeFs");
+Object.defineProperty(exports, "FsaNodeFs", { enumerable: true, get: function () { return FsaNodeFs_1.FsaNodeFs; } });
+var FsaNodeSyncAdapterWorker_1 = require("./worker/FsaNodeSyncAdapterWorker");
+Object.defineProperty(exports, "FsaNodeSyncAdapterWorker", { enumerable: true, get: function () { return FsaNodeSyncAdapterWorker_1.FsaNodeSyncAdapterWorker; } });

package/lib/fsa-to-node/json.d.ts

@@ -0,0 +1,4 @@
+import { CborEncoder } from 'json-joy/es6/json-pack/cbor/CborEncoder';
+import { CborDecoder } from 'json-joy/es6/json-pack/cbor/CborDecoder';
+export declare const encoder: CborEncoder;
+export declare const decoder: CborDecoder;

package/lib/fsa-to-node/json.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoder = exports.encoder = void 0;
+const CborEncoder_1 = require("json-joy/es6/json-pack/cbor/CborEncoder");
+const CborDecoder_1 = require("json-joy/es6/json-pack/cbor/CborDecoder");
+exports.encoder = new CborEncoder_1.CborEncoder();
+exports.decoder = new CborDecoder_1.CborDecoder();

package/lib/fsa-to-node/types.d.ts

@@ -0,0 +1,37 @@
+import type { IFileSystemFileHandle } from '../fsa/types';
+import type * as opts from '../node/types/options';
+import type * as misc from '../node/types/misc';
+export type FsLocation = [folder: string[], file: string];
+/**
+ * Adapter which implements synchronous calls to the FSA API.
+ */
+export interface FsaNodeSyncAdapterApi {
+    stat(location: FsLocation): FsaNodeSyncAdapterStats;
+    access(req: [filename: string, mode: number]): void;
+    readFile(req: [filename: string, opts?: opts.IReadFileOptions]): Uint8Array;
+    writeFile(req: [filename: string, data: Uint8Array, opts?: opts.IWriteFileOptions]): void;
+    appendFile(req: [filename: string, data: Uint8Array, opts?: opts.IAppendFileOptions]): void;
+    copy(req: [src: string, dst: string, flags?: number]): void;
+    move(req: [src: string, dst: string]): void;
+    rmdir(req: [filename: string, opts?: opts.IRmdirOptions]): void;
+    rm(req: [filename: string, opts?: opts.IRmOptions]): void;
+    mkdir(req: [filename: string, opts?: misc.TMode | opts.IMkdirOptions]): string | undefined;
+    mkdtemp(req: [filename: string, opts?: misc.TMode | opts.IOptions]): string;
+    trunc(req: [filename: string, len: number]): void;
+    unlink(req: [filename: string]): void;
+    readdir(req: [filename: string]): FsaNodeSyncAdapterEntry[];
+    read(req: [filename: string, position: number, length: number]): Uint8Array;
+    write(req: [filename: string, data: Uint8Array, position: number | null]): number;
+    open(req: [filename: string, flags: number, mode: number]): IFileSystemFileHandle;
+}
+export interface FsaNodeSyncAdapter {
+    call<K extends keyof FsaNodeSyncAdapterApi>(method: K, payload: Parameters<FsaNodeSyncAdapterApi[K]>[0]): ReturnType<FsaNodeSyncAdapterApi[K]>;
+}
+export interface FsaNodeSyncAdapterStats {
+    kind: 'file' | 'directory';
+    size?: number;
+}
+export interface FsaNodeSyncAdapterEntry {
+    kind: 'file' | 'directory';
+    name: string;
+}

package/lib/fsa-to-node/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/fsa-to-node/util.d.ts

@@ -0,0 +1,4 @@
+import { IFileSystemDirectoryHandle } from '../fsa/types';
+import type { FsLocation } from './types';
+export declare const pathToLocation: (path: string) => FsLocation;
+export declare const testDirectoryIsWritable: (dir: IFileSystemDirectoryHandle) => Promise<boolean>;

package/lib/fsa-to-node/util.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testDirectoryIsWritable = exports.pathToLocation = void 0;
+const pathToLocation = (path) => {
+    if (path[0] === "/" /* FsaToNodeConstants.Separator */)
+        path = path.slice(1);
+    const lastSlashIndex = path.lastIndexOf("/" /* FsaToNodeConstants.Separator */);
+    if (lastSlashIndex === -1)
+        return [[], path];
+    const file = path.slice(lastSlashIndex + 1);
+    const folder = path.slice(0, lastSlashIndex).split("/" /* FsaToNodeConstants.Separator */);
+    return [folder, file];
+};
+exports.pathToLocation = pathToLocation;
+const testDirectoryIsWritable = (dir) => __awaiter(void 0, void 0, void 0, function* () {
+    const testFileName = '__memfs_writable_test_file_' + Math.random().toString(36).slice(2) + Date.now();
+    try {
+        yield dir.getFileHandle(testFileName, { create: true });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+    finally {
+        try {
+            yield dir.removeEntry(testFileName);
+        }
+        catch (e) { }
+    }
+});
+exports.testDirectoryIsWritable = testDirectoryIsWritable;

package/lib/fsa-to-node/worker/FsaNodeSyncAdapterWorker.d.ts

@@ -0,0 +1,10 @@
+import { SyncMessenger } from './SyncMessenger';
+import type * as fsa from '../../fsa/types';
+import type { FsaNodeSyncAdapter, FsaNodeSyncAdapterApi } from '../types';
+export declare class FsaNodeSyncAdapterWorker implements FsaNodeSyncAdapter {
+    protected readonly messenger: SyncMessenger;
+    protected readonly root: fsa.IFileSystemDirectoryHandle;
+    static start(url: string, dir: fsa.IFileSystemDirectoryHandle | Promise<fsa.IFileSystemDirectoryHandle>): Promise<FsaNodeSyncAdapterWorker>;
+    constructor(messenger: SyncMessenger, root: fsa.IFileSystemDirectoryHandle);
+    call<K extends keyof FsaNodeSyncAdapterApi>(method: K, payload: Parameters<FsaNodeSyncAdapterApi[K]>[0]): ReturnType<FsaNodeSyncAdapterApi[K]>;
+}

package/lib/fsa-to-node/worker/FsaNodeSyncAdapterWorker.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeSyncAdapterWorker = void 0;
+const Defer_1 = require("thingies/es6/Defer");
+const SyncMessenger_1 = require("./SyncMessenger");
+const json_1 = require("../json");
+let rootId = 0;
+class FsaNodeSyncAdapterWorker {
+    static start(url, dir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const worker = new Worker(url);
+            const future = new Defer_1.Defer();
+            let id = rootId++;
+            let messenger = undefined;
+            const _dir = yield dir;
+            worker.onmessage = e => {
+                const data = e.data;
+                if (!Array.isArray(data))
+                    return;
+                const msg = data;
+                const code = msg[0];
+                switch (code) {
+                    case 0 /* FsaNodeWorkerMessageCode.Init */: {
+                        const [, sab] = msg;
+                        messenger = new SyncMessenger_1.SyncMessenger(sab);
+                        const setRootMessage = [1 /* FsaNodeWorkerMessageCode.SetRoot */, id, _dir];
+                        worker.postMessage(setRootMessage);
+                        break;
+                    }
+                    case 2 /* FsaNodeWorkerMessageCode.RootSet */: {
+                        const [, rootId] = msg;
+                        if (id !== rootId)
+                            return;
+                        const adapter = new FsaNodeSyncAdapterWorker(messenger, _dir);
+                        future.resolve(adapter);
+                        break;
+                    }
+                }
+            };
+            return yield future.promise;
+        });
+    }
+    constructor(messenger, root) {
+        this.messenger = messenger;
+        this.root = root;
+    }
+    call(method, payload) {
+        const request = [3 /* FsaNodeWorkerMessageCode.Request */, method, payload];
+        const encoded = json_1.encoder.encode(request);
+        const encodedResponse = this.messenger.callSync(encoded);
+        const [code, data] = json_1.decoder.decode(encodedResponse);
+        switch (code) {
+            case 4 /* FsaNodeWorkerMessageCode.Response */:
+                return data;
+            case 5 /* FsaNodeWorkerMessageCode.ResponseError */:
+                throw data;
+            default: {
+                throw new Error('Invalid response message code');
+            }
+        }
+    }
+}
+exports.FsaNodeSyncAdapterWorker = FsaNodeSyncAdapterWorker;

package/lib/fsa-to-node/worker/FsaNodeSyncWorker.d.ts

@@ -0,0 +1,20 @@
+import { AsyncCallback, SyncMessenger } from './SyncMessenger';
+import { FsaNodeFs } from '../FsaNodeFs';
+import type * as fsa from '../../fsa/types';
+import type { FsaNodeWorkerMsg } from './types';
+import type { FsaNodeSyncAdapterApi } from '../types';
+export declare class FsaNodeSyncWorker {
+    protected readonly sab: SharedArrayBuffer;
+    protected readonly messenger: SyncMessenger;
+    protected root: fsa.IFileSystemDirectoryHandle;
+    protected fs: FsaNodeFs;
+    start(): void;
+    protected onPostMessage: (msg: FsaNodeWorkerMsg) => void;
+    protected readonly onRequest: AsyncCallback;
+    protected getDir(path: string[], create: boolean, funcName?: string): Promise<fsa.IFileSystemDirectoryHandle>;
+    protected getFile(path: string[], name: string, funcName?: string, create?: boolean): Promise<fsa.IFileSystemFileHandle>;
+    protected getFileOrDir(path: string[], name: string, funcName?: string, create?: boolean): Promise<fsa.IFileSystemFileHandle | fsa.IFileSystemDirectoryHandle>;
+    protected handlers: {
+        [K in keyof FsaNodeSyncAdapterApi]: (request: Parameters<FsaNodeSyncAdapterApi[K]>[0]) => Promise<ReturnType<FsaNodeSyncAdapterApi[K]>>;
+    };
+}

package/lib/fsa-to-node/worker/FsaNodeSyncWorker.js

@@ -0,0 +1,190 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsaNodeSyncWorker = void 0;
+const SyncMessenger_1 = require("./SyncMessenger");
+const FsaNodeFs_1 = require("../FsaNodeFs");
+const json_1 = require("../json");
+class FsaNodeSyncWorker {
+    constructor() {
+        this.sab = new SharedArrayBuffer(1024 * 1024);
+        this.messenger = new SyncMessenger_1.SyncMessenger(this.sab);
+        this.onPostMessage = (msg) => {
+            switch (msg[0]) {
+                case 1 /* FsaNodeWorkerMessageCode.SetRoot */: {
+                    const [, id, dir] = msg;
+                    this.root = dir;
+                    this.fs = new FsaNodeFs_1.FsaNodeFs(this.root);
+                    const response = [2 /* FsaNodeWorkerMessageCode.RootSet */, id];
+                    postMessage(response);
+                    this.messenger.serveAsync(this.onRequest);
+                    break;
+                }
+            }
+        };
+        this.onRequest = (request) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const message = json_1.decoder.decode(request);
+                if (!Array.isArray(message))
+                    throw new Error('Invalid message format');
+                const code = message[0];
+                if (code !== 3 /* FsaNodeWorkerMessageCode.Request */)
+                    throw new Error('Invalid message code');
+                const [, method, payload] = message;
+                const handler = this.handlers[method];
+                if (!handler)
+                    throw new Error(`Unknown method ${method}`);
+                const response = yield handler(payload);
+                return json_1.encoder.encode([4 /* FsaNodeWorkerMessageCode.Response */, response]);
+            }
+            catch (err) {
+                const message = err && typeof err === 'object' && err.message ? err.message : 'Unknown error';
+                const error = { message };
+                if (err && typeof err === 'object' && (err.code || err.name))
+                    error.code = err.code || err.name;
+                return json_1.encoder.encode([5 /* FsaNodeWorkerMessageCode.ResponseError */, error]);
+            }
+        });
+        this.handlers = {
+            stat: (location) => __awaiter(this, void 0, void 0, function* () {
+                const handle = yield this.getFileOrDir(location[0], location[1], 'statSync');
+                return {
+                    kind: handle.kind,
+                };
+            }),
+            access: ([filename, mode]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.access(filename, mode);
+            }),
+            readFile: ([filename, opts]) => __awaiter(this, void 0, void 0, function* () {
+                const buf = (yield this.fs.promises.readFile(filename, Object.assign(Object.assign({}, opts), { encoding: 'buffer' })));
+                const uint8 = new Uint8Array(buf, buf.byteOffset, buf.byteLength);
+                return uint8;
+            }),
+            writeFile: ([filename, data, opts]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.writeFile(filename, data, Object.assign(Object.assign({}, opts), { encoding: 'buffer' }));
+            }),
+            appendFile: ([filename, data, opts]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.appendFile(filename, data, Object.assign(Object.assign({}, opts), { encoding: 'buffer' }));
+            }),
+            copy: ([src, dst, flags]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.copyFile(src, dst, flags);
+            }),
+            move: ([src, dst]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.rename(src, dst);
+            }),
+            rmdir: ([filename, options]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.rmdir(filename, options);
+            }),
+            rm: ([filename, options]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.rm(filename, options);
+            }),
+            mkdir: ([filename, options]) => __awaiter(this, void 0, void 0, function* () {
+                return yield this.fs.promises.mkdir(filename, options);
+            }),
+            mkdtemp: ([filename]) => __awaiter(this, void 0, void 0, function* () {
+                return (yield this.fs.promises.mkdtemp(filename, { encoding: 'utf8' }));
+            }),
+            trunc: ([filename, len]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.truncate(filename, len);
+            }),
+            unlink: ([filename]) => __awaiter(this, void 0, void 0, function* () {
+                yield this.fs.promises.unlink(filename);
+            }),
+            readdir: ([filename]) => __awaiter(this, void 0, void 0, function* () {
+                const list = (yield this.fs.promises.readdir(filename, { withFileTypes: true, encoding: 'utf8' }));
+                const res = list.map(entry => ({
+                    kind: entry.isDirectory() ? 'directory' : 'file',
+                    name: entry.name,
+                }));
+                return res;
+            }),
+            read: ([filename, position, length]) => __awaiter(this, void 0, void 0, function* () {
+                let uint8 = new Uint8Array(length);
+                const handle = yield this.fs.promises.open(filename, 'r');
+                const bytesRead = yield new Promise((resolve, reject) => {
+                    this.fs.read(handle.fd, uint8, 0, length, position, (err, bytesRead) => {
+                        if (err)
+                            return reject(err);
+                        resolve(bytesRead || length);
+                    });
+                });
+                if (bytesRead < length)
+                    uint8 = uint8.slice(0, bytesRead);
+                return uint8;
+            }),
+            write: ([filename, data, position]) => __awaiter(this, void 0, void 0, function* () {
+                const handle = yield this.fs.promises.open(filename, 'a');
+                const { bytesWritten } = yield handle.write(data, 0, data.length, position || undefined);
+                return bytesWritten;
+            }),
+            open: ([filename, flags, mode]) => __awaiter(this, void 0, void 0, function* () {
+                const handle = yield this.fs.promises.open(filename, flags, mode);
+                const file = yield this.fs.__getFileById(handle.fd);
+                yield handle.close();
+                return file;
+            }),
+        };
+    }
+    start() {
+        onmessage = e => {
+            if (!Array.isArray(e.data))
+                return;
+            this.onPostMessage(e.data);
+        };
+        const initMsg = [0 /* FsaNodeWorkerMessageCode.Init */, this.sab];
+        postMessage(initMsg);
+    }
+    getDir(path, create, funcName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let curr = this.root;
+            const options = { create };
+            try {
+                for (const name of path) {
+                    curr = yield curr.getDirectoryHandle(name, options);
+                }
+            }
+            catch (error) {
+                // if (error && typeof error === 'object' && error.name === 'TypeMismatchError')
+                //   throw createError('ENOTDIR', funcName, path.join(FsaToNodeConstants.Separator));
+                throw error;
+            }
+            return curr;
+        });
+    }
+    getFile(path, name, funcName, create) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dir = yield this.getDir(path, false, funcName);
+            const file = yield dir.getFileHandle(name, { create });
+            return file;
+        });
+    }
+    getFileOrDir(path, name, funcName, create) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dir = yield this.getDir(path, false, funcName);
+            try {
+                const file = yield dir.getFileHandle(name);
+                return file;
+            }
+            catch (error) {
+                if (error && typeof error === 'object') {
+                    switch (error.name) {
+                        case 'TypeMismatchError':
+                            return yield dir.getDirectoryHandle(name);
+                        // case 'NotFoundError':
+                        //   throw createError('ENOENT', funcName, path.join(FsaToNodeConstants.Separator));
+                    }
+                }
+                throw error;
+            }
+        });
+    }
+}
+exports.FsaNodeSyncWorker = FsaNodeSyncWorker;

package/lib/fsa-to-node/worker/SyncMessenger.d.ts

@@ -0,0 +1,24 @@
+export type AsyncCallback = (request: Uint8Array) => Promise<Uint8Array>;
+/**
+ * `SyncMessenger` allows to execute asynchronous code synchronously. The
+ * asynchronous code is executed in a Worker thread, while the main thread is
+ * blocked until the asynchronous code is finished.
+ *
+ * First four 4-byte words is the header, where the first word is used for Atomics
+ * notifications. The second word is used for spin-locking the main thread until
+ * the asynchronous code is finished. The third word is used to specify payload
+ * length. The fourth word is currently unused.
+ *
+ * The maximum payload size is the size of the SharedArrayBuffer minus the
+ * header size.
+ */
+export declare class SyncMessenger {
+    protected readonly sab: SharedArrayBuffer;
+    protected readonly int32: Int32Array;
+    protected readonly uint8: Uint8Array;
+    protected readonly headerSize: any;
+    protected readonly dataSize: any;
+    constructor(sab: SharedArrayBuffer);
+    callSync(data: Uint8Array): Uint8Array;
+    serveAsync(callback: AsyncCallback): void;
+}

package/lib/fsa-to-node/worker/SyncMessenger.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncMessenger = void 0;
+/**
+ * @param condition Condition to wait for, when true, the function returns.
+ * @param ms Maximum time to wait in milliseconds.
+ */
+const sleepUntil = (condition, ms = 100) => {
+    const start = Date.now();
+    while (!condition()) {
+        const now = Date.now();
+        if (now - start > ms)
+            throw new Error('Timeout');
+    }
+};
+/**
+ * `SyncMessenger` allows to execute asynchronous code synchronously. The
+ * asynchronous code is executed in a Worker thread, while the main thread is
+ * blocked until the asynchronous code is finished.
+ *
+ * First four 4-byte words is the header, where the first word is used for Atomics
+ * notifications. The second word is used for spin-locking the main thread until
+ * the asynchronous code is finished. The third word is used to specify payload
+ * length. The fourth word is currently unused.
+ *
+ * The maximum payload size is the size of the SharedArrayBuffer minus the
+ * header size.
+ */
+class SyncMessenger {
+    constructor(sab) {
+        this.sab = sab;
+        this.int32 = new Int32Array(sab);
+        this.uint8 = new Uint8Array(sab);
+        this.headerSize = 4 * 4;
+        this.dataSize = sab.byteLength - this.headerSize;
+    }
+    callSync(data) {
+        const requestLength = data.length;
+        const headerSize = this.headerSize;
+        const int32 = this.int32;
+        int32[1] = 0;
+        int32[2] = requestLength;
+        this.uint8.set(data, headerSize);
+        Atomics.notify(int32, 0);
+        sleepUntil(() => int32[1] === 1);
+        const responseLength = int32[2];
+        const response = this.uint8.slice(headerSize, headerSize + responseLength);
+        return response;
+    }
+    serveAsync(callback) {
+        const headerSize = this.headerSize;
+        (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const int32 = this.int32;
+                const res = Atomics.wait(int32, 0, 0);
+                if (res !== 'ok')
+                    throw new Error(`Unexpected Atomics.wait result: ${res}`);
+                const requestLength = this.int32[2];
+                const request = this.uint8.slice(headerSize, headerSize + requestLength);
+                const response = yield callback(request);
+                const responseLength = response.length;
+                int32[2] = responseLength;
+                this.uint8.set(response, headerSize);
+                int32[1] = 1;
+            }
+            catch (_a) { }
+            this.serveAsync(callback);
+        }))().catch(() => { });
+    }
+}
+exports.SyncMessenger = SyncMessenger;

package/lib/fsa-to-node/worker/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const enum FsaNodeWorkerMessageCode {
+    Init = 0,
+    SetRoot = 1,
+    RootSet = 2,
+    Request = 3,
+    Response = 4,
+    ResponseError = 5
+}

package/lib/fsa-to-node/worker/constants.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/fsa-to-node/worker/types.d.ts

@@ -0,0 +1,17 @@
+import type { IFileSystemDirectoryHandle } from '../../fsa/types';
+import type { FsaNodeWorkerMessageCode } from './constants';
+export type FsaNodeWorkerMsgInit = [type: FsaNodeWorkerMessageCode.Init, sab: SharedArrayBuffer];
+export type FsaNodeWorkerMsgSetRoot = [
+    type: FsaNodeWorkerMessageCode.SetRoot,
+    id: number,
+    dir: IFileSystemDirectoryHandle
+];
+export type FsaNodeWorkerMsgRootSet = [type: FsaNodeWorkerMessageCode.RootSet, id: number];
+export type FsaNodeWorkerMsgRequest = [type: FsaNodeWorkerMessageCode.Request, method: string, data: unknown];
+export type FsaNodeWorkerMsgResponse = [type: FsaNodeWorkerMessageCode.Response, data: unknown];
+export type FsaNodeWorkerMsgResponseError = [type: FsaNodeWorkerMessageCode.ResponseError, data: unknown];
+export interface FsaNodeWorkerError {
+    message: string;
+    code?: string;
+}
+export type FsaNodeWorkerMsg = FsaNodeWorkerMsgInit | FsaNodeWorkerMsgSetRoot | FsaNodeWorkerMsgRootSet | FsaNodeWorkerMsgRequest | FsaNodeWorkerMsgResponse | FsaNodeWorkerMsgResponseError;

package/lib/fsa-to-node/worker/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -1,9 +1,10 @@
 import Stats from './Stats';
 import Dirent from './Dirent';
-import { Volume as _Volume, StatWatcher, FSWatcher, IReadStream, IWriteStream, DirectoryJSON } from './volume';
+import { Volume as _Volume, StatWatcher, FSWatcher, IWriteStream, DirectoryJSON, NestedDirectoryJSON } from './volume';
 import { constants } from './constants';
 import type { FsPromisesApi } from './node/types';
-export { DirectoryJSON };
+import type * as misc from './node/types/misc';
+export { DirectoryJSON, NestedDirectoryJSON };
 export declare const Volume: typeof _Volume;
 export declare const vol: _Volume;
 export interface IFs extends _Volume {
@@ -12,7 +13,7 @@ export interface IFs extends _Volume {
     Dirent: new (...args: any[]) => Dirent;
     StatWatcher: new () => StatWatcher;
     FSWatcher: new () => FSWatcher;
-    ReadStream: new (...args: any[]) => IReadStream;
+    ReadStream: new (...args: any[]) => misc.IReadStream;
     WriteStream: new (...args: any[]) => IWriteStream;
     promises: FsPromisesApi;
     _toUnixTimestamp: any;
@@ -29,7 +30,7 @@ export declare const fs: IFs;
  * @returns A `memfs` file system instance, which is a drop-in replacement for
  *          the `fs` module.
  */
-export declare const memfs: (json?: DirectoryJSON, cwd?: string) => IFs;
+export declare const memfs: (json?: NestedDirectoryJSON, cwd?: string) => IFs;
 export type IFsWithVolume = IFs & {
     __vol: _Volume;
 };

package/lib/index.js

@@ -41,7 +41,7 @@ exports.fs = createFsFromVolume(exports.vol);
  *          the `fs` module.
  */
 const memfs = (json = {}, cwd = '/') => {
-    const volume = exports.Volume.fromJSON(json, cwd);
+    const volume = exports.Volume.fromNestedJSON(json, cwd);
     const fs = createFsFromVolume(volume);
     return fs;
 };