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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/99/constants_993db3d18bc6186d69bd3869e6686734

@@ -0,0 +1,18 @@
+358a9f931d3c049231e6c1888b2b650d
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0'
+
+const MAX_LENGTH = 256
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+/* istanbul ignore next */ 9007199254740991
+
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16
+
+module.exports = {
+  SEMVER_SPEC_VERSION,
+  MAX_LENGTH,
+  MAX_SAFE_INTEGER,
+  MAX_SAFE_COMPONENT_LENGTH,
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/9a/index_9afc29e15688c6855cbfd3494af0f8e6

@@ -0,0 +1,45 @@
+4aafdc1060ad700c013432df55dbdbba
+"use strict";
+exports.__esModule = true;
+function parseArgsStringToArgv(value, env, file) {
+    // ([^\s'"]([^\s'"]*(['"])([^\3]*?)\3)+[^\s'"]*) Matches nested quotes until the first space outside of quotes
+    // [^\s'"]+ or Match if not a space ' or "
+    // (['"])([^\5]*?)\5 or Match "quoted text" without quotes
+    // `\3` and `\5` are a backreference to the quote style (' or ") captured
+    var myRegexp = /([^\s'"]([^\s'"]*(['"])([^\3]*?)\3)+[^\s'"]*)|[^\s'"]+|(['"])([^\5]*?)\5/gi;
+    var myString = value;
+    var myArray = [];
+    if (env) {
+        myArray.push(env);
+    }
+    if (file) {
+        myArray.push(file);
+    }
+    var match;
+    do {
+        // Each call to exec returns the next regex match as an array
+        match = myRegexp.exec(myString);
+        if (match !== null) {
+            // Index 1 in the array is the captured group if it exists
+            // Index 0 is the matched text, which we use if no captured group exists
+            myArray.push(firstString(match[1], match[6], match[0]));
+        }
+    } while (match !== null);
+    return myArray;
+}
+exports["default"] = parseArgsStringToArgv;
+exports.parseArgsStringToArgv = parseArgsStringToArgv;
+// Accepts any number of arguments, and returns the first one that is a string
+// (even an empty string)
+function firstString() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        if (typeof arg === "string") {
+            return arg;
+        }
+    }
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/9b/const_9b7421e189c528d99006e6fe10ec68d0

@@ -0,0 +1,22 @@
+77bdd566a871b894895aae626a4a5baa
+//
+// Constants
+//
+
+'use strict';
+
+module.exports.EOL = '\n';
+
+module.exports.SUPPRESS = '==SUPPRESS==';
+
+module.exports.OPTIONAL = '?';
+
+module.exports.ZERO_OR_MORE = '*';
+
+module.exports.ONE_OR_MORE = '+';
+
+module.exports.PARSER = 'A...';
+
+module.exports.REMAINDER = '...';
+
+module.exports._UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args';

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/9c/argparse_9c97ed9dfc279c7cfbd90530b5e22ca0

@@ -0,0 +1,15 @@
+8c53af72750678f55eaabc57d5e26056
+'use strict';
+
+module.exports.ArgumentParser = require('./argument_parser.js');
+module.exports.Namespace = require('./namespace');
+module.exports.Action = require('./action');
+module.exports.HelpFormatter = require('./help/formatter.js');
+module.exports.Const = require('./const.js');
+
+module.exports.ArgumentDefaultsHelpFormatter =
+  require('./help/added_formatters.js').ArgumentDefaultsHelpFormatter;
+module.exports.RawDescriptionHelpFormatter =
+  require('./help/added_formatters.js').RawDescriptionHelpFormatter;
+module.exports.RawTextHelpFormatter =
+  require('./help/added_formatters.js').RawTextHelpFormatter;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/9e/Colors_9ecc4a155788090d261edabf2719d1f8

