namespace ts {

/* @internal */

export function trace(host: ModuleResolutionHost, message: DiagnosticMessage, ...args: any[]): void;

export function trace(host: ModuleResolutionHost): void {

host.trace!(formatMessage.apply(undefined, arguments));

}

/* @internal */

export function isTraceEnabled(compilerOptions: CompilerOptions, host: ModuleResolutionHost): boolean {

return !!compilerOptions.traceResolution && host.trace !== undefined;

}

function withPackageId(packageInfo: PackageJsonInfo | undefined, r: PathAndExtension | undefined): Resolved | undefined {

let packageId: PackageId | undefined;

if (r && packageInfo) {

const packageJsonContent = packageInfo.packageJsonContent as PackageJson;

if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") {

packageId = {

name: packageJsonContent.name,

subModuleName: r.path.slice(packageInfo.packageDirectory.length + directorySeparator.length),

version: packageJsonContent.version

};

}

}

return r && { path: r.path, extension: r.ext, packageId };

}

function noPackageId(r: PathAndExtension | undefined): Resolved | undefined {

return withPackageId(/*packageInfo*/ undefined, r);

}

function removeIgnoredPackageId(r: Resolved | undefined): PathAndExtension | undefined {

if (r) {

Debug.assert(r.packageId === undefined);

return { path: r.path, ext: r.extension };

}

}

/** Result of trying to resolve a module. */

interface Resolved {

path: string;

extension: Extension;

packageId: PackageId | undefined;

/**

* When the resolved is not created from cache, the value is

* - string if it is symbolic link to the resolved `path`

* - undefined if `path` is not a symbolic link

* When the resolved is created using value from cache of ResolvedModuleWithFailedLookupLocations, the value is:

* - string if it is symbolic link to the resolved `path`

* - true if `path` is not a symbolic link - this indicates that the `originalPath` calculation is already done and needs to be skipped

* Note: This is a file name with preserved original casing, not a normalized `Path`.

*/

originalPath?: string | true;

}

/** Result of trying to resolve a module at a file. Needs to have 'packageId' added later. */

interface PathAndExtension {

path: string;

// (Use a different name than `extension` to make sure Resolved isn't assignable to PathAndExtension.)

ext: Extension;

}

/**

* Kinds of file that we are currently looking for.

* Typically there is one pass with Extensions.TypeScript, then a second pass with Extensions.JavaScript.

*/

enum Extensions {

TypeScript, /** '.ts', '.tsx', or '.d.ts' */

JavaScript, /** '.js' or '.jsx' */

Json, /** '.json' */

TSConfig, /** '.json' with `tsconfig` used instead of `index` */

DtsOnly /** Only '.d.ts' */

}

interface PathAndPackageId {

readonly fileName: string;

readonly packageId: PackageId | undefined;

}

/** Used with `Extensions.DtsOnly` to extract the path from TypeScript results. */

function resolvedTypeScriptOnly(resolved: Resolved | undefined): PathAndPackageId | undefined {

if (!resolved) {

return undefined;

}

Debug.assert(extensionIsTS(resolved.extension));

return { fileName: resolved.path, packageId: resolved.packageId };

}

function createResolvedModuleWithFailedLookupLocations(resolved: Resolved | undefined, isExternalLibraryImport: boolean | undefined, failedLookupLocations: string[], resultFromCache: ResolvedModuleWithFailedLookupLocations | undefined): ResolvedModuleWithFailedLookupLocations {

if (resultFromCache) {

resultFromCache.failedLookupLocations.push(...failedLookupLocations);

return resultFromCache;

}

return {

resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport, packageId: resolved.packageId },

failedLookupLocations

};

}

/*@internal*/

interface ModuleResolutionState {

host: ModuleResolutionHost;

compilerOptions: CompilerOptions;

traceEnabled: boolean;

failedLookupLocations: Push<string>;

resultFromCache?: ResolvedModuleWithFailedLookupLocations;

packageJsonInfoCache: PackageJsonInfoCache | undefined;

features: NodeResolutionFeatures;

conditions: string[];

}

/** Just the fields that we use for module resolution. */

/*@internal*/

interface PackageJsonPathFields {

typings?: string;

types?: string;

typesVersions?: MapLike<MapLike<string[]>>;

main?: string;

tsconfig?: string;

type?: string;

imports?: object;

exports?: object;

name?: string;

}

