@zenfs/core 0.0.8 → 0.0.9

package/dist/emulation/callbacks.d.ts

@@ -90,10 +90,10 @@ export declare function open(path: string, flag: string, mode: number | string,
  * @option options [String] flag Defaults to `'r'`.
  * @param callback If no encoding is specified, then the raw buffer is returned.
  */
-export declare function readFile(filename: string, cb: BFSCallback<Buffer>): void;
+export declare function readFile(filename: string, cb: BFSCallback<Uint8Array>): void;
 export declare function readFile(filename: string, options: {
     flag?: string;
-}, callback?: BFSCallback<Buffer>): void;
+}, callback?: BFSCallback<Uint8Array>): void;
 export declare function readFile(filename: string, options: {
     encoding: string;
     flag?: string;
@@ -188,7 +188,7 @@ export declare function fdatasync(fd: number, cb?: BFSOneArgCallback): void;
  * Note that it is unsafe to use fs.write multiple times on the same file
  * without waiting for the callback.
  * @param fd
- * @param buffer Buffer containing the data to write to
+ * @param buffer 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.
@@ -197,8 +197,8 @@ export declare function fdatasync(fd: number, cb?: BFSOneArgCallback): void;
  *   the current position.
  * @param callback The number specifies the number of bytes written into the file.
  */
-export declare function write(fd: number, buffer: Buffer, offset: number, length: number, cb?: BFSThreeArgCallback<number, Buffer>): void;
-export declare function write(fd: number, buffer: Buffer, offset: number, length: number, position: number | null, cb?: BFSThreeArgCallback<number, Buffer>): void;
+export declare function write(fd: number, buffer: Uint8Array, offset: number, length: number, cb?: BFSThreeArgCallback<number, Uint8Array>): void;
+export declare function write(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, cb?: BFSThreeArgCallback<number, Uint8Array>): void;
 export declare function write(fd: number, data: FileContents, cb?: BFSThreeArgCallback<number, string>): void;
 export declare function write(fd: number, data: FileContents, position: number | null, cb?: BFSThreeArgCallback<number, string>): void;
 export declare function write(fd: number, data: FileContents, position: number | null, encoding: BufferEncoding, cb?: BFSThreeArgCallback<number, string>): void;
@@ -214,7 +214,7 @@ export declare function write(fd: number, data: FileContents, position: number |
  *   position.
  * @param callback The number is the number of bytes read
  */
-export declare function read(fd: number, buffer: Buffer, offset: number, length: number, position?: number, cb?: BFSThreeArgCallback<number, Buffer>): void;
+export declare function read(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number, cb?: BFSThreeArgCallback<number, Uint8Array>): void;
 /**
  * Asynchronous `fchown`.
  * @param fd

package/dist/emulation/callbacks.js

@@ -2,6 +2,7 @@ import { ApiError, ErrorCode } from '../ApiError.js';
 import { nop, normalizeMode } from './shared.js';
 import * as promises from './promises.js';
 import { R_OK } from './constants.js';
+import { decode, encode } from '../utils.js';
 /**
  * Asynchronous rename. No arguments other than a possible exception are given
  * to the completion callback.
@@ -167,13 +168,13 @@ export function write(fd, arg2, arg3, arg4, arg5, cb = nop) {
                 cb(new ApiError(ErrorCode.EINVAL, 'Invalid arguments.'));
                 return;
         }
-        buffer = Buffer.from(arg2, encoding);
+        buffer = encode(arg2);
         offset = 0;
         length = buffer.length;
         const _cb = cb;
         promises
             .write(fd, buffer, offset, length, position)
-            .then(bytesWritten => _cb(null, bytesWritten, buffer.toString(encoding)))
+            .then(bytesWritten => _cb(null, bytesWritten, decode(buffer)))
             .catch(_cb);
     }
     else {

package/dist/emulation/promises.d.ts

@@ -55,11 +55,11 @@ export declare function open(path: string, flag: string, mode?: number | string)
  * @param options
  * @option options [String] encoding The string encoding for the file contents. Defaults to `null`.
  * @option options [String] flag Defaults to `'r'`.
- * @return [String | ZenFS.node.Buffer]
+ * @return [String | ZenFS.node.Uint8Array]
  */
 export declare function readFile(filename: string, options?: {
     flag?: string;
-}): Promise<Buffer>;
+}): Promise<Uint8Array>;
 export declare function readFile(filename: string, options: {
     encoding: string;
     flag?: string;
@@ -144,7 +144,7 @@ export declare function fdatasync(fd: number): Promise<void>;
  * Note that it is unsafe to use fs.write multiple times on the same file
  * without waiting for it to return.
  * @param fd
- * @param buffer Buffer containing the data to write to
+ * @param buffer 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.
@@ -152,7 +152,7 @@ export declare function fdatasync(fd: number): Promise<void>;
  *   data should be written. If position is null, the data will be written at
  *   the current position.
  */
-export declare function write(fd: number, buffer: Buffer, offset: number, length: number, position?: number): Promise<number>;
+export declare function write(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number): Promise<number>;
 export declare function write(fd: number, data: string, position?: number | null, encoding?: BufferEncoding): Promise<number>;
 /**
  * Read data from the file specified by `fd`.
@@ -166,9 +166,9 @@ export declare function write(fd: number, data: string, position?: number | null
  *   in the file. If position is null, data will be read from the current file
  *   position.
  */
-export declare function read(fd: number, buffer: Buffer, offset: number, length: number, position?: number): Promise<{
+export declare function read(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number): Promise<{
     bytesRead: number;
-    buffer: Buffer;
+    buffer: Uint8Array;
 }>;
 /**
  * `fchown`.

package/dist/emulation/promises.js

@@ -12,6 +12,7 @@ import * as constants from './constants.js';
 export { constants };
 import { FileFlag } from '../file.js';
 import { normalizePath, normalizeMode, getFdForFile, normalizeOptions, fd2file, fdMap, normalizeTime, cred, nop, resolveFS, fixError, mounts } from './shared.js';
+import { encode } from '../utils.js';
 /**
  * Utility for FS ops. It handles
  * - path normalization (for the first parameter to the FS op)
@@ -234,7 +235,7 @@ export function write(fd, arg2, arg3, arg4, arg5) {
             position = typeof arg3 === 'number' ? arg3 : null;
             const encoding = (typeof arg4 === 'string' ? arg4 : 'utf8');
             offset = 0;
-            buffer = Buffer.from(arg2, encoding);
+            buffer = encode(arg2);
             length = buffer.length;
         }
         else {

package/dist/emulation/sync.d.ts

@@ -54,11 +54,11 @@ export declare function openSync(path: string, flag: string, mode?: number | str
  * @param options
  * @option options [String] encoding The string encoding for the file contents. Defaults to `null`.
  * @option options [String] flag Defaults to `'r'`.
- * @return [String | ZenFS.node.Buffer]
+ * @return [String | ZenFS.node.Uint8Array]
  */
 export declare function readFileSync(filename: string, options?: {
     flag?: string;
-}): Buffer;
+}): Uint8Array;
 export declare function readFileSync(filename: string, options: {
     encoding: string;
     flag?: string;
@@ -138,7 +138,7 @@ export declare function fdatasyncSync(fd: number): void;
  * Note that it is unsafe to use fs.write multiple times on the same file
  * without waiting for it to return.
  * @param fd
- * @param buffer Buffer containing the data to write to
+ * @param buffer 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.
@@ -146,7 +146,7 @@ export declare function fdatasyncSync(fd: number): void;
  *   data should be written. If position is null, the data will be written at
  *   the current position.
  */
-export declare function writeSync(fd: number, buffer: Buffer, offset: number, length: number, position?: number | null): number;
+export declare function writeSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number | null): number;
 export declare function writeSync(fd: number, data: string, position?: number | null, encoding?: BufferEncoding): number;
 /**
  * Read data from the file specified by `fd`.
@@ -160,8 +160,8 @@ export declare function writeSync(fd: number, data: string, position?: number |
  *   in the file. If position is null, data will be read from the current file
  *   position.
  */
-export declare function readSync(fd: number, buffer: Buffer, opts?: ReadSyncOptions): number;
-export declare function readSync(fd: number, buffer: Buffer, offset: number, length: number, position?: number): number;
+export declare function readSync(fd: number, buffer: Uint8Array, opts?: ReadSyncOptions): number;
+export declare function readSync(fd: number, buffer: Uint8Array, offset: number, length: number, position?: number): number;
 /**
  * Synchronous `fchown`.
  * @param fd

package/dist/emulation/sync.js

@@ -1,6 +1,7 @@
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { FileFlag } from '../file.js';
 import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts } from './shared.js';
+import { encode } from '../utils.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
@@ -175,7 +176,7 @@ export function writeSync(fd, arg2, arg3, arg4, arg5) {
         position = typeof arg3 === 'number' ? arg3 : null;
         const encoding = (typeof arg4 === 'string' ? arg4 : 'utf8');
         offset = 0;
-        buffer = Buffer.from(arg2, encoding);
+        buffer = encode(arg2);
         length = buffer.length;
     }
     else {

package/dist/file.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { Stats } from './stats.js';
 import { FileSystem } from './filesystem.js';
 export declare enum ActionType {
@@ -127,7 +126,7 @@ export interface File {
      * **Core**: Write buffer to the file.
      * Note that it is unsafe to use fs.write multiple times on the same file
      * without waiting for the callback.
-     * @param buffer Buffer containing the data to write to
+     * @param buffer 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.
@@ -136,12 +135,12 @@ export interface File {
      *   the current position.
      * @returns Promise resolving to the new length of the buffer
      */
-    write(buffer: Buffer, offset: number, length: number, position: number | null): Promise<number>;
+    write(buffer: Uint8Array, offset: number, length: number, position: number | null): Promise<number>;
     /**
      * **Core**: Write buffer to the file.
      * Note that it is unsafe to use fs.writeSync multiple times on the same file
      * without waiting for it to return.
-     * @param buffer Buffer containing the data to write to
+     * @param buffer 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.
@@ -149,7 +148,7 @@ export interface File {
      *   data should be written. If position is null, the data will be written at
      *   the current position.
      */
-    writeSync(buffer: Buffer, offset: number, length: number, position: number | null): number;
+    writeSync(buffer: Uint8Array, offset: number, length: number, position: number | null): number;
     /**
      * **Core**: Read data from the file.
      * @param buffer The buffer that the data will be
@@ -162,9 +161,9 @@ export interface File {
      *   position.
      * @returns Promise resolving to the new length of the buffer
      */
-    read(buffer: Buffer, offset: number, length: number, position: number | null): Promise<{
+    read(buffer: Uint8Array, offset: number, length: number, position: number | null): Promise<{
         bytesRead: number;
-        buffer: Buffer;
+        buffer: Uint8Array;
     }>;
     /**
      * **Core**: Read data from the file.
@@ -175,7 +174,7 @@ export interface File {
      *   in the file. If position is null, data will be read from the current file
      *   position.
      */
-    readSync(buffer: Buffer, offset: number, length: number, position: number): number;
+    readSync(buffer: Uint8Array, offset: number, length: number, position: number): number;
     /**
      * **Supplementary**: Asynchronous `datasync`.
      *
@@ -231,7 +230,7 @@ export declare class BaseFile {
 }
 /**
  * An implementation of the File interface that operates on a file that is
- * completely in-memory. PreloadFiles are backed by a Buffer.
+ * completely in-memory. PreloadFiles are backed by a Uint8Array.
  *
  * This is also an abstract class, as it lacks an implementation of 'sync' and
  * 'close'. Each filesystem that wishes to use this file representation must
@@ -244,7 +243,7 @@ export declare class PreloadFile<T extends FileSystem> extends BaseFile {
     protected _path: string;
     protected _stat: Stats;
     protected _flag: FileFlag;
-    protected _buffer: Buffer;
+    protected _buffer: Uint8Array;
     protected _dirty: boolean;
     /**
      * Creates a file with the given path and, optionally, the given contents. Note
@@ -260,11 +259,11 @@ export declare class PreloadFile<T extends FileSystem> extends BaseFile {
      *   contents of the file. PreloadFile will mutate this buffer. If not
      *   specified, we assume it is a new file.
      */
-    constructor(_fs: T, _path: string, _flag: FileFlag, _stat: Stats, contents?: Buffer);
+    constructor(_fs: T, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     /**
      * NONSTANDARD: Get the underlying buffer for this file. !!DO NOT MUTATE!! Will mess up dirty tracking.
      */
-    getBuffer(): Buffer;
+    getBuffer(): Uint8Array;
     /**
      * NONSTANDARD: Get underlying stats for this file. !!DO NOT MUTATE!!
      */
@@ -339,22 +338,22 @@ export declare class PreloadFile<T extends FileSystem> extends BaseFile {
      * Write buffer to the file.
      * Note that it is unsafe to use fs.write multiple times on the same file
      * without waiting for the callback.
-     * @param [ZenFS.node.Buffer] buffer Buffer containing the data to write to
+     * @param [ZenFS.node.Uint8Array] buffer Uint8Array containing the data to write to
      *  the file.
      * @param [Number] offset Offset in the buffer to start reading data from.
      * @param [Number] length The amount of bytes to write to the file.
      * @param [Number] 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.
-     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Buffer)]
+     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Uint8Array)]
      *   cb The number specifies the number of bytes written into the file.
      */
-    write(buffer: Buffer, offset: number, length: number, position: number): Promise<number>;
+    write(buffer: Uint8Array, offset: number, length: number, position: number): Promise<number>;
     /**
      * Write buffer to the file.
      * Note that it is unsafe to use fs.writeSync multiple times on the same file
      * without waiting for the callback.
-     * @param [ZenFS.node.Buffer] buffer Buffer containing the data to write to
+     * @param [ZenFS.node.Uint8Array] buffer Uint8Array containing the data to write to
      *  the file.
      * @param [Number] offset Offset in the buffer to start reading data from.
      * @param [Number] length The amount of bytes to write to the file.
@@ -363,10 +362,10 @@ export declare class PreloadFile<T extends FileSystem> extends BaseFile {
      *   the current position.
      * @return [Number]
      */
-    writeSync(buffer: Buffer, offset: number, length: number, position: number): number;
+    writeSync(buffer: Uint8Array, offset: number, length: number, position: number): number;
     /**
      * Read data from the file.
-     * @param [ZenFS.node.Buffer] buffer The buffer that the data will be
+     * @param [ZenFS.node.Uint8Array] buffer The buffer that the data will be
      *   written to.
      * @param [Number] offset The offset within the buffer where writing will
      *   start.
@@ -374,16 +373,16 @@ export declare class PreloadFile<T extends FileSystem> extends BaseFile {
      * @param [Number] 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.
-     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Buffer)] cb The
+     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Uint8Array)] cb The
      *   number is the number of bytes read
      */
-    read(buffer: Buffer, offset: number, length: number, position: number): Promise<{
+    read(buffer: Uint8Array, offset: number, length: number, position: number): Promise<{
         bytesRead: number;
-        buffer: Buffer;
+        buffer: Uint8Array;
     }>;
     /**
      * Read data from the file.
-     * @param [ZenFS.node.Buffer] buffer The buffer that the data will be
+     * @param [ZenFS.node.Uint8Array] buffer The buffer that the data will be
      *   written to.
      * @param [Number] offset The offset within the buffer where writing will
      *   start.
@@ -393,7 +392,7 @@ export declare class PreloadFile<T extends FileSystem> extends BaseFile {
      *   position.
      * @return [Number]
      */
-    readSync(buffer: Buffer, offset: number, length: number, position: number): number;
+    readSync(buffer: Uint8Array, offset: number, length: number, position: number): number;
     /**
      * Asynchronous `fchmod`.
      * @param [Number|String] mode
@@ -427,7 +426,7 @@ export declare class PreloadFile<T extends FileSystem> extends BaseFile {
  * Doesn't sync to anything, so it works nicely for memory-only files.
  */
 export declare class NoSyncFile<T extends FileSystem> extends PreloadFile<T> implements File {
-    constructor(_fs: T, _path: string, _flag: FileFlag, _stat: Stats, contents?: Buffer);
+    constructor(_fs: T, _path: string, _flag: FileFlag, _stat: Stats, contents?: Uint8Array);
     /**
      * Asynchronous sync. Doesn't do anything, simply calls the cb.
      * @param [Function(ZenFS.ApiError)] cb

package/dist/file.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { ApiError, ErrorCode } from './ApiError.js';
 import { Stats } from './stats.js';
 import { getMount } from './emulation/shared.js';
-import { Buffer } from 'buffer';
 export var ActionType;
 (function (ActionType) {
     // Indicates that the code should not do anything.
@@ -200,7 +199,7 @@ export class BaseFile {
 }
 /**
  * An implementation of the File interface that operates on a file that is
- * completely in-memory. PreloadFiles are backed by a Buffer.
+ * completely in-memory. PreloadFiles are backed by a Uint8Array.
  *
  * This is also an abstract class, as it lacks an implementation of 'sync' and
  * 'close'. Each filesystem that wishes to use this file representation must
@@ -230,13 +229,13 @@ export class PreloadFile extends BaseFile {
         this._path = _path;
         this._flag = _flag;
         this._stat = _stat;
-        this._buffer = contents ? contents : Buffer.alloc(0);
+        this._buffer = contents ? contents : new Uint8Array(0);
         // Note: This invariant is *not* maintained once the file starts getting
         // modified.
         // Note: Only actually matters if file is readable, as writeable modes may
         // truncate/append to file.
         if (this._stat.size !== this._buffer.length && this._flag.isReadable()) {
-            throw new Error(`Invalid buffer: Buffer is ${this._buffer.length} long, yet Stats object specifies that file is ${this._stat.size} long.`);
+            throw new Error(`Invalid buffer: Uint8Array is ${this._buffer.length} long, yet Stats object specifies that file is ${this._stat.size} long.`);
         }
     }
     /**
@@ -359,7 +358,7 @@ export class PreloadFile extends BaseFile {
         }
         this._stat.mtimeMs = Date.now();
         if (len > this._buffer.length) {
-            const buf = Buffer.alloc(len - this._buffer.length, 0);
+            const buf = new Uint8Array(len - this._buffer.length);
             // Write will set @_stat.size for us.
             this.writeSync(buf, 0, buf.length, this._buffer.length);
             if (this._flag.isSynchronous() && getMount('/').metadata.synchronous) {
@@ -369,9 +368,7 @@ export class PreloadFile extends BaseFile {
         }
         this._stat.size = len;
         // Truncate buffer to 'len'.
-        const newBuff = Buffer.alloc(len);
-        this._buffer.copy(newBuff, 0, 0, len);
-        this._buffer = newBuff;
+        this._buffer = this._buffer.subarray(0, len);
         if (this._flag.isSynchronous() && getMount('/').metadata.synchronous) {
             this.syncSync();
         }
@@ -380,14 +377,14 @@ export class PreloadFile extends BaseFile {
      * Write buffer to the file.
      * Note that it is unsafe to use fs.write multiple times on the same file
      * without waiting for the callback.
-     * @param [ZenFS.node.Buffer] buffer Buffer containing the data to write to
+     * @param [ZenFS.node.Uint8Array] buffer Uint8Array containing the data to write to
      *  the file.
      * @param [Number] offset Offset in the buffer to start reading data from.
      * @param [Number] length The amount of bytes to write to the file.
      * @param [Number] 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.
-     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Buffer)]
+     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Uint8Array)]
      *   cb The number specifies the number of bytes written into the file.
      */
     write(buffer, offset, length, position) {
@@ -399,7 +396,7 @@ export class PreloadFile extends BaseFile {
      * Write buffer to the file.
      * Note that it is unsafe to use fs.writeSync multiple times on the same file
      * without waiting for the callback.
-     * @param [ZenFS.node.Buffer] buffer Buffer containing the data to write to
+     * @param [ZenFS.node.Uint8Array] buffer Uint8Array containing the data to write to
      *  the file.
      * @param [Number] offset Offset in the buffer to start reading data from.
      * @param [Number] length The amount of bytes to write to the file.
@@ -421,12 +418,13 @@ export class PreloadFile extends BaseFile {
             this._stat.size = endFp;
             if (endFp > this._buffer.length) {
                 // Extend the buffer!
-                const newBuff = Buffer.alloc(endFp);
-                this._buffer.copy(newBuff);
-                this._buffer = newBuff;
+                const newBuffer = new Uint8Array(endFp);
+                newBuffer.set(this._buffer);
+                this._buffer = newBuffer;
             }
         }
-        const len = buffer.copy(this._buffer, position, offset, offset + length);
+        this._buffer.set(buffer.slice(offset, offset + length), position);
+        const len = this._buffer.length;
         this._stat.mtimeMs = Date.now();
         if (this._flag.isSynchronous()) {
             this.syncSync();
@@ -437,7 +435,7 @@ export class PreloadFile extends BaseFile {
     }
     /**
      * Read data from the file.
-     * @param [ZenFS.node.Buffer] buffer The buffer that the data will be
+     * @param [ZenFS.node.Uint8Array] buffer The buffer that the data will be
      *   written to.
      * @param [Number] offset The offset within the buffer where writing will
      *   start.
@@ -445,7 +443,7 @@ export class PreloadFile extends BaseFile {
      * @param [Number] 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.
-     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Buffer)] cb The
+     * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Uint8Array)] cb The
      *   number is the number of bytes read
      */
     read(buffer, offset, length, position) {
@@ -455,7 +453,7 @@ export class PreloadFile extends BaseFile {
     }
     /**
      * Read data from the file.
-     * @param [ZenFS.node.Buffer] buffer The buffer that the data will be
+     * @param [ZenFS.node.Uint8Array] buffer The buffer that the data will be
      *   written to.
      * @param [Number] offset The offset within the buffer where writing will
      *   start.
@@ -476,10 +474,10 @@ export class PreloadFile extends BaseFile {
         if (endRead > this._stat.size) {
             length = this._stat.size - position;
         }
-        const rv = this._buffer.copy(buffer, offset, position, position + length);
+        this._buffer.set(buffer.slice(offset, offset + length), position);
         this._stat.atimeMs = Date.now();
         this._pos = position + length;
-        return rv;
+        return this._buffer.length;
     }
     /**
      * Asynchronous `fchmod`.

package/dist/filesystem.d.ts

@@ -6,7 +6,7 @@ import { Cred } from './cred.js';
 export type BFSOneArgCallback = (e?: ApiError) => unknown;
 export type BFSCallback<T> = (e?: ApiError, rv?: T) => unknown;
 export type BFSThreeArgCallback<T, U> = (e?: ApiError, arg1?: T, arg2?: U) => unknown;
-export type FileContents = Buffer | string;
+export type FileContents = Uint8Array | string;
 /**
  * Metadata about a FileSystem
  */
@@ -181,7 +181,7 @@ export declare abstract class FileSystem {
      * Asynchronously reads the entire contents of a file.
      * @param encoding If non-null, the file's contents should be decoded
      *   into a string using that encoding. Otherwise, if encoding is null, fetch
-     *   the file's contents as a Buffer.
+     *   the file's contents as a Uint8Array.
      * If no encoding is specified, then the raw buffer is returned.
      */
     abstract readFile(fname: string, encoding: BufferEncoding | null, flag: FileFlag, cred: Cred): Promise<FileContents>;
@@ -189,7 +189,7 @@ export declare abstract class FileSystem {
      * Synchronously reads the entire contents of a file.
      * @param encoding If non-null, the file's contents should be decoded
      *   into a string using that encoding. Otherwise, if encoding is null, fetch
-     *   the file's contents as a Buffer.
+     *   the file's contents as a Uint8Array.
      */
     abstract readFileSync(fname: string, encoding: BufferEncoding | null, flag: FileFlag, cred: Cred): FileContents;
     /**

package/dist/filesystem.js

@@ -13,7 +13,7 @@ var _a;
 import { ApiError, ErrorCode } from './ApiError.js';
 import { FileFlag, ActionType } from './file.js';
 import * as path from './emulation/path.js';
-import { Buffer } from 'buffer';
+import { decode, encode } from './utils.js';
 /**
  * Structure for a filesystem. **All** ZenFS FileSystems must implement
  * this.
@@ -324,13 +324,13 @@ export class BaseFileSystem extends FileSystem {
             try {
                 const stat = yield fd.stat();
                 // Allocate buffer.
-                const buf = Buffer.alloc(stat.size);
+                const buf = new Uint8Array(stat.size);
                 yield fd.read(buf, 0, stat.size, 0);
                 yield fd.close();
                 if (encoding === null) {
                     return buf;
                 }
-                return buf.toString(encoding);
+                return decode(buf);
             }
             finally {
                 yield fd.close();
@@ -343,13 +343,13 @@ export class BaseFileSystem extends FileSystem {
         try {
             const stat = fd.statSync();
             // Allocate buffer.
-            const buf = Buffer.alloc(stat.size);
+            const buf = new Uint8Array(stat.size);
             fd.readSync(buf, 0, stat.size, 0);
             fd.closeSync();
             if (encoding === null) {
                 return buf;
             }
-            return buf.toString(encoding);
+            return decode(buf);
         }
         finally {
             fd.closeSync();
@@ -361,7 +361,7 @@ export class BaseFileSystem extends FileSystem {
             const fd = yield this.open(fname, flag, mode, cred);
             try {
                 if (typeof data === 'string') {
-                    data = Buffer.from(data, encoding);
+                    data = encode(data);
                 }
                 // Write into file.
                 yield fd.write(data, 0, data.length, 0);
@@ -376,7 +376,7 @@ export class BaseFileSystem extends FileSystem {
         const fd = this.openSync(fname, flag, mode, cred);
         try {
             if (typeof data === 'string') {
-                data = Buffer.from(data, encoding);
+                data = encode(data);
             }
             // Write into file.
             fd.writeSync(data, 0, data.length, 0);
@@ -390,7 +390,7 @@ export class BaseFileSystem extends FileSystem {
             const fd = yield this.open(fname, flag, mode, cred);
             try {
                 if (typeof data === 'string') {
-                    data = Buffer.from(data, encoding);
+                    data = encode(data);
                 }
                 yield fd.write(data, 0, data.length, null);
             }
@@ -403,7 +403,7 @@ export class BaseFileSystem extends FileSystem {
         const fd = this.openSync(fname, flag, mode, cred);
         try {
             if (typeof data === 'string') {
-                data = Buffer.from(data, encoding);
+                data = encode(data);
             }
             fd.writeSync(data, 0, data.length, null);
         }

package/dist/inode.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { Stats } from './stats.js';
 /**
  * Generic inode definition that can easily be serialized.
@@ -15,7 +14,7 @@ export default class Inode {
     /**
      * Converts the buffer into an Inode.
      */
-    static fromBuffer(buffer: Buffer): Inode;
+    static Deserialize(data: ArrayBufferLike | ArrayBufferView): Inode;
     constructor(id: string, size: number, mode: number, atime: number, mtime: number, ctime: number, uid: number, gid: number);
     /**
      * Handy function that converts the Inode to a Node Stats object.
@@ -28,7 +27,7 @@ export default class Inode {
     /**
      * Writes the inode into the start of the buffer.
      */
-    toBuffer(buff?: Buffer): Buffer;
+    serialize(data?: ArrayBufferLike | ArrayBufferView): Uint8Array;
     /**
      * Updates the Inode using information from the stats object. Used by file
      * systems at sync time, e.g.: