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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/33/URL_33382dd2bd04cfe3a63ad984d9d1495c

@@ -0,0 +1,197 @@
+849eac5a0d7fd731acf0948d18a9ef6c
+"use strict";
+
+const conversions = require("webidl-conversions");
+const utils = require("./utils.js");
+const Impl = require(".//URL-impl.js");
+
+const impl = utils.implSymbol;
+
+function URL(url) {
+  if (!this || this[impl] || !(this instanceof URL)) {
+    throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
+  }
+  if (arguments.length < 1) {
+    throw new TypeError("Failed to construct 'URL': 1 argument required, but only " + arguments.length + " present.");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 2; ++i) {
+    args[i] = arguments[i];
+  }
+  args[0] = conversions["USVString"](args[0]);
+  if (args[1] !== undefined) {
+  args[1] = conversions["USVString"](args[1]);
+  }
+
+  module.exports.setup(this, args);
+}
+
+URL.prototype.toJSON = function toJSON() {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  const args = [];
+  for (let i = 0; i < arguments.length && i < 0; ++i) {
+    args[i] = arguments[i];
+  }
+  return this[impl].toJSON.apply(this[impl], args);
+};
+Object.defineProperty(URL.prototype, "href", {
+  get() {
+    return this[impl].href;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].href = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+URL.prototype.toString = function () {
+  if (!this || !module.exports.is(this)) {
+    throw new TypeError("Illegal invocation");
+  }
+  return this.href;
+};
+
+Object.defineProperty(URL.prototype, "origin", {
+  get() {
+    return this[impl].origin;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "protocol", {
+  get() {
+    return this[impl].protocol;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].protocol = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "username", {
+  get() {
+    return this[impl].username;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].username = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "password", {
+  get() {
+    return this[impl].password;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].password = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "host", {
+  get() {
+    return this[impl].host;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].host = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "hostname", {
+  get() {
+    return this[impl].hostname;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].hostname = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "port", {
+  get() {
+    return this[impl].port;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].port = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "pathname", {
+  get() {
+    return this[impl].pathname;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].pathname = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "search", {
+  get() {
+    return this[impl].search;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].search = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+Object.defineProperty(URL.prototype, "hash", {
+  get() {
+    return this[impl].hash;
+  },
+  set(V) {
+    V = conversions["USVString"](V);
+    this[impl].hash = V;
+  },
+  enumerable: true,
+  configurable: true
+});
+
+
+module.exports = {
+  is(obj) {
+    return !!obj && obj[impl] instanceof Impl.implementation;
+  },
+  create(constructorArgs, privateData) {
+    let obj = Object.create(URL.prototype);
+    this.setup(obj, constructorArgs, privateData);
+    return obj;
+  },
+  setup(obj, constructorArgs, privateData) {
+    if (!privateData) privateData = {};
+    privateData.wrapper = obj;
+
+    obj[impl] = new Impl.implementation(constructorArgs, privateData);
+    obj[impl][utils.wrapperSymbol] = obj;
+  },
+  interface: URL,
+  expose: {
+    Window: { URL: URL },
+    Worker: { URL: URL }
+  }
+};
+

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/34/SyncHook_3450bad6af5c4ae6f675e42c4f3c8961

@@ -0,0 +1,47 @@
+07d1ddb6d4bb0c46f34d328edd0dc137
+/*
+	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 SyncHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncHookCodeFactory();
+
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncHook");
+};
+
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncHook");
+};
+
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function SyncHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
+
+SyncHook.prototype = null;
+
+module.exports = SyncHook;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/35/CommandLineHelper_35432de5b9e0472d8b4b0363144700a3

@@ -0,0 +1,23 @@
+b449d07e462ca506a8e85559ab967d35
+"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.CommandLineHelper = void 0;
+/**
+ * Helpers for working with the ts-command-line API.
+ *
+ * @public
+ */
+class CommandLineHelper {
+    /**
+     * Returns true if the current command line action is tab-complete.
+     *
+     * @public
+     */
+    static isTabCompletionActionRequest(argv) {
+        return argv && argv.length > 2 && argv[2] === "tab-complete" /* CommandLineConstants.TabCompletionActionName */;
+    }
+}
+exports.CommandLineHelper = CommandLineHelper;
+//# sourceMappingURL=CommandLineHelper.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/35/index_351599b17438e340506c874eb4c4d916

@@ -0,0 +1,70 @@
+05c87f01a5bfe72321888d75f680f44a
+'use strict';
+
+var has = require('has');
+
+function specifierIncluded(current, specifier) {
+	var nodeParts = current.split('.');
+	var parts = specifier.split(' ');
+	var op = parts.length > 1 ? parts[0] : '=';
+	var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split('.');
+
+	for (var i = 0; i < 3; ++i) {
+		var cur = parseInt(nodeParts[i] || 0, 10);
+		var ver = parseInt(versionParts[i] || 0, 10);
+		if (cur === ver) {
+			continue; // eslint-disable-line no-restricted-syntax, no-continue
+		}
+		if (op === '<') {
+			return cur < ver;
+		}
+		if (op === '>=') {
+			return cur >= ver;
+		}
+		return false;
+	}
+	return op === '>=';
+}
+
+function matchesRange(current, range) {
+	var specifiers = range.split(/ ?&& ?/);
+	if (specifiers.length === 0) {
+		return false;
+	}
+	for (var i = 0; i < specifiers.length; ++i) {
+		if (!specifierIncluded(current, specifiers[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function versionIncluded(nodeVersion, specifierValue) {
+	if (typeof specifierValue === 'boolean') {
+		return specifierValue;
+	}
+
+	var current = typeof nodeVersion === 'undefined'
+		? process.versions && process.versions.node
+		: nodeVersion;
+
+	if (typeof current !== 'string') {
+		throw new TypeError(typeof nodeVersion === 'undefined' ? 'Unable to determine current node version' : 'If provided, a valid node version is required');
+	}
+
+	if (specifierValue && typeof specifierValue === 'object') {
+		for (var i = 0; i < specifierValue.length; ++i) {
+			if (matchesRange(current, specifierValue[i])) {
+				return true;
+			}
+		}
+		return false;
+	}
+	return matchesRange(current, specifierValue);
+}
+
+var data = require('./core.json');
+
+module.exports = function isCore(x, nodeVersion) {
+	return has(data, x) && versionIncluded(nodeVersion, data[x]);
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/36/index_36c8f6d5633e9389ceab255fbf71ae18

@@ -0,0 +1,6 @@
+3cf1fca7a7d2c1aba4a508a38e31c344
+'use strict'
+
+module.exports = {
+  copySync: require('./copy-sync')
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/37/RemoveColorsTextRewriter_3774df1d77755492e62324174f09d9e9

@@ -0,0 +1,96 @@
+2a506240c9d33934c2f3fbeded1e7ddf
+"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.RemoveColorsTextRewriter = void 0;
+const node_core_library_1 = require("@rushstack/node-core-library");
+const TextRewriter_1 = require("./TextRewriter");
+var State;
+(function (State) {
+    // Buffer is empty, and we're looking for the ESC character
+    State[State["Start"] = 0] = "Start";
+    // We're looking for the '[' character
+    State[State["AwaitingBracket"] = 1] = "AwaitingBracket";
+    // We're reading the codes after the '[' character
+    State[State["ReadingCodes"] = 2] = "ReadingCodes";
+})(State || (State = {}));
+/**
+ * For use with {@link TextRewriterTransform}, this rewriter removes ANSI escape codes
+ * including colored text.
+ *
+ * @remarks
+ * The implementation also removes other ANSI escape codes such as cursor positioning.
+ * The specific set of affected codes may be adjusted in the future.
+ *
+ * @public
+ */
+class RemoveColorsTextRewriter extends TextRewriter_1.TextRewriter {
+    initialize() {
+        return { buffer: '', parseState: State.Start };
+    }
+    process(unknownState, text) {
+        const state = unknownState;
+        // We will be matching AnsiEscape._csiRegExp:
+        //
+        //  /\x1b\[([\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e])/gu
+        //
+        const ESC = '\x1b';
+        let result = '';
+        let index = 0;
+        while (index < text.length) {
+            if (state.parseState === State.Start) {
+                // The buffer is empty, which means we haven't found anything yet
+                const csiIndex = text.indexOf(ESC, index);
+                if (csiIndex < 0) {
+                    // We reached the end of "text" without finding another CSI prefix
+                    result += text.substring(index);
+                    break;
+                }
+                // Append everything up to the CSI prefix
+                result += text.substring(index, csiIndex);
+                // Save the partial match in the buffer
+                state.buffer = ESC;
+                index = csiIndex + 1;
+                state.parseState = State.AwaitingBracket;
+            }
+            else {
+                // The buffer has characters, which means we started matching a partial sequence
+                // Read another character into the buffer
+                const c = text[index];
+                ++index;
+                state.buffer += c;
+                if (state.parseState === State.AwaitingBracket) {
+                    if (c === '[') {
+                        state.parseState = State.ReadingCodes;
+                    }
+                    else {
+                        // Failed to match, so append the buffer and start over
+                        result += state.buffer;
+                        state.buffer = '';
+                        state.parseState = State.Start;
+                    }
+                }
+                else {
+                    // state.state === State.ReadingCodes
+                    // Stop when we reach any character that is not [\x30-\x3f] or [\x20-\x2f]
+                    const code = c.charCodeAt(0);
+                    if (code < 0x20 || code > 0x3f) {
+                        result += node_core_library_1.AnsiEscape.removeCodes(state.buffer);
+                        state.buffer = '';
+                        state.parseState = State.Start;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    close(unknownState) {
+        const state = unknownState;
+        const result = state.buffer;
+        state.buffer = '';
+        return result;
+    }
+}
+exports.RemoveColorsTextRewriter = RemoveColorsTextRewriter;
+//# sourceMappingURL=RemoveColorsTextRewriter.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/37/Sort_37dfd29dc09c27aacc04846107b87488

@@ -0,0 +1,213 @@
+6a375a0213b588bcf19baef215135052
+"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.Sort = void 0;
+/**
+ * Operations for sorting collections.
+ *
+ * @public
+ */
+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]
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static compareByValue(x, y) {
+        if (x === y) {
+            return 0;
+        }
+        // Undefined is smaller than anything else
+        if (x === undefined) {
+            return -1;
+        }
+        if (y === undefined) {
+            return 1;
+        }
+        // Null is smaller than anything except undefined
+        if (x === null) {
+            return -1;
+        }
+        if (y === null) {
+            return 1;
+        }
+        // These comparisons always return false if either of the arguments is "undefined".
+        // These comparisons return nonsense for "null" (true for "null > -1", but false for "null < 0" and "null > 0")
+        if (x < y) {
+            return -1;
+        }
+        if (x > y) {
+            return 1;
+        }
+        return 0;
+    }
+    /**
+     * 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(array, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    keySelector, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    comparer = Sort.compareByValue) {
+        array.sort((x, y) => comparer(keySelector(x), keySelector(y)));
+    }
+    /**
+     * Returns true if the collection is already sorted.
+     */
+    static isSorted(collection, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    comparer = Sort.compareByValue) {
+        let isFirst = true;
+        let previous = undefined;
+        for (const element of collection) {
+            if (isFirst) {
+                // Don't start by comparing against undefined.
+                isFirst = false;
+            }
+            else if (comparer(previous, element) > 0) {
+                return false;
+            }
+            previous = element;
+        }
+        return true;
+    }
+    /**
+     * 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(collection, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    keySelector, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    comparer = Sort.compareByValue) {
+        let isFirst = true;
+        let previousKey = undefined;
+        for (const element of collection) {
+            const key = keySelector(element);
+            if (isFirst) {
+                // Don't start by comparing against undefined.
+                isFirst = false;
+            }
+            else if (comparer(previousKey, key) > 0) {
+                return false;
+            }
+            previousKey = key;
+        }
+        return true;
+    }
+    /**
+     * 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"]
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static sortMapKeys(map, keyComparer = Sort.compareByValue) {
+        // Sorting a map is expensive, so first check whether it's already sorted.
+        if (Sort.isSorted(map.keys(), keyComparer)) {
+            return;
+        }
+        const pairs = Array.from(map.entries());
+        Sort.sortBy(pairs, (x) => x[0], keyComparer);
+        map.clear();
+        for (const pair of pairs) {
+            map.set(pair[0], pair[1]);
+        }
+    }
+    /**
+     * 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(set, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    keySelector, keyComparer = Sort.compareByValue) {
+        // Sorting a set is expensive, so first check whether it's already sorted.
+        if (Sort.isSortedBy(set, keySelector, keyComparer)) {
+            return;
+        }
+        const array = Array.from(set);
+        array.sort((x, y) => keyComparer(keySelector(x), keySelector(y)));
+        set.clear();
+        for (const item of array) {
+            set.add(item);
+        }
+    }
+    /**
+     * 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']
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static sortSet(set, comparer = Sort.compareByValue) {
+        // Sorting a set is expensive, so first check whether it's already sorted.
+        if (Sort.isSorted(set, comparer)) {
+            return;
+        }
+        const array = Array.from(set);
+        array.sort((x, y) => comparer(x, y));
+        set.clear();
+        for (const item of array) {
+            set.add(item);
+        }
+    }
+}
+exports.Sort = Sort;
+//# sourceMappingURL=Sort.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/37/index_37474d53f1aec6000961e1f22d1c83ad

@@ -0,0 +1,24 @@
+68e93d6534353e9665f5d954de79edb2
+'use strict'
+
+const file = require('./file')
+const link = require('./link')
+const symlink = require('./symlink')
+
+module.exports = {
+  // file
+  createFile: file.createFile,
+  createFileSync: file.createFileSync,
+  ensureFile: file.createFile,
+  ensureFileSync: file.createFileSync,
+  // link
+  createLink: link.createLink,
+  createLinkSync: link.createLinkSync,
+  ensureLink: link.createLink,
+  ensureLinkSync: link.createLinkSync,
+  // symlink
+  createSymlink: symlink.createSymlink,
+  createSymlinkSync: symlink.createSymlinkSync,
+  ensureSymlink: symlink.createSymlink,
+  ensureSymlinkSync: symlink.createSymlinkSync
+}