memfs 3.5.3 → 3.6.0

package/lib/node/FileHandle.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandle = void 0;
+const util_1 = require("./util");
+class FileHandle {
+    constructor(fs, fd) {
+        this.fs = fs;
+        this.fd = fd;
+    }
+    appendFile(data, options) {
+        return (0, util_1.promisify)(this.fs, 'appendFile')(this.fd, data, options);
+    }
+    chmod(mode) {
+        return (0, util_1.promisify)(this.fs, 'fchmod')(this.fd, mode);
+    }
+    chown(uid, gid) {
+        return (0, util_1.promisify)(this.fs, 'fchown')(this.fd, uid, gid);
+    }
+    close() {
+        return (0, util_1.promisify)(this.fs, 'close')(this.fd);
+    }
+    datasync() {
+        return (0, util_1.promisify)(this.fs, 'fdatasync')(this.fd);
+    }
+    read(buffer, offset, length, position) {
+        return (0, util_1.promisify)(this.fs, 'read', bytesRead => ({ bytesRead, buffer }))(this.fd, buffer, offset, length, position);
+    }
+    readFile(options) {
+        return (0, util_1.promisify)(this.fs, 'readFile')(this.fd, options);
+    }
+    stat(options) {
+        return (0, util_1.promisify)(this.fs, 'fstat')(this.fd, options);
+    }
+    sync() {
+        return (0, util_1.promisify)(this.fs, 'fsync')(this.fd);
+    }
+    truncate(len) {
+        return (0, util_1.promisify)(this.fs, 'ftruncate')(this.fd, len);
+    }
+    utimes(atime, mtime) {
+        return (0, util_1.promisify)(this.fs, 'futimes')(this.fd, atime, mtime);
+    }
+    write(buffer, offset, length, position) {
+        return (0, util_1.promisify)(this.fs, 'write', bytesWritten => ({ bytesWritten, buffer }))(this.fd, buffer, offset, length, position);
+    }
+    writeFile(data, options) {
+        return (0, util_1.promisify)(this.fs, 'writeFile')(this.fd, data, options);
+    }
+}
+exports.FileHandle = FileHandle;

package/lib/node/promises.d.ts

@@ -0,0 +1,2 @@
+import type { FsCallbackApi, FsPromisesApi } from './types';
+export declare function createPromisesApi(vol: FsCallbackApi): null | FsPromisesApi;

