@typescript-deploys/pr-build 4.8.0-pr-50007-2 → 4.8.0-pr-50085-2

package/lib/typingsInstaller.js

@@ -4701,15 +4701,13 @@ var ts;
     (function (FilePreprocessingDiagnosticsKind) {
         FilePreprocessingDiagnosticsKind[FilePreprocessingDiagnosticsKind["FilePreprocessingReferencedDiagnostic"] = 0] = "FilePreprocessingReferencedDiagnostic";
         FilePreprocessingDiagnosticsKind[FilePreprocessingDiagnosticsKind["FilePreprocessingFileExplainingDiagnostic"] = 1] = "FilePreprocessingFileExplainingDiagnostic";
-        FilePreprocessingDiagnosticsKind[FilePreprocessingDiagnosticsKind["ResolutionDiagnostics"] = 2] = "ResolutionDiagnostics";
     })(FilePreprocessingDiagnosticsKind = ts.FilePreprocessingDiagnosticsKind || (ts.FilePreprocessingDiagnosticsKind = {}));
     /* @internal */
     var StructureIsReused;
     (function (StructureIsReused) {
         StructureIsReused[StructureIsReused["Not"] = 0] = "Not";
-        StructureIsReused[StructureIsReused["SafeModuleCache"] = 1] = "SafeModuleCache";
-        StructureIsReused[StructureIsReused["SafeModules"] = 2] = "SafeModules";
-        StructureIsReused[StructureIsReused["Completely"] = 3] = "Completely";
+        StructureIsReused[StructureIsReused["SafeModules"] = 1] = "SafeModules";
+        StructureIsReused[StructureIsReused["Completely"] = 2] = "Completely";
     })(StructureIsReused = ts.StructureIsReused || (ts.StructureIsReused = {}));
     /** Return code used by getEmitOutput function to indicate status of the function */
     var ExitStatus;
@@ -9644,7 +9642,6 @@ var ts;
         Specify_how_the_TypeScript_watch_mode_works: diag(6715, ts.DiagnosticCategory.Message, "Specify_how_the_TypeScript_watch_mode_works_6715", "Specify how the TypeScript watch mode works."),
         Require_undeclared_properties_from_index_signatures_to_use_element_accesses: diag(6717, ts.DiagnosticCategory.Message, "Require_undeclared_properties_from_index_signatures_to_use_element_accesses_6717", "Require undeclared properties from index signatures to use element accesses."),
         Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, ts.DiagnosticCategory.Message, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
-        Save_resolutions_into_tsbuildinfo_file_and_use_them_for_incremental_compilation: diag(6719, ts.DiagnosticCategory.Message, "Save_resolutions_into_tsbuildinfo_file_and_use_them_for_incremental_compilation_6719", "Save resolutions into .tsbuildinfo file and use them for incremental compilation."),
         Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, ts.DiagnosticCategory.Message, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
         one_of_Colon: diag(6900, ts.DiagnosticCategory.Message, "one_of_Colon_6900", "one of:"),
         one_or_more_Colon: diag(6901, ts.DiagnosticCategory.Message, "one_or_more_Colon_6901", "one or more:"),
@@ -14386,8 +14383,7 @@ var ts;
     }
     ts.changesAffectModuleResolution = changesAffectModuleResolution;
     function optionsHaveModuleResolutionChanges(oldOptions, newOptions) {
-        return oldOptions.pathsBasePath !== newOptions.pathsBasePath ||
-            optionsHaveChanges(oldOptions, newOptions, ts.moduleResolutionOptionDeclarations);
+        return optionsHaveChanges(oldOptions, newOptions, ts.moduleResolutionOptionDeclarations);
     }
     ts.optionsHaveModuleResolutionChanges = optionsHaveModuleResolutionChanges;
     function changesAffectingProgramStructure(oldOptions, newOptions) {
@@ -14465,20 +14461,21 @@ var ts;
     }
     ts.getFullWidth = getFullWidth;
     function getResolvedModule(sourceFile, moduleNameText, mode) {
-        var _a, _b;
-        return (_b = (_a = sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.resolvedModules) === null || _a === void 0 ? void 0 : _a.get(moduleNameText, mode)) === null || _b === void 0 ? void 0 : _b.resolvedModule;
+        return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode);
     }
     ts.getResolvedModule = getResolvedModule;
     function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) {
-        var _a;
-        (_a = sourceFile.resolvedModules) !== null && _a !== void 0 ? _a : (sourceFile.resolvedModules = ts.createModeAwareCache());
+        if (!sourceFile.resolvedModules) {
+            sourceFile.resolvedModules = ts.createModeAwareCache();
+        }
         sourceFile.resolvedModules.set(moduleNameText, mode, resolvedModule);
     }
     ts.setResolvedModule = setResolvedModule;
-    function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective, mode) {
-        var _a;
-        (_a = sourceFile.resolvedTypeReferenceDirectiveNames) !== null && _a !== void 0 ? _a : (sourceFile.resolvedTypeReferenceDirectiveNames = ts.createModeAwareCache());
-        sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, mode, resolvedTypeReferenceDirective);
+    function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) {
+        if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
+            sourceFile.resolvedTypeReferenceDirectiveNames = ts.createModeAwareCache();
+        }
+        sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, /*mode*/ undefined, resolvedTypeReferenceDirective);
     }
     ts.setResolvedTypeReferenceDirective = setResolvedTypeReferenceDirective;
     function projectReferenceIsEqualTo(oldRef, newRef) {
@@ -14488,15 +14485,11 @@ var ts;
     }
     ts.projectReferenceIsEqualTo = projectReferenceIsEqualTo;
     function moduleResolutionIsEqualTo(oldResolution, newResolution) {
-        return oldResolution === newResolution ||
-            oldResolution.resolvedModule === newResolution.resolvedModule ||
-            !!oldResolution.resolvedModule &&
-                !!newResolution.resolvedModule &&
-                oldResolution.resolvedModule.isExternalLibraryImport === newResolution.resolvedModule.isExternalLibraryImport &&
-                oldResolution.resolvedModule.extension === newResolution.resolvedModule.extension &&
-                oldResolution.resolvedModule.resolvedFileName === newResolution.resolvedModule.resolvedFileName &&
-                oldResolution.resolvedModule.originalPath === newResolution.resolvedModule.originalPath &&
-                packageIdIsEqual(oldResolution.resolvedModule.packageId, newResolution.resolvedModule.packageId);
+        return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport &&
+            oldResolution.extension === newResolution.extension &&
+            oldResolution.resolvedFileName === newResolution.resolvedFileName &&
+            oldResolution.originalPath === newResolution.originalPath &&
+            packageIdIsEqual(oldResolution.packageId, newResolution.packageId);
     }
     ts.moduleResolutionIsEqualTo = moduleResolutionIsEqualTo;
     function packageIdIsEqual(a, b) {
@@ -14512,13 +14505,9 @@ var ts;
     }
     ts.packageIdToString = packageIdToString;
     function typeDirectiveIsEqualTo(oldResolution, newResolution) {
-        return oldResolution === newResolution ||
-            oldResolution.resolvedTypeReferenceDirective === newResolution.resolvedTypeReferenceDirective ||
-            !!oldResolution.resolvedTypeReferenceDirective &&
-                !!newResolution.resolvedTypeReferenceDirective &&
-                oldResolution.resolvedTypeReferenceDirective.resolvedFileName === newResolution.resolvedTypeReferenceDirective.resolvedFileName &&
-                !!oldResolution.resolvedTypeReferenceDirective.primary === !!newResolution.resolvedTypeReferenceDirective.primary &&
-                oldResolution.resolvedTypeReferenceDirective.originalPath === newResolution.resolvedTypeReferenceDirective.originalPath;
+        return oldResolution.resolvedFileName === newResolution.resolvedFileName
+            && oldResolution.primary === newResolution.primary
+            && oldResolution.originalPath === newResolution.originalPath;
     }
     ts.typeDirectiveIsEqualTo = typeDirectiveIsEqualTo;
     function hasChangesInResolutions(names, newResolutions, oldResolutions, oldSourceFile, comparer) {
@@ -19375,20 +19364,23 @@ var ts;
         return getStringFromExpandedCharCodes(expandedCharCodes);
     }
     ts.base64decode = base64decode;
-    function readJsonIgnoringErrors(path, host) {
-        return readJsonIgnoringErrorsFromText(path, host.readFile(path));
-    }
-    ts.readJsonIgnoringErrors = readJsonIgnoringErrors;
-    function readJsonIgnoringErrorsFromText(path, jsonText) {
-        if (!jsonText)
-            return {};
-        var result = ts.parseConfigFileTextToJson(path, jsonText);
-        if (result.error) {
+    function readJson(path, host) {
+        try {
+            var jsonText = host.readFile(path);
+            if (!jsonText)
+                return {};
+            var result = ts.parseConfigFileTextToJson(path, jsonText);
+            if (result.error) {
+                return {};
+            }
+            return result.config;
+        }
+        catch (e) {
+            // gracefully handle if readFile fails or returns not JSON
             return {};
         }
-        return result.config;
     }
-    ts.readJsonIgnoringErrorsFromText = readJsonIgnoringErrorsFromText;
+    ts.readJson = readJson;
     function directoryProbablyExists(directoryName, host) {
         // if host does not support 'directoryExists' assume that directory will exist
         return !host.directoryExists || host.directoryExists(directoryName);
@@ -20470,15 +20462,14 @@ var ts;
             },
             setSymlinksFromResolutions: function (files, typeReferenceDirectives) {
                 var _this = this;
-                var _a, _b;
+                var _a;
                 ts.Debug.assert(!hasProcessedResolutions);
                 hasProcessedResolutions = true;
                 for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
                     var file = files_1[_i];
-                    (_a = file.resolvedModules) === null || _a === void 0 ? void 0 : _a.forEach(function (resolution) { return processResolution(_this, resolution === null || resolution === void 0 ? void 0 : resolution.resolvedModule); });
-                    (_b = file.resolvedTypeReferenceDirectiveNames) === null || _b === void 0 ? void 0 : _b.forEach(function (resolution) { return processResolution(_this, resolution === null || resolution === void 0 ? void 0 : resolution.resolvedTypeReferenceDirective); });
+                    (_a = file.resolvedModules) === null || _a === void 0 ? void 0 : _a.forEach(function (resolution) { return processResolution(_this, resolution); });
                 }
-                typeReferenceDirectives.forEach(function (resolution) { return processResolution(_this, resolution.resolvedTypeReferenceDirective); });
+                typeReferenceDirectives === null || typeReferenceDirectives === void 0 ? void 0 : typeReferenceDirectives.forEach(function (resolution) { return processResolution(_this, resolution); });
             },
             hasProcessedResolutions: function () { return hasProcessedResolutions; },
         };
@@ -39738,17 +39729,6 @@ var ts;
             transpileOptionValue: undefined,
             defaultValueDescription: ts.Diagnostics.false_unless_composite_is_set
         },
-        {
-            name: "cacheResolutions",
-            type: "boolean",
-            category: ts.Diagnostics.Projects,
-            description: ts.Diagnostics.Save_resolutions_into_tsbuildinfo_file_and_use_them_for_incremental_compilation,
-            affectsModuleResolution: true,
-            affectsMultiFileEmitBuildInfo: true,
-            affectsBundleEmitBuildInfo: true,
-            transpileOptionValue: undefined,
-            defaultValueDescription: false,
-        },
         {
             name: "assumeChangesOnlyAffectDirectDependencies",
             type: "boolean",
@@ -41846,9 +41826,6 @@ var ts;
         if (result.configFilePath) {
             result.configFilePath = toAbsolutePath(result.configFilePath);
         }
-        if (result.pathsBasePath) {
-            result.pathsBasePath = toAbsolutePath(result.pathsBasePath);
-        }
         return result;
     }
     ts.convertToOptionsWithAbsolutePaths = convertToOptionsWithAbsolutePaths;
@@ -42834,36 +42811,20 @@ var ts;
         ts.Debug.assert(ts.extensionIsTS(resolved.extension));
         return { fileName: resolved.path, packageId: resolved.packageId };
     }
-    function createResolvedModuleWithFailedLookupLocations(compilerOptions, resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
-        var _a;
-        var _b;
+    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
+        var _a, _b;
         if (resultFromCache) {
-            if ((!compilerOptions.cacheResolutions || !((_b = resultFromCache.resolvedModule) === null || _b === void 0 ? void 0 : _b.resolvedFileName)) && failedLookupLocations.length)
-                (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
-            resultFromCache.affectingLocations = updateResolutionField(resultFromCache.affectingLocations, affectingLocations);
-            resultFromCache.resolutionDiagnostics = updateResolutionField(resultFromCache.resolutionDiagnostics, diagnostics);
+            (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
+            (_b = resultFromCache.affectingLocations).push.apply(_b, affectingLocations);
             return resultFromCache;
         }
         return {
             resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
-            failedLookupLocations: !compilerOptions.cacheResolutions || !(resolved === null || resolved === void 0 ? void 0 : resolved.path) ? failedLookupLocations : ts.emptyArray,
-            affectingLocations: initializeResolutionField(affectingLocations),
-            resolutionDiagnostics: initializeResolutionField(diagnostics),
+            failedLookupLocations: failedLookupLocations,
+            affectingLocations: affectingLocations,
+            resolutionDiagnostics: diagnostics,
         };
     }
-    function initializeResolutionField(value) {
-        return value.length ? value : undefined;
-    }
-    /*@internal*/
-    function updateResolutionField(to, value) {
-        if (!(value === null || value === void 0 ? void 0 : value.length))
-            return to;
-        if (!(to === null || to === void 0 ? void 0 : to.length))
-            return value;
-        to.push.apply(to, value);
-        return to;
-    }
-    ts.updateResolutionField = updateResolutionField;
     function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
         if (!ts.hasProperty(jsonContent, fieldName)) {
             if (state.traceEnabled) {
@@ -43015,7 +42976,8 @@ var ts;
             options = redirectedReference.commandLine.options;
         }
         var containingDirectory = containingFile ? ts.getDirectoryPath(containingFile) : undefined;
-        var result = containingDirectory ? cache === null || cache === void 0 ? void 0 : cache.getFromCache(containingDirectory, typeReferenceDirectiveName, /*mode*/ resolutionMode, redirectedReference) : undefined;
+        var perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : undefined;
+        var result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, /*mode*/ resolutionMode);
         if (result) {
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);
@@ -43073,7 +43035,7 @@ var ts;
             features: features,
             conditions: conditions,
             requestContainingDirectory: containingDirectory,
-            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var resolved = primaryLookup();
         var primary = true;
@@ -43093,15 +43055,8 @@ var ts;
                 isExternalLibraryImport: pathContainsNodeModules(fileName),
             };
         }
-        result = {
-            resolvedTypeReferenceDirective: resolvedTypeReferenceDirective,
-            failedLookupLocations: !options.cacheResolutions || !(resolvedTypeReferenceDirective === null || resolvedTypeReferenceDirective === void 0 ? void 0 : resolvedTypeReferenceDirective.resolvedFileName) ? failedLookupLocations : ts.emptyArray,
-            affectingLocations: initializeResolutionField(affectingLocations),
-            resolutionDiagnostics: initializeResolutionField(diagnostics),
-        };
-        if (containingDirectory && cache) {
-            cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);
-        }
+        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, affectingLocations: affectingLocations, resolutionDiagnostics: diagnostics };
+        perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result);
         if (traceEnabled)
             traceResult(result);
         return result;
@@ -43111,10 +43066,10 @@ var ts;
                 trace(host, ts.Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
             }
             else if (result.resolvedTypeReferenceDirective.packageId) {
-                trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, ts.packageIdToString(result.resolvedTypeReferenceDirective.packageId), !!result.resolvedTypeReferenceDirective.primary);
+                trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, ts.packageIdToString(result.resolvedTypeReferenceDirective.packageId), result.resolvedTypeReferenceDirective.primary);
             }
             else {
-                trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, !!result.resolvedTypeReferenceDirective.primary);
+                trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, result.resolvedTypeReferenceDirective.primary);
             }
         }
         function primaryLookup() {
@@ -43213,7 +43168,7 @@ var ts;
                             // `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
-                            var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJsonIgnoringErrors(packageJsonPath, host).typings === null;
+                            var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJson(packageJsonPath, host).typings === null;
                             if (!isNotNeededPackage) {
                                 var baseFileName = ts.getBaseFileName(normalized);
                                 // At this stage, skip results with leading dot.
@@ -43230,143 +43185,49 @@ var ts;
         return result;
     }
     ts.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames;
-    function compilerOptionValueToString(value) {
-        var _a;
-        if (value === null || typeof value !== "object") { // eslint-disable-line no-null/no-null
-            return "" + value;
-        }
-        if (ts.isArray(value)) {
-            return "[" + ((_a = ts.map(value, function (e) { return compilerOptionValueToString(e); })) === null || _a === void 0 ? void 0 : _a.join(",")) + "]";
-        }
-        var str = "{";
-        for (var key in value) {
-            if (ts.hasProperty(value, key)) {
-                str += key + ": " + compilerOptionValueToString(value[key]);
-            }
-        }
-        return str + "}";
-    }
-    /*@internal*/
-    function getKeyForCompilationSettings(settings, options) {
-        return options.map(function (option) { return compilerOptionValueToString(ts.getCompilerOptionValue(settings, option)); }).join("|") + ("|" + settings.pathsBasePath);
-    }
-    ts.getKeyForCompilationSettings = getKeyForCompilationSettings;
-    /*@internal*/
-    function getRedirectsCacheKey(options) {
-        return getKeyForCompilationSettings(options, ts.moduleResolutionOptionDeclarations);
-    }
-    ts.getRedirectsCacheKey = getRedirectsCacheKey;
     /*@internal*/
-    function createCacheWithRedirects(ownOptions) {
-        var ownMap;
-        var ownKey;
-        var redirectsKeyToCache = new ts.Map();
+    function createCacheWithRedirects(options) {
+        var ownMap = new ts.Map();
         var redirectsMap = new ts.Map();
         return {
             getOwnMap: getOwnMap,
-            redirectsKeyToCache: redirectsKeyToCache,
-            createMapForCompilerOptions: createMapForCompilerOptions,
-            getMapOfCacheRedirects: getMapOfCacheRedirects,
+            redirectsMap: redirectsMap,
             getOrCreateMapOfCacheRedirects: getOrCreateMapOfCacheRedirects,
             clear: clear,
-            update: update,
-            clearRedirectsMap: function () { return redirectsMap.clear(); },
+            setOwnOptions: setOwnOptions,
+            setOwnMap: setOwnMap
         };
-        function ensureOwnKeyCached() {
-            ownKey !== null && ownKey !== void 0 ? ownKey : (ownKey = ownOptions && getRedirectsCacheKey(ownOptions));
-            if (ownKey && !redirectsKeyToCache.has(ownKey))
-                redirectsKeyToCache.set(ownKey, { map: ownMap !== null && ownMap !== void 0 ? ownMap : (ownMap = new ts.Map()), options: ownOptions });
-        }
-        function createMapForCompilerOptions(options, optionsKey) {
-            if (options === ownOptions)
-                return ownMap !== null && ownMap !== void 0 ? ownMap : (ownMap = new ts.Map());
-            return getOrCreateRedirectMapAndKey(options, /*path*/ undefined, optionsKey);
+        function getOwnMap() {
+            return ownMap;
         }
-        function getOrCreateRedirectMapAndKey(options, path, optionsKey) {
-            var _a;
-            if (path || options.configFile) {
-                var redirects = redirectsMap.get(path || options.configFile.path);
-                if (redirects)
-                    return redirects;
-            }
-            var key = optionsKey || getRedirectsCacheKey(options);
-            var map = (_a = redirectsKeyToCache.get(key)) === null || _a === void 0 ? void 0 : _a.map;
-            if (!map) {
-                ensureOwnKeyCached();
-                if (ownKey === key) {
-                    map = ownMap;
-                }
-                else {
-                    redirectsKeyToCache.set(key, { map: map = new ts.Map(), options: options });
-                }
-            }
-            if (path || options.configFile)
-                redirectsMap.set(path || options.configFile.path, map);
-            return map;
+        function setOwnOptions(newOptions) {
+            options = newOptions;
         }
-        function getOwnMap() {
-            return ownMap !== null && ownMap !== void 0 ? ownMap : (ownMap = new ts.Map());
-        }
-        function update(newOwnOptions) {
-            // Store existing options:
-            if (ownMap && (ownOptions === null || ownOptions === void 0 ? void 0 : ownOptions.configFile)) {
-                ensureOwnKeyCached();
-                if (!redirectsMap.has(ownOptions.configFile.path)) {
-                    redirectsMap.set(ownOptions.configFile.path, ownMap);
-                }
-            }
-            // If this is already present use it
-            if (newOwnOptions.configFile) {
-                var existing_1 = redirectsMap.get(newOwnOptions.configFile.path);
-                if (existing_1) {
-                    ownMap = existing_1;
-                    ownOptions = newOwnOptions;
-                    return;
-                }
-            }
-            var key = getRedirectsCacheKey(newOwnOptions);
-            var existing = redirectsKeyToCache.get(key);
-            ownMap = (existing === null || existing === void 0 ? void 0 : existing.map) || new ts.Map();
-            ownKey = key;
-            ownOptions = newOwnOptions;
-            if (newOwnOptions.configFile)
-                redirectsMap.set(newOwnOptions.configFile.path, ownMap);
+        function setOwnMap(newOwnMap) {
+            ownMap = newOwnMap;
         }
-        function getMapOfCacheRedirects(redirectedReference) {
-            if (!redirectedReference)
-                return ownMap;
-            var directResult = redirectsMap.get(redirectedReference.sourceFile.path);
-            if (directResult)
-                return directResult;
-            var key = getRedirectsCacheKey(redirectedReference.commandLine.options);
-            var fromKey = redirectsKeyToCache.get(key);
-            if (fromKey) {
-                redirectsMap.set(redirectedReference.sourceFile.path, fromKey.map);
-                return fromKey.map;
-            }
-            if (ownMap)
-                ensureOwnKeyCached();
-            if (ownKey === key) {
-                redirectsMap.set(redirectedReference.sourceFile.path, ownMap);
+        function getOrCreateMapOfCacheRedirects(redirectedReference) {
+            if (!redirectedReference) {
                 return ownMap;
             }
-            return undefined;
-        }
-        function getOrCreateMapOfCacheRedirects(redirectedReference) {
-            return !redirectedReference || redirectedReference.commandLine.options === ownOptions ?
-                getOwnMap() :
-                getOrCreateRedirectMapAndKey(redirectedReference.commandLine.options, redirectedReference.sourceFile.path, /*optionsKey*/ undefined);
+            var path = redirectedReference.sourceFile.path;
+            var redirects = redirectsMap.get(path);
+            if (!redirects) {
+                // Reuse map if redirected reference map uses same resolution
+                redirects = !options || ts.optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? new ts.Map() : ownMap;
+                redirectsMap.set(path, redirects);
+            }
+            return redirects;
         }
         function clear() {
-            ownKey = undefined;
-            ownMap = undefined;
+            ownMap.clear();
             redirectsMap.clear();
-            redirectsKeyToCache.clear();
         }
     }
     ts.createCacheWithRedirects = createCacheWithRedirects;
-    function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName, cache) {
-        return { getPackageJsonInfo: getPackageJsonInfo, setPackageJsonInfo: setPackageJsonInfo, clear: clear, entries: entries, clone: clone };
+    function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
+        var cache;
+        return { getPackageJsonInfo: getPackageJsonInfo, setPackageJsonInfo: setPackageJsonInfo, clear: clear, entries: entries };
         function getPackageJsonInfo(packageJsonPath) {
             return cache === null || cache === void 0 ? void 0 : cache.get(ts.toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
         }
@@ -43380,9 +43241,6 @@ var ts;
             var iter = cache === null || cache === void 0 ? void 0 : cache.entries();
             return iter ? ts.arrayFrom(iter) : [];
         }
-        function clone() {
-            return createPackageJsonInfoCache(currentDirectory, getCanonicalFileName, cache && new ts.Map(cache));
-        }
     }
     function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
         var cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
@@ -43393,43 +43251,47 @@ var ts;
         }
         return result;
     }
+    function updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
+        if (!options.configFile)
+            return;
+        if (directoryToModuleNameMap.redirectsMap.size === 0) {
+            // The own map will be for projectCompilerOptions
+            ts.Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size === 0);
+            ts.Debug.assert(directoryToModuleNameMap.getOwnMap().size === 0);
+            ts.Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.getOwnMap().size === 0);
+            directoryToModuleNameMap.redirectsMap.set(options.configFile.path, directoryToModuleNameMap.getOwnMap());
+            moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.redirectsMap.set(options.configFile.path, moduleNameToDirectoryMap.getOwnMap());
+        }
+        else {
+            // Set correct own map
+            ts.Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size > 0);
+            var ref = {
+                sourceFile: options.configFile,
+                commandLine: { options: options }
+            };
+            directoryToModuleNameMap.setOwnMap(directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref));
+            moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.setOwnMap(moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref));
+        }
+        directoryToModuleNameMap.setOwnOptions(options);
+        moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.setOwnOptions(options);
+    }
     function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap) {
-        var oldResolutionCache;
         return {
-            getFromCache: getFromCache,
             getOrCreateCacheForDirectory: getOrCreateCacheForDirectory,
             clear: clear,
             update: update,
-            setOldResolutionCache: function (cache) { return oldResolutionCache = cache; }
         };
         function clear() {
-            oldResolutionCache = undefined;
             directoryToModuleNameMap.clear();
         }
         function update(options) {
-            directoryToModuleNameMap.update(options);
+            updateRedirectsMap(options, directoryToModuleNameMap);
         }
         function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
             var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName);
