typescript 5.0.0-dev.20221205 → 5.0.0-dev.20221207

package/lib/tsserverlibrary.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20221205`;
+      version = `${versionMajorMinor}.0-dev.20221207`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -2190,22 +2190,8 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
         function enableDebugInfo() {
           if (isDebugInfoEnabled)
             return;
-          let weakTypeTextMap;
-          let weakNodeTextMap;
-          function getWeakTypeTextMap() {
-            if (weakTypeTextMap === void 0) {
-              if (typeof WeakMap === "function")
-                weakTypeTextMap = /* @__PURE__ */ new WeakMap();
-            }
-            return weakTypeTextMap;
-          }
-          function getWeakNodeTextMap() {
-            if (weakNodeTextMap === void 0) {
-              if (typeof WeakMap === "function")
-                weakNodeTextMap = /* @__PURE__ */ new WeakMap();
-            }
-            return weakNodeTextMap;
-          }
+          const weakTypeTextMap = /* @__PURE__ */ new WeakMap();
+          const weakNodeTextMap = /* @__PURE__ */ new WeakMap();
           Object.defineProperties(objectAllocator.getSymbolConstructor().prototype, {
             __tsDebuggerDisplay: {
               value() {
@@ -2234,11 +2220,10 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
             } },
             __debugTypeToString: {
               value() {
-                const map2 = getWeakTypeTextMap();
-                let text = map2 == null ? void 0 : map2.get(this);
+                let text = weakTypeTextMap.get(this);
                 if (text === void 0) {
                   text = this.checker.typeToString(this);
-                  map2 == null ? void 0 : map2.set(this, text);
+                  weakTypeTextMap.set(this, text);
                 }
                 return text;
               }
@@ -2290,13 +2275,12 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
                   value(includeTrivia) {
                     if (nodeIsSynthesized(this))
                       return "";
-                    const map2 = getWeakNodeTextMap();
-                    let text = map2 == null ? void 0 : map2.get(this);
+                    let text = weakNodeTextMap.get(this);
                     if (text === void 0) {
                       const parseNode = getParseTreeNode(this);
                       const sourceFile = parseNode && getSourceFileOfNode(parseNode);
                       text = sourceFile ? getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
-                      map2 == null ? void 0 : map2.set(this, text);
+                      weakNodeTextMap.set(this, text);
                     }
                     return text;
                   }
@@ -4097,6 +4081,7 @@ ${lanes.join("\n")}
       FilePreprocessingDiagnosticsKind = /* @__PURE__ */ ((FilePreprocessingDiagnosticsKind2) => {
         FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["FilePreprocessingReferencedDiagnostic"] = 0] = "FilePreprocessingReferencedDiagnostic";
         FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["FilePreprocessingFileExplainingDiagnostic"] = 1] = "FilePreprocessingFileExplainingDiagnostic";
+        FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["ResolutionDiagnostics"] = 2] = "ResolutionDiagnostics";
         return FilePreprocessingDiagnosticsKind2;
       })(FilePreprocessingDiagnosticsKind || {});
       EmitOnly = /* @__PURE__ */ ((EmitOnly4) => {
@@ -12244,7 +12229,8 @@ ${lanes.join("\n")}
     return node.end - node.pos;
   }
   function getResolvedModule(sourceFile, moduleNameText, mode) {
-    return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode);
+    var _a2, _b;
+    return (_b = (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedModules) == null ? void 0 : _a2.get(moduleNameText, mode)) == null ? void 0 : _b.resolvedModule;
   }
   function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) {
     if (!sourceFile.resolvedModules) {
@@ -12259,14 +12245,14 @@ ${lanes.join("\n")}
     sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, mode, resolvedTypeReferenceDirective);
   }
   function getResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, mode) {
-    var _a2;
-    return (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _a2.get(typeReferenceDirectiveName, mode);
+    var _a2, _b;
+    return (_b = (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _a2.get(typeReferenceDirectiveName, mode)) == null ? void 0 : _b.resolvedTypeReferenceDirective;
   }
   function projectReferenceIsEqualTo(oldRef, newRef) {
     return oldRef.path === newRef.path && !oldRef.prepend === !newRef.prepend && !oldRef.circular === !newRef.circular;
   }
   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);
   }
   function packageIdIsEqual(a, b) {
     return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version;
@@ -12278,15 +12264,15 @@ ${lanes.join("\n")}
     return `${packageIdToPackageName(packageId)}@${packageId.version}`;
   }
   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;
   }
-  function hasChangesInResolutions(names, newSourceFile, newResolutions, oldResolutions, comparer) {
+  function hasChangesInResolutions(names, newSourceFile, newResolutions, oldResolutions, comparer, nameAndModeGetter) {
     Debug.assert(names.length === newResolutions.length);
     for (let i = 0; i < names.length; i++) {
       const newResolution = newResolutions[i];
       const entry = names[i];
-      const name = getResolutionName(entry);
-      const mode = getResolutionMode(entry, newSourceFile);
+      const name = nameAndModeGetter.getName(entry);
+      const mode = nameAndModeGetter.getMode(entry, newSourceFile);
       const oldResolution = oldResolutions && oldResolutions.get(name, mode);
       const changed = oldResolution ? !newResolution || !comparer(oldResolution, newResolution) : newResolution;
       if (changed) {
@@ -16635,13 +16621,14 @@ ${lanes.join("\n")}
         }
       },
       setSymlinksFromResolutions(files, typeReferenceDirectives) {
-        var _a2;
+        var _a2, _b;
         Debug.assert(!hasProcessedResolutions);
         hasProcessedResolutions = true;
         for (const file of files) {
-          (_a2 = file.resolvedModules) == null ? void 0 : _a2.forEach((resolution) => processResolution(this, resolution));
+          (_a2 = file.resolvedModules) == null ? void 0 : _a2.forEach((resolution) => processResolution(this, resolution.resolvedModule));
+          (_b = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _b.forEach((resolution) => processResolution(this, resolution.resolvedTypeReferenceDirective));
         }
-        typeReferenceDirectives == null ? void 0 : typeReferenceDirectives.forEach((resolution) => processResolution(this, resolution));
+        typeReferenceDirectives.forEach((resolution) => processResolution(this, resolution.resolvedTypeReferenceDirective));
       },
       hasProcessedResolutions: () => hasProcessedResolutions
     };
@@ -34981,17 +34968,29 @@ ${lanes.join("\n")}
   }
   function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
     if (resultFromCache) {
-      resultFromCache.failedLookupLocations.push(...failedLookupLocations);
-      resultFromCache.affectingLocations.push(...affectingLocations);
+      resultFromCache.failedLookupLocations = updateResolutionField(resultFromCache.failedLookupLocations, 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 ? void 0 : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport, packageId: resolved.packageId },
-      failedLookupLocations,
-      affectingLocations,
-      resolutionDiagnostics: diagnostics
+      failedLookupLocations: initializeResolutionField(failedLookupLocations),
+      affectingLocations: initializeResolutionField(affectingLocations),
+      resolutionDiagnostics: initializeResolutionField(diagnostics)
     };
   }
+  function initializeResolutionField(value) {
+    return value.length ? value : void 0;
+  }
+  function updateResolutionField(to, value) {
+    if (!(value == null ? void 0 : value.length))
+      return to;
+    if (!(to == null ? void 0 : to.length))
+      return value;
+    to.push(...value);
+    return to;
+  }
   function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
     if (!hasProperty(jsonContent, fieldName)) {
       if (state.traceEnabled) {
@@ -35124,8 +35123,10 @@ ${lanes.join("\n")}
       options = redirectedReference.commandLine.options;
     }
     const containingDirectory = containingFile ? getDirectoryPath(containingFile) : void 0;
-    const perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : void 0;
-    let result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, resolutionMode);
+    let result = containingDirectory ? cache == null ? void 0 : cache.getFromDirectoryCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference) : void 0;
+    if (!result && containingDirectory && !isExternalModuleNameRelative(typeReferenceDirectiveName)) {
+      result = cache == null ? void 0 : cache.getFromNonRelativeNameCache(typeReferenceDirectiveName, resolutionMode, containingDirectory, redirectedReference);
+    }
     if (result) {
       if (traceEnabled) {
         trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);
@@ -35195,8 +35196,18 @@ ${lanes.join("\n")}
         isExternalLibraryImport: pathContainsNodeModules(fileName)
       };
     }
-    result = { resolvedTypeReferenceDirective, failedLookupLocations, affectingLocations, resolutionDiagnostics: diagnostics };
-    perFolderCache == null ? void 0 : perFolderCache.set(typeReferenceDirectiveName, resolutionMode, result);
+    result = {
+      resolvedTypeReferenceDirective,
+      failedLookupLocations: initializeResolutionField(failedLookupLocations),
+      affectingLocations: initializeResolutionField(affectingLocations),
+      resolutionDiagnostics: initializeResolutionField(diagnostics)
+    };
+    if (containingDirectory) {
+      cache == null ? void 0 : cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(typeReferenceDirectiveName, resolutionMode, result);
+      if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
+        cache == null ? void 0 : cache.getOrCreateCacheForNonRelativeName(typeReferenceDirectiveName, resolutionMode, redirectedReference).set(containingDirectory, result);
+      }
+    }
     if (traceEnabled)
       traceResult(result);
     return result;
@@ -35326,23 +35337,27 @@ ${lanes.join("\n")}
     if (ownOptions)
       redirectsMap.set(ownOptions, ownMap);
     return {
+      getMapOfCacheRedirects,
       getOrCreateMapOfCacheRedirects,
       update,
       clear: clear2
     };
+    function getMapOfCacheRedirects(redirectedReference) {
+      return redirectedReference ? getOrCreateMap(redirectedReference.commandLine.options, false) : ownMap;
+    }
     function getOrCreateMapOfCacheRedirects(redirectedReference) {
-      return redirectedReference ? getOrCreateMap(redirectedReference.commandLine.options) : ownMap;
+      return redirectedReference ? getOrCreateMap(redirectedReference.commandLine.options, true) : ownMap;
     }
     function update(newOptions) {
       if (ownOptions !== newOptions) {
         if (ownOptions)
-          ownMap = getOrCreateMap(newOptions);
+          ownMap = getOrCreateMap(newOptions, true);
         else
           redirectsMap.set(newOptions, ownMap);
         ownOptions = newOptions;
       }
     }
-    function getOrCreateMap(redirectOptions) {
+    function getOrCreateMap(redirectOptions, create) {
       let result = redirectsMap.get(redirectOptions);
       if (result)
         return result;
@@ -35356,9 +35371,13 @@ ${lanes.join("\n")}
           else if (!redirectsKeyToMap.has(ownKey))
             redirectsKeyToMap.set(ownKey, ownMap);
         }
-        redirectsKeyToMap.set(key, result != null ? result : result = /* @__PURE__ */ new Map());
+        if (create)
+          result != null ? result : result = /* @__PURE__ */ new Map();
+        if (result)
+          redirectsKeyToMap.set(key, result);
       }
-      redirectsMap.set(redirectOptions, result);
+      if (result)
+        redirectsMap.set(redirectOptions, result);
       return result;
     }
     function clear2() {
@@ -35410,8 +35429,10 @@ ${lanes.join("\n")}
     }
     return result;
   }
-  function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap) {
+  function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options) {
+    const directoryToModuleNameMap = createCacheWithRedirects(options);
     return {
+      getFromDirectoryCache,
       getOrCreateCacheForDirectory,
       clear: clear2,
       update
@@ -35419,13 +35440,18 @@ ${lanes.join("\n")}
     function clear2() {
       directoryToModuleNameMap.clear();
     }
-    function update(options) {
-      directoryToModuleNameMap.update(options);
+    function update(options2) {
+      directoryToModuleNameMap.update(options2);
     }
     function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
       const path = toPath(directoryName, currentDirectory, getCanonicalFileName);
       return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, () => createModeAwareCache());
     }
+    function getFromDirectoryCache(name, mode, directoryName, redirectedReference) {
+      var _a2, _b;
+      const path = toPath(directoryName, currentDirectory, getCanonicalFileName);
+      return (_b = (_a2 = directoryToModuleNameMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a2.get(path)) == null ? void 0 : _b.get(name, mode);
+    }
   }
   function createModeAwareCacheKey(specifier, mode) {
     return mode === void 0 ? specifier : `${mode}|${specifier}`;
@@ -35465,48 +35491,41 @@ ${lanes.join("\n")}
       return result;
     }
   }
-  function getResolutionName(entry) {
-    return !isString(entry) ? isStringLiteralLike(entry) ? entry.text : toFileNameLowerCase(entry.fileName) : entry;
-  }
-  function getResolutionMode(entry, file) {
-    return isStringLiteralLike(entry) ? getModeForUsageLocation(file, entry) : entry.resolutionMode || file.impliedNodeFormat;
-  }
-  function zipToModeAwareCache(file, keys, values) {
+  function zipToModeAwareCache(file, keys, values, nameAndModeGetter) {
     Debug.assert(keys.length === values.length);
     const map2 = createModeAwareCache();
     for (let i = 0; i < keys.length; ++i) {
       const entry = keys[i];
-      map2.set(getResolutionName(entry), getResolutionMode(entry, file), values[i]);
+      map2.set(nameAndModeGetter.getName(entry), nameAndModeGetter.getMode(entry, file), values[i]);
     }
     return map2;
   }
-  function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options) {
-    const directoryToModuleNameMap = createCacheWithRedirects(options);
-    const perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap);
+  function getOriginalOrResolvedModuleFileName(result) {
+    return result.resolvedModule && (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
+  }
+  function getOriginalOrResolvedTypeReferenceFileName(result) {
+    return result.resolvedTypeReferenceDirective && (result.resolvedTypeReferenceDirective.originalPath || result.resolvedTypeReferenceDirective.resolvedFileName);
+  }
+  function createNonRelativeNameResolutionCache(currentDirectory, getCanonicalFileName, options, getResolvedFileName) {
     const moduleNameToDirectoryMap = createCacheWithRedirects(options);
-    const packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
     return {
-      ...packageJsonInfoCache,
-      ...perDirectoryResolutionCache,
-      getOrCreateCacheForModuleName,
+      getFromNonRelativeNameCache,
+      getOrCreateCacheForNonRelativeName,
       clear: clear2,
-      update,
-      getPackageJsonInfoCache: () => packageJsonInfoCache,
-      clearAllExceptPackageJsonInfoCache
+      update
     };
     function clear2() {
-      clearAllExceptPackageJsonInfoCache();
-      packageJsonInfoCache.clear();
-    }
-    function clearAllExceptPackageJsonInfoCache() {
-      perDirectoryResolutionCache.clear();
       moduleNameToDirectoryMap.clear();
     }
     function update(options2) {
-      directoryToModuleNameMap.update(options2);
       moduleNameToDirectoryMap.update(options2);
     }
-    function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) {
+    function getFromNonRelativeNameCache(nonRelativeModuleName, mode, directoryName, redirectedReference) {
+      var _a2, _b;
+      Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName));
+      return (_b = (_a2 = moduleNameToDirectoryMap.getMapOfCacheRedirects(redirectedReference)) == null ? void 0 : _a2.get(createModeAwareCacheKey(nonRelativeModuleName, mode))) == null ? void 0 : _b.get(directoryName);
+    }
+    function getOrCreateCacheForNonRelativeName(nonRelativeModuleName, mode, redirectedReference) {
       Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName));
       return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, createModeAwareCacheKey(nonRelativeModuleName, mode), createPerModuleNameCache);
     }
@@ -35522,7 +35541,7 @@ ${lanes.join("\n")}
           return;
         }
         directoryPathMap.set(path, result);
-        const resolvedFileName = result.resolvedModule && (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
+        const resolvedFileName = getResolvedFileName(result);
         const commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);
         let current = path;
         while (current !== commonPrefix) {
@@ -35556,14 +35575,22 @@ ${lanes.join("\n")}
       }
     }
   }
-  function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache) {
-    const directoryToModuleNameMap = createCacheWithRedirects(options);
-    const perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap);
-    packageJsonInfoCache || (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName));
+  function createModuleOrTypeReferenceResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, getResolvedFileName) {
+    const perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options);
+    const nonRelativeNameResolutionCache = createNonRelativeNameResolutionCache(
+      currentDirectory,
+      getCanonicalFileName,
+      options,
+      getResolvedFileName
+    );
+    packageJsonInfoCache != null ? packageJsonInfoCache : packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
     return {
       ...packageJsonInfoCache,
       ...perDirectoryResolutionCache,
+      ...nonRelativeNameResolutionCache,
       clear: clear2,
+      update,
+      getPackageJsonInfoCache: () => packageJsonInfoCache,
       clearAllExceptPackageJsonInfoCache
     };
     function clear2() {
@@ -35572,14 +35599,36 @@ ${lanes.join("\n")}
     }
     function clearAllExceptPackageJsonInfoCache() {
       perDirectoryResolutionCache.clear();
+      nonRelativeNameResolutionCache.clear();
+    }
+    function update(options2) {
+      perDirectoryResolutionCache.update(options2);
+      nonRelativeNameResolutionCache.update(options2);
     }
   }
+  function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options) {
+    const result = createModuleOrTypeReferenceResolutionCache(
+      currentDirectory,
+      getCanonicalFileName,
+      options,
+      void 0,
+      getOriginalOrResolvedModuleFileName
+    );
+    result.getOrCreateCacheForModuleName = (nonRelativeName, mode, redirectedReference) => result.getOrCreateCacheForNonRelativeName(nonRelativeName, mode, redirectedReference);
+    return result;
+  }
+  function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache) {
+    return createModuleOrTypeReferenceResolutionCache(
+      currentDirectory,
+      getCanonicalFileName,
+      options,
+      packageJsonInfoCache,
+      getOriginalOrResolvedTypeReferenceFileName
+    );
+  }
   function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
     const containingDirectory = getDirectoryPath(containingFile);
-    const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
-    if (!perFolderCache)
-      return void 0;
-    return perFolderCache.get(moduleName, mode);
+    return cache.getFromDirectoryCache(moduleName, mode, containingDirectory, void 0);
   }
   function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
     const traceEnabled = isTraceEnabled(compilerOptions, host);
@@ -35593,8 +35642,7 @@ ${lanes.join("\n")}
       }
     }
     const containingDirectory = getDirectoryPath(containingFile);
-    const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
-    let result = perFolderCache && perFolderCache.get(moduleName, resolutionMode);
+    let result = cache == null ? void 0 : cache.getFromDirectoryCache(moduleName, resolutionMode, containingDirectory, redirectedReference);
     if (result) {
       if (traceEnabled) {
         trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -35644,11 +35692,9 @@ ${lanes.join("\n")}
       if (result && result.resolvedModule)
         perfLogger.logInfoEvent(`Module "${moduleName}" resolved to "${result.resolvedModule.resolvedFileName}"`);
       perfLogger.logStopResolveModule(result && result.resolvedModule ? "" + result.resolvedModule.resolvedFileName : "null");
-      if (perFolderCache) {
-        perFolderCache.set(moduleName, resolutionMode, result);
-        if (!isExternalModuleNameRelative(moduleName)) {
-          cache.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
-        }
+      cache == null ? void 0 : cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference).set(moduleName, resolutionMode, result);
+      if (!isExternalModuleNameRelative(moduleName)) {
+        cache == null ? void 0 : cache.getOrCreateCacheForNonRelativeName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
       }
     }
     if (traceEnabled) {
@@ -35765,7 +35811,7 @@ ${lanes.join("\n")}
   function resolveJSModule(moduleName, initialDir, host) {
     const { resolvedModule, failedLookupLocations } = tryResolveJSModuleWorker(moduleName, initialDir, host);
     if (!resolvedModule) {
-      throw new Error(`Could not resolve JS module '${moduleName}' starting at '${initialDir}'. Looked in: ${failedLookupLocations.join(", ")}`);
+      throw new Error(`Could not resolve JS module '${moduleName}' starting at '${initialDir}'. Looked in: ${failedLookupLocations == null ? void 0 : failedLookupLocations.join(", ")}`);
     }
     return resolvedModule.resolvedFileName;
   }
@@ -36627,7 +36673,7 @@ ${lanes.join("\n")}
     return loadModuleFromNearestNodeModulesDirectoryWorker(4 /* Declaration */, moduleName, directory, state, true, void 0, void 0);
   }
   function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
-    const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? void 0 : state.features & 32 /* EsmMode */ ? 99 /* ESNext */ : 1 /* CommonJS */, redirectedReference);
+    const mode = state.features === 0 ? void 0 : state.features & 32 /* EsmMode */ ? 99 /* ESNext */ : 1 /* CommonJS */;
     const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
     const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
     if (priorityExtensions) {
@@ -36641,7 +36687,7 @@ ${lanes.join("\n")}
     function lookup(extensions2) {
       return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => {
         if (getBaseFileName(ancestorDirectory) !== "node_modules") {
-          const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
+          const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, ancestorDirectory, redirectedReference, state);
           if (resolutionFromCache) {
             return resolutionFromCache;
           }
@@ -36786,8 +36832,8 @@ ${lanes.join("\n")}
   function unmangleScopedPackageName(typesPackageName) {
     return stringContains(typesPackageName, mangledScopedPackageSeparator) ? "@" + typesPackageName.replace(mangledScopedPackageSeparator, directorySeparator) : typesPackageName;
   }
-  function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) {
-    const result = cache && cache.get(containingDirectory);
+  function tryFindNonRelativeModuleNameInCache(cache, moduleName, mode, containingDirectory, redirectedReference, state) {
+    const result = cache && cache.getFromNonRelativeNameCache(moduleName, mode, containingDirectory, redirectedReference);
     if (result) {
       if (state.traceEnabled) {
         trace(state.host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
@@ -36830,9 +36876,8 @@ ${lanes.join("\n")}
         return { value: resolvedUsingSettings };
       }
       if (!isExternalModuleNameRelative(moduleName)) {
-        const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, void 0, redirectedReference);
         const resolved2 = forEachAncestorDirectory(containingDirectory, (directory) => {
-          const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, directory, state);
+          const resolutionFromCache = tryFindNonRelativeModuleNameInCache(cache, moduleName, void 0, directory, redirectedReference, state);
           if (resolutionFromCache) {
             return resolutionFromCache;
           }
@@ -40244,7 +40289,7 @@ ${lanes.join("\n")}
     if (!shortest) {
       return void 0;
     }
-    return getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */ ? removeExtensionAndIndexPostFix(shortest, ending, compilerOptions) : removeFileExtension(shortest);
+    return getEmitModuleResolutionKind(compilerOptions) === 1 /* Classic */ ? removeFileExtension(shortest) : removeExtensionAndIndexPostFix(shortest, ending, compilerOptions);
   }
   function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileName, sourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
     if (!host.fileExists || !host.readFile) {
@@ -40480,9 +40525,9 @@ ${lanes.join("\n")}
       host.getSourceFiles().forEach((sf) => {
         if (!sf.resolvedModules)
           return;
-        sf.resolvedModules.forEach((r) => {
-          if (r && r.packageId)
-            map2.set(r.packageId.name, r.extension === ".d.ts" /* Dts */ || !!map2.get(r.packageId.name));
+        sf.resolvedModules.forEach(({ resolvedModule }) => {
+          if (resolvedModule == null ? void 0 : resolvedModule.packageId)
+            map2.set(resolvedModule.packageId.name, resolvedModule.extension === ".d.ts" /* Dts */ || !!map2.get(resolvedModule.packageId.name));
         });
       });
       return map2;
@@ -41286,6 +41331,12 @@ ${lanes.join("\n")}
       return diagnostic;
     }
     function isDeprecatedSymbol(symbol) {
+      if (length(symbol.declarations) > 1) {
+        const parentSymbol = getParentOfSymbol(symbol);
+        if (parentSymbol && parentSymbol.flags & 64 /* Interface */) {
+          return some(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
+        }
+      }
       return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
     }
     function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
@@ -50979,7 +51030,7 @@ ${lanes.join("\n")}
             const resolved = resolveAlias(aliasSymbol2);
             if (resolved && resolved.flags & 524288 /* TypeAlias */) {
               newAliasSymbol = resolved;
-              aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node);
+              aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node) || (typeParameters ? [] : void 0);
             }
           }
         }
@@ -59795,13 +59846,13 @@ ${lanes.join("\n")}
         }
         const target = getReferenceCandidate(typeOfExpr.expression);
         if (!isMatchingReference(reference, target)) {
-          const propertyAccess = getDiscriminantPropertyAccess(typeOfExpr.expression, type);
+          if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
+            type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+          }
+          const propertyAccess = getDiscriminantPropertyAccess(target, type);
           if (propertyAccess) {
             return narrowTypeByDiscriminant(type, propertyAccess, (t) => narrowTypeByLiteralExpression(t, literal, assumeTrue));
           }
-          if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
-            return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
-          }
           return type;
         }
         return narrowTypeByLiteralExpression(type, literal, assumeTrue);
@@ -70284,7 +70335,6 @@ ${lanes.join("\n")}
       let firstDefaultClause;
       let hasDuplicateDefaultClause = false;
       const expressionType = checkExpression(node.expression);
-      const expressionIsLiteral = isLiteralType(expressionType);
       forEach(node.caseBlock.clauses, (clause) => {
         if (clause.kind === 293 /* DefaultClause */ && !hasDuplicateDefaultClause) {
           if (firstDefaultClause === void 0) {
@@ -70303,15 +70353,9 @@ ${lanes.join("\n")}
         }
         function createLazyCaseClauseDiagnostics(clause2) {
           return () => {
-            let caseType = checkExpression(clause2.expression);
-            const caseIsLiteral = isLiteralType(caseType);
-            let comparedExpressionType = expressionType;
-            if (!caseIsLiteral || !expressionIsLiteral) {
-              caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType;
-              comparedExpressionType = getBaseTypeOfLiteralType(expressionType);
-            }
-            if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) {
-              checkTypeComparableTo(caseType, comparedExpressionType, clause2.expression, void 0);
+            const caseType = checkExpression(clause2.expression);
+            if (!isTypeEqualityComparableTo(expressionType, caseType)) {
+              checkTypeComparableTo(caseType, expressionType, clause2.expression, void 0);
             }
           };
         }
@@ -73412,11 +73456,11 @@ ${lanes.join("\n")}
       let fileToDirective;
       if (resolvedTypeReferenceDirectives) {
         fileToDirective = /* @__PURE__ */ new Map();
-        resolvedTypeReferenceDirectives.forEach((resolvedDirective, key, mode) => {
-          if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
+        resolvedTypeReferenceDirectives.forEach(({ resolvedTypeReferenceDirective }, key, mode) => {
+          if (!(resolvedTypeReferenceDirective == null ? void 0 : resolvedTypeReferenceDirective.resolvedFileName)) {
             return;
           }
-          const file = host.getSourceFile(resolvedDirective.resolvedFileName);
+          const file = host.getSourceFile(resolvedTypeReferenceDirective.resolvedFileName);
           if (file) {
             addReferencedFilesToTypeDirective(file, key, mode);
           }
@@ -100199,25 +100243,6 @@ ${lanes.join("\n")}
     }
     return result;
   }
-  function loadWithTypeDirectiveCache(names, containingFile, redirectedReference, containingFileMode, loader) {
-    if (names.length === 0) {
-      return [];
-    }
-    const resolutions = [];
-    const cache = createModeAwareCache();
-    for (const name of names) {
-      let result;
-      const mode = getModeForFileReference(name, containingFileMode);
-      const strName = getResolutionName(name);
-      if (cache.has(strName, mode)) {
-        result = cache.get(strName, mode);
-      } else {
-        cache.set(strName, mode, result = loader(strName, containingFile, redirectedReference, mode));
-      }
-      resolutions.push(result);
-    }
-    return resolutions;
-  }
   function getModeForFileReference(ref, containingFileMode) {
     return (isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode;
   }
@@ -100283,22 +100308,53 @@ ${lanes.join("\n")}
     }
     return elem.value.text === "import" ? 99 /* ESNext */ : 1 /* CommonJS */;
   }
-  function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, resolutionInfo, loader) {
-    if (names.length === 0) {
-      return [];
-    }
+  function getModuleResolutionName(literal) {
+    return literal.text;
+  }
+  function createModuleResolutionLoader(containingFile, redirectedReference, options, host, cache) {
+    return {
+      nameAndMode: moduleResolutionNameAndModeGetter,
+      resolve: (moduleName, resoluionMode) => resolveModuleName(
+        moduleName,
+        containingFile,
+        options,
+        host,
+        cache,
+        redirectedReference,
+        resoluionMode
+      )
+    };
+  }
+  function getTypeReferenceResolutionName(entry) {
+    return !isString(entry) ? toFileNameLowerCase(entry.fileName) : entry;
+  }
+  function createTypeReferenceResolutionLoader(containingFile, redirectedReference, options, host, cache) {
+    return {
+      nameAndMode: typeReferenceResolutionNameAndModeGetter,
+      resolve: (typeRef, resoluionMode) => resolveTypeReferenceDirective(
+        typeRef,
+        containingFile,
+        options,
+        host,
+        redirectedReference,
+        cache,
+        resoluionMode
+      )
+    };
+  }
+  function loadWithModeAwareCache(entries, containingFile, redirectedReference, options, containingSourceFile, host, resolutionCache, createLoader) {
+    if (entries.length === 0)
+      return emptyArray;
     const resolutions = [];
-    const cache = createModeAwareCache();
-    let i = 0;
-    for (const entry of resolutionInfo ? resolutionInfo.names : names) {
-      let result;
-      const mode = !isString(entry) ? getModeForUsageLocation(containingFile, entry) : getModeForResolutionAtIndex(containingFile, i);
-      i++;
-      const name = isString(entry) ? entry : entry.text;
-      if (cache.has(name, mode)) {
-        result = cache.get(name, mode);
-      } else {
-        cache.set(name, mode, result = loader(name, mode, containingFileName, redirectedReference));
+    const cache = /* @__PURE__ */ new Map();
+    const loader = createLoader(containingFile, redirectedReference, options, host, resolutionCache);
+    for (const entry of entries) {
+      const name = loader.nameAndMode.getName(entry);
+      const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
+      const key = createModeAwareCacheKey(name, mode);
+      let result = cache.get(key);
+      if (!result) {
+        cache.set(key, result = loader.resolve(name, mode));
       }
       resolutions.push(result);
     }
@@ -100343,14 +100399,14 @@ ${lanes.join("\n")}
     return location.pos !== void 0;
   }
   function getReferencedFileLocation(getSourceFileByPath, ref) {
-    var _a2, _b, _c, _d;
+    var _a2, _b, _c, _d, _e, _f;
     const file = Debug.checkDefined(getSourceFileByPath(ref.file));
     const { kind, index } = ref;
     let pos, end, packageId, resolutionMode;
     switch (kind) {
       case 3 /* Import */:
         const importLiteral = getModuleNameStringLiteralAt(file, index);
-        packageId = (_b = (_a2 = file.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) == null ? void 0 : _b.packageId;
+        packageId = (_c = (_b = (_a2 = file.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) == null ? void 0 : _b.resolvedModule) == null ? void 0 : _c.packageId;
         if (importLiteral.pos === -1)
           return { file, packageId, text: importLiteral.text };
         pos = skipTrivia(file.text, importLiteral.pos);
@@ -100361,7 +100417,7 @@ ${lanes.join("\n")}
         break;
       case 5 /* TypeReferenceDirective */:
         ({ pos, end, resolutionMode } = file.typeReferenceDirectives[index]);
-        packageId = (_d = (_c = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _c.get(toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) == null ? void 0 : _d.packageId;
+        packageId = (_f = (_e = (_d = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _d.get(toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) == null ? void 0 : _e.resolvedTypeReferenceDirective) == null ? void 0 : _f.packageId;
         break;
       case 7 /* LibReferenceDirective */:
         ({ pos, end } = file.libReferenceDirectives[index]);
@@ -100457,7 +100513,7 @@ ${lanes.join("\n")}
     };
   }
   function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
-    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
     const { rootNames, options, configFileParsingDiagnostics, projectReferences } = createProgramOptions;
     let { oldProgram } = createProgramOptions;
@@ -100474,6 +100530,8 @@ ${lanes.join("\n")}
     const cachedDeclarationDiagnosticsForFile = {};
     let resolvedTypeReferenceDirectives = createModeAwareCache();
     let fileProcessingDiagnostics;
+    let automaticTypeDirectiveNames;
+    let automaticTypeDirectiveResolutions;
     const maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
     let currentNodeModulesDepth = 0;
     const modulesWithElidedImports = /* @__PURE__ */ new Map();
@@ -100492,50 +100550,59 @@ ${lanes.join("\n")}
     const hasEmitBlockingDiagnostics = /* @__PURE__ */ new Map();
     let _compilerOptionsObjectLiteralSyntax;
     let moduleResolutionCache;
-    let typeReferenceDirectiveResolutionCache;
     let actualResolveModuleNamesWorker;
     const hasInvalidatedResolutions = host.hasInvalidatedResolutions || returnFalse;
-    if (host.resolveModuleNames) {
-      actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => {
-        var _a3;
-        return host.resolveModuleNames(
-          moduleNames.map((literal) => literal.text),
-          containingFileName,
-          (_a3 = resolutionInfo == null ? void 0 : resolutionInfo.reusedNames) == null ? void 0 : _a3.map((literal) => literal.text),
-          redirectedReference,
-          options,
-          containingFile,
-          resolutionInfo
-        ).map((resolved) => {
-          if (!resolved || resolved.extension !== void 0) {
-            return resolved;
-          }
-          const withExtension = clone(resolved);
-          withExtension.extension = extensionFromPath(resolved.resolvedFileName);
-          return withExtension;
-        });
-      };
+    if (host.resolveModuleNameLiterals) {
+      actualResolveModuleNamesWorker = host.resolveModuleNameLiterals.bind(host);
       moduleResolutionCache = (_b = host.getModuleResolutionCache) == null ? void 0 : _b.call(host);
+    } else if (host.resolveModuleNames) {
+      actualResolveModuleNamesWorker = (moduleNames, containingFile, redirectedReference, options2, containingSourceFile, reusedNames) => host.resolveModuleNames(
+        moduleNames.map(getModuleResolutionName),
+        containingFile,
+        reusedNames == null ? void 0 : reusedNames.map(getModuleResolutionName),
+        redirectedReference,
+        options2,
+        containingSourceFile
+      ).map(
+        (resolved) => resolved ? resolved.extension !== void 0 ? { resolvedModule: resolved } : { resolvedModule: { ...resolved, extension: extensionFromPath(resolved.resolvedFileName) } } : emptyResolution
+      );
+      moduleResolutionCache = (_c = host.getModuleResolutionCache) == null ? void 0 : _c.call(host);
     } else {
       moduleResolutionCache = createModuleResolutionCache(currentDirectory, getCanonicalFileName, options);
-      const loader = (moduleName, resolverMode, containingFileName, redirectedReference) => resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
-      actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => loadWithModeAwareCache(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo, loader);
+      actualResolveModuleNamesWorker = (moduleNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        moduleNames,
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
+        moduleResolutionCache,
+        createModuleResolutionLoader
+      );
     }
     let actualResolveTypeReferenceDirectiveNamesWorker;
-    if (host.resolveTypeReferenceDirectives) {
-      actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) => host.resolveTypeReferenceDirectives(Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode, resolutionInfo);
+    if (host.resolveTypeReferenceDirectiveReferences) {
+      actualResolveTypeReferenceDirectiveNamesWorker = host.resolveTypeReferenceDirectiveReferences.bind(host);
+    } else if (host.resolveTypeReferenceDirectives) {
+      actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, options2, containingSourceFile) => host.resolveTypeReferenceDirectives(
+        typeDirectiveNames.map(getTypeReferenceResolutionName),
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat
+      ).map((resolvedTypeReferenceDirective) => ({ resolvedTypeReferenceDirective }));
     } else {
-      typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
-      const loader = (typesRef, containingFile, redirectedReference, resolutionMode) => resolveTypeReferenceDirective(
-        typesRef,
+      const typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
+      actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        typeDirectiveNames,
         containingFile,
-        options,
-        host,
         redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
         typeReferenceDirectiveResolutionCache,
-        resolutionMode
-      ).resolvedTypeReferenceDirective;
-      actualResolveTypeReferenceDirectiveNamesWorker = (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
+        createTypeReferenceResolutionLoader
+      );
     }
     const packageIdToSourceFile = /* @__PURE__ */ new Map();
     let sourceFileToPackageName = /* @__PURE__ */ new Map();
@@ -100548,7 +100615,7 @@ ${lanes.join("\n")}
     let projectReferenceRedirects;
     let mapFromFileToProjectReferenceRedirects;
     let mapFromToProjectReferenceRedirectSource;
-    const useSourceOfProjectReferenceRedirect = !!((_c = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _c.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
+    const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
     const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
       compilerHost: host,
       getSymlinkCache,
@@ -100559,13 +100626,13 @@ ${lanes.join("\n")}
       forEachResolvedProjectReference: forEachResolvedProjectReference2
     });
     const readFile = host.readFile.bind(host);
-    (_d = tracing) == null ? void 0 : _d.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
+    (_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
     const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
-    (_e = tracing) == null ? void 0 : _e.pop();
+    (_f = tracing) == null ? void 0 : _f.pop();
     let structureIsReused;
-    (_f = tracing) == null ? void 0 : _f.push(tracing.Phase.Program, "tryReuseStructureFromOldProgram", {});
+    (_g = tracing) == null ? void 0 : _g.push(tracing.Phase.Program, "tryReuseStructureFromOldProgram", {});
     structureIsReused = tryReuseStructureFromOldProgram();
-    (_g = tracing) == null ? void 0 : _g.pop();
+    (_h = tracing) == null ? void 0 : _h.pop();
     if (structureIsReused !== 2 /* Completely */) {
       processingDefaultLibFiles = [];
       processingOtherFiles = [];
@@ -100599,19 +100666,30 @@ ${lanes.join("\n")}
           });
         }
       }
-      (_h = tracing) == null ? void 0 : _h.push(tracing.Phase.Program, "processRootFiles", { count: rootNames.length });
+      (_i = tracing) == null ? void 0 : _i.push(tracing.Phase.Program, "processRootFiles", { count: rootNames.length });
       forEach(rootNames, (name, index) => processRootFile(name, false, false, { kind: 0 /* RootFile */, index }));
-      (_i = tracing) == null ? void 0 : _i.pop();
-      const typeReferences = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
-      if (typeReferences.length) {
-        (_j = tracing) == null ? void 0 : _j.push(tracing.Phase.Program, "processTypeReferences", { count: typeReferences.length });
+      (_j = tracing) == null ? void 0 : _j.pop();
+      automaticTypeDirectiveNames != null ? automaticTypeDirectiveNames : automaticTypeDirectiveNames = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
+      automaticTypeDirectiveResolutions = createModeAwareCache();
+      if (automaticTypeDirectiveNames.length) {
+        (_k = tracing) == null ? void 0 : _k.push(tracing.Phase.Program, "processTypeReferences", { count: automaticTypeDirectiveNames.length });
         const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
         const containingFilename = combinePaths(containingDirectory, inferredTypesContainingFile);
-        const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeReferences, containingFilename);
-        for (let i = 0; i < typeReferences.length; i++) {
-          processTypeReferenceDirective(typeReferences[i], void 0, resolutions[i], { kind: 8 /* AutomaticTypeDirectiveFile */, typeReference: typeReferences[i], packageId: (_k = resolutions[i]) == null ? void 0 : _k.packageId });
+        const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(automaticTypeDirectiveNames, containingFilename);
+        for (let i = 0; i < automaticTypeDirectiveNames.length; i++) {
+          automaticTypeDirectiveResolutions.set(automaticTypeDirectiveNames[i], void 0, resolutions[i]);
+          processTypeReferenceDirective(
+            automaticTypeDirectiveNames[i],
+            void 0,
+            resolutions[i],
+            {
+              kind: 8 /* AutomaticTypeDirectiveFile */,
+              typeReference: automaticTypeDirectiveNames[i],
+              packageId: (_m = (_l = resolutions[i]) == null ? void 0 : _l.resolvedTypeReferenceDirective) == null ? void 0 : _m.packageId
+            }
+          );
         }
-        (_l = tracing) == null ? void 0 : _l.pop();
+        (_n = tracing) == null ? void 0 : _n.pop();
       }
       if (rootNames.length && !skipDefaultLib) {
         const defaultLibraryFileName = getDefaultLibraryFileName();
@@ -100658,7 +100736,6 @@ ${lanes.join("\n")}
         }
       );
     }
-    typeReferenceDirectiveResolutionCache = void 0;
     oldProgram = void 0;
     const program = {
       getRootFileNames: () => rootNames,
@@ -100691,6 +100768,8 @@ ${lanes.join("\n")}
       getRelationCacheSizes: () => getTypeChecker().getRelationCacheSizes(),
       getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
       getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,
+      getAutomaticTypeDirectiveNames: () => automaticTypeDirectiveNames,
+      getAutomaticTypeDirectiveResolutions: () => automaticTypeDirectiveResolutions,
       isSourceFileFromExternalLibrary,
       isSourceFileDefaultLibrary,
       getSourceFileFromReference,
@@ -100700,7 +100779,6 @@ ${lanes.join("\n")}
       usesUriStyleNodeCoreModules,
       isEmittedFile,
       getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics2,
-      getResolvedModuleWithFailedLookupLocationsFromCache,
       getProjectReferences,
       getResolvedProjectReferences,
       getProjectReferenceRedirect,
@@ -100713,7 +100791,7 @@ ${lanes.join("\n")}
       readFile,
       directoryExists,
       getSymlinkCache,
-      realpath: (_m = host.realpath) == null ? void 0 : _m.bind(host),
+      realpath: (_o = host.realpath) == null ? void 0 : _o.bind(host),
       useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
       getFileIncludeReasons: () => fileReasons,
       structureIsReused,
@@ -100727,6 +100805,8 @@ ${lanes.join("\n")}
         case 0 /* FilePreprocessingReferencedDiagnostic */:
           const { file, pos, end } = getReferencedFileLocation(getSourceFileByPath, diagnostic.reason);
           return programDiagnostics.add(createFileDiagnostic(file, Debug.checkDefined(pos), Debug.checkDefined(end) - pos, diagnostic.diagnostic, ...diagnostic.args || emptyArray));
+        case 2 /* ResolutionDiagnostics */:
+          return diagnostic.diagnostics.forEach((d) => programDiagnostics.add(d));
         default:
           Debug.assertNever(diagnostic);
       }
@@ -100734,32 +100814,30 @@ ${lanes.join("\n")}
     verifyCompilerOptions();
     mark("afterProgram");
     measure("Program", "beforeProgram", "afterProgram");
-    (_n = tracing) == null ? void 0 : _n.pop();
+    (_p = tracing) == null ? void 0 : _p.pop();
     return program;
-    function addResolutionDiagnostics(list) {
-      if (!list)
+    function addResolutionDiagnostics(resolution) {
+      var _a3;
+      if (!((_a3 = resolution.resolutionDiagnostics) == null ? void 0 : _a3.length))
         return;
-      for (const elem of list) {
-        programDiagnostics.add(elem);
-      }
+      (fileProcessingDiagnostics != null ? fileProcessingDiagnostics : fileProcessingDiagnostics = []).push({
+        kind: 2 /* ResolutionDiagnostics */,
+        diagnostics: resolution.resolutionDiagnostics
+      });
     }
-    function pullDiagnosticsFromCache(names, containingFile) {
-      var _a3;
-      if (!moduleResolutionCache)
+    function addResolutionDiagnosticsFromResolutionOrCache(containingFile, name, resolution, mode) {
+      if (host.resolveModuleNameLiterals || !host.resolveModuleNames)
+        return addResolutionDiagnostics(resolution);
+      if (!moduleResolutionCache || isExternalModuleNameRelative(name))
         return;
       const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
       const containingDir = getDirectoryPath(containingFileName);
       const redirectedReference = getRedirectReferenceForResolution(containingFile);
-      for (const n of names) {
-        const mode = getResolutionMode(n, containingFile);
-        const name = getResolutionName(n);
-        if (isExternalModuleNameRelative(name))
-          continue;
-        const diags = (_a3 = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) == null ? void 0 : _a3.resolutionDiagnostics;
-        addResolutionDiagnostics(diags);
-      }
+      const fromCache = moduleResolutionCache.getFromNonRelativeNameCache(name, mode, containingDir, redirectedReference);
+      if (fromCache)
+        addResolutionDiagnostics(fromCache);
     }
-    function resolveModuleNamesWorker(moduleNames, containingFile, resolutionInfo) {
+    function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
       var _a3, _b2;
       if (!moduleNames.length)
         return emptyArray;
@@ -100767,23 +100845,22 @@ ${lanes.join("\n")}
       const redirectedReference = getRedirectReferenceForResolution(containingFile);
       (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveModuleNamesWorker", { containingFileName });
       mark("beforeResolveModule");
-      const result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo);
+      const result = actualResolveModuleNamesWorker(moduleNames, containingFileName, redirectedReference, options, containingFile, reusedNames);
       mark("afterResolveModule");
       measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
       (_b2 = tracing) == null ? void 0 : _b2.pop();
-      pullDiagnosticsFromCache(moduleNames, containingFile);
       return result;
     }
-    function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, resolutionInfo) {
+    function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, reusedNames) {
       var _a3, _b2;
       if (!typeDirectiveNames.length)
         return [];
+      const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
       const containingFileName = !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
-      const redirectedReference = !isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : void 0;
-      const containingFileMode = !isString(containingFile) ? containingFile.impliedNodeFormat : void 0;
+      const redirectedReference = containingSourceFile && getRedirectReferenceForResolution(containingSourceFile);
       (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
       mark("beforeResolveTypeReference");
-      const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode, resolutionInfo);
+      const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, options, containingSourceFile, reusedNames);
       mark("afterResolveTypeReference");
       measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
       (_b2 = tracing) == null ? void 0 : _b2.pop();
@@ -100829,9 +100906,6 @@ ${lanes.join("\n")}
       }
       return libs.length + 2;
     }
-    function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) {
-      return moduleResolutionCache && resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode);
-    }
     function toPath3(fileName) {
       return toPath(fileName, currentDirectory, getCanonicalFileName);
     }
@@ -100860,6 +100934,7 @@ ${lanes.join("\n")}
       return classifiableNames;
     }
     function resolveModuleNamesReusingOldState(moduleNames, file) {
+      var _a3;
       if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
         return resolveModuleNamesWorker(moduleNames, file, void 0);
       }
@@ -100875,24 +100950,24 @@ ${lanes.join("\n")}
       let unknownModuleNames;
       let result;
       let reusedNames;
-      const predictedToResolveToAmbientModuleMarker = {};
+      const predictedToResolveToAmbientModuleMarker = emptyResolution;
       for (let i = 0; i < moduleNames.length; i++) {
         const moduleName = moduleNames[i];
         if (file === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path)) {
           const mode = getModeForUsageLocation(file, moduleName);
-          const oldResolvedModule = getResolvedModule(oldSourceFile, moduleName.text, mode);
-          if (oldResolvedModule) {
+          const oldResolution = (_a3 = oldSourceFile.resolvedModules) == null ? void 0 : _a3.get(moduleName.text, mode);
+          if (oldResolution == null ? void 0 : oldResolution.resolvedModule) {
             if (isTraceEnabled(options, host)) {
               trace(
                 host,
-                oldResolvedModule.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
+                oldResolution.resolvedModule.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
                 moduleName.text,
                 getNormalizedAbsolutePath(file.originalFileName, currentDirectory),
-                oldResolvedModule.resolvedFileName,
-                oldResolvedModule.packageId && packageIdToString(oldResolvedModule.packageId)
+                oldResolution.resolvedModule.resolvedFileName,
+                oldResolution.resolvedModule.packageId && packageIdToString(oldResolution.resolvedModule.packageId)
               );
             }
-            (result != null ? result : result = new Array(moduleNames.length))[i] = oldResolvedModule;
+            (result != null ? result : result = new Array(moduleNames.length))[i] = oldResolution;
             (reusedNames != null ? reusedNames : reusedNames = []).push(moduleName);
             continue;
           }
@@ -100912,18 +100987,14 @@ ${lanes.join("\n")}
           (unknownModuleNames != null ? unknownModuleNames : unknownModuleNames = []).push(moduleName);
         }
       }
-      const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, { names: unknownModuleNames, reusedNames }) : emptyArray;
+      const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames) : emptyArray;
       if (!result) {
         Debug.assert(resolutions.length === moduleNames.length);
         return resolutions;
       }
       let j = 0;
       for (let i = 0; i < result.length; i++) {
-        if (result[i]) {
-          if (result[i] === predictedToResolveToAmbientModuleMarker) {
-            result[i] = void 0;
-          }
-        } else {
+        if (!result[i]) {
           result[i] = resolutions[j];
           j++;
         }
@@ -100947,6 +101018,7 @@ ${lanes.join("\n")}
       }
     }
     function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
+      var _a3;
       if (structureIsReused === 0 /* Not */) {
         return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, void 0);
       }
@@ -100955,7 +101027,7 @@ ${lanes.join("\n")}
         if (oldSourceFile !== containingFile && containingFile.resolvedTypeReferenceDirectiveNames) {
           const result2 = [];
           for (const typeDirectiveName of typeDirectiveNames) {
-            const resolvedTypeReferenceDirective = containingFile.resolvedTypeReferenceDirectiveNames.get(getResolutionName(typeDirectiveName), typeDirectiveName.resolutionMode || containingFile.impliedNodeFormat);
+            const resolvedTypeReferenceDirective = containingFile.resolvedTypeReferenceDirectiveNames.get(getTypeReferenceResolutionName(typeDirectiveName), getModeForFileReference(typeDirectiveName, containingFile.impliedNodeFormat));
             result2.push(resolvedTypeReferenceDirective);
           }
           return result2;
@@ -100969,21 +101041,21 @@ ${lanes.join("\n")}
       for (let i = 0; i < typeDirectiveNames.length; i++) {
         const entry = typeDirectiveNames[i];
         if (canReuseResolutions) {
-          const typeDirectiveName = getResolutionName(entry);
+          const typeDirectiveName = getTypeReferenceResolutionName(entry);
           const mode = getModeForFileReference(entry, containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat);
-          const oldResolvedTypeReferenceDirective = getResolvedTypeReferenceDirective(oldSourceFile, typeDirectiveName, mode);
-          if (oldResolvedTypeReferenceDirective) {
+          const oldResolution = (_a3 = !isString(containingFile) ? oldSourceFile == null ? void 0 : oldSourceFile.resolvedTypeReferenceDirectiveNames : oldProgram == null ? void 0 : oldProgram.getAutomaticTypeDirectiveResolutions()) == null ? void 0 : _a3.get(typeDirectiveName, mode);
+          if (oldResolution == null ? void 0 : oldResolution.resolvedTypeReferenceDirective) {
             if (isTraceEnabled(options, host)) {
               trace(
                 host,
-                oldResolvedTypeReferenceDirective.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
+                oldResolution.resolvedTypeReferenceDirective.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
                 typeDirectiveName,
                 !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile,
-                oldResolvedTypeReferenceDirective.resolvedFileName,
-                oldResolvedTypeReferenceDirective.packageId && packageIdToString(oldResolvedTypeReferenceDirective.packageId)
+                oldResolution.resolvedTypeReferenceDirective.resolvedFileName,
+                oldResolution.resolvedTypeReferenceDirective.packageId && packageIdToString(oldResolution.resolvedTypeReferenceDirective.packageId)
               );
             }
-            (result != null ? result : result = new Array(typeDirectiveNames.length))[i] = oldResolvedTypeReferenceDirective;
+            (result != null ? result : result = new Array(typeDirectiveNames.length))[i] = oldResolution;
             (reusedNames != null ? reusedNames : reusedNames = []).push(entry);
             continue;
           }
@@ -100995,7 +101067,7 @@ ${lanes.join("\n")}
       const resolutions = resolveTypeReferenceDirectiveNamesWorker(
         unknownTypeReferenceDirectiveNames,
         containingFile,
-        { names: unknownTypeReferenceDirectiveNames, reusedNames }
+        reusedNames
       );
       if (!result) {
         Debug.assert(resolutions.length === typeDirectiveNames.length);
@@ -101031,7 +101103,7 @@ ${lanes.join("\n")}
       );
     }
     function tryReuseStructureFromOldProgram() {
-      var _a3, _b2;
+      var _a3;
       if (!oldProgram) {
         return 0 /* Not */;
       }
@@ -101141,19 +101213,19 @@ ${lanes.join("\n")}
       for (const { oldFile: oldSourceFile, newFile: newSourceFile } of modifiedSourceFiles) {
         const moduleNames = getModuleNames(newSourceFile);
         const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
-        const resolutionsChanged = hasChangesInResolutions(moduleNames, newSourceFile, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo);
+        const resolutionsChanged = hasChangesInResolutions(moduleNames, newSourceFile, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo, moduleResolutionNameAndModeGetter);
         if (resolutionsChanged) {
           structureIsReused = 1 /* SafeModules */;
-          newSourceFile.resolvedModules = zipToModeAwareCache(newSourceFile, moduleNames, resolutions);
+          newSourceFile.resolvedModules = zipToModeAwareCache(newSourceFile, moduleNames, resolutions, moduleResolutionNameAndModeGetter);
         } else {
           newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
         }
         const typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
         const typeReferenceResolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typesReferenceDirectives, newSourceFile);
-        const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, newSourceFile, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo);
+        const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, newSourceFile, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo, typeReferenceResolutionNameAndModeGetter);
         if (typeReferenceResolutionsChanged) {
           structureIsReused = 1 /* SafeModules */;
-          newSourceFile.resolvedTypeReferenceDirectiveNames = zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
+          newSourceFile.resolvedTypeReferenceDirectiveNames = zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions, typeReferenceResolutionNameAndModeGetter);
         } else {
           newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
         }
@@ -101161,9 +101233,17 @@ ${lanes.join("\n")}
       if (structureIsReused !== 2 /* Completely */) {
         return structureIsReused;
       }
-      if (changesAffectingProgramStructure(oldOptions, options) || ((_b2 = host.hasChangedAutomaticTypeDirectiveNames) == null ? void 0 : _b2.call(host))) {
+      if (changesAffectingProgramStructure(oldOptions, options)) {
         return 1 /* SafeModules */;
       }
+      if (host.hasChangedAutomaticTypeDirectiveNames) {
+        if (host.hasChangedAutomaticTypeDirectiveNames())
+          return 1 /* SafeModules */;
+      } else {
+        automaticTypeDirectiveNames = getAutomaticTypeDirectiveNames(options, host);
+        if (!arrayIsEqualTo(oldProgram.getAutomaticTypeDirectiveNames(), automaticTypeDirectiveNames))
+          return 1 /* SafeModules */;
+      }
       missingFilePaths = oldProgram.getMissingFilePaths();
       Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
       for (const newSourceFile of newSourceFiles) {
@@ -101187,6 +101267,8 @@ ${lanes.join("\n")}
       fileReasons = oldProgram.getFileIncludeReasons();
       fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
       resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
+      automaticTypeDirectiveNames = oldProgram.getAutomaticTypeDirectiveNames();
+      automaticTypeDirectiveResolutions = oldProgram.getAutomaticTypeDirectiveResolutions();
       sourceFileToPackageName = oldProgram.sourceFileToPackageName;
       redirectTargetsMap = oldProgram.redirectTargetsMap;
       usesUriStyleNodeCoreModules = oldProgram.usesUriStyleNodeCoreModules;
@@ -102130,7 +102212,8 @@ ${lanes.join("\n")}
     }
     function processTypeReferenceDirectives(file) {
       const typeDirectives = file.typeReferenceDirectives;
-      if (!typeDirectives) {
+      if (!typeDirectives.length) {
+        file.resolvedTypeReferenceDirectiveNames = void 0;
         return;
       }
       const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
@@ -102141,23 +102224,31 @@ ${lanes.join("\n")}
         setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat));
         const mode = ref.resolutionMode || file.impliedNodeFormat;
         if (mode && getEmitModuleResolutionKind(options) !== 3 /* Node16 */ && getEmitModuleResolutionKind(options) !== 99 /* NodeNext */) {
-          programDiagnostics.add(createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext));
+          (fileProcessingDiagnostics != null ? fileProcessingDiagnostics : fileProcessingDiagnostics = []).push({
+            kind: 2 /* ResolutionDiagnostics */,
+            diagnostics: [
+              createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext)
+            ]
+          });
         }
         processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });
       }
     }
-    function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
+    function processTypeReferenceDirective(typeReferenceDirective, mode, resolution, reason) {
       var _a3, _b2;
-      (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : void 0 });
-      processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
+      (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolution.resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : void 0 });
+      processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason);
       (_b2 = tracing) == null ? void 0 : _b2.pop();
     }
-    function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-      const previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode);
+    function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason) {
+      var _a3;
+      addResolutionDiagnostics(resolution);
+      const previousResolution = (_a3 = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode)) == null ? void 0 : _a3.resolvedTypeReferenceDirective;
       if (previousResolution && previousResolution.primary) {
         return;
       }
       let saveResolution = true;
+      const { resolvedTypeReferenceDirective } = resolution;
       if (resolvedTypeReferenceDirective) {
         if (resolvedTypeReferenceDirective.isExternalLibraryImport)
           currentNodeModulesDepth++;
@@ -102188,7 +102279,7 @@ ${lanes.join("\n")}
         addFilePreprocessingFileExplainingDiagnostic(void 0, reason, Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]);
       }
       if (saveResolution) {
-        resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective);
+        resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolution);
       }
     }
     function pathForLibFile(libFileName) {
@@ -102237,8 +102328,11 @@ ${lanes.join("\n")}
         Debug.assert(resolutions.length === moduleNames.length);
         const optionsForFile = (useSourceOfProjectReferenceRedirect ? (_a3 = getRedirectReferenceForResolution(file)) == null ? void 0 : _a3.commandLine.options : void 0) || options;
         for (let index = 0; index < moduleNames.length; index++) {
-          const resolution = resolutions[index];
-          setResolvedModule(file, moduleNames[index].text, resolution, getModeForUsageLocation(file, moduleNames[index]));
+          const resolution = resolutions[index].resolvedModule;
+          const moduleName = moduleNames[index].text;
+          const mode = getModeForUsageLocation(file, moduleNames[index]);
+          setResolvedModule(file, moduleName, resolutions[index], mode);
+          addResolutionDiagnosticsFromResolutionOrCache(file, moduleName, resolutions[index], mode);
           if (!resolution) {
             continue;
           }
@@ -102879,8 +102973,8 @@ ${lanes.join("\n")}
       if (!symlinks) {
         symlinks = createSymlinkCache(currentDirectory, getCanonicalFileName);
       }
-      if (files && resolvedTypeReferenceDirectives && !symlinks.hasProcessedResolutions()) {
-        symlinks.setSymlinksFromResolutions(files, resolvedTypeReferenceDirectives);
+      if (files && automaticTypeDirectiveResolutions && !symlinks.hasProcessedResolutions()) {
+        symlinks.setSymlinksFromResolutions(files, automaticTypeDirectiveResolutions);
       }
       return symlinks;
     }
@@ -103123,7 +103217,7 @@ ${lanes.join("\n")}
     }
     Debug.fail("should never ask for module name at index higher than possible module name");
   }
-  var ForegroundColorEscapeSequences, gutterStyleSequence, gutterSeparator, resetEscapeSequence, ellipsis, halfIndent, indent, inferredTypesContainingFile, plainJSErrors, emitSkippedWithNoDiagnostics;
+  var ForegroundColorEscapeSequences, gutterStyleSequence, gutterSeparator, resetEscapeSequence, ellipsis, halfIndent, indent, emptyResolution, moduleResolutionNameAndModeGetter, typeReferenceResolutionNameAndModeGetter, inferredTypesContainingFile, plainJSErrors, emitSkippedWithNoDiagnostics;
   var init_program = __esm({
     "src/compiler/program.ts"() {
       "use strict";
@@ -103144,6 +103238,18 @@ ${lanes.join("\n")}
       ellipsis = "...";
       halfIndent = "  ";
       indent = "    ";
+      emptyResolution = {
+        resolvedModule: void 0,
+        resolvedTypeReferenceDirective: void 0
+      };
+      moduleResolutionNameAndModeGetter = {
+        getName: getModuleResolutionName,
+        getMode: (entry, file) => getModeForUsageLocation(file, entry)
+      };
+      typeReferenceResolutionNameAndModeGetter = {
+        getName: getTypeReferenceResolutionName,
+        getMode: (entry, file) => getModeForFileReference(entry, file == null ? void 0 : file.impliedNodeFormat)
+      };
       inferredTypesContainingFile = "__inferred type names__.ts";
       plainJSErrors = /* @__PURE__ */ new Set([
         Diagnostics.Cannot_redeclare_block_scoped_variable_0.code,
@@ -103350,7 +103456,7 @@ ${lanes.join("\n")}
             }
           }
           if (sourceFile.resolvedTypeReferenceDirectiveNames) {
-            sourceFile.resolvedTypeReferenceDirectiveNames.forEach((resolvedTypeReferenceDirective) => {
+            sourceFile.resolvedTypeReferenceDirectiveNames.forEach(({ resolvedTypeReferenceDirective }) => {
               if (!resolvedTypeReferenceDirective) {
                 return;
               }
@@ -103472,6 +103578,26 @@ ${lanes.join("\n")}
           (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path);
         }
         BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
+        function computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, onNewSignature) {
+          programOfThisState.emit(
+            sourceFile,
+            (fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) => {
+              Debug.assert(isDeclarationFileName(fileName), `File extension for signature expected to be dts: Got:: ${fileName}`);
+              onNewSignature(computeSignatureWithDiagnostics(
+                programOfThisState,
+                sourceFile,
+                text,
+                host,
+                data
+              ), sourceFiles);
+            },
+            cancellationToken,
+            true,
+            void 0,
+            true
+          );
+        }
+        BuilderState2.computeDtsSignature = computeDtsSignature;
         function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host, useFileVersionAsSignature = state.useFileVersionAsSignature) {
           var _a2;
           if ((_a2 = state.hasCalledUpdateShapeSignature) == null ? void 0 : _a2.has(sourceFile.resolvedPath))
@@ -103480,26 +103606,12 @@ ${lanes.join("\n")}
           const prevSignature = info.signature;
           let latestSignature;
           if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
-            programOfThisState.emit(
-              sourceFile,
-              (fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) => {
-                Debug.assert(isDeclarationFileName(fileName), `File extension for signature expected to be dts: Got:: ${fileName}`);
-                latestSignature = computeSignatureWithDiagnostics(
-                  programOfThisState,
-                  sourceFile,
-                  text,
-                  host,
-                  data
-                );
-                if (latestSignature !== prevSignature) {
-                  updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
-                }
-              },
-              cancellationToken,
-              true,
-              void 0,
-              true
-            );
+            computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, (signature, sourceFiles) => {
+              latestSignature = signature;
+              if (latestSignature !== prevSignature) {
+                updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
+              }
+            });
           }
           if (latestSignature === void 0) {
             latestSignature = sourceFile.version;
@@ -103523,27 +103635,24 @@ ${lanes.join("\n")}
           if (!state.exportedModulesMap)
             return;
           (state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
-          if (!exportedModulesFromDeclarationEmit) {
-            state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
-            return;
-          }
-          let exportedModules;
-          exportedModulesFromDeclarationEmit.forEach((symbol) => addExportedModule(getReferencedFilesFromImportedModuleSymbol(symbol)));
+          const exportedModules = getExportedModules(exportedModulesFromDeclarationEmit);
           if (exportedModules) {
             state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
           } else {
             state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
           }
-          function addExportedModule(exportedModulePaths) {
-            if (exportedModulePaths == null ? void 0 : exportedModulePaths.length) {
-              if (!exportedModules) {
-                exportedModules = /* @__PURE__ */ new Set();
-              }
-              exportedModulePaths.forEach((path) => exportedModules.add(path));
-            }
-          }
         }
         BuilderState2.updateExportedModules = updateExportedModules;
+        function getExportedModules(exportedModulesFromDeclarationEmit) {
+          let exportedModules;
+          exportedModulesFromDeclarationEmit == null ? void 0 : exportedModulesFromDeclarationEmit.forEach(
+            (symbol) => getReferencedFilesFromImportedModuleSymbol(symbol).forEach(
+              (path) => (exportedModules != null ? exportedModules : exportedModules = /* @__PURE__ */ new Set()).add(path)
+            )
+          );
+          return exportedModules;
+        }
+        BuilderState2.getExportedModules = getExportedModules;
         function getAllDependencies(state, programOfThisState, sourceFile) {
           const compilerOptions = programOfThisState.getCompilerOptions();
           if (outFile(compilerOptions)) {
@@ -103687,9 +103796,9 @@ ${lanes.join("\n")}
   function hasSameKeys(map1, map2) {
     return map1 === map2 || map1 !== void 0 && map2 !== void 0 && map1.size === map2.size && !forEachKey(map1, (key) => !map2.has(key));
   }
-  function createBuilderProgramState(newProgram, oldState, disableUseFileVersionAsSignature) {
+  function createBuilderProgramState(newProgram, oldState) {
     var _a2, _b;
-    const state = BuilderState.create(newProgram, oldState, disableUseFileVersionAsSignature);
+    const state = BuilderState.create(newProgram, oldState, false);
     state.program = newProgram;
     const compilerOptions = newProgram.getCompilerOptions();
     state.compilerOptions = compilerOptions;
@@ -103981,7 +104090,7 @@ ${lanes.join("\n")}
           sourceFile,
           cancellationToken,
           host,
-          !host.disableUseFileVersionAsSignature
+          true
         );
         if (getEmitDeclarations(state.compilerOptions)) {
           addToAffectedFilesPendingEmit(state, path, state.compilerOptions.declarationMap ? 24 /* AllDts */ : 8 /* Dts */);
@@ -104364,7 +104473,7 @@ ${lanes.join("\n")}
       oldState = void 0;
       return oldProgram;
     }
-    const state = createBuilderProgramState(newProgram, oldState, host.disableUseFileVersionAsSignature);
+    const state = createBuilderProgramState(newProgram, oldState);
     newProgram.getBuildInfo = (bundle) => getBuildInfo2(state, bundle);
     newProgram = void 0;
     oldProgram = void 0;
@@ -104861,9 +104970,9 @@ ${lanes.join("\n")}
     let filesWithInvalidatedResolutions;
     let filesWithInvalidatedNonRelativeUnresolvedImports;
     const nonRelativeExternalModuleResolutions = createMultiMap();
-    const resolutionsWithFailedLookups = [];
-    const resolutionsWithOnlyAffectingLocations = [];
-    const resolvedFileToResolution = createMultiMap();
+    const resolutionsWithFailedLookups = /* @__PURE__ */ new Set();
+    const resolutionsWithOnlyAffectingLocations = /* @__PURE__ */ new Set();
+    const resolvedFileToResolution = /* @__PURE__ */ new Map();
     const impliedFormatPackageJsons = /* @__PURE__ */ new Map();
     let hasChangedAutomaticTypeDirectiveNames = false;
     let affectingPathChecksForFile;
@@ -104900,9 +105009,9 @@ ${lanes.join("\n")}
       finishRecordingFilesWithChangedResolutions,
       startCachingPerDirectoryResolution,
       finishCachingPerDirectoryResolution,
-      resolveModuleNames,
-      getResolvedModuleWithFailedLookupLocationsFromCache,
-      resolveTypeReferenceDirectives,
+      resolveModuleNameLiterals,
+      resolveTypeReferenceDirectiveReferences,
+      resolveSingleModuleNameWithoutWatching,
       removeResolutionsFromProjectReferenceRedirects,
       removeResolutionsOfFile,
       hasChangedAutomaticTypeDirectiveNames: () => hasChangedAutomaticTypeDirectiveNames,
@@ -104936,8 +105045,8 @@ ${lanes.join("\n")}
       resolvedModuleNames.clear();
       resolvedTypeReferenceDirectives.clear();
       resolvedFileToResolution.clear();
-      resolutionsWithFailedLookups.length = 0;
-      resolutionsWithOnlyAffectingLocations.length = 0;
+      resolutionsWithFailedLookups.clear();
+      resolutionsWithOnlyAffectingLocations.clear();
       failedLookupChecks = void 0;
       startsWithPathChecks = void 0;
       isInDirectoryChecks = void 0;
@@ -105020,14 +105129,16 @@ ${lanes.join("\n")}
       });
       hasChangedAutomaticTypeDirectiveNames = false;
     }
-    function resolveModuleName2(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
+    function resolveModuleName2(moduleName, containingFile, compilerOptions, redirectedReference, mode) {
+      var _a2;
+      const host = ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost;
       const primaryResult = resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
       if (!resolutionHost.getGlobalCache) {
         return primaryResult;
       }
       const globalCache = resolutionHost.getGlobalCache();
       if (globalCache !== void 0 && !isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && extensionIsTS(primaryResult.resolvedModule.extension))) {
-        const { resolvedModule, failedLookupLocations, affectingLocations } = loadModuleFromGlobalCache(
+        const { resolvedModule, failedLookupLocations, affectingLocations, resolutionDiagnostics } = loadModuleFromGlobalCache(
           Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName),
           resolutionHost.projectName,
           compilerOptions,
@@ -105037,49 +105148,55 @@ ${lanes.join("\n")}
         );
         if (resolvedModule) {
           primaryResult.resolvedModule = resolvedModule;
-          primaryResult.failedLookupLocations.push(...failedLookupLocations);
-          primaryResult.affectingLocations.push(...affectingLocations);
+          primaryResult.failedLookupLocations = updateResolutionField(primaryResult.failedLookupLocations, failedLookupLocations);
+          primaryResult.affectingLocations = updateResolutionField(primaryResult.affectingLocations, affectingLocations);
+          primaryResult.resolutionDiagnostics = updateResolutionField(primaryResult.resolutionDiagnostics, resolutionDiagnostics);
           return primaryResult;
         }
       }
       return primaryResult;
     }
-    function resolveTypeReferenceDirective2(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, _containingSourceFile, resolutionMode) {
-      return resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode);
+    function createModuleResolutionLoader2(containingFile, redirectedReference, options) {
+      return {
+        nameAndMode: moduleResolutionNameAndModeGetter,
+        resolve: (moduleName, resoluionMode) => resolveModuleName2(
+          moduleName,
+          containingFile,
+          options,
+          redirectedReference,
+          resoluionMode
+        )
+      };
     }
     function resolveNamesWithLocalCache({
-      names,
+      entries,
       containingFile,
+      containingSourceFile,
       redirectedReference,
+      options,
       perFileCache,
+      reusedNames,
       loader,
       getResolutionWithResolvedFileName,
       shouldRetryResolution,
-      reusedNames,
-      resolutionInfo,
-      logChanges,
-      containingSourceFile,
-      containingSourceFileMode
+      logChanges
     }) {
-      var _a2, _b, _c;
+      var _a2;
       const path = resolutionHost.toPath(containingFile);
       const resolutionsInFile = perFileCache.get(path) || perFileCache.set(path, createModeAwareCache()).get(path);
       const resolvedModules = [];
-      const compilerOptions = resolutionHost.getCompilationSettings();
       const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path);
       const program = resolutionHost.getCurrentProgram();
       const oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile);
       const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
       const seenNamesInFile = createModeAwareCache();
-      let i = 0;
-      for (const entry of containingSourceFile && resolutionInfo ? resolutionInfo.names : names) {
-        const name = getResolutionName(entry);
-        const mode = !isString(entry) ? isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode) : containingSourceFile ? getModeForResolutionAtIndex(containingSourceFile, i) : void 0;
-        i++;
+      for (const entry of entries) {
+        const name = loader.nameAndMode.getName(entry);
+        const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
         let resolution = resolutionsInFile.get(name, mode);
         if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
           const existingResolution = resolution;
-          resolution = loader(name, containingFile, compilerOptions, ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile, mode);
+          resolution = loader.resolve(name, mode);
           if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
             resolutionHost.onDiscoveredSymlink();
           }
@@ -105093,12 +105210,12 @@ ${lanes.join("\n")}
             logChanges = false;
           }
         } else {
-          const host = ((_b = resolutionHost.getCompilerHost) == null ? void 0 : _b.call(resolutionHost)) || resolutionHost;
-          if (isTraceEnabled(compilerOptions, host) && !seenNamesInFile.has(name, mode)) {
+          const host = ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost;
+          if (isTraceEnabled(options, host) && !seenNamesInFile.has(name, mode)) {
             const resolved = getResolutionWithResolvedFileName(resolution);
             trace(
               host,
-              loader === resolveModuleName2 ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved,
+              perFileCache === resolvedModuleNames ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved,
               name,
               containingFile,
               resolved == null ? void 0 : resolved.resolvedFileName,
@@ -105108,19 +105225,16 @@ ${lanes.join("\n")}
         }
         Debug.assert(resolution !== void 0 && !resolution.isInvalidated);
         seenNamesInFile.set(name, mode, true);
-        resolvedModules.push(getResolutionWithResolvedFileName(resolution));
-      }
-      if (resolutionInfo && (loader === resolveTypeReferenceDirective2 || containingSourceFile)) {
-        (_c = resolutionInfo.reusedNames) == null ? void 0 : _c.forEach((entry) => seenNamesInFile.set(
-          getResolutionName(entry),
-          !isString(entry) && isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode),
-          true
-        ));
-        reusedNames = void 0;
+        resolvedModules.push(resolution);
       }
+      reusedNames == null ? void 0 : reusedNames.forEach((entry) => seenNamesInFile.set(
+        loader.nameAndMode.getName(entry),
+        loader.nameAndMode.getMode(entry, containingSourceFile),
+        true
+      ));
       if (resolutionsInFile.size() !== seenNamesInFile.size()) {
         resolutionsInFile.forEach((resolution, name, mode) => {
-          if (!seenNamesInFile.has(name, mode) && !contains(reusedNames, name)) {
+          if (!seenNamesInFile.has(name, mode)) {
             stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
             resolutionsInFile.delete(name, mode);
           }
@@ -105145,39 +105259,53 @@ ${lanes.join("\n")}
         return oldResult.resolvedFileName === newResult.resolvedFileName;
       }
     }
-    function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) {
+    function resolveTypeReferenceDirectiveReferences(typeDirectiveReferences, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
+      var _a2;
       return resolveNamesWithLocalCache({
-        names: typeDirectiveNames,
+        entries: typeDirectiveReferences,
         containingFile,
+        containingSourceFile,
         redirectedReference,
+        options,
+        reusedNames,
         perFileCache: resolvedTypeReferenceDirectives,
-        loader: resolveTypeReferenceDirective2,
+        loader: createTypeReferenceResolutionLoader(
+          containingFile,
+          redirectedReference,
+          options,
+          ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost,
+          typeReferenceDirectiveResolutionCache
+        ),
         getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective2,
-        shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
-        containingSourceFileMode: containingFileMode,
-        resolutionInfo
+        shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0
       });
     }
-    function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile, resolutionInfo) {
+    function resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
       return resolveNamesWithLocalCache({
-        names: moduleNames,
+        entries: moduleLiterals,
         containingFile,
+        containingSourceFile,
         redirectedReference,
+        options,
+        reusedNames,
         perFileCache: resolvedModuleNames,
-        loader: resolveModuleName2,
+        loader: createModuleResolutionLoader2(
+          containingFile,
+          redirectedReference,
+          options
+        ),
         getResolutionWithResolvedFileName: getResolvedModule2,
         shouldRetryResolution: (resolution) => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
-        reusedNames,
-        resolutionInfo,
-        logChanges: logChangesWhenResolvingModule,
-        containingSourceFile
+        logChanges: logChangesWhenResolvingModule
       });
     }
-    function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
-      const cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile));
-      if (!cache)
-        return void 0;
-      return cache.get(moduleName, resolutionMode);
+    function resolveSingleModuleNameWithoutWatching(moduleName, containingFile) {
+      const path = resolutionHost.toPath(containingFile);
+      const resolutionsInFile = resolvedModuleNames.get(path);
+      const resolution = resolutionsInFile == null ? void 0 : resolutionsInFile.get(moduleName, void 0);
+      if (resolution && !resolution.isInvalidated)
+        return resolution;
+      return resolveModuleName2(moduleName, containingFile, resolutionHost.getCompilationSettings());
     }
     function isNodeModulesAtTypesDirectory(dirPath) {
       return endsWith(dirPath, "/node_modules/@types");
@@ -105235,12 +105363,13 @@ ${lanes.join("\n")}
       return fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
     }
     function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName) {
+      var _a2, _b;
       if (resolution.refCount) {
         resolution.refCount++;
         Debug.assertIsDefined(resolution.files);
       } else {
         resolution.refCount = 1;
-        Debug.assert(length(resolution.files) === 0);
+        Debug.assert(!((_a2 = resolution.files) == null ? void 0 : _a2.size));
         if (isExternalModuleNameRelative(name)) {
           watchFailedLookupLocationOfResolution(resolution);
         } else {
@@ -105248,48 +105377,54 @@ ${lanes.join("\n")}
         }
         const resolved = getResolutionWithResolvedFileName(resolution);
         if (resolved && resolved.resolvedFileName) {
-          resolvedFileToResolution.add(resolutionHost.toPath(resolved.resolvedFileName), resolution);
+          const key = resolutionHost.toPath(resolved.resolvedFileName);
+          let resolutions = resolvedFileToResolution.get(key);
+          if (!resolutions)
+            resolvedFileToResolution.set(key, resolutions = /* @__PURE__ */ new Set());
+          resolutions.add(resolution);
         }
       }
-      (resolution.files || (resolution.files = [])).push(filePath);
+      ((_b = resolution.files) != null ? _b : resolution.files = /* @__PURE__ */ new Set()).add(filePath);
     }
     function watchFailedLookupLocationOfResolution(resolution) {
       Debug.assert(!!resolution.refCount);
       const { failedLookupLocations, affectingLocations } = resolution;
-      if (!failedLookupLocations.length && !affectingLocations.length)
+      if (!(failedLookupLocations == null ? void 0 : failedLookupLocations.length) && !(affectingLocations == null ? void 0 : affectingLocations.length))
         return;
-      if (failedLookupLocations.length)
-        resolutionsWithFailedLookups.push(resolution);
+      if (failedLookupLocations == null ? void 0 : failedLookupLocations.length)
+        resolutionsWithFailedLookups.add(resolution);
       let setAtRoot = false;
-      for (const failedLookupLocation of failedLookupLocations) {
-        const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
-        const toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
-        if (toWatch) {
-          const { dir, dirPath, nonRecursive } = toWatch;
-          if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) {
-            const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
-            customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
-          }
-          if (dirPath === rootPath) {
-            Debug.assert(!nonRecursive);
-            setAtRoot = true;
-          } else {
-            setDirectoryWatcher(dir, dirPath, nonRecursive);
+      if (failedLookupLocations) {
+        for (const failedLookupLocation of failedLookupLocations) {
+          const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
+          const toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
+          if (toWatch) {
+            const { dir, dirPath, nonRecursive } = toWatch;
+            if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) {
+              const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
+              customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
+            }
+            if (dirPath === rootPath) {
+              Debug.assert(!nonRecursive);
+              setAtRoot = true;
+            } else {
+              setDirectoryWatcher(dir, dirPath, nonRecursive);
+            }
           }
         }
+        if (setAtRoot) {
+          setDirectoryWatcher(rootDir, rootPath, true);
+        }
       }
-      if (setAtRoot) {
-        setDirectoryWatcher(rootDir, rootPath, true);
-      }
-      watchAffectingLocationsOfResolution(resolution, !failedLookupLocations.length);
+      watchAffectingLocationsOfResolution(resolution, !(failedLookupLocations == null ? void 0 : failedLookupLocations.length));
     }
     function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
       Debug.assert(!!resolution.refCount);
       const { affectingLocations } = resolution;
-      if (!affectingLocations.length)
+      if (!(affectingLocations == null ? void 0 : affectingLocations.length))
         return;
       if (addToResolutionsWithOnlyAffectingLocations)
-        resolutionsWithOnlyAffectingLocations.push(resolution);
+        resolutionsWithOnlyAffectingLocations.add(resolution);
       for (const affectingLocation of affectingLocations) {
         createFileWatcherOfAffectingLocation(affectingLocation, true);
       }
@@ -105368,17 +105503,20 @@ ${lanes.join("\n")}
       }
     }
     function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName) {
-      unorderedRemoveItem(Debug.checkDefined(resolution.files), filePath);
+      Debug.checkDefined(resolution.files).delete(filePath);
       resolution.refCount--;
       if (resolution.refCount) {
         return;
       }
       const resolved = getResolutionWithResolvedFileName(resolution);
       if (resolved && resolved.resolvedFileName) {
-        resolvedFileToResolution.remove(resolutionHost.toPath(resolved.resolvedFileName), resolution);
+        const key = resolutionHost.toPath(resolved.resolvedFileName);
+        const resolutions = resolvedFileToResolution.get(key);
+        if ((resolutions == null ? void 0 : resolutions.delete(resolution)) && !resolutions.size)
+          resolvedFileToResolution.delete(key);
       }
       const { failedLookupLocations, affectingLocations } = resolution;
-      if (unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) {
+      if (resolutionsWithFailedLookups.delete(resolution)) {
         let removeAtRoot = false;
         for (const failedLookupLocation of failedLookupLocations) {
           const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
@@ -105404,12 +105542,14 @@ ${lanes.join("\n")}
         if (removeAtRoot) {
           removeDirectoryWatcher(rootPath);
         }
-      } else if (affectingLocations.length) {
-        unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution);
+      } else if (affectingLocations == null ? void 0 : affectingLocations.length) {
+        resolutionsWithOnlyAffectingLocations.delete(resolution);
       }
-      for (const affectingLocation of affectingLocations) {
-        const watcher = fileWatchesOfAffectingLocations.get(affectingLocation);
-        watcher.resolutions--;
+      if (affectingLocations) {
+        for (const affectingLocation of affectingLocations) {
+          const watcher = fileWatchesOfAffectingLocations.get(affectingLocation);
+          watcher.resolutions--;
+        }
       }
     }
     function removeDirectoryWatcher(dirPath) {
@@ -105451,15 +105591,15 @@ ${lanes.join("\n")}
       if (!resolutions)
         return false;
       let invalidated = false;
-      for (const resolution of resolutions) {
+      resolutions.forEach((resolution) => {
         if (resolution.isInvalidated || !canInvalidate(resolution))
-          continue;
+          return;
         resolution.isInvalidated = invalidated = true;
         for (const containingFilePath of Debug.checkDefined(resolution.files)) {
           (filesWithInvalidatedResolutions != null ? filesWithInvalidatedResolutions : filesWithInvalidatedResolutions = /* @__PURE__ */ new Set()).add(containingFilePath);
           hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || endsWith(containingFilePath, inferredTypesContainingFile);
         }
-      }
+      });
       return invalidated;
     }
     function invalidateResolutionOfFile(filePath) {
@@ -105531,17 +105671,19 @@ ${lanes.join("\n")}
       return invalidated;
     }
     function canInvalidateFailedLookupResolution(resolution) {
+      var _a2;
       if (canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution))
         return true;
       if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks)
         return false;
-      return resolution.failedLookupLocations.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)));
+      return (_a2 = resolution.failedLookupLocations) == null ? void 0 : _a2.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)));
     }
     function isInvalidatedFailedLookup(locationPath) {
       return (failedLookupChecks == null ? void 0 : failedLookupChecks.has(locationPath)) || firstDefinedIterator((startsWithPathChecks == null ? void 0 : startsWithPathChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => startsWith(locationPath, fileOrDirectoryPath) ? true : void 0) || firstDefinedIterator((isInDirectoryChecks == null ? void 0 : isInDirectoryChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : void 0);
     }
     function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
-      return !!affectingPathChecks && resolution.affectingLocations.some((location) => affectingPathChecks.has(location));
+      var _a2;
+      return !!affectingPathChecks && ((_a2 = resolution.affectingLocations) == null ? void 0 : _a2.some((location) => affectingPathChecks.has(location)));
     }
     function closeTypeRootsWatch() {
       clearMap(typeRootsWatches, closeFileWatcher);
@@ -106022,7 +106164,6 @@ ${lanes.join("\n")}
       getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
       createHash: maybeBind(host, host.createHash),
       readDirectory: maybeBind(host, host.readDirectory),
-      disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
       storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
     };
     return compilerHost;
@@ -106089,7 +106230,6 @@ ${lanes.join("\n")}
       writeFile: (path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
       createHash: maybeBind(system, system.createHash),
       createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
-      disableUseFileVersionAsSignature: system.disableUseFileVersionAsSignature,
       storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
       now: maybeBind(system, system.now)
     };
@@ -106230,7 +106370,6 @@ ${lanes.join("\n")}
   function createIncrementalCompilerHost(options, system = sys) {
     const host = createCompilerHostWorker(options, void 0, system);
     host.createHash = maybeBind(system, system.createHash);
-    host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
     host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
     setGetSourceFileAsHashVersioned(host);
     changeCompilerHostLikeToUseCache(host, (fileName) => toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName));
@@ -106346,10 +106485,18 @@ ${lanes.join("\n")}
       configFileName ? getDirectoryPath(getNormalizedAbsolutePath(configFileName, currentDirectory)) : currentDirectory,
       false
     );
-    compilerHost.resolveModuleNames = host.resolveModuleNames ? (...args) => host.resolveModuleNames(...args) : (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile, resolutionInfo) => resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile, resolutionInfo);
-    compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ? (...args) => host.resolveTypeReferenceDirectives(...args) : (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode, resolutionInfo) => resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo);
-    compilerHost.getModuleResolutionCache = host.resolveModuleNames ? maybeBind(host, host.getModuleResolutionCache) : () => resolutionCache.getModuleResolutionCache();
-    const userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
+    compilerHost.resolveModuleNameLiterals = maybeBind(host, host.resolveModuleNameLiterals);
+    compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
+    if (!compilerHost.resolveModuleNameLiterals && !compilerHost.resolveModuleNames) {
+      compilerHost.resolveModuleNameLiterals = resolutionCache.resolveModuleNameLiterals.bind(resolutionCache);
+    }
+    compilerHost.resolveTypeReferenceDirectiveReferences = maybeBind(host, host.resolveTypeReferenceDirectiveReferences);
+    compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
+    if (!compilerHost.resolveTypeReferenceDirectiveReferences && !compilerHost.resolveTypeReferenceDirectives) {
+      compilerHost.resolveTypeReferenceDirectiveReferences = resolutionCache.resolveTypeReferenceDirectiveReferences.bind(resolutionCache);
+    }
+    compilerHost.getModuleResolutionCache = host.resolveModuleNameLiterals || host.resolveModuleNames ? maybeBind(host, host.getModuleResolutionCache) : () => resolutionCache.getModuleResolutionCache();
+    const userProvidedResolution = !!host.resolveModuleNameLiterals || !!host.resolveTypeReferenceDirectiveReferences || !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
     const customHasInvalidatedResolutions = userProvidedResolution ? maybeBind(host, host.hasInvalidatedResolutions) || returnTrue : returnFalse;
     builderProgram = readBuilderProgram(compilerOptions, compilerHost);
     synchronizeProgram();
@@ -107020,19 +107167,38 @@ ${lanes.join("\n")}
     const compilerHost = createCompilerHostFromProgramHost(host, () => state.projectCompilerOptions);
     setGetSourceFileAsHashVersioned(compilerHost);
     compilerHost.getParsedCommandLine = (fileName) => parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName));
+    compilerHost.resolveModuleNameLiterals = maybeBind(host, host.resolveModuleNameLiterals);
+    compilerHost.resolveTypeReferenceDirectiveReferences = maybeBind(host, host.resolveTypeReferenceDirectiveReferences);
     compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
     compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
     compilerHost.getModuleResolutionCache = maybeBind(host, host.getModuleResolutionCache);
-    const moduleResolutionCache = !compilerHost.resolveModuleNames ? createModuleResolutionCache(currentDirectory, getCanonicalFileName) : void 0;
-    const typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : void 0;
-    if (!compilerHost.resolveModuleNames) {
-      const loader = (moduleName, resolverMode, containingFile, redirectedReference) => resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
-      compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile, resolutionInfo) => loadWithModeAwareCache(Debug.checkEachDefined(moduleNames), Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, resolutionInfo, loader);
+    let moduleResolutionCache, typeReferenceDirectiveResolutionCache;
+    if (!compilerHost.resolveModuleNameLiterals && !compilerHost.resolveModuleNames) {
+      moduleResolutionCache = createModuleResolutionCache(currentDirectory, getCanonicalFileName);
+      compilerHost.resolveModuleNameLiterals = (moduleNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        moduleNames,
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
+        moduleResolutionCache,
+        createModuleResolutionLoader
+      );
       compilerHost.getModuleResolutionCache = () => moduleResolutionCache;
     }
-    if (!compilerHost.resolveTypeReferenceDirectives) {
-      const loader = (moduleName, containingFile, redirectedReference, containingFileMode) => resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode).resolvedTypeReferenceDirective;
-      compilerHost.resolveTypeReferenceDirectives = (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
+    if (!compilerHost.resolveTypeReferenceDirectiveReferences && !compilerHost.resolveTypeReferenceDirectives) {
+      typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
+      compilerHost.resolveTypeReferenceDirectiveReferences = (typeDirectiveNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        typeDirectiveNames,
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
+        typeReferenceDirectiveResolutionCache,
+        createTypeReferenceResolutionLoader
+      );
     }
     compilerHost.getBuildInfo = (fileName, configFilePath) => getBuildInfo3(state, fileName, toResolvedConfigFilePath(state, configFilePath), void 0);
     const { watchFile: watchFile2, watchDirectory, writeLog } = createWatchFactory(hostWithWatch, options);
@@ -114067,13 +114233,14 @@ ${lanes.join("\n")}
     return ensurePathIsNonModuleName(combineNormal(pathA, pathB));
   }
   function getSourceFileToImport(importedModuleSymbol, importLiteral, importingSourceFile, program, host, oldToNew) {
+    var _a2;
     if (importedModuleSymbol) {
       const oldFileName = find(importedModuleSymbol.declarations, isSourceFile).fileName;
       const newFileName = oldToNew(oldFileName);
       return newFileName === void 0 ? { newFileName: oldFileName, updated: false } : { newFileName, updated: true };
     } else {
       const mode = getModeForUsageLocation(importingSourceFile, importLiteral);
-      const resolved = host.resolveModuleNames ? host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode) : program.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode);
+      const resolved = host.resolveModuleNameLiterals || !host.resolveModuleNames ? (_a2 = importingSourceFile.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, mode) : host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode);
       return getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, program.getSourceFiles());
     }
   }
@@ -116394,6 +116561,8 @@ ${lanes.join("\n")}
         getModuleResolutionCache: maybeBind(host, host.getModuleResolutionCache),
         createHash: maybeBind(host, host.createHash),
         resolveTypeReferenceDirectives: maybeBind(host, host.resolveTypeReferenceDirectives),
+        resolveModuleNameLiterals: maybeBind(host, host.resolveModuleNameLiterals),
+        resolveTypeReferenceDirectiveReferences: maybeBind(host, host.resolveTypeReferenceDirectiveReferences),
         useSourceOfProjectReferenceRedirect: maybeBind(host, host.useSourceOfProjectReferenceRedirect),
         getParsedCommandLine
       };
@@ -124590,6 +124759,7 @@ ${lanes.join("\n")}
 
   // src/services/codefixes/fixAddMissingMember.ts
   function getInfo7(sourceFile, tokenPos, errorCode, checker, program) {
+    var _a2;
     const token = getTokenAtPosition(sourceFile, tokenPos);
     const parent2 = token.parent;
     if (errorCode === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) {
@@ -124625,7 +124795,7 @@ ${lanes.join("\n")}
       return { kind: 4 /* JsxAttributes */, token, attributes, parentDeclaration: token.parent };
     }
     if (isIdentifier(token)) {
-      const type = checker.getContextualType(token);
+      const type = (_a2 = checker.getContextualType(token)) == null ? void 0 : _a2.getNonNullableType();
       if (type && getObjectFlags(type) & 16 /* Anonymous */) {
         const signature = firstOrUndefined(checker.getSignaturesOfType(type, 0 /* Call */));
         if (signature === void 0)
@@ -129496,6 +129666,7 @@ ${lanes.join("\n")}
       isTypeOnlyLocation,
       isJsxIdentifierExpected,
       isRightOfOpenTag,
+      isRightOfDotOrQuestionDot,
       importStatementCompletion,
       insideJsDocTagTypeExpression,
       symbolToSortTextMap,
@@ -129561,7 +129732,7 @@ ${lanes.join("\n")}
       getJSCompletionEntries(sourceFile, location.pos, uniqueNames, getEmitScriptTarget(compilerOptions), entries);
     }
     let caseBlock;
-    if (preferences.includeCompletionsWithInsertText && contextToken && (caseBlock = findAncestor(contextToken, isCaseBlock))) {
+    if (preferences.includeCompletionsWithInsertText && contextToken && !isRightOfOpenTag && !isRightOfDotOrQuestionDot && (caseBlock = findAncestor(contextToken, isCaseBlock))) {
       const cases = getExhaustiveCaseSnippets(caseBlock, sourceFile, preferences, compilerOptions, host, program, formatContext);
       if (cases) {
         entries.push(cases.entry);
@@ -130932,6 +131103,7 @@ ${lanes.join("\n")}
       isTypeOnlyLocation,
       isJsxIdentifierExpected,
       isRightOfOpenTag,
+      isRightOfDotOrQuestionDot: isRightOfDot || isRightOfQuestionDot,
       importStatementCompletion,
       hasUnresolvedAutoImports,
       flags
@@ -133495,6 +133667,7 @@ ${lanes.join("\n")}
     });
   }
   function findModuleReferences(program, sourceFiles, searchModuleSymbol) {
+    var _a2;
     const refs = [];
     const checker = program.getTypeChecker();
     for (const referencingFile of sourceFiles) {
@@ -133506,7 +133679,7 @@ ${lanes.join("\n")}
           }
         }
         for (const ref of referencingFile.typeReferenceDirectives) {
-          const referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat);
+          const referenced = (_a2 = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat)) == null ? void 0 : _a2.resolvedTypeReferenceDirective;
           if (referenced !== void 0 && referenced.resolvedFileName === searchSourceFile.fileName) {
             refs.push({ kind: "reference", referencingFile, ref });
           }
@@ -134217,7 +134390,7 @@ ${lanes.join("\n")}
       })(FindReferencesUse || {});
       ((Core2) => {
         function getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options = {}, sourceFilesSet = new Set(sourceFiles.map((f) => f.fileName))) {
-          var _a2, _b;
+          var _a2, _b, _c;
           node = getAdjustedNode(node, options);
           if (isSourceFile(node)) {
             const resolvedRef = ts_GoToDefinition_exports.getReferenceAtPosition(node, position, program);
@@ -134249,7 +134422,7 @@ ${lanes.join("\n")}
             if (!options.implementations && isStringLiteralLike(node)) {
               if (isModuleSpecifierLike(node)) {
                 const fileIncludeReasons = program.getFileIncludeReasons();
-                const referencedFileName = (_b = (_a2 = node.getSourceFile().resolvedModules) == null ? void 0 : _a2.get(node.text, getModeForUsageLocation(node.getSourceFile(), node))) == null ? void 0 : _b.resolvedFileName;
+                const referencedFileName = (_c = (_b = (_a2 = node.getSourceFile().resolvedModules) == null ? void 0 : _a2.get(node.text, getModeForUsageLocation(node.getSourceFile(), node))) == null ? void 0 : _b.resolvedModule) == null ? void 0 : _c.resolvedFileName;
                 const referencedFile = referencedFileName ? program.getSourceFile(referencedFileName) : void 0;
                 if (referencedFile) {
                   return [{ definition: { type: 4 /* String */, node }, references: getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || emptyArray }];
@@ -135494,7 +135667,7 @@ ${lanes.join("\n")}
 
   // src/services/goToDefinition.ts
   function getDefinitionAtPosition(program, sourceFile, position, searchOtherFilesOnly, stopAtAlias) {
-    var _a2;
+    var _a2, _b;
     const resolvedRef = getReferenceAtPosition(sourceFile, position, program);
     const fileReferenceDefinition = resolvedRef && [getDefinitionInfoForFileReference(resolvedRef.reference.fileName, resolvedRef.fileName, resolvedRef.unverified)] || emptyArray;
     if (resolvedRef == null ? void 0 : resolvedRef.file) {
@@ -135540,7 +135713,7 @@ ${lanes.join("\n")}
       }
     }
     if (!symbol && isModuleSpecifierLike(fallbackNode)) {
-      const ref = (_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.get(fallbackNode.text, getModeForUsageLocation(sourceFile, fallbackNode));
+      const ref = (_b = (_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.get(fallbackNode.text, getModeForUsageLocation(sourceFile, fallbackNode))) == null ? void 0 : _b.resolvedModule;
       if (ref) {
         return [{
           name: fallbackNode.text,
@@ -135618,7 +135791,7 @@ ${lanes.join("\n")}
     return getDefinitionFromSymbol(typeChecker, symbol, node);
   }
   function getReferenceAtPosition(sourceFile, position, program) {
-    var _a2, _b;
+    var _a2, _b, _c, _d;
     const referencePath = findReferenceInPosition(sourceFile.referencedFiles, position);
     if (referencePath) {
       const file = program.getSourceFileFromReference(sourceFile, referencePath);
@@ -135626,7 +135799,7 @@ ${lanes.join("\n")}
     }
     const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
     if (typeReferenceDirective) {
-      const reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat);
+      const reference = (_a2 = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat)) == null ? void 0 : _a2.resolvedTypeReferenceDirective;
       const file = reference && program.getSourceFile(reference.resolvedFileName);
       return file && { reference: typeReferenceDirective, fileName: file.fileName, file, unverified: false };
     }
@@ -135635,10 +135808,10 @@ ${lanes.join("\n")}
       const file = program.getLibFileFromReference(libReferenceDirective);
       return file && { reference: libReferenceDirective, fileName: file.fileName, file, unverified: false };
     }
-    if ((_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.size()) {
+    if ((_b = sourceFile.resolvedModules) == null ? void 0 : _b.size()) {
       const node = getTouchingToken(sourceFile, position);
       if (isModuleSpecifierLike(node) && isExternalModuleNameRelative(node.text) && sourceFile.resolvedModules.has(node.text, getModeForUsageLocation(sourceFile, node))) {
-        const verifiedFileName = (_b = sourceFile.resolvedModules.get(node.text, getModeForUsageLocation(sourceFile, node))) == null ? void 0 : _b.resolvedFileName;
+        const verifiedFileName = (_d = (_c = sourceFile.resolvedModules.get(node.text, getModeForUsageLocation(sourceFile, node))) == null ? void 0 : _c.resolvedModule) == null ? void 0 : _d.resolvedFileName;
         const fileName = verifiedFileName || resolvePath(getDirectoryPath(sourceFile.fileName), node.text);
         return {
           file: program.getSourceFile(fileName),
@@ -137868,7 +138041,8 @@ ${lanes.join("\n")}
     changes.insertNodeBefore(file, enclosingNode, ignoreSourceNewlines(newTypeNode), true);
     changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(id.name, void 0))), { leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude, trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.ExcludeWhitespace });
   }
-  function doTypedefChange(changes, program, file, name, info) {
+  function doTypedefChange(changes, context, file, name, info) {
+    var _a2;
     const { enclosingNode, selection, typeParameters } = info;
     setEmitFlags(selection, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
     const node = factory.createJSDocTypedefTag(
@@ -137890,7 +138064,7 @@ ${lanes.join("\n")}
     const jsDoc = factory.createJSDocComment(void 0, factory.createNodeArray(concatenate(templates, [node])));
     if (isJSDoc(enclosingNode)) {
       const pos = enclosingNode.getStart(file);
-      const newLineCharacter = getNewLineCharacter(program.getCompilerOptions());
+      const newLineCharacter = getNewLineOrDefaultFromHost(context.host, (_a2 = context.formatContext) == null ? void 0 : _a2.options);
       changes.insertNodeAt(file, enclosingNode.getStart(file), jsDoc, {
         suffix: newLineCharacter + newLineCharacter + file.text.slice(getPrecedingNonSpaceCharacterPosition(file.text, pos - 1), pos)
       });
@@ -137955,7 +138129,7 @@ ${lanes.join("\n")}
           return emptyArray;
         },
         getEditsForAction: function getRefactorEditsToExtractType(context, actionName2) {
-          const { file, program } = context;
+          const { file } = context;
           const info = getRangeToExtract(context);
           Debug.assert(info && !isRefactorErrorInfo(info), "Expected to find a range to extract");
           const name = getUniqueName("NewType", file);
@@ -137966,7 +138140,7 @@ ${lanes.join("\n")}
                 return doTypeAliasChange(changes, file, name, info);
               case extractToTypeDefAction.name:
                 Debug.assert(info.isJS, "Invalid actionName/JS combo");
-                return doTypedefChange(changes, program, file, name, info);
+                return doTypedefChange(changes, context, file, name, info);
               case extractToInterfaceAction.name:
                 Debug.assert(!info.isJS && !!info.typeElements, "Invalid actionName/JS combo");
                 return doInterfaceChange(changes, file, name, info);
@@ -138024,10 +138198,17 @@ ${lanes.join("\n")}
     const usage = getUsageInfo(oldFile, toMove.all, checker);
     const currentDirectory = getDirectoryPath(oldFile.fileName);
     const extension = extensionFromPath(oldFile.fileName);
-    const newModuleName = makeUniqueModuleName(getNewModuleName(usage.oldFileImportsFromNewFile, usage.movedSymbols), extension, currentDirectory, host);
-    const newFileNameWithExtension = newModuleName + extension;
-    changes.createNewFile(oldFile, combinePaths(currentDirectory, newFileNameWithExtension), getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences));
-    addNewFileToTsconfig(program, changes, oldFile.fileName, newFileNameWithExtension, hostGetCanonicalFileName(host));
+    const newFilename = combinePaths(
+      currentDirectory,
+      makeUniqueFilename(
+        inferNewFilename(usage.oldFileImportsFromNewFile, usage.movedSymbols),
+        extension,
+        currentDirectory,
+        host
+      )
+    ) + extension;
+    changes.createNewFile(oldFile, newFilename, getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, host, newFilename, preferences));
+    addNewFileToTsconfig(program, changes, oldFile.fileName, newFilename, hostGetCanonicalFileName(host));
   }
   function getStatementsToMove(context) {
     const rangeToMove = getRangeToMove(context);
@@ -138070,7 +138251,7 @@ ${lanes.join("\n")}
       changes.insertNodeInListAfter(cfg, last(filesProp.initializer.elements), factory.createStringLiteral(newFilePath), filesProp.initializer.elements);
     }
   }
-  function getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences) {
+  function getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, host, newFilename, preferences) {
     const checker = program.getTypeChecker();
     const prologueDirectives = takeWhile(oldFile.statements, isPrologueDirective);
     if (oldFile.externalModuleIndicator === void 0 && oldFile.commonJsModuleIndicator === void 0 && usage.oldImportsNeededByNewFile.size() === 0) {
@@ -138079,14 +138260,14 @@ ${lanes.join("\n")}
     }
     const useEsModuleSyntax = !!oldFile.externalModuleIndicator;
     const quotePreference = getQuotePreference(oldFile, preferences);
-    const importsFromNewFile = createOldFileImportsFromNewFile(usage.oldFileImportsFromNewFile, newModuleName, useEsModuleSyntax, quotePreference);
+    const importsFromNewFile = createOldFileImportsFromNewFile(oldFile, usage.oldFileImportsFromNewFile, newFilename, program, host, useEsModuleSyntax, quotePreference);
     if (importsFromNewFile) {
       insertImports(changes, oldFile, importsFromNewFile, true);
     }
     deleteUnusedOldImports(oldFile, toMove.all, changes, usage.unusedImportsFromOldFile, checker);
     deleteMovedStatements(oldFile, toMove.ranges, changes);
-    updateImportsInOtherFiles(changes, program, oldFile, usage.movedSymbols, newModuleName);
-    const imports = getNewFileImportsAndAddExportInOldFile(oldFile, usage.oldImportsNeededByNewFile, usage.newFileImportsFromOldFile, changes, checker, useEsModuleSyntax, quotePreference);
+    updateImportsInOtherFiles(changes, program, host, oldFile, usage.movedSymbols, newFilename);
+    const imports = getNewFileImportsAndAddExportInOldFile(oldFile, usage.oldImportsNeededByNewFile, usage.newFileImportsFromOldFile, changes, checker, program, host, useEsModuleSyntax, quotePreference);
     const body = addExports(oldFile, toMove.all, usage.oldFileImportsFromNewFile, useEsModuleSyntax);
     if (imports.length && body.length) {
       return [
@@ -138114,7 +138295,7 @@ ${lanes.join("\n")}
       forEachImportInStatement(statement, (i) => deleteUnusedImports(oldFile, i, changes, (name) => toDelete.has(checker.getSymbolAtLocation(name))));
     }
   }
-  function updateImportsInOtherFiles(changes, program, oldFile, movedSymbols, newModuleName) {
+  function updateImportsInOtherFiles(changes, program, host, oldFile, movedSymbols, newFilename) {
     const checker = program.getTypeChecker();
     for (const sourceFile of program.getSourceFiles()) {
       if (sourceFile === oldFile)
@@ -138128,13 +138309,14 @@ ${lanes.join("\n")}
             return !!symbol && movedSymbols.has(symbol);
           };
           deleteUnusedImports(sourceFile, importNode, changes, shouldMove);
-          const newModuleSpecifier = combinePaths(getDirectoryPath(moduleSpecifierFromImport(importNode).text), newModuleName);
+          const pathToNewFileWithExtension = resolvePath(getDirectoryPath(oldFile.path), newFilename);
+          const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.path, pathToNewFileWithExtension, createModuleSpecifierResolutionHost(program, host));
           const newImportDeclaration = filterImport(importNode, factory.createStringLiteral(newModuleSpecifier), shouldMove);
           if (newImportDeclaration)
             changes.insertNodeAfter(sourceFile, statement, newImportDeclaration);
           const ns = getNamespaceLikeImport(importNode);
           if (ns)
-            updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, ns, importNode);
+            updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleSpecifier, ns, importNode);
         });
       }
     }
@@ -138151,8 +138333,8 @@ ${lanes.join("\n")}
         return Debug.assertNever(node, `Unexpected node kind ${node.kind}`);
     }
   }
-  function updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, oldImportId, oldImportNode) {
-    const preferredNewNamespaceName = ts_codefix_exports.moduleSpecifierToValidIdentifier(newModuleName, 99 /* ESNext */);
+  function updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleSpecifier, oldImportId, oldImportNode) {
+    const preferredNewNamespaceName = ts_codefix_exports.moduleSpecifierToValidIdentifier(newModuleSpecifier, 99 /* ESNext */);
     let needUniqueName = false;
     const toChange = [];
     ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(oldImportId, checker, sourceFile, (ref) => {
@@ -138168,7 +138350,7 @@ ${lanes.join("\n")}
       for (const ref of toChange) {
         changes.replaceNode(sourceFile, ref, factory.createIdentifier(newNamespaceName));
       }
-      changes.insertNodeAfter(sourceFile, oldImportNode, updateNamespaceLikeImportNode(oldImportNode, newModuleName, newModuleSpecifier));
+      changes.insertNodeAfter(sourceFile, oldImportNode, updateNamespaceLikeImportNode(oldImportNode, preferredNewNamespaceName, newModuleSpecifier));
     }
   }
   function updateNamespaceLikeImportNode(node, newNamespaceName, newModuleSpecifier) {
@@ -138209,7 +138391,7 @@ ${lanes.join("\n")}
       }
     }
   }
-  function createOldFileImportsFromNewFile(newFileNeedExport, newFileNameWithExtension, useEs6Imports, quotePreference) {
+  function createOldFileImportsFromNewFile(sourceFile, newFileNeedExport, newFileNameWithExtension, program, host, useEs6Imports, quotePreference) {
     let defaultImport;
     const imports = [];
     newFileNeedExport.forEach((symbol) => {
@@ -138219,17 +138401,18 @@ ${lanes.join("\n")}
         imports.push(symbol.name);
       }
     });
-    return makeImportOrRequire(defaultImport, imports, newFileNameWithExtension, useEs6Imports, quotePreference);
+    return makeImportOrRequire(sourceFile, defaultImport, imports, newFileNameWithExtension, program, host, useEs6Imports, quotePreference);
   }
-  function makeImportOrRequire(defaultImport, imports, path, useEs6Imports, quotePreference) {
-    path = ensurePathIsNonModuleName(path);
+  function makeImportOrRequire(sourceFile, defaultImport, imports, newFileNameWithExtension, program, host, useEs6Imports, quotePreference) {
+    const pathToNewFile = resolvePath(getDirectoryPath(sourceFile.path), newFileNameWithExtension);
+    const pathToNewFileWithCorrectExtension = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.path, pathToNewFile, createModuleSpecifierResolutionHost(program, host));
     if (useEs6Imports) {
       const specifiers = imports.map((i) => factory.createImportSpecifier(false, void 0, factory.createIdentifier(i)));
-      return makeImportIfNecessary(defaultImport, specifiers, path, quotePreference);
+      return makeImportIfNecessary(defaultImport, specifiers, pathToNewFileWithCorrectExtension, quotePreference);
     } else {
       Debug.assert(!defaultImport, "No default import should exist");
       const bindingElements = imports.map((i) => factory.createBindingElement(void 0, void 0, i));
-      return bindingElements.length ? makeVariableStatement(factory.createObjectBindingPattern(bindingElements), void 0, createRequireCall(factory.createStringLiteral(path))) : void 0;
+      return bindingElements.length ? makeVariableStatement(factory.createObjectBindingPattern(bindingElements), void 0, createRequireCall(factory.createStringLiteral(pathToNewFileWithCorrectExtension))) : void 0;
     }
   }
   function makeVariableStatement(name, type, initializer, flags = 2 /* Const */) {
@@ -138326,7 +138509,7 @@ ${lanes.join("\n")}
         break;
     }
   }
-  function getNewFileImportsAndAddExportInOldFile(oldFile, importsToCopy, newFileImportsFromOldFile, changes, checker, useEsModuleSyntax, quotePreference) {
+  function getNewFileImportsAndAddExportInOldFile(oldFile, importsToCopy, newFileImportsFromOldFile, changes, checker, program, host, useEsModuleSyntax, quotePreference) {
     const copiedOldImports = [];
     for (const oldStatement of oldFile.statements) {
       forEachImportInStatement(oldStatement, (i) => {
@@ -138357,19 +138540,19 @@ ${lanes.join("\n")}
         }
       }
     });
-    append(copiedOldImports, makeImportOrRequire(oldFileDefault, oldFileNamedImports, removeFileExtension(getBaseFileName(oldFile.fileName)), useEsModuleSyntax, quotePreference));
+    append(copiedOldImports, makeImportOrRequire(oldFile, oldFileDefault, oldFileNamedImports, getBaseFileName(oldFile.fileName), program, host, useEsModuleSyntax, quotePreference));
     return copiedOldImports;
   }
-  function makeUniqueModuleName(moduleName, extension, inDirectory, host) {
-    let newModuleName = moduleName;
+  function makeUniqueFilename(proposedFilename, extension, inDirectory, host) {
+    let newFilename = proposedFilename;
     for (let i = 1; ; i++) {
-      const name = combinePaths(inDirectory, newModuleName + extension);
+      const name = combinePaths(inDirectory, newFilename + extension);
       if (!host.fileExists(name))
-        return newModuleName;
-      newModuleName = `${moduleName}.${i}`;
+        return newFilename;
+      newFilename = `${proposedFilename}.${i}`;
     }
   }
-  function getNewModuleName(importsFromNewFile, movedSymbols) {
+  function inferNewFilename(importsFromNewFile, movedSymbols) {
     return importsFromNewFile.forEachEntry(symbolNameNoDefault) || movedSymbols.forEachEntry(symbolNameNoDefault) || "newFile";
   }
   function getUsageInfo(oldFile, toMove, checker) {
@@ -138643,6 +138826,7 @@ ${lanes.join("\n")}
   var init_moveToNewFile = __esm({
     "src/services/refactors/moveToNewFile.ts"() {
       "use strict";
+      init_moduleSpecifiers();
       init_ts4();
       init_ts_refactor();
       refactorName4 = "Move to a new file";
@@ -149604,7 +149788,7 @@ ${options.prefix}` : "\n" : options.prefix
       if (!file.resolvedModules)
         return emptyArray2;
       let unresolvedImports;
