@pnpm/exe 12.9.0 → 12.10.0

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

@@ -1,78 +0,0 @@
-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

@@ -1,229 +0,0 @@
-"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

@@ -1,223 +0,0 @@
-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;
-}