package/lib/node/promises.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromisesApi = void 0;
+const FileHandle_1 = require("./FileHandle");
+const util_1 = require("./util");
+function createPromisesApi(vol) {
+    if (typeof Promise === 'undefined')
+        return null;
+    return {
+        FileHandle: FileHandle_1.FileHandle,
+        access(path, mode) {
+            return (0, util_1.promisify)(vol, 'access')(path, mode);
+        },
+        appendFile(path, data, options) {
+            return (0, util_1.promisify)(vol, 'appendFile')(path instanceof FileHandle_1.FileHandle ? path.fd : path, data, options);
+        },
+        chmod(path, mode) {
+            return (0, util_1.promisify)(vol, 'chmod')(path, mode);
+        },
+        chown(path, uid, gid) {
+            return (0, util_1.promisify)(vol, 'chown')(path, uid, gid);
+        },
+        copyFile(src, dest, flags) {
+            return (0, util_1.promisify)(vol, 'copyFile')(src, dest, flags);
+        },
+        lchmod(path, mode) {
+            return (0, util_1.promisify)(vol, 'lchmod')(path, mode);
+        },
+        lchown(path, uid, gid) {
+            return (0, util_1.promisify)(vol, 'lchown')(path, uid, gid);
+        },
+        link(existingPath, newPath) {
+            return (0, util_1.promisify)(vol, 'link')(existingPath, newPath);
+        },
+        lstat(path, options) {
+            return (0, util_1.promisify)(vol, 'lstat')(path, options);
+        },
+        mkdir(path, options) {
+            return (0, util_1.promisify)(vol, 'mkdir')(path, options);
+        },
+        mkdtemp(prefix, options) {
+            return (0, util_1.promisify)(vol, 'mkdtemp')(prefix, options);
+        },
+        open(path, flags, mode) {
+            return (0, util_1.promisify)(vol, 'open', fd => new FileHandle_1.FileHandle(vol, fd))(path, flags, mode);
+        },
+        readdir(path, options) {
+            return (0, util_1.promisify)(vol, 'readdir')(path, options);
+        },
+        readFile(id, options) {
+            return (0, util_1.promisify)(vol, 'readFile')(id instanceof FileHandle_1.FileHandle ? id.fd : id, options);
+        },
+        readlink(path, options) {
+            return (0, util_1.promisify)(vol, 'readlink')(path, options);
+        },
+        realpath(path, options) {
+            return (0, util_1.promisify)(vol, 'realpath')(path, options);
+        },
+        rename(oldPath, newPath) {
+            return (0, util_1.promisify)(vol, 'rename')(oldPath, newPath);
+        },
+        rmdir(path, options) {
+            return (0, util_1.promisify)(vol, 'rmdir')(path, options);
+        },
+        rm(path, options) {
+            return (0, util_1.promisify)(vol, 'rm')(path, options);
+        },
+        stat(path, options) {
+            return (0, util_1.promisify)(vol, 'stat')(path, options);
+        },
+        symlink(target, path, type) {
+            return (0, util_1.promisify)(vol, 'symlink')(target, path, type);
+        },
+        truncate(path, len) {
+            return (0, util_1.promisify)(vol, 'truncate')(path, len);
+        },
+        unlink(path) {
+            return (0, util_1.promisify)(vol, 'unlink')(path);
+        },
+        utimes(path, atime, mtime) {
+            return (0, util_1.promisify)(vol, 'utimes')(path, atime, mtime);
+        },
+        writeFile(id, data, options) {
+            return (0, util_1.promisify)(vol, 'writeFile')(id instanceof FileHandle_1.FileHandle ? id.fd : id, data, options);
+        },
+    };
+}
+exports.createPromisesApi = createPromisesApi;

