@zenfs/core 0.0.7 → 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/path.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { ParsedPath } from 'node:path';
+export declare const cwd = "/";
+export declare const sep = "/";
+export declare function normalizeString(path: string, allowAboveRoot: boolean): string;
+export declare function formatExt(ext: string): string;
+export declare function resolve(...args: string[]): string;
+export declare function normalize(path: string): string;
+export declare function isAbsolute(path: string): boolean;
+export declare function join(...args: string[]): string;
+export declare function relative(from: string, to: string): string;
+export declare function dirname(path: string): string;
+export declare function basename(path: string, suffix?: string): string;
+export declare function extname(path: string): string;
+export declare function format(pathObject: ParsedPath): string;
+export declare function parse(path: string): ParsedPath;

package/dist/emulation/path.js

@@ -0,0 +1,451 @@
+/*
+Copyright Joyent, Inc. and other Node contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+export const cwd = '/';
+export const sep = '/';
+function validateString(str, name) {
+    if (typeof str != 'string') {
+        throw new TypeError(`"${name}" is not a string`);
+    }
+}
+function validateObject(str, name) {
+    if (typeof str != 'object') {
+        throw new TypeError(`"${name}" is not an object`);
+    }
+}
+// Resolves . and .. elements in a path with directory names
+export function normalizeString(path, allowAboveRoot) {
+    let res = '';
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let char = '\x00';
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length) {
+            char = path[i];
+        }
+        else if (char == '/') {
+            break;
+        }
+        else {
+            char = '/';
+        }
+        if (char == '/') {
+            if (lastSlash === i - 1 || dots === 1) {
+                // NOOP
+            }
+            else if (dots === 2) {
+                if (res.length < 2 || lastSegmentLength !== 2 || res.at(-1) !== '.' || res.at(-2) !== '.') {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf('/');
+                        if (lastSlashIndex === -1) {
+                            res = '';
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length !== 0) {
+                        res = '';
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? '/..' : '..';
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0)
+                    res += '/' + path.slice(lastSlash + 1, i);
+                else
+                    res = path.slice(lastSlash + 1, i);
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (char === '.' && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+export function formatExt(ext) {
+    return ext ? `${ext[0] === '.' ? '' : '.'}${ext}` : '';
+}
+export function resolve(...args) {
+    let resolvedPath = '';
+    let resolvedAbsolute = false;
+    for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        const path = i >= 0 ? args[i] : cwd;
+        validateString(path, `paths[${i}]`);
+        // Skip empty entries
+        if (path.length === 0) {
+            continue;
+        }
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = path[0] === '/';
+    }
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+    // Normalize the path
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+        return `/${resolvedPath}`;
+    }
+    return resolvedPath.length > 0 ? resolvedPath : '.';
+}
+export function normalize(path) {
+    validateString(path, 'path');
+    if (path.length === 0)
+        return '.';
+    const isAbsolute = path[0] === '/';
+    const trailingSeparator = path.at(-1) === '/';
+    // Normalize the path
+    path = normalizeString(path, !isAbsolute);
+    if (path.length === 0) {
+        if (isAbsolute)
+            return '/';
+        return trailingSeparator ? './' : '.';
+    }
+    if (trailingSeparator)
+        path += '/';
+    return isAbsolute ? `/${path}` : path;
+}
+export function isAbsolute(path) {
+    validateString(path, 'path');
+    return path.length > 0 && path[0] === '/';
+}
+export function join(...args) {
+    if (args.length === 0)
+        return '.';
+    let joined;
+    for (let i = 0; i < args.length; ++i) {
+        const arg = args[i];
+        validateString(arg, 'path');
+        if (arg.length > 0) {
+            if (joined === undefined)
+                joined = arg;
+            else
+                joined += `/${arg}`;
+        }
+    }
+    if (joined === undefined)
+        return '.';
+    return normalize(joined);
+}
+export function relative(from, to) {
+    validateString(from, 'from');
+    validateString(to, 'to');
+    if (from === to)
+        return '';
+    // Trim leading forward slashes.
+    from = resolve(from);
+    to = resolve(to);
+    if (from === to)
+        return '';
+    const fromStart = 1;
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    const toStart = 1;
+    const toLen = to.length - toStart;
+    // Compare paths to find the longest common path from root
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i < length; i++) {
+        const fromCode = from[fromStart + i];
+        if (fromCode !== to[toStart + i])
+            break;
+        else if (fromCode === '/')
+            lastCommonSep = i;
+    }
+    if (i === length) {
+        if (toLen > length) {
+            if (to[toStart + i] === '/') {
+                // We get here if `from` is the exact base path for `to`.
+                // For example: from='/foo/bar'; to='/foo/bar/baz'
+                return to.slice(toStart + i + 1);
+            }
+            if (i === 0) {
+                // We get here if `from` is the root
+                // For example: from='/'; to='/foo'
+                return to.slice(toStart + i);
+            }
+        }
+        else if (fromLen > length) {
+            if (from[fromStart + i] === '/') {
+                // We get here if `to` is the exact base path for `from`.
+                // For example: from='/foo/bar/baz'; to='/foo/bar'
+                lastCommonSep = i;
+            }
+            else if (i === 0) {
+                // We get here if `to` is the root.
+                // For example: from='/foo/bar'; to='/'
+                lastCommonSep = 0;
+            }
+        }
+    }
+    let out = '';
+    // Generate the relative path based on the path difference between `to`
+    // and `from`.
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+        if (i === fromEnd || from[i] === '/') {
+            out += out.length === 0 ? '..' : '/..';
+        }
+    }
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts.
+    return `${out}${to.slice(toStart + lastCommonSep)}`;
+}
+export function dirname(path) {
+    validateString(path, 'path');
+    if (path.length === 0)
+        return '.';
+    const hasRoot = path[0] === '/';
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1; i >= 1; --i) {
+        if (path[i] === '/') {
+            if (!matchedSlash) {
+                end = i;
+                break;
+            }
+        }
+        else {
+            // We saw the first non-path separator
+            matchedSlash = false;
+        }
+    }
+    if (end === -1)
+        return hasRoot ? '/' : '.';
+    if (hasRoot && end === 1)
+        return '//';
+    return path.slice(0, end);
+}
+export function basename(path, suffix) {
+    if (suffix !== undefined)
+        validateString(suffix, 'ext');
+    validateString(path, 'path');
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+    if (suffix !== undefined && suffix.length > 0 && suffix.length <= path.length) {
+        if (suffix === path)
+            return '';
+        let extIdx = suffix.length - 1;
+        let firstNonSlashEnd = -1;
+        for (let i = path.length - 1; i >= 0; --i) {
+            if (path[i] === '/') {
+                // If we reached a path separator that was not part of a set of path
+                // separators at the end of the string, stop now
+                if (!matchedSlash) {
+                    start = i + 1;
+                    break;
+                }
+            }
+            else {
+                if (firstNonSlashEnd === -1) {
+                    // We saw the first non-path separator, remember this index in case
+                    // we need it if the extension ends up not matching
+                    matchedSlash = false;
+                    firstNonSlashEnd = i + 1;
+                }
+                if (extIdx >= 0) {
+                    // Try to match the explicit extension
+                    if (path[i] === suffix[extIdx]) {
+                        if (--extIdx === -1) {
+                            // We matched the extension, so mark this as the end of our path
+                            // component
+                            end = i;
+                        }
+                    }
+                    else {
+                        // Extension does not match, so our result is the entire path
+                        // component
+                        extIdx = -1;
+                        end = firstNonSlashEnd;
+                    }
+                }
+            }
+        }
+        if (start === end)
+            end = firstNonSlashEnd;
+        else if (end === -1)
+            end = path.length;
+        return path.slice(start, end);
+    }
+    for (let i = path.length - 1; i >= 0; --i) {
+        if (path[i] === '/') {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // path component
+            matchedSlash = false;
+            end = i + 1;
+        }
+    }
+    if (end === -1)
+        return '';
+    return path.slice(start, end);
+}
+export function extname(path) {
+    validateString(path, 'path');
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    for (let i = path.length - 1; i >= 0; --i) {
+        if (path[i] === '/') {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // extension
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (path[i] === '.') {
+            // If this is our first dot, mark it as the start of our extension
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            // We saw a non-dot and non-path separator before our dot, so we should
+            // have a good chance at having a non-empty extension
+            preDotState = -1;
+        }
+    }
+    if (startDot === -1 ||
+        end === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+        return '';
+    }
+    return path.slice(startDot, end);
+}
+export function format(pathObject) {
+    validateObject(pathObject, 'pathObject');
+    const dir = pathObject.dir || pathObject.root;
+    const base = pathObject.base || `${pathObject.name || ''}${formatExt(pathObject.ext)}`;
+    if (!dir) {
+        return base;
+    }
+    return dir === pathObject.root ? `${dir}${base}` : `${dir}/${base}`;
+}
+export function parse(path) {
+    validateString(path, 'path');
+    const isAbsolute = path[0] === '/';
+    const ret = { root: isAbsolute ? '/' : '', dir: '', base: '', ext: '', name: '' };
+    if (path.length === 0)
+        return ret;
+    const start = isAbsolute ? 1 : 0;
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    // Get non-dir info
+    for (; i >= start; --i) {
+        if (path[i] === '/') {
+            // If we reached a path separator that was not part of a set of path
+            // separators at the end of the string, stop now
+            if (!matchedSlash) {
+                startPart = i + 1;
+                break;
+            }
+            continue;
+        }
+        if (end === -1) {
+            // We saw the first non-path separator, mark this as the end of our
+            // extension
+            matchedSlash = false;
+            end = i + 1;
+        }
+        if (path[i] === '.') {
+            // If this is our first dot, mark it as the start of our extension
+            if (startDot === -1)
+                startDot = i;
+            else if (preDotState !== 1)
+                preDotState = 1;
+        }
+        else if (startDot !== -1) {
+            // We saw a non-dot and non-path separator before our dot, so we should
+            // have a good chance at having a non-empty extension
+            preDotState = -1;
+        }
+    }
+    if (end !== -1) {
+        const start = startPart === 0 && isAbsolute ? 1 : startPart;
+        if (startDot === -1 ||
+            // We saw a non-dot character immediately before the dot
+            preDotState === 0 ||
+            // The (right-most) trimmed path component is exactly '..'
+            (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)) {
+            ret.base = ret.name = path.slice(start, end);
+        }
+        else {
+            ret.name = path.slice(start, startDot);
+            ret.base = path.slice(start, end);
+            ret.ext = path.slice(startDot, end);
+        }
+    }
+    if (startPart > 0)
+        ret.dir = path.slice(0, startPart - 1);
+    else if (isAbsolute)
+        ret.dir = '/';
+    return ret;
+}

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/shared.js

@@ -1,5 +1,5 @@
 // Utilities and shared data
-import { posix as path } from 'path';
+import { resolve } from './path.js';
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { Cred } from '../cred.js';
 //import { BackendConstructor } from '../backends.js';
@@ -52,7 +52,7 @@ export function normalizePath(p) {
         throw new ApiError(ErrorCode.EINVAL, 'Path must not be empty.');
     }
     p = p.replaceAll(/\/+/g, '/');
-    return path.resolve(p);
+    return resolve(p);
 }
 export function normalizeOptions(options, defEnc, defFlag, defMode) {
     // typeof null === 'object' so special-case handing is needed.
@@ -129,7 +129,7 @@ export function mount(mountPoint, fs) {
     if (mountPoint[0] !== '/') {
         mountPoint = '/' + mountPoint;
     }
-    mountPoint = path.resolve(mountPoint);
+    mountPoint = resolve(mountPoint);
     if (mounts.has(mountPoint)) {
         throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
     }
@@ -142,7 +142,7 @@ export function umount(mountPoint) {
     if (mountPoint[0] !== '/') {
         mountPoint = `/${mountPoint}`;
     }
-    mountPoint = path.resolve(mountPoint);
+    mountPoint = resolve(mountPoint);
     if (!mounts.has(mountPoint)) {
         throw new ApiError(ErrorCode.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
     }

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