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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a5/SyncBailHook_a52e9aaf0f808558574466e14a2f4c20

@@ -0,0 +1,52 @@
+563b47455360a108f14fdf6524dd91ad
+/*
+	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 SyncBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) =>
+				`if(${result} !== undefined) {\n${onResult(
+					result
+				)};\n} else {\n${next()}}\n`,
+			resultReturns,
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncBailHookCodeFactory();
+
+const TAP_ASYNC = () => {
+	throw new Error("tapAsync is not supported on a SyncBailHook");
+};
+
+const TAP_PROMISE = () => {
+	throw new Error("tapPromise is not supported on a SyncBailHook");
+};
+
+const COMPILE = function(options) {
+	factory.setup(this, options);
+	return factory.create(options);
+};
+
+function SyncBailHook(args = [], name = undefined) {
+	const hook = new Hook(args, name);
+	hook.constructor = SyncBailHook;
+	hook.tapAsync = TAP_ASYNC;
+	hook.tapPromise = TAP_PROMISE;
+	hook.compile = COMPILE;
+	return hook;
+}
+
+SyncBailHook.prototype = null;
+
+module.exports = SyncBailHook;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a6/hasflag_a64b2cc5845c94a8a4ff212a6480c528

@@ -0,0 +1,36 @@
+414ff6fe54234eeb07a52887bcc462dd
+/*
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+'use strict';
+
+module.exports = function(flag, argv) {
+  argv = argv || process.argv;
+
+  var terminatorPos = argv.indexOf('--');
+  var prefix = /^-{1,2}/.test(flag) ? '' : '--';
+  var pos = argv.indexOf(prefix + flag);
+
+  return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a7/MockWritable_a745bd72731e0b51f6097d118713aa9d

@@ -0,0 +1,33 @@
+ef495d9a0cdd6457dafb2a937ab8459c
+"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.MockWritable = void 0;
+const TerminalWritable_1 = require("./TerminalWritable");
+const node_core_library_1 = require("@rushstack/node-core-library");
+/**
+ * A {@link TerminalWritable} subclass for use by unit tests.
+ *
+ * @beta
+ */
+class MockWritable extends TerminalWritable_1.TerminalWritable {
+    constructor() {
+        super(...arguments);
+        this.chunks = [];
+    }
+    onWriteChunk(chunk) {
+        this.chunks.push(chunk);
+    }
+    reset() {
+        this.chunks.length = 0;
+    }
+    getAllOutput() {
+        return node_core_library_1.AnsiEscape.formatForTests(this.chunks.map((x) => x.text).join(''));
+    }
+    getFormattedChunks() {
+        return this.chunks.map((x) => (Object.assign(Object.assign({}, x), { text: node_core_library_1.AnsiEscape.formatForTests(x.text) })));
+    }
+}
+exports.MockWritable = MockWritable;
+//# sourceMappingURL=MockWritable.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a7/TerminalTransform_a791046363f27a01a21b28a5fc18e159

@@ -0,0 +1,58 @@
+87200454d09adad668e67faad34751e0
+"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.TerminalTransform = void 0;
+const TerminalWritable_1 = require("./TerminalWritable");
+/**
+ * The abstract base class for {@link TerminalWritable} objects that receive an input,
+ * transform it somehow, and then write the output to another `TerminalWritable`.
+ *
+ * @remarks
+ *
+ * The `TerminalTransform` and {@link SplitterTransform} base classes formalize the idea
+ * of modeling data flow as a directed acyclic graph of reusable transforms, whose
+ * final outputs are `TerminalWritable` objects.
+ *
+ * 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.
+ *
+ * The main feature of the `TerminalTransform` class is its {@link TerminalTransform.destination}
+ * property, which tracks the next link in the graph.
+ *
+ * @public
+ */
+class TerminalTransform extends TerminalWritable_1.TerminalWritable {
+    constructor(options) {
+        super();
+        this.destination = options.destination;
+        this.preventDestinationAutoclose = !!options.preventDestinationAutoclose;
+    }
+    /** @override */
+    onClose() {
+        this.autocloseDestination();
+    }
+    /**
+     * The default implementation of {@link TerminalTransform.onClose} calls this
+     * method, which closes the {@link TerminalTransform.destination} if appropriate.
+     *
+     * @remarks
+     * The destination will not be closed if its {@link TerminalWritable.preventAutoclose}
+     * property is `true`.  The destination will not be closed if
+     * {@link ITerminalTransformOptions.preventDestinationAutoclose}
+     * is `true`.
+     *
+     * @sealed
+     */
+    autocloseDestination() {
+        if (!this.preventDestinationAutoclose && !this.destination.preventAutoclose) {
+            this.destination.close();
+        }
+    }
+}
+exports.TerminalTransform = TerminalTransform;
+//# sourceMappingURL=TerminalTransform.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a7/gtr_a7c6cf87054408dfaa332053e93e500f