interface PackageJson extends PackageJsonPathFields {

name?: string;

version?: string;

}

function readPackageJsonField<TMatch, K extends MatchingKeys<PackageJson, string | undefined>>(jsonContent: PackageJson, fieldName: K, typeOfTag: "string", state: ModuleResolutionState): PackageJson[K] | undefined;

function readPackageJsonField<K extends MatchingKeys<PackageJson, object | undefined>>(jsonContent: PackageJson, fieldName: K, typeOfTag: "object", state: ModuleResolutionState): PackageJson[K] | undefined;

function readPackageJsonField<K extends keyof PackageJson>(jsonContent: PackageJson, fieldName: K, typeOfTag: "string" | "object", state: ModuleResolutionState): PackageJson[K] | undefined {

if (!hasProperty(jsonContent, fieldName)) {

if (state.traceEnabled) {

trace(state.host, Diagnostics.package_json_does_not_have_a_0_field, fieldName);

}

return;

}

const value = jsonContent[fieldName];

if (typeof value !== typeOfTag || value === null) { // eslint-disable-line no-null/no-null

if (state.traceEnabled) {

// eslint-disable-next-line no-null/no-null

trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, fieldName, typeOfTag, value === null ? "null" : typeof value);

}

return;

}

return value;

}

function readPackageJsonPathField<K extends "typings" | "types" | "main" | "tsconfig">(jsonContent: PackageJson, fieldName: K, baseDirectory: string, state: ModuleResolutionState): PackageJson[K] | undefined {

const fileName = readPackageJsonField(jsonContent, fieldName, "string", state);

if (fileName === undefined) {

return;

}

if (!fileName) {

if (state.traceEnabled) {

trace(state.host, Diagnostics.package_json_had_a_falsy_0_field, fieldName);

}

return;

}

const path = normalizePath(combinePaths(baseDirectory, fileName));

if (state.traceEnabled) {

trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path);

}

return path;

}

function readPackageJsonTypesFields(jsonContent: PackageJson, baseDirectory: string, state: ModuleResolutionState) {

return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state)

|| readPackageJsonPathField(jsonContent, "types", baseDirectory, state);

}

function readPackageJsonTSConfigField(jsonContent: PackageJson, baseDirectory: string, state: ModuleResolutionState) {

return readPackageJsonPathField(jsonContent, "tsconfig", baseDirectory, state);

}

function readPackageJsonMainField(jsonContent: PackageJson, baseDirectory: string, state: ModuleResolutionState) {

return readPackageJsonPathField(jsonContent, "main", baseDirectory, state);

}

function readPackageJsonTypesVersionsField(jsonContent: PackageJson, state: ModuleResolutionState) {

const typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state);

if (typesVersions === undefined) return;

if (state.traceEnabled) {

trace(state.host, Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings);

}

return typesVersions;

}

/*@internal*/

interface VersionPaths {

version: string;

paths: MapLike<string[]>;

}

function readPackageJsonTypesVersionPaths(jsonContent: PackageJson, state: ModuleResolutionState): VersionPaths | undefined {

const typesVersions = readPackageJsonTypesVersionsField(jsonContent, state);

if (typesVersions === undefined) return;

if (state.traceEnabled) {

for (const key in typesVersions) {

if (hasProperty(typesVersions, key) && !VersionRange.tryParse(key)) {

trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key);

}

}

}

const result = getPackageJsonTypesVersionsPaths(typesVersions);

if (!result) {

if (state.traceEnabled) {

trace(state.host, Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, versionMajorMinor);

}

return;

}

const { version: bestVersionKey, paths: bestVersionPaths } = result;

if (typeof bestVersionPaths !== "object") {

if (state.traceEnabled) {

trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, `typesVersions['${bestVersionKey}']`, "object", typeof bestVersionPaths);

}

return;

}

return result;

}

let typeScriptVersion: Version | undefined;

/* @internal */

export function getPackageJsonTypesVersionsPaths(typesVersions: MapLike<MapLike<string[]>>) {

if (!typeScriptVersion) typeScriptVersion = new Version(version);

for (const key in typesVersions) {

if (!hasProperty(typesVersions, key)) continue;

const keyRange = VersionRange.tryParse(key);

if (keyRange === undefined) {

continue;

}

// return the first entry whose range matches the current compiler version.

if (keyRange.test(typeScriptVersion)) {

return { version: key, paths: typesVersions[key] };

}

}

}

