import {

append,

appendIfUnique,

arrayIsEqualTo,

changeAnyExtension,

changeFullExtension,

CharacterCodes,

combinePaths,

CommandLineOption,

comparePaths,

Comparison,

CompilerHost,

CompilerOptions,

concatenate,

contains,

containsPath,

createCompilerDiagnostic,

Debug,

deduplicate,

Diagnostic,

DiagnosticMessage,

DiagnosticReporter,

Diagnostics,

directoryProbablyExists,

directorySeparator,

emptyArray,

endsWith,

ensureTrailingDirectorySeparator,

every,

Extension,

extensionIsTS,

fileExtensionIs,

fileExtensionIsOneOf,

filter,

firstDefined,

forEach,

forEachAncestorDirectory,

formatMessage,

getAllowImportingTsExtensions,

getAllowJSCompilerOption,

getAnyExtensionFromPath,

getBaseFileName,

GetCanonicalFileName,

getCommonSourceDirectory,

getCompilerOptionValue,

getDirectoryPath,

GetEffectiveTypeRootsHost,

getEmitModuleResolutionKind,

getNormalizedAbsolutePath,

getOwnKeys,

getPathComponents,

getPathFromPathComponents,

getPathsBasePath,

getPossibleOriginalInputExtensionForExtension,

getRelativePathFromDirectory,

getResolveJsonModule,

getRootLength,

hasProperty,

hasTrailingDirectorySeparator,

hostGetCanonicalFileName,

inferredTypesContainingFile,

isArray,

isDeclarationFileName,

isExternalModuleNameRelative,

isRootedDiskPath,

isString,

lastOrUndefined,

length,

MapLike,

matchedText,

MatchingKeys,

matchPatternOrExact,

ModuleKind,

ModuleResolutionHost,

ModuleResolutionKind,

moduleResolutionOptionDeclarations,

moduleResolutionSupportsPackageJsonExportsAndImports,

ModuleSpecifierResolutionHost,

noop,

normalizePath,

normalizeSlashes,

PackageId,

packageIdToString,

ParsedPatterns,

Path,

pathIsRelative,

patternText,

readJson,

removeExtension,

removeFileExtension,

removePrefix,

replaceFirstStar,

ResolutionMode,

ResolvedModuleWithFailedLookupLocations,

ResolvedProjectReference,

ResolvedTypeReferenceDirective,

ResolvedTypeReferenceDirectiveWithFailedLookupLocations,

some,

startsWith,

supportedDeclarationExtensions,

supportedJSExtensionsFlat,

supportedTSImplementationExtensions,

toPath,

toSorted,

tryExtractTSExtension,

tryGetExtensionFromPath,

tryParsePatterns,

Version,

version,

versionMajorMinor,

VersionRange,

} from "./_namespaces/ts.js";

/** @internal */

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

host.trace!(formatMessage(message, ...args));

}

/** @internal */

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

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

}

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

let packageId: PackageId | undefined;

if (r && packageInfo) {

const packageJsonContent = packageInfo.contents.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,

peerDependencies: getPeerDependenciesOfPackageJsonInfo(packageInfo, state),

};

}

}

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

}

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

return withPackageId(/*packageInfo*/ undefined, r, /*state*/ undefined!); // State will not be used so no need to pass

}

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

if (r) {

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

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

}

}

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

interface Resolved {

path: string;

extension: string;

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;

resolvedUsingTsExtension: boolean | undefined;

}

/** 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: string;

resolvedUsingTsExtension: boolean | undefined;

}

// dprint-ignore

/**

* Kinds of file that we are currently looking for.

*/

const enum Extensions {

TypeScript = 1 << 0, // '.ts', '.tsx', '.mts', '.cts'

JavaScript = 1 << 1, // '.js', '.jsx', '.mjs', '.cjs'

Declaration = 1 << 2, // '.d.ts', etc.

Json = 1 << 3, // '.json'

ImplementationFiles = TypeScript | JavaScript,

}