-            return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, createModeAwareCache);
-        }
-        function getFromCache(directoryName, name, mode, redirectedReference) {
-            var _a, _b;
-            var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName);
-            var result = (_b = (_a = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) === null || _a === void 0 ? void 0 : _a.get(path)) === null || _b === void 0 ? void 0 : _b.get(name, mode);
-            if (result)
-                return result;
-            var resultFromOld = oldResolutionCache === null || oldResolutionCache === void 0 ? void 0 : oldResolutionCache.getResolved(path, name, mode, redirectedReference);
-            if (resultFromOld)
-                getOrCreateCacheForDirectory(directoryName, redirectedReference).set(name, mode, resultFromOld);
-            return resultFromOld;
+            return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, function () { return createModeAwareCache(); });
         }
     }
-    /*@internal*/
-    function getModeAwareCacheKey(specifier, mode) {
-        return (mode === undefined ? specifier : mode + "|" + specifier);
-    }
-    ts.getModeAwareCacheKey = getModeAwareCacheKey;
     /* @internal */
     function createModeAwareCache() {
         var underlying = new ts.Map();
@@ -43455,22 +43317,13 @@ var ts;
                     return cb(elem, specifier, mode);
                 });
             },
-            entries: function () {
-                var keys = underlying.entries();
-                return {
-                    next: function () {
-                        var next = keys.next();
-                        return !next.done ? { value: __spreadArray(__spreadArray([], memoizedReverseKeys.get(next.value[0]), true), [next.value[1]], false) } : next;
-                    },
-                };
-            },
             size: function () {
                 return underlying.size;
-            },
+            }
         };
         return cache;
         function getUnderlyingCacheKey(specifier, mode) {
-            var result = getModeAwareCacheKey(specifier, mode);
+            var result = mode === undefined ? specifier : mode + "|" + specifier;
             memoizedReverseKeys.set(result, [specifier, mode]);
             return result;
         }
@@ -43483,121 +43336,35 @@ var ts;
         for (var i = 0; i < keys.length; ++i) {
             var entry = keys[i];
             // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
-            var name = !ts.isString(entry) ? ts.toFileNameLowerCase(entry.fileName) : entry;
+            var name = !ts.isString(entry) ? entry.fileName.toLowerCase() : entry;
             var mode = !ts.isString(entry) ? entry.resolutionMode || file.impliedNodeFormat : ts.getModeForResolutionAtIndex(file, i);
             map.set(name, mode, values[i]);
         }
         return map;
     }
     ts.zipToModeAwareCache = zipToModeAwareCache;
-    function getCommonPrefix(directory, resolution, toPath) {
-        var resolutionDirectory = toPath(ts.getDirectoryPath(resolution));
-        // find first position where directory and resolution differs
-        var i = 0;
-        var 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] === ts.directorySeparator)) {
-            return directory;
-        }
-        var rootLength = ts.getRootLength(directory);
-        if (i < rootLength) {
-            return undefined;
-        }
-        var sep = directory.lastIndexOf(ts.directorySeparator, i - 1);
-        if (sep === -1) {
-            return undefined;
-        }
-        return directory.substr(0, Math.max(sep, rootLength));
-    }
-    /*@internal*/
-    function getResolvedFileNameForModuleNameToDirectorySet(result) {
-        return result.resolvedModule &&
-            (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
-    }
-    ts.getResolvedFileNameForModuleNameToDirectorySet = getResolvedFileNameForModuleNameToDirectorySet;
-    /**
-     * At first this function add entry directory -> module resolution result to the table.
-     * Then it computes the set of parent folders for 'directory' that should have the same module resolution result
-     * and for every parent folder in set it adds entry: parent -> module resolution. .
-     * Lets say we first directory name: /a/b/c/d/e and resolution result is: /a/b/bar.ts.
-     * Set of parent folders that should have the same result will be:
-     * [
-     *     /a/b/c/d, /a/b/c, /a/b
-     * ]
-     * this means that request for module resolution from file in any of these folder will be immediately found in cache.
-     */
-    /*@internal*/
-    function moduleNameToDirectorySet(directoryPathMap, directory, result, getResolvedFileName, toPath, ancestoryWorker) {
-        // if entry is already in cache do nothing
-        if (directoryPathMap.has(directory))
-            return;
-        directoryPathMap.set(directory, result);
-        var resolvedFileName = getResolvedFileName(result);
-        // 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
-        var commonPrefix = resolvedFileName && getCommonPrefix(directory, resolvedFileName, toPath);
-        var current = directory;
-        while (current !== commonPrefix) {
-            var parent = ts.getDirectoryPath(current);
-            if (parent === current)
-                break;
-            if (directoryPathMap.has(parent)) {
-                ancestoryWorker(parent);
-                break;
-            }
-            directoryPathMap.set(parent, result);
-            ancestoryWorker(parent);
-            current = parent;
-        }
-    }
-    ts.moduleNameToDirectorySet = moduleNameToDirectorySet;
-    function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options) {
-        var directoryToModuleNameMap = createCacheWithRedirects(options);
-        var moduleNameToDirectoryMap = createCacheWithRedirects(options);
-        var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap);
+    function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
+        var preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
+        moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options));
         var packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
-        var oldResolutionCache;
-        return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, getFromModuleNameCache: getFromModuleNameCache, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; }, setOldResolutionCache: setOldResolutionCache });
+        return __assign(__assign(__assign({}, packageJsonInfoCache), preDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; } });
         function clear() {
-            oldResolutionCache = undefined;
-            perDirectoryResolutionCache.clear();
+            preDirectoryResolutionCache.clear();
             moduleNameToDirectoryMap.clear();
             packageJsonInfoCache.clear();
         }
         function update(options) {
-            directoryToModuleNameMap.update(options);
-            moduleNameToDirectoryMap.update(options);
-        }
-        function setOldResolutionCache(cache) {
-            oldResolutionCache = cache;
-            perDirectoryResolutionCache.setOldResolutionCache(cache);
-        }
-        function getFromModuleNameCache(directoryName, nonRelativeModuleName, mode, redirectedReference) {
-            var _a, _b;
-            ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName));
-            var result = (_b = (_a = moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) === null || _a === void 0 ? void 0 : _a.get(getModeAwareCacheKey(nonRelativeModuleName, mode))) === null || _b === void 0 ? void 0 : _b.get(directoryName);
-            if (result)
-                return result;
-            var fromOld = oldResolutionCache === null || oldResolutionCache === void 0 ? void 0 : oldResolutionCache.getResolved(toPath(directoryName), nonRelativeModuleName, mode, redirectedReference);
-            if (fromOld)
-                getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference).set(directoryName, fromOld);
-            return fromOld;
+            updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap);
         }
         function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) {
             ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName));
-            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, getModeAwareCacheKey(nonRelativeModuleName, mode), createPerModuleNameCache);
+            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === undefined ? nonRelativeModuleName : mode + "|" + nonRelativeModuleName, createPerModuleNameCache);
         }
         function createPerModuleNameCache() {
             var directoryPathMap = new ts.Map();
             return { get: get, set: set };
             function get(directory) {
-                return directoryPathMap.get(toPath(directory));
+                return directoryPathMap.get(ts.toPath(directory, currentDirectory, getCanonicalFileName));
             }
             /**
              * At first this function add entry directory -> module resolution result to the table.
@@ -43611,17 +43378,57 @@ var ts;
              * this means that request for module resolution from file in any of these folder will be immediately found in cache.
              */
             function set(directory, result) {
-                return moduleNameToDirectorySet(directoryPathMap, toPath(directory), result, getResolvedFileNameForModuleNameToDirectorySet, toPath, ts.noop);
+                var path = ts.toPath(directory, currentDirectory, getCanonicalFileName);
+                // if entry is already in cache do nothing
+                if (directoryPathMap.has(path)) {
+                    return;
+                }
+                directoryPathMap.set(path, result);
+                var 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
+                var commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);
+                var current = path;
+                while (current !== commonPrefix) {
+                    var parent = ts.getDirectoryPath(current);
+                    if (parent === current || directoryPathMap.has(parent)) {
+                        break;
+                    }
+                    directoryPathMap.set(parent, result);
+                    current = parent;
+                }
+            }
+            function getCommonPrefix(directory, resolution) {
+                var resolutionDirectory = ts.toPath(ts.getDirectoryPath(resolution), currentDirectory, getCanonicalFileName);
+                // find first position where directory and resolution differs
+                var i = 0;
+                var 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] === ts.directorySeparator)) {
+                    return directory;
+                }
+                var rootLength = ts.getRootLength(directory);
+                if (i < rootLength) {
+                    return undefined;
+                }
+                var sep = directory.lastIndexOf(ts.directorySeparator, i - 1);
+                if (sep === -1) {
+                    return undefined;
+                }
+                return directory.substr(0, Math.max(sep, rootLength));
             }
-        }
-        function toPath(fileName) {
-            return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
         }
     }
     ts.createModuleResolutionCache = createModuleResolutionCache;
-    function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache) {
-        var directoryToModuleNameMap = createCacheWithRedirects(options);
-        var preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap);
+    function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, directoryToModuleNameMap) {
+        var preDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
         packageJsonInfoCache || (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName));
         return __assign(__assign(__assign({}, packageJsonInfoCache), preDirectoryResolutionCache), { clear: clear });
         function clear() {
@@ -43632,7 +43439,10 @@ var ts;
     ts.createTypeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache;
     function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
         var containingDirectory = ts.getDirectoryPath(containingFile);
-        return cache === null || cache === void 0 ? void 0 : cache.getFromCache(containingDirectory, moduleName, mode);
+        var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
+        if (!perFolderCache)
+            return undefined;
+        return perFolderCache.get(moduleName, mode);
     }
     ts.resolveModuleNameFromCache = resolveModuleNameFromCache;
     function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
@@ -43647,7 +43457,8 @@ var ts;
             }
         }
         var containingDirectory = ts.getDirectoryPath(containingFile);
-        var result = cache === null || cache === void 0 ? void 0 : cache.getFromCache(containingDirectory, moduleName, resolutionMode, redirectedReference);
+        var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
+        var result = perFolderCache && perFolderCache.get(moduleName, resolutionMode);
         if (result) {
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -43699,8 +43510,8 @@ var ts;
             if (result && result.resolvedModule)
                 ts.perfLogger.logInfoEvent("Module \"" + moduleName + "\" resolved to \"" + result.resolvedModule.resolvedFileName + "\"");
             ts.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null");
-            if (cache) {
-                cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, result);
+            if (perFolderCache) {
+                perFolderCache.set(moduleName, resolutionMode, result);
                 if (!ts.isExternalModuleNameRelative(moduleName)) {
                     // put result in per-module name cache
                     cache.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
@@ -43986,10 +43797,10 @@ var ts;
             features: features,
             conditions: conditions,
             requestContainingDirectory: containingDirectory,
-            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
-        return createResolvedModuleWithFailedLookupLocations(compilerOptions, (_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ true); };
             var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
@@ -44366,7 +44177,7 @@ var ts;
             features: NodeResolutionFeatures.None,
             conditions: ts.emptyArray,
             requestContainingDirectory: undefined,
-            reportResolutionDiagnostic: ts.noop
+            reportDiagnostic: ts.noop
         };
     }
     ts.getTemporaryModuleResolutionState = getTemporaryModuleResolutionState;
@@ -44413,13 +44224,12 @@ var ts;
         }
         var directoryExists = ts.directoryProbablyExists(packageDirectory, host);
         if (directoryExists && host.fileExists(packageJsonPath)) {
-            var packageJsonText = host.readFile(packageJsonPath);
-            var packageJsonContent = ts.readJsonIgnoringErrorsFromText(packageJsonPath, packageJsonText);
+            var packageJsonContent = ts.readJson(packageJsonPath, host);
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
             }
             var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
-            var result = { packageDirectory: packageDirectory, packageJsonText: packageJsonText, packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined };
+            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined };
             (_b = state.packageJsonInfoCache) === null || _b === void 0 ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
             state.affectingLocations.push(packageJsonPath);
             return result;
@@ -44844,8 +44654,12 @@ var ts;
                             fragment = ts.ensureTrailingDirectorySeparator(commonDir_1);
                         }
                     }
-                    if (commonSourceDirGuesses.length > 1)
-                        state.reportResolutionDiagnostic({ isImports: isImports, entry: entry, packagePath: packagePath });
+                    if (commonSourceDirGuesses.length > 1) {
+                        state.reportDiagnostic(ts.createCompilerDiagnostic(isImports
+                            ? ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate
+                            : ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate, entry === "" ? "." : entry, // replace empty string with `.` - the reverse of the operation done when entries are built - so main entrypoint errors don't look weird
+                        packagePath));
+                    }
                     for (var _i = 0, commonSourceDirGuesses_1 = commonSourceDirGuesses; _i < commonSourceDirGuesses_1.length; _i++) {
                         var commonSourceDirGuess = commonSourceDirGuesses_1[_i];
                         var candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
@@ -44915,10 +44729,10 @@ var ts;
         return loadModuleFromNearestNodeModulesDirectoryWorker(Extensions.DtsOnly, moduleName, directory, state, /*typesScopeOnly*/ true, /*cache*/ undefined, /*redirectedReference*/ undefined);
     }
     function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
-        var mode = state.features === 0 ? undefined : state.features & NodeResolutionFeatures.EsmMode ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+        var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? undefined : state.features & NodeResolutionFeatures.EsmMode ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS, redirectedReference);
         return ts.forEachAncestorDirectory(ts.normalizeSlashes(directory), function (ancestorDirectory) {
             if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
-                var resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state);
+                var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
                 if (resolutionFromCache) {
                     return resolutionFromCache;
                 }
@@ -45070,8 +44884,8 @@ var ts;
             typesPackageName;
     }
     ts.unmangleScopedPackageName = unmangleScopedPackageName;
-    function tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, containingDirectory, redirectedReference, state) {
-        var result = cache === null || cache === void 0 ? void 0 : cache.getFromModuleNameCache(containingDirectory, moduleName, mode, redirectedReference);
+    function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) {
+        var result = cache && cache.get(containingDirectory);
         if (result) {
             if (state.traceEnabled) {
                 trace(state.host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -45096,11 +44910,11 @@ var ts;
             features: NodeResolutionFeatures.None,
             conditions: [],
             requestContainingDirectory: containingDirectory,
-            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
         // No originalPath because classic resolution doesn't resolve realPath
-        return createResolvedModuleWithFailedLookupLocations(compilerOptions, resolved && resolved.value, 
+        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, 
         /*isExternalLibraryImport*/ false, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
@@ -45108,9 +44922,10 @@ var ts;
                 return { value: resolvedUsingSettings };
             }
             if (!ts.isExternalModuleNameRelative(moduleName)) {
+                var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, /*mode*/ undefined, redirectedReference);
                 // Climb up parent directories looking for a module.
                 var resolved_3 = ts.forEachAncestorDirectory(containingDirectory, function (directory) {
-                    var resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, /*mode*/ undefined, directory, redirectedReference, state);
+                    var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache_1, moduleName, directory, state);
                     if (resolutionFromCache) {
                         return resolutionFromCache;
                     }
@@ -45155,10 +44970,10 @@ var ts;
             features: NodeResolutionFeatures.None,
             conditions: [],
             requestContainingDirectory: undefined,
-            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined);
-        return createResolvedModuleWithFailedLookupLocations(compilerOptions, resolved, 
+        return createResolvedModuleWithFailedLookupLocations(resolved, 
         /*isExternalLibraryImport*/ true, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
     }
     ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
@@ -48844,10 +48659,9 @@ var ts;
             host.getSourceFiles().forEach(function (sf) {
                 if (!sf.resolvedModules)
                     return;
-                sf.resolvedModules.forEach(function (_a) {
-                    var resolvedModule = _a.resolvedModule;
-                    if (resolvedModule === null || resolvedModule === void 0 ? void 0 : resolvedModule.packageId)
-                        map.set(resolvedModule.packageId.name, resolvedModule.extension === ".d.ts" /* Dts */ || !!map.get(resolvedModule.packageId.name));
+                sf.resolvedModules.forEach(function (r) {
+                    if (r && r.packageId)
+                        map.set(r.packageId.name, r.extension === ".d.ts" /* Dts */ || !!map.get(r.packageId.name));
                 });
             });
             return map;
@@ -88302,12 +88116,11 @@ var ts;
             if (resolvedTypeReferenceDirectives) {
                 // populate reverse mapping: file path -> type reference directive that was resolved to this file
                 fileToDirective = new ts.Map();
-                resolvedTypeReferenceDirectives.forEach(function (_a, key, mode) {
-                    var resolvedTypeReferenceDirective = _a.resolvedTypeReferenceDirective;
-                    if (!resolvedTypeReferenceDirective || !resolvedTypeReferenceDirective.resolvedFileName) {
+                resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key, mode) {
+                    if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
                         return;
                     }
-                    var file = host.getSourceFile(resolvedTypeReferenceDirective.resolvedFileName);
+                    var file = host.getSourceFile(resolvedDirective.resolvedFileName);
                     if (file) {
                         // Add the transitive closure of path references loaded by this file (as long as they are not)
                         // part of an existing type reference.
@@ -111779,7 +111592,7 @@ var ts;
                     var sourceMap = sourceMapGenerator.toString();
                     ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles);
                     if (printer.bundleFileInfo)
-                        printer.bundleFileInfo.mapHash = ts.computeSignature(sourceMap, host);
+                        printer.bundleFileInfo.mapHash = ts.computeSignature(sourceMap, ts.maybeBind(host, host.createHash));
                 }
             }
             else {
@@ -111791,7 +111604,7 @@ var ts;
             // We store the hash of the text written in the buildinfo to ensure that text of the referenced d.ts file is same as whats in the buildinfo
             // This is needed because incremental can be toggled between two runs and we might use stale file text to do text manipulation in prepend mode
             if (printer.bundleFileInfo)
-                printer.bundleFileInfo.hash = ts.computeSignature(text, host);
+                printer.bundleFileInfo.hash = ts.computeSignature(text, ts.maybeBind(host, host.createHash));
             // Reset state
             writer.clear();
         }
@@ -111934,6 +111747,7 @@ var ts;
     }
     /*@internal*/
     function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
+        var createHash = ts.maybeBind(host, host.createHash);
         var _a = getOutputPathsForBundle(config.options, /*forceDtsPaths*/ false), buildInfoPath = _a.buildInfoPath, jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath;
         var buildInfo;
         if (host.getBuildInfo) {
@@ -111955,25 +111769,25 @@ var ts;
         if (!jsFileText)
             return jsFilePath;
         // If the jsFileText is not same has what it was created with, tsbuildinfo is stale so dont use it
-        if (ts.computeSignature(jsFileText, host) !== buildInfo.bundle.js.hash)
+        if (ts.computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash)
             return jsFilePath;
         var sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
         // error if no source map or for now if inline sourcemap
         if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap)
             return sourceMapFilePath || "inline sourcemap decoding";
-        if (sourceMapFilePath && ts.computeSignature(sourceMapText, host) !== buildInfo.bundle.js.mapHash)
+        if (sourceMapFilePath && ts.computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash)
             return sourceMapFilePath;
         // read declaration text
         var declarationText = declarationFilePath && host.readFile(declarationFilePath);
         if (declarationFilePath && !declarationText)
             return declarationFilePath;
-        if (declarationFilePath && ts.computeSignature(declarationText, host) !== buildInfo.bundle.dts.hash)
+        if (declarationFilePath && ts.computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash)
             return declarationFilePath;
         var declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
         // error if no source map or for now if inline sourcemap
         if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap)
             return declarationMapPath || "inline sourcemap decoding";
-        if (declarationMapPath && ts.computeSignature(declarationMapText, host) !== buildInfo.bundle.dts.mapHash)
+        if (declarationMapPath && ts.computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
             return declarationMapPath;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var ownPrependInput = ts.createInputFiles(jsFileText, declarationText, sourceMapFilePath, sourceMapText, declarationMapPath, declarationMapText, jsFilePath, declarationFilePath, buildInfoPath, buildInfo, 
@@ -112013,7 +111827,7 @@ var ts;
                         newBuildInfo.program = buildInfo.program;
                         if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) {
                             // Update the output signature
-                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, host, changedDtsData);
+                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, createHash, changedDtsData);
                         }
                         // Update sourceFileInfo
                         var _a = buildInfo.bundle, js = _a.js, dts = _a.dts, sourceFiles = _a.sourceFiles;
@@ -112047,7 +111861,7 @@ var ts;
             getSourceFileFromReference: ts.returnUndefined,
             redirectTargetsMap: ts.createMultiMap(),
             getFileIncludeReasons: ts.notImplemented,
-            createHash: ts.maybeBind(host, host.createHash),
+            createHash: createHash,
         };
         emitFiles(ts.notImplementedResolver, emitHost, 
         /*targetSourceFile*/ undefined, ts.getTransformers(config.options, customTransformers));
@@ -117524,7 +117338,7 @@ var ts;
             var result = void 0;
             var mode = getModeForFileReference(name, containingFileMode);
             // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
-            var strName = ts.isString(name) ? name : ts.toFileNameLowerCase(name.fileName);
+            var strName = ts.isString(name) ? name : name.fileName.toLowerCase();
             var cacheKey = mode !== undefined ? mode + "|" + strName : strName;
             if (cache.has(cacheKey)) {
                 result = cache.get(cacheKey);
@@ -117628,22 +117442,8 @@ var ts;
         return elem.value.text === "import" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
     }
     ts.getResolutionModeOverrideForClause = getResolutionModeOverrideForClause;
-    var emptyResolution = {
-        resolvedModule: undefined,
-        resolvedTypeReferenceDirective: undefined,
-        failedLookupLocations: [],
-        affectingLocations: [],
-        resolutionDiagnostics: [],
-    };
-    function isResolvedModuleWithFailedLookupLocation(resolved) {
-        return !!resolved && !!resolved.failedLookupLocations;
-    }
-    function isResolvedTypeReferenceDirectiveWithFailedLookupLocations(resolved) {
-        return !!resolved && !!resolved.failedLookupLocations;
-    }
     /* @internal */
-    function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, partialResolutionInfo, loader) {
-        var _a;
+    function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, loader) {
         if (names.length === 0) {
             return [];
         }
@@ -117653,7 +117453,7 @@ var ts;
         for (var _i = 0, names_3 = names; _i < names_3.length; _i++) {
             var name = names_3[_i];
             var result = void 0;
-            var mode = getModeForResolutionAtIndex(containingFile, (_a = partialResolutionInfo === null || partialResolutionInfo === void 0 ? void 0 : partialResolutionInfo.namesIndex[i]) !== null && _a !== void 0 ? _a : i);
+            var mode = getModeForResolutionAtIndex(containingFile, i);
             i++;
             var cacheKey = mode !== undefined ? mode + "|" + name : name;
             if (cache.has(cacheKey)) {
@@ -117718,14 +117518,14 @@ var ts;
     /*@internal*/
     function getReferencedFileLocation(getSourceFileByPath, ref) {
         var _a, _b, _c;
-        var _d, _e, _f, _g, _h, _j;
+        var _d, _e, _f, _g;
         var file = ts.Debug.checkDefined(getSourceFileByPath(ref.file));
         var kind = ref.kind, index = ref.index;
         var pos, end, packageId, resolutionMode;
         switch (kind) {
             case ts.FileIncludeKind.Import:
                 var importLiteral = getModuleNameStringLiteralAt(file, index);
-                packageId = (_f = (_e = (_d = file.resolvedModules) === null || _d === void 0 ? void 0 : _d.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) === null || _e === void 0 ? void 0 : _e.resolvedModule) === null || _f === void 0 ? void 0 : _f.packageId;
+                packageId = (_e = (_d = file.resolvedModules) === null || _d === void 0 ? void 0 : _d.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) === null || _e === void 0 ? void 0 : _e.packageId;
                 if (importLiteral.pos === -1)
                     return { file: file, packageId: packageId, text: importLiteral.text };
                 pos = ts.skipTrivia(file.text, importLiteral.pos);
@@ -117736,7 +117536,7 @@ var ts;
                 break;
             case ts.FileIncludeKind.TypeReferenceDirective:
                 (_b = file.typeReferenceDirectives[index], pos = _b.pos, end = _b.end, resolutionMode = _b.resolutionMode);
-                packageId = (_j = (_h = (_g = file.resolvedTypeReferenceDirectiveNames) === null || _g === void 0 ? void 0 : _g.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) === null || _h === void 0 ? void 0 : _h.resolvedTypeReferenceDirective) === null || _j === void 0 ? void 0 : _j.packageId;
+                packageId = (_g = (_f = file.resolvedTypeReferenceDirectiveNames) === null || _f === void 0 ? void 0 : _f.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) === null || _g === void 0 ? void 0 : _g.packageId;
                 break;
             case ts.FileIncludeKind.LibReferenceDirective:
                 (_c = file.libReferenceDirectives[index], pos = _c.pos, end = _c.end);
@@ -117966,10 +117766,10 @@ var ts;
         };
     }
     function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         var createProgramOptions = ts.isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions; // TODO: GH#18217
         var rootNames = createProgramOptions.rootNames, options = createProgramOptions.options, configFileParsingDiagnostics = createProgramOptions.configFileParsingDiagnostics, projectReferences = createProgramOptions.projectReferences;
-        var oldProgramOrOldBuildInfoProgramConstructor = createProgramOptions.oldProgram;
+        var oldProgram = createProgramOptions.oldProgram;
         var processingDefaultLibFiles;
         var processingOtherFiles;
         var files;
@@ -117983,8 +117783,6 @@ var ts;
         var cachedDeclarationDiagnosticsForFile = {};
         var resolvedTypeReferenceDirectives = ts.createModeAwareCache();
         var fileProcessingDiagnostics;
-        var automaticTypeDirectiveNames;
-        var automaticTypeDirectiveResolutions;
         // The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules.
         // This works as imported modules are discovered recursively in a depth first manner, specifically:
         // - For each root file, findSourceFile is called.
@@ -118006,11 +117804,6 @@ var ts;
         var skipDefaultLib = options.noLib;
         var getDefaultLibraryFileName = ts.memoize(function () { return host.getDefaultLibFileName(options); });
         var defaultLibraryPath = host.getDefaultLibLocation ? host.getDefaultLibLocation() : ts.getDirectoryPath(getDefaultLibraryFileName());
-        /**
-         * Diagnostics for the program
-         * Only add diagnostics directly if it always would be done irrespective of program structure reuse.
-         * Otherwise fileProcessingDiagnostics is correct locations so that the diagnostics can be reported in all structure use scenarios
-         */
         var programDiagnostics = ts.createDiagnosticCollection();
         var currentDirectory = host.getCurrentDirectory();
         var supportedExtensions = ts.getSupportedExtensions(options);
@@ -118023,71 +117816,30 @@ var ts;
         var actualResolveModuleNamesWorker;
         var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse;
         if (host.resolveModuleNames) {
-            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, redirectedReference, partialResolutionInfo) {
-                var _a;
-                var result = host.resolveModuleNames(moduleNames, containingFileName, (_a = partialResolutionInfo === null || partialResolutionInfo === void 0 ? void 0 : partialResolutionInfo.reusedNames) === null || _a === void 0 ? void 0 : _a.map(function (_a) {
-                    var name = _a.name;
-                    return name;
-                }), redirectedReference, options, containingFile, partialResolutionInfo);
-                return result.some(isResolvedModuleWithFailedLookupLocation) ?
-                    result :
-                    result.map(function (resolved) { return resolved ?
-                        resolved.extension !== undefined ?
-                            // An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName.
-                            { resolvedModule: resolved, failedLookupLocations: emptyResolution.failedLookupLocations } :
-                            { resolvedModule: __assign(__assign({}, resolved), { extension: ts.extensionFromPath(resolved.resolvedFileName) }), failedLookupLocations: emptyResolution.failedLookupLocations } :
-                        emptyResolution; });
-            };
+            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, reusedNames, redirectedReference) { return host.resolveModuleNames(ts.Debug.checkEachDefined(moduleNames), containingFileName, reusedNames, redirectedReference, options, containingFile).map(function (resolved) {
+                // An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName.
+                if (!resolved || resolved.extension !== undefined) {
+                    return resolved;
+                }
+                var withExtension = ts.clone(resolved);
+                withExtension.extension = ts.extensionFromPath(resolved.resolvedFileName);
+                return withExtension;
+            }); };
             moduleResolutionCache = (_a = host.getModuleResolutionCache) === null || _a === void 0 ? void 0 : _a.call(host);
         }
         else {
             moduleResolutionCache = ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName, options);
-            var loader_1 = function (moduleName, resolverMode, containingFileName, redirectedReference) { return ts.resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode); };
-            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, redirectedReference, partialResolutionInfo) {
-                return loadWithModeAwareCache(moduleNames, containingFile, containingFileName, redirectedReference, partialResolutionInfo, loader_1);
-            };
+            var loader_1 = function (moduleName, resolverMode, containingFileName, redirectedReference) { return ts.resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule; }; // TODO: GH#18217
+            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, _reusedNames, redirectedReference) { return loadWithModeAwareCache(ts.Debug.checkEachDefined(moduleNames), containingFile, containingFileName, redirectedReference, loader_1); };
         }
         var actualResolveTypeReferenceDirectiveNamesWorker;
         if (host.resolveTypeReferenceDirectives) {
-            actualResolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile, redirectedReference, containingFileMode, partialResolutionInfo) {
-                var result = host.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, options, containingFileMode, partialResolutionInfo);
-                return result.some(isResolvedTypeReferenceDirectiveWithFailedLookupLocations) ?
-                    result :
-                    result.map(function (resolved) { return resolved ?
-                        { resolvedTypeReferenceDirective: resolved, failedLookupLocations: emptyResolution.failedLookupLocations } :
-                        emptyResolution; });
-            };
-            typeReferenceDirectiveResolutionCache = (_b = host.getTypeReferenceDirectiveResolutionCache) === null || _b === void 0 ? void 0 : _b.call(host);
+            actualResolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile, redirectedReference, containingFileMode) { return host.resolveTypeReferenceDirectives(ts.Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode); };
         }
         else {
             typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, /*options*/ undefined, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
-            var loader_2 = function (typesRef, containingFile, redirectedReference, resolutionMode) { return ts.resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode); };
-            actualResolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) {
-                return loadWithTypeDirectiveCache(typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode, loader_2);
-            };
-        }
-        var oldProgram = typeof oldProgramOrOldBuildInfoProgramConstructor === "object" ? oldProgramOrOldBuildInfoProgramConstructor : undefined;
-        var oldBuildInfoProgram;
-        if (!oldProgram && typeof oldProgramOrOldBuildInfoProgramConstructor === "function") {
-            var state_11 = ts.getTemporaryModuleResolutionState(moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options);
-            oldBuildInfoProgram = oldProgramOrOldBuildInfoProgramConstructor({
-                fileExists: function (fileName) { return host.fileExists(fileName); },
-                createHash: ts.maybeBind(host, host.createHash),
-                getPackageJsonInfo: function (fileName) { return ts.getPackageJsonInfo(ts.getDirectoryPath(fileName), /*onlyRecordFailures*/ false, state_11); },
-            });
-            if (oldBuildInfoProgram) {
-                // Ensure redirected references are verified before using existing cache
-                moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.setOldResolutionCache({
-                    getResolved: function (dirPath, name, mode, redirectedReference) {
-                        return oldBuildInfoProgram === null || oldBuildInfoProgram === void 0 ? void 0 : oldBuildInfoProgram.getResolvedModule(dirPath, name, mode, redirectedReference);
-                    }
-                });
-                typeReferenceDirectiveResolutionCache === null || typeReferenceDirectiveResolutionCache === void 0 ? void 0 : typeReferenceDirectiveResolutionCache.setOldResolutionCache({
-                    getResolved: function (dirPath, name, mode, redirectedReference) {
-                        return oldBuildInfoProgram === null || oldBuildInfoProgram === void 0 ? void 0 : oldBuildInfoProgram.getResolvedTypeReferenceDirective(dirPath, name, mode, redirectedReference);
-                    }
-                });
-            }
+            var loader_2 = function (typesRef, containingFile, redirectedReference, resolutionMode) { return ts.resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode).resolvedTypeReferenceDirective; }; // TODO: GH#18217
+            actualResolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) { return loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_2); };
         }
         // Map from a stringified PackageId to the source file with that id.
         // Only one source file may have a given packageId. Others become redirects (see createRedirectSourceFile).
