/* eslint-disable */
// @ts-nocheck

import fs from 'fs';
import {URL as URL$1, fileURLToPath, pathToFileURL} from 'url';
import path from 'path';
import {createHash} from 'crypto';
import {EOL} from 'os';
import esmModule, {createRequire, isBuiltin} from 'module';
import assert from 'assert';

const SAFE_TIME = 456789e3;

const PortablePath = {
    root: `/`,
    dot: `.`,
    parent: `..`
};
const npath = Object.create(path);
const ppath = Object.create(path.posix);
npath.cwd = () => process.cwd();
ppath.cwd = process.platform === `win32` ? () => toPortablePath(process.cwd()) : process.cwd;
if (process.platform === `win32`) {
    ppath.resolve = (...segments) => {
        if (segments.length > 0 && ppath.isAbsolute(segments[0])) {
            return path.posix.resolve(...segments);
        } else {
            return path.posix.resolve(ppath.cwd(), ...segments);
        }
    };
}
const contains = function (pathUtils, from, to) {
    from = pathUtils.normalize(from);
    to = pathUtils.normalize(to);
    if (from === to)
        return `.`;
    if (!from.endsWith(pathUtils.sep))
        from = from + pathUtils.sep;
    if (to.startsWith(from)) {
        return to.slice(from.length);
    } else {
        return null;
    }
};
npath.contains = (from, to) => contains(npath, from, to);
ppath.contains = (from, to) => contains(ppath, from, to);
const WINDOWS_PATH_REGEXP = /^([a-zA-Z]:.*)$/;
const UNC_WINDOWS_PATH_REGEXP = /^\/\/(\.\/)?(.*)$/;
const PORTABLE_PATH_REGEXP = /^\/([a-zA-Z]:.*)$/;
const UNC_PORTABLE_PATH_REGEXP = /^\/unc\/(\.dot\/)?(.*)$/;

function fromPortablePathWin32(p) {
    let portablePathMatch, uncPortablePathMatch;
    if (portablePathMatch = p.match(PORTABLE_PATH_REGEXP))
        p = portablePathMatch[1];
    else if (uncPortablePathMatch = p.match(UNC_PORTABLE_PATH_REGEXP))
        p = `\\\\${uncPortablePathMatch[1] ? `.\\` : ``}${uncPortablePathMatch[2]}`;
    else
        return p;
    return p.replace(/\//g, `\\`);
}

function toPortablePathWin32(p) {
    p = p.replace(/\\/g, `/`);
    let windowsPathMatch, uncWindowsPathMatch;
    if (windowsPathMatch = p.match(WINDOWS_PATH_REGEXP))
        p = `/${windowsPathMatch[1]}`;
    else if (uncWindowsPathMatch = p.match(UNC_WINDOWS_PATH_REGEXP))
        p = `/unc/${uncWindowsPathMatch[1] ? `.dot/` : ``}${uncWindowsPathMatch[2]}`;
    return p;
}

const toPortablePath = process.platform === `win32` ? toPortablePathWin32 : (p) => p;
const fromPortablePath = process.platform === `win32` ? fromPortablePathWin32 : (p) => p;
npath.fromPortablePath = fromPortablePath;
npath.toPortablePath = toPortablePath;

function convertPath(targetPathUtils, sourcePath) {
    return targetPathUtils === npath ? fromPortablePath(sourcePath) : toPortablePath(sourcePath);
}

const defaultTime = new Date(SAFE_TIME * 1e3);
const defaultTimeMs = defaultTime.getTime();

async function copyPromise(destinationFs, destination, sourceFs, source, opts) {
    const normalizedDestination = destinationFs.pathUtils.normalize(destination);
    const normalizedSource = sourceFs.pathUtils.normalize(source);
    const prelayout = [];
    const postlayout = [];
    const {atime, mtime} = opts.stableTime ? {
        atime: defaultTime,
        mtime: defaultTime
    } : await sourceFs.lstatPromise(normalizedSource);
    await destinationFs.mkdirpPromise(destinationFs.pathUtils.dirname(destination), {utimes: [atime, mtime]});
    await copyImpl(prelayout, postlayout, destinationFs, normalizedDestination, sourceFs, normalizedSource, {
        ...opts,
        didParentExist: true
    });
    for (const operation of prelayout)
        await operation();
    await Promise.all(postlayout.map((operation) => {
        return operation();
    }));
}

async function copyImpl(prelayout, postlayout, destinationFs, destination, sourceFs, source, opts) {
    const destinationStat = opts.didParentExist ? await maybeLStat(destinationFs, destination) : null;
    const sourceStat = await sourceFs.lstatPromise(source);
    const {atime, mtime} = opts.stableTime ? {atime: defaultTime, mtime: defaultTime} : sourceStat;
    let updated;
    switch (true) {
        case sourceStat.isDirectory(): {
            updated = await copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
        }
            break;
        case sourceStat.isFile(): {
            updated = await copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
        }
            break;
        case sourceStat.isSymbolicLink(): {
            updated = await copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
        }
            break;
        default: {
            throw new Error(`Unsupported file type (${sourceStat.mode})`);
        }
    }
    if (opts.linkStrategy?.type !== `HardlinkFromIndex` || !sourceStat.isFile()) {
        if (updated || destinationStat?.mtime?.getTime() !== mtime.getTime() || destinationStat?.atime?.getTime() !== atime.getTime()) {
            postlayout.push(() => destinationFs.lutimesPromise(destination, atime, mtime));
            updated = true;
        }
        if (destinationStat === null || (destinationStat.mode & 511) !== (sourceStat.mode & 511)) {
            postlayout.push(() => destinationFs.chmodPromise(destination, sourceStat.mode & 511));
            updated = true;
        }
    }
    return updated;
}

async function maybeLStat(baseFs, p) {
    try {
        return await baseFs.lstatPromise(p);
    } catch (e) {
        return null;
    }
}

async function copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
    if (destinationStat !== null && !destinationStat.isDirectory()) {
        if (opts.overwrite) {
            prelayout.push(async () => destinationFs.removePromise(destination));
            destinationStat = null;
        } else {
            return false;
        }
    }
    let updated = false;
    if (destinationStat === null) {
        prelayout.push(async () => {
            try {
                await destinationFs.mkdirPromise(destination, {mode: sourceStat.mode});
            } catch (err) {
                if (err.code !== `EEXIST`) {
                    throw err;
                }
            }
        });
        updated = true;
    }
    const entries = await sourceFs.readdirPromise(source);
    const nextOpts = opts.didParentExist && !destinationStat ? {...opts, didParentExist: false} : opts;
    if (opts.stableSort) {
        for (const entry of entries.sort()) {
            if (await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts)) {
                updated = true;
            }
        }
    } else {
        const entriesUpdateStatus = await Promise.all(entries.map(async (entry) => {
            await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts);
        }));
        if (entriesUpdateStatus.some((status) => status)) {
            updated = true;
        }
    }
    return updated;
}

async function copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, linkStrategy) {
    const sourceHash = await sourceFs.checksumFilePromise(source, {algorithm: `sha1`});
    const defaultMode = 420;
    const sourceMode = sourceStat.mode & 511;
    const indexFileName = `${sourceHash}${sourceMode !== defaultMode ? sourceMode.toString(8) : ``}`;
    const indexPath = destinationFs.pathUtils.join(linkStrategy.indexPath, sourceHash.slice(0, 2), `${indexFileName}.dat`);
    let AtomicBehavior;
    ((AtomicBehavior2) => {
        AtomicBehavior2[AtomicBehavior2["Lock"] = 0] = "Lock";
        AtomicBehavior2[AtomicBehavior2["Rename"] = 1] = "Rename";
    })(AtomicBehavior || (AtomicBehavior = {}));
    let atomicBehavior = 1 /* Rename */;
    let indexStat = await maybeLStat(destinationFs, indexPath);
    if (destinationStat) {
        const isDestinationHardlinkedFromIndex = indexStat && destinationStat.dev === indexStat.dev && destinationStat.ino === indexStat.ino;
        const isIndexModified = indexStat?.mtimeMs !== defaultTimeMs;
        if (isDestinationHardlinkedFromIndex) {
            if (isIndexModified && linkStrategy.autoRepair) {
                atomicBehavior = 0 /* Lock */;
                indexStat = null;
            }
        }
        if (!isDestinationHardlinkedFromIndex) {
            if (opts.overwrite) {
                prelayout.push(async () => destinationFs.removePromise(destination));
                destinationStat = null;
            } else {
                return false;
            }
        }
    }
    const tempPath = !indexStat && atomicBehavior === 1 /* Rename */ ? `${indexPath}.${Math.floor(Math.random() * 4294967296).toString(16).padStart(8, `0`)}` : null;
    let tempPathCleaned = false;
    prelayout.push(async () => {
        if (!indexStat) {
            if (atomicBehavior === 0 /* Lock */) {
                await destinationFs.lockPromise(indexPath, async () => {
                    const content = await sourceFs.readFilePromise(source);
                    await destinationFs.writeFilePromise(indexPath, content);
                });
            }
            if (atomicBehavior === 1 /* Rename */ && tempPath) {
                const content = await sourceFs.readFilePromise(source);
                await destinationFs.writeFilePromise(tempPath, content);
                try {
                    await destinationFs.linkPromise(tempPath, indexPath);
                } catch (err) {
                    if (err.code === `EEXIST`) {
                        tempPathCleaned = true;
                        await destinationFs.unlinkPromise(tempPath);
                    } else {
                        throw err;
                    }
                }
            }
        }
        if (!destinationStat) {
            await destinationFs.linkPromise(indexPath, destination);
        }
    });
    postlayout.push(async () => {
        if (!indexStat) {
            await destinationFs.lutimesPromise(indexPath, defaultTime, defaultTime);
            if (sourceMode !== defaultMode) {
                await destinationFs.chmodPromise(indexPath, sourceMode);
            }
        }
        if (tempPath && !tempPathCleaned) {
            await destinationFs.unlinkPromise(tempPath);
        }
    });
    return false;
}