function formatExtensions(extensions: Extensions) {

const result: string[] = [];

if (extensions & Extensions.TypeScript) result.push("TypeScript");

if (extensions & Extensions.JavaScript) result.push("JavaScript");

if (extensions & Extensions.Declaration) result.push("Declaration");

if (extensions & Extensions.Json) result.push("JSON");

return result.join(", ");

}

function extensionsToExtensionsArray(extensions: Extensions) {

const result: Extension[] = [];

if (extensions & Extensions.TypeScript) result.push(...supportedTSImplementationExtensions);

if (extensions & Extensions.JavaScript) result.push(...supportedJSExtensionsFlat);

if (extensions & Extensions.Declaration) result.push(...supportedDeclarationExtensions);

if (extensions & Extensions.Json) result.push(Extension.Json);

return result;

}

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 createResolvedModuleWithFailedLookupLocationsHandlingSymlink(

moduleName: string,

resolved: Resolved | undefined,

isExternalLibraryImport: boolean | undefined,

failedLookupLocations: string[],

affectingLocations: string[],

diagnostics: Diagnostic[],

state: ModuleResolutionState,

cache: ModuleResolutionCache | NonRelativeModuleNameResolutionCache | undefined,

alternateResult?: string,

): ResolvedModuleWithFailedLookupLocations {

// If this is from node_modules for non relative name, always respect preserveSymlinks

if (

!state.resultFromCache &&

!state.compilerOptions.preserveSymlinks &&

resolved &&

isExternalLibraryImport &&

!resolved.originalPath &&

!isExternalModuleNameRelative(moduleName)

) {

const { resolvedFileName, originalPath } = getOriginalAndResolvedFileName(resolved.path, state.host, state.traceEnabled);

if (originalPath) resolved = { ...resolved, path: resolvedFileName, originalPath };

}

return createResolvedModuleWithFailedLookupLocations(

resolved,

isExternalLibraryImport,

failedLookupLocations,

affectingLocations,

diagnostics,

state.resultFromCache,

cache,

alternateResult,

);

}

function createResolvedModuleWithFailedLookupLocations(

resolved: Resolved | undefined,

isExternalLibraryImport: boolean | undefined,

failedLookupLocations: string[],

affectingLocations: string[],

diagnostics: Diagnostic[],

resultFromCache: ResolvedModuleWithFailedLookupLocations | undefined,

cache: ModuleResolutionCache | NonRelativeModuleNameResolutionCache | undefined,

alternateResult?: string,

): ResolvedModuleWithFailedLookupLocations {

if (resultFromCache) {

if (!cache?.isReadonly) {

resultFromCache.failedLookupLocations = updateResolutionField(resultFromCache.failedLookupLocations, failedLookupLocations);

resultFromCache.affectingLocations = updateResolutionField(resultFromCache.affectingLocations, affectingLocations);

resultFromCache.resolutionDiagnostics = updateResolutionField(resultFromCache.resolutionDiagnostics, diagnostics);

return resultFromCache;

}

else {

return {

...resultFromCache,

failedLookupLocations: initializeResolutionFieldForReadonlyCache(resultFromCache.failedLookupLocations, failedLookupLocations),

affectingLocations: initializeResolutionFieldForReadonlyCache(resultFromCache.affectingLocations, affectingLocations),

resolutionDiagnostics: initializeResolutionFieldForReadonlyCache(resultFromCache.resolutionDiagnostics, diagnostics),

};

}

}

return {

resolvedModule: resolved && {

resolvedFileName: resolved.path,

originalPath: resolved.originalPath === true ? undefined : resolved.originalPath,

extension: resolved.extension,

isExternalLibraryImport,

packageId: resolved.packageId,

resolvedUsingTsExtension: !!resolved.resolvedUsingTsExtension,

},

failedLookupLocations: initializeResolutionField(failedLookupLocations),

affectingLocations: initializeResolutionField(affectingLocations),

resolutionDiagnostics: initializeResolutionField(diagnostics),

alternateResult,

};

}

function initializeResolutionField<T>(value: T[]): T[] | undefined {

return value.length ? value : undefined;

}

