@wo658/redpact 0.3.0 → 0.5.0

package/node_modules/@rushstack/node-core-library/lib/TypeUuid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeUuid.js","sourceRoot":"","sources":["../src/TypeUuid.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,mDAAgD;AAEhD,MAAM,wBAAwB,GAAW,MAAM,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAa,QAAQ;IAGnB;;;;OAIG;IACH,8DAA8D;IACvD,MAAM,CAAC,aAAa,CAAC,WAAgB,EAAE,QAAgB;QAC5D,IAAI,OAAO,WAAW,KAAK,UAAU,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;QAC1E,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CAAC,0EAA0E,QAAQ,GAAG,CAAC,CAAC;QACzG,CAAC;QAED,8DAA8D;QAC9D,MAAM,oBAAoB,GAAQ,WAAW,CAAC,SAAS,CAAC;QAExD,IAAI,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,oBAAoB,EAAE,wBAAwB,CAAC,EAAE,CAAC;YAC/E,MAAM,YAAY,GAAW,oBAAoB,CAAC,wBAAwB,CAAC,CAAC;YAC5E,MAAM,IAAI,6BAAa,CACrB,oCAAoC,WAAW,CAAC,IAAI,IAAI,EAAE,aAAa,QAAQ,EAAE;gBAC/E,oDAAoD,YAAY,EAAE,CACrE,CAAC;QACJ,CAAC;QACD,oBAAoB,CAAC,wBAAwB,CAAC,GAAG,QAAQ,CAAC;IAC5D,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,YAAY,CAAC,YAAqB,EAAE,QAAgB;QAChE,IAAI,YAAY,KAAK,SAAS,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YACxD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,eAAe,GAAO,MAAM,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;QAC9D,OAAO,eAAe,KAAK,SAAS,IAAI,eAAe,KAAK,IAAI,EAAE,CAAC;YACjE,8DAA8D;YAC9D,MAAM,cAAc,GAAY,eAAuB,CAAC,wBAAwB,CAAC,CAAC;YAClF,IAAI,cAAc,KAAK,QAAQ,EAAE,CAAC;gBAChC,OAAO,IAAI,CAAC;YACd,CAAC;YACD,gDAAgD;YAChD,eAAe,GAAG,MAAM,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;;AApDH,4BAqDC;AApDgB,oBAAW,GAAW,gEAAgE,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport { InternalError } from './InternalError';\n\nconst classPrototypeUuidSymbol: symbol = Symbol.for('TypeUuid.classPrototypeUuid');\n\n/**\n * Provides a version-independent implementation of the JavaScript `instanceof` operator.\n *\n * @remarks\n * The JavaScript `instanceof` operator normally only identifies objects from a particular library instance.\n * For example, suppose the NPM package `example-lib` has two published versions 1.2.0 and 1.3.0, and\n * it exports a class called `A`.  Suppose some code consumes version `1.3.0` of the library, but it receives\n * an object that was constructed using version `1.2.0`.  In this situation `a instanceof A` will return `false`,\n * even though `a` is an instance of `A`.  The reason is that there are two prototypes for `A`; one for each\n * version.\n *\n * The `TypeUuid` facility provides a way to make `a instanceof A` return true for both prototypes of `A`,\n * by instead using a universally unique identifier (UUID) to detect object instances.\n *\n * You can use `Symbol.hasInstance` to enable the system `instanceof` operator to recognize type UUID equivalence:\n * ```ts\n * const uuidWidget: string = '9c340ef0-d29f-4e2e-a09f-42bacc59024b';\n * class Widget {\n *   public static [Symbol.hasInstance](instance: object): boolean {\n *     return TypeUuid.isInstanceOf(instance, uuidWidget);\n *   }\n * }\n * ```\n * // Example usage:\n * ```ts\n * import { Widget as Widget1 } from 'v1-of-library';\n * import { Widget as Widget2 } from 'v2-of-library';\n * const widget = new Widget2();\n * console.log(widget instanceof Widget1); // prints true\n * ```\n *\n * @public\n */\nexport class TypeUuid {\n  private static _uuidRegExp: RegExp = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;\n\n  /**\n   * Registers a JavaScript class as having a type identified by the specified UUID.\n   * @privateRemarks\n   * We cannot use a construct signature for `targetClass` because it may be an abstract class.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public static registerClass(targetClass: any, typeUuid: string): void {\n    if (typeof targetClass !== 'function') {\n      throw new Error('The targetClass parameter must be a JavaScript class');\n    }\n\n    if (!TypeUuid._uuidRegExp.test(typeUuid)) {\n      throw new Error(`The type UUID must be specified as lowercase hexadecimal with dashes: \"${typeUuid}\"`);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const targetClassPrototype: any = targetClass.prototype;\n\n    if (Object.hasOwnProperty.call(targetClassPrototype, classPrototypeUuidSymbol)) {\n      const existingUuid: string = targetClassPrototype[classPrototypeUuidSymbol];\n      throw new InternalError(\n        `Cannot register the target class ${targetClass.name || ''} typeUuid=${typeUuid}` +\n          ` because it was already registered with typeUuid=${existingUuid}`\n      );\n    }\n    targetClassPrototype[classPrototypeUuidSymbol] = typeUuid;\n  }\n\n  /**\n   * Returns true if the `targetObject` is an instance of a JavaScript class that was previously\n   * registered using the specified `typeUuid`.  Base classes are also considered.\n   */\n  public static isInstanceOf(targetObject: unknown, typeUuid: string): boolean {\n    if (targetObject === undefined || targetObject === null) {\n      return false;\n    }\n\n    let objectPrototype: {} = Object.getPrototypeOf(targetObject);\n    while (objectPrototype !== undefined && objectPrototype !== null) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const registeredUuid: string = (objectPrototype as any)[classPrototypeUuidSymbol];\n      if (registeredUuid === typeUuid) {\n        return true;\n      }\n      // Walk upwards an examine base class prototypes\n      objectPrototype = Object.getPrototypeOf(objectPrototype);\n    }\n\n    return false;\n  }\n}\n"]}

package/node_modules/@rushstack/node-core-library/lib/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" preserve="true" />
+/**
+ * Core libraries that every NodeJS toolchain project should use.
+ *
+ * @packageDocumentation
+ */
+export { AlreadyReportedError } from './AlreadyReportedError';
+export { Async, AsyncQueue, type IAsyncParallelismOptions, type IRunWithRetriesOptions, type IWeighted } from './Async';
+export type { Brand } from './PrimitiveTypes';
+export { FileConstants, FolderConstants } from './Constants';
+export { Enum } from './Enum';
+export { EnvironmentMap, type IEnvironmentEntry } from './EnvironmentMap';
+export { type ExecutableStdioStreamMapping, type ExecutableStdioMapping, type IExecutableResolveOptions, type IExecutableSpawnSyncOptions, type IExecutableSpawnOptions, type IWaitForExitOptions, type IWaitForExitWithBufferOptions, type IWaitForExitWithStringOptions, type IWaitForExitResult, type IProcessInfo, Executable } from './Executable';
+export { type IFileErrorOptions, type IFileErrorFormattingOptions, FileError } from './FileError';
+export type { INodePackageJson, IPackageJson, IPackageJsonDependencyTable, IPackageJsonScriptTable, IPackageJsonRepository, IPeerDependenciesMetaTable, IDependenciesMetaTable, IPackageJsonExports } from './IPackageJson';
+export { Import, type IImportResolveOptions, type IImportResolveAsyncOptions, type IImportResolveModuleOptions, type IImportResolveModuleAsyncOptions, type IImportResolvePackageOptions, type IImportResolvePackageAsyncOptions } from './Import';
+export { InternalError } from './InternalError';
+export { type JsonObject, type JsonNull, JsonSyntax, type IJsonFileParseOptions, type IJsonFileLoadAndValidateOptions, type IJsonFileStringifyOptions, type IJsonFileSaveOptions, JsonFile } from './JsonFile';
+export { type IJsonSchemaErrorInfo, type IJsonSchemaCustomFormat, type IJsonSchemaFromFileOptions, type IJsonSchemaFromObjectOptions, type IJsonSchemaLoadOptions, type IJsonSchemaValidateOptions, type IJsonSchemaValidateObjectWithOptions, JsonSchema, type JsonSchemaVersion } from './JsonSchema';
+export { LockFile } from './LockFile';
+export { MapExtensions } from './MapExtensions';
+export { MinimumHeap } from './MinimumHeap';
+export { PosixModeBits } from './PosixModeBits';
+export { ProtectableMap, type IProtectableMapParameters } from './ProtectableMap';
+export { type IPackageJsonLookupParameters, PackageJsonLookup } from './PackageJsonLookup';
+export { PackageName, PackageNameParser, type IPackageNameParserOptions, type IParsedPackageName, type IParsedPackageNameOrError } from './PackageName';
+export { Path, type FileLocationStyle, type IPathFormatFileLocationOptions, type IPathFormatConciselyOptions } from './Path';
+export { RealNodeModulePathResolver, type IRealNodeModulePathResolverOptions } from './RealNodeModulePath';
+export { Encoding, Text, NewlineKind, type IReadLinesFromIterableOptions } from './Text';
+export { Sort } from './Sort';
+export { AlreadyExistsBehavior, FileSystem, type FileSystemCopyFilesAsyncFilter, type FileSystemCopyFilesFilter, type FolderItem, type FileSystemStats, type IFileSystemCopyFileBaseOptions, type IFileSystemCopyFileOptions, type IFileSystemCopyFilesAsyncOptions, type IFileSystemCopyFilesOptions, type IFileSystemCreateLinkOptions, type IFileSystemDeleteFileOptions, type IFileSystemMoveOptions, type IFileSystemReadFileOptions, type IFileSystemReadFolderOptions, type IFileSystemUpdateTimeParameters, type IFileSystemWriteBinaryFileOptions, type IFileSystemWriteFileOptions } from './FileSystem';
+export { FileWriter, type IFileWriterFlags } from './FileWriter';
+export { LegacyAdapters, type LegacyCallback } from './LegacyAdapters';
+export { StringBuilder, type IStringBuilder } from './StringBuilder';
+export { type ISubprocessOptions, SubprocessTerminator } from './SubprocessTerminator';
+export { TypeUuid } from './TypeUuid';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@rushstack/node-core-library/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/node_modules/@rushstack/node-core-library/lib/index.js

@@ -0,0 +1,75 @@
+"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.TypeUuid = exports.SubprocessTerminator = exports.StringBuilder = exports.LegacyAdapters = exports.FileWriter = exports.FileSystem = exports.AlreadyExistsBehavior = exports.Sort = exports.NewlineKind = exports.Text = exports.Encoding = exports.RealNodeModulePathResolver = exports.Path = exports.PackageNameParser = exports.PackageName = exports.PackageJsonLookup = exports.ProtectableMap = exports.PosixModeBits = exports.MinimumHeap = exports.MapExtensions = exports.LockFile = exports.JsonSchema = exports.JsonFile = exports.JsonSyntax = exports.InternalError = exports.Import = exports.FileError = exports.Executable = exports.EnvironmentMap = exports.Enum = exports.FolderConstants = exports.FileConstants = exports.AsyncQueue = exports.Async = exports.AlreadyReportedError = void 0;
+/// <reference types="node" preserve="true" />
+/**
+ * Core libraries that every NodeJS toolchain project should use.
+ *
+ * @packageDocumentation
+ */
+var AlreadyReportedError_1 = require("./AlreadyReportedError");
+Object.defineProperty(exports, "AlreadyReportedError", { enumerable: true, get: function () { return AlreadyReportedError_1.AlreadyReportedError; } });
+var Async_1 = require("./Async");
+Object.defineProperty(exports, "Async", { enumerable: true, get: function () { return Async_1.Async; } });
+Object.defineProperty(exports, "AsyncQueue", { enumerable: true, get: function () { return Async_1.AsyncQueue; } });
+var Constants_1 = require("./Constants");
+Object.defineProperty(exports, "FileConstants", { enumerable: true, get: function () { return Constants_1.FileConstants; } });
+Object.defineProperty(exports, "FolderConstants", { enumerable: true, get: function () { return Constants_1.FolderConstants; } });
+var Enum_1 = require("./Enum");
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return Enum_1.Enum; } });
+var EnvironmentMap_1 = require("./EnvironmentMap");
+Object.defineProperty(exports, "EnvironmentMap", { enumerable: true, get: function () { return EnvironmentMap_1.EnvironmentMap; } });
+var Executable_1 = require("./Executable");
+Object.defineProperty(exports, "Executable", { enumerable: true, get: function () { return Executable_1.Executable; } });
+var FileError_1 = require("./FileError");
+Object.defineProperty(exports, "FileError", { enumerable: true, get: function () { return FileError_1.FileError; } });
+var Import_1 = require("./Import");
+Object.defineProperty(exports, "Import", { enumerable: true, get: function () { return Import_1.Import; } });
+var InternalError_1 = require("./InternalError");
+Object.defineProperty(exports, "InternalError", { enumerable: true, get: function () { return InternalError_1.InternalError; } });
+var JsonFile_1 = require("./JsonFile");
+Object.defineProperty(exports, "JsonSyntax", { enumerable: true, get: function () { return JsonFile_1.JsonSyntax; } });
+Object.defineProperty(exports, "JsonFile", { enumerable: true, get: function () { return JsonFile_1.JsonFile; } });
+var JsonSchema_1 = require("./JsonSchema");
+Object.defineProperty(exports, "JsonSchema", { enumerable: true, get: function () { return JsonSchema_1.JsonSchema; } });
+var LockFile_1 = require("./LockFile");
+Object.defineProperty(exports, "LockFile", { enumerable: true, get: function () { return LockFile_1.LockFile; } });
+var MapExtensions_1 = require("./MapExtensions");
+Object.defineProperty(exports, "MapExtensions", { enumerable: true, get: function () { return MapExtensions_1.MapExtensions; } });
+var MinimumHeap_1 = require("./MinimumHeap");
+Object.defineProperty(exports, "MinimumHeap", { enumerable: true, get: function () { return MinimumHeap_1.MinimumHeap; } });
+var PosixModeBits_1 = require("./PosixModeBits");
+Object.defineProperty(exports, "PosixModeBits", { enumerable: true, get: function () { return PosixModeBits_1.PosixModeBits; } });
+var ProtectableMap_1 = require("./ProtectableMap");
+Object.defineProperty(exports, "ProtectableMap", { enumerable: true, get: function () { return ProtectableMap_1.ProtectableMap; } });
+var PackageJsonLookup_1 = require("./PackageJsonLookup");
+Object.defineProperty(exports, "PackageJsonLookup", { enumerable: true, get: function () { return PackageJsonLookup_1.PackageJsonLookup; } });
+var PackageName_1 = require("./PackageName");
+Object.defineProperty(exports, "PackageName", { enumerable: true, get: function () { return PackageName_1.PackageName; } });
+Object.defineProperty(exports, "PackageNameParser", { enumerable: true, get: function () { return PackageName_1.PackageNameParser; } });
+var Path_1 = require("./Path");
+Object.defineProperty(exports, "Path", { enumerable: true, get: function () { return Path_1.Path; } });
+var RealNodeModulePath_1 = require("./RealNodeModulePath");
+Object.defineProperty(exports, "RealNodeModulePathResolver", { enumerable: true, get: function () { return RealNodeModulePath_1.RealNodeModulePathResolver; } });
+var Text_1 = require("./Text");
+Object.defineProperty(exports, "Encoding", { enumerable: true, get: function () { return Text_1.Encoding; } });
+Object.defineProperty(exports, "Text", { enumerable: true, get: function () { return Text_1.Text; } });
+Object.defineProperty(exports, "NewlineKind", { enumerable: true, get: function () { return Text_1.NewlineKind; } });
+var Sort_1 = require("./Sort");
+Object.defineProperty(exports, "Sort", { enumerable: true, get: function () { return Sort_1.Sort; } });
+var FileSystem_1 = require("./FileSystem");
+Object.defineProperty(exports, "AlreadyExistsBehavior", { enumerable: true, get: function () { return FileSystem_1.AlreadyExistsBehavior; } });
+Object.defineProperty(exports, "FileSystem", { enumerable: true, get: function () { return FileSystem_1.FileSystem; } });
+var FileWriter_1 = require("./FileWriter");
+Object.defineProperty(exports, "FileWriter", { enumerable: true, get: function () { return FileWriter_1.FileWriter; } });
+var LegacyAdapters_1 = require("./LegacyAdapters");
+Object.defineProperty(exports, "LegacyAdapters", { enumerable: true, get: function () { return LegacyAdapters_1.LegacyAdapters; } });
+var StringBuilder_1 = require("./StringBuilder");
+Object.defineProperty(exports, "StringBuilder", { enumerable: true, get: function () { return StringBuilder_1.StringBuilder; } });
+var SubprocessTerminator_1 = require("./SubprocessTerminator");
+Object.defineProperty(exports, "SubprocessTerminator", { enumerable: true, get: function () { return SubprocessTerminator_1.SubprocessTerminator; } });
+var TypeUuid_1 = require("./TypeUuid");
+Object.defineProperty(exports, "TypeUuid", { enumerable: true, get: function () { return TypeUuid_1.TypeUuid; } });
+//# sourceMappingURL=index.js.map