async function copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
    if (destinationStat !== null) {
        if (opts.overwrite) {
            prelayout.push(async () => destinationFs.removePromise(destination));
            destinationStat = null;
        } else {
            return false;
        }
    }
    prelayout.push(async () => {
        const content = await sourceFs.readFilePromise(source);
        await destinationFs.writeFilePromise(destination, content);
    });
    return true;
}

async function copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
    if (opts.linkStrategy?.type === `HardlinkFromIndex`) {
        return copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, opts.linkStrategy);
    } else {
        return copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
    }
}

async function copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
    if (destinationStat !== null) {
        if (opts.overwrite) {
            prelayout.push(async () => destinationFs.removePromise(destination));
            destinationStat = null;
        } else {
            return false;
        }
    }
    prelayout.push(async () => {
        await destinationFs.symlinkPromise(convertPath(destinationFs.pathUtils, await sourceFs.readlinkPromise(source)), destination);
    });
    return true;
}

class FakeFS {
    pathUtils;

    constructor(pathUtils) {
        this.pathUtils = pathUtils;
    }

    async* genTraversePromise(init, {stableSort = false} = {}) {
        const stack = [init];
        while (stack.length > 0) {
            const p = stack.shift();
            const entry = await this.lstatPromise(p);
            if (entry.isDirectory()) {
                const entries = await this.readdirPromise(p);
                if (stableSort) {
                    for (const entry2 of entries.sort()) {
                        stack.push(this.pathUtils.join(p, entry2));
                    }
                } else {
                    throw new Error(`Not supported`);
                }
            } else {
                yield p;
            }
        }
    }

    async checksumFilePromise(path, {algorithm = `sha512`} = {}) {
        const fd = await this.openPromise(path, `r`);
        try {
            const CHUNK_SIZE = 65536;
            const chunk = Buffer.allocUnsafeSlow(CHUNK_SIZE);
            const hash = createHash(algorithm);
            let bytesRead = 0;
            while ((bytesRead = await this.readPromise(fd, chunk, 0, CHUNK_SIZE)) !== 0)
                hash.update(bytesRead === CHUNK_SIZE ? chunk : chunk.slice(0, bytesRead));
            return hash.digest(`hex`);
        } finally {
            await this.closePromise(fd);
        }
    }

    async removePromise(p, {recursive = true, maxRetries = 5} = {}) {
        let stat;
        try {
            stat = await this.lstatPromise(p);
        } catch (error) {
            if (error.code === `ENOENT`) {
                return;
            } else {
                throw error;
            }
        }
        if (stat.isDirectory()) {
            if (recursive) {
                const entries = await this.readdirPromise(p);
                await Promise.all(entries.map((entry) => {
                    return this.removePromise(this.pathUtils.resolve(p, entry));
                }));
            }
            for (let t = 0; t <= maxRetries; t++) {
                try {
                    await this.rmdirPromise(p);
                    break;
                } catch (error) {
                    if (error.code !== `EBUSY` && error.code !== `ENOTEMPTY`) {
                        throw error;
                    } else if (t < maxRetries) {
                        await new Promise((resolve) => setTimeout(resolve, t * 100));
                    }
                }
            }
        } else {
            await this.unlinkPromise(p);
        }
    }

    removeSync(p, {recursive = true} = {}) {
        let stat;
        try {
            stat = this.lstatSync(p);
        } catch (error) {
            if (error.code === `ENOENT`) {
                return;
            } else {
                throw error;
            }
        }
        if (stat.isDirectory()) {
            if (recursive)
                for (const entry of this.readdirSync(p))
                    this.removeSync(this.pathUtils.resolve(p, entry));
            this.rmdirSync(p);
        } else {
            this.unlinkSync(p);
        }
    }

    async mkdirpPromise(p, {chmod, utimes} = {}) {
        p = this.resolve(p);
        if (p === this.pathUtils.dirname(p))
            return void 0;
        const parts = p.split(this.pathUtils.sep);
        let createdDirectory;
        for (let u = 2; u <= parts.length; ++u) {
            const subPath = parts.slice(0, u).join(this.pathUtils.sep);
            if (!this.existsSync(subPath)) {
                try {
                    await this.mkdirPromise(subPath);
                } catch (error) {
                    if (error.code === `EEXIST`) {
                        continue;
                    } else {
                        throw error;
                    }
                }
                createdDirectory ??= subPath;
                if (chmod != null)
                    await this.chmodPromise(subPath, chmod);
                if (utimes != null) {
                    await this.utimesPromise(subPath, utimes[0], utimes[1]);
                } else {
                    const parentStat = await this.statPromise(this.pathUtils.dirname(subPath));
                    await this.utimesPromise(subPath, parentStat.atime, parentStat.mtime);
                }
            }
        }
        return createdDirectory;
    }

    mkdirpSync(p, {chmod, utimes} = {}) {
        p = this.resolve(p);
        if (p === this.pathUtils.dirname(p))
            return void 0;
        const parts = p.split(this.pathUtils.sep);
        let createdDirectory;
        for (let u = 2; u <= parts.length; ++u) {
            const subPath = parts.slice(0, u).join(this.pathUtils.sep);
            if (!this.existsSync(subPath)) {
                try {
                    this.mkdirSync(subPath);
                } catch (error) {
                    if (error.code === `EEXIST`) {
                        continue;
                    } else {
                        throw error;
                    }
                }
                createdDirectory ??= subPath;
                if (chmod != null)
                    this.chmodSync(subPath, chmod);
                if (utimes != null) {
                    this.utimesSync(subPath, utimes[0], utimes[1]);
                } else {
                    const parentStat = this.statSync(this.pathUtils.dirname(subPath));
                    this.utimesSync(subPath, parentStat.atime, parentStat.mtime);
                }
            }
        }
        return createdDirectory;
    }

    async copyPromise(destination, source, {
        baseFs = this,
        overwrite = true,
        stableSort = false,
        stableTime = false,
        linkStrategy = null
    } = {}) {
        return await copyPromise(this, destination, baseFs, source, {overwrite, stableSort, stableTime, linkStrategy});
    }

    copySync(destination, source, {baseFs = this, overwrite = true} = {}) {
        const stat = baseFs.lstatSync(source);
        const exists = this.existsSync(destination);
        if (stat.isDirectory()) {
            this.mkdirpSync(destination);
            const directoryListing = baseFs.readdirSync(source);
            for (const entry of directoryListing) {
                this.copySync(this.pathUtils.join(destination, entry), baseFs.pathUtils.join(source, entry), {
                    baseFs,
                    overwrite
                });
            }
        } else if (stat.isFile()) {
            if (!exists || overwrite) {
                if (exists)
                    this.removeSync(destination);
                const content = baseFs.readFileSync(source);
                this.writeFileSync(destination, content);
            }
        } else if (stat.isSymbolicLink()) {
            if (!exists || overwrite) {
                if (exists)
                    this.removeSync(destination);
                const target = baseFs.readlinkSync(source);
                this.symlinkSync(convertPath(this.pathUtils, target), destination);
            }
        } else {
            throw new Error(`Unsupported file type (file: ${source}, mode: 0o${stat.mode.toString(8).padStart(6, `0`)})`);
        }
        const mode = stat.mode & 511;
        this.chmodSync(destination, mode);
    }

    async changeFilePromise(p, content, opts = {}) {
        if (Buffer.isBuffer(content)) {
            return this.changeFileBufferPromise(p, content, opts);
        } else {
            return this.changeFileTextPromise(p, content, opts);
        }
    }

    async changeFileBufferPromise(p, content, {mode} = {}) {
        let current = Buffer.alloc(0);
        try {
            current = await this.readFilePromise(p);
        } catch (error) {
        }
        if (Buffer.compare(current, content) === 0)
            return;
        await this.writeFilePromise(p, content, {mode});
    }

    async changeFileTextPromise(p, content, {automaticNewlines, mode} = {}) {
        let current = ``;
        try {
            current = await this.readFilePromise(p, `utf8`);
        } catch (error) {
        }
        const normalizedContent = automaticNewlines ? normalizeLineEndings(current, content) : content;
        if (current === normalizedContent)
            return;
        await this.writeFilePromise(p, normalizedContent, {mode});
    }

