@zenfs/core 0.5.4 → 0.5.6

package/dist/emulation/sync.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import { FileContents } from '../filesystem.js';
-import { BigIntStats, type Stats } from '../stats.js';
-import type { symlink, ReadSyncOptions, BaseEncodingOptions, BufferEncodingOption } from 'fs';
+import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import type { symlink, ReadSyncOptions, EncodingOption, BufferEncodingOption } from 'fs';
 import type * as Node from 'fs';
 import { PathLike } from './shared.js';
 import { Dir, Dirent } from './dir.js';
@@ -23,7 +23,7 @@ export declare function existsSync(path: PathLike): boolean;
  * @returns Stats
  */
 export declare function statSync(path: PathLike, options?: {
-    bigint: false;
+    bigint?: false;
 }): Stats;
 export declare function statSync(path: PathLike, options: {
     bigint: true;
@@ -35,7 +35,7 @@ export declare function statSync(path: PathLike, options: {
  * @param path
  */
 export declare function lstatSync(path: PathLike, options?: {
-    bigint: false;
+    bigint?: false;
 }): Stats;
 export declare function lstatSync(path: PathLike, options: {
     bigint: true;
@@ -75,12 +75,10 @@ export declare function lopenSync(path: PathLike, flag: string, mode?: Node.Mode
  */
 export declare function readFileSync(filename: string, options?: {
     flag?: string;
-}): Uint8Array;
-export declare function readFileSync(filename: string, options: {
-    encoding: string;
+}): Buffer;
+export declare function readFileSync(filename: string, options: (Node.EncodingOption & {
     flag?: string;
-}): string;
-export declare function readFileSync(filename: string, encoding: string): string;
+}) | BufferEncoding): string;
 /**
  * Synchronously writes data to a file, replacing the file if it already
  * exists.
@@ -106,8 +104,7 @@ export declare function writeFileSync(filename: string, data: FileContents, enco
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export declare function appendFileSync(filename: string, data: FileContents, options?: Node.WriteFileOptions): void;
-export declare function appendFileSync(filename: string, data: FileContents, encoding?: string): void;
+export declare function appendFileSync(filename: string, data: FileContents, _options?: Node.WriteFileOptions): void;
 /**
  * Synchronous `fstat`.
  * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
@@ -219,7 +216,7 @@ export declare function readdirSync(path: PathLike, options?: {
 export declare function readdirSync(path: PathLike, options: {
     encoding: 'buffer';
     withFileTypes?: false;
-} | 'buffer'): Uint8Array[];
+} | 'buffer'): Buffer[];
 export declare function readdirSync(path: PathLike, options: {
     withFileTypes: true;
 }): Dirent[];
@@ -240,8 +237,8 @@ export declare function symlinkSync(target: PathLike, path: PathLike, type?: sym
  * Synchronous readlink.
  * @param path
  */
-export declare function readlinkSync(path: PathLike, options?: BufferEncodingOption): Uint8Array;
-export declare function readlinkSync(path: PathLike, options: BaseEncodingOptions | BufferEncoding): string;
+export declare function readlinkSync(path: PathLike, options?: BufferEncodingOption): Buffer;
+export declare function readlinkSync(path: PathLike, options: EncodingOption | BufferEncoding): string;
 /**
  * Synchronous `chown`.
  * @param path
@@ -290,18 +287,53 @@ export declare function lutimesSync(path: PathLike, atime: string | number | Dat
  *   known real paths.
  * @returns the real path
  */
-export declare function realpathSync(path: PathLike, options: BufferEncodingOption): Uint8Array;
-export declare function realpathSync(path: PathLike, options?: BaseEncodingOptions | BufferEncoding): string;
+export declare function realpathSync(path: PathLike, options: BufferEncodingOption): Buffer;
+export declare function realpathSync(path: PathLike, options?: EncodingOption): string;
 /**
  * Synchronous `access`.
  * @param path
  * @param mode
  */
 export declare function accessSync(path: PathLike, mode?: number): void;
+/**
+ * @todo Implement
+ */
 export declare function rmSync(path: PathLike): void;
-export declare function mkdtempSync(prefix: string, options: BufferEncodingOption): Uint8Array;
-export declare function mkdtempSync(prefix: string, options?: BaseEncodingOptions | BufferEncoding): string;
+/**
+ * @todo Implement
+ */
+export declare function mkdtempSync(prefix: string, options: BufferEncodingOption): Buffer;
+export declare function mkdtempSync(prefix: string, options?: EncodingOption): string;
+/**
+ * @todo Implement
+ */
 export declare function copyFileSync(src: string, dest: string, flags?: number): void;
+/**
+ * @todo Implement
+ */
 export declare function readvSync(fd: number, buffers: readonly Uint8Array[], position?: number): number;
+/**
+ * @todo Implement
+ */
 export declare function writevSync(fd: number, buffers: readonly Uint8Array[], position?: number): number;
+/**
+ * @todo Implement
+ */
 export declare function opendirSync(path: PathLike, options?: Node.OpenDirOptions): Dir;
+/**
+ * @todo Implement
+ */
+export declare function cpSync(source: PathLike, destination: PathLike, opts?: Node.CopySyncOptions): void;
+/**
+ * Synchronous statfs(2). Returns information about the mounted file system which contains path. The callback gets two arguments (err, stats) where stats is an <fs.StatFs> object.
+ * In case of an error, the err.code will be one of Common System Errors.
+ * @param path A path to an existing file or directory on the file system to be queried.
+ * @param callback
+ */
+export declare function statfsSync(path: PathLike, options?: Node.StatFsOptions & {
+    bigint?: false;
+}): StatsFs;
+export declare function statfsSync(path: PathLike, options: Node.StatFsOptions & {
+    bigint: true;
+}): BigIntStatsFs;
+export declare function statfsSync(path: PathLike, options?: Node.StatFsOptions): StatsFs | BigIntStatsFs;

package/dist/emulation/sync.js

@@ -1,8 +1,7 @@
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
-import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts, } from './shared.js';
-import { decode, encode } from '../utils.js';
+import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts } from './shared.js';
 import { Dirent } from './dir.js';
 import { dirname, join } from './path.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
@@ -31,8 +30,7 @@ export function renameSync(oldPath, newPath) {
         if (_old === _new) {
             return _old.fs.renameSync(_old.path, _new.path, cred);
         }
-        const data = readFileSync(oldPath);
-        writeFileSync(newPath, data);
+        writeFileSync(newPath, readFileSync(oldPath));
         unlinkSync(oldPath);
     }
     catch (e) {
@@ -105,22 +103,22 @@ function _openSync(_path, _flag, _mode, resolveSymlinks) {
                 // Ensure parent exists.
                 const parentStats = doOp('statSync', resolveSymlinks, dirname(path), cred);
                 if (!parentStats.isDirectory()) {
-                    throw ApiError.ENOTDIR(dirname(path));
+                    throw ApiError.With('ENOTDIR', dirname(path), '_openSync');
                 }
                 return doOp('createFileSync', resolveSymlinks, path, flag, mode, cred);
             case ActionType.THROW:
-                throw ApiError.ENOENT(path);
+                throw ApiError.With('ENOENT', path, '_openSync');
             default:
                 throw new ApiError(ErrorCode.EINVAL, 'Invalid FileFlag object.');
         }
     }
     if (!stats.hasAccess(mode, cred)) {
-        throw ApiError.EACCES(path);
+        throw ApiError.With('EACCES', path, '_openSync');
     }
     // File exists.
     switch (pathExistsAction(flag)) {
         case ActionType.THROW:
-            throw ApiError.EEXIST(path);
+            throw ApiError.With('EEXIST', path, '_openSync');
         case ActionType.TRUNCATE:
             // Delete file.
             doOp('unlinkSync', resolveSymlinks, path, cred);
@@ -180,8 +178,8 @@ export function readFileSync(filename, arg2 = {}) {
     if (!isReadable(flag)) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = _readFileSync(filename, options.flag, true);
-    return options.encoding ? decode(data, options.encoding) : data;
+    const data = Buffer.from(_readFileSync(filename, options.flag, true));
+    return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
 /**
@@ -208,7 +206,7 @@ export function writeFileSync(filename, data, _options) {
     if (typeof data != 'string' && !options.encoding) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
+    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
     if (encodedData === undefined) {
         throw new ApiError(ErrorCode.EINVAL, 'Data not specified');
     }
@@ -228,8 +226,19 @@ function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
         file.closeSync();
     }
 }
-export function appendFileSync(filename, data, arg3) {
-    const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
+/**
+ * Asynchronously append data to a file, creating the file if it not yet
+ * exists.
+ *
+ * @param filename
+ * @param data
+ * @param options
+ * @option options encoding Defaults to `'utf8'`.
+ * @option options mode Defaults to `0644`.
+ * @option options flag Defaults to `'a'`.
+ */
+export function appendFileSync(filename, data, _options) {
+    const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
     const flag = parseFlag(options.flag);
     if (!isAppendable(flag)) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
@@ -237,7 +246,7 @@ export function appendFileSync(filename, data, arg3) {
     if (typeof data != 'string' && !options.encoding) {
         throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
     }
-    const encodedData = typeof data == 'string' ? encode(data) : data;
+    const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
     _appendFileSync(filename, encodedData, options.flag, options.mode, true);
 }
 appendFileSync;
@@ -290,7 +299,7 @@ export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
         position = typeof posOrOff === 'number' ? posOrOff : null;
         const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
         offset = 0;
-        buffer = encode(data, encoding);
+        buffer = Buffer.from(data, encoding);
         length = buffer.length;
     }
     else {
@@ -309,11 +318,13 @@ export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
 writeSync;
 export function readSync(fd, buffer, opts, length, position) {
     const file = fd2file(fd);
-    let offset = opts;
+    const offset = typeof opts == 'object' ? opts.offset : opts;
     if (typeof opts == 'object') {
-        ({ offset, length, position } = opts);
+        length = opts.length;
+        position = opts.position;
     }
-    if (isNaN(+position)) {
+    position = Number(position);
+    if (isNaN(position)) {
         position = file.position;
     }
     return file.readSync(buffer, offset, length, position);
@@ -386,7 +397,7 @@ export function readdirSync(path, options) {
             return new Dirent(entry, statSync(join(path, entry)));
         }
         if (options == 'buffer' || (typeof options == 'object' && options.encoding == 'buffer')) {
-            return encode(entry);
+            return Buffer.from(entry);
         }
         return entry;
     });
@@ -414,7 +425,7 @@ export function symlinkSync(target, path, type = 'file') {
         throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
     }
     if (existsSync(path)) {
-        throw ApiError.EEXIST(path);
+        throw ApiError.With('EEXIST', path, 'symlinkSync');
     }
     writeFileSync(path, target);
     const file = _openSync(path, 'r+', 0o644, false);
@@ -422,12 +433,12 @@ export function symlinkSync(target, path, type = 'file') {
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = _readFileSync(path, 'r', false);
+    const value = Buffer.from(_readFileSync(path, 'r', false));
     const encoding = typeof options == 'object' ? options.encoding : options;
     if (encoding == 'buffer') {
         return value;
     }
-    return decode(value, encoding);
+    return value.toString(encoding);
 }
 readlinkSync;
 // PROPERTY OPERATIONS
@@ -509,7 +520,7 @@ export function realpathSync(path, options) {
         if (!stats.isSymbolicLink()) {
             return path;
         }
-        const dst = normalizePath(mountPoint + decode(_readFileSync(resolvedPath, 'r+', false)));
+        const dst = normalizePath(mountPoint + Buffer.from(_readFileSync(resolvedPath, 'r+', false)).toString());
         return realpathSync(dst);
     }
     catch (e) {
@@ -529,27 +540,52 @@ export function accessSync(path, mode = 0o600) {
     }
 }
 accessSync;
+/**
+ * @todo Implement
+ */
 export function rmSync(path) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+    throw ApiError.With('ENOTSUP', path, 'rmSync');
 }
 rmSync;
 export function mkdtempSync(prefix, options) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+    throw ApiError.With('ENOTSUP', prefix, 'mkdtempSync');
 }
 mkdtempSync;
+/**
+ * @todo Implement
+ */
 export function copyFileSync(src, dest, flags) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+    throw ApiError.With('ENOTSUP', src, 'copyFileSync');
 }
 copyFileSync;
+/**
+ * @todo Implement
+ */
 export function readvSync(fd, buffers, position) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+    throw ApiError.With('ENOTSUP', fd2file(fd).path, 'readvSync');
 }
 readvSync;
+/**
+ * @todo Implement
+ */
 export function writevSync(fd, buffers, position) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+    throw ApiError.With('ENOTSUP', fd2file(fd).path, 'writevSync');
 }
 writevSync;
+/**
+ * @todo Implement
+ */
 export function opendirSync(path, options) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+    throw ApiError.With('ENOTSUP', path, 'opendirSync');
 }
 opendirSync;
