@pnpm/exe 12.9.0 → 12.9.1

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/patchFs/patchFs.js

@@ -1,265 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchFs = patchFs;
-exports.extendFs = extendFs;
-const util_1 = require("util");
-const NodePathFS_1 = require("../NodePathFS");
-const FileHandle_1 = require("./FileHandle");
-const SYNC_IMPLEMENTATIONS = new Set([
-    `accessSync`,
-    `appendFileSync`,
-    `createReadStream`,
-    `createWriteStream`,
-    `chmodSync`,
-    `fchmodSync`,
-    `chownSync`,
-    `fchownSync`,
-    `closeSync`,
-    `copyFileSync`,
-    `linkSync`,
-    `lstatSync`,
-    `fstatSync`,
-    `lutimesSync`,
-    `mkdirSync`,
-    `openSync`,
-    `opendirSync`,
-    `readlinkSync`,
-    `readFileSync`,
-    `readdirSync`,
-    `readlinkSync`,
-    `realpathSync`,
-    `renameSync`,
-    `rmdirSync`,
-    `rmSync`,
-    `statSync`,
-    `symlinkSync`,
-    `truncateSync`,
-    `ftruncateSync`,
-    `unlinkSync`,
-    `unwatchFile`,
-    `utimesSync`,
-    `watch`,
-    `watchFile`,
-    `writeFileSync`,
-    `writeSync`,
-]);
-const ASYNC_IMPLEMENTATIONS = new Set([
-    `accessPromise`,
-    `appendFilePromise`,
-    `fchmodPromise`,
-    `chmodPromise`,
-    `fchownPromise`,
-    `chownPromise`,
-    `closePromise`,
-    `copyFilePromise`,
-    `linkPromise`,
-    `fstatPromise`,
-    `lstatPromise`,
-    `lutimesPromise`,
-    `mkdirPromise`,
-    `openPromise`,
-    `opendirPromise`,
-    `readdirPromise`,
-    `realpathPromise`,
-    `readFilePromise`,
-    `readdirPromise`,
-    `readlinkPromise`,
-    `renamePromise`,
-    `rmdirPromise`,
-    `rmPromise`,
-    `statPromise`,
-    `symlinkPromise`,
-    `truncatePromise`,
-    `ftruncatePromise`,
-    `unlinkPromise`,
-    `utimesPromise`,
-    `writeFilePromise`,
-    `writeSync`,
-]);
-//#endregion
-function patchFs(patchedFs, fakeFs) {
-    // We wrap the `fakeFs` with a `NodePathFS` to add support for all path types supported by Node
-    fakeFs = new NodePathFS_1.NodePathFS(fakeFs);
-    const setupFn = (target, name, replacement) => {
-        const orig = target[name];
-        target[name] = replacement;
-        // Preserve any util.promisify implementations
-        if (typeof orig?.[util_1.promisify.custom] !== `undefined`) {
-            replacement[util_1.promisify.custom] = orig[util_1.promisify.custom];
-        }
-    };
-    /** Callback implementations */
-    {
-        setupFn(patchedFs, `exists`, (p, ...args) => {
-            const hasCallback = typeof args[args.length - 1] === `function`;
-            const callback = hasCallback ? args.pop() : () => { };
-            process.nextTick(() => {
-                fakeFs.existsPromise(p).then(exists => {
-                    callback(exists);
-                }, () => {
-                    callback(false);
-                });
-            });
-        });
-        // Adapted from https://github.com/nodejs/node/blob/e5c1fd7a2a1801fd75bdde23b260488e85453eb2/lib/fs.js#L603-L667
-        setupFn(patchedFs, `read`, (...args) => {
-            let [fd, buffer, offset, length, position, callback] = args;
-            if (args.length <= 3) {
-                // Assume fs.read(fd, options, callback)
-                let options = {};
-                if (args.length < 3) {
-                    // This is fs.read(fd, callback)
-                    callback = args[1];
-                }
-                else {
-                    // This is fs.read(fd, {}, callback)
-                    options = args[1];
-                    callback = args[2];
-                }
-                ({
-                    buffer = Buffer.alloc(16384),
-                    offset = 0,
-                    length = buffer.byteLength,
-                    position,
-                } = options);
-            }
-            if (offset == null)
-                offset = 0;
-            length |= 0;
-            if (length === 0) {
-                process.nextTick(() => {
-                    callback(null, 0, buffer);
-                });
-                return;
-            }
-            if (position == null)
-                position = -1;
-            process.nextTick(() => {
-                fakeFs.readPromise(fd, buffer, offset, length, position).then(bytesRead => {
-                    callback(null, bytesRead, buffer);
-                }, error => {
-                    // https://github.com/nodejs/node/blob/1317252dfe8824fd9cfee125d2aaa94004db2f3b/lib/fs.js#L655-L658
-                    // Known issue: bytesRead could theoretically be > than 0, but we currently always return 0
-                    callback(error, 0, buffer);
-                });
-            });
-        });
-        for (const fnName of ASYNC_IMPLEMENTATIONS) {
-            const origName = fnName.replace(/Promise$/, ``);
-            if (typeof patchedFs[origName] === `undefined`)
-                continue;
-            const fakeImpl = fakeFs[fnName];
-            if (typeof fakeImpl === `undefined`)
-                continue;
-            const wrapper = (...args) => {
-                const hasCallback = typeof args[args.length - 1] === `function`;
-                const callback = hasCallback ? args.pop() : () => { };
-                process.nextTick(() => {
-                    fakeImpl.apply(fakeFs, args).then((result) => {
-                        callback(null, result);
-                    }, (error) => {
-                        callback(error);
-                    });
-                });
-            };
-            setupFn(patchedFs, origName, wrapper);
-        }
-        patchedFs.realpath.native = patchedFs.realpath;
-    }
-    /** Sync implementations */
-    {
-        setupFn(patchedFs, `existsSync`, (p) => {
-            try {
-                return fakeFs.existsSync(p);
-            }
-            catch {
-                return false;
-            }
-        });
-        // Adapted from https://github.com/nodejs/node/blob/e5c1fd7a2a1801fd75bdde23b260488e85453eb2/lib/fs.js#L684-L725
-        setupFn(patchedFs, `readSync`, (...args) => {
-            let [fd, buffer, offset, length, position] = args;
-            if (args.length <= 3) {
-                // Assume fs.read(fd, buffer, options)
-                const options = args[2] || {};
-                ({ offset = 0, length = buffer.byteLength, position } = options);
-            }
-            if (offset == null)
-                offset = 0;
-            length |= 0;
-            if (length === 0)
-                return 0;
-            if (position == null)
-                position = -1;
-            return fakeFs.readSync(fd, buffer, offset, length, position);
-        });
-        for (const fnName of SYNC_IMPLEMENTATIONS) {
-            const origName = fnName;
-            if (typeof patchedFs[origName] === `undefined`)
-                continue;
-            const fakeImpl = fakeFs[fnName];
-            if (typeof fakeImpl === `undefined`)
-                continue;
-            setupFn(patchedFs, origName, fakeImpl.bind(fakeFs));
-        }
-        patchedFs.realpathSync.native = patchedFs.realpathSync;
-    }
-    /** Promise implementations */
-    {
-        // `fs.promises` is a getter that returns a reference to require(`fs/promises`),
-        // so we can just patch `fs.promises` and both will be updated
-        const patchedFsPromises = patchedFs.promises;
-        // `fs.promises.exists` doesn't exist
-        for (const fnName of ASYNC_IMPLEMENTATIONS) {
-            const origName = fnName.replace(/Promise$/, ``);
-            if (typeof patchedFsPromises[origName] === `undefined`)
-                continue;
-            const fakeImpl = fakeFs[fnName];
-            if (typeof fakeImpl === `undefined`)
-                continue;
-            // Open is a bit particular with fs.promises: it returns a file handle
-            // instance instead of the traditional file descriptor number
-            if (fnName === `open`)
-                continue;
-            setupFn(patchedFsPromises, origName, (pathLike, ...args) => {
-                if (pathLike instanceof FileHandle_1.FileHandle) {
-                    return pathLike[origName].apply(pathLike, args);
-                }
-                else {
-                    return fakeImpl.call(fakeFs, pathLike, ...args);
-                }
-            });
-        }
-        setupFn(patchedFsPromises, `open`, async (...args) => {
-            // @ts-expect-error - reason TBS
-            const fd = await fakeFs.openPromise(...args);
-            return new FileHandle_1.FileHandle(fd, fakeFs);
-        });
-        // `fs.promises.realpath` doesn't have a `native` property
-    }
-    /** util.promisify implementations */
-    {
-        // TODO add promisified `fs.readv` and `fs.writev`, once they are implemented
-        // Override the promisified versions of `fs.read` and `fs.write` to return an object as per
-        // https://github.com/nodejs/node/blob/dc79f3f37caf6f25b8efee4623bec31e2c20f595/lib/fs.js#L559-L560
-        // and
-        // https://github.com/nodejs/node/blob/dc79f3f37caf6f25b8efee4623bec31e2c20f595/lib/fs.js#L690-L691
-        // and
-        // https://github.com/nodejs/node/blob/ba684805b6c0eded76e5cd89ee00328ac7a59365/lib/internal/util.js#L293
-        // @ts-expect-error - reason TBS
-        patchedFs.read[util_1.promisify.custom] = async (fd, buffer, ...args) => {
-            const res = fakeFs.readPromise(fd, buffer, ...args);
-            return { bytesRead: await res, buffer };
-        };
-        // @ts-expect-error - reason TBS
-        patchedFs.write[util_1.promisify.custom] = async (fd, buffer, ...args) => {
-            const res = fakeFs.writePromise(fd, buffer, ...args);
-            return { bytesWritten: await res, buffer };
-        };
-    }
-}
-function extendFs(realFs, fakeFs) {
-    const patchedFs = Object.create(realFs);
-    patchFs(patchedFs, fakeFs);
-    return patchedFs;
-}

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/path.d.ts