    changeFileSync(p, content, opts = {}) {
        if (Buffer.isBuffer(content)) {
            return this.changeFileBufferSync(p, content, opts);
        } else {
            return this.changeFileTextSync(p, content, opts);
        }
    }

    changeFileBufferSync(p, content, {mode} = {}) {
        let current = Buffer.alloc(0);
        try {
            current = this.readFileSync(p);
        } catch (error) {
        }
        if (Buffer.compare(current, content) === 0)
            return;
        this.writeFileSync(p, content, {mode});
    }

    changeFileTextSync(p, content, {automaticNewlines = false, mode} = {}) {
        let current = ``;
        try {
            current = this.readFileSync(p, `utf8`);
        } catch (error) {
        }
        const normalizedContent = automaticNewlines ? normalizeLineEndings(current, content) : content;
        if (current === normalizedContent)
            return;
        this.writeFileSync(p, normalizedContent, {mode});
    }

    async movePromise(fromP, toP) {
        try {
            await this.renamePromise(fromP, toP);
        } catch (error) {
            if (error.code === `EXDEV`) {
                await this.copyPromise(toP, fromP);
                await this.removePromise(fromP);
            } else {
                throw error;
            }
        }
    }

    moveSync(fromP, toP) {
        try {
            this.renameSync(fromP, toP);
        } catch (error) {
            if (error.code === `EXDEV`) {
                this.copySync(toP, fromP);
                this.removeSync(fromP);
            } else {
                throw error;
            }
        }
    }

    async lockPromise(affectedPath, callback) {
        const lockPath = `${affectedPath}.flock`;
        const interval = 1e3 / 60;
        const startTime = Date.now();
        let fd = null;
        const isAlive = async () => {
            let pid;
            try {
                [pid] = await this.readJsonPromise(lockPath);
            } catch (error) {
                return Date.now() - startTime < 500;
            }
            try {
                process.kill(pid, 0);
                return true;
            } catch (error) {
                return false;
            }
        };
        while (fd === null) {
            try {
                fd = await this.openPromise(lockPath, `wx`);
            } catch (error) {
                if (error.code === `EEXIST`) {
                    if (!await isAlive()) {
                        try {
                            await this.unlinkPromise(lockPath);
                            continue;
                        } catch (error2) {
                        }
                    }
                    if (Date.now() - startTime < 60 * 1e3) {
                        await new Promise((resolve) => setTimeout(resolve, interval));
                    } else {
                        throw new Error(`Couldn't acquire a lock in a reasonable time (via ${lockPath})`);
                    }
                } else {
                    throw error;
                }
            }
        }
        await this.writePromise(fd, JSON.stringify([process.pid]));
        try {
            return await callback();
        } finally {
            try {
                await this.closePromise(fd);
                await this.unlinkPromise(lockPath);
            } catch (error) {
            }
        }
    }

    async readJsonPromise(p) {
        const content = await this.readFilePromise(p, `utf8`);
        try {
            return JSON.parse(content);
        } catch (error) {
            error.message += ` (in ${p})`;
            throw error;
        }
    }

    readJsonSync(p) {
        const content = this.readFileSync(p, `utf8`);
        try {
            return JSON.parse(content);
        } catch (error) {
            error.message += ` (in ${p})`;
            throw error;
        }
    }

    async writeJsonPromise(p, data, {compact = false} = {}) {
        const space = compact ? 0 : 2;
        return await this.writeFilePromise(p, `${JSON.stringify(data, null, space)}
`);
    }

    writeJsonSync(p, data, {compact = false} = {}) {
        const space = compact ? 0 : 2;
        return this.writeFileSync(p, `${JSON.stringify(data, null, space)}
`);
    }

    async preserveTimePromise(p, cb) {
        const stat = await this.lstatPromise(p);
        const result = await cb();
        if (typeof result !== `undefined`)
            p = result;
        await this.lutimesPromise(p, stat.atime, stat.mtime);
    }

    async preserveTimeSync(p, cb) {
        const stat = this.lstatSync(p);
        const result = cb();
        if (typeof result !== `undefined`)
            p = result;
        this.lutimesSync(p, stat.atime, stat.mtime);
    }
}

class BasePortableFakeFS extends FakeFS {
    constructor() {
        super(ppath);
    }
}

function getEndOfLine(content) {
    const matches = content.match(/\r?\n/g);
    if (matches === null)
        return EOL;
    const crlf = matches.filter((nl) => nl === `\r
`).length;
    const lf = matches.length - crlf;
    return crlf > lf ? `\r
` : `
`;
}

function normalizeLineEndings(originalContent, newContent) {
    return newContent.replace(/\r?\n/g, getEndOfLine(originalContent));
}

class ProxiedFS extends FakeFS {
    getExtractHint(hints) {
        return this.baseFs.getExtractHint(hints);
    }

    resolve(path) {
        return this.mapFromBase(this.baseFs.resolve(this.mapToBase(path)));
    }

    getRealPath() {
        return this.mapFromBase(this.baseFs.getRealPath());
    }

    async openPromise(p, flags, mode) {
        return this.baseFs.openPromise(this.mapToBase(p), flags, mode);
    }

    openSync(p, flags, mode) {
        return this.baseFs.openSync(this.mapToBase(p), flags, mode);
    }

    async opendirPromise(p, opts) {
        return Object.assign(await this.baseFs.opendirPromise(this.mapToBase(p), opts), {path: p});
    }

    opendirSync(p, opts) {
        return Object.assign(this.baseFs.opendirSync(this.mapToBase(p), opts), {path: p});
    }

    async readPromise(fd, buffer, offset, length, position) {
        return await this.baseFs.readPromise(fd, buffer, offset, length, position);
    }

    readSync(fd, buffer, offset, length, position) {
        return this.baseFs.readSync(fd, buffer, offset, length, position);
    }

    async writePromise(fd, buffer, offset, length, position) {
        if (typeof buffer === `string`) {
            return await this.baseFs.writePromise(fd, buffer, offset);
        } else {
            return await this.baseFs.writePromise(fd, buffer, offset, length, position);
        }
    }

    writeSync(fd, buffer, offset, length, position) {
        if (typeof buffer === `string`) {
            return this.baseFs.writeSync(fd, buffer, offset);
        } else {
            return this.baseFs.writeSync(fd, buffer, offset, length, position);
        }
    }

    async closePromise(fd) {
        return this.baseFs.closePromise(fd);
    }

    closeSync(fd) {
        this.baseFs.closeSync(fd);
    }

    createReadStream(p, opts) {
        return this.baseFs.createReadStream(p !== null ? this.mapToBase(p) : p, opts);
    }

    createWriteStream(p, opts) {
        return this.baseFs.createWriteStream(p !== null ? this.mapToBase(p) : p, opts);
    }

    async realpathPromise(p) {
        return this.mapFromBase(await this.baseFs.realpathPromise(this.mapToBase(p)));
    }

    realpathSync(p) {
        return this.mapFromBase(this.baseFs.realpathSync(this.mapToBase(p)));
    }

    async existsPromise(p) {
        return this.baseFs.existsPromise(this.mapToBase(p));
    }

    existsSync(p) {
        return this.baseFs.existsSync(this.mapToBase(p));
    }

    accessSync(p, mode) {
        return this.baseFs.accessSync(this.mapToBase(p), mode);
    }

    async accessPromise(p, mode) {
        return this.baseFs.accessPromise(this.mapToBase(p), mode);
    }

    async statPromise(p, opts) {
        return this.baseFs.statPromise(this.mapToBase(p), opts);
    }

    statSync(p, opts) {
        return this.baseFs.statSync(this.mapToBase(p), opts);
    }

    async fstatPromise(fd, opts) {
        return this.baseFs.fstatPromise(fd, opts);
    }

    fstatSync(fd, opts) {
        return this.baseFs.fstatSync(fd, opts);
    }

    lstatPromise(p, opts) {
        return this.baseFs.lstatPromise(this.mapToBase(p), opts);
    }

    lstatSync(p, opts) {
        return this.baseFs.lstatSync(this.mapToBase(p), opts);
    }

    async fchmodPromise(fd, mask) {
        return this.baseFs.fchmodPromise(fd, mask);
    }

    fchmodSync(fd, mask) {
        return this.baseFs.fchmodSync(fd, mask);
    }

    async chmodPromise(p, mask) {
        return this.baseFs.chmodPromise(this.mapToBase(p), mask);
    }

    chmodSync(p, mask) {
        return this.baseFs.chmodSync(this.mapToBase(p), mask);
    }

    async fchownPromise(fd, uid, gid) {
        return this.baseFs.fchownPromise(fd, uid, gid);
    }

    fchownSync(fd, uid, gid) {
        return this.baseFs.fchownSync(fd, uid, gid);
    }

    async chownPromise(p, uid, gid) {
        return this.baseFs.chownPromise(this.mapToBase(p), uid, gid);
    }

    chownSync(p, uid, gid) {
        return this.baseFs.chownSync(this.mapToBase(p), uid, gid);
    }

    async renamePromise(oldP, newP) {
        return this.baseFs.renamePromise(this.mapToBase(oldP), this.mapToBase(newP));
    }