/** @internal */

export function updateResolutionField<T>(to: T[] | undefined, value: T[] | undefined): T[] | undefined {

if (!value?.length) return to;

if (!to?.length) return value;

to.push(...value);

return to;

}

function initializeResolutionFieldForReadonlyCache<T>(fromCache: T[] | undefined, value: T[]): T[] | undefined {

if (!fromCache?.length) return initializeResolutionField(value);

if (!value.length) return fromCache.slice();

return [...fromCache, ...value];

}

/** @internal */

export interface ModuleResolutionState {

host: ModuleResolutionHost;

compilerOptions: CompilerOptions;

traceEnabled: boolean;

failedLookupLocations: string[] | undefined;

affectingLocations: string[] | undefined;

resultFromCache?: ResolvedModuleWithFailedLookupLocations;

packageJsonInfoCache: PackageJsonInfoCache | undefined;

features: NodeResolutionFeatures;

conditions: readonly string[];

requestContainingDirectory: string | undefined;

reportDiagnostic: DiagnosticReporter;

isConfigLookup: boolean;

candidateIsFromPackageJsonField: boolean;

resolvedPackageDirectory: boolean;

}

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

*

* @internal

*/

export interface PackageJsonPathFields {

typings?: string;

types?: string;

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

main?: string;

tsconfig?: string;

type?: string;

imports?: object;

exports?: object;

name?: string;

dependencies?: MapLike<string>;

peerDependencies?: MapLike<string>;

optionalDependencies?: MapLike<string>;

}

interface PackageJson extends PackageJsonPathFields {

name?: string;

version?: string;

}

function readPackageJsonField<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; // eslint-disable-line @typescript-eslint/unified-signatures

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-restricted-syntax

if (state.traceEnabled) {

// eslint-disable-next-line no-restricted-syntax

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 */

export 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[]>>): VersionPaths | undefined {

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);

}

}

/**

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

* Returns undefined if there are none.

*/

function getDefaultTypeRoots(currentDirectory: string): string[] | undefined {

let typeRoots: string[] | undefined;

forEachAncestorDirectory(normalizePath(currentDirectory), directory => {

const atTypes = combinePaths(directory, nodeModulesAtTypes);

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

});

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;

}

function getOriginalAndResolvedFileName(fileName: string, host: ModuleResolutionHost, traceEnabled: boolean) {

const resolvedFileName = realPath(fileName, host, traceEnabled);

const pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host);

return {

// If the fileName and realpath are differing only in casing prefer fileName so that we can issue correct errors for casing under forceConsistentCasingInFileNames

resolvedFileName: pathsAreEqual ? fileName : resolvedFileName,

originalPath: pathsAreEqual ? undefined : fileName,

};

}

function getCandidateFromTypeRoot(typeRoot: string, typeReferenceDirectiveName: string, moduleResolutionState: ModuleResolutionState) {

const nameForLookup = endsWith(typeRoot, "/node_modules/@types") || endsWith(typeRoot, "/node_modules/@types/") ?

mangleScopedPackageNameWithTrace(typeReferenceDirectiveName, moduleResolutionState) :

typeReferenceDirectiveName;

return combinePaths(typeRoot, nameForLookup);

}