@@ -0,0 +1,185 @@
+b2a0f5d4189f335fa626d34f4684a042
+"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.Colors = exports.ConsoleColorCodes = exports.TextAttribute = exports.ColorValue = exports.eolSequence = void 0;
+exports.eolSequence = {
+    isEol: true
+};
+/**
+ * Colors used with {@link IColorableSequence}.
+ * @beta
+ */
+var ColorValue;
+(function (ColorValue) {
+    ColorValue[ColorValue["Black"] = 0] = "Black";
+    ColorValue[ColorValue["Red"] = 1] = "Red";
+    ColorValue[ColorValue["Green"] = 2] = "Green";
+    ColorValue[ColorValue["Yellow"] = 3] = "Yellow";
+    ColorValue[ColorValue["Blue"] = 4] = "Blue";
+    ColorValue[ColorValue["Magenta"] = 5] = "Magenta";
+    ColorValue[ColorValue["Cyan"] = 6] = "Cyan";
+    ColorValue[ColorValue["White"] = 7] = "White";
+    ColorValue[ColorValue["Gray"] = 8] = "Gray";
+})(ColorValue = exports.ColorValue || (exports.ColorValue = {}));
+/**
+ * Text styles used with {@link IColorableSequence}.
+ * @beta
+ */
+var TextAttribute;
+(function (TextAttribute) {
+    TextAttribute[TextAttribute["Bold"] = 0] = "Bold";
+    TextAttribute[TextAttribute["Dim"] = 1] = "Dim";
+    TextAttribute[TextAttribute["Underline"] = 2] = "Underline";
+    TextAttribute[TextAttribute["Blink"] = 3] = "Blink";
+    TextAttribute[TextAttribute["InvertColor"] = 4] = "InvertColor";
+    TextAttribute[TextAttribute["Hidden"] = 5] = "Hidden";
+})(TextAttribute = exports.TextAttribute || (exports.TextAttribute = {}));
+var ConsoleColorCodes;
+(function (ConsoleColorCodes) {
+    ConsoleColorCodes[ConsoleColorCodes["BlackForeground"] = 30] = "BlackForeground";
+    ConsoleColorCodes[ConsoleColorCodes["RedForeground"] = 31] = "RedForeground";
+    ConsoleColorCodes[ConsoleColorCodes["GreenForeground"] = 32] = "GreenForeground";
+    ConsoleColorCodes[ConsoleColorCodes["YellowForeground"] = 33] = "YellowForeground";
+    ConsoleColorCodes[ConsoleColorCodes["BlueForeground"] = 34] = "BlueForeground";
+    ConsoleColorCodes[ConsoleColorCodes["MagentaForeground"] = 35] = "MagentaForeground";
+    ConsoleColorCodes[ConsoleColorCodes["CyanForeground"] = 36] = "CyanForeground";
+    ConsoleColorCodes[ConsoleColorCodes["WhiteForeground"] = 37] = "WhiteForeground";
+    ConsoleColorCodes[ConsoleColorCodes["GrayForeground"] = 90] = "GrayForeground";
+    ConsoleColorCodes[ConsoleColorCodes["DefaultForeground"] = 39] = "DefaultForeground";
+    ConsoleColorCodes[ConsoleColorCodes["BlackBackground"] = 40] = "BlackBackground";
+    ConsoleColorCodes[ConsoleColorCodes["RedBackground"] = 41] = "RedBackground";
+    ConsoleColorCodes[ConsoleColorCodes["GreenBackground"] = 42] = "GreenBackground";
+    ConsoleColorCodes[ConsoleColorCodes["YellowBackground"] = 43] = "YellowBackground";
+    ConsoleColorCodes[ConsoleColorCodes["BlueBackground"] = 44] = "BlueBackground";
+    ConsoleColorCodes[ConsoleColorCodes["MagentaBackground"] = 45] = "MagentaBackground";
+    ConsoleColorCodes[ConsoleColorCodes["CyanBackground"] = 46] = "CyanBackground";
+    ConsoleColorCodes[ConsoleColorCodes["WhiteBackground"] = 47] = "WhiteBackground";
+    ConsoleColorCodes[ConsoleColorCodes["GrayBackground"] = 100] = "GrayBackground";
+    ConsoleColorCodes[ConsoleColorCodes["DefaultBackground"] = 49] = "DefaultBackground";
+    ConsoleColorCodes[ConsoleColorCodes["Bold"] = 1] = "Bold";
+    // On Linux, the "BoldOff" code instead causes the text to be double-underlined:
+    // https://en.wikipedia.org/wiki/Talk:ANSI_escape_code#SGR_21%E2%80%94%60Bold_off%60_not_widely_supported
+    // Use "NormalColorOrIntensity" instead
+    // BoldOff = 21,
+    ConsoleColorCodes[ConsoleColorCodes["Dim"] = 2] = "Dim";
+    ConsoleColorCodes[ConsoleColorCodes["NormalColorOrIntensity"] = 22] = "NormalColorOrIntensity";
+    ConsoleColorCodes[ConsoleColorCodes["Underline"] = 4] = "Underline";
+    ConsoleColorCodes[ConsoleColorCodes["UnderlineOff"] = 24] = "UnderlineOff";
+    ConsoleColorCodes[ConsoleColorCodes["Blink"] = 5] = "Blink";
+    ConsoleColorCodes[ConsoleColorCodes["BlinkOff"] = 25] = "BlinkOff";
+    ConsoleColorCodes[ConsoleColorCodes["InvertColor"] = 7] = "InvertColor";
+    ConsoleColorCodes[ConsoleColorCodes["InvertColorOff"] = 27] = "InvertColorOff";
+    ConsoleColorCodes[ConsoleColorCodes["Hidden"] = 8] = "Hidden";
+    ConsoleColorCodes[ConsoleColorCodes["HiddenOff"] = 28] = "HiddenOff";
+})(ConsoleColorCodes = exports.ConsoleColorCodes || (exports.ConsoleColorCodes = {}));
+/**
+ * The static functions on this class are used to produce colored text
+ * for use with the node-core-library terminal.
+ *
+ * @example
+ * terminal.writeLine(Colors.green('Green Text!'), ' ', Colors.blue('Blue Text!'));
+ *
+ * @beta
+ */
+class Colors {
+    static black(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Black });
+    }
+    static red(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Red });
+    }
+    static green(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Green });
+    }
+    static yellow(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Yellow });
+    }
+    static blue(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Blue });
+    }
+    static magenta(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Magenta });
+    }
+    static cyan(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Cyan });
+    }
+    static white(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.White });
+    }
+    static gray(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { foregroundColor: ColorValue.Gray });
+    }
+    static blackBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Black });
+    }
+    static redBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Red });
+    }
+    static greenBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Green });
+    }
+    static yellowBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Yellow });
+    }
+    static blueBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Blue });
+    }
+    static magentaBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Magenta });
+    }
+    static cyanBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Cyan });
+    }
+    static whiteBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.White });
+    }
+    static grayBackground(text) {
+        return Object.assign(Object.assign({}, Colors._normalizeStringOrColorableSequence(text)), { backgroundColor: ColorValue.Gray });
+    }
+    static bold(text) {
+        return Colors._applyTextAttribute(text, TextAttribute.Bold);
+    }
+    static dim(text) {
+        return Colors._applyTextAttribute(text, TextAttribute.Dim);
+    }
+    static underline(text) {
+        return Colors._applyTextAttribute(text, TextAttribute.Underline);
+    }
+    static blink(text) {
+        return Colors._applyTextAttribute(text, TextAttribute.Blink);
+    }
+    static invertColor(text) {
+        return Colors._applyTextAttribute(text, TextAttribute.InvertColor);
+    }
+    static hidden(text) {
+        return Colors._applyTextAttribute(text, TextAttribute.Hidden);
+    }
+    /**
+     * If called with a string, returns the string wrapped in a {@link IColorableSequence}.
+     * If called with a {@link IColorableSequence}, returns the {@link IColorableSequence}.
+     *
+     * @internal
+     */
+    static _normalizeStringOrColorableSequence(value) {
+        if (typeof value === 'string') {
+            return {
+                text: value
+            };
+        }
+        else {
+            return value;
+        }
+    }
+    static _applyTextAttribute(text, attribute) {
+        const sequence = Colors._normalizeStringOrColorableSequence(text);
+        if (!sequence.textAttributes) {
+            sequence.textAttributes = [];
+        }
+        sequence.textAttributes.push(attribute);
+        return sequence;
+    }
+}
+exports.Colors = Colors;
+//# sourceMappingURL=Colors.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/9e/MapExtensions_9e5b8afe723b86b4ee5b79a35287a9e0