-      file.resolvedModules.forEach((resolvedModule, name) => {
+      file.resolvedModules.forEach(({ resolvedModule }, name) => {
         if ((!resolvedModule || !resolutionExtensionIsTSOrJson(resolvedModule.extension)) && !isExternalModuleNameRelative(name) && !ambientModules.some((m) => m === name)) {
           unresolvedImports = append(unresolvedImports, parsePackageName(name).packageName);
         }
@@ -149768,7 +149952,7 @@ ${options.prefix}` : "\n" : options.prefix
           if (this.program && !this.symlinks.hasProcessedResolutions()) {
             this.symlinks.setSymlinksFromResolutions(
               this.program.getSourceFiles(),
-              this.program.getResolvedTypeReferenceDirectives()
+              this.program.getAutomaticTypeDirectiveResolutions()
             );
           }
           return this.symlinks;
@@ -149852,17 +150036,21 @@ ${options.prefix}` : "\n" : options.prefix
           const path = this.toPath(file);
           return !this.isWatchedMissingFile(path) && this.directoryStructureHost.fileExists(file);
         }
-        resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, _options, containingSourceFile, resolutionInfo) {
-          return this.resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile, resolutionInfo);
+        resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
+          return this.resolutionCache.resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames);
         }
         getModuleResolutionCache() {
           return this.resolutionCache.getModuleResolutionCache();
         }
