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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/23/AlreadyReportedError_23dbb838b51752afa3d8495f3062de58

@@ -0,0 +1,55 @@
+d7e026c38dbc3ed9f47e99ec15a9f805
+"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.AlreadyReportedError = void 0;
+const TypeUuid_1 = require("./TypeUuid");
+const uuidAlreadyReportedError = 'f26b0640-a49b-49d1-9ead-1a516d5920c7';
+/**
+ * This exception can be thrown to indicate that an operation failed and an error message has already
+ * been reported appropriately. Thus, the catch handler does not have responsibility for reporting
+ * the error.
+ *
+ * @remarks
+ * For example, suppose a tool writes interactive output to `console.log()`.  When an exception is thrown,
+ * the `catch` handler will typically provide simplistic reporting such as this:
+ *
+ * ```ts
+ * catch (error) {
+ *   console.log("ERROR: " + error.message);
+ * }
+ * ```
+ *
+ * Suppose that the code performing the operation normally prints rich output to the console.  It may be able to
+ * present an error message more nicely (for example, as part of a table, or structured log format).  Throwing
+ * `AlreadyReportedError` provides a way to use exception handling to abort the operation, but instruct the `catch`
+ * handler not to print an error a second time:
+ *
+ * ```ts
+ * catch (error) {
+ *   if (error instanceof AlreadyReportedError) {
+ *     return;
+ *   }
+ *   console.log("ERROR: " + error.message);
+ * }
+ * ```
+ *
+ * @public
+ */
+class AlreadyReportedError extends Error {
+    constructor() {
+        super('An error occurred.');
+        // Manually set the prototype, as we can no longer extend built-in classes like Error, Array, Map, etc
+        // [https://github.com/microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work](https://github.com/microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work)
+        //
+        // Note: the prototype must also be set on any classes which extend this one
+        this.__proto__ = AlreadyReportedError.prototype; // eslint-disable-line @typescript-eslint/no-explicit-any
+    }
+    static [Symbol.hasInstance](instance) {
+        return TypeUuid_1.TypeUuid.isInstanceOf(instance, uuidAlreadyReportedError);
+    }
+}
+exports.AlreadyReportedError = AlreadyReportedError;
+TypeUuid_1.TypeUuid.registerClass(AlreadyReportedError, uuidAlreadyReportedError);
+//# sourceMappingURL=AlreadyReportedError.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/23/minsatisfying_231e7868208d4f1c9e82cecdce4c81ef

@@ -0,0 +1,25 @@
+2155aea4b92343159e1b803f878a4729
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const minSatisfying = (versions, range, options) => {
+  let min = null
+  let minSV = null
+  let rangeObj = null
+  try {
+    rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v
+        minSV = new SemVer(min, options)
+      }
+    }
+  })
+  return min
+}
+module.exports = minSatisfying

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/24/error_245d118d6aaef020e6c9b74d975e24d7

