@pnpm/exe 12.8.2 → 12.9.0

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

@@ -0,0 +1,36 @@
+export declare function EBUSY(message: string): Error & {
+    code: string;
+};
+export declare function ENOSYS(message: string, reason: string): Error & {
+    code: string;
+};
+export declare function EINVAL(reason: string): Error & {
+    code: string;
+};
+export declare function EBADF(reason: string): Error & {
+    code: string;
+};
+export declare function ENOENT(reason: string): Error & {
+    code: string;
+};
+export declare function ENOTDIR(reason: string): Error & {
+    code: string;
+};
+export declare function EISDIR(reason: string): Error & {
+    code: string;
+};
+export declare function EEXIST(reason: string): Error & {
+    code: string;
+};
+export declare function EROFS(reason: string): Error & {
+    code: string;
+};
+export declare function ENOTEMPTY(reason: string): Error & {
+    code: string;
+};
+export declare function EOPNOTSUPP(reason: string): Error & {
+    code: string;
+};
+export declare function ERR_DIR_CLOSED(): Error & {
+    code: string;
+};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EBUSY = EBUSY;
+exports.ENOSYS = ENOSYS;
+exports.EINVAL = EINVAL;
+exports.EBADF = EBADF;
+exports.ENOENT = ENOENT;
+exports.ENOTDIR = ENOTDIR;
+exports.EISDIR = EISDIR;
+exports.EEXIST = EEXIST;
+exports.EROFS = EROFS;
+exports.ENOTEMPTY = ENOTEMPTY;
+exports.EOPNOTSUPP = EOPNOTSUPP;
+exports.ERR_DIR_CLOSED = ERR_DIR_CLOSED;
+function makeError(code, message) {
+    return Object.assign(new Error(`${code}: ${message}`), { code });
+}
+function EBUSY(message) {
+    return makeError(`EBUSY`, message);
+}
+function ENOSYS(message, reason) {
+    return makeError(`ENOSYS`, `${message}, ${reason}`);
+}
+function EINVAL(reason) {
+    return makeError(`EINVAL`, `invalid argument, ${reason}`);
+}
+function EBADF(reason) {
+    return makeError(`EBADF`, `bad file descriptor, ${reason}`);
+}
+function ENOENT(reason) {
+    return makeError(`ENOENT`, `no such file or directory, ${reason}`);
+}
+function ENOTDIR(reason) {
+    return makeError(`ENOTDIR`, `not a directory, ${reason}`);
+}
+function EISDIR(reason) {
+    return makeError(`EISDIR`, `illegal operation on a directory, ${reason}`);
+}
+function EEXIST(reason) {
+    return makeError(`EEXIST`, `file already exists, ${reason}`);
+}
+function EROFS(reason) {
+    return makeError(`EROFS`, `read-only filesystem, ${reason}`);
+}
+function ENOTEMPTY(reason) {
+    return makeError(`ENOTEMPTY`, `directory not empty, ${reason}`);
+}
+function EOPNOTSUPP(reason) {
+    return makeError(`EOPNOTSUPP`, `operation not supported, ${reason}`);
+}
+// ------------------------------------------------------------------------
+function ERR_DIR_CLOSED() {
+    return makeError(`ERR_DIR_CLOSED`, `Directory handle was closed`);
+}

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