package/node_modules/@rushstack/node-core-library/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D,8CAA8C;AAE9C;;;;GAIG;AAEH,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA;AAC7B,iCAMiB;AALf,8FAAA,KAAK,OAAA;AACL,mGAAA,UAAU,OAAA;AAMZ,yCAA6D;AAApD,0GAAA,aAAa,OAAA;AAAE,4GAAA,eAAe,OAAA;AACvC,+BAA8B;AAArB,4FAAA,IAAI,OAAA;AACb,mDAA0E;AAAjE,gHAAA,cAAc,OAAA;AACvB,2CAYsB;AADpB,wGAAA,UAAU,OAAA;AAEZ,yCAAkG;AAA/B,sGAAA,SAAS,OAAA;AAW5E,mCAQkB;AAPhB,gGAAA,MAAM,OAAA;AAQR,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,uCASoB;AANlB,sGAAA,UAAU,OAAA;AAKV,oGAAA,QAAQ,OAAA;AAEV,2CAUsB;AAFpB,wGAAA,UAAU,OAAA;AAGZ,uCAAsC;AAA7B,oGAAA,QAAQ,OAAA;AACjB,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,6CAA4C;AAAnC,0GAAA,WAAW,OAAA;AACpB,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AACtB,mDAAkF;AAAzE,gHAAA,cAAc,OAAA;AACvB,yDAA2F;AAA/C,sHAAA,iBAAiB,OAAA;AAC7D,6CAMuB;AALrB,0GAAA,WAAW,OAAA;AACX,gHAAA,iBAAiB,OAAA;AAKnB,+BAKgB;AAJd,4FAAA,IAAI,OAAA;AAKN,2DAA2G;AAAlG,gIAAA,0BAA0B,OAAA;AACnC,+BAAyF;AAAhF,gGAAA,QAAQ,OAAA;AAAE,4FAAA,IAAI,OAAA;AAAE,mGAAA,WAAW,OAAA;AACpC,+BAA8B;AAArB,4FAAA,IAAI,OAAA;AACb,2CAmBsB;AAlBpB,mHAAA,qBAAqB,OAAA;AACrB,wGAAA,UAAU,OAAA;AAkBZ,2CAAiE;AAAxD,wGAAA,UAAU,OAAA;AACnB,mDAAuE;AAA9D,gHAAA,cAAc,OAAA;AACvB,iDAAqE;AAA5D,8GAAA,aAAa,OAAA;AACtB,+DAAuF;AAArD,4HAAA,oBAAoB,OAAA;AACtD,uCAAsC;AAA7B,oGAAA,QAAQ,OAAA","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/// <reference types=\"node\" preserve=\"true\" />\n\n/**\n * Core libraries that every NodeJS toolchain project should use.\n *\n * @packageDocumentation\n */\n\nexport { AlreadyReportedError } from './AlreadyReportedError';\nexport {\n  Async,\n  AsyncQueue,\n  type IAsyncParallelismOptions,\n  type IRunWithRetriesOptions,\n  type IWeighted\n} from './Async';\nexport type { Brand } from './PrimitiveTypes';\nexport { FileConstants, FolderConstants } from './Constants';\nexport { Enum } from './Enum';\nexport { EnvironmentMap, type IEnvironmentEntry } from './EnvironmentMap';\nexport {\n  type ExecutableStdioStreamMapping,\n  type ExecutableStdioMapping,\n  type IExecutableResolveOptions,\n  type IExecutableSpawnSyncOptions,\n  type IExecutableSpawnOptions,\n  type IWaitForExitOptions,\n  type IWaitForExitWithBufferOptions,\n  type IWaitForExitWithStringOptions,\n  type IWaitForExitResult,\n  type IProcessInfo,\n  Executable\n} from './Executable';\nexport { type IFileErrorOptions, type IFileErrorFormattingOptions, FileError } from './FileError';\nexport type {\n  INodePackageJson,\n  IPackageJson,\n  IPackageJsonDependencyTable,\n  IPackageJsonScriptTable,\n  IPackageJsonRepository,\n  IPeerDependenciesMetaTable,\n  IDependenciesMetaTable,\n  IPackageJsonExports\n} from './IPackageJson';\nexport {\n  Import,\n  type IImportResolveOptions,\n  type IImportResolveAsyncOptions,\n  type IImportResolveModuleOptions,\n  type IImportResolveModuleAsyncOptions,\n  type IImportResolvePackageOptions,\n  type IImportResolvePackageAsyncOptions\n} from './Import';\nexport { InternalError } from './InternalError';\nexport {\n  type JsonObject,\n  type JsonNull,\n  JsonSyntax,\n  type IJsonFileParseOptions,\n  type IJsonFileLoadAndValidateOptions,\n  type IJsonFileStringifyOptions,\n  type IJsonFileSaveOptions,\n  JsonFile\n} from './JsonFile';\nexport {\n  type IJsonSchemaErrorInfo,\n  type IJsonSchemaCustomFormat,\n  type IJsonSchemaFromFileOptions,\n  type IJsonSchemaFromObjectOptions,\n  type IJsonSchemaLoadOptions,\n  type IJsonSchemaValidateOptions,\n  type IJsonSchemaValidateObjectWithOptions,\n  JsonSchema,\n  type JsonSchemaVersion\n} from './JsonSchema';\nexport { LockFile } from './LockFile';\nexport { MapExtensions } from './MapExtensions';\nexport { MinimumHeap } from './MinimumHeap';\nexport { PosixModeBits } from './PosixModeBits';\nexport { ProtectableMap, type IProtectableMapParameters } from './ProtectableMap';\nexport { type IPackageJsonLookupParameters, PackageJsonLookup } from './PackageJsonLookup';\nexport {\n  PackageName,\n  PackageNameParser,\n  type IPackageNameParserOptions,\n  type IParsedPackageName,\n  type IParsedPackageNameOrError\n} from './PackageName';\nexport {\n  Path,\n  type FileLocationStyle,\n  type IPathFormatFileLocationOptions,\n  type IPathFormatConciselyOptions\n} from './Path';\nexport { RealNodeModulePathResolver, type IRealNodeModulePathResolverOptions } from './RealNodeModulePath';\nexport { Encoding, Text, NewlineKind, type IReadLinesFromIterableOptions } from './Text';\nexport { Sort } from './Sort';\nexport {\n  AlreadyExistsBehavior,\n  FileSystem,\n  type FileSystemCopyFilesAsyncFilter,\n  type FileSystemCopyFilesFilter,\n  type FolderItem,\n  type FileSystemStats,\n  type IFileSystemCopyFileBaseOptions,\n  type IFileSystemCopyFileOptions,\n  type IFileSystemCopyFilesAsyncOptions,\n  type IFileSystemCopyFilesOptions,\n  type IFileSystemCreateLinkOptions,\n  type IFileSystemDeleteFileOptions,\n  type IFileSystemMoveOptions,\n  type IFileSystemReadFileOptions,\n  type IFileSystemReadFolderOptions,\n  type IFileSystemUpdateTimeParameters,\n  type IFileSystemWriteBinaryFileOptions,\n  type IFileSystemWriteFileOptions\n} from './FileSystem';\nexport { FileWriter, type IFileWriterFlags } from './FileWriter';\nexport { LegacyAdapters, type LegacyCallback } from './LegacyAdapters';\nexport { StringBuilder, type IStringBuilder } from './StringBuilder';\nexport { type ISubprocessOptions, SubprocessTerminator } from './SubprocessTerminator';\nexport { TypeUuid } from './TypeUuid';\n"]}

