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

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20221205`;
+var version = `${versionMajorMinor}.0-dev.20221207`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1695,22 +1695,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() {
@@ -1739,11 +1725,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;
         }
@@ -1795,13 +1780,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;
             }
@@ -10702,7 +10686,8 @@ function getFullWidth(node) {
   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) {
@@ -10716,15 +10701,11 @@ function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveNam
   }
   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);
-}
 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;
@@ -10736,15 +10717,15 @@ function packageIdToString(packageId) {
   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) {
@@ -14824,13 +14805,14 @@ function createSymlinkCache(cwd, getCanonicalFileName) {
       }
     },
     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
   };
@@ -32721,17 +32703,29 @@ function resolvedTypeScriptOnly(resolved) {
 }
 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) {
@@ -32866,8 +32860,10 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
     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);
@@ -32937,8 +32933,18 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
       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;
@@ -33058,23 +33064,27 @@ function createCacheWithRedirects(ownOptions) {
   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;
@@ -33088,9 +33098,13 @@ function createCacheWithRedirects(ownOptions) {
         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() {
@@ -33142,8 +33156,10 @@ function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create)
   }
   return result;
 }
-function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap) {
+function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, options) {
+  const directoryToModuleNameMap = createCacheWithRedirects(options);
   return {
+    getFromDirectoryCache,
     getOrCreateCacheForDirectory,
     clear: clear2,
     update
@@ -33151,13 +33167,18 @@ function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileNam
   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}`;
@@ -33197,48 +33218,41 @@ function createModeAwareCache() {
     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);
   }
@@ -33254,7 +33268,7 @@ function createModuleResolutionCache(currentDirectory, getCanonicalFileName, opt
         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) {
@@ -33288,14 +33302,22 @@ function createModuleResolutionCache(currentDirectory, getCanonicalFileName, opt
     }
   }
 }
-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() {
@@ -33304,14 +33326,32 @@ function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanoni
   }
   function clearAllExceptPackageJsonInfoCache() {
     perDirectoryResolutionCache.clear();
+    nonRelativeNameResolutionCache.clear();
+  }
+  function update(options2) {
+    perDirectoryResolutionCache.update(options2);
+    nonRelativeNameResolutionCache.update(options2);
   }
 }
-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);
+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 resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
   const traceEnabled = isTraceEnabled(compilerOptions, host);
@@ -33325,8 +33365,7 @@ function resolveModuleName(moduleName, containingFile, compilerOptions, host, ca
     }
   }
   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);
@@ -33376,11 +33415,9 @@ function resolveModuleName(moduleName, containingFile, compilerOptions, host, ca
     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) {
@@ -33497,7 +33534,7 @@ function tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state) {
 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;
 }
@@ -34290,7 +34327,7 @@ function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directo
   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) {
@@ -34304,7 +34341,7 @@ function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName,
   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;
         }
@@ -34450,8 +34487,8 @@ function getPackageNameFromTypesPackageName(mangledName) {
 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);
@@ -34494,9 +34531,8 @@ function classicNameResolver(moduleName, containingFile, compilerOptions, host,
       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;
         }
@@ -37837,7 +37873,7 @@ function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory,
   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) {
@@ -38169,9 +38205,9 @@ function createTypeChecker(host) {
     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;
@@ -38975,6 +39011,12 @@ function createTypeChecker(host) {
     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) {
@@ -48668,7 +48710,7 @@ function createTypeChecker(host) {
           const resolved = resolveAlias(aliasSymbol2);
           if (resolved && resolved.flags & 524288 /* TypeAlias */) {
             newAliasSymbol = resolved;
-            aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node);
+            aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node) || (typeParameters ? [] : void 0);
           }
         }
       }
@@ -57484,13 +57526,13 @@ function createTypeChecker(host) {
       }
       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);
@@ -67973,7 +68015,6 @@ function createTypeChecker(host) {
     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) {
@@ -67992,15 +68033,9 @@ function createTypeChecker(host) {
       }
       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);
           }
         };
       }
@@ -71101,11 +71136,11 @@ function createTypeChecker(host) {
     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);
         }
@@ -97353,25 +97388,6 @@ function flattenDiagnosticMessageText(diag2, newLine, indent2 = 0) {
   }
   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;
 }
@@ -97437,22 +97453,65 @@ function getResolutionModeOverrideForClause(clause, grammarErrorOnNode) {
   }
   return elem.value.text === "import" ? 99 /* ESNext */ : 1 /* CommonJS */;
 }