@@ -0,0 +1,48 @@
+import * as constants from './constants';
+import * as errors from './errors';
+import * as statUtils from './statUtils';
+export { constants };
+export { errors };
+export { statUtils };
+export type { LinkStrategy } from './algorithms/copyPromise';
+export { setupCopyIndex } from './algorithms/copyPromise';
+export { opendir, CustomDir } from './algorithms/opendir';
+export { watchFile, unwatchFile, unwatchAllFiles } from './algorithms/watchFile';
+export { normalizeLineEndings } from './FakeFS';
+export type { BufferEncodingOrBuffer } from './FakeFS';
+export type { CreateReadStreamOptions } from './FakeFS';
+export type { CreateWriteStreamOptions } from './FakeFS';
+export type { Dirent, DirentNoPath, Dir, SymlinkType } from './FakeFS';
+export type { MkdirOptions } from './FakeFS';
+export type { ReaddirOptions } from './FakeFS';
+export type { RmdirOptions, RmOptions } from './FakeFS';
+export type { WatchOptions } from './FakeFS';
+export type { WatchCallback } from './FakeFS';
+export type { Watcher } from './FakeFS';
+export type { WriteFileOptions } from './FakeFS';
+export type { ExtractHintOptions } from './FakeFS';
+export type { WatchFileOptions } from './FakeFS';
+export type { WatchFileCallback } from './FakeFS';
+export type { StatWatcher } from './FakeFS';
+export type { OpendirOptions } from './FakeFS';
+export type { StatOptions, StatSyncOptions } from './FakeFS';
+export type { Stats, BigIntStats } from './FakeFS';
+export { PortablePath, Filename } from './path';
+export type { FSPath, Path, NativePath } from './path';
+export type { ParsedPath, PathUtils, FormatInputPathObject } from './path';
+export { npath, ppath } from './path';
+export { AliasFS } from './AliasFS';
+export { FakeFS, BasePortableFakeFS } from './FakeFS';
+export { CwdFS } from './CwdFS';
+export { JailFS } from './JailFS';
+export { LazyFS } from './LazyFS';
+export { MountFS } from './MountFS';
+export type { GetMountPointFn, MountableFS, MountFSOptions } from './MountFS';
+export { NoFS } from './NoFS';
+export { NodeFS } from './NodeFS';
+export { PosixFS } from './PosixFS';
+export { ProxiedFS } from './ProxiedFS';
+export { VirtualFS } from './VirtualFS';
+export { patchFs, extendFs } from './patchFs/patchFs';
+export { xfs } from './xfs';
+export type { XFS } from './xfs';

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xfs = exports.extendFs = exports.patchFs = exports.VirtualFS = exports.ProxiedFS = exports.PosixFS = exports.NodeFS = exports.NoFS = exports.MountFS = exports.LazyFS = exports.JailFS = exports.CwdFS = exports.BasePortableFakeFS = exports.FakeFS = exports.AliasFS = exports.ppath = exports.npath = exports.Filename = exports.PortablePath = exports.normalizeLineEndings = exports.unwatchAllFiles = exports.unwatchFile = exports.watchFile = exports.CustomDir = exports.opendir = exports.setupCopyIndex = exports.statUtils = exports.errors = exports.constants = void 0;
+const tslib_1 = require("tslib");
+const constants = tslib_1.__importStar(require("./constants"));
+exports.constants = constants;
+const errors = tslib_1.__importStar(require("./errors"));
+exports.errors = errors;
+const statUtils = tslib_1.__importStar(require("./statUtils"));
+exports.statUtils = statUtils;
+var copyPromise_1 = require("./algorithms/copyPromise");
+Object.defineProperty(exports, "setupCopyIndex", { enumerable: true, get: function () { return copyPromise_1.setupCopyIndex; } });
+var opendir_1 = require("./algorithms/opendir");
+Object.defineProperty(exports, "opendir", { enumerable: true, get: function () { return opendir_1.opendir; } });
+Object.defineProperty(exports, "CustomDir", { enumerable: true, get: function () { return opendir_1.CustomDir; } });
+var watchFile_1 = require("./algorithms/watchFile");
+Object.defineProperty(exports, "watchFile", { enumerable: true, get: function () { return watchFile_1.watchFile; } });
+Object.defineProperty(exports, "unwatchFile", { enumerable: true, get: function () { return watchFile_1.unwatchFile; } });
+Object.defineProperty(exports, "unwatchAllFiles", { enumerable: true, get: function () { return watchFile_1.unwatchAllFiles; } });
+var FakeFS_1 = require("./FakeFS");
+Object.defineProperty(exports, "normalizeLineEndings", { enumerable: true, get: function () { return FakeFS_1.normalizeLineEndings; } });
+var path_1 = require("./path");
+Object.defineProperty(exports, "PortablePath", { enumerable: true, get: function () { return path_1.PortablePath; } });
+Object.defineProperty(exports, "Filename", { enumerable: true, get: function () { return path_1.Filename; } });
+var path_2 = require("./path");
+Object.defineProperty(exports, "npath", { enumerable: true, get: function () { return path_2.npath; } });
+Object.defineProperty(exports, "ppath", { enumerable: true, get: function () { return path_2.ppath; } });
+var AliasFS_1 = require("./AliasFS");
+Object.defineProperty(exports, "AliasFS", { enumerable: true, get: function () { return AliasFS_1.AliasFS; } });
+var FakeFS_2 = require("./FakeFS");
+Object.defineProperty(exports, "FakeFS", { enumerable: true, get: function () { return FakeFS_2.FakeFS; } });
+Object.defineProperty(exports, "BasePortableFakeFS", { enumerable: true, get: function () { return FakeFS_2.BasePortableFakeFS; } });
+var CwdFS_1 = require("./CwdFS");
+Object.defineProperty(exports, "CwdFS", { enumerable: true, get: function () { return CwdFS_1.CwdFS; } });
+var JailFS_1 = require("./JailFS");
+Object.defineProperty(exports, "JailFS", { enumerable: true, get: function () { return JailFS_1.JailFS; } });
+var LazyFS_1 = require("./LazyFS");
+Object.defineProperty(exports, "LazyFS", { enumerable: true, get: function () { return LazyFS_1.LazyFS; } });
+var MountFS_1 = require("./MountFS");
+Object.defineProperty(exports, "MountFS", { enumerable: true, get: function () { return MountFS_1.MountFS; } });
+var NoFS_1 = require("./NoFS");
+Object.defineProperty(exports, "NoFS", { enumerable: true, get: function () { return NoFS_1.NoFS; } });
+var NodeFS_1 = require("./NodeFS");
+Object.defineProperty(exports, "NodeFS", { enumerable: true, get: function () { return NodeFS_1.NodeFS; } });
+var PosixFS_1 = require("./PosixFS");
+Object.defineProperty(exports, "PosixFS", { enumerable: true, get: function () { return PosixFS_1.PosixFS; } });
+var ProxiedFS_1 = require("./ProxiedFS");
+Object.defineProperty(exports, "ProxiedFS", { enumerable: true, get: function () { return ProxiedFS_1.ProxiedFS; } });
+var VirtualFS_1 = require("./VirtualFS");
+Object.defineProperty(exports, "VirtualFS", { enumerable: true, get: function () { return VirtualFS_1.VirtualFS; } });
+var patchFs_1 = require("./patchFs/patchFs");
+Object.defineProperty(exports, "patchFs", { enumerable: true, get: function () { return patchFs_1.patchFs; } });
+Object.defineProperty(exports, "extendFs", { enumerable: true, get: function () { return patchFs_1.extendFs; } });
+var xfs_1 = require("./xfs");
+Object.defineProperty(exports, "xfs", { enumerable: true, get: function () { return xfs_1.xfs; } });

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

