@pnpm/exe 12.8.2 → 12.9.0

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

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCopyIndex = setupCopyIndex;
+exports.copyPromise = copyPromise;
+const tslib_1 = require("tslib");
+const constants = tslib_1.__importStar(require("../constants"));
+const path_1 = require("../path");
+const defaultTime = new Date(constants.SAFE_TIME * 1000);
+const defaultTimeMs = defaultTime.getTime();
+async function setupCopyIndex(destinationFs, linkStrategy) {
+    const hexCharacters = `0123456789abcdef`;
+    await destinationFs.mkdirPromise(linkStrategy.indexPath, { recursive: true });
+    const promises = [];
+    for (const l1 of hexCharacters)
+        for (const l2 of hexCharacters)
+            promises.push(destinationFs.mkdirPromise(destinationFs.pathUtils.join(linkStrategy.indexPath, `${l1}${l2}`), { recursive: true }));
+    await Promise.all(promises);
+    return linkStrategy.indexPath;
+}
+async function copyPromise(destinationFs, destination, sourceFs, source, opts) {
+    const normalizedDestination = destinationFs.pathUtils.normalize(destination);
+    const normalizedSource = sourceFs.pathUtils.normalize(source);
+    const prelayout = [];
+    const postlayout = [];
+    const { atime, mtime } = opts.stableTime
+        ? { atime: defaultTime, mtime: defaultTime }
+        : await sourceFs.lstatPromise(normalizedSource);
+    await destinationFs.mkdirpPromise(destinationFs.pathUtils.dirname(destination), { utimes: [atime, mtime] });
+    await copyImpl(prelayout, postlayout, destinationFs, normalizedDestination, sourceFs, normalizedSource, { ...opts, didParentExist: true });
+    for (const operation of prelayout)
+        await operation();
+    await Promise.all(postlayout.map(operation => {
+        return operation();
+    }));
+}
+async function copyImpl(prelayout, postlayout, destinationFs, destination, sourceFs, source, opts) {
+    const destinationStat = opts.didParentExist ? await maybeLStat(destinationFs, destination) : null;
+    const sourceStat = await sourceFs.lstatPromise(source);
+    const { atime, mtime } = opts.stableTime
+        ? { atime: defaultTime, mtime: defaultTime }
+        : sourceStat;
+    let updated;
+    switch (true) {
+        case sourceStat.isDirectory():
+            {
+                updated = await copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+            }
+            break;
+        case sourceStat.isFile():
+            {
+                updated = await copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+            }
+            break;
+        case sourceStat.isSymbolicLink():
+            {
+                updated = await copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+            }
+            break;
+        default: {
+            throw new Error(`Unsupported file type (${sourceStat.mode})`);
+        }
+    }
+    // We aren't allowed to modify the destination if we work with the index,
+    // since otherwise we'd accidentally propagate the changes to all projects.
+    if (opts.linkStrategy?.type !== `HardlinkFromIndex` || !sourceStat.isFile()) {
+        if (updated || destinationStat?.mtime?.getTime() !== mtime.getTime() || destinationStat?.atime?.getTime() !== atime.getTime()) {
+            postlayout.push(() => destinationFs.lutimesPromise(destination, atime, mtime));
+            updated = true;
+        }
+        if (destinationStat === null || (destinationStat.mode & 0o777) !== (sourceStat.mode & 0o777)) {
+            postlayout.push(() => destinationFs.chmodPromise(destination, sourceStat.mode & 0o777));
+            updated = true;
+        }
+    }
+    return updated;
+}
+async function maybeLStat(baseFs, p) {
+    try {
+        return await baseFs.lstatPromise(p);
+    }
+    catch {
+        return null;
+    }
+}
+async function copyFolder(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+    if (destinationStat !== null && !destinationStat.isDirectory()) {
+        if (opts.overwrite) {
+            prelayout.push(async () => destinationFs.removePromise(destination));
+            destinationStat = null;
+        }
+        else {
+            return false;
+        }
+    }
+    let updated = false;
+    if (destinationStat === null) {
+        prelayout.push(async () => {
+            try {
+                await destinationFs.mkdirPromise(destination, { mode: sourceStat.mode });
+            }
+            catch (err) {
+                if (err.code !== `EEXIST`) {
+                    throw err;
+                }
+            }
+        });
+        updated = true;
+    }
+    const entries = await sourceFs.readdirPromise(source);
+    const nextOpts = opts.didParentExist && !destinationStat ? { ...opts, didParentExist: false } : opts;
+    if (opts.stableSort) {
+        for (const entry of entries.sort()) {
+            if (await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts)) {
+                updated = true;
+            }
+        }
+    }
+    else {
+        const entriesUpdateStatus = await Promise.all(entries.map(async (entry) => {
+            await copyImpl(prelayout, postlayout, destinationFs, destinationFs.pathUtils.join(destination, entry), sourceFs, sourceFs.pathUtils.join(source, entry), nextOpts);
+        }));
+        if (entriesUpdateStatus.some(status => status)) {
+            updated = true;
+        }
+    }
+    return updated;
+}
+async function copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, linkStrategy) {
+    const sourceHash = await sourceFs.checksumFilePromise(source, { algorithm: `sha1` });
+    const defaultMode = 0o644;
+    const sourceMode = sourceStat.mode & 0o777;
+    // add mode to the index file name if it's not the default b/c different packages could have the file with same content, but different modes
+    const indexFileName = `${sourceHash}${sourceMode !== defaultMode ? sourceMode.toString(8) : ``}`;
+    const indexPath = destinationFs.pathUtils.join(linkStrategy.indexPath, sourceHash.slice(0, 2), `${indexFileName}.dat`);
+    let AtomicBehavior;
+    (function (AtomicBehavior) {
+        AtomicBehavior[AtomicBehavior["Lock"] = 0] = "Lock";
+        AtomicBehavior[AtomicBehavior["Rename"] = 1] = "Rename";
+    })(AtomicBehavior || (AtomicBehavior = {}));
+    let atomicBehavior = AtomicBehavior.Rename;
+    let indexStat = await maybeLStat(destinationFs, indexPath);
+    if (destinationStat) {
+        const isDestinationHardlinkedFromIndex = indexStat && destinationStat.dev === indexStat.dev && destinationStat.ino === indexStat.ino;
+        const isIndexModified = indexStat?.mtimeMs !== defaultTimeMs;
+        if (isDestinationHardlinkedFromIndex) {
+            // If the index is modified, we will want to repair it. However, the
+            // default logic ensuring atomicity (creating a file in a temporary
+            // place before atomically moving it into its final location) won't
+            // work: we'd lose all the existing hardlinks.
+            //
+            // To avoid that, when repairing a file, we fallback to the slow but
+            // safer `lockPromise`-based mutex, which will prevent multiple
+            // processes to modify the file without impacting their inode.
+            //
+            // Give that the repair mechanism should be very rarely needed in
+            // situation where performance is critical, it should be ok.
+            //
+            if (isIndexModified && linkStrategy.autoRepair) {
+                atomicBehavior = AtomicBehavior.Lock;
+                indexStat = null;
+            }
+        }
+        if (!isDestinationHardlinkedFromIndex) {
+            if (opts.overwrite) {
+                prelayout.push(async () => destinationFs.removePromise(destination));
+                destinationStat = null;
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    const tempPath = !indexStat && atomicBehavior === AtomicBehavior.Rename
+        ? `${indexPath}.${Math.floor(Math.random() * 0x100000000).toString(16).padStart(8, `0`)}`
+        : null;
+    let tempPathCleaned = false;
+    prelayout.push(async () => {
+        if (!indexStat) {
+            if (atomicBehavior === AtomicBehavior.Lock) {
+                await destinationFs.lockPromise(indexPath, async () => {
+                    const content = await sourceFs.readFilePromise(source);
+                    await destinationFs.writeFilePromise(indexPath, content);
+                });
+            }
+            if (atomicBehavior === AtomicBehavior.Rename && tempPath) {
+                const content = await sourceFs.readFilePromise(source);
+                await destinationFs.writeFilePromise(tempPath, content);
+                // We use `linkPromise` rather than `renamePromise` because the later
+                // overwrites the destination if it already exists; usually this
+                // wouldn't be a problem, but since we care about preserving the
+                // hardlink identity of the destination, we can't do that.
+                //
+                // So instead we create a hardlink of the source file (which will
+                // fail with EEXIST if the destination already exists), and we remove
+                // the source in the postlayout steps.
+                //
+                try {
+                    await destinationFs.linkPromise(tempPath, indexPath);
+                }
+                catch (err) {
+                    if (err.code === `EEXIST`) {
+                        tempPathCleaned = true;
+                        await destinationFs.unlinkPromise(tempPath);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+        }
+        if (!destinationStat) {
+            await destinationFs.linkPromise(indexPath, destination);
+        }
+    });
+    postlayout.push(async () => {
+        if (!indexStat) {
+            await destinationFs.lutimesPromise(indexPath, defaultTime, defaultTime);
+            if (sourceMode !== defaultMode) {
+                await destinationFs.chmodPromise(indexPath, sourceMode);
+            }
+        }
+        if (tempPath && !tempPathCleaned) {
+            await destinationFs.unlinkPromise(tempPath);
+        }
+    });
+    return false;
+}
+async function copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+    if (destinationStat !== null) {
+        if (opts.overwrite) {
+            prelayout.push(async () => destinationFs.removePromise(destination));
+            destinationStat = null;
+        }
+        else {
+            return false;
+        }
+    }
+    // TODO: Add support for file cloning, by adding a flag inside the FakeFS
+    // instances to detect which "namespace" they're part of (for example, the
+    // NodeFS and the ZipFS would be different namespaces since you can't clone
+    // from one disk to the other; on the other hand, a CwdFS would share the
+    // namespace from its base FS and thus would support cloning).
+    prelayout.push(async () => {
+        const content = await sourceFs.readFilePromise(source);
+        await destinationFs.writeFilePromise(destination, content);
+    });
+    return true;
+}
+async function copyFile(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+    if (opts.linkStrategy?.type === `HardlinkFromIndex`) {
+        return copyFileViaIndex(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts, opts.linkStrategy);
+    }
+    else {
+        return copyFileDirect(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts);
+    }
+}
+async function copySymlink(prelayout, postlayout, destinationFs, destination, destinationStat, sourceFs, source, sourceStat, opts) {
+    if (destinationStat !== null) {
+        if (opts.overwrite) {
+            prelayout.push(async () => destinationFs.removePromise(destination));
+            destinationStat = null;
+        }
+        else {
+            return false;
+        }
+    }
+    prelayout.push(async () => {
+        await destinationFs.symlinkPromise((0, path_1.convertPath)(destinationFs.pathUtils, await sourceFs.readlinkPromise(source)), destination);
+    });
+    return true;
+}

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

@@ -0,0 +1,22 @@
+import { NoParamCallback } from 'fs';
+import { Dir, DirentNoPath, FakeFS } from '../FakeFS';
+import { Filename, Path } from '../path';
+export type CustomDirOptions = {
+    onClose?: () => void;
+};
+export declare class CustomDir<P extends Path> implements Dir<P> {
+    readonly path: P;
+    private readonly nextDirent;
+    private readonly opts;
+    constructor(path: P, nextDirent: () => DirentNoPath | null, opts?: CustomDirOptions);
+    closed: boolean;
+    throwIfClosed(): void;
+    [Symbol.asyncIterator](): AsyncGenerator<DirentNoPath, void, unknown>;
+    read(): Promise<DirentNoPath>;
+    read(cb: (err: NodeJS.ErrnoException | null, dirent: DirentNoPath | null) => void): void;
+    readSync(): DirentNoPath | null;
+    close(): Promise<void>;
+    close(cb: NoParamCallback): void;
+    closeSync(): void;
+}
+export declare function opendir<P extends Path>(fakeFs: FakeFS<P>, path: P, entries: Array<Filename>, opts?: CustomDirOptions): CustomDir<P>;

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/algorithms/opendir.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomDir = void 0;
+exports.opendir = opendir;
+const tslib_1 = require("tslib");
+const errors = tslib_1.__importStar(require("../errors"));
+class CustomDir {
+    constructor(path, nextDirent, opts = {}) {
+        this.path = path;
+        this.nextDirent = nextDirent;
+        this.opts = opts;
+        this.closed = false;
+    }
+    throwIfClosed() {
+        if (this.closed) {
+            throw errors.ERR_DIR_CLOSED();
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            let dirent;
+            while ((dirent = await this.read()) !== null) {
+                yield dirent;
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+    read(cb) {
+        const dirent = this.readSync();
+        if (typeof cb !== `undefined`)
+            return cb(null, dirent);
+        return Promise.resolve(dirent);
+    }
+    readSync() {
+        this.throwIfClosed();
+        return this.nextDirent();
+    }
+    close(cb) {
+        this.closeSync();
+        if (typeof cb !== `undefined`)
+            return cb(null);
+        return Promise.resolve();
+    }
+    closeSync() {
+        this.throwIfClosed();
+        this.opts.onClose?.();
+        this.closed = true;
+    }
+}
+exports.CustomDir = CustomDir;
+function opendir(fakeFs, path, entries, opts) {
+    const nextDirent = () => {
+        const filename = entries.shift();
+        if (typeof filename === `undefined`)
+            return null;
+        const entryPath = fakeFs.pathUtils.join(path, filename);
+        return Object.assign(fakeFs.statSync(entryPath), {
+            name: filename,
+            path: undefined,
+        });
+    };
+    return new CustomDir(path, nextDirent, opts);
+}

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

@@ -0,0 +1,59 @@
+import { EventEmitter } from 'events';
+import { BigIntStats, Stats } from 'fs';
+import { StatWatcher, WatchFileCallback, WatchFileOptions, FakeFS } from '../../FakeFS';
+import { Path } from '../../path';
+export declare enum Event {
+    Change = "change",
+    Stop = "stop"
+}
+export declare enum Status {
+    Ready = "ready",
+    Running = "running",
+    Stopped = "stopped"
+}
+export declare function assertStatus<T extends Status>(current: Status, expected: T): asserts current is T;
+export type ListenerOptions = Omit<Required<WatchFileOptions>, `bigint`>;
+export type CustomStatWatcherOptions = {
+    bigint?: boolean;
+};
+export declare class CustomStatWatcher<P extends Path> extends EventEmitter implements StatWatcher {
+    readonly fakeFs: FakeFS<P>;
+    readonly path: P;
+    readonly bigint: boolean;
+    private status;
+    private changeListeners;
+    private lastStats;
+    private startTimeout;
+    static create<P extends Path>(fakeFs: FakeFS<P>, path: P, opts?: CustomStatWatcherOptions): CustomStatWatcher<P>;
+    private constructor();
+    start(): void;
+    stop(): void;
+    stat(): Stats | BigIntStats;
+    /**
+     * Creates an interval whose callback compares the current stats with the previous stats and notifies all listeners in case of changes.
+     *
+     * @param opts.persistent Decides whether the interval should be immediately unref-ed.
+     */
+    makeInterval(opts: ListenerOptions): NodeJS.Timeout;
+    /**
+     * Registers a listener and assigns it an interval.
+     */
+    registerChangeListener(listener: WatchFileCallback, opts: ListenerOptions): void;
+    /**
+     * Unregisters the listener and clears the assigned interval.
+     */
+    unregisterChangeListener(listener: WatchFileCallback): void;
+    /**
+     * Unregisters all listeners and clears all assigned intervals.
+     */
+    unregisterAllChangeListeners(): void;
+    hasChangeListeners(): boolean;
+    /**
+     * Refs all stored intervals.
+     */
+    ref(): this;
+    /**
+     * Unrefs all stored intervals.
+     */
+    unref(): this;
+}

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/algorithms/watchFile/CustomStatWatcher.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomStatWatcher = exports.Status = exports.Event = void 0;
+exports.assertStatus = assertStatus;
+const tslib_1 = require("tslib");
+const events_1 = require("events");
+const statUtils = tslib_1.__importStar(require("../../statUtils"));
+var Event;
+(function (Event) {
+    Event["Change"] = "change";
+    Event["Stop"] = "stop";
+})(Event || (exports.Event = Event = {}));
+var Status;
+(function (Status) {
+    Status["Ready"] = "ready";
+    Status["Running"] = "running";
+    Status["Stopped"] = "stopped";
+})(Status || (exports.Status = Status = {}));
+function assertStatus(current, expected) {
+    if (current !== expected) {
+        throw new Error(`Invalid StatWatcher status: expected '${expected}', got '${current}'`);
+    }
+}
+class CustomStatWatcher extends events_1.EventEmitter {
+    static create(fakeFs, path, opts) {
+        const statWatcher = new CustomStatWatcher(fakeFs, path, opts);
+        statWatcher.start();
+        return statWatcher;
+    }
+    constructor(fakeFs, path, { bigint = false } = {}) {
+        super();
+        this.status = Status.Ready;
+        this.changeListeners = new Map();
+        this.startTimeout = null;
+        this.fakeFs = fakeFs;
+        this.path = path;
+        this.bigint = bigint;
+        this.lastStats = this.stat();
+    }
+    start() {
+        assertStatus(this.status, Status.Ready);
+        this.status = Status.Running;
+        // Node allows other listeners to be registered up to 3 milliseconds
+        // after the watcher has been started, so that's what we're doing too
+        this.startTimeout = setTimeout(() => {
+            this.startTimeout = null;
+            // Per the Node FS docs:
+            // "When an fs.watchFile operation results in an ENOENT error,
+            // it will invoke the listener once, with all the fields zeroed
+            // (or, for dates, the Unix Epoch)."
+            if (!this.fakeFs.existsSync(this.path)) {
+                this.emit(Event.Change, this.lastStats, this.lastStats);
+            }
+        }, 3);
+    }
+    stop() {
+        assertStatus(this.status, Status.Running);
+        this.status = Status.Stopped;
+        if (this.startTimeout !== null) {
+            clearTimeout(this.startTimeout);
+            this.startTimeout = null;
+        }
+        this.emit(Event.Stop);
+    }
+    stat() {
+        try {
+            return this.fakeFs.statSync(this.path, { bigint: this.bigint });
+        }
+        catch {
+            // From observation, all errors seem to be mostly ignored by Node.
+            // Checked with ENOENT, ENOTDIR, EPERM
+            const statInstance = this.bigint
+                ? new statUtils.BigIntStatsEntry()
+                : new statUtils.StatEntry();
+            return statUtils.clearStats(statInstance);
+        }
+    }
+    /**
+     * Creates an interval whose callback compares the current stats with the previous stats and notifies all listeners in case of changes.
+     *
+     * @param opts.persistent Decides whether the interval should be immediately unref-ed.
+     */
+    makeInterval(opts) {
+        const interval = setInterval(() => {
+            const currentStats = this.stat();
+            const previousStats = this.lastStats;
+            if (statUtils.areStatsEqual(currentStats, previousStats))
+                return;
+            this.lastStats = currentStats;
+            this.emit(Event.Change, currentStats, previousStats);
+        }, opts.interval);
+        return opts.persistent ? interval : interval.unref();
+    }
+    /**
+     * Registers a listener and assigns it an interval.
+     */
+    registerChangeListener(listener, opts) {
+        this.addListener(Event.Change, listener);
+        this.changeListeners.set(listener, this.makeInterval(opts));
+    }
+    /**
+     * Unregisters the listener and clears the assigned interval.
+     */
+    unregisterChangeListener(listener) {
+        this.removeListener(Event.Change, listener);
+        const interval = this.changeListeners.get(listener);
+        if (typeof interval !== `undefined`)
+            clearInterval(interval);
+        this.changeListeners.delete(listener);
+    }
+    /**
+     * Unregisters all listeners and clears all assigned intervals.
+     */
+    unregisterAllChangeListeners() {
+        for (const listener of this.changeListeners.keys()) {
+            this.unregisterChangeListener(listener);
+        }
+    }
+    hasChangeListeners() {
+        return this.changeListeners.size > 0;
+    }
+    /**
+     * Refs all stored intervals.
+     */
+    ref() {
+        for (const interval of this.changeListeners.values())
+            interval.ref();
+        return this;
+    }
+    /**
+     * Unrefs all stored intervals.
+     */
+    unref() {
+        for (const interval of this.changeListeners.values())
+            interval.unref();
+        return this;
+    }
+}
+exports.CustomStatWatcher = CustomStatWatcher;

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

@@ -0,0 +1,6 @@
+import { FakeFS, WatchFileOptions, WatchFileCallback } from '../FakeFS';
+import { Path } from '../path';
+import { CustomStatWatcher } from './watchFile/CustomStatWatcher';
+export declare function watchFile<P extends Path>(fakeFs: FakeFS<P>, path: P, a: WatchFileOptions | WatchFileCallback, b?: WatchFileCallback): CustomStatWatcher<P>;
+export declare function unwatchFile<P extends Path>(fakeFs: FakeFS<P>, path: P, cb?: WatchFileCallback): void;
+export declare function unwatchAllFiles(fakeFs: FakeFS<Path>): void;

package/dist/wasm/node_modules/@yarnpkg/fslib/lib/algorithms/watchFile.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchFile = watchFile;
+exports.unwatchFile = unwatchFile;
+exports.unwatchAllFiles = unwatchAllFiles;
+const CustomStatWatcher_1 = require("./watchFile/CustomStatWatcher");
+const statWatchersByFakeFS = new WeakMap();
+function watchFile(fakeFs, path, a, b) {
+    let bigint;
+    let persistent;
+    let interval;
+    let listener;
+    switch (typeof a) {
+        case `function`:
+            {
+                bigint = false;
+                persistent = true;
+                interval = 5007;
+                listener = a;
+            }
+            break;
+        default:
+            {
+                ({
+                    bigint = false,
+                    persistent = true,
+                    interval = 5007,
+                } = a);
+                listener = b;
+            }
+            break;
+    }
+    let statWatchers = statWatchersByFakeFS.get(fakeFs);
+    if (typeof statWatchers === `undefined`)
+        statWatchersByFakeFS.set(fakeFs, statWatchers = new Map());
+    let statWatcher = statWatchers.get(path);
+    if (typeof statWatcher === `undefined`) {
+        statWatcher = CustomStatWatcher_1.CustomStatWatcher.create(fakeFs, path, { bigint });
+        statWatchers.set(path, statWatcher);
+    }
+    statWatcher.registerChangeListener(listener, { persistent, interval });
+    return statWatcher;
+}
+function unwatchFile(fakeFs, path, cb) {
+    const statWatchers = statWatchersByFakeFS.get(fakeFs);
+    if (typeof statWatchers === `undefined`)
+        return;
+    const statWatcher = statWatchers.get(path);
+    if (typeof statWatcher === `undefined`)
+        return;
+    if (typeof cb === `undefined`)
+        statWatcher.unregisterAllChangeListeners();
+    else
+        statWatcher.unregisterChangeListener(cb);
+    if (!statWatcher.hasChangeListeners()) {
+        statWatcher.stop();
+        statWatchers.delete(path);
+    }
+}
+function unwatchAllFiles(fakeFs) {
+    const statWatchers = statWatchersByFakeFS.get(fakeFs);
+    if (typeof statWatchers === `undefined`)
+        return;
+    for (const path of statWatchers.keys()) {
+        unwatchFile(fakeFs, path);
+    }
+}

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

@@ -0,0 +1,13 @@
+export declare const S_IFMT = 61440;
+export declare const S_IFDIR = 16384;
+export declare const S_IFREG = 32768;
+export declare const S_IFLNK = 40960;
+/**
+ * Unix timestamp for `1984-06-22T21:50:00.000Z`
+ *
+ * It needs to be after 1980-01-01 because that's what Zip supports, and it
+ * needs to have a slight offset to account for different timezones (because
+ * zip assumes that all times are local to whoever writes the file, which is
+ * really silly).
+ */
+export declare const SAFE_TIME = 456789000;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAFE_TIME = exports.S_IFLNK = exports.S_IFREG = exports.S_IFDIR = exports.S_IFMT = void 0;
+exports.S_IFMT = 0o170000;
+exports.S_IFDIR = 0o040000;
+exports.S_IFREG = 0o100000;
+exports.S_IFLNK = 0o120000;
+/**
+ * Unix timestamp for `1984-06-22T21:50:00.000Z`
+ *
+ * It needs to be after 1980-01-01 because that's what Zip supports, and it
+ * needs to have a slight offset to account for different timezones (because
+ * zip assumes that all times are local to whoever writes the file, which is
+ * really silly).
+ */
+exports.SAFE_TIME = 456789000;