@@ -1,84 +0,0 @@
-declare enum PathType {
-    File = 0,
-    Portable = 1,
-    Native = 2
-}
-export type PortablePath = string & {
-    __pathType: PathType.File | PathType.Portable;
-};
-export type NativePath = string & {
-    __pathType?: PathType.File | PathType.Native;
-};
-export declare const PortablePath: {
-    root: PortablePath;
-    dot: PortablePath;
-    parent: PortablePath;
-};
-export type Filename = string & {
-    __pathType: PathType.File;
-};
-export type Path = PortablePath | NativePath;
-export declare const Filename: {
-    home: Filename;
-    nodeModules: Filename;
-    manifest: Filename;
-    lockfile: Filename;
-    virtual: Filename;
-    /**
-     * @deprecated
-     */
-    pnpJs: Filename;
-    pnpCjs: Filename;
-    pnpData: Filename;
-    pnpEsmLoader: Filename;
-    rc: Filename;
-    env: Filename;
-};
-export type TolerateLiterals<T> = {
-    [K in keyof T]: ValidateLiteral<T[K]> | PortablePath | Filename;
-};
-export type ValidateLiteral<T> = T extends `${infer X}` ? T : never;
-export interface PortablePathGenerics {
-    join<T extends Array<string>>(...segments: TolerateLiterals<T>): PortablePath;
-    resolve<T extends string>(...pathSegments: Array<PortablePath | Filename | TolerateLiterals<T>>): PortablePath;
-}
-export type FSPath<T extends Path> = T | number;
-export declare const npath: PathUtils<NativePath> & ConvertUtils;
-export declare const ppath: PathUtils<PortablePath> & PortablePathGenerics;
-export interface ParsedPath<P extends Path> {
-    root: P;
-    dir: P;
-    base: Filename;
-    ext: string;
-    name: Filename;
-}
-export interface FormatInputPathObject<P extends Path> {
-    root?: P;
-    dir?: P;
-    base?: Filename;
-    ext?: string;
-    name?: Filename;
-}
-type NoInfer<T> = [T][T extends any ? 0 : never];
-export interface PathUtils<P extends Path> {
-    cwd(): P;
-    join(...paths: Array<NoInfer<P> | Filename>): P;
-    resolve(...pathSegments: Array<NoInfer<P> | Filename>): P;
-    normalize(p: P): P;
-    isAbsolute(path: P): boolean;
-    relative(from: P, to: P): P;
-    dirname(p: P): P;
-    basename(p: P, ext?: string): Filename;
-    extname(p: P): string;
-    readonly sep: P;
-    readonly delimiter: string;
-    parse(pathString: P): ParsedPath<P>;
-    format(pathObject: FormatInputPathObject<P>): P;
-    contains(from: P, to: P): P | null;
-}
-export interface ConvertUtils {
-    fromPortablePath: (p: Path) => NativePath;
-    toPortablePath: (p: Path) => PortablePath;
-}
-export declare function convertPath<P extends Path>(targetPathUtils: PathUtils<P>, sourcePath: Path): P;
-export {};

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/path.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ppath = exports.npath = exports.Filename = exports.PortablePath = void 0;
-exports.convertPath = convertPath;
-const tslib_1 = require("tslib");
-const path_1 = tslib_1.__importDefault(require("path"));
-var PathType;
-(function (PathType) {
-    PathType[PathType["File"] = 0] = "File";
-    PathType[PathType["Portable"] = 1] = "Portable";
-    PathType[PathType["Native"] = 2] = "Native";
-})(PathType || (PathType = {}));
-exports.PortablePath = {
-    root: `/`,
-    dot: `.`,
-    parent: `..`,
-};
-exports.Filename = {
-    home: `~`,
-    nodeModules: `node_modules`,
-    manifest: `package.json`,
-    lockfile: `yarn.lock`,
-    virtual: `__virtual__`,
-    /**
-     * @deprecated
-     */
-    pnpJs: `.pnp.js`,
-    pnpCjs: `.pnp.cjs`,
-    pnpData: `.pnp.data.json`,
-    pnpEsmLoader: `.pnp.loader.mjs`,
-    rc: `.yarnrc.yml`,
-    env: `.env`,
-};
-exports.npath = Object.create(path_1.default);
-exports.ppath = Object.create(path_1.default.posix);
-exports.npath.cwd = () => process.cwd();
-exports.ppath.cwd = process.platform === `win32`
-    ? () => toPortablePath(process.cwd())
-    : process.cwd;
-if (process.platform === `win32`) {
-    exports.ppath.resolve = (...segments) => {
-        if (segments.length > 0 && exports.ppath.isAbsolute(segments[0])) {
-            return path_1.default.posix.resolve(...segments);
-        }
-        else {
-            return path_1.default.posix.resolve(exports.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;
-    }
-};
-exports.npath.contains = (from, to) => contains(exports.npath, from, to);
-exports.ppath.contains = (from, to) => contains(exports.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\/)?(.*)$/;
-// Path should look like "/N:/berry/scripts/plugin-pack.js"
-// And transform to "N:\berry\scripts\plugin-pack.js"
-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, `\\`);
-}
-// Path should look like "N:/berry/scripts/plugin-pack.js"
-// And transform to "/N:/berry/scripts/plugin-pack.js"
-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;
-exports.npath.fromPortablePath = fromPortablePath;
-exports.npath.toPortablePath = toPortablePath;
-function convertPath(targetPathUtils, sourcePath) {
-    return (targetPathUtils === exports.npath ? fromPortablePath(sourcePath) : toPortablePath(sourcePath));
-}

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/statUtils.d.ts

