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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e3/DiscardStdoutTransform_e3ca398d1799ec51a0da3262837e8907

@@ -0,0 +1,94 @@
+2ea95f0c6a0db21966b1983a9cb3de62
+"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.DiscardStdoutTransform = void 0;
+const TerminalTransform_1 = require("./TerminalTransform");
+var State;
+(function (State) {
+    State[State["Okay"] = 0] = "Okay";
+    State[State["StderrFragment"] = 1] = "StderrFragment";
+    State[State["InsertLinefeed"] = 2] = "InsertLinefeed";
+})(State || (State = {}));
+/**
+ * `DiscardStdoutTransform` discards `stdout` chunks while fixing up malformed `stderr` lines.
+ *
+ * @remarks
+ * Suppose that a poorly behaved process produces output like this:
+ *
+ * ```ts
+ * process.stdout.write('Starting operation...\n');
+ * process.stderr.write('An error occurred');
+ * process.stdout.write('\nFinishing up\n');
+ * process.stderr.write('The process completed with errors\n');
+ * ```
+ *
+ * When `stdout` and `stderr` are combined on the console, the mistake in the output would not be noticeable:
+ * ```
+ * Starting operation...
+ * An error occurred
+ * Finishing up
+ * The process completed with errors
+ * ```
+ *
+ * However, if we discard `stdout`, then `stderr` is missing a newline:
+ * ```
+ * An error occurredThe process completed with errors
+ * ```
+ *
+ * Tooling scripts can introduce these sorts of problems via edge cases that are difficult to find and fix.
+ * `DiscardStdoutTransform` can discard the `stdout` stream and fix up `stderr`:
+ *
+ * ```
+ * An error occurred
+ * The process completed with errors
+ * ```
+ *
+ * @privateRemarks
+ * This class is experimental and marked as `@beta`.  The algorithm may need some fine-tuning, or there may
+ * be better solutions to this problem.
+ *
+ * @beta
+ */
+class DiscardStdoutTransform extends TerminalTransform_1.TerminalTransform {
+    constructor(options) {
+        super(options);
+        this._state = State.Okay;
+    }
+    onWriteChunk(chunk) {
+        if (chunk.text.indexOf('\r') >= 0) {
+            throw new Error('DiscardStdoutTransform expects chunks with normalized newlines');
+        }
+        if (chunk.kind === "O" /* TerminalChunkKind.Stdout */) {
+            if (this._state === State.StderrFragment) {
+                if (chunk.text.indexOf('\n') >= 0) {
+                    this._state = State.InsertLinefeed;
+                }
+            }
+        }
+        else if (chunk.kind === "E" /* TerminalChunkKind.Stderr */) {
+            let correctedText;
+            if (this._state === State.InsertLinefeed) {
+                correctedText = '\n' + chunk.text;
+            }
+            else {
+                correctedText = chunk.text;
+            }
+            this.destination.writeChunk({ kind: "E" /* TerminalChunkKind.Stderr */, text: correctedText });
+            if (correctedText.length > 0) {
+                if (correctedText[correctedText.length - 1] === '\n') {
+                    this._state = State.Okay;
+                }
+                else {
+                    this._state = State.StderrFragment;
+                }
+            }
+        }
+        else {
+            this.destination.writeChunk(chunk);
+        }
+    }
+}
+exports.DiscardStdoutTransform = DiscardStdoutTransform;
+//# sourceMappingURL=DiscardStdoutTransform.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e3/PackageJsonLookup_e391de8a3bc029ef14212787d6efef5a