package/node_modules/@rushstack/node-core-library/node_modules/lru-cache/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/node_modules/@rushstack/node-core-library/node_modules/lru-cache/README.md

@@ -0,0 +1,166 @@
+# lru cache
+
+A cache object that deletes the least-recently-used items.
+
+[![Build Status](https://travis-ci.org/isaacs/node-lru-cache.svg?branch=master)](https://travis-ci.org/isaacs/node-lru-cache) [![Coverage Status](https://coveralls.io/repos/isaacs/node-lru-cache/badge.svg?service=github)](https://coveralls.io/github/isaacs/node-lru-cache)
+
+## Installation:
+
+```javascript
+npm install lru-cache --save
+```
+
+## Usage:
+
+```javascript
+var LRU = require("lru-cache")
+  , options = { max: 500
+              , length: function (n, key) { return n * 2 + key.length }
+              , dispose: function (key, n) { n.close() }
+              , maxAge: 1000 * 60 * 60 }
+  , cache = new LRU(options)
+  , otherCache = new LRU(50) // sets just the max size
+
+cache.set("key", "value")
+cache.get("key") // "value"
+
+// non-string keys ARE fully supported
+// but note that it must be THE SAME object, not
+// just a JSON-equivalent object.
+var someObject = { a: 1 }
+cache.set(someObject, 'a value')
+// Object keys are not toString()-ed
+cache.set('[object Object]', 'a different value')
+assert.equal(cache.get(someObject), 'a value')
+// A similar object with same keys/values won't work,
+// because it's a different object identity
+assert.equal(cache.get({ a: 1 }), undefined)
+
+cache.reset()    // empty the cache
+```
+
+If you put more stuff in it, then items will fall out.
+
+If you try to put an oversized thing in it, then it'll fall out right
+away.
+
+## Options
+
+* `max` The maximum size of the cache, checked by applying the length
+  function to all values in the cache.  Not setting this is kind of
+  silly, since that's the whole purpose of this lib, but it defaults
+  to `Infinity`.  Setting it to a non-number or negative number will
+  throw a `TypeError`.  Setting it to 0 makes it be `Infinity`.
+* `maxAge` Maximum age in ms.  Items are not pro-actively pruned out
+  as they age, but if you try to get an item that is too old, it'll
+  drop it and return undefined instead of giving it to you.
+  Setting this to a negative value will make everything seem old!
+  Setting it to a non-number will throw a `TypeError`.
+* `length` Function that is used to calculate the length of stored
+  items.  If you're storing strings or buffers, then you probably want
+  to do something like `function(n, key){return n.length}`.  The default is
+  `function(){return 1}`, which is fine if you want to store `max`
+  like-sized things.  The item is passed as the first argument, and
+  the key is passed as the second argumnet.
+* `dispose` Function that is called on items when they are dropped
+  from the cache.  This can be handy if you want to close file
+  descriptors or do other cleanup tasks when items are no longer
+  accessible.  Called with `key, value`.  It's called *before*
+  actually removing the item from the internal cache, so if you want
+  to immediately put it back in, you'll have to do that in a
+  `nextTick` or `setTimeout` callback or it won't do anything.
+* `stale` By default, if you set a `maxAge`, it'll only actually pull
+  stale items out of the cache when you `get(key)`.  (That is, it's
+  not pre-emptively doing a `setTimeout` or anything.)  If you set
+  `stale:true`, it'll return the stale value before deleting it.  If
+  you don't set this, then it'll return `undefined` when you try to
+  get a stale entry, as if it had already been deleted.
+* `noDisposeOnSet` By default, if you set a `dispose()` method, then
+  it'll be called whenever a `set()` operation overwrites an existing
+  key.  If you set this option, `dispose()` will only be called when a
+  key falls out of the cache, not when it is overwritten.
+* `updateAgeOnGet` When using time-expiring entries with `maxAge`,
+  setting this to `true` will make each item's effective time update
+  to the current time whenever it is retrieved from cache, causing it
+  to not expire.  (It can still fall out of cache based on recency of
+  use, of course.)
+
+## API
+
+* `set(key, value, maxAge)`
+* `get(key) => value`
+
+    Both of these will update the "recently used"-ness of the key.
+    They do what you think. `maxAge` is optional and overrides the
+    cache `maxAge` option if provided.
+
+    If the key is not found, `get()` will return `undefined`.
+
+    The key and val can be any value.
+
+* `peek(key)`
+
+    Returns the key value (or `undefined` if not found) without
+    updating the "recently used"-ness of the key.
+
+    (If you find yourself using this a lot, you *might* be using the
+    wrong sort of data structure, but there are some use cases where
+    it's handy.)
+
+* `del(key)`
+
+    Deletes a key out of the cache.
+
+* `reset()`
+
+    Clear the cache entirely, throwing away all values.
+
+* `has(key)`
+
+    Check if a key is in the cache, without updating the recent-ness
+    or deleting it for being stale.
+
+* `forEach(function(value,key,cache), [thisp])`
+
+    Just like `Array.prototype.forEach`.  Iterates over all the keys
+    in the cache, in order of recent-ness.  (Ie, more recently used
+    items are iterated over first.)
+
+* `rforEach(function(value,key,cache), [thisp])`
+
+    The same as `cache.forEach(...)` but items are iterated over in
+    reverse order.  (ie, less recently used items are iterated over
+    first.)
+
+* `keys()`
+
+    Return an array of the keys in the cache.
+
+* `values()`
+
+    Return an array of the values in the cache.
+
+* `length`
+
+    Return total length of objects in cache taking into account
+    `length` options function.
+
+* `itemCount`
+
+    Return total quantity of objects currently in cache. Note, that
+    `stale` (see options) items are returned as part of this item
+    count.
+
+* `dump()`
+
+    Return an array of the cache entries ready for serialization and usage
+    with 'destinationCache.load(arr)`.
+
+* `load(cacheEntriesArray)`
+
+    Loads another cache entries array, obtained with `sourceCache.dump()`,
+    into the cache. The destination cache is reset before loading new entries
+
+* `prune()`
+
+    Manually iterates over the entire cache proactively pruning old entries

package/node_modules/@rushstack/node-core-library/node_modules/lru-cache/index.js

@@ -0,0 +1,334 @@
+'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