    renameSync(oldP, newP) {
        return this.baseFs.renameSync(this.mapToBase(oldP), this.mapToBase(newP));
    }

    async copyFilePromise(sourceP, destP, flags = 0) {
        return this.baseFs.copyFilePromise(this.mapToBase(sourceP), this.mapToBase(destP), flags);
    }

    copyFileSync(sourceP, destP, flags = 0) {
        return this.baseFs.copyFileSync(this.mapToBase(sourceP), this.mapToBase(destP), flags);
    }

    async appendFilePromise(p, content, opts) {
        return this.baseFs.appendFilePromise(this.fsMapToBase(p), content, opts);
    }

    appendFileSync(p, content, opts) {
        return this.baseFs.appendFileSync(this.fsMapToBase(p), content, opts);
    }

    async writeFilePromise(p, content, opts) {
        return this.baseFs.writeFilePromise(this.fsMapToBase(p), content, opts);
    }

    writeFileSync(p, content, opts) {
        return this.baseFs.writeFileSync(this.fsMapToBase(p), content, opts);
    }

    async unlinkPromise(p) {
        return this.baseFs.unlinkPromise(this.mapToBase(p));
    }

    unlinkSync(p) {
        return this.baseFs.unlinkSync(this.mapToBase(p));
    }

    async utimesPromise(p, atime, mtime) {
        return this.baseFs.utimesPromise(this.mapToBase(p), atime, mtime);
    }

    utimesSync(p, atime, mtime) {
        return this.baseFs.utimesSync(this.mapToBase(p), atime, mtime);
    }

    async lutimesPromise(p, atime, mtime) {
        return this.baseFs.lutimesPromise(this.mapToBase(p), atime, mtime);
    }

    lutimesSync(p, atime, mtime) {
        return this.baseFs.lutimesSync(this.mapToBase(p), atime, mtime);
    }

    async mkdirPromise(p, opts) {
        return this.baseFs.mkdirPromise(this.mapToBase(p), opts);
    }

    mkdirSync(p, opts) {
        return this.baseFs.mkdirSync(this.mapToBase(p), opts);
    }

    async rmdirPromise(p, opts) {
        return this.baseFs.rmdirPromise(this.mapToBase(p), opts);
    }

    rmdirSync(p, opts) {
        return this.baseFs.rmdirSync(this.mapToBase(p), opts);
    }

    async rmPromise(p, opts) {
        return this.baseFs.rmPromise(this.mapToBase(p), opts);
    }

    rmSync(p, opts) {
        return this.baseFs.rmSync(this.mapToBase(p), opts);
    }

    async linkPromise(existingP, newP) {
        return this.baseFs.linkPromise(this.mapToBase(existingP), this.mapToBase(newP));
    }

    linkSync(existingP, newP) {
        return this.baseFs.linkSync(this.mapToBase(existingP), this.mapToBase(newP));
    }

    async symlinkPromise(target, p, type) {
        const mappedP = this.mapToBase(p);
        if (this.pathUtils.isAbsolute(target))
            return this.baseFs.symlinkPromise(this.mapToBase(target), mappedP, type);
        const mappedAbsoluteTarget = this.mapToBase(this.pathUtils.join(this.pathUtils.dirname(p), target));
        const mappedTarget = this.baseFs.pathUtils.relative(this.baseFs.pathUtils.dirname(mappedP), mappedAbsoluteTarget);
        return this.baseFs.symlinkPromise(mappedTarget, mappedP, type);
    }

    symlinkSync(target, p, type) {
        const mappedP = this.mapToBase(p);
        if (this.pathUtils.isAbsolute(target))
            return this.baseFs.symlinkSync(this.mapToBase(target), mappedP, type);
        const mappedAbsoluteTarget = this.mapToBase(this.pathUtils.join(this.pathUtils.dirname(p), target));
        const mappedTarget = this.baseFs.pathUtils.relative(this.baseFs.pathUtils.dirname(mappedP), mappedAbsoluteTarget);
        return this.baseFs.symlinkSync(mappedTarget, mappedP, type);
    }

    async readFilePromise(p, encoding) {
        return this.baseFs.readFilePromise(this.fsMapToBase(p), encoding);
    }

    readFileSync(p, encoding) {
        return this.baseFs.readFileSync(this.fsMapToBase(p), encoding);
    }

    readdirPromise(p, opts) {
        return this.baseFs.readdirPromise(this.mapToBase(p), opts);
    }

    readdirSync(p, opts) {
        return this.baseFs.readdirSync(this.mapToBase(p), opts);
    }

    async readlinkPromise(p) {
        return this.mapFromBase(await this.baseFs.readlinkPromise(this.mapToBase(p)));
    }

    readlinkSync(p) {
        return this.mapFromBase(this.baseFs.readlinkSync(this.mapToBase(p)));
    }

    async truncatePromise(p, len) {
        return this.baseFs.truncatePromise(this.mapToBase(p), len);
    }

    truncateSync(p, len) {
        return this.baseFs.truncateSync(this.mapToBase(p), len);
    }

    async ftruncatePromise(fd, len) {
        return this.baseFs.ftruncatePromise(fd, len);
    }

    ftruncateSync(fd, len) {
        return this.baseFs.ftruncateSync(fd, len);
    }

    watch(p, a, b) {
        return this.baseFs.watch(
            this.mapToBase(p),
            // @ts-expect-error
            a,
            b
        );
    }

    watchFile(p, a, b) {
        return this.baseFs.watchFile(
            this.mapToBase(p),
            // @ts-expect-error
            a,
            b
        );
    }

    unwatchFile(p, cb) {
        return this.baseFs.unwatchFile(this.mapToBase(p), cb);
    }

    fsMapToBase(p) {
        if (typeof p === `number`) {
            return p;
        } else {
            return this.mapToBase(p);
        }
    }
}

function direntToPortable(dirent) {
    const portableDirent = dirent;
    if (typeof dirent.path === `string`)
        portableDirent.path = npath.toPortablePath(dirent.path);
    return portableDirent;
}

class NodeFS extends BasePortableFakeFS {
    realFs;

    constructor(realFs = fs) {
        super();
        this.realFs = realFs;
    }

    getExtractHint() {
        return false;
    }

    getRealPath() {
        return PortablePath.root;
    }

    resolve(p) {
        return ppath.resolve(p);
    }

    async openPromise(p, flags, mode) {
        return await new Promise((resolve, reject) => {
            this.realFs.open(npath.fromPortablePath(p), flags, mode, this.makeCallback(resolve, reject));
        });
    }

    openSync(p, flags, mode) {
        return this.realFs.openSync(npath.fromPortablePath(p), flags, mode);
    }

    async opendirPromise(p, opts) {
        return await new Promise((resolve, reject) => {
            if (typeof opts !== `undefined`) {
                this.realFs.opendir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.opendir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
            }
        }).then((dir) => {
            const dirWithFixedPath = dir;
            Object.defineProperty(dirWithFixedPath, `path`, {
                value: p,
                configurable: true,
                writable: true
            });
            return dirWithFixedPath;
        });
    }

    opendirSync(p, opts) {
        const dir = typeof opts !== `undefined` ? this.realFs.opendirSync(npath.fromPortablePath(p), opts) : this.realFs.opendirSync(npath.fromPortablePath(p));
        const dirWithFixedPath = dir;
        Object.defineProperty(dirWithFixedPath, `path`, {
            value: p,
            configurable: true,
            writable: true
        });
        return dirWithFixedPath;
    }

    async readPromise(fd, buffer, offset = 0, length = 0, position = -1) {
        return await new Promise((resolve, reject) => {
            this.realFs.read(fd, buffer, offset, length, position, (error, bytesRead) => {
                if (error) {
                    reject(error);
                } else {
                    resolve(bytesRead);
                }
            });
        });
    }

    readSync(fd, buffer, offset, length, position) {
        return this.realFs.readSync(fd, buffer, offset, length, position);
    }

    async writePromise(fd, buffer, offset, length, position) {
        return await new Promise((resolve, reject) => {
            if (typeof buffer === `string`) {
                return this.realFs.write(fd, buffer, offset, this.makeCallback(resolve, reject));
            } else {
                return this.realFs.write(fd, buffer, offset, length, position, this.makeCallback(resolve, reject));
            }
        });
    }

    writeSync(fd, buffer, offset, length, position) {
        if (typeof buffer === `string`) {
            return this.realFs.writeSync(fd, buffer, offset);
        } else {
            return this.realFs.writeSync(fd, buffer, offset, length, position);
        }
    }

    async closePromise(fd) {
        await new Promise((resolve, reject) => {
            this.realFs.close(fd, this.makeCallback(resolve, reject));
        });
    }

    closeSync(fd) {
        this.realFs.closeSync(fd);
    }

    createReadStream(p, opts) {
        const realPath = p !== null ? npath.fromPortablePath(p) : p;
        return this.realFs.createReadStream(realPath, opts);
    }

    createWriteStream(p, opts) {
        const realPath = p !== null ? npath.fromPortablePath(p) : p;
        return this.realFs.createWriteStream(realPath, opts);
    }