/**

* @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, resolutionMode?: ResolutionMode): ResolvedTypeReferenceDirectiveWithFailedLookupLocations {

Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");

const traceEnabled = isTraceEnabled(options, host);

if (redirectedReference) {

options = redirectedReference.commandLine.options;

}

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

let result = containingDirectory ? cache?.getFromDirectoryCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference) : undefined;

if (!result && containingDirectory && !isExternalModuleNameRelative(typeReferenceDirectiveName)) {

result = cache?.getFromNonRelativeNameCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference);

}

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 affectingLocations: string[] = [];

// Allow type reference directives to opt into `exports` resolution in any resolution mode

// when a `resolution-mode` override is present.

let features = getNodeResolutionFeatures(options);

if (resolutionMode !== undefined) {

features |= NodeResolutionFeatures.AllFeatures;

}

const moduleResolution = getEmitModuleResolutionKind(options);

if (resolutionMode === ModuleKind.ESNext && (ModuleResolutionKind.Node16 <= moduleResolution && moduleResolution <= ModuleResolutionKind.NodeNext)) {

features |= NodeResolutionFeatures.EsmMode;

}

const conditions = (features & NodeResolutionFeatures.Exports)

? getConditions(options, resolutionMode)

: [];

const diagnostics: Diagnostic[] = [];

const moduleResolutionState: ModuleResolutionState = {

compilerOptions: options,

host,

traceEnabled,

failedLookupLocations,

affectingLocations,

packageJsonInfoCache: cache,

features,

conditions,

requestContainingDirectory: containingDirectory,

reportDiagnostic: diag => void diagnostics.push(diag),

isConfigLookup: false,

candidateIsFromPackageJsonField: false,

resolvedPackageDirectory: false,

};

let resolved = primaryLookup();

let primary = true;

if (!resolved) {

resolved = secondaryLookup();

primary = false;

}

let resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective | undefined;

if (resolved) {

const { fileName, packageId } = resolved;

let resolvedFileName = fileName, originalPath: string | undefined;

if (!options.preserveSymlinks) ({ resolvedFileName, originalPath } = getOriginalAndResolvedFileName(fileName, host, traceEnabled));

resolvedTypeReferenceDirective = {

primary,

resolvedFileName,

originalPath,

packageId,

isExternalLibraryImport: pathContainsNodeModules(fileName),

};

}

result = {

resolvedTypeReferenceDirective,

failedLookupLocations: initializeResolutionField(failedLookupLocations),

affectingLocations: initializeResolutionField(affectingLocations),

resolutionDiagnostics: initializeResolutionField(diagnostics),

};

if (containingDirectory && cache && !cache.isReadonly) {

cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);

if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {

cache.getOrCreateCacheForNonRelativeName(typeReferenceDirectiveName, resolutionMode, redirectedReference).set(containingDirectory, 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 = getCandidateFromTypeRoot(typeRoot, typeReferenceDirectiveName, moduleResolutionState);

const directoryExists = directoryProbablyExists(typeRoot, host);

if (!directoryExists && traceEnabled) {

trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);

}

if (options.typeRoots) {

// Custom typeRoots resolve as file or directory just like we do modules

const resolvedFromFile = loadModuleFromFile(Extensions.Declaration, candidate, !directoryExists, moduleResolutionState);

if (resolvedFromFile) {

const packageDirectory = parseNodeModuleFromPath(resolvedFromFile.path);

const packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, /*onlyRecordFailures*/ false, moduleResolutionState) : undefined;

return resolvedTypeScriptOnly(withPackageId(packageInfo, resolvedFromFile, moduleResolutionState));

}

}

return resolvedTypeScriptOnly(

loadNodeModuleFromDirectory(Extensions.Declaration, 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) {

let result: Resolved | undefined;

if (!options.typeRoots || !endsWith(containingFile!, inferredTypesContainingFile)) {

// check secondary locations

if (traceEnabled) {

trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);

}

if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {

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

result = searchResult && searchResult.value;

}

else {

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

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

}

}

else if (traceEnabled) {

trace(host, Diagnostics.Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder);

}

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);

}

}

}

}

function getNodeResolutionFeatures(options: CompilerOptions) {

let features = NodeResolutionFeatures.None;

switch (getEmitModuleResolutionKind(options)) {

case ModuleResolutionKind.Node16:

features = NodeResolutionFeatures.Node16Default;

break;

case ModuleResolutionKind.NodeNext:

features = NodeResolutionFeatures.NodeNextDefault;

break;

case ModuleResolutionKind.Bundler:

features = NodeResolutionFeatures.BundlerDefault;

break;

}

if (options.resolvePackageJsonExports) {

features |= NodeResolutionFeatures.Exports;

}

else if (options.resolvePackageJsonExports === false) {

features &= ~NodeResolutionFeatures.Exports;

}

if (options.resolvePackageJsonImports) {

features |= NodeResolutionFeatures.Imports;

}

else if (options.resolvePackageJsonImports === false) {

features &= ~NodeResolutionFeatures.Imports;

}

return features;

}

