@wo658/redpact 0.3.0 → 0.5.0

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

@@ -0,0 +1,390 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Import = void 0;
+const path = __importStar(require("path"));
+const importLazy = require("import-lazy");
+const Resolve = __importStar(require("resolve"));
+const nodeModule = require("module");
+const PackageJsonLookup_1 = require("./PackageJsonLookup");
+const FileSystem_1 = require("./FileSystem");
+const PackageName_1 = require("./PackageName");
+/**
+ * Helpers for resolving and importing Node.js modules.
+ * @public
+ */
+class Import {
+    static get _builtInModules() {
+        if (!Import.__builtInModules) {
+            Import.__builtInModules = new Set(nodeModule.builtinModules);
+        }
+        return Import.__builtInModules;
+    }
+    /**
+     * Provides a way to improve process startup times by lazy-loading imported modules.
+     *
+     * @remarks
+     * This is a more structured wrapper for the {@link https://www.npmjs.com/package/import-lazy|import-lazy}
+     * package.  It enables you to replace an import like this:
+     *
+     * ```ts
+     * import * as example from 'example'; // <-- 100ms load time
+     *
+     * if (condition) {
+     *   example.doSomething();
+     * }
+     * ```
+     *
+     * ...with a pattern like this:
+     *
+     * ```ts
+     * const example: typeof import('example') = Import.lazy('example', require);
+     *
+     * if (condition) {
+     *   example.doSomething(); // <-- 100ms load time occurs here, only if needed
+     * }
+     * ```
+     *
+     * The implementation relies on JavaScript's `Proxy` feature to intercept access to object members.  Thus
+     * it will only work correctly with certain types of module exports.  If a particular export isn't well behaved,
+     * you may need to find (or introduce) some other module in your dependency graph to apply the optimization to.
+     *
+     * Usage guidelines:
+     *
+     * - Always specify types using `typeof` as shown above.
+     *
+     * - Never apply lazy-loading in a way that would convert the module's type to `any`. Losing type safety
+     *   seriously impacts the maintainability of the code base.
+     *
+     * - In cases where the non-runtime types are needed, import them separately using the `Types` suffix:
+     *
+     * ```ts
+     * const example: typeof import('example') = Import.lazy('example', require);
+     * import type * as exampleTypes from 'example';
+     * ```
+     *
+     * - If the imported module confusingly has the same name as its export, then use the Module suffix:
+     *
+     * ```ts
+     * const exampleModule: typeof import('../../logic/Example') = Import.lazy(
+     *   '../../logic/Example', require);
+     * import type * as exampleTypes from '../../logic/Example';
+     * ```
+     *
+     * - If the exports cause a lot of awkwardness (e.g. too many expressions need to have `exampleModule.` inserted
+     *   into them), or if some exports cannot be proxied (e.g. `Import.lazy('example', require)` returns a function
+     *   signature), then do not lazy-load that module.  Instead, apply lazy-loading to some other module which is
+     *   better behaved.
+     *
+     * - It's recommended to sort imports in a standard ordering:
+     *
+     * ```ts
+     * // 1. external imports
+     * import * as path from 'path';
+     * import { Import, JsonFile, JsonObject } from '@rushstack/node-core-library';
+     *
+     * // 2. local imports
+     * import { LocalFile } from './path/LocalFile';
+     *
+     * // 3. lazy-imports (which are technically variables, not imports)
+     * const semver: typeof import('semver') = Import.lazy('semver', require);
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static lazy(moduleName, require) {
+        const importLazyLocal = importLazy(require);
+        return importLazyLocal(moduleName);
+    }
+    /**
+     * This resolves a module path using similar logic as the Node.js `require.resolve()` API,
+     * but supporting extra features such as specifying the base folder.
+     *
+     * @remarks
+     * A module path is a text string that might appear in a statement such as
+     * `import { X } from "____";` or `const x = require("___");`.  The implementation is based
+     * on the popular `resolve` NPM package.
+     *
+     * Suppose `example` is an NPM package whose entry point is `lib/index.js`:
+     * ```ts
+     * // Returns "/path/to/project/node_modules/example/lib/index.js"
+     * Import.resolveModule({ modulePath: 'example' });
+     *
+     * // Returns "/path/to/project/node_modules/example/lib/other.js"
+     * Import.resolveModule({ modulePath: 'example/lib/other' });
+     * ```
+     * If you need to determine the containing package folder
+     * (`/path/to/project/node_modules/example`), use {@link Import.resolvePackage} instead.
+     *
+     * @returns the absolute path of the resolved module.
+     * If {@link IImportResolveOptions.includeSystemModules} is specified
+     * and a system module is found, then its name is returned without any file path.
+     */
+    static resolveModule(options) {
+        const { modulePath, baseFolderPath, includeSystemModules, allowSelfReference, getRealPath } = options;
+        if (path.isAbsolute(modulePath)) {
+            return modulePath;
+        }
+        const normalizedRootPath = (getRealPath || FileSystem_1.FileSystem.getRealPath)(baseFolderPath);
+        if (modulePath.startsWith('.')) {
+            // This looks like a conventional relative path
+            return path.resolve(normalizedRootPath, modulePath);
+        }
+        // Built-in modules do not have a scope, so if there is a slash, then we need to check
+        // against the first path segment
+        const slashIndex = modulePath.indexOf('/');
+        const moduleName = slashIndex === -1 ? modulePath : modulePath.slice(0, slashIndex);
+        if (!includeSystemModules && Import._builtInModules.has(moduleName)) {
+            throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}".`);
+        }
+        if (allowSelfReference === true) {
+            const ownPackage = Import._getPackageName(normalizedRootPath);
+            if (ownPackage &&
+                (modulePath === ownPackage.packageName || modulePath.startsWith(`${ownPackage.packageName}/`))) {
+                const packagePath = modulePath.slice(ownPackage.packageName.length + 1);
+                return path.resolve(ownPackage.packageRootPath, packagePath);
+            }
+        }
+        try {
+            return Resolve.sync(modulePath, {
+                basedir: normalizedRootPath,
+                preserveSymlinks: false,
+                realpathSync: getRealPath
+            });
+        }
+        catch (e) {
+            throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}": ${e}`);
+        }
+    }
+    /**
+     * Async version of {@link Import.resolveModule}.
+     */
+    static async resolveModuleAsync(options) {
+        const { modulePath, baseFolderPath, includeSystemModules, allowSelfReference, getRealPath, getRealPathAsync } = options;
+        if (path.isAbsolute(modulePath)) {
+            return modulePath;
+        }
+        const normalizedRootPath = await (getRealPathAsync || getRealPath || FileSystem_1.FileSystem.getRealPathAsync)(baseFolderPath);
+        if (modulePath.startsWith('.')) {
+            // This looks like a conventional relative path
+            return path.resolve(normalizedRootPath, modulePath);
+        }
+        // Built-in modules do not have a scope, so if there is a slash, then we need to check
+        // against the first path segment
+        const slashIndex = modulePath.indexOf('/');
+        const moduleName = slashIndex === -1 ? modulePath : modulePath.slice(0, slashIndex);
+        if (!includeSystemModules && Import._builtInModules.has(moduleName)) {
+            throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}".`);
+        }
+        if (allowSelfReference === true) {
+            const ownPackage = Import._getPackageName(normalizedRootPath);
+            if (ownPackage &&
+                (modulePath === ownPackage.packageName || modulePath.startsWith(`${ownPackage.packageName}/`))) {
+                const packagePath = modulePath.slice(ownPackage.packageName.length + 1);
+                return path.resolve(ownPackage.packageRootPath, packagePath);
+            }
+        }
+        try {
+            const resolvePromise = new Promise((resolve, reject) => {
+                const realPathFn = getRealPathAsync || getRealPath
+                    ? (filePath, callback) => {
+                        if (getRealPathAsync) {
+                            getRealPathAsync(filePath)
+                                .then((resolvedPath) => callback(null, resolvedPath))
+                                .catch((error) => callback(error));
+                        }
+                        else {
+                            try {
+                                const resolvedPath = getRealPath(filePath);
+                                callback(null, resolvedPath);
+                            }
+                            catch (error) {
+                                callback(error);
+                            }
+                        }
+                    }
+                    : undefined;
+                Resolve.default(modulePath, {
+                    basedir: normalizedRootPath,
+                    preserveSymlinks: false,
+                    realpath: realPathFn
+                }, (error, resolvedPath) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        // Resolve docs state that either an error will be returned, or the resolved path.
+                        // In this case, the resolved path should always be populated.
+                        resolve(resolvedPath);
+                    }
+                });
+            });
+            return await resolvePromise;
+        }
+        catch (e) {
+            throw new Error(`Cannot find module "${modulePath}" from "${options.baseFolderPath}": ${e}`);
+        }
+    }
+    /**
+     * Performs module resolution to determine the folder where a package is installed.
+     *
+     * @remarks
+     * Suppose `example` is an NPM package whose entry point is `lib/index.js`:
+     * ```ts
+     * // Returns "/path/to/project/node_modules/example"
+     * Import.resolvePackage({ packageName: 'example' });
+     * ```
+     *
+     * If you need to resolve a module path, use {@link Import.resolveModule} instead:
+     * ```ts
+     * // Returns "/path/to/project/node_modules/example/lib/index.js"
+     * Import.resolveModule({ modulePath: 'example' });
+     * ```
+     *
+     * @returns the absolute path of the package folder.
+     * If {@link IImportResolveOptions.includeSystemModules} is specified
+     * and a system module is found, then its name is returned without any file path.
+     */
+    static resolvePackage(options) {
+        const { packageName, includeSystemModules, baseFolderPath, allowSelfReference, getRealPath, useNodeJSResolver } = options;
+        if (includeSystemModules && Import._builtInModules.has(packageName)) {
+            return packageName;
+        }
+        const normalizedRootPath = (getRealPath || FileSystem_1.FileSystem.getRealPath)(baseFolderPath);
+        if (allowSelfReference) {
+            const ownPackage = Import._getPackageName(normalizedRootPath);
+            if (ownPackage && ownPackage.packageName === packageName) {
+                return ownPackage.packageRootPath;
+            }
+        }
+        PackageName_1.PackageName.parse(packageName); // Ensure the package name is valid and doesn't contain a path
+        try {
+            const resolvedPath = useNodeJSResolver
+                ? require.resolve(`${packageName}/package.json`, {
+                    paths: [normalizedRootPath]
+                })
+                : // Append `/package.json` to ensure `resolve.sync` doesn't attempt to return a system package, and to avoid
+                    // having to mess with the `packageFilter` option.
+                    Resolve.sync(`${packageName}/package.json`, {
+                        basedir: normalizedRootPath,
+                        preserveSymlinks: false,
+                        realpathSync: getRealPath
+                    });
+            const packagePath = path.dirname(resolvedPath);
+            return packagePath;
+        }
+        catch (e) {
+            throw new Error(`Cannot find package "${packageName}" from "${baseFolderPath}": ${e}.`);
+        }
+    }
+    /**
+     * Async version of {@link Import.resolvePackage}.
+     */
+    static async resolvePackageAsync(options) {
+        const { packageName, includeSystemModules, baseFolderPath, allowSelfReference, getRealPath, getRealPathAsync } = options;
+        if (includeSystemModules && Import._builtInModules.has(packageName)) {
+            return packageName;
+        }
+        const normalizedRootPath = await (getRealPathAsync || getRealPath || FileSystem_1.FileSystem.getRealPathAsync)(baseFolderPath);
+        if (allowSelfReference) {
+            const ownPackage = Import._getPackageName(normalizedRootPath);
+            if (ownPackage && ownPackage.packageName === packageName) {
+                return ownPackage.packageRootPath;
+            }
+        }
+        PackageName_1.PackageName.parse(packageName); // Ensure the package name is valid and doesn't contain a path
+        try {
+            const resolvePromise = new Promise((resolve, reject) => {
+                const realPathFn = getRealPathAsync || getRealPath
+                    ? (filePath, callback) => {
+                        if (getRealPathAsync) {
+                            getRealPathAsync(filePath)
+                                .then((resolvedPath) => callback(null, resolvedPath))
+                                .catch((error) => callback(error));
+                        }
+                        else {
+                            try {
+                                const resolvedPath = getRealPath(filePath);
+                                callback(null, resolvedPath);
+                            }
+                            catch (error) {
+                                callback(error);
+                            }
+                        }
+                    }
+                    : undefined;
+                Resolve.default(
+                // Append `/package.json` to ensure `resolve` doesn't attempt to return a system package, and to avoid
+                // having to mess with the `packageFilter` option.
+                `${packageName}/package.json`, {
+                    basedir: normalizedRootPath,
+                    preserveSymlinks: false,
+                    realpath: realPathFn
+                }, (error, resolvedPath) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        // Resolve docs state that either an error will be returned, or the resolved path.
+                        // In this case, the resolved path should always be populated.
+                        resolve(resolvedPath);
+                    }
+                });
+            });
+            const resolvedPath = await resolvePromise;
+            const packagePath = path.dirname(resolvedPath);
+            return packagePath;
+        }
+        catch (e) {
+            throw new Error(`Cannot find package "${packageName}" from "${baseFolderPath}": ${e}`);
+        }
+    }
+    static _getPackageName(rootPath) {
+        const packageJsonPath = PackageJsonLookup_1.PackageJsonLookup.instance.tryGetPackageJsonFilePathFor(rootPath);
+        if (packageJsonPath) {
+            const packageJson = PackageJsonLookup_1.PackageJsonLookup.instance.loadPackageJson(packageJsonPath);
+            return {
+                packageRootPath: path.dirname(packageJsonPath),
+                packageName: packageJson.name
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+exports.Import = Import;
+//# sourceMappingURL=Import.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Import.js","sourceRoot":"","sources":["../src/Import.ts"],"names":[],"mappings":"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","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 * as path from 'path';\nimport importLazy = require('import-lazy');\nimport * as Resolve from 'resolve';\nimport nodeModule = require('module');\n\nimport { PackageJsonLookup } from './PackageJsonLookup';\nimport { FileSystem } from './FileSystem';\nimport type { IPackageJson } from './IPackageJson';\nimport { PackageName } from './PackageName';\n\ntype RealpathFnType = Parameters<typeof Resolve.default>[1]['realpath'];\n\n/**\n * Common options shared by {@link IImportResolveModuleOptions} and {@link IImportResolvePackageOptions}\n * @public\n */\nexport interface IImportResolveOptions {\n  /**\n   * The path from which {@link IImportResolveModuleOptions.modulePath} or\n   * {@link IImportResolvePackageOptions.packageName} should be resolved.\n   */\n  baseFolderPath: string;\n\n  /**\n   * If true, if the package name matches a Node.js system module, then the return\n   * value will be the package name without any path.\n   *\n   * @remarks\n   * This will take precedence over an installed NPM package of the same name.\n   *\n   * Example:\n   * ```ts\n   * // Returns the string \"fs\" indicating the Node.js system module\n   * Import.resolveModulePath({\n   *   resolvePath: \"fs\",\n   *   basePath: process.cwd()\n   * })\n   * ```\n   */\n  includeSystemModules?: boolean;\n\n  /**\n   * If true, then resolvePath is allowed to refer to the package.json of the active project.\n   *\n   * @remarks\n   * This will take precedence over any installed dependency with the same name.\n   * Note that this requires an additional PackageJsonLookup calculation.\n   *\n   * Example:\n   * ```ts\n   * // Returns an absolute path to the current package\n   * Import.resolveModulePath({\n   *   resolvePath: \"current-project\",\n   *   basePath: process.cwd(),\n   *   allowSelfReference: true\n   * })\n   * ```\n   */\n  allowSelfReference?: boolean;\n\n  /**\n   * A function used to resolve the realpath of a provided file path.\n   *\n   * @remarks\n   * This is used to resolve symlinks and other non-standard file paths. By default, this uses the\n   * {@link FileSystem.getRealPath} function. However, it can be overridden to use a custom implementation\n   * which may be faster, more accurate, or provide support for additional non-standard file paths.\n   */\n  getRealPath?: (filePath: string) => string;\n}\n\n/**\n * Common options shared by {@link IImportResolveModuleAsyncOptions} and {@link IImportResolvePackageAsyncOptions}\n * @public\n */\nexport interface IImportResolveAsyncOptions extends IImportResolveOptions {\n  /**\n   * A function used to resolve the realpath of a provided file path.\n   *\n   * @remarks\n   * This is used to resolve symlinks and other non-standard file paths. By default, this uses the\n   * {@link FileSystem.getRealPath} function. However, it can be overridden to use a custom implementation\n   * which may be faster, more accurate, or provide support for additional non-standard file paths.\n   */\n  getRealPathAsync?: (filePath: string) => Promise<string>;\n}\n\n/**\n * Options for {@link Import.resolveModule}\n * @public\n */\nexport interface IImportResolveModuleOptions extends IImportResolveOptions {\n  /**\n   * The module identifier to resolve. For example \"\\@rushstack/node-core-library\" or\n   * \"\\@rushstack/node-core-library/lib/index.js\"\n   */\n  modulePath: string;\n}\n\n/**\n * Options for {@link Import.resolveModuleAsync}\n * @public\n */\nexport interface IImportResolveModuleAsyncOptions extends IImportResolveAsyncOptions {\n  /**\n   * The module identifier to resolve. For example \"\\@rushstack/node-core-library\" or\n   * \"\\@rushstack/node-core-library/lib/index.js\"\n   */\n  modulePath: string;\n}\n\n/**\n * Options for {@link Import.resolvePackage}\n * @public\n */\nexport interface IImportResolvePackageOptions extends IImportResolveOptions {\n  /**\n   * The package name to resolve. For example \"\\@rushstack/node-core-library\"\n   */\n  packageName: string;\n\n  /**\n   * If true, then the module path will be resolved using Node.js's built-in resolution algorithm.\n   *\n   * @remarks\n   * This allows reusing Node's built-in resolver cache.\n   * This implies `allowSelfReference: true`. The passed `getRealPath` will only be used on `baseFolderPath`.\n   */\n  useNodeJSResolver?: boolean;\n}\n\n/**\n * Options for {@link Import.resolvePackageAsync}\n * @public\n */\nexport interface IImportResolvePackageAsyncOptions extends IImportResolveAsyncOptions {\n  /**\n   * The package name to resolve. For example \"\\@rushstack/node-core-library\"\n   */\n  packageName: string;\n}\n\ninterface IPackageDescriptor {\n  packageRootPath: string;\n  packageName: string;\n}\n\n/**\n * Helpers for resolving and importing Node.js modules.\n * @public\n */\nexport class Import {\n  private static __builtInModules: Set<string> | undefined;\n  private static get _builtInModules(): Set<string> {\n    if (!Import.__builtInModules) {\n      Import.__builtInModules = new Set<string>(nodeModule.builtinModules);\n    }\n\n    return Import.__builtInModules;\n  }\n\n  /**\n   * Provides a way to improve process startup times by lazy-loading imported modules.\n   *\n   * @remarks\n   * This is a more structured wrapper for the {@link https://www.npmjs.com/package/import-lazy|import-lazy}\n   * package.  It enables you to replace an import like this:\n   *\n   * ```ts\n   * import * as example from 'example'; // <-- 100ms load time\n   *\n   * if (condition) {\n   *   example.doSomething();\n   * }\n   * ```\n   *\n   * ...with a pattern like this:\n   *\n   * ```ts\n   * const example: typeof import('example') = Import.lazy('example', require);\n   *\n   * if (condition) {\n   *   example.doSomething(); // <-- 100ms load time occurs here, only if needed\n   * }\n   * ```\n   *\n   * The implementation relies on JavaScript's `Proxy` feature to intercept access to object members.  Thus\n   * it will only work correctly with certain types of module exports.  If a particular export isn't well behaved,\n   * you may need to find (or introduce) some other module in your dependency graph to apply the optimization to.\n   *\n   * Usage guidelines:\n   *\n   * - Always specify types using `typeof` as shown above.\n   *\n   * - Never apply lazy-loading in a way that would convert the module's type to `any`. Losing type safety\n   *   seriously impacts the maintainability of the code base.\n   *\n   * - In cases where the non-runtime types are needed, import them separately using the `Types` suffix:\n   *\n   * ```ts\n   * const example: typeof import('example') = Import.lazy('example', require);\n   * import type * as exampleTypes from 'example';\n   * ```\n   *\n   * - If the imported module confusingly has the same name as its export, then use the Module suffix:\n   *\n   * ```ts\n   * const exampleModule: typeof import('../../logic/Example') = Import.lazy(\n   *   '../../logic/Example', require);\n   * import type * as exampleTypes from '../../logic/Example';\n   * ```\n   *\n   * - If the exports cause a lot of awkwardness (e.g. too many expressions need to have `exampleModule.` inserted\n   *   into them), or if some exports cannot be proxied (e.g. `Import.lazy('example', require)` returns a function\n   *   signature), then do not lazy-load that module.  Instead, apply lazy-loading to some other module which is\n   *   better behaved.\n   *\n   * - It's recommended to sort imports in a standard ordering:\n   *\n   * ```ts\n   * // 1. external imports\n   * import * as path from 'path';\n   * import { Import, JsonFile, JsonObject } from '@rushstack/node-core-library';\n   *\n   * // 2. local imports\n   * import { LocalFile } from './path/LocalFile';\n   *\n   * // 3. lazy-imports (which are technically variables, not imports)\n   * const semver: typeof import('semver') = Import.lazy('semver', require);\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public static lazy(moduleName: string, require: (id: string) => unknown): any {\n    const importLazyLocal: (moduleName: string) => unknown = importLazy(require);\n    return importLazyLocal(moduleName);\n  }\n\n  /**\n   * This resolves a module path using similar logic as the Node.js `require.resolve()` API,\n   * but supporting extra features such as specifying the base folder.\n   *\n   * @remarks\n   * A module path is a text string that might appear in a statement such as\n   * `import { X } from \"____\";` or `const x = require(\"___\");`.  The implementation is based\n   * on the popular `resolve` NPM package.\n   *\n   * Suppose `example` is an NPM package whose entry point is `lib/index.js`:\n   * ```ts\n   * // Returns \"/path/to/project/node_modules/example/lib/index.js\"\n   * Import.resolveModule({ modulePath: 'example' });\n   *\n   * // Returns \"/path/to/project/node_modules/example/lib/other.js\"\n   * Import.resolveModule({ modulePath: 'example/lib/other' });\n   * ```\n   * If you need to determine the containing package folder\n   * (`/path/to/project/node_modules/example`), use {@link Import.resolvePackage} instead.\n   *\n   * @returns the absolute path of the resolved module.\n   * If {@link IImportResolveOptions.includeSystemModules} is specified\n   * and a system module is found, then its name is returned without any file path.\n   */\n  public static resolveModule(options: IImportResolveModuleOptions): string {\n    const { modulePath, baseFolderPath, includeSystemModules, allowSelfReference, getRealPath } = options;\n\n    if (path.isAbsolute(modulePath)) {\n      return modulePath;\n    }\n\n    const normalizedRootPath: string = (getRealPath || FileSystem.getRealPath)(baseFolderPath);\n\n    if (modulePath.startsWith('.')) {\n      // This looks like a conventional relative path\n      return path.resolve(normalizedRootPath, modulePath);\n    }\n\n    // Built-in modules do not have a scope, so if there is a slash, then we need to check\n    // against the first path segment\n    const slashIndex: number = modulePath.indexOf('/');\n    const moduleName: string = slashIndex === -1 ? modulePath : modulePath.slice(0, slashIndex);\n    if (!includeSystemModules && Import._builtInModules.has(moduleName)) {\n      throw new Error(`Cannot find module \"${modulePath}\" from \"${options.baseFolderPath}\".`);\n    }\n\n    if (allowSelfReference === true) {\n      const ownPackage: IPackageDescriptor | undefined = Import._getPackageName(normalizedRootPath);\n      if (\n        ownPackage &&\n        (modulePath === ownPackage.packageName || modulePath.startsWith(`${ownPackage.packageName}/`))\n      ) {\n        const packagePath: string = modulePath.slice(ownPackage.packageName.length + 1);\n        return path.resolve(ownPackage.packageRootPath, packagePath);\n      }\n    }\n\n    try {\n      return Resolve.sync(modulePath, {\n        basedir: normalizedRootPath,\n        preserveSymlinks: false,\n        realpathSync: getRealPath\n      });\n    } catch (e: unknown) {\n      throw new Error(`Cannot find module \"${modulePath}\" from \"${options.baseFolderPath}\": ${e}`);\n    }\n  }\n\n  /**\n   * Async version of {@link Import.resolveModule}.\n   */\n  public static async resolveModuleAsync(options: IImportResolveModuleAsyncOptions): Promise<string> {\n    const {\n      modulePath,\n      baseFolderPath,\n      includeSystemModules,\n      allowSelfReference,\n      getRealPath,\n      getRealPathAsync\n    } = options;\n\n    if (path.isAbsolute(modulePath)) {\n      return modulePath;\n    }\n\n    const normalizedRootPath: string = await (getRealPathAsync || getRealPath || FileSystem.getRealPathAsync)(\n      baseFolderPath\n    );\n\n    if (modulePath.startsWith('.')) {\n      // This looks like a conventional relative path\n      return path.resolve(normalizedRootPath, modulePath);\n    }\n\n    // Built-in modules do not have a scope, so if there is a slash, then we need to check\n    // against the first path segment\n    const slashIndex: number = modulePath.indexOf('/');\n    const moduleName: string = slashIndex === -1 ? modulePath : modulePath.slice(0, slashIndex);\n    if (!includeSystemModules && Import._builtInModules.has(moduleName)) {\n      throw new Error(`Cannot find module \"${modulePath}\" from \"${options.baseFolderPath}\".`);\n    }\n\n    if (allowSelfReference === true) {\n      const ownPackage: IPackageDescriptor | undefined = Import._getPackageName(normalizedRootPath);\n      if (\n        ownPackage &&\n        (modulePath === ownPackage.packageName || modulePath.startsWith(`${ownPackage.packageName}/`))\n      ) {\n        const packagePath: string = modulePath.slice(ownPackage.packageName.length + 1);\n        return path.resolve(ownPackage.packageRootPath, packagePath);\n      }\n    }\n\n    try {\n      const resolvePromise: Promise<string> = new Promise(\n        (resolve: (resolvedPath: string) => void, reject: (error: Error) => void) => {\n          const realPathFn: RealpathFnType =\n            getRealPathAsync || getRealPath\n              ? (filePath: string, callback: (error: Error | null, resolvedPath?: string) => void) => {\n                  if (getRealPathAsync) {\n                    getRealPathAsync(filePath)\n                      .then((resolvedPath) => callback(null, resolvedPath))\n                      .catch((error) => callback(error));\n                  } else {\n                    try {\n                      const resolvedPath: string = getRealPath!(filePath);\n                      callback(null, resolvedPath);\n                    } catch (error: unknown) {\n                      callback(error as Error);\n                    }\n                  }\n                }\n              : undefined;\n\n          Resolve.default(\n            modulePath,\n            {\n              basedir: normalizedRootPath,\n              preserveSymlinks: false,\n              realpath: realPathFn\n            },\n            (error: Error | null, resolvedPath?: string) => {\n              if (error) {\n                reject(error);\n              } else {\n                // Resolve docs state that either an error will be returned, or the resolved path.\n                // In this case, the resolved path should always be populated.\n                resolve(resolvedPath!);\n              }\n            }\n          );\n        }\n      );\n      return await resolvePromise;\n    } catch (e: unknown) {\n      throw new Error(`Cannot find module \"${modulePath}\" from \"${options.baseFolderPath}\": ${e}`);\n    }\n  }\n\n  /**\n   * Performs module resolution to determine the folder where a package is installed.\n   *\n   * @remarks\n   * Suppose `example` is an NPM package whose entry point is `lib/index.js`:\n   * ```ts\n   * // Returns \"/path/to/project/node_modules/example\"\n   * Import.resolvePackage({ packageName: 'example' });\n   * ```\n   *\n   * If you need to resolve a module path, use {@link Import.resolveModule} instead:\n   * ```ts\n   * // Returns \"/path/to/project/node_modules/example/lib/index.js\"\n   * Import.resolveModule({ modulePath: 'example' });\n   * ```\n   *\n   * @returns the absolute path of the package folder.\n   * If {@link IImportResolveOptions.includeSystemModules} is specified\n   * and a system module is found, then its name is returned without any file path.\n   */\n  public static resolvePackage(options: IImportResolvePackageOptions): string {\n    const {\n      packageName,\n      includeSystemModules,\n      baseFolderPath,\n      allowSelfReference,\n      getRealPath,\n      useNodeJSResolver\n    } = options;\n\n    if (includeSystemModules && Import._builtInModules.has(packageName)) {\n      return packageName;\n    }\n\n    const normalizedRootPath: string = (getRealPath || FileSystem.getRealPath)(baseFolderPath);\n\n    if (allowSelfReference) {\n      const ownPackage: IPackageDescriptor | undefined = Import._getPackageName(normalizedRootPath);\n      if (ownPackage && ownPackage.packageName === packageName) {\n        return ownPackage.packageRootPath;\n      }\n    }\n\n    PackageName.parse(packageName); // Ensure the package name is valid and doesn't contain a path\n\n    try {\n      const resolvedPath: string = useNodeJSResolver\n        ? require.resolve(`${packageName}/package.json`, {\n            paths: [normalizedRootPath]\n          })\n        : // Append `/package.json` to ensure `resolve.sync` doesn't attempt to return a system package, and to avoid\n          // having to mess with the `packageFilter` option.\n          Resolve.sync(`${packageName}/package.json`, {\n            basedir: normalizedRootPath,\n            preserveSymlinks: false,\n            realpathSync: getRealPath\n          });\n\n      const packagePath: string = path.dirname(resolvedPath);\n      return packagePath;\n    } catch (e: unknown) {\n      throw new Error(`Cannot find package \"${packageName}\" from \"${baseFolderPath}\": ${e}.`);\n    }\n  }\n\n  /**\n   * Async version of {@link Import.resolvePackage}.\n   */\n  public static async resolvePackageAsync(options: IImportResolvePackageAsyncOptions): Promise<string> {\n    const {\n      packageName,\n      includeSystemModules,\n      baseFolderPath,\n      allowSelfReference,\n      getRealPath,\n      getRealPathAsync\n    } = options;\n\n    if (includeSystemModules && Import._builtInModules.has(packageName)) {\n      return packageName;\n    }\n\n    const normalizedRootPath: string = await (getRealPathAsync || getRealPath || FileSystem.getRealPathAsync)(\n      baseFolderPath\n    );\n\n    if (allowSelfReference) {\n      const ownPackage: IPackageDescriptor | undefined = Import._getPackageName(normalizedRootPath);\n      if (ownPackage && ownPackage.packageName === packageName) {\n        return ownPackage.packageRootPath;\n      }\n    }\n\n    PackageName.parse(packageName); // Ensure the package name is valid and doesn't contain a path\n\n    try {\n      const resolvePromise: Promise<string> = new Promise(\n        (resolve: (resolvedPath: string) => void, reject: (error: Error) => void) => {\n          const realPathFn: RealpathFnType =\n            getRealPathAsync || getRealPath\n              ? (filePath: string, callback: (error: Error | null, resolvedPath?: string) => void) => {\n                  if (getRealPathAsync) {\n                    getRealPathAsync(filePath)\n                      .then((resolvedPath) => callback(null, resolvedPath))\n                      .catch((error) => callback(error));\n                  } else {\n                    try {\n                      const resolvedPath: string = getRealPath!(filePath);\n                      callback(null, resolvedPath);\n                    } catch (error: unknown) {\n                      callback(error as Error);\n                    }\n                  }\n                }\n              : undefined;\n\n          Resolve.default(\n            // Append `/package.json` to ensure `resolve` doesn't attempt to return a system package, and to avoid\n            // having to mess with the `packageFilter` option.\n            `${packageName}/package.json`,\n            {\n              basedir: normalizedRootPath,\n              preserveSymlinks: false,\n              realpath: realPathFn\n            },\n            (error: Error | null, resolvedPath?: string) => {\n              if (error) {\n                reject(error);\n              } else {\n                // Resolve docs state that either an error will be returned, or the resolved path.\n                // In this case, the resolved path should always be populated.\n                resolve(resolvedPath!);\n              }\n            }\n          );\n        }\n      );\n      const resolvedPath: string = await resolvePromise;\n\n      const packagePath: string = path.dirname(resolvedPath);\n      return packagePath;\n    } catch (e: unknown) {\n      throw new Error(`Cannot find package \"${packageName}\" from \"${baseFolderPath}\": ${e}`);\n    }\n  }\n\n  private static _getPackageName(rootPath: string): IPackageDescriptor | undefined {\n    const packageJsonPath: string | undefined =\n      PackageJsonLookup.instance.tryGetPackageJsonFilePathFor(rootPath);\n    if (packageJsonPath) {\n      const packageJson: IPackageJson = PackageJsonLookup.instance.loadPackageJson(packageJsonPath);\n      return {\n        packageRootPath: path.dirname(packageJsonPath),\n        packageName: packageJson.name\n      };\n    } else {\n      return undefined;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,36 @@
+/**
+ * An `Error` subclass that should be thrown to report an unexpected state that may indicate a software defect.
+ * An application may handle this error by instructing the end user to report an issue to the application maintainers.
+ *
+ * @remarks
+ * Do not use this class unless you intend to solicit bug reports from end users.
+ *
+ * @public
+ */
+export declare class InternalError extends Error {
+    /**
+     * If true, a JavScript `debugger;` statement will be invoked whenever the `InternalError` constructor is called.
+     *
+     * @remarks
+     * Generally applications should not be catching and ignoring an `InternalError`.  Instead, the error should
+     * be reported and typically the application will terminate.  Thus, if `InternalError` is constructed, it's
+     * almost always something we want to examine in a debugger.
+     */
+    static breakInDebugger: boolean;
+    /**
+     * The underlying error message, without the additional boilerplate for an `InternalError`.
+     */
+    readonly unformattedMessage: string;
+    /**
+     * Constructs a new instance of the {@link InternalError} class.
+     *
+     * @param message - A message describing the error.  This will be assigned to
+     * {@link InternalError.unformattedMessage}.  The `Error.message` field will have additional boilerplate
+     * explaining that the user has encountered a software defect.
+     */
+    constructor(message: string);
+    private static _formatMessage;
+    /** @override */
+    toString(): string;
+}
+//# sourceMappingURL=InternalError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InternalError.d.ts","sourceRoot":"","sources":["../src/InternalError.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC;;;;;;;OAOG;IACH,OAAc,eAAe,EAAE,OAAO,CAAQ;IAE9C;;OAEG;IACH,SAAgB,kBAAkB,EAAE,MAAM,CAAC;IAE3C;;;;;;OAMG;gBACgB,OAAO,EAAE,MAAM;IAiBlC,OAAO,CAAC,MAAM,CAAC,cAAc;IAO7B,gBAAgB;IACT,QAAQ,IAAI,MAAM;CAG1B"}

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

@@ -0,0 +1,55 @@
+"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.InternalError = void 0;
+/**
+ * An `Error` subclass that should be thrown to report an unexpected state that may indicate a software defect.
+ * An application may handle this error by instructing the end user to report an issue to the application maintainers.
+ *
+ * @remarks
+ * Do not use this class unless you intend to solicit bug reports from end users.
+ *
+ * @public
+ */
+class InternalError extends Error {
+    /**
+     * Constructs a new instance of the {@link InternalError} class.
+     *
+     * @param message - A message describing the error.  This will be assigned to
+     * {@link InternalError.unformattedMessage}.  The `Error.message` field will have additional boilerplate
+     * explaining that the user has encountered a software defect.
+     */
+    constructor(message) {
+        super(InternalError._formatMessage(message));
+        // Manually set the prototype, as we can no longer extend built-in classes like Error, Array, Map, etc.
+        // https://github.com/microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        //
+        // Note: the prototype must also be set on any classes which extend this one
+        this.__proto__ = InternalError.prototype; // eslint-disable-line @typescript-eslint/no-explicit-any
+        this.unformattedMessage = message;
+        if (InternalError.breakInDebugger) {
+            // eslint-disable-next-line no-debugger
+            debugger;
+        }
+    }
+    static _formatMessage(unformattedMessage) {
+        return (`Internal Error: ${unformattedMessage}\n\nYou have encountered a software defect. Please consider` +
+            ` reporting the issue to the maintainers of this application.`);
+    }
+    /** @override */
+    toString() {
+        return this.message; // Avoid adding the "Error:" prefix
+    }
+}
+exports.InternalError = InternalError;
+/**
+ * If true, a JavScript `debugger;` statement will be invoked whenever the `InternalError` constructor is called.
+ *
+ * @remarks
+ * Generally applications should not be catching and ignoring an `InternalError`.  Instead, the error should
+ * be reported and typically the application will terminate.  Thus, if `InternalError` is constructed, it's
+ * almost always something we want to examine in a debugger.
+ */
+InternalError.breakInDebugger = true;
+//# sourceMappingURL=InternalError.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InternalError.js","sourceRoot":"","sources":["../src/InternalError.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D;;;;;;;;GAQG;AACH,MAAa,aAAc,SAAQ,KAAK;IAgBtC;;;;;;OAMG;IACH,YAAmB,OAAe;QAChC,KAAK,CAAC,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;QAE7C,uGAAuG;QACvG,6IAA6I;QAC7I,EAAE;QACF,4EAA4E;QAC3E,IAAY,CAAC,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,yDAAyD;QAE5G,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC;QAElC,IAAI,aAAa,CAAC,eAAe,EAAE,CAAC;YAClC,uCAAuC;YACvC,QAAQ,CAAC;QACX,CAAC;IACH,CAAC;IAEO,MAAM,CAAC,cAAc,CAAC,kBAA0B;QACtD,OAAO,CACL,mBAAmB,kBAAkB,6DAA6D;YAClG,8DAA8D,CAC/D,CAAC;IACJ,CAAC;IAED,gBAAgB;IACT,QAAQ;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,mCAAmC;IAC1D,CAAC;;AAlDH,sCAmDC;AAlDC;;;;;;;GAOG;AACW,6BAAe,GAAY,IAAI,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\n/**\n * An `Error` subclass that should be thrown to report an unexpected state that may indicate a software defect.\n * An application may handle this error by instructing the end user to report an issue to the application maintainers.\n *\n * @remarks\n * Do not use this class unless you intend to solicit bug reports from end users.\n *\n * @public\n */\nexport class InternalError extends Error {\n  /**\n   * If true, a JavScript `debugger;` statement will be invoked whenever the `InternalError` constructor is called.\n   *\n   * @remarks\n   * Generally applications should not be catching and ignoring an `InternalError`.  Instead, the error should\n   * be reported and typically the application will terminate.  Thus, if `InternalError` is constructed, it's\n   * almost always something we want to examine in a debugger.\n   */\n  public static breakInDebugger: boolean = true;\n\n  /**\n   * The underlying error message, without the additional boilerplate for an `InternalError`.\n   */\n  public readonly unformattedMessage: string;\n\n  /**\n   * Constructs a new instance of the {@link InternalError} class.\n   *\n   * @param message - A message describing the error.  This will be assigned to\n   * {@link InternalError.unformattedMessage}.  The `Error.message` field will have additional boilerplate\n   * explaining that the user has encountered a software defect.\n   */\n  public constructor(message: string) {\n    super(InternalError._formatMessage(message));\n\n    // Manually set the prototype, as we can no longer extend built-in classes like Error, Array, Map, etc.\n    // https://github.com/microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    //\n    // Note: the prototype must also be set on any classes which extend this one\n    (this as any).__proto__ = InternalError.prototype; // eslint-disable-line @typescript-eslint/no-explicit-any\n\n    this.unformattedMessage = message;\n\n    if (InternalError.breakInDebugger) {\n      // eslint-disable-next-line no-debugger\n      debugger;\n    }\n  }\n\n  private static _formatMessage(unformattedMessage: string): string {\n    return (\n      `Internal Error: ${unformattedMessage}\\n\\nYou have encountered a software defect. Please consider` +\n      ` reporting the issue to the maintainers of this application.`\n    );\n  }\n\n  /** @override */\n  public toString(): string {\n    return this.message; // Avoid adding the \"Error:\" prefix\n  }\n}\n"]}