export function getEffectiveTypeRoots(options: CompilerOptions, host: GetEffectiveTypeRootsHost): string[] | undefined {

if (options.typeRoots) {

return options.typeRoots;

}

let currentDirectory: string | undefined;

if (options.configFilePath) {

currentDirectory = getDirectoryPath(options.configFilePath);

}

else if (host.getCurrentDirectory) {

currentDirectory = host.getCurrentDirectory();

}

if (currentDirectory !== undefined) {

return getDefaultTypeRoots(currentDirectory, host);

}

}

/**

* Returns the path to every node_modules/@types directory from some ancestor directory.

* Returns undefined if there are none.

*/

function getDefaultTypeRoots(currentDirectory: string, host: { directoryExists?: (directoryName: string) => boolean }): string[] | undefined {

if (!host.directoryExists) {

return [combinePaths(currentDirectory, nodeModulesAtTypes)];

// And if it doesn't exist, tough.

}

let typeRoots: string[] | undefined;

forEachAncestorDirectory(normalizePath(currentDirectory), directory => {

const atTypes = combinePaths(directory, nodeModulesAtTypes);

if (host.directoryExists!(atTypes)) {

(typeRoots || (typeRoots = [])).push(atTypes);

}

return undefined;

});

return typeRoots;

}

const nodeModulesAtTypes = combinePaths("node_modules", "@types");

function arePathsEqual(path1: string, path2: string, host: ModuleResolutionHost): boolean {

const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;

return comparePaths(path1, path2, !useCaseSensitiveFileNames) === Comparison.EqualTo;

}

/**

* @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.

* This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups

* is assumed to be the same as root directory of the project.

*/

export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost, redirectedReference?: ResolvedProjectReference, cache?: TypeReferenceDirectiveResolutionCache): ResolvedTypeReferenceDirectiveWithFailedLookupLocations {

const traceEnabled = isTraceEnabled(options, host);

if (redirectedReference) {

options = redirectedReference.commandLine.options;

}

const containingDirectory = containingFile ? getDirectoryPath(containingFile) : undefined;

const perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : undefined;

let result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, /*mode*/ undefined);

if (result) {

if (traceEnabled) {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);

if (redirectedReference) trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);

trace(host, Diagnostics.Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1, typeReferenceDirectiveName, containingDirectory);

traceResult(result);

}

return result;

}

const typeRoots = getEffectiveTypeRoots(options, host);

if (traceEnabled) {

if (containingFile === undefined) {

if (typeRoots === undefined) {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);

}

else {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);

}

}

else {

if (typeRoots === undefined) {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);

}

else {

trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);

}

}

if (redirectedReference) {

trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);

}

}

const failedLookupLocations: string[] = [];

const moduleResolutionState: ModuleResolutionState = { compilerOptions: options, host, traceEnabled, failedLookupLocations, packageJsonInfoCache: cache, features: NodeResolutionFeatures.AllFeatures, conditions: ["node", "require", "types"] };

let resolved = primaryLookup();

let primary = true;

if (!resolved) {

resolved = secondaryLookup();

primary = false;

}

let resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective | undefined;

if (resolved) {

const { fileName, packageId } = resolved;

const resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled);

resolvedTypeReferenceDirective = {

primary,

resolvedFileName,

originalPath: arePathsEqual(fileName, resolvedFileName, host) ? undefined : fileName,

packageId,

isExternalLibraryImport: pathContainsNodeModules(fileName),

};

}

result = { resolvedTypeReferenceDirective, failedLookupLocations };

perFolderCache?.set(typeReferenceDirectiveName, /*mode*/ undefined, result);

if (traceEnabled) traceResult(result);

return result;

function traceResult(result: ResolvedTypeReferenceDirectiveWithFailedLookupLocations) {

if (!result.resolvedTypeReferenceDirective?.resolvedFileName) {

trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);

}

else if (result.resolvedTypeReferenceDirective.packageId) {

trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, packageIdToString(result.resolvedTypeReferenceDirective.packageId), result.resolvedTypeReferenceDirective.primary);

}

else {

trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, result.resolvedTypeReferenceDirective.primary);

}

}

function primaryLookup(): PathAndPackageId | undefined {

// Check primary library paths

if (typeRoots && typeRoots.length) {

if (traceEnabled) {

trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));

}