-function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, resolutionInfo, loader) {
-  if (names.length === 0) {
-    return [];
-  }
+var emptyResolution = {
+  resolvedModule: void 0,
+  resolvedTypeReferenceDirective: void 0
+};
+function getModuleResolutionName(literal) {
+  return literal.text;
+}
+var moduleResolutionNameAndModeGetter = {
+  getName: getModuleResolutionName,
+  getMode: (entry, file) => getModeForUsageLocation(file, entry)
+};
+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;
+}
+var typeReferenceResolutionNameAndModeGetter = {
+  getName: getTypeReferenceResolutionName,
+  getMode: (entry, file) => getModeForFileReference(entry, file == null ? void 0 : file.impliedNodeFormat)
+};
+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);
   }
@@ -97498,14 +97557,14 @@ function isReferenceFileLocation(location) {
   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);
@@ -97516,7 +97575,7 @@ function getReferencedFileLocation(getSourceFileByPath, ref) {
       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]);
@@ -97705,7 +97764,7 @@ function createCreateProgramOptions(rootNames, options, host, oldProgram, config
   };
 }
 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;
@@ -97722,6 +97781,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   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();
@@ -97740,50 +97801,59 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   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();
@@ -97796,7 +97866,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   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,
@@ -97807,13 +97877,13 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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 = [];
@@ -97847,19 +97917,30 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         });
       }
     }
-    (_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();
@@ -97906,7 +97987,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       }
     );
   }
-  typeReferenceDirectiveResolutionCache = void 0;
   oldProgram = void 0;
   const program = {
     getRootFileNames: () => rootNames,
@@ -97939,6 +98019,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     getRelationCacheSizes: () => getTypeChecker().getRelationCacheSizes(),
     getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
     getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,
+    getAutomaticTypeDirectiveNames: () => automaticTypeDirectiveNames,
+    getAutomaticTypeDirectiveResolutions: () => automaticTypeDirectiveResolutions,
     isSourceFileFromExternalLibrary,
     isSourceFileDefaultLibrary,
     getSourceFileFromReference,
@@ -97948,7 +98030,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     usesUriStyleNodeCoreModules,
     isEmittedFile,
     getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics2,
-    getResolvedModuleWithFailedLookupLocationsFromCache,
     getProjectReferences,
     getResolvedProjectReferences,
     getProjectReferenceRedirect,
@@ -97961,7 +98042,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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,
@@ -97975,6 +98056,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       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);
     }
@@ -97982,32 +98065,30 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   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;
@@ -98015,23 +98096,22 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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();
@@ -98077,9 +98157,6 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
     return libs.length + 2;
   }
-  function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) {
-    return moduleResolutionCache && resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode);
-  }
   function toPath3(fileName) {
     return toPath(fileName, currentDirectory, getCanonicalFileName);
   }
@@ -98108,6 +98185,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     return classifiableNames;
   }
   function resolveModuleNamesReusingOldState(moduleNames, file) {
+    var _a3;
     if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
       return resolveModuleNamesWorker(moduleNames, file, void 0);
     }
@@ -98123,24 +98201,24 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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;
         }
@@ -98160,18 +98238,14 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         (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++;
       }
@@ -98195,6 +98269,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
   }
   function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
+    var _a3;
     if (structureIsReused === 0 /* Not */) {
       return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, void 0);
     }
@@ -98203,7 +98278,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       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;
@@ -98217,21 +98292,21 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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;
         }
@@ -98243,7 +98318,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     const resolutions = resolveTypeReferenceDirectiveNamesWorker(
       unknownTypeReferenceDirectiveNames,
       containingFile,
-      { names: unknownTypeReferenceDirectiveNames, reusedNames }
+      reusedNames
     );
     if (!result) {
       Debug.assert(resolutions.length === typeDirectiveNames.length);
@@ -98279,7 +98354,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     );
   }
   function tryReuseStructureFromOldProgram() {
-    var _a3, _b2;
+    var _a3;
     if (!oldProgram) {
       return 0 /* Not */;
     }
@@ -98389,19 +98464,19 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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;
       }
@@ -98409,9 +98484,17 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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) {
@@ -98435,6 +98518,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     fileReasons = oldProgram.getFileIncludeReasons();
     fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
     resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
+    automaticTypeDirectiveNames = oldProgram.getAutomaticTypeDirectiveNames();
+    automaticTypeDirectiveResolutions = oldProgram.getAutomaticTypeDirectiveResolutions();
     sourceFileToPackageName = oldProgram.sourceFileToPackageName;
     redirectTargetsMap = oldProgram.redirectTargetsMap;
     usesUriStyleNodeCoreModules = oldProgram.usesUriStyleNodeCoreModules;
@@ -99378,7 +99463,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   }
   function processTypeReferenceDirectives(file) {
     const typeDirectives = file.typeReferenceDirectives;
-    if (!typeDirectives) {
+    if (!typeDirectives.length) {
+      file.resolvedTypeReferenceDirectiveNames = void 0;
       return;
     }
     const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
@@ -99389,23 +99475,31 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       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++;
@@ -99436,7 +99530,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       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) {
@@ -99485,8 +99579,11 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       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;
         }
@@ -100127,8 +100224,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     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;
   }
