@pnpm/exe 12.9.0 → 12.10.0

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

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

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

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

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

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

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

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

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

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