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

};

}

}

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

if (r) {

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

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

}

path: string;

extension: string;

packageId: PackageId | undefined;

/**

originalPath?: string | true;

resolvedUsingTsExtension: boolean | undefined;

path: string;

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

ext: string;

resolvedUsingTsExtension: boolean | undefined;

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,

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(", ");

if (!resolved) {

return undefined;

}

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

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

moduleName: string,

resolved: Resolved | undefined,

isExternalLibraryImport: boolean | undefined,

failedLookupLocations: string[],

affectingLocations: string[],

diagnostics: Diagnostic[],

state: ModuleResolutionState,

legacyResult?: 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,

legacyResult,

);

resolved: Resolved | undefined,

isExternalLibraryImport: boolean | undefined,

failedLookupLocations: string[],

affectingLocations: string[],

diagnostics: Diagnostic[],

resultFromCache: ResolvedModuleWithFailedLookupLocations | undefined,

legacyResult?: string,

): ResolvedModuleWithFailedLookupLocations {

if (resultFromCache) {

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

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

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

return resultFromCache;

}

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

node10Result: legacyResult,

};

if (!value?.length) return to;

if (!to?.length) return value;

to.push(...value);

return to;

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;

typings?: string;

types?: string;

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

main?: string;

tsconfig?: string;

type?: string;

imports?: object;

exports?: object;

name?: string;

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;

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;

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;

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;

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] };

}

}

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

}

let typeRoots: string[] | undefined;

forEachAncestorDirectory(normalizePath(currentDirectory), directory => {

const atTypes = combinePaths(directory, nodeModulesAtTypes);

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

});

return typeRoots;

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,

};

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

mangleScopedPackageNameWithTrace(typeReferenceDirectiveName, moduleResolutionState) :

typeReferenceDirectiveName;

return combinePaths(typeRoot, nameForLookup);

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

let features = getNodeResolutionFeatures(options);

// Unlike `import` statements, whose mode-calculating APIs are all guaranteed to return `undefined` if we're in an un-mode-ed module resolution

// setting, type references will return their target mode regardless of options because of how the parser works, so we guard against the mode being

// set in a non-modal module resolution setting here. Do note that our behavior is not particularly well defined when these mode-overriding imports

// are present in a non-modal project; while in theory we'd like to either ignore the mode or provide faithful modern resolution, depending on what we feel is best,

// in practice, not every cache has the options available to intelligently make the choice to ignore the mode request, and it's unclear how modern "faithful modern

// resolution" should be (`node16`? `nodenext`?). As such, witnessing a mode-overriding triple-slash reference in a non-modal module resolution

// context should _probably_ be an error - and that should likely be handled by the `Program` (which is what we do).

if (resolutionMode === ModuleKind.ESNext && (getEmitModuleResolutionKind(options) === ModuleResolutionKind.Node16 || getEmitModuleResolutionKind(options) === ModuleResolutionKind.NodeNext)) {

features |= NodeResolutionFeatures.EsmMode;

}

const conditions = features & NodeResolutionFeatures.Exports ? getConditions(options, !!(features & NodeResolutionFeatures.EsmMode)) : [];

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,

};

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

}

}

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

}

}

}

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;

// 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 = esmMode || getEmitModuleResolutionKind(options) === ModuleResolutionKind.Bundler

? ["import"]

: ["require"];

if (!options.noDtsResolution) {

conditions.push("types");

}

if (getEmitModuleResolutionKind(options) !== ModuleResolutionKind.Bundler) {

conditions.push("node");

}

return concatenate(conditions, options.customConditions);

packageName: string,

containingDirectory: string,

options: CompilerOptions,

host: ModuleResolutionHost,

cache: ModuleResolutionCache | undefined,

): PackageJsonInfo | undefined {

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

return forEachAncestorDirectory(containingDirectory, ancestorDirectory => {

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

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

const candidate = combinePaths(nodeModulesFolder, packageName);

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

}

});

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

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;

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

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

clear(): void;

/**

update(options: CompilerOptions): void;

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