@pnpm/exe 12.8.2 → 12.9.0

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

@@ -0,0 +1,78 @@
+import { FakeFS } from './FakeFS';
+import { PortablePath } from './path';
+export declare class NoFS extends FakeFS<PortablePath> {
+    static readonly instance: NoFS;
+    constructor();
+    getExtractHint(): never;
+    getRealPath(): never;
+    resolve(): never;
+    openPromise(): Promise<never>;
+    openSync(): never;
+    opendirPromise(): Promise<never>;
+    opendirSync(): never;
+    readPromise(): Promise<never>;
+    readSync(): never;
+    writePromise(): Promise<never>;
+    writeSync(): never;
+    closePromise(): Promise<never>;
+    closeSync(): never;
+    createWriteStream(): never;
+    createReadStream(): never;
+    realpathPromise(): Promise<never>;
+    realpathSync(): never;
+    readdirPromise(): Promise<never>;
+    readdirSync(): never;
+    existsPromise(p: PortablePath): Promise<never>;
+    existsSync(p: PortablePath): never;
+    accessPromise(): Promise<never>;
+    accessSync(): never;
+    statPromise(): Promise<never>;
+    statSync(): never;
+    fstatPromise(fd: number): Promise<never>;
+    fstatSync(fd: number): never;
+    lstatPromise(p: PortablePath): Promise<never>;
+    lstatSync(p: PortablePath): never;
+    fchmodPromise(): Promise<never>;
+    fchmodSync(): never;
+    chmodPromise(): Promise<never>;
+    chmodSync(): never;
+    fchownPromise(): Promise<never>;
+    fchownSync(): never;
+    chownPromise(): Promise<never>;
+    chownSync(): never;
+    mkdirPromise(): Promise<never>;
+    mkdirSync(): never;
+    rmdirPromise(): Promise<never>;
+    rmdirSync(): never;
+    rmPromise(): Promise<never>;
+    rmSync(): never;
+    linkPromise(): Promise<never>;
+    linkSync(): never;
+    symlinkPromise(): Promise<never>;
+    symlinkSync(): never;
+    renamePromise(): Promise<never>;
+    renameSync(): never;
+    copyFilePromise(): Promise<never>;
+    copyFileSync(): never;
+    appendFilePromise(): Promise<never>;
+    appendFileSync(): never;
+    writeFilePromise(): Promise<never>;
+    writeFileSync(): never;
+    unlinkPromise(): Promise<never>;
+    unlinkSync(): never;
+    utimesPromise(): Promise<never>;
+    utimesSync(): never;
+    lutimesPromise(): Promise<never>;
+    lutimesSync(): never;
+    readFilePromise(): Promise<never>;
+    readFileSync(): never;
+    readlinkPromise(): Promise<never>;
+    readlinkSync(): never;
+    truncatePromise(): Promise<never>;
+    truncateSync(): never;
+    ftruncatePromise(fd: number, len?: number): Promise<never>;
+    ftruncateSync(fd: number, len?: number): never;
+    watch(): never;
+    watchFile(): never;
+    unwatchFile(): never;
+}

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

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoFS = void 0;
+const FakeFS_1 = require("./FakeFS");
+const path_1 = require("./path");
+const makeError = () => Object.assign(new Error(`ENOSYS: unsupported filesystem access`), { code: `ENOSYS` });
+class NoFS extends FakeFS_1.FakeFS {
+    constructor() {
+        super(path_1.ppath);
+    }
+    getExtractHint() {
+        throw makeError();
+    }
+    getRealPath() {
+        throw makeError();
+    }
+    resolve() {
+        throw makeError();
+    }
+    async openPromise() {
+        throw makeError();
+    }
+    openSync() {
+        throw makeError();
+    }
+    async opendirPromise() {
+        throw makeError();
+    }
+    opendirSync() {
+        throw makeError();
+    }
+    async readPromise() {
+        throw makeError();
+    }
+    readSync() {
+        throw makeError();
+    }
+    async writePromise() {
+        throw makeError();
+    }
+    writeSync() {
+        throw makeError();
+    }
+    async closePromise() {
+        throw makeError();
+    }
+    closeSync() {
+        throw makeError();
+    }
+    createWriteStream() {
+        throw makeError();
+    }
+    createReadStream() {
+        throw makeError();
+    }
+    async realpathPromise() {
+        throw makeError();
+    }
+    realpathSync() {
+        throw makeError();
+    }
+    async readdirPromise() {
+        throw makeError();
+    }
+    readdirSync() {
+        throw makeError();
+    }
+    async existsPromise(p) {
+        throw makeError();
+    }
+    existsSync(p) {
+        throw makeError();
+    }
+    async accessPromise() {
+        throw makeError();
+    }
+    accessSync() {
+        throw makeError();
+    }
+    async statPromise() {
+        throw makeError();
+    }
+    statSync() {
+        throw makeError();
+    }
+    async fstatPromise(fd) {
+        throw makeError();
+    }
+    fstatSync(fd) {
+        throw makeError();
+    }
+    async lstatPromise(p) {
+        throw makeError();
+    }
+    lstatSync(p) {
+        throw makeError();
+    }
+    async fchmodPromise() {
+        throw makeError();
+    }
+    fchmodSync() {
+        throw makeError();
+    }
+    async chmodPromise() {
+        throw makeError();
+    }
+    chmodSync() {
+        throw makeError();
+    }
+    async fchownPromise() {
+        throw makeError();
+    }
+    fchownSync() {
+        throw makeError();
+    }
+    async chownPromise() {
+        throw makeError();
+    }
+    chownSync() {
+        throw makeError();
+    }
+    async mkdirPromise() {
+        throw makeError();
+    }
+    mkdirSync() {
+        throw makeError();
+    }
+    async rmdirPromise() {
+        throw makeError();
+    }
+    rmdirSync() {
+        throw makeError();
+    }
+    async rmPromise() {
+        throw makeError();
+    }
+    rmSync() {
+        throw makeError();
+    }
+    async linkPromise() {
+        throw makeError();
+    }
+    linkSync() {
+        throw makeError();
+    }
+    async symlinkPromise() {
+        throw makeError();
+    }
+    symlinkSync() {
+        throw makeError();
+    }
+    async renamePromise() {
+        throw makeError();
+    }
+    renameSync() {
+        throw makeError();
+    }
+    async copyFilePromise() {
+        throw makeError();
+    }
+    copyFileSync() {
+        throw makeError();
+    }
+    async appendFilePromise() {
+        throw makeError();
+    }
+    appendFileSync() {
+        throw makeError();
+    }
+    async writeFilePromise() {
+        throw makeError();
+    }
+    writeFileSync() {
+        throw makeError();
+    }
+    async unlinkPromise() {
+        throw makeError();
+    }
+    unlinkSync() {
+        throw makeError();
+    }
+    async utimesPromise() {
+        throw makeError();
+    }
+    utimesSync() {
+        throw makeError();
+    }
+    async lutimesPromise() {
+        throw makeError();
+    }
+    lutimesSync() {
+        throw makeError();
+    }
+    async readFilePromise() {
+        throw makeError();
+    }
+    readFileSync() {
+        throw makeError();
+    }
+    async readlinkPromise() {
+        throw makeError();
+    }
+    readlinkSync() {
+        throw makeError();
+    }
+    async truncatePromise() {
+        throw makeError();
+    }
+    truncateSync() {
+        throw makeError();
+    }
+    async ftruncatePromise(fd, len) {
+        throw makeError();
+    }
+    ftruncateSync(fd, len) {
+        throw makeError();
+    }
+    watch() {
+        throw makeError();
+    }
+    watchFile() {
+        throw makeError();
+    }
+    unwatchFile() {
+        throw makeError();
+    }
+}
+exports.NoFS = NoFS;
+NoFS.instance = new NoFS();

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

