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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5d/rsort_5d475d23748e66c70f21cab766127fe8

@@ -0,0 +1,4 @@
+1e99dcf8aa9518558b2a6945302273ac
+const compareBuild = require('./compare-build')
+const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
+module.exports = rsort

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5e/index_5e83cfb096cb71c3c3b5071c51c76352

@@ -0,0 +1,29 @@
+870c3b855b53846077900e0f5167c6b4
+'use strict'
+
+module.exports = Object.assign(
+  {},
+  // Export promiseified graceful-fs:
+  require('./fs'),
+  // Export extra methods:
+  require('./copy-sync'),
+  require('./copy'),
+  require('./empty'),
+  require('./ensure'),
+  require('./json'),
+  require('./mkdirs'),
+  require('./move-sync'),
+  require('./move'),
+  require('./output'),
+  require('./path-exists'),
+  require('./remove')
+)
+
+// Export fs.promises as a getter property so that we don't trigger
+// ExperimentalWarning before fs.promises is actually accessed.
+const fs = require('fs')
+if (Object.getOwnPropertyDescriptor(fs, 'promises')) {
+  Object.defineProperty(module.exports, 'promises', {
+    get () { return fs.promises }
+  })
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/5f/major_5f17be93c674dbdf30dc56dca1ceeb61

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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/60/iterator_605cedebcb174a610571f444f3e35cb9

@@ -0,0 +1,9 @@
+357867d11a5f3f9a52d44300e107ef4b
+'use strict'
+module.exports = function (Yallist) {
+  Yallist.prototype[Symbol.iterator] = function* () {
+    for (let walker = this.head; walker; walker = walker.next) {
+      yield walker.value
+    }
+  }
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/61/index_61b111e1602c823e36866ed58bfa5c02

@@ -0,0 +1,225 @@
+16e4157ef75b25b0c4d6f71d264af7ea
+"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 _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._rushSdk_loadInternalModule = void 0;
+const path = __importStar(require("path"));
+const node_core_library_1 = require("@rushstack/node-core-library");
+const RUSH_LIB_NAME = '@microsoft/rush-lib';
+const RUSH_LIB_PATH_ENV_VAR_NAME = '_RUSH_LIB_PATH';
+const verboseEnabled = typeof process !== 'undefined' && process.env.RUSH_SDK_DEBUG === '1';
+const terminal = new node_core_library_1.Terminal(new node_core_library_1.ConsoleTerminalProvider({
+    verboseEnabled
+}));
+function _require(moduleName) {
+    if (typeof __non_webpack_require__ === 'function') {
+        // If this library has been bundled with Webpack, we need to call the real `require` function
+        // that doesn't get turned into a `__webpack_require__` statement.
+        // `__non_webpack_require__` is a Webpack macro that gets turned into a `require` statement
+        // during bundling.
+        return __non_webpack_require__(moduleName);
+    }
+    else {
+        return require(moduleName);
+    }
+}
+// SCENARIO 1:  Rush's PluginManager has initialized "rush-sdk" with Rush's own instance of rush-lib.
+// The Rush host process will assign "global.___rush___rushLibModule" before loading the plugin.
+let rushLibModule = global.___rush___rushLibModule ||
+    global.___rush___rushLibModuleFromEnvironment ||
+    global.___rush___rushLibModuleFromInstallAndRunRush;
+let errorMessage = '';
+// SCENARIO 2:  The project importing "rush-sdk" has installed its own instance of "rush-lib"
+// as a package.json dependency.  For example, this is used by the Jest tests for Rush plugins.
+if (rushLibModule === undefined) {
+    const importingPath = (_a = module === null || module === void 0 ? void 0 : module.parent) === null || _a === void 0 ? void 0 : _a.filename;
+    if (importingPath) {
+        const callerPackageFolder = node_core_library_1.PackageJsonLookup.instance.tryGetPackageFolderFor(importingPath);
+        if (callerPackageFolder !== undefined) {
+            const callerPackageJson = _require(path.join(callerPackageFolder, 'package.json'));
+            // Does the caller properly declare a dependency on rush-lib?
+            if ((callerPackageJson.dependencies && callerPackageJson.dependencies[RUSH_LIB_NAME] !== undefined) ||
+                (callerPackageJson.devDependencies &&
+                    callerPackageJson.devDependencies[RUSH_LIB_NAME] !== undefined) ||
+                (callerPackageJson.peerDependencies &&
+                    callerPackageJson.peerDependencies[RUSH_LIB_NAME] !== undefined)) {
+                // Try to resolve rush-lib from the caller's folder
+                terminal.writeVerboseLine(`Try to load ${RUSH_LIB_NAME} from caller package`);
+                try {
+                    rushLibModule = requireRushLibUnderFolderPath(callerPackageFolder);
+                }
+                catch (error) {
+                    // If we fail to resolve it, ignore the error
+                    terminal.writeVerboseLine(`Failed to load ${RUSH_LIB_NAME} from caller package`);
+                }
+                // If two different libraries invoke `rush-sdk`, and one of them provides "rush-lib"
+                // then the first version to be loaded wins.  We do not support side-by-side instances of "rush-lib".
+                if (rushLibModule !== undefined) {
+                    // to track which scenario is active and how it got initialized.
+                    global.___rush___rushLibModule = rushLibModule;
+                    terminal.writeVerboseLine(`Loaded ${RUSH_LIB_NAME} from caller`);
+                }
+            }
+        }
+    }
+}
+// SCENARIO 3: A tool or script has been invoked as a child process by an instance of "rush-lib" and can use the
+// version that invoked it. In this case, use process.env._RUSH_LIB_PATH to find "rush-lib".
+if (rushLibModule === undefined) {
+    const rushLibPath = process.env[RUSH_LIB_PATH_ENV_VAR_NAME];
+    if (rushLibPath) {
+        terminal.writeVerboseLine(`Try to load ${RUSH_LIB_NAME} from process.env.${RUSH_LIB_PATH_ENV_VAR_NAME} from caller package`);
+        try {
+            rushLibModule = _require(rushLibPath);
+        }
+        catch (error) {
+            // Log this as a warning, since it is unexpected to define an incorrect value of the variable.
+            terminal.writeWarningLine(`Failed to load ${RUSH_LIB_NAME} via process.env.${RUSH_LIB_PATH_ENV_VAR_NAME}`);
+        }
+        if (rushLibModule !== undefined) {
+            // to track which scenario is active and how it got initialized.
+            global.___rush___rushLibModuleFromEnvironment = rushLibModule;
+            terminal.writeVerboseLine(`Loaded ${RUSH_LIB_NAME} from process.env.${RUSH_LIB_PATH_ENV_VAR_NAME}`);
+        }
+    }
+}
+// SCENARIO 4:  A standalone tool or script depends on "rush-sdk", and is meant to be used inside a monorepo folder.
+// In this case, we can use install-run-rush.js to obtain the appropriate rush-lib version for the monorepo.
+if (rushLibModule === undefined) {
+    try {
+        const rushJsonPath = tryFindRushJsonLocation(process.cwd());
+        if (!rushJsonPath) {
+            throw new Error('Unable to find rush.json in the current folder or its parent folders.\n' +
+                'This tool is meant to be invoked from a working directory inside a Rush repository.');
+        }
+        const monorepoRoot = path.dirname(rushJsonPath);
+        const rushJson = node_core_library_1.JsonFile.load(rushJsonPath);
+        const { rushVersion } = rushJson;
+        const installRunNodeModuleFolder = path.join(monorepoRoot, `common/temp/install-run/@microsoft+rush@${rushVersion}`);
+        try {
+            // First, try to load the version of "rush-lib" that was installed by install-run-rush.js
+            terminal.writeVerboseLine(`Trying to load  ${RUSH_LIB_NAME} installed by install-run-rush`);
+            rushLibModule = requireRushLibUnderFolderPath(installRunNodeModuleFolder);
+        }
+        catch (e) {
+            let installAndRunRushStderrContent = '';
+            try {
+                const installAndRunRushJSPath = path.join(monorepoRoot, 'common/scripts/install-run-rush.js');
+                terminal.writeLine('The Rush engine has not been installed yet. Invoking install-run-rush.js...');
+                const installAndRuhRushProcess = node_core_library_1.Executable.spawnSync('node', [installAndRunRushJSPath, '--help'], {
+                    stdio: 'pipe'
+                });
+                installAndRunRushStderrContent = installAndRuhRushProcess.stderr;
+                if (installAndRuhRushProcess.status !== 0) {
+                    throw new Error(`The ${RUSH_LIB_NAME} package failed to install`);
+                }
+                // Retry to load "rush-lib" after install-run-rush run
+                terminal.writeVerboseLine(`Trying to load  ${RUSH_LIB_NAME} installed by install-run-rush a second time`);
+                rushLibModule = requireRushLibUnderFolderPath(installRunNodeModuleFolder);
+            }
+            catch (e) {
+                console.error(`${installAndRunRushStderrContent}`);
+                throw new Error(`The ${RUSH_LIB_NAME} package failed to load`);
+            }
+        }
+        if (rushLibModule !== undefined) {
+            // to track which scenario is active and how it got initialized.
+            global.___rush___rushLibModuleFromInstallAndRunRush = rushLibModule;
+            terminal.writeVerboseLine(`Loaded ${RUSH_LIB_NAME} installed by install-run-rush`);
+        }
+    }
+    catch (e) {
+        // no-catch
+        errorMessage = e.message;
+    }
+}
+if (rushLibModule === undefined) {
+    // This error indicates that a project is trying to import "@rushstack/rush-sdk", but the Rush engine
+    // instance cannot be found.  If you are writing Jest tests for a Rush plugin, add "@microsoft/rush-lib"
+    // to the devDependencies for your project.
+    console.error(`Error: The @rushstack/rush-sdk package was not able to load the Rush engine:
+${errorMessage}
+`);
+    process.exit(1);
+}
+// Based on TypeScript's __exportStar()
+for (const property in rushLibModule) {
+    if (property !== 'default' && !exports.hasOwnProperty(property)) {
+        const rushLibModuleForClosure = rushLibModule;
+        // Based on TypeScript's __createBinding()
+        Object.defineProperty(exports, property, {
+            enumerable: true,
+            get: function () {
+                return rushLibModuleForClosure[property];
+            }
+        });
+    }
+}
+/**
+ * Used by the .js stubs for path-based imports of `@microsoft/rush-lib` internal APIs.
+ */
+function _rushSdk_loadInternalModule(srcImportPath) {
+    if (!exports._RushInternals) {
+        throw new Error(`Rush version ${exports.Rush.version} does not support internal API imports via rush-sdk`);
+    }
+    return exports._RushInternals.loadModule(srcImportPath);
+}
+exports._rushSdk_loadInternalModule = _rushSdk_loadInternalModule;
+/**
+ * Require `@microsoft/rush-lib` under the specified folder path.
+ */
+function requireRushLibUnderFolderPath(folderPath) {
+    const rushLibModulePath = node_core_library_1.Import.resolveModule({
+        modulePath: RUSH_LIB_NAME,
+        baseFolderPath: folderPath
+    });
+    return _require(rushLibModulePath);
+}
+/**
+ * Find the rush.json location and return the path, or undefined if a rush.json can't be found.
+ *
+ * @privateRemarks
+ * Keep this in sync with `RushConfiguration.tryFindRushJsonLocation`.
+ */
+function tryFindRushJsonLocation(startingFolder) {
+    let currentFolder = startingFolder;
+    // Look upwards at parent folders until we find a folder containing rush.json
+    for (let i = 0; i < 10; ++i) {
+        const rushJsonFilename = path.join(currentFolder, 'rush.json');
+        if (node_core_library_1.FileSystem.exists(rushJsonFilename)) {
+            return rushJsonFilename;
+        }
+        const parentFolder = path.dirname(currentFolder);
+        if (parentFolder === currentFolder) {
+            break;
+        }
+        currentFolder = parentFolder;
+    }
+    return undefined;
+}
+//# sourceMappingURL=index.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/62/package_62ad16cf4b73e547a38b9be0e0826b2e

@@ -0,0 +1,37 @@
+da6c8ab891640eac17325dd71cd2e216
+{
+  "name": "@rushstack/rush-http-build-cache-plugin",
+  "version": "5.92.0",
+  "description": "Rush plugin for generic HTTP cloud build cache",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/rushstack",
+    "directory": "rush-plugins/rush-http-build-cache-plugin"
+  },
+  "homepage": "https://rushjs.io",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "heft build --clean",
+    "start": "heft test --clean --watch",
+    "test": "heft test",
+    "_phase:build": "heft build --clean",
+    "_phase:test": "heft test --no-build"
+  },
+  "dependencies": {
+    "@rushstack/node-core-library": "workspace:*",
+    "@rushstack/rush-sdk": "workspace:*",
+    "https-proxy-agent": "~5.0.0",
+    "node-fetch": "2.6.7"
+  },
+  "devDependencies": {
+    "@microsoft/rush-lib": "workspace:*",
+    "@rushstack/eslint-config": "workspace:*",
+    "@rushstack/heft": "workspace:*",
+    "@rushstack/heft-node-rig": "workspace:*",
+    "@types/heft-jest": "1.0.1",
+    "@types/node": "14.18.36",
+    "@types/node-fetch": "2.6.2"
+  }
+}