@@ -118114,9 +117866,9 @@ var ts;
         var projectReferenceRedirects;
         var mapFromFileToProjectReferenceRedirects;
         var mapFromToProjectReferenceRedirectSource;
-        var useSourceOfProjectReferenceRedirect = !!((_c = host.useSourceOfProjectReferenceRedirect) === null || _c === void 0 ? void 0 : _c.call(host)) &&
+        var useSourceOfProjectReferenceRedirect = !!((_b = host.useSourceOfProjectReferenceRedirect) === null || _b === void 0 ? void 0 : _b.call(host)) &&
             !options.disableSourceOfProjectReferenceRedirect;
-        var _f = updateHostForUseSourceOfProjectReferenceRedirect({
+        var _e = updateHostForUseSourceOfProjectReferenceRedirect({
             compilerHost: host,
             getSymlinkCache: getSymlinkCache,
             useSourceOfProjectReferenceRedirect: useSourceOfProjectReferenceRedirect,
@@ -118124,7 +117876,7 @@ var ts;
             getResolvedProjectReferences: getResolvedProjectReferences,
             getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect,
             forEachResolvedProjectReference: forEachResolvedProjectReference
-        }), onProgramCreateComplete = _f.onProgramCreateComplete, fileExists = _f.fileExists, directoryExists = _f.directoryExists;
+        }), onProgramCreateComplete = _e.onProgramCreateComplete, fileExists = _e.fileExists, directoryExists = _e.directoryExists;
         var readFile = host.readFile.bind(host);
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
         var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
@@ -118135,7 +117887,7 @@ var ts;
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "tryReuseStructureFromOldProgram", {});
         structureIsReused = tryReuseStructureFromOldProgram(); // eslint-disable-line prefer-const
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
-        if (structureIsReused !== 3 /* Completely */) {
+        if (structureIsReused !== 2 /* Completely */) {
             processingDefaultLibFiles = [];
             processingOtherFiles = [];
             if (projectReferences) {
@@ -118176,15 +117928,16 @@ var ts;
             ts.forEach(rootNames, function (name, index) { return processRootFile(name, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.RootFile, index: index }); });
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders
-            automaticTypeDirectiveNames !== null && automaticTypeDirectiveNames !== void 0 ? automaticTypeDirectiveNames : (automaticTypeDirectiveNames = rootNames.length ? ts.getAutomaticTypeDirectiveNames(options, host) : ts.emptyArray);
-            automaticTypeDirectiveResolutions = ts.createModeAwareCache();
-            if (automaticTypeDirectiveNames.length) {
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferences", { count: automaticTypeDirectiveNames.length });
-                var resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(automaticTypeDirectiveNames, getAutomaticTypeDirectiveContainingFile());
-                for (var i = 0; i < automaticTypeDirectiveNames.length; i++) {
+            var typeReferences = rootNames.length ? ts.getAutomaticTypeDirectiveNames(options, host) : ts.emptyArray;
+            if (typeReferences.length) {
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferences", { count: typeReferences.length });
+                // This containingFilename needs to match with the one used in managed-side
+                var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
+                var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile);
+                var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
+                for (var i = 0; i < typeReferences.length; i++) {
                     // under node16/nodenext module resolution, load `types`/ata include names as cjs resolution results by passing an `undefined` mode
-                    automaticTypeDirectiveResolutions.set(automaticTypeDirectiveNames[i], /*mode*/ undefined, resolutions[i]);
-                    processTypeReferenceDirective(automaticTypeDirectiveNames[i], /*mode*/ undefined, resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: automaticTypeDirectiveNames[i], packageId: (_d = resolutions[i].resolvedTypeReferenceDirective) === null || _d === void 0 ? void 0 : _d.packageId });
+                    processTypeReferenceDirective(typeReferences[i], /*mode*/ undefined, resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_c = resolutions[i]) === null || _c === void 0 ? void 0 : _c.packageId });
                 }
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             }
@@ -118224,13 +117977,13 @@ var ts;
                 if (shouldCreateNewSourceFile || !newFile ||
                     // old file wasn't redirect but new file is
                     (oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) {
-                    host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions());
+                    host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
                 }
             }
             if (!host.getParsedCommandLine) {
                 oldProgram.forEachResolvedProjectReference(function (resolvedProjectReference) {
                     if (!getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) {
-                        host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions());
+                        host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions(), /*hasSourceFileByPath*/ false);
                     }
                 });
             }
@@ -118248,8 +118001,6 @@ var ts;
         typeReferenceDirectiveResolutionCache = undefined;
         // unconditionally set oldProgram to undefined to prevent it from being captured in closure
         oldProgram = undefined;
-        oldBuildInfoProgram = undefined;
-        oldProgramOrOldBuildInfoProgramConstructor = undefined;
         var program = {
             getRootFileNames: function () { return rootNames; },
             getSourceFile: getSourceFile,
@@ -118257,7 +118008,6 @@ var ts;
             getSourceFiles: function () { return files; },
             getMissingFilePaths: function () { return missingFilePaths; },
             getModuleResolutionCache: function () { return moduleResolutionCache; },
-            getTypeReferenceDirectiveResolutionCache: function () { return typeReferenceDirectiveResolutionCache; },
             getFilesByNameMap: function () { return filesByName; },
             getCompilerOptions: function () { return options; },
             getSyntacticDiagnostics: getSyntacticDiagnostics,
@@ -118282,9 +118032,6 @@ var ts;
             getRelationCacheSizes: function () { return getTypeChecker().getRelationCacheSizes(); },
             getFileProcessingDiagnostics: function () { return fileProcessingDiagnostics; },
             getResolvedTypeReferenceDirectives: function () { return resolvedTypeReferenceDirectives; },
-            getAutomaticTypeDirectiveNames: function () { return automaticTypeDirectiveNames; },
-            getAutomaticTypeDirectiveResolutions: function () { return automaticTypeDirectiveResolutions; },
-            getAutomaticTypeDirectiveContainingFile: getAutomaticTypeDirectiveContainingFile,
             isSourceFileFromExternalLibrary: isSourceFileFromExternalLibrary,
             isSourceFileDefaultLibrary: isSourceFileDefaultLibrary,
             getSourceFileFromReference: getSourceFileFromReference,
@@ -118294,12 +118041,12 @@ var ts;
             usesUriStyleNodeCoreModules: usesUriStyleNodeCoreModules,
             isEmittedFile: isEmittedFile,
             getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics,
+            getResolvedModuleWithFailedLookupLocationsFromCache: getResolvedModuleWithFailedLookupLocationsFromCache,
             getProjectReferences: getProjectReferences,
             getResolvedProjectReferences: getResolvedProjectReferences,
             getProjectReferenceRedirect: getProjectReferenceRedirect,
             getResolvedProjectReferenceToRedirect: getResolvedProjectReferenceToRedirect,
             getResolvedProjectReferenceByPath: getResolvedProjectReferenceByPath,
-            getRedirectReferenceForResolution: getRedirectReferenceForResolution,
             forEachResolvedProjectReference: forEachResolvedProjectReference,
             isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect,
             emitBuildInfo: emitBuildInfo,
@@ -118307,7 +118054,7 @@ var ts;
             readFile: readFile,
             directoryExists: directoryExists,
             getSymlinkCache: getSymlinkCache,
-            realpath: (_e = host.realpath) === null || _e === void 0 ? void 0 : _e.bind(host),
+            realpath: (_d = host.realpath) === null || _d === void 0 ? void 0 : _d.bind(host),
             useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); },
             getFileIncludeReasons: function () { return fileReasons; },
             structureIsReused: structureIsReused,
@@ -118322,8 +118069,6 @@ var ts;
                 case 0 /* FilePreprocessingReferencedDiagnostic */:
                     var _a = getReferencedFileLocation(getSourceFileByPath, diagnostic.reason), file = _a.file, pos = _a.pos, end = _a.end;
                     return programDiagnostics.add(ts.createFileDiagnostic.apply(void 0, __spreadArray([file, ts.Debug.checkDefined(pos), ts.Debug.checkDefined(end) - pos, diagnostic.diagnostic], diagnostic.args || ts.emptyArray, false)));
-                case 2 /* ResolutionDiagnostics */:
-                    return diagnostic.diagnostics.forEach(function (d) { return programDiagnostics.add(d); });
                 default:
                     ts.Debug.assertNever(diagnostic);
             }
@@ -118333,46 +118078,63 @@ var ts;
         ts.performance.measure("Program", "beforeProgram", "afterProgram");
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         return program;
-        function getAutomaticTypeDirectiveContainingFile() {
-            // This containingFilename needs to match with the one used in managed-side
-            var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
-            return ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile);
+        function addResolutionDiagnostics(list) {
+            if (!list)
+                return;
+            for (var _i = 0, list_3 = list; _i < list_3.length; _i++) {
+                var elem = list_3[_i];
+                programDiagnostics.add(elem);
+            }
         }
-        function addResolutionDiagnostics(resolution) {
-            if (!resolution.resolutionDiagnostics)
+        function pullDiagnosticsFromCache(names, containingFile) {
+            var _a;
+            if (!moduleResolutionCache)
                 return;
-            (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
-                kind: 2 /* ResolutionDiagnostics */,
-                diagnostics: resolution.resolutionDiagnostics.map(function (d) { return ts.createCompilerDiagnostic(d.isImports
-                    ? ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate
-                    : ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate, d.entry === "" ? "." : d.entry, // replace empty string with `.` - the reverse of the operation done when entries are built - so main entrypoint errors don't look weird
-                d.packagePath); })
-            });
+            var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
+            var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
+            var containingDir = ts.getDirectoryPath(containingFileName);
+            var redirectedReference = getRedirectReferenceForResolution(containingFile);
+            var i = 0;
+            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
+                var n = names_4[_i];
+                // mimics logic done in the resolution cache, should be resilient to upgrading it to use `FileReference`s for non-type-reference modal lookups to make it rely on the index in the list less
+                var mode = typeof n === "string" ? getModeForResolutionAtIndex(containingFile, i) : getModeForFileReference(n, containingFileMode);
+                var name = typeof n === "string" ? n : n.fileName;
+                i++;
+                // only nonrelative names hit the cache, and, at least as of right now, only nonrelative names can issue diagnostics
+                // (Since diagnostics are only issued via import or export map lookup)
+                // This may totally change if/when the issue of output paths not mapping to input files is fixed in a broader context
+                // When it is, how we extract diagnostics from the module name resolver will have the be refined - the current cache
+                // APIs wrapping the underlying resolver make it almost impossible to smuggle the diagnostics out in a generalized way
+                if (ts.isExternalModuleNameRelative(name))
+                    continue;
+                var diags = (_a = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) === null || _a === void 0 ? void 0 : _a.resolutionDiagnostics;
+                addResolutionDiagnostics(diags);
+            }
         }
-        function resolveModuleNamesWorker(moduleNames, containingFile, partialResolutionInfo, redirectedReference) {
+        function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
             if (!moduleNames.length)
                 return ts.emptyArray;
             var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
-            if (redirectedReference === undefined)
-                redirectedReference = getRedirectReferenceForResolution(containingFile);
+            var redirectedReference = getRedirectReferenceForResolution(containingFile);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "resolveModuleNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveModule");
-            var result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, redirectedReference || undefined, partialResolutionInfo);
+            var result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, reusedNames, redirectedReference);
             ts.performance.mark("afterResolveModule");
             ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
+            pullDiagnosticsFromCache(moduleNames, containingFile);
             return result;
         }
-        function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, partialResolutionInfo, redirectedReference) {
+        function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) {
             if (!typeDirectiveNames.length)
                 return [];
             var containingFileName = !ts.isString(containingFile) ? ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
-            if (redirectedReference === undefined && !ts.isString(containingFile))
-                redirectedReference = getRedirectReferenceForResolution(containingFile);
+            var redirectedReference = !ts.isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined;
             var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveTypeReference");
-            var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference || undefined, containingFileMode, partialResolutionInfo);
+            var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode);
             ts.performance.mark("afterResolveTypeReference");
             ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
@@ -118425,6 +118187,9 @@ var ts;
             }
             return ts.libs.length + 2;
         }
+        function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) {
+            return moduleResolutionCache && ts.resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode);
+        }
         function toPath(fileName) {
             return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
         }
@@ -118449,11 +118214,10 @@ var ts;
             return classifiableNames;
         }
         function resolveModuleNamesReusingOldState(moduleNames, file) {
-            var _a;
             if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
                 // If the old program state does not permit reusing resolutions and `file` does not contain locally defined ambient modules,
                 // the best we can do is fallback to the default logic.
-                return resolveModuleNamesWorker(moduleNames, file, /*partialResolutionInfo*/ undefined, /*redirectedReference*/ undefined);
+                return resolveModuleNamesWorker(moduleNames, file, /*reusedNames*/ undefined);
             }
             var oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
             if (oldSourceFile !== file && file.resolvedModules) {
@@ -118481,8 +118245,6 @@ var ts;
             // With this information, we can infer some module resolutions without performing resolution.
             /** An ordered list of module names for which we cannot recover the resolution. */
             var unknownModuleNames;
-            var unknownModuleNamesIndex;
-            var reusedNames;
             /**
              * The indexing of elements in this list matches that of `moduleNames`.
              *
@@ -118493,33 +118255,22 @@ var ts;
              * * ResolvedModuleFull instance: can be reused.
              */
             var result;
+            var reusedNames;
             /** A transient placeholder used to mark predicted resolution in the result list. */
-            var predictedToResolveToAmbientModuleMarker = true;
-            var redirectedReference;
+            var predictedToResolveToAmbientModuleMarker = {};
             for (var i = 0; i < moduleNames.length; i++) {
                 var moduleName = moduleNames[i];
                 // If the source file is unchanged and doesnt have invalidated resolution, reuse the module resolutions
-                if (oldBuildInfoProgram || file === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) {
-                    var mode = getModeForResolutionAtIndex(file, i);
-                    var oldResolution = !oldBuildInfoProgram ?
-                        (_a = oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.resolvedModules) === null || _a === void 0 ? void 0 : _a.get(moduleName, mode) :
-                        oldBuildInfoProgram.getResolvedModule(ts.getDirectoryPath(file.path), moduleName, mode, (redirectedReference === undefined ? (redirectedReference = getRedirectReferenceForResolution(file) || false) : redirectedReference) || undefined);
-                    if (oldResolution === null || oldResolution === void 0 ? void 0 : oldResolution.resolvedModule) {
+                if (file === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) {
+                    var oldResolvedModule = ts.getResolvedModule(oldSourceFile, moduleName, getModeForResolutionAtIndex(oldSourceFile, i));
+                    if (oldResolvedModule) {
                         if (ts.isTraceEnabled(options, host)) {
-                            var fileLocation = ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory);
-                            if (!oldBuildInfoProgram) {
-                                ts.trace(host, oldResolution.resolvedModule.packageId ?
-                                    ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 :
-                                    ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2, moduleName, fileLocation, oldResolution.resolvedModule.resolvedFileName, oldResolution.resolvedModule.packageId && ts.packageIdToString(oldResolution.resolvedModule.packageId));
-                            }
-                            else {
-                                ts.trace(host, oldResolution.resolvedModule.packageId ?
-                                    ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 :
-                                    ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3, moduleName, fileLocation, ts.getDirectoryPath(fileLocation), oldResolution.resolvedModule.resolvedFileName, oldResolution.resolvedModule.packageId && ts.packageIdToString(oldResolution.resolvedModule.packageId));
-                            }
+                            ts.trace(host, oldResolvedModule.packageId ?
+                                ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 :
+                                ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2, moduleName, ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory), oldResolvedModule.resolvedFileName, oldResolvedModule.packageId && ts.packageIdToString(oldResolvedModule.packageId));
                         }
-                        (result !== null && result !== void 0 ? result : (result = new Array(moduleNames.length)))[i] = oldResolution;
-                        (reusedNames !== null && reusedNames !== void 0 ? reusedNames : (reusedNames = [])).push({ name: moduleName, mode: mode });
+                        (result || (result = new Array(moduleNames.length)))[i] = oldResolvedModule;
+                        (reusedNames || (reusedNames = [])).push(moduleName);
                         continue;
                     }
                 }
@@ -118538,16 +118289,15 @@ var ts;
                     resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, i);
                 }
                 if (resolvesToAmbientModuleInNonModifiedFile) {
-                    (result !== null && result !== void 0 ? result : (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
+                    (result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
                 }
                 else {
                     // Resolution failed in the old program, or resolved to an ambient module for which we can't reuse the result.
-                    (unknownModuleNames !== null && unknownModuleNames !== void 0 ? unknownModuleNames : (unknownModuleNames = [])).push(moduleName);
-                    (unknownModuleNamesIndex !== null && unknownModuleNamesIndex !== void 0 ? unknownModuleNamesIndex : (unknownModuleNamesIndex = [])).push(i);
+                    (unknownModuleNames || (unknownModuleNames = [])).push(moduleName);
                 }
             }
             var resolutions = unknownModuleNames && unknownModuleNames.length
-                ? resolveModuleNamesWorker(unknownModuleNames, file, { reusedNames: reusedNames, namesIndex: unknownModuleNamesIndex }, redirectedReference)
+                ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames)
                 : ts.emptyArray;
             // Combine results of resolutions and predicted results
             if (!result) {
@@ -118561,7 +118311,7 @@ var ts;
                     // `result[i]` is either a `ResolvedModuleFull` or a marker.
                     // If it is the former, we can leave it as is.
                     if (result[i] === predictedToResolveToAmbientModuleMarker) {
-                        result[i] = emptyResolution;
+                        result[i] = undefined;
                     }
                 }
                 else {
@@ -118596,96 +118346,6 @@ var ts;
                 return true;
             }
         }
