errors: Push<Diagnostic>,

createDiagnostic: (message: DiagnosticMessage, arg1?: string) => Diagnostic) {

extendedConfig = normalizeSlashes(extendedConfig);

}

}

}

function getExtendedConfig(

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

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

Json, /** '.json' */

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

}

types?: string;

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

main?: string;

}

interface PackageJson extends PackageJsonPathFields {

return value;

}

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

if (fileName === undefined) return;

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

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

}

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

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

}

return resolvedModule && resolvedModule.resolvedFileName;

}

function tryResolveJSModuleWorker(moduleName: string, initialDir: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations {

}

}

const traceEnabled = isTraceEnabled(compilerOptions, host);

const failedLookupLocations: string[] = [];

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

if (result && result.value) {

const { resolved, isExternalLibraryImport } = result.value;

return createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations);

function loadModuleFromFile(extensions: Extensions, candidate: string, onlyRecordFailures: boolean, state: ModuleResolutionState): PathAndExtension | undefined {

const extensionLess = tryRemoveExtension(candidate, Extension.Json);

}

// First, try adding an extension. An import of "foo" could be matched by a file "foo.ts", or "foo.js" by "foo.js.ts"

return tryExtension(Extension.Ts) || tryExtension(Extension.Tsx) || tryExtension(Extension.Dts);

case Extensions.JavaScript:

return tryExtension(Extension.Js) || tryExtension(Extension.Jsx);

case Extensions.Json:

return tryExtension(Extension.Json);

}

}

function loadNodeModuleFromDirectoryWorker(extensions: Extensions, candidate: string, onlyRecordFailures: boolean, state: ModuleResolutionState, jsonContent: PackageJsonPathFields | undefined, versionPaths: VersionPaths | undefined): PathAndExtension | undefined {

const loader: ResolutionKindSpecificLoader = (extensions, candidate, onlyRecordFailures, state) => {

const fromFile = tryFile(candidate, onlyRecordFailures, state);

const onlyRecordFailuresForPackageFile = packageFile ? !directoryProbablyExists(getDirectoryPath(packageFile), state.host) : undefined;

const onlyRecordFailuresForIndex = onlyRecordFailures || !directoryProbablyExists(candidate, state.host);

if (versionPaths && (!packageFile || containsPath(candidate, packageFile))) {

const moduleName = getRelativePathFromDirectory(candidate, packageFile || indexPath, /*ignoreCase*/ false);

switch (extensions) {

case Extensions.JavaScript:

return extension === Extension.Js || extension === Extension.Jsx;

case Extensions.Json:

return extension === Extension.Json;

case Extensions.TypeScript:

if (packageResult) {

return packageResult;

}

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

let nodeModulesAtTypesExists = nodeModulesFolderExists;

if (nodeModulesFolderExists && !directoryProbablyExists(nodeModulesAtTypes, state.host)) {

readFile: f => host.readFile(f),

useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(),

getCurrentDirectory: () => host.getCurrentDirectory(),

};

}

fileExists(path: string): boolean;

readFile(path: string): string | undefined;

}

/**

fileExists: path => host.fileExists(path),

readFile,

getCurrentDirectory,

};

// From tsc we want to get already parsed result and hence check for rootFileNames