@@ -0,0 +1,328 @@
+53413ea3bb2dc2a62039f646a8b9c484
+"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.PackageJsonLookup = void 0;
+const path = __importStar(require("path"));
+const JsonFile_1 = require("./JsonFile");
+const Constants_1 = require("./Constants");
+const FileSystem_1 = require("./FileSystem");
+/**
+ * This class provides methods for finding the nearest "package.json" for a folder
+ * and retrieving the name of the package.  The results are cached.
+ *
+ * @public
+ */
+class PackageJsonLookup {
+    constructor(parameters) {
+        this._loadExtraFields = false;
+        if (parameters) {
+            if (parameters.loadExtraFields) {
+                this._loadExtraFields = parameters.loadExtraFields;
+            }
+        }
+        this.clearCache();
+    }
+    /**
+     * A singleton instance of `PackageJsonLookup`, which is useful for short-lived processes
+     * that can reasonably assume that the file system will not be modified after the cache
+     * is populated.
+     *
+     * @remarks
+     * For long-running processes that need to clear the cache at appropriate times,
+     * it is recommended to create your own instance of `PackageJsonLookup` instead
+     * of relying on this instance.
+     */
+    static get instance() {
+        if (!PackageJsonLookup._instance) {
+            PackageJsonLookup._instance = new PackageJsonLookup({ loadExtraFields: true });
+        }
+        return PackageJsonLookup._instance;
+    }
+    /**
+     * A helper for loading the caller's own package.json file.
+     *
+     * @remarks
+     *
+     * This function provides a concise and efficient way for an NPM package to report metadata about itself.
+     * For example, a tool might want to report its version.
+     *
+     * The `loadOwnPackageJson()` probes upwards from the caller's folder, expecting to find a package.json file,
+     * which is assumed to be the caller's package.  The result is cached, under the assumption that a tool's
+     * own package.json (and intermediary folders) will never change during the lifetime of the process.
+     *
+     * @example
+     * ```ts
+     * // Report the version of our NPM package
+     * const myPackageVersion: string = PackageJsonLookup.loadOwnPackageJson(__dirname).version;
+     * console.log(`Cool Tool - Version ${myPackageVersion}`);
+     * ```
+     *
+     * @param dirnameOfCaller - The NodeJS `__dirname` macro for the caller.
+     * @returns This function always returns a valid `IPackageJson` object.  If any problems are encountered during
+     * loading, an exception will be thrown instead.
+     */
+    static loadOwnPackageJson(dirnameOfCaller) {
+        const packageJson = PackageJsonLookup.instance.tryLoadPackageJsonFor(dirnameOfCaller);
+        if (packageJson === undefined) {
+            throw new Error(`PackageJsonLookup.loadOwnPackageJson() failed to find the caller's package.json.` +
+                `  The __dirname was: ${dirnameOfCaller}`);
+        }
+        if (packageJson.version !== undefined) {
+            return packageJson;
+        }
+        const errorPath = PackageJsonLookup.instance.tryGetPackageJsonFilePathFor(dirnameOfCaller) || 'package.json';
+        throw new Error(`PackageJsonLookup.loadOwnPackageJson() failed because the "version" field is missing in` +
+            ` ${errorPath}`);
+    }
+    /**
+     * Clears the internal file cache.
+     * @remarks
+     * Call this method if changes have been made to the package.json files on disk.
+     */
+    clearCache() {
+        this._packageFolderCache = new Map();
+        this._packageJsonCache = new Map();
+    }
+    /**
+     * Returns the absolute path of a folder containing a package.json file, by looking
+     * upwards from the specified fileOrFolderPath.  If no package.json can be found,
+     * undefined is returned.
+     *
+     * @remarks
+     * The fileOrFolderPath is not required to actually exist on disk.
+     * The fileOrFolderPath itself can be the return value, if it is a folder containing
+     * a package.json file.
+     * Both positive and negative lookup results are cached.
+     *
+     * @param fileOrFolderPath - a relative or absolute path to a source file or folder
+     * that may be part of a package
+     * @returns an absolute path to a folder containing a package.json file
+     */
+    tryGetPackageFolderFor(fileOrFolderPath) {
+        // Convert it to an absolute path
+        const resolvedFileOrFolderPath = path.resolve(fileOrFolderPath);
+        // Optimistically hope that the starting string is already in the cache,
+        // in which case we can avoid disk access entirely.
+        //
+        // (Two lookups are required, because get() cannot distinguish the undefined value
+        // versus a missing key.)
+        if (this._packageFolderCache.has(resolvedFileOrFolderPath)) {
+            return this._packageFolderCache.get(resolvedFileOrFolderPath);
+        }
+        // Now call the recursive part of the algorithm
+        return this._tryGetPackageFolderFor(resolvedFileOrFolderPath);
+    }
+    /**
+     * If the specified file or folder is part of a package, this returns the absolute path
+     * to the associated package.json file.
+     *
+     * @remarks
+     * The package folder is determined using the same algorithm
+     * as {@link PackageJsonLookup.tryGetPackageFolderFor}.
+     *
+     * @param fileOrFolderPath - a relative or absolute path to a source file or folder
+     * that may be part of a package
+     * @returns an absolute path to * package.json file
+     */
+    tryGetPackageJsonFilePathFor(fileOrFolderPath) {
+        const packageJsonFolder = this.tryGetPackageFolderFor(fileOrFolderPath);
+        if (!packageJsonFolder) {
+            return undefined;
+        }
+        return path.join(packageJsonFolder, Constants_1.FileConstants.PackageJson);
+    }
+    /**
+     * If the specified file or folder is part of a package, this loads and returns the
+     * associated package.json file.
+     *
+     * @remarks
+     * The package folder is determined using the same algorithm
+     * as {@link PackageJsonLookup.tryGetPackageFolderFor}.
+     *
+     * @param fileOrFolderPath - a relative or absolute path to a source file or folder
+     * that may be part of a package
+     * @returns an IPackageJson object, or undefined if the fileOrFolderPath does not
+     * belong to a package
+     */
+    tryLoadPackageJsonFor(fileOrFolderPath) {
+        const packageJsonFilePath = this.tryGetPackageJsonFilePathFor(fileOrFolderPath);
+        if (!packageJsonFilePath) {
+            return undefined;
+        }
+        return this.loadPackageJson(packageJsonFilePath);
+    }
+    /**
+     * This function is similar to {@link PackageJsonLookup.tryLoadPackageJsonFor}, except that it does not report
+     * an error if the `version` field is missing from the package.json file.
+     */
+    tryLoadNodePackageJsonFor(fileOrFolderPath) {
+        const packageJsonFilePath = this.tryGetPackageJsonFilePathFor(fileOrFolderPath);
+        if (!packageJsonFilePath) {
+            return undefined;
+        }
+        return this.loadNodePackageJson(packageJsonFilePath);
+    }
+    /**
+     * Loads the specified package.json file, if it is not already present in the cache.
+     *
+     * @remarks
+     * Unless {@link IPackageJsonLookupParameters.loadExtraFields} was specified,
+     * the returned IPackageJson object will contain a subset of essential fields.
+     * The returned object should be considered to be immutable; the caller must never
+     * modify it.
+     *
+     * @param jsonFilename - a relative or absolute path to a package.json file
+     */
+    loadPackageJson(jsonFilename) {
+        const packageJson = this.loadNodePackageJson(jsonFilename);
+        if (!packageJson.version) {
+            throw new Error(`Error reading "${jsonFilename}":\n  The required field "version" was not found`);
+        }
+        return packageJson;
+    }
+    /**
+     * This function is similar to {@link PackageJsonLookup.loadPackageJson}, except that it does not report an error
+     * if the `version` field is missing from the package.json file.
+     */
+    loadNodePackageJson(jsonFilename) {
+        return this._loadPackageJsonInner(jsonFilename);
+    }
+    _loadPackageJsonInner(jsonFilename, errorsToIgnore) {
+        const loadResult = this._tryLoadNodePackageJsonInner(jsonFilename);
+        if (loadResult.error && (errorsToIgnore === null || errorsToIgnore === void 0 ? void 0 : errorsToIgnore.has(loadResult.error))) {
+            return undefined;
+        }
+        switch (loadResult.error) {
+            case 'FILE_NOT_FOUND': {
+                throw new Error(`Input file not found: ${jsonFilename}`);
+            }
+            case 'MISSING_NAME_FIELD': {
+                throw new Error(`Error reading "${jsonFilename}":\n  The required field "name" was not found`);
+            }
+            case 'OTHER_ERROR': {
+                throw loadResult.errorObject;
+            }
+            default: {
+                return loadResult.packageJson;
+            }
+        }
+    }
+    /**
+     * Try to load a package.json file as an INodePackageJson,
+     * returning undefined if the found file does not contain a `name` field.
+     */
+    _tryLoadNodePackageJsonInner(jsonFilename) {
+        // Since this will be a cache key, follow any symlinks and get an absolute path
+        // to minimize duplication.  (Note that duplication can still occur due to e.g. character case.)
+        let normalizedFilePath;
+        try {
+            normalizedFilePath = FileSystem_1.FileSystem.getRealPath(jsonFilename);
+        }
+        catch (e) {
+            if (FileSystem_1.FileSystem.isNotExistError(e)) {
+                return {
+                    error: 'FILE_NOT_FOUND'
+                };
+            }
+            else {
+                return {
+                    error: 'OTHER_ERROR',
+                    errorObject: e
+                };
+            }
+        }
+        let packageJson = this._packageJsonCache.get(normalizedFilePath);
+        if (!packageJson) {
+            const loadedPackageJson = JsonFile_1.JsonFile.load(normalizedFilePath);
+            // Make sure this is really a package.json file.  CommonJS has fairly strict requirements,
+            // but NPM only requires "name" and "version"
+            if (!loadedPackageJson.name) {
+                return {
+                    error: 'MISSING_NAME_FIELD'
+                };
+            }
+            if (this._loadExtraFields) {
+                packageJson = loadedPackageJson;
+            }
+            else {
+                packageJson = {};
+                // Unless "loadExtraFields" was requested, copy over the essential fields only
+                packageJson.bin = loadedPackageJson.bin;
+                packageJson.dependencies = loadedPackageJson.dependencies;
+                packageJson.description = loadedPackageJson.description;
+                packageJson.devDependencies = loadedPackageJson.devDependencies;
+                packageJson.homepage = loadedPackageJson.homepage;
+                packageJson.license = loadedPackageJson.license;
+                packageJson.main = loadedPackageJson.main;
+                packageJson.name = loadedPackageJson.name;
+                packageJson.optionalDependencies = loadedPackageJson.optionalDependencies;
+                packageJson.peerDependencies = loadedPackageJson.peerDependencies;
+                packageJson.private = loadedPackageJson.private;
+                packageJson.scripts = loadedPackageJson.scripts;
+                packageJson.typings = loadedPackageJson.typings || loadedPackageJson.types;
+                packageJson.tsdocMetadata = loadedPackageJson.tsdocMetadata;
+                packageJson.version = loadedPackageJson.version;
+            }
+            Object.freeze(packageJson);
+            this._packageJsonCache.set(normalizedFilePath, packageJson);
+        }
+        return {
+            packageJson
+        };
+    }
+    // Recursive part of the algorithm from tryGetPackageFolderFor()
+    _tryGetPackageFolderFor(resolvedFileOrFolderPath) {
+        // Two lookups are required, because get() cannot distinguish the undefined value
+        // versus a missing key.
+        if (this._packageFolderCache.has(resolvedFileOrFolderPath)) {
+            return this._packageFolderCache.get(resolvedFileOrFolderPath);
+        }
+        // Is resolvedFileOrFolderPath itself a folder with a valid package.json file?  If so, return it.
+        const packageJsonFilePath = `${resolvedFileOrFolderPath}/${Constants_1.FileConstants.PackageJson}`;
+        const packageJson = this._loadPackageJsonInner(packageJsonFilePath, new Set(['FILE_NOT_FOUND', 'MISSING_NAME_FIELD']));
+        if (packageJson) {
+            this._packageFolderCache.set(resolvedFileOrFolderPath, resolvedFileOrFolderPath);
+            return resolvedFileOrFolderPath;
+        }
+        // Otherwise go up one level
+        const parentFolder = path.dirname(resolvedFileOrFolderPath);
+        if (!parentFolder || parentFolder === resolvedFileOrFolderPath) {
+            // We reached the root directory without finding a package.json file,
+            // so cache the negative result
+            this._packageFolderCache.set(resolvedFileOrFolderPath, undefined);
+            return undefined; // no match
+        }
+        // Recurse upwards, caching every step along the way
+        const parentResult = this._tryGetPackageFolderFor(parentFolder);
+        // Cache the parent's answer as well
+        this._packageFolderCache.set(resolvedFileOrFolderPath, parentResult);
+        return parentResult;
+    }
+}
+exports.PackageJsonLookup = PackageJsonLookup;
+//# sourceMappingURL=PackageJsonLookup.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e4/lte_e41aef5564169e2c9a26d71b55ac32cc

