@rushstack/rush-http-build-cache-plugin 5.92.0

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f8/BaseClasses_f86545813589e9e0e828bd06fd6f483b

@@ -0,0 +1,170 @@
+90a4b99fcb0789538986015483f22ec0
+"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.CommandLineParameterWithArgument = exports.CommandLineParameter = exports.CommandLineParameterKind = void 0;
+/**
+ * Identifies the kind of a CommandLineParameter.
+ * @public
+ */
+var CommandLineParameterKind;
+(function (CommandLineParameterKind) {
+    /** Indicates a CommandLineChoiceParameter */
+    CommandLineParameterKind[CommandLineParameterKind["Choice"] = 0] = "Choice";
+    /** Indicates a CommandLineFlagParameter */
+    CommandLineParameterKind[CommandLineParameterKind["Flag"] = 1] = "Flag";
+    /** Indicates a CommandLineIntegerParameter */
+    CommandLineParameterKind[CommandLineParameterKind["Integer"] = 2] = "Integer";
+    /** Indicates a CommandLineStringParameter */
+    CommandLineParameterKind[CommandLineParameterKind["String"] = 3] = "String";
+    /** Indicates a CommandLineStringListParameter */
+    CommandLineParameterKind[CommandLineParameterKind["StringList"] = 4] = "StringList";
+    /** Indicates a CommandLineChoiceListParameter */
+    CommandLineParameterKind[CommandLineParameterKind["ChoiceList"] = 5] = "ChoiceList";
+    /** Indicates a CommandLineIntegerListParameter */
+    CommandLineParameterKind[CommandLineParameterKind["IntegerList"] = 6] = "IntegerList";
+})(CommandLineParameterKind = exports.CommandLineParameterKind || (exports.CommandLineParameterKind = {}));
+/**
+ * Matches kebab-case formatted strings prefixed with double dashes.
+ * Example: "--do-something"
+ */
+const LONG_NAME_REGEXP = /^-(-[a-z0-9]+)+$/;
+/**
+ * Matches a single upper-case or lower-case letter prefixed with a dash.
+ * Example: "-d"
+ */
+const SHORT_NAME_REGEXP = /^-[a-zA-Z]$/;
+/**
+ * Matches kebab-case formatted strings
+ * Example: "my-scope"
+ */
+const SCOPE_REGEXP = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/**
+ * "Environment variable names used by the utilities in the Shell and Utilities volume of
+ * IEEE Std 1003.1-2001 consist solely of uppercase letters, digits, and the '_' (underscore)
+ * from the characters defined in Portable Character Set and do not begin with a digit."
+ * Example: "THE_SETTING"
+ */
+const ENVIRONMENT_VARIABLE_NAME_REGEXP = /^[A-Z_][A-Z0-9_]*$/;
+/**
+ * The base class for the various command-line parameter types.
+ * @public
+ */
+class CommandLineParameter {
+    /** @internal */
+    constructor(definition) {
+        this.longName = definition.parameterLongName;
+        this.shortName = definition.parameterShortName;
+        this.parameterGroup = definition.parameterGroup;
+        this.parameterScope = definition.parameterScope;
+        this.description = definition.description;
+        this.required = !!definition.required;
+        this.environmentVariable = definition.environmentVariable;
+        this.undocumentedSynonyms = definition.undocumentedSynonyms;
+        if (!LONG_NAME_REGEXP.test(this.longName)) {
+            throw new Error(`Invalid name: "${this.longName}". The parameter long name must be` +
+                ` lower-case and use dash delimiters (e.g. "--do-a-thing")`);
+        }
+        if (this.shortName) {
+            if (!SHORT_NAME_REGEXP.test(this.shortName)) {
+                throw new Error(`Invalid name: "${this.shortName}". The parameter short name must be` +
+                    ` a dash followed by a single upper-case or lower-case letter (e.g. "-a")`);
+            }
+        }
+        if (this.parameterScope) {
+            if (!SCOPE_REGEXP.test(this.parameterScope)) {
+                throw new Error(`Invalid scope: "${this.parameterScope}". The parameter scope name must be` +
+                    ` lower-case and use dash delimiters (e.g. "my-scope")`);
+            }
+            // Parameter long name is guaranteed to start with '--' since this is validated above
+            const unprefixedLongName = this.longName.slice(2);
+            this.scopedLongName = `--${this.parameterScope}:${unprefixedLongName}`;
+        }
+        if (this.environmentVariable) {
+            if (this.required) {
+                // TODO: This constraint is imposed only because argparse enforces "required" parameters, but
+                // it does not know about ts-command-line environment variable mappings.  We should fix this.
+                throw new Error(`An "environmentVariable" cannot be specified for "${this.longName}"` +
+                    ` because it is a required parameter`);
+            }
+            if (!ENVIRONMENT_VARIABLE_NAME_REGEXP.test(this.environmentVariable)) {
+                throw new Error(`Invalid environment variable name: "${this.environmentVariable}". The name must` +
+                    ` consist only of upper-case letters, numbers, and underscores. It may not start with a number.`);
+            }
+        }
+        if (this.undocumentedSynonyms && this.undocumentedSynonyms.length > 0) {
+            for (const undocumentedSynonym of this.undocumentedSynonyms) {
+                if (this.longName === undocumentedSynonym) {
+                    throw new Error(`Invalid name: "${undocumentedSynonym}". Undocumented synonyms must not be the same` +
+                        ` as the the long name.`);
+                }
+                else if (!LONG_NAME_REGEXP.test(undocumentedSynonym)) {
+                    throw new Error(`Invalid name: "${undocumentedSynonym}". All undocumented synonyms name must be lower-case and ` +
+                        'use dash delimiters (e.g. "--do-a-thing")');
+                }
+            }
+        }
+    }
+    /**
+     * Returns additional text used by the help formatter.
+     * @internal
+     */
+    _getSupplementaryNotes(supplementaryNotes) {
+        // virtual
+        if (this.environmentVariable !== undefined) {
+            supplementaryNotes.push('This parameter may alternatively be specified via the ' +
+                this.environmentVariable +
+                ' environment variable.');
+        }
+    }
+    /**
+     * Internal usage only.  Used to report unexpected output from the argparse library.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    reportInvalidData(data) {
+        throw new Error(`Unexpected data object for parameter "${this.longName}": ` + JSON.stringify(data));
+    }
+    validateDefaultValue(hasDefaultValue) {
+        if (this.required && hasDefaultValue) {
+            // If a parameter is "required", then the user understands that they always need to
+            // specify a value for this parameter (either via the command line or via an environment variable).
+            // It would be confusing to allow a default value that sometimes allows the "required" parameter
+            // to be omitted.  If you sometimes don't have a suitable default value, then the better approach
+            // is to throw a custom error explaining why the parameter is required in that case.
+            throw new Error(`A default value cannot be specified for "${this.longName}" because it is a "required" parameter`);
+        }
+    }
+}
+exports.CommandLineParameter = CommandLineParameter;
+/**
+ * The common base class for parameters types that receive an argument.
+ *
+ * @remarks
+ * An argument is an accompanying command-line token, such as "123" in the
+ * example "--max-count 123".
+ * @public
+ */
+class CommandLineParameterWithArgument extends CommandLineParameter {
+    /** @internal */
+    constructor(definition) {
+        super(definition);
+        if (definition.argumentName === '') {
+            throw new Error('The argument name cannot be an empty string. (For the default name, specify undefined.)');
+        }
+        if (definition.argumentName.toUpperCase() !== definition.argumentName) {
+            throw new Error(`Invalid name: "${definition.argumentName}". The argument name must be all upper case.`);
+        }
+        const match = definition.argumentName.match(CommandLineParameterWithArgument._invalidArgumentNameRegExp);
+        if (match) {
+            throw new Error(`The argument name "${definition.argumentName}" contains an invalid character "${match[0]}".` +
+                ` Only upper-case letters, numbers, and underscores are allowed.`);
+        }
+        this.argumentName = definition.argumentName;
+        this.completions = definition.completions;
+    }
+}
+exports.CommandLineParameterWithArgument = CommandLineParameterWithArgument;
+// Matches the first character that *isn't* part of a valid upper-case argument name such as "URL_2"
+CommandLineParameterWithArgument._invalidArgumentNameRegExp = /[^A-Z_0-9]/;
+//# sourceMappingURL=BaseClasses.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f8/Helpers_f82226d33bc83e35ab5d60a911a8baa0

@@ -0,0 +1,72 @@
+7832280f1f6dbc4cf612f523a2587203
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Helpers = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const resolve_1 = __importDefault(require("resolve"));
+// These helpers avoid taking dependencies on other NPM packages
+class Helpers {
+    static async nodeResolveAsync(id, opts) {
+        return await new Promise((resolve, reject) => {
+            (0, resolve_1.default)(id, opts, (error, result) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+        });
+    }
+    static async fsExistsAsync(path) {
+        return await new Promise((resolve) => {
+            fs.exists(path, (exists) => {
+                resolve(exists);
+            });
+        });
+    }
+    // Based on Path.isDownwardRelative() from @rushstack/node-core-library
+    static isDownwardRelative(inputPath) {
+        if (path.isAbsolute(inputPath)) {
+            return false;
+        }
+        // Does it contain ".."
+        if (Helpers._upwardPathSegmentRegex.test(inputPath)) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.Helpers = Helpers;
+// Based on Path.isDownwardRelative() from @rushstack/node-core-library
+Helpers._upwardPathSegmentRegex = /([\/\\]|^)\.\.([\/\\]|$)/;
+//# sourceMappingURL=Helpers.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f8/eq_f83b8f41e78fb9dcd93f57ba31fd2fb7

@@ -0,0 +1,4 @@
+498639a97e5682386b94c24096f133db
+const compare = require('./compare')
+const eq = (a, b, loose) => compare(a, b, loose) === 0
+module.exports = eq

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f9/TerminalWritable_f95360cc0a4458d3f87824bca7c56ec7

@@ -0,0 +1,124 @@
+1e6e6b70829751763bcd6736b0f80863
+"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.TerminalWritable = void 0;
+/**
+ * The abstract base class for objects that can present, route, or process text output for
+ * a console application.  This output is typically prepared using
+ * the {@link @rushstack/node-core-library#Terminal} API.
+ *
+ * @remarks
+ *
+ * The design is based loosely on the `WritableStream` and `TransformStream` classes from
+ * the system {@link https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Concepts
+ * | Streams API}, except that instead of asynchronous byte streams, the `TerminalWritable`
+ * system synchronously transmits human readable messages intended to be rendered on a text
+ * console or log file.
+ *
+ * Consider a console application whose output may need to be processed in different ways
+ * before finally being output.  The conceptual block diagram might look like this:
+ *
+ * ```
+ *          [Terminal API]
+ *                 |
+ *                 V
+ *        [normalize newlines]
+ *                 |
+ *                 V
+ *       +----[splitter]-------+
+ *       |                     |
+ *       V                     V
+ *   [shell console]     [remove ANSI colors]
+ *                             |
+ *                             V
+ *                       [write to build.log]
+ * ```
+ *
+ * The application uses the `Terminal` API to print `stdout` and `stderr` messages, for example with standardized
+ * formatting for errors and warnings, and ANSI escapes to make nice colors.  Maybe it also includes text
+ * received from external processes, whose newlines may be inconsistent.  Ultimately we want to write the
+ * output to the shell console and a `build.log` file, but we don't want to put ANSI colors in the build log.
+ *
+ * For the above example, `[shell console]` and `[write to build.log]` would be modeled as subclasses of
+ * `TerminalWritable`.  The `[normalize newlines]` and `[remove ANSI colors]` steps are modeled as subclasses
+ * of {@link TerminalTransform}, because they output to a "destination" object.  The `[splitter]` would be
+ * implemented using {@link SplitterTransform}.
+ *
+ * The stream of messages are {@link ITerminalChunk} objects, which can represent both `stdout` and `stderr`
+ * channels.  The pipeline operates synchronously on each chunk, but by processing one chunk at a time,
+ * it avoids storing the entire output in memory.  This means that operations like `[remove ANSI colors]`
+ * cannot be simple regular expressions -- they must be implemented as state machines ({@link TextRewriter}
+ * subclasses) capable of matching substrings that span multiple chunks.
+ *
+ * @public
+ */
+class TerminalWritable {
+    constructor(options) {
+        this._isOpen = true;
+        if (!options) {
+            options = {};
+        }
+        this.preventAutoclose = !!options.preventAutoclose;
+    }
+    /**
+     * This property is initially `true` when the object is constructed, and becomes `false`
+     * when `close()` is called.
+     * @sealed
+     */
+    get isOpen() {
+        return this._isOpen;
+    }
+    /**
+     * Upstream objects call this method to provide inputs to this object.
+     *
+     * @remarks
+     * The subclass provides its implementation via the the {@link TerminalWritable.onWriteChunk}
+     * method, which is called by `writeChunk()`.
+     *
+     * The object that calls `writeChunk()` must call `close()` when it is finished;
+     * failing to do so may introduce a resource leak, or may prevent some buffered data from
+     * being written.
+     *
+     * @sealed
+     */
+    writeChunk(chunk) {
+        if (!this._isOpen) {
+            throw new Error('Writer was already closed');
+        }
+        this.onWriteChunk(chunk);
+    }
+    /**
+     * Calling this method flushes any remaining outputs and permanently transitions the
+     * `TerminalWritable` to a "closed" state, where no further chunks can be written.
+     *
+     * @remarks
+     * The subclass provides its implementation via the the {@link TerminalWritable.onClose}
+     * method, which is called by `close()`.
+     *
+     * If this method is called more than once, the additional calls are ignored;
+     * `TerminalWritable.onClose` will be called at most once.
+     *
+     * @sealed
+     */
+    close() {
+        if (this._isOpen) {
+            this.onClose();
+            this._isOpen = false;
+        }
+    }
+    /**
+     * Subclasses can override this empty method to perform additional operations
+     * such as closing a file handle.
+     *
+     * @remarks
+     * It is guaranteed that this method will be called at most once during the lifetime
+     * of a `TerminalWritable` object.
+     *
+     * @virtual
+     */
+    onClose() { }
+}
+exports.TerminalWritable = TerminalWritable;
+//# sourceMappingURL=TerminalWritable.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/f9/compare_f98f6def50e53b4e306f892abb74cc0e

@@ -0,0 +1,6 @@
+33ec903e117ba1fe05cddedb86a9601d
+const SemVer = require('../classes/semver')
+const compare = (a, b, loose) =>
+  new SemVer(a, loose).compare(new SemVer(b, loose))
+
+module.exports = compare