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

if (r) {

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

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

}

path: string;

extension: Extension;

packageId: PackageId | undefined;

/**

originalPath?: string | true;

path: string;

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

ext: Extension;

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

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

Json, /** '.json' */

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

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

if (!resolved) {

return undefined;

}

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

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

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

};

host: ModuleResolutionHost;

compilerOptions: CompilerOptions;

traceEnabled: boolean;

failedLookupLocations: Push<string>;

resultFromCache?: ResolvedModuleWithFailedLookupLocations;

typings?: string;

types?: string;

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

main?: string;

tsconfig?: 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, host);

}

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 traceEnabled = isTraceEnabled(options, host);

if (redirectedReference) {

options = redirectedReference.commandLine.options;

}

const failedLookupLocations: string[] = [];

const moduleResolutionState: ModuleResolutionState = { compilerOptions: options, host, traceEnabled, failedLookupLocations };

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

}

}

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

if (traceEnabled) {

if (packageId) {

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

}

else {

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

}

}

resolvedTypeReferenceDirective = { primary, resolvedFileName, packageId, isExternalLibraryImport: pathContainsNodeModules(fileName) };

}

return { resolvedTypeReferenceDirective, failedLookupLocations };

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

}

const resolvedFile = resolvedTypeScriptOnly(result);

if (!resolvedFile && traceEnabled) {

trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);

}

return resolvedFile;

}

else {

if (traceEnabled) {

trace(host, Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);

}

}

}

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

return createModuleResolutionCacheWithMaps(

createCacheWithRedirects(options),

createCacheWithRedirects(options),

currentDirectory,

getCanonicalFileName

);

ownMap: Map<T>;

redirectsMap: Map<Map<T>>;

getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<T>;

clear(): void;

setOwnOptions(newOptions: CompilerOptions): void;

setOwnMap(newOwnMap: Map<T>): void;

let ownMap: Map<T> = createMap();

const redirectsMap: Map<Map<T>> = createMap();

return {

ownMap,

redirectsMap,

getOrCreateMapOfCacheRedirects,

clear,

setOwnOptions,

setOwnMap

};

function setOwnOptions(newOptions: CompilerOptions) {

options = newOptions;

}

function setOwnMap(newOwnMap: Map<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) ? createMap() : ownMap;

redirectsMap.set(path, redirects);

}

return redirects;

}

function clear() {

ownMap.clear();

redirectsMap.clear();

}

directoryToModuleNameMap: CacheWithRedirects<Map<ResolvedModuleWithFailedLookupLocations>>,

moduleNameToDirectoryMap: CacheWithRedirects<PerModuleNameCache>,

currentDirectory: string,

getCanonicalFileName: GetCanonicalFileName): ModuleResolutionCache {

return { getOrCreateCacheForDirectory, getOrCreateCacheForModuleName, directoryToModuleNameMap, moduleNameToDirectoryMap };

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

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

return getOrCreateCache<Map<ResolvedModuleWithFailedLookupLocations>>(directoryToModuleNameMap, redirectedReference, path, createMap);

}

function getOrCreateCacheForModuleName(nonRelativeModuleName: string, redirectedReference?: ResolvedProjectReference): PerModuleNameCache {

Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName));

return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, nonRelativeModuleName, createPerModuleNameCache);

}

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 createPerModuleNameCache(): PerModuleNameCache {

const directoryPathMap = createMap<ResolvedModuleWithFailedLookupLocations>();

return { get, set };

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

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

}

/**

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

}

}

const containingDirectory = getDirectoryPath(containingFile);

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

return perFolderCache && perFolderCache.get(moduleName);

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

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

moduleResolution = getEmitModuleKind(compilerOptions) === ModuleKind.CommonJS ? ModuleResolutionKind.NodeJs : ModuleResolutionKind.Classic;

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.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, result);

if (!isExternalModuleNameRelative(moduleName)) {

// put result in per-module name cache

cache!.getOrCreateCacheForModuleName(moduleName, 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;

state: ModuleResolutionState): Resolved | undefined {

const resolved = tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state);

if (resolved) return resolved.value;

if (!isExternalModuleNameRelative(moduleName)) {

return tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state);

}

else {

return tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state);

}

const { baseUrl, paths } = state.compilerOptions;

if (baseUrl && paths && !pathIsRelative(moduleName)) {

if (state.traceEnabled) {

trace(state.host, Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);

trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);

}

return tryLoadModuleUsingPaths(extensions, moduleName, baseUrl, paths, loader, /*onlyRecordFailures*/ false, state);

}

state: ModuleResolutionState): Resolved | undefined {

if (!state.compilerOptions.rootDirs) {

return undefined;

}

if (state.traceEnabled) {

trace(state.host, Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);

}

const candidate = normalizePath(combinePaths(containingDirectory, moduleName));

let matchedRootDir: string | undefined;

let matchedNormalizedPrefix: string | undefined;

for (const rootDir of state.compilerOptions.rootDirs) {