@typescript-deploys/pr-build 4.9.0-pr-50248-2 → 4.9.0-pr-50247-2

package/lib/tsc.js

@@ -6645,6 +6645,8 @@ var ts;
         Found_1_error_in_1: diag(6259, ts.DiagnosticCategory.Message, "Found_1_error_in_1_6259", "Found 1 error in {1}"),
         Found_0_errors_in_the_same_file_starting_at_Colon_1: diag(6260, ts.DiagnosticCategory.Message, "Found_0_errors_in_the_same_file_starting_at_Colon_1_6260", "Found {0} errors in the same file, starting at: {1}"),
         Found_0_errors_in_1_files: diag(6261, ts.DiagnosticCategory.Message, "Found_0_errors_in_1_files_6261", "Found {0} errors in {1} files."),
+        Directory_0_resolves_to_1_scope_according_to_cache: diag(6263, ts.DiagnosticCategory.Message, "Directory_0_resolves_to_1_scope_according_to_cache_6263", "Directory '{0}' resolves to '{1}' scope according to cache."),
+        Directory_0_has_no_containing_package_json_scope_according_to_cache: diag(6264, ts.DiagnosticCategory.Message, "Directory_0_has_no_containing_package_json_scope_according_to_cache_6264", "Directory '{0}' has no containing package.json scope according to cache."),
         Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, ts.DiagnosticCategory.Message, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
         Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, ts.DiagnosticCategory.Message, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
         Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, ts.DiagnosticCategory.Message, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
@@ -6828,6 +6830,7 @@ 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:"),
@@ -10965,7 +10968,8 @@ var ts;
     }
     ts.changesAffectModuleResolution = changesAffectModuleResolution;
     function optionsHaveModuleResolutionChanges(oldOptions, newOptions) {
-        return optionsHaveChanges(oldOptions, newOptions, ts.moduleResolutionOptionDeclarations);
+        return oldOptions.pathsBasePath !== newOptions.pathsBasePath ||
+            optionsHaveChanges(oldOptions, newOptions, ts.moduleResolutionOptionDeclarations);
     }
     ts.optionsHaveModuleResolutionChanges = optionsHaveModuleResolutionChanges;
     function changesAffectingProgramStructure(oldOptions, newOptions) {
@@ -11037,21 +11041,20 @@ var ts;
     }
     ts.getFullWidth = getFullWidth;
     function getResolvedModule(sourceFile, moduleNameText, mode) {
-        return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(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;
     }
     ts.getResolvedModule = getResolvedModule;
     function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) {
-        if (!sourceFile.resolvedModules) {
-            sourceFile.resolvedModules = ts.createModeAwareCache();
-        }
+        var _a;
+        (_a = sourceFile.resolvedModules) !== null && _a !== void 0 ? _a : (sourceFile.resolvedModules = ts.createModeAwareCache());
         sourceFile.resolvedModules.set(moduleNameText, mode, resolvedModule);
     }
     ts.setResolvedModule = setResolvedModule;
-    function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) {
-        if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
-            sourceFile.resolvedTypeReferenceDirectiveNames = ts.createModeAwareCache();
-        }
-        sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, undefined, resolvedTypeReferenceDirective);
+    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);
     }
     ts.setResolvedTypeReferenceDirective = setResolvedTypeReferenceDirective;
     function projectReferenceIsEqualTo(oldRef, newRef) {
@@ -11061,11 +11064,15 @@ var ts;
     }
     ts.projectReferenceIsEqualTo = projectReferenceIsEqualTo;
     function moduleResolutionIsEqualTo(oldResolution, newResolution) {
-        return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport &&
-            oldResolution.extension === newResolution.extension &&
-            oldResolution.resolvedFileName === newResolution.resolvedFileName &&
-            oldResolution.originalPath === newResolution.originalPath &&
-            packageIdIsEqual(oldResolution.packageId, newResolution.packageId);
+        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);
     }
     ts.moduleResolutionIsEqualTo = moduleResolutionIsEqualTo;
     function packageIdIsEqual(a, b) {
@@ -11081,9 +11088,13 @@ var ts;
     }
     ts.packageIdToString = packageIdToString;
     function typeDirectiveIsEqualTo(oldResolution, newResolution) {
-        return oldResolution.resolvedFileName === newResolution.resolvedFileName
-            && oldResolution.primary === newResolution.primary
-            && oldResolution.originalPath === newResolution.originalPath;
+        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;
     }
     ts.typeDirectiveIsEqualTo = typeDirectiveIsEqualTo;
     function hasChangesInResolutions(names, newResolutions, oldResolutions, oldSourceFile, comparer) {
@@ -15282,22 +15293,20 @@ var ts;
         return getStringFromExpandedCharCodes(expandedCharCodes);
     }
     ts.base64decode = base64decode;
-    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) {
+    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) {
             return {};
         }
+        return result.config;
     }
-    ts.readJson = readJson;
+    ts.readJsonIgnoringErrorsFromText = readJsonIgnoringErrorsFromText;
     function directoryProbablyExists(directoryName, host) {
         return !host.directoryExists || host.directoryExists(directoryName);
     }
@@ -16275,14 +16284,15 @@ var ts;
             },
             setSymlinksFromResolutions: function (files, typeReferenceDirectives) {
                 var _this = this;
-                var _a;
+                var _a, _b;
                 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); });
+                    (_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); });
                 }
-                typeReferenceDirectives === null || typeReferenceDirectives === void 0 ? void 0 : typeReferenceDirectives.forEach(function (resolution) { return processResolution(_this, resolution); });
+                typeReferenceDirectives.forEach(function (resolution) { return processResolution(_this, resolution.resolvedTypeReferenceDirective); });
             },
             hasProcessedResolutions: function () { return hasProcessedResolutions; },
         };
@@ -32193,6 +32203,17 @@ 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",
@@ -34149,6 +34170,9 @@ var ts;
         if (result.configFilePath) {
             result.configFilePath = toAbsolutePath(result.configFilePath);
         }
+        if (result.pathsBasePath) {
+            result.pathsBasePath = toAbsolutePath(result.pathsBasePath);
+        }
         return result;
     }
     ts.convertToOptionsWithAbsolutePaths = convertToOptionsWithAbsolutePaths;
@@ -34974,20 +34998,35 @@ var ts;
         ts.Debug.assert(ts.extensionIsTS(resolved.extension));
         return { fileName: resolved.path, packageId: resolved.packageId };
     }
-    function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
-        var _a, _b;
+    function createResolvedModuleWithFailedLookupLocations(compilerOptions, resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
+        var _a;
+        var _b;
         if (resultFromCache) {
-            (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations);
-            (_b = resultFromCache.affectingLocations).push.apply(_b, affectingLocations);
+            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);
             return resultFromCache;
         }
         return {
             resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId },
-            failedLookupLocations: failedLookupLocations,
-            affectingLocations: affectingLocations,
-            resolutionDiagnostics: diagnostics,
+            failedLookupLocations: !compilerOptions.cacheResolutions || !(resolved === null || resolved === void 0 ? void 0 : resolved.path) ? failedLookupLocations : ts.emptyArray,
+            affectingLocations: initializeResolutionField(affectingLocations),
+            resolutionDiagnostics: initializeResolutionField(diagnostics),
         };
     }
+    function initializeResolutionField(value) {
+        return value.length ? value : undefined;
+    }
+    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) {
@@ -35126,8 +35165,7 @@ var ts;
             options = redirectedReference.commandLine.options;
         }
         var containingDirectory = containingFile ? ts.getDirectoryPath(containingFile) : undefined;
-        var perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : undefined;
-        var result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, resolutionMode);
+        var result = containingDirectory ? cache === null || cache === void 0 ? void 0 : cache.getFromCache(containingDirectory, typeReferenceDirectiveName, resolutionMode, redirectedReference) : undefined;
         if (result) {
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);
@@ -35178,7 +35216,7 @@ var ts;
             features: features,
             conditions: conditions,
             requestContainingDirectory: containingDirectory,
-            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var resolved = primaryLookup();
         var primary = true;
@@ -35198,8 +35236,15 @@ var ts;
                 isExternalLibraryImport: pathContainsNodeModules(fileName),
             };
         }
-        result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, affectingLocations: affectingLocations, resolutionDiagnostics: diagnostics };
-        perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, resolutionMode, result);
+        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, resolutionMode, result);
+        }
         if (traceEnabled)
             traceResult(result);
         return result;
@@ -35209,10 +35254,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() {
@@ -35292,7 +35337,7 @@ var ts;
                             var typeDirectivePath = _b[_a];
                             var normalized = ts.normalizePath(typeDirectivePath);
                             var packageJsonPath = ts.combinePaths(root, normalized, "package.json");
-                            var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJson(packageJsonPath, host).typings === null;
+                            var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJsonIgnoringErrors(packageJsonPath, host).typings === null;
                             if (!isNotNeededPackage) {
                                 var baseFileName = ts.getBaseFileName(normalized);
                                 if (baseFileName.charCodeAt(0) !== 46) {
@@ -35307,62 +35352,181 @@ var ts;
         return result;
     }
     ts.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames;
-    function createCacheWithRedirects(options) {
-        var ownMap = new ts.Map();
+    function getPackageJsconLocationFromScope(scope) {
+        return ts.lastOrUndefined(scope.affectingLocations);
+    }
+    ts.getPackageJsconLocationFromScope = getPackageJsconLocationFromScope;
+    function compilerOptionValueToString(value) {
+        var _a;
+        if (value === null || typeof value !== "object") {
+            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 + "}";
+    }
+    function getKeyForCompilationSettings(settings, options) {
+        return options.map(function (option) { return compilerOptionValueToString(ts.getCompilerOptionValue(settings, option)); }).join("|") + ("|" + settings.pathsBasePath);
+    }
+    ts.getKeyForCompilationSettings = getKeyForCompilationSettings;
+    function getRedirectsCacheKey(options) {
+        return getKeyForCompilationSettings(options, ts.moduleResolutionOptionDeclarations);
+    }
+    ts.getRedirectsCacheKey = getRedirectsCacheKey;
+    function createCacheWithRedirects(ownOptions) {
+        var ownMap;
+        var ownKey;
+        var redirectsKeyToCache = new ts.Map();
         var redirectsMap = new ts.Map();
         return {
             getOwnMap: getOwnMap,
-            redirectsMap: redirectsMap,
+            redirectsKeyToCache: redirectsKeyToCache,
+            createMapForCompilerOptions: createMapForCompilerOptions,
+            getMapOfCacheRedirects: getMapOfCacheRedirects,
             getOrCreateMapOfCacheRedirects: getOrCreateMapOfCacheRedirects,
             clear: clear,
-            setOwnOptions: setOwnOptions,
-            setOwnMap: setOwnMap
+            update: update,
+            clearRedirectsMap: function () { return redirectsMap.clear(); },
         };
-        function getOwnMap() {
-            return ownMap;
+        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 setOwnOptions(newOptions) {
-            options = newOptions;
+        function createMapForCompilerOptions(options, optionsKey) {
+            if (options === ownOptions)
+                return ownMap !== null && ownMap !== void 0 ? ownMap : (ownMap = new ts.Map());
+            return getOrCreateRedirectMapAndKey(options, undefined, optionsKey);
         }
-        function setOwnMap(newOwnMap) {
-            ownMap = newOwnMap;
+        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 getOrCreateMapOfCacheRedirects(redirectedReference) {
-            if (!redirectedReference) {
-                return ownMap;
+        function getOwnMap() {
+            return ownMap !== null && ownMap !== void 0 ? ownMap : (ownMap = new ts.Map());
+        }
+        function update(newOwnOptions) {
+            if (ownMap && (ownOptions === null || ownOptions === void 0 ? void 0 : ownOptions.configFile)) {
+                ensureOwnKeyCached();
+                if (!redirectsMap.has(ownOptions.configFile.path)) {
+                    redirectsMap.set(ownOptions.configFile.path, ownMap);
+                }
             }
-            var path = redirectedReference.sourceFile.path;
-            var redirects = redirectsMap.get(path);
-            if (!redirects) {
-                redirects = !options || ts.optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? new ts.Map() : ownMap;
-                redirectsMap.set(path, redirects);
+            if (newOwnOptions.configFile) {
+                var existing_1 = redirectsMap.get(newOwnOptions.configFile.path);
+                if (existing_1) {
+                    ownMap = existing_1;
+                    ownOptions = newOwnOptions;
+                    return;
+                }
             }
-            return redirects;
+            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 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);
+                return ownMap;
+            }
+            return undefined;
+        }
+        function getOrCreateMapOfCacheRedirects(redirectedReference) {
+            return !redirectedReference || redirectedReference.commandLine.options === ownOptions ?
+                getOwnMap() :
+                getOrCreateRedirectMapAndKey(redirectedReference.commandLine.options, redirectedReference.sourceFile.path, undefined);
         }
         function clear() {
-            ownMap.clear();
+            ownKey = undefined;
+            ownMap = undefined;
             redirectsMap.clear();
+            redirectsKeyToCache.clear();
         }
     }
     ts.createCacheWithRedirects = createCacheWithRedirects;
-    function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
-        var cache;
-        return { getPackageJsonInfo: getPackageJsonInfo, setPackageJsonInfo: setPackageJsonInfo, clear: clear, entries: entries, getInternalMap: getInternalMap };
+    function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName, cache) {
+        var dirToPackageJsonScope = new ts.Map();
+        var oldPackageJsonInfoCache;
+        return {
+            getPackageJsonInfo: getPackageJsonInfo,
+            setPackageJsonInfo: setPackageJsonInfo,
+            clear: clear,
+            entries: entries,
+            getInternalMap: function () { return cache; },
+            setInternalMap: function (value) { return cache = value; },
+            clone: clone,
+            getPackageJsonScope: getPackageJsonScope,
+            setPackageJsonScope: setPackageJsonScope,
+            setOldPackageJsonScopeCache: function (cache) { return oldPackageJsonInfoCache = cache; },
+        };
         function getPackageJsonInfo(packageJsonPath) {
-            return cache === null || cache === void 0 ? void 0 : cache.get(ts.toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
+            return cache === null || cache === void 0 ? void 0 : cache.get(toPath(packageJsonPath));
         }
         function setPackageJsonInfo(packageJsonPath, info) {
-            (cache || (cache = new ts.Map())).set(ts.toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info);
+            (cache || (cache = new ts.Map())).set(toPath(packageJsonPath), info);
         }
         function clear() {
+            oldPackageJsonInfoCache = undefined;
             cache = undefined;
+            dirToPackageJsonScope.clear();
         }
         function entries() {
             var iter = cache === null || cache === void 0 ? void 0 : cache.entries();
             return iter ? ts.arrayFrom(iter) : [];
         }
-        function getInternalMap() {
-            return cache;
+        function clone() {
+            return createPackageJsonInfoCache(currentDirectory, getCanonicalFileName, cache && new ts.Map(cache));
+        }
+        function getPackageJsonScope(dir) {
+            return dirToPackageJsonScope.get(dir) || (oldPackageJsonInfoCache === null || oldPackageJsonInfoCache === void 0 ? void 0 : oldPackageJsonInfoCache.getPackageJsonScope(dir));
+        }
+        function setPackageJsonScope(dir, scope) {
+            moduleNameToDirectorySet(dirToPackageJsonScope, dir, scope, getPackageJsconLocationFromScope, toPath, ts.noop);
+        }
+        function toPath(file) {
+            return ts.toPath(file, currentDirectory, getCanonicalFileName);
         }
     }
     function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
@@ -35374,45 +35538,43 @@ var ts;
         }
         return result;
     }
-    function updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
-        if (!options.configFile)
-            return;
-        if (directoryToModuleNameMap.redirectsMap.size === 0) {
-            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 {
-            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) {
+    function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options) {
+        var directoryToModuleNameMap = createCacheWithRedirects(options);
+        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) {
-            updateRedirectsMap(options, directoryToModuleNameMap);
+            directoryToModuleNameMap.update(options);
         }
         function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
             var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName);
-            return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, function () { return createModeAwareCache(); });
+            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;
         }
     }
+    function getModeAwareCacheKey(specifier, mode) {
+        return (mode === undefined ? specifier : mode + "|" + specifier);
+    }
+    ts.getModeAwareCacheKey = getModeAwareCacheKey;
     function createModeAwareCache() {
         var underlying = new ts.Map();
         var memoizedReverseKeys = new ts.Map();
@@ -35437,13 +35599,22 @@ 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 = mode === undefined ? specifier : mode + "|" + specifier;
+            var result = getModeAwareCacheKey(specifier, mode);
             memoizedReverseKeys.set(result, [specifier, mode]);
             return result;
         }
@@ -35454,100 +35625,122 @@ var ts;
         var map = createModeAwareCache();
         for (var i = 0; i < keys.length; ++i) {
             var entry = keys[i];
-            var name = !ts.isString(entry) ? entry.fileName.toLowerCase() : entry;
+            var name = !ts.isString(entry) ? ts.toFileNameLowerCase(entry.fileName) : 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 createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
-        var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
-        moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options));
+    function getCommonPrefix(directory, resolution, toPath) {
+        var resolutionDirectory = toPath(ts.getDirectoryPath(resolution));
+        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 getResolvedFileNameForModuleNameToDirectorySet(result) {
+        return result.resolvedModule &&
+            (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
+    }
+    ts.getResolvedFileNameForModuleNameToDirectorySet = getResolvedFileNameForModuleNameToDirectorySet;
+    function moduleNameToDirectorySet(directoryPathMap, directory, result, getResolvedFileName, toPath, ancestoryWorker) {
+        if (directoryPathMap.has(directory))
+            return;
+        directoryPathMap.set(directory, result);
+        var resolvedFileName = getResolvedFileName(result);
+        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 moduleNameToDirectoryMap = createCacheWithRedirects(options);
+        var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options);
         var packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
-        return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; }, clearAllExceptPackageJsonInfoCache: clearAllExceptPackageJsonInfoCache });
+        var oldResolutionCache;
+        return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, getFromModuleNameCache: getFromModuleNameCache, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; }, setOldResolutionCache: setOldResolutionCache });
         function clear() {
-            clearAllExceptPackageJsonInfoCache();
-            packageJsonInfoCache.clear();
-        }
-        function clearAllExceptPackageJsonInfoCache() {
+            oldResolutionCache = undefined;
             perDirectoryResolutionCache.clear();
             moduleNameToDirectoryMap.clear();
+            packageJsonInfoCache.clear();
         }
         function update(options) {
-            updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap);
+            perDirectoryResolutionCache.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;
         }
         function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) {
             ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName));