return firstDefined(typeRoots, typeRoot => {

const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);

const candidateDirectory = getDirectoryPath(candidate);

const directoryExists = directoryProbablyExists(candidateDirectory, host);

if (!directoryExists && traceEnabled) {

trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);

}

return resolvedTypeScriptOnly(

loadNodeModuleFromDirectory(Extensions.DtsOnly, candidate,

!directoryExists, moduleResolutionState));

});

}

else {

if (traceEnabled) {

trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);

}

}

}

function secondaryLookup(): PathAndPackageId | undefined {

const initialLocationForSecondaryLookup = containingFile && getDirectoryPath(containingFile);

if (initialLocationForSecondaryLookup !== undefined) {

// check secondary locations

if (traceEnabled) {

trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);

}

let result: Resolved | undefined;

if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {

const searchResult = loadModuleFromNearestNodeModulesDirectory(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, /*cache*/ undefined, /*redirectedReference*/ undefined);

result = searchResult && searchResult.value;

}

else {

const { path: candidate } = normalizePathAndParts(combinePaths(initialLocationForSecondaryLookup, typeReferenceDirectiveName));

result = nodeLoadModuleByRelativeName(Extensions.DtsOnly, candidate, /*onlyRecordFailures*/ false, moduleResolutionState, /*considerPackageJson*/ true);

}

return resolvedTypeScriptOnly(result);

}

else {

if (traceEnabled) {

trace(host, Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);

}

}

}

}

/**

* Given a set of options, returns the set of type directive names

* that should be included for this program automatically.

* This list could either come from the config file,

* or from enumerating the types root + initial secondary types lookup location.

* More type directives might appear in the program later as a result of loading actual source files;

* this list is only the set of defaults that are implicitly included.

*/

export function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[] {

// Use explicit type list from tsconfig.json

if (options.types) {

return options.types;

}

// Walk the primary type lookup locations

const result: string[] = [];

if (host.directoryExists && host.getDirectories) {

const typeRoots = getEffectiveTypeRoots(options, host);

if (typeRoots) {

for (const root of typeRoots) {

if (host.directoryExists(root)) {

for (const typeDirectivePath of host.getDirectories(root)) {

const normalized = normalizePath(typeDirectivePath);

const packageJsonPath = combinePaths(root, normalized, "package.json");

// `types-publisher` sometimes creates packages with `"typings": null` for packages that don't provide their own types.

// See `createNotNeededPackageJSON` in the types-publisher` repo.

// eslint-disable-next-line no-null/no-null

const isNotNeededPackage = host.fileExists(packageJsonPath) && (readJson(packageJsonPath, host) as PackageJson).typings === null;

if (!isNotNeededPackage) {

const baseFileName = getBaseFileName(normalized);

// At this stage, skip results with leading dot.

if (baseFileName.charCodeAt(0) !== CharacterCodes.dot) {

// Return just the type directive names

result.push(baseFileName);

}

}

}

}

}

}

}

return result;

}

export interface TypeReferenceDirectiveResolutionCache extends PerDirectoryResolutionCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>, PackageJsonInfoCache {

}

export interface ModeAwareCache<T> {

get(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): T | undefined;

set(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined, value: T): this;

delete(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): this;

has(key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): boolean;

forEach(cb: (elem: T, key: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined) => void): void;

size(): number;

}

/**

* Cached resolutions per containing directory.

* This assumes that any module id will have the same resolution for sibling files located in the same folder.

*/

export interface PerDirectoryResolutionCache<T> {

getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): ModeAwareCache<T>;

clear(): void;

/**

* Updates with the current compilerOptions the cache will operate with.

* This updates the redirects map as well if needed so module resolutions are cached if they can across the projects

*/

update(options: CompilerOptions): void;

}

export interface ModuleResolutionCache extends PerDirectoryResolutionCache<ResolvedModuleWithFailedLookupLocations>, NonRelativeModuleNameResolutionCache, PackageJsonInfoCache {

getPackageJsonInfoCache(): PackageJsonInfoCache;

}

/**

* Stored map from non-relative module name to a table: directory -> result of module lookup in this directory

* We support only non-relative module names because resolution of relative module names is usually more deterministic and thus less expensive.

*/