@@ -0,0 +1,51 @@
+ebbd30aee8c24eca5643fa73dbf09632
+'use strict';
+
+
+var format  = require('util').format;
+
+
+var ERR_CODE = 'ARGError';
+
+/*:nodoc:*
+ * argumentError(argument, message) -> TypeError
+ * - argument (Object): action with broken argument
+ * - message (String): error message
+ *
+ * Error format helper. An error from creating or using an argument
+ * (optional or positional). The string value of this exception
+ * is the message, augmented with information
+ * about the argument that caused it.
+ *
+ * #####Example
+ *
+ *      var argumentErrorHelper = require('./argument/error');
+ *      if (conflictOptionals.length > 0) {
+ *        throw argumentErrorHelper(
+ *          action,
+ *          format('Conflicting option string(s): %s', conflictOptionals.join(', '))
+ *        );
+ *      }
+ *
+ **/
+module.exports = function (argument, message) {
+  var argumentName = null;
+  var errMessage;
+  var err;
+
+  if (argument.getName) {
+    argumentName = argument.getName();
+  } else {
+    argumentName = '' + argument;
+  }
+
+  if (!argumentName) {
+    errMessage = message;
+  } else {
+    errMessage = format('argument "%s": %s', argumentName, message);
+  }
+
+  err = new TypeError(errMessage);
+  err.code = ERR_CODE;
+  return err;
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/26/Enum_26f7c648b8042f36def6f28b90b3995f

@@ -0,0 +1,137 @@
+871e9fe489757c0d71026a75abf48f33
+"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.Enum = void 0;
+/**
+ * A helper for looking up TypeScript `enum` keys/values.
+ *
+ * @remarks
+ * TypeScript enums implement a lookup table for mapping between their keys and values:
+ *
+ * ```ts
+ * enum Colors {
+ *   Red = 1
+ * }
+ *
+ * // Prints "Red"
+ * console.log(Colors[1]);
+ *
+ * // Prints "1"
+ * console.log(Colors["Red]);
+ * ```
+ *
+ * However the compiler's "noImplicitAny" validation has trouble with these mappings, because
+ * there are so many possible types for the map elements:
+ *
+ * ```ts
+ * function f(s: string): Colors | undefined {
+ *   // (TS 7015) Element implicitly has an 'any' type because
+ *   // index expression is not of type 'number'.
+ *   return Colors[s];
+ * }
+ * ```
+ *
+ * The `Enum` helper provides a more specific, strongly typed way to access members:
+ *
+ * ```ts
+ * function f(s: string): Colors | undefined {
+ *   return Enum.tryGetValueByKey(Colors, s);
+ * }
+ * ```
+ *
+ * @public
+ */
+class Enum {
+    constructor() { }
+    /**
+     * Returns an enum value, given its key. Returns `undefined` if no matching key is found.
+     *
+     * @example
+     *
+     * Example usage:
+     * ```ts
+     * enum Colors {
+     *   Red = 1
+     * }
+     *
+     * // Prints "1"
+     * console.log(Enum.tryGetValueByKey(Colors, "Red"));
+     *
+     * // Prints "undefined"
+     * console.log(Enum.tryGetValueByKey(Colors, "Black"));
+     * ```
+     */
+    static tryGetValueByKey(enumObject, key) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return enumObject[key];
+    }
+    /**
+     * This API is similar to {@link Enum.tryGetValueByKey}, except that it throws an exception
+     * if the key is undefined.
+     */
+    static getValueByKey(enumObject, key) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result = enumObject[key];
+        if (result === undefined) {
+            throw new Error(`The lookup key ${JSON.stringify(key)} is not defined`);
+        }
+        return result;
+    }
+    /**
+     * Returns an enum string key, given its numeric value.  Returns `undefined` if no matching value
+     * is found.
+     *
+     * @remarks
+     * The TypeScript compiler only creates a reverse mapping for enum members whose value is numeric.
+     * For example:
+     *
+     * ```ts
+     * enum E {
+     *   A = 1,
+     *   B = 'c'
+     * }
+     *
+     * // Prints "A"
+     * console.log(E[1]);
+     *
+     * // Prints "undefined"
+     * console.log(E["c"]);
+     * ```
+     *
+     * @example
+     *
+     * Example usage:
+     * ```ts
+     * enum Colors {
+     *   Red = 1,
+     *   Blue = 'blue'
+     * }
+     *
+     * // Prints "Red"
+     * console.log(Enum.tryGetKeyByNumber(Colors, 1));
+     *
+     * // Prints "undefined"
+     * console.log(Enum.tryGetKeyByNumber(Colors, -1));
+     * ```
+     */
+    static tryGetKeyByNumber(enumObject, value) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return enumObject[value];
+    }
+    /**
+     * This API is similar to {@link Enum.tryGetKeyByNumber}, except that it throws an exception
+     * if the key is undefined.
+     */
+    static getKeyByNumber(enumObject, value) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result = enumObject[value];
+        if (result === undefined) {
+            throw new Error(`The value ${value} does not exist in the mapping`);
+        }
+        return result;
+    }
+}
+exports.Enum = Enum;
+//# sourceMappingURL=Enum.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/26/index_269839caa72382caf6110fdff62b8b0f