package/lib/node/types/callback.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { PathLike, symlink } from 'fs';
+import type * as misc from './misc';
+import type * as opts from './options';
+export interface FsCallbackApi {
+    open(path: PathLike, flags: misc.TFlags, /* ... */ callback: misc.TCallback<number>): any;
+    open(path: PathLike, flags: misc.TFlags, mode: misc.TMode, callback: misc.TCallback<number>): any;
+    close(fd: number, callback: misc.TCallback<void>): void;
+    read(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset: number, length: number, position: number, callback: (err?: Error | null, bytesRead?: number, buffer?: Buffer | ArrayBufferView | DataView) => void): void;
+    readFile(id: misc.TFileId, callback: misc.TCallback<misc.TDataOut>): any;
+    readFile(id: misc.TFileId, options: opts.IReadFileOptions | string, callback: misc.TCallback<misc.TDataOut>): any;
+    write(fd: number, buffer: Buffer | ArrayBufferView | DataView, callback: (...args: any[]) => void): any;
+    write(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset: number, callback: (...args: any[]) => void): any;
+    write(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset: number, length: number, callback: (...args: any[]) => void): any;
+    write(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset: number, length: number, position: number, callback: (...args: any[]) => void): any;
+    write(fd: number, str: string, callback: (...args: any[]) => void): any;
+    write(fd: number, str: string, position: number, callback: (...args: any[]) => void): any;
+    write(fd: number, str: string, position: number, encoding: BufferEncoding, callback: (...args: any[]) => void): any;
+    writeFile(id: misc.TFileId, data: misc.TData, callback: misc.TCallback<void>): any;
+    writeFile(id: misc.TFileId, data: misc.TData, options: opts.IWriteFileOptions | string, callback: misc.TCallback<void>): any;
+    copyFile(src: PathLike, dest: PathLike, callback: misc.TCallback<void>): any;
+    copyFile(src: PathLike, dest: PathLike, flags: misc.TFlagsCopy, callback: misc.TCallback<void>): any;
+    link(existingPath: PathLike, newPath: PathLike, callback: misc.TCallback<void>): void;
+    unlink(path: PathLike, callback: misc.TCallback<void>): void;
+    symlink(target: PathLike, path: PathLike, callback: misc.TCallback<void>): any;
+    symlink(target: PathLike, path: PathLike, type: symlink.Type, callback: misc.TCallback<void>): any;
+    realpath(path: PathLike, callback: misc.TCallback<misc.TDataOut>): any;
+    realpath(path: PathLike, options: opts.IRealpathOptions | string, callback: misc.TCallback<misc.TDataOut>): any;
+    lstat(path: PathLike, callback: misc.TCallback<misc.IStats>): void;
+    lstat(path: PathLike, options: opts.IStatOptions, callback: misc.TCallback<misc.IStats>): void;
+    stat(path: PathLike, callback: misc.TCallback<misc.IStats>): void;
+    stat(path: PathLike, options: opts.IStatOptions, callback: misc.TCallback<misc.IStats>): void;
+    fstat(fd: number, callback: misc.TCallback<misc.IStats>): void;
+    fstat(fd: number, options: opts.IFStatOptions, callback: misc.TCallback<misc.IStats>): void;
+    rename(oldPath: PathLike, newPath: PathLike, callback: misc.TCallback<void>): void;
+    exists(path: PathLike, callback: (exists: boolean) => void): void;
+    access(path: PathLike, callback: misc.TCallback<void>): any;
+    access(path: PathLike, mode: number, callback: misc.TCallback<void>): any;
+    appendFile(id: misc.TFileId, data: misc.TData, callback: misc.TCallback<void>): any;
+    appendFile(id: misc.TFileId, data: misc.TData, options: opts.IAppendFileOptions | string, callback: misc.TCallback<void>): any;
+    readdir(path: PathLike, callback: misc.TCallback<misc.TDataOut[] | misc.IDirent[]>): any;
+    readdir(path: PathLike, options: opts.IReaddirOptions | string, callback: misc.TCallback<misc.TDataOut[] | misc.IDirent[]>): any;
+    readlink(path: PathLike, callback: misc.TCallback<misc.TDataOut>): any;
+    readlink(path: PathLike, options: opts.IOptions, callback: misc.TCallback<misc.TDataOut>): any;
+    fsyncSync(fd: number): void;
+    fsync(fd: number, callback: misc.TCallback<void>): void;
+    fdatasync(fd: number, callback: misc.TCallback<void>): void;
+    ftruncate(fd: number, callback: misc.TCallback<void>): any;
+    ftruncate(fd: number, len: number, callback: misc.TCallback<void>): any;
+    truncate(id: misc.TFileId, callback: misc.TCallback<void>): any;
+    truncate(id: misc.TFileId, len: number, callback: misc.TCallback<void>): any;
+    futimes(fd: number, atime: misc.TTime, mtime: misc.TTime, callback: misc.TCallback<void>): void;
+    utimes(path: PathLike, atime: misc.TTime, mtime: misc.TTime, callback: misc.TCallback<void>): void;
+    mkdir(path: PathLike, callback: misc.TCallback<void>): any;
+    mkdir(path: PathLike, mode: misc.TMode | (opts.IMkdirOptions & {
+        recursive?: false;
+    }), callback: misc.TCallback<void>): any;
+    mkdir(path: PathLike, mode: opts.IMkdirOptions & {
+        recursive: true;
+    }, callback: misc.TCallback<string>): any;
+    mkdir(path: PathLike, mode: misc.TMode | opts.IMkdirOptions, callback: misc.TCallback<string>): any;
+    mkdirp(path: PathLike, callback: misc.TCallback<string>): any;
+    mkdirp(path: PathLike, mode: misc.TMode, callback: misc.TCallback<string>): any;
+    mkdtemp(prefix: string, callback: misc.TCallback<void>): void;
+    mkdtemp(prefix: string, options: opts.IOptions, callback: misc.TCallback<void>): any;
+    rmdir(path: PathLike, callback: misc.TCallback<void>): any;
+    rmdir(path: PathLike, options: opts.IRmdirOptions, callback: misc.TCallback<void>): any;
+    rm(path: PathLike, callback: misc.TCallback<void>): void;
+    rm(path: PathLike, options: opts.IRmOptions, callback: misc.TCallback<void>): void;
+    fchmod(fd: number, mode: misc.TMode, callback: misc.TCallback<void>): void;
+    chmod(path: PathLike, mode: misc.TMode, callback: misc.TCallback<void>): void;
+    lchmod(path: PathLike, mode: misc.TMode, callback: misc.TCallback<void>): void;
+    fchown(fd: number, uid: number, gid: number, callback: misc.TCallback<void>): void;
+    chown(path: PathLike, uid: number, gid: number, callback: misc.TCallback<void>): void;
+    lchown(path: PathLike, uid: number, gid: number, callback: misc.TCallback<void>): void;
+    watchFile(path: PathLike, listener: (curr: misc.IStats, prev: misc.IStats) => void): misc.IStatWatcher;
+    watchFile(path: PathLike, options: opts.IWatchFileOptions, listener: (curr: misc.IStats, prev: misc.IStats) => void): misc.IStatWatcher;
+    unwatchFile(path: PathLike, listener?: (curr: misc.IStats, prev: misc.IStats) => void): void;
+    createReadStream(path: PathLike, options?: opts.IReadStreamOptions | string): misc.IReadStream;
+    createWriteStream(path: PathLike, options?: opts.IWriteStreamOptions | string): misc.IWriteStream;
+    watch(path: PathLike, options?: opts.IWatchOptions | string, listener?: (eventType: string, filename: string) => void): misc.IFSWatcher;
+}