export interface NonRelativeModuleNameResolutionCache extends PackageJsonInfoCache {

getOrCreateCacheForModuleName(nonRelativeModuleName: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined, redirectedReference?: ResolvedProjectReference): PerModuleNameCache;

}

export interface PackageJsonInfoCache {

/*@internal*/ getPackageJsonInfo(packageJsonPath: string): PackageJsonInfo | boolean | undefined;

/*@internal*/ setPackageJsonInfo(packageJsonPath: string, info: PackageJsonInfo | boolean): void;

/*@internal*/ entries(): [Path, PackageJsonInfo | boolean][];

clear(): void;

}

export interface PerModuleNameCache {

get(directory: string): ResolvedModuleWithFailedLookupLocations | undefined;

set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void;

}

/*@internal*/

export interface CacheWithRedirects<T> {

getOwnMap: () => ESMap<string, T>;

redirectsMap: ESMap<Path, ESMap<string, T>>;

getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): ESMap<string, T>;

clear(): void;

setOwnOptions(newOptions: CompilerOptions): void;

setOwnMap(newOwnMap: ESMap<string, T>): void;

}

/*@internal*/

export function createCacheWithRedirects<T>(options?: CompilerOptions): CacheWithRedirects<T> {

let ownMap: ESMap<string, T> = new Map();

const redirectsMap = new Map<Path, ESMap<string, T>>();

return {

getOwnMap,

redirectsMap,

getOrCreateMapOfCacheRedirects,

clear,

setOwnOptions,

setOwnMap

};

function getOwnMap() {

return ownMap;

}

function setOwnOptions(newOptions: CompilerOptions) {

options = newOptions;

}

function setOwnMap(newOwnMap: ESMap<string, T>) {

ownMap = newOwnMap;

}

function getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined) {

if (!redirectedReference) {

return ownMap;

}

const path = redirectedReference.sourceFile.path;

let redirects = redirectsMap.get(path);

if (!redirects) {

// Reuse map if redirected reference map uses same resolution

redirects = !options || optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? new Map() : ownMap;

redirectsMap.set(path, redirects);

}

return redirects;

}

function clear() {

ownMap.clear();

redirectsMap.clear();

}

}

function createPackageJsonInfoCache(currentDirectory: string, getCanonicalFileName: (s: string) => string): PackageJsonInfoCache {

let cache: ESMap<Path, PackageJsonInfo | boolean> | undefined;

return { getPackageJsonInfo, setPackageJsonInfo, clear, entries };

function getPackageJsonInfo(packageJsonPath: string) {

return cache?.get(toPath(packageJsonPath, currentDirectory, getCanonicalFileName));

}

function setPackageJsonInfo(packageJsonPath: string, info: PackageJsonInfo | boolean) {

(cache ||= new Map()).set(toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info);

}

function clear() {

cache = undefined;

}

function entries() {

const iter = cache?.entries();

return iter ? arrayFrom(iter) : [];

}

}

function getOrCreateCache<T>(cacheWithRedirects: CacheWithRedirects<T>, redirectedReference: ResolvedProjectReference | undefined, key: string, create: () => T): T {

const cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);

let result = cache.get(key);

if (!result) {

result = create();

cache.set(key, result);

}

return result;

}

function updateRedirectsMap<T>(

options: CompilerOptions,

directoryToModuleNameMap: CacheWithRedirects<ModeAwareCache<T>>,

moduleNameToDirectoryMap?: CacheWithRedirects<PerModuleNameCache>

) {

if (!options.configFile) return;

if (directoryToModuleNameMap.redirectsMap.size === 0) {

// The own map will be for projectCompilerOptions

Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size === 0);

Debug.assert(directoryToModuleNameMap.getOwnMap().size === 0);

Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.getOwnMap().size === 0);

directoryToModuleNameMap.redirectsMap.set(options.configFile.path, directoryToModuleNameMap.getOwnMap());

moduleNameToDirectoryMap?.redirectsMap.set(options.configFile.path, moduleNameToDirectoryMap.getOwnMap());

}

else {

// Set correct own map

Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size > 0);

const ref: ResolvedProjectReference = {

sourceFile: options.configFile,

commandLine: { options } as ParsedCommandLine

};

directoryToModuleNameMap.setOwnMap(directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref));

moduleNameToDirectoryMap?.setOwnMap(moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref));

}

directoryToModuleNameMap.setOwnOptions(options);

