path: string;

extension: Extension;

packageId: PackageId | undefined;

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

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

if (!resolved) {

return undefined;

}

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

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

return {

resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath, extension: resolved.extension, isExternalLibraryImport, packageId: resolved.packageId },

failedLookupLocations

};

host: ModuleResolutionHost;

compilerOptions: CompilerOptions;

traceEnabled: boolean;

typings?: string;

types?: string;

main?: string;

return readTypes ? tryReadFromField("typings") || tryReadFromField("types") : tryReadFromField("main");

function tryReadFromField(fieldName: "typings" | "types" | "main"): string | undefined {

if (!hasProperty(jsonContent, fieldName)) {

if (state.traceEnabled) {

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

}

return;

}

const fileName = jsonContent[fieldName];

if (!isString(fileName)) {

if (state.traceEnabled) {

trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_string_got_1, fieldName, typeof fileName);

}

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;

}

try {

const jsonText = host.readFile(path);

return jsonText ? JSON.parse(jsonText) : {};

}

catch (e) {

// gracefully handle if readFile fails or returns not JSON

return {};

}

if (options.typeRoots) {

return options.typeRoots;

}

let currentDirectory: string;

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

forEachAncestorDirectory(ts.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);

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

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

}

}

}

const failedLookupLocations: string[] = [];

let resolved = primaryLookup();

let primary = true;

if (!resolved) {

resolved = secondaryLookup();

primary = false;

}

let resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective | undefined;

if (resolved) {

if (!options.preserveSymlinks) {

resolved = { ...resolved, fileName: realPath(resolved.fileName, host, traceEnabled) };

}

if (traceEnabled) {

trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, resolved.fileName, primary);

}

resolvedTypeReferenceDirective = { primary, resolvedFileName: resolved.fileName, packageId: resolved.packageId };

}

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 forEach(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, failedLookupLocations,

!directoryExists, moduleResolutionState));

});

}

else {

if (traceEnabled) {

trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);

}

}

}

function secondaryLookup(): PathAndPackageId | undefined {

let resolvedFile: PathAndPackageId;

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

}

const result = loadModuleFromNodeModules(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, failedLookupLocations, moduleResolutionState, /*cache*/ undefined);

resolvedFile = resolvedTypeScriptOnly(result && result.value);

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 = pathToPackageJson(combinePaths(root, normalized));

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

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

// tslint:disable-next-line:no-null-keyword

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

if (!isNotNeededPackage) {

// Return just the type directive names

result.push(getBaseFileName(normalized));

}

}

}

}

}

}

return result;

const directoryToModuleNameMap = createMap<Map<ResolvedModuleWithFailedLookupLocations>>();

const moduleNameToDirectoryMap = createMap<PerModuleNameCache>();

return { getOrCreateCacheForDirectory, getOrCreateCacheForModuleName };

function getOrCreateCacheForDirectory(directoryName: string) {

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

let perFolderCache = directoryToModuleNameMap.get(path);

if (!perFolderCache) {

perFolderCache = createMap<ResolvedModuleWithFailedLookupLocations>();

directoryToModuleNameMap.set(path, perFolderCache);

}

return perFolderCache;

}

function getOrCreateCacheForModuleName(nonRelativeModuleName: string) {

if (isExternalModuleNameRelative(nonRelativeModuleName)) {

return undefined;

}

let perModuleNameCache = moduleNameToDirectoryMap.get(nonRelativeModuleName);

if (!perModuleNameCache) {

perModuleNameCache = createPerModuleNameCache();

moduleNameToDirectoryMap.set(nonRelativeModuleName, perModuleNameCache);

}

return perModuleNameCache;

}

function createPerModuleNameCache(): PerModuleNameCache {

const directoryPathMap = createMap<ResolvedModuleWithFailedLookupLocations>();

return { get, set };

function get(directory: string): ResolvedModuleWithFailedLookupLocations {

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.resolvedFileName;

// find common prefix between directory and resolved file name

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

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

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

const commonPrefix = getCommonPrefix(path, resolvedFileName);

let current = path;

while (true) {

const parent = getDirectoryPath(current);

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

break;

}

directoryPathMap.set(parent, result);

current = parent;

if (current === commonPrefix) {

break;

}

}

}

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

if (resolution === undefined) {

return undefined;

}

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