-            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === undefined ? nonRelativeModuleName : mode + "|" + nonRelativeModuleName, createPerModuleNameCache);
+            return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, getModeAwareCacheKey(nonRelativeModuleName, mode), createPerModuleNameCache);
         }
         function createPerModuleNameCache() {
             var directoryPathMap = new ts.Map();
             return { get: get, set: set };
             function get(directory) {
-                return directoryPathMap.get(ts.toPath(directory, currentDirectory, getCanonicalFileName));
+                return directoryPathMap.get(toPath(directory));
             }
             function set(directory, result) {
-                var path = ts.toPath(directory, currentDirectory, getCanonicalFileName);
-                if (directoryPathMap.has(path)) {
-                    return;
-                }
-                directoryPathMap.set(path, result);
-                var resolvedFileName = result.resolvedModule &&
-                    (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
-                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);
-                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));
+                return moduleNameToDirectorySet(directoryPathMap, toPath(directory), result, getResolvedFileNameForModuleNameToDirectorySet, toPath, ts.noop);
             }
         }
+        function toPath(fileName) {
+            return ts.toPath(fileName, currentDirectory, getCanonicalFileName);
+        }
     }
     ts.createModuleResolutionCache = createModuleResolutionCache;
-    function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, directoryToModuleNameMap) {
-        var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
+    function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache) {
+        var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options);
         packageJsonInfoCache || (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName));
-        return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { clear: clear, clearAllExceptPackageJsonInfoCache: clearAllExceptPackageJsonInfoCache });
+        return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { clear: clear });
         function clear() {
-            clearAllExceptPackageJsonInfoCache();
-            packageJsonInfoCache.clear();
-        }
-        function clearAllExceptPackageJsonInfoCache() {
             perDirectoryResolutionCache.clear();
+            packageJsonInfoCache.clear();
         }
     }
     ts.createTypeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache;
     function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
         var containingDirectory = ts.getDirectoryPath(containingFile);
-        var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
-        if (!perFolderCache)
-            return undefined;
-        return perFolderCache.get(moduleName, mode);
+        return cache === null || cache === void 0 ? void 0 : cache.getFromCache(containingDirectory, moduleName, mode);
     }
     ts.resolveModuleNameFromCache = resolveModuleNameFromCache;
     function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
@@ -35562,8 +35755,7 @@ var ts;
             }
         }
         var containingDirectory = ts.getDirectoryPath(containingFile);
-        var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
-        var result = perFolderCache && perFolderCache.get(moduleName, resolutionMode);
+        var result = cache === null || cache === void 0 ? void 0 : cache.getFromCache(containingDirectory, moduleName, resolutionMode, redirectedReference);
         if (result) {
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -35615,8 +35807,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 (perFolderCache) {
-                perFolderCache.set(moduleName, resolutionMode, result);
+            if (cache) {
+                cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, result);
                 if (!ts.isExternalModuleNameRelative(moduleName)) {
                     cache.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
                 }
@@ -35820,10 +36012,10 @@ var ts;
             features: features,
             conditions: conditions,
             requestContainingDirectory: containingDirectory,
-            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
-        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);
+        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);
         function tryResolve(extensions) {
             var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, true); };
             var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state);
@@ -36159,21 +36351,42 @@ var ts;
             features: NodeResolutionFeatures.None,
             conditions: ts.emptyArray,
             requestContainingDirectory: undefined,
-            reportDiagnostic: ts.noop
+            reportResolutionDiagnostic: ts.noop
         };
     }
     ts.getTemporaryModuleResolutionState = getTemporaryModuleResolutionState;
-    function getPackageScopeForPath(fileName, state) {
-        var parts = ts.getPathComponents(fileName);
-        parts.pop();
-        while (parts.length > 0) {
-            var pkg = getPackageJsonInfo(ts.getPathFromPathComponents(parts), false, state);
-            if (pkg) {
-                return pkg;
-            }
-            parts.pop();
-        }
-        return undefined;
+    function getPackageScope(dir, packageJsonInfoCache, host, options) {
+        var state = getTemporaryModuleResolutionState(packageJsonInfoCache, host, options);
+        var failedLookupLocations = [];
+        var affectingLocations = [];
+        state.failedLookupLocations = failedLookupLocations;
+        state.affectingLocations = affectingLocations;
+        var result = ts.forEachAncestorDirectory(dir, function (directory) {
+            var _a;
+            var fromCache = (_a = state.packageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.getPackageJsonScope(directory);
+            if (fromCache) {
+                var host_1 = state.host, traceEnabled = state.traceEnabled;
+                if (traceEnabled) {
+                    trace(host_1, fromCache.info ?
+                        ts.Diagnostics.Directory_0_resolves_to_1_scope_according_to_cache :
+                        ts.Diagnostics.Directory_0_has_no_containing_package_json_scope_according_to_cache, directory, getPackageJsconLocationFromScope(fromCache));
+                }
+                return fromCache;
+            }
+            var info = getPackageJsonInfo(directory, false, state);
+            if (info)
+                return { info: info };
+        }) || { info: undefined };
+        result.failedLookupLocations = updateResolutionField(result.failedLookupLocations, !options.cacheResolutions || !result.info ? failedLookupLocations : undefined);
+        result.affectingLocations = updateResolutionField(result.affectingLocations, affectingLocations);
+        packageJsonInfoCache === null || packageJsonInfoCache === void 0 ? void 0 : packageJsonInfoCache.setPackageJsonScope(dir, result);
+        return result;
+    }
+    ts.getPackageScope = getPackageScope;
+    function getPackageScopeForPath(dir, state) {
+        return ts.forEachAncestorDirectory(dir, function (directory) {
+            return getPackageJsonInfo(directory, false, state);
+        });
     }
     ts.getPackageScopeForPath = getPackageScopeForPath;
     function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
@@ -36201,12 +36414,13 @@ var ts;
         }
         var directoryExists = ts.directoryProbablyExists(packageDirectory, host);
         if (directoryExists && host.fileExists(packageJsonPath)) {
-            var packageJsonContent = ts.readJson(packageJsonPath, host);
+            var packageJsonText = host.readFile(packageJsonPath);
+            var packageJsonContent = ts.readJsonIgnoringErrorsFromText(packageJsonPath, packageJsonText);
             if (traceEnabled) {
                 trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath);
             }
             var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
-            var result = { packageDirectory: packageDirectory, packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined };
+            var result = { packageDirectory: packageDirectory, packageJsonText: packageJsonText, 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;
@@ -36319,7 +36533,7 @@ var ts;
     function loadModuleFromSelfNameReference(extensions, moduleName, directory, state, cache, redirectedReference) {
         var _a, _b;
         var useCaseSensitiveFileNames = typeof state.host.useCaseSensitiveFileNames === "function" ? state.host.useCaseSensitiveFileNames() : state.host.useCaseSensitiveFileNames;
-        var directoryPath = ts.toPath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
+        var directoryPath = ts.toPath(directory, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
         var scope = getPackageScopeForPath(directoryPath, state);
         if (!scope || !scope.packageJsonContent.exports) {
             return undefined;
@@ -36378,7 +36592,7 @@ var ts;
             return toSearchResult(undefined);
         }
         var useCaseSensitiveFileNames = typeof state.host.useCaseSensitiveFileNames === "function" ? state.host.useCaseSensitiveFileNames() : state.host.useCaseSensitiveFileNames;
-        var directoryPath = ts.toPath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
+        var directoryPath = ts.toPath(directory, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
         var scope = getPackageScopeForPath(directoryPath, state);
         if (!scope) {
             if (state.traceEnabled) {
@@ -36578,11 +36792,8 @@ var ts;
                             fragment = ts.ensureTrailingDirectorySeparator(commonDir_1);
                         }
                     }
-                    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, packagePath));
-                    }
+                    if (commonSourceDirGuesses.length > 1)
+                        state.reportResolutionDiagnostic({ isImports: isImports, entry: entry, packagePath: packagePath });
                     for (var _i = 0, commonSourceDirGuesses_1 = commonSourceDirGuesses; _i < commonSourceDirGuesses_1.length; _i++) {
                         var commonSourceDirGuess = commonSourceDirGuesses_1[_i];
                         var candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
@@ -36647,10 +36858,10 @@ var ts;
         return loadModuleFromNearestNodeModulesDirectoryWorker(Extensions.DtsOnly, moduleName, directory, state, true, undefined, undefined);
     }
     function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
-        var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? undefined : state.features & NodeResolutionFeatures.EsmMode ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS, redirectedReference);
+        var mode = state.features === 0 ? undefined : state.features & NodeResolutionFeatures.EsmMode ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
         return ts.forEachAncestorDirectory(ts.normalizeSlashes(directory), function (ancestorDirectory) {
             if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
-                var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
+                var resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state);
                 if (resolutionFromCache) {
                     return resolutionFromCache;
                 }
@@ -36787,8 +36998,8 @@ var ts;
             typesPackageName;
     }
     ts.unmangleScopedPackageName = unmangleScopedPackageName;
-    function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) {
-        var result = cache && cache.get(containingDirectory);
+    function tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, containingDirectory, redirectedReference, state) {
+        var result = cache === null || cache === void 0 ? void 0 : cache.getFromModuleNameCache(containingDirectory, moduleName, mode, redirectedReference);
         if (result) {
             if (state.traceEnabled) {
                 trace(state.host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -36813,19 +37024,18 @@ var ts;
             features: NodeResolutionFeatures.None,
             conditions: [],
             requestContainingDirectory: containingDirectory,
-            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript);
-        return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, false, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(compilerOptions, resolved && resolved.value, false, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
         function tryResolve(extensions) {
             var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
             if (resolvedUsingSettings) {
                 return { value: resolvedUsingSettings };
             }
             if (!ts.isExternalModuleNameRelative(moduleName)) {
-                var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, undefined, redirectedReference);
                 var resolved_3 = ts.forEachAncestorDirectory(containingDirectory, function (directory) {
-                    var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache_1, moduleName, directory, state);
+                    var resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, undefined, directory, redirectedReference, state);
                     if (resolutionFromCache) {
                         return resolutionFromCache;
                     }
@@ -36864,10 +37074,10 @@ var ts;
             features: NodeResolutionFeatures.None,
             conditions: [],
             requestContainingDirectory: undefined,
-            reportDiagnostic: function (diag) { return void diagnostics.push(diag); },
+            reportResolutionDiagnostic: function (diag) { return void diagnostics.push(diag); },
         };
         var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, false, undefined, undefined);
-        return createResolvedModuleWithFailedLookupLocations(resolved, true, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
+        return createResolvedModuleWithFailedLookupLocations(compilerOptions, resolved, true, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache);
     }
     ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache;
     function toSearchResult(value) {
@@ -39880,9 +40090,10 @@ var ts;
             host.getSourceFiles().forEach(function (sf) {
                 if (!sf.resolvedModules)
                     return;
-                sf.resolvedModules.forEach(function (r) {
-                    if (r && r.packageId)
-                        map.set(r.packageId.name, r.extension === ".d.ts" || !!map.get(r.packageId.name));
+                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" || !!map.get(resolvedModule.packageId.name));
                 });
             });
             return map;
@@ -42477,7 +42688,7 @@ var ts;
                 : undefined;
         }
         function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
             if (isForAugmentation === void 0) { isForAugmentation = false; }
             if (ts.startsWith(moduleReference, "@types/")) {
                 var diag = ts.Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
@@ -42523,7 +42734,7 @@ var ts;
                                 var diagnosticDetails = void 0;
                                 var ext = ts.tryGetExtensionFromPath(currentSourceFile.fileName);
                                 if (ext === ".ts" || ext === ".js" || ext === ".tsx" || ext === ".jsx") {
-                                    var scope = currentSourceFile.packageJsonScope;
+                                    var scope = (_h = currentSourceFile.packageJsonScope) === null || _h === void 0 ? void 0 : _h.info;
                                     var targetExt = ext === ".ts" ? ".mts" : ext === ".js" ? ".mjs" : undefined;
                                     if (scope && !scope.packageJsonContent.type) {
                                         if (targetExt) {
@@ -42607,10 +42818,10 @@ var ts;
                     }
                     else if (mode === ts.ModuleKind.ESNext && resolutionIsNode16OrNext && isExtensionlessRelativePathImport) {
                         var absoluteRef_1 = ts.getNormalizedAbsolutePath(moduleReference, ts.getDirectoryPath(currentSourceFile.path));
-                        var suggestedExt = (_h = suggestedExtensions.find(function (_a) {
+                        var suggestedExt = (_j = suggestedExtensions.find(function (_a) {
                             var actualExt = _a[0], _importExt = _a[1];
                             return host.fileExists(absoluteRef_1 + actualExt);
-                        })) === null || _h === void 0 ? void 0 : _h[1];
+                        })) === null || _j === void 0 ? void 0 : _j[1];
                         if (suggestedExt) {
                             error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0, moduleReference + suggestedExt);
                         }
@@ -72974,12 +73185,12 @@ var ts;
             var parent = node.parent;
             var paramTag = node.parent.parent;
             if (ts.isJSDocTypeExpression(node.parent) && ts.isJSDocParameterTag(paramTag)) {
-                var host_1 = ts.getHostSignatureFromJSDoc(paramTag);
+                var host_2 = ts.getHostSignatureFromJSDoc(paramTag);
                 var isCallbackTag = ts.isJSDocCallbackTag(paramTag.parent.parent);
-                if (host_1 || isCallbackTag) {
+                if (host_2 || isCallbackTag) {
                     var lastParamDeclaration = isCallbackTag
                         ? ts.lastOrUndefined(paramTag.parent.parent.typeExpression.parameters)
-                        : ts.lastOrUndefined(host_1.parameters);
+                        : ts.lastOrUndefined(host_2.parameters);
                     var symbol = ts.getParameterSymbolFromJSDoc(paramTag);
                     if (!lastParamDeclaration ||
                         symbol && lastParamDeclaration.symbol === symbol && ts.isRestParameter(lastParamDeclaration)) {
@@ -74214,11 +74425,12 @@ var ts;
             var fileToDirective;
             if (resolvedTypeReferenceDirectives) {
                 fileToDirective = new ts.Map();
-                resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key, mode) {
-                    if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
+                resolvedTypeReferenceDirectives.forEach(function (_a, key, mode) {
+                    var resolvedTypeReferenceDirective = _a.resolvedTypeReferenceDirective;
+                    if (!resolvedTypeReferenceDirective || !resolvedTypeReferenceDirective.resolvedFileName) {
                         return;
                     }
-                    var file = host.getSourceFile(resolvedDirective.resolvedFileName);
+                    var file = host.getSourceFile(resolvedTypeReferenceDirective.resolvedFileName);
                     if (file) {
                         addReferencedFilesToTypeDirective(file, key, mode);
                     }
@@ -75495,9 +75707,9 @@ var ts;
                 }
                 var parent = ts.walkUpParenthesizedTypes(node.parent);
                 if (ts.isInJSFile(parent) && ts.isJSDocTypeExpression(parent)) {
-                    var host_2 = ts.getJSDocHost(parent);
-                    if (host_2) {
-                        parent = ts.getSingleVariableOfVariableStatement(host_2) || host_2;
+                    var host_3 = ts.getJSDocHost(parent);
+                    if (host_3) {
+                        parent = ts.getSingleVariableOfVariableStatement(host_3) || host_3;
                     }
                 }
                 switch (parent.kind) {
@@ -92014,7 +92226,7 @@ var ts;
                     var sourceMap = sourceMapGenerator.toString();
                     ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles);
                     if (printer.bundleFileInfo)
-                        printer.bundleFileInfo.mapHash = ts.computeSignature(sourceMap, ts.maybeBind(host, host.createHash));
+                        printer.bundleFileInfo.mapHash = ts.computeSignature(sourceMap, host);
                 }
             }
             else {
@@ -92023,7 +92235,7 @@ var ts;
             var text = writer.getText();
             ts.writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos, diagnostics: transform.diagnostics });
             if (printer.bundleFileInfo)
-                printer.bundleFileInfo.hash = ts.computeSignature(text, ts.maybeBind(host, host.createHash));
+                printer.bundleFileInfo.hash = ts.computeSignature(text, host);
             writer.clear();
         }
         function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) {
@@ -92148,7 +92360,6 @@ var ts;
         });
     }
     function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
-        var createHash = ts.maybeBind(host, host.createHash);
         var _a = getOutputPathsForBundle(config.options, false), buildInfoPath = _a.buildInfoPath, jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath;
         var buildInfo;
         if (host.getBuildInfo) {
@@ -92168,22 +92379,22 @@ var ts;
         var jsFileText = host.readFile(ts.Debug.checkDefined(jsFilePath));
         if (!jsFileText)
             return jsFilePath;
-        if (ts.computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash)
+        if (ts.computeSignature(jsFileText, host) !== buildInfo.bundle.js.hash)
             return jsFilePath;
         var sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
         if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap)
             return sourceMapFilePath || "inline sourcemap decoding";
-        if (sourceMapFilePath && ts.computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash)
+        if (sourceMapFilePath && ts.computeSignature(sourceMapText, host) !== buildInfo.bundle.js.mapHash)
             return sourceMapFilePath;
         var declarationText = declarationFilePath && host.readFile(declarationFilePath);
         if (declarationFilePath && !declarationText)
             return declarationFilePath;
-        if (declarationFilePath && ts.computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash)
+        if (declarationFilePath && ts.computeSignature(declarationText, host) !== buildInfo.bundle.dts.hash)
             return declarationFilePath;
         var declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
         if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap)
             return declarationMapPath || "inline sourcemap decoding";
-        if (declarationMapPath && ts.computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
+        if (declarationMapPath && ts.computeSignature(declarationMapText, host) !== 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, true);
@@ -92221,7 +92432,7 @@ var ts;
                         var newBuildInfo = data.buildInfo;
                         newBuildInfo.program = buildInfo.program;
                         if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) {
-                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, createHash, changedDtsData);
+                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, host, changedDtsData);
                         }
                         var _a = buildInfo.bundle, js = _a.js, dts = _a.dts, sourceFiles = _a.sourceFiles;
                         newBuildInfo.bundle.js.sources = js.sources;
@@ -92254,7 +92465,7 @@ var ts;
             getSourceFileFromReference: ts.returnUndefined,
             redirectTargetsMap: ts.createMultiMap(),
             getFileIncludeReasons: ts.notImplemented,
-            createHash: createHash,
+            createHash: ts.maybeBind(host, host.createHash),
         };
         emitFiles(ts.notImplementedResolver, emitHost, undefined, ts.getTransformers(config.options, customTransformers));
         return outputFiles;
@@ -97252,7 +97463,7 @@ var ts;
             var name = names_2[_i];
             var result = void 0;
             var mode = getModeForFileReference(name, containingFileMode);
-            var strName = ts.isString(name) ? name : name.fileName.toLowerCase();
+            var strName = ts.isString(name) ? name : ts.toFileNameLowerCase(name.fileName);
             var cacheKey = mode !== undefined ? mode + "|" + strName : strName;
             if (cache.has(cacheKey)) {
                 result = cache.get(cacheKey);
@@ -97336,7 +97547,21 @@ var ts;
         return elem.value.text === "import" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
     }
     ts.getResolutionModeOverrideForClause = getResolutionModeOverrideForClause;
-    function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, loader) {
+    var emptyResolution = {
+        resolvedModule: undefined,
+        resolvedTypeReferenceDirective: undefined,
+        failedLookupLocations: [],
+        affectingLocations: [],
+        resolutionDiagnostics: [],
+    };
+    function isResolvedModuleWithFailedLookupLocation(resolved) {
+        return !!resolved && !!resolved.failedLookupLocations;
+    }
+    function isResolvedTypeReferenceDirectiveWithFailedLookupLocations(resolved) {
+        return !!resolved && !!resolved.failedLookupLocations;
+    }
+    function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, partialResolutionInfo, loader) {
+        var _a;
         if (names.length === 0) {
             return [];
         }
@@ -97346,7 +97571,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, i);
+            var mode = getModeForResolutionAtIndex(containingFile, (_a = partialResolutionInfo === null || partialResolutionInfo === void 0 ? void 0 : partialResolutionInfo.namesIndex[i]) !== null && _a !== void 0 ? _a : i);
             i++;
             var cacheKey = mode !== undefined ? mode + "|" + name : name;
             if (cache.has(cacheKey)) {
@@ -97404,14 +97629,14 @@ var ts;
     ts.isReferenceFileLocation = isReferenceFileLocation;
     function getReferencedFileLocation(getSourceFileByPath, ref) {
         var _a, _b, _c;
-        var _d, _e, _f, _g;
+        var _d, _e, _f, _g, _h, _j;
         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 = (_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;
+                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;
                 if (importLiteral.pos === -1)
                     return { file: file, packageId: packageId, text: importLiteral.text };
                 pos = ts.skipTrivia(file.text, importLiteral.pos);
@@ -97422,7 +97647,7 @@ var ts;
                 break;
             case ts.FileIncludeKind.TypeReferenceDirective:
                 (_b = file.typeReferenceDirectives[index], pos = _b.pos, end = _b.end, resolutionMode = _b.resolutionMode);
-                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;
+                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;
                 break;
             case ts.FileIncludeKind.LibReferenceDirective:
                 (_c = file.libReferenceDirectives[index], pos = _c.pos, end = _c.end);
@@ -97506,13 +97731,13 @@ var ts;
                 return undefined;
         }
         function lookupFromPackageJson() {
-            var state = ts.getTemporaryModuleResolutionState(packageJsonInfoCache, host, options);
-            var packageJsonLocations = [];
-            state.failedLookupLocations = packageJsonLocations;
-            state.affectingLocations = packageJsonLocations;
-            var packageJsonScope = ts.getPackageScopeForPath(fileName, state);
-            var impliedNodeFormat = (packageJsonScope === null || packageJsonScope === void 0 ? void 0 : packageJsonScope.packageJsonContent.type) === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
-            return { impliedNodeFormat: impliedNodeFormat, packageJsonLocations: packageJsonLocations, packageJsonScope: packageJsonScope };
+            var _a;
+            var packageJsonScope = ts.getPackageScope(ts.getDirectoryPath(fileName), packageJsonInfoCache, host, options);
+            var impliedNodeFormat = ((_a = packageJsonScope.info) === null || _a === void 0 ? void 0 : _a.packageJsonContent.type) === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
+            return {
+                impliedNodeFormat: impliedNodeFormat,
+                packageJsonScope: packageJsonScope,
+            };
         }
     }
     ts.getImpliedNodeFormatForFileWorker = getImpliedNodeFormatForFileWorker;
@@ -97624,10 +97849,10 @@ var ts;
         };
     }
     function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         var createProgramOptions = ts.isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
         var rootNames = createProgramOptions.rootNames, options = createProgramOptions.options, configFileParsingDiagnostics = createProgramOptions.configFileParsingDiagnostics, projectReferences = createProgramOptions.projectReferences;
