@zenfs/core 0.0.7 → 0.0.9

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

@@ -12,8 +12,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a;
 import { ApiError, ErrorCode } from './ApiError.js';
 import { FileFlag, ActionType } from './file.js';
-import * as path from 'path';
-import { Buffer } from 'buffer';
+import * as path from './emulation/path.js';
+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.:

package/dist/inode.js

@@ -1,5 +1,5 @@
 import { Stats, FileType } from './stats.js';
-import { Buffer } from 'buffer';
+import { decode, encode } from './utils.js';
 /**
  * Generic inode definition that can easily be serialized.
  */
@@ -7,11 +7,9 @@ export default class Inode {
     /**
      * Converts the buffer into an Inode.
      */
-    static fromBuffer(buffer) {
-        if (buffer === undefined) {
-            throw new Error('NO');
-        }
-        return new Inode(buffer.toString('ascii', 38), buffer.readUInt32LE(0), buffer.readUInt16LE(4), buffer.readDoubleLE(6), buffer.readDoubleLE(14), buffer.readDoubleLE(22), buffer.readUInt32LE(30), buffer.readUInt32LE(34));
+    static Deserialize(data) {
+        const view = new DataView('buffer' in data ? data.buffer : data);
+        return new Inode(decode(view.buffer.slice(38)), view.getUint32(0, true), view.getUint16(4, true), view.getFloat64(6, true), view.getFloat64(14, true), view.getFloat64(22, true), view.getUint32(30, true), view.getUint32(34, true));
     }
     constructor(id, size, mode, atime, mtime, ctime, uid, gid) {
         this.id = id;
@@ -33,22 +31,24 @@ export default class Inode {
      * Get the size of this Inode, in bytes.
      */
     getSize() {
-        // ASSUMPTION: ID is ASCII (1 byte per char).
+        // ASSUMPTION: ID is 1 byte per char.
         return 38 + this.id.length;
     }
     /**
      * Writes the inode into the start of the buffer.
      */
-    toBuffer(buff = Buffer.alloc(this.getSize())) {
-        buff.writeUInt32LE(this.size, 0);
-        buff.writeUInt16LE(this.mode, 4);
-        buff.writeDoubleLE(this.atime, 6);
-        buff.writeDoubleLE(this.mtime, 14);
-        buff.writeDoubleLE(this.ctime, 22);
-        buff.writeUInt32LE(this.uid, 30);
-        buff.writeUInt32LE(this.gid, 34);
-        buff.write(this.id, 38, this.id.length, 'ascii');
-        return buff;
+    serialize(data = new Uint8Array(this.getSize())) {
+        const view = new DataView('buffer' in data ? data.buffer : data);
+        view.setUint32(0, this.size, true);
+        view.setUint16(4, this.mode, true);
+        view.setFloat64(6, this.atime, true);
+        view.setFloat64(14, this.mtime, true);
+        view.setFloat64(22, this.ctime, true);
+        view.setUint32(30, this.uid, true);
+        view.setUint32(34, this.gid, true);
+        const buffer = new Uint8Array(view.buffer);
+        buffer.set(encode(this.id), 38);
+        return buffer;
     }
     /**
      * Updates the Inode using information from the stats object. Used by file

package/dist/stats.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
 import type { StatsBase } from 'fs';
 import { Cred } from './cred.js';
 /**
@@ -18,7 +17,7 @@ export declare enum FileType {
  * @see http://man7.org/linux/man-pages/man2/stat.2.html
  */
 export declare class Stats implements StatsBase<number> {
-    static fromBuffer(buffer: Buffer): Stats;
+    static Deserialize(data: ArrayBufferLike | ArrayBufferView): Stats;
     /**
      * Clones the stats object.
      */
@@ -32,7 +31,7 @@ export declare class Stats implements StatsBase<number> {
     blksize: number;
     uid: number;
     gid: number;
-    fileData: Buffer | null;
+    fileData: Uint8Array | null;
     atimeMs: number;
     mtimeMs: number;
     ctimeMs: number;
@@ -56,7 +55,7 @@ export declare class Stats implements StatsBase<number> {
      * @param birthtimeMs time of file creation, in milliseconds since epoch
      */
     constructor(itemType: FileType, size: number, mode?: number, atimeMs?: number, mtimeMs?: number, ctimeMs?: number, uid?: number, gid?: number, birthtimeMs?: number);
-    toBuffer(): Buffer;
+    serialize(): Uint8Array;
     /**
      * @return [Boolean] True if this item is a file.
      */

package/dist/stats.js

@@ -1,5 +1,4 @@
 import { Cred } from './cred.js';
-import { Buffer } from 'buffer';
 import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG } from './emulation/constants.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
@@ -18,8 +17,9 @@ export var FileType;
  * @see http://man7.org/linux/man-pages/man2/stat.2.html
  */
 export class Stats {
-    static fromBuffer(buffer) {
-        const size = buffer.readUInt32LE(0), mode = buffer.readUInt32LE(4), atime = buffer.readDoubleLE(8), mtime = buffer.readDoubleLE(16), ctime = buffer.readDoubleLE(24), uid = buffer.readUInt32LE(32), gid = buffer.readUInt32LE(36);
+    static Deserialize(data) {
+        const view = new DataView('buffer' in data ? data.buffer : data);
+        const size = view.getUint32(0, true), mode = view.getUint32(4, true), atime = view.getFloat64(8, true), mtime = view.getFloat64(16, true), ctime = view.getFloat64(24, true), uid = view.getUint32(32, true), gid = view.getUint32(36, true);
         return new Stats(mode & S_IFMT, size, mode & ~S_IFMT, atime, mtime, ctime, uid, gid);
     }
     /**
@@ -125,16 +125,16 @@ export class Stats {
             this.mode |= itemType;
         }
     }
-    toBuffer() {
-        const buffer = Buffer.alloc(32);
-        buffer.writeUInt32LE(this.size, 0);
-        buffer.writeUInt32LE(this.mode, 4);
-        buffer.writeDoubleLE(this.atime.getTime(), 8);
-        buffer.writeDoubleLE(this.mtime.getTime(), 16);
-        buffer.writeDoubleLE(this.ctime.getTime(), 24);
-        buffer.writeUInt32LE(this.uid, 32);
-        buffer.writeUInt32LE(this.gid, 36);
-        return buffer;
+    serialize() {
+        const data = new Uint8Array(32), view = new DataView(data.buffer);
+        view.setUint32(0, this.size, true);
+        view.setUint32(4, this.mode, true);
+        view.setFloat64(8, this.atime.getTime(), true);
+        view.setFloat64(16, this.mtime.getTime(), true);
+        view.setFloat64(24, this.ctime.getTime(), true);
+        view.setUint32(32, this.uid, true);
+        view.setUint32(36, this.gid, true);
+        return data;
     }
     /**
      * @return [Boolean] True if this item is a file.

package/dist/utils.d.ts

@@ -1,10 +1,12 @@
 /// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 /**
  * Grab bag of utility functions used across the code.
  */
 import { FileSystem } from './filesystem.js';
 import { Cred } from './cred.js';
 import type { BaseBackendConstructor } from './backends/backend.js';
+import type { TextEncoder as TextEncoderType, TextDecoder as TextDecoderType } from 'node:util';
 /**
  * Synchronous recursive makedir.
  * @internal
@@ -30,11 +32,14 @@ export declare const setImmediate: typeof globalThis.setImmediate | ((cb: any) =
  * @internal
  */
 export declare const ROOT_NODE_ID: string;
-/**
- * Returns an empty directory node.
- * @internal
- */
-export declare function getEmptyDirNode(): Buffer;
+declare global {
+    const TextEncoder: typeof TextEncoderType;
+    const TextDecoder: typeof TextDecoderType;
+}
+export declare const encode: (input?: string) => Uint8Array;
+export declare const decode: (input?: ArrayBuffer | NodeJS.ArrayBufferView, options?: {
+    stream?: boolean;
+}) => string;
 /**
  * Generates a random ID.
  * @internal

package/dist/utils.js

@@ -8,8 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ErrorCode, ApiError } from './ApiError.js';
-import * as path from 'path';
-import { Buffer } from 'buffer';
+import * as path from './emulation/path.js';
 /**
  * Synchronous recursive makedir.
  * @internal
@@ -213,13 +212,8 @@ export const setImmediate = typeof globalThis.setImmediate == 'function' ? globa
  * @internal
  */
 export const ROOT_NODE_ID = '/';
-/**
- * Returns an empty directory node.
- * @internal
- */
-export function getEmptyDirNode() {
-    return Buffer.from('{}');
-}
+export const encode = new TextEncoder().encode;
+export const decode = new TextDecoder().decode;
 /**
  * Generates a random ID.
  * @internal