@@ -0,0 +1,81 @@
+import type { Abortable } from 'events';
+import type { FlagAndOpenMode, FileReadResult, FileReadOptions } from 'fs/promises';
+import type { CreateReadStreamOptions, CreateWriteStreamOptions, FakeFS } from '../FakeFS';
+import type { Path } from '../path';
+import type { BigIntStats, ObjectEncodingOptions, OpenMode, ReadStream, ReadVResult, StatOptions, Stats, WriteStream, WriteVResult } from 'fs';
+type WriteArgsBuffer<TBuffer extends Uint8Array> = [
+    buffer: TBuffer,
+    offset?: number | null,
+    length?: number | null,
+    position?: number | null
+];
+type WriteArgsString = [
+    data: string,
+    position?: number | null,
+    encoding?: BufferEncoding | null
+];
+declare const kBaseFs: unique symbol;
+declare const kFd: unique symbol;
+declare const kClosePromise: unique symbol;
+declare const kCloseResolve: unique symbol;
+declare const kCloseReject: unique symbol;
+declare const kRefs: unique symbol;
+declare const kRef: unique symbol;
+declare const kUnref: unique symbol;
+export declare class FileHandle<P extends Path> {
+    [kBaseFs]: FakeFS<P>;
+    [kFd]: number;
+    [kRefs]: number;
+    [kClosePromise]: Promise<void> | undefined;
+    [kCloseResolve]: (() => void) | undefined;
+    [kCloseReject]: (() => void) | undefined;
+    constructor(fd: number, baseFs: FakeFS<P>);
+    get fd(): number;
+    appendFile(data: string | Uint8Array, options?: (ObjectEncodingOptions & FlagAndOpenMode) | BufferEncoding | null): Promise<void>;
+    chown(uid: number, gid: number): Promise<void>;
+    chmod(mode: number): Promise<void>;
+    createReadStream(options?: CreateReadStreamOptions): ReadStream;
+    createWriteStream(options?: CreateWriteStreamOptions): WriteStream;
+    datasync(): Promise<void>;
+    sync(): Promise<void>;
+    read<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number | null, length?: number | null, position?: number | null): Promise<FileReadResult<T>>;
+    read<T extends NodeJS.ArrayBufferView>(buffer: T, options?: Omit<FileReadOptions<T>, `buffer`>): Promise<FileReadResult<T>>;
+    read<T extends NodeJS.ArrayBufferView = NonSharedBuffer>(options: FileReadOptions<T> & {
+        buffer: T;
+    }): Promise<FileReadResult<T>>;
+    read(options?: FileReadOptions<NonSharedBuffer> & {
+        buffer?: never;
+    }): Promise<FileReadResult<NonSharedBuffer>>;
+    readFile(options?: {
+        encoding?: null | undefined;
+        flag?: OpenMode | undefined;
+    } | null): Promise<Buffer>;
+    readFile(options: {
+        encoding: BufferEncoding;
+        flag?: OpenMode | undefined;
+    } | BufferEncoding): Promise<string>;
+    readLines(options?: CreateReadStreamOptions): import("readline").Interface;
+    stat(opts?: StatOptions & {
+        bigint?: false | undefined;
+    }): Promise<Stats>;
+    stat(opts: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    truncate(len?: number): Promise<void>;
+    utimes(atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    writeFile(data: string | Uint8Array, options?: (ObjectEncodingOptions & FlagAndOpenMode & Abortable) | BufferEncoding | null): Promise<void>;
+    write(...args: WriteArgsString): Promise<{
+        bytesWritten: number;
+        buffer: string;
+    }>;
+    write<TBuffer extends Uint8Array>(...args: WriteArgsBuffer<TBuffer>): Promise<{
+        bytesWritten: number;
+        buffer: TBuffer;
+    }>;
+    writev(buffers: Array<NodeJS.ArrayBufferView>, position?: number): Promise<WriteVResult>;
+    readv(buffers: ReadonlyArray<NodeJS.ArrayBufferView>, position?: number): Promise<ReadVResult>;
+    close(): Promise<void>;
+    [kRef](caller: Function): void;
+    [kUnref](): void;
+}
+export {};

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

@@ -0,0 +1,254 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandle = void 0;
+const readline_1 = require("readline");
+const kBaseFs = Symbol(`kBaseFs`);
+const kFd = Symbol(`kFd`);
+const kClosePromise = Symbol(`kClosePromise`);
+const kCloseResolve = Symbol(`kCloseResolve`);
+const kCloseReject = Symbol(`kCloseReject`);
+const kRefs = Symbol(`kRefs`);
+const kRef = Symbol(`kRef`);
+const kUnref = Symbol(`kUnref`);
+class FileHandle {
+    constructor(fd, baseFs) {
+        this[_a] = 1;
+        this[_b] = undefined;
+        this[_c] = undefined;
+        this[_d] = undefined;
+        this[kBaseFs] = baseFs;
+        this[kFd] = fd;
+    }
+    get fd() {
+        return this[kFd];
+    }
+    async appendFile(data, options) {
+        try {
+            this[kRef](this.appendFile);
+            const encoding = (typeof options === `string` ? options : options?.encoding) ?? undefined;
+            return await this[kBaseFs].appendFilePromise(this.fd, data, encoding ? { encoding } : undefined);
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    async chown(uid, gid) {
+        try {
+            this[kRef](this.chown);
+            return await this[kBaseFs].fchownPromise(this.fd, uid, gid);
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    async chmod(mode) {
+        try {
+            this[kRef](this.chmod);
+            return await this[kBaseFs].fchmodPromise(this.fd, mode);
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    createReadStream(options) {
+        return this[kBaseFs].createReadStream(null, { ...options, fd: this.fd });
+    }
+    createWriteStream(options) {
+        return this[kBaseFs].createWriteStream(null, { ...options, fd: this.fd });
+    }
+    // FIXME: Missing FakeFS version
+    datasync() {
+        throw new Error(`Method not implemented.`);
+    }
+    // FIXME: Missing FakeFS version
+    sync() {
+        throw new Error(`Method not implemented.`);
+    }
+    async read(bufferOrOptions, offsetOrOptions, length, position) {
+        try {
+            this[kRef](this.read);
+            let buffer;
+            let offset;
+            if (!ArrayBuffer.isView(bufferOrOptions)) {
+                // read([options])
+                // TypeScript isn't able to infer that the coalescing happens only in the no-generic case
+                buffer = bufferOrOptions?.buffer ?? Buffer.alloc(16384);
+                offset = bufferOrOptions?.offset ?? 0;
+                length = bufferOrOptions?.length ?? buffer.byteLength - offset;
+                position = bufferOrOptions?.position ?? null;
+            }
+            else if (typeof offsetOrOptions === `object` && offsetOrOptions !== null) {
+                // read(buffer[, options])
+                buffer = bufferOrOptions;
+                offset = offsetOrOptions?.offset ?? 0;
+                length = offsetOrOptions?.length ?? buffer.byteLength - offset;
+                position = offsetOrOptions?.position ?? null;
+            }
+            else {
+                // read(buffer, offset[, length[, position]])
+                buffer = bufferOrOptions;
+                offset = offsetOrOptions ?? 0;
+                length ??= 0;
+            }
+            if (length === 0) {
+                return {
+                    bytesRead: length,
+                    buffer,
+                };
+            }
+            const bytesRead = await this[kBaseFs].readPromise(this.fd, 
+            // FIXME: FakeFS should support ArrayBufferViews directly
+            Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength), offset, length, position);
+            return {
+                bytesRead,
+                buffer,
+            };
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    async readFile(options) {
+        try {
+            this[kRef](this.readFile);
+            const encoding = (typeof options === `string` ? options : options?.encoding) ?? undefined;
+            return await this[kBaseFs].readFilePromise(this.fd, encoding);
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    readLines(options) {
+        return (0, readline_1.createInterface)({
+            input: this.createReadStream(options),
+            crlfDelay: Infinity,
+        });
+    }
+    async stat(opts) {
+        try {
+            this[kRef](this.stat);
+            return await this[kBaseFs].fstatPromise(this.fd, opts);
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    async truncate(len) {
+        try {
+            this[kRef](this.truncate);
+            return await this[kBaseFs].ftruncatePromise(this.fd, len);
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    // FIXME: Missing FakeFS version
+    utimes(atime, mtime) {
+        throw new Error(`Method not implemented.`);
+    }
+    async writeFile(data, options) {
+        try {
+            this[kRef](this.writeFile);
+            const encoding = (typeof options === `string` ? options : options?.encoding) ?? undefined;
+            await this[kBaseFs].writeFilePromise(this.fd, data, encoding);
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    async write(...args) {
+        try {
+            this[kRef](this.write);
+            if (ArrayBuffer.isView(args[0])) {
+                const [buffer, offset, length, position] = args;
+                const bytesWritten = await this[kBaseFs].writePromise(this.fd, buffer, offset ?? undefined, length ?? undefined, position ?? undefined);
+                return { bytesWritten, buffer };
+            }
+            else {
+                const [data, position, encoding] = args;
+                // @ts-expect-error - FIXME: Types/implementation need to be updated in FakeFS
+                const bytesWritten = await this[kBaseFs].writePromise(this.fd, data, position, encoding);
+                return { bytesWritten, buffer: data };
+            }
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    // TODO: Use writev from FakeFS when that is implemented
+    async writev(buffers, position) {
+        try {
+            this[kRef](this.writev);
+            let bytesWritten = 0;
+            if (typeof position !== `undefined`) {
+                for (const buffer of buffers) {
+                    const writeResult = await this.write(buffer, undefined, undefined, position);
+                    bytesWritten += writeResult.bytesWritten;
+                    position += writeResult.bytesWritten;
+                }
+            }
+            else {
+                for (const buffer of buffers) {
+                    const writeResult = await this.write(buffer);
+                    bytesWritten += writeResult.bytesWritten;
+                }
+            }
+            return {
+                buffers,
+                bytesWritten,
+            };
+        }
+        finally {
+            this[kUnref]();
+        }
+    }
+    // FIXME: Missing FakeFS version
+    readv(buffers, position) {
+        throw new Error(`Method not implemented.`);
+    }
+    close() {
+        if (this[kFd] === -1)
+            return Promise.resolve();
+        if (this[kClosePromise])
+            return this[kClosePromise];
+        this[kRefs]--;
+        if (this[kRefs] === 0) {
+            const fd = this[kFd];
+            this[kFd] = -1;
+            this[kClosePromise] = this[kBaseFs].closePromise(fd).finally(() => {
+                this[kClosePromise] = undefined;
+            });
+        }
+        else {
+            this[kClosePromise] =
+                new Promise((resolve, reject) => {
+                    this[kCloseResolve] = resolve;
+                    this[kCloseReject] = reject;
+                }).finally(() => {
+                    this[kClosePromise] = undefined;
+                    this[kCloseReject] = undefined;
+                    this[kCloseResolve] = undefined;
+                });
+        }
+        return this[kClosePromise];
+    }
+    [(_a = kRefs, _b = kClosePromise, _c = kCloseResolve, _d = kCloseReject, kRef)](caller) {
+        if (this[kFd] === -1) {
+            const err = new Error(`file closed`);
+            err.code = `EBADF`;
+            err.syscall = caller.name;
+            throw err;
+        }
+        this[kRefs]++;
+    }
+    [kUnref]() {
+        this[kRefs]--;
+        if (this[kRefs] === 0) {
+            const fd = this[kFd];
+            this[kFd] = -1;
+            this[kBaseFs].closePromise(fd).then(this[kCloseResolve], this[kCloseReject]);
+        }
+    }
+}
+exports.FileHandle = FileHandle;

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

@@ -0,0 +1,5 @@
+import fs from 'fs';
+import { FakeFS } from '../FakeFS';
+import { NativePath } from '../path';
+export declare function patchFs(patchedFs: typeof fs, fakeFs: FakeFS<NativePath>): void;
+export declare function extendFs(realFs: typeof fs, fakeFs: FakeFS<NativePath>): typeof fs;