@@ -0,0 +1,41 @@
+4022f7992facf9256054a7f43344db15
+"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.MapExtensions = void 0;
+/**
+ * Helper functions for working with the `Map<K, V>` data type.
+ *
+ * @public
+ */
+class MapExtensions {
+    /**
+     * Adds all the (key, value) pairs from the source map into the target map.
+     * @remarks
+     * This function modifies targetMap.  Any existing keys will be overwritten.
+     * @param targetMap - The map that entries will be added to
+     * @param sourceMap - The map containing the entries to be added
+     */
+    static mergeFromMap(targetMap, sourceMap) {
+        for (const pair of sourceMap.entries()) {
+            targetMap.set(pair[0], pair[1]);
+        }
+    }
+    /**
+     * Converts a string-keyed map to an object.
+     * @remarks
+     * This function has the same effect as Object.fromEntries(map.entries())
+     * in supported versions of Node (\>= 12.0.0).
+     * @param map - The map that the object properties will be sourced from
+     */
+    static toObject(map) {
+        const object = {};
+        for (const [key, value] of map.entries()) {
+            object[key] = value;
+        }
+        return object;
+    }
+}
+exports.MapExtensions = MapExtensions;
+//# sourceMappingURL=MapExtensions.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/9e/symlinktype_9e28e4f4457ee603d982b6fb686f0ed3