/** @internal */

export function getConditions(options: CompilerOptions, resolutionMode?: ResolutionMode): string[] {

const moduleResolution = getEmitModuleResolutionKind(options);

if (resolutionMode === undefined) {

if (moduleResolution === ModuleResolutionKind.Bundler) {

// bundler always uses `import` unless explicitly overridden

resolutionMode = ModuleKind.ESNext;

}

else if (moduleResolution === ModuleResolutionKind.Node10) {

// node10 does not support package.json imports/exports without

// an explicit resolution-mode override on a type-only import

// (indicated by `esmMode` being set)

return [];

}

}

// conditions are only used by the node16/nodenext/bundler resolvers - there's no priority order in the list,

// it's essentially a set (priority is determined by object insertion order in the object we look at).

const conditions = resolutionMode === ModuleKind.ESNext

? ["import"]

: ["require"];

if (!options.noDtsResolution) {

conditions.push("types");

}

if (moduleResolution !== ModuleResolutionKind.Bundler) {

conditions.push("node");

}

return concatenate(conditions, options.customConditions);

}

/**

* @internal

* Does not try `@types/${packageName}` - use a second pass if needed.

*/

export function resolvePackageNameToPackageJson(

packageName: string,

containingDirectory: string,

options: CompilerOptions,

host: ModuleResolutionHost,

cache: ModuleResolutionCache | undefined,

): PackageJsonInfo | undefined {

const moduleResolutionState = getTemporaryModuleResolutionState(cache?.getPackageJsonInfoCache(), host, options);

return forEachAncestorDirectoryStoppingAtGlobalCache(host, containingDirectory, ancestorDirectory => {

if (getBaseFileName(ancestorDirectory) !== "node_modules") {

const nodeModulesFolder = combinePaths(ancestorDirectory, "node_modules");

const candidate = combinePaths(nodeModulesFolder, packageName);

return getPackageJsonInfo(candidate, /*onlyRecordFailures*/ false, moduleResolutionState);

}

});

}

/**

* 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-restricted-syntax

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>, NonRelativeNameResolutionCache<ResolvedTypeReferenceDirectiveWithFailedLookupLocations>, PackageJsonInfoCache {

/** @internal */ clearAllExceptPackageJsonInfoCache(): void;

}

export interface ModeAwareCache<T> {

get(key: string, mode: ResolutionMode): T | undefined;

set(key: string, mode: ResolutionMode, value: T): this;

delete(key: string, mode: ResolutionMode): this;

has(key: string, mode: ResolutionMode): boolean;

forEach(cb: (elem: T, key: string, mode: ResolutionMode) => 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> {

getFromDirectoryCache(name: string, mode: ResolutionMode, directoryName: string, redirectedReference: ResolvedProjectReference | undefined): T | undefined;

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;

/** @internal */ directoryToModuleNameMap: CacheWithRedirects<Path, ModeAwareCache<T>>;

/** @internal */ isReadonly?: boolean;

}

export interface NonRelativeNameResolutionCache<T> {

getFromNonRelativeNameCache(nonRelativeName: string, mode: ResolutionMode, directoryName: string, redirectedReference: ResolvedProjectReference | undefined): T | undefined;

getOrCreateCacheForNonRelativeName(nonRelativeName: string, mode: ResolutionMode, redirectedReference?: ResolvedProjectReference): PerNonRelativeNameCache<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;

/** @internal */ isReadonly?: boolean;

}

export interface PerNonRelativeNameCache<T> {

get(directory: string): T | undefined;

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

/** @internal */ isReadonly?: boolean;

}

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

getPackageJsonInfoCache(): PackageJsonInfoCache;

/** @internal */ clearAllExceptPackageJsonInfoCache(): void;

/** @internal */ optionsToRedirectsKey: Map<CompilerOptions, RedirectsCacheKey>;

}

/**

* 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 NonRelativeNameResolutionCache<ResolvedModuleWithFailedLookupLocations>, PackageJsonInfoCache {

/** @deprecated Use getOrCreateCacheForNonRelativeName */

getOrCreateCacheForModuleName(nonRelativeModuleName: string, mode: ResolutionMode, redirectedReference?: ResolvedProjectReference): PerModuleNameCache;

}