    async realpathPromise(p) {
        return await new Promise((resolve, reject) => {
            this.realFs.realpath(npath.fromPortablePath(p), {}, this.makeCallback(resolve, reject));
        }).then((path) => {
            return npath.toPortablePath(path);
        });
    }

    realpathSync(p) {
        return npath.toPortablePath(this.realFs.realpathSync(npath.fromPortablePath(p), {}));
    }

    async existsPromise(p) {
        return await new Promise((resolve) => {
            this.realFs.exists(npath.fromPortablePath(p), resolve);
        });
    }

    accessSync(p, mode) {
        return this.realFs.accessSync(npath.fromPortablePath(p), mode);
    }

    async accessPromise(p, mode) {
        return await new Promise((resolve, reject) => {
            this.realFs.access(npath.fromPortablePath(p), mode, this.makeCallback(resolve, reject));
        });
    }

    existsSync(p) {
        return this.realFs.existsSync(npath.fromPortablePath(p));
    }

    async statPromise(p, opts) {
        return await new Promise((resolve, reject) => {
            if (opts) {
                this.realFs.stat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.stat(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
            }
        });
    }

    statSync(p, opts) {
        if (opts) {
            return this.realFs.statSync(npath.fromPortablePath(p), opts);
        } else {
            return this.realFs.statSync(npath.fromPortablePath(p));
        }
    }

    async fstatPromise(fd, opts) {
        return await new Promise((resolve, reject) => {
            if (opts) {
                this.realFs.fstat(fd, opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.fstat(fd, this.makeCallback(resolve, reject));
            }
        });
    }

    fstatSync(fd, opts) {
        if (opts) {
            return this.realFs.fstatSync(fd, opts);
        } else {
            return this.realFs.fstatSync(fd);
        }
    }

    async lstatPromise(p, opts) {
        return await new Promise((resolve, reject) => {
            if (opts) {
                this.realFs.lstat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.lstat(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
            }
        });
    }

    lstatSync(p, opts) {
        if (opts) {
            return this.realFs.lstatSync(npath.fromPortablePath(p), opts);
        } else {
            return this.realFs.lstatSync(npath.fromPortablePath(p));
        }
    }

    async fchmodPromise(fd, mask) {
        return await new Promise((resolve, reject) => {
            this.realFs.fchmod(fd, mask, this.makeCallback(resolve, reject));
        });
    }

    fchmodSync(fd, mask) {
        return this.realFs.fchmodSync(fd, mask);
    }

    async chmodPromise(p, mask) {
        return await new Promise((resolve, reject) => {
            this.realFs.chmod(npath.fromPortablePath(p), mask, this.makeCallback(resolve, reject));
        });
    }

    chmodSync(p, mask) {
        return this.realFs.chmodSync(npath.fromPortablePath(p), mask);
    }

    async fchownPromise(fd, uid, gid) {
        return await new Promise((resolve, reject) => {
            this.realFs.fchown(fd, uid, gid, this.makeCallback(resolve, reject));
        });
    }

    fchownSync(fd, uid, gid) {
        return this.realFs.fchownSync(fd, uid, gid);
    }

    async chownPromise(p, uid, gid) {
        return await new Promise((resolve, reject) => {
            this.realFs.chown(npath.fromPortablePath(p), uid, gid, this.makeCallback(resolve, reject));
        });
    }

    chownSync(p, uid, gid) {
        return this.realFs.chownSync(npath.fromPortablePath(p), uid, gid);
    }

    async renamePromise(oldP, newP) {
        return await new Promise((resolve, reject) => {
            this.realFs.rename(npath.fromPortablePath(oldP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject));
        });
    }

    renameSync(oldP, newP) {
        return this.realFs.renameSync(npath.fromPortablePath(oldP), npath.fromPortablePath(newP));
    }

    async copyFilePromise(sourceP, destP, flags = 0) {
        return await new Promise((resolve, reject) => {
            this.realFs.copyFile(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags, this.makeCallback(resolve, reject));
        });
    }

    copyFileSync(sourceP, destP, flags = 0) {
        return this.realFs.copyFileSync(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags);
    }

    async appendFilePromise(p, content, opts) {
        return await new Promise((resolve, reject) => {
            const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
            if (opts) {
                this.realFs.appendFile(fsNativePath, content, opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.appendFile(fsNativePath, content, this.makeCallback(resolve, reject));
            }
        });
    }

    appendFileSync(p, content, opts) {
        const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
        if (opts) {
            this.realFs.appendFileSync(fsNativePath, content, opts);
        } else {
            this.realFs.appendFileSync(fsNativePath, content);
        }
    }

    async writeFilePromise(p, content, opts) {
        return await new Promise((resolve, reject) => {
            const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
            if (opts) {
                this.realFs.writeFile(fsNativePath, content, opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.writeFile(fsNativePath, content, this.makeCallback(resolve, reject));
            }
        });
    }

    writeFileSync(p, content, opts) {
        const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
        if (opts) {
            this.realFs.writeFileSync(fsNativePath, content, opts);
        } else {
            this.realFs.writeFileSync(fsNativePath, content);
        }
    }

    async unlinkPromise(p) {
        return await new Promise((resolve, reject) => {
            this.realFs.unlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
        });
    }

    unlinkSync(p) {
        return this.realFs.unlinkSync(npath.fromPortablePath(p));
    }

    async utimesPromise(p, atime, mtime) {
        return await new Promise((resolve, reject) => {
            this.realFs.utimes(npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject));
        });
    }

    utimesSync(p, atime, mtime) {
        this.realFs.utimesSync(npath.fromPortablePath(p), atime, mtime);
    }

    async lutimesPromise(p, atime, mtime) {
        return await new Promise((resolve, reject) => {
            this.realFs.lutimes(npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject));
        });
    }

    lutimesSync(p, atime, mtime) {
        this.realFs.lutimesSync(npath.fromPortablePath(p), atime, mtime);
    }

    async mkdirPromise(p, opts) {
        return await new Promise((resolve, reject) => {
            this.realFs.mkdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
        });
    }

    mkdirSync(p, opts) {
        return this.realFs.mkdirSync(npath.fromPortablePath(p), opts);
    }

    async rmdirPromise(p, opts) {
        return await new Promise((resolve, reject) => {
            if (opts) {
                this.realFs.rmdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.rmdir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
            }
        });
    }

    rmdirSync(p, opts) {
        return this.realFs.rmdirSync(npath.fromPortablePath(p), opts);
    }

    async rmPromise(p, opts) {
        return await new Promise((resolve, reject) => {
            if (opts) {
                this.realFs.rm(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
            } else {
                this.realFs.rm(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
            }
        });
    }

    rmSync(p, opts) {
        return this.realFs.rmSync(npath.fromPortablePath(p), opts);
    }

    async linkPromise(existingP, newP) {
        return await new Promise((resolve, reject) => {
            this.realFs.link(npath.fromPortablePath(existingP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject));
        });
    }

    linkSync(existingP, newP) {
        return this.realFs.linkSync(npath.fromPortablePath(existingP), npath.fromPortablePath(newP));
    }

    async symlinkPromise(target, p, type) {
        return await new Promise((resolve, reject) => {
            this.realFs.symlink(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type, this.makeCallback(resolve, reject));
        });
    }

    symlinkSync(target, p, type) {
        return this.realFs.symlinkSync(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type);
    }

    async readFilePromise(p, encoding) {
        return await new Promise((resolve, reject) => {
            const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
            this.realFs.readFile(fsNativePath, encoding, this.makeCallback(resolve, reject));
        });
    }

    readFileSync(p, encoding) {
        const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p;
        return this.realFs.readFileSync(fsNativePath, encoding);
    }

    async readdirPromise(p, opts) {
        return await new Promise((resolve, reject) => {
            if (opts) {
                if (opts.recursive && process.platform === `win32`) {
                    if (opts.withFileTypes) {
                        this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback((results) => resolve(results.map(direntToPortable)), reject));
                    } else {
                        this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback((results) => resolve(results.map(npath.toPortablePath)), reject));
                    }
                } else {
                    this.realFs.readdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject));
                }
            } else {
                this.realFs.readdir(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
            }
        });
    }

    readdirSync(p, opts) {
        if (opts) {
            if (opts.recursive && process.platform === `win32`) {
                if (opts.withFileTypes) {
                    return this.realFs.readdirSync(npath.fromPortablePath(p), opts).map(direntToPortable);
                } else {
                    return this.realFs.readdirSync(npath.fromPortablePath(p), opts).map(npath.toPortablePath);
                }
            } else {
                return this.realFs.readdirSync(npath.fromPortablePath(p), opts);
            }
        } else {
            return this.realFs.readdirSync(npath.fromPortablePath(p));
        }
    }

    async readlinkPromise(p) {
        return await new Promise((resolve, reject) => {
            this.realFs.readlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject));
        }).then((path) => {
            return npath.toPortablePath(path);
        });
    }

    readlinkSync(p) {
        return npath.toPortablePath(this.realFs.readlinkSync(npath.fromPortablePath(p)));
    }

    async truncatePromise(p, len) {
        return await new Promise((resolve, reject) => {
            this.realFs.truncate(npath.fromPortablePath(p), len, this.makeCallback(resolve, reject));
        });
    }