@@ -0,0 +1,4 @@
+bd1875ed01c16e0bf753352e775cfc3d
+const compare = require('./compare')
+const lte = (a, b, loose) => compare(a, b, loose) <= 0
+module.exports = lte

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e4/minversion_e4899cb3e82f3792e99b5d72895f46d7

@@ -0,0 +1,62 @@
+04dab32f676a52ee4c81f440eb1b5d6c
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const gt = require('../functions/gt')
+
+const minVersion = (range, loose) => {
+  range = new Range(range, loose)
+
+  let minver = new SemVer('0.0.0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = new SemVer('0.0.0-0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = null
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let setMin = null
+    comparators.forEach((comparator) => {
+      // Clone to avoid manipulating the comparator's semver object.
+      const compver = new SemVer(comparator.semver.version)
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++
+          } else {
+            compver.prerelease.push(0)
+          }
+          compver.raw = compver.format()
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!setMin || gt(compver, setMin)) {
+            setMin = compver
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Unexpected operation: ${comparator.operator}`)
+      }
+    })
+    if (setMin && (!minver || gt(minver, setMin))) {
+      minver = setMin
+    }
+  }
+
+  if (minver && range.test(minver)) {
+    return minver
+  }
+
+  return null
+}
+module.exports = minVersion

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e4/styles_e45b23904077bb02545672de0f04ca03

@@ -0,0 +1,78 @@
+520f9c71e307bed4892d132348bd5f74
+/*
+The MIT License (MIT)
+
+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.
+
+*/
+
+var styles = {};
+module['exports'] = styles;
+
+var codes = {
+  reset: [0, 0],
+
+  bold: [1, 22],
+  dim: [2, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  gray: [90, 39],
+  grey: [90, 39],
+
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+
+  // legacy styles for colors pre v1.0.0
+  blackBG: [40, 49],
+  redBG: [41, 49],
+  greenBG: [42, 49],
+  yellowBG: [43, 49],
+  blueBG: [44, 49],
+  magentaBG: [45, 49],
+  cyanBG: [46, 49],
+  whiteBG: [47, 49],
+
+};
+
+Object.keys(codes).forEach(function(key) {
+  var val = codes[key];
+  var style = styles[key] = [];
+  style.open = '\u001b[' + val[0] + 'm';
+  style.close = '\u001b[' + val[1] + 'm';
+});

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e5/Constants_e5916bdbd55b7c5751c61c22c2d8ac34

@@ -0,0 +1,35 @@
+39bac73ca8d48c1bfdd6d2c1ae9dcd56
+"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.FolderConstants = exports.FileConstants = void 0;
+/**
+ * String constants for common filenames and parts of filenames.
+ *
+ * @public
+ */
+var FileConstants;
+(function (FileConstants) {
+    /**
+     * "package.json" - the configuration file that defines an NPM package
+     */
+    FileConstants["PackageJson"] = "package.json";
+})(FileConstants = exports.FileConstants || (exports.FileConstants = {}));
+/**
+ * String constants for common folder names.
+ *
+ * @public
+ */
+var FolderConstants;
+(function (FolderConstants) {
+    /**
+     * ".git" - the data storage for a Git working folder
+     */
+    FolderConstants["Git"] = ".git";
+    /**
+     * "node_modules" - the folder where package managers install their files
+     */
+    FolderConstants["NodeModules"] = "node_modules";
+})(FolderConstants = exports.FolderConstants || (exports.FolderConstants = {}));
+//# sourceMappingURL=Constants.js.map