-        var oldProgram = createProgramOptions.oldProgram;
+        var oldProgramOrOldBuildInfoProgramConstructor = createProgramOptions.oldProgram;
         var processingDefaultLibFiles;
         var processingOtherFiles;
         var files;
@@ -97641,6 +97866,8 @@ var ts;
         var cachedDeclarationDiagnosticsForFile = {};
         var resolvedTypeReferenceDirectives = ts.createModeAwareCache();
         var fileProcessingDiagnostics;
+        var automaticTypeDirectiveNames;
+        var automaticTypeDirectiveResolutions;
         var maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
         var currentNodeModulesDepth = 0;
         var modulesWithElidedImports = new ts.Map();
@@ -97663,29 +97890,72 @@ var ts;
         var actualResolveModuleNamesWorker;
         var hasInvalidatedResolution = host.hasInvalidatedResolution || ts.returnFalse;
         if (host.resolveModuleNames) {
-            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, reusedNames, redirectedReference) { return host.resolveModuleNames(ts.Debug.checkEachDefined(moduleNames), containingFileName, reusedNames, redirectedReference, options, containingFile).map(function (resolved) {
-                if (!resolved || resolved.extension !== undefined) {
-                    return resolved;
-                }
-                var withExtension = ts.clone(resolved);
-                withExtension.extension = ts.extensionFromPath(resolved.resolvedFileName);
-                return withExtension;
-            }); };
+            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 ?
+                            { resolvedModule: resolved, failedLookupLocations: emptyResolution.failedLookupLocations } :
+                            { resolvedModule: __assign(__assign({}, resolved), { extension: ts.extensionFromPath(resolved.resolvedFileName) }), failedLookupLocations: emptyResolution.failedLookupLocations } :
+                        emptyResolution; });
+            };
             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).resolvedModule; };
-            actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, _reusedNames, redirectedReference) { return loadWithModeAwareCache(ts.Debug.checkEachDefined(moduleNames), containingFile, containingFileName, redirectedReference, loader_1); };
+            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 actualResolveTypeReferenceDirectiveNamesWorker;
         if (host.resolveTypeReferenceDirectives) {
-            actualResolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile, redirectedReference, containingFileMode) { return host.resolveTypeReferenceDirectives(ts.Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode); };
+            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);
         }
         else {
             typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, 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).resolvedTypeReferenceDirective; };
-            actualResolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) { return loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_2); };
+            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), false, state_11); },
+            });
+            if (oldBuildInfoProgram) {
+                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);
+                    }
+                });
+                moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache().setOldPackageJsonScopeCache({
+                    getPackageJsonScope: function (dirPath) { return oldBuildInfoProgram === null || oldBuildInfoProgram === void 0 ? void 0 : oldBuildInfoProgram.getPackageJsonScope(dirPath); }
+                });
+            }
         }
         var packageIdToSourceFile = new ts.Map();
         var sourceFileToPackageName = new ts.Map();
@@ -97698,9 +97968,9 @@ var ts;
         var projectReferenceRedirects;
         var mapFromFileToProjectReferenceRedirects;
         var mapFromToProjectReferenceRedirectSource;
-        var useSourceOfProjectReferenceRedirect = !!((_b = host.useSourceOfProjectReferenceRedirect) === null || _b === void 0 ? void 0 : _b.call(host)) &&
+        var useSourceOfProjectReferenceRedirect = !!((_c = host.useSourceOfProjectReferenceRedirect) === null || _c === void 0 ? void 0 : _c.call(host)) &&
             !options.disableSourceOfProjectReferenceRedirect;
-        var _e = updateHostForUseSourceOfProjectReferenceRedirect({
+        var _f = updateHostForUseSourceOfProjectReferenceRedirect({
             compilerHost: host,
             getSymlinkCache: getSymlinkCache,
             useSourceOfProjectReferenceRedirect: useSourceOfProjectReferenceRedirect,
@@ -97708,7 +97978,7 @@ var ts;
             getResolvedProjectReferences: getResolvedProjectReferences,
             getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect,
             forEachResolvedProjectReference: forEachResolvedProjectReference
-        }), onProgramCreateComplete = _e.onProgramCreateComplete, fileExists = _e.fileExists, directoryExists = _e.directoryExists;
+        }), onProgramCreateComplete = _f.onProgramCreateComplete, fileExists = _f.fileExists, directoryExists = _f.directoryExists;
         var readFile = host.readFile.bind(host);
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
         var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
@@ -97717,7 +97987,7 @@ var ts;
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "tryReuseStructureFromOldProgram", {});
         structureIsReused = tryReuseStructureFromOldProgram();
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
-        if (structureIsReused !== 2) {
+        if (structureIsReused !== 3) {
             processingDefaultLibFiles = [];
             processingOtherFiles = [];
             if (projectReferences) {
@@ -97757,14 +98027,14 @@ var ts;
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "processRootFiles", { count: rootNames.length });
             ts.forEach(rootNames, function (name, index) { return processRootFile(name, false, false, { kind: ts.FileIncludeKind.RootFile, index: index }); });
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
-            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", "processTypeReferences", { count: typeReferences.length });
-                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++) {
-                    processTypeReferenceDirective(typeReferences[i], undefined, resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_c = resolutions[i]) === null || _c === void 0 ? void 0 : _c.packageId });
+            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", "processTypeReferences", { count: automaticTypeDirectiveNames.length });
+                var resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(automaticTypeDirectiveNames, getAutomaticTypeDirectiveContainingFile());
+                for (var i = 0; i < automaticTypeDirectiveNames.length; i++) {
+                    automaticTypeDirectiveResolutions.set(automaticTypeDirectiveNames[i], undefined, resolutions[i]);
+                    processTypeReferenceDirective(automaticTypeDirectiveNames[i], undefined, resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: automaticTypeDirectiveNames[i], packageId: (_d = resolutions[i].resolvedTypeReferenceDirective) === null || _d === void 0 ? void 0 : _d.packageId });
                 }
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             }
@@ -97795,13 +98065,13 @@ var ts;
                 var newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
                 if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat ||
                     (oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) {
-                    host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
+                    host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions());
                 }
             }
             if (!host.getParsedCommandLine) {
                 oldProgram.forEachResolvedProjectReference(function (resolvedProjectReference) {
                     if (!getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) {
-                        host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions(), false);
+                        host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions());
                     }
                 });
             }
@@ -97817,6 +98087,8 @@ var ts;
         }
         typeReferenceDirectiveResolutionCache = undefined;
         oldProgram = undefined;
+        oldBuildInfoProgram = undefined;
+        oldProgramOrOldBuildInfoProgramConstructor = undefined;
         var program = {
             getRootFileNames: function () { return rootNames; },
             getSourceFile: getSourceFile,
@@ -97824,6 +98096,7 @@ 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,
@@ -97848,6 +98121,9 @@ 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,
@@ -97857,12 +98133,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,
@@ -97870,7 +98146,7 @@ var ts;
             readFile: readFile,
             directoryExists: directoryExists,
             getSymlinkCache: getSymlinkCache,
-            realpath: (_d = host.realpath) === null || _d === void 0 ? void 0 : _d.bind(host),
+            realpath: (_e = host.realpath) === null || _e === void 0 ? void 0 : _e.bind(host),
             useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); },
             getFileIncludeReasons: function () { return fileReasons; },
             structureIsReused: structureIsReused,
@@ -97884,6 +98160,8 @@ var ts;
                 case 0:
                     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:
+                    return diagnostic.diagnostics.forEach(function (d) { return programDiagnostics.add(d); });
                 default:
                     ts.Debug.assertNever(diagnostic);
             }
@@ -97893,57 +98171,44 @@ var ts;
         ts.performance.measure("Program", "beforeProgram", "afterProgram");
         ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         return program;
-        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 getAutomaticTypeDirectiveContainingFile() {
+            var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
+            return ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile);
         }
-        function pullDiagnosticsFromCache(names, containingFile) {
-            var _a;
-            if (!moduleResolutionCache)
+        function addResolutionDiagnostics(resolution) {
+            if (!resolution.resolutionDiagnostics)
                 return;
-            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];
-                var mode = typeof n === "string" ? getModeForResolutionAtIndex(containingFile, i) : getModeForFileReference(n, containingFileMode);
-                var name = typeof n === "string" ? n : n.fileName;
-                i++;
-                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);
-            }
+            (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
+                kind: 2,
+                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, d.packagePath); })
+            });
         }
-        function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
+        function resolveModuleNamesWorker(moduleNames, containingFile, partialResolutionInfo, redirectedReference) {
             if (!moduleNames.length)
                 return ts.emptyArray;
             var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
-            var redirectedReference = getRedirectReferenceForResolution(containingFile);
+            if (redirectedReference === undefined)
+                redirectedReference = getRedirectReferenceForResolution(containingFile);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "resolveModuleNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveModule");
-            var result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, reusedNames, redirectedReference);
+            var result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, redirectedReference || undefined, partialResolutionInfo);
             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) {
+        function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, partialResolutionInfo, redirectedReference) {
             if (!typeDirectiveNames.length)
                 return [];
             var containingFileName = !ts.isString(containingFile) ? ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
-            var redirectedReference = !ts.isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined;
+            if (redirectedReference === undefined && !ts.isString(containingFile))
+                redirectedReference = getRedirectReferenceForResolution(containingFile);
             var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined;
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveTypeReference");
-            var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode);
+            var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference || undefined, containingFileMode, partialResolutionInfo);
             ts.performance.mark("afterResolveTypeReference");
             ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
@@ -97989,9 +98254,6 @@ 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);
         }
@@ -98015,8 +98277,9 @@ var ts;
             return classifiableNames;
         }
         function resolveModuleNamesReusingOldState(moduleNames, file) {
+            var _a;
             if (structureIsReused === 0 && !file.ambientModuleNames.length) {
-                return resolveModuleNamesWorker(moduleNames, file, undefined);
+                return resolveModuleNamesWorker(moduleNames, file, undefined, undefined);
             }
             var oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
             if (oldSourceFile !== file && file.resolvedModules) {
@@ -98031,21 +98294,34 @@ var ts;
                 return result_14;
             }
             var unknownModuleNames;
-            var result;
+            var unknownModuleNamesIndex;
             var reusedNames;
-            var predictedToResolveToAmbientModuleMarker = {};
+            var result;
+            var predictedToResolveToAmbientModuleMarker = true;
+            var redirectedReference;
             for (var i = 0; i < moduleNames.length; i++) {
                 var moduleName = moduleNames[i];
-                if (file === oldSourceFile && !hasInvalidatedResolution(oldSourceFile.path)) {
-                    var oldResolvedModule = ts.getResolvedModule(oldSourceFile, moduleName, getModeForResolutionAtIndex(oldSourceFile, i));
-                    if (oldResolvedModule) {
+                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 (ts.isTraceEnabled(options, host)) {
-                            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));
+                            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));
+                            }
                         }
-                        (result || (result = new Array(moduleNames.length)))[i] = oldResolvedModule;
-                        (reusedNames || (reusedNames = [])).push(moduleName);
+                        (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 });
                         continue;
                     }
                 }
@@ -98060,14 +98336,15 @@ var ts;
                     resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, i);
                 }
                 if (resolvesToAmbientModuleInNonModifiedFile) {
-                    (result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
+                    (result !== null && result !== void 0 ? result : (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
                 }
                 else {
-                    (unknownModuleNames || (unknownModuleNames = [])).push(moduleName);
+                    (unknownModuleNames !== null && unknownModuleNames !== void 0 ? unknownModuleNames : (unknownModuleNames = [])).push(moduleName);
+                    (unknownModuleNamesIndex !== null && unknownModuleNamesIndex !== void 0 ? unknownModuleNamesIndex : (unknownModuleNamesIndex = [])).push(i);
                 }
             }
             var resolutions = unknownModuleNames && unknownModuleNames.length
-                ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames)
+                ? resolveModuleNamesWorker(unknownModuleNames, file, { reusedNames: reusedNames, namesIndex: unknownModuleNamesIndex }, redirectedReference)
                 : ts.emptyArray;
             if (!result) {
                 ts.Debug.assert(resolutions.length === moduleNames.length);
@@ -98077,7 +98354,7 @@ var ts;
             for (var i = 0; i < result.length; i++) {
                 if (result[i]) {
                     if (result[i] === predictedToResolveToAmbientModuleMarker) {
-                        result[i] = undefined;
+                        result[i] = emptyResolution;
                     }
                 }
                 else {
@@ -98105,6 +98382,78 @@ var ts;
                 return true;
             }
         }
+        function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
+            var _a;
+            if (structureIsReused === 0) {
+                return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, undefined, 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) {
+                var result_15 = [];
+                for (var _i = 0, _b = typeDirectiveNames; _i < _b.length; _i++) {
+                    var typeDirectiveName = _b[_i];
+                    var resolvedTypeReferenceDirective = containingSourceFile.resolvedTypeReferenceDirectiveNames.get(ts.toFileNameLowerCase(typeDirectiveName.fileName), typeDirectiveName.resolutionMode || containingSourceFile.impliedNodeFormat);
+                    result_15.push(resolvedTypeReferenceDirective);
+                }
+                return result_15;
+            }
+            var unknownTypeReferenceDirectiveNames;
+            var unknownTypeReferenceDirectiveNamesIndex;
+            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 (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;
+                    }
+                }
+                (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];
@@ -98123,12 +98472,17 @@ var ts;
             });
         }
         function tryReuseStructureFromOldProgram() {
-            var _a, _b;
-            if (!oldProgram) {
+            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)) {
                 return 0;
             }