    truncateSync(p, len) {
        return this.realFs.truncateSync(npath.fromPortablePath(p), len);
    }

    async ftruncatePromise(fd, len) {
        return await new Promise((resolve, reject) => {
            this.realFs.ftruncate(fd, len, this.makeCallback(resolve, reject));
        });
    }

    ftruncateSync(fd, len) {
        return this.realFs.ftruncateSync(fd, len);
    }

    watch(p, a, b) {
        return this.realFs.watch(
            npath.fromPortablePath(p),
            // @ts-expect-error
            a,
            b
        );
    }

    watchFile(p, a, b) {
        return this.realFs.watchFile(
            npath.fromPortablePath(p),
            // @ts-expect-error
            a,
            b
        );
    }

    unwatchFile(p, cb) {
        return this.realFs.unwatchFile(npath.fromPortablePath(p), cb);
    }

    makeCallback(resolve, reject) {
        return (err, result) => {
            if (err) {
                reject(err);
            } else {
                resolve(result);
            }
        };
    }
}

const NUMBER_REGEXP = /^[0-9]+$/;
const VIRTUAL_REGEXP = /^(\/(?:[^/]+\/)*?(?:\$\$virtual|__virtual__))((?:\/((?:[^/]+-)?[a-f0-9]+)(?:\/([^/]+))?)?((?:\/.*)?))$/;
const VALID_COMPONENT = /^([^/]+-)?[a-f0-9]+$/;

class VirtualFS extends ProxiedFS {
    baseFs;

    static makeVirtualPath(base, component, to) {
        if (ppath.basename(base) !== `__virtual__`)
            throw new Error(`Assertion failed: Virtual folders must be named "__virtual__"`);
        if (!ppath.basename(component).match(VALID_COMPONENT))
            throw new Error(`Assertion failed: Virtual components must be ended by an hexadecimal hash`);
        const target = ppath.relative(ppath.dirname(base), to);
        const segments = target.split(`/`);
        let depth = 0;
        while (depth < segments.length && segments[depth] === `..`)
            depth += 1;
        const finalSegments = segments.slice(depth);
        const fullVirtualPath = ppath.join(base, component, String(depth), ...finalSegments);
        return fullVirtualPath;
    }

    static resolveVirtual(p) {
        const match = p.match(VIRTUAL_REGEXP);
        if (!match || !match[3] && match[5])
            return p;
        const target = ppath.dirname(match[1]);
        if (!match[3] || !match[4])
            return target;
        const isnum = NUMBER_REGEXP.test(match[4]);
        if (!isnum)
            return p;
        const depth = Number(match[4]);
        const backstep = `../`.repeat(depth);
        const subpath = match[5] || `.`;
        return VirtualFS.resolveVirtual(ppath.join(target, backstep, subpath));
    }

    constructor({baseFs = new NodeFS()} = {}) {
        super(ppath);
        this.baseFs = baseFs;
    }

    getExtractHint(hints) {
        return this.baseFs.getExtractHint(hints);
    }

    getRealPath() {
        return this.baseFs.getRealPath();
    }

    realpathSync(p) {
        const match = p.match(VIRTUAL_REGEXP);
        if (!match)
            return this.baseFs.realpathSync(p);
        if (!match[5])
            return p;
        const realpath = this.baseFs.realpathSync(this.mapToBase(p));
        return VirtualFS.makeVirtualPath(match[1], match[3], realpath);
    }

    async realpathPromise(p) {
        const match = p.match(VIRTUAL_REGEXP);
        if (!match)
            return await this.baseFs.realpathPromise(p);
        if (!match[5])
            return p;
        const realpath = await this.baseFs.realpathPromise(this.mapToBase(p));
        return VirtualFS.makeVirtualPath(match[1], match[3], realpath);
    }

    mapToBase(p) {
        if (p === ``)
            return p;
        if (this.pathUtils.isAbsolute(p))
            return VirtualFS.resolveVirtual(p);
        const resolvedRoot = VirtualFS.resolveVirtual(this.baseFs.resolve(PortablePath.dot));
        const resolvedP = VirtualFS.resolveVirtual(this.baseFs.resolve(p));
        return ppath.relative(resolvedRoot, resolvedP) || PortablePath.dot;
    }

    mapFromBase(p) {
        return p;
    }
}

const URL = Number(process.versions.node.split('.', 1)[0]) < 20 ? URL$1 : globalThis.URL;

const [major, minor] = process.versions.node.split(`.`).map((value) => parseInt(value, 10));
const WATCH_MODE_MESSAGE_USES_ARRAYS = major > 19 || major === 19 && minor >= 2 || major === 18 && minor >= 13;
const HAS_LAZY_LOADED_TRANSLATORS = major === 20 && minor < 6 || major === 19 && minor >= 3;
const SUPPORTS_IMPORT_ATTRIBUTES = major >= 21 || major === 20 && minor >= 10 || major === 18 && minor >= 20;
const SUPPORTS_IMPORT_ATTRIBUTES_ONLY = major >= 22;

function readPackageScope(checkPath) {
    const rootSeparatorIndex = checkPath.indexOf(npath.sep);
    let separatorIndex;
    do {
        separatorIndex = checkPath.lastIndexOf(npath.sep);
        checkPath = checkPath.slice(0, separatorIndex);
        if (checkPath.endsWith(`${npath.sep}node_modules`))
            return false;
        const pjson = readPackage(checkPath + npath.sep);
        if (pjson) {
            return {
                data: pjson,
                path: checkPath
            };
        }
    } while (separatorIndex > rootSeparatorIndex);
    return false;
}

function readPackage(requestPath) {
    const jsonPath = npath.resolve(requestPath, `package.json`);
    if (!fs.existsSync(jsonPath))
        return null;
    return JSON.parse(fs.readFileSync(jsonPath, `utf8`));
}

async function tryReadFile$1(path2) {
    try {
        return await fs.promises.readFile(path2, `utf8`);
    } catch (error) {
        if (error.code === `ENOENT`)
            return null;
        throw error;
    }
}

function tryParseURL(str, base) {
    try {
        return new URL(str, base);
    } catch {
        return null;
    }
}

let entrypointPath = null;

function setEntrypointPath(file) {
    entrypointPath = file;
}

function getFileFormat(filepath) {
    const ext = path.extname(filepath);
    switch (ext) {
        case `.mjs`: {
            return `module`;
        }
        case `.cjs`: {
            return `commonjs`;
        }
        case `.wasm`: {
            throw new Error(
                `Unknown file extension ".wasm" for ${filepath}`
            );
        }
        case `.json`: {
            return `json`;
        }
        case `.js`: {
            const pkg = readPackageScope(filepath);
            if (!pkg)
                return `commonjs`;
            return pkg.data.type ?? `commonjs`;
        }
        default: {
            if (entrypointPath !== filepath)
                return null;
            const pkg = readPackageScope(filepath);
            if (!pkg)
                return `commonjs`;
            if (pkg.data.type === `module`)
                return null;
            return pkg.data.type ?? `commonjs`;
        }
    }
}

async function load$1(urlString, context, nextLoad) {
    const url = tryParseURL(urlString);
    if (url?.protocol !== `file:`)
        return nextLoad(urlString, context, nextLoad);
    const filePath = fileURLToPath(url);
    const format = getFileFormat(filePath);
    if (!format)
        return nextLoad(urlString, context, nextLoad);
    if (format === `json`) {
        if (SUPPORTS_IMPORT_ATTRIBUTES_ONLY) {
            if (context.importAttributes?.type !== `json`) {
                const err = new TypeError(`[ERR_IMPORT_ATTRIBUTE_MISSING]: Module "${urlString}" needs an import attribute of "type: json"`);
                err.code = `ERR_IMPORT_ATTRIBUTE_MISSING`;
                throw err;
            }
        } else {
            const type = `importAttributes` in context ? context.importAttributes?.type : context.importAssertions?.type;
            if (type !== `json`) {
                const err = new TypeError(`[ERR_IMPORT_ASSERTION_TYPE_MISSING]: Module "${urlString}" needs an import ${SUPPORTS_IMPORT_ATTRIBUTES ? `attribute` : `assertion`} of type "json"`);
                err.code = `ERR_IMPORT_ASSERTION_TYPE_MISSING`;
                throw err;
            }
        }
    }
    if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
        const pathToSend = pathToFileURL(
            npath.fromPortablePath(
                VirtualFS.resolveVirtual(npath.toPortablePath(filePath))
            )
        ).href;
        process.send({
            "watch:import": WATCH_MODE_MESSAGE_USES_ARRAYS ? [pathToSend] : pathToSend
        });
    }
    return {
        format,
        source: format === `commonjs` ? void 0 : await fs.promises.readFile(filePath, `utf8`),
        shortCircuit: true
    };
}