@@ -100462,7 +100559,7 @@ var BuilderState;
       }
     }
     if (sourceFile.resolvedTypeReferenceDirectiveNames) {
-      sourceFile.resolvedTypeReferenceDirectiveNames.forEach((resolvedTypeReferenceDirective) => {
+      sourceFile.resolvedTypeReferenceDirectiveNames.forEach(({ resolvedTypeReferenceDirective }) => {
         if (!resolvedTypeReferenceDirective) {
           return;
         }
@@ -100584,6 +100681,26 @@ var BuilderState;
     (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))
@@ -100592,26 +100709,12 @@ var BuilderState;
     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;
@@ -100635,27 +100738,24 @@ var BuilderState;
     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)) {
@@ -100797,9 +100897,9 @@ function getPendingEmitKind(optionsOrEmitKind, oldOptionsOrEmitKind) {
 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;
@@ -101091,7 +101191,7 @@ function handleDtsMayChangeOf(state, path, cancellationToken, host) {
         sourceFile,
         cancellationToken,
         host,
-        !host.disableUseFileVersionAsSignature
+        true
       );
       if (getEmitDeclarations(state.compilerOptions)) {
         addToAffectedFilesPendingEmit(state, path, state.compilerOptions.declarationMap ? 24 /* AllDts */ : 8 /* Dts */);
@@ -101474,7 +101574,7 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
     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;
@@ -101933,9 +102033,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   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;
@@ -101972,9 +102072,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     finishRecordingFilesWithChangedResolutions,
     startCachingPerDirectoryResolution,
     finishCachingPerDirectoryResolution,
-    resolveModuleNames,
-    getResolvedModuleWithFailedLookupLocationsFromCache,
-    resolveTypeReferenceDirectives,
+    resolveModuleNameLiterals,
+    resolveTypeReferenceDirectiveReferences,
+    resolveSingleModuleNameWithoutWatching,
     removeResolutionsFromProjectReferenceRedirects,
     removeResolutionsOfFile,
     hasChangedAutomaticTypeDirectiveNames: () => hasChangedAutomaticTypeDirectiveNames,
@@ -101990,7 +102090,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function getResolvedModule2(resolution) {
     return resolution.resolvedModule;
   }
-  function getResolvedTypeReferenceDirective2(resolution) {
+  function getResolvedTypeReferenceDirective(resolution) {
     return resolution.resolvedTypeReferenceDirective;
   }
   function isInDirectoryPath(dir, file) {
@@ -102008,8 +102108,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     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;
@@ -102092,14 +102192,16 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     });
     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,
@@ -102109,49 +102211,55 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       );
       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();
         }
@@ -102165,12 +102273,12 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           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,
@@ -102180,19 +102288,16 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       }
       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);
         }
@@ -102217,39 +102322,53 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       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,
-      getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective2,
-      shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
-      containingSourceFileMode: containingFileMode,
-      resolutionInfo
+      loader: createTypeReferenceResolutionLoader(
+        containingFile,
+        redirectedReference,
+        options,
+        ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost,
+        typeReferenceDirectiveResolutionCache
+      ),
+      getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
+      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");
@@ -102307,12 +102426,13 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     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 {
@@ -102320,48 +102440,54 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       }
       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);
     }
@@ -102440,17 +102566,20 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     }
   }
   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);
@@ -102476,12 +102605,14 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       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) {
@@ -102517,21 +102648,21 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   }
   function removeResolutionsOfFile(filePath) {
     removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule2);
-    removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective2);
+    removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective);
   }
   function invalidateResolutions(resolutions, canInvalidate) {
     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) {
@@ -102603,17 +102734,19 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     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);
@@ -103119,7 +103252,6 @@ function createCompilerHostFromProgramHost(host, getCompilerOptions, directorySt
     getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
     createHash: maybeBind(host, host.createHash),
     readDirectory: maybeBind(host, host.readDirectory),
-    disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
     storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
   };
   return compilerHost;
@@ -103186,7 +103318,6 @@ function createProgramHost(system, createProgram2) {
     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)
   };
@@ -103288,7 +103419,6 @@ function readBuilderProgram(compilerOptions, host) {
 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));
@@ -103379,10 +103509,18 @@ function createWatchProgram(host) {
     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();
@@ -104021,19 +104159,38 @@ function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, optio
   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);