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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/b7/URLimpl_b7e473a6d12ed1315b560494844887bd

@@ -0,0 +1,201 @@
+c59fc2cbaff55db3419a0f3fc3274cb6
+"use strict";
+const usm = require("./url-state-machine");
+
+exports.implementation = class URLImpl {
+  constructor(constructorArgs) {
+    const url = constructorArgs[0];
+    const base = constructorArgs[1];
+
+    let parsedBase = null;
+    if (base !== undefined) {
+      parsedBase = usm.basicURLParse(base);
+      if (parsedBase === "failure") {
+        throw new TypeError("Invalid base URL");
+      }
+    }
+
+    const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
+    if (parsedURL === "failure") {
+      throw new TypeError("Invalid URL");
+    }
+
+    this._url = parsedURL;
+
+    // TODO: query stuff
+  }
+
+  get href() {
+    return usm.serializeURL(this._url);
+  }
+
+  set href(v) {
+    const parsedURL = usm.basicURLParse(v);
+    if (parsedURL === "failure") {
+      throw new TypeError("Invalid URL");
+    }
+
+    this._url = parsedURL;
+  }
+
+  get origin() {
+    return usm.serializeURLOrigin(this._url);
+  }
+
+  get protocol() {
+    return this._url.scheme + ":";
+  }
+
+  set protocol(v) {
+    usm.basicURLParse(v + ":", { url: this._url, stateOverride: "scheme start" });
+  }
+
+  get username() {
+    return this._url.username;
+  }
+
+  set username(v) {
+    if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
+      return;
+    }
+
+    usm.setTheUsername(this._url, v);
+  }
+
+  get password() {
+    return this._url.password;
+  }
+
+  set password(v) {
+    if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
+      return;
+    }
+
+    usm.setThePassword(this._url, v);
+  }
+
+  get host() {
+    const url = this._url;
+
+    if (url.host === null) {
+      return "";
+    }
+
+    if (url.port === null) {
+      return usm.serializeHost(url.host);
+    }
+
+    return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port);
+  }
+
+  set host(v) {
+    if (this._url.cannotBeABaseURL) {
+      return;
+    }
+
+    usm.basicURLParse(v, { url: this._url, stateOverride: "host" });
+  }
+
+  get hostname() {
+    if (this._url.host === null) {
+      return "";
+    }
+
+    return usm.serializeHost(this._url.host);
+  }
+
+  set hostname(v) {
+    if (this._url.cannotBeABaseURL) {
+      return;
+    }
+
+    usm.basicURLParse(v, { url: this._url, stateOverride: "hostname" });
+  }
+
+  get port() {
+    if (this._url.port === null) {
+      return "";
+    }
+
+    return usm.serializeInteger(this._url.port);
+  }
+
+  set port(v) {
+    if (usm.cannotHaveAUsernamePasswordPort(this._url)) {
+      return;
+    }
+
+    if (v === "") {
+      this._url.port = null;
+    } else {
+      usm.basicURLParse(v, { url: this._url, stateOverride: "port" });
+    }
+  }
+
+  get pathname() {
+    if (this._url.cannotBeABaseURL) {
+      return this._url.path[0];
+    }
+
+    if (this._url.path.length === 0) {
+      return "";
+    }
+
+    return "/" + this._url.path.join("/");
+  }
+
+  set pathname(v) {
+    if (this._url.cannotBeABaseURL) {
+      return;
+    }
+
+    this._url.path = [];
+    usm.basicURLParse(v, { url: this._url, stateOverride: "path start" });
+  }
+
+  get search() {
+    if (this._url.query === null || this._url.query === "") {
+      return "";
+    }
+
+    return "?" + this._url.query;
+  }
+
+  set search(v) {
+    // TODO: query stuff
+
+    const url = this._url;
+
+    if (v === "") {
+      url.query = null;
+      return;
+    }
+
+    const input = v[0] === "?" ? v.substring(1) : v;
+    url.query = "";
+    usm.basicURLParse(input, { url, stateOverride: "query" });
+  }
+
+  get hash() {
+    if (this._url.fragment === null || this._url.fragment === "") {
+      return "";
+    }
+
+    return "#" + this._url.fragment;
+  }
+
+  set hash(v) {
+    if (v === "") {
+      this._url.fragment = null;
+      return;
+    }
+
+    const input = v[0] === "#" ? v.substring(1) : v;
+    this._url.fragment = "";
+    usm.basicURLParse(input, { url: this._url, stateOverride: "fragment" });
+  }
+
+  toJSON() {
+    return this.href;
+  }
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/b8/patch_b81e5f0e2e6da3056822bf2f4ed9e7e7