const ArrayIsArray = Array.isArray;
const JSONStringify = JSON.stringify;
const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames;
const ObjectPrototypeHasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
const RegExpPrototypeExec = (obj, string) => RegExp.prototype.exec.call(obj, string);
const RegExpPrototypeSymbolReplace = (obj, ...rest) => RegExp.prototype[Symbol.replace].apply(obj, rest);
const StringPrototypeEndsWith = (str, ...rest) => String.prototype.endsWith.apply(str, rest);
const StringPrototypeIncludes = (str, ...rest) => String.prototype.includes.apply(str, rest);
const StringPrototypeLastIndexOf = (str, ...rest) => String.prototype.lastIndexOf.apply(str, rest);
const StringPrototypeIndexOf = (str, ...rest) => String.prototype.indexOf.apply(str, rest);
const StringPrototypeReplace = (str, ...rest) => String.prototype.replace.apply(str, rest);
const StringPrototypeSlice = (str, ...rest) => String.prototype.slice.apply(str, rest);
const StringPrototypeStartsWith = (str, ...rest) => String.prototype.startsWith.apply(str, rest);
const SafeMap = Map;
const JSONParse = JSON.parse;

function createErrorType(code, messageCreator, errorType) {
    return class extends errorType {
        constructor(...args) {
            super(messageCreator(...args));
            this.code = code;
            this.name = `${errorType.name} [${code}]`;
        }
    };
}

const ERR_PACKAGE_IMPORT_NOT_DEFINED = createErrorType(
    `ERR_PACKAGE_IMPORT_NOT_DEFINED`,
    (specifier, packagePath, base) => {
        return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ``} imported from ${base}`;
    },
    TypeError
);
const ERR_INVALID_MODULE_SPECIFIER = createErrorType(
    `ERR_INVALID_MODULE_SPECIFIER`,
    (request, reason, base = void 0) => {
        return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ``}`;
    },
    TypeError
);
const ERR_INVALID_PACKAGE_TARGET = createErrorType(
    `ERR_INVALID_PACKAGE_TARGET`,
    (pkgPath, key, target, isImport = false, base = void 0) => {
        const relError = typeof target === `string` && !isImport && target.length && !StringPrototypeStartsWith(target, `./`);
        if (key === `.`) {
            assert(isImport === false);
            return `Invalid "exports" main target ${JSONStringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`;
        }
        return `Invalid "${isImport ? `imports` : `exports`}" target ${JSONStringify(
            target
        )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`;
    },
    Error
);
const ERR_INVALID_PACKAGE_CONFIG = createErrorType(
    `ERR_INVALID_PACKAGE_CONFIG`,
    (path, base, message) => {
        return `Invalid package config ${path}${base ? ` while importing ${base}` : ``}${message ? `. ${message}` : ``}`;
    },
    Error
);

function filterOwnProperties(source, keys) {
    const filtered = /* @__PURE__ */ Object.create(null);
    for (let i = 0; i < keys.length; i++) {
        const key = keys[i];
        if (ObjectPrototypeHasOwnProperty(source, key)) {
            filtered[key] = source[key];
        }
    }
    return filtered;
}

const packageJSONCache = new SafeMap();

function getPackageConfig(path, specifier, base, readFileSyncFn) {
    const existing = packageJSONCache.get(path);
    if (existing !== void 0) {
        return existing;
    }
    const source = readFileSyncFn(path);
    if (source === void 0) {
        const packageConfig2 = {
            pjsonPath: path,
            exists: false,
            main: void 0,
            name: void 0,
            type: "none",
            exports: void 0,
            imports: void 0
        };
        packageJSONCache.set(path, packageConfig2);
        return packageConfig2;
    }
    let packageJSON;
    try {
        packageJSON = JSONParse(source);
    } catch (error) {
        throw new ERR_INVALID_PACKAGE_CONFIG(
            path,
            (base ? `"${specifier}" from ` : "") + fileURLToPath(base || specifier),
            error.message
        );
    }
    let {imports, main, name, type} = filterOwnProperties(packageJSON, [
        "imports",
        "main",
        "name",
        "type"
    ]);
    const exports = ObjectPrototypeHasOwnProperty(packageJSON, "exports") ? packageJSON.exports : void 0;
    if (typeof imports !== "object" || imports === null) {
        imports = void 0;
    }
    if (typeof main !== "string") {
        main = void 0;
    }
    if (typeof name !== "string") {
        name = void 0;
    }
    if (type !== "module" && type !== "commonjs") {
        type = "none";
    }
    const packageConfig = {
        pjsonPath: path,
        exists: true,
        main,
        name,
        type,
        exports,
        imports
    };
    packageJSONCache.set(path, packageConfig);
    return packageConfig;
}

function getPackageScopeConfig(resolved, readFileSyncFn) {
    let packageJSONUrl = new URL("./package.json", resolved);
    while (true) {
        const packageJSONPath2 = packageJSONUrl.pathname;
        if (StringPrototypeEndsWith(packageJSONPath2, "node_modules/package.json")) {
            break;
        }
        const packageConfig2 = getPackageConfig(
            fileURLToPath(packageJSONUrl),
            resolved,
            void 0,
            readFileSyncFn
        );
        if (packageConfig2.exists) {
            return packageConfig2;
        }
        const lastPackageJSONUrl = packageJSONUrl;
        packageJSONUrl = new URL("../package.json", packageJSONUrl);
        if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
            break;
        }
    }
    const packageJSONPath = fileURLToPath(packageJSONUrl);
    const packageConfig = {
        pjsonPath: packageJSONPath,
        exists: false,
        main: void 0,
        name: void 0,
        type: "none",
        exports: void 0,
        imports: void 0
    };
    packageJSONCache.set(packageJSONPath, packageConfig);
    return packageConfig;
}

function throwImportNotDefined(specifier, packageJSONUrl, base) {
    throw new ERR_PACKAGE_IMPORT_NOT_DEFINED(
        specifier,
        packageJSONUrl && fileURLToPath(new URL(".", packageJSONUrl)),
        fileURLToPath(base)
    );
}

function throwInvalidSubpath(subpath, packageJSONUrl, internal, base) {
    const reason = `request is not a valid subpath for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath(packageJSONUrl)}`;
    throw new ERR_INVALID_MODULE_SPECIFIER(
        subpath,
        reason,
        base && fileURLToPath(base)
    );
}

function throwInvalidPackageTarget(subpath, target, packageJSONUrl, internal, base) {
    if (typeof target === "object" && target !== null) {
        target = JSONStringify(target, null, "");
    } else {
        target = `${target}`;
    }
    throw new ERR_INVALID_PACKAGE_TARGET(
        fileURLToPath(new URL(".", packageJSONUrl)),
        subpath,
        target,
        internal,
        base && fileURLToPath(base)
    );
}

const invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
const patternRegEx = /\*/g;

function resolvePackageTargetString(target, subpath, match, packageJSONUrl, base, pattern, internal, conditions) {
    if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
        throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
    if (!StringPrototypeStartsWith(target, "./")) {
        if (internal && !StringPrototypeStartsWith(target, "../") && !StringPrototypeStartsWith(target, "/")) {
            let isURL = false;
            try {
                new URL(target);
                isURL = true;
            } catch {
            }
            if (!isURL) {
                const exportTarget = pattern ? RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) : target + subpath;
                return exportTarget;
            }
        }
        throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
    }
    if (RegExpPrototypeExec(
        invalidSegmentRegEx,
        StringPrototypeSlice(target, 2)
    ) !== null)
        throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
    const resolved = new URL(target, packageJSONUrl);
    const resolvedPath = resolved.pathname;
    const packagePath = new URL(".", packageJSONUrl).pathname;
    if (!StringPrototypeStartsWith(resolvedPath, packagePath))
        throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base);
    if (subpath === "") return resolved;
    if (RegExpPrototypeExec(invalidSegmentRegEx, subpath) !== null) {
        const request = pattern ? StringPrototypeReplace(match, "*", () => subpath) : match + subpath;
        throwInvalidSubpath(request, packageJSONUrl, internal, base);
    }
    if (pattern) {
        return new URL(
            RegExpPrototypeSymbolReplace(patternRegEx, resolved.href, () => subpath)
        );
    }
    return new URL(subpath, resolved);
}

function isArrayIndex(key) {
    const keyNum = +key;
    if (`${keyNum}` !== key) return false;
    return keyNum >= 0 && keyNum < 4294967295;
}

function resolvePackageTarget(packageJSONUrl, target, subpath, packageSubpath, base, pattern, internal, conditions) {
    if (typeof target === "string") {
        return resolvePackageTargetString(
            target,
            subpath,
            packageSubpath,
            packageJSONUrl,
            base,
            pattern,
            internal);
    } else if (ArrayIsArray(target)) {
        if (target.length === 0) {
            return null;
        }
        let lastException;
        for (let i = 0; i < target.length; i++) {
            const targetItem = target[i];
            let resolveResult;
            try {
                resolveResult = resolvePackageTarget(
                    packageJSONUrl,
                    targetItem,
                    subpath,
                    packageSubpath,
                    base,
                    pattern,
                    internal,
                    conditions
                );
            } catch (e) {
                lastException = e;
                if (e.code === "ERR_INVALID_PACKAGE_TARGET") {
                    continue;
                }
                throw e;
            }
            if (resolveResult === void 0) {
                continue;
            }
            if (resolveResult === null) {
                lastException = null;
                continue;
            }
            return resolveResult;
        }
        if (lastException === void 0 || lastException === null)
            return lastException;
        throw lastException;
    } else if (typeof target === "object" && target !== null) {
        const keys = ObjectGetOwnPropertyNames(target);
        for (let i = 0; i < keys.length; i++) {
            const key = keys[i];
            if (isArrayIndex(key)) {
                throw new ERR_INVALID_PACKAGE_CONFIG(
                    fileURLToPath(packageJSONUrl),
                    base,
                    '"exports" cannot contain numeric property keys.'
                );
            }
        }
        for (let i = 0; i < keys.length; i++) {
            const key = keys[i];
            if (key === "default" || conditions.has(key)) {
                const conditionalTarget = target[key];
                const resolveResult = resolvePackageTarget(
                    packageJSONUrl,
                    conditionalTarget,
                    subpath,
                    packageSubpath,
                    base,
                    pattern,
                    internal,
                    conditions
                );
                if (resolveResult === void 0) continue;
                return resolveResult;
            }
        }
        return void 0;
    } else if (target === null) {
        return null;
    }
    throwInvalidPackageTarget(
        packageSubpath,
        target,
        packageJSONUrl,
        internal,
        base
    );
}