moduleNameToDirectoryMap?.setOwnOptions(options);

}

function createPerDirectoryResolutionCache<T>(currentDirectory: string, getCanonicalFileName: GetCanonicalFileName, directoryToModuleNameMap: CacheWithRedirects<ModeAwareCache<T>>): PerDirectoryResolutionCache<T> {

return {

getOrCreateCacheForDirectory,

clear,

update,

};

function clear() {

directoryToModuleNameMap.clear();

}

function update(options: CompilerOptions) {

updateRedirectsMap(options, directoryToModuleNameMap);

}

function getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference) {

const path = toPath(directoryName, currentDirectory, getCanonicalFileName);

return getOrCreateCache<ModeAwareCache<T>>(directoryToModuleNameMap, redirectedReference, path, () => createModeAwareCache());

}

}

/* @internal */

export function createModeAwareCache<T>(): ModeAwareCache<T> {

const underlying = new Map<string, T>();

const memoizedReverseKeys = new Map<string, [specifier: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined]>();

const cache: ModeAwareCache<T> = {

get(specifier, mode) {

return underlying.get(getUnderlyingCacheKey(specifier, mode));

},

set(specifier, mode, value) {

underlying.set(getUnderlyingCacheKey(specifier, mode), value);

return cache;

},

delete(specifier, mode) {

underlying.delete(getUnderlyingCacheKey(specifier, mode));

return cache;

},

has(specifier, mode) {

return underlying.has(getUnderlyingCacheKey(specifier, mode));

},

forEach(cb) {

return underlying.forEach((elem, key) => {

const [specifier, mode] = memoizedReverseKeys.get(key)!;

return cb(elem, specifier, mode);

});

},

size() {

return underlying.size;

}

};

return cache;

function getUnderlyingCacheKey(specifier: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined) {

const result = mode === undefined ? specifier : `${mode}|${specifier}`;

memoizedReverseKeys.set(result, [specifier, mode]);

return result;

}

}

/* @internal */

export function zipToModeAwareCache<V>(file: SourceFile, keys: readonly string[], values: readonly V[]): ModeAwareCache<V> {

Debug.assert(keys.length === values.length);

const map = createModeAwareCache<V>();

for (let i = 0; i < keys.length; ++i) {

map.set(keys[i], getModeForResolutionAtIndex(file, i), values[i]);

}

return map;

}

export function createModuleResolutionCache(

currentDirectory: string,

getCanonicalFileName: (s: string) => string,

options?: CompilerOptions

): ModuleResolutionCache;

/*@internal*/

export function createModuleResolutionCache(

currentDirectory: string,

getCanonicalFileName: GetCanonicalFileName,

options: undefined,

directoryToModuleNameMap: CacheWithRedirects<ModeAwareCache<ResolvedModuleWithFailedLookupLocations>>,

moduleNameToDirectoryMap: CacheWithRedirects<PerModuleNameCache>,

): ModuleResolutionCache;

export function createModuleResolutionCache(

currentDirectory: string,

getCanonicalFileName: GetCanonicalFileName,

options?: CompilerOptions,

directoryToModuleNameMap?: CacheWithRedirects<ModeAwareCache<ResolvedModuleWithFailedLookupLocations>>,

moduleNameToDirectoryMap?: CacheWithRedirects<PerModuleNameCache>,

): ModuleResolutionCache {

const preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap ||= createCacheWithRedirects(options));

moduleNameToDirectoryMap ||= createCacheWithRedirects(options);

const packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);

return {

...packageJsonInfoCache,

...preDirectoryResolutionCache,

getOrCreateCacheForModuleName,

clear,

update,

getPackageJsonInfoCache: () => packageJsonInfoCache,

};

function clear() {

preDirectoryResolutionCache.clear();

moduleNameToDirectoryMap!.clear();

packageJsonInfoCache.clear();

}

function update(options: CompilerOptions) {

updateRedirectsMap(options, directoryToModuleNameMap!, moduleNameToDirectoryMap);

}

function getOrCreateCacheForModuleName(nonRelativeModuleName: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined, redirectedReference?: ResolvedProjectReference): PerModuleNameCache {

Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName));

return getOrCreateCache(moduleNameToDirectoryMap!, redirectedReference, mode === undefined ? nonRelativeModuleName : `${mode}|${nonRelativeModuleName}`, createPerModuleNameCache);

}