@@ -0,0 +1,32 @@
+a7303f6372ea7442c2750c3e1de89802
+'use strict'
+
+const fs = require('graceful-fs')
+
+function symlinkType (srcpath, type, callback) {
+  callback = (typeof type === 'function') ? type : callback
+  type = (typeof type === 'function') ? false : type
+  if (type) return callback(null, type)
+  fs.lstat(srcpath, (err, stats) => {
+    if (err) return callback(null, 'file')
+    type = (stats && stats.isDirectory()) ? 'dir' : 'file'
+    callback(null, type)
+  })
+}
+
+function symlinkTypeSync (srcpath, type) {
+  let stats
+
+  if (type) return type
+  try {
+    stats = fs.lstatSync(srcpath)
+  } catch (e) {
+    return 'file'
+  }
+  return (stats && stats.isDirectory()) ? 'dir' : 'file'
+}
+
+module.exports = {
+  symlinkType,
+  symlinkTypeSync
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/9f/EnvironmentVariableParser_9f0570850bed25007c419377e7c7340e

@@ -0,0 +1,52 @@
+13cb78fb756f095b63cb93c2fe8b0b05
+"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.EnvironmentVariableParser = void 0;
+/**
+ * Some parameter types can receive their values from an environment variable instead of
+ * a command line argument. This class provides some utility methods for parsing environment
+ * variable values.
+ * @internal
+ */
+class EnvironmentVariableParser {
+    static parseAsList(envVarName) {
+        const environmentValue = process.env[envVarName];
+        if (environmentValue !== undefined) {
+            // NOTE: If the environment variable is defined as an empty string,
+            // here we will accept the empty string as our value.  (For number/flag we don't do that.)
+            if (environmentValue.trimLeft()[0] === '[') {
+                // Specifying multiple items in an environment variable is a somewhat rare case.  But environment
+                // variables are actually a pretty reliable way for a tool to avoid shell escaping problems
+                // when spawning another tool.  For this case, we need a reliable way to pass an array of strings
+                // that could contain any character.  For example, if we simply used ";" as the list delimiter,
+                // then what to do if a string contains that character?  We'd need to design an escaping mechanism.
+                // Since JSON is simple and standard and can escape every possible string, it's a better option
+                // than a custom delimiter.
+                try {
+                    const parsedJson = JSON.parse(environmentValue);
+                    if (!Array.isArray(parsedJson) ||
+                        !parsedJson.every((x) => typeof x === 'string' || typeof x === 'boolean' || typeof x === 'number')) {
+                        throw new Error(`The ${environmentValue} environment variable value must be a JSON ` +
+                            ` array containing only strings, numbers, and booleans.`);
+                    }
+                    return parsedJson.map((x) => x.toString());
+                }
+                catch (ex) {
+                    throw new Error(`The ${environmentValue} environment variable value looks like a JSON array` +
+                        ` but failed to parse: ` +
+                        ex.message);
+                }
+            }
+            else {
+                // As a shorthand, a single value may be specified without JSON encoding, as long as it does not
+                // start with the "[" character.
+                return [environmentValue];
+            }
+        }
+        return undefined;
+    }
+}
+exports.EnvironmentVariableParser = EnvironmentVariableParser;
+//# sourceMappingURL=EnvironmentVariableParser.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a1/exclusive_a143a742fec2463ca3a09bb335d9db42

@@ -0,0 +1,55 @@
+c38a1586d7e145698239ccfd20c16458
+/** internal
+ * class MutuallyExclusiveGroup
+ *
+ * Group arguments.
+ * By default, ArgumentParser groups command-line arguments
+ * into “positional arguments” and “optional arguments”
+ * when displaying help messages. When there is a better
+ * conceptual grouping of arguments than this default one,
+ * appropriate groups can be created using the addArgumentGroup() method
+ *
+ * This class inherited from [[ArgumentContainer]]
+ **/
+'use strict';
+
+var util = require('util');
+
+var ArgumentGroup = require('./group');
+
+/**
+ * new MutuallyExclusiveGroup(container, options)
+ * - container (object): main container
+ * - options (object): options.required -> true/false
+ *
+ * `required` could be an argument itself, but making it a property of
+ * the options argument is more consistent with the JS adaptation of the Python)
+ **/
+var MutuallyExclusiveGroup = module.exports = function MutuallyExclusiveGroup(container, options) {
+  var required;
+  options = options || {};
+  required = options.required || false;
+  ArgumentGroup.call(this, container);
+  this.required = required;
+
+};
+util.inherits(MutuallyExclusiveGroup, ArgumentGroup);
+
+
+MutuallyExclusiveGroup.prototype._addAction = function (action) {
+  var msg;
+  if (action.required) {
+    msg = 'mutually exclusive arguments must be optional';
+    throw new Error(msg);
+  }
+  action = this._container._addAction(action);
+  this._groupActions.push(action);
+  return action;
+};
+
+
+MutuallyExclusiveGroup.prototype._removeAction = function (action) {
+  this._container._removeAction(action);
+  this._groupActions.remove(action);
+};
+

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a1/implementation_a1723a009de8984b2f21159b10fc6520

@@ -0,0 +1,53 @@
+338b8a48b59871c22e35e642ef4f09b8
+'use strict';
+
+/* eslint no-invalid-this: 1 */
+
+var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
+var slice = Array.prototype.slice;
+var toStr = Object.prototype.toString;
+var funcType = '[object Function]';
+
+module.exports = function bind(that) {
+    var target = this;
+    if (typeof target !== 'function' || toStr.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+    }
+    var args = slice.call(arguments, 1);
+
+    var bound;
+    var binder = function () {
+        if (this instanceof bound) {
+            var result = target.apply(
+                this,
+                args.concat(slice.call(arguments))
+            );
+            if (Object(result) === result) {
+                return result;
+            }
+            return this;
+        } else {
+            return target.apply(
+                that,
+                args.concat(slice.call(arguments))
+            );
+        }
+    };
+
+    var boundLength = Math.max(0, target.length - args.length);
+    var boundArgs = [];
+    for (var i = 0; i < boundLength; i++) {
+        boundArgs.push('$' + i);
+    }
+
+    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
+
+    if (target.prototype) {
+        var Empty = function Empty() {};
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+    }
+
+    return bound;
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/a1/outside_a1760cf8e60702091d1e4d477923e3a6

@@ -0,0 +1,81 @@
+c6f8b84ebd967e5479159e2f876f3ba2
+const SemVer = require('../classes/semver')
+const Comparator = require('../classes/comparator')
+const { ANY } = Comparator
+const Range = require('../classes/range')
+const satisfies = require('../functions/satisfies')
+const gt = require('../functions/gt')
+const lt = require('../functions/lt')
+const lte = require('../functions/lte')
+const gte = require('../functions/gte')
+
+const outside = (version, range, hilo, options) => {
+  version = new SemVer(version, options)
+  range = new Range(range, options)
+
+  let gtfn, ltefn, ltfn, comp, ecomp
+  switch (hilo) {
+    case '>':
+      gtfn = gt
+      ltefn = lte
+      ltfn = lt
+      comp = '>'
+      ecomp = '>='
+      break
+    case '<':
+      gtfn = lt
+      ltefn = gte
+      ltfn = gt
+      comp = '<'
+      ecomp = '<='
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
+
+  // If it satisfies the range it is not outside
+  if (satisfies(version, range, options)) {
+    return false
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let high = null
+    let low = null
+
+    comparators.forEach((comparator) => {
+      if (comparator.semver === ANY) {
+        comparator = new Comparator('>=0.0.0')
+      }
+      high = high || comparator
+      low = low || comparator
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator
+      }
+    })
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
+    }
+  }
+  return true
+}
+
+module.exports = outside