@zenfs/core 2.4.0 → 2.4.2

package/dist/vfs/async.js

@@ -1,518 +1,229 @@
-import { Buffer } from 'buffer';
-import { UV, withErrno } from 'kerium';
+import { setUVMessage, UV } from 'kerium';
+import { decodeUTF8 } from 'utilium';
+import * as constants from '../constants.js';
+import { defaultContext } from '../internal/contexts.js';
+import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
+import { basename, dirname, join, parse, resolve as resolvePath } from '../path.js';
 import { normalizeMode, normalizePath } from '../utils.js';
-import { R_OK } from './constants.js';
-import * as promises from './promises.js';
-import { BigIntStats } from './stats.js';
-import { ReadStream, WriteStream } from './streams.js';
-import { FSWatcher, StatWatcher } from './watchers.js';
-const nop = () => { };
+import { checkAccess } from './config.js';
+import { Dirent, ifToDt } from './dir.js';
+import { Handle } from './file.js';
+import * as flags from './flags.js';
+import { resolveMount } from './shared.js';
+import { emitChange } from './watchers.js';
 /**
- * Helper to collect an async iterator into an array
+ * Resolves the mount and real path for a path.
+ * Additionally, any stats fetched will be returned for de-duplication
+ * @internal @hidden
  */
-async function collectAsyncIterator(it) {
-    const results = [];
-    for await (const result of it) {
-        results.push(result);
+export async function resolve($, path, preserveSymlinks, extra) {
+    if (preserveSymlinks) {
+        const resolved = resolveMount(path, $, extra);
+        const stats = await resolved.fs.stat(resolved.path).catch(() => undefined);
+        return { ...resolved, fullPath: path, stats };
     }
-    return results;
-}
-/**
- * Asynchronous rename. No arguments other than a possible exception are given to the completion callback.
- */
-export function rename(oldPath, newPath, cb = nop) {
-    promises.rename
-        .call(this, oldPath, newPath)
-        .then(() => cb(null))
-        .catch(cb);
-}
-rename;
-/**
- * Test whether or not `path` exists by checking with the file system.
- * Then call the callback argument with either true or false.
- * According to Node.js: deprecated Use {@link stat} or {@link access} instead.
- */
-export function exists(path, cb = nop) {
-    promises.exists
-        .call(this, path)
-        .then(cb)
-        .catch(() => cb(false));
-}
-exists;
-export function stat(path, options, callback = nop) {
-    callback = typeof options == 'function' ? options : callback;
-    promises.stat
-        .call(this, path, typeof options != 'function' ? options : {})
-        .then(stats => callback(null, stats))
-        .catch(callback);
-}
-stat;
-export function lstat(path, options, callback = nop) {
-    callback = typeof options == 'function' ? options : callback;
-    promises.lstat
-        .call(this, path, typeof options != 'function' ? options : {})
-        .then(stats => callback(null, stats))
-        .catch(callback);
-}
-lstat;
-export function truncate(path, cbLen = 0, cb = nop) {
-    cb = typeof cbLen === 'function' ? cbLen : cb;
-    const len = typeof cbLen === 'number' ? cbLen : 0;
-    promises.truncate
-        .call(this, path, len)
-        .then(() => cb(null))
-        .catch(cb);
-}
-truncate;
-export function unlink(path, cb = nop) {
-    promises.unlink
-        .call(this, path)
-        .then(() => cb(null))
-        .catch(cb);
-}
-unlink;
-export function open(path, flag, cbMode, cb = nop) {
-    const mode = normalizeMode(cbMode, 0o644);
-    cb = typeof cbMode === 'function' ? cbMode : cb;
-    promises.open
-        .call(this, path, flag, mode)
-        .then(handle => cb(null, handle.fd))
-        .catch(cb);
-}
-open;
-export function readFile(filename, options, cb = nop) {
-    cb = typeof options === 'function' ? options : cb;
-    promises.readFile
-        .call(this, filename, typeof options === 'function' ? null : options)
-        .then(data => cb(null, data))
-        .catch(cb);
-}
-readFile;
-export function writeFile(filename, data, cbEncOpts, cb = nop) {
-    cb = typeof cbEncOpts === 'function' ? cbEncOpts : cb;
-    promises.writeFile
-        .call(this, filename, data, typeof cbEncOpts != 'function' ? cbEncOpts : null)
-        .then(() => cb(null))
-        .catch(cb);
-}
-writeFile;
-export function appendFile(filename, data, cbEncOpts, cb = nop) {
-    const optionsOrEncoding = typeof cbEncOpts != 'function' ? cbEncOpts : undefined;
-    cb = typeof cbEncOpts === 'function' ? cbEncOpts : cb;
-    promises.appendFile
-        .call(this, filename, data, optionsOrEncoding)
-        .then(() => cb(null))
-        .catch(cb);
-}
-appendFile;
-export function fstat(fd, options, cb = nop) {
-    cb = typeof options == 'function' ? options : cb;
-    new promises.FileHandle(this, fd)
-        .stat()
-        .then(stats => cb(null, typeof options == 'object' && options?.bigint ? new BigIntStats(stats) : stats))
-        .catch(cb);
-}
-fstat;
-export function close(fd, cb = nop) {
-    new promises.FileHandle(this, fd)
-        .close()
-        .then(() => cb(null))
-        .catch(cb);
-}
-close;
-export function ftruncate(fd, lenOrCB, cb = nop) {
-    const length = typeof lenOrCB === 'number' ? lenOrCB : 0;
-    cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
-    const file = new promises.FileHandle(this, fd);
-    if (length < 0)
-        throw withErrno('EINVAL');
-    file.truncate(length)
-        .then(() => cb(null))
-        .catch(cb);
-}
-ftruncate;
-export function fsync(fd, cb = nop) {
-    new promises.FileHandle(this, fd)
-        .sync()
-        .then(() => cb(null))
-        .catch(cb);
-}
-fsync;
-export function fdatasync(fd, cb = nop) {
-    new promises.FileHandle(this, fd)
-        .datasync()
-        .then(() => cb(null))
-        .catch(cb);
-}
-fdatasync;
-export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
-    let buffer, offset, length, position, encoding;
-    const handle = new promises.FileHandle(this, fd);
-    if (typeof data === 'string') {
-        // Signature 1: (fd, string, [position?, [encoding?]], cb?)
-        encoding = 'utf8';
-        switch (typeof cbPosOff) {
-            case 'function':
-                // (fd, string, cb)
-                cb = cbPosOff;
-                break;
-            case 'number':
-                // (fd, string, position, encoding?, cb?)
-                position = cbPosOff;
-                encoding = typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8';
-                cb = typeof cbPosEnc === 'function' ? cbPosEnc : cb;
-                break;
-            default:
-                // ...try to find the callback and get out of here!
-                cb = (typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-                cb(withErrno('EINVAL'));
-                return;
+    /* Try to resolve it directly. If this works,
+    that means we don't need to perform any resolution for parent directories. */
+    try {
+        const resolved = resolveMount(path, $);
+        // Stat it to make sure it exists
+        const stats = await resolved.fs.stat(resolved.path);
+        if (!isSymbolicLink(stats)) {
+            return { ...resolved, fullPath: path, stats };
         }
-        buffer = Buffer.from(data);
-        offset = 0;
-        length = buffer.length;
-        const _cb = cb;
-        handle
-            .write(buffer, offset, length, position)
-            .then(({ bytesWritten }) => _cb(null, bytesWritten, buffer.toString(encoding)))
-            .catch(_cb);
+        const target = resolvePath.call($, dirname(path), await readlink.call($, path));
+        return await resolve($, target, preserveSymlinks, extra);
     }
-    else {
-        // Signature 2: (fd, buffer, offset, length, position?, cb?)
-        buffer = Buffer.from(data.buffer);
-        offset = cbPosOff;
-        length = cbLenEnc;
-        position = typeof cbPosEnc === 'number' ? cbPosEnc : null;
-        const _cb = (typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-        void handle
-            .write(buffer, offset, length, position)
-            .then(({ bytesWritten }) => _cb(null, bytesWritten, buffer))
-            .catch(_cb);
+    catch {
+        // Go the long way
     }
+    const { base, dir } = parse(path);
+    const realDir = dir == '/' ? '/' : (await resolve($, dir, false, extra)).fullPath;
+    const maybePath = join(realDir, base);
+    const resolved = resolveMount(maybePath, $);
+    const stats = await resolved.fs.stat(resolved.path).catch((e) => {
+        if (e.code == 'ENOENT')
+            return;
+        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath }));
+    });
+    if (!stats)
+        return { ...resolved, fullPath: path };
+    if (!isSymbolicLink(stats)) {
+        return { ...resolved, fullPath: maybePath, stats };
+    }
+    const target = resolvePath.call($, realDir, await readlink.call($, maybePath));
+    return await resolve($, target, false, extra);
 }
-write;
-/**
- * Read data from the file specified by `fd`.
- * @param buffer The buffer that the data will be written to.
- * @param offset The offset within the buffer where writing will start.
- * @param length An integer specifying the number of bytes to read.
- * @param 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 cb The number is the number of bytes read
- */
-export function read(fd, buffer, offset, length, position, cb = nop) {
-    new promises.FileHandle(this, fd)
-        .read(buffer, offset, length, position)
-        .then(({ bytesRead, buffer }) => cb(null, bytesRead, buffer))
-        .catch(cb);
-}
-read;
-export function fchown(fd, uid, gid, cb = nop) {
-    new promises.FileHandle(this, fd)
-        .chown(uid, gid)
-        .then(() => cb(null))
-        .catch(cb);
-}
-fchown;
-export function fchmod(fd, mode, cb) {
-    new promises.FileHandle(this, fd)
-        .chmod(mode)
-        .then(() => cb(null))
-        .catch(cb);
-}
-fchmod;
-/**
- * Change the file timestamps of a file referenced by the supplied file descriptor.
- */
-export function futimes(fd, atime, mtime, cb = nop) {
-    new promises.FileHandle(this, fd)
-        .utimes(atime, mtime)
-        .then(() => cb(null))
-        .catch(cb);
-}
-futimes;
-export function rmdir(path, cb = nop) {
-    promises.rmdir
-        .call(this, path)
-        .then(() => cb(null))
-        .catch(cb);
-}
-rmdir;
-/**
- * Asynchronous `mkdir`.
- * @param mode defaults to `0777`
- */
-export function mkdir(path, mode, cb = nop) {
-    promises.mkdir
-        .call(this, path, mode)
-        .then(() => cb(null))
-        .catch(cb);
-}
-mkdir;
-export function readdir(path, _options, cb = nop) {
-    cb = typeof _options == 'function' ? _options : cb;
-    const options = typeof _options != 'function' ? _options : {};
-    promises.readdir
-        .call(this, path, options)
-        .then(entries => cb(null, entries))
-        .catch(cb);
-}
-readdir;
-export function link(existing, newpath, cb = nop) {
-    promises.link
-        .call(this, existing, newpath)
-        .then(() => cb(null))
-        .catch(cb);
-}
-link;
-export function symlink(target, path, typeOrCB, cb = nop) {
-    const type = typeof typeOrCB === 'string' ? typeOrCB : 'file';
-    cb = typeof typeOrCB === 'function' ? typeOrCB : cb;
-    promises.symlink
-        .call(this, target, path, type)
-        .then(() => cb(null))
-        .catch(cb);
-}
-symlink;
-export function readlink(path, options, callback = nop) {
-    callback = typeof options == 'function' ? options : callback;
-    promises.readlink
-        .call(this, path)
-        .then(result => callback(null, result))
-        .catch(callback);
-}
-readlink;
-export function chown(path, uid, gid, cb = nop) {
-    promises.chown
-        .call(this, path, uid, gid)
-        .then(() => cb(null))
-        .catch(cb);
-}
-chown;
-export function lchown(path, uid, gid, cb = nop) {
-    promises.lchown
-        .call(this, path, uid, gid)
-        .then(() => cb(null))
-        .catch(cb);
-}
-lchown;
-export function chmod(path, mode, cb = nop) {
-    promises.chmod
-        .call(this, path, mode)
-        .then(() => cb(null))
-        .catch(cb);
-}
-chmod;
-export function lchmod(path, mode, cb = nop) {
-    promises.lchmod
-        .call(this, path, mode)
-        .then(() => cb(null))
-        .catch(cb);
-}
-lchmod;
-/**
- * Change file timestamps of the file referenced by the supplied path.
- */
-export function utimes(path, atime, mtime, cb = nop) {
-    promises.utimes
-        .call(this, path, atime, mtime)
-        .then(() => cb(null))
-        .catch(cb);
-}
-utimes;
 /**
- * Change file timestamps of the file referenced by the supplied path.
+ * Opens a file. This helper handles the complexity of file flags.
+ * @internal
  */
-export function lutimes(path, atime, mtime, cb = nop) {
-    promises.lutimes
-        .call(this, path, atime, mtime)
-        .then(() => cb(null))
-        .catch(cb);
-}
-lutimes;
-export function realpath(path, arg2, cb = nop) {
-    cb = typeof arg2 === 'function' ? arg2 : cb;
-    promises.realpath
-        .call(this, path, typeof arg2 === 'function' ? null : arg2)
-        .then(result => cb(null, result))
-        .catch(cb);
-}
-realpath;
-export function access(path, cbMode, cb = nop) {
-    const mode = typeof cbMode === 'number' ? cbMode : R_OK;
-    cb = typeof cbMode === 'function' ? cbMode : cb;
-    promises.access
-        .call(this, path, mode)
-        .then(() => cb(null))
-        .catch(cb);
-}
-access;
-const statWatchers = new Map();
-export function watchFile(path, options, listener) {
-    const normalizedPath = normalizePath(path);
-    const opts = typeof options != 'function' ? options : {};
-    if (typeof options == 'function') {
-        listener = options;
+export async function open($, path, opt) {
+    path = normalizePath(path);
+    const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
+    const $ex = { syscall: 'open', path };
+    const { fs, path: resolved, stats } = await resolve($, path, opt.preserveSymlinks, $ex);
+    if (!stats) {
+        if (!(flag & constants.O_CREAT))
+            throw UV('ENOENT', $ex);
+        // Create the file
+        const parentStats = await fs.stat(dirname(resolved));
+        if (checkAccess && !hasAccess($, parentStats, constants.W_OK))
+            throw UV('EACCES', 'open', dirname(path));
+        if (!isDirectory(parentStats))
+            throw UV('ENOTDIR', 'open', dirname(path));
+        if (!opt.allowDirectory && mode & constants.S_IFDIR)
+            throw UV('EISDIR', 'open', path);
+        const { euid: uid, egid: gid } = $?.credentials ?? defaultContext.credentials;
+        const inode = await fs.createFile(resolved, {
+            mode,
+            uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
+            gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
+        });
+        return new Handle($, path, fs, resolved, flag, inode);
     }
-    if (!listener)
-        throw UV('EINVAL', 'watch', path.toString());
-    if (statWatchers.has(normalizedPath)) {
-        const entry = statWatchers.get(normalizedPath);
-        if (entry) {
-            entry.listeners.add(listener);
-        }
+    if (checkAccess && !hasAccess($, stats, flags.toMode(flag)))
+        throw UV('EACCES', $ex);
+    if (flag & constants.O_EXCL)
+        throw UV('EEXIST', $ex);
+    const handle = new Handle($, path, fs, resolved, flag, stats);
+    if (!opt.allowDirectory && mode & constants.S_IFDIR)
+        throw UV('EISDIR', 'open', path);
+    if (flag & constants.O_TRUNC)
+        await handle.truncate(0);
+    return handle;
+}
+export async function readlink(path) {
+    path = normalizePath(path);
+    const $ex = { syscall: 'readlink', path };
+    const { fs, stats, path: resolved } = await resolve(this, path, true, $ex);
+    if (!stats)
+        throw UV('ENOENT', $ex);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', $ex);
+    if (!isSymbolicLink(stats))
+        throw UV('EINVAL', $ex);
+    const size = stats.size;
+    const data = new Uint8Array(size);
+    await fs.read(resolved, data, 0, size);
+    return decodeUTF8(data);
+}
+export async function mkdir(path, options = {}) {
+    path = normalizePath(path);
+    const { euid: uid, egid: gid } = this?.credentials ?? defaultContext.credentials;
+    const { mode = 0o777, recursive } = options;
+    const { fs, path: resolved } = resolveMount(path, this, { syscall: 'mkdir' });
+    const __create = async (path, resolved, parent) => {
+        if (checkAccess && !hasAccess(this, parent, constants.W_OK))
+            throw UV('EACCES', 'mkdir', path);
+        const inode = await fs.mkdir(resolved, {
+            mode,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        });
+        emitChange(this, 'rename', path);
+        return inode;
+    };
+    if (!recursive) {
+        await __create(path, resolved, await fs.stat(dirname(resolved)));
         return;
     }
-    const watcher = new StatWatcher(this, normalizedPath, opts);
-    watcher.on('change', (curr, prev) => {
-        const entry = statWatchers.get(normalizedPath);
-        if (!entry) {
+    const dirs = [];
+    let origDir = path;
+    for (let dir = resolved; !(await fs.exists(dir)); dir = dirname(dir), origDir = dirname(origDir)) {
+        dirs.unshift([origDir, dir]);
+    }
+    if (!dirs.length)
+        return;
+    const stats = [await fs.stat(dirname(dirs[0][1]))];
+    for (const [i, [path, resolved]] of dirs.entries()) {
+        stats.push(await __create(path, resolved, stats[i]));
+    }
+    return dirs[0][0];
+}
+export async function readdir(path, options = {}) {
+    path = normalizePath(path);
+    const $ex = { syscall: 'readdir', path };
+    const { fs, path: resolved, stats } = await resolve(this, path, false, $ex);
+    if (!stats)
+        throw UV('ENOENT', $ex);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', $ex);
+    if (!isDirectory(stats))
+        throw UV('ENOTDIR', $ex);
+    const entries = await fs.readdir(resolved);
+    const values = [];
+    const addEntry = async (entry) => {
+        const entryStats = await fs.stat(join(resolved, entry)).catch((e) => {
+            if (e.code == 'ENOENT')
+                return;
+            throw e;
+        });
+        if (!entryStats)
             return;
-        }
-        for (const listener of entry.listeners) {
-            listener(curr, prev);
-        }
+        const ent = new Dirent();
+        ent.ino = entryStats.ino;
+        ent.type = ifToDt(entryStats.mode);
+        ent.path = entry;
+        ent.name = basename(entry);
+        values.push(ent);
+        if (!options.recursive || !isDirectory(entryStats))
+            return;
+        const children = await fs.readdir(join(resolved, entry));
+        for (const child of children)
+            await addEntry(join(entry, child));
+    };
+    await Promise.all(entries.map(addEntry));
+    return values;
+}
+export async function rename(oldPath, newPath) {
+    oldPath = normalizePath(oldPath);
+    newPath = normalizePath(newPath);
+    const $ex = { syscall: 'rename', path: oldPath, dest: newPath };
+    const src = await resolve(this, oldPath, true, $ex);
+    const dst = resolveMount(newPath, this, $ex);
+    if (src.fs.uuid !== dst.fs.uuid)
+        throw UV('EXDEV', $ex);
+    if (dst.path.startsWith(src.path + '/'))
+        throw UV('EBUSY', $ex);
+    if (!src.stats)
+        throw UV('ENOENT', $ex);
+    const fs = src.fs;
+    const oldParent = await fs.stat(dirname(src.path));
+    const newParent = await fs.stat(dirname(dst.path));
+    const newStats = await fs.stat(dst.path).catch((e) => {
+        if (e.code == 'ENOENT')
+            return null;
+        throw e;
     });
-    statWatchers.set(normalizedPath, { watcher, listeners: new Set() });
-}
-watchFile;
-/**
- * Stop watching for changes on a file.
- *
- * If the `listener` is specified, only that particular listener is removed.
- * If no `listener` is specified, all listeners are removed, and the file is no longer watched.
- *
- * @param path The path to the file to stop watching.
- * @param listener Optional listener to remove.
- */
-export function unwatchFile(path, listener = nop) {
-    const normalizedPath = normalizePath(path);
-    const entry = statWatchers.get(normalizedPath);
-    if (entry) {
-        if (listener && listener !== nop) {
-            entry.listeners.delete(listener);
-        }
-        else {
-            // If no listener is specified, remove all listeners
-            entry.listeners.clear();
-        }
-        if (entry.listeners.size === 0) {
-            // No more listeners, stop the watcher
-            entry.watcher.stop();
-            statWatchers.delete(normalizedPath);
-        }
+    if (checkAccess && (!hasAccess(this, oldParent, constants.R_OK) || !hasAccess(this, newParent, constants.W_OK)))
+        throw UV('EACCES', $ex);
+    if (newStats && !isDirectory(src.stats) && isDirectory(newStats))
+        throw UV('EISDIR', $ex);
+    if (newStats && isDirectory(src.stats) && !isDirectory(newStats))
+        throw UV('ENOTDIR', $ex);
+    await src.fs.rename(src.path, dst.path);
+    emitChange(this, 'rename', oldPath);
+    emitChange(this, 'change', newPath);
+}
+export async function link(target, link) {
+    target = normalizePath(target);
+    link = normalizePath(link);
+    const $ex = { syscall: 'link', path: link, dest: target };
+    const { fs, path: resolved } = resolveMount(target, this, $ex);
+    const dst = resolveMount(link, this, $ex);
+    if (fs.uuid != dst.fs.uuid)
+        throw UV('EXDEV', $ex);
+    const stats = await fs.stat(resolved);
+    if (checkAccess) {
+        if (!hasAccess(this, stats, constants.R_OK))
+            throw UV('EACCES', $ex);
+        const dirStats = await fs.stat(dirname(resolved));
+        if (!hasAccess(this, dirStats, constants.R_OK))
+            throw UV('EACCES', $ex);
+        const destStats = await fs.stat(dirname(dst.path));
+        if (!hasAccess(this, destStats, constants.W_OK))
+            throw UV('EACCES', $ex);
     }
+    return await fs.link(resolved, dst.path);
 }
-unwatchFile;
-export function watch(path, options, listener) {
-    const watcher = new FSWatcher(this, normalizePath(path), typeof options == 'object' ? options : {});
-    listener = typeof options == 'function' ? options : listener;
-    watcher.on('change', listener || nop);
-    return watcher;
-}
-watch;
-/**
- * Opens a file in read mode and creates a Node.js-like ReadStream.
- *
- * @param path The path to the file to be opened.
- * @param options Options for the ReadStream and file opening (e.g., `encoding`, `highWaterMark`, `mode`).
- * @returns A ReadStream object for interacting with the file's contents.
- */
-export function createReadStream(path, options) {
-    options = typeof options == 'object' ? options : { encoding: options };
-    const _handle = promises.open.call(this, path, 'r', options?.mode);
-    return new ReadStream({ ...options, autoClose: true }, _handle);
-}
-createReadStream;
-/**
- * Opens a file in write mode and creates a Node.js-like WriteStream.
- *
- * @param path The path to the file to be opened.
- * @param options Options for the WriteStream and file opening (e.g., `encoding`, `highWaterMark`, `mode`).
- * @returns A WriteStream object for writing to the file.
- */
-export function createWriteStream(path, options) {
-    options = typeof options == 'object' ? options : { encoding: options };
-    const _handle = promises.open.call(this, path, 'w', options?.mode);
-    return new WriteStream(options, _handle);
-}
-createWriteStream;
-export function rm(path, options, callback = nop) {
-    callback = typeof options === 'function' ? options : callback;
-    promises.rm
-        .call(this, path, typeof options === 'function' ? undefined : options)
-        .then(() => callback(null))
-        .catch(callback);
-}
-rm;
-export function mkdtemp(prefix, options, callback = nop) {
-    callback = typeof options === 'function' ? options : callback;
-    promises.mkdtemp
-        .call(this, prefix, typeof options != 'function' ? options : null)
-        .then(result => callback(null, result))
-        .catch(callback);
-}
-mkdtemp;
-export function copyFile(src, dest, flags, callback = nop) {
-    callback = typeof flags === 'function' ? flags : callback;
-    promises.copyFile
-        .call(this, src, dest, typeof flags === 'function' ? undefined : flags)
-        .then(() => callback(null))
-        .catch(callback);
-}
-copyFile;
-export function readv(fd, buffers, position, cb = nop) {
-    cb = typeof position === 'function' ? position : cb;
-    new promises.FileHandle(this, fd)
-        .readv(buffers, typeof position === 'function' ? undefined : position)
-        .then(({ buffers, bytesRead }) => cb(null, bytesRead, buffers))
-        .catch(cb);
-}
-readv;
-export function writev(fd, buffers, position, cb = nop) {
-    cb = typeof position === 'function' ? position : cb;
-    new promises.FileHandle(this, fd)
-        .writev(buffers, typeof position === 'function' ? undefined : position)
-        .then(({ buffers, bytesWritten }) => cb(null, bytesWritten, buffers))
-        .catch(cb);
-}
-writev;
-export function opendir(path, options, cb = nop) {
-    cb = typeof options === 'function' ? options : cb;
-    promises.opendir
-        .call(this, path, typeof options === 'function' ? undefined : options)
-        .then(result => cb(null, result))
-        .catch(cb);
-}
-opendir;
-export function cp(source, destination, opts, callback = nop) {
-    callback = typeof opts === 'function' ? opts : callback;
-    promises.cp
-        .call(this, source, destination, typeof opts === 'function' ? undefined : opts)
-        .then(() => callback(null))
-        .catch(callback);
-}
-cp;
-export function statfs(path, options, callback = nop) {
-    callback = typeof options === 'function' ? options : callback;
-    promises.statfs
-        .call(this, path, typeof options === 'function' ? undefined : options)
-        .then(result => callback(null, result))
-        .catch(callback);
-}
-statfs;
-export async function openAsBlob(path, options) {
-    const handle = await promises.open.call(this, path.toString(), 'r');
-    const buffer = await handle.readFile();
-    await handle.close();
-    return new Blob([buffer], options);
-}
-openAsBlob;
-export function glob(pattern, options, callback = nop) {
-    callback = typeof options == 'function' ? options : callback;
-    const it = promises.glob.call(this, pattern, typeof options === 'function' ? undefined : options);
-    collectAsyncIterator(it)
-        .then(results => callback(null, results ?? []))
-        .catch((e) => callback(e));
-}
-glob;