@@ -0,0 +1,5 @@
+4f69fb02e28923fe7126531d80862dc8
+// Determine if version is greater than all the versions possible in the range.
+const outside = require('./outside')
+const gtr = (version, range, options) => outside(version, range, '>', options)
+module.exports = gtr

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a7/simplify_a7134847013b1ea2f9417ee16c03824b

@@ -0,0 +1,48 @@
+bc651999d477c5698289adcd2ed8773c
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+module.exports = (versions, range, options) => {
+  const set = []
+  let first = null
+  let prev = null
+  const v = versions.sort((a, b) => compare(a, b, options))
+  for (const version of v) {
+    const included = satisfies(version, range, options)
+    if (included) {
+      prev = version
+      if (!first) {
+        first = version
+      }
+    } else {
+      if (prev) {
+        set.push([first, prev])
+      }
+      prev = null
+      first = null
+    }
+  }
+  if (first) {
+    set.push([first, null])
+  }
+
+  const ranges = []
+  for (const [min, max] of set) {
+    if (min === max) {
+      ranges.push(min)
+    } else if (!max && min === v[0]) {
+      ranges.push('*')
+    } else if (!max) {
+      ranges.push(`>=${min}`)
+    } else if (min === v[0]) {
+      ranges.push(`<=${max}`)
+    } else {
+      ranges.push(`${min} - ${max}`)
+    }
+  }
+  const simplified = ranges.join(' || ')
+  const original = typeof range.raw === 'string' ? range.raw : String(range)
+  return simplified.length < original.length ? simplified : range
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a8/CommandLineAction_a8253bed5d1978bb6a92066326e38357

@@ -0,0 +1,77 @@
+7478ae389f5ee8bce30dd0cafa78c697
+"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.CommandLineAction = void 0;
+const CommandLineParameterProvider_1 = require("./CommandLineParameterProvider");
+/**
+ * Example: "do-something"
+ */
+const ACTION_NAME_REGEXP = /^[a-z][a-z0-9]*([-:][a-z0-9]+)*$/;
+/**
+ * Represents a sub-command that is part of the CommandLineParser command line.
+ * Applications should create subclasses of CommandLineAction corresponding to
+ * each action that they want to expose.
+ *
+ * The action name should be comprised of lower case words separated by hyphens
+ * or colons. The name should include an English verb (e.g. "deploy"). Use a
+ * hyphen to separate words (e.g. "upload-docs"). A group of related commands
+ * can be prefixed with a colon (e.g. "docs:generate", "docs:deploy",
+ * "docs:serve", etc).
+ *
+ * @public
+ */
+class CommandLineAction extends CommandLineParameterProvider_1.CommandLineParameterProvider {
+    constructor(options) {
+        super();
+        if (!ACTION_NAME_REGEXP.test(options.actionName)) {
+            throw new Error(`Invalid action name "${options.actionName}". ` +
+                `The name must be comprised of lower-case words optionally separated by hyphens or colons.`);
+        }
+        this.actionName = options.actionName;
+        this.summary = options.summary;
+        this.documentation = options.documentation;
+        this._argumentParser = undefined;
+    }
+    /**
+     * This is called internally by CommandLineParser.addAction()
+     * @internal
+     */
+    _buildParser(actionsSubParser) {
+        var _a;
+        this._argumentParser = actionsSubParser.addParser(this.actionName, {
+            help: this.summary,
+            description: this.documentation
+        });
+        (_a = this.onDefineParameters) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    /**
+     * This is called internally by CommandLineParser.execute()
+     * @internal
+     */
+    _processParsedData(parserOptions, data) {
+        super._processParsedData(parserOptions, data);
+    }
+    /**
+     * Invoked by CommandLineParser.onExecute().
+     * @internal
+     */
+    _execute() {
+        return this.onExecute();
+    }
+    /**
+     * {@inheritDoc CommandLineParameterProvider._getArgumentParser}
+     * @internal
+     */
+    _getArgumentParser() {
+        // override
+        if (!this._argumentParser) {
+            // We will improve this in the future
+            throw new Error('The CommandLineAction must be added to a CommandLineParser before it can be used');
+        }
+        return this._argumentParser;
+    }
+}
+exports.CommandLineAction = CommandLineAction;
+//# sourceMappingURL=CommandLineAction.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/ac/NormalizeNewlinesTextRewriter_ac3af2a268ce9d6922f1294a58da6c4a

@@ -0,0 +1,71 @@
+7452c68c04cfddae24d9d6c4be397a6c
+"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.NormalizeNewlinesTextRewriter = void 0;
+const node_core_library_1 = require("@rushstack/node-core-library");
+const TextRewriter_1 = require("./TextRewriter");
+/**
+ * For use with {@link TextRewriterTransform}, this rewriter converts all newlines to
+ * a standard format.
+ *
+ * @public
+ */
+class NormalizeNewlinesTextRewriter extends TextRewriter_1.TextRewriter {
+    constructor(options) {
+        super();
+        this.newlineKind = options.newlineKind;
+        this.newline = node_core_library_1.Text.getNewline(options.newlineKind);
+        this.ensureNewlineAtEnd = !!options.ensureNewlineAtEnd;
+    }
+    initialize() {
+        return {
+            characterToIgnore: '',
+            incompleteLine: false
+        };
+    }
+    process(unknownState, text) {
+        const state = unknownState;
+        let result = '';
+        if (text.length > 0) {
+            let i = 0;
+            do {
+                const c = text[i];
+                ++i;
+                if (c === state.characterToIgnore) {
+                    state.characterToIgnore = '';
+                }
+                else if (c === '\r') {
+                    result += this.newline;
+                    state.characterToIgnore = '\n';
+                    state.incompleteLine = false;
+                }
+                else if (c === '\n') {
+                    result += this.newline;
+                    state.characterToIgnore = '\r';
+                    state.incompleteLine = false;
+                }
+                else {
+                    result += c;
+                    state.characterToIgnore = '';
+                    state.incompleteLine = true;
+                }
+            } while (i < text.length);
+        }
+        return result;
+    }
+    close(unknownState) {
+        const state = unknownState;
+        state.characterToIgnore = '';
+        if (state.incompleteLine) {
+            state.incompleteLine = false;
+            return this.newline;
+        }
+        else {
+            return '';
+        }
+    }
+}
+exports.NormalizeNewlinesTextRewriter = NormalizeNewlinesTextRewriter;
+//# sourceMappingURL=NormalizeNewlinesTextRewriter.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/b2/extendStringPrototype_b2f9a6c1379034ad868c5f667877fadc

@@ -0,0 +1,107 @@
+f1ca7e20c664e761baceabe2b520defc
+var colors = require('./colors');
+
+module['exports'] = function() {
+  //
+  // Extends prototype of native string object to allow for "foo".red syntax
+  //
+  var addProperty = function(color, func) {
+    String.prototype.__defineGetter__(color, func);
+  };
+
+  addProperty('strip', function() {
+    return colors.strip(this);
+  });
+
+  addProperty('stripColors', function() {
+    return colors.strip(this);
+  });
+
+  addProperty('trap', function() {
+    return colors.trap(this);
+  });
+
+  addProperty('zalgo', function() {
+    return colors.zalgo(this);
+  });
+
+  addProperty('zebra', function() {
+    return colors.zebra(this);
+  });
+
+  addProperty('rainbow', function() {
+    return colors.rainbow(this);
+  });
+
+  addProperty('random', function() {
+    return colors.random(this);
+  });
+
+  addProperty('america', function() {
+    return colors.america(this);
+  });
+
+  //
+  // Iterate through all default styles and colors
+  //
+  var x = Object.keys(colors.styles);
+  x.forEach(function(style) {
+    addProperty(style, function() {
+      return colors.stylize(this, style);
+    });
+  });
+
+  function applyTheme(theme) {
+    //
+    // Remark: This is a list of methods that exist
+    // on String that you should not overwrite.
+    //
+    var stringPrototypeBlacklist = [
+      '__defineGetter__', '__defineSetter__', '__lookupGetter__',
+      '__lookupSetter__', 'charAt', 'constructor', 'hasOwnProperty',
+      'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString',
+      'valueOf', 'charCodeAt', 'indexOf', 'lastIndexOf', 'length',
+      'localeCompare', 'match', 'repeat', 'replace', 'search', 'slice',
+      'split', 'substring', 'toLocaleLowerCase', 'toLocaleUpperCase',
+      'toLowerCase', 'toUpperCase', 'trim', 'trimLeft', 'trimRight',
+    ];
+
+    Object.keys(theme).forEach(function(prop) {
+      if (stringPrototypeBlacklist.indexOf(prop) !== -1) {
+        console.log('warn: '.red + ('String.prototype' + prop).magenta +
+          ' is probably something you don\'t want to override.  ' +
+          'Ignoring style name');
+      } else {
+        if (typeof(theme[prop]) === 'string') {
+          colors[prop] = colors[theme[prop]];
+          addProperty(prop, function() {
+            return colors[theme[prop]](this);
+          });
+        } else {
+          addProperty(prop, function() {
+            var ret = this;
+            for (var t = 0; t < theme[prop].length; t++) {
+              ret = colors[theme[prop][t]](ret);
+            }
+            return ret;
+          });
+        }
+      }
+    });
+  }
+
+  colors.setTheme = function(theme) {
+    if (typeof theme === 'string') {
+      try {
+        colors.themes[theme] = require(theme);
+        applyTheme(colors.themes[theme]);
+        return colors.themes[theme];
+      } catch (err) {
+        console.log(err);
+        return err;
+      }
+    } else {
+      applyTheme(theme);
+    }
+  };
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/b4/namespace_b4914dcf7fc2fb8f7f972c13b48f6645

@@ -0,0 +1,77 @@
+bafd49e54122c7da05f0458457878bda
+/**
+ * class Namespace
+ *
+ * Simple object for storing attributes. Implements equality by attribute names
+ * and values, and provides a simple string representation.
+ *
+ * See also [original guide][1]
+ *
+ * [1]:http://docs.python.org/dev/library/argparse.html#the-namespace-object
+ **/
+'use strict';
+
+var $$ = require('./utils');
+
+/**
+ * new Namespace(options)
+ * - options(object): predefined propertis for result object
+ *
+ **/
+var Namespace = module.exports = function Namespace(options) {
+  $$.extend(this, options);
+};
+
+/**
+ * Namespace#isset(key) -> Boolean
+ * - key (string|number): property name
+ *
+ * Tells whenever `namespace` contains given `key` or not.
+ **/
+Namespace.prototype.isset = function (key) {
+  return $$.has(this, key);
+};
+
+/**
+ * Namespace#set(key, value) -> self
+ * -key (string|number|object): propery name
+ * -value (mixed): new property value
+ *
+ * Set the property named key with value.
+ * If key object then set all key properties to namespace object
+ **/
+Namespace.prototype.set = function (key, value) {
+  if (typeof (key) === 'object') {
+    $$.extend(this, key);
+  } else {
+    this[key] = value;
+  }
+  return this;
+};
+
+/**
+ * Namespace#get(key, defaultValue) -> mixed
+ * - key (string|number): property name
+ * - defaultValue (mixed): default value
+ *
+ * Return the property key or defaulValue if not set
+ **/
+Namespace.prototype.get = function (key, defaultValue) {
+  return !this[key] ? defaultValue : this[key];
+};
+
+/**
+ * Namespace#unset(key, defaultValue) -> mixed
+ * - key (string|number): property name
+ * - defaultValue (mixed): default value
+ *
+ * Return data[key](and delete it) or defaultValue
+ **/
+Namespace.prototype.unset = function (key, defaultValue) {
+  var value = this[key];
+  if (value !== null) {
+    delete this[key];
+    return value;
+  }
+  return defaultValue;
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/b5/constant_b5b769be9acb440042a7957665debf5a

@@ -0,0 +1,44 @@
+7ce2e16789498e50b65363d0d8fc4efc
+/*:nodoc:*
+ * class ActionStoreConstant
+ *
+ * This action stores the value specified by the const keyword argument.
+ * (Note that the const keyword argument defaults to the rather unhelpful null.)
+ * The 'store_const' action is most commonly used with optional
+ * arguments that specify some sort of flag.
+ *
+ * This class inherited from [[Action]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var Action = require('../../action');
+
+/*:nodoc:*
+ * new ActionStoreConstant(options)
+ * - options (object): options hash see [[Action.new]]
+ *
+ **/
+var ActionStoreConstant = module.exports = function ActionStoreConstant(options) {
+  options = options || {};
+  options.nargs = 0;
+  if (typeof options.constant === 'undefined') {
+    throw new Error('constant option is required for storeAction');
+  }
+  Action.call(this, options);
+};
+util.inherits(ActionStoreConstant, Action);
+
+/*:nodoc:*
+ * ActionStoreConstant#call(parser, namespace, values, optionString) -> Void
+ * - parser (ArgumentParser): current parser
+ * - namespace (Namespace): namespace for output data
+ * - values (Array): parsed values
+ * - optionString (Array): input option string(not parsed)
+ *
+ * Call the action. Save result in namespace object
+ **/
+ActionStoreConstant.prototype.call = function (parser, namespace) {
+  namespace.set(this.dest, this.constant);
+};