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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/80/compareloose_80136cfdc57ee904f7908e1485f4edb0

@@ -0,0 +1,4 @@
+1c581d61f0ab057af7fed4ad01c66d09
+const compare = require('./compare')
+const compareLoose = (a, b) => compare(a, b, true)
+module.exports = compareLoose

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/80/index_8021860f6bdaf0355b9b55768096ad1f

@@ -0,0 +1,17 @@
+f538a10df9409e9d86f7425494c71a44
+'use strict'
+
+const u = require('universalify').fromCallback
+const jsonFile = require('./jsonfile')
+
+jsonFile.outputJson = u(require('./output-json'))
+jsonFile.outputJsonSync = require('./output-json-sync')
+// aliases
+jsonFile.outputJSON = jsonFile.outputJson
+jsonFile.outputJSONSync = jsonFile.outputJsonSync
+jsonFile.writeJSON = jsonFile.writeJson
+jsonFile.writeJSONSync = jsonFile.writeJsonSync
+jsonFile.readJSON = jsonFile.readJson
+jsonFile.readJSONSync = jsonFile.readJsonSync
+
+module.exports = jsonFile

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/81/index_81958cb0f4d5af47c9f4ff027730a354

@@ -0,0 +1,335 @@
+b8b9a8ec246e3ef6fec472a55ab97cd0
+'use strict'
+
+// A linked list to keep track of recently-used-ness
+const Yallist = require('yallist')
+
+const MAX = Symbol('max')
+const LENGTH = Symbol('length')
+const LENGTH_CALCULATOR = Symbol('lengthCalculator')
+const ALLOW_STALE = Symbol('allowStale')
+const MAX_AGE = Symbol('maxAge')
+const DISPOSE = Symbol('dispose')
+const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet')
+const LRU_LIST = Symbol('lruList')
+const CACHE = Symbol('cache')
+const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet')
+
+const naiveLength = () => 1
+
+// lruList is a yallist where the head is the youngest
+// item, and the tail is the oldest.  the list contains the Hit
+// objects as the entries.
+// Each Hit object has a reference to its Yallist.Node.  This
+// never changes.
+//
+// cache is a Map (or PseudoMap) that matches the keys to
+// the Yallist.Node object.
+class LRUCache {
+  constructor (options) {
+    if (typeof options === 'number')
+      options = { max: options }
+
+    if (!options)
+      options = {}
+
+    if (options.max && (typeof options.max !== 'number' || options.max < 0))
+      throw new TypeError('max must be a non-negative number')
+    // Kind of weird to have a default max of Infinity, but oh well.
+    const max = this[MAX] = options.max || Infinity
+
+    const lc = options.length || naiveLength
+    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc
+    this[ALLOW_STALE] = options.stale || false
+    if (options.maxAge && typeof options.maxAge !== 'number')
+      throw new TypeError('maxAge must be a number')
+    this[MAX_AGE] = options.maxAge || 0
+    this[DISPOSE] = options.dispose
+    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false
+    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false
+    this.reset()
+  }
+
+  // resize the cache when the max changes.
+  set max (mL) {
+    if (typeof mL !== 'number' || mL < 0)
+      throw new TypeError('max must be a non-negative number')
+
+    this[MAX] = mL || Infinity
+    trim(this)
+  }
+  get max () {
+    return this[MAX]
+  }
+
+  set allowStale (allowStale) {
+    this[ALLOW_STALE] = !!allowStale
+  }
+  get allowStale () {
+    return this[ALLOW_STALE]
+  }
+
+  set maxAge (mA) {
+    if (typeof mA !== 'number')
+      throw new TypeError('maxAge must be a non-negative number')
+
+    this[MAX_AGE] = mA
+    trim(this)
+  }
+  get maxAge () {
+    return this[MAX_AGE]
+  }
+
+  // resize the cache when the lengthCalculator changes.
+  set lengthCalculator (lC) {
+    if (typeof lC !== 'function')
+      lC = naiveLength
+
+    if (lC !== this[LENGTH_CALCULATOR]) {
+      this[LENGTH_CALCULATOR] = lC
+      this[LENGTH] = 0
+      this[LRU_LIST].forEach(hit => {
+        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key)
+        this[LENGTH] += hit.length
+      })
+    }
+    trim(this)
+  }
+  get lengthCalculator () { return this[LENGTH_CALCULATOR] }
+
+  get length () { return this[LENGTH] }
+  get itemCount () { return this[LRU_LIST].length }
+
+  rforEach (fn, thisp) {
+    thisp = thisp || this
+    for (let walker = this[LRU_LIST].tail; walker !== null;) {
+      const prev = walker.prev
+      forEachStep(this, fn, walker, thisp)
+      walker = prev
+    }
+  }
+
+  forEach (fn, thisp) {
+    thisp = thisp || this
+    for (let walker = this[LRU_LIST].head; walker !== null;) {
+      const next = walker.next
+      forEachStep(this, fn, walker, thisp)
+      walker = next
+    }
+  }
+
+  keys () {
+    return this[LRU_LIST].toArray().map(k => k.key)
+  }
+
+  values () {
+    return this[LRU_LIST].toArray().map(k => k.value)
+  }
+
+  reset () {
+    if (this[DISPOSE] &&
+        this[LRU_LIST] &&
+        this[LRU_LIST].length) {
+      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value))
+    }
+
+    this[CACHE] = new Map() // hash of items by key
+    this[LRU_LIST] = new Yallist() // list of items in order of use recency
+    this[LENGTH] = 0 // length of items in the list
+  }
+
+  dump () {
+    return this[LRU_LIST].map(hit =>
+      isStale(this, hit) ? false : {
+        k: hit.key,
+        v: hit.value,
+        e: hit.now + (hit.maxAge || 0)
+      }).toArray().filter(h => h)
+  }
+
+  dumpLru () {
+    return this[LRU_LIST]
+  }
+
+  set (key, value, maxAge) {
+    maxAge = maxAge || this[MAX_AGE]
+
+    if (maxAge && typeof maxAge !== 'number')
+      throw new TypeError('maxAge must be a number')
+
+    const now = maxAge ? Date.now() : 0
+    const len = this[LENGTH_CALCULATOR](value, key)
+
+    if (this[CACHE].has(key)) {
+      if (len > this[MAX]) {
+        del(this, this[CACHE].get(key))
+        return false
+      }
+
+      const node = this[CACHE].get(key)
+      const item = node.value
+
+      // dispose of the old one before overwriting
+      // split out into 2 ifs for better coverage tracking
+      if (this[DISPOSE]) {
+        if (!this[NO_DISPOSE_ON_SET])
+          this[DISPOSE](key, item.value)
+      }
+
+      item.now = now
+      item.maxAge = maxAge
+      item.value = value
+      this[LENGTH] += len - item.length
+      item.length = len
+      this.get(key)
+      trim(this)
+      return true
+    }
+
+    const hit = new Entry(key, value, len, now, maxAge)
+
+    // oversized objects fall out of cache automatically.
+    if (hit.length > this[MAX]) {
+      if (this[DISPOSE])
+        this[DISPOSE](key, value)
+
+      return false
+    }
+
+    this[LENGTH] += hit.length
+    this[LRU_LIST].unshift(hit)
+    this[CACHE].set(key, this[LRU_LIST].head)
+    trim(this)
+    return true
+  }
+
+  has (key) {
+    if (!this[CACHE].has(key)) return false
+    const hit = this[CACHE].get(key).value
+    return !isStale(this, hit)
+  }
+
+  get (key) {
+    return get(this, key, true)
+  }
+
+  peek (key) {
+    return get(this, key, false)
+  }
+
+  pop () {
+    const node = this[LRU_LIST].tail
+    if (!node)
+      return null
+
+    del(this, node)
+    return node.value
+  }
+
+  del (key) {
+    del(this, this[CACHE].get(key))
+  }
+
+  load (arr) {
+    // reset the cache
+    this.reset()
+
+    const now = Date.now()
+    // A previous serialized cache has the most recent items first
+    for (let l = arr.length - 1; l >= 0; l--) {
+      const hit = arr[l]
+      const expiresAt = hit.e || 0
+      if (expiresAt === 0)
+        // the item was created without expiration in a non aged cache
+        this.set(hit.k, hit.v)
+      else {
+        const maxAge = expiresAt - now
+        // dont add already expired items
+        if (maxAge > 0) {
+          this.set(hit.k, hit.v, maxAge)
+        }
+      }
+    }
+  }
+
+  prune () {
+    this[CACHE].forEach((value, key) => get(this, key, false))
+  }
+}
+
+const get = (self, key, doUse) => {
+  const node = self[CACHE].get(key)
+  if (node) {
+    const hit = node.value
+    if (isStale(self, hit)) {
+      del(self, node)
+      if (!self[ALLOW_STALE])
+        return undefined
+    } else {
+      if (doUse) {
+        if (self[UPDATE_AGE_ON_GET])
+          node.value.now = Date.now()
+        self[LRU_LIST].unshiftNode(node)
+      }
+    }
+    return hit.value
+  }
+}
+
+const isStale = (self, hit) => {
+  if (!hit || (!hit.maxAge && !self[MAX_AGE]))
+    return false
+
+  const diff = Date.now() - hit.now
+  return hit.maxAge ? diff > hit.maxAge
+    : self[MAX_AGE] && (diff > self[MAX_AGE])
+}
+
+const trim = self => {
+  if (self[LENGTH] > self[MAX]) {
+    for (let walker = self[LRU_LIST].tail;
+      self[LENGTH] > self[MAX] && walker !== null;) {
+      // We know that we're about to delete this one, and also
+      // what the next least recently used key will be, so just
+      // go ahead and set it now.
+      const prev = walker.prev
+      del(self, walker)
+      walker = prev
+    }
+  }
+}
+
+const del = (self, node) => {
+  if (node) {
+    const hit = node.value
+    if (self[DISPOSE])
+      self[DISPOSE](hit.key, hit.value)
+
+    self[LENGTH] -= hit.length
+    self[CACHE].delete(hit.key)
+    self[LRU_LIST].removeNode(node)
+  }
+}
+
+class Entry {
+  constructor (key, value, length, now, maxAge) {
+    this.key = key
+    this.value = value
+    this.length = length
+    this.now = now
+    this.maxAge = maxAge || 0
+  }
+}
+
+const forEachStep = (self, fn, node, thisp) => {
+  let hit = node.value
+  if (isStale(self, hit)) {
+    del(self, node)
+    if (!self[ALLOW_STALE])
+      hit = undefined
+  }
+  if (hit)
+    fn.call(thisp, hit.value, hit.key, self)
+}
+
+module.exports = LRUCache

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/86/RigConfig_8614551e6fbc38bf3f0d0dd1d1150e2e