-        getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
-          return this.resolutionCache.getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode);
-        }
-        resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode, resolutionInfo) {
-          return this.resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo);
+        resolveTypeReferenceDirectiveReferences(typeDirectiveReferences, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
+          return this.resolutionCache.resolveTypeReferenceDirectiveReferences(
+            typeDirectiveReferences,
+            containingFile,
+            redirectedReference,
+            options,
+            containingSourceFile,
+            reusedNames
+          );
         }
         directoryExists(path) {
           return this.directoryStructureHost.directoryExists(path);
@@ -155967,7 +156155,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
           definitions = definitions.filter((d) => !d.isAmbient && !d.failedAliasResolution);
           return this.mapDefinitionInfo(definitions, project);
           function findImplementationFileFromDtsFileName(fileName, resolveFromFile, auxiliaryProject) {
-            var _a3;
+            var _a3, _b, _c;
             const nodeModulesPathParts = getNodeModulePathParts(fileName);
             if (nodeModulesPathParts && fileName.lastIndexOf(nodeModulesPathPart) === nodeModulesPathParts.topLevelNodeModulesIndex) {
               const packageDirectory = fileName.substring(0, nodeModulesPathParts.packageRootIndex);
@@ -155989,13 +156177,11 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
               const packageName = getPackageNameFromTypesPackageName(unmangleScopedPackageName(packageNamePathPart));
               const path = project.toPath(fileName);
               if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path)) {
-                const [implementationResolution] = auxiliaryProject.resolveModuleNames([packageName], resolveFromFile);
-                return implementationResolution == null ? void 0 : implementationResolution.resolvedFileName;
+                return (_b = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(packageName, resolveFromFile).resolvedModule) == null ? void 0 : _b.resolvedFileName;
               } else {
                 const pathToFileInPackage = fileName.substring(nodeModulesPathParts.packageRootIndex + 1);
                 const specifier = `${packageName}/${removeFileExtension(pathToFileInPackage)}`;
-                const [implementationResolution] = auxiliaryProject.resolveModuleNames([specifier], resolveFromFile);
-                return implementationResolution == null ? void 0 : implementationResolution.resolvedFileName;
+                return (_c = auxiliaryProject.resolutionCache.resolveSingleModuleNameWithoutWatching(specifier, resolveFromFile).resolvedModule) == null ? void 0 : _c.resolvedFileName;
               }
             }
             return void 0;
