@pnpm/exe 12.9.0 → 12.10.0

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

@@ -1,229 +0,0 @@
-import { Stats, BigIntStats } from 'fs';
-import { CreateReadStreamOptions, CreateWriteStreamOptions, FakeFS, ExtractHintOptions, WatchFileCallback, WatchFileOptions, StatWatcher, Dir, OpendirOptions, DirentNoPath } from './FakeFS';
-import { Dirent, SymlinkType, StatSyncOptions, StatOptions } from './FakeFS';
-import { MkdirOptions, RmdirOptions, RmOptions, WriteFileOptions, WatchCallback, WatchOptions, Watcher } from './FakeFS';
-import { FSPath, Filename, Path } from './path';
-export declare abstract class ProxiedFS<P extends Path, IP extends Path> extends FakeFS<P> {
-    protected abstract readonly baseFs: FakeFS<IP>;
-    /**
-     * Convert a path from the user format into what should be fed into the internal FS.
-     */
-    protected abstract mapToBase(path: P): IP;
-    /**
-     * Convert a path from the format supported by the base FS into the user one.
-     */
-    protected abstract mapFromBase(path: IP): P;
-    getExtractHint(hints: ExtractHintOptions): boolean;
-    resolve(path: P): P;
-    getRealPath(): P;
-    openPromise(p: P, flags: string, mode?: number): Promise<number>;
-    openSync(p: P, flags: string, mode?: number): number;
-    opendirPromise(p: P, opts?: OpendirOptions): Promise<Dir<P>>;
-    opendirSync(p: P, opts?: OpendirOptions): Dir<P>;
-    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: P | null, opts?: CreateReadStreamOptions): import("fs").ReadStream;
-    createWriteStream(p: P | null, opts?: CreateWriteStreamOptions): import("fs").WriteStream;
-    realpathPromise(p: P): Promise<P>;
-    realpathSync(p: P): P;
-    existsPromise(p: P): Promise<boolean>;
-    existsSync(p: P): boolean;
-    accessSync(p: P, mode?: number): void;
-    accessPromise(p: P, mode?: number): Promise<void>;
-    statPromise(p: P): Promise<Stats>;
-    statPromise(p: P, opts: (StatOptions & {
-        bigint?: false | undefined;
-    }) | undefined): Promise<Stats>;
-    statPromise(p: P, opts: StatOptions & {
-        bigint: true;
-    }): Promise<BigIntStats>;
-    statSync(p: P): Stats;
-    statSync(p: P, opts?: StatSyncOptions & {
-        bigint?: false | undefined;
-        throwIfNoEntry: false;
-    }): Stats | undefined;
-    statSync(p: P, opts: StatSyncOptions & {
-        bigint: true;
-        throwIfNoEntry: false;
-    }): BigIntStats | undefined;
-    statSync(p: P, opts?: StatSyncOptions & {
-        bigint?: false | undefined;
-    }): Stats;
-    statSync(p: P, opts: StatSyncOptions & {
-        bigint: true;
-    }): BigIntStats;
-    statSync(p: P, 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: P): Promise<Stats>;
-    lstatPromise(p: P, opts: (StatOptions & {
-        bigint?: false | undefined;
-    }) | undefined): Promise<Stats>;
-    lstatPromise(p: P, opts: StatOptions & {
-        bigint: true;
-    }): Promise<BigIntStats>;
-    lstatSync(p: P): Stats;
-    lstatSync(p: P, opts?: StatSyncOptions & {
-        bigint?: false | undefined;
-        throwIfNoEntry: false;
-    }): Stats | undefined;
-    lstatSync(p: P, opts: StatSyncOptions & {
-        bigint: true;
-        throwIfNoEntry: false;
-    }): BigIntStats | undefined;
-    lstatSync(p: P, opts?: StatSyncOptions & {
-        bigint?: false | undefined;
-    }): Stats;
-    lstatSync(p: P, opts: StatSyncOptions & {
-        bigint: true;
-    }): BigIntStats;
-    lstatSync(p: P, opts: StatSyncOptions & {
-        bigint: boolean;
-        throwIfNoEntry?: false | undefined;
-    }): Stats | BigIntStats;
-    fchmodPromise(fd: number, mask: number): Promise<void>;
-    fchmodSync(fd: number, mask: number): void;
-    chmodPromise(p: P, mask: number): Promise<void>;
-    chmodSync(p: P, mask: number): void;
-    fchownPromise(fd: number, uid: number, gid: number): Promise<void>;
-    fchownSync(fd: number, uid: number, gid: number): void;
-    chownPromise(p: P, uid: number, gid: number): Promise<void>;
-    chownSync(p: P, uid: number, gid: number): void;
-    renamePromise(oldP: P, newP: P): Promise<void>;
-    renameSync(oldP: P, newP: P): void;
-    copyFilePromise(sourceP: P, destP: P, flags?: number): Promise<void>;
-    copyFileSync(sourceP: P, destP: P, flags?: number): void;
-    appendFilePromise(p: FSPath<P>, content: string | Uint8Array, opts?: WriteFileOptions): Promise<void>;
-    appendFileSync(p: FSPath<P>, content: string | Uint8Array, opts?: WriteFileOptions): void;
-    writeFilePromise(p: FSPath<P>, content: string | NodeJS.ArrayBufferView, opts?: WriteFileOptions): Promise<void>;
-    writeFileSync(p: FSPath<P>, content: string | NodeJS.ArrayBufferView, opts?: WriteFileOptions): void;
-    unlinkPromise(p: P): Promise<void>;
-    unlinkSync(p: P): void;
-    utimesPromise(p: P, atime: Date | string | number, mtime: Date | string | number): Promise<void>;
-    utimesSync(p: P, atime: Date | string | number, mtime: Date | string | number): void;
-    lutimesPromise(p: P, atime: Date | string | number, mtime: Date | string | number): Promise<void>;
-    lutimesSync(p: P, atime: Date | string | number, mtime: Date | string | number): void;
-    mkdirPromise(p: P, opts?: MkdirOptions): Promise<string | undefined>;
-    mkdirSync(p: P, opts?: MkdirOptions): string | undefined;
-    rmdirPromise(p: P, opts?: RmdirOptions): Promise<void>;
-    rmdirSync(p: P, opts?: RmdirOptions): void;
-    rmPromise(p: P, opts?: RmOptions): Promise<void>;
-    rmSync(p: P, opts?: RmOptions): void;
-    linkPromise(existingP: P, newP: P): Promise<void>;
-    linkSync(existingP: P, newP: P): void;
-    symlinkPromise(target: P, p: P, type?: SymlinkType): Promise<void>;
-    symlinkSync(target: P, p: P, type?: SymlinkType): void;
-    readFilePromise(p: FSPath<P>, encoding?: null): Promise<NonSharedBuffer>;
-    readFilePromise(p: FSPath<P>, encoding: BufferEncoding): Promise<string>;
-    readFilePromise(p: FSPath<P>, encoding?: BufferEncoding | null): Promise<NonSharedBuffer | string>;
-    readFileSync(p: FSPath<P>, encoding?: null): NonSharedBuffer;
-    readFileSync(p: FSPath<P>, encoding: BufferEncoding): string;
-    readFileSync(p: FSPath<P>, encoding?: BufferEncoding | null): NonSharedBuffer | string;
-    readdirPromise(p: P, opts?: null): Promise<Array<Filename>>;
-    readdirPromise(p: P, opts: {
-        recursive?: false;
-        withFileTypes: true;
-    }): Promise<Array<DirentNoPath>>;
-    readdirPromise(p: P, opts: {
-        recursive?: false;
-        withFileTypes?: false;
-    }): Promise<Array<Filename>>;
-    readdirPromise(p: P, opts: {
-        recursive?: false;
-        withFileTypes: boolean;
-    }): Promise<Array<DirentNoPath | Filename>>;
-    readdirPromise(p: P, opts: {
-        recursive: true;
-        withFileTypes: true;
-    }): Promise<Array<Dirent<P>>>;
-    readdirPromise(p: P, opts: {
-        recursive: true;
-        withFileTypes?: false;
-    }): Promise<Array<P>>;
-    readdirPromise(p: P, opts: {
-        recursive: true;
-        withFileTypes: boolean;
-    }): Promise<Array<Dirent<P> | P>>;
-    readdirPromise(p: P, opts: {
-        recursive: boolean;
-        withFileTypes: true;
-    }): Promise<Array<Dirent<P> | DirentNoPath>>;
-    readdirPromise(p: P, opts: {
-        recursive: boolean;
-        withFileTypes?: false;
-    }): Promise<Array<P>>;
-    readdirPromise(p: P, opts: {
-        recursive: boolean;
-        withFileTypes: boolean;
-    }): Promise<Array<Dirent<P> | DirentNoPath | P>>;
-    readdirSync(p: P, opts?: null): Array<Filename>;
-    readdirSync(p: P, opts: {
-        recursive?: false;
-        withFileTypes: true;
-    }): Array<DirentNoPath>;
-    readdirSync(p: P, opts: {
-        recursive?: false;
-        withFileTypes?: false;
-    }): Array<Filename>;
-    readdirSync(p: P, opts: {
-        recursive?: false;
-        withFileTypes: boolean;
-    }): Array<DirentNoPath | Filename>;
-    readdirSync(p: P, opts: {
-        recursive: true;
-        withFileTypes: true;
-    }): Array<Dirent<P>>;
-    readdirSync(p: P, opts: {
-        recursive: true;
-        withFileTypes?: false;
-    }): Array<P>;
-    readdirSync(p: P, opts: {
-        recursive: true;
-        withFileTypes: boolean;
-    }): Array<Dirent<P> | P>;
-    readdirSync(p: P, opts: {
-        recursive: boolean;
-        withFileTypes: true;
-    }): Array<Dirent<P> | DirentNoPath>;
-    readdirSync(p: P, opts: {
-        recursive: boolean;
-        withFileTypes?: false;
-    }): Array<P>;
-    readdirSync(p: P, opts: {
-        recursive: boolean;
-        withFileTypes: boolean;
-    }): Array<Dirent<P> | DirentNoPath | P>;
-    readlinkPromise(p: P): Promise<P>;
-    readlinkSync(p: P): P;
-    truncatePromise(p: P, len?: number): Promise<void>;
-    truncateSync(p: P, len?: number): void;
-    ftruncatePromise(fd: number, len?: number): Promise<void>;
-    ftruncateSync(fd: number, len?: number): void;
-    watch(p: P, cb?: WatchCallback): Watcher;
-    watch(p: P, opts: WatchOptions, cb?: WatchCallback): Watcher;
-    watchFile(p: P, cb: WatchFileCallback): StatWatcher;
-    watchFile(p: P, opts: WatchFileOptions, cb: WatchFileCallback): StatWatcher;
-    unwatchFile(p: P, cb?: WatchFileCallback): void;
-    private fsMapToBase;
-}

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