-        function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
-            var _a;
-            if (structureIsReused === 0 /* Not */) {
-                return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, /*partialResolutionInfo*/ undefined, /*redirectedReference*/ undefined);
-            }
-            var containingSourceFile = !ts.isString(containingFile) ? containingFile : undefined;
-            var inferredTypeFile = !ts.isString(containingFile) ? undefined : containingFile;
-            var oldSourceFile = containingSourceFile && (oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getSourceFile(containingSourceFile.fileName));
-            if (containingSourceFile && oldSourceFile !== containingSourceFile && containingSourceFile.resolvedTypeReferenceDirectiveNames) {
-                // `file` was created for the new program.
-                //
-                // We only set `file.resolvedTypeReferenceDirectiveNames` via work from the current function,
-                // so it is defined iff we already called the current function on `file`.
-                // That call happened no later than the creation of the `file` object,
-                // which per above occurred during the current program creation.
-                // Since we assume the filesystem does not change during program creation,
-                // it is safe to reuse resolutions from the earlier call.
-                var result_15 = [];
-                for (var _i = 0, _b = typeDirectiveNames; _i < _b.length; _i++) {
-                    var typeDirectiveName = _b[_i];
-                    // We lower-case all type references because npm automatically lowercases all packages. See GH#9824.
-                    var resolvedTypeReferenceDirective = containingSourceFile.resolvedTypeReferenceDirectiveNames.get(ts.toFileNameLowerCase(typeDirectiveName.fileName), typeDirectiveName.resolutionMode || containingSourceFile.impliedNodeFormat);
-                    result_15.push(resolvedTypeReferenceDirective);
-                }
-                return result_15;
-            }
-            /** An ordered list of module names for which we cannot recover the resolution. */
-            var unknownTypeReferenceDirectiveNames;
-            var unknownTypeReferenceDirectiveNamesIndex;
-            /**
-             * The indexing of elements in this list matches that of `moduleNames`.
-             *
-             * Before combining results, result[i] is in one of the following states:
-             * * undefined: needs to be recomputed,
-             */
-            var result;
-            var reusedNames;
-            var canReuseResolutions = oldBuildInfoProgram || (containingSourceFile ?
-                containingSourceFile === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path) :
-                !hasInvalidatedResolution(toPath(inferredTypeFile)));
-            var redirectedReference;
-            for (var i = 0; i < typeDirectiveNames.length; i++) {
-                var entry = typeDirectiveNames[i];
-                // If the source file is unchanged and doesnt have invalidated resolution, reuse the module resolutions
-                if (canReuseResolutions) {
-                    var typeDirectiveName = !ts.isString(entry) ? entry.fileName.toLowerCase() : entry;
-                    var mode = getModeForFileReference(entry, containingSourceFile === null || containingSourceFile === void 0 ? void 0 : containingSourceFile.impliedNodeFormat);
-                    var oldResolution = !oldBuildInfoProgram ?
-                        (_a = (containingSourceFile ? oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.resolvedTypeReferenceDirectiveNames : oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getAutomaticTypeDirectiveResolutions())) === null || _a === void 0 ? void 0 : _a.get(typeDirectiveName, mode) :
-                        oldBuildInfoProgram.getResolvedTypeReferenceDirective(ts.getDirectoryPath(containingSourceFile ? containingSourceFile.path : toPath(inferredTypeFile)), typeDirectiveName, mode, containingSourceFile && (redirectedReference === undefined ? (redirectedReference = getRedirectReferenceForResolution(containingSourceFile) || false) : redirectedReference) || undefined);
-                    if (oldResolution === null || oldResolution === void 0 ? void 0 : oldResolution.resolvedTypeReferenceDirective) {
-                        if (ts.isTraceEnabled(options, host)) {
-                            var fileLocation = containingSourceFile ? ts.getNormalizedAbsolutePath(containingSourceFile.originalFileName, currentDirectory) : inferredTypeFile;
-                            if (!oldBuildInfoProgram) {
-                                ts.trace(host, oldResolution.resolvedTypeReferenceDirective.packageId ?
-                                    ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 :
-                                    ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2, typeDirectiveName, fileLocation, oldResolution.resolvedTypeReferenceDirective.resolvedFileName, oldResolution.resolvedTypeReferenceDirective.packageId && ts.packageIdToString(oldResolution.resolvedTypeReferenceDirective.packageId));
-                            }
-                            else {
-                                ts.trace(host, oldResolution.resolvedTypeReferenceDirective.packageId ?
-                                    ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 :
-                                    ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3, typeDirectiveName, fileLocation, ts.getDirectoryPath(fileLocation), oldResolution.resolvedTypeReferenceDirective.resolvedFileName, oldResolution.resolvedTypeReferenceDirective.packageId && ts.packageIdToString(oldResolution.resolvedTypeReferenceDirective.packageId));
-                            }
-                        }
-                        (result || (result = new Array(typeDirectiveNames.length)))[i] = oldResolution;
-                        (reusedNames !== null && reusedNames !== void 0 ? reusedNames : (reusedNames = [])).push({ name: typeDirectiveName, mode: mode });
-                        continue;
-                    }
-                }
-                // Resolution failed in the old program, or resolved to an ambient module for which we can't reuse the result.
-                (unknownTypeReferenceDirectiveNames !== null && unknownTypeReferenceDirectiveNames !== void 0 ? unknownTypeReferenceDirectiveNames : (unknownTypeReferenceDirectiveNames = [])).push(entry);
-                (unknownTypeReferenceDirectiveNamesIndex !== null && unknownTypeReferenceDirectiveNamesIndex !== void 0 ? unknownTypeReferenceDirectiveNamesIndex : (unknownTypeReferenceDirectiveNamesIndex = [])).push(i);
-            }
-            if (!unknownTypeReferenceDirectiveNames)
-                return result || ts.emptyArray;
-            var resolutions = resolveTypeReferenceDirectiveNamesWorker(unknownTypeReferenceDirectiveNames, containingFile, { reusedNames: reusedNames, namesIndex: unknownTypeReferenceDirectiveNamesIndex }, redirectedReference);
-            if (!result) {
-                ts.Debug.assert(resolutions.length === typeDirectiveNames.length);
-                return resolutions;
-            }
-            var j = 0;
-            for (var i = 0; i < result.length; i++) {
-                if (!result[i]) {
-                    result[i] = resolutions[j];
-                    j++;
-                }
-            }
-            ts.Debug.assert(j === resolutions.length);
-            return result;
-        }
         function canReuseProjectReferences() {
             return !forEachProjectReference(oldProgram.getProjectReferences(), oldProgram.getResolvedProjectReferences(), function (oldResolvedRef, parent, index) {
                 var newRef = (parent ? parent.commandLine.projectReferences : projectReferences)[index];
@@ -118707,19 +118367,14 @@ var ts;
             });
         }
         function tryReuseStructureFromOldProgram() {
-            // check properties that can affect structure of the program or module resolution strategy
-            // if any of these properties has changed - structure cannot be reused
-            var oldOptions = (oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getCompilerOptions()) || (oldBuildInfoProgram === null || oldBuildInfoProgram === void 0 ? void 0 : oldBuildInfoProgram.getCompilerOptions());
-            if (!oldOptions || ts.changesAffectModuleResolution(oldOptions, options)) {
+            var _a;
+            if (!oldProgram) {
                 return 0 /* Not */;
             }
-            var result = tryReuseStructureFromOldProgramWorker();
-            return options.cacheResolutions && (oldProgram || oldBuildInfoProgram) && result === 0 /* Not */ ?
-                1 /* SafeModuleCache */ :
-                result;
-        }
-        function tryReuseStructureFromOldProgramWorker() {
-            if (!oldProgram) {
+            // check properties that can affect structure of the program or module resolution strategy
+            // if any of these properties has changed - structure cannot be reused
+            var oldOptions = oldProgram.getCompilerOptions();
+            if (ts.changesAffectModuleResolution(oldOptions, options)) {
                 return 0 /* Not */;
             }
             // there is an old program, check if we can reuse its structure
@@ -118737,7 +118392,7 @@ var ts;
             // check if program source files has changed in the way that can affect structure of the program
             var newSourceFiles = [];
             var modifiedSourceFiles = [];
-            structureIsReused = 3 /* Completely */;
+            structureIsReused = 2 /* Completely */;
             // If the missing file paths are now present, it can change the progam structure,
             // and hence cant reuse the structure.
             // This is same as how we dont reuse the structure if one of the file from old program is now missing
@@ -118801,107 +118456,98 @@ var ts;
                     // The `newSourceFile` object was created for the new program.
                     if (!ts.arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) {
                         // 'lib' references has changed. Matches behavior in changesAffectModuleResolution
-                        structureIsReused = 2 /* SafeModules */;
+                        structureIsReused = 1 /* SafeModules */;
                     }
                     if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
                         // value of no-default-lib has changed
                         // this will affect if default library is injected into the list of files
-                        structureIsReused = 2 /* SafeModules */;
+                        structureIsReused = 1 /* SafeModules */;
                     }
                     // check tripleslash references
                     if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
                         // tripleslash references has changed
-                        structureIsReused = 2 /* SafeModules */;
+                        structureIsReused = 1 /* SafeModules */;
                     }
                     // check imports and module augmentations
                     collectExternalModuleReferences(newSourceFile);
                     if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
                         // imports has changed
-                        structureIsReused = 2 /* SafeModules */;
+                        structureIsReused = 1 /* SafeModules */;
                     }
                     if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
                         // moduleAugmentations has changed
-                        structureIsReused = 2 /* SafeModules */;
+                        structureIsReused = 1 /* SafeModules */;
                     }
                     if ((oldSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */)) {
                         // dynamicImport has changed
-                        structureIsReused = 2 /* SafeModules */;
+                        structureIsReused = 1 /* SafeModules */;
                     }
                     if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
                         // 'types' references has changed
-                        structureIsReused = 2 /* SafeModules */;
+                        structureIsReused = 1 /* SafeModules */;
                     }
                     // tentatively approve the file
                     modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
                 }
                 else if (hasInvalidatedResolution(oldSourceFile.path)) {
                     // 'module/types' references could have changed
-                    structureIsReused = 2 /* SafeModules */;
+                    structureIsReused = 1 /* SafeModules */;
                     // add file to the modified list so that we will resolve it later
                     modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
                 }
                 // if file has passed all checks it should be safe to reuse it
                 newSourceFiles.push(newSourceFile);
             }
-            if (structureIsReused !== 3 /* Completely */) {
+            if (structureIsReused !== 2 /* Completely */) {
                 return structureIsReused;
             }
             var modifiedFiles = modifiedSourceFiles.map(function (f) { return f.oldFile; });
-            for (var _a = 0, oldSourceFiles_3 = oldSourceFiles; _a < oldSourceFiles_3.length; _a++) {
-                var oldFile = oldSourceFiles_3[_a];
+            for (var _b = 0, oldSourceFiles_3 = oldSourceFiles; _b < oldSourceFiles_3.length; _b++) {
+                var oldFile = oldSourceFiles_3[_b];
                 if (!ts.contains(modifiedFiles, oldFile)) {
-                    for (var _b = 0, _c = oldFile.ambientModuleNames; _b < _c.length; _b++) {
-                        var moduleName = _c[_b];
+                    for (var _c = 0, _d = oldFile.ambientModuleNames; _c < _d.length; _c++) {
+                        var moduleName = _d[_c];
                         ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName);
                     }
                 }
             }
             // try to verify results of module resolution
-            for (var _d = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _d < modifiedSourceFiles_1.length; _d++) {
-                var _e = modifiedSourceFiles_1[_d], oldSourceFile = _e.oldFile, newSourceFile = _e.newFile;
+            for (var _e = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _e < modifiedSourceFiles_1.length; _e++) {
+                var _f = modifiedSourceFiles_1[_e], oldSourceFile = _f.oldFile, newSourceFile = _f.newFile;
                 var moduleNames = getModuleNames(newSourceFile);
                 var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
                 // ensure that module resolution results are still correct
                 var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, oldSourceFile, ts.moduleResolutionIsEqualTo);
                 if (resolutionsChanged) {
-                    structureIsReused = 2 /* SafeModules */;
+                    structureIsReused = 1 /* SafeModules */;
                     newSourceFile.resolvedModules = ts.zipToModeAwareCache(newSourceFile, moduleNames, resolutions);
                 }
                 else {
                     newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
                 }
                 var typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
-                var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typesReferenceDirectives, newSourceFile);
+                var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
                 // ensure that types resolutions are still correct
                 var typeReferenceResolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, ts.typeDirectiveIsEqualTo);
                 if (typeReferenceResolutionsChanged) {
-                    structureIsReused = 2 /* SafeModules */;
+                    structureIsReused = 1 /* SafeModules */;
                     newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
                 }
                 else {
                     newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
                 }
             }
-            if (structureIsReused !== 3 /* Completely */) {
+            if (structureIsReused !== 2 /* Completely */) {
                 return structureIsReused;
             }
-            if (ts.changesAffectingProgramStructure(oldProgram.getCompilerOptions(), options)) {
-                return 2 /* SafeModules */;
-            }
-            if (host.hasChangedAutomaticTypeDirectiveNames) {
-                if (host.hasChangedAutomaticTypeDirectiveNames())
-                    return 2 /* SafeModules */;
-            }
-            else {
-                automaticTypeDirectiveNames = ts.getAutomaticTypeDirectiveNames(options, host);
-                if (!ts.arrayIsEqualTo(oldProgram.getAutomaticTypeDirectiveNames(), automaticTypeDirectiveNames))
-                    return 2 /* SafeModules */;
+            if (ts.changesAffectingProgramStructure(oldOptions, options) || ((_a = host.hasChangedAutomaticTypeDirectiveNames) === null || _a === void 0 ? void 0 : _a.call(host))) {
+                return 1 /* SafeModules */;
             }
             missingFilePaths = oldProgram.getMissingFilePaths();
             // update fileName -> file mapping
             ts.Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
-            for (var _f = 0, newSourceFiles_1 = newSourceFiles; _f < newSourceFiles_1.length; _f++) {
-                var newSourceFile = newSourceFiles_1[_f];
+            for (var _g = 0, newSourceFiles_1 = newSourceFiles; _g < newSourceFiles_1.length; _g++) {
+                var newSourceFile = newSourceFiles_1[_g];
                 filesByName.set(newSourceFile.path, newSourceFile);
             }
             var oldFilesByNameMap = oldProgram.getFilesByNameMap();
@@ -118923,12 +118569,10 @@ var ts;
             fileReasons = oldProgram.getFileIncludeReasons();
             fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
             resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
-            automaticTypeDirectiveNames = oldProgram.getAutomaticTypeDirectiveNames();
-            automaticTypeDirectiveResolutions = oldProgram.getAutomaticTypeDirectiveResolutions();
             sourceFileToPackageName = oldProgram.sourceFileToPackageName;
             redirectTargetsMap = oldProgram.redirectTargetsMap;
             usesUriStyleNodeCoreModules = oldProgram.usesUriStyleNodeCoreModules;
-            return 3 /* Completely */;
+            return 2 /* Completely */;
         }
         function getEmitHost(writeFileCallback) {
             return {
@@ -119970,42 +119614,35 @@ var ts;
         }
         function processTypeReferenceDirectives(file) {
             var typeDirectives = file.typeReferenceDirectives;
-            if (!typeDirectives.length) {
-                file.resolvedTypeReferenceDirectiveNames = undefined;
+            if (!typeDirectives) {
                 return;
             }
-            var resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
+            var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file);
             for (var index = 0; index < typeDirectives.length; index++) {
                 var ref = file.typeReferenceDirectives[index];
                 var resolvedTypeReferenceDirective = resolutions[index];
                 // store resolved type directive on the file
                 var fileName = ts.toFileNameLowerCase(ref.fileName);
-                ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat));
+                ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective);
                 var mode = ref.resolutionMode || file.impliedNodeFormat;
                 if (mode && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
-                    (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
-                        kind: 2 /* ResolutionDiagnostics */,
-                        diagnostics: [ts.createDiagnosticForRange(file, ref, ts.Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext)]
-                    });
+                    programDiagnostics.add(ts.createDiagnosticForRange(file, ref, ts.Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext));
                 }
                 processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: ts.FileIncludeKind.TypeReferenceDirective, file: file.path, index: index, });
             }
         }
-        function processTypeReferenceDirective(typeReferenceDirective, mode, resolution, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolution.resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
-            processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason);
+        function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
-        function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason) {
-            var _a;
-            addResolutionDiagnostics(resolution);
+        function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
             // If we already found this library as a primary reference - nothing to do
-            var previousResolution = (_a = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode)) === null || _a === void 0 ? void 0 : _a.resolvedTypeReferenceDirective;
+            var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode);
             if (previousResolution && previousResolution.primary) {
                 return;
             }
             var saveResolution = true;
-            var resolvedTypeReferenceDirective = resolution.resolvedTypeReferenceDirective;
             if (resolvedTypeReferenceDirective) {
                 if (resolvedTypeReferenceDirective.isExternalLibraryImport)
                     currentNodeModulesDepth++;
@@ -120040,7 +119677,7 @@ var ts;
                 addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]);
             }
             if (saveResolution) {
-                resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolution);
+                resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective);
             }
         }
         function pathForLibFile(libFileName) {
@@ -120073,7 +119710,7 @@ var ts;
                     var unqualifiedLibName = ts.removeSuffix(ts.removePrefix(libName, "lib."), ".d.ts");
                     var suggestion = ts.getSpellingSuggestion(unqualifiedLibName, ts.libs, ts.identity);
                     var diagnostic = suggestion ? ts.Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : ts.Diagnostics.Cannot_find_lib_definition_for_0;
-                    (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
+                    (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
                         kind: 0 /* FilePreprocessingReferencedDiagnostic */,
                         reason: { kind: ts.FileIncludeKind.LibReferenceDirective, file: file.path, index: index, },
                         diagnostic: diagnostic,
@@ -120097,14 +119734,13 @@ var ts;
                 for (var index = 0; index < moduleNames.length; index++) {
                     var resolution = resolutions[index];
                     ts.setResolvedModule(file, moduleNames[index], resolution, getModeForResolutionAtIndex(file, index));
-                    addResolutionDiagnostics(resolution);
-                    if (!resolution.resolvedModule) {
+                    if (!resolution) {
                         continue;
                     }
-                    var isFromNodeModulesSearch = resolution.resolvedModule.isExternalLibraryImport;
-                    var isJsFile = !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension);
+                    var isFromNodeModulesSearch = resolution.isExternalLibraryImport;
+                    var isJsFile = !ts.resolutionExtensionIsTSOrJson(resolution.extension);
                     var isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile;
-                    var resolvedFileName = resolution.resolvedModule.resolvedFileName;
+                    var resolvedFileName = resolution.resolvedFileName;
                     if (isFromNodeModulesSearch) {
                         currentNodeModulesDepth++;
                     }
@@ -120117,7 +119753,7 @@ var ts;
                     // Don't add the file if it has a bad extension (e.g. 'tsx' if we don't have '--allowJs')
                     // This may still end up being an untyped module -- the file won't be included but imports will be allowed.
                     var shouldAddFile = resolvedFileName
-                        && !getResolutionDiagnostic(optionsForFile, resolution.resolvedModule)
+                        && !getResolutionDiagnostic(optionsForFile, resolution)
                         && !optionsForFile.noResolve
                         && index < file.imports.length
                         && !elideImport
@@ -120129,7 +119765,7 @@ var ts;
                     else if (shouldAddFile) {
                         findSourceFile(resolvedFileName, 
                         /*isDefaultLib*/ false, 
-                        /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.Import, file: file.path, index: index, }, resolution.resolvedModule.packageId);
+                        /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.Import, file: file.path, index: index, }, resolution.packageId);
                     }
                     if (isFromNodeModulesSearch) {
                         currentNodeModulesDepth--;
@@ -120233,9 +119869,6 @@ var ts;
                     createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_incremental_compilation, "declaration");
                 }
             }
-            if (options.cacheResolutions && !ts.isIncrementalCompilation(options)) {
-                createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "cacheResolutions", "incremental", "composite");
-            }
             var outputFile = ts.outFile(options);
             if (options.tsBuildInfoFile) {
                 if (!ts.isIncrementalCompilation(options)) {
@@ -120504,7 +120137,7 @@ var ts;
             }
         }
         function addFilePreprocessingFileExplainingDiagnostic(file, fileProcessingReason, diagnostic, args) {
-            (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
+            (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
                 kind: 1 /* FilePreprocessingFileExplainingDiagnostic */,
                 file: file && file.path,
                 fileProcessingReason: fileProcessingReason,
@@ -120772,8 +120405,8 @@ var ts;
             if (!symlinks) {
                 symlinks = ts.createSymlinkCache(currentDirectory, getCanonicalFileName);
             }
-            if (files && automaticTypeDirectiveResolutions && !symlinks.hasProcessedResolutions()) {
-                symlinks.setSymlinksFromResolutions(files, automaticTypeDirectiveResolutions);
+            if (files && resolvedTypeReferenceDirectives && !symlinks.hasProcessedResolutions()) {
+                symlinks.setSymlinksFromResolutions(files, resolvedTypeReferenceDirectives);
             }
             return symlinks;
         }
@@ -121186,8 +120819,7 @@ var ts;
             }
             // Handle type reference directives
             if (sourceFile.resolvedTypeReferenceDirectiveNames) {
-                sourceFile.resolvedTypeReferenceDirectiveNames.forEach(function (_a) {
-                    var resolvedTypeReferenceDirective = _a.resolvedTypeReferenceDirective;
+                sourceFile.resolvedTypeReferenceDirectiveNames.forEach(function (resolvedTypeReferenceDirective) {
                     if (!resolvedTypeReferenceDirective) {
                         return;
                     }
@@ -121246,13 +120878,12 @@ var ts;
         /**
          * Creates the state of file references and signature for the new program from oldState if it is safe
          */
-        function create(newProgram, oldState, disableUseFileVersionAsSignature) {
+        function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
             var _a, _b, _c;
             var fileInfos = new ts.Map();
             var referencedMap = newProgram.getCompilerOptions().module !== ts.ModuleKind.None ? createManyToManyPathMap() : undefined;
             var exportedModulesMap = referencedMap ? createManyToManyPathMap() : undefined;
             var useOldState = canReuseOldState(referencedMap, oldState);
-            var getCanonicalFileName = ts.createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames());
             // Ensure source files have parent pointers set
             newProgram.getTypeChecker();
             // Create the reference map, and set the file infos
@@ -121305,23 +120936,23 @@ var ts;
         /**
          * Gets the files affected by the path from the program
          */
-        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, host) {
+        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) {
             var _a, _b;
-            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, host);
+            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName);
             (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear();
             (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
             return result;
         }
         BuilderState.getFilesAffectedBy = getFilesAffectedBy;
-        function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, host) {
+        function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) {
             var sourceFile = programOfThisState.getSourceFileByPath(path);
             if (!sourceFile) {
                 return ts.emptyArray;
             }
-            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host)) {
+            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
                 return [sourceFile];
             }
-            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
+            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName);
         }
         BuilderState.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
         function updateSignatureOfFile(state, signature, path) {
@@ -121332,7 +120963,7 @@ var ts;
         /**
          * Returns if the shape of the signature has changed since last emit
          */
-        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host, useFileVersionAsSignature) {
+        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName, useFileVersionAsSignature) {
             var _a;
             if (useFileVersionAsSignature === void 0) { useFileVersionAsSignature = state.useFileVersionAsSignature; }
             // If we have cached the result for this file, that means hence forth we should assume file shape is uptodate
@@ -121344,7 +120975,7 @@ var ts;
             if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
                 programOfThisState.emit(sourceFile, function (fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) {
                     ts.Debug.assert(ts.isDeclarationFileName(fileName), "File extension for signature expected to be dts: Got:: " + fileName);
-                    latestSignature = ts.computeSignatureWithDiagnostics(sourceFile, text, host, ts.createGetCanonicalFileName(programOfThisState.useCaseSensitiveFileNames()), data);
+                    latestSignature = ts.computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanonicalFileName, data);
                     if (latestSignature !== prevSignature) {
                         updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
                     }
@@ -121523,7 +121154,7 @@ var ts;
         /**
          * When program emits modular code, gets the files affected by the sourceFile whose shape has changed
          */
-        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, host) {
+        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash, getCanonicalFileName) {
             if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
                 return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
             }
@@ -121543,7 +121174,7 @@ var ts;
                 if (!seenFileNamesMap.has(currentPath)) {
                     var currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
                     seenFileNamesMap.set(currentPath, currentSourceFile);
-                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, host)) {
+                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
                         queue.push.apply(queue, getReferencedByPaths(state, currentSourceFile.resolvedPath));
                     }
                 }
@@ -121568,9 +121199,9 @@ var ts;
     /**
      * Create the state so that we can iterate on changedFiles/affected files
      */
-    function createBuilderProgramState(newProgram, oldState, disableUseFileVersionAsSignature) {
+    function createBuilderProgramState(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
         var _a, _b;
-        var state = ts.BuilderState.create(newProgram, oldState, disableUseFileVersionAsSignature);
+        var state = ts.BuilderState.create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature);
         state.program = newProgram;
         var compilerOptions = newProgram.getCompilerOptions();
         state.compilerOptions = compilerOptions;
@@ -121634,7 +121265,7 @@ var ts;
                 // Unchanged file copy diagnostics
                 var diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
                 if (diagnostics) {
-                    state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : diagnostics);
+                    state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) : diagnostics);
                     if (!state.semanticDiagnosticsFromOldState) {
                         state.semanticDiagnosticsFromOldState = new ts.Set();
                     }
@@ -121659,16 +121290,13 @@ var ts;
             state.seenAffectedFiles = state.seenAffectedFiles || new ts.Set();
         }
         // Since old states change files set is copied, any additional change means we would need to emit build info
-        state.buildInfoEmitPending = !useOldState ||
-            state.changedFilesSet.size !== (((_b = oldState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.size) || 0) ||
-            state.fileInfos.size !== oldState.fileInfos.size;
+        state.buildInfoEmitPending = !useOldState || state.changedFilesSet.size !== (((_b = oldState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.size) || 0);
         return state;
     }
-    function convertToDiagnostics(diagnostics, newProgram) {
+    function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) {
         if (!diagnostics.length)
             return ts.emptyArray;
-        var buildInfoDirectory;
-        var getCanonicalFileName;
+        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
         return diagnostics.map(function (diagnostic) {
             var result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath);
             result.reportsUnnecessary = diagnostic.reportsUnnecessary;
@@ -121684,8 +121312,7 @@ var ts;
             return result;
         });
         function toPath(path) {
-            buildInfoDirectory !== null && buildInfoDirectory !== void 0 ? buildInfoDirectory : (buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory())));
-            return ts.toPath(path, buildInfoDirectory, getCanonicalFileName !== null && getCanonicalFileName !== void 0 ? getCanonicalFileName : (getCanonicalFileName = ts.createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames())));
+            return ts.toPath(path, buildInfoDirectory, getCanonicalFileName);
         }
     }
     function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath) {
@@ -121697,9 +121324,6 @@ var ts;
      */
     function releaseCache(state) {
         ts.BuilderState.releaseCache(state);
-        // Store the resolutions if possible
-        if (!state.resuableCacheResolutions)
-            getCacheResolutions(state);
         state.program = undefined;
     }
     function backupBuilderProgramEmitState(state) {
@@ -121744,7 +121368,7 @@ var ts;
      * This is to allow the callers to be able to actually remove affected file only when the operation is complete
      * eg. if during diagnostics check cancellation token ends up cancelling the request, the affected file should be retained
      */
-    function getNextAffectedFile(state, cancellationToken, host) {
+    function getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a, _b;
         while (true) {
             var affectedFiles = state.affectedFiles;
@@ -121756,7 +121380,7 @@ var ts;
                     if (!seenAffectedFiles.has(affectedFile.resolvedPath)) {
                         // Set the next affected file as seen and remove the cached semantic diagnostics
                         state.affectedFilesIndex = affectedFilesIndex;
-                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, host);
+                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host);
                         return affectedFile;
                     }
                     affectedFilesIndex++;
@@ -121784,7 +121408,7 @@ var ts;
                 return program;
             }
             // Get next batch of affected files
-            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, host);
+            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, computeHash, getCanonicalFileName);
             state.currentChangedFilePath = nextKey.value;
             state.affectedFilesIndex = 0;
             if (!state.seenAffectedFiles)