@@ -0,0 +1,89 @@
+72b763f2edbc5528a9648291b1c363fe
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = require('./internal/re')
+const constants = require('./internal/constants')
+const SemVer = require('./classes/semver')
+const identifiers = require('./internal/identifiers')
+const parse = require('./functions/parse')
+const valid = require('./functions/valid')
+const clean = require('./functions/clean')
+const inc = require('./functions/inc')
+const diff = require('./functions/diff')
+const major = require('./functions/major')
+const minor = require('./functions/minor')
+const patch = require('./functions/patch')
+const prerelease = require('./functions/prerelease')
+const compare = require('./functions/compare')
+const rcompare = require('./functions/rcompare')
+const compareLoose = require('./functions/compare-loose')
+const compareBuild = require('./functions/compare-build')
+const sort = require('./functions/sort')
+const rsort = require('./functions/rsort')
+const gt = require('./functions/gt')
+const lt = require('./functions/lt')
+const eq = require('./functions/eq')
+const neq = require('./functions/neq')
+const gte = require('./functions/gte')
+const lte = require('./functions/lte')
+const cmp = require('./functions/cmp')
+const coerce = require('./functions/coerce')
+const Comparator = require('./classes/comparator')
+const Range = require('./classes/range')
+const satisfies = require('./functions/satisfies')
+const toComparators = require('./ranges/to-comparators')
+const maxSatisfying = require('./ranges/max-satisfying')
+const minSatisfying = require('./ranges/min-satisfying')
+const minVersion = require('./ranges/min-version')
+const validRange = require('./ranges/valid')
+const outside = require('./ranges/outside')
+const gtr = require('./ranges/gtr')
+const ltr = require('./ranges/ltr')
+const intersects = require('./ranges/intersects')
+const simplifyRange = require('./ranges/simplify')
+const subset = require('./ranges/subset')
+module.exports = {
+  parse,
+  valid,
+  clean,
+  inc,
+  diff,
+  major,
+  minor,
+  patch,
+  prerelease,
+  compare,
+  rcompare,
+  compareLoose,
+  compareBuild,
+  sort,
+  rsort,
+  gt,
+  lt,
+  eq,
+  neq,
+  gte,
+  lte,
+  cmp,
+  coerce,
+  Comparator,
+  Range,
+  satisfies,
+  toComparators,
+  maxSatisfying,
+  minSatisfying,
+  minVersion,
+  validRange,
+  outside,
+  gtr,
+  ltr,
+  intersects,
+  simplifyRange,
+  subset,
+  SemVer,
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+  compareIdentifiers: identifiers.compareIdentifiers,
+  rcompareIdentifiers: identifiers.rcompareIdentifiers,
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/26/symlinkpaths_269231f2a465387e8122e02bc23a585b

@@ -0,0 +1,100 @@
+7235c0b4e3fa0d284084da7b4b885df9
+'use strict'
+
+const path = require('path')
+const fs = require('graceful-fs')
+const pathExists = require('../path-exists').pathExists
+
+/**
+ * Function that returns two types of paths, one relative to symlink, and one
+ * relative to the current working directory. Checks if path is absolute or
+ * relative. If the path is relative, this function checks if the path is
+ * relative to symlink or relative to current working directory. This is an
+ * initiative to find a smarter `srcpath` to supply when building symlinks.
+ * This allows you to determine which path to use out of one of three possible
+ * types of source paths. The first is an absolute path. This is detected by
+ * `path.isAbsolute()`. When an absolute path is provided, it is checked to
+ * see if it exists. If it does it's used, if not an error is returned
+ * (callback)/ thrown (sync). The other two options for `srcpath` are a
+ * relative url. By default Node's `fs.symlink` works by creating a symlink
+ * using `dstpath` and expects the `srcpath` to be relative to the newly
+ * created symlink. If you provide a `srcpath` that does not exist on the file
+ * system it results in a broken symlink. To minimize this, the function
+ * checks to see if the 'relative to symlink' source file exists, and if it
+ * does it will use it. If it does not, it checks if there's a file that
+ * exists that is relative to the current working directory, if does its used.
+ * This preserves the expectations of the original fs.symlink spec and adds
+ * the ability to pass in `relative to current working direcotry` paths.
+ */
+
+function symlinkPaths (srcpath, dstpath, callback) {
+  if (path.isAbsolute(srcpath)) {
+    return fs.lstat(srcpath, (err) => {
+      if (err) {
+        err.message = err.message.replace('lstat', 'ensureSymlink')
+        return callback(err)
+      }
+      return callback(null, {
+        'toCwd': srcpath,
+        'toDst': srcpath
+      })
+    })
+  } else {
+    const dstdir = path.dirname(dstpath)
+    const relativeToDst = path.join(dstdir, srcpath)
+    return pathExists(relativeToDst, (err, exists) => {
+      if (err) return callback(err)
+      if (exists) {
+        return callback(null, {
+          'toCwd': relativeToDst,
+          'toDst': srcpath
+        })
+      } else {
+        return fs.lstat(srcpath, (err) => {
+          if (err) {
+            err.message = err.message.replace('lstat', 'ensureSymlink')
+            return callback(err)
+          }
+          return callback(null, {
+            'toCwd': srcpath,
+            'toDst': path.relative(dstdir, srcpath)
+          })
+        })
+      }
+    })
+  }
+}
+
+function symlinkPathsSync (srcpath, dstpath) {
+  let exists
+  if (path.isAbsolute(srcpath)) {
+    exists = fs.existsSync(srcpath)
+    if (!exists) throw new Error('absolute srcpath does not exist')
+    return {
+      'toCwd': srcpath,
+      'toDst': srcpath
+    }
+  } else {
+    const dstdir = path.dirname(dstpath)
+    const relativeToDst = path.join(dstdir, srcpath)
+    exists = fs.existsSync(relativeToDst)
+    if (exists) {
+      return {
+        'toCwd': relativeToDst,
+        'toDst': srcpath
+      }
+    } else {
+      exists = fs.existsSync(srcpath)
+      if (!exists) throw new Error('relative srcpath does not exist')
+      return {
+        'toCwd': srcpath,
+        'toDst': path.relative(dstdir, srcpath)
+      }
+    }
+  }
+}
+
+module.exports = {
+  symlinkPaths,
+  symlinkPathsSync
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/27/AsyncParallelBailHook_277e441e1512e36622369a45ebd3f58b

@@ -0,0 +1,86 @@
+03ebda6c19f57daed729fa01ff720d95
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class AsyncParallelBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, onDone }) {
+		let code = "";
+		code += `var _results = new Array(${this.options.taps.length});\n`;
+		code += "var _checkDone = function() {\n";
+		code += "for(var i = 0; i < _results.length; i++) {\n";
+		code += "var item = _results[i];\n";
+		code += "if(item === undefined) return false;\n";
+		code += "if(item.result !== undefined) {\n";
+		code += onResult("item.result");
+		code += "return true;\n";
+		code += "}\n";
+		code += "if(item.error) {\n";
+		code += onError("item.error");
+		code += "return true;\n";
+		code += "}\n";
+		code += "}\n";
+		code += "return false;\n";
+		code += "}\n";
+		code += this.callTapsParallel({
+			onError: (i, err, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && ((_results.length = ${i +
+					1}), (_results[${i}] = { error: ${err} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onResult: (i, result, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && (${result} !== undefined && (_results.length = ${i +
+					1}), (_results[${i}] = { result: ${result} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onTap: (i, run, done, doneBreak) => {
+				let code = "";
+				if (i > 0) {
+					code += `if(${i} >= _results.length) {\n`;
+					code += done();
+					code += "} else {\n";
+				}
+				code += run();
+				if (i > 0) code += "}\n";
+				return code;
+			},
+			onDone
+		});
+		return code;
+	}
+}
+
+const factory = new AsyncParallelBailHookCodeFactory();
+
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function AsyncParallelBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = AsyncParallelBailHook;
+	hook.compile = COMPILE;
+	hook._call = undefined;
+	hook.call = undefined;
+	return hook;
+}
+
+AsyncParallelBailHook.prototype = null;
+
+module.exports = AsyncParallelBailHook;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/27/index_272b3290b49eb1250dd5383c4066d1d6

@@ -0,0 +1,44 @@
+94663944a825ca6ef69ad28574c6874a
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * This library implements a system for processing human readable text that
+ * will be output by console applications.
+ *
+ * @remarks
+ * See the {@link TerminalWritable} documentation for an overview of the major concepts.
+ *
+ * @packageDocumentation
+ */
+__exportStar(require("./CallbackWritable"), exports);
+__exportStar(require("./DiscardStdoutTransform"), exports);
+__exportStar(require("./ITerminalChunk"), exports);
+__exportStar(require("./MockWritable"), exports);
+__exportStar(require("./NormalizeNewlinesTextRewriter"), exports);
+__exportStar(require("./PrintUtilities"), exports);
+__exportStar(require("./RemoveColorsTextRewriter"), exports);
+__exportStar(require("./SplitterTransform"), exports);
+__exportStar(require("./StdioLineTransform"), exports);
+__exportStar(require("./StdioSummarizer"), exports);
+__exportStar(require("./StdioWritable"), exports);
+__exportStar(require("./TerminalTransform"), exports);
+__exportStar(require("./TerminalWritable"), exports);
+__exportStar(require("./TextRewriter"), exports);
+__exportStar(require("./TextRewriterTransform"), exports);
+//# sourceMappingURL=index.js.map