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

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

@@ -0,0 +1,288 @@
+4f4ab2a2a86abe97a537503ad1328232
+const debug = require('../internal/debug')
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')
+const { re, t } = require('../internal/re')
+
+const parseOptions = require('../internal/parse-options')
+const { compareIdentifiers } = require('../internal/identifiers')
+class SemVer {
+  constructor (version, options) {
+    options = parseOptions(options)
+
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose &&
+          version.includePrerelease === !!options.includePrerelease) {
+        return version
+      } else {
+        version = version.version
+      }
+    } else if (typeof version !== 'string') {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      )
+    }
+
+    debug('SemVer', version, options)
+    this.options = options
+    this.loose = !!options.loose
+    // this isn't actually relevant for versions, but keep it so that we
+    // don't run into trouble passing this.options around.
+    this.includePrerelease = !!options.includePrerelease
+
+    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
+
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    this.raw = version
+
+    // these are actually numbers
+    this.major = +m[1]
+    this.minor = +m[2]
+    this.patch = +m[3]
+
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError('Invalid major version')
+    }
+
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError('Invalid minor version')
+    }
+
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
+
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = []
+    } else {
+      this.prerelease = m[4].split('.').map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
+          }
+        }
+        return id
+      })
+    }
+
+    this.build = m[5] ? m[5].split('.') : []
+    this.format()
+  }
+
+  format () {
+    this.version = `${this.major}.${this.minor}.${this.patch}`
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join('.')}`
+    }
+    return this.version
+  }
+
+  toString () {
+    return this.version
+  }
+
+  compare (other) {
+    debug('SemVer.compare', this.version, this.options, other)
+    if (!(other instanceof SemVer)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer(other, this.options)
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
+  }
+
+  compareMain (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    return (
+      compareIdentifiers(this.major, other.major) ||
+      compareIdentifiers(this.minor, other.minor) ||
+      compareIdentifiers(this.patch, other.patch)
+    )
+  }
+
+  comparePre (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    // NOT having a prerelease is > having one
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0
+    }
+
+    let i = 0
+    do {
+      const a = this.prerelease[i]
+      const b = other.prerelease[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  compareBuild (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    let i = 0
+    do {
+      const a = this.build[i]
+      const b = other.build[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc (release, identifier) {
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor = 0
+        this.major++
+        this.inc('pre', identifier)
+        break
+      case 'preminor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor++
+        this.inc('pre', identifier)
+        break
+      case 'prepatch':
+        // If this is already a prerelease, it will bump to the next version
+        // drop any prereleases that might already exist, since they are not
+        // relevant at this point.
+        this.prerelease.length = 0
+        this.inc('patch', identifier)
+        this.inc('pre', identifier)
+        break
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
+      case 'prerelease':
+        if (this.prerelease.length === 0) {
+          this.inc('patch', identifier)
+        }
+        this.inc('pre', identifier)
+        break
+
+      case 'major':
+        // If this is a pre-major version, bump up to the same major version.
+        // Otherwise increment major.
+        // 1.0.0-5 bumps to 1.0.0
+        // 1.1.0 bumps to 2.0.0
+        if (
+          this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0
+        ) {
+          this.major++
+        }
+        this.minor = 0
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'minor':
+        // If this is a pre-minor version, bump up to the same minor version.
+        // Otherwise increment minor.
+        // 1.2.0-5 bumps to 1.2.0
+        // 1.2.1 bumps to 1.3.0
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++
+        }
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'patch':
+        // If this is not a pre-release version, it will increment the patch.
+        // If it is a pre-release it will bump up to the same patch version.
+        // 1.2.0-5 patches to 1.2.0
+        // 1.2.0 patches to 1.2.1
+        if (this.prerelease.length === 0) {
+          this.patch++
+        }
+        this.prerelease = []
+        break
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+      case 'pre':
+        if (this.prerelease.length === 0) {
+          this.prerelease = [0]
+        } else {
+          let i = this.prerelease.length
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === 'number') {
+              this.prerelease[i]++
+              i = -2
+            }
+          }
+          if (i === -1) {
+            // didn't increment anything
+            this.prerelease.push(0)
+          }
+        }
+        if (identifier) {
+          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = [identifier, 0]
+            }
+          } else {
+            this.prerelease = [identifier, 0]
+          }
+        }
+        break
+
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
+    }
+    this.format()
+    this.raw = this.version
+    return this
+  }
+}
+
+module.exports = SemVer

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/38/index_3845abe725b203bc5c4e6a1238cb36c9

@@ -0,0 +1,20 @@
+c0623f6fb5033ef0ddf79ec7b5f50be7
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+exports.__esModule = true;
+exports.SyncHook = require("./SyncHook");
+exports.SyncBailHook = require("./SyncBailHook");
+exports.SyncWaterfallHook = require("./SyncWaterfallHook");
+exports.SyncLoopHook = require("./SyncLoopHook");
+exports.AsyncParallelHook = require("./AsyncParallelHook");
+exports.AsyncParallelBailHook = require("./AsyncParallelBailHook");
+exports.AsyncSeriesHook = require("./AsyncSeriesHook");
+exports.AsyncSeriesBailHook = require("./AsyncSeriesBailHook");
+exports.AsyncSeriesLoopHook = require("./AsyncSeriesLoopHook");
+exports.AsyncSeriesWaterfallHook = require("./AsyncSeriesWaterfallHook");
+exports.HookMap = require("./HookMap");
+exports.MultiHook = require("./MultiHook");

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/39/MultiHook_39ae7d5e7f9fb6b6c2daef78c7830798

@@ -0,0 +1,55 @@
+c4c0a2f35c213102f06e3929177edd9b
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+
+class MultiHook {
+	constructor(hooks, name = undefined) {
+		this.hooks = hooks;
+		this.name = name;
+	}
+
+	tap(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tap(options, fn);
+		}
+	}
+
+	tapAsync(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapAsync(options, fn);
+		}
+	}
+
+	tapPromise(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapPromise(options, fn);
+		}
+	}
+
+	isUsed() {
+		for (const hook of this.hooks) {
+			if (hook.isUsed()) return true;
+		}
+		return false;
+	}
+
+	intercept(interceptor) {
+		for (const hook of this.hooks) {
+			hook.intercept(interceptor);
+		}
+	}
+
+	withOptions(options) {
+		return new MultiHook(
+			this.hooks.map(h => h.withOptions(options)),
+			this.name
+		);
+	}
+}
+
+module.exports = MultiHook;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/39/index_39a7e36288e762fe97d6899aff7bb080

@@ -0,0 +1,7 @@
+f685df7a46989c967bf917a5632a5872
+'use strict'
+
+const u = require('universalify').fromCallback
+module.exports = {
+  copy: u(require('./copy'))
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/39/index_39f2106e77a53f183393c1eb12dc0abd

@@ -0,0 +1,6 @@
+f761bc101bf315e6124f737d1691aaa7
+'use strict';
+
+var implementation = require('./implementation');
+
+module.exports = Function.prototype.bind || implementation;

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/3c/iscore_3cd337d75d2dc1446345a2444372d63e

@@ -0,0 +1,6 @@
+4d6318c847f3bc91dd1b0f647bfb98d5
+var isCoreModule = require('is-core-module');
+
+module.exports = function isCore(x) {
+    return isCoreModule(x);
+};

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/3d/index_3df2d3d9ea8e302f11de5ec1fc1aeec9

@@ -0,0 +1,15 @@
+75beff177d9331bfd48cd6a5f769bfd5
+'use strict'
+const u = require('universalify').fromCallback
+const mkdirs = u(require('./mkdirs'))
+const mkdirsSync = require('./mkdirs-sync')
+
+module.exports = {
+  mkdirs,
+  mkdirsSync,
+  // alias
+  mkdirp: mkdirs,
+  mkdirpSync: mkdirsSync,
+  ensureDir: mkdirs,
+  ensureDirSync: mkdirsSync
+}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/3e/JsonSchema_3e5211cb39cc2174977ac14cd08caab3

@@ -0,0 +1,219 @@
+5894e79180c0a484dea9dd11e7e87ce2
+"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.JsonSchema = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const JsonFile_1 = require("./JsonFile");
+const FileSystem_1 = require("./FileSystem");
+const Validator = require('z-schema/dist/ZSchema-browser-min');
+/**
+ * Represents a JSON schema that can be used to validate JSON data files loaded by the JsonFile class.
+ * @remarks
+ * The schema itself is normally loaded and compiled later, only if it is actually required to validate
+ * an input.  To avoid schema errors at runtime, it's recommended to create a unit test that calls
+ * JsonSchema.ensureCompiled() for each of your schema objects.
+ *
+ * @public
+ */
+class JsonSchema {
+    constructor() {
+        this._dependentSchemas = [];
+        this._filename = '';
+        this._validator = undefined;
+        this._schemaObject = undefined;
+    }
+    /**
+     * Registers a JsonSchema that will be loaded from a file on disk.
+     * @remarks
+     * NOTE: An error occurs if the file does not exist; however, the file itself is not loaded or validated
+     * until it the schema is actually used.
+     */
+    static fromFile(filename, options) {
+        // This is a quick and inexpensive test to avoid the catch the most common errors early.
+        // Full validation will happen later in JsonSchema.compile().
+        if (!FileSystem_1.FileSystem.exists(filename)) {
+            throw new Error('Schema file not found: ' + filename);
+        }
+        const schema = new JsonSchema();
+        schema._filename = filename;
+        if (options) {
+            schema._dependentSchemas = options.dependentSchemas || [];
+        }
+        return schema;
+    }
+    /**
+     * Registers a JsonSchema that will be loaded from a file on disk.
+     * @remarks
+     * NOTE: An error occurs if the file does not exist; however, the file itself is not loaded or validated
+     * until it the schema is actually used.
+     */
+    static fromLoadedObject(schemaObject) {
+        const schema = new JsonSchema();
+        schema._schemaObject = schemaObject;
+        return schema;
+    }
+    static _collectDependentSchemas(collectedSchemas, dependentSchemas, seenObjects, seenIds) {
+        for (const dependentSchema of dependentSchemas) {
+            // It's okay for the same schema to appear multiple times in the tree, but we only process it once
+            if (seenObjects.has(dependentSchema)) {
+                continue;
+            }
+            seenObjects.add(dependentSchema);
+            const schemaId = dependentSchema._ensureLoaded();
+            if (schemaId === '') {
+                throw new Error(`This schema ${dependentSchema.shortName} cannot be referenced` +
+                    ' because is missing the "id" field');
+            }
+            if (seenIds.has(schemaId)) {
+                throw new Error(`This schema ${dependentSchema.shortName} has the same "id" as another schema in this set`);
+            }
+            seenIds.add(schemaId);
+            collectedSchemas.push(dependentSchema);
+            JsonSchema._collectDependentSchemas(collectedSchemas, dependentSchema._dependentSchemas, seenObjects, seenIds);
+        }
+    }
+    /**
+     * Used to nicely format the ZSchema error tree.
+     */
+    static _formatErrorDetails(errorDetails) {
+        return JsonSchema._formatErrorDetailsHelper(errorDetails, '', '');
+    }
+    /**
+     * Used by _formatErrorDetails.
+     */
+    static _formatErrorDetailsHelper(errorDetails, indent, buffer) {
+        for (const errorDetail of errorDetails) {
+            buffer += os.EOL + indent + `Error: ${errorDetail.path}`;
+            if (errorDetail.description) {
+                const MAX_LENGTH = 40;
+                let truncatedDescription = errorDetail.description.trim();
+                if (truncatedDescription.length > MAX_LENGTH) {
+                    truncatedDescription = truncatedDescription.substr(0, MAX_LENGTH - 3) + '...';
+                }
+                buffer += ` (${truncatedDescription})`;
+            }
+            buffer += os.EOL + indent + `       ${errorDetail.message}`;
+            if (errorDetail.inner) {
+                buffer = JsonSchema._formatErrorDetailsHelper(errorDetail.inner, indent + '  ', buffer);
+            }
+        }
+        return buffer;
+    }
+    /**
+     * Returns a short name for this schema, for use in error messages.
+     * @remarks
+     * If the schema was loaded from a file, then the base filename is used.  Otherwise, the "id"
+     * field is used if available.
+     */
+    get shortName() {
+        if (!this._filename) {
+            if (this._schemaObject) {
+                const schemaWithId = this._schemaObject;
+                if (schemaWithId.id) {
+                    return schemaWithId.id;
+                }
+            }
+            return '(anonymous schema)';
+        }
+        else {
+            return path.basename(this._filename);
+        }
+    }
+    /**
+     * If not already done, this loads the schema from disk and compiles it.
+     * @remarks
+     * Any dependencies will be compiled as well.
+     */
+    ensureCompiled() {
+        this._ensureLoaded();
+        if (!this._validator) {
+            // Don't assign this to _validator until we're sure everything was successful
+            const newValidator = new Validator({
+                breakOnFirstError: false,
+                noTypeless: true,
+                noExtraKeywords: true
+            });
+            const anythingSchema = {
+                type: ['array', 'boolean', 'integer', 'number', 'object', 'string']
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            newValidator.setRemoteReference('http://json-schema.org/draft-04/schema', anythingSchema);
+            const collectedSchemas = [];
+            const seenObjects = new Set();
+            const seenIds = new Set();
+            JsonSchema._collectDependentSchemas(collectedSchemas, this._dependentSchemas, seenObjects, seenIds);
+            // Validate each schema in order.  We specifically do not supply them all together, because we want
+            // to make sure that circular references will fail to validate.
+            for (const collectedSchema of collectedSchemas) {
+                if (!newValidator.validateSchema(collectedSchema._schemaObject)) {
+                    throw new Error(`Failed to validate schema "${collectedSchema.shortName}":` +
+                        os.EOL +
+                        JsonSchema._formatErrorDetails(newValidator.getLastErrors()));
+                }
+            }
+            this._validator = newValidator;
+        }
+    }
+    /**
+     * Validates the specified JSON object against this JSON schema.  If the validation fails,
+     * an exception will be thrown.
+     * @param jsonObject - The JSON data to be validated
+     * @param filenameForErrors - The filename that the JSON data was available, or an empty string
+     *    if not applicable
+     * @param options - Other options that control the validation
+     */
+    validateObject(jsonObject, filenameForErrors, options) {
+        this.validateObjectWithCallback(jsonObject, (errorInfo) => {
+            const prefix = options && options.customErrorHeader ? options.customErrorHeader : 'JSON validation failed:';
+            throw new Error(prefix + os.EOL + filenameForErrors + os.EOL + errorInfo.details);
+        });
+    }
+    /**
+     * Validates the specified JSON object against this JSON schema.  If the validation fails,
+     * a callback is called for each validation error.
+     */
+    validateObjectWithCallback(jsonObject, errorCallback) {
+        this.ensureCompiled();
+        if (!this._validator.validate(jsonObject, this._schemaObject)) {
+            const errorDetails = JsonSchema._formatErrorDetails(this._validator.getLastErrors());
+            const args = {
+                details: errorDetails
+            };
+            errorCallback(args);
+        }
+    }
+    _ensureLoaded() {
+        if (!this._schemaObject) {
+            this._schemaObject = JsonFile_1.JsonFile.load(this._filename);
+        }
+        return this._schemaObject.id || '';
+    }
+}
+exports.JsonSchema = JsonSchema;
+//# sourceMappingURL=JsonSchema.js.map