@zenfs/core 0.5.5 → 0.5.7

package/dist/emulation/shared.d.ts

@@ -3,7 +3,7 @@
 import { Cred } from '../cred.js';
 import { FileSystem } from '../filesystem.js';
 import type { File } from '../file.js';
-import type { BaseEncodingOptions, OpenMode, WriteFileOptions } from 'node:fs';
+import type { EncodingOption, OpenMode, WriteFileOptions } from 'node:fs';
 /**
  * converts Date or number to a integer UNIX timestamp
  * Grabbed from NodeJS sources (lib/fs.js)
@@ -34,7 +34,7 @@ export declare function normalizePath(p: string): string;
  * @param mode default mode
  * @internal
  */
-export declare function normalizeOptions(options?: WriteFileOptions | (BaseEncodingOptions & {
+export declare function normalizeOptions(options?: WriteFileOptions | (EncodingOption & {
     flag?: OpenMode;
 }), encoding?: BufferEncoding, flag?: string, mode?: number): {
     encoding: BufferEncoding;
@@ -91,12 +91,3 @@ export declare function initialize(mountMapping: MountMapping): void;
  * In the future, maybe support URL?
  */
 export type PathLike = string;
-/**
- * @internal
- *
- * Recursivly converts `From` in `Target` to `To`
- */
-export type Convert<Target, From, To> = Target extends From ? To : Target extends (...args: any[]) => unknown ? (...args: Convert<Parameters<Target>, From, To> & Array<unknown>) => Convert<ReturnType<Target>, From, To> : Target extends object ? {
-    [K in keyof Target]: Convert<Target[K], From, To>;
-} : Target;
-export type BufferToUint8Array<T> = Convert<T, Buffer, Uint8Array>;

package/dist/emulation/streams.d.ts

@@ -67,6 +67,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     addListener(event: 'pipe', listener: (src: Readable) => void): this;
     addListener(event: 'ready', listener: () => void): this;
     addListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
     on(event: 'close', listener: () => void): this;
     on(event: 'drain', listener: () => void): this;
     on(event: 'error', listener: (err: Error) => void): this;
@@ -75,6 +76,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     on(event: 'pipe', listener: (src: Readable) => void): this;
     on(event: 'ready', listener: () => void): this;
     on(event: 'unpipe', listener: (src: Readable) => void): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
     once(event: 'close', listener: () => void): this;
     once(event: 'drain', listener: () => void): this;
     once(event: 'error', listener: (err: Error) => void): this;
@@ -83,6 +85,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     once(event: 'pipe', listener: (src: Readable) => void): this;
     once(event: 'ready', listener: () => void): this;
     once(event: 'unpipe', listener: (src: Readable) => void): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
     prependListener(event: 'close', listener: () => void): this;
     prependListener(event: 'drain', listener: () => void): this;
     prependListener(event: 'error', listener: (err: Error) => void): this;
@@ -91,6 +94,7 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     prependListener(event: 'pipe', listener: (src: Readable) => void): this;
     prependListener(event: 'ready', listener: () => void): this;
     prependListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
     prependOnceListener(event: 'close', listener: () => void): this;
     prependOnceListener(event: 'drain', listener: () => void): this;
     prependOnceListener(event: 'error', listener: (err: Error) => void): this;
@@ -99,4 +103,5 @@ export declare class WriteStream extends Writable implements Node.WriteStream {
     prependOnceListener(event: 'pipe', listener: (src: Readable) => void): this;
     prependOnceListener(event: 'ready', listener: () => void): this;
     prependOnceListener(event: 'unpipe', listener: (src: Readable) => void): this;
+    prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
 }

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,8 +75,8 @@ 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: (Node.BaseEncodingOptions & {
+}): Buffer;
+export declare function readFileSync(filename: string, options: (Node.EncodingOption & {
     flag?: string;
 }) | BufferEncoding): string;
 /**
@@ -104,7 +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, arg3?: Node.WriteFileOptions): 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
@@ -216,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[];
@@ -237,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
@@ -287,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]) {
@@ -179,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;
 /**
@@ -207,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');
     }
@@ -238,8 +237,8 @@ function _appendFileSync(fname, data, flag, mode, resolveSymlinks) {
  * @option options mode Defaults to `0644`.
  * @option options flag Defaults to `'a'`.
  */
-export function appendFileSync(filename, data, arg3) {
-    const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
+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.');
@@ -247,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;
@@ -300,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 {
@@ -319,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);
@@ -396,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;
     });
@@ -432,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
@@ -519,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) {
@@ -539,27 +540,54 @@ export function accessSync(path, mode = 0o600) {
     }
 }
 accessSync;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * @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');
+}
+/* eslint-enable @typescript-eslint/no-unused-vars */

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 {
@@ -122,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.
@@ -135,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`.
      *
@@ -302,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;
     }>;
@@ -317,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

@@ -379,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;
     }
     /**

package/dist/stats.d.ts

@@ -201,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

@@ -235,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

package/dist/utils.js

@@ -97,109 +97,23 @@ export const setImmediate = typeof globalThis.setImmediate == 'function' ? globa
  * Encodes a string into a buffer
  * @internal
  */
-export function encode(input, encoding = 'utf8') {
+export function encode(input) {
     if (typeof input != 'string') {
         throw new ApiError(ErrorCode.EINVAL, 'Can not encode a non-string');
     }
-    switch (encoding) {
-        case 'ascii':
-            return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0) & 0x7f));
-        case 'latin1':
-        case 'binary':
-            return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0)));
-        case 'utf8':
-        case 'utf-8':
-            return new Uint8Array(Array.from(input).flatMap(char => {
-                const code = char.charCodeAt(0);
-                if (code < 0x80) {
-                    return code;
-                }
-                const a = (code & 0x3f) | 0x80;
-                if (code < 0x800) {
-                    return [(code >> 6) | 0xc0, a];
-                }
-                const b = ((code >> 6) & 0x3f) | 0x80;
-                if (code < 0x10000) {
-                    return [(code >> 12) | 0xe0, b, a];
-                }
-                return [(code >> 18) | 0xf0, ((code >> 12) & 0x3f) | 0x80, b, a];
-            }));
-        case 'base64':
-            return encode(atob(input), 'binary');
-        case 'base64url':
-            return encode(input.replace('_', '/').replace('-', '+'), 'base64');
-        case 'hex':
-            return new Uint8Array(input.match(/.{1,2}/g).map(e => parseInt(e, 16)));
-        case 'utf16le':
-        case 'ucs2':
-        case 'ucs-2':
-            const u16 = new Uint16Array(new ArrayBuffer(input.length * 2));
-            for (let i = 0; i < input.length; i++) {
-                u16[i] = input.charCodeAt(i);
-            }
-            return new Uint8Array(u16.buffer);
-        default:
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid encoding: ' + encoding);
-    }
+    return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0)));
 }
 /**
  * Decodes a string from a buffer
  * @internal
  */
-export function decode(input, encoding = 'utf8') {
+export function decode(input) {
     if (!(input instanceof Uint8Array)) {
         throw new ApiError(ErrorCode.EINVAL, 'Can not decode a non-Uint8Array');
     }
-    switch (encoding) {
-        case 'ascii':
-            return Array.from(input)
-                .map(char => String.fromCharCode(char & 0x7f))
-                .join('');
-        case 'latin1':
-        case 'binary':
-            return Array.from(input)
-                .map(char => String.fromCharCode(char))
-                .join('');
-        case 'utf8':
-        case 'utf-8':
-            let utf8String = '';
-            for (let i = 0; i < input.length; i++) {
-                let code;
-                if (input[i] < 0x80) {
-                    code = input[i];
-                }
-                else if (input[i] < 0xe0) {
-                    code = ((input[i] & 0x1f) << 6) | (input[++i] & 0x3f);
-                }
-                else if (input[i] < 0xf0) {
-                    code = ((input[i] & 0x0f) << 12) | ((input[++i] & 0x3f) << 6) | (input[++i] & 0x3f);
-                }
-                else {
-                    code = ((input[i] & 0x07) << 18) | ((input[++i] & 0x3f) << 12) | ((input[++i] & 0x3f) << 6) | (input[++i] & 0x3f);
-                }
-                utf8String += String.fromCharCode(code);
-            }
-            return utf8String;
-        case 'utf16le':
-        case 'ucs2':
-        case 'ucs-2':
-            let utf16leString = '';
-            for (let i = 0; i < input.length; i += 2) {
-                const code = input[i] | (input[i + 1] << 8);
-                utf16leString += String.fromCharCode(code);
-            }
-            return utf16leString;
-        case 'base64':
-            return btoa(decode(input, 'binary'));
-        case 'base64url':
-            return decode(input, 'base64').replace('/', '_').replace('+', '-');
-        case 'hex':
-            return Array.from(input)
-                .map(e => e.toString(16).padStart(2, '0'))
-                .join('');
-        default:
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid encoding: ' + encoding);
-    }
+    return Array.from(input)
+        .map(char => String.fromCharCode(char))
+        .join('');
 }
 /**
  * Decodes a directory listing