@@ -121835,7 +121459,7 @@ var ts;
      *  Handles semantic diagnostics and dts emit for affectedFile and files, that are referencing modules that export entities from affected file
      *  This is because even though js emit doesnt change, dts emit / type used can change resulting in need for dts emit and js change
      */
-    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, host) {
+    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
         removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
         // If affected files is everything except default library, then nothing more to do
         if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
@@ -121843,18 +121467,18 @@ var ts;
             // When a change affects the global scope, all files are considered to be affected without updating their signature
             // That means when affected file is handled, its signature can be out of date
             // To avoid this, ensure that we update the signature for any affected file in this scenario.
-            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, host);
+            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, computeHash, getCanonicalFileName);
             return;
         }
         if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
             return;
-        handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host);
+        handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host);
     }
     /**
      * Handle the dts may change, so they need to be added to pending emit if dts emit is enabled,
      * Also we need to make sure signature is updated for these files
      */
-    function handleDtsMayChangeOf(state, path, cancellationToken, host) {
+    function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, getCanonicalFileName, host) {
         removeSemanticDiagnosticsOf(state, path);
         if (!state.changedFilesSet.has(path)) {
             var program = ts.Debug.checkDefined(state.program);
@@ -121865,7 +121489,7 @@ var ts;
                 // This ensures that we dont later during incremental builds considering wrong signature.
                 // Eg where this also is needed to ensure that .tsbuildinfo generated by incremental build should be same as if it was first fresh build
                 // But we avoid expensive full shape computation, as using file version as shape is enough for correctness.
-                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, host, !host.disableUseFileVersionAsSignature);
+                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, computeHash, getCanonicalFileName, !host.disableUseFileVersionAsSignature);
                 // If not dts emit, nothing more to do
                 if (ts.getEmitDeclarations(state.compilerOptions)) {
                     addToAffectedFilesPendingEmit(state, path, 0 /* DtsOnly */);
@@ -121890,20 +121514,20 @@ var ts;
         var newSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
         return newSignature !== oldSignature;
     }
-    function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host) {
+    function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a;
         if (!((_a = state.fileInfos.get(filePath)) === null || _a === void 0 ? void 0 : _a.affectsGlobalScope))
             return false;
         // Every file needs to be handled
         ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program, /*firstSourceFile*/ undefined)
-            .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, host); });
+            .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, computeHash, getCanonicalFileName, host); });
         removeDiagnosticsOfLibraryFiles(state);
         return true;
     }
     /**
      * Iterate on referencing modules that export entities from affected file and delete diagnostics and add pending emit
      */
-    function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host) {
+    function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a;
         // If there was change in signature (dts output) for the changed file,
         // then only we need to handle pending file emit
@@ -121921,9 +121545,9 @@ var ts;
                 var currentPath = queue.pop();
                 if (!seenFileNamesMap.has(currentPath)) {
                     seenFileNamesMap.set(currentPath, true);
-                    if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, host))
+                    if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host))
                         return;
-                    handleDtsMayChangeOf(state, currentPath, cancellationToken, host);
+                    handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host);
                     if (isChangedSignature(state, currentPath)) {
                         var currentSourceFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
                         queue.push.apply(queue, ts.BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
@@ -121935,11 +121559,11 @@ var ts;
         // Go through exported modules from cache first
         // If exported modules has path, all files referencing file exported from are affected
         (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, host))
+            if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, getCanonicalFileName, host))
                 return true;
             var references = state.referencedMap.getKeys(exportedFromPath);
             return references && ts.forEachKey(references, function (filePath) {
-                return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host);
+                return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host);
             });
         });
     }
@@ -121947,22 +121571,22 @@ var ts;
      * handle dts and semantic diagnostics on file and iterate on anything that exports this file
      * return true when all work is done and we can exit handling dts emit and semantic diagnostics
      */
-    function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host) {
+    function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a, _b;
         if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath))
             return undefined;
-        if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host))
+        if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host))
             return true;
-        handleDtsMayChangeOf(state, filePath, cancellationToken, host);
+        handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host);
         // If exported modules has path, all files referencing file exported from are affected
         (_a = state.exportedModulesMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, host);
+            return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host);
         });
         // Remove diagnostics of files that import this file (without going to exports of referencing files)
         (_b = state.referencedMap.getKeys(filePath)) === null || _b === void 0 ? void 0 : _b.forEach(function (referencingFilePath) {
             return !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file
                 handleDtsMayChangeOf(// Dont add to seen since this is not yet done with the export removal
-                state, referencingFilePath, cancellationToken, host);
+                state, referencingFilePath, cancellationToken, computeHash, getCanonicalFileName, host);
         });
         return undefined;
     }
@@ -122041,46 +121665,35 @@ var ts;
     /**
      * Gets the program information to be emitted in buildInfo so that we can use it to create new program
      */
-    function getProgramBuildInfo(state, host) {
+    function getProgramBuildInfo(state, getCanonicalFileName) {
         var outFilePath = ts.outFile(state.compilerOptions);
-        if (outFilePath && !state.compilerOptions.composite && !state.compilerOptions.cacheResolutions)
+        if (outFilePath && !state.compilerOptions.composite)
             return;
         var currentDirectory = ts.Debug.checkDefined(state.program).getCurrentDirectory();
-        var getCanonicalFileName = ts.createGetCanonicalFileName(state.program.useCaseSensitiveFileNames());
-        var buildInfoPath = ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory);
-        var buildInfoDirectory = ts.getDirectoryPath(buildInfoPath);
+        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
         // Convert the file name to Path here if we set the fileName instead to optimize multiple d.ts file emits and having to compute Canonical path
         var latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : undefined;
-        var fileNames = [];
-        var fileNameToFileId = new ts.Map();
-        var resolutions;
-        var names;
-        var resolutionNameToResolutionNameId;
-        var resolutionEntries;
-        var resolutionEntryToResolutionEntryId;
-        var affectedFilesHash;
         if (outFilePath) {
-            var fileInfos_1;
-            if (state.compilerOptions.composite) {
-                state.program.getRootFileNames().forEach(function (f) {
-                    var sourceFile = state.program.getSourceFile(f);
-                    if (!sourceFile)
-                        return;
-                    var fileId = toFileId(sourceFile.resolvedPath);
-                    (fileInfos_1 !== null && fileInfos_1 !== void 0 ? fileInfos_1 : (fileInfos_1 = []))[fileId - 1] = sourceFile.version;
-                });
-            }
-            var cacheResolutions_1 = toProgramBuildInfoCacheResolutions();
-            var result_16 = {
-                fileNames: fileNames,
+            var fileNames_1 = [];
+            var fileInfos_1 = [];
+            state.program.getRootFileNames().forEach(function (f) {
+                var sourceFile = state.program.getSourceFile(f);
+                if (!sourceFile)
+                    return;
+                fileNames_1.push(relativeToBuildInfo(sourceFile.resolvedPath));
+                fileInfos_1.push(sourceFile.version);
+            });
+            var result_15 = {
+                fileNames: fileNames_1,
                 fileInfos: fileInfos_1,
-                options: toProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo", !!state.compilerOptions.cacheResolutions),
+                options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
                 outSignature: state.outSignature,
                 latestChangedDtsFile: latestChangedDtsFile,
-                cacheResolutions: cacheResolutions_1,
             };
-            return result_16;
+            return result_15;
         }
+        var fileNames = [];
+        var fileNameToFileId = new ts.Map();
         var fileIdsList;
         var fileNamesToFileIdListId;
         var emitSignatures;
@@ -122144,7 +121757,7 @@ var ts;
                 (semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(value.length ?
                     [
                         toFileId(key),
-                        value.map(toReusableDiagnostic)
+                        convertToReusableDiagnostics(value, relativeToBuildInfo)
                     ] :
                     toFileId(key));
             }
@@ -122166,11 +121779,10 @@ var ts;
                 (changeFileSet || (changeFileSet = [])).push(toFileId(path));
             }
         }
-        var cacheResolutions = toProgramBuildInfoCacheResolutions();
         var result = {
             fileNames: fileNames,
             fileInfos: fileInfos,
-            options: toProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsMultiFileEmitBuildInfo", !!state.compilerOptions.cacheResolutions),
+            options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsMultiFileEmitBuildInfo"),
             fileIdsList: fileIdsList,
             referencedMap: referencedMap,
             exportedModulesMap: exportedModulesMap,
@@ -122179,7 +121791,6 @@ var ts;
             changeFileSet: changeFileSet,
             emitSignatures: emitSignatures,
             latestChangedDtsFile: latestChangedDtsFile,
-            cacheResolutions: cacheResolutions,
         };
         return result;
         function relativeToBuildInfoEnsuringAbsolutePath(path) {
@@ -122188,7 +121799,7 @@ var ts;
         function relativeToBuildInfo(path) {
             return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(buildInfoDirectory, path, getCanonicalFileName));
         }