@@ -1,81 +0,0 @@
-import { BigIntStats, Stats } from 'fs';
-import { Filename } from './path';
-export declare const DEFAULT_MODE: number;
-export declare class DirEntry<T = undefined> {
-    name: Filename;
-    path: T;
-    mode: number;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isDirectory(): boolean;
-    isFIFO(): boolean;
-    isFile(): boolean;
-    isSocket(): boolean;
-    isSymbolicLink(): boolean;
-}
-export declare class StatEntry {
-    uid: number;
-    gid: number;
-    size: number;
-    blksize: number;
-    atimeMs: number;
-    mtimeMs: number;
-    ctimeMs: number;
-    birthtimeMs: number;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
-    dev: number;
-    ino: number;
-    mode: number;
-    nlink: number;
-    rdev: number;
-    blocks: number;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isDirectory(): boolean;
-    isFIFO(): boolean;
-    isFile(): boolean;
-    isSocket(): boolean;
-    isSymbolicLink(): boolean;
-}
-export declare class BigIntStatsEntry {
-    uid: bigint;
-    gid: bigint;
-    size: bigint;
-    blksize: bigint;
-    atimeMs: bigint;
-    mtimeMs: bigint;
-    ctimeMs: bigint;
-    birthtimeMs: bigint;
-    atimeNs: bigint;
-    mtimeNs: bigint;
-    ctimeNs: bigint;
-    birthtimeNs: bigint;
-    atime: Date;
-    mtime: Date;
-    ctime: Date;
-    birthtime: Date;
-    dev: bigint;
-    ino: bigint;
-    mode: bigint;
-    nlink: bigint;
-    rdev: bigint;
-    blocks: bigint;
-    isBlockDevice(): boolean;
-    isCharacterDevice(): boolean;
-    isDirectory(): boolean;
-    isFIFO(): boolean;
-    isFile(): boolean;
-    isSocket(): boolean;
-    isSymbolicLink(): boolean;
-}
-export declare function makeDefaultStats(): StatEntry;
-export declare function makeEmptyStats(): Stats | BigIntStats;
-/**
- * Mutates the provided stats object to zero it out then returns it for convenience
- */
-export declare function clearStats(stats: Stats | BigIntStats): Stats | BigIntStats;
-export declare function convertToBigIntStats(stats: Stats): BigIntStats;
-export declare function areStatsEqual(a: Stats | BigIntStatsEntry, b: Stats | BigIntStatsEntry): boolean;