@@ -0,0 +1,223 @@
+import fs, { BigIntStats, Stats } from 'fs';
+import { CreateReadStreamOptions, CreateWriteStreamOptions, Dir, StatWatcher, WatchFileCallback, WatchFileOptions, OpendirOptions, DirentNoPath } from './FakeFS';
+import { Dirent, SymlinkType, StatSyncOptions, StatOptions } from './FakeFS';
+import { BasePortableFakeFS, WriteFileOptions } from './FakeFS';
+import { MkdirOptions, RmdirOptions, RmOptions, WatchOptions, WatchCallback, Watcher } from './FakeFS';
+import { FSPath, PortablePath, Filename } from './path';
+export declare class NodeFS extends BasePortableFakeFS {
+    private readonly realFs;
+    constructor(realFs?: typeof fs);
+    getExtractHint(): boolean;
+    getRealPath(): PortablePath;
+    resolve(p: PortablePath): PortablePath;
+    openPromise(p: PortablePath, flags: string, mode?: number): Promise<number>;
+    openSync(p: PortablePath, flags: string, mode?: number): number;
+    opendirPromise(p: PortablePath, opts?: OpendirOptions): Promise<Dir<PortablePath>>;
+    opendirSync(p: PortablePath, opts?: OpendirOptions): Dir<PortablePath>;
+    readPromise(fd: number, buffer: Buffer, offset?: number, length?: number, position?: number | null): Promise<number>;
+    readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
+    writePromise(fd: number, buffer: Buffer, offset?: number, length?: number, position?: number): Promise<number>;
+    writePromise(fd: number, buffer: string, position?: number): Promise<number>;
+    writeSync(fd: number, buffer: Buffer, offset?: number, length?: number, position?: number): number;
+    writeSync(fd: number, buffer: string, position?: number): number;
+    closePromise(fd: number): Promise<void>;
+    closeSync(fd: number): void;
+    createReadStream(p: PortablePath | null, opts?: CreateReadStreamOptions): fs.ReadStream;
+    createWriteStream(p: PortablePath | null, opts?: CreateWriteStreamOptions): fs.WriteStream;
+    realpathPromise(p: PortablePath): Promise<PortablePath>;
+    realpathSync(p: PortablePath): PortablePath;
+    existsPromise(p: PortablePath): Promise<boolean>;
+    accessSync(p: PortablePath, mode?: number): void;
+    accessPromise(p: PortablePath, mode?: number): Promise<void>;
+    existsSync(p: PortablePath): boolean;
+    statPromise(p: PortablePath): Promise<Stats>;
+    statPromise(p: PortablePath, opts: (StatOptions & {
+        bigint?: false | undefined;
+    }) | undefined): Promise<Stats>;
+    statPromise(p: PortablePath, opts: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    statSync(p: PortablePath): Stats;
+    statSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }): Stats | undefined;
+    statSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): BigIntStats | undefined;
+    statSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+    }): Stats;
+    statSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+    }): BigIntStats;
+    statSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: boolean;
+        throwIfNoEntry?: false | undefined;
+    }): Stats | BigIntStats;
+    fstatPromise(fd: number): Promise<Stats>;
+    fstatPromise(fd: number, opts: {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    fstatPromise(fd: number, opts?: {
+        bigint: boolean;
+    }): Promise<BigIntStats | Stats>;
+    fstatSync(fd: number): Stats;
+    fstatSync(fd: number, opts: {
+        bigint: true;
+    }): BigIntStats;
+    fstatSync(fd: number, opts?: {
+        bigint: boolean;
+    }): BigIntStats | Stats;
+    lstatPromise(p: PortablePath): Promise<Stats>;
+    lstatPromise(p: PortablePath, opts: (StatOptions & {
+        bigint?: false | undefined;
+    }) | undefined): Promise<Stats>;
+    lstatPromise(p: PortablePath, opts: StatOptions & {
+        bigint: true;
+    }): Promise<BigIntStats>;
+    lstatSync(p: PortablePath): Stats;
+    lstatSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }): Stats | undefined;
+    lstatSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): BigIntStats | undefined;
+    lstatSync(p: PortablePath, opts?: StatSyncOptions & {
+        bigint?: false | undefined;
+    }): Stats;
+    lstatSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: true;
+    }): BigIntStats;
+    lstatSync(p: PortablePath, opts: StatSyncOptions & {
+        bigint: boolean;
+        throwIfNoEntry?: false | undefined;
+    }): Stats | BigIntStats;
+    fchmodPromise(fd: number, mask: number): Promise<void>;
+    fchmodSync(fd: number, mask: number): void;
+    chmodPromise(p: PortablePath, mask: number): Promise<void>;
+    chmodSync(p: PortablePath, mask: number): void;
+    fchownPromise(fd: number, uid: number, gid: number): Promise<void>;
+    fchownSync(fd: number, uid: number, gid: number): void;
+    chownPromise(p: PortablePath, uid: number, gid: number): Promise<void>;
+    chownSync(p: PortablePath, uid: number, gid: number): void;
+    renamePromise(oldP: PortablePath, newP: PortablePath): Promise<void>;
+    renameSync(oldP: PortablePath, newP: PortablePath): void;
+    copyFilePromise(sourceP: PortablePath, destP: PortablePath, flags?: number): Promise<void>;
+    copyFileSync(sourceP: PortablePath, destP: PortablePath, flags?: number): void;
+    appendFilePromise(p: FSPath<PortablePath>, content: string | Uint8Array, opts?: WriteFileOptions): Promise<void>;
+    appendFileSync(p: PortablePath, content: string | Uint8Array, opts?: WriteFileOptions): void;
+    writeFilePromise(p: FSPath<PortablePath>, content: string | NodeJS.ArrayBufferView, opts?: WriteFileOptions): Promise<void>;
+    writeFileSync(p: PortablePath, content: string | NodeJS.ArrayBufferView, opts?: WriteFileOptions): void;
+    unlinkPromise(p: PortablePath): Promise<void>;
+    unlinkSync(p: PortablePath): void;
+    utimesPromise(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): Promise<void>;
+    utimesSync(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): void;
+    lutimesPromise(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): Promise<void>;
+    lutimesSync(p: PortablePath, atime: Date | string | number, mtime: Date | string | number): void;
+    mkdirPromise(p: PortablePath, opts?: MkdirOptions): Promise<string | undefined>;
+    mkdirSync(p: PortablePath, opts?: MkdirOptions): string | undefined;
+    rmdirPromise(p: PortablePath, opts?: RmdirOptions): Promise<void>;
+    rmdirSync(p: PortablePath, opts?: RmdirOptions): void;
+    rmPromise(p: PortablePath, opts?: RmOptions): Promise<void>;
+    rmSync(p: PortablePath, opts?: RmOptions): void;
+    linkPromise(existingP: PortablePath, newP: PortablePath): Promise<void>;
+    linkSync(existingP: PortablePath, newP: PortablePath): void;
+    symlinkPromise(target: PortablePath, p: PortablePath, type?: SymlinkType): Promise<void>;
+    symlinkSync(target: PortablePath, p: PortablePath, type?: SymlinkType): void;
+    readFilePromise(p: FSPath<PortablePath>, encoding?: null): Promise<NonSharedBuffer>;
+    readFilePromise(p: FSPath<PortablePath>, encoding: BufferEncoding): Promise<string>;
+    readFilePromise(p: FSPath<PortablePath>, encoding?: BufferEncoding | null): Promise<NonSharedBuffer | string>;
+    readFileSync(p: FSPath<PortablePath>, encoding?: null): NonSharedBuffer;
+    readFileSync(p: FSPath<PortablePath>, encoding: BufferEncoding): string;
+    readFileSync(p: FSPath<PortablePath>, encoding?: BufferEncoding | null): NonSharedBuffer | string;
+    readdirPromise(p: PortablePath, opts?: null): Promise<Array<Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: true;
+    }): Promise<Array<DirentNoPath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes?: false;
+    }): Promise<Array<Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: boolean;
+    }): Promise<Array<DirentNoPath | Filename>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: true;
+    }): Promise<Array<Dirent<PortablePath>>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes?: false;
+    }): Promise<Array<PortablePath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: boolean;
+    }): Promise<Array<Dirent<PortablePath> | PortablePath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: true;
+    }): Promise<Array<Dirent<PortablePath> | DirentNoPath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes?: false;
+    }): Promise<Array<PortablePath>>;
+    readdirPromise(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: boolean;
+    }): Promise<Array<Dirent<PortablePath> | DirentNoPath | PortablePath>>;
+    readdirSync(p: PortablePath, opts?: null): Array<Filename>;
+    readdirSync(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: true;
+    }): Array<DirentNoPath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes?: false;
+    }): Array<Filename>;
+    readdirSync(p: PortablePath, opts: {
+        recursive?: false;
+        withFileTypes: boolean;
+    }): Array<DirentNoPath | Filename>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: true;
+    }): Array<Dirent<PortablePath>>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes?: false;
+    }): Array<PortablePath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: true;
+        withFileTypes: boolean;
+    }): Array<Dirent<PortablePath> | PortablePath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: true;
+    }): Array<Dirent<PortablePath> | DirentNoPath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes?: false;
+    }): Array<PortablePath>;
+    readdirSync(p: PortablePath, opts: {
+        recursive: boolean;
+        withFileTypes: boolean;
+    }): Array<Dirent<PortablePath> | DirentNoPath | PortablePath>;
+    readlinkPromise(p: PortablePath): Promise<PortablePath>;
+    readlinkSync(p: PortablePath): PortablePath;
+    truncatePromise(p: PortablePath, len?: number): Promise<void>;
+    truncateSync(p: PortablePath, len?: number): void;
+    ftruncatePromise(fd: number, len?: number): Promise<void>;
+    ftruncateSync(fd: number, len?: number): void;
+    watch(p: PortablePath, cb?: WatchCallback): Watcher;
+    watch(p: PortablePath, opts: WatchOptions, cb?: WatchCallback): Watcher;
+    watchFile(p: PortablePath, cb: WatchFileCallback): StatWatcher;
+    watchFile(p: PortablePath, opts: WatchFileOptions, cb: WatchFileCallback): StatWatcher;
+    unwatchFile(p: PortablePath, cb?: WatchFileCallback): void;
+    private makeCallback;
+}