/** @internal */

export interface MissingPackageJsonInfo {

packageDirectory: string;

directoryExists: boolean;

}

/** @internal */

export type PackageJsonInfoCacheEntry = PackageJsonInfo | MissingPackageJsonInfo;

/** @internal */

export function isPackageJsonInfo(entry: PackageJsonInfoCacheEntry | undefined): entry is PackageJsonInfo {

return !!(entry as PackageJsonInfo | undefined)?.contents;

}

/** @internal */

export function isMissingPackageJsonInfo(entry: PackageJsonInfoCacheEntry | undefined): entry is MissingPackageJsonInfo {

return !!entry && !(entry as PackageJsonInfo).contents;

}

export interface PackageJsonInfoCache {

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

/** @internal */ setPackageJsonInfo(packageJsonPath: string, info: PackageJsonInfoCacheEntry): void;

/** @internal */ getInternalMap(): Map<Path, PackageJsonInfoCacheEntry> | undefined;

clear(): void;

/** @internal */ isReadonly?: boolean;

}

export type PerModuleNameCache = PerNonRelativeNameCache<ResolvedModuleWithFailedLookupLocations>;

function compilerOptionValueToString(value: unknown): string {

if (value === null || typeof value !== "object") { // eslint-disable-line no-restricted-syntax

return "" + value;

}

if (isArray(value)) {

return `[${value.map(e => compilerOptionValueToString(e))?.join(",")}]`;

}

let str = "{";

for (const key in value) {

if (hasProperty(value, key)) {

str += `${key}: ${compilerOptionValueToString((value as any)[key])}`;

}

}

return str + "}";

}

/** @internal */

export function getKeyForCompilerOptions(options: CompilerOptions, affectingOptionDeclarations: readonly CommandLineOption[]): string {

return affectingOptionDeclarations.map(option => compilerOptionValueToString(getCompilerOptionValue(options, option))).join("|") + `|${options.pathsBasePath}`;

}

/** @internal */

export interface CacheWithRedirects<K, V> {

getMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<K, V> | undefined;

getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<K, V>;

update(newOptions: CompilerOptions): void;

clear(): void;

getOwnMap(): Map<K, V>;

}

/** @internal */

export type RedirectsCacheKey = string & { __compilerOptionsKey: any; };

function createCacheWithRedirects<K, V>(ownOptions: CompilerOptions | undefined, optionsToRedirectsKey: Map<CompilerOptions, RedirectsCacheKey>): CacheWithRedirects<K, V> {

const redirectsMap = new Map<CompilerOptions, Map<K, V>>();

const redirectsKeyToMap = new Map<RedirectsCacheKey, Map<K, V>>();

let ownMap = new Map<K, V>();

if (ownOptions) redirectsMap.set(ownOptions, ownMap);

return {

getMapOfCacheRedirects,

getOrCreateMapOfCacheRedirects,

update,

clear,

getOwnMap: () => ownMap,

};

function getMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<K, V> | undefined {

return redirectedReference ?

getOrCreateMap(redirectedReference.commandLine.options, /*create*/ false) :

ownMap;

}

function getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<K, V> {

return redirectedReference ?

getOrCreateMap(redirectedReference.commandLine.options, /*create*/ true) :

ownMap;

}

function update(newOptions: CompilerOptions) {

if (ownOptions !== newOptions) {

if (ownOptions) ownMap = getOrCreateMap(newOptions, /*create*/ true); // set new map for new options as ownMap

else redirectsMap.set(newOptions, ownMap); // Use existing map if oldOptions = undefined