function patternKeyCompare(a, b) {
    const aPatternIndex = StringPrototypeIndexOf(a, "*");
    const bPatternIndex = StringPrototypeIndexOf(b, "*");
    const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
    const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
    if (baseLenA > baseLenB) return -1;
    if (baseLenB > baseLenA) return 1;
    if (aPatternIndex === -1) return 1;
    if (bPatternIndex === -1) return -1;
    if (a.length > b.length) return -1;
    if (b.length > a.length) return 1;
    return 0;
}

function packageImportsResolve({name, base, conditions, readFileSyncFn}) {
    if (name === "#" || StringPrototypeStartsWith(name, "#/") || StringPrototypeEndsWith(name, "/")) {
        const reason = "is not a valid internal imports specifier name";
        throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base));
    }
    let packageJSONUrl;
    const packageConfig = getPackageScopeConfig(base, readFileSyncFn);
    if (packageConfig.exists) {
        packageJSONUrl = pathToFileURL(packageConfig.pjsonPath);
        const imports = packageConfig.imports;
        if (imports) {
            if (ObjectPrototypeHasOwnProperty(imports, name) && !StringPrototypeIncludes(name, "*")) {
                const resolveResult = resolvePackageTarget(
                    packageJSONUrl,
                    imports[name],
                    "",
                    name,
                    base,
                    false,
                    true,
                    conditions
                );
                if (resolveResult != null) {
                    return resolveResult;
                }
            } else {
                let bestMatch = "";
                let bestMatchSubpath;
                const keys = ObjectGetOwnPropertyNames(imports);
                for (let i = 0; i < keys.length; i++) {
                    const key = keys[i];
                    const patternIndex = StringPrototypeIndexOf(key, "*");
                    if (patternIndex !== -1 && StringPrototypeStartsWith(
                        name,
                        StringPrototypeSlice(key, 0, patternIndex)
                    )) {
                        const patternTrailer = StringPrototypeSlice(key, patternIndex + 1);
                        if (name.length >= key.length && StringPrototypeEndsWith(name, patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && StringPrototypeLastIndexOf(key, "*") === patternIndex) {
                            bestMatch = key;
                            bestMatchSubpath = StringPrototypeSlice(
                                name,
                                patternIndex,
                                name.length - patternTrailer.length
                            );
                        }
                    }
                }
                if (bestMatch) {
                    const target = imports[bestMatch];
                    const resolveResult = resolvePackageTarget(
                        packageJSONUrl,
                        target,
                        bestMatchSubpath,
                        bestMatch,
                        base,
                        true,
                        true,
                        conditions
                    );
                    if (resolveResult != null) {
                        return resolveResult;
                    }
                }
            }
        }
    }
    throwImportNotDefined(name, packageJSONUrl, base);
}

let findPnpApi = esmModule.findPnpApi;
if (!findPnpApi) {
    const require = createRequire(import.meta.url);
    const pnpApi = require(`./.pnp.cjs`);
    pnpApi.setup();
    findPnpApi = esmModule.findPnpApi;
}
const pathRegExp = /^(?![a-zA-Z]:[\\/]|\\\\|\.{0,2}(?:\/|$))((?:node:)?(?:@[^/]+\/)?[^/]+)\/*(.*|)$/;
const isRelativeRegexp = /^\.{0,2}\//;

function tryReadFile(filePath) {
    try {
        return fs.readFileSync(filePath, `utf8`);
    } catch (err) {
        if (err.code === `ENOENT`)
            return void 0;
        throw err;
    }
}

async function resolvePrivateRequest(specifier, issuer, context, nextResolve) {
    const resolved = packageImportsResolve({
        name: specifier,
        base: pathToFileURL(issuer),
        conditions: new Set(context.conditions),
        readFileSyncFn: tryReadFile
    });
    if (resolved instanceof URL) {
        return {url: resolved.href, shortCircuit: true};
    } else {
        if (resolved.startsWith(`#`))
            throw new Error(`Mapping from one private import to another isn't allowed`);
        return resolve$1(resolved, context, nextResolve);
    }
}

async function resolve$1(originalSpecifier, context, nextResolve) {
    if (!findPnpApi || isBuiltin(originalSpecifier))
        return nextResolve(originalSpecifier, context, nextResolve);
    let specifier = originalSpecifier;
    const url = tryParseURL(specifier, isRelativeRegexp.test(specifier) ? context.parentURL : void 0);
    if (url) {
        if (url.protocol !== `file:`)
            return nextResolve(originalSpecifier, context, nextResolve);
        specifier = fileURLToPath(url);
    }
    const {parentURL, conditions = []} = context;
    const issuer = parentURL && tryParseURL(parentURL)?.protocol === `file:` ? fileURLToPath(parentURL) : process.cwd();
    const pnpapi = findPnpApi(issuer) ?? (url ? findPnpApi(specifier) : null);
    if (!pnpapi)
        return nextResolve(originalSpecifier, context, nextResolve);
    if (specifier.startsWith(`#`))
        return resolvePrivateRequest(specifier, issuer, context, nextResolve);
    const dependencyNameMatch = specifier.match(pathRegExp);
    let allowLegacyResolve = false;
    if (dependencyNameMatch) {
        const [, dependencyName, subPath] = dependencyNameMatch;
        if (subPath === `` && dependencyName !== `pnpapi`) {
            const resolved = pnpapi.resolveToUnqualified(`${dependencyName}/package.json`, issuer);
            if (resolved) {
                const content = await tryReadFile$1(resolved);
                if (content) {
                    const pkg = JSON.parse(content);
                    allowLegacyResolve = pkg.exports == null;
                }
            }
        }
    }
    let result;
    try {
        result = pnpapi.resolveRequest(specifier, issuer, {
            conditions: new Set(conditions),
            // TODO: Handle --experimental-specifier-resolution=node
            extensions: allowLegacyResolve ? void 0 : []
        });
    } catch (err) {
        if (err instanceof Error && `code` in err && err.code === `MODULE_NOT_FOUND`)
            err.code = `ERR_MODULE_NOT_FOUND`;
        throw err;
    }
    if (!result)
        throw new Error(`Resolving '${specifier}' from '${issuer}' failed`);
    const resultURL = pathToFileURL(result);
    if (url) {
        resultURL.search = url.search;
        resultURL.hash = url.hash;
    }
    if (!parentURL)
        setEntrypointPath(fileURLToPath(resultURL));
    return {
        url: resultURL.href,
        shortCircuit: true
    };
}

if (!HAS_LAZY_LOADED_TRANSLATORS) {
    const binding = process.binding(`fs`);
    const originalReadFile = binding.readFileUtf8 || binding.readFileSync;
    if (originalReadFile) {
        binding[originalReadFile.name] = function (...args) {
            try {
                return fs.readFileSync(args[0], {
                    encoding: `utf8`,
                    // @ts-expect-error - The docs says it needs to be a string but
                    // links to https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#file-system-flags
                    // which says it can be a number which matches the implementation.
                    flag: args[1]
                });
            } catch {
            }
            return originalReadFile.apply(this, args);
        };
    } else {
        const binding2 = process.binding(`fs`);
        const originalfstat = binding2.fstat;
        const ZIP_MASK = 4278190080;
        const ZIP_MAGIC = 704643072;
        binding2.fstat = function (...args) {
            const [fd, useBigint, req] = args;
            if ((fd & ZIP_MASK) === ZIP_MAGIC && useBigint === false && req === void 0) {
                try {
                    const stats = fs.fstatSync(fd);
                    return new Float64Array([
                        stats.dev,
                        stats.mode,
                        stats.nlink,
                        stats.uid,
                        stats.gid,
                        stats.rdev,
                        stats.blksize,
                        stats.ino,
                        stats.size,
                        stats.blocks
                        // atime sec
                        // atime ns
                        // mtime sec
                        // mtime ns
                        // ctime sec
                        // ctime ns
                        // birthtime sec
                        // birthtime ns
                    ]);
                } catch {
                }
            }
            return originalfstat.apply(this, args);
        };
    }
}

const resolve = resolve$1;
const load = load$1;

export {load, resolve};