-        function toFileAndAbsoluteFileId(path) {
+        function toFileId(path) {
             var fileId = fileNameToFileId.get(path);
             if (fileId === undefined) {
                 fileNames.push(relativeToBuildInfo(path));
@@ -122196,12 +121807,6 @@ var ts;
             }
             return fileId;
         }
-        function toFileId(path) {
-            return toFileAndAbsoluteFileId(path);
-        }
-        function toAbsoluteFileId(path) {
-            return toFileAndAbsoluteFileId(ts.getNormalizedAbsolutePath(path, currentDirectory));
-        }
         function toFileIdListId(set) {
             var fileIds = ts.arrayFrom(set.keys(), toFileId).sort(ts.compareValues);
             var key = fileIds.join();
@@ -122214,241 +121819,54 @@ var ts;
         }
         /**
          * @param optionKey key of CommandLineOption to use to determine if the option should be serialized in tsbuildinfo
-         * @param affectsModuleResolution serialize options affecting module resolution
          */
-        function toProgramBuildInfoCompilerOptions(options, optionKey, affectsModuleResolution) {
+        function convertToProgramBuildInfoCompilerOptions(options, optionKey) {
             var result;
             var optionsNameMap = ts.getOptionsNameMap().optionsNameMap;
             for (var _i = 0, _a = ts.getOwnKeys(options).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) {
                 var name = _a[_i];
                 var optionInfo = optionsNameMap.get(name.toLowerCase());
-                if ((optionKey && (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo[optionKey])) || (affectsModuleResolution && (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo.affectsModuleResolution))) {
-                    (result !== null && result !== void 0 ? result : (result = {}))[name] = toReusableCompilerOptionValue(optionInfo, options[name]);
-                }
-                else if (affectsModuleResolution && name === "pathsBasePath") {
-                    (result !== null && result !== void 0 ? result : (result = {})).pathsBasePath = relativeToBuildInfoEnsuringAbsolutePath(options.pathsBasePath);
-                    continue;
+                if (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo[optionKey]) {
+                    (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfoEnsuringAbsolutePath);
                 }
             }
             return result;
         }
-        function toReusableCompilerOptionValue(option, value) {
-            if (option) {
-                if (option.type === "list") {
-                    var values = value;
-                    if (option.element.isFilePath && values.length) {
-                        return values.map(relativeToBuildInfoEnsuringAbsolutePath);
-                    }
-                }
-                else if (option.isFilePath) {
-                    return relativeToBuildInfoEnsuringAbsolutePath(value);
+    }
+    function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
+        if (option) {
+            if (option.type === "list") {
+                var values = value;
+                if (option.element.isFilePath && values.length) {
+                    return values.map(relativeToBuildInfo);
                 }
             }
-            return value;
-        }
-        function toReadonlyArrayOrUndefined(array, map) {
-            return (array === null || array === void 0 ? void 0 : array.length) ? array.map(map) : undefined;
+            else if (option.isFilePath) {
+                return relativeToBuildInfo(value);
+            }
         }
-        function toReusableDiagnostic(diagnostic) {
-            var result = toReusableDiagnosticRelatedInformation(diagnostic);
+        return value;
+    }
+    function convertToReusableDiagnostics(diagnostics, relativeToBuildInfo) {
+        ts.Debug.assert(!!diagnostics.length);
+        return diagnostics.map(function (diagnostic) {
+            var result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
             result.reportsUnnecessary = diagnostic.reportsUnnecessary;
             result.reportDeprecated = diagnostic.reportsDeprecated;
             result.source = diagnostic.source;
             result.skippedOn = diagnostic.skippedOn;
             var relatedInformation = diagnostic.relatedInformation;
-            result.relatedInformation = relatedInformation === null || relatedInformation === void 0 ? void 0 : relatedInformation.map(toReusableDiagnosticRelatedInformation);
-            return result;
-        }
-        function toReusableDiagnosticRelatedInformation(diagnostic) {
-            var file = diagnostic.file;
-            return __assign(__assign({}, diagnostic), { file: file ? relativeToBuildInfo(file.resolvedPath) : undefined });
-        }
-        function toProgramBuildInfoCacheResolutions() {
-            var cacheResolutions = getCacheResolutions(state);
-            var modules = toProgramBuildInfoResolutionCacheWithRedirects(cacheResolutions === null || cacheResolutions === void 0 ? void 0 : cacheResolutions.modules);
-            var typeRefs = toProgramBuildInfoResolutionCacheWithRedirects(cacheResolutions === null || cacheResolutions === void 0 ? void 0 : cacheResolutions.typeRefs);
-            if (!resolutions)
-                return;
-            ts.Debug.assertIsDefined(names);
-            ts.Debug.assertIsDefined(resolutionEntries);
-            state.resuableCacheResolutions = {
-                cache: {
-                    resolutions: resolutions.map(toProgramBuildInfoResolution),
-                    names: names,
-                    hash: toProgramBuildInfoHashes(),
-                    resolutionEntries: resolutionEntries,
-                    modules: modules,
-                    typeRefs: typeRefs,
-                },
-                getProgramBuildInfoFilePathDecoder: ts.memoize(function () { return getProgramBuildInfoFilePathDecoder(fileNames, buildInfoPath, currentDirectory, getCanonicalFileName); })
-            };
-            return state.resuableCacheResolutions.cache;
-        }
-        function toProgramBuildInfoResolutionCacheWithRedirects(cache) {
-            if (!cache)
-                return undefined;
-            var ownMap = cache.getOwnMap();
-            var own = toProgramBuildInfoResolutionCache(ownMap);
-            var redirects;
-            cache.redirectsKeyToCache.forEach(function (_a) {
-                var map = _a.map, options = _a.options;
-                if (map === ownMap)
-                    return;
-                var redirectCache = toProgramBuildInfoResolutionCache(map);
-                if (redirectCache) {
-                    (redirects !== null && redirects !== void 0 ? redirects : (redirects = [])).push({
-                        options: toProgramBuildInfoCompilerOptions(options, /*optionKey*/ undefined, /*affectsModuleResolution*/ true),
-                        cache: redirectCache
-                    });
-                }
-            });
-            return !redirects ? own : { own: own, redirects: redirects };
-        }
-        function toProgramBuildInfoResolutionCache(cache) {
-            var result;
-            cache === null || cache === void 0 ? void 0 : cache.forEach(function (dirCache, dirPath) { return dirCache.size() ?
-                (result !== null && result !== void 0 ? result : (result = [])).push([
-                    toFileId(dirPath),
-                    ts.arrayFrom(dirCache.entries()).map(toProgramBuildInfoResolutionEntryId)
-                ]) :
-                undefined; });
+            result.relatedInformation = relatedInformation ?
+                relatedInformation.length ?
+                    relatedInformation.map(function (r) { return convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo); }) :
+                    [] :
+                undefined;
             return result;
-        }
-        function toProgramBuildInfoResolutionEntryId(_a) {
-            var name = _a[0], mode = _a[1], resolution = _a[2];
-            var resolutionNameId = toProgramBuildInfoResolutionNameId(name);
-            var resolutionId = toProgramBuildInfoResolutionId(resolution);
-            var key = resolutionNameId + "," + mode + "," + resolutionId;
-            var resolutionEntryId = resolutionEntryToResolutionEntryId === null || resolutionEntryToResolutionEntryId === void 0 ? void 0 : resolutionEntryToResolutionEntryId.get(key);
-            if (resolutionEntryId === undefined) {
-                (resolutionEntries || (resolutionEntries = [])).push(mode ? [resolutionNameId, resolutionId, mode] : [resolutionNameId, resolutionId]);
-                (resolutionEntryToResolutionEntryId || (resolutionEntryToResolutionEntryId = new ts.Map())).set(key, resolutionEntryId = resolutionEntries.length);
-            }
-            return resolutionEntryId;
-        }
-        function toProgramBuildInfoResolutionNameId(name) {
-            var resolutionNameId = resolutionNameToResolutionNameId === null || resolutionNameToResolutionNameId === void 0 ? void 0 : resolutionNameToResolutionNameId.get(name);
-            if (resolutionNameId === undefined) {
-                (names !== null && names !== void 0 ? names : (names = [])).push(name);
-                (resolutionNameToResolutionNameId !== null && resolutionNameToResolutionNameId !== void 0 ? resolutionNameToResolutionNameId : (resolutionNameToResolutionNameId = new ts.Map())).set(name, resolutionNameId = names.length);
-            }
-            return resolutionNameId;
-        }
-        function toProgramBuildInfoResolutionId(resolution) {
-            if (resolution.serializationIndex === undefined) {
-                (resolutions !== null && resolutions !== void 0 ? resolutions : (resolutions = [])).push(resolution);
-                resolution.serializationIndex = resolutions.length;
-            }
-            return resolution.serializationIndex;
-        }
-        function toProgramBuildInfoResolution(resolution) {
-            resolution.serializationIndex = undefined;
-            return {
-                resolvedModule: toProgramBuildInfoResolved(resolution.resolvedModule),
-                resolvedTypeReferenceDirective: toProgramBuildInfoResolved(resolution.resolvedTypeReferenceDirective),
-                affectingLocations: toReadonlyArrayOrUndefined(resolution.affectingLocations, toAffectedFileId),
-                resolutionDiagnostics: toReadonlyArrayOrUndefined(resolution.resolutionDiagnostics, toProgramBuildInfoResolutionDiagnostic),
-            };
-        }
-        function toProgramBuildInfoHashes() {
-            if (!affectedFilesHash)
-                return undefined;
-            var hashes = [];
-            for (var _i = 0, _a = ts.arrayFrom(affectedFilesHash.keys()).sort(ts.compareValues); _i < _a.length; _i++) {
-                var key = _a[_i];
-                var value = affectedFilesHash.get(key);
-                hashes.push(value ? [key, value] : key);
-            }
-            return hashes;
-        }
-        function toAffectedFileId(file) {
-            var _a;
-            var fileId = toAbsoluteFileId(file);
-            if (!(affectedFilesHash === null || affectedFilesHash === void 0 ? void 0 : affectedFilesHash.has(fileId))) {
-                // Store the file hash
-                var packageJsonInfo = (_a = state.program.getModuleResolutionCache()) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfo(file);
-                var text = typeof packageJsonInfo === "object" ? packageJsonInfo.packageJsonText : undefined;
-                (affectedFilesHash !== null && affectedFilesHash !== void 0 ? affectedFilesHash : (affectedFilesHash = new ts.Map())).set(fileId, text ? computeSignature(text, host) : undefined);
-            }
-            return fileId;
-        }
-        function toProgramBuildInfoResolved(resolved) {
-            return resolved ? __assign(__assign({}, resolved), { resolvedFileName: toAbsoluteFileId(resolved.resolvedFileName), isExternalLibraryImport: resolved.isExternalLibraryImport ? true : undefined, originalPath: resolved.originalPath ? toAbsoluteFileId(resolved.originalPath) : undefined, primary: resolved.primary || undefined, extension: undefined }) : undefined;
-        }
-        function toProgramBuildInfoResolutionDiagnostic(d) {
-            return {
-                isImports: d.isImports || undefined,
-                entry: d.entry || undefined,
-                packagePath: toAbsoluteFileId(d.packagePath),
-            };
-        }
-    }
-    function getCacheResolutions(state) {
-        var _a;
-        if (state.cacheResolutions || !state.compilerOptions.cacheResolutions)
-            return state.cacheResolutions;
-        var modules;
-        var typeRefs;
-        var moduleNameToDirectoryMap = ts.createCacheWithRedirects(state.compilerOptions);
-        var getCanonicalFileName = ts.createGetCanonicalFileName(state.program.useCaseSensitiveFileNames());
-        state.program.getSourceFiles().forEach(function (f) {
-            modules = toPerDirectoryCache(state, getCanonicalFileName, modules, f, f.resolvedModules, moduleNameToDirectoryMap);
-            typeRefs = toPerDirectoryCache(state, getCanonicalFileName, typeRefs, f, f.resolvedTypeReferenceDirectiveNames);
         });
-        var automaticTypeDirectiveNames = state.program.getAutomaticTypeDirectiveNames();
-        if (automaticTypeDirectiveNames.length) {
-            var currentDirectory = state.program.getCurrentDirectory();
-            var containingPath = ts.toPath(state.program.getAutomaticTypeDirectiveContainingFile(), currentDirectory, getCanonicalFileName);
-            typeRefs = toPerDirectoryCache(state, getCanonicalFileName, typeRefs, containingPath, state.program.getAutomaticTypeDirectiveResolutions());
-        }
-        return state.cacheResolutions = {
-            modules: modules,
-            typeRefs: typeRefs,
-            moduleNameToDirectoryMap: moduleNameToDirectoryMap,
-            packageJsonCache: (_a = state.program.getModuleResolutionCache()) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfoCache().clone(),
-        };
     }
-    function toPerDirectoryCache(state, getCanonicalFileName, cacheWithRedirects, fOrPath, cache, moduleNameToDirectoryMap) {
-        if (!(cache === null || cache === void 0 ? void 0 : cache.size()))
-            return cacheWithRedirects;
-        var dirPath, redirectedReference;
-        if (!ts.isString(fOrPath)) {
-            redirectedReference = state.program.getRedirectReferenceForResolution(fOrPath);
-            dirPath = ts.getDirectoryPath(fOrPath.path);
-        }
-        else {
-            dirPath = ts.getDirectoryPath(fOrPath);
-        }
-        var perDirResolutionCache = cacheWithRedirects === null || cacheWithRedirects === void 0 ? void 0 : cacheWithRedirects.getMapOfCacheRedirects(redirectedReference);
-        var dirCache = perDirResolutionCache === null || perDirResolutionCache === void 0 ? void 0 : perDirResolutionCache.get(dirPath);
-        cache.forEach(function (resolution, name, mode) {
-            var _a, _b, _c, _d;
-            if (!((_a = resolution.resolvedModule) === null || _a === void 0 ? void 0 : _a.resolvedFileName) && !((_b = resolution.resolvedTypeReferenceDirective) === null || _b === void 0 ? void 0 : _b.resolvedFileName))
-                return;
-            if (dirCache === null || dirCache === void 0 ? void 0 : dirCache.has(name, mode))
-                return;
-            // If there was already external module resolution that is same, set for child directory, dont set resolution for this directory
-            if (moduleNameToDirectoryMap &&
-                !ts.isExternalModuleNameRelative(name) &&
-                ((_d = (_c = moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) === null || _c === void 0 ? void 0 : _c.get(ts.getModeAwareCacheKey(name, mode))) === null || _d === void 0 ? void 0 : _d.get(dirPath))) {
-                return;
-            }
-            if (!dirCache) {
-                perDirResolutionCache !== null && perDirResolutionCache !== void 0 ? perDirResolutionCache : (perDirResolutionCache = (cacheWithRedirects !== null && cacheWithRedirects !== void 0 ? cacheWithRedirects : (cacheWithRedirects = ts.createCacheWithRedirects(state.compilerOptions))).getOrCreateMapOfCacheRedirects(redirectedReference));
-                perDirResolutionCache.set(dirPath, dirCache = ts.createModeAwareCache());
-            }
-            dirCache.set(name, mode, resolution);
-            if (!moduleNameToDirectoryMap || ts.isExternalModuleNameRelative(name))
-                return;
-            // put result in per-module name cache and delete everything that is not needed
-            var actualModuleNameToDirectoryMap = moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(redirectedReference);
-            var key = ts.getModeAwareCacheKey(name, mode);
-            var directoryPathMap = actualModuleNameToDirectoryMap.get(key);
-            if (!directoryPathMap)
-                actualModuleNameToDirectoryMap.set(key, directoryPathMap = new ts.Map());
-            ts.moduleNameToDirectorySet(directoryPathMap, dirPath, resolution, ts.getResolvedFileNameForModuleNameToDirectorySet, function (dir) { return ts.toPath(dir, state.program.getCurrentDirectory(), getCanonicalFileName); }, function (ancestorPath) { var _a; return (_a = perDirResolutionCache === null || perDirResolutionCache === void 0 ? void 0 : perDirResolutionCache.get(ancestorPath)) === null || _a === void 0 ? void 0 : _a.delete(name, mode); });
-        });
-        return cacheWithRedirects;
+    function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) {
+        var file = diagnostic.file;
+        return __assign(__assign({}, diagnostic), { file: file ? relativeToBuildInfo(file.resolvedPath) : undefined });
     }
     var BuilderProgramKind;
     (function (BuilderProgramKind) {
@@ -122472,7 +121890,7 @@ var ts;
                 rootNames: newProgramOrRootNames,
                 options: hostOrOptions,
                 host: oldProgramOrHost,
-                oldProgram: oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getProgramOrOldBuildInfoProgramUndefined(),
+                oldProgram: oldProgram && oldProgram.getProgramOrUndefined(),
                 configFileParsingDiagnostics: configFileParsingDiagnostics,
                 projectReferences: projectReferences
             });
@@ -122490,8 +121908,8 @@ var ts;
     function getTextHandlingSourceMapForSignature(text, data) {
         return (data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text;
     }
-    function computeSignatureWithDiagnostics(sourceFile, text, host, getCanonicalFileName, data) {
-        var _a, _b;
+    function computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanonicalFileName, data) {
+        var _a;
         text = getTextHandlingSourceMapForSignature(text, data);
         var sourceFileDirectory;
         if ((_a = data === null || data === void 0 ? void 0 : data.diagnostics) === null || _a === void 0 ? void 0 : _a.length) {
@@ -122499,7 +121917,7 @@ var ts;
                 return "" + locationInfo(diagnostic) + ts.DiagnosticCategory[diagnostic.category] + diagnostic.code + ": " + flattenDiagnosticMessageText(diagnostic.messageText);
             }).join("\n");
         }
-        return ((_b = host.createHash) !== null && _b !== void 0 ? _b : ts.generateDjb2Hash)(text);
+        return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(text);
         function flattenDiagnosticMessageText(diagnostic) {
             return ts.isString(diagnostic) ?
                 diagnostic :
@@ -122518,9 +121936,8 @@ var ts;
         }
     }
     ts.computeSignatureWithDiagnostics = computeSignatureWithDiagnostics;
-    function computeSignature(text, host, data) {
-        var _a;
-        return ((_a = host.createHash) !== null && _a !== void 0 ? _a : ts.generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
+    function computeSignature(text, computeHash, data) {
+        return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
     }
     ts.computeSignature = computeSignature;
     function createBuilderProgram(kind, _a) {
@@ -122532,8 +121949,16 @@ var ts;
             oldState = undefined;
             return oldProgram;
         }
-        var state = createBuilderProgramState(newProgram, oldState, host.disableUseFileVersionAsSignature);
-        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, host); };
+        /**
+         * Create the canonical file name for identity
+         */
+        var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
+        /**
+         * Computing hash to for signature verification
+         */
+        var computeHash = ts.maybeBind(host, host.createHash);
+        var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature);
+        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); };
         // To ensure that we arent storing any references to old program or new program without state
         newProgram = undefined; // TODO: GH#18217
         oldProgram = undefined;
@@ -122548,7 +121973,6 @@ var ts;
         builderProgram.getSemanticDiagnostics = getSemanticDiagnostics;
         builderProgram.emit = emit;
         builderProgram.releaseProgram = function () { return releaseCache(state); };
-        builderProgram.getProgramOrOldBuildInfoProgramUndefined = createGetProgramOrOldBuildInfoProgramUndefined(state);
         if (kind === BuilderProgramKind.SemanticDiagnosticsBuilderProgram) {
             builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
         }
@@ -122575,7 +121999,7 @@ var ts;
          * in that order would be used to write the files
          */
         function emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
-            var affected = getNextAffectedFile(state, cancellationToken, host);
+            var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
             var emitKind = 1 /* Full */;
             var isPendingEmitFile = false;
             if (!affected) {
@@ -122621,7 +122045,7 @@ var ts;
                             var file = sourceFiles[0];
                             var info = state.fileInfos.get(file.resolvedPath);
                             if (info.signature === file.version) {
-                                var signature = computeSignatureWithDiagnostics(file, text, host, ts.createGetCanonicalFileName(state.program.useCaseSensitiveFileNames()), data);
+                                var signature = computeSignatureWithDiagnostics(file, text, computeHash, getCanonicalFileName, data);
                                 // With d.ts diagnostics they are also part of the signature so emitSignature will be different from it since its just hash of d.ts
                                 if (!((_a = data === null || data === void 0 ? void 0 : data.diagnostics) === null || _a === void 0 ? void 0 : _a.length))
                                     emitSignature = signature;
@@ -122651,7 +122075,7 @@ var ts;
                         if (state.compilerOptions.composite) {
                             var filePath = sourceFiles[0].resolvedPath;
                             var oldSignature = (_f = state.emitSignatures) === null || _f === void 0 ? void 0 : _f.get(filePath);
-                            emitSignature !== null && emitSignature !== void 0 ? emitSignature : (emitSignature = computeSignature(text, host, data));
+                            emitSignature !== null && emitSignature !== void 0 ? emitSignature : (emitSignature = computeSignature(text, computeHash, data));
                             // Dont write dts files if they didn't change
                             if (emitSignature === oldSignature)
                                 return;
@@ -122661,7 +122085,7 @@ var ts;
                         }
                     }
                     else if (state.compilerOptions.composite) {
-                        var newSignature = computeSignature(text, host, data);
+                        var newSignature = computeSignature(text, computeHash, data);
                         // Dont write dts files if they didn't change
                         if (newSignature === state.outSignature)
                             return;
@@ -122743,7 +122167,7 @@ var ts;
          */
         function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
             while (true) {
-                var affected = getNextAffectedFile(state, cancellationToken, host);
+                var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
                 if (!affected) {
                     // Done
                     return undefined;
@@ -122823,32 +122247,12 @@ var ts;
                 { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
-    function getProgramBuildInfoFilePathDecoder(fileNames, buildInfoPath, currentDirectory, getCanonicalFileName) {
-        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, currentDirectory));
-        var filePaths;
-        var fileAbsolutePaths;
-        return { toAbsolutePath: toAbsolutePath, toFilePath: toFilePath, toFileAbsolutePath: toFileAbsolutePath, currentDirectory: currentDirectory, getCanonicalFileName: getCanonicalFileName };
-        function toPath(path) {
-            return ts.toPath(path, buildInfoDirectory, getCanonicalFileName);
-        }
-        function toAbsolutePath(path) {
-            return ts.getNormalizedAbsolutePath(path, buildInfoDirectory);
-        }
-        function toFilePath(fileId) {
-            var _a;
-            return (_a = filePaths === null || filePaths === void 0 ? void 0 : filePaths[fileId - 1]) !== null && _a !== void 0 ? _a : ((filePaths !== null && filePaths !== void 0 ? filePaths : (filePaths = new Array(fileNames.length)))[fileId - 1] = toPath(fileNames[fileId - 1]));
-        }
-        function toFileAbsolutePath(fileId) {
-            var _a;
-            return (_a = fileAbsolutePaths === null || fileAbsolutePaths === void 0 ? void 0 : fileAbsolutePaths[fileId - 1]) !== null && _a !== void 0 ? _a : ((fileAbsolutePaths !== null && fileAbsolutePaths !== void 0 ? fileAbsolutePaths : (fileAbsolutePaths = new Array(fileNames.length)))[fileId - 1] = toAbsolutePath(fileNames[fileId - 1]));
-        }
-    }
-    ts.getProgramBuildInfoFilePathDecoder = getProgramBuildInfoFilePathDecoder;
-    function createBuilderProgramUsingProgramBuildInfo(program, buildInfoPath, host, configFilePath) {
-        var _a, _b, _c;
-        var buildInfoFilePathDecoder = getProgramBuildInfoFilePathDecoder(program.fileNames, buildInfoPath, host.getCurrentDirectory(), ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()));
-        var toFilePath = buildInfoFilePathDecoder.toFilePath, toAbsolutePath = buildInfoFilePathDecoder.toAbsolutePath;
+    function createBuilderProgramUsingProgramBuildInfo(program, buildInfoPath, host) {
+        var _a, _b, _c, _d;
+        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
+        var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
         var state;
+        var filePaths;
         var filePathsSetList;
         var latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : undefined;
         if (isProgramBundleEmitBuildInfo(program)) {
@@ -122857,13 +122261,13 @@ var ts;
                 compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
                 latestChangedDtsFile: latestChangedDtsFile,
                 outSignature: program.outSignature,
-                resuableCacheResolutions: toResuableCacheResolutions(),
             };
         }
         else {
-            filePathsSetList = (_a = program.fileIdsList) === null || _a === void 0 ? void 0 : _a.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
+            filePaths = (_a = program.fileNames) === null || _a === void 0 ? void 0 : _a.map(toPath);
+            filePathsSetList = (_b = program.fileIdsList) === null || _b === void 0 ? void 0 : _b.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
             var fileInfos_2 = new ts.Map();
-            var emitSignatures_1 = ((_b = program.options) === null || _b === void 0 ? void 0 : _b.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
+            var emitSignatures_1 = ((_c = program.options) === null || _c === void 0 ? void 0 : _c.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
             program.fileInfos.forEach(function (fileInfo, index) {
                 var path = toFilePath(index + 1);
                 var stateFileInfo = toBuilderStateFileInfo(fileInfo);
@@ -122871,7 +122275,7 @@ var ts;
                 if (emitSignatures_1 && stateFileInfo.signature)
                     emitSignatures_1.set(path, stateFileInfo.signature);
             });
-            (_c = program.emitSignatures) === null || _c === void 0 ? void 0 : _c.forEach(function (value) {
+            (_d = program.emitSignatures) === null || _d === void 0 ? void 0 : _d.forEach(function (value) {
                 if (ts.isNumber(value))
                     emitSignatures_1.delete(toFilePath(value));
                 else
@@ -122890,17 +122294,14 @@ var ts;
                 changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)),
                 latestChangedDtsFile: latestChangedDtsFile,
                 emitSignatures: (emitSignatures_1 === null || emitSignatures_1 === void 0 ? void 0 : emitSignatures_1.size) ? emitSignatures_1 : undefined,
-                resuableCacheResolutions: toResuableCacheResolutions(),
             };
         }
-        state.compilerOptions.configFilePath = configFilePath;
         return {
             getState: function () { return state; },
             saveEmitState: ts.noop,
             restoreEmitState: ts.noop,
             getProgram: ts.notImplemented,
             getProgramOrUndefined: ts.returnUndefined,
-            getProgramOrOldBuildInfoProgramUndefined: createGetProgramOrOldBuildInfoProgramUndefined(state),
             releaseProgram: ts.noop,
             getCompilerOptions: function () { return state.compilerOptions; },
             getSourceFile: ts.notImplemented,
@@ -122920,6 +122321,15 @@ var ts;
             close: ts.noop,
             hasChangedEmitSignature: ts.returnFalse,
         };
+        function toPath(path) {
+            return ts.toPath(path, buildInfoDirectory, getCanonicalFileName);
+        }
+        function toAbsolutePath(path) {
+            return ts.getNormalizedAbsolutePath(path, buildInfoDirectory);
+        }
+        function toFilePath(fileId) {
+            return filePaths[fileId - 1];
+        }
         function toFilePathsSet(fileIdsListId) {
             return filePathsSetList[fileIdsListId - 1];
         }
@@ -122934,194 +122344,8 @@ var ts;
             });
             return map;
         }
-        function toResuableCacheResolutions() {
-            return program.cacheResolutions && {
-                cache: program.cacheResolutions,
-                getProgramBuildInfoFilePathDecoder: function () { return buildInfoFilePathDecoder; },
-            };
-        }
     }
     ts.createBuilderProgramUsingProgramBuildInfo = createBuilderProgramUsingProgramBuildInfo;
-    function createGetProgramOrOldBuildInfoProgramUndefined(state) {
-        return function () {
-            var _a;
-            return (_a = state.program) !== null && _a !== void 0 ? _a : (state.cacheResolutions || state.resuableCacheResolutions ?
-                (function (host) { return createOldBuildInfoProgram(host, state.compilerOptions, state.cacheResolutions, 
-                // Prefer cached resolutions over serialized format
-                !state.cacheResolutions ? state.resuableCacheResolutions : undefined); }) :
-                undefined);
-        };
-    }
-    function createOldBuildInfoProgram(host, compilerOptions, cacheResolutions, resuableCacheResolutions) {
-        if (!cacheResolutions && !resuableCacheResolutions)
-            return undefined;
-        var fileExistsMap = new ts.Map();
-        var affectingLoationsSameMap = new ts.Map();
-        var decodedResolvedModules = ts.createCacheWithRedirects(compilerOptions);
-        var decodedResolvedTypeRefs = ts.createCacheWithRedirects(compilerOptions);
-        var decodedModuleNameToDirectoryMap = ts.createCacheWithRedirects(compilerOptions);
-        var decodedHashes;
-        var resolutions;
-        var originalPathOrResolvedFileNames;
-        var resolutionEntries;
-        return {
-            getCompilerOptions: function () { return compilerOptions; },
-            getResolvedModule: function (dirPath, name, mode, redirectedReference) { return getResolvedFromCache(cacheResolutions === null || cacheResolutions === void 0 ? void 0 : cacheResolutions.modules, resuableCacheResolutions === null || resuableCacheResolutions === void 0 ? void 0 : resuableCacheResolutions.cache.modules, decodedResolvedModules, dirPath, name, mode, redirectedReference, cacheResolutions === null || cacheResolutions === void 0 ? void 0 : cacheResolutions.moduleNameToDirectoryMap, decodedModuleNameToDirectoryMap); },
-            getResolvedTypeReferenceDirective: function (dirPath, name, mode, redirectedReference) { return getResolvedFromCache(cacheResolutions === null || cacheResolutions === void 0 ? void 0 : cacheResolutions.typeRefs, resuableCacheResolutions === null || resuableCacheResolutions === void 0 ? void 0 : resuableCacheResolutions.cache.typeRefs, decodedResolvedTypeRefs, dirPath, name, mode, redirectedReference, 
-            /*moduleNameToDirectoryMap*/ undefined, 
-            /*decodedModuleNameToDirectoryMap*/ undefined); },
-        };
-        function fileExists(fileName) {
-            var result = fileExistsMap.get(fileName);
-            if (result === undefined)
-                fileExistsMap.set(fileName, result = host.fileExists(fileName));
-            return result;
-        }
-        function affectingLocationsSame(fileName, expected) {
-            var _a;
-            var result = affectingLoationsSameMap.get(fileName);
-            if (result !== undefined)
-                return result;
-            var packageJsonInfo = host.getPackageJsonInfo(fileName);
-            var currentText = typeof packageJsonInfo === "object" ? packageJsonInfo.packageJsonText : undefined;
-            if (ts.isString(expected)) {
-                result = !!currentText && ((_a = host.createHash) !== null && _a !== void 0 ? _a : ts.generateDjb2Hash)(currentText) === expected;
-            }
-            else {
-                var expectedText = typeof expected === "object" ? expected.packageJsonText : undefined;
-                result = currentText === expectedText;
-            }
-            affectingLoationsSameMap.set(fileName, result);
-            return result;
-        }
-        function getResolvedFromCache(cache, reusableCache, decodedReusableCache, dirPath, name, mode, redirectedReference, moduleNameToDirectoryMap, decodedModuleNameToDirectoryMap) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-            // If we are using the cache, directly get from there
-            var fromCache = ((_b = (_a = cache === null || cache === void 0 ? void 0 : cache.getMapOfCacheRedirects(redirectedReference)) === null || _a === void 0 ? void 0 : _a.get(dirPath)) === null || _b === void 0 ? void 0 : _b.get(name, mode)) ||
-                ((_d = (_c = moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) === null || _c === void 0 ? void 0 : _c.get(ts.getModeAwareCacheKey(name, mode))) === null || _d === void 0 ? void 0 : _d.get(dirPath));
-            if (fromCache) {
-                return fileExists(((_e = fromCache.resolvedModule) === null || _e === void 0 ? void 0 : _e.resolvedFileName) ||
-                    fromCache.resolvedTypeReferenceDirective.resolvedFileName) && ts.every(fromCache.affectingLocations, function (fileName) { var _a; return affectingLocationsSame(fileName, (_a = cacheResolutions.packageJsonCache) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfo(fileName)); }) ? fromCache : undefined;
-            }
-            if (!reusableCache)
-                return undefined;
-            // Decode so we have maps for directories
-            if (!decodedReusableCache.getOwnMap().size && !decodedReusableCache.redirectsKeyToCache.size) {
-                if (ts.isArray(reusableCache)) {
-                    setBuildInfoResolutionEntries(decodedReusableCache, compilerOptions, /*optionsKey*/ undefined, reusableCache, decodedModuleNameToDirectoryMap);
-                }
-                else {
-                    if (reusableCache.own)
-                        setBuildInfoResolutionEntries(decodedReusableCache, compilerOptions, /*optionsKey*/ undefined, reusableCache.own, decodedModuleNameToDirectoryMap);
-                    reusableCache.redirects.forEach(function (_a) {
-                        var options = _a.options, cache = _a.cache;
-                        var compilerOptions = options ? ts.convertToOptionsWithAbsolutePaths(options, resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().toAbsolutePath) : {};
-                        setBuildInfoResolutionEntries(decodedReusableCache, compilerOptions, ts.getRedirectsCacheKey(compilerOptions), cache, decodedModuleNameToDirectoryMap);
-                    });
-                }
-                // Ensure redirected reference verifies options before using redirects map
-                decodedReusableCache.clearRedirectsMap();
-                decodedModuleNameToDirectoryMap === null || decodedModuleNameToDirectoryMap === void 0 ? void 0 : decodedModuleNameToDirectoryMap.clearRedirectsMap();
-            }
-            var resolutionId = ((_g = (_f = decodedReusableCache.getMapOfCacheRedirects(redirectedReference)) === null || _f === void 0 ? void 0 : _f.get(dirPath)) === null || _g === void 0 ? void 0 : _g.get(name, mode)) ||
-                ((_j = (_h = decodedModuleNameToDirectoryMap === null || decodedModuleNameToDirectoryMap === void 0 ? void 0 : decodedModuleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) === null || _h === void 0 ? void 0 : _h.get(ts.getModeAwareCacheKey(name, mode))) === null || _j === void 0 ? void 0 : _j.get(dirPath));
-            return resolutionId ? toResolution(resolutionId) : undefined;
-        }
-        function setBuildInfoResolutionEntries(decodedReusableCache, options, optionsKey, reusableCache, decodedModuleNameToDirectoryMap) {
-            var map = decodedReusableCache.createMapForCompilerOptions(options, optionsKey);
-            reusableCache.forEach(function (_a) {
-                var dirId = _a[0], entryId = _a[1];
-                var dirPath = resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().toFilePath(dirId);
-                map.set(dirPath, toModeAwareCache(entryId, dirPath, options, optionsKey, decodedModuleNameToDirectoryMap));
-            });
-        }
-        function toModeAwareCache(entries, dirPath, options, optionsKey, decodedModuleNameToDirectoryMap) {
-            var modeAwareCache = ts.createModeAwareCache();
-            entries.forEach(function (entryId) {
-                var _a = toResolutionEntry(entryId), name = _a[0], resolutionId = _a[1], mode = _a[2];
-                modeAwareCache.set(name, mode, resolutionId);
-                if (!decodedModuleNameToDirectoryMap || ts.isExternalModuleNameRelative(name))
-                    return;
-                var mapForOptions = decodedModuleNameToDirectoryMap.createMapForCompilerOptions(options, optionsKey);
-                var key = ts.getModeAwareCacheKey(name, mode);
-                var moduleNameMap = mapForOptions.get(key);
-                ;
-                if (!moduleNameMap)
-                    mapForOptions.set(key, moduleNameMap = new ts.Map());
-                ts.moduleNameToDirectorySet(moduleNameMap, dirPath, resolutionId, toOriginalPathOrResolvedFileName, function (fileName) { return ts.toPath(fileName, resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().currentDirectory, resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().getCanonicalFileName); }, ts.noop);
-            });
-            return modeAwareCache;
-        }
-        function toResolutionEntry(entryId) {
-            var existing = resolutionEntries === null || resolutionEntries === void 0 ? void 0 : resolutionEntries[entryId - 1];
-            if (existing)
-                return existing;
-            resolutionEntries !== null && resolutionEntries !== void 0 ? resolutionEntries : (resolutionEntries = new Array(resuableCacheResolutions.cache.resolutionEntries.length));
-            var _a = resuableCacheResolutions.cache.resolutionEntries[entryId - 1], nameId = _a[0], resolutionId = _a[1], mode = _a[2];
-            return resolutionEntries[entryId - 1] = [
-                toName(nameId),
-                resolutionId,
-                mode
-            ];
-        }
-        function toName(nameId) {
-            return resuableCacheResolutions.cache.names[nameId - 1];
-        }
-        function toOriginalPathOrResolvedFileName(resolutionId) {
-            var _a;
-            return (_a = originalPathOrResolvedFileNames === null || originalPathOrResolvedFileNames === void 0 ? void 0 : originalPathOrResolvedFileNames[resolutionId - 1]) !== null && _a !== void 0 ? _a : ((originalPathOrResolvedFileNames !== null && originalPathOrResolvedFileNames !== void 0 ? originalPathOrResolvedFileNames : (originalPathOrResolvedFileNames = new Array(resuableCacheResolutions.cache.resolutions.length)))[resolutionId - 1] = resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().toFileAbsolutePath(resuableCacheResolutions.cache.resolutions[resolutionId - 1].resolvedModule.originalPath ||
-                resuableCacheResolutions.cache.resolutions[resolutionId - 1].resolvedModule.resolvedFileName));
-        }
-        function toAffectingFileLocation(fileId) {
-            if (!decodedHashes && resuableCacheResolutions.cache.hash) {
-                decodedHashes = ts.arrayToMap(resuableCacheResolutions.cache.hash, function (hash) { return ts.isArray(hash) ? hash[0] : hash; }, function (hash) { return ts.isArray(hash) ? hash[1] : undefined; });
-            }
-            var hash = decodedHashes === null || decodedHashes === void 0 ? void 0 : decodedHashes.get(fileId);
-            var file = resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().toFileAbsolutePath(fileId);
-            return affectingLocationsSame(file, hash) ? file : undefined;
-        }
-        function toResolution(resolutionId) {
-            var _a, _b;
-            var existing = resolutions === null || resolutions === void 0 ? void 0 : resolutions[resolutionId - 1];
-            if (existing !== undefined)
-                return existing || undefined;
-            resolutions !== null && resolutions !== void 0 ? resolutions : (resolutions = new Array(resuableCacheResolutions.cache.resolutions.length));
-            var resolution = resuableCacheResolutions.cache.resolutions[resolutionId - 1];
-            var resolvedFileName = resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().toFileAbsolutePath(((_a = resolution.resolvedModule) === null || _a === void 0 ? void 0 : _a.resolvedFileName) || resolution.resolvedTypeReferenceDirective.resolvedFileName);
-            var affectingLocations;
-            if (fileExists(resolvedFileName) && ts.every(resolution.affectingLocations, function (fileId) {
-                var file = toAffectingFileLocation(fileId);
-                if (file)
-                    (affectingLocations !== null && affectingLocations !== void 0 ? affectingLocations : (affectingLocations = [])).push(file);
-                return !!file;
-            })) {
-                // Type Ref doesnt need extension
-                var extenstion = resolution.resolvedModule ? ts.extensionFromPath(resolvedFileName) : undefined;
-                return resolutions[resolutionId - 1] = {
-                    resolvedModule: toResolved(resolution.resolvedModule, resolvedFileName, extenstion),
-                    resolvedTypeReferenceDirective: toResolved(resolution.resolvedTypeReferenceDirective, resolvedFileName, extenstion),
-                    failedLookupLocations: ts.emptyArray,
-                    affectingLocations: affectingLocations,
-                    resolutionDiagnostics: (_b = resolution.resolutionDiagnostics) === null || _b === void 0 ? void 0 : _b.map(toResolutionDiagnostic)
-                };
-            }
-            resolutions[resolutionId - 1] = false;
-            return undefined;
-        }
-        function toResolved(resolved, resolvedFileName, extension) {
-            if (!resolved)
-                return undefined;
-            return __assign(__assign({}, resolved), { resolvedFileName: resolvedFileName, originalPath: resolved.originalPath ? resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().toFileAbsolutePath(resolved.originalPath) : undefined, extension: extension });
-        }
-        function toResolutionDiagnostic(d) {
-            return {
-                isImports: !!d.isImports,
-                entry: d.entry || "",
-                packagePath: resuableCacheResolutions.getProgramBuildInfoFilePathDecoder().toFileAbsolutePath(d.packagePath)
-            };
-        }
-    }
-    ts.createOldBuildInfoProgram = createOldBuildInfoProgram;
     function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
@@ -123141,7 +122365,6 @@ var ts;
             restoreEmitState: ts.noop,
             getProgram: getProgram,
             getProgramOrUndefined: function () { return getState().program; },
-            getProgramOrOldBuildInfoProgramUndefined: function () { return getState().program; },
             releaseProgram: function () { return getState().program = undefined; },
             getCompilerOptions: function () { return getState().compilerOptions; },
             getSourceFile: function (fileName) { return getProgram().getSourceFile(fileName); },
@@ -123240,10 +122463,11 @@ var ts;
     function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
         var filesWithChangedSetOfUnresolvedImports;
         var filesWithInvalidatedResolutions;
+        var filesWithInvalidatedNonRelativeUnresolvedImports;
+        var nonRelativeExternalModuleResolutions = ts.createMultiMap();
         var resolutionsWithFailedLookups = [];
         var resolutionsWithOnlyAffectingLocations = [];
         var resolvedFileToResolution = ts.createMultiMap();
-        var resolutionsToCloseWatcherOn;
         var hasChangedAutomaticTypeDirectiveNames = false;
         var affectingPathChecks;
         var failedLookupChecks;
@@ -123251,15 +122475,18 @@ var ts;
         var isInDirectoryChecks;
         var getCurrentDirectory = ts.memoize(function () { return resolutionHost.getCurrentDirectory(); }); // TODO: GH#18217
         var cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost();
-        var oldModuleAndTypeRefCache;
         // The resolvedModuleNames and resolvedTypeReferenceDirectives are the cache of resolutions per file.
         // The key in the map is source file's path.
         // The values are Map of resolutions with key being name lookedup.
         var resolvedModuleNames = new ts.Map();
-        var moduleResolutionCache = ts.createModuleResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName);
+        var perDirectoryResolvedModuleNames = ts.createCacheWithRedirects();
+        var nonRelativeModuleNameCache = ts.createCacheWithRedirects();
+        var moduleResolutionCache = ts.createModuleResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName, 
+        /*options*/ undefined, perDirectoryResolvedModuleNames, nonRelativeModuleNameCache);
         var resolvedTypeReferenceDirectives = new ts.Map();
+        var perDirectoryResolvedTypeReferenceDirectives = ts.createCacheWithRedirects();
         var typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName, 