function createPerModuleNameCache(): PerModuleNameCache {

const directoryPathMap = new Map<string, ResolvedModuleWithFailedLookupLocations>();

return { get, set };

function get(directory: string): ResolvedModuleWithFailedLookupLocations | undefined {

return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));

}

/**

* At first this function add entry directory -> module resolution result to the table.

* Then it computes the set of parent folders for 'directory' that should have the same module resolution result

* and for every parent folder in set it adds entry: parent -> module resolution. .

* Lets say we first directory name: /a/b/c/d/e and resolution result is: /a/b/bar.ts.

* Set of parent folders that should have the same result will be:

* [

* /a/b/c/d, /a/b/c, /a/b

* ]

* this means that request for module resolution from file in any of these folder will be immediately found in cache.

*/

function set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void {

const path = toPath(directory, currentDirectory, getCanonicalFileName);

// if entry is already in cache do nothing

if (directoryPathMap.has(path)) {

return;

}

directoryPathMap.set(path, result);

const resolvedFileName = result.resolvedModule &&

(result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);

// find common prefix between directory and resolved file name

// this common prefix should be the shortest path that has the same resolution

// directory: /a/b/c/d/e

// resolvedFileName: /a/b/foo.d.ts

// commonPrefix: /a/b

// for failed lookups cache the result for every directory up to root

const commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);

let current = path;

while (current !== commonPrefix) {

const parent = getDirectoryPath(current);

if (parent === current || directoryPathMap.has(parent)) {

break;

}

directoryPathMap.set(parent, result);

current = parent;

}

}

function getCommonPrefix(directory: Path, resolution: string) {

const resolutionDirectory = toPath(getDirectoryPath(resolution), currentDirectory, getCanonicalFileName);

// find first position where directory and resolution differs

let i = 0;

const limit = Math.min(directory.length, resolutionDirectory.length);

while (i < limit && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) {

i++;

}

if (i === directory.length && (resolutionDirectory.length === i || resolutionDirectory[i] === directorySeparator)) {

return directory;

}

const rootLength = getRootLength(directory);

if (i < rootLength) {

return undefined;

}

const sep = directory.lastIndexOf(directorySeparator, i - 1);

if (sep === -1) {

return undefined;

}

return directory.substr(0, Math.max(sep, rootLength));

}

}

}

export function createTypeReferenceDirectiveResolutionCache(

currentDirectory: string,

getCanonicalFileName: (s: string) => string,

options?: CompilerOptions,

packageJsonInfoCache?: PackageJsonInfoCache,

): TypeReferenceDirectiveResolutionCache;

/*@internal*/

export function createTypeReferenceDirectiveResolutionCache(

currentDirectory: string,

getCanonicalFileName: GetCanonicalFileName,

options: undefined,

packageJsonInfoCache: PackageJsonInfoCache | undefined,

directoryToModuleNameMap: CacheWithRedirects<ModeAwareCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>>,

): TypeReferenceDirectiveResolutionCache;

export function createTypeReferenceDirectiveResolutionCache(

currentDirectory: string,

getCanonicalFileName: GetCanonicalFileName,

options?: CompilerOptions,

packageJsonInfoCache?: PackageJsonInfoCache | undefined,

directoryToModuleNameMap?: CacheWithRedirects<ModeAwareCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>>,

): TypeReferenceDirectiveResolutionCache {

const preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap ||= createCacheWithRedirects(options));

packageJsonInfoCache ||= createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);

return {

...packageJsonInfoCache,

...preDirectoryResolutionCache,

clear,

};

function clear() {

preDirectoryResolutionCache.clear();

packageJsonInfoCache!.clear();

}

}

export function resolveModuleNameFromCache(moduleName: string, containingFile: string, cache: ModuleResolutionCache, mode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations | undefined {

const containingDirectory = getDirectoryPath(containingFile);

const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);

if (!perFolderCache) return undefined;

return perFolderCache.get(moduleName, mode);

}

export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ModuleKind.CommonJS | ModuleKind.ESNext): ResolvedModuleWithFailedLookupLocations {

const traceEnabled = isTraceEnabled(compilerOptions, host);

if (redirectedReference) {

compilerOptions = redirectedReference.commandLine.options;

}

if (traceEnabled) {

trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);

if (redirectedReference) {

trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);

}

}