package/lib/node/types/callback.js

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

package/lib/node/types/index.d.ts

@@ -0,0 +1,7 @@
+import type { FsSynchronousApi } from './sync';
+import type { FsCallbackApi } from './callback';
+import type { FsPromisesApi } from './promises';
+export { FsSynchronousApi, FsCallbackApi, FsPromisesApi };
+export interface FsApi extends FsCallbackApi, FsSynchronousApi {
+    promises: FsPromisesApi;
+}

package/lib/node/types/index.js

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

package/lib/node/types/misc.d.ts

@@ -0,0 +1,112 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { PathLike, symlink } from 'fs';
+import type { constants } from '../../constants';
+import type { EventEmitter } from 'events';
+import type { TSetTimeout } from '../../setTimeoutUnref';
+import type { IAppendFileOptions, IReadFileOptions, IReadStreamOptions, IStatOptions, IWriteFileOptions, IWriteStreamOptions } from './options';
+import type { Readable, Writable } from 'stream';
+export { PathLike, symlink };
+export type TDataOut = string | Buffer;
+export type TEncodingExtended = BufferEncoding | 'buffer';
+export type TFileId = PathLike | number;
+export type TData = TDataOut | ArrayBufferView | DataView;
+export type TFlags = string | number;
+export type TMode = string | number;
+export type TTime = number | string | Date;
+export type TCallback<TData> = (error?: IError | null, data?: TData) => void;
+export interface IError extends Error {
+    code?: string;
+}
+export type TFlagsCopy = typeof constants.COPYFILE_EXCL | typeof constants.COPYFILE_FICLONE | typeof constants.COPYFILE_FICLONE_FORCE;
+export type TStatNumber = number | bigint;
+export interface IStats<T = TStatNumber> {
+    uid: T;
+    gid: T;
+    rdev: T;
+    blksize: T;
+    ino: T;
+    size: T;
+    blocks: T;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    atimeMs: T;
+    mtimeMs: T;
+    ctimeMs: T;
+    birthtimeMs: T;
+    dev: T;
+    mode: T;
+    nlink: T;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export interface IDirent {
+    name: TDataOut;
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isSymbolicLink(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+export interface IStatWatcher extends EventEmitter {
+    filename: string;
+    interval: number;
+    timeoutRef?: any;
+    setTimeout: TSetTimeout;
+    prev: IStats;
+    start(path: string, persistent?: boolean, interval?: number): void;
+    stop(): void;
+}
+export interface IReadStream extends Readable {
+    new (path: PathLike, options: IReadStreamOptions): any;
+    open(): any;
+    close(callback: TCallback<void>): any;
+    bytesRead: number;
+    path: string;
+}
+export interface IWriteStream extends Writable {
+    bytesWritten: number;
+    path: string;
+    new (path: PathLike, options: IWriteStreamOptions): any;
+    open(): any;
+    close(): any;
+}
+export interface IFSWatcher extends EventEmitter {
+    start(path: PathLike, persistent?: boolean, recursive?: boolean, encoding?: BufferEncoding): void;
+    close(): void;
+}
+export interface IFileHandle {
+    fd: number;
+    appendFile(data: TData, options?: IAppendFileOptions | string): Promise<void>;
+    chmod(mode: TMode): Promise<void>;
+    chown(uid: number, gid: number): Promise<void>;
+    close(): Promise<void>;
+    datasync(): Promise<void>;
+    read(buffer: Buffer | Uint8Array, offset: number, length: number, position: number): Promise<TFileHandleReadResult>;
+    readFile(options?: IReadFileOptions | string): Promise<TDataOut>;
+    stat(options?: IStatOptions): Promise<IStats>;
+    truncate(len?: number): Promise<void>;
+    utimes(atime: TTime, mtime: TTime): Promise<void>;
+    write(buffer: Buffer | ArrayBufferView | DataView, offset?: number, length?: number, position?: number): Promise<TFileHandleWriteResult>;
+    writeFile(data: TData, options?: IWriteFileOptions): Promise<void>;
+}
+export type TFileHandle = PathLike | IFileHandle;
+export interface TFileHandleReadResult {
+    bytesRead: number;
+    buffer: Buffer | Uint8Array;
+}
+export interface TFileHandleWriteResult {
+    bytesWritten: number;
+    buffer: Buffer | Uint8Array;
+}

package/lib/node/types/misc.js

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

package/lib/node/types/options.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import type { TEncodingExtended, TFlags, TMode } from './misc';
+export interface IOptions {
+    encoding?: BufferEncoding | TEncodingExtended;
+}
+export interface IFileOptions extends IOptions {
+    mode?: TMode;
+    flag?: TFlags;
+}
+export interface IWriteFileOptions extends IFileOptions {
+}
+export interface IReadFileOptions extends IOptions {
+    flag?: string;
+}
+export interface IRealpathOptions {
+    encoding?: TEncodingExtended;
+}
+export interface IAppendFileOptions extends IFileOptions {
+}
+export interface IStatOptions {
+    bigint?: boolean;
+    throwIfNoEntry?: boolean;
+}
+export interface IFStatOptions {
+    bigint?: boolean;
+}
+export interface IAppendFileOptions extends IFileOptions {
+}
+export interface IReaddirOptions extends IOptions {
+    withFileTypes?: boolean;
+}
+export interface IMkdirOptions {
+    mode?: TMode;
+    recursive?: boolean;
+}
+export interface IRmdirOptions {
+    /** @deprecated */
+    recursive?: boolean;
+    maxRetries?: number;
+    retryDelay?: number;
+}
+export interface IRmOptions {
+    force?: boolean;
+    maxRetries?: number;
+    recursive?: boolean;
+    retryDelay?: number;
+}
+export interface IWatchFileOptions {
+    persistent?: boolean;
+    interval?: number;
+}
+export interface IReadStreamOptions {
+    flags?: TFlags;
+    encoding?: BufferEncoding;
+    fd?: number;
+    mode?: TMode;
+    autoClose?: boolean;
+    start?: number;
+    end?: number;
+}
+export interface IWriteStreamOptions {
+    flags?: TFlags;
+    defaultEncoding?: BufferEncoding;
+    fd?: number;
+    mode?: TMode;
+    autoClose?: boolean;
+    start?: number;
+}
+export interface IWatchOptions extends IOptions {
+    persistent?: boolean;
+    recursive?: boolean;
+}

package/lib/node/types/options.js

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

package/lib/node/types/promises.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import * as misc from './misc';
+import * as opts from './options';
+export interface FsPromisesApi {
+    FileHandle: new (...args: unknown[]) => misc.IFileHandle;
+    access(path: misc.PathLike, mode?: number): Promise<void>;
+    appendFile(path: misc.TFileHandle, data: misc.TData, options?: opts.IAppendFileOptions | string): Promise<void>;
+    chmod(path: misc.PathLike, mode: misc.TMode): Promise<void>;
+    chown(path: misc.PathLike, uid: number, gid: number): Promise<void>;
+    copyFile(src: misc.PathLike, dest: misc.PathLike, flags?: misc.TFlagsCopy): Promise<void>;
+    lchmod(path: misc.PathLike, mode: misc.TMode): Promise<void>;
+    lchown(path: misc.PathLike, uid: number, gid: number): Promise<void>;
+    link(existingPath: misc.PathLike, newPath: misc.PathLike): Promise<void>;
+    lstat(path: misc.PathLike, options?: opts.IStatOptions): Promise<misc.IStats>;
+    mkdir(path: misc.PathLike, options?: misc.TMode | opts.IMkdirOptions): Promise<void>;
+    mkdtemp(prefix: string, options?: opts.IOptions): Promise<misc.TDataOut>;
+    open(path: misc.PathLike, flags: misc.TFlags, mode?: misc.TMode): Promise<misc.IFileHandle>;
+    readdir(path: misc.PathLike, options?: opts.IReaddirOptions | string): Promise<misc.TDataOut[] | misc.IDirent[]>;
+    readFile(id: misc.TFileHandle, options?: opts.IReadFileOptions | string): Promise<misc.TDataOut>;
+    readlink(path: misc.PathLike, options?: opts.IOptions): Promise<misc.TDataOut>;
+    realpath(path: misc.PathLike, options?: opts.IRealpathOptions | string): Promise<misc.TDataOut>;
+    rename(oldPath: misc.PathLike, newPath: misc.PathLike): Promise<void>;
+    rmdir(path: misc.PathLike, options?: opts.IRmdirOptions): Promise<void>;
+    rm(path: misc.PathLike, options?: opts.IRmOptions): Promise<void>;
+    stat(path: misc.PathLike, options?: opts.IStatOptions): Promise<misc.IStats>;
+    symlink(target: misc.PathLike, path: misc.PathLike, type?: misc.symlink.Type): Promise<void>;
+    truncate(path: misc.PathLike, len?: number): Promise<void>;
+    unlink(path: misc.PathLike): Promise<void>;
+    utimes(path: misc.PathLike, atime: misc.TTime, mtime: misc.TTime): Promise<void>;
+    writeFile(id: misc.TFileHandle, data: misc.TData, options?: opts.IWriteFileOptions): Promise<void>;
+}

package/lib/node/types/promises.js

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

package/lib/node/types/sync.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { PathLike, symlink } from 'fs';
+import type * as misc from './misc';
+import type * as opts from './options';
+export interface FsSynchronousApi {
+    openSync(path: PathLike, flags: misc.TFlags, mode?: misc.TMode): number;
+    closeSync(fd: number): void;
+    readSync(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset: number, length: number, position: number): number;
+    readFileSync(file: misc.TFileId, options?: opts.IReadFileOptions | string): misc.TDataOut;
+    writeSync(fd: number, buffer: Buffer | ArrayBufferView | DataView, offset?: number, length?: number, position?: number): number;
+    writeSync(fd: number, str: string, position?: number, encoding?: BufferEncoding): number;
+    writeFileSync(id: misc.TFileId, data: misc.TData, options?: opts.IWriteFileOptions): void;
+    copyFileSync(src: PathLike, dest: PathLike, flags?: misc.TFlagsCopy): void;
+    linkSync(existingPath: PathLike, newPath: PathLike): void;
+    unlinkSync(path: PathLike): void;
+    symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type): void;
+    realpathSync(path: PathLike, options?: opts.IRealpathOptions | string): misc.TDataOut;
+    lstatSync(path: PathLike): misc.IStats<number>;
+    lstatSync(path: PathLike, options: {
+        throwIfNoEntry?: true | undefined;
+    }): misc.IStats<number>;
+    lstatSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry?: true | undefined;
+    }): misc.IStats<number>;
+    lstatSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry?: true | undefined;
+    }): misc.IStats<bigint>;
+    lstatSync(path: PathLike, options: {
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    lstatSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    lstatSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): misc.IStats<bigint> | undefined;
+    statSync(path: PathLike): misc.IStats<number>;
+    statSync(path: PathLike, options: {
+        throwIfNoEntry?: true;
+    }): misc.IStats<number>;
+    statSync(path: PathLike, options: {
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    statSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry?: true;
+    }): misc.IStats<number>;
+    statSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry?: true;
+    }): misc.IStats<bigint>;
+    statSync(path: PathLike, options: {
+        bigint: false;
+        throwIfNoEntry: false;
+    }): misc.IStats<number> | undefined;
+    statSync(path: PathLike, options: {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): misc.IStats<bigint> | undefined;
+    fstatSync(fd: number): misc.IStats<number>;
+    fstatSync(fd: number, options: {
+        bigint: false;
+    }): misc.IStats<number>;
+    fstatSync(fd: number, options: {
+        bigint: true;
+    }): misc.IStats<bigint>;
+    renameSync(oldPath: PathLike, newPath: PathLike): void;
+    existsSync(path: PathLike): boolean;
+    accessSync(path: PathLike, mode?: number): void;
+    appendFileSync(id: misc.TFileId, data: misc.TData, options?: opts.IAppendFileOptions | string): void;
+    readdirSync(path: PathLike, options?: opts.IReaddirOptions | string): misc.TDataOut[] | misc.IDirent[];
+    readlinkSync(path: PathLike, options?: opts.IOptions): misc.TDataOut;
+    fdatasyncSync(fd: number): void;
+    ftruncateSync(fd: number, len?: number): void;
+    truncateSync(id: misc.TFileId, len?: number): void;
+    futimesSync(fd: number, atime: misc.TTime, mtime: misc.TTime): void;
+    utimesSync(path: PathLike, atime: misc.TTime, mtime: misc.TTime): void;
+    mkdirSync(path: PathLike, options: opts.IMkdirOptions & {
+        recursive: true;
+    }): string | undefined;
+    mkdirSync(path: PathLike, options?: misc.TMode | (opts.IMkdirOptions & {
+        recursive?: false;
+    })): void;
+    mkdirSync(path: PathLike, options?: misc.TMode | opts.IMkdirOptions): string | undefined;
+    mkdirpSync(path: PathLike, mode?: misc.TMode): void;
+    mkdtempSync(prefix: string, options?: opts.IOptions): misc.TDataOut;
+    rmdirSync(path: PathLike, options?: opts.IRmdirOptions): void;
+    rmSync(path: PathLike, options?: opts.IRmOptions): void;
+    fchmodSync(fd: number, mode: misc.TMode): void;
+    chmodSync(path: PathLike, mode: misc.TMode): void;
+    lchmodSync(path: PathLike, mode: misc.TMode): void;
+    fchownSync(fd: number, uid: number, gid: number): void;
+    chownSync(path: PathLike, uid: number, gid: number): void;
+    lchownSync(path: PathLike, uid: number, gid: number): void;
+}