// find first position where directory and resolution differs

let i = 0;

while (i < Math.min(directory.length, resolutionDirectory.length) && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) {

i++;

}

// find last directory separator before position i

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

if (sep < 0) {

return undefined;

}

return directory.substr(0, sep);

}

}

const traceEnabled = isTraceEnabled(compilerOptions, host);

if (traceEnabled) {

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

}

const containingDirectory = getDirectoryPath(containingFile);

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

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

if (result) {

if (traceEnabled) {

trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache, moduleName);

}

}

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

}

}

switch (moduleResolution) {

case ModuleResolutionKind.NodeJs:

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

break;

case ModuleResolutionKind.Classic:

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

break;

default:

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

}

if (perFolderCache) {

perFolderCache.set(moduleName, result);

// put result in per-module name cache

const perModuleNameCache = cache.getOrCreateCacheForModuleName(moduleName);

if (perModuleNameCache) {

perModuleNameCache.set(containingDirectory, result);

}

}

}

if (traceEnabled) {

if (result.resolvedModule) {

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;

failedLookupLocations: Push<string>, state: ModuleResolutionState): Resolved | undefined {

if (!isExternalModuleNameRelative(moduleName)) {

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

}

else {

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

}

failedLookupLocations: Push<string>, 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;

let matchedNormalizedPrefix: string;

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

// rootDirs are expected to be absolute

// in case of tsconfig.json this will happen automatically - compiler will expand relative names

// using location of tsconfig.json as base location

let normalizedRoot = normalizePath(rootDir);

if (!endsWith(normalizedRoot, directorySeparator)) {

normalizedRoot += directorySeparator;

}

const isLongestMatchingPrefix =

startsWith(candidate, normalizedRoot) &&

(matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length);

if (state.traceEnabled) {

trace(state.host, Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix);

}

if (isLongestMatchingPrefix) {

matchedNormalizedPrefix = normalizedRoot;

matchedRootDir = rootDir;

}

}

if (matchedNormalizedPrefix) {

if (state.traceEnabled) {

trace(state.host, Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);

}

const suffix = candidate.substr(matchedNormalizedPrefix.length);

// first - try to load from a initial location

if (state.traceEnabled) {

trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);

}

const resolvedFileName = loader(extensions, candidate, failedLookupLocations, !directoryProbablyExists(containingDirectory, state.host), state);

if (resolvedFileName) {

return resolvedFileName;

}

if (state.traceEnabled) {

trace(state.host, Diagnostics.Trying_other_entries_in_rootDirs);

}

// then try to resolve using remaining entries in rootDirs

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

if (rootDir === matchedRootDir) {

// skip the initially matched entry

continue;

}

const candidate = combinePaths(normalizePath(rootDir), suffix);

if (state.traceEnabled) {

trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate);

}

const baseDirectory = getDirectoryPath(candidate);

const resolvedFileName = loader(extensions, candidate, failedLookupLocations, !directoryProbablyExists(baseDirectory, state.host), state);

if (resolvedFileName) {

return resolvedFileName;

}

}

if (state.traceEnabled) {

trace(state.host, Diagnostics.Module_resolution_using_rootDirs_has_failed);

}

}

return undefined;

if (!state.compilerOptions.baseUrl) {

return undefined;

}

if (state.traceEnabled) {

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

}

// string is for exact match

let matchedPattern: Pattern | string | undefined = undefined;

if (state.compilerOptions.paths) {

if (state.traceEnabled) {

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

}

matchedPattern = matchPatternOrExact(getOwnKeys(state.compilerOptions.paths), moduleName);

}

if (matchedPattern) {

const matchedStar = isString(matchedPattern) ? undefined : matchedText(matchedPattern, moduleName);

const matchedPatternText = isString(matchedPattern) ? matchedPattern : patternText(matchedPattern);

if (state.traceEnabled) {

trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);

}

return forEach(state.compilerOptions.paths[matchedPatternText], subst => {

const path = matchedStar ? subst.replace("*", matchedStar) : subst;

const candidate = normalizePath(combinePaths(state.compilerOptions.baseUrl, path));

if (state.traceEnabled) {

trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);

}

// A path mapping may have an extension, in contrast to an import, which should omit it.

const extension = tryGetExtensionFromPath(candidate);

if (extension !== undefined) {

const path = tryFile(candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state);

if (path !== undefined) {

return noPackageId({ path, ext: extension });

}

}

return loader(extensions, candidate, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);

});

}