const containingDirectory = getDirectoryPath(containingFile);

const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);

let result = perFolderCache && perFolderCache.get(moduleName, resolutionMode);

if (result) {

if (traceEnabled) {

trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);

}

}

else {

let moduleResolution = compilerOptions.moduleResolution;

if (moduleResolution === undefined) {

switch (getEmitModuleKind(compilerOptions)) {

case ModuleKind.CommonJS:

moduleResolution = ModuleResolutionKind.NodeJs;

break;

case ModuleKind.Node12:

moduleResolution = ModuleResolutionKind.Node12;

break;

case ModuleKind.NodeNext:

moduleResolution = ModuleResolutionKind.NodeNext;

break;

default:

moduleResolution = ModuleResolutionKind.Classic;

break;

}

if (traceEnabled) {

trace(host, Diagnostics.Module_resolution_kind_is_not_specified_using_0, ModuleResolutionKind[moduleResolution]);

}

}

else {

if (traceEnabled) {

trace(host, Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ModuleResolutionKind[moduleResolution]);

}

}

perfLogger.logStartResolveModule(moduleName /* , containingFile, ModuleResolutionKind[moduleResolution]*/);

switch (moduleResolution) {

case ModuleResolutionKind.Node12:

result = node12ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);

break;

case ModuleResolutionKind.NodeNext:

result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);

break;

case ModuleResolutionKind.NodeJs:

result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);

break;

case ModuleResolutionKind.Classic:

result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);

break;

default:

return Debug.fail(`Unexpected moduleResolution: ${moduleResolution}`);

}

if (result && result.resolvedModule) perfLogger.logInfoEvent(`Module "${moduleName}" resolved to "${result.resolvedModule.resolvedFileName}"`);

perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null");

if (perFolderCache) {

perFolderCache.set(moduleName, resolutionMode, result);

if (!isExternalModuleNameRelative(moduleName)) {

// put result in per-module name cache

cache!.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);

}

}

}

if (traceEnabled) {

if (result.resolvedModule) {

if (result.resolvedModule.packageId) {

trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, packageIdToString(result.resolvedModule.packageId));

}

else {

trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);

}

}

else {

trace(host, Diagnostics.Module_name_0_was_not_resolved, moduleName);

}

}

return result;

}

/*

* Every module resolution kind can has its specific understanding how to load module from a specific path on disk

* I.e. for path '/a/b/c':

* - Node loader will first to try to check if '/a/b/c' points to a file with some supported extension and if this fails

* it will try to load module from directory: directory '/a/b/c' should exist and it should have either 'package.json' with

* 'typings' entry or file 'index' with some supported extension

* - Classic loader will only try to interpret '/a/b/c' as file.

*/

type ResolutionKindSpecificLoader = (extensions: Extensions, candidate: string, onlyRecordFailures: boolean, state: ModuleResolutionState) => Resolved | undefined;

/**

* Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to

* mitigate differences between design time structure of the project and its runtime counterpart so the same import name

* can be resolved successfully by TypeScript compiler and runtime module loader.

* If these settings are set then loading procedure will try to use them to resolve module name and it can of failure it will

* fallback to standard resolution routine.

*

* - baseUrl - this setting controls how non-relative module names are resolved. If this setting is specified then non-relative

* names will be resolved relative to baseUrl: i.e. if baseUrl is '/a/b' then candidate location to resolve module name 'c/d' will

* be '/a/b/c/d'

* - paths - this setting can only be used when baseUrl is specified. allows to tune how non-relative module names

* will be resolved based on the content of the module name.

* Structure of 'paths' compiler options

* 'paths': {

* pattern-1: [...substitutions],

* pattern-2: [...substitutions],

* ...

* pattern-n: [...substitutions]

* }

* Pattern here is a string that can contain zero or one '*' character. During module resolution module name will be matched against

* all patterns in the list. Matching for patterns that don't contain '*' means that module name must be equal to pattern respecting the case.

* If pattern contains '*' then to match pattern "<prefix>*<suffix>" module name must start with the <prefix> and end with <suffix>.

* <MatchedStar> denotes part of the module name between <prefix> and <suffix>.

* If module name can be matches with multiple patterns then pattern with the longest prefix will be picked.

* After selecting pattern we'll use list of substitutions to get candidate locations of the module and the try to load module

* from the candidate location.