@pnpm/exe 12.8.2 → 12.9.0

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

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

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

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

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

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