@wo658/redpact 0.4.1 → 0.5.0

package/node_modules/@rushstack/node-core-library/lib/ProtectableMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtectableMap.js","sourceRoot":"","sources":["../src/ProtectableMap.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,6DAA0D;AA4B1D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,cAAc;IAGzB,YAAmB,UAA2C;QAC5D,IAAI,CAAC,cAAc,GAAG,IAAI,uCAAkB,CAAO,IAAI,EAAE,UAAU,CAAC,CAAC;IACvE,CAAC;IAED;;OAEG;IACH,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,8EAA8E;IAC9E,qDAAqD;IAErD;;;OAGG;IACI,KAAK;QACV,IAAI,CAAC,cAAc,CAAC,iBAAiB,EAAE,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,GAAM;QAClB,OAAO,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACI,GAAG,CAAC,GAAM,EAAE,KAAQ;QACzB,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,8EAA8E;IAC9E,oDAAoD;IAEpD;;OAEG;IACH,8DAA8D;IACvD,OAAO,CAAC,UAAsD,EAAE,OAAa;QAClF,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACI,GAAG,CAAC,GAAM;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACI,GAAG,CAAC,GAAM;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,IAAW,IAAI;QACb,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC;IAClC,CAAC;CACF;AA3ED,wCA2EC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport { ProtectableMapView } from './ProtectableMapView';\n\n/**\n * Constructor parameters for {@link ProtectableMap}\n *\n * @public\n */\nexport interface IProtectableMapParameters<K, V> {\n  /**\n   * An optional hook that will be invoked before Map.clear() is performed.\n   */\n  onClear?: (source: ProtectableMap<K, V>) => void;\n\n  /**\n   * An optional hook that will be invoked before Map.delete() is performed.\n   */\n  onDelete?: (source: ProtectableMap<K, V>, key: K) => void;\n\n  /**\n   * An optional hook that will be invoked before Map.set() is performed.\n   * @remarks\n   * If this hook is provided, the function MUST return the `value` parameter.\n   * This provides the opportunity to modify the value before it is added\n   * to the map.\n   */\n  onSet?: (source: ProtectableMap<K, V>, key: K, value: V) => V;\n}\n\n/**\n * The ProtectableMap provides an easy way for an API to expose a `Map<K, V>` property\n * while intercepting and validating any write operations that are performed by\n * consumers of the API.\n *\n * @remarks\n * The ProtectableMap itself is intended to be a private object that only its owner\n * can access directly.  Any operations performed directly on the ProtectableMap will\n * bypass the hooks and any validation they perform.  The public property that is exposed\n * to API consumers should return {@link ProtectableMap.protectedView} instead.\n *\n * For example, suppose you want to share your `Map<string, number>` data structure,\n * but you want to enforce that the key must always be an upper case string:\n * You could use the onSet() hook to validate the keys and throw an exception\n * if the key is not uppercase.\n *\n * @public\n */\nexport class ProtectableMap<K, V> {\n  private readonly _protectedView: ProtectableMapView<K, V>;\n\n  public constructor(parameters: IProtectableMapParameters<K, V>) {\n    this._protectedView = new ProtectableMapView<K, V>(this, parameters);\n  }\n\n  /**\n   * The owner of the protectable map should return this object via its public API.\n   */\n  public get protectedView(): Map<K, V> {\n    return this._protectedView;\n  }\n\n  // ---------------------------------------------------------------------------\n  // lib.es2015.collections contract - write operations\n\n  /**\n   * Removes all entries from the map.\n   * This operation does NOT invoke the ProtectableMap onClear() hook.\n   */\n  public clear(): void {\n    this._protectedView._clearUnprotected();\n  }\n\n  /**\n   * Removes the specified key from the map.\n   * This operation does NOT invoke the ProtectableMap onDelete() hook.\n   */\n  public delete(key: K): boolean {\n    return this._protectedView._deleteUnprotected(key);\n  }\n\n  /**\n   * Sets a value for the specified key.\n   * This operation does NOT invoke the ProtectableMap onSet() hook.\n   */\n  public set(key: K, value: V): this {\n    this._protectedView._setUnprotected(key, value);\n    return this;\n  }\n\n  // ---------------------------------------------------------------------------\n  // lib.es2015.collections contract - read operations\n\n  /**\n   * Performs an operation for each (key, value) entries in the map.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {\n    this._protectedView.forEach(callbackfn);\n  }\n\n  /**\n   * Retrieves the value for the specified key.\n   * @returns undefined if the value is undefined OR if the key is missing;\n   * otherwise returns the value associated with the key.\n   */\n  public get(key: K): V | undefined {\n    return this._protectedView.get(key);\n  }\n\n  /**\n   * Returns true if the specified key belongs to the map.\n   */\n  public has(key: K): boolean {\n    return this._protectedView.has(key);\n  }\n\n  /**\n   * Returns the number of (key, value) entries in the map.\n   */\n  public get size(): number {\n    return this._protectedView.size;\n  }\n}\n"]}

package/node_modules/@rushstack/node-core-library/lib/ProtectableMapView.d.ts

@@ -0,0 +1,20 @@
+import type { ProtectableMap, IProtectableMapParameters } from './ProtectableMap';
+/**
+ * The internal wrapper used by ProtectableMap.  It extends the real `Map<K, V>` base class,
+ * but hooks the destructive operations (clear/delete/set) to give the owner a chance
+ * to block them.
+ *
+ * NOTE: This is not a public API.
+ */
+export declare class ProtectableMapView<K, V> extends Map<K, V> {
+    private readonly _owner;
+    private readonly _parameters;
+    constructor(owner: ProtectableMap<K, V>, parameters: IProtectableMapParameters<K, V>);
+    clear(): void;
+    delete(key: K): boolean;
+    set(key: K, value: V): this;
+    _clearUnprotected(): void;
+    _deleteUnprotected(key: K): boolean;
+    _setUnprotected(key: K, value: V): void;
+}
+//# sourceMappingURL=ProtectableMapView.d.ts.map

package/node_modules/@rushstack/node-core-library/lib/ProtectableMapView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtectableMapView.d.ts","sourceRoot":"","sources":["../src/ProtectableMapView.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAC;AAElF;;;;;;GAMG;AACH,qBAAa,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;gBAE3C,KAAK,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC;IAOpF,KAAK,IAAI,IAAI;IAQb,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAQvB,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAW3B,iBAAiB,IAAI,IAAI;IAKzB,kBAAkB,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAKnC,eAAe,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;CAG/C"}

package/node_modules/@rushstack/node-core-library/lib/ProtectableMapView.js

@@ -0,0 +1,56 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtectableMapView = void 0;
+/**
+ * The internal wrapper used by ProtectableMap.  It extends the real `Map<K, V>` base class,
+ * but hooks the destructive operations (clear/delete/set) to give the owner a chance
+ * to block them.
+ *
+ * NOTE: This is not a public API.
+ */
+class ProtectableMapView extends Map {
+    constructor(owner, parameters) {
+        super();
+        this._owner = owner;
+        this._parameters = parameters;
+    }
+    clear() {
+        // override
+        if (this._parameters.onClear) {
+            this._parameters.onClear(this._owner);
+        }
+        super.clear();
+    }
+    delete(key) {
+        // override
+        if (this._parameters.onDelete) {
+            this._parameters.onDelete(this._owner, key);
+        }
+        return super.delete(key);
+    }
+    set(key, value) {
+        // override
+        let modifiedValue = value;
+        if (this._parameters.onSet) {
+            modifiedValue = this._parameters.onSet(this._owner, key, modifiedValue);
+        }
+        super.set(key, modifiedValue);
+        return this;
+    }
+    // INTERNAL USAGE ONLY
+    _clearUnprotected() {
+        super.clear();
+    }
+    // INTERNAL USAGE ONLY
+    _deleteUnprotected(key) {
+        return super.delete(key);
+    }
+    // INTERNAL USAGE ONLY
+    _setUnprotected(key, value) {
+        super.set(key, value);
+    }
+}
+exports.ProtectableMapView = ProtectableMapView;
+//# sourceMappingURL=ProtectableMapView.js.map

package/node_modules/@rushstack/node-core-library/lib/ProtectableMapView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtectableMapView.js","sourceRoot":"","sources":["../src/ProtectableMapView.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAI3D;;;;;;GAMG;AACH,MAAa,kBAAyB,SAAQ,GAAS;IAIrD,YAAmB,KAA2B,EAAE,UAA2C;QACzF,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAEM,KAAK;QACV,WAAW;QACX,IAAI,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC;QACD,KAAK,CAAC,KAAK,EAAE,CAAC;IAChB,CAAC;IAEM,MAAM,CAAC,GAAM;QAClB,WAAW;QACX,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAEM,GAAG,CAAC,GAAM,EAAE,KAAQ;QACzB,WAAW;QACX,IAAI,aAAa,GAAM,KAAK,CAAC;QAC7B,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;YAC3B,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,aAAa,CAAC,CAAC;QAC1E,CAAC;QACD,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sBAAsB;IACf,iBAAiB;QACtB,KAAK,CAAC,KAAK,EAAE,CAAC;IAChB,CAAC;IAED,sBAAsB;IACf,kBAAkB,CAAC,GAAM;QAC9B,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,sBAAsB;IACf,eAAe,CAAC,GAAM,EAAE,KAAQ;QACrC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACxB,CAAC;CACF;AAnDD,gDAmDC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport type { ProtectableMap, IProtectableMapParameters } from './ProtectableMap';\n\n/**\n * The internal wrapper used by ProtectableMap.  It extends the real `Map<K, V>` base class,\n * but hooks the destructive operations (clear/delete/set) to give the owner a chance\n * to block them.\n *\n * NOTE: This is not a public API.\n */\nexport class ProtectableMapView<K, V> extends Map<K, V> {\n  private readonly _owner: ProtectableMap<K, V>;\n  private readonly _parameters: IProtectableMapParameters<K, V>;\n\n  public constructor(owner: ProtectableMap<K, V>, parameters: IProtectableMapParameters<K, V>) {\n    super();\n\n    this._owner = owner;\n    this._parameters = parameters;\n  }\n\n  public clear(): void {\n    // override\n    if (this._parameters.onClear) {\n      this._parameters.onClear(this._owner);\n    }\n    super.clear();\n  }\n\n  public delete(key: K): boolean {\n    // override\n    if (this._parameters.onDelete) {\n      this._parameters.onDelete(this._owner, key);\n    }\n    return super.delete(key);\n  }\n\n  public set(key: K, value: V): this {\n    // override\n    let modifiedValue: V = value;\n    if (this._parameters.onSet) {\n      modifiedValue = this._parameters.onSet(this._owner, key, modifiedValue);\n    }\n    super.set(key, modifiedValue);\n    return this;\n  }\n\n  // INTERNAL USAGE ONLY\n  public _clearUnprotected(): void {\n    super.clear();\n  }\n\n  // INTERNAL USAGE ONLY\n  public _deleteUnprotected(key: K): boolean {\n    return super.delete(key);\n  }\n\n  // INTERNAL USAGE ONLY\n  public _setUnprotected(key: K, value: V): void {\n    super.set(key, value);\n  }\n}\n"]}

package/node_modules/@rushstack/node-core-library/lib/RealNodeModulePath.d.ts

@@ -0,0 +1,58 @@
+import * as nodeFs from 'fs';
+import * as nodePath from 'path';
+/**
+ * Arguments used to create a function that resolves symlinked node_modules in a path
+ * @public
+ */
+export interface IRealNodeModulePathResolverOptions {
+    fs?: Partial<Pick<typeof nodeFs, 'lstatSync' | 'readlinkSync'>>;
+    path?: Partial<Pick<typeof nodePath, 'isAbsolute' | 'join' | 'resolve' | 'sep'>>;
+    /**
+     * If set to true, the resolver will not throw if part of the path does not exist.
+     * @defaultValue false
+     */
+    ignoreMissingPaths?: boolean;
+}
+/**
+ * This class encapsulates a caching resolver for symlinks in node_modules directories.
+ * It assumes that the only symlinks that exist in input paths are those that correspond to
+ * npm packages.
+ *
+ * @remarks
+ * In a repository with a symlinked node_modules installation, some symbolic links need to be mapped for
+ * node module resolution to produce correct results. However, calling `fs.realpathSync.native` on every path,
+ * as is commonly done by most resolvers, involves an enormous number of file system operations (for reference,
+ * each invocation of `fs.realpathSync.native` involves a series of `fs.readlinkSync` calls, up to one for each
+ * path segment in the input).
+ *
+ * @public
+ */
+export declare class RealNodeModulePathResolver {
+    /**
+     * Similar in function to `fs.realpathSync.native`, but assumes the only symlinks present are npm packages.
+     *
+     * @param input - A path to a file or directory, where the path separator is `${require('node:path').sep}`
+     * @returns The real path to the input, resolving the node_modules symlinks in the path
+     * @public
+     */
+    readonly realNodeModulePath: (input: string) => string;
+    private readonly _cache;
+    private readonly _errorCache;
+    private readonly _fs;
+    private readonly _path;
+    private readonly _lstatOptions;
+    constructor(options?: IRealNodeModulePathResolverOptions);
+    /**
+     * Clears the cache of resolved symlinks.
+     * @public
+     */
+    clearCache(): void;
+    /**
+     * Tries to read a symbolic link at the specified path.
+     * If the input is not a symbolic link, returns undefined.
+     * @param link - The link to try to read
+     * @returns The target of the symbolic link, or undefined if the input is not a symbolic link
+     */
+    private _tryReadLink;
+}
+//# sourceMappingURL=RealNodeModulePath.d.ts.map

package/node_modules/@rushstack/node-core-library/lib/RealNodeModulePath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealNodeModulePath.d.ts","sourceRoot":"","sources":["../src/RealNodeModulePath.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,MAAM,MAAM,IAAI,CAAC;AAC7B,OAAO,KAAK,QAAQ,MAAM,MAAM,CAAC;AAEjC;;;GAGG;AACH,MAAM,WAAW,kCAAkC;IACjD,EAAE,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,MAAM,EAAE,WAAW,GAAG,cAAc,CAAC,CAAC,CAAC;IAChE,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,QAAQ,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC;IACjF;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,0BAA0B;IACrC;;;;;;OAMG;IACH,SAAgB,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAE9D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkE;IACtF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoE;IAC1F,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiD;gBAE5D,OAAO,GAAE,kCAAuC;IA0GnE;;;OAGG;IACI,UAAU,IAAI,IAAI;IAIzB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;CA4BrB"}

package/node_modules/@rushstack/node-core-library/lib/RealNodeModulePath.js

@@ -0,0 +1,177 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RealNodeModulePathResolver = void 0;
+const nodeFs = __importStar(require("fs"));
+const nodePath = __importStar(require("path"));
+/**
+ * This class encapsulates a caching resolver for symlinks in node_modules directories.
+ * It assumes that the only symlinks that exist in input paths are those that correspond to
+ * npm packages.
+ *
+ * @remarks
+ * In a repository with a symlinked node_modules installation, some symbolic links need to be mapped for
+ * node module resolution to produce correct results. However, calling `fs.realpathSync.native` on every path,
+ * as is commonly done by most resolvers, involves an enormous number of file system operations (for reference,
+ * each invocation of `fs.realpathSync.native` involves a series of `fs.readlinkSync` calls, up to one for each
+ * path segment in the input).
+ *
+ * @public
+ */
+class RealNodeModulePathResolver {
+    constructor(options = {}) {
+        const { fs: { lstatSync = nodeFs.lstatSync, readlinkSync = nodeFs.readlinkSync } = nodeFs, path: { isAbsolute = nodePath.isAbsolute, join = nodePath.join, resolve = nodePath.resolve, sep = nodePath.sep } = nodePath, ignoreMissingPaths = false } = options;
+        const cache = (this._cache = new Map());
+        this._errorCache = new Map();
+        this._fs = {
+            lstatSync,
+            readlinkSync
+        };
+        this._path = {
+            isAbsolute,
+            join,
+            resolve,
+            sep
+        };
+        this._lstatOptions = {
+            throwIfNoEntry: !ignoreMissingPaths
+        };
+        const nodeModulesToken = `${sep}node_modules${sep}`;
+        const self = this;
+        function realNodeModulePathInternal(input) {
+            // Find the last node_modules path segment
+            const nodeModulesIndex = input.lastIndexOf(nodeModulesToken);
+            if (nodeModulesIndex < 0) {
+                // No node_modules in path, so we assume it is already the real path
+                return input;
+            }
+            // First assume that the next path segment after node_modules is a symlink
+            let linkStart = nodeModulesIndex + nodeModulesToken.length - 1;
+            let linkEnd = input.indexOf(sep, linkStart + 1);
+            // If the path segment starts with a '@', then it is a scoped package
+            const isScoped = input.charAt(linkStart + 1) === '@';
+            if (isScoped) {
+                // For a scoped package, the scope is an ordinary directory, so we need to find the next path segment
+                if (linkEnd < 0) {
+                    // Symlink missing, so see if anything before the last node_modules needs resolving,
+                    // and preserve the rest of the path
+                    return join(realNodeModulePathInternal(input.slice(0, nodeModulesIndex)), input.slice(nodeModulesIndex + 1), 
+                    // Joining to `.` will clean up any extraneous trailing slashes
+                    '.');
+                }
+                linkStart = linkEnd;
+                linkEnd = input.indexOf(sep, linkStart + 1);
+            }
+            // No trailing separator, so the link is the last path segment
+            if (linkEnd < 0) {
+                linkEnd = input.length;
+            }
+            const linkCandidate = input.slice(0, linkEnd);
+            // Check if the link is a symlink
+            const linkTarget = self._tryReadLink(linkCandidate);
+            if (linkTarget && isAbsolute(linkTarget)) {
+                // Absolute path, combine the link target with any remaining path segments
+                // Cache the resolution to avoid the readlink call in subsequent calls
+                cache.set(linkCandidate, linkTarget);
+                cache.set(linkTarget, linkTarget);
+                // Joining to `.` will clean up any extraneous trailing slashes
+                return join(linkTarget, input.slice(linkEnd + 1), '.');
+            }
+            // Relative path or does not exist
+            // Either way, the path before the last node_modules could itself be in a node_modules folder
+            // So resolve the base path to find out what paths are relative to
+            const realpathBeforeNodeModules = realNodeModulePathInternal(input.slice(0, nodeModulesIndex));
+            if (linkTarget) {
+                // Relative path in symbolic link. Should be resolved relative to real path of base path.
+                const resolvedTarget = resolve(realpathBeforeNodeModules, input.slice(nodeModulesIndex + 1, linkStart), linkTarget);
+                // Cache the result of the combined resolution to avoid the readlink call in subsequent calls
+                cache.set(linkCandidate, resolvedTarget);
+                cache.set(resolvedTarget, resolvedTarget);
+                // Joining to `.` will clean up any extraneous trailing slashes
+                return join(resolvedTarget, input.slice(linkEnd + 1), '.');
+            }
+            // No symlink, so just return the real path before the last node_modules combined with the
+            // subsequent path segments
+            // Joining to `.` will clean up any extraneous trailing slashes
+            return join(realpathBeforeNodeModules, input.slice(nodeModulesIndex + 1), '.');
+        }
+        this.realNodeModulePath = (input) => {
+            return realNodeModulePathInternal(resolve(input));
+        };
+    }
+    /**
+     * Clears the cache of resolved symlinks.
+     * @public
+     */
+    clearCache() {
+        this._cache.clear();
+    }
+    /**
+     * Tries to read a symbolic link at the specified path.
+     * If the input is not a symbolic link, returns undefined.
+     * @param link - The link to try to read
+     * @returns The target of the symbolic link, or undefined if the input is not a symbolic link
+     */
+    _tryReadLink(link) {
+        const cached = this._cache.get(link);
+        if (cached !== undefined) {
+            return cached || undefined;
+        }
+        const cachedError = this._errorCache.get(link);
+        if (cachedError) {
+            // Fill the properties but fix the stack trace.
+            throw Object.assign(new Error(cachedError.message), cachedError);
+        }
+        // On Windows, calling `readlink` on a directory throws an EUNKOWN, not EINVAL, so just pay the cost
+        // of an lstat call.
+        try {
+            const stat = this._fs.lstatSync(link, this._lstatOptions);
+            if (stat === null || stat === void 0 ? void 0 : stat.isSymbolicLink()) {
+                // path.join(x, '.') will trim trailing slashes, if applicable
+                const result = this._path.join(this._fs.readlinkSync(link, 'utf8'), '.');
+                return result;
+            }
+            // Ensure we cache that this was not a symbolic link.
+            this._cache.set(link, false);
+        }
+        catch (err) {
+            this._errorCache.set(link, err);
+        }
+    }
+}
+exports.RealNodeModulePathResolver = RealNodeModulePathResolver;
+//# sourceMappingURL=RealNodeModulePath.js.map

package/node_modules/@rushstack/node-core-library/lib/RealNodeModulePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealNodeModulePath.js","sourceRoot":"","sources":["../src/RealNodeModulePath.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport * as nodeFs from 'fs';\nimport * as nodePath from 'path';\n\n/**\n * Arguments used to create a function that resolves symlinked node_modules in a path\n * @public\n */\nexport interface IRealNodeModulePathResolverOptions {\n  fs?: Partial<Pick<typeof nodeFs, 'lstatSync' | 'readlinkSync'>>;\n  path?: Partial<Pick<typeof nodePath, 'isAbsolute' | 'join' | 'resolve' | 'sep'>>;\n  /**\n   * If set to true, the resolver will not throw if part of the path does not exist.\n   * @defaultValue false\n   */\n  ignoreMissingPaths?: boolean;\n}\n\n/**\n * This class encapsulates a caching resolver for symlinks in node_modules directories.\n * It assumes that the only symlinks that exist in input paths are those that correspond to\n * npm packages.\n *\n * @remarks\n * In a repository with a symlinked node_modules installation, some symbolic links need to be mapped for\n * node module resolution to produce correct results. However, calling `fs.realpathSync.native` on every path,\n * as is commonly done by most resolvers, involves an enormous number of file system operations (for reference,\n * each invocation of `fs.realpathSync.native` involves a series of `fs.readlinkSync` calls, up to one for each\n * path segment in the input).\n *\n * @public\n */\nexport class RealNodeModulePathResolver {\n  /**\n   * Similar in function to `fs.realpathSync.native`, but assumes the only symlinks present are npm packages.\n   *\n   * @param input - A path to a file or directory, where the path separator is `${require('node:path').sep}`\n   * @returns The real path to the input, resolving the node_modules symlinks in the path\n   * @public\n   */\n  public readonly realNodeModulePath: (input: string) => string;\n\n  private readonly _cache: Map<string, string | false>;\n  private readonly _errorCache: Map<string, Error>;\n  private readonly _fs: Required<NonNullable<IRealNodeModulePathResolverOptions['fs']>>;\n  private readonly _path: Required<NonNullable<IRealNodeModulePathResolverOptions['path']>>;\n  private readonly _lstatOptions: Pick<nodeFs.StatSyncOptions, 'throwIfNoEntry'>;\n\n  public constructor(options: IRealNodeModulePathResolverOptions = {}) {\n    const {\n      fs: { lstatSync = nodeFs.lstatSync, readlinkSync = nodeFs.readlinkSync } = nodeFs,\n      path: {\n        isAbsolute = nodePath.isAbsolute,\n        join = nodePath.join,\n        resolve = nodePath.resolve,\n        sep = nodePath.sep\n      } = nodePath,\n      ignoreMissingPaths = false\n    } = options;\n    const cache: Map<string, string> = (this._cache = new Map());\n    this._errorCache = new Map();\n    this._fs = {\n      lstatSync,\n      readlinkSync\n    };\n    this._path = {\n      isAbsolute,\n      join,\n      resolve,\n      sep\n    };\n    this._lstatOptions = {\n      throwIfNoEntry: !ignoreMissingPaths\n    };\n\n    const nodeModulesToken: string = `${sep}node_modules${sep}`;\n    const self: this = this;\n\n    function realNodeModulePathInternal(input: string): string {\n      // Find the last node_modules path segment\n      const nodeModulesIndex: number = input.lastIndexOf(nodeModulesToken);\n      if (nodeModulesIndex < 0) {\n        // No node_modules in path, so we assume it is already the real path\n        return input;\n      }\n\n      // First assume that the next path segment after node_modules is a symlink\n      let linkStart: number = nodeModulesIndex + nodeModulesToken.length - 1;\n      let linkEnd: number = input.indexOf(sep, linkStart + 1);\n      // If the path segment starts with a '@', then it is a scoped package\n      const isScoped: boolean = input.charAt(linkStart + 1) === '@';\n      if (isScoped) {\n        // For a scoped package, the scope is an ordinary directory, so we need to find the next path segment\n        if (linkEnd < 0) {\n          // Symlink missing, so see if anything before the last node_modules needs resolving,\n          // and preserve the rest of the path\n          return join(\n            realNodeModulePathInternal(input.slice(0, nodeModulesIndex)),\n            input.slice(nodeModulesIndex + 1),\n            // Joining to `.` will clean up any extraneous trailing slashes\n            '.'\n          );\n        }\n\n        linkStart = linkEnd;\n        linkEnd = input.indexOf(sep, linkStart + 1);\n      }\n\n      // No trailing separator, so the link is the last path segment\n      if (linkEnd < 0) {\n        linkEnd = input.length;\n      }\n\n      const linkCandidate: string = input.slice(0, linkEnd);\n      // Check if the link is a symlink\n      const linkTarget: string | undefined = self._tryReadLink(linkCandidate);\n      if (linkTarget && isAbsolute(linkTarget)) {\n        // Absolute path, combine the link target with any remaining path segments\n        // Cache the resolution to avoid the readlink call in subsequent calls\n        cache.set(linkCandidate, linkTarget);\n        cache.set(linkTarget, linkTarget);\n        // Joining to `.` will clean up any extraneous trailing slashes\n        return join(linkTarget, input.slice(linkEnd + 1), '.');\n      }\n\n      // Relative path or does not exist\n      // Either way, the path before the last node_modules could itself be in a node_modules folder\n      // So resolve the base path to find out what paths are relative to\n      const realpathBeforeNodeModules: string = realNodeModulePathInternal(input.slice(0, nodeModulesIndex));\n      if (linkTarget) {\n        // Relative path in symbolic link. Should be resolved relative to real path of base path.\n        const resolvedTarget: string = resolve(\n          realpathBeforeNodeModules,\n          input.slice(nodeModulesIndex + 1, linkStart),\n          linkTarget\n        );\n        // Cache the result of the combined resolution to avoid the readlink call in subsequent calls\n        cache.set(linkCandidate, resolvedTarget);\n        cache.set(resolvedTarget, resolvedTarget);\n        // Joining to `.` will clean up any extraneous trailing slashes\n        return join(resolvedTarget, input.slice(linkEnd + 1), '.');\n      }\n\n      // No symlink, so just return the real path before the last node_modules combined with the\n      // subsequent path segments\n      // Joining to `.` will clean up any extraneous trailing slashes\n      return join(realpathBeforeNodeModules, input.slice(nodeModulesIndex + 1), '.');\n    }\n\n    this.realNodeModulePath = (input: string) => {\n      return realNodeModulePathInternal(resolve(input));\n    };\n  }\n\n  /**\n   * Clears the cache of resolved symlinks.\n   * @public\n   */\n  public clearCache(): void {\n    this._cache.clear();\n  }\n\n  /**\n   * Tries to read a symbolic link at the specified path.\n   * If the input is not a symbolic link, returns undefined.\n   * @param link - The link to try to read\n   * @returns The target of the symbolic link, or undefined if the input is not a symbolic link\n   */\n  private _tryReadLink(link: string): string | undefined {\n    const cached: string | false | undefined = this._cache.get(link);\n    if (cached !== undefined) {\n      return cached || undefined;\n    }\n\n    const cachedError: Error | undefined = this._errorCache.get(link);\n    if (cachedError) {\n      // Fill the properties but fix the stack trace.\n      throw Object.assign(new Error(cachedError.message), cachedError);\n    }\n\n    // On Windows, calling `readlink` on a directory throws an EUNKOWN, not EINVAL, so just pay the cost\n    // of an lstat call.\n    try {\n      const stat: nodeFs.Stats | undefined = this._fs.lstatSync(link, this._lstatOptions);\n      if (stat?.isSymbolicLink()) {\n        // path.join(x, '.') will trim trailing slashes, if applicable\n        const result: string = this._path.join(this._fs.readlinkSync(link, 'utf8'), '.');\n        return result;\n      }\n\n      // Ensure we cache that this was not a symbolic link.\n      this._cache.set(link, false);\n    } catch (err) {\n      this._errorCache.set(link, err as Error);\n    }\n  }\n}\n"]}

package/node_modules/@rushstack/node-core-library/lib/Sort.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Operations for sorting collections.
+ *
+ * @public
+ */
+export declare class Sort {
+    /**
+     * Compares `x` and `y` using the JavaScript `>` and `<` operators.  This function is suitable for usage as
+     * the callback for `array.sort()`.
+     *
+     * @remarks
+     *
+     * The JavaScript ordering is generalized so that `undefined` \< `null` \< all other values.
+     *
+     * @returns -1 if `x` is smaller than `y`, 1 if `x` is greater than `y`, or 0 if the values are equal.
+     *
+     * @example
+     *
+     * ```ts
+     * let array: number[] = [3, 6, 2];
+     * array.sort(Sort.compareByValue);  // [2, 3, 6]
+     * ```
+     */
+    static compareByValue(x: any, y: any): number;
+    /**
+     * Sorts the array according to a key which is obtained from the array elements.
+     * The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let array: string[] = [ 'aaa', 'bb', 'c' ];
+     * Sort.sortBy(array, x => x.length);  // [ 'c', 'bb', 'aaa' ]
+     * ```
+     */
+    static sortBy<T>(array: T[], keySelector: (element: T) => any, comparer?: (x: any, y: any) => number): void;
+    /**
+     * Returns true if the collection is already sorted.
+     */
+    static isSorted<T>(collection: Iterable<T>, comparer?: (x: any, y: any) => number): boolean;
+    /**
+     * Returns true if the collection is already sorted by the specified key.
+     *
+     * @example
+     *
+     * ```ts
+     * let array: string[] = [ 'a', 'bb', 'ccc' ];
+     * Sort.isSortedBy(array, x => x.length); // true
+     * ```
+     */
+    static isSortedBy<T>(collection: Iterable<T>, keySelector: (element: T) => any, comparer?: (x: any, y: any) => number): boolean;
+    /**
+     * Sorts the entries in a Map object according to the map keys.
+     * The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let map: Map<string, number> = new Map<string, number>();
+     * map.set('zebra', 1);
+     * map.set('goose', 2);
+     * map.set('aardvark', 3);
+     * Sort.sortMapKeys(map);
+     * console.log(JSON.stringify(Array.from(map.keys()))); // ["aardvark","goose","zebra"]
+     * ```
+     */
+    static sortMapKeys<K, V>(map: Map<K, V>, keyComparer?: (x: K, y: K) => number): void;
+    /**
+     * Sorts the entries in a Set object according to the specified keys.
+     * The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let set: Set<string> = new Set<string>();
+     * set.add('aaa');
+     * set.add('bb');
+     * set.add('c');
+     * Sort.sortSetBy(set, x => x.length);
+     * console.log(Array.from(set)); // ['c', 'bb', 'aaa']
+     * ```
+     */
+    static sortSetBy<T>(set: Set<T>, keySelector: (element: T) => any, keyComparer?: (x: T, y: T) => number): void;
+    /**
+     * Sorts the entries in a Set object.  The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let set: Set<string> = new Set<string>();
+     * set.add('zebra');
+     * set.add('goose');
+     * set.add('aardvark');
+     * Sort.sortSet(set);
+     * console.log(Array.from(set)); // ['aardvark', 'goose', 'zebra']
+     * ```
+     */
+    static sortSet<T>(set: Set<T>, comparer?: (x: T, y: T) => number): void;
+    /**
+     * Sort the keys deeply given an object or an array.
+     *
+     * Doesn't handle cyclic reference.
+     *
+     * @param object - The object to be sorted
+     *
+     * @example
+     *
+     * ```ts
+     * console.log(Sort.sortKeys({ c: 3, b: 2, a: 1 })); // { a: 1, b: 2, c: 3}
+     * ```
+     */
+    static sortKeys<T extends Partial<Record<string, unknown>> | unknown[]>(object: T): T;
+}
+//# sourceMappingURL=Sort.d.ts.map

package/node_modules/@rushstack/node-core-library/lib/Sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sort.d.ts","sourceRoot":"","sources":["../src/Sort.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,qBAAa,IAAI;IACf;;;;;;;;;;;;;;;;OAgBG;WAEW,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM;IAiCpD;;;;;;;;;;OAUG;WACW,MAAM,CAAC,CAAC,EACpB,KAAK,EAAE,CAAC,EAAE,EAEV,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,GAAG,EAEhC,QAAQ,GAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,MAA4B,GACzD,IAAI;IAIP;;OAEG;WACW,QAAQ,CAAC,CAAC,EACtB,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,EAEvB,QAAQ,GAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,MAA4B,GACzD,OAAO;IAeV;;;;;;;;;OASG;WACW,UAAU,CAAC,CAAC,EACxB,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,EAEvB,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,GAAG,EAEhC,QAAQ,GAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,MAA4B,GACzD,OAAO;IAgBV;;;;;;;;;;;;;;OAcG;WAEW,WAAW,CAAC,CAAC,EAAE,CAAC,EAC5B,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EACd,WAAW,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAA4B,GACxD,IAAI;IAeP;;;;;;;;;;;;;;OAcG;WACW,SAAS,CAAC,CAAC,EACvB,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAEX,WAAW,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,GAAG,EAChC,WAAW,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAA4B,GACxD,IAAI;IAeP;;;;;;;;;;;;;OAaG;WAEW,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAA4B,GAAG,IAAI;IAenG;;;;;;;;;;;;OAYG;WACW,QAAQ,CAAC,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;CAO7F"}