@zenfs/core 2.6.6 → 2.7.1

package/dist/internal/ioctl.js

@@ -0,0 +1,368 @@
+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;
+};
+import { Errno, Exception, withErrno } from 'kerium';
+import { sizeof } from 'memium';
+import { $from, struct, types as t } from 'memium/decorators';
+import { _throw } from 'utilium';
+import { BufferView } from 'utilium/buffer';
+import { InodeFlags } from './inode.js';
+/*
+ * Flags for the fsxattr.xflags field
+ */
+var XFlag;
+(function (XFlag) {
+    /** data in realtime volume */
+    XFlag[XFlag["RealTime"] = 1] = "RealTime";
+    /** preallocated file extents */
+    XFlag[XFlag["PreAlloc"] = 2] = "PreAlloc";
+    /** file cannot be modified */
+    XFlag[XFlag["Immutable"] = 8] = "Immutable";
+    /** all writes append */
+    XFlag[XFlag["Append"] = 16] = "Append";
+    /** all writes synchronous */
+    XFlag[XFlag["Sync"] = 32] = "Sync";
+    /** do not update access time */
+    XFlag[XFlag["NoAtime"] = 64] = "NoAtime";
+    /** do not include in backups */
+    XFlag[XFlag["NoDump"] = 128] = "NoDump";
+    /** create with rt bit set */
+    XFlag[XFlag["RtInherit"] = 256] = "RtInherit";
+    /** create with parents projid */
+    XFlag[XFlag["ProjInherit"] = 512] = "ProjInherit";
+    /** disallow symlink creation */
+    XFlag[XFlag["NoSymlinks"] = 1024] = "NoSymlinks";
+    /** extent size allocator hint */
+    XFlag[XFlag["ExtSize"] = 2048] = "ExtSize";
+    /** inherit inode extent size */
+    XFlag[XFlag["ExtSzInherit"] = 4096] = "ExtSzInherit";
+    /** do not defragment */
+    XFlag[XFlag["NoDefrag"] = 8192] = "NoDefrag";
+    /** use filestream allocator */
+    XFlag[XFlag["FileStream"] = 16384] = "FileStream";
+    /** use DAX for IO */
+    XFlag[XFlag["Dax"] = 32768] = "Dax";
+    /** CoW extent size allocator hint */
+    XFlag[XFlag["CowExtSize"] = 65536] = "CowExtSize";
+    /** no DIFLAG for this */
+    XFlag[XFlag["HasAttr"] = 2147483648] = "HasAttr";
+})(XFlag || (XFlag = {}));
+let fsxattr = (() => {
+    var _a, _b, _c, _d, _e;
+    let _classDecorators = [struct()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = $from(BufferView);
+    let _xflags_decorators;
+    let _xflags_initializers = [];
+    let _xflags_extraInitializers = [];
+    let _extsize_decorators;
+    let _extsize_initializers = [];
+    let _extsize_extraInitializers = [];
+    let _nextents_decorators;
+    let _nextents_initializers = [];
+    let _nextents_extraInitializers = [];
+    let _projid_decorators;
+    let _projid_initializers = [];
+    let _projid_extraInitializers = [];
+    let _cowextsize_decorators;
+    let _cowextsize_initializers = [];
+    let _cowextsize_extraInitializers = [];
+    let _pad_decorators;
+    let _pad_initializers = [];
+    let _pad_extraInitializers = [];
+    var fsxattr = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _xflags_decorators = [(_a = t).uint32.bind(_a)];
+            _extsize_decorators = [(_b = t).uint32.bind(_b)];
+            _nextents_decorators = [(_c = t).uint32.bind(_c)];
+            _projid_decorators = [(_d = t).uint32.bind(_d)];
+            _cowextsize_decorators = [(_e = t).uint32.bind(_e)];
+            _pad_decorators = [t.char(8)];
+            __esDecorate(this, null, _xflags_decorators, { kind: "accessor", name: "xflags", static: false, private: false, access: { has: obj => "xflags" in obj, get: obj => obj.xflags, set: (obj, value) => { obj.xflags = value; } }, metadata: _metadata }, _xflags_initializers, _xflags_extraInitializers);
+            __esDecorate(this, null, _extsize_decorators, { kind: "accessor", name: "extsize", static: false, private: false, access: { has: obj => "extsize" in obj, get: obj => obj.extsize, set: (obj, value) => { obj.extsize = value; } }, metadata: _metadata }, _extsize_initializers, _extsize_extraInitializers);
+            __esDecorate(this, null, _nextents_decorators, { kind: "accessor", name: "nextents", static: false, private: false, access: { has: obj => "nextents" in obj, get: obj => obj.nextents, set: (obj, value) => { obj.nextents = value; } }, metadata: _metadata }, _nextents_initializers, _nextents_extraInitializers);
+            __esDecorate(this, null, _projid_decorators, { kind: "accessor", name: "projid", static: false, private: false, access: { has: obj => "projid" in obj, get: obj => obj.projid, set: (obj, value) => { obj.projid = value; } }, metadata: _metadata }, _projid_initializers, _projid_extraInitializers);
+            __esDecorate(this, null, _cowextsize_decorators, { kind: "accessor", name: "cowextsize", static: false, private: false, access: { has: obj => "cowextsize" in obj, get: obj => obj.cowextsize, set: (obj, value) => { obj.cowextsize = value; } }, metadata: _metadata }, _cowextsize_initializers, _cowextsize_extraInitializers);
+            __esDecorate(this, null, _pad_decorators, { kind: "accessor", name: "pad", static: false, private: false, access: { has: obj => "pad" in obj, get: obj => obj.pad, set: (obj, value) => { obj.pad = value; } }, metadata: _metadata }, _pad_initializers, _pad_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            fsxattr = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static name = 'fsxattr';
+        #xflags_accessor_storage = __runInitializers(this, _xflags_initializers, void 0);
+        /** xflags field value */
+        get xflags() { return this.#xflags_accessor_storage; }
+        set xflags(value) { this.#xflags_accessor_storage = value; }
+        #extsize_accessor_storage = (__runInitializers(this, _xflags_extraInitializers), __runInitializers(this, _extsize_initializers, void 0));
+        /** extsize field value */
+        get extsize() { return this.#extsize_accessor_storage; }
+        set extsize(value) { this.#extsize_accessor_storage = value; }
+        #nextents_accessor_storage = (__runInitializers(this, _extsize_extraInitializers), __runInitializers(this, _nextents_initializers, void 0));
+        /** nextents field value */
+        get nextents() { return this.#nextents_accessor_storage; }
+        set nextents(value) { this.#nextents_accessor_storage = value; }
+        #projid_accessor_storage = (__runInitializers(this, _nextents_extraInitializers), __runInitializers(this, _projid_initializers, void 0));
+        /** project identifier */
+        get projid() { return this.#projid_accessor_storage; }
+        set projid(value) { this.#projid_accessor_storage = value; }
+        #cowextsize_accessor_storage = (__runInitializers(this, _projid_extraInitializers), __runInitializers(this, _cowextsize_initializers, void 0));
+        /** CoW extsize field value */
+        get cowextsize() { return this.#cowextsize_accessor_storage; }
+        set cowextsize(value) { this.#cowextsize_accessor_storage = value; }
+        #pad_accessor_storage = (__runInitializers(this, _cowextsize_extraInitializers), __runInitializers(this, _pad_initializers, []));
+        get pad() { return this.#pad_accessor_storage; }
+        set pad(value) { this.#pad_accessor_storage = value; }
+        constructor(inode = _throw(new Exception(Errno.EINVAL, 'fsxattr must be initialized with an inode'))) {
+            super(new ArrayBuffer(sizeof(fsxattr)));
+            __runInitializers(this, _pad_extraInitializers);
+            this.extsize = inode.size;
+            this.nextents = 1;
+            this.projid = inode.uid;
+            this.cowextsize = inode.size;
+            for (const name of Object.keys(InodeFlags)) {
+                if (!((inode.flags || 0) & InodeFlags[name]))
+                    continue;
+                if (name in XFlag)
+                    this.xflags |= XFlag[name];
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return fsxattr = _classThis;
+})();
+/**
+ * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
+ * @see `FS_*_FL` in `include/uapi/linux/fs.h` (around L250)
+ * @experimental
+ */
+var FileFlag;
+(function (FileFlag) {
+    /** Secure deletion */
+    FileFlag[FileFlag["SecureRm"] = 1] = "SecureRm";
+    /** Undelete */
+    FileFlag[FileFlag["Undelete"] = 2] = "Undelete";
+    /** Compress file */
+    FileFlag[FileFlag["Compress"] = 4] = "Compress";
+    /** Synchronous updates */
+    FileFlag[FileFlag["Sync"] = 8] = "Sync";
+    /** Immutable file */
+    FileFlag[FileFlag["Immutable"] = 16] = "Immutable";
+    /** Writes to file may only append */
+    FileFlag[FileFlag["Append"] = 32] = "Append";
+    /** do not dump file */
+    FileFlag[FileFlag["NoDump"] = 64] = "NoDump";
+    /** do not update atime */
+    FileFlag[FileFlag["NoAtime"] = 128] = "NoAtime";
+    // Reserved for compression usage...
+    FileFlag[FileFlag["Dirty"] = 256] = "Dirty";
+    /** One or more compressed clusters */
+    FileFlag[FileFlag["CompressBlk"] = 512] = "CompressBlk";
+    /** Don't compress */
+    FileFlag[FileFlag["NoCompress"] = 1024] = "NoCompress";
+    // End compression flags --- maybe not all used
+    /** Encrypted file */
+    FileFlag[FileFlag["Encrypt"] = 2048] = "Encrypt";
+    /** btree format dir */
+    FileFlag[FileFlag["Btree"] = 4096] = "Btree";
+    /** hash-indexed directory */
+    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
+    FileFlag[FileFlag["Index"] = 4096] = "Index";
+    /** AFS directory */
+    FileFlag[FileFlag["IMagic"] = 8192] = "IMagic";
+    /** Reserved for ext3 */
+    FileFlag[FileFlag["JournalData"] = 16384] = "JournalData";
+    /** file tail should not be merged */
+    FileFlag[FileFlag["NoTail"] = 32768] = "NoTail";
+    /** dirsync behaviour (directories only) */
+    FileFlag[FileFlag["DirSync"] = 65536] = "DirSync";
+    /** Top of directory hierarchies*/
+    FileFlag[FileFlag["TopDir"] = 131072] = "TopDir";
+    /** Reserved for ext4 */
+    FileFlag[FileFlag["HugeFile"] = 262144] = "HugeFile";
+    /** Extents */
+    FileFlag[FileFlag["Extent"] = 524288] = "Extent";
+    /** Verity protected inode */
+    FileFlag[FileFlag["Verity"] = 1048576] = "Verity";
+    /** Inode used for large EA */
+    FileFlag[FileFlag["EaInode"] = 2097152] = "EaInode";
+    /** Reserved for ext4 */
+    FileFlag[FileFlag["EofBlocks"] = 4194304] = "EofBlocks";
+    /** Do not cow file */
+    FileFlag[FileFlag["NoCow"] = 8388608] = "NoCow";
+    /** Inode is DAX */
+    FileFlag[FileFlag["Dax"] = 33554432] = "Dax";
+    /** Reserved for ext4 */
+    FileFlag[FileFlag["InlineData"] = 268435456] = "InlineData";
+    /** Create with parents projid */
+    FileFlag[FileFlag["ProjInherit"] = 536870912] = "ProjInherit";
+    /** Folder is case insensitive */
+    FileFlag[FileFlag["CaseFold"] = 1073741824] = "CaseFold";
+    /** reserved for ext2 lib */
+    FileFlag[FileFlag["Reserved"] = 2147483648] = "Reserved";
+})(FileFlag || (FileFlag = {}));
+/**
+ * `FS_IOC_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export var IOC;
+(function (IOC) {
+    IOC[IOC["GetFlags"] = 2148034049] = "GetFlags";
+    IOC[IOC["SetFlags"] = 1074292226] = "SetFlags";
+    IOC[IOC["GetVersion"] = 2148038145] = "GetVersion";
+    IOC[IOC["SetVersion"] = 1074296322] = "SetVersion";
+    IOC[IOC["Fiemap"] = 3223348747] = "Fiemap";
+    IOC[IOC["GetXattr"] = 2149341215] = "GetXattr";
+    IOC[IOC["SetXattr"] = 1075599392] = "SetXattr";
+    IOC[IOC["GetLabel"] = 2164298801] = "GetLabel";
+    IOC[IOC["SetLabel"] = 1090556978] = "SetLabel";
+    IOC[IOC["GetUUID"] = 2148603136] = "GetUUID";
+    IOC[IOC["GetSysfsPath"] = 2155943169] = "GetSysfsPath";
+})(IOC || (IOC = {}));
+/**
+ * `FS_IOC32_*` commands for {@link ioctl | `ioctl`}
+ * @remarks
+ * These are computed from a script since constant values are needed for enum member types
+ */
+export var IOC32;
+(function (IOC32) {
+    IOC32[IOC32["GetFlags"] = 2147771905] = "GetFlags";
+    IOC32[IOC32["SetFlags"] = 1074030082] = "SetFlags";
+    IOC32[IOC32["GetVersion"] = 2147776001] = "GetVersion";
+    IOC32[IOC32["SetVersion"] = 1074034178] = "SetVersion";
+})(IOC32 || (IOC32 = {}));
+/**
+ * @internal
+ * @category ioctl
+ */
+export const ioctl_default_ops = {
+    [IOC.GetFlags]($) {
+        if (typeof $.inode.flags !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.flags;
+    },
+    [IOC32.GetFlags]($) {
+        if (typeof $.inode.flags !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.flags;
+    },
+    [IOC.GetVersion]($) {
+        if (typeof $.inode.version !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.version;
+    },
+    [IOC32.GetVersion]($) {
+        if (typeof $.inode.version !== 'number')
+            throw withErrno('ENOTTY');
+        return $.inode.version;
+    },
+    [IOC.Fiemap]() {
+        throw withErrno('ENOTSUP');
+    },
+    [IOC.GetXattr]($, _name) {
+        return new fsxattr($.inode);
+    },
+    [IOC.SetXattr]($, _name, _value) {
+        throw withErrno('ENOTSUP');
+    },
+    [IOC.GetLabel]($) {
+        return $.fs.label;
+    },
+    [IOC.SetLabel]($, label) {
+        $.fs.label = label;
+    },
+    [IOC.GetUUID]($) {
+        return $.fs.uuid;
+    },
+    [IOC.GetSysfsPath]($) {
+        /**
+         * Returns the path component under /sys/fs/ that refers to this filesystem;
+         * also /sys/kernel/debug/ for filesystems with debugfs exports
+         * @todo Implement sysfs and have each FS implement the /sys/fs/<name> tree
+         */
+        return `/sys/fs/${$.fs.name}/${$.fs.uuid}`;
+    },
+};
+/**
+ * @internal
+ * @category ioctl
+ */
+export const ioctl_default_ops_async = {
+    ...ioctl_default_ops,
+    async [IOC.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        await $.fs.touch($.path, $.inode);
+    },
+    async [IOC32.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        await $.fs.touch($.path, $.inode);
+    },
+    async [IOC.SetVersion]($, version) {
+        $.inode.version = version;
+        await $.fs.touch($.path, $.inode);
+    },
+    async [IOC32.SetVersion]($, version) {
+        $.inode.version = version;
+        await $.fs.touch($.path, $.inode);
+    },
+};
+/**
+ * @internal
+ * @category ioctl
+ */
+export const ioctl_default_ops_sync = {
+    ...ioctl_default_ops,
+    [IOC.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        $.fs.touchSync($.path, $.inode);
+    },
+    [IOC32.SetFlags]($, flags) {
+        $.inode.flags = flags;
+        $.fs.touchSync($.path, $.inode);
+    },
+    [IOC.SetVersion]($, version) {
+        $.inode.version = version;
+        $.fs.touchSync($.path, $.inode);
+    },
+    [IOC32.SetVersion]($, version) {
+        $.inode.version = version;
+        $.fs.touchSync($.path, $.inode);
+    },
+};

package/dist/mixins/async.js

@@ -1,9 +1,10 @@
-import { _asyncFSKeys } from './shared.js';
+// SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { crit, debug, err } from 'kerium/log';
 import { StoreFS } from '../backends/store/fs.js';
 import { isDirectory } from '../internal/inode.js';
 import { join } from '../path.js';
+import { _asyncFSKeys } from './shared.js';
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -143,6 +144,10 @@ export function Async(FS) {
             this._sync.writeSync(path, buffer, offset);
             this._async(() => this.write(path, buffer, offset));
         }
+        ioctlSync(context, command, ...args) {
+            this.checkSync();
+            return this._sync.ioctlSync(context, command, ...args);
+        }
         streamWrite(path, options) {
             this.checkSync();
             const sync = this._sync.streamWrite(path, options).getWriter();

package/dist/mixins/mutexed.d.ts

@@ -2,6 +2,7 @@ import type { UUID } from 'node:crypto';
 import type { Concrete } from 'utilium';
 import type { CreationOptions, FileSystem, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
+import type { IoctlContext } from '../internal/ioctl.js';
 import '../polyfills.js';
 /**
  * @category Internals
@@ -90,6 +91,8 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     writeSync(path: string, buffer: Uint8Array, offset: number): void;
     streamRead(path: string, options: StreamOptions): ReadableStream;
     streamWrite(path: string, options: StreamOptions): WritableStream;
+    ioctl(context: IoctlContext, command: number, ...args: any[]): Promise<any>;
+    ioctlSync(context: IoctlContext, command: number, ...args: any[]): any;
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/mutexed.js

@@ -50,6 +50,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+// SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
 import { err } from 'kerium/log';
 import '../polyfills.js';
@@ -170,7 +171,6 @@ export class _MutexedFS {
     get isLocked() {
         return !!this.currentLock?.isLocked;
     }
-    /* eslint-disable @typescript-eslint/no-unused-vars */
     async rename(oldPath, newPath) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
@@ -563,6 +563,34 @@ export class _MutexedFS {
             __disposeResources(env_28);
         }
     }
+    async ioctl(context, command, ...args) {
+        const env_29 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_29, await this.lock(), false);
+            return await this._fs.ioctl({ ...context, fs: this._fs }, command, ...args);
+        }
+        catch (e_29) {
+            env_29.error = e_29;
+            env_29.hasError = true;
+        }
+        finally {
+            __disposeResources(env_29);
+        }
+    }
+    ioctlSync(context, command, ...args) {
+        const env_30 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_30, this.lockSync(), false);
+            return this._fs.ioctlSync({ ...context, fs: this._fs }, command, ...args);
+        }
+        catch (e_30) {
+            env_30.error = e_30;
+            env_30.hasError = true;
+        }
+        finally {
+            __disposeResources(env_30);
+        }
+    }
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/shared.d.ts

@@ -18,7 +18,7 @@ export type _SyncFSKeys = Exclude<Extract<keyof FileSystem, `${string}Sync`>, '_
 export type _AsyncFSKeys = {
     [K in _SyncFSKeys]: K extends `${infer T}Sync` ? T : never;
 }[_SyncFSKeys];
-export declare const _asyncFSKeys: ["rename", "stat", "touch", "createFile", "unlink", "rmdir", "mkdir", "readdir", "exists", "link", "sync", "read", "write"];
+export declare const _asyncFSKeys: ["rename", "stat", "touch", "createFile", "unlink", "rmdir", "mkdir", "readdir", "exists", "link", "sync", "read", "write", "ioctl"];
 /**
  * Asynchronous `FileSystem` methods. This is a convenience type for all of the async operations.
  * @category Internals

package/dist/mixins/shared.js

@@ -13,4 +13,5 @@ export const _asyncFSKeys = [
     'sync',
     'read',
     'write',
+    'ioctl',
 ];

package/dist/mixins/sync.js

@@ -44,6 +44,9 @@ export function Sync(FS) {
         async write(path, buffer, offset) {
             return this.writeSync(path, buffer, offset);
         }
+        async ioctl(context, command, ...args) {
+            return this.ioctlSync(context, command, ...args);
+        }
     }
     return SyncFS;
 }

package/dist/node/async.js

@@ -328,7 +328,7 @@ export function access(path, cbMode, cb = nop) {
 access;
 const statWatchers = new Map();
 export function watchFile(path, options, listener) {
-    const normalizedPath = normalizePath(path);
+    const normalizedPath = normalizePath.call(this, path);
     const opts = typeof options != 'function' ? options : {};
     if (typeof options == 'function') {
         listener = options;
@@ -365,7 +365,7 @@ watchFile;
  * @param listener Optional listener to remove.
  */
 export function unwatchFile(path, listener = nop) {
-    const normalizedPath = normalizePath(path);
+    const normalizedPath = normalizePath.call(this, path);
     const entry = statWatchers.get(normalizedPath);
     if (entry) {
         if (listener && listener !== nop) {
@@ -384,7 +384,7 @@ export function unwatchFile(path, listener = nop) {
 }
 unwatchFile;
 export function watch(path, options, listener) {
-    const watcher = new FSWatcher(this, normalizePath(path), typeof options == 'object' ? options : {});
+    const watcher = new FSWatcher(this, normalizePath.call(this, path), typeof options == 'object' ? options : {});
     listener = typeof options == 'function' ? options : listener;
     watcher.on('change', listener || nop);
     return watcher;

package/dist/node/promises.js

@@ -529,7 +529,7 @@ rename;
  * Test whether or not `path` exists by checking with the file system.
  */
 export async function exists(path) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     try {
         const { fs, path: resolved } = await _async.resolve(this, path);
         return await fs.exists(resolved);
@@ -579,7 +579,7 @@ truncate;
 export async function unlink(path) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
-        path = normalizePath(path);
+        path = normalizePath.call(this, path);
         const { fs, path: resolved } = resolveMount(path, this);
         const $ex = { syscall: 'unlink', path };
         const stats = await fs.stat(resolved).catch(rethrow($ex));
@@ -691,7 +691,7 @@ appendFile;
 export async function rmdir(path) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        path = normalizePath(path);
+        path = normalizePath.call(this, path);
         const { fs, path: resolved } = await _async.resolve(this, path);
         const $ex = { syscall: 'rmdir', path };
         const stats = await fs.stat(resolved).catch(rethrow($ex));
@@ -722,7 +722,7 @@ export async function mkdir(path, options) {
 }
 mkdir;
 export async function readdir(path, options) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const opt = typeof options === 'object' && options != null ? options : { encoding: options, withFileTypes: false, recursive: false };
     const rawEntries = await _async.readdir.call(this, path, opt);
     const values = [];
@@ -755,11 +755,11 @@ export async function symlink(dest, path, type = 'file') {
     try {
         if (!['file', 'dir', 'junction'].includes(type))
             throw new TypeError('Invalid symlink type: ' + type);
-        path = normalizePath(path);
+        path = normalizePath.call(this, path);
         if (await exists.call(this, path))
             throw UV('EEXIST', 'symlink', path);
         const handle = __addDisposableResource(env_7, await _async.open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
-        const encoded = encodeUTF8(normalizePath(dest, true));
+        const encoded = encodeUTF8(normalizePath.call(this, dest, true));
         await handle.write(encoded, 0, encoded.length, 0);
         await handle.chmod(constants.S_IFLNK);
     }
@@ -775,7 +775,7 @@ export async function symlink(dest, path, type = 'file') {
 }
 symlink;
 export async function readlink(path, options) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const buf = Buffer.from(await _async.readlink.call(this, path), 'utf-8');
     const encoding = typeof options == 'object' ? options?.encoding : options;
     // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
@@ -824,7 +824,7 @@ lchown;
 export async function chmod(path, mode) {
     const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await open.call(this, path, 'r+').catch(rethrow({ syscall: 'chmod', path: normalizePath(path) })), true);
+        const handle = __addDisposableResource(env_10, await open.call(this, path, 'r+').catch(rethrow({ syscall: 'chmod', path: normalizePath.call(this, path) })), true);
         await handle.chmod(mode);
     }
     catch (e_10) {
@@ -911,7 +911,7 @@ export async function lutimes(path, atime, mtime) {
 lutimes;
 export async function realpath(path, options) {
     const encoding = typeof options == 'string' ? options : (options?.encoding ?? 'utf8');
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const { fullPath } = await _async.resolve(this, path);
     if (encoding == 'utf8' || encoding == 'utf-8')
         return fullPath;
@@ -976,7 +976,7 @@ access;
  * @param path The path to the file or directory to remove.
  */
 export async function rm(path, options) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const stats = await lstat.call(this, path).catch((error) => {
         if (error.code == 'ENOENT' && options?.force)
             return undefined;
@@ -1034,8 +1034,8 @@ export async function mkdtempDisposable(prefix, options) {
  *    * `fs.constants.COPYFILE_EXCL`: If the destination file already exists, the operation fails.
  */
 export async function copyFile(src, dest, mode) {
-    src = normalizePath(src);
-    dest = normalizePath(dest);
+    src = normalizePath.call(this, src);
+    dest = normalizePath.call(this, dest);
     if (mode && mode & constants.COPYFILE_EXCL && (await exists.call(this, dest)))
         throw UV('EEXIST', 'copyFile', dest);
     await writeFile.call(this, dest, await readFile.call(this, src));
@@ -1050,7 +1050,7 @@ copyFile;
  * @todo Use options
  */
 export function opendir(path, options) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     return Promise.resolve(new Dir(path, this));
 }
 opendir;
@@ -1067,8 +1067,8 @@ opendir;
  *   * `recursive`: If `true`, copies directories recursively.
  */
 export async function cp(source, destination, opts) {
-    source = normalizePath(source);
-    destination = normalizePath(destination);
+    source = normalizePath.call(this, source);
+    destination = normalizePath.call(this, destination);
     const srcStats = await lstat.call(this, source); // Use lstat to follow symlinks if not dereferencing
     if (opts?.errorOnExist && (await exists.call(this, destination)))
         throw UV('EEXIST', 'cp', destination);
@@ -1116,7 +1116,7 @@ export async function cp(source, destination, opts) {
 }
 cp;
 export async function statfs(path, opts) {
-    path = normalizePath(path);
+    path = normalizePath.call(this, path);
     const { fs } = resolveMount(path, this);
     return Promise.resolve(_statfs(fs, opts?.bigint));
 }