@zenfs/core 0.5.5 → 0.5.7

package/dist/emulation/promises.d.ts

@@ -1,13 +1,21 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer } from 'buffer';
 import type * as Node from 'node:fs';
-export * as constants from './constants.js';
-import type { PathLike, BufferToUint8Array } from './shared.js';
+import type * as promises from 'node:fs/promises';
+import type { CreateReadStreamOptions, CreateWriteStreamOptions, FileChangeInfo, FileReadResult, FlagAndOpenMode } from 'node:fs/promises';
 import { FileContents } from '../filesystem.js';
-import { BigIntStats, type Stats } from '../stats.js';
-import { Dirent } from './dir.js';
-export declare class FileHandle implements BufferToUint8Array<Node.promises.FileHandle> {
+import { BigIntStats, type BigIntStatsFs, type Stats, type StatsFs } from '../stats.js';
+import { Dirent, type Dir } from './dir.js';
+import type { PathLike } from './shared.js';
+export * as constants from './constants.js';
+import type { ReadableStream } from 'node:stream/web';
+import type { Interface as ReadlineInterface } from 'readline';
+export declare class FileHandle implements promises.FileHandle {
     /**
      * Gets the file descriptor for this file handle.
      */
@@ -17,6 +25,8 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      * Gets the file descriptor for this file handle.
      */
     fd: number);
+    private get file();
+    private get path();
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
@@ -55,11 +65,7 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      * If `mode` is a string, it is parsed as an octal integer.
      * If `flag` is not supplied, the default of `'a'` is used.
      */
-    appendFile(data: string | Uint8Array, _options?: {
-        encoding?: BufferEncoding;
-        mode?: Node.Mode;
-        flag?: Node.OpenMode;
-    } | BufferEncoding): Promise<void>;
+    appendFile(data: string | Uint8Array, _options?: (Node.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<void>;
     /**
      * Asynchronously reads data from the file.
      * The `FileHandle` must have been opened for reading.
@@ -68,10 +74,7 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      * @param length The number of bytes to read.
      * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position.
      */
-    read<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
-        bytesRead: number;
-        buffer: TBuffer;
-    }>;
+    read<TBuffer extends NodeJS.ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<FileReadResult<TBuffer>>;
     /**
      * Asynchronously reads the entire contents of a file. The underlying file will _not_ be closed automatically.
      * The `FileHandle` must have been opened for reading.
@@ -80,11 +83,22 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      */
     readFile(_options?: {
         flag?: Node.OpenMode;
-    }): Promise<Uint8Array>;
-    readFile(_options: {
-        encoding: BufferEncoding;
-        flag?: Node.OpenMode;
-    } | BufferEncoding): Promise<string>;
+    }): Promise<Buffer>;
+    readFile(_options: (Node.ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding): Promise<string>;
+    /**
+     * Returns a `ReadableStream` that may be used to read the files data.
+     *
+     * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed
+     * or closing.
+     *
+     * While the `ReadableStream` will read the file to completion, it will not close the `FileHandle` automatically. User code must still call the `fileHandle.close()` method.
+     *
+     * @since v17.0.0
+     * @experimental
+     */
+    readableWebStream(options?: promises.ReadableWebStreamOptions): ReadableStream;
+    readLines(options?: promises.CreateReadStreamOptions): ReadlineInterface;
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * Asynchronous fstat(2) - Get file status.
      */
@@ -104,9 +118,9 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
      * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
      */
-    write(buffer: Uint8Array, offset?: number, length?: number, position?: number): Promise<{
+    write<TBuffer extends Uint8Array>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{
         bytesWritten: number;
-        buffer: Uint8Array;
+        buffer: TBuffer;
     }>;
     /**
      * Asynchronously writes `string` to the file.
@@ -134,17 +148,21 @@ export declare class FileHandle implements BufferToUint8Array<Node.promises.File
      */
     writeFile(data: string | Uint8Array, _options?: Node.WriteFileOptions): Promise<void>;
     /**
-     * See `fs.writev` promisified version.
+     * Asynchronous close(2) - close a `FileHandle`.
      */
-    writev(buffers: ReadonlyArray<Uint8Array>, position?: number): Promise<Node.WriteVResult>;
+    close(): Promise<void>;
     /**
-     * See `fs.readv` promisified version.
+     * See `fs.writev` promisified version.
+     * @todo Implement
      */
-    readv(buffers: ReadonlyArray<Uint8Array>, position?: number): Promise<Node.ReadVResult>;
+    writev(buffers: NodeJS.ArrayBufferView[], position?: number): Promise<Node.WriteVResult>;
     /**
-     * Asynchronous close(2) - close a `FileHandle`.
+     * See `fs.readv` promisified version.
+     * @todo Implement
      */
-    close(): Promise<void>;
+    readv(buffers: readonly NodeJS.ArrayBufferView[], position?: number): Promise<Node.ReadVResult>;
+    createReadStream(options?: CreateReadStreamOptions): Node.ReadStream;
+    createWriteStream(options?: CreateWriteStreamOptions): Node.WriteStream;
 }
 /**
  * Renames a file
@@ -213,8 +231,8 @@ export declare function lopen(path: PathLike, flag: string, mode?: Node.Mode): P
  */
 export declare function readFile(filename: PathLike, options?: {
     flag?: Node.OpenMode;
-}): Promise<Uint8Array>;
-export declare function readFile(filename: PathLike, options: (Node.BaseEncodingOptions & {
+}): Promise<Buffer>;
+export declare function readFile(filename: PathLike, options: (Node.EncodingOption & {
     flag?: Node.OpenMode;
 }) | BufferEncoding): Promise<string>;
 /**
@@ -239,64 +257,10 @@ export declare function writeFile(filename: PathLike, data: FileContents, _optio
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export declare function appendFile(filename: PathLike, data: FileContents, _options?: BufferEncoding | (Node.BaseEncodingOptions & {
+export declare function appendFile(filename: PathLike, data: FileContents, _options?: BufferEncoding | (Node.EncodingOption & {
     mode?: Node.Mode;
     flag?: Node.OpenMode;
 })): Promise<void>;
-/**
- * Write buffer to the file specified by `fd`.
- * Note that it is unsafe to use fs.write multiple times on the same file without waiting for it to return.
- * @param handle
- * @param data Uint8Array containing the data to write to the file.
- * @param offset Offset in the buffer to start reading data from.
- * @param length The amount of bytes to write to the file.
- * @param position Offset from the beginning of the file where this data should be written. If position is null, the data will be written at the current position.
- */
-export declare function write(handle: FileHandle, data: Uint8Array, offset: number, length: number, position?: number): Promise<{
-    bytesWritten: number;
-    buffer: Uint8Array;
-}>;
-export declare function write(handle: FileHandle, data: string, position?: number, encoding?: BufferEncoding): Promise<{
-    bytesWritten: number;
-    buffer: string;
-}>;
-/**
- * Read data from the file specified by `fd`.
- * @param handle
- * @param buffer The buffer that the data will be
- *   written to.
- * @param offset The offset within the buffer where writing will
- *   start.
- * @param length An integer specifying the number of bytes to read.
- * @param position An integer specifying where to begin reading from
- *   in the file. If position is null, data will be read from the current file
- *   position.
- */
-export declare function read(handle: FileHandle, buffer: Uint8Array, offset: number, length: number, position?: number): Promise<{
-    bytesRead: number;
-    buffer: Uint8Array;
-}>;
-/**
- * `fchown`.
- * @param handle
- * @param uid
- * @param gid
- */
-export declare function fchown(handle: FileHandle, uid: number, gid: number): Promise<void>;
-/**
- * `fchmod`.
- * @param handle
- * @param mode
- */
-export declare function fchmod(handle: FileHandle, mode: Node.Mode): Promise<void>;
-/**
- * Change the file timestamps of a file referenced by the supplied file
- * descriptor.
- * @param handle
- * @param atime
- * @param mtime
- */
-export declare function futimes(handle: FileHandle, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
 /**
  * `rmdir`.
  * @param path
@@ -317,13 +281,13 @@ export declare function mkdir(path: PathLike, mode: Node.MakeDirectoryOptions &
  * `readdir`. Reads the contents of a directory.
  * @param path
  */
-export declare function readdir(path: PathLike, options?: (Node.BaseEncodingOptions & {
+export declare function readdir(path: PathLike, options?: (Node.EncodingOption & {
     withFileTypes?: false;
 }) | BufferEncoding): Promise<string[]>;
 export declare function readdir(path: PathLike, options: Node.BufferEncodingOption & {
     withFileTypes?: false;
-}): Promise<Uint8Array[]>;
-export declare function readdir(path: PathLike, options: Node.BaseEncodingOptions & {
+}): Promise<Buffer[]>;
+export declare function readdir(path: PathLike, options: Node.EncodingOption & {
     withFileTypes: true;
 }): Promise<Dirent[]>;
 /**
@@ -343,8 +307,8 @@ export declare function symlink(target: PathLike, path: PathLike, type?: Node.sy
  * readlink.
  * @param path
  */
-export declare function readlink(path: PathLike, options: Node.BufferEncodingOption): Promise<Uint8Array>;
-export declare function readlink(path: PathLike, options?: Node.BaseEncodingOptions | BufferEncoding): Promise<string>;
+export declare function readlink(path: PathLike, options: Node.BufferEncodingOption): Promise<Buffer>;
+export declare function readlink(path: PathLike, options?: Node.EncodingOption | BufferEncoding): Promise<string>;
 /**
  * `chown`.
  * @param path
@@ -392,37 +356,47 @@ export declare function lutimes(path: PathLike, atime: number | Date, mtime: num
  *
  * Note: This *Can not* use doOp since doOp depends on it
  */
-export declare function realpath(path: PathLike, options: Node.BufferEncodingOption): Promise<Uint8Array>;
-export declare function realpath(path: PathLike, options?: Node.BaseEncodingOptions | BufferEncoding): Promise<string>;
-export declare function watchFile(filename: PathLike, listener: (curr: Stats, prev: Stats) => void): Promise<void>;
-export declare function watchFile(filename: PathLike, options: {
-    persistent?: boolean;
-    interval?: number;
-}, listener: (curr: Stats, prev: Stats) => void): Promise<void>;
-export declare function unwatchFile(filename: PathLike, listener?: (curr: Stats, prev: Stats) => void): Promise<void>;
-export declare function watch(filename: PathLike, listener?: (event: string, filename: PathLike) => any): Promise<Node.FSWatcher>;
-export declare function watch(filename: PathLike, options: {
-    persistent?: boolean;
-}, listener?: (event: string, filename: string) => any): Promise<Node.FSWatcher>;
+export declare function realpath(path: PathLike, options: Node.BufferEncodingOption): Promise<Buffer>;
+export declare function realpath(path: PathLike, options?: Node.EncodingOption | BufferEncoding): Promise<string>;
+/**
+ * @todo Implement
+ */
+export declare function watch(filename: PathLike, options: (Node.WatchOptions & {
+    encoding: 'buffer';
+}) | 'buffer'): AsyncIterable<FileChangeInfo<Buffer>>;
+export declare function watch(filename: PathLike, options?: Node.WatchOptions | BufferEncoding): AsyncIterable<FileChangeInfo<string>>;
 /**
  * `access`.
  * @param path
  * @param mode
  */
 export declare function access(path: PathLike, mode?: number): Promise<void>;
-export declare function createReadStream(path: PathLike, options?: {
-    flags?: string;
-    encoding?: string;
-    fd?: number;
-    mode?: number;
-    autoClose?: boolean;
-}): Promise<Node.ReadStream>;
-export declare function createWriteStream(path: PathLike, options?: {
-    flags?: string;
-    encoding?: string;
-    fd?: number;
-    mode?: number;
-}): Promise<Node.WriteStream>;
-export declare function rm(path: PathLike): Promise<void>;
-export declare function mkdtemp(path: PathLike): Promise<void>;
-export declare function copyFile(path: PathLike): Promise<void>;
+/**
+ * @todo Implement
+ */
+export declare function rm(path: PathLike, options?: Node.RmOptions): Promise<void>;
+/**
+ * @todo Implement
+ */
+export declare function mkdtemp(prefix: string, options?: Node.EncodingOption): Promise<string>;
+export declare function mkdtemp(prefix: string, options?: Node.BufferEncodingOption): Promise<Buffer>;
+/**
+ * @todo Implement
+ */
+export declare function copyFile(src: PathLike, dest: PathLike, mode?: number): Promise<void>;
+/**
+ * @todo Implement
+ */
+export declare function opendir(path: PathLike, options?: Node.OpenDirOptions): Promise<Dir>;
+export declare function cp(source: PathLike, destination: PathLike, opts?: Node.CopyOptions): Promise<void>;
+/**
+ * @since v18.15.0
+ * @return Fulfills with an {fs.StatFs} for the file system.
+ */
+export declare function statfs(path: PathLike, opts?: Node.StatFsOptions & {
+    bigint?: false;
+}): Promise<StatsFs>;
+export declare function statfs(path: PathLike, opts: Node.StatFsOptions & {
+    bigint: true;
+}): Promise<BigIntStatsFs>;
+export declare function statfs(path: PathLike, opts?: Node.StatFsOptions): Promise<StatsFs | BigIntStatsFs>;

package/dist/emulation/promises.js

@@ -1,12 +1,12 @@
+import { Buffer } from 'buffer';
 import { ApiError, ErrorCode } from '../ApiError.js';
-export * as constants from './constants.js';
-import { ActionType, isReadable, isWriteable, isAppendable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
-import { normalizePath, normalizeMode, getFdForFile, normalizeOptions, fd2file, fdMap, normalizeTime, cred, nop, resolveFS, fixError, mounts } from './shared.js';
+import { ActionType, isAppendable, isReadable, isWriteable, parseFlag, pathExistsAction, pathNotExistsAction } from '../file.js';
 import { BigIntStats, FileType } from '../stats.js';
-import { decode, encode } from '../utils.js';
+import { F_OK } from './constants.js';
 import { Dirent } from './dir.js';
 import { dirname, join } from './path.js';
-import { F_OK } from './constants.js';
+import { cred, fd2file, fdMap, fixError, getFdForFile, mounts, normalizeMode, normalizeOptions, normalizePath, normalizeTime, resolveFS } from './shared.js';
+export * as constants from './constants.js';
 export class FileHandle {
     constructor(
     /**
@@ -15,11 +15,17 @@ export class FileHandle {
     fd) {
         this.fd = fd;
     }
+    get file() {
+        return fd2file(this.fd);
+    }
+    get path() {
+        return this.file.path;
+    }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
     chown(uid, gid) {
-        return fd2file(this.fd).chown(uid, gid);
+        return this.file.chown(uid, gid);
     }
     /**
      * Asynchronous fchmod(2) - Change permissions of a file.
@@ -30,19 +36,19 @@ export class FileHandle {
         if (numMode < 0) {
             throw new ApiError(ErrorCode.EINVAL, 'Invalid mode.');
         }
-        return fd2file(this.fd).chmod(numMode);
+        return this.file.chmod(numMode);
     }
     /**
      * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
      */
     datasync() {
-        return fd2file(this.fd).datasync();
+        return this.file.datasync();
     }
     /**
      * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
      */
     sync() {
-        return fd2file(this.fd).sync();
+        return this.file.sync();
     }
     /**
      * Asynchronous ftruncate(2) - Truncate a file to a specified length.
@@ -52,7 +58,7 @@ export class FileHandle {
         if (len < 0) {
             throw new ApiError(ErrorCode.EINVAL);
         }
-        return fd2file(this.fd).truncate(len);
+        return this.file.truncate(len);
     }
     /**
      * Asynchronously change file timestamps of the file.
@@ -60,7 +66,7 @@ export class FileHandle {
      * @param mtime The last modified time. If a string is provided, it will be coerced to number.
      */
     utimes(atime, mtime) {
-        return fd2file(this.fd).utimes(normalizeTime(atime), normalizeTime(mtime));
+        return this.file.utimes(normalizeTime(atime), normalizeTime(mtime));
     }
     /**
      * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
@@ -81,8 +87,8 @@ export class FileHandle {
         if (typeof data != 'string' && !options.encoding) {
             throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
         }
-        const encodedData = typeof data == 'string' ? encode(data) : data;
-        await fd2file(this.fd).write(encodedData, 0, encodedData.length, null);
+        const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
+        await this.file.write(encodedData, 0, encodedData.length, null);
     }
     /**
      * Asynchronously reads data from the file.
@@ -94,9 +100,9 @@ export class FileHandle {
      */
     read(buffer, offset, length, position) {
         if (isNaN(+position)) {
-            position = fd2file(this.fd).position;
+            position = this.file.position;
         }
-        return fd2file(this.fd).read(buffer, offset, length, position);
+        return this.file.read(buffer, offset, length, position);
     }
     async readFile(_options) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
@@ -106,11 +112,32 @@ export class FileHandle {
         }
         const { size } = await this.stat();
         const data = new Uint8Array(size);
-        await fd2file(this.fd).read(data, 0, size, 0);
-        return options.encoding ? decode(data, options.encoding) : data;
+        await this.file.read(data, 0, size, 0);
+        const buffer = Buffer.from(data);
+        return options.encoding ? buffer.toString(options.encoding) : buffer;
+    }
+    /**
+     * Returns a `ReadableStream` that may be used to read the files data.
+     *
+     * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed
+     * or closing.
+     *
+     * While the `ReadableStream` will read the file to completion, it will not close the `FileHandle` automatically. User code must still call the `fileHandle.close()` method.
+     *
+     * @since v17.0.0
+     * @experimental
+     */
+    readableWebStream(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readableWebStream');
+    }
+    readLines(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readLines');
+    }
+    [Symbol.asyncDispose]() {
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.@@asyncDispose');
     }
     async stat(opts) {
-        const stats = await fd2file(this.fd).stat();
+        const stats = await this.file.stat();
         return opts?.bigint ? new BigIntStats(stats) : stats;
     }
     async write(data, posOrOff, lenOrEnc, position) {
@@ -120,7 +147,7 @@ export class FileHandle {
             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 {
@@ -130,8 +157,8 @@ export class FileHandle {
             length = lenOrEnc;
             position = typeof position === 'number' ? position : null;
         }
-        position ?? (position = fd2file(this.fd).position);
-        const bytesWritten = await fd2file(this.fd).write(buffer, offset, length, position);
+        position ?? (position = this.file.position);
+        const bytesWritten = await this.file.write(buffer, offset, length, position);
         return { buffer, bytesWritten };
     }
     /**
@@ -154,27 +181,36 @@ export class FileHandle {
         if (typeof data != 'string' && !options.encoding) {
             throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
         }
-        const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
-        await fd2file(this.fd).write(encodedData, 0, encodedData.length, 0);
+        const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
+        await this.file.write(encodedData, 0, encodedData.length, 0);
     }
+    /**
+     * Asynchronous close(2) - close a `FileHandle`.
+     */
+    async close() {
+        await this.file.close();
+        fdMap.delete(this.fd);
+    }
+    /* eslint-disable @typescript-eslint/no-unused-vars */
     /**
      * See `fs.writev` promisified version.
+     * @todo Implement
      */
     writev(buffers, position) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.writev');
     }
     /**
      * See `fs.readv` promisified version.
+     * @todo Implement
      */
     readv(buffers, position) {
-        throw new ApiError(ErrorCode.ENOTSUP);
+        throw ApiError.With('ENOTSUP', this.path, 'FileHandle.readv');
     }
-    /**
-     * Asynchronous close(2) - close a `FileHandle`.
-     */
-    async close() {
-        await fd2file(this.fd).close();
-        fdMap.delete(this.fd);
+    createReadStream(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'createReadStream');
+    }
+    createWriteStream(options) {
+        throw ApiError.With('ENOTSUP', this.path, 'createWriteStream');
     }
 }
 /**
@@ -363,8 +399,8 @@ export async function readFile(filename, _options) {
     if (!isReadable(flag)) {
         throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
     }
-    const data = await _readFile(filename, options.flag, true);
-    return options.encoding ? decode(data, options.encoding) : data;
+    const data = Buffer.from(await _readFile(filename, options.flag, true));
+    return options.encoding ? data.toString(options.encoding) : data;
 }
 readFile;
 /**
@@ -421,60 +457,10 @@ export async function appendFile(filename, data, _options) {
     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;
     await _appendFile(filename, encodedData, options.flag, options.mode, true);
 }
 appendFile;
-export function write(handle, data, posOrOff, lenOrEnc, position) {
-    return handle.write(data, posOrOff, lenOrEnc, position);
-}
-write;
-/**
- * Read data from the file specified by `fd`.
- * @param handle
- * @param buffer The buffer that the data will be
- *   written to.
- * @param offset The offset within the buffer where writing will
- *   start.
- * @param length An integer specifying the number of bytes to read.
- * @param position An integer specifying where to begin reading from
- *   in the file. If position is null, data will be read from the current file
- *   position.
- */
-export function read(handle, buffer, offset, length, position) {
-    return handle.read(buffer, offset, length, position);
-}
-read;
-/**
- * `fchown`.
- * @param handle
- * @param uid
- * @param gid
- */
-export function fchown(handle, uid, gid) {
-    return handle.chown(uid, gid);
-}
-fchown;
-/**
- * `fchmod`.
- * @param handle
- * @param mode
- */
-export function fchmod(handle, mode) {
-    return handle.chmod(mode);
-}
-fchmod;
-/**
- * Change the file timestamps of a file referenced by the supplied file
- * descriptor.
- * @param handle
- * @param atime
- * @param mtime
- */
-export function futimes(handle, atime, mtime) {
-    return handle.utimes(atime, mtime);
-}
-futimes;
 // DIRECTORY-ONLY METHODS
 /**
  * `rmdir`.
@@ -539,12 +525,12 @@ export async function symlink(target, path, type = 'file') {
 }
 symlink;
 export async function readlink(path, options) {
-    const value = await _readFile(path, 'r', false);
+    const value = Buffer.from(await _readFile(path, 'r', false));
     const encoding = typeof options == 'object' ? options.encoding : options;
     if (encoding == 'buffer') {
         return value;
     }
-    return decode(value, encoding);
+    return value.toString(encoding);
 }
 readlink;
 // PROPERTY OPERATIONS
@@ -650,7 +636,7 @@ export async function realpath(path, options) {
         if (!stats.isSymbolicLink()) {
             return path;
         }
-        const dst = mountPoint + normalizePath(decode(await _readFile(resolvedPath, 'r+', false)));
+        const dst = mountPoint + normalizePath(Buffer.from(await _readFile(resolvedPath, 'r+', false)).toString());
         return realpath(dst);
     }
     catch (e) {
@@ -658,15 +644,10 @@ export async function realpath(path, options) {
     }
 }
 realpath;
-export async function watchFile(filename, arg2, listener = nop) {
-    throw new ApiError(ErrorCode.ENOTSUP);
-}
-export async function unwatchFile(filename, listener = nop) {
-    throw new ApiError(ErrorCode.ENOTSUP);
-}
-export async function watch(filename, arg2, listener = nop) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+export function watch(filename, options) {
+    throw ApiError.With('ENOTSUP', filename, 'watch');
 }
+watch;
 /**
  * `access`.
  * @param path
@@ -678,18 +659,38 @@ export async function access(path, mode = F_OK) {
         throw new ApiError(ErrorCode.EACCES);
     }
 }
-export async function createReadStream(path, options) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+access;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * @todo Implement
+ */
+export async function rm(path, options) {
+    throw ApiError.With('ENOTSUP', path, 'rm');
+}
+rm;
+export async function mkdtemp(prefix, options) {
+    throw ApiError.With('ENOTSUP', prefix, 'mkdtemp');
 }
-export async function createWriteStream(path, options) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+mkdtemp;
+/**
+ * @todo Implement
+ */
+export async function copyFile(src, dest, mode) {
+    throw ApiError.With('ENOTSUP', src, 'copyFile');
 }
-export async function rm(path) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+copyFile;
+/**
+ * @todo Implement
+ */
+export async function opendir(path, options) {
+    throw ApiError.With('ENOTSUP', path, 'opendir');
 }
-export async function mkdtemp(path) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+opendir;
+export async function cp(source, destination, opts) {
+    throw ApiError.With('ENOTSUP', source, 'cp');
 }
-export async function copyFile(path) {
-    throw new ApiError(ErrorCode.ENOTSUP);
+cp;
+export async function statfs(path, opts) {
+    throw ApiError.With('ENOTSUP', path, 'statfs');
 }
+/* eslint-enable @typescript-eslint/no-unused-vars */