else {

const candidate = normalizePath(combinePaths(state.compilerOptions.baseUrl, moduleName));

if (state.traceEnabled) {

trace(state.host, Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, state.compilerOptions.baseUrl, candidate);

}

return loader(extensions, candidate, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);

}

const { resolvedModule, failedLookupLocations } =

nodeModuleNameResolverWorker(moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, /*jsOnly*/ true);

if (!resolvedModule) {

throw new Error(`Could not resolve JS module '${moduleName}' starting at '${initialDir}'. Looked in: ${failedLookupLocations.join(", ")}`);

}

return resolvedModule.resolvedFileName;

const traceEnabled = isTraceEnabled(compilerOptions, host);

const failedLookupLocations: string[] = [];

const state: ModuleResolutionState = { compilerOptions, host, traceEnabled };

const result = jsOnly ? tryResolve(Extensions.JavaScript) : (tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript));

if (result && result.value) {

const { resolved, originalPath, isExternalLibraryImport } = result.value;

return createResolvedModuleWithFailedLookupLocations(resolved, originalPath, isExternalLibraryImport, failedLookupLocations);

}

return { resolvedModule: undefined, failedLookupLocations };

function tryResolve(extensions: Extensions): SearchResult<{ resolved: Resolved, originalPath?: string, isExternalLibraryImport: boolean }> {

const loader: ResolutionKindSpecificLoader = (extensions, candidate, failedLookupLocations, onlyRecordFailures, state) => nodeLoadModuleByRelativeName(extensions, candidate, failedLookupLocations, onlyRecordFailures, state, /*considerPackageJson*/ true);

const resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, failedLookupLocations, state);

if (resolved) {

return toSearchResult({ resolved, isExternalLibraryImport: false });

}

if (!isExternalModuleNameRelative(moduleName)) {

if (traceEnabled) {

trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]);

}

const resolved = loadModuleFromNodeModules(extensions, moduleName, containingDirectory, failedLookupLocations, state, cache);

if (!resolved) return undefined;

let resolvedValue = resolved.value;

let originalPath: string | undefined;

if (!compilerOptions.preserveSymlinks && resolvedValue) {

originalPath = resolvedValue.path;

const path = realPath(resolved.value.path, host, traceEnabled);

if (path === originalPath) {

originalPath = undefined;

}

resolvedValue = { ...resolvedValue, path };

}

// For node_modules lookups, get the real path so that multiple accesses to an `npm link`-ed module do not create duplicate files.

return { value: resolvedValue && { resolved: resolvedValue, originalPath, isExternalLibraryImport: true } };

}

else {

const { path: candidate, parts } = normalizePathAndParts(combinePaths(containingDirectory, moduleName));

const resolved = nodeLoadModuleByRelativeName(extensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, state, /*considerPackageJson*/ true);

// Treat explicit "node_modules" import as an external library import.

return resolved && toSearchResult({ resolved, isExternalLibraryImport: contains(parts, "node_modules") });

}

}

if (!host.realpath) {

return path;

}

const real = normalizePath(host.realpath(path));

if (traceEnabled) {

trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path, real);

}

return real;

if (state.traceEnabled) {

trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]);

}

if (!pathEndsWithDirectorySeparator(candidate)) {

if (!onlyRecordFailures) {

const parentOfCandidate = getDirectoryPath(candidate);

if (!directoryProbablyExists(parentOfCandidate, state.host)) {

if (state.traceEnabled) {

trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate);

}

onlyRecordFailures = true;

}

}

const resolvedFromFile = loadModuleFromFile(extensions, candidate, failedLookupLocations, onlyRecordFailures, state);

if (resolvedFromFile) {

const nm = considerPackageJson ? parseNodeModuleFromPath(resolvedFromFile) : undefined;

const packageId = nm && getPackageJsonInfo(nm.packageDirectory, nm.subModuleName, failedLookupLocations, /*onlyRecordFailures*/ false, state).packageId;

return withPackageId(packageId, resolvedFromFile);

}

}

if (!onlyRecordFailures) {

const candidateExists = directoryProbablyExists(candidate, state.host);