@@ -1,255 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProxiedFS = void 0;
-const FakeFS_1 = require("./FakeFS");
-class ProxiedFS extends FakeFS_1.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 - reason TBS
-        a, b);
-    }
-    watchFile(p, a, b) {
-        return this.baseFs.watchFile(this.mapToBase(p), 
-        // @ts-expect-error - reason TBS
-        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);
-        }
-    }
-}
-exports.ProxiedFS = ProxiedFS;

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

@@ -1,19 +0,0 @@
-import { FakeFS, ExtractHintOptions } from './FakeFS';
-import { ProxiedFS } from './ProxiedFS';
-import { Filename, PortablePath } from './path';
-export type VirtualFSOptions = {
-    baseFs?: FakeFS<PortablePath>;
-    folderName?: Filename;
-};
-export declare class VirtualFS extends ProxiedFS<PortablePath, PortablePath> {
-    protected readonly baseFs: FakeFS<PortablePath>;
-    static makeVirtualPath(base: PortablePath, component: Filename, to: PortablePath): PortablePath;
-    static resolveVirtual(p: PortablePath): PortablePath;
-    constructor({ baseFs }?: VirtualFSOptions);
-    getExtractHint(hints: ExtractHintOptions): boolean;
-    getRealPath(): PortablePath;
-    realpathSync(p: PortablePath): PortablePath;
-    realpathPromise(p: PortablePath): Promise<PortablePath>;
-    mapToBase(p: PortablePath): PortablePath;
-    mapFromBase(p: PortablePath): PortablePath;
-}

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