+/**
+ * @todo Implement
+ */
+export function cpSync(source, destination, opts) {
+    throw ApiError.With('ENOTSUP', source, 'cpSync');
+}
+cpSync;
+export function statfsSync(path, options) {
+    throw ApiError.With('ENOTSUP', path, 'statfsSync');
+}

package/dist/file.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { FileReadResult } from 'node:fs/promises';
 import type { FileSystem } from './filesystem.js';
 import { Stats, type FileType } from './stats.js';
 declare global {
@@ -29,6 +32,10 @@ export declare enum ActionType {
 export declare function parseFlag(flag: string | number): string;
 export declare function flagToString(flag: number): string;
 export declare function flagToNumber(flag: string): number;
+/**
+ * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
+ * @param flag the flag to parse
+ */
 export declare function flagToMode(flag: string): number;
 export declare function isReadable(flag: string): boolean;
 export declare function isWriteable(flag: string): boolean;
@@ -118,10 +125,7 @@ export declare abstract class File {
      *   position.
      * @returns Promise resolving to the new length of the buffer
      */
-    abstract read<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
-        bytesRead: number;
-        buffer: TBuffer;
-    }>;
+    abstract read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<FileReadResult<TBuffer>>;
     /**
      * Read data from the file.
      * @param buffer The buffer that the data will be written to.
@@ -131,7 +135,7 @@ export declare abstract class File {
      *   in the file. If position is null, data will be read from the current file
      *   position.
      */
-    abstract readSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
+    abstract readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
     /**
      * Asynchronous `datasync`.
      *
@@ -298,7 +302,7 @@ export declare abstract class PreloadFile<FS extends FileSystem> extends File {
      *   in the file. If position is null, data will be read from the current file
      *   position.
      */
-    read<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
+    read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
         bytesRead: number;
         buffer: TBuffer;
     }>;
@@ -313,7 +317,7 @@ export declare abstract class PreloadFile<FS extends FileSystem> extends File {
      *   position.
      * @returns number of bytes written
      */
-    readSync(buffer: Uint8Array, offset?: number, length?: number, position?: number): number;
+    readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
     /**
      * Asynchronous `fchmod`.
      * @param mode the mode

package/dist/file.js

@@ -86,6 +86,10 @@ export function flagToNumber(flag) {
             throw new Error('Invalid flag string: ' + flag);
     }
 }
+/**
+ * Parses a flag as a mode (W_OK, R_OK, and/or X_OK)
+ * @param flag the flag to parse
+ */
 export function flagToMode(flag) {
     let mode = 0;
     mode <<= 1;
@@ -323,15 +327,16 @@ export class PreloadFile extends File {
                 }
             }
         }
-        this._buffer.set(buffer.slice(offset, offset + length), position);
-        const len = this._buffer.byteOffset;
+        const slice = buffer.slice(offset, offset + length);
+        this._buffer.set(slice, position);
+        const bytesWritten = slice.byteLength;
         this.stats.mtimeMs = Date.now();
         if (isSynchronous(this.flag)) {
             this.syncSync();
-            return len;
+            return bytesWritten;
         }
-        this.position = position + len;
-        return len;
+        this.position = position + bytesWritten;
+        return bytesWritten;
     }
     /**
      * Read data from the file.
@@ -374,7 +379,7 @@ export class PreloadFile extends File {
             // No copy/read. Return immediatly for better performance
             return bytesRead;
         }
-        buffer.set(this._buffer.slice(position, end), offset);
+        new Uint8Array(buffer.buffer).set(this._buffer.slice(position, end), offset);
         return bytesRead;
     }
     /**
@@ -389,9 +394,6 @@ export class PreloadFile extends File {
      * @param mode
      */
     chmodSync(mode) {
-        if (!this.fs.metadata().supportsProperties) {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        }
         this._dirty = true;
         this.stats.chmod(mode);
         this.syncSync();
@@ -410,9 +412,6 @@ export class PreloadFile extends File {
      * @param gid
      */
     chownSync(uid, gid) {
-        if (!this.fs.metadata().supportsProperties) {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        }
         this._dirty = true;
         this.stats.chown(uid, gid);
         this.syncSync();
@@ -421,9 +420,6 @@ export class PreloadFile extends File {
         this.utimesSync(atime, mtime);
     }
     utimesSync(atime, mtime) {
-        if (!this.fs.metadata().supportsProperties) {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        }
         this._dirty = true;
         this.stats.atime = atime;
         this.stats.mtime = mtime;

package/dist/stats.d.ts

@@ -146,9 +146,8 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     isFIFO(): boolean;
     /**
      * Checks if a given user/group has access to this item
-     * @param mode The request access as 4 bits (unused, read, write, execute)
-     * @param uid The requesting UID
-     * @param gid The requesting GID
+     * @param mode The requested access, combination of W_OK, R_OK, and X_OK
+     * @param cred The requesting credentials
      * @returns True if the request has access, false if the request does not
      * @internal
      */
@@ -202,19 +201,35 @@ export declare class BigIntStats extends StatsCommon<bigint> implements Node.Big
      */
     static clone(stats: BigIntStats | Stats): BigIntStats;
 }
-/**
- * @returns true if stats is a file.
- */
-export declare function isFile(stats: StatsLike): boolean;
-/**
- * @returns True if stats is a directory.
- */
-export declare function isDirectory(stats: StatsLike): boolean;
-/**
- * @returns true if stats is a symbolic link
- */
-export declare function isSymbolicLink(stats: StatsLike): boolean;
-export declare function isSocket(): boolean;
-export declare function isBlockDevice(): boolean;
-export declare function isCharacterDevice(): boolean;
-export declare function isFIFO(): boolean;
+export declare class StatsFs implements Node.StatsFsBase<number> {
+    /** Type of file system. */
+    type: number;
+    /**  Optimal transfer block size. */
+    bsize: number;
+    /**  Total data blocks in file system. */
+    blocks: number;
+    /** Free blocks in file system. */
+    bfree: number;
+    /** Available blocks for unprivileged users */
+    bavail: number;
+    /** Total file nodes in file system. */
+    files: number;
+    /** Free file nodes in file system. */
+    ffree: number;
+}
+export declare class BigIntStatsFs implements Node.StatsFsBase<bigint> {
+    /** Type of file system. */
+    type: bigint;
+    /**  Optimal transfer block size. */
+    bsize: bigint;
+    /**  Total data blocks in file system. */
+    blocks: bigint;
+    /** Free blocks in file system. */
+    bfree: bigint;
+    /** Available blocks for unprivileged users */
+    bavail: bigint;
+    /** Total file nodes in file system. */
+    files: bigint;
+    /** Free file nodes in file system. */
+    ffree: bigint;
+}

package/dist/stats.js

@@ -1,4 +1,4 @@
-import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG } from './emulation/constants.js';
+import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, S_IRWXG, S_IRWXO, S_IRWXU } from './emulation/constants.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
  */
@@ -145,9 +145,8 @@ export class StatsCommon {
     }
     /**
      * Checks if a given user/group has access to this item
-     * @param mode The request access as 4 bits (unused, read, write, execute)
-     * @param uid The requesting UID
-     * @param gid The requesting GID
+     * @param mode The requested access, combination of W_OK, R_OK, and X_OK
+     * @param cred The requesting credentials
      * @returns True if the request has access, false if the request does not
      * @internal
      */
@@ -156,24 +155,9 @@ export class StatsCommon {
             //Running as root
             return true;
         }
-        const perms = this.mode & ~S_IFMT;
-        let uMode = 0xf, gMode = 0xf, wMode = 0xf;
-        if (cred.euid == this.uid) {
-            const uPerms = (0xf00 & perms) >> 8;
-            uMode = (mode ^ uPerms) & mode;
-        }
-        if (cred.egid == this.gid) {
-            const gPerms = (0xf0 & perms) >> 4;
-            gMode = (mode ^ gPerms) & mode;
-        }
-        const wPerms = 0xf & perms;
-        wMode = (mode ^ wPerms) & mode;
-        /*
-        Result = 0b0xxx (read, write, execute)
-        If any bits are set that means the request does not have that permission.
-        */
-        const result = uMode & gMode & wMode;
-        return !result;
+        // Mask for
+        const adjusted = (cred.uid == this.uid ? S_IRWXU : 0) | (cred.gid == this.gid ? S_IRWXG : 0) | S_IRWXO;
+        return (mode & this.mode & adjusted) == mode;
     }
     /**
      * Convert the current stats object into a credentials object
@@ -251,34 +235,7 @@ export class BigIntStats extends StatsCommon {
         return new BigIntStats(stats);
     }
 }
-BigIntStats;
-/**
- * @returns true if stats is a file.
- */
-export function isFile(stats) {
-    return (Number(stats.mode) & S_IFMT) === S_IFREG;
-}
-/**
- * @returns True if stats is a directory.
- */
-export function isDirectory(stats) {
-    return (Number(stats.mode) & S_IFMT) === S_IFDIR;
-}
-/**
- * @returns true if stats is a symbolic link
- */
-export function isSymbolicLink(stats) {
-    return (Number(stats.mode) & S_IFMT) === S_IFLNK;
-}
-export function isSocket() {
-    return false;
-}
-export function isBlockDevice() {
-    return false;
-}
-export function isCharacterDevice() {
-    return false;
+export class StatsFs {
 }
-export function isFIFO() {
-    return false;
+export class BigIntStatsFs {
 }

package/dist/utils.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { FileSystem } from './filesystem.js';
 import { Cred } from './cred.js';
 declare global {
@@ -25,12 +24,12 @@ export declare const setImmediate: (callback: () => unknown) => void;
  * Encodes a string into a buffer
  * @internal
  */
-export declare function encode(input: string, encoding?: BufferEncoding): Uint8Array;
+export declare function encode(input: string): Uint8Array;
 /**
  * Decodes a string from a buffer
  * @internal
  */
-export declare function decode(input?: Uint8Array, encoding?: BufferEncoding): string;
+export declare function decode(input?: Uint8Array): string;
 /**
  * Decodes a directory listing
  * @internal