@@ -0,0 +1,316 @@
+d4586a027bc63ab5b2978cf014a0cc29
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RigConfig = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const nodeResolve = __importStar(require("resolve"));
+const strip_json_comments_1 = __importDefault(require("strip-json-comments"));
+const Helpers_1 = require("./Helpers");
+/**
+ * This is the main API for loading the `config/rig.json` file format.
+ *
+ * @public
+ */
+class RigConfig {
+    constructor(options) {
+        const { projectFolderPath, rigFound, filePath, rigPackageName, rigProfile = 'default' } = options;
+        this.projectFolderOriginalPath = projectFolderPath;
+        this.projectFolderPath = path.resolve(projectFolderPath);
+        this.rigFound = rigFound;
+        this.filePath = filePath;
+        this.rigPackageName = rigPackageName;
+        this.rigProfile = rigProfile;
+        if (this.rigFound) {
+            this.relativeProfileFolderPath = 'profiles/' + this.rigProfile;
+        }
+        else {
+            this.relativeProfileFolderPath = '';
+        }
+    }
+    /**
+     * The JSON contents of the {@link RigConfig.jsonSchemaPath} file.
+     *
+     * @remarks
+     * The JSON object will be lazily loaded when this property getter is accessed, and the result
+     * will be cached.
+     * Accessing this property may make a synchronous filesystem call.
+     */
+    static get jsonSchemaObject() {
+        if (RigConfig._jsonSchemaObject === undefined) {
+            const jsonSchemaContent = fs.readFileSync(RigConfig.jsonSchemaPath).toString();
+            RigConfig._jsonSchemaObject = JSON.parse(jsonSchemaContent);
+        }
+        return RigConfig._jsonSchemaObject;
+    }
+    /**
+     * Use this method to load the `config/rig.json` file for a given project.
+     *
+     * @remarks
+     * If the file cannot be found, an empty `RigConfig` object will be returned with {@link RigConfig.rigFound}
+     * equal to `false`.
+     */
+    static loadForProjectFolder(options) {
+        const { overrideRigJsonObject, projectFolderPath } = options;
+        const fromCache = !options.bypassCache && !overrideRigJsonObject
+            ? RigConfig._configCache.get(projectFolderPath)
+            : undefined;
+        if (fromCache) {
+            return fromCache;
+        }
+        const rigConfigFilePath = path.join(projectFolderPath, 'config/rig.json');
+        let config;
+        let json = overrideRigJsonObject;
+        try {
+            if (!json) {
+                const rigConfigFileContent = fs.readFileSync(rigConfigFilePath).toString();
+                json = JSON.parse((0, strip_json_comments_1.default)(rigConfigFileContent));
+            }
+            RigConfig._validateSchema(json);
+        }
+        catch (error) {
+            config = RigConfig._handleConfigError(error, projectFolderPath, rigConfigFilePath);
+        }
+        if (!config) {
+            config = new RigConfig({
+                projectFolderPath: projectFolderPath,
+                rigFound: true,
+                filePath: rigConfigFilePath,
+                rigPackageName: json.rigPackageName,
+                rigProfile: json.rigProfile
+            });
+        }
+        if (!overrideRigJsonObject) {
+            RigConfig._configCache.set(projectFolderPath, config);
+        }
+        return config;
+    }
+    /**
+     * An async variant of {@link RigConfig.loadForProjectFolder}
+     */
+    static async loadForProjectFolderAsync(options) {
+        const { overrideRigJsonObject, projectFolderPath } = options;
+        const fromCache = !options.bypassCache && !overrideRigJsonObject && RigConfig._configCache.get(projectFolderPath);
+        if (fromCache) {
+            return fromCache;
+        }
+        const rigConfigFilePath = path.join(projectFolderPath, 'config/rig.json');
+        let config;
+        let json = overrideRigJsonObject;
+        try {
+            if (!json) {
+                const rigConfigFileContent = (await fs.promises.readFile(rigConfigFilePath)).toString();
+                json = JSON.parse((0, strip_json_comments_1.default)(rigConfigFileContent));
+            }
+            RigConfig._validateSchema(json);
+        }
+        catch (error) {
+            config = RigConfig._handleConfigError(error, projectFolderPath, rigConfigFilePath);
+        }
+        if (!config) {
+            config = new RigConfig({
+                projectFolderPath: projectFolderPath,
+                rigFound: true,
+                filePath: rigConfigFilePath,
+                rigPackageName: json.rigPackageName,
+                rigProfile: json.rigProfile
+            });
+        }
+        if (!overrideRigJsonObject) {
+            RigConfig._configCache.set(projectFolderPath, config);
+        }
+        return config;
+    }
+    static _handleConfigError(error, projectFolderPath, rigConfigFilePath) {
+        if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') {
+            throw new Error(error.message + '\nError loading config file: ' + rigConfigFilePath);
+        }
+        // File not found, i.e. no rig config
+        return new RigConfig({
+            projectFolderPath,
+            rigFound: false,
+            filePath: '',
+            rigPackageName: '',
+            rigProfile: ''
+        });
+    }
+    /**
+     * Performs Node.js module resolution to locate the rig package folder, then returns the absolute path
+     * of the rig profile folder specified by `rig.json`.
+     *
+     * @remarks
+     * If no `rig.json` file was found, then this method throws an error.  The first time this method
+     * is called, the result is cached and will be returned by all subsequent calls.
+     *
+     * Example: `/path/to/your-project/node_modules/example-rig/profiles/example-profile`
+     */
+    getResolvedProfileFolder() {
+        if (this._resolvedRigPackageFolder === undefined) {
+            if (!this.rigFound) {
+                throw new Error('Cannot resolve the rig package because no rig was specified for this project');
+            }
+            const rigPackageJsonModuleSpecifier = `${this.rigPackageName}/package.json`;
+            const resolveOptions = { basedir: this.projectFolderPath };
+            const resolvedRigPackageJsonPath = nodeResolve.sync(rigPackageJsonModuleSpecifier, resolveOptions);
+            this._resolvedRigPackageFolder = path.dirname(resolvedRigPackageJsonPath);
+        }
+        if (this._resolvedProfileFolder === undefined) {
+            this._resolvedProfileFolder = path.join(this._resolvedRigPackageFolder, this.relativeProfileFolderPath);
+            if (!fs.existsSync(this._resolvedProfileFolder)) {
+                throw new Error(`The rig profile "${this.rigProfile}" is not defined` +
+                    ` by the rig package "${this.rigPackageName}"`);
+            }
+        }
+        return this._resolvedProfileFolder;
+    }
+    /**
+     * An async variant of {@link RigConfig.getResolvedProfileFolder}
+     */
+    async getResolvedProfileFolderAsync() {
+        if (this._resolvedRigPackageFolder === undefined) {
+            if (!this.rigFound) {
+                throw new Error('Cannot resolve the rig package because no rig was specified for this project');
+            }
+            const rigPackageJsonModuleSpecifier = `${this.rigPackageName}/package.json`;
+            const resolveOptions = { basedir: this.projectFolderPath };
+            const resolvedRigPackageJsonPath = await Helpers_1.Helpers.nodeResolveAsync(rigPackageJsonModuleSpecifier, resolveOptions);
+            this._resolvedRigPackageFolder = path.dirname(resolvedRigPackageJsonPath);
+        }
+        if (this._resolvedProfileFolder === undefined) {
+            this._resolvedProfileFolder = path.join(this._resolvedRigPackageFolder, this.relativeProfileFolderPath);
+            if (!(await Helpers_1.Helpers.fsExistsAsync(this._resolvedProfileFolder))) {
+                throw new Error(`The rig profile "${this.rigProfile}" is not defined` +
+                    ` by the rig package "${this.rigPackageName}"`);
+            }
+        }
+        return this._resolvedProfileFolder;
+    }
+    /**
+     * This lookup first checks for the specified relative path under `projectFolderPath`; if it does
+     * not exist there, then it checks in the resolved rig profile folder.  If the file is found,
+     * its absolute path is returned. Otherwise, `undefined` is returned.
+     *
+     * @remarks
+     * For example, suppose the rig profile is:
+     *
+     * `/path/to/your-project/node_modules/example-rig/profiles/example-profile`
+     *
+     * And suppose `configFileRelativePath` is `folder/file.json`. Then the following locations will be checked:
+     *
+     * `/path/to/your-project/folder/file.json`
+     *
+     * `/path/to/your-project/node_modules/example-rig/profiles/example-profile/folder/file.json`
+     */
+    tryResolveConfigFilePath(configFileRelativePath) {
+        if (!Helpers_1.Helpers.isDownwardRelative(configFileRelativePath)) {
+            throw new Error('The configFileRelativePath is not a relative path: ' + configFileRelativePath);
+        }
+        const localPath = path.join(this.projectFolderPath, configFileRelativePath);
+        if (fs.existsSync(localPath)) {
+            return localPath;
+        }
+        if (this.rigFound) {
+            const riggedPath = path.join(this.getResolvedProfileFolder(), configFileRelativePath);
+            if (fs.existsSync(riggedPath)) {
+                return riggedPath;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * An async variant of {@link RigConfig.tryResolveConfigFilePath}
+     */
+    async tryResolveConfigFilePathAsync(configFileRelativePath) {
+        if (!Helpers_1.Helpers.isDownwardRelative(configFileRelativePath)) {
+            throw new Error('The configFileRelativePath is not a relative path: ' + configFileRelativePath);
+        }
+        const localPath = path.join(this.projectFolderPath, configFileRelativePath);
+        if (await Helpers_1.Helpers.fsExistsAsync(localPath)) {
+            return localPath;
+        }
+        if (this.rigFound) {
+            const riggedPath = path.join(await this.getResolvedProfileFolderAsync(), configFileRelativePath);
+            if (await Helpers_1.Helpers.fsExistsAsync(riggedPath)) {
+                return riggedPath;
+            }
+        }
+        return undefined;
+    }
+    static _validateSchema(json) {
+        for (const key of Object.getOwnPropertyNames(json)) {
+            switch (key) {
+                case '$schema':
+                case 'rigPackageName':
+                case 'rigProfile':
+                    break;
+                default:
+                    throw new Error(`Unsupported field ${JSON.stringify(key)}`);
+            }
+        }
+        if (!json.rigPackageName) {
+            throw new Error('Missing required field "rigPackageName"');
+        }
+        if (!RigConfig._packageNameRegExp.test(json.rigPackageName)) {
+            throw new Error(`The "rigPackageName" value is not a valid NPM package name: ${JSON.stringify(json.rigPackageName)}`);
+        }
+        if (!RigConfig._rigNameRegExp.test(json.rigPackageName)) {
+            throw new Error(`The "rigPackageName" value is missing the "-rig" suffix: ` + JSON.stringify(json.rigProfile));
+        }
+        if (json.rigProfile !== undefined) {
+            if (!RigConfig._profileNameRegExp.test(json.rigProfile)) {
+                throw new Error(`The profile name must consist of lowercase alphanumeric words separated by hyphens: ` +
+                    JSON.stringify(json.rigProfile));
+            }
+        }
+    }
+}
+exports.RigConfig = RigConfig;
+// For syntax details, see PackageNameParser from @rushstack/node-core-library
+RigConfig._packageNameRegExp = /^(@[A-Za-z0-9\-_\.]+\/)?[A-Za-z0-9\-_\.]+$/;
+// Rig package names must have the "-rig" suffix.
+// Also silently accept "-rig-test" for our build test projects.
+RigConfig._rigNameRegExp = /-rig(-test)?$/;
+// Profiles must be lowercase alphanumeric words separated by hyphens
+RigConfig._profileNameRegExp = /^[a-z0-9_\.]+(\-[a-z0-9_\.]+)*$/;
+/**
+ * Returns the absolute path of the `rig.schema.json` JSON schema file for `config/rig.json`,
+ * which is bundled with this NPM package.
+ *
+ * @remarks
+ * The `RigConfig` class already performs schema validation when loading `rig.json`; however
+ * this schema file may be useful for integration with other validation tools.
+ *
+ * @public
+ */
+RigConfig.jsonSchemaPath = path.resolve(__dirname, './schemas/rig.schema.json');
+RigConfig._jsonSchemaObject = undefined;
+RigConfig._configCache = new Map();
+//# sourceMappingURL=RigConfig.js.map