@zenfs/core 1.11.4 → 2.1.0

package/dist/utils.js

@@ -1,56 +1,6 @@
-import { Errno, ErrnoError } from './internal/error.js';
-import { log_deprecated } from './internal/log.js';
-import { resolve } from './vfs/path.js';
-/**
- * Encodes a string into a buffer
- * @internal
- */
-export function encodeRaw(input) {
-    if (typeof input != 'string') {
-        throw new ErrnoError(Errno.EINVAL, 'Can not encode a non-string');
-    }
-    return new Uint8Array(Array.from(input).map(char => char.charCodeAt(0)));
-}
-/**
- * Decodes a string from a buffer
- * @internal
- */
-export function decodeRaw(input) {
-    if (!(input instanceof Uint8Array)) {
-        throw new ErrnoError(Errno.EINVAL, 'Can not decode a non-Uint8Array');
-    }
-    return Array.from(input)
-        .map(char => String.fromCharCode(char))
-        .join('');
-}
-const encoder = new TextEncoder();
-/**
- * Encodes a string into a buffer
- * @internal
- */
-export function encodeUTF8(input) {
-    if (typeof input != 'string') {
-        throw new ErrnoError(Errno.EINVAL, 'Can not encode a non-string');
-    }
-    return encoder.encode(input);
-}
-/* node:coverage disable */
-export { /** @deprecated @hidden */ encodeUTF8 as encode };
-/* node:coverage enable */
-const decoder = new TextDecoder();
-/**
- * Decodes a string from a buffer
- * @internal
- */
-export function decodeUTF8(input) {
-    if (!(input instanceof Uint8Array)) {
-        throw new ErrnoError(Errno.EINVAL, 'Can not decode a non-Uint8Array');
-    }
-    return decoder.decode(input);
-}
-/* node:coverage disable */
-export { /** @deprecated @hidden */ decodeUTF8 as decode };
-/* node:coverage enable */
+import { withErrno } from 'kerium';
+import { decodeUTF8, encodeUTF8 } from 'utilium';
+import { resolve } from './path.js';
 /**
  * Decodes a directory listing
  * @hidden
@@ -81,7 +31,7 @@ export function normalizeMode(mode, def) {
     }
     if (typeof def == 'number')
         return def;
-    throw new ErrnoError(Errno.EINVAL, 'Invalid mode: ' + (mode === null || mode === void 0 ? void 0 : mode.toString()));
+    throw withErrno('EINVAL', 'Invalid mode: ' + (mode === null || mode === void 0 ? void 0 : mode.toString()));
 }
 /**
  * Normalizes a time
@@ -94,9 +44,15 @@ export function normalizeTime(time) {
         return Number(time);
     }
     catch {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid time.');
+        throw withErrno('EINVAL', 'Invalid time.');
     }
 }
+/**
+ * TypeScript is dumb, so we need to assert the type of a value sometimes.
+ * For example, after calling `normalizePath`, TS still thinks the type is `PathLike` and not `string`.
+ * @internal @hidden
+ */
+export function __assertType(value) { }
 /**
  * Normalizes a path
  * @internal
@@ -104,19 +60,18 @@ export function normalizeTime(time) {
 export function normalizePath(p, noResolve = false) {
     if (p instanceof URL) {
         if (p.protocol != 'file:')
-            throw new ErrnoError(Errno.EINVAL, 'URLs must use the file: protocol');
+            throw withErrno('EINVAL', 'URLs must use the file: protocol');
         p = p.pathname;
     }
     p = p.toString();
     if (p.startsWith('file://'))
         p = p.slice('file://'.length);
-    if (p.includes('\x00')) {
-        throw new ErrnoError(Errno.EINVAL, 'Path can not contain null character');
-    }
-    if (p.length == 0) {
-        throw new ErrnoError(Errno.EINVAL, 'Path can not be empty');
-    }
+    if (p.includes('\x00'))
+        throw withErrno('EINVAL', 'Path can not contain null character');
+    if (p.length == 0)
+        throw withErrno('EINVAL', 'Path can not be empty');
     p = p.replaceAll(/[/\\]+/g, '/');
+    // Note: PWD is not resolved here, it is resolved later.
     return noResolve ? p : resolve(p);
 }
 /**
@@ -141,26 +96,3 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
         mode: normalizeMode('mode' in options ? options === null || options === void 0 ? void 0 : options.mode : null, mode),
     };
 }
-/* node:coverage disable */
-import { randomHex } from 'utilium';
-/**
- * Generate a random ino
- * @internal @deprecated @hidden
- */
-export function randomBigInt() {
-    log_deprecated('randomBigInt');
-    return BigInt('0x' + randomHex(8));
-}
-/**
- * Prevents infinite loops
- * @internal
- * @deprecated Use `canary` from Utilium
- */
-export function canary(path, syscall) {
-    log_deprecated('canary');
-    const timeout = setTimeout(() => {
-        throw ErrnoError.With('EDEADLK', path, syscall);
-    }, 5000);
-    return () => clearTimeout(timeout);
-}
-/* node:coverage enable */