-        /*options*/ undefined, moduleResolutionCache.getPackageJsonInfoCache());
+        /*options*/ undefined, moduleResolutionCache.getPackageJsonInfoCache(), perDirectoryResolvedTypeReferenceDirectives);
         /**
          * These are the extensions that failed lookup files will have by default,
          * any other extension of failed lookup will be store that path in custom failed lookup path
@@ -123276,23 +122503,26 @@ var ts;
         // TypeRoot watches for the types that get added as part of getAutomaticTypeDirectiveNames
         var typeRootsWatches = new ts.Map();
         return {
-            resolvedModuleNames: resolvedModuleNames,
-            resolvedTypeReferenceDirectives: resolvedTypeReferenceDirectives,
             getModuleResolutionCache: function () { return moduleResolutionCache; },
-            getTypeReferenceDirectiveResolutionCache: function () { return typeReferenceDirectiveResolutionCache; },
             startRecordingFilesWithChangedResolutions: startRecordingFilesWithChangedResolutions,
             finishRecordingFilesWithChangedResolutions: finishRecordingFilesWithChangedResolutions,
             // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
             // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
-            startCachingPerDirectoryResolution: startCachingPerDirectoryResolution,
+            startCachingPerDirectoryResolution: clearPerDirectoryResolutions,
             finishCachingPerDirectoryResolution: finishCachingPerDirectoryResolution,
             resolveModuleNames: resolveModuleNames,
+            getResolvedModuleWithFailedLookupLocationsFromCache: getResolvedModuleWithFailedLookupLocationsFromCache,
             resolveTypeReferenceDirectives: resolveTypeReferenceDirectives,
+            removeResolutionsFromProjectReferenceRedirects: removeResolutionsFromProjectReferenceRedirects,
+            removeResolutionsOfFile: removeResolutionsOfFile,
             hasChangedAutomaticTypeDirectiveNames: function () { return hasChangedAutomaticTypeDirectiveNames; },
             invalidateResolutionOfFile: invalidateResolutionOfFile,
             invalidateResolutionsOfFailedLookupLocations: invalidateResolutionsOfFailedLookupLocations,
             setFilesWithInvalidatedNonRelativeUnresolvedImports: setFilesWithInvalidatedNonRelativeUnresolvedImports,
             createHasInvalidatedResolution: createHasInvalidatedResolution,
+            isFileWithInvalidatedNonRelativeUnresolvedImports: isFileWithInvalidatedNonRelativeUnresolvedImports,
+            updateTypeRootsWatch: updateTypeRootsWatch,
+            closeTypeRootsWatch: closeTypeRootsWatch,
             clear: clear
         };
         function getResolvedModule(resolution) {
@@ -123311,6 +122541,7 @@ var ts;
             ts.clearMap(directoryWatchesOfFailedLookups, ts.closeFileWatcherOf);
             ts.clearMap(fileWatchesOfAffectingLocations, ts.closeFileWatcherOf);
             customFailedLookupPaths.clear();
+            nonRelativeExternalModuleResolutions.clear();
             closeTypeRootsWatch();
             resolvedModuleNames.clear();
             resolvedTypeReferenceDirectives.clear();
@@ -123321,12 +122552,9 @@ var ts;
             startsWithPathChecks = undefined;
             isInDirectoryChecks = undefined;
             affectingPathChecks = undefined;
-            resolutionsToCloseWatcherOn = undefined;
             // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update
             // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution)
-            moduleResolutionCache.clear();
-            typeReferenceDirectiveResolutionCache.clear();
-            oldModuleAndTypeRefCache = undefined;
+            clearPerDirectoryResolutions();
             hasChangedAutomaticTypeDirectiveNames = false;
         }
         function startRecordingFilesWithChangedResolutions() {
@@ -123337,6 +122565,14 @@ var ts;
             filesWithChangedSetOfUnresolvedImports = undefined;
             return collected;
         }
+        function isFileWithInvalidatedNonRelativeUnresolvedImports(path) {
+            if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
+                return false;
+            }
+            // Invalidated if file has unresolved imports
+            var value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);
+            return !!value && !!value.length;
+        }
         function createHasInvalidatedResolution(forceAllFilesAsInvalidated) {
             // Ensure pending resolutions are applied
             invalidateResolutionsOfFailedLookupLocations();
@@ -123347,155 +122583,36 @@ var ts;
             }
             var collected = filesWithInvalidatedResolutions;
             filesWithInvalidatedResolutions = undefined;
-            return function (path) { return !!(collected === null || collected === void 0 ? void 0 : collected.has(path)); };
+            return function (path) { return (!!collected && collected.has(path)) ||
+                isFileWithInvalidatedNonRelativeUnresolvedImports(path); };
         }
-        function startCachingPerDirectoryResolution() {
+        function clearPerDirectoryResolutions() {
             moduleResolutionCache.clear();
             typeReferenceDirectiveResolutionCache.clear();
-            moduleResolutionCache.update(resolutionHost.getCompilationSettings());
-            typeReferenceDirectiveResolutionCache.update(resolutionHost.getCompilationSettings());
-            if (oldModuleAndTypeRefCache) {
-                oldModuleAndTypeRefCache.clearRedirectsMap();
-                moduleResolutionCache.setOldResolutionCache(oldModuleAndTypeRefCache.modules);
-                typeReferenceDirectiveResolutionCache.setOldResolutionCache(oldModuleAndTypeRefCache.typeRefs);
-            }
+            nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
+            nonRelativeExternalModuleResolutions.clear();
         }
-        function finishCachingPerDirectoryResolution(newProgram, oldProgram) {
+        function finishCachingPerDirectoryResolution() {
+            filesWithInvalidatedNonRelativeUnresolvedImports = undefined;
+            clearPerDirectoryResolutions();
+            directoryWatchesOfFailedLookups.forEach(function (watcher, path) {
+                if (watcher.refCount === 0) {
+                    directoryWatchesOfFailedLookups.delete(path);
+                    watcher.watcher.close();
+                }
+            });
+            fileWatchesOfAffectingLocations.forEach(function (watcher, path) {
+                if (watcher.refCount === 0) {
+                    fileWatchesOfAffectingLocations.delete(path);
+                    watcher.watcher.close();
+                    // Ensure when watching symlinked package.json, we can close the actual file watcher only once
+                    watcher.watcher = ts.noopFileWatcher;
+                }
+            });
             hasChangedAutomaticTypeDirectiveNames = false;
-            if (!newProgram) {
-                clear();
-                return;
-            }
-            if (newProgram === oldProgram || newProgram.structureIsReused === 3 /* Completely */)
-                return;
-            var modules;
-            var typeRefs;
-            var moduleNameToDirectoryMap = ts.createCacheWithRedirects(newProgram.getCompilerOptions());
-            // Update resolution caches
-            for (var _i = 0, _a = newProgram.getSourceFiles(); _i < _a.length; _i++) {
-                var f = _a[_i];
-                modules = ensureResolutionsOfFile(newProgram, resolvedModuleNames, f.resolvedModules, f, getResolvedModule, modules, moduleNameToDirectoryMap);
-                typeRefs = ensureResolutionsOfFile(newProgram, resolvedTypeReferenceDirectives, f.resolvedTypeReferenceDirectiveNames, f, getResolvedTypeReferenceDirective, typeRefs, 
-                /*moduleNameToDirectoryMap*/ undefined);
-            }
-            var newProgramAutoTypeRefContainingFile = resolutionHost.toPath(newProgram.getAutomaticTypeDirectiveContainingFile());
-            typeRefs = ensureResolutionsOfFile(newProgram, resolvedTypeReferenceDirectives, newProgram.getAutomaticTypeDirectiveResolutions(), newProgramAutoTypeRefContainingFile, getResolvedTypeReferenceDirective, typeRefs, 
-            /*moduleNameToDirectoryMap*/ undefined);
-            if (!modules && !typeRefs) {
-                oldModuleAndTypeRefCache = undefined;
-            }
-            else {
-                oldModuleAndTypeRefCache = getOldResolutionCache(modules, typeRefs, moduleNameToDirectoryMap);
-            }
-            // Remove resolutions for files not in the program
-            if (oldProgram) {
-                for (var _b = 0, _c = oldProgram.getSourceFiles(); _b < _c.length; _b++) {
-                    var f = _c[_b];
-                    if (!newProgram.getSourceFileByPath(f.path))
-                        removeResolutionsOfFile(f.path);
-                }
-                var oldProgramAutoTypeRefContainingFile = resolutionHost.toPath(oldProgram.getAutomaticTypeDirectiveContainingFile());
-                if (oldProgramAutoTypeRefContainingFile !== newProgramAutoTypeRefContainingFile) {
-                    removeResolutionsOfFile(oldProgramAutoTypeRefContainingFile);
-                }
-            }
-            if (!oldProgram || newProgram.getCompilerOptions() !== oldProgram.getCompilerOptions())
-                updateTypeRootsWatch();
-            // Remove symlinked watchers that have zero ref count
-            resolutionsToCloseWatcherOn === null || resolutionsToCloseWatcherOn === void 0 ? void 0 : resolutionsToCloseWatcherOn.forEach(closeWatchersOfResolution);
-            resolutionsToCloseWatcherOn = undefined;
-            fileWatchesOfAffectingLocations.forEach(closeAffectingFileWatcher);
-        }
-        function closeAffectingFileWatcher(watcher, path) {
-            if (watcher.refCount === 0) {
-                fileWatchesOfAffectingLocations.delete(path);
-                watcher.watcher.close();
-                // Ensure when watching symlinked package.json, we can close the actual file watcher only once
-                watcher.watcher = ts.noopFileWatcher;
-            }
-        }
-        function ensureResolutionsOfFile(newProgram, perFileCache, fileCacheFromProgram, sourceFileOrPath, getResolutionWithResolvedFileName, perDirCache, moduleNameToDirectoryMap) {
-            var path = !ts.isString(sourceFileOrPath) ? sourceFileOrPath.path : sourceFileOrPath;
-            var resolutionsInFile = perFileCache.get(path);
-            var seenNamesInFile = ts.createModeAwareCache();
-            if (fileCacheFromProgram === null || fileCacheFromProgram === void 0 ? void 0 : fileCacheFromProgram.size()) {
-                // If keys dont match release existing resolutions
-                var redirectedReference = !ts.isString(sourceFileOrPath) ? newProgram.getRedirectReferenceForResolution(sourceFileOrPath) : undefined;
-                var options_3 = (redirectedReference === null || redirectedReference === void 0 ? void 0 : redirectedReference.commandLine.options) || newProgram.getCompilerOptions();
-                var key_2 = ts.getRedirectsCacheKey(options_3);
-                if (resolutionsInFile && resolutionsInFile.key !== key_2) {
-                    resolutionsInFile.cache.forEach(function (r) { return stopWatchingResolution(r, path, getResolutionWithResolvedFileName); });
-                    resolutionsInFile = undefined;
-                }
-                var dirPath_1 = ts.getDirectoryPath(path);
-                var perDirResolutionCache_1 = perDirCache === null || perDirCache === void 0 ? void 0 : perDirCache.getMapOfCacheRedirects(redirectedReference);
-                var cacheForDir_1 = perDirResolutionCache_1 === null || perDirResolutionCache_1 === void 0 ? void 0 : perDirResolutionCache_1.get(dirPath_1);
-                fileCacheFromProgram.forEach(function (r, name, mode) {
-                    seenNamesInFile.set(name, mode, true);
-                    var existing = resolutionsInFile === null || resolutionsInFile === void 0 ? void 0 : resolutionsInFile.cache.get(name, mode);
-                    if (existing && r !== existing)
-                        stopWatchingResolution(existing, path, getResolutionWithResolvedFileName);
-                    watchResolution(newProgram, name, r, path, getResolutionWithResolvedFileName);
-                    if (!resolutionsInFile)
-                        perFileCache.set(path, resolutionsInFile = { key: key_2, cache: ts.createModeAwareCache() });
-                    resolutionsInFile.cache.set(name, mode, r);
-                    if (cacheForDir_1 === null || cacheForDir_1 === void 0 ? void 0 : cacheForDir_1.has(name, mode))
-                        return;
-                    if (!cacheForDir_1) {
-                        perDirResolutionCache_1 !== null && perDirResolutionCache_1 !== void 0 ? perDirResolutionCache_1 : (perDirResolutionCache_1 = (perDirCache !== null && perDirCache !== void 0 ? perDirCache : (perDirCache = ts.createCacheWithRedirects(newProgram.getCompilerOptions()))).createMapForCompilerOptions(options_3, key_2));
-                        perDirResolutionCache_1.set(dirPath_1, cacheForDir_1 = ts.createModeAwareCache());
-                    }
-                    cacheForDir_1.set(name, mode, r);
-                    if (!moduleNameToDirectoryMap || ts.isExternalModuleNameRelative(name))
-                        return;
-                    var actualModuleNameToDirectoryMap = moduleNameToDirectoryMap.createMapForCompilerOptions(options_3, key_2);
-                    var modeAwareCacheKey = ts.getModeAwareCacheKey(name, mode);
-                    var directoryPathMap = actualModuleNameToDirectoryMap.get(modeAwareCacheKey);
-                    if (!directoryPathMap)
-                        actualModuleNameToDirectoryMap.set(modeAwareCacheKey, directoryPathMap = new ts.Map());
-                    ts.moduleNameToDirectorySet(directoryPathMap, dirPath_1, r, ts.getResolvedFileNameForModuleNameToDirectorySet, function (dir) { return resolutionHost.toPath(dir); }, ts.noop);
-                });
-            }
-            if (((resolutionsInFile === null || resolutionsInFile === void 0 ? void 0 : resolutionsInFile.cache.size()) || 0) !== seenNamesInFile.size()) {
-                // Stop watching and remove the unused name
-                resolutionsInFile.cache.forEach(function (resolution, name, mode) {
-                    if (!seenNamesInFile.has(name, mode)) {
-                        stopWatchingResolution(resolution, path, getResolutionWithResolvedFileName);
-                        resolutionsInFile.cache.delete(name, mode);
-                    }
-                });
-                if (!(resolutionsInFile === null || resolutionsInFile === void 0 ? void 0 : resolutionsInFile.cache.size))
-                    perFileCache.delete(path);
-            }
-            return perDirCache;
-        }
-        function getOldResolutionCache(modules, typeRefs, moduleNameToDirectoryMap) {
-            if (!modules && !typeRefs)
-                return undefined;
-            return {
-                modules: {
-                    getResolved: function (dirPath, name, mode, redirectedReference) { return getResolvedWithOldCache(dirPath, name, mode, redirectedReference, modules, moduleNameToDirectoryMap); }
-                },
-                typeRefs: {
-                    getResolved: function (dirPath, name, mode, redirectedReference) { return getResolvedWithOldCache(dirPath, name, mode, redirectedReference, typeRefs, /*moduleNameToDirectoryMap*/ undefined); }
-                },
-                clearRedirectsMap: function () {
-                    modules === null || modules === void 0 ? void 0 : modules.clearRedirectsMap();
-                    typeRefs === null || typeRefs === void 0 ? void 0 : typeRefs.clearRedirectsMap();
-                    moduleNameToDirectoryMap.clearRedirectsMap();
-                },
-            };
-        }
-        function getResolvedWithOldCache(dirPath, name, mode, redirectedReference, perDirCache, moduleNameToDirectoryMap) {
-            var _a, _b, _c, _d;
-            if (!perDirCache)
-                return undefined;
-            var result = ((_b = (_a = perDirCache.getMapOfCacheRedirects(redirectedReference)) === null || _a === void 0 ? void 0 : _a.get(dirPath)) === null || _b === void 0 ? void 0 : _b.get(name, mode)) ||
-                ((_d = (_c = moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) === null || _c === void 0 ? void 0 : _c.get(ts.getModeAwareCacheKey(name, mode))) === null || _d === void 0 ? void 0 : _d.get(dirPath));
-            return result && !result.isInvalidated ? result : undefined;
         }
         function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
-            var _a;
+            var _a, _b;
             var primaryResult = ts.resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
             // return result immediately only if global cache support is not enabled or if it is .ts, .tsx or .d.ts
             if (!resolutionHost.getGlobalCache) {
@@ -123506,16 +122623,12 @@ var ts;
             if (globalCache !== undefined && !ts.isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && ts.extensionIsTS(primaryResult.resolvedModule.extension))) {
                 // create different collection of failed lookup locations for second pass
                 // if it will fail and we've already found something during the first pass - we don't want to pollute its results
-                var _b = ts.loadModuleFromGlobalCache(ts.Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName), resolutionHost.projectName, compilerOptions, host, globalCache, moduleResolutionCache), resolvedModule = _b.resolvedModule, failedLookupLocations = _b.failedLookupLocations, affectingLocations = _b.affectingLocations, resolutionDiagnostics = _b.resolutionDiagnostics;
+                var _c = ts.loadModuleFromGlobalCache(ts.Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName), resolutionHost.projectName, compilerOptions, host, globalCache, moduleResolutionCache), resolvedModule = _c.resolvedModule, failedLookupLocations = _c.failedLookupLocations, affectingLocations = _c.affectingLocations;
                 if (resolvedModule) {
                     // Modify existing resolution so its saved in the directory cache as well
                     primaryResult.resolvedModule = resolvedModule;
-                    if (!compilerOptions.cacheResolutions)
-                        (_a = primaryResult.failedLookupLocations).push.apply(_a, failedLookupLocations);
-                    else
-                        primaryResult.failedLookupLocations.length = 0;
-                    primaryResult.affectingLocations = ts.updateResolutionField(primaryResult.affectingLocations, affectingLocations);
-                    primaryResult.resolutionDiagnostics = ts.updateResolutionField(primaryResult.resolutionDiagnostics, resolutionDiagnostics);
+                    (_a = primaryResult.failedLookupLocations).push.apply(_a, failedLookupLocations);
+                    (_b = primaryResult.affectingLocations).push.apply(_b, affectingLocations);
                     return primaryResult;
                 }
             }
@@ -123526,41 +122639,76 @@ var ts;
             return ts.resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode);
         }
         function resolveNamesWithLocalCache(_a) {
-            var _b, _c, _d, _e;
-            var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, perFileCache = _a.perFileCache, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, partialResolutionInfo = _a.partialResolutionInfo, logChanges = _a.logChanges, containingSourceFile = _a.containingSourceFile, containingSourceFileMode = _a.containingSourceFileMode;
+            var _b, _c, _d;
+            var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, cache = _a.cache, perDirectoryCacheWithRedirects = _a.perDirectoryCacheWithRedirects, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, shouldRetryResolution = _a.shouldRetryResolution, reusedNames = _a.reusedNames, logChanges = _a.logChanges, containingSourceFile = _a.containingSourceFile, containingSourceFileMode = _a.containingSourceFileMode;
             var path = resolutionHost.toPath(containingFile);
-            var resolutionsInFile = perFileCache.get(path);
-            var compilerOptions = resolutionHost.getCompilationSettings();
-            var key = ts.getRedirectsCacheKey((redirectedReference === null || redirectedReference === void 0 ? void 0 : redirectedReference.commandLine.options) || compilerOptions);
-            if (!resolutionsInFile || resolutionsInFile.key !== key) {
-                resolutionsInFile === null || resolutionsInFile === void 0 ? void 0 : resolutionsInFile.cache.forEach(function (r) { return stopWatchingResolution(r, path, getResolutionWithResolvedFileName); });
-                perFileCache.set(path, resolutionsInFile = { key: key, cache: ts.createModeAwareCache() });
+            var resolutionsInFile = cache.get(path) || cache.set(path, ts.createModeAwareCache()).get(path);
+            var dirPath = ts.getDirectoryPath(path);
+            var perDirectoryCache = perDirectoryCacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
+            var perDirectoryResolution = perDirectoryCache.get(dirPath);
+            if (!perDirectoryResolution) {
+                perDirectoryResolution = ts.createModeAwareCache();
+                perDirectoryCache.set(dirPath, perDirectoryResolution);
             }
             var resolvedModules = [];
+            var compilerOptions = resolutionHost.getCompilationSettings();
+            var hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path);
+            // All the resolutions in this file are invalidated if this file wasn't resolved using same redirect
+            var program = resolutionHost.getCurrentProgram();
+            var oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile);
+            var unmatchedRedirects = oldRedirect ?
+                !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path :
+                !!redirectedReference;
             var seenNamesInFile = ts.createModeAwareCache();
             var i = 0;
-            for (var _i = 0, names_4 = names; _i < names_4.length; _i++) {
-                var entry = names_4[_i];
-                var name = ts.isString(entry) ? entry : ts.toFileNameLowerCase(entry.fileName);
+            for (var _i = 0, names_5 = names; _i < names_5.length; _i++) {
+                var entry = names_5[_i];
+                var name = ts.isString(entry) ? entry : entry.fileName.toLowerCase();
                 // Imports supply a `containingSourceFile` but no `containingSourceFileMode` - it would be redundant
                 // they require calculating the mode for a given import from it's position in the resolution table, since a given
                 // import's syntax may override the file's default mode.
                 // Type references instead supply a `containingSourceFileMode` and a non-string entry which contains
                 // a default file mode override if applicable.
                 var mode = !ts.isString(entry) ? ts.getModeForFileReference(entry, containingSourceFileMode) :
-                    containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, (_b = partialResolutionInfo === null || partialResolutionInfo === void 0 ? void 0 : partialResolutionInfo.namesIndex[i]) !== null && _b !== void 0 ? _b : i) : undefined;
+                    containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, i) : undefined;
                 i++;
-                var resolution = resolutionsInFile.cache.get(name, mode);
+                var resolution = resolutionsInFile.get(name, mode);
                 // Resolution is valid if it is present and not invalidated
-                if (!seenNamesInFile.has(name, mode) && (!resolution || resolution.isInvalidated)) {
+                if (!seenNamesInFile.has(name, mode) &&
+                    unmatchedRedirects || !resolution || resolution.isInvalidated ||
+                    // If the name is unresolved import that was invalidated, recalculate
+                    (hasInvalidatedNonRelativeUnresolvedImport && !ts.isExternalModuleNameRelative(name) && shouldRetryResolution(resolution))) {
                     var existingResolution = resolution;
-                    resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile, mode);
-                    if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
-                        resolutionHost.onDiscoveredSymlink();
+                    var resolutionInDirectory = perDirectoryResolution.get(name, mode);
+                    if (resolutionInDirectory) {
+                        resolution = resolutionInDirectory;
+                        var host = ((_b = resolutionHost.getCompilerHost) === null || _b === void 0 ? void 0 : _b.call(resolutionHost)) || resolutionHost;
+                        if (ts.isTraceEnabled(compilerOptions, host)) {
+                            var resolved = getResolutionWithResolvedFileName(resolution);
+                            ts.trace(host, loader === resolveModuleName ?
+                                (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ?
+                                    resolved.packagetId ?
+                                        ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 :
+                                        ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 :
+                                    ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved :
+                                (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ?
+                                    resolved.packagetId ?
+                                        ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 :
+                                        ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 :
+                                    ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved, name, containingFile, ts.getDirectoryPath(containingFile), resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName, (resolved === null || resolved === void 0 ? void 0 : resolved.packagetId) && ts.packageIdToString(resolved.packagetId));
+                        }
+                    }
+                    else {
+                        resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile, mode);
+                        perDirectoryResolution.set(name, mode, resolution);
+                        if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
+                            resolutionHost.onDiscoveredSymlink();
+                        }
                     }
-                    resolutionsInFile.cache.set(name, mode, resolution);
+                    resolutionsInFile.set(name, mode, resolution);
+                    watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName);
                     if (existingResolution) {
-                        stopWatchingResolution(existingResolution, path, getResolutionWithResolvedFileName);
+                        stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
                     }
                     if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
                         filesWithChangedSetOfUnresolvedImports.push(path);
@@ -123574,34 +122722,28 @@ var ts;
                         var resolved = getResolutionWithResolvedFileName(resolution);
                         ts.trace(host, loader === resolveModuleName ?
                             (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ?
-                                resolved.packageId ?
+                                resolved.packagetId ?
                                     ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 :
                                     ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 :
                                 ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved :
                             (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ?
-                                resolved.packageId ?
+                                resolved.packagetId ?
                                     ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 :
                                     ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 :
-                                ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved, name, containingFile, resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName, (resolved === null || resolved === void 0 ? void 0 : resolved.packageId) && ts.packageIdToString(resolved.packageId));
+                                ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved, name, containingFile, resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName, (resolved === null || resolved === void 0 ? void 0 : resolved.packagetId) && ts.packageIdToString(resolved.packagetId));
                     }
                 }
                 ts.Debug.assert(resolution !== undefined && !resolution.isInvalidated);
                 seenNamesInFile.set(name, mode, true);
-                resolvedModules.push(resolution);
+                resolvedModules.push(getResolutionWithResolvedFileName(resolution));
             }