@@ -158645,6 +158831,7 @@ ${e.message}`;
     createModuleBlock: () => createModuleBlock,
     createModuleDeclaration: () => createModuleDeclaration,
     createModuleResolutionCache: () => createModuleResolutionCache,
+    createModuleResolutionLoader: () => createModuleResolutionLoader,
     createModuleSpecifierResolutionHost: () => createModuleSpecifierResolutionHost,
     createMultiMap: () => createMultiMap,
     createNamedExports: () => createNamedExports,
@@ -158767,6 +158954,7 @@ ${e.message}`;
     createTypeQueryNode: () => createTypeQueryNode,
     createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
     createTypeReferenceNode: () => createTypeReferenceNode,
+    createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
     createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
     createUnionTypeNode: () => createUnionTypeNode,
     createUniqueName: () => createUniqueName,
@@ -159256,9 +159444,7 @@ ${e.message}`;
     getRenameLocation: () => getRenameLocation,
     getReplacementSpanForContextToken: () => getReplacementSpanForContextToken,
     getResolutionDiagnostic: () => getResolutionDiagnostic,
-    getResolutionMode: () => getResolutionMode,
     getResolutionModeOverrideForClause: () => getResolutionModeOverrideForClause,
-    getResolutionName: () => getResolutionName,
     getResolvedExternalModuleName: () => getResolvedExternalModuleName,
     getResolvedModule: () => getResolvedModule,
     getResolvedTypeReferenceDirective: () => getResolvedTypeReferenceDirective,
@@ -160077,7 +160263,6 @@ ${e.message}`;
     listFiles: () => listFiles,
     loadModuleFromGlobalCache: () => loadModuleFromGlobalCache,
     loadWithModeAwareCache: () => loadWithModeAwareCache,