package/dist/vfs/acl.d.ts

@@ -0,0 +1,42 @@
+import { BufferView } from 'utilium/buffer.js';
+import { type V_Context } from '../internal/contexts.js';
+import { type InodeLike } from '../internal/inode.js';
+export declare const enum Type {
+    Access = 32768,
+    Default = 16384
+}
+export declare const enum Tag {
+    UserObj = 1,
+    User = 2,
+    GroupObj = 4,
+    Group = 8,
+    Mask = 16,
+    Other = 32,
+    /**
+     * @internal @hidden
+     */
+    _None = 0
+}
+export declare class Entry extends BufferView {
+    accessor tag: Tag;
+    accessor perm: number;
+    accessor id: number;
+}
+export declare class ACL extends BufferView {
+    accessor version: number;
+    entries: Entry[];
+    constructor(...args: ConstructorParameters<typeof BufferView>);
+}
+export declare function fromMode(mode: number): ACL;
+export declare function toMode(acl: ACL): number;
+export declare function get($: V_Context, path: string): Promise<ACL>;
+export declare function getSync($: V_Context, path: string): ACL;
+export declare function set($: V_Context, path: string, acl: ACL): Promise<void>;
+export declare function setSync($: V_Context, path: string, acl: ACL): void;
+export declare let shouldCheck: boolean;
+export declare function setChecks(enabled: boolean): void;
+/**
+ * Checks if a given user/group has access to this item
+ * @param access The requested access, combination of `W_OK`, `R_OK`, and `X_OK`
+ */
+export declare function check($: V_Context, inode: InodeLike, access: number): boolean;

package/dist/vfs/acl.js