@@ -1,89 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VirtualFS = void 0;
-const NodeFS_1 = require("./NodeFS");
-const ProxiedFS_1 = require("./ProxiedFS");
-const path_1 = require("./path");
-const NUMBER_REGEXP = /^[0-9]+$/;
-// $0: full path
-// $1: virtual folder
-// $2: virtual segment
-// $3: hash
-// $4: depth
-// $5: subpath
-const VIRTUAL_REGEXP = /^(\/(?:[^/]+\/)*?(?:\$\$virtual|__virtual__))((?:\/((?:[^/]+-)?[a-f0-9]+)(?:\/([^/]+))?)?((?:\/.*)?))$/;
-const VALID_COMPONENT = /^([^/]+-)?[a-f0-9]+$/;
-class VirtualFS extends ProxiedFS_1.ProxiedFS {
-    static makeVirtualPath(base, component, to) {
-        if (path_1.ppath.basename(base) !== `__virtual__`)
-            throw new Error(`Assertion failed: Virtual folders must be named "__virtual__"`);
-        if (!path_1.ppath.basename(component).match(VALID_COMPONENT))
-            throw new Error(`Assertion failed: Virtual components must be ended by an hexadecimal hash`);
-        // Obtains the relative distance between the virtual path and its actual target
-        const target = path_1.ppath.relative(path_1.ppath.dirname(base), to);
-        const segments = target.split(`/`);
-        // Counts how many levels we need to go back to start applying the rest of the path
-        let depth = 0;
-        while (depth < segments.length && segments[depth] === `..`)
-            depth += 1;
-        const finalSegments = segments.slice(depth);
-        const fullVirtualPath = path_1.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 = path_1.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(path_1.ppath.join(target, backstep, subpath));
-    }
-    constructor({ baseFs = new NodeFS_1.NodeFS() } = {}) {
-        super(path_1.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(path_1.PortablePath.dot));
-        const resolvedP = VirtualFS.resolveVirtual(this.baseFs.resolve(p));
-        return path_1.ppath.relative(resolvedRoot, resolvedP) || path_1.PortablePath.dot;
-    }
-    mapFromBase(p) {
-        return p;
-    }
-}
-exports.VirtualFS = VirtualFS;

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

@@ -1,19 +0,0 @@
-import { FakeFS } from '../FakeFS';
-import { Path } from '../path';
-export type HardlinkFromIndexStrategy<P> = {
-    type: `HardlinkFromIndex`;
-    indexPath: P;
-    autoRepair?: boolean;
-    readOnly?: boolean;
-};
-export type LinkStrategy<P> = HardlinkFromIndexStrategy<P>;
-export type CopyOptions<P> = {
-    linkStrategy: LinkStrategy<P> | null;
-    stableTime: boolean;
-    stableSort: boolean;
-    overwrite: boolean;
-};
-export type Operations = Array<() => Promise<void>>;
-export type LUTimes<P extends Path> = Array<[P, Date | number, Date | number]>;
-export declare function setupCopyIndex<P extends Path>(destinationFs: FakeFS<P>, linkStrategy: Pick<HardlinkFromIndexStrategy<P>, `indexPath`>): Promise<P>;
-export declare function copyPromise<P1 extends Path, P2 extends Path>(destinationFs: FakeFS<P1>, destination: P1, sourceFs: FakeFS<P2>, source: P2, opts: CopyOptions<P1>): Promise<void>;