-    loadWithTypeDirectiveCache: () => loadWithTypeDirectiveCache,
     makeIdentifierFromModuleName: () => makeIdentifierFromModuleName,
     makeImport: () => makeImport,
     makeImportIfNecessary: () => makeImportIfNecessary,
@@ -160109,6 +160294,7 @@ ${e.message}`;
     modifiersToFlags: () => modifiersToFlags,
     moduleOptionDeclaration: () => moduleOptionDeclaration,
     moduleResolutionIsEqualTo: () => moduleResolutionIsEqualTo,
+    moduleResolutionNameAndModeGetter: () => moduleResolutionNameAndModeGetter,
     moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations,
     moduleResolutionRespectsExports: () => moduleResolutionRespectsExports,
     moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
@@ -160485,6 +160671,7 @@ ${e.message}`;
     typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
     typeKeywords: () => typeKeywords,
     typeParameterNamePart: () => typeParameterNamePart,
+    typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,
     typeToDisplayParts: () => typeToDisplayParts,
     unchangedPollThresholds: () => unchangedPollThresholds,
     unchangedTextChangeRange: () => unchangedTextChangeRange,
@@ -160600,6 +160787,7 @@ ${e.message}`;
     updatePropertyAssignment: () => updatePropertyAssignment,
     updatePropertySignature: () => updatePropertySignature,
     updateQualifiedName: () => updateQualifiedName,
+    updateResolutionField: () => updateResolutionField,
     updateRestTypeNode: () => updateRestTypeNode,
     updateReturn: () => updateReturn,
     updateSetAccessor: () => updateSetAccessor,
@@ -161267,6 +161455,7 @@ ${e.message}`;
     createModuleBlock: () => createModuleBlock,
     createModuleDeclaration: () => createModuleDeclaration,
     createModuleResolutionCache: () => createModuleResolutionCache,