@@ -0,0 +1,268 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+/*
+    Access Control Lists.
+    At the moment, they are only intended for internal use.
+    They also are not checked for permissions yet.
+    Please use a namespace import for the best experience.
+*/
+import { withErrno } from 'kerium';
+import { err } from 'kerium/log';
+import { packed, sizeof, struct, types as t } from 'memium';
+import { BufferView } from 'utilium/buffer.js';
+import { defaultContext } from '../internal/contexts.js';
+import { Attributes } from '../internal/inode.js';
+import { R_OK, S_IRWXG, S_IRWXO, S_IRWXU, W_OK, X_OK } from './constants.js';
+import * as xattr from './xattr.js';
+const version = 2;
+export var Type;
+(function (Type) {
+    Type[Type["Access"] = 32768] = "Access";
+    Type[Type["Default"] = 16384] = "Default";
+})(Type || (Type = {}));
+export var Tag;
+(function (Tag) {
+    Tag[Tag["UserObj"] = 1] = "UserObj";
+    Tag[Tag["User"] = 2] = "User";
+    Tag[Tag["GroupObj"] = 4] = "GroupObj";
+    Tag[Tag["Group"] = 8] = "Group";
+    Tag[Tag["Mask"] = 16] = "Mask";
+    Tag[Tag["Other"] = 32] = "Other";
+    /**
+     * @internal @hidden
+     */
+    Tag[Tag["_None"] = 0] = "_None";
+})(Tag || (Tag = {}));
+let Entry = (() => {
+    var _Entry_tag_accessor_storage, _Entry_perm_accessor_storage, _Entry_id_accessor_storage;
+    var _a, _b, _c;
+    let _classDecorators = [struct(packed)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = BufferView;
+    let _tag_decorators;
+    let _tag_initializers = [];
+    let _tag_extraInitializers = [];
+    let _perm_decorators;
+    let _perm_initializers = [];
+    let _perm_extraInitializers = [];
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    var Entry = _classThis = class extends _classSuper {
+        get tag() { return __classPrivateFieldGet(this, _Entry_tag_accessor_storage, "f"); }
+        set tag(value) { __classPrivateFieldSet(this, _Entry_tag_accessor_storage, value, "f"); }
+        get perm() { return __classPrivateFieldGet(this, _Entry_perm_accessor_storage, "f"); }
+        set perm(value) { __classPrivateFieldSet(this, _Entry_perm_accessor_storage, value, "f"); }
+        get id() { return __classPrivateFieldGet(this, _Entry_id_accessor_storage, "f"); }
+        set id(value) { __classPrivateFieldSet(this, _Entry_id_accessor_storage, value, "f"); }
+        constructor() {
+            super(...arguments);
+            _Entry_tag_accessor_storage.set(this, __runInitializers(this, _tag_initializers, void 0));
+            _Entry_perm_accessor_storage.set(this, (__runInitializers(this, _tag_extraInitializers), __runInitializers(this, _perm_initializers, void 0)));
+            _Entry_id_accessor_storage.set(this, (__runInitializers(this, _perm_extraInitializers), __runInitializers(this, _id_initializers, void 0)));
+            __runInitializers(this, _id_extraInitializers);
+        }
+    };
+    _Entry_tag_accessor_storage = new WeakMap();
+    _Entry_perm_accessor_storage = new WeakMap();
+    _Entry_id_accessor_storage = new WeakMap();
+    __setFunctionName(_classThis, "Entry");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        _tag_decorators = [(_a = t).uint16.bind(_a)];
+        _perm_decorators = [(_b = t).uint16.bind(_b)];
+        _id_decorators = [(_c = t).uint32.bind(_c)];
+        __esDecorate(_classThis, null, _tag_decorators, { kind: "accessor", name: "tag", static: false, private: false, access: { has: obj => "tag" in obj, get: obj => obj.tag, set: (obj, value) => { obj.tag = value; } }, metadata: _metadata }, _tag_initializers, _tag_extraInitializers);
+        __esDecorate(_classThis, null, _perm_decorators, { kind: "accessor", name: "perm", static: false, private: false, access: { has: obj => "perm" in obj, get: obj => obj.perm, set: (obj, value) => { obj.perm = value; } }, metadata: _metadata }, _perm_initializers, _perm_extraInitializers);
+        __esDecorate(_classThis, null, _id_decorators, { kind: "accessor", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        Entry = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return Entry = _classThis;
+})();
+export { Entry };
+let ACL = (() => {
+    var _ACL_version_accessor_storage;
+    var _a;
+    let _classDecorators = [struct(packed)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = BufferView;
+    let _version_decorators;
+    let _version_initializers = [];
+    let _version_extraInitializers = [];
+    var ACL = _classThis = class extends _classSuper {
+        get version() { return __classPrivateFieldGet(this, _ACL_version_accessor_storage, "f"); }
+        set version(value) { __classPrivateFieldSet(this, _ACL_version_accessor_storage, value, "f"); }
+        constructor(...args) {
+            super(...args);
+            _ACL_version_accessor_storage.set(this, __runInitializers(this, _version_initializers, void 0));
+            this.entries = (__runInitializers(this, _version_extraInitializers), []);
+            this.version || (this.version = version);
+            if (this.version != version)
+                throw err(withErrno('EINVAL', 'Invalid ACL version'));
+            for (let offset = sizeof(ACL); offset < this.byteLength; offset += sizeof(Entry)) {
+                if (offset + sizeof(Entry) > this.byteLength)
+                    throw err(withErrno('EIO', 'Invalid ACL data'));
+                this.entries.push(new Entry(this.buffer, offset));
+            }
+        }
+    };
+    _ACL_version_accessor_storage = new WeakMap();
+    __setFunctionName(_classThis, "ACL");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        _version_decorators = [(_a = t).uint32.bind(_a)];
+        __esDecorate(_classThis, null, _version_decorators, { kind: "accessor", name: "version", static: false, private: false, access: { has: obj => "version" in obj, get: obj => obj.version, set: (obj, value) => { obj.version = value; } }, metadata: _metadata }, _version_initializers, _version_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        ACL = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return ACL = _classThis;
+})();
+export { ACL };
+export function fromMode(mode) {
+    const acl = new ACL();
+    acl.entries.push(Object.assign(new Entry(), { tag: Tag.UserObj, perm: (mode & S_IRWXU) >> 6 }), Object.assign(new Entry(), { tag: Tag.GroupObj, perm: (mode & S_IRWXG) >> 3 }), Object.assign(new Entry(), { tag: Tag.Other, perm: mode & S_IRWXO }));
+    return acl;
+}
+export function toMode(acl) {
+    let mode = 0;
+    for (const entry of acl.entries) {
+        switch (entry.tag) {
+            case Tag.UserObj:
+                mode |= entry.perm << 6;
+                break;
+            case Tag.GroupObj:
+                mode |= entry.perm << 3;
+                break;
+            case Tag.Other:
+                mode |= entry.perm;
+                break;
+            case Tag.User:
+            case Tag.Group:
+            case Tag.Mask:
+            case Tag._None:
+                continue;
+        }
+    }
+    return mode;
+}
+export async function get($, path) {
+    return new ACL(await xattr.get.call($, path, 'system.posix_acl_access'));
+}
+export function getSync($, path) {
+    return new ACL(xattr.getSync.call($, path, 'system.posix_acl_access'));
+}
+export async function set($, path, acl) {
+    await xattr.set.call($, path, 'system.posix_acl_access', new Uint8Array(acl.buffer, acl.byteOffset, acl.byteLength));
+}
+export function setSync($, path, acl) {
+    xattr.setSync.call($, path, 'system.posix_acl_access', new Uint8Array(acl.buffer, acl.byteOffset, acl.byteLength));
+}
+export let shouldCheck = true;
+export function setChecks(enabled) {
+    shouldCheck = enabled;
+}
+/**
+ * Checks if a given user/group has access to this item
+ * @param access The requested access, combination of `W_OK`, `R_OK`, and `X_OK`
+ */
+export function check($, inode, access) {
+    var _a, _b;
+    if (!shouldCheck)
+        return true;
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const { euid, egid } = (_b = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _b !== void 0 ? _b : defaultContext.credentials;
+    const data = inode.attributes.get('system.posix_acl_access');
+    if (!data)
+        return true;
+    const acl = new ACL(data);
+    let mask = R_OK | W_OK | X_OK;
+    let result = false;
+    for (const entry of acl.entries) {
+        switch (entry.tag) {
+            case Tag.UserObj:
+                if (inode.uid == euid && (entry.perm & access) === access)
+                    result = true;
+                break;
+            case Tag.User:
+                if (entry.id == euid && (entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag.GroupObj:
+                if (inode.gid == egid && (entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag.Group:
+                if (entry.id == egid && (entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag.Mask:
+                mask = entry.perm;
+                break;
+            case Tag.Other:
+                if ((entry.perm & mask & access) === access)
+                    result = true;
+                break;
+            case Tag._None:
+                continue;
+        }
+    }
+    return result;
+}

package/dist/vfs/async.d.ts

@@ -1,12 +1,12 @@
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
-import type { Stats } from '../stats.js';
 import type { Callback } from '../utils.js';
 import type { Dir, Dirent } from './dir.js';
+import type { Stats } from './stats.js';
 import type { FileContents } from './types.js';
 import { Buffer } from 'buffer';
-import { ErrnoError } from '../internal/error.js';
-import { BigIntStats } from '../stats.js';
+import { type Exception } from 'kerium';
+import { BigIntStats } from './stats.js';
 import { ReadStream, WriteStream, type ReadStreamOptions, type WriteStreamOptions } from './streams.js';
 import { FSWatcher } from './watchers.js';
 /**
@@ -16,7 +16,7 @@ export declare function rename(this: V_Context, oldPath: fs.PathLike, newPath: f
 /**
  * Test whether or not `path` exists by checking with the file system.
  * Then call the callback argument with either true or false.
- * @deprecated Use {@link stat} or {@link access} instead.
+ * According to Node.js: deprecated Use {@link stat} or {@link access} instead.
  */
 export declare function exists(this: V_Context, path: fs.PathLike, cb?: (exists: boolean) => unknown): void;
 export declare function stat(this: V_Context, path: fs.PathLike, callback: Callback<[Stats]>): void;
@@ -48,25 +48,11 @@ export declare function unlink(this: V_Context, path: fs.PathLike, cb?: Callback
  * Exclusive mode ensures that path is newly created.
  * Mode defaults to `0644`
  *
- * `flags` can be:
- *
- * * `'r'` - Open file for reading. An exception occurs if the file does not exist.
- * * `'r+'` - Open file for reading and writing. An exception occurs if the file does not exist.
- * * `'rs'` - Open file for reading in synchronous mode. Instructs the filesystem to not cache writes.
- * * `'rs+'` - Open file for reading and writing, and opens the file in synchronous mode.
- * * `'w'` - Open file for writing. The file is created (if it does not exist) or truncated (if it exists).
- * * `'wx'` - Like 'w' but opens the file in exclusive mode.
- * * `'w+'` - Open file for reading and writing. The file is created (if it does not exist) or truncated (if it exists).
- * * `'wx+'` - Like 'w+' but opens the file in exclusive mode.
- * * `'a'` - Open file for appending. The file is created if it does not exist.
- * * `'ax'` - Like 'a' but opens the file in exclusive mode.
- * * `'a+'` - Open file for reading and appending. The file is created if it does not exist.
- * * `'ax+'` - Like 'a+' but opens the file in exclusive mode.
- *
- * @see http://www.manpagez.com/man/2/open/
+ * @see https://nodejs.org/api/fs.html#fsopenpath-flags-mode-callback
+ * @param flags {@link https://nodejs.org/api/fs.html#file-system-flags}
  */
-export declare function open(this: V_Context, path: fs.PathLike, flag: string, cb?: Callback<[number]>): void;
-export declare function open(this: V_Context, path: fs.PathLike, flag: string, mode: number | string, cb?: Callback<[number]>): void;
+export declare function open(this: V_Context, path: fs.PathLike, flag: fs.OpenMode, cb?: Callback<[number]>): void;
+export declare function open(this: V_Context, path: fs.PathLike, flag: fs.OpenMode, mode: number | string, cb?: Callback<[number]>): void;
 /**
  * Asynchronously reads the entire contents of a file.
  * @option encoding The string encoding for the file contents. Defaults to `null`.
@@ -281,7 +267,7 @@ export declare function statfs(this: V_Context, path: fs.PathLike, options: fs.S
     bigint: true;
 }, callback: Callback<[fs.BigIntStatsFs]>): void;
 export declare function openAsBlob(this: V_Context, path: fs.PathLike, options?: fs.OpenAsBlobOptions): Promise<Blob>;
-type GlobCallback<Args extends unknown[]> = (e: ErrnoError | null, ...args: Args) => unknown;
+type GlobCallback<Args extends unknown[]> = (e: Exception | null, ...args: Args) => unknown;
 /**
  * Retrieves the files matching the specified pattern.
  */