package/lib/node/types/sync.js

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

package/lib/node/util.d.ts

@@ -0,0 +1,2 @@
+import type { FsCallbackApi } from './types';
+export declare function promisify(fs: FsCallbackApi, fn: string, getResult?: (result: any) => any): (...args: any[]) => Promise<any>;

package/lib/node/util.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promisify = void 0;
+function promisify(fs, fn, getResult = input => input) {
+    return (...args) => new Promise((resolve, reject) => {
+        fs[fn].bind(fs)(...args, (error, result) => {
+            if (error)
+                return reject(error);
+            return resolve(getResult(result));
+        });
+    });
+}
+exports.promisify = promisify;

package/lib/node.d.ts

@@ -48,7 +48,7 @@ export declare class Node extends EventEmitter {
     isSymlink(): boolean;
     makeSymlink(steps: string[]): void;
     write(buf: Buffer, off?: number, len?: number, pos?: number): number;
-    read(buf: Buffer | Uint8Array, off?: number, len?: number, pos?: number): number;
+    read(buf: Buffer | ArrayBufferView | DataView, off?: number, len?: number, pos?: number): number;
     truncate(len?: number): void;
     chmod(perm: number): void;
     chown(uid: number, gid: number): void;
@@ -150,7 +150,7 @@ export declare class File {
     seekTo(position: number): void;
     stats(): Stats<number>;
     write(buf: Buffer, offset?: number, length?: number, position?: number): number;
-    read(buf: Buffer | Uint8Array, offset?: number, length?: number, position?: number): number;
+    read(buf: Buffer | ArrayBufferView | DataView, offset?: number, length?: number, position?: number): number;
     chmod(perm: number): void;
     chown(uid: number, gid: number): void;
 }