+    createModuleResolutionLoader: () => createModuleResolutionLoader,
     createModuleSpecifierResolutionHost: () => createModuleSpecifierResolutionHost,
     createMultiMap: () => createMultiMap,
     createNamedExports: () => createNamedExports,
@@ -161389,6 +161578,7 @@ ${e.message}`;
     createTypeQueryNode: () => createTypeQueryNode,
     createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
     createTypeReferenceNode: () => createTypeReferenceNode,
+    createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
     createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
     createUnionTypeNode: () => createUnionTypeNode,
     createUniqueName: () => createUniqueName,
@@ -161878,9 +162068,7 @@ ${e.message}`;
     getRenameLocation: () => getRenameLocation,
     getReplacementSpanForContextToken: () => getReplacementSpanForContextToken,
     getResolutionDiagnostic: () => getResolutionDiagnostic,
-    getResolutionMode: () => getResolutionMode,
     getResolutionModeOverrideForClause: () => getResolutionModeOverrideForClause,
-    getResolutionName: () => getResolutionName,
     getResolvedExternalModuleName: () => getResolvedExternalModuleName,
     getResolvedModule: () => getResolvedModule,
     getResolvedTypeReferenceDirective: () => getResolvedTypeReferenceDirective,
@@ -162699,7 +162887,6 @@ ${e.message}`;
     listFiles: () => listFiles,
     loadModuleFromGlobalCache: () => loadModuleFromGlobalCache,
     loadWithModeAwareCache: () => loadWithModeAwareCache,
-    loadWithTypeDirectiveCache: () => loadWithTypeDirectiveCache,
     makeIdentifierFromModuleName: () => makeIdentifierFromModuleName,
     makeImport: () => makeImport,
     makeImportIfNecessary: () => makeImportIfNecessary,
@@ -162731,6 +162918,7 @@ ${e.message}`;
     modifiersToFlags: () => modifiersToFlags,
     moduleOptionDeclaration: () => moduleOptionDeclaration,
     moduleResolutionIsEqualTo: () => moduleResolutionIsEqualTo,
+    moduleResolutionNameAndModeGetter: () => moduleResolutionNameAndModeGetter,
     moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations,
     moduleResolutionRespectsExports: () => moduleResolutionRespectsExports,
     moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
@@ -163107,6 +163295,7 @@ ${e.message}`;
     typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
     typeKeywords: () => typeKeywords,
     typeParameterNamePart: () => typeParameterNamePart,
+    typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,
     typeToDisplayParts: () => typeToDisplayParts,
     unchangedPollThresholds: () => unchangedPollThresholds,
     unchangedTextChangeRange: () => unchangedTextChangeRange,
@@ -163222,6 +163411,7 @@ ${e.message}`;
     updatePropertyAssignment: () => updatePropertyAssignment,
     updatePropertySignature: () => updatePropertySignature,
     updateQualifiedName: () => updateQualifiedName,
+    updateResolutionField: () => updateResolutionField,
     updateRestTypeNode: () => updateRestTypeNode,
     updateReturn: () => updateReturn,
     updateSetAccessor: () => updateSetAccessor,