-            (_e = partialResolutionInfo === null || partialResolutionInfo === void 0 ? void 0 : partialResolutionInfo.reusedNames) === null || _e === void 0 ? void 0 : _e.forEach(function (_a) {
-                var name = _a.name, mode = _a.mode;
-                return seenNamesInFile.set(name, mode, true);
+            // Stop watching and remove the unused name
+            resolutionsInFile.forEach(function (resolution, name, mode) {
+                if (!seenNamesInFile.has(name, mode) && !ts.contains(reusedNames, name)) {
+                    stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
+                    resolutionsInFile.delete(name, mode);
+                }
             });
-            if (resolutionsInFile.cache.size() !== seenNamesInFile.size()) {
-                // Stop watching and remove the unused name
-                resolutionsInFile.cache.forEach(function (resolution, name, mode) {
-                    if (!seenNamesInFile.has(name, mode)) {
-                        stopWatchingResolution(resolution, path, getResolutionWithResolvedFileName);
-                        resolutionsInFile.cache.delete(name, mode);
-                    }
-                });
-            }
             return resolvedModules;
             function resolutionIsEqualTo(oldResolution, newResolution) {
                 if (oldResolution === newResolution) {
@@ -123621,31 +122763,40 @@ var ts;
                 return oldResult.resolvedFileName === newResult.resolvedFileName;
             }
         }
-        function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, partialResolutionInfo) {
+        function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode) {
             return resolveNamesWithLocalCache({
                 names: typeDirectiveNames,
                 containingFile: containingFile,
                 redirectedReference: redirectedReference,
-                perFileCache: resolvedTypeReferenceDirectives,
+                cache: resolvedTypeReferenceDirectives,
+                perDirectoryCacheWithRedirects: perDirectoryResolvedTypeReferenceDirectives,
                 loader: resolveTypeReferenceDirective,
                 getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
-                containingSourceFileMode: containingFileMode,
-                partialResolutionInfo: partialResolutionInfo,
+                shouldRetryResolution: function (resolution) { return resolution.resolvedTypeReferenceDirective === undefined; },
+                containingSourceFileMode: containingFileMode
             });
         }
-        function resolveModuleNames(moduleNames, containingFile, redirectedReference, containingSourceFile, partialResolutionInfo) {
+        function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile) {
             return resolveNamesWithLocalCache({
                 names: moduleNames,
                 containingFile: containingFile,
                 redirectedReference: redirectedReference,
-                perFileCache: resolvedModuleNames,
+                cache: resolvedModuleNames,
+                perDirectoryCacheWithRedirects: perDirectoryResolvedModuleNames,
                 loader: resolveModuleName,
                 getResolutionWithResolvedFileName: getResolvedModule,
-                partialResolutionInfo: partialResolutionInfo,
+                shouldRetryResolution: function (resolution) { return !resolution.resolvedModule || !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension); },
+                reusedNames: reusedNames,
                 logChanges: logChangesWhenResolvingModule,
                 containingSourceFile: containingSourceFile,
             });
         }
+        function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
+            var cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile));
+            if (!cache)
+                return undefined;
+            return cache.get(moduleName, resolutionMode);
+        }
         function isNodeModulesAtTypesDirectory(dirPath) {
             return ts.endsWith(dirPath, "/node_modules/@types");
         }
@@ -123705,42 +122856,37 @@ var ts;
         function isPathWithDefaultFailedLookupExtension(path) {
             return ts.fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
         }
-        function watchResolution(newProgram, name, resolution, filePath, getResolutionWithResolvedFileName) {
-            if (resolution.files) {
-                resolution.files.add(filePath);
-                if (resolution.watchedFailed !== false)
-                    watchFailedLookupLocationOfResolution(resolution);
-                watchAffectingLocationsOfResolution(resolution);
-                return;
-            }
-            resolution.files = new ts.Set();
-            resolution.files.add(filePath);
-            var resolved = getResolutionWithResolvedFileName(resolution);
-            if (resolved && resolved.resolvedFileName) {
-                resolvedFileToResolution.add(resolutionHost.toPath(resolved.resolvedFileName), resolution);
-            }
-            if (ts.isExternalModuleNameRelative(name) || !newProgram.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) {
-                watchFailedLookupLocationOfResolution(resolution);
-                watchAffectingLocationsOfResolution(resolution);
+        function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName) {
+            if (resolution.refCount) {
+                resolution.refCount++;
+                ts.Debug.assertIsDefined(resolution.files);
             }
             else {
-                resolution.watchedFailed = false;
-                watchAffectingLocationsOfResolution(resolution);
+                resolution.refCount = 1;
+                ts.Debug.assert(ts.length(resolution.files) === 0); // This resolution shouldnt be referenced by any file yet
+                if (ts.isExternalModuleNameRelative(name)) {
+                    watchFailedLookupLocationOfResolution(resolution);
+                }
+                else {
+                    nonRelativeExternalModuleResolutions.add(name, resolution);
+                }
+                var resolved = getResolutionWithResolvedFileName(resolution);
+                if (resolved && resolved.resolvedFileName) {
+                    resolvedFileToResolution.add(resolutionHost.toPath(resolved.resolvedFileName), resolution);
+                }
             }
+            (resolution.files || (resolution.files = [])).push(filePath);
         }
         function watchFailedLookupLocationOfResolution(resolution) {
-            var failedLookupLocations = resolution.failedLookupLocations;
-            if (!failedLookupLocations.length || resolution.watchedFailed === failedLookupLocations.length)
+            ts.Debug.assert(!!resolution.refCount);
+            var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations;
+            if (!failedLookupLocations.length && !affectingLocations.length)
                 return;
-            if (!resolution.watchedFailed) {
+            if (failedLookupLocations.length)
                 resolutionsWithFailedLookups.push(resolution);
-                // Remove resolution from only watching affected locations
-                if (resolution.watchedAffected)
-                    ts.unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution);
-            }
-            var setAtRoot = !!resolution.setAtRoot;
-            for (var i = resolution.watchedFailed || 0; i < failedLookupLocations.length; i++) {
-                var failedLookupLocation = failedLookupLocations[i];
+            var setAtRoot = false;
+            for (var _i = 0, failedLookupLocations_1 = failedLookupLocations; _i < failedLookupLocations_1.length; _i++) {
+                var failedLookupLocation = failedLookupLocations_1[_i];
                 var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
                 var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
                 if (toWatch) {
@@ -123760,24 +122906,24 @@ var ts;
                     }
                 }
             }
-            if (setAtRoot && !resolution.setAtRoot) {
+            if (setAtRoot) {
                 // This is always non recursive
-                setDirectoryWatcher(rootDir, rootPath, /*nonRecursive*/ true);
+                setDirectoryWatcher(rootDir, rootPath, /*nonRecursive*/ true); // TODO: GH#18217
             }
-            resolution.setAtRoot = setAtRoot;
-            resolution.watchedFailed = failedLookupLocations.length;
+            watchAffectingLocationsOfResolution(resolution, !failedLookupLocations.length);
         }
-        function watchAffectingLocationsOfResolution(resolution) {
+        function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
+            ts.Debug.assert(!!resolution.refCount);
             var affectingLocations = resolution.affectingLocations;
-            if (!(affectingLocations === null || affectingLocations === void 0 ? void 0 : affectingLocations.length) || resolution.watchedAffected === affectingLocations.length)
+            if (!affectingLocations.length)
                 return;
-            if (!resolution.watchedFailed && !resolution.watchedAffected)
+            if (addToResolutionsWithOnlyAffectingLocations)
                 resolutionsWithOnlyAffectingLocations.push(resolution);
             // Watch package json
-            for (var i = resolution.watchedAffected || 0; i < affectingLocations.length; i++) {
-                createFileWatcherOfAffectingLocation(affectingLocations[i]);
+            for (var _i = 0, affectingLocations_1 = affectingLocations; _i < affectingLocations_1.length; _i++) {
+                var affectingLocation = affectingLocations_1[_i];
+                createFileWatcherOfAffectingLocation(affectingLocation);
             }
-            resolution.watchedAffected = affectingLocations.length;
         }
         function createFileWatcherOfAffectingLocation(affectingLocation) {
             var path = resolutionHost.toPath(affectingLocation);
@@ -123818,6 +122964,15 @@ var ts;
                 paths.add(path);
             }
         }
+        function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
+            var program = resolutionHost.getCurrentProgram();
+            if (!program || !program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) {
+                resolutions.forEach(watchFailedLookupLocationOfResolution);
+            }
+            else {
+                resolutions.forEach(function (resolution) { return watchAffectingLocationsOfResolution(resolution, /*addToResolutionWithOnlyAffectingLocations*/ true); });
+            }
+        }
         function setDirectoryWatcher(dir, dirPath, nonRecursive) {
             var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
             if (dirWatcher) {
@@ -123828,28 +122983,21 @@ var ts;
                 directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive: nonRecursive });
             }
         }
-        function stopWatchingResolution(resolution, filePath, getResolutionWithResolvedFileName) {
-            var _a, _b;
-            (_a = resolution.files) === null || _a === void 0 ? void 0 : _a.delete(filePath);
-            if (!((_b = resolution.files) === null || _b === void 0 ? void 0 : _b.size))
-                (resolutionsToCloseWatcherOn !== null && resolutionsToCloseWatcherOn !== void 0 ? resolutionsToCloseWatcherOn : (resolutionsToCloseWatcherOn = [])).push({ resolution: resolution, getResolved: getResolutionWithResolvedFileName });
-        }
-        function closeWatchersOfResolution(_a) {
-            var _b;
-            var resolution = _a.resolution, getResolved = _a.getResolved;
-            // If some files are using this resolution or we have already closed all watchers ignore
-            if (((_b = resolution.files) === null || _b === void 0 ? void 0 : _b.size) || !resolution.files)
+        function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName) {
+            ts.unorderedRemoveItem(ts.Debug.checkDefined(resolution.files), filePath);
+            resolution.refCount--;
+            if (resolution.refCount) {
                 return;
-            resolution.files = undefined;
-            var resolved = getResolved(resolution);
+            }
+            var resolved = getResolutionWithResolvedFileName(resolution);
             if (resolved && resolved.resolvedFileName) {
                 resolvedFileToResolution.remove(resolutionHost.toPath(resolved.resolvedFileName), resolution);
             }
-            if (resolution.watchedFailed) {
-                ts.unorderedRemoveItem(resolutionsWithFailedLookups, resolution);
+            var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations;
+            if (ts.unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) {
                 var removeAtRoot = false;
-                for (var i = 0; i < resolution.watchedFailed; i++) {
-                    var failedLookupLocation = resolution.failedLookupLocations[i];
+                for (var _i = 0, failedLookupLocations_2 = failedLookupLocations; _i < failedLookupLocations_2.length; _i++) {
+                    var failedLookupLocation = failedLookupLocations_2[_i];
                     var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
                     var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
                     if (toWatch) {
@@ -123872,31 +123020,23 @@ var ts;
                         }
                     }
                 }
-                ts.Debug.assert(resolution.setAtRoot === removeAtRoot);
                 if (removeAtRoot) {
                     removeDirectoryWatcher(rootPath);
                 }
             }
-            else if (resolution.watchedAffected) {
+            else if (affectingLocations.length) {
                 ts.unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution);
             }
-            if (resolution.watchedAffected) {
-                for (var i = 0; i < resolution.watchedAffected; i++) {
-                    var affectingLocation = resolution.affectingLocations[i];
-                    var path = resolutionHost.toPath(affectingLocation);
-                    var watcher = fileWatchesOfAffectingLocations.get(path);
-                    watcher.refCount--;
-                    closeAffectingFileWatcher(watcher, path);
-                }
+            for (var _a = 0, affectingLocations_2 = affectingLocations; _a < affectingLocations_2.length; _a++) {
+                var affectingLocation = affectingLocations_2[_a];
+                var watcher = fileWatchesOfAffectingLocations.get(resolutionHost.toPath(affectingLocation));
+                watcher.refCount--;
             }
         }
         function removeDirectoryWatcher(dirPath) {
             var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
+            // Do not close the watcher yet since it might be needed by other failed lookup locations.
             dirWatcher.refCount--;
-            if (dirWatcher.refCount === 0) {
-                directoryWatchesOfFailedLookups.delete(dirPath);
-                dirWatcher.watcher.close();
-            }
         }
         function createDirectoryWatcher(directory, dirPath, nonRecursive) {
             return resolutionHost.watchDirectoryOfFailedLookupLocation(directory, function (fileOrDirectory) {
@@ -123912,16 +123052,28 @@ var ts;
             // Deleted file, stop watching failed lookups for all the resolutions in the file
             var resolutions = cache.get(filePath);
             if (resolutions) {
-                resolutions.cache.forEach(function (resolution) { return stopWatchingResolution(resolution, filePath, getResolutionWithResolvedFileName); });
+                resolutions.forEach(function (resolution) { return stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName); });
                 cache.delete(filePath);
             }
         }
+        function removeResolutionsFromProjectReferenceRedirects(filePath) {
+            if (!ts.fileExtensionIs(filePath, ".json" /* Json */))
+                return;
+            var program = resolutionHost.getCurrentProgram();
+            if (!program)
+                return;
+            // If this file is input file for the referenced project, get it
+            var resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath);
+            if (!resolvedProjectReference)
+                return;
+            // filePath is for the projectReference and the containing file is from this project reference, invalidate the resolution
+            resolvedProjectReference.commandLine.fileNames.forEach(function (f) { return removeResolutionsOfFile(resolutionHost.toPath(f)); });
+        }
         function removeResolutionsOfFile(filePath) {
             removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule);
             removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective);
         }
         function invalidateResolutions(resolutions, canInvalidate) {
-            var _a;
             if (!resolutions)
                 return false;
             var invalidated = false;
@@ -123930,15 +123082,17 @@ var ts;
                 if (resolution.isInvalidated || !canInvalidate(resolution))
                     continue;
                 resolution.isInvalidated = invalidated = true;
-                (_a = resolution.files) === null || _a === void 0 ? void 0 : _a.forEach(function (containingFilePath) {
+                for (var _a = 0, _b = ts.Debug.checkDefined(resolution.files); _a < _b.length; _a++) {
+                    var containingFilePath = _b[_a];
                     (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = new ts.Set())).add(containingFilePath);
                     // When its a file with inferred types resolution, invalidate type reference directive resolution
                     hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || ts.endsWith(containingFilePath, ts.inferredTypesContainingFile);
-                });
+                }
             }
             return invalidated;
         }
         function invalidateResolutionOfFile(filePath) {
+            removeResolutionsOfFile(filePath);
             // Resolution is invalidated if the resulting file name is same as the deleted file path
             var prevHasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
             if (invalidateResolutions(resolvedFileToResolution.get(filePath), ts.returnTrue) &&
@@ -123948,28 +123102,8 @@ var ts;
             }
         }
         function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap) {
-            filesMap.forEach(function (_a, filePath) {
-                var imports = _a.imports;
-                if (!imports.length)
-                    return;
-                var resolvedModules = resolvedModuleNames.get(filePath);
-                var resolvedTypeRefs = resolvedTypeReferenceDirectives.get(filePath);
-                if (!(resolvedModules === null || resolvedModules === void 0 ? void 0 : resolvedModules.cache.size()) && !(resolvedTypeRefs === null || resolvedTypeRefs === void 0 ? void 0 : resolvedTypeRefs.cache.size()))
-                    return;
-                imports.forEach(function (_a) {
-                    var name = _a.name, mode = _a.mode;
-                    var resolvedModule = resolvedModules === null || resolvedModules === void 0 ? void 0 : resolvedModules.cache.get(name, mode);
-                    if (resolvedModule && !resolvedModule.isInvalidated && (!resolvedModule.resolvedModule || !ts.resolutionExtensionIsTSOrJson(resolvedModule.resolvedModule.extension))) {
-                        resolvedModule.isInvalidated = true;
-                        (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(filePath);
-                    }
-                    var resolvedTypeRef = resolvedTypeRefs === null || resolvedTypeRefs === void 0 ? void 0 : resolvedTypeRefs.cache.get(name, mode);
-                    if (resolvedTypeRef && !resolvedTypeRef.isInvalidated && !resolvedTypeRef.resolvedTypeReferenceDirective) {
-                        resolvedTypeRef.isInvalidated = true;
-                        (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(filePath);
-                    }
-                });
-            });
+            ts.Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === undefined);
+            filesWithInvalidatedNonRelativeUnresolvedImports = filesMap;
         }
         function scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) {
             if (isCreatingWatchedDirectory) {
@@ -124041,10 +123175,9 @@ var ts;
             });
         }
         function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
-            var _a;
-            return !!affectingPathChecks && !!((_a = resolution.affectingLocations) === null || _a === void 0 ? void 0 : _a.some(function (location) {
+            return !!affectingPathChecks && resolution.affectingLocations.some(function (location) {
                 return affectingPathChecks.has(resolutionHost.toPath(location));
-            }));
+            });
         }
         function closeTypeRootsWatch() {
             ts.clearMap(typeRootsWatches, ts.closeFileWatcher);
@@ -124434,9 +123567,9 @@ var ts;
             if (!preferSymlinks) {
                 // Symlinks inside ignored paths are already filtered out of the symlink cache,
                 // so we only need to remove them from the realpath filenames.
-                var result_17 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_17)
-                    return result_17;
+                var result_16 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_16)
+                    return result_16;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -124456,10 +123589,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_18 = cb(option, target === referenceRedirect);
+                        var result_17 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                        if (result_18)
-                            return result_18;
+                        if (result_17)
+                            return result_17;
                     }
                 });
             });
@@ -124525,9 +123658,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_12 = _loop_35(directory);
+                var state_11 = _loop_35(directory);
                 directory = out_directory_1;
-                if (state_12 === "break")
+                if (state_11 === "break")
                     break;
             }
             if (allFileNames.size) {
@@ -125496,8 +124629,7 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
-    /*@internal*/
-    function readBuildInfoForProgram(compilerOptions, host) {
+    function readBuilderProgram(compilerOptions, host) {
         var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(compilerOptions);
         if (!buildInfoPath)
             return undefined;
@@ -125518,12 +124650,7 @@ var ts;
             return undefined;
         if (!buildInfo.program)
             return undefined;
-        return { buildInfo: buildInfo, buildInfoPath: buildInfoPath };
-    }
-    ts.readBuildInfoForProgram = readBuildInfoForProgram;
-    function readBuilderProgram(compilerOptions, host) {
-        var result = readBuildInfoForProgram(compilerOptions, host);
-        return result && ts.createBuilderProgramUsingProgramBuildInfo(result.buildInfo.program, result.buildInfoPath, host, compilerOptions.configFilePath);
+        return ts.createBuilderProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);
     }
     ts.readBuilderProgram = readBuilderProgram;
     function createIncrementalCompilerHost(options, system) {
@@ -125662,7 +124789,7 @@ var ts;
                 }
                 return host.resolveModuleNames.apply(host, args);
             }) :
-            (function (moduleNames, containingFile, _reusedNames, redirectedReference, _options, sourceFile, partialResolutionInfo) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, redirectedReference, sourceFile, partialResolutionInfo); });
+            (function (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile); });
         compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ?
             (function () {
                 var args = [];
@@ -125671,13 +124798,7 @@ var ts;
                 }
                 return host.resolveTypeReferenceDirectives.apply(host, args);
             }) :
-            (function (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode, partialResolutionInfo) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, partialResolutionInfo); });
-        compilerHost.getModuleResolutionCache = host.resolveModuleNames ?
-            ts.maybeBind(host, host.getModuleResolutionCache) :
-            (function () { return resolutionCache.getModuleResolutionCache(); });
-        compilerHost.getTypeReferenceDirectiveResolutionCache = host.resolveTypeReferenceDirectives ?
-            ts.maybeBind(host, host.getTypeReferenceDirectiveResolutionCache) :
-            (function () { return resolutionCache.getTypeReferenceDirectiveResolutionCache(); });
+            (function (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode); });
         var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
         builderProgram = readBuilderProgram(compilerOptions, compilerHost);
         synchronizeProgram();
@@ -125746,8 +124867,7 @@ var ts;
             }
             // All resolutions are invalid if user provided resolutions
             var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution);
-            var _a = ts.changeCompilerHostLikeToUseCache(compilerHost, toPath), originalReadFile = _a.originalReadFile, originalFileExists = _a.originalFileExists, originalDirectoryExists = _a.originalDirectoryExists, originalCreateDirectory = _a.originalCreateDirectory, originalWriteFile = _a.originalWriteFile;
-            if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+            if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
                 if (hasChangedConfigFileParsingErrors) {
                     if (reportFileChangeDetectedOnCreateProgram) {
                         reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -125766,11 +124886,6 @@ var ts;
             if (host.afterProgramCreate && program !== builderProgram) {
                 host.afterProgramCreate(builderProgram);
             }
-            compilerHost.readFile = originalReadFile;
-            compilerHost.fileExists = originalFileExists;
-            compilerHost.directoryExists = originalDirectoryExists;
-            compilerHost.createDirectory = originalCreateDirectory;
-            compilerHost.writeFile = originalWriteFile;
             return builderProgram;
         }
         function createNewProgram(hasInvalidatedResolution) {
@@ -125780,16 +124895,19 @@ var ts;
             writeLog("  options: " + JSON.stringify(compilerOptions));
             if (projectReferences)
                 writeLog("  projectReferences: " + JSON.stringify(projectReferences));
+            var needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !getCurrentProgram();
             hasChangedCompilerOptions = false;
             hasChangedConfigFileParsingErrors = false;
             resolutionCache.startCachingPerDirectoryResolution();
             compilerHost.hasInvalidatedResolution = hasInvalidatedResolution;
             compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
-            var oldProgram = getCurrentProgram();
             builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
-            resolutionCache.finishCachingPerDirectoryResolution(builderProgram.getProgram(), oldProgram);
+            resolutionCache.finishCachingPerDirectoryResolution();
             // Update watches
             ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = new ts.Map()), watchMissingFilePath);
+            if (needsUpdateInTypeRootWatch) {
+                resolutionCache.updateTypeRootsWatch();
+            }
             if (missingFilePathsRequestedForRelease) {
                 // These are the paths that program creater told us as not in use any more but were missing on the disk.
                 // We didnt remove the entry for them from sourceFiles cache so that we dont have to do File IO,
@@ -125866,6 +124984,9 @@ var ts;
                         sourceFilesCache.set(path, false);
                     }
                 }
+                if (sourceFile) {
+                    sourceFile.impliedNodeFormat = ts.getImpliedNodeFormatForFile(path, resolutionCache.getModuleResolutionCache().getPackageJsonInfoCache(), compilerHost, compilerHost.getCompilationSettings());
+                }
                 return sourceFile;
             }
             return hostSourceFile.sourceFile;
@@ -125886,7 +125007,7 @@ var ts;
             var hostSourceFile = sourceFilesCache.get(path);
             return !hostSourceFile || !hostSourceFile.version ? undefined : hostSourceFile.version;
         }
-        function onReleaseOldSourceFile(oldSourceFile) {
+        function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
             var hostSourceFileInfo = sourceFilesCache.get(oldSourceFile.resolvedPath);
             // If this is the source file thats in the cache and new program doesnt need it,
             // remove the cached entry.
@@ -125902,6 +125023,9 @@ var ts;
                         hostSourceFileInfo.fileWatcher.close();
                     }
                     sourceFilesCache.delete(oldSourceFile.resolvedPath);
+                    if (!hasSourceFileByPath) {
+                        resolutionCache.removeResolutionsOfFile(oldSourceFile.path);
+                    }
                 }
             }
         }
@@ -126158,6 +125282,7 @@ var ts;
                         var config = parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.get(projectPath);
                         if (config)
                             config.reloadLevel = ts.ConfigFileProgramReloadLevel.Full;
+                        resolutionCache.removeResolutionsFromProjectReferenceRedirects(projectPath);
                     }
                     scheduleProgramUpdate();
                 });
@@ -126171,6 +125296,7 @@ var ts;
                 var config = parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.get(configPath);
                 if (config)
                     config.reloadLevel = ts.ConfigFileProgramReloadLevel.Full;
+                resolutionCache.removeResolutionsFromProjectReferenceRedirects(configPath);
                 scheduleProgramUpdate();
             }, ts.PollingInterval.High, ((_a = commandLine.parsedCommandLine) === null || _a === void 0 ? void 0 : _a.watchOptions) || watchOptions, ts.WatchType.ConfigFileOfReferencedProject));
             // Watch Wild card
@@ -126376,23 +125502,20 @@ var ts;
         compilerHost.getParsedCommandLine = function (fileName) { return parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName)); };
         compilerHost.resolveModuleNames = ts.maybeBind(host, host.resolveModuleNames);
         compilerHost.resolveTypeReferenceDirectives = ts.maybeBind(host, host.resolveTypeReferenceDirectives);
-        compilerHost.getModuleResolutionCache = ts.maybeBind(host, host.getModuleResolutionCache);
-        compilerHost.getTypeReferenceDirectiveResolutionCache = ts.maybeBind(host, host.getTypeReferenceDirectiveResolutionCache);
         var moduleResolutionCache = !compilerHost.resolveModuleNames ? ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName) : undefined;
         var typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, /*options*/ undefined, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : undefined;
         if (!compilerHost.resolveModuleNames) {
-            var loader_3 = function (moduleName, resolverMode, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode); };
-            compilerHost.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile, partialResolutionInfo) {
-                return ts.loadWithModeAwareCache(moduleNames, ts.Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, partialResolutionInfo, loader_3);
+            var loader_3 = function (moduleName, resolverMode, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule; };
+            compilerHost.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile) {
+                return ts.loadWithModeAwareCache(ts.Debug.checkEachDefined(moduleNames), ts.Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, loader_3);
             };
             compilerHost.getModuleResolutionCache = function () { return moduleResolutionCache; };
         }
         if (!compilerHost.resolveTypeReferenceDirectives) {
-            var loader_4 = function (moduleName, containingFile, redirectedReference, containingFileMode) { return ts.resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode); };
+            var loader_4 = function (moduleName, containingFile, redirectedReference, containingFileMode) { return ts.resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode).resolvedTypeReferenceDirective; };
             compilerHost.resolveTypeReferenceDirectives = function (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) {
-                return ts.loadWithTypeDirectiveCache(typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode, loader_4);
+                return ts.loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_4);
             };
-            compilerHost.getTypeReferenceDirectiveResolutionCache = function () { return typeReferenceDirectiveResolutionCache; };
         }
         compilerHost.getBuildInfo = function (fileName, configFilePath) { return getBuildInfo(state, fileName, toResolvedConfigFilePath(state, configFilePath), /*modifiedTime*/ undefined); };
         var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog;
@@ -127380,7 +126503,7 @@ var ts;
             if (buildInfoTime && buildInfoTime < inputTime) {
                 var version_3 = void 0;
                 var currentVersion = void 0;
-                if (buildInfoProgram === null || buildInfoProgram === void 0 ? void 0 : buildInfoProgram.fileInfos) {
+                if (buildInfoProgram) {
                     // Read files and see if they are same, read is anyways cached
                     if (!buildInfoVersionMap)
                         buildInfoVersionMap = ts.getBuildInfoFileVersionMap(buildInfoProgram, buildInfoPath, host);