@@ -0,0 +1,4 @@
+a78ef0c69e82d2a7b1f4f697e620aef6
+const SemVer = require('../classes/semver')
+const patch = (a, loose) => new SemVer(a, loose).patch
+module.exports = patch

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/b9/ProtectableMapView_b9b1fd8ad3e74d9d06a42d6e7db85a90

@@ -0,0 +1,57 @@
+69c477a2f21cc49ac61eb01350ed4c9b
+"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/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/bc/AnsiEscape_bc9207c145be8aaf6afacb84732c22e3

@@ -0,0 +1,134 @@
+dbeef10a295ac93918ac301cb0408762
+"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.AnsiEscape = void 0;
+const Colors_1 = require("./Colors");
+/**
+ * Operations for working with text strings that contain
+ * {@link https://en.wikipedia.org/wiki/ANSI_escape_code | ANSI escape codes}.
+ * The most commonly used escape codes set the foreground/background color for console output.
+ * @public
+ */
+class AnsiEscape {
+    /**
+     * Returns the input text with all ANSI escape codes removed.  For example, this is useful when saving
+     * colorized console output to a log file.
+     */
+    static removeCodes(text) {
+        // eslint-disable-next-line no-control-regex
+        return text.replace(AnsiEscape._csiRegExp, '');
+    }
+    /**
+     * Replaces ANSI escape codes with human-readable tokens.  This is useful for unit tests
+     * that compare text strings in test assertions or snapshot files.
+     */
+    static formatForTests(text, options) {
+        if (!options) {
+            options = {};
+        }
+        let result = text.replace(AnsiEscape._csiRegExp, (capture, csiCode) => {
+            // If it is an SGR code, then try to show a friendly token
+            const match = csiCode.match(AnsiEscape._sgrRegExp);
+            if (match) {
+                const sgrParameter = parseInt(match[1]);
+                const sgrParameterName = AnsiEscape._tryGetSgrFriendlyName(sgrParameter);
+                if (sgrParameterName) {
+                    // Example: "[black-bg]"
+                    return `[${sgrParameterName}]`;
+                }
+            }
+            // Otherwise show the raw code, but without the "[" from the CSI prefix
+            // Example: "[31m]"
+            return `[${csiCode}]`;
+        });
+        if (options.encodeNewlines) {
+            result = result
+                .replace(AnsiEscape._backslashNRegExp, '[n]')
+                .replace(AnsiEscape._backslashRRegExp, `[r]`);
+        }
+        return result;
+    }
+    // Returns a human-readable token representing an SGR parameter, or undefined for parameter that is not well-known.
+    // The SGR parameter numbers are documented in this table:
+    // https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters
+    static _tryGetSgrFriendlyName(sgiParameter) {
+        switch (sgiParameter) {
+            case Colors_1.ConsoleColorCodes.BlackForeground:
+                return 'black';
+            case Colors_1.ConsoleColorCodes.RedForeground:
+                return 'red';
+            case Colors_1.ConsoleColorCodes.GreenForeground:
+                return 'green';
+            case Colors_1.ConsoleColorCodes.YellowForeground:
+                return 'yellow';
+            case Colors_1.ConsoleColorCodes.BlueForeground:
+                return 'blue';
+            case Colors_1.ConsoleColorCodes.MagentaForeground:
+                return 'magenta';
+            case Colors_1.ConsoleColorCodes.CyanForeground:
+                return 'cyan';
+            case Colors_1.ConsoleColorCodes.WhiteForeground:
+                return 'white';
+            case Colors_1.ConsoleColorCodes.GrayForeground:
+                return 'gray';
+            case Colors_1.ConsoleColorCodes.DefaultForeground:
+                return 'default';
+            case Colors_1.ConsoleColorCodes.BlackBackground:
+                return 'black-bg';
+            case Colors_1.ConsoleColorCodes.RedBackground:
+                return 'red-bg';
+            case Colors_1.ConsoleColorCodes.GreenBackground:
+                return 'green-bg';
+            case Colors_1.ConsoleColorCodes.YellowBackground:
+                return 'yellow-bg';
+            case Colors_1.ConsoleColorCodes.BlueBackground:
+                return 'blue-bg';
+            case Colors_1.ConsoleColorCodes.MagentaBackground:
+                return 'magenta-bg';
+            case Colors_1.ConsoleColorCodes.CyanBackground:
+                return 'cyan-bg';
+            case Colors_1.ConsoleColorCodes.WhiteBackground:
+                return 'white-bg';
+            case Colors_1.ConsoleColorCodes.GrayBackground:
+                return 'gray-bg';
+            case Colors_1.ConsoleColorCodes.DefaultBackground:
+                return 'default-bg';
+            case Colors_1.ConsoleColorCodes.Bold:
+                return 'bold';
+            case Colors_1.ConsoleColorCodes.Dim:
+                return 'dim';
+            case Colors_1.ConsoleColorCodes.NormalColorOrIntensity:
+                return 'normal';
+            case Colors_1.ConsoleColorCodes.Underline:
+                return 'underline';
+            case Colors_1.ConsoleColorCodes.UnderlineOff:
+                return 'underline-off';
+            case Colors_1.ConsoleColorCodes.Blink:
+                return 'blink';
+            case Colors_1.ConsoleColorCodes.BlinkOff:
+                return 'blink-off';
+            case Colors_1.ConsoleColorCodes.InvertColor:
+                return 'invert';
+            case Colors_1.ConsoleColorCodes.InvertColorOff:
+                return 'invert-off';
+            case Colors_1.ConsoleColorCodes.Hidden:
+                return 'hidden';
+            case Colors_1.ConsoleColorCodes.HiddenOff:
+                return 'hidden-off';
+            default:
+                return undefined;
+        }
+    }
+}
+exports.AnsiEscape = AnsiEscape;
+// For now, we only care about the Control Sequence Introducer (CSI) commands which always start with "[".
+// eslint-disable-next-line no-control-regex
+AnsiEscape._csiRegExp = /\x1b\[([\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e])/gu;
+// Text coloring is performed using Select Graphic Rendition (SGR) codes, which come after the
+// CSI introducer "ESC [".  The SGR sequence is a number followed by "m".
+AnsiEscape._sgrRegExp = /([0-9]+)m/u;
+AnsiEscape._backslashNRegExp = /\n/g;
+AnsiEscape._backslashRRegExp = /\r/g;
+//# sourceMappingURL=AnsiEscape.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/bc/runner_bc68aa9a21b7738e0d6c25423b185c0f

@@ -0,0 +1,11 @@
+59e09aaacd77acebbcf19b41d4b59884
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Allow people to use `jest-circus/runner` as a runner.
+const runner = require('./build/legacy-code-todo-rewrite/jestAdapter').default;
+module.exports = runner;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/bc/symlink_bc0175250b3ab636a40c845a9eddb39d

@@ -0,0 +1,64 @@
+dfc14c66722e60dc6879221877aecf94
+'use strict'
+
+const u = require('universalify').fromCallback
+const path = require('path')
+const fs = require('graceful-fs')
+const _mkdirs = require('../mkdirs')
+const mkdirs = _mkdirs.mkdirs
+const mkdirsSync = _mkdirs.mkdirsSync
+
+const _symlinkPaths = require('./symlink-paths')
+const symlinkPaths = _symlinkPaths.symlinkPaths
+const symlinkPathsSync = _symlinkPaths.symlinkPathsSync
+
+const _symlinkType = require('./symlink-type')
+const symlinkType = _symlinkType.symlinkType
+const symlinkTypeSync = _symlinkType.symlinkTypeSync
+
+const pathExists = require('../path-exists').pathExists
+
+function createSymlink (srcpath, dstpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback
+  type = (typeof type === 'function') ? false : type
+
+  pathExists(dstpath, (err, destinationExists) => {
+    if (err) return callback(err)
+    if (destinationExists) return callback(null)
+    symlinkPaths(srcpath, dstpath, (err, relative) => {
+      if (err) return callback(err)
+      srcpath = relative.toDst
+      symlinkType(relative.toCwd, type, (err, type) => {
+        if (err) return callback(err)
+        const dir = path.dirname(dstpath)
+        pathExists(dir, (err, dirExists) => {
+          if (err) return callback(err)
+          if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)
+          mkdirs(dir, err => {
+            if (err) return callback(err)
+            fs.symlink(srcpath, dstpath, type, callback)
+          })
+        })
+      })
+    })
+  })
+}
+
+function createSymlinkSync (srcpath, dstpath, type) {
+  const destinationExists = fs.existsSync(dstpath)
+  if (destinationExists) return undefined
+
+  const relative = symlinkPathsSync(srcpath, dstpath)
+  srcpath = relative.toDst
+  type = symlinkTypeSync(relative.toCwd, type)
+  const dir = path.dirname(dstpath)
+  const exists = fs.existsSync(dir)
+  if (exists) return fs.symlinkSync(srcpath, dstpath, type)
+  mkdirsSync(dir)
+  return fs.symlinkSync(srcpath, dstpath, type)
+}
+
+module.exports = {
+  createSymlink: u(createSymlink),
+  createSymlinkSync
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/bd/CommandLineParserExitError_bd2152fe7b2d6044694614b16bd42828

@@ -0,0 +1,58 @@
+c986fbb7d5bb06c0e00d732e8105b924
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomArgumentParser = exports.CommandLineParserExitError = void 0;
+const argparse = __importStar(require("argparse"));
+class CommandLineParserExitError extends Error {
+    constructor(exitCode, message) {
+        super(message);
+        // 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
+        //
+        // Note: the prototype must also be set on any classes which extend this one
+        this.__proto__ = CommandLineParserExitError.prototype; // eslint-disable-line @typescript-eslint/no-explicit-any
+        this.exitCode = exitCode;
+    }
+}
+exports.CommandLineParserExitError = CommandLineParserExitError;
+class CustomArgumentParser extends argparse.ArgumentParser {
+    exit(status, message) {
+        // override
+        throw new CommandLineParserExitError(status, message);
+    }
+    error(err) {
+        // override
+        // Ensure the ParserExitError bubbles up to the top without any special processing
+        if (err instanceof CommandLineParserExitError) {
+            throw err;
+        }
+        super.error(err);
+    }
+}
+exports.CustomArgumentParser = CustomArgumentParser;
+//# sourceMappingURL=CommandLineParserExitError.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/be/index_be50ea9cf8c03c5389c9952e3199b3f0

@@ -0,0 +1,14 @@
+7d17be54fd3e8709ccc8675c77e97308
+var colors = require('./colors');
+module['exports'] = colors;
+
+// Remark: By default, colors will add style properties to String.prototype.
+//
+// If you don't wish to extend String.prototype, you can do this instead and
+// native String will not be touched:
+//
+//   var colors = require('colors/safe);
+//   colors.red("foo")
+//
+//
+require('./extendStringPrototype')();

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/be/zebra_bee85ff6bfd6c73305c83bae9403032a

@@ -0,0 +1,6 @@
+3b358b12988dce6954c76d2b24b244a8
+var colors = require('../colors');
+
+module['exports'] = function(letter, i, exploded) {
+  return i % 2 === 0 ? letter : colors.inverse(letter);
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/bf/index_bff0217ff50de0880fe9c3dd5a042b61

@@ -0,0 +1,26 @@
+a302a92b024c32b20a054ae539f58107
+"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.ensureGitMinimumVersion = exports.getRepoStateAsync = exports.getRepoRoot = exports.getRepoChanges = exports.getGitHashForFiles = exports.getPackageDeps = void 0;
+/**
+ * This package builds a JSON object containing the git hashes of all files used to produce a given NPM package.
+ * The {@link https://rushjs.io/ | Rush} tool uses this library to implement incremental build detection.
+ *
+ * @remarks
+ *
+ * For more info, please see the package {@link https://www.npmjs.com/package/@rushstack/package-deps-hash
+ * | README}.
+ *
+ * @packageDocumentation
+ */
+var getPackageDeps_1 = require("./getPackageDeps");
+Object.defineProperty(exports, "getPackageDeps", { enumerable: true, get: function () { return getPackageDeps_1.getPackageDeps; } });
+Object.defineProperty(exports, "getGitHashForFiles", { enumerable: true, get: function () { return getPackageDeps_1.getGitHashForFiles; } });
+var getRepoState_1 = require("./getRepoState");
+Object.defineProperty(exports, "getRepoChanges", { enumerable: true, get: function () { return getRepoState_1.getRepoChanges; } });
+Object.defineProperty(exports, "getRepoRoot", { enumerable: true, get: function () { return getRepoState_1.getRepoRoot; } });
+Object.defineProperty(exports, "getRepoStateAsync", { enumerable: true, get: function () { return getRepoState_1.getRepoStateAsync; } });
+Object.defineProperty(exports, "ensureGitMinimumVersion", { enumerable: true, get: function () { return getRepoState_1.ensureGitMinimumVersion; } });
+//# sourceMappingURL=index.js.map