-            var oldOptions = oldProgram.getCompilerOptions();
-            if (ts.changesAffectModuleResolution(oldOptions, options)) {
+            var result = tryReuseStructureFromOldProgramWorker();
+            return options.cacheResolutions && (oldProgram || oldBuildInfoProgram) && result === 0 ?
+                1 :
+                result;
+        }
+        function tryReuseStructureFromOldProgramWorker() {
+            if (!oldProgram) {
                 return 0;
             }
             var oldRootNames = oldProgram.getRootFileNames();
@@ -98143,7 +98497,7 @@ var ts;
             }
             var newSourceFiles = [];
             var modifiedSourceFiles = [];
-            structureIsReused = 2;
+            structureIsReused = 3;
             if (oldProgram.getMissingFilePaths().some(function (missingFilePath) { return host.fileExists(missingFilePath); })) {
                 return 0;
             }
@@ -98151,14 +98505,13 @@ var ts;
             var seenPackageNames = new ts.Map();
             for (var _i = 0, oldSourceFiles_2 = oldSourceFiles; _i < oldSourceFiles_2.length; _i++) {
                 var oldSourceFile = oldSourceFiles_2[_i];
-                var sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options);
+                var sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName);
                 var newSourceFile = host.getSourceFileByPath
                     ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, sourceFileOptions, undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat)
                     : host.getSourceFile(oldSourceFile.fileName, sourceFileOptions, undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat);
                 if (!newSourceFile) {
                     return 0;
                 }
-                newSourceFile.packageJsonLocations = ((_a = sourceFileOptions.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) ? sourceFileOptions.packageJsonLocations : undefined;
                 newSourceFile.packageJsonScope = sourceFileOptions.packageJsonScope;
                 ts.Debug.assert(!newSourceFile.redirectInfo, "Host should not return a redirect source file from `getSourceFile`");
                 var fileChanged = void 0;
@@ -98193,86 +98546,95 @@ var ts;
                 }
                 if (fileChanged) {
                     if (oldSourceFile.impliedNodeFormat !== newSourceFile.impliedNodeFormat) {
-                        structureIsReused = 1;
+                        structureIsReused = 2;
                     }
                     else if (!ts.arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) {
-                        structureIsReused = 1;
+                        structureIsReused = 2;
                     }
                     else if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
-                        structureIsReused = 1;
+                        structureIsReused = 2;
                     }
                     else if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
-                        structureIsReused = 1;
+                        structureIsReused = 2;
                     }
                     else {
                         collectExternalModuleReferences(newSourceFile);
                         if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
-                            structureIsReused = 1;
+                            structureIsReused = 2;
                         }
                         else if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
-                            structureIsReused = 1;
+                            structureIsReused = 2;
                         }
                         else if ((oldSourceFile.flags & 6291456) !== (newSourceFile.flags & 6291456)) {
-                            structureIsReused = 1;
+                            structureIsReused = 2;
                         }
                         else if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
-                            structureIsReused = 1;
+                            structureIsReused = 2;
                         }
                     }
                     modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
                 }
                 else if (hasInvalidatedResolution(oldSourceFile.path)) {
-                    structureIsReused = 1;
+                    structureIsReused = 2;
                     modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
                 }
                 newSourceFiles.push(newSourceFile);
             }
-            if (structureIsReused !== 2) {
+            if (structureIsReused !== 3) {
                 return structureIsReused;
             }
             var modifiedFiles = modifiedSourceFiles.map(function (f) { return f.oldFile; });
-            for (var _c = 0, oldSourceFiles_3 = oldSourceFiles; _c < oldSourceFiles_3.length; _c++) {
-                var oldFile = oldSourceFiles_3[_c];
+            for (var _a = 0, oldSourceFiles_3 = oldSourceFiles; _a < oldSourceFiles_3.length; _a++) {
+                var oldFile = oldSourceFiles_3[_a];
                 if (!ts.contains(modifiedFiles, oldFile)) {
-                    for (var _d = 0, _e = oldFile.ambientModuleNames; _d < _e.length; _d++) {
-                        var moduleName = _e[_d];
+                    for (var _b = 0, _c = oldFile.ambientModuleNames; _b < _c.length; _b++) {
+                        var moduleName = _c[_b];
                         ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName);
                     }
                 }
             }
-            for (var _f = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _f < modifiedSourceFiles_1.length; _f++) {
-                var _g = modifiedSourceFiles_1[_f], oldSourceFile = _g.oldFile, newSourceFile = _g.newFile;
+            for (var _d = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _d < modifiedSourceFiles_1.length; _d++) {
+                var _e = modifiedSourceFiles_1[_d], oldSourceFile = _e.oldFile, newSourceFile = _e.newFile;
                 var moduleNames = getModuleNames(newSourceFile);
                 var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
                 var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, oldSourceFile, ts.moduleResolutionIsEqualTo);
                 if (resolutionsChanged) {
-                    structureIsReused = 1;
+                    structureIsReused = 2;
                     newSourceFile.resolvedModules = ts.zipToModeAwareCache(newSourceFile, moduleNames, resolutions);
                 }
                 else {
                     newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
                 }
                 var typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
-                var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
+                var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typesReferenceDirectives, newSourceFile);
                 var typeReferenceResolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, ts.typeDirectiveIsEqualTo);
                 if (typeReferenceResolutionsChanged) {
-                    structureIsReused = 1;
+                    structureIsReused = 2;
                     newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
                 }
                 else {
                     newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
                 }
             }
-            if (structureIsReused !== 2) {
+            if (structureIsReused !== 3) {
                 return structureIsReused;
             }
-            if (ts.changesAffectingProgramStructure(oldOptions, options) || ((_b = host.hasChangedAutomaticTypeDirectiveNames) === null || _b === void 0 ? void 0 : _b.call(host))) {
-                return 1;
+            if (ts.changesAffectingProgramStructure(oldProgram.getCompilerOptions(), options)) {
+                return 2;
+            }
+            if (host.hasChangedAutomaticTypeDirectiveNames) {
+                if (host.hasChangedAutomaticTypeDirectiveNames())
+                    return 2;
+            }
+            else {
+                automaticTypeDirectiveNames = ts.getAutomaticTypeDirectiveNames(options, host);
+                if (!ts.arrayIsEqualTo(oldProgram.getAutomaticTypeDirectiveNames(), automaticTypeDirectiveNames))
+                    return 2;
             }
             missingFilePaths = oldProgram.getMissingFilePaths();
             ts.Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
-            for (var _h = 0, newSourceFiles_1 = newSourceFiles; _h < newSourceFiles_1.length; _h++) {
-                var newSourceFile = newSourceFiles_1[_h];
+            for (var _f = 0, newSourceFiles_1 = newSourceFiles; _f < newSourceFiles_1.length; _f++) {
+                var newSourceFile = newSourceFiles_1[_f];
                 filesByName.set(newSourceFile.path, newSourceFile);
             }
             var oldFilesByNameMap = oldProgram.getFilesByNameMap();
@@ -98293,10 +98655,12 @@ 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 2;
+            return 3;
         }
         function getEmitHost(writeFileCallback) {
             return {
@@ -98973,14 +99337,12 @@ var ts;
             }
         }
         function createRedirectSourceFile(redirectTarget, unredirected, fileName, path, resolvedPath, originalFileName, sourceFileOptions) {
-            var _a;
             var redirect = Object.create(redirectTarget);
             redirect.fileName = fileName;
             redirect.path = path;
             redirect.resolvedPath = resolvedPath;
             redirect.originalFileName = originalFileName;
             redirect.redirectInfo = { redirectTarget: redirectTarget, unredirected: unredirected };
-            redirect.packageJsonLocations = ((_a = sourceFileOptions.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) ? sourceFileOptions.packageJsonLocations : undefined;
             redirect.packageJsonScope = sourceFileOptions.packageJsonScope;
             sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
             Object.defineProperties(redirect, {
@@ -99005,7 +99367,7 @@ var ts;
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return result;
         }
-        function getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options) {
+        function getCreateSourceFileOptions(fileName) {
             var result = getImpliedNodeFormatForFileWorker(toPath(fileName), moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options);
             var languageVersion = ts.getEmitScriptTarget(options);
             var setExternalModuleIndicator = ts.getSetExternalModuleIndicator(options);
@@ -99013,7 +99375,7 @@ var ts;
                 { languageVersion: languageVersion, impliedNodeFormat: result, setExternalModuleIndicator: setExternalModuleIndicator };
         }
         function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
-            var _a, _b;
+            var _a;
             var path = toPath(fileName);
             if (useSourceOfProjectReferenceRedirect) {
                 var source = getSourceOfProjectReferenceRedirect(path);
@@ -99083,7 +99445,7 @@ var ts;
                     redirectedPath = toPath(redirect);
                 }
             }
-            var sourceFileOptions = getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options);
+            var sourceFileOptions = getCreateSourceFileOptions(fileName);
             var file = host.getSourceFile(fileName, sourceFileOptions, function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile || (((_a = oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getSourceFileByPath(toPath(fileName))) === null || _a === void 0 ? void 0 : _a.impliedNodeFormat) !== sourceFileOptions.impliedNodeFormat));
             if (packageId) {
                 var packageIdKey = ts.packageIdToString(packageId);
@@ -99109,7 +99471,6 @@ var ts;
                 file.path = path;
                 file.resolvedPath = toPath(fileName);
                 file.originalFileName = originalFileName;
-                file.packageJsonLocations = ((_b = sourceFileOptions.packageJsonLocations) === null || _b === void 0 ? void 0 : _b.length) ? sourceFileOptions.packageJsonLocations : undefined;
                 file.packageJsonScope = sourceFileOptions.packageJsonScope;
                 addFileIncludeReason(file, reason);
                 if (host.useCaseSensitiveFileNames()) {
@@ -99226,33 +99587,40 @@ var ts;
         }
         function processTypeReferenceDirectives(file) {
             var typeDirectives = file.typeReferenceDirectives;
-            if (!typeDirectives) {
+            if (!typeDirectives.length) {
+                file.resolvedTypeReferenceDirectiveNames = undefined;
                 return;
             }
-            var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file);
+            var resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
             for (var index = 0; index < typeDirectives.length; index++) {
                 var ref = file.typeReferenceDirectives[index];
                 var resolvedTypeReferenceDirective = resolutions[index];
                 var fileName = ts.toFileNameLowerCase(ref.fileName);
-                ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective);
+                ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat));
                 var mode = ref.resolutionMode || file.impliedNodeFormat;
                 if (mode && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
-                    programDiagnostics.add(ts.createDiagnosticForRange(file, ref, ts.Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext));
+                    (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
+                        kind: 2,
+                        diagnostics: [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, resolvedTypeReferenceDirective, reason) {
-            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
-            processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
+        function processTypeReferenceDirective(typeReferenceDirective, mode, resolution, reason) {
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program", "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolution.resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason);
             ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
-        function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-            var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode);
+        function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason) {
+            var _a;
+            addResolutionDiagnostics(resolution);
+            var previousResolution = (_a = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode)) === null || _a === void 0 ? void 0 : _a.resolvedTypeReferenceDirective;
             if (previousResolution && previousResolution.primary) {
                 return;
             }
             var saveResolution = true;
+            var resolvedTypeReferenceDirective = resolution.resolvedTypeReferenceDirective;
             if (resolvedTypeReferenceDirective) {
                 if (resolvedTypeReferenceDirective.isExternalLibraryImport)
                     currentNodeModulesDepth++;
@@ -99281,7 +99649,7 @@ var ts;
                 addFilePreprocessingFileExplainingDiagnostic(undefined, reason, ts.Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]);
             }
             if (saveResolution) {
-                resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective);
+                resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolution);
             }
         }
         function pathForLibFile(libFileName) {
@@ -99310,7 +99678,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 || (fileProcessingDiagnostics = [])).push({
+                    (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
                         kind: 0,
                         reason: { kind: ts.FileIncludeKind.LibReferenceDirective, file: file.path, index: index, },
                         diagnostic: diagnostic,
@@ -99333,19 +99701,20 @@ var ts;
                 for (var index = 0; index < moduleNames.length; index++) {
                     var resolution = resolutions[index];
                     ts.setResolvedModule(file, moduleNames[index], resolution, getModeForResolutionAtIndex(file, index));
-                    if (!resolution) {
+                    addResolutionDiagnostics(resolution);
+                    if (!resolution.resolvedModule) {
                         continue;
                     }
-                    var isFromNodeModulesSearch = resolution.isExternalLibraryImport;
-                    var isJsFile = !ts.resolutionExtensionIsTSOrJson(resolution.extension);
+                    var isFromNodeModulesSearch = resolution.resolvedModule.isExternalLibraryImport;
+                    var isJsFile = !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension);
                     var isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile;
-                    var resolvedFileName = resolution.resolvedFileName;
+                    var resolvedFileName = resolution.resolvedModule.resolvedFileName;
                     if (isFromNodeModulesSearch) {
                         currentNodeModulesDepth++;
                     }
                     var elideImport = isJsFileFromNodeModules && currentNodeModulesDepth > maxNodeModuleJsDepth;
                     var shouldAddFile = resolvedFileName
-                        && !getResolutionDiagnostic(optionsForFile, resolution)
+                        && !getResolutionDiagnostic(optionsForFile, resolution.resolvedModule)
                         && !optionsForFile.noResolve
                         && index < file.imports.length
                         && !elideImport
@@ -99355,7 +99724,7 @@ var ts;
                         modulesWithElidedImports.set(file.path, true);
                     }
                     else if (shouldAddFile) {
-                        findSourceFile(resolvedFileName, false, false, { kind: ts.FileIncludeKind.Import, file: file.path, index: index, }, resolution.packageId);
+                        findSourceFile(resolvedFileName, false, false, { kind: ts.FileIncludeKind.Import, file: file.path, index: index, }, resolution.resolvedModule.packageId);
                     }
                     if (isFromNodeModulesSearch) {
                         currentNodeModulesDepth--;
@@ -99456,6 +99825,11 @@ var ts;
                     createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_incremental_compilation, "declaration");
                 }
             }
+            if (ts.isIncrementalCompilation(options))
+                options.cacheResolutions = true;
+            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)) {
@@ -99705,7 +100079,7 @@ var ts;
             }
         }
         function addFilePreprocessingFileExplainingDiagnostic(file, fileProcessingReason, diagnostic, args) {
-            (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
+            (fileProcessingDiagnostics !== null && fileProcessingDiagnostics !== void 0 ? fileProcessingDiagnostics : (fileProcessingDiagnostics = [])).push({
                 kind: 1,
                 file: file && file.path,
                 fileProcessingReason: fileProcessingReason,
@@ -99966,8 +100340,8 @@ var ts;
             if (!symlinks) {
                 symlinks = ts.createSymlinkCache(currentDirectory, getCanonicalFileName);
             }
-            if (files && resolvedTypeReferenceDirectives && !symlinks.hasProcessedResolutions()) {
-                symlinks.setSymlinksFromResolutions(files, resolvedTypeReferenceDirectives);
+            if (files && automaticTypeDirectiveResolutions && !symlinks.hasProcessedResolutions()) {
+                symlinks.setSymlinksFromResolutions(files, automaticTypeDirectiveResolutions);
             }
             return symlinks;
         }
@@ -100326,7 +100700,8 @@ var ts;
                 }
             }
             if (sourceFile.resolvedTypeReferenceDirectiveNames) {
-                sourceFile.resolvedTypeReferenceDirectiveNames.forEach(function (resolvedTypeReferenceDirective) {
+                sourceFile.resolvedTypeReferenceDirectiveNames.forEach(function (_a) {
+                    var resolvedTypeReferenceDirective = _a.resolvedTypeReferenceDirective;
                     if (!resolvedTypeReferenceDirective) {
                         return;
                     }
@@ -100375,12 +100750,13 @@ var ts;
             return oldState && !oldState.referencedMap === !newReferencedMap;
         }
         BuilderState.canReuseOldState = canReuseOldState;
-        function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
+        function create(newProgram, 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());
             newProgram.getTypeChecker();
             for (var _i = 0, _d = newProgram.getSourceFiles(); _i < _d.length; _i++) {
                 var sourceFile = _d[_i];
@@ -100424,23 +100800,23 @@ var ts;
             state.allFileNames = undefined;
         }
         BuilderState.releaseCache = releaseCache;
-        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) {
+        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, host) {
             var _a, _b;
-            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName);
+            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, host);
             (_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, computeHash, getCanonicalFileName) {
+        function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, host) {
             var sourceFile = programOfThisState.getSourceFileByPath(path);
             if (!sourceFile) {
                 return ts.emptyArray;
             }
-            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
+            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host)) {
                 return [sourceFile];
             }
-            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName);
+            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
         }
         BuilderState.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
         function updateSignatureOfFile(state, signature, path) {
@@ -100448,7 +100824,7 @@ var ts;
             (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = new ts.Set())).add(path);
         }
         BuilderState.updateSignatureOfFile = updateSignatureOfFile;
-        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName, useFileVersionAsSignature) {
+        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host, useFileVersionAsSignature) {
             var _a;
             if (useFileVersionAsSignature === void 0) { useFileVersionAsSignature = state.useFileVersionAsSignature; }
             if ((_a = state.hasCalledUpdateShapeSignature) === null || _a === void 0 ? void 0 : _a.has(sourceFile.resolvedPath))
@@ -100459,7 +100835,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, computeHash, getCanonicalFileName, data);
+                    latestSignature = ts.computeSignatureWithDiagnostics(sourceFile, text, host, ts.createGetCanonicalFileName(programOfThisState.useCaseSensitiveFileNames()), data);
                     if (latestSignature !== prevSignature) {
                         updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
                     }
@@ -100593,7 +100969,7 @@ var ts;
             }
             return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
         }
-        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash, getCanonicalFileName) {
+        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, host) {
             if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
                 return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
             }
@@ -100609,7 +100985,7 @@ var ts;
                 if (!seenFileNamesMap.has(currentPath)) {
                     var currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
                     seenFileNamesMap.set(currentPath, currentSourceFile);
-                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
+                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, host)) {
                         queue.push.apply(queue, getReferencedByPaths(state, currentSourceFile.resolvedPath));
                     }
                 }
@@ -100623,9 +100999,9 @@ var ts;
     function hasSameKeys(map1, map2) {
         return map1 === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !ts.forEachKey(map1, function (key) { return !map2.has(key); });
     }
-    function createBuilderProgramState(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) {
+    function createBuilderProgramState(newProgram, oldState, disableUseFileVersionAsSignature) {
         var _a, _b;
-        var state = ts.BuilderState.create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature);
+        var state = ts.BuilderState.create(newProgram, oldState, disableUseFileVersionAsSignature);
         state.program = newProgram;
         var compilerOptions = newProgram.getCompilerOptions();
         state.compilerOptions = compilerOptions;
@@ -100678,7 +101054,7 @@ var ts;
                     return;
                 var diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
                 if (diagnostics) {
-                    state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) : diagnostics);
+                    state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : diagnostics);
                     if (!state.semanticDiagnosticsFromOldState) {
                         state.semanticDiagnosticsFromOldState = new ts.Set();
                     }
@@ -100700,13 +101076,16 @@ var ts;
             ts.Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
             state.seenAffectedFiles = state.seenAffectedFiles || new ts.Set();
         }
-        state.buildInfoEmitPending = !useOldState || state.changedFilesSet.size !== (((_b = oldState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.size) || 0);
+        state.buildInfoEmitPending = !useOldState ||
+            state.changedFilesSet.size !== (((_b = oldState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.size) || 0) ||
+            state.fileInfos.size !== oldState.fileInfos.size;
         return state;
     }
-    function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) {
+    function convertToDiagnostics(diagnostics, newProgram) {
         if (!diagnostics.length)
             return ts.emptyArray;
-        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
+        var buildInfoDirectory;
+        var getCanonicalFileName;
         return diagnostics.map(function (diagnostic) {
             var result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath);
             result.reportsUnnecessary = diagnostic.reportsUnnecessary;
@@ -100722,7 +101101,8 @@ var ts;
             return result;
         });
         function toPath(path) {
-            return ts.toPath(path, buildInfoDirectory, getCanonicalFileName);
+            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())));
         }
     }
     function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath) {
@@ -100731,6 +101111,8 @@ var ts;
     }
     function releaseCache(state) {
         ts.BuilderState.releaseCache(state);
+        if (!state.resuableCacheResolutions)
+            getCacheResolutions(state);
         state.program = undefined;
     }
     function backupBuilderProgramEmitState(state) {
@@ -100765,7 +101147,7 @@ var ts;
     function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) {
         ts.Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath));
     }
-    function getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host) {
+    function getNextAffectedFile(state, cancellationToken, host) {
         var _a, _b;
         while (true) {
             var affectedFiles = state.affectedFiles;
@@ -100776,7 +101158,7 @@ var ts;
                     var affectedFile = affectedFiles[affectedFilesIndex];
                     if (!seenAffectedFiles.has(affectedFile.resolvedPath)) {
                         state.affectedFilesIndex = affectedFilesIndex;
-                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host);
+                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, host);
                         return affectedFile;
                     }
                     affectedFilesIndex++;
@@ -100797,7 +101179,7 @@ var ts;
                 ts.Debug.assert(!state.semanticDiagnosticsPerFile);
                 return program;
             }
-            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, computeHash, getCanonicalFileName);
+            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, host);
             state.currentChangedFilePath = nextKey.value;
             state.affectedFilesIndex = 0;
             if (!state.seenAffectedFiles)
@@ -100840,24 +101222,24 @@ var ts;
             });
         }
     }
-    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
+    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, host) {
         removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
         if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
             removeDiagnosticsOfLibraryFiles(state);
-            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, computeHash, getCanonicalFileName);
+            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, host);
             return;
         }
         if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
             return;
-        handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host);
+        handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host);
     }
-    function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, getCanonicalFileName, host) {
+    function handleDtsMayChangeOf(state, path, cancellationToken, host) {
         removeSemanticDiagnosticsOf(state, path);
         if (!state.changedFilesSet.has(path)) {
             var program = ts.Debug.checkDefined(state.program);
             var sourceFile = program.getSourceFileByPath(path);
             if (sourceFile) {
-                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, computeHash, getCanonicalFileName, !host.disableUseFileVersionAsSignature);
+                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, host, !host.disableUseFileVersionAsSignature);
                 if (ts.getEmitDeclarations(state.compilerOptions)) {
                     addToAffectedFilesPendingEmit(state, path, 0);
                 }
@@ -100877,16 +101259,16 @@ var ts;
         var newSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
         return newSignature !== oldSignature;
     }
-    function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host) {
+    function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host) {
         var _a;
         if (!((_a = state.fileInfos.get(filePath)) === null || _a === void 0 ? void 0 : _a.affectsGlobalScope))
             return false;
         ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program, undefined)
-            .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, computeHash, getCanonicalFileName, host); });
+            .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, host); });
         removeDiagnosticsOfLibraryFiles(state);
         return true;
     }
-    function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
+    function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host) {
         var _a;
         if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
             return;
@@ -100900,9 +101282,9 @@ var ts;
                 var currentPath = queue.pop();
                 if (!seenFileNamesMap.has(currentPath)) {
                     seenFileNamesMap.set(currentPath, true);
-                    if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host))
+                    if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, host))
                         return;
-                    handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host);
+                    handleDtsMayChangeOf(state, currentPath, cancellationToken, host);
                     if (isChangedSignature(state, currentPath)) {
                         var currentSourceFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
                         queue.push.apply(queue, ts.BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
@@ -100912,27 +101294,27 @@ var ts;
         }
         var seenFileAndExportsOfFile = new ts.Set();
         (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, getCanonicalFileName, host))
+            if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, host))
                 return true;
             var references = state.referencedMap.getKeys(exportedFromPath);
             return references && ts.forEachKey(references, function (filePath) {
-                return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host);
+                return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host);
             });
         });
     }
-    function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host) {
+    function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host) {
         var _a, _b;
         if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath))
             return undefined;
-        if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host))
+        if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host))
             return true;
-        handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host);
+        handleDtsMayChangeOf(state, filePath, cancellationToken, host);
         (_a = state.exportedModulesMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host);
+            return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, host);
         });
         (_b = state.referencedMap.getKeys(filePath)) === null || _b === void 0 ? void 0 : _b.forEach(function (referencingFilePath) {
             return !seenFileAndExportsOfFile.has(referencingFilePath) &&
-                handleDtsMayChangeOf(state, referencingFilePath, cancellationToken, computeHash, getCanonicalFileName, host);
+                handleDtsMayChangeOf(state, referencingFilePath, cancellationToken, host);
         });
         return undefined;
     }
@@ -100987,34 +101369,45 @@ var ts;
         return !!ts.outFile(info.options || {});
     }
     ts.isProgramBundleEmitBuildInfo = isProgramBundleEmitBuildInfo;
-    function getProgramBuildInfo(state, getCanonicalFileName) {
+    function getProgramBuildInfo(state, host) {
         var outFilePath = ts.outFile(state.compilerOptions);
-        if (outFilePath && !state.compilerOptions.composite)
+        if (outFilePath && !state.compilerOptions.composite && !state.compilerOptions.cacheResolutions)
             return;
         var currentDirectory = ts.Debug.checkDefined(state.program).getCurrentDirectory();
-        var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
+        var getCanonicalFileName = ts.createGetCanonicalFileName(state.program.useCaseSensitiveFileNames());
+        var buildInfoPath = ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory);
+        var buildInfoDirectory = ts.getDirectoryPath(buildInfoPath);
         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 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,
+            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,
                 fileInfos: fileInfos_1,
-                options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
+                options: toProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo", !!state.compilerOptions.cacheResolutions),
                 outSignature: state.outSignature,
                 latestChangedDtsFile: latestChangedDtsFile,
+                cacheResolutions: cacheResolutions_1,
             };
-            return result_15;
+            return result_16;
         }
-        var fileNames = [];
-        var fileNameToFileId = new ts.Map();
         var fileIdsList;
         var fileNamesToFileIdListId;
         var emitSignatures;
@@ -101071,7 +101464,7 @@ var ts;
                 (semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(value.length ?
                     [
                         toFileId(key),
-                        convertToReusableDiagnostics(value, relativeToBuildInfo)
+                        value.map(toReusableDiagnostic)
                     ] :
                     toFileId(key));
             }
@@ -101093,10 +101486,11 @@ var ts;
                 (changeFileSet || (changeFileSet = [])).push(toFileId(path));
             }
         }
+        var cacheResolutions = toProgramBuildInfoCacheResolutions();
         var result = {
             fileNames: fileNames,
             fileInfos: fileInfos,
-            options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsMultiFileEmitBuildInfo"),
+            options: toProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsMultiFileEmitBuildInfo", !!state.compilerOptions.cacheResolutions),
             fileIdsList: fileIdsList,
             referencedMap: referencedMap,
             exportedModulesMap: exportedModulesMap,
@@ -101105,6 +101499,7 @@ var ts;
             changeFileSet: changeFileSet,
             emitSignatures: emitSignatures,
             latestChangedDtsFile: latestChangedDtsFile,
+            cacheResolutions: cacheResolutions,
         };
         return result;
         function relativeToBuildInfoEnsuringAbsolutePath(path) {
@@ -101113,7 +101508,7 @@ var ts;
         function relativeToBuildInfo(path) {
             return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(buildInfoDirectory, path, getCanonicalFileName));
         }
-        function toFileId(path) {
+        function toFileAndAbsoluteFileId(path) {
             var fileId = fileNameToFileId.get(path);
             if (fileId === undefined) {
                 fileNames.push(relativeToBuildInfo(path));
@@ -101121,6 +101516,12 @@ 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();
@@ -101131,53 +101532,232 @@ var ts;
             }
             return fileIdListId;
         }
-        function convertToProgramBuildInfoCompilerOptions(options, optionKey) {
+        function toProgramBuildInfoCompilerOptions(options, optionKey, affectsModuleResolution) {
             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 (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo[optionKey]) {
-                    (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfoEnsuringAbsolutePath);
+                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;
                 }
             }
             return result;
         }
-    }
-    function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
-        if (option) {
-            if (option.type === "list") {
-                var values = value;
-                if (option.element.isFilePath && values.length) {
-                    return values.map(relativeToBuildInfo);
+        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);
                 }
             }
-            else if (option.isFilePath) {
-                return relativeToBuildInfo(value);
-            }
+            return value;
         }
-        return value;
-    }
-    function convertToReusableDiagnostics(diagnostics, relativeToBuildInfo) {
-        ts.Debug.assert(!!diagnostics.length);
-        return diagnostics.map(function (diagnostic) {
-            var result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
+        function toReadonlyArrayOrUndefined(array, map) {
+            return (array === null || array === void 0 ? void 0 : array.length) ? array.map(map) : undefined;
+        }
+        function toReusableDiagnostic(diagnostic) {
+            var result = toReusableDiagnosticRelatedInformation(diagnostic);
             result.reportsUnnecessary = diagnostic.reportsUnnecessary;
             result.reportDeprecated = diagnostic.reportsDeprecated;
             result.source = diagnostic.source;
             result.skippedOn = diagnostic.skippedOn;
             var relatedInformation = diagnostic.relatedInformation;
-            result.relatedInformation = relatedInformation ?
-                relatedInformation.length ?
-                    relatedInformation.map(function (r) { return convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo); }) :
-                    [] :
-                undefined;
+            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);
+            var packageJsons = toProgramBuildInfoPackageJsons(cacheResolutions === null || cacheResolutions === void 0 ? void 0 : cacheResolutions.perDirPackageJsonMap);
+            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,
+                    packageJsons: packageJsons,
+                },
+                getProgramBuildInfoFilePathDecoder: ts.memoize(function () { return getProgramBuildInfoFilePathDecoder(fileNames, buildInfoPath, currentDirectory, getCanonicalFileName); })
+            };
+            return state.resuableCacheResolutions.cache;
+        }
+        function toProgramBuildInfoPackageJsons(cache) {
+            var result;
+            cache === null || cache === void 0 ? void 0 : cache.forEach(function (packageJson, dirPath) {
+                var packageJsonDirPath = ts.getDirectoryPath(ts.toPath(packageJson, currentDirectory, getCanonicalFileName));
+                if (packageJsonDirPath !== dirPath) {
+                    (result !== null && result !== void 0 ? result : (result = [])).push([
+                        toFileId(dirPath),
+                        toAbsoluteFileId(packageJson),
+                    ]);
+                }
+            });
+            return result;
+        }
+        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, undefined, 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; });
+            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))) {
+                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 dirToPackageJsonScope = new ts.Map();
+        var perDirPackageJsonMap;
+        var getCanonicalFileName = ts.createGetCanonicalFileName(state.program.useCaseSensitiveFileNames());
+        state.program.getSourceFiles().forEach(function (f) {
+            var _a;
+            modules = toPerDirectoryCache(state, getCanonicalFileName, modules, ts.getResolvedModuleOfResolution, f, f.resolvedModules, moduleNameToDirectoryMap);
+            typeRefs = toPerDirectoryCache(state, getCanonicalFileName, typeRefs, ts.getResolvedTypeReferenceDirectiveOfResolution, f, f.resolvedTypeReferenceDirectiveNames);
+            if ((_a = f.packageJsonScope) === null || _a === void 0 ? void 0 : _a.info) {
+                var dirPath = ts.getDirectoryPath(f.resolvedPath);
+                if (!(dirToPackageJsonScope === null || dirToPackageJsonScope === void 0 ? void 0 : dirToPackageJsonScope.has(dirPath))) {
+                    (perDirPackageJsonMap !== null && perDirPackageJsonMap !== void 0 ? perDirPackageJsonMap : (perDirPackageJsonMap = new ts.Map())).set(dirPath, ts.getPackageJsconLocationFromScope(f.packageJsonScope));
+                    ts.moduleNameToDirectorySet(dirToPackageJsonScope, dirPath, f.packageJsonScope, ts.getPackageJsconLocationFromScope, function (dir) { return ts.toPath(dir, state.program.getCurrentDirectory(), getCanonicalFileName); }, function (ancestorPath) { return perDirPackageJsonMap === null || perDirPackageJsonMap === void 0 ? void 0 : perDirPackageJsonMap.delete(ancestorPath); });
+                }
+            }
         });
+        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, ts.getResolvedTypeReferenceDirectiveOfResolution, containingPath, state.program.getAutomaticTypeDirectiveResolutions());
+        }
+        return state.cacheResolutions = {
+            modules: modules,
+            typeRefs: typeRefs,
+            moduleNameToDirectoryMap: moduleNameToDirectoryMap,
+            dirToPackageJsonScope: dirToPackageJsonScope,
+            perDirPackageJsonMap: perDirPackageJsonMap,
+            packageJsonCache: (_a = state.program.getModuleResolutionCache()) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfoCache().clone(),
+        };
     }
-    function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) {
-        var file = diagnostic.file;
-        return __assign(__assign({}, diagnostic), { file: file ? relativeToBuildInfo(file.resolvedPath) : undefined });
+    function toPerDirectoryCache(state, getCanonicalFileName, perDirCache, getResolutionWithResolvedFileName, sourceFileOrPath, fileCacheFromProgram, moduleNameToDirectoryMap) {
+        return ts.toPerDirectoryResolution(state.program, fileCacheFromProgram, sourceFileOrPath, perDirCache, moduleNameToDirectoryMap, ts.noop, function (r, name, mode, _key, redirectedReference, dirPath) {
+            var _a, _b, _c;
+            return !((_a = getResolutionWithResolvedFileName(r)) === null || _a === void 0 ? void 0 : _a.resolvedFileName) ||
+                (moduleNameToDirectoryMap &&
+                    !ts.isExternalModuleNameRelative(name) &&
+                    ((_c = (_b = moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) === null || _b === void 0 ? void 0 : _b.get(ts.getModeAwareCacheKey(name, mode))) === null || _c === void 0 ? void 0 : _c.get(dirPath)));
+        }, function (dir) { return ts.toPath(dir, state.program.getCurrentDirectory(), getCanonicalFileName); }, function (ancestorPath, name, mode, perDirResolutionCache) { var _a; return (_a = perDirResolutionCache === null || perDirResolutionCache === void 0 ? void 0 : perDirResolutionCache.get(ancestorPath)) === null || _a === void 0 ? void 0 : _a.delete(name, mode); });
     }
     var BuilderProgramKind;
     (function (BuilderProgramKind) {
@@ -101201,7 +101781,7 @@ var ts;
                 rootNames: newProgramOrRootNames,
                 options: hostOrOptions,
                 host: oldProgramOrHost,
-                oldProgram: oldProgram && oldProgram.getProgramOrUndefined(),
+                oldProgram: oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getProgramOrOldBuildInfoProgramUndefined(),
                 configFileParsingDiagnostics: configFileParsingDiagnostics,
                 projectReferences: projectReferences
             });
@@ -101219,8 +101799,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, computeHash, getCanonicalFileName, data) {
-        var _a;
+    function computeSignatureWithDiagnostics(sourceFile, text, host, getCanonicalFileName, data) {
+        var _a, _b;
         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) {
@@ -101228,7 +101808,7 @@ var ts;
                 return "" + locationInfo(diagnostic) + ts.DiagnosticCategory[diagnostic.category] + diagnostic.code + ": " + flattenDiagnosticMessageText(diagnostic.messageText);
             }).join("\n");
         }
-        return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(text);
+        return ((_b = host.createHash) !== null && _b !== void 0 ? _b : ts.generateDjb2Hash)(text);
         function flattenDiagnosticMessageText(diagnostic) {
             return ts.isString(diagnostic) ?
                 diagnostic :
@@ -101247,8 +101827,9 @@ var ts;
         }
     }
     ts.computeSignatureWithDiagnostics = computeSignatureWithDiagnostics;
-    function computeSignature(text, computeHash, data) {
-        return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
+    function computeSignature(text, host, data) {
+        var _a;
+        return ((_a = host.createHash) !== null && _a !== void 0 ? _a : ts.generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
     }
     ts.computeSignature = computeSignature;
     function createBuilderProgram(kind, _a) {
@@ -101259,10 +101840,8 @@ var ts;
             oldState = undefined;
             return oldProgram;
         }
-        var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames());
-        var computeHash = ts.maybeBind(host, host.createHash);
-        var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature);
-        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); };
+        var state = createBuilderProgramState(newProgram, oldState, host.disableUseFileVersionAsSignature);
+        newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, host); };
         newProgram = undefined;
         oldProgram = undefined;
         oldState = undefined;
@@ -101276,6 +101855,7 @@ 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;
         }
@@ -101297,7 +101877,7 @@ var ts;
             return ts.emitSkippedWithNoDiagnostics;
         }
         function emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
-            var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
+            var affected = getNextAffectedFile(state, cancellationToken, host);
             var emitKind = 1;
             var isPendingEmitFile = false;
             if (!affected) {
@@ -101335,7 +101915,7 @@ var ts;
                             var file = sourceFiles[0];
                             var info = state.fileInfos.get(file.resolvedPath);
                             if (info.signature === file.version) {
-                                var signature = computeSignatureWithDiagnostics(file, text, computeHash, getCanonicalFileName, data);
+                                var signature = computeSignatureWithDiagnostics(file, text, host, ts.createGetCanonicalFileName(state.program.useCaseSensitiveFileNames()), data);
                                 if (!((_a = data === null || data === void 0 ? void 0 : data.diagnostics) === null || _a === void 0 ? void 0 : _a.length))
                                     emitSignature = signature;
                                 if (signature !== file.version) {
@@ -101359,7 +101939,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, computeHash, data));
+                            emitSignature !== null && emitSignature !== void 0 ? emitSignature : (emitSignature = computeSignature(text, host, data));
                             if (emitSignature === oldSignature)
                                 return;
                             ((_g = state.emitSignatures) !== null && _g !== void 0 ? _g : (state.emitSignatures = new ts.Map())).set(filePath, emitSignature);
@@ -101368,7 +101948,7 @@ var ts;
                         }
                     }
                     else if (state.compilerOptions.composite) {
-                        var newSignature = computeSignature(text, computeHash, data);
+                        var newSignature = computeSignature(text, host, data);
                         if (newSignature === state.outSignature)
                             return;
                         state.outSignature = newSignature;
@@ -101429,7 +102009,7 @@ var ts;
         }
         function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
             while (true) {
-                var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
+                var affected = getNextAffectedFile(state, cancellationToken, host);
                 if (!affected) {
                     return undefined;
                 }
@@ -101487,12 +102067,32 @@ var ts;
                 { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
     }
     ts.toBuilderStateFileInfo = toBuilderStateFileInfo;
-    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;
+    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;
+        var state;
         var filePathsSetList;
         var latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : undefined;
         if (isProgramBundleEmitBuildInfo(program)) {
@@ -101501,13 +102101,13 @@ var ts;
                 compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
                 latestChangedDtsFile: latestChangedDtsFile,
                 outSignature: program.outSignature,
+                resuableCacheResolutions: toResuableCacheResolutions(),
             };
         }
         else {
-            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)); });
+            filePathsSetList = (_a = program.fileIdsList) === null || _a === void 0 ? void 0 : _a.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); });
             var fileInfos_2 = new ts.Map();
-            var emitSignatures_1 = ((_c = program.options) === null || _c === void 0 ? void 0 : _c.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
+            var emitSignatures_1 = ((_b = program.options) === null || _b === void 0 ? void 0 : _b.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined;
             program.fileInfos.forEach(function (fileInfo, index) {
                 var path = toFilePath(index + 1);
                 var stateFileInfo = toBuilderStateFileInfo(fileInfo);
@@ -101515,7 +102115,7 @@ var ts;
                 if (emitSignatures_1 && stateFileInfo.signature)
                     emitSignatures_1.set(path, stateFileInfo.signature);
             });
-            (_d = program.emitSignatures) === null || _d === void 0 ? void 0 : _d.forEach(function (value) {
+            (_c = program.emitSignatures) === null || _c === void 0 ? void 0 : _c.forEach(function (value) {
                 if (ts.isNumber(value))
                     emitSignatures_1.delete(toFilePath(value));
                 else
@@ -101534,14 +102134,17 @@ 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,
@@ -101561,15 +102164,6 @@ 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];
         }
@@ -101584,8 +102178,241 @@ 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, !state.cacheResolutions ? state.resuableCacheResolutions : undefined); }) :
+                undefined);
+        };
+    }
+    function createOldBuildInfoProgram(host, compilerOptions, cacheResolutions, resuableCacheResolutions) {
+        if (!cacheResolutions && !resuableCacheResolutions)
+            return undefined;
+        var fileExistsMap = new ts.Map();
+        var packageJsonInfoMap = new ts.Map();
+        var affectingLoationsSameMap = new ts.Map();
+        var decodedResolvedModules = ts.createCacheWithRedirects(compilerOptions);
+        var decodedResolvedTypeRefs = ts.createCacheWithRedirects(compilerOptions);
+        var decodedModuleNameToDirectoryMap = ts.createCacheWithRedirects(compilerOptions);
+        var decodedPackageJsonMap;
+        var packageJsonScopes;
+        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, undefined, undefined); },
+            getPackageJsonScope: getPackageJsonScope,
+        };
+        function fileExists(fileName) {
+            var result = fileExistsMap.get(fileName);
+            if (result === undefined)
+                fileExistsMap.set(fileName, result = host.fileExists(fileName));
+            return result;
+        }
+        function getPackageJsonInfo(fileName) {
+            var result = packageJsonInfoMap.get(fileName);
+            if (result === undefined)
+                packageJsonInfoMap.set(fileName, result = host.getPackageJsonInfo(fileName) || false);
+            return result || undefined;
+        }
+        function affectingLocationsSame(fileName, expected) {
+            var _a;
+            var result = affectingLoationsSameMap.get(fileName);
+            if (result !== undefined)
+                return result;
+            var packageJsonInfo = 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 getPackageJsonScope(dirPath) {
+            var _a;
+            var fromCache = (_a = cacheResolutions === null || cacheResolutions === void 0 ? void 0 : cacheResolutions.dirToPackageJsonScope) === null || _a === void 0 ? void 0 : _a.get(dirPath);
+            if (fromCache) {
+                var packageJson = ts.getPackageJsconLocationFromScope(fromCache);
+                var result = packageJsonScopes === null || packageJsonScopes === void 0 ? void 0 : packageJsonScopes.get(packageJson);
+                if (result === undefined) {
+                    (packageJsonScopes !== null && packageJsonScopes !== void 0 ? packageJsonScopes : (packageJsonScopes = new ts.Map())).set(packageJson, result = affectingLocationsSame(packageJson, fromCache.info) ?
+                        fromCache :
+                        fileExists(packageJson) ?
+                            { info: getPackageJsonInfo(packageJson), affectingLocations: [packageJson] } :
+                            false);
+                }
+                return result || undefined;
+            }
+            if (!(resuableCacheResolutions === null || resuableCacheResolutions === void 0 ? void 0 : resuableCacheResolutions.cache.packageJsons))
+                return;
+            if (!decodedPackageJsonMap) {
+                decodedPackageJsonMap = new ts.Map();
+                var filePathDecoder_1 = resuableCacheResolutions.getProgramBuildInfoFilePathDecoder();
+                for (var _i = 0, _b = resuableCacheResolutions.cache.packageJsons; _i < _b.length; _i++) {
+                    var dirIdOrDirAndPackageJson = _b[_i];
+                    var dirPath_1 = filePathDecoder_1.toFilePath(dirIdOrDirAndPackageJson[0]);
+                    var packageJson = filePathDecoder_1.toFileAbsolutePath(dirIdOrDirAndPackageJson[1]);
+                    ts.moduleNameToDirectorySet(decodedPackageJsonMap, dirPath_1, packageJson, ts.identity, function (fileName) { return ts.toPath(fileName, filePathDecoder_1.currentDirectory, filePathDecoder_1.getCanonicalFileName); }, ts.noop);
+                }
+            }
+            return toPackageJsonScope(decodedPackageJsonMap.get(dirPath));
+        }
+        function toPackageJsonScope(file) {
+            if (!file)
+                return undefined;
+            var result = packageJsonScopes === null || packageJsonScopes === void 0 ? void 0 : packageJsonScopes.get(file);
+            if (result !== undefined)
+                return result || undefined;
+            (packageJsonScopes !== null && packageJsonScopes !== void 0 ? packageJsonScopes : (packageJsonScopes = new ts.Map()));
+            if (fileExists(file)) {
+                result = {
+                    info: getPackageJsonInfo(file),
+                    affectingLocations: [file]
+                };
+            }
+            packageJsonScopes.set(file, result || false);
+            return result;
+        }
+        function getResolvedFromCache(cache, reusableCache, decodedReusableCache, dirPath, name, mode, redirectedReference, moduleNameToDirectoryMap, decodedModuleNameToDirectoryMap) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            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;
+            if (!decodedReusableCache.getOwnMap().size && !decodedReusableCache.redirectsKeyToCache.size) {
+                if (ts.isArray(reusableCache)) {
+                    setBuildInfoResolutionEntries(decodedReusableCache, compilerOptions, undefined, reusableCache, decodedModuleNameToDirectoryMap);
+                }
+                else {
+                    if (reusableCache.own)
+                        setBuildInfoResolutionEntries(decodedReusableCache, compilerOptions, 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);
+                    });
+                }
+                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;
+            })) {
+                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());
@@ -101605,6 +102432,7 @@ 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); },
@@ -101687,15 +102515,57 @@ var ts;
         return true;
     }
     ts.canWatchDirectoryOrFile = canWatchDirectoryOrFile;
+    function getResolvedModuleOfResolution(resolution) {
+        return resolution.resolvedModule;
+    }
+    ts.getResolvedModuleOfResolution = getResolvedModuleOfResolution;
+    function getResolvedTypeReferenceDirectiveOfResolution(resolution) {
+        return resolution.resolvedTypeReferenceDirective;
+    }
+    ts.getResolvedTypeReferenceDirectiveOfResolution = getResolvedTypeReferenceDirectiveOfResolution;
+    function toPerDirectoryResolution(newProgram, fileCacheFromProgram, sourceFileOrPath, perDirCache, moduleNameToDirectoryMap, onRedirectedReferenceKey, forEachResolution, toPath, ancestoryWorker) {
+        if (!(fileCacheFromProgram === null || fileCacheFromProgram === void 0 ? void 0 : fileCacheFromProgram.size()))
+            return perDirCache;
+        var path = !ts.isString(sourceFileOrPath) ? sourceFileOrPath.path : sourceFileOrPath;
+        var redirectedReference = !ts.isString(sourceFileOrPath) ? newProgram.getRedirectReferenceForResolution(sourceFileOrPath) : undefined;
+        var options = (redirectedReference === null || redirectedReference === void 0 ? void 0 : redirectedReference.commandLine.options) || newProgram.getCompilerOptions();
+        var key = ts.getRedirectsCacheKey(options);
+        onRedirectedReferenceKey(key);
+        var dirPath = ts.getDirectoryPath(path);
+        var perDirResolutionCache = perDirCache === null || perDirCache === void 0 ? void 0 : perDirCache.getMapOfCacheRedirects(redirectedReference);
+        var cacheForDir = perDirResolutionCache === null || perDirResolutionCache === void 0 ? void 0 : perDirResolutionCache.get(dirPath);
+        fileCacheFromProgram.forEach(function (r, name, mode) {
+            if (forEachResolution(r, name, mode, key, redirectedReference, dirPath))
+                return;
+            if (cacheForDir === null || cacheForDir === void 0 ? void 0 : cacheForDir.has(name, mode))
+                return;
+            if (!cacheForDir) {
+                perDirResolutionCache !== null && perDirResolutionCache !== void 0 ? perDirResolutionCache : (perDirResolutionCache = (perDirCache !== null && perDirCache !== void 0 ? perDirCache : (perDirCache = ts.createCacheWithRedirects(newProgram.getCompilerOptions()))).createMapForCompilerOptions(options, key));
+                perDirResolutionCache.set(dirPath, cacheForDir = ts.createModeAwareCache());
+            }
+            cacheForDir.set(name, mode, r);
+            if (!moduleNameToDirectoryMap || ts.isExternalModuleNameRelative(name))
+                return;
+            var actualModuleNameToDirectoryMap = moduleNameToDirectoryMap.createMapForCompilerOptions(options, key);
+            var modeAwareCacheKey = ts.getModeAwareCacheKey(name, mode);
+            var directoryPathMap = actualModuleNameToDirectoryMap.get(modeAwareCacheKey);
+            if (!directoryPathMap)
+                actualModuleNameToDirectoryMap.set(modeAwareCacheKey, directoryPathMap = new ts.Map());
+            ts.moduleNameToDirectorySet(directoryPathMap, dirPath, r, ts.getResolvedFileNameForModuleNameToDirectorySet, toPath, function (ancestorPath) { return ancestoryWorker(ancestorPath, name, mode, perDirResolutionCache); });
+        });
+        return perDirCache;
+    }
+    ts.toPerDirectoryResolution = toPerDirectoryResolution;
     function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
         var filesWithChangedSetOfUnresolvedImports;
         var filesWithInvalidatedResolutions;
-        var filesWithInvalidatedNonRelativeUnresolvedImports;
-        var nonRelativeExternalModuleResolutions = ts.createMultiMap();
         var resolutionsWithFailedLookups = [];
         var resolutionsWithOnlyAffectingLocations = [];
         var resolvedFileToResolution = ts.createMultiMap();
-        var impliedFormatPackageJsons = new ts.Map();
+        var perFilePackageJsonScope = new ts.Map();
+        var watchedPackageJsonScopes = [];
+        var packageJsonsToCloseWatcherOn;
+        var resolutionsToCloseWatcherOn;
         var hasChangedAutomaticTypeDirectiveNames = false;
         var affectingPathChecksForFile;
         var affectingPathChecks;
@@ -101704,13 +102574,12 @@ var ts;
         var isInDirectoryChecks;
         var getCurrentDirectory = ts.memoize(function () { return resolutionHost.getCurrentDirectory(); });
         var cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost();
+        var oldModuleAndTypeRefCache;
+        var oldPackageJsonInfoCache;
         var resolvedModuleNames = new ts.Map();
-        var perDirectoryResolvedModuleNames = ts.createCacheWithRedirects();
-        var nonRelativeModuleNameCache = ts.createCacheWithRedirects();
-        var moduleResolutionCache = ts.createModuleResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName, undefined, perDirectoryResolvedModuleNames, nonRelativeModuleNameCache);
+        var moduleResolutionCache = ts.createModuleResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName);
         var resolvedTypeReferenceDirectives = new ts.Map();
-        var perDirectoryResolvedTypeReferenceDirectives = ts.createCacheWithRedirects();
-        var typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName, undefined, moduleResolutionCache.getPackageJsonInfoCache(), perDirectoryResolvedTypeReferenceDirectives);
+        var typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName, undefined, moduleResolutionCache.getPackageJsonInfoCache());
         var failedLookupDefaultExtensions = [".ts", ".tsx", ".js", ".jsx", ".json"];
         var customFailedLookupPaths = new ts.Map();
         var directoryWatchesOfFailedLookups = new ts.Map();
@@ -101720,32 +102589,23 @@ var ts;
         var rootSplitLength = rootPath !== undefined ? rootPath.split(ts.directorySeparator).length : 0;
         var typeRootsWatches = new ts.Map();
         return {
+            resolvedModuleNames: resolvedModuleNames,
+            resolvedTypeReferenceDirectives: resolvedTypeReferenceDirectives,
             getModuleResolutionCache: function () { return moduleResolutionCache; },
+            getTypeReferenceDirectiveResolutionCache: function () { return typeReferenceDirectiveResolutionCache; },
             startRecordingFilesWithChangedResolutions: startRecordingFilesWithChangedResolutions,
             finishRecordingFilesWithChangedResolutions: finishRecordingFilesWithChangedResolutions,
             startCachingPerDirectoryResolution: startCachingPerDirectoryResolution,
             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) {
-            return resolution.resolvedModule;
-        }
-        function getResolvedTypeReferenceDirective(resolution) {
-            return resolution.resolvedTypeReferenceDirective;
-        }
         function isInDirectoryPath(dir, file) {
             if (dir === undefined || file.length <= dir.length) {
                 return false;
@@ -101756,21 +102616,25 @@ var ts;
             ts.clearMap(directoryWatchesOfFailedLookups, ts.closeFileWatcherOf);
             ts.clearMap(fileWatchesOfAffectingLocations, ts.closeFileWatcherOf);
             customFailedLookupPaths.clear();
-            nonRelativeExternalModuleResolutions.clear();
             closeTypeRootsWatch();
             resolvedModuleNames.clear();
             resolvedTypeReferenceDirectives.clear();
             resolvedFileToResolution.clear();
             resolutionsWithFailedLookups.length = 0;
             resolutionsWithOnlyAffectingLocations.length = 0;
+            watchedPackageJsonScopes.length = 0;
             failedLookupChecks = undefined;
             startsWithPathChecks = undefined;
             isInDirectoryChecks = undefined;
             affectingPathChecks = undefined;
             affectingPathChecksForFile = undefined;
+            resolutionsToCloseWatcherOn = undefined;
+            packageJsonsToCloseWatcherOn = undefined;
+            oldModuleAndTypeRefCache = undefined;
+            oldPackageJsonInfoCache = undefined;
             moduleResolutionCache.clear();
             typeReferenceDirectiveResolutionCache.clear();
-            impliedFormatPackageJsons.clear();
+            perFilePackageJsonScope.clear();
             hasChangedAutomaticTypeDirectiveNames = false;
         }
         function startRecordingFilesWithChangedResolutions() {
@@ -101781,13 +102645,6 @@ var ts;
             filesWithChangedSetOfUnresolvedImports = undefined;
             return collected;
         }
-        function isFileWithInvalidatedNonRelativeUnresolvedImports(path) {
-            if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
-                return false;
-            }
-            var value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);
-            return !!value && !!value.length;
-        }
         function createHasInvalidatedResolution(forceAllFilesAsInvalidated) {
             invalidateResolutionsOfFailedLookupLocations();
             if (forceAllFilesAsInvalidated) {
@@ -101796,71 +102653,239 @@ var ts;
             }
             var collected = filesWithInvalidatedResolutions;
             filesWithInvalidatedResolutions = undefined;
-            return function (path) { return (!!collected && collected.has(path)) ||
-                isFileWithInvalidatedNonRelativeUnresolvedImports(path); };
+            return function (path) { return !!(collected === null || collected === void 0 ? void 0 : collected.has(path)); };
         }
         function startCachingPerDirectoryResolution() {
-            moduleResolutionCache.clearAllExceptPackageJsonInfoCache();
-            typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();
-            nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
-            nonRelativeExternalModuleResolutions.clear();
+            var packageJsonInfoCache = moduleResolutionCache.getPackageJsonInfoCache();
+            var internalCache = packageJsonInfoCache.getInternalMap();
+            moduleResolutionCache.clear();
+            typeReferenceDirectiveResolutionCache.clear();
+            moduleResolutionCache.update(resolutionHost.getCompilationSettings());
+            typeReferenceDirectiveResolutionCache.update(resolutionHost.getCompilationSettings());
+            if (oldModuleAndTypeRefCache) {
+                oldModuleAndTypeRefCache.clearRedirectsMap();
+                moduleResolutionCache.setOldResolutionCache(oldModuleAndTypeRefCache.modules);
+                typeReferenceDirectiveResolutionCache.setOldResolutionCache(oldModuleAndTypeRefCache.typeRefs);
+            }
+            packageJsonInfoCache.setInternalMap(internalCache);
+            packageJsonInfoCache.setOldPackageJsonScopeCache(oldPackageJsonInfoCache);
         }
         function finishCachingPerDirectoryResolution(newProgram, oldProgram) {
-            filesWithInvalidatedNonRelativeUnresolvedImports = undefined;
-            nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
-            nonRelativeExternalModuleResolutions.clear();
-            if (newProgram !== oldProgram) {
-                newProgram === null || newProgram === void 0 ? void 0 : newProgram.getSourceFiles().forEach(function (newFile) {
-                    var _a, _b, _c;
-                    var expected = ts.isExternalOrCommonJsModule(newFile) ? (_b = (_a = newFile.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 : 0;
-                    var existing = (_c = impliedFormatPackageJsons.get(newFile.path)) !== null && _c !== void 0 ? _c : ts.emptyArray;
-                    for (var i = existing.length; i < expected; i++) {
-                        createFileWatcherOfAffectingLocation(newFile.packageJsonLocations[i], false);
+            hasChangedAutomaticTypeDirectiveNames = false;
+            if (!newProgram) {
+                clear();
+                return;
+            }
+            if (newProgram === oldProgram)
+                return;
+            var needsResolutionUpdate = newProgram.structureIsReused !== 3;
+            var modules;
+            var typeRefs;
+            var moduleNameToDirectoryMap = ts.createCacheWithRedirects(newProgram.getCompilerOptions());
+            var dirToPackageJsonScope = new ts.Map();
+            for (var _i = 0, _a = newProgram.getSourceFiles(); _i < _a.length; _i++) {
+                var newFile = _a[_i];
+                if (needsResolutionUpdate) {
+                    modules = ensureResolutionsOfFile(newProgram, resolvedModuleNames, newFile.resolvedModules, newFile, getResolvedModuleOfResolution, modules, moduleNameToDirectoryMap);
+                    typeRefs = ensureResolutionsOfFile(newProgram, resolvedTypeReferenceDirectives, newFile.resolvedTypeReferenceDirectiveNames, newFile, getResolvedTypeReferenceDirectiveOfResolution, typeRefs, undefined);
+                }
+                ensurePackageJsonWatchesForFile(newFile, dirToPackageJsonScope);
+            }
+            if (needsResolutionUpdate) {
+                var newProgramAutoTypeRefContainingFile = resolutionHost.toPath(newProgram.getAutomaticTypeDirectiveContainingFile());
+                typeRefs = ensureResolutionsOfFile(newProgram, resolvedTypeReferenceDirectives, newProgram.getAutomaticTypeDirectiveResolutions(), newProgramAutoTypeRefContainingFile, getResolvedTypeReferenceDirectiveOfResolution, typeRefs, undefined);
+                if (!modules && !typeRefs) {
+                    oldModuleAndTypeRefCache = undefined;
+                }
+                else {
+                    oldModuleAndTypeRefCache = getOldResolutionCache(modules, typeRefs, moduleNameToDirectoryMap);
+                }
+                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);
                     }
-                    if (existing.length > expected) {
-                        for (var i = expected; i < existing.length; i++) {
-                            fileWatchesOfAffectingLocations.get(existing[i]).files--;
-                        }
+                    var oldProgramAutoTypeRefContainingFile = resolutionHost.toPath(oldProgram.getAutomaticTypeDirectiveContainingFile());
+                    if (oldProgramAutoTypeRefContainingFile !== newProgramAutoTypeRefContainingFile) {
+                        removeResolutionsOfFile(oldProgramAutoTypeRefContainingFile);
                     }
-                    if (expected)
-                        impliedFormatPackageJsons.set(newFile.path, newFile.packageJsonLocations);
-                    else
-                        impliedFormatPackageJsons.delete(newFile.path);
-                });
-                impliedFormatPackageJsons.forEach(function (existing, path) {
-                    if (!(newProgram === null || newProgram === void 0 ? void 0 : newProgram.getSourceFileByPath(path))) {
-                        existing.forEach(function (location) { return fileWatchesOfAffectingLocations.get(location).files--; });
-                        impliedFormatPackageJsons.delete(path);
-                    }
-                });
+                }
             }
-            directoryWatchesOfFailedLookups.forEach(function (watcher, path) {
-                if (watcher.refCount === 0) {
-                    directoryWatchesOfFailedLookups.delete(path);
-                    watcher.watcher.close();
+            perFilePackageJsonScope.forEach(function (existing, path) {
+                if (!(newProgram === null || newProgram === void 0 ? void 0 : newProgram.getSourceFileByPath(path))) {
+                    stopWatchingPackageJsonScope(existing, path);
+                    perFilePackageJsonScope.delete(path);
                 }
             });
+            if (dirToPackageJsonScope.size) {
+                oldPackageJsonInfoCache = getOldPackageJsonInfoCache(dirToPackageJsonScope);
+            }
+            else {
+                oldPackageJsonInfoCache = undefined;
+            }
+            if (needsResolutionUpdate && (!oldProgram || newProgram.getCompilerOptions() !== oldProgram.getCompilerOptions()))
+                updateTypeRootsWatch();
+            resolutionsToCloseWatcherOn === null || resolutionsToCloseWatcherOn === void 0 ? void 0 : resolutionsToCloseWatcherOn.forEach(closeWatchersOfResolution);
+            resolutionsToCloseWatcherOn = undefined;
+            packageJsonsToCloseWatcherOn === null || packageJsonsToCloseWatcherOn === void 0 ? void 0 : packageJsonsToCloseWatcherOn.forEach(closeWatchersOfPackageJsonScope);
+            packageJsonsToCloseWatcherOn = undefined;
             fileWatchesOfAffectingLocations.forEach(function (watcher, path) {
                 if (watcher.files === 0 && watcher.resolutions === 0) {
                     fileWatchesOfAffectingLocations.delete(path);
                     watcher.watcher.close();
                 }
             });
-            hasChangedAutomaticTypeDirectiveNames = false;
         }
-        function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
+        function ensurePackageJsonWatchesForFile(newFile, dirToPackageJsonScope) {
+            var _a;
+            var existing = perFilePackageJsonScope.get(newFile.path);
+            var scope = ts.isExternalOrCommonJsModule(newFile) ? newFile.packageJsonScope : undefined;
+            if (scope) {
+                ((_a = scope.files) !== null && _a !== void 0 ? _a : (scope.files = new ts.Set())).add(newFile.path);
+                watchPackageJsonScopeLocations(scope, scope.failedLookupLocations, "watchedFailed");
+                watchPackageJsonScopeLocations(scope, scope.affectingLocations, "watchedAffected");
+                perFilePackageJsonScope.set(newFile.path, scope);
+                ts.moduleNameToDirectorySet(dirToPackageJsonScope, ts.getDirectoryPath(newFile.resolvedPath), scope, ts.getPackageJsconLocationFromScope, function (dir) { return resolutionHost.toPath(dir); }, ts.noop);
+            }
+            if (existing && scope !== existing)
+                stopWatchingPackageJsonScope(existing, newFile.path);
+        }
+        function stopWatchingPackageJsonScope(scope, path) {
             var _a, _b;
+            (_a = scope.files) === null || _a === void 0 ? void 0 : _a.delete(path);
+            if (!((_b = scope.files) === null || _b === void 0 ? void 0 : _b.size))
+                (packageJsonsToCloseWatcherOn !== null && packageJsonsToCloseWatcherOn !== void 0 ? packageJsonsToCloseWatcherOn : (packageJsonsToCloseWatcherOn = [])).push(scope);
+        }
+        function watchPackageJsonScopeLocations(scope, locations, field) {
+            var _a, _b;
+            var locationsLength = (_a = locations === null || locations === void 0 ? void 0 : locations.length) !== null && _a !== void 0 ? _a : 0;
+            if (!locationsLength || scope[field] === locationsLength)
+                return;
+            if (!scope.watchedFailed && !scope.watchedAffected)
+                watchedPackageJsonScopes.push(scope);
+            for (var i = (_b = scope[field]) !== null && _b !== void 0 ? _b : 0; i < locationsLength; i++) {
+                createFileWatcherOfAffectingLocation(locations[i], false);
+            }
+            scope[field] = locationsLength;
+        }
+        function closeWatchersOfPackageJsonScope(scope) {
+            var _a;
+            if (((_a = scope.files) === null || _a === void 0 ? void 0 : _a.size) || !scope.files)
+                return;
+            scope.files = undefined;
+            ts.unorderedRemoveItem(watchedPackageJsonScopes, scope);
+            stopWatchingPackageJsonScopeLocations(scope, scope.failedLookupLocations, "watchedFailed");
+            stopWatchingPackageJsonScopeLocations(scope, scope.affectingLocations, "watchedAffected");
+        }
+        function stopWatchingPackageJsonScopeLocations(scope, locations, field) {
+            if (!scope[field])
+                return;
+            for (var i = 0; i < scope[field]; i++) {
+                fileWatchesOfAffectingLocations.get(locations[i]).files--;
+            }
+            scope[field] = undefined;
+        }
+        function getOldPackageJsonInfoCache(dirToPackageJsonScope) {
+            var packageJsons;
+            return {
+                getPackageJsonScope: function (dir) {
+                    var _a;
+                    var scope = dirToPackageJsonScope.get(dir);
+                    if (!scope)
+                        return undefined;
+                    if (!scope.isInvalidated)
+                        return scope;
+                    if (!resolutionHost.getCompilationSettings().cacheResolutions || !scope.info)
+                        return undefined;
+                    var packageJson = ts.getPackageJsconLocationFromScope(scope);
+                    var result = packageJsons === null || packageJsons === void 0 ? void 0 : packageJsons.get(packageJson);
+                    if (result !== undefined)
+                        return result || undefined;
+                    if (resolutionHost.fileExists(packageJson)) {
+                        result = {
+                            info: ts.getPackageJsonInfo(ts.getDirectoryPath(packageJson), false, ts.getTemporaryModuleResolutionState(moduleResolutionCache.getPackageJsonInfoCache(), ((_a = resolutionHost.getCompilerHost) === null || _a === void 0 ? void 0 : _a.call(resolutionHost)) || resolutionHost, resolutionHost.getCompilationSettings())),
+                            affectingLocations: [packageJson],
+                        };
+                    }
+                    (packageJsons !== null && packageJsons !== void 0 ? packageJsons : (packageJsons = new ts.Map())).set(packageJson, result || false);
+                    return result;
+                }
+            };
+        }
+        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();
+            perDirCache = toPerDirectoryResolution(newProgram, fileCacheFromProgram, sourceFileOrPath, perDirCache, moduleNameToDirectoryMap, function (key) {
+                if (resolutionsInFile && resolutionsInFile.key !== key) {
+                    resolutionsInFile.cache.forEach(function (r) { return stopWatchingResolution(r, path, getResolutionWithResolvedFileName); });
+                    resolutionsInFile = undefined;
+                }
+            }, function (r, name, mode, key) {
+                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, cache: ts.createModeAwareCache() });
+                resolutionsInFile.cache.set(name, mode, r);
+            }, function (dir) { return resolutionHost.toPath(dir); }, ts.noop);
+            if (((resolutionsInFile === null || resolutionsInFile === void 0 ? void 0 : resolutionsInFile.cache.size()) || 0) !== seenNamesInFile.size()) {
+                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, 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 primaryResult = ts.resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
             if (!resolutionHost.getGlobalCache) {
                 return primaryResult;
             }
             var globalCache = resolutionHost.getGlobalCache();
             if (globalCache !== undefined && !ts.isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && ts.extensionIsTS(primaryResult.resolvedModule.extension))) {
-                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;
+                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;
                 if (resolvedModule) {
                     primaryResult.resolvedModule = resolvedModule;
-                    (_a = primaryResult.failedLookupLocations).push.apply(_a, failedLookupLocations);
-                    (_b = primaryResult.affectingLocations).push.apply(_b, affectingLocations);
+                    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);
                     return primaryResult;
                 }
             }
@@ -101870,68 +102895,35 @@ var ts;
             return ts.resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode);
         }
         function resolveNamesWithLocalCache(_a) {
-            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 _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 path = resolutionHost.toPath(containingFile);
-            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 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 resolvedModules = [];
-            var compilerOptions = resolutionHost.getCompilationSettings();
-            var hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path);
-            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_5 = names; _i < names_5.length; _i++) {
-                var entry = names_5[_i];
-                var name = ts.isString(entry) ? entry : entry.fileName.toLowerCase();
+            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);
                 var mode = !ts.isString(entry) ? ts.getModeForFileReference(entry, containingSourceFileMode) :
-                    containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, i) : undefined;
+                    containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, (_b = partialResolutionInfo === null || partialResolutionInfo === void 0 ? void 0 : partialResolutionInfo.namesIndex[i]) !== null && _b !== void 0 ? _b : i) : undefined;
                 i++;
-                var resolution = resolutionsInFile.get(name, mode);
-                if (!seenNamesInFile.has(name, mode) &&
-                    unmatchedRedirects || !resolution || resolution.isInvalidated ||
-                    (hasInvalidatedNonRelativeUnresolvedImport && !ts.isExternalModuleNameRelative(name) && shouldRetryResolution(resolution))) {
+                var resolution = resolutionsInFile.cache.get(name, mode);
+                if (!seenNamesInFile.has(name, mode) && (!resolution || resolution.isInvalidated)) {
                     var existingResolution = resolution;
-                    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));
-                        }
+                    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();
                     }
-                    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.set(name, mode, resolution);
-                    watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName);
+                    resolutionsInFile.cache.set(name, mode, resolution);
                     if (existingResolution) {
-                        stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
+                        stopWatchingResolution(existingResolution, path, getResolutionWithResolvedFileName);
                     }
                     if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
                         filesWithChangedSetOfUnresolvedImports.push(path);
@@ -101944,27 +102936,33 @@ var ts;
                         var resolved = getResolutionWithResolvedFileName(resolution);
                         ts.trace(host, loader === resolveModuleName ?
                             (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ?
-                                resolved.packagetId ?
+                                resolved.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 :
                                 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.packagetId ?
+                                resolved.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 :
-                                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.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.Debug.assert(resolution !== undefined && !resolution.isInvalidated);
                 seenNamesInFile.set(name, mode, true);
-                resolvedModules.push(getResolutionWithResolvedFileName(resolution));
+                resolvedModules.push(resolution);
             }
-            resolutionsInFile.forEach(function (resolution, name, mode) {
-                if (!seenNamesInFile.has(name, mode) && !ts.contains(reusedNames, name)) {
-                    stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
-                    resolutionsInFile.delete(name, mode);
-                }
+            (_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);
             });
+            if (resolutionsInFile.cache.size() !== seenNamesInFile.size()) {
+                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) {
@@ -101984,40 +102982,31 @@ var ts;
                 return oldResult.resolvedFileName === newResult.resolvedFileName;
             }
         }
-        function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode) {
+        function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, partialResolutionInfo) {
             return resolveNamesWithLocalCache({
                 names: typeDirectiveNames,
                 containingFile: containingFile,
                 redirectedReference: redirectedReference,
-                cache: resolvedTypeReferenceDirectives,
-                perDirectoryCacheWithRedirects: perDirectoryResolvedTypeReferenceDirectives,
+                perFileCache: resolvedTypeReferenceDirectives,
                 loader: resolveTypeReferenceDirective,
-                getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
-                shouldRetryResolution: function (resolution) { return resolution.resolvedTypeReferenceDirective === undefined; },
-                containingSourceFileMode: containingFileMode
+                getResolutionWithResolvedFileName: getResolvedTypeReferenceDirectiveOfResolution,
+                containingSourceFileMode: containingFileMode,
+                partialResolutionInfo: partialResolutionInfo,
             });
         }
-        function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile) {
+        function resolveModuleNames(moduleNames, containingFile, redirectedReference, containingSourceFile, partialResolutionInfo) {
             return resolveNamesWithLocalCache({
                 names: moduleNames,
                 containingFile: containingFile,
                 redirectedReference: redirectedReference,
-                cache: resolvedModuleNames,
-                perDirectoryCacheWithRedirects: perDirectoryResolvedModuleNames,
+                perFileCache: resolvedModuleNames,
                 loader: resolveModuleName,
-                getResolutionWithResolvedFileName: getResolvedModule,
-                shouldRetryResolution: function (resolution) { return !resolution.resolvedModule || !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension); },
-                reusedNames: reusedNames,
+                getResolutionWithResolvedFileName: getResolvedModuleOfResolution,
+                partialResolutionInfo: partialResolutionInfo,
                 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");
         }
@@ -102071,37 +103060,41 @@ var ts;
         function isPathWithDefaultFailedLookupExtension(path) {
             return ts.fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
         }
-        function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName) {
-            if (resolution.refCount) {
-                resolution.refCount++;
-                ts.Debug.assertIsDefined(resolution.files);
+        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);
             }
             else {
-                resolution.refCount = 1;
-                ts.Debug.assert(ts.length(resolution.files) === 0);
-                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.watchedFailed = false;
+                watchAffectingLocationsOfResolution(resolution);
             }
-            (resolution.files || (resolution.files = [])).push(filePath);
         }
         function watchFailedLookupLocationOfResolution(resolution) {
-            ts.Debug.assert(!!resolution.refCount);
-            var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations;
-            if (!failedLookupLocations.length && !affectingLocations.length)
+            var failedLookupLocations = resolution.failedLookupLocations;
+            if (!failedLookupLocations.length || resolution.watchedFailed === failedLookupLocations.length)
                 return;
-            if (failedLookupLocations.length)
+            if (!resolution.watchedFailed) {
                 resolutionsWithFailedLookups.push(resolution);
-            var setAtRoot = false;
-            for (var _i = 0, failedLookupLocations_1 = failedLookupLocations; _i < failedLookupLocations_1.length; _i++) {
-                var failedLookupLocation = failedLookupLocations_1[_i];
+                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 failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
                 var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
                 if (toWatch) {
@@ -102119,22 +103112,22 @@ var ts;
                     }
                 }
             }
-            if (setAtRoot) {
+            if (setAtRoot && !resolution.setAtRoot) {
                 setDirectoryWatcher(rootDir, rootPath, true);
             }
-            watchAffectingLocationsOfResolution(resolution, !failedLookupLocations.length);
+            resolution.setAtRoot = setAtRoot;
+            resolution.watchedFailed = failedLookupLocations.length;
         }
-        function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
-            ts.Debug.assert(!!resolution.refCount);
+        function watchAffectingLocationsOfResolution(resolution) {
             var affectingLocations = resolution.affectingLocations;
-            if (!affectingLocations.length)
+            if (!(affectingLocations === null || affectingLocations === void 0 ? void 0 : affectingLocations.length) || resolution.watchedAffected === affectingLocations.length)
                 return;
-            if (addToResolutionsWithOnlyAffectingLocations)
+            if (!resolution.watchedFailed && !resolution.watchedAffected)
                 resolutionsWithOnlyAffectingLocations.push(resolution);
-            for (var _i = 0, affectingLocations_1 = affectingLocations; _i < affectingLocations_1.length; _i++) {
-                var affectingLocation = affectingLocations_1[_i];
-                createFileWatcherOfAffectingLocation(affectingLocation, true);
+            for (var i = resolution.watchedAffected || 0; i < affectingLocations.length; i++) {
+                createFileWatcherOfAffectingLocation(affectingLocations[i], true);
             }
+            resolution.watchedAffected = affectingLocations.length;
         }
         function createFileWatcherOfAffectingLocation(affectingLocation, forResolution) {
             var fileWatcher = fileWatchesOfAffectingLocations.get(affectingLocation);
@@ -102193,15 +103186,6 @@ var ts;
                 paths.add(affectingLocation);
             }
         }
-        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, true); });
-            }
-        }
         function setDirectoryWatcher(dir, dirPath, nonRecursive) {
             var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
             if (dirWatcher) {
@@ -102212,21 +103196,27 @@ var ts;
                 directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive: nonRecursive });
             }
         }
-        function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName) {
-            ts.unorderedRemoveItem(ts.Debug.checkDefined(resolution.files), filePath);
-            resolution.refCount--;
-            if (resolution.refCount) {
+        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 (((_b = resolution.files) === null || _b === void 0 ? void 0 : _b.size) || !resolution.files)
                 return;
-            }
-            var resolved = getResolutionWithResolvedFileName(resolution);
+            resolution.files = undefined;
+            var resolved = getResolved(resolution);
             if (resolved && resolved.resolvedFileName) {
                 resolvedFileToResolution.remove(resolutionHost.toPath(resolved.resolvedFileName), resolution);
             }
-            var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations;
-            if (ts.unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) {
+            if (resolution.watchedFailed) {
+                ts.unorderedRemoveItem(resolutionsWithFailedLookups, resolution);
                 var removeAtRoot = false;
-                for (var _i = 0, failedLookupLocations_2 = failedLookupLocations; _i < failedLookupLocations_2.length; _i++) {
-                    var failedLookupLocation = failedLookupLocations_2[_i];
+                for (var i = 0; i < resolution.watchedFailed; i++) {
+                    var failedLookupLocation = resolution.failedLookupLocations[i];
                     var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
                     var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
                     if (toWatch) {
@@ -102249,22 +103239,28 @@ var ts;
                         }
                     }
                 }
+                ts.Debug.assert(resolution.setAtRoot === removeAtRoot);
                 if (removeAtRoot) {
                     removeDirectoryWatcher(rootPath);
                 }
             }
-            else if (affectingLocations.length) {
+            else if (resolution.watchedAffected) {
                 ts.unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution);
             }
-            for (var _a = 0, affectingLocations_2 = affectingLocations; _a < affectingLocations_2.length; _a++) {
-                var affectingLocation = affectingLocations_2[_a];
-                var watcher = fileWatchesOfAffectingLocations.get(affectingLocation);
-                watcher.resolutions--;
+            if (resolution.watchedAffected) {
+                for (var i = 0; i < resolution.watchedAffected; i++) {
+                    var watcher = fileWatchesOfAffectingLocations.get(resolution.affectingLocations[i]);
+                    watcher.resolutions--;
+                }
             }
         }
         function removeDirectoryWatcher(dirPath) {
             var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
             dirWatcher.refCount--;
+            if (dirWatcher.refCount === 0) {
+                directoryWatchesOfFailedLookups.delete(dirPath);
+                dirWatcher.watcher.close();
+            }
         }
         function createDirectoryWatcher(directory, dirPath, nonRecursive) {
             return resolutionHost.watchDirectoryOfFailedLookupLocation(directory, function (fileOrDirectory) {
@@ -102278,26 +103274,16 @@ var ts;
         function removeResolutionsOfFileFromCache(cache, filePath, getResolutionWithResolvedFileName) {
             var resolutions = cache.get(filePath);
             if (resolutions) {
-                resolutions.forEach(function (resolution) { return stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName); });
+                resolutions.cache.forEach(function (resolution) { return stopWatchingResolution(resolution, filePath, getResolutionWithResolvedFileName); });
                 cache.delete(filePath);
             }
         }
-        function removeResolutionsFromProjectReferenceRedirects(filePath) {
-            if (!ts.fileExtensionIs(filePath, ".json"))
-                return;
-            var program = resolutionHost.getCurrentProgram();
-            if (!program)
-                return;
-            var resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath);
-            if (!resolvedProjectReference)
-                return;
-            resolvedProjectReference.commandLine.fileNames.forEach(function (f) { return removeResolutionsOfFile(resolutionHost.toPath(f)); });
-        }
         function removeResolutionsOfFile(filePath) {
-            removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule);
-            removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective);
+            removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModuleOfResolution);
+            removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirectiveOfResolution);
         }
         function invalidateResolutions(resolutions, canInvalidate) {
+            var _a;
             if (!resolutions)
                 return false;
             var invalidated = false;
@@ -102306,16 +103292,14 @@ var ts;
                 if (resolution.isInvalidated || !canInvalidate(resolution))
                     continue;
                 resolution.isInvalidated = invalidated = true;
-                for (var _a = 0, _b = ts.Debug.checkDefined(resolution.files); _a < _b.length; _a++) {
-                    var containingFilePath = _b[_a];
+                (_a = resolution.files) === null || _a === void 0 ? void 0 : _a.forEach(function (containingFilePath) {
                     (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(containingFilePath);
                     hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || ts.endsWith(containingFilePath, ts.inferredTypesContainingFile);
-                }
+                });
             }
             return invalidated;
         }
         function invalidateResolutionOfFile(filePath) {
-            removeResolutionsOfFile(filePath);
             var prevHasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
             if (invalidateResolutions(resolvedFileToResolution.get(filePath), ts.returnTrue) &&
                 hasChangedAutomaticTypeDirectiveNames &&
@@ -102324,8 +103308,28 @@ var ts;
             }
         }
         function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap) {
-            ts.Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === undefined);
-            filesWithInvalidatedNonRelativeUnresolvedImports = 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);
+                    }
+                });
+            });
         }
         function scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) {
             if (isCreatingWatchedDirectory) {
@@ -102364,12 +103368,17 @@ var ts;
             var _a;
             var invalidated = false;
             if (affectingPathChecksForFile) {
-                (_a = resolutionHost.getCurrentProgram()) === null || _a === void 0 ? void 0 : _a.getSourceFiles().forEach(function (f) {
-                    if (ts.some(f.packageJsonLocations, function (location) { return affectingPathChecksForFile.has(location); })) {
-                        (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(f.path);
+                for (var _i = 0, watchedPackageJsonScopes_1 = watchedPackageJsonScopes; _i < watchedPackageJsonScopes_1.length; _i++) {
+                    var scope = watchedPackageJsonScopes_1[_i];
+                    if (scope.isInvalidated)
+                        continue;
+                    if (ts.some(scope.failedLookupLocations, function (location) { return affectingPathChecksForFile.has(location); }) ||
+                        ts.some(scope.affectingLocations, function (location) { return affectingPathChecksForFile.has(location); })) {
+                        scope.isInvalidated = true;
                         invalidated = true;
+                        (_a = scope.files) === null || _a === void 0 ? void 0 : _a.forEach(function (path) { return (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(path); });
                     }
-                });
+                }
                 affectingPathChecksForFile = undefined;
             }
             if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks && !affectingPathChecks) {
@@ -102400,7 +103409,8 @@ var ts;
                 ts.firstDefinedIterator((isInDirectoryChecks === null || isInDirectoryChecks === void 0 ? void 0 : isInDirectoryChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : undefined; });
         }
         function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
-            return !!affectingPathChecks && resolution.affectingLocations.some(function (location) { return affectingPathChecks.has(location); });
+            var _a;
+            return !!affectingPathChecks && !!((_a = resolution.affectingLocations) === null || _a === void 0 ? void 0 : _a.some(function (location) { return affectingPathChecks.has(location); }));
         }
         function closeTypeRootsWatch() {
             ts.clearMap(typeRootsWatches, ts.closeFileWatcher);
@@ -102701,9 +103711,9 @@ var ts;
             var targets = importedFileNames.map(function (f) { return ts.getNormalizedAbsolutePath(f, cwd); });
             var shouldFilterIgnoredPaths = !ts.every(targets, ts.containsIgnoredPath);
             if (!preferSymlinks) {
-                var result_16 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_16)
-                    return result_16;
+                var result_17 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_17)
+                    return result_17;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -102722,10 +103732,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_17 = cb(option, target === referenceRedirect);
+                        var result_18 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true;
-                        if (result_17)
-                            return result_17;
+                        if (result_18)
+                            return result_18;
                     }
                 });
             });
@@ -102784,9 +103794,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_11 = _loop_35(directory);
+                var state_12 = _loop_35(directory);
                 directory = out_directory_1;
-                if (state_11 === "break")
+                if (state_12 === "break")
                     break;
             }
             if (allFileNames.size) {
@@ -102876,9 +103886,9 @@ var ts;
                 };
                 for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) {
                     var patternText_1 = _a[_i];
-                    var state_12 = _loop_36(patternText_1);
-                    if (typeof state_12 === "object")
-                        return state_12.value;
+                    var state_13 = _loop_36(patternText_1);
+                    if (typeof state_13 === "object")
+                        return state_13.value;
                 }
             }
             function validateEnding(_a) {
@@ -103331,7 +104341,7 @@ var ts;
     }
     ts.explainFiles = explainFiles;
     function explainIfFileIsRedirectAndImpliedFormat(file, fileNameConvertor) {
-        var _a;
+        var _a, _b;
         var result;
         if (file.path !== file.resolvedPath) {
             (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(undefined, ts.Diagnostics.File_is_output_of_project_reference_source_0, toFileName(file.originalFileName, fileNameConvertor)));
@@ -103342,17 +104352,17 @@ var ts;
         if (ts.isExternalOrCommonJsModule(file)) {
             switch (file.impliedNodeFormat) {
                 case ts.ModuleKind.ESNext:
-                    if (file.packageJsonScope) {
-                        (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(undefined, ts.Diagnostics.File_is_ECMAScript_module_because_0_has_field_type_with_value_module, toFileName(ts.last(file.packageJsonLocations), fileNameConvertor)));
+                    if ((_a = file.packageJsonScope) === null || _a === void 0 ? void 0 : _a.info) {
+                        (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(undefined, ts.Diagnostics.File_is_ECMAScript_module_because_0_has_field_type_with_value_module, toFileName(ts.getPackageJsconLocationFromScope(file.packageJsonScope), fileNameConvertor)));
                     }
                     break;
                 case ts.ModuleKind.CommonJS:
-                    if (file.packageJsonScope) {
-                        (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(undefined, file.packageJsonScope.packageJsonContent.type ?
+                    if ((_b = file.packageJsonScope) === null || _b === void 0 ? void 0 : _b.info) {
+                        (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(undefined, file.packageJsonScope.info.packageJsonContent.type ?
                             ts.Diagnostics.File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module :
-                            ts.Diagnostics.File_is_CommonJS_module_because_0_does_not_have_field_type, toFileName(ts.last(file.packageJsonLocations), fileNameConvertor)));
+                            ts.Diagnostics.File_is_CommonJS_module_because_0_does_not_have_field_type, toFileName(ts.getPackageJsconLocationFromScope(file.packageJsonScope), fileNameConvertor)));
                     }
-                    else if ((_a = file.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) {
+                    else if (file.packageJsonScope) {
                         (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages(undefined, ts.Diagnostics.File_is_CommonJS_module_because_package_json_was_not_found));
                     }
                     break;
@@ -103723,7 +104733,7 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
-    function readBuilderProgram(compilerOptions, host) {
+    function readBuildInfoForProgram(compilerOptions, host) {
         var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(compilerOptions);
         if (!buildInfoPath)
             return undefined;
@@ -103743,7 +104753,12 @@ var ts;
             return undefined;
         if (!buildInfo.program)
             return undefined;
-        return ts.createBuilderProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);
+        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);
     }
     ts.readBuilderProgram = readBuilderProgram;
     function createIncrementalCompilerHost(options, system) {
@@ -103876,7 +104891,7 @@ var ts;
                 }
                 return host.resolveModuleNames.apply(host, args);
             }) :
-            (function (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile); });
+            (function (moduleNames, containingFile, _reusedNames, redirectedReference, _options, sourceFile, partialResolutionInfo) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, redirectedReference, sourceFile, partialResolutionInfo); });
         compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ?
             (function () {
                 var args = [];
@@ -103885,10 +104900,13 @@ var ts;
                 }
                 return host.resolveTypeReferenceDirectives.apply(host, args);
             }) :
-            (function (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode); });
+            (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(); });
         var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
         builderProgram = readBuilderProgram(compilerOptions, compilerHost);
         synchronizeProgram();
@@ -103954,7 +104972,8 @@ var ts;
                 }
             }
             var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution);
-            if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+            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 (hasChangedConfigFileParsingErrors) {
                     if (reportFileChangeDetectedOnCreateProgram) {
                         reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -103973,6 +104992,11 @@ 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) {
@@ -103981,7 +105005,6 @@ var ts;
             writeLog("  options: " + JSON.stringify(compilerOptions));
             if (projectReferences)
                 writeLog("  projectReferences: " + JSON.stringify(projectReferences));
-            var needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !getCurrentProgram();
             hasChangedCompilerOptions = false;
             hasChangedConfigFileParsingErrors = false;
             resolutionCache.startCachingPerDirectoryResolution();
@@ -103991,9 +105014,6 @@ var ts;
             builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
             resolutionCache.finishCachingPerDirectoryResolution(builderProgram.getProgram(), oldProgram);
             ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = new ts.Map()), watchMissingFilePath);
-            if (needsUpdateInTypeRootWatch) {
-                resolutionCache.updateTypeRootsWatch();
-            }
             if (missingFilePathsRequestedForRelease) {
                 for (var _i = 0, missingFilePathsRequestedForRelease_1 = missingFilePathsRequestedForRelease; _i < missingFilePathsRequestedForRelease_1.length; _i++) {
                     var missingFilePath = missingFilePathsRequestedForRelease_1[_i];
@@ -104078,7 +105098,7 @@ var ts;
             var hostSourceFile = sourceFilesCache.get(path);
             return !hostSourceFile || !hostSourceFile.version ? undefined : hostSourceFile.version;
         }
-        function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
+        function onReleaseOldSourceFile(oldSourceFile) {
             var hostSourceFileInfo = sourceFilesCache.get(oldSourceFile.resolvedPath);
             if (hostSourceFileInfo !== undefined) {
                 if (isFileMissingOnHost(hostSourceFileInfo)) {
@@ -104089,9 +105109,6 @@ var ts;
                         hostSourceFileInfo.fileWatcher.close();
                     }
                     sourceFilesCache.delete(oldSourceFile.resolvedPath);
-                    if (!hasSourceFileByPath) {
-                        resolutionCache.removeResolutionsOfFile(oldSourceFile.path);
-                    }
                 }
             }
         }
@@ -104326,7 +105343,6 @@ 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();
                 });
@@ -104339,7 +105355,6 @@ 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));
             if ((_b = commandLine.parsedCommandLine) === null || _b === void 0 ? void 0 : _b.wildcardDirectories) {
@@ -104512,20 +105527,22 @@ var ts;
         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, 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).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);
+            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);
             };
             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).resolvedTypeReferenceDirective; };
+            var loader_4 = function (moduleName, containingFile, redirectedReference, containingFileMode) { return ts.resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode); };
             compilerHost.resolveTypeReferenceDirectives = function (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) {
-                return ts.loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_4);
+                return ts.loadWithTypeDirectiveCache(typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode, loader_4);
             };
+            compilerHost.getTypeReferenceDirectiveResolutionCache = function () { return typeReferenceDirectiveResolutionCache; };
         }
         compilerHost.getBuildInfo = function (fileName, configFilePath) { return getBuildInfo(state, fileName, toResolvedConfigFilePath(state, configFilePath), undefined); };
         var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog;
@@ -105469,7 +106486,7 @@ var ts;
             if (buildInfoTime && buildInfoTime < inputTime) {
                 var version_3 = void 0;
                 var currentVersion = void 0;
-                if (buildInfoProgram) {
+                if (buildInfoProgram === null || buildInfoProgram === void 0 ? void 0 : buildInfoProgram.fileInfos) {
                     if (!buildInfoVersionMap)
                         buildInfoVersionMap = ts.getBuildInfoFileVersionMap(buildInfoProgram, buildInfoPath, host);
                     version_3 = buildInfoVersionMap.get(toPath(state, inputFile));