typescript 5.0.0-dev.20221205 → 5.0.0-dev.20221206

package/lib/typescript.js

@@ -42,7 +42,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20221205`;
+      version = `${versionMajorMinor}.0-dev.20221206`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4097,6 +4097,7 @@ ${lanes.join("\n")}
       FilePreprocessingDiagnosticsKind = /* @__PURE__ */ ((FilePreprocessingDiagnosticsKind2) => {
         FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["FilePreprocessingReferencedDiagnostic"] = 0] = "FilePreprocessingReferencedDiagnostic";
         FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["FilePreprocessingFileExplainingDiagnostic"] = 1] = "FilePreprocessingFileExplainingDiagnostic";
+        FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["ResolutionDiagnostics"] = 2] = "ResolutionDiagnostics";
         return FilePreprocessingDiagnosticsKind2;
       })(FilePreprocessingDiagnosticsKind || {});
       EmitOnly = /* @__PURE__ */ ((EmitOnly4) => {
@@ -12244,7 +12245,8 @@ ${lanes.join("\n")}
     return node.end - node.pos;
   }
   function getResolvedModule(sourceFile, moduleNameText, mode) {
-    return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode);
+    var _a2, _b;
+    return (_b = (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedModules) == null ? void 0 : _a2.get(moduleNameText, mode)) == null ? void 0 : _b.resolvedModule;
   }
   function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) {
     if (!sourceFile.resolvedModules) {
@@ -12259,14 +12261,14 @@ ${lanes.join("\n")}
     sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, mode, resolvedTypeReferenceDirective);
   }
   function getResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, mode) {
-    var _a2;
-    return (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _a2.get(typeReferenceDirectiveName, mode);
+    var _a2, _b;
+    return (_b = (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _a2.get(typeReferenceDirectiveName, mode)) == null ? void 0 : _b.resolvedTypeReferenceDirective;
   }
   function projectReferenceIsEqualTo(oldRef, newRef) {
     return oldRef.path === newRef.path && !oldRef.prepend === !newRef.prepend && !oldRef.circular === !newRef.circular;
   }
   function moduleResolutionIsEqualTo(oldResolution, newResolution) {
-    return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport && oldResolution.extension === newResolution.extension && oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.originalPath === newResolution.originalPath && packageIdIsEqual(oldResolution.packageId, newResolution.packageId);
+    return oldResolution === newResolution || oldResolution.resolvedModule === newResolution.resolvedModule || !!oldResolution.resolvedModule && !!newResolution.resolvedModule && oldResolution.resolvedModule.isExternalLibraryImport === newResolution.resolvedModule.isExternalLibraryImport && oldResolution.resolvedModule.extension === newResolution.resolvedModule.extension && oldResolution.resolvedModule.resolvedFileName === newResolution.resolvedModule.resolvedFileName && oldResolution.resolvedModule.originalPath === newResolution.resolvedModule.originalPath && packageIdIsEqual(oldResolution.resolvedModule.packageId, newResolution.resolvedModule.packageId);
   }
   function packageIdIsEqual(a, b) {
     return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version;
@@ -12278,15 +12280,15 @@ ${lanes.join("\n")}
     return `${packageIdToPackageName(packageId)}@${packageId.version}`;
   }
   function typeDirectiveIsEqualTo(oldResolution, newResolution) {
-    return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary && oldResolution.originalPath === newResolution.originalPath;
+    return oldResolution === newResolution || oldResolution.resolvedTypeReferenceDirective === newResolution.resolvedTypeReferenceDirective || !!oldResolution.resolvedTypeReferenceDirective && !!newResolution.resolvedTypeReferenceDirective && oldResolution.resolvedTypeReferenceDirective.resolvedFileName === newResolution.resolvedTypeReferenceDirective.resolvedFileName && !!oldResolution.resolvedTypeReferenceDirective.primary === !!newResolution.resolvedTypeReferenceDirective.primary && oldResolution.resolvedTypeReferenceDirective.originalPath === newResolution.resolvedTypeReferenceDirective.originalPath;
   }
-  function hasChangesInResolutions(names, newSourceFile, newResolutions, oldResolutions, comparer) {
+  function hasChangesInResolutions(names, newSourceFile, newResolutions, oldResolutions, comparer, nameAndModeGetter) {
     Debug.assert(names.length === newResolutions.length);
     for (let i = 0; i < names.length; i++) {
       const newResolution = newResolutions[i];
       const entry = names[i];
-      const name = getResolutionName(entry);
-      const mode = getResolutionMode(entry, newSourceFile);
+      const name = nameAndModeGetter.getName(entry);
+      const mode = nameAndModeGetter.getMode(entry, newSourceFile);
       const oldResolution = oldResolutions && oldResolutions.get(name, mode);
       const changed = oldResolution ? !newResolution || !comparer(oldResolution, newResolution) : newResolution;
       if (changed) {
@@ -16635,13 +16637,14 @@ ${lanes.join("\n")}
         }
       },
       setSymlinksFromResolutions(files, typeReferenceDirectives) {
-        var _a2;
+        var _a2, _b;
         Debug.assert(!hasProcessedResolutions);
         hasProcessedResolutions = true;
         for (const file of files) {
-          (_a2 = file.resolvedModules) == null ? void 0 : _a2.forEach((resolution) => processResolution(this, resolution));
+          (_a2 = file.resolvedModules) == null ? void 0 : _a2.forEach((resolution) => processResolution(this, resolution.resolvedModule));
+          (_b = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _b.forEach((resolution) => processResolution(this, resolution.resolvedTypeReferenceDirective));
         }
-        typeReferenceDirectives == null ? void 0 : typeReferenceDirectives.forEach((resolution) => processResolution(this, resolution));
+        typeReferenceDirectives.forEach((resolution) => processResolution(this, resolution.resolvedTypeReferenceDirective));
       },
       hasProcessedResolutions: () => hasProcessedResolutions
     };
@@ -34981,17 +34984,29 @@ ${lanes.join("\n")}
   }
   function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
     if (resultFromCache) {
-      resultFromCache.failedLookupLocations.push(...failedLookupLocations);
-      resultFromCache.affectingLocations.push(...affectingLocations);
+      resultFromCache.failedLookupLocations = updateResolutionField(resultFromCache.failedLookupLocations, failedLookupLocations);
+      resultFromCache.affectingLocations = updateResolutionField(resultFromCache.affectingLocations, affectingLocations);
+      resultFromCache.resolutionDiagnostics = updateResolutionField(resultFromCache.resolutionDiagnostics, diagnostics);
       return resultFromCache;
     }
     return {
       resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? void 0 : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport, packageId: resolved.packageId },
-      failedLookupLocations,
-      affectingLocations,
-      resolutionDiagnostics: diagnostics
+      failedLookupLocations: initializeResolutionField(failedLookupLocations),
+      affectingLocations: initializeResolutionField(affectingLocations),
+      resolutionDiagnostics: initializeResolutionField(diagnostics)
     };
   }
+  function initializeResolutionField(value) {
+    return value.length ? value : void 0;
+  }
+  function updateResolutionField(to, value) {
+    if (!(value == null ? void 0 : value.length))
+      return to;
+    if (!(to == null ? void 0 : to.length))
+      return value;
+    to.push(...value);
+    return to;
+  }
   function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
     if (!hasProperty(jsonContent, fieldName)) {
       if (state.traceEnabled) {
@@ -35195,7 +35210,12 @@ ${lanes.join("\n")}
         isExternalLibraryImport: pathContainsNodeModules(fileName)
       };
     }
-    result = { resolvedTypeReferenceDirective, failedLookupLocations, affectingLocations, resolutionDiagnostics: diagnostics };
+    result = {
+      resolvedTypeReferenceDirective,
+      failedLookupLocations: initializeResolutionField(failedLookupLocations),
+      affectingLocations: initializeResolutionField(affectingLocations),
+      resolutionDiagnostics: initializeResolutionField(diagnostics)
+    };
     perFolderCache == null ? void 0 : perFolderCache.set(typeReferenceDirectiveName, resolutionMode, result);
     if (traceEnabled)
       traceResult(result);
@@ -35465,18 +35485,12 @@ ${lanes.join("\n")}
       return result;
     }
   }
-  function getResolutionName(entry) {
-    return !isString(entry) ? isStringLiteralLike(entry) ? entry.text : toFileNameLowerCase(entry.fileName) : entry;
-  }
-  function getResolutionMode(entry, file) {
-    return isStringLiteralLike(entry) ? getModeForUsageLocation(file, entry) : entry.resolutionMode || file.impliedNodeFormat;
-  }
-  function zipToModeAwareCache(file, keys, values) {
+  function zipToModeAwareCache(file, keys, values, nameAndModeGetter) {
     Debug.assert(keys.length === values.length);
     const map2 = createModeAwareCache();
     for (let i = 0; i < keys.length; ++i) {
       const entry = keys[i];
-      map2.set(getResolutionName(entry), getResolutionMode(entry, file), values[i]);
+      map2.set(nameAndModeGetter.getName(entry), nameAndModeGetter.getMode(entry, file), values[i]);
     }
     return map2;
   }
@@ -35765,7 +35779,7 @@ ${lanes.join("\n")}
   function resolveJSModule(moduleName, initialDir, host) {
     const { resolvedModule, failedLookupLocations } = tryResolveJSModuleWorker(moduleName, initialDir, host);
     if (!resolvedModule) {
-      throw new Error(`Could not resolve JS module '${moduleName}' starting at '${initialDir}'. Looked in: ${failedLookupLocations.join(", ")}`);
+      throw new Error(`Could not resolve JS module '${moduleName}' starting at '${initialDir}'. Looked in: ${failedLookupLocations == null ? void 0 : failedLookupLocations.join(", ")}`);
     }
     return resolvedModule.resolvedFileName;
   }
@@ -40480,9 +40494,9 @@ ${lanes.join("\n")}
       host.getSourceFiles().forEach((sf) => {
         if (!sf.resolvedModules)
           return;
-        sf.resolvedModules.forEach((r) => {
-          if (r && r.packageId)
-            map2.set(r.packageId.name, r.extension === ".d.ts" /* Dts */ || !!map2.get(r.packageId.name));
+        sf.resolvedModules.forEach(({ resolvedModule }) => {
+          if (resolvedModule == null ? void 0 : resolvedModule.packageId)
+            map2.set(resolvedModule.packageId.name, resolvedModule.extension === ".d.ts" /* Dts */ || !!map2.get(resolvedModule.packageId.name));
         });
       });
       return map2;
@@ -41286,6 +41300,12 @@ ${lanes.join("\n")}
       return diagnostic;
     }
     function isDeprecatedSymbol(symbol) {
+      if (length(symbol.declarations) > 1) {
+        const parentSymbol = getParentOfSymbol(symbol);
+        if (parentSymbol && parentSymbol.flags & 64 /* Interface */) {
+          return some(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
+        }
+      }
       return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
     }
     function addDeprecatedSuggestion(location, declarations, deprecatedEntity) {
@@ -50979,7 +50999,7 @@ ${lanes.join("\n")}
             const resolved = resolveAlias(aliasSymbol2);
             if (resolved && resolved.flags & 524288 /* TypeAlias */) {
               newAliasSymbol = resolved;
-              aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node);
+              aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node) || (typeParameters ? [] : void 0);
             }
           }
         }
@@ -59795,13 +59815,13 @@ ${lanes.join("\n")}
         }
         const target = getReferenceCandidate(typeOfExpr.expression);
         if (!isMatchingReference(reference, target)) {
-          const propertyAccess = getDiscriminantPropertyAccess(typeOfExpr.expression, type);
+          if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
+            type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
+          }
+          const propertyAccess = getDiscriminantPropertyAccess(target, type);
           if (propertyAccess) {
             return narrowTypeByDiscriminant(type, propertyAccess, (t) => narrowTypeByLiteralExpression(t, literal, assumeTrue));
           }
-          if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
-            return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
-          }
           return type;
         }
         return narrowTypeByLiteralExpression(type, literal, assumeTrue);
@@ -73412,11 +73432,11 @@ ${lanes.join("\n")}
       let fileToDirective;
       if (resolvedTypeReferenceDirectives) {
         fileToDirective = /* @__PURE__ */ new Map();
-        resolvedTypeReferenceDirectives.forEach((resolvedDirective, key, mode) => {
-          if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
+        resolvedTypeReferenceDirectives.forEach(({ resolvedTypeReferenceDirective }, key, mode) => {
+          if (!(resolvedTypeReferenceDirective == null ? void 0 : resolvedTypeReferenceDirective.resolvedFileName)) {
             return;
           }
-          const file = host.getSourceFile(resolvedDirective.resolvedFileName);
+          const file = host.getSourceFile(resolvedTypeReferenceDirective.resolvedFileName);
           if (file) {
             addReferencedFilesToTypeDirective(file, key, mode);
           }
@@ -100199,25 +100219,6 @@ ${lanes.join("\n")}
     }
     return result;
   }
-  function loadWithTypeDirectiveCache(names, containingFile, redirectedReference, containingFileMode, loader) {
-    if (names.length === 0) {
-      return [];
-    }
-    const resolutions = [];
-    const cache = createModeAwareCache();
-    for (const name of names) {
-      let result;
-      const mode = getModeForFileReference(name, containingFileMode);
-      const strName = getResolutionName(name);
-      if (cache.has(strName, mode)) {
-        result = cache.get(strName, mode);
-      } else {
-        cache.set(strName, mode, result = loader(strName, containingFile, redirectedReference, mode));
-      }
-      resolutions.push(result);
-    }
-    return resolutions;
-  }
   function getModeForFileReference(ref, containingFileMode) {
     return (isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode;
   }
@@ -100283,22 +100284,53 @@ ${lanes.join("\n")}
     }
     return elem.value.text === "import" ? 99 /* ESNext */ : 1 /* CommonJS */;
   }
-  function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, resolutionInfo, loader) {
-    if (names.length === 0) {
-      return [];
-    }
+  function getModuleResolutionName(literal) {
+    return literal.text;
+  }
+  function createModuleResolutionLoader(containingFile, redirectedReference, options, host, cache) {
+    return {
+      nameAndMode: moduleResolutionNameAndModeGetter,
+      resolve: (moduleName, resoluionMode) => resolveModuleName(
+        moduleName,
+        containingFile,
+        options,
+        host,
+        cache,
+        redirectedReference,
+        resoluionMode
+      )
+    };
+  }
+  function getTypeReferenceResolutionName(entry) {
+    return !isString(entry) ? toFileNameLowerCase(entry.fileName) : entry;
+  }
+  function createTypeReferenceResolutionLoader(containingFile, redirectedReference, options, host, cache) {
+    return {
+      nameAndMode: typeReferenceResolutionNameAndModeGetter,
+      resolve: (typeRef, resoluionMode) => resolveTypeReferenceDirective(
+        typeRef,
+        containingFile,
+        options,
+        host,
+        redirectedReference,
+        cache,
+        resoluionMode
+      )
+    };
+  }
+  function loadWithModeAwareCache(entries, containingFile, redirectedReference, options, containingSourceFile, host, resolutionCache, createLoader) {
+    if (entries.length === 0)
+      return emptyArray;
     const resolutions = [];
-    const cache = createModeAwareCache();
-    let i = 0;
-    for (const entry of resolutionInfo ? resolutionInfo.names : names) {
-      let result;
-      const mode = !isString(entry) ? getModeForUsageLocation(containingFile, entry) : getModeForResolutionAtIndex(containingFile, i);
-      i++;
-      const name = isString(entry) ? entry : entry.text;
-      if (cache.has(name, mode)) {
-        result = cache.get(name, mode);
-      } else {
-        cache.set(name, mode, result = loader(name, mode, containingFileName, redirectedReference));
+    const cache = /* @__PURE__ */ new Map();
+    const loader = createLoader(containingFile, redirectedReference, options, host, resolutionCache);
+    for (const entry of entries) {
+      const name = loader.nameAndMode.getName(entry);
+      const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
+      const key = createModeAwareCacheKey(name, mode);
+      let result = cache.get(key);
+      if (!result) {
+        cache.set(key, result = loader.resolve(name, mode));
       }
       resolutions.push(result);
     }
@@ -100343,14 +100375,14 @@ ${lanes.join("\n")}
     return location.pos !== void 0;
   }
   function getReferencedFileLocation(getSourceFileByPath, ref) {
-    var _a2, _b, _c, _d;
+    var _a2, _b, _c, _d, _e, _f;
     const file = Debug.checkDefined(getSourceFileByPath(ref.file));
     const { kind, index } = ref;
     let pos, end, packageId, resolutionMode;
     switch (kind) {
       case 3 /* Import */:
         const importLiteral = getModuleNameStringLiteralAt(file, index);
-        packageId = (_b = (_a2 = file.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) == null ? void 0 : _b.packageId;
+        packageId = (_c = (_b = (_a2 = file.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) == null ? void 0 : _b.resolvedModule) == null ? void 0 : _c.packageId;
         if (importLiteral.pos === -1)
           return { file, packageId, text: importLiteral.text };
         pos = skipTrivia(file.text, importLiteral.pos);
@@ -100361,7 +100393,7 @@ ${lanes.join("\n")}
         break;
       case 5 /* TypeReferenceDirective */:
         ({ pos, end, resolutionMode } = file.typeReferenceDirectives[index]);
-        packageId = (_d = (_c = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _c.get(toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) == null ? void 0 : _d.packageId;
+        packageId = (_f = (_e = (_d = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _d.get(toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) == null ? void 0 : _e.resolvedTypeReferenceDirective) == null ? void 0 : _f.packageId;
         break;
       case 7 /* LibReferenceDirective */:
         ({ pos, end } = file.libReferenceDirectives[index]);
@@ -100457,7 +100489,7 @@ ${lanes.join("\n")}
     };
   }
   function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
-    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+    var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
     const { rootNames, options, configFileParsingDiagnostics, projectReferences } = createProgramOptions;
     let { oldProgram } = createProgramOptions;
@@ -100474,6 +100506,8 @@ ${lanes.join("\n")}
     const cachedDeclarationDiagnosticsForFile = {};
     let resolvedTypeReferenceDirectives = createModeAwareCache();
     let fileProcessingDiagnostics;
+    let automaticTypeDirectiveNames;
+    let automaticTypeDirectiveResolutions;
     const maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
     let currentNodeModulesDepth = 0;
     const modulesWithElidedImports = /* @__PURE__ */ new Map();
@@ -100492,50 +100526,59 @@ ${lanes.join("\n")}
     const hasEmitBlockingDiagnostics = /* @__PURE__ */ new Map();
     let _compilerOptionsObjectLiteralSyntax;
     let moduleResolutionCache;
-    let typeReferenceDirectiveResolutionCache;
     let actualResolveModuleNamesWorker;
     const hasInvalidatedResolutions = host.hasInvalidatedResolutions || returnFalse;
-    if (host.resolveModuleNames) {
-      actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => {
-        var _a3;
-        return host.resolveModuleNames(
-          moduleNames.map((literal) => literal.text),
-          containingFileName,
-          (_a3 = resolutionInfo == null ? void 0 : resolutionInfo.reusedNames) == null ? void 0 : _a3.map((literal) => literal.text),
-          redirectedReference,
-          options,
-          containingFile,
-          resolutionInfo
-        ).map((resolved) => {
-          if (!resolved || resolved.extension !== void 0) {
-            return resolved;
-          }
-          const withExtension = clone(resolved);
-          withExtension.extension = extensionFromPath(resolved.resolvedFileName);
-          return withExtension;
-        });
-      };
+    if (host.resolveModuleNameLiterals) {
+      actualResolveModuleNamesWorker = host.resolveModuleNameLiterals.bind(host);
       moduleResolutionCache = (_b = host.getModuleResolutionCache) == null ? void 0 : _b.call(host);
+    } else if (host.resolveModuleNames) {
+      actualResolveModuleNamesWorker = (moduleNames, containingFile, redirectedReference, options2, containingSourceFile, reusedNames) => host.resolveModuleNames(
+        moduleNames.map(getModuleResolutionName),
+        containingFile,
+        reusedNames == null ? void 0 : reusedNames.map(getModuleResolutionName),
+        redirectedReference,
+        options2,
+        containingSourceFile
+      ).map(
+        (resolved) => resolved ? resolved.extension !== void 0 ? { resolvedModule: resolved } : { resolvedModule: { ...resolved, extension: extensionFromPath(resolved.resolvedFileName) } } : emptyResolution
+      );
+      moduleResolutionCache = (_c = host.getModuleResolutionCache) == null ? void 0 : _c.call(host);
     } else {
       moduleResolutionCache = createModuleResolutionCache(currentDirectory, getCanonicalFileName, options);
-      const loader = (moduleName, resolverMode, containingFileName, redirectedReference) => resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
-      actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => loadWithModeAwareCache(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo, loader);
+      actualResolveModuleNamesWorker = (moduleNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        moduleNames,
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
+        moduleResolutionCache,
+        createModuleResolutionLoader
+      );
     }
     let actualResolveTypeReferenceDirectiveNamesWorker;
-    if (host.resolveTypeReferenceDirectives) {
-      actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) => host.resolveTypeReferenceDirectives(Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode, resolutionInfo);
+    if (host.resolveTypeReferenceDirectiveReferences) {
+      actualResolveTypeReferenceDirectiveNamesWorker = host.resolveTypeReferenceDirectiveReferences.bind(host);
+    } else if (host.resolveTypeReferenceDirectives) {
+      actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, options2, containingSourceFile) => host.resolveTypeReferenceDirectives(
+        typeDirectiveNames.map(getTypeReferenceResolutionName),
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat
+      ).map((resolvedTypeReferenceDirective) => ({ resolvedTypeReferenceDirective }));
     } else {
-      typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
-      const loader = (typesRef, containingFile, redirectedReference, resolutionMode) => resolveTypeReferenceDirective(
-        typesRef,
+      const typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
+      actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        typeDirectiveNames,
         containingFile,
-        options,
-        host,
         redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
         typeReferenceDirectiveResolutionCache,
-        resolutionMode
-      ).resolvedTypeReferenceDirective;
-      actualResolveTypeReferenceDirectiveNamesWorker = (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
+        createTypeReferenceResolutionLoader
+      );
     }
     const packageIdToSourceFile = /* @__PURE__ */ new Map();
     let sourceFileToPackageName = /* @__PURE__ */ new Map();
@@ -100548,7 +100591,7 @@ ${lanes.join("\n")}
     let projectReferenceRedirects;
     let mapFromFileToProjectReferenceRedirects;
     let mapFromToProjectReferenceRedirectSource;
-    const useSourceOfProjectReferenceRedirect = !!((_c = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _c.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
+    const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
     const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
       compilerHost: host,
       getSymlinkCache,
@@ -100559,13 +100602,13 @@ ${lanes.join("\n")}
       forEachResolvedProjectReference: forEachResolvedProjectReference2
     });
     const readFile = host.readFile.bind(host);
-    (_d = tracing) == null ? void 0 : _d.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
+    (_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
     const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
-    (_e = tracing) == null ? void 0 : _e.pop();
+    (_f = tracing) == null ? void 0 : _f.pop();
     let structureIsReused;
-    (_f = tracing) == null ? void 0 : _f.push(tracing.Phase.Program, "tryReuseStructureFromOldProgram", {});
+    (_g = tracing) == null ? void 0 : _g.push(tracing.Phase.Program, "tryReuseStructureFromOldProgram", {});
     structureIsReused = tryReuseStructureFromOldProgram();
-    (_g = tracing) == null ? void 0 : _g.pop();
+    (_h = tracing) == null ? void 0 : _h.pop();
     if (structureIsReused !== 2 /* Completely */) {
       processingDefaultLibFiles = [];
       processingOtherFiles = [];
@@ -100599,19 +100642,30 @@ ${lanes.join("\n")}
           });
         }
       }
-      (_h = tracing) == null ? void 0 : _h.push(tracing.Phase.Program, "processRootFiles", { count: rootNames.length });
+      (_i = tracing) == null ? void 0 : _i.push(tracing.Phase.Program, "processRootFiles", { count: rootNames.length });
       forEach(rootNames, (name, index) => processRootFile(name, false, false, { kind: 0 /* RootFile */, index }));
-      (_i = tracing) == null ? void 0 : _i.pop();
-      const typeReferences = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
-      if (typeReferences.length) {
-        (_j = tracing) == null ? void 0 : _j.push(tracing.Phase.Program, "processTypeReferences", { count: typeReferences.length });
+      (_j = tracing) == null ? void 0 : _j.pop();
+      automaticTypeDirectiveNames != null ? automaticTypeDirectiveNames : automaticTypeDirectiveNames = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
+      automaticTypeDirectiveResolutions = createModeAwareCache();
+      if (automaticTypeDirectiveNames.length) {
+        (_k = tracing) == null ? void 0 : _k.push(tracing.Phase.Program, "processTypeReferences", { count: automaticTypeDirectiveNames.length });
         const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
         const containingFilename = combinePaths(containingDirectory, inferredTypesContainingFile);
-        const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeReferences, containingFilename);
-        for (let i = 0; i < typeReferences.length; i++) {
-          processTypeReferenceDirective(typeReferences[i], void 0, resolutions[i], { kind: 8 /* AutomaticTypeDirectiveFile */, typeReference: typeReferences[i], packageId: (_k = resolutions[i]) == null ? void 0 : _k.packageId });
+        const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(automaticTypeDirectiveNames, containingFilename);
+        for (let i = 0; i < automaticTypeDirectiveNames.length; i++) {
+          automaticTypeDirectiveResolutions.set(automaticTypeDirectiveNames[i], void 0, resolutions[i]);
+          processTypeReferenceDirective(
+            automaticTypeDirectiveNames[i],
+            void 0,
+            resolutions[i],
+            {
+              kind: 8 /* AutomaticTypeDirectiveFile */,
+              typeReference: automaticTypeDirectiveNames[i],
+              packageId: (_m = (_l = resolutions[i]) == null ? void 0 : _l.resolvedTypeReferenceDirective) == null ? void 0 : _m.packageId
+            }
+          );
         }
-        (_l = tracing) == null ? void 0 : _l.pop();
+        (_n = tracing) == null ? void 0 : _n.pop();
       }
       if (rootNames.length && !skipDefaultLib) {
         const defaultLibraryFileName = getDefaultLibraryFileName();
@@ -100658,7 +100712,6 @@ ${lanes.join("\n")}
         }
       );
     }
-    typeReferenceDirectiveResolutionCache = void 0;
     oldProgram = void 0;
     const program = {
       getRootFileNames: () => rootNames,
@@ -100691,6 +100744,8 @@ ${lanes.join("\n")}
       getRelationCacheSizes: () => getTypeChecker().getRelationCacheSizes(),
       getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
       getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,
+      getAutomaticTypeDirectiveNames: () => automaticTypeDirectiveNames,
+      getAutomaticTypeDirectiveResolutions: () => automaticTypeDirectiveResolutions,
       isSourceFileFromExternalLibrary,
       isSourceFileDefaultLibrary,
       getSourceFileFromReference,
@@ -100700,7 +100755,6 @@ ${lanes.join("\n")}
       usesUriStyleNodeCoreModules,
       isEmittedFile,
       getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics2,
-      getResolvedModuleWithFailedLookupLocationsFromCache,
       getProjectReferences,
       getResolvedProjectReferences,
       getProjectReferenceRedirect,
@@ -100713,7 +100767,7 @@ ${lanes.join("\n")}
       readFile,
       directoryExists,
       getSymlinkCache,
-      realpath: (_m = host.realpath) == null ? void 0 : _m.bind(host),
+      realpath: (_o = host.realpath) == null ? void 0 : _o.bind(host),
       useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
       getFileIncludeReasons: () => fileReasons,
       structureIsReused,
@@ -100727,6 +100781,8 @@ ${lanes.join("\n")}
         case 0 /* FilePreprocessingReferencedDiagnostic */:
           const { file, pos, end } = getReferencedFileLocation(getSourceFileByPath, diagnostic.reason);
           return programDiagnostics.add(createFileDiagnostic(file, Debug.checkDefined(pos), Debug.checkDefined(end) - pos, diagnostic.diagnostic, ...diagnostic.args || emptyArray));
+        case 2 /* ResolutionDiagnostics */:
+          return diagnostic.diagnostics.forEach((d) => programDiagnostics.add(d));
         default:
           Debug.assertNever(diagnostic);
       }
@@ -100734,32 +100790,30 @@ ${lanes.join("\n")}
     verifyCompilerOptions();
     mark("afterProgram");
     measure("Program", "beforeProgram", "afterProgram");
-    (_n = tracing) == null ? void 0 : _n.pop();
+    (_p = tracing) == null ? void 0 : _p.pop();
     return program;
-    function addResolutionDiagnostics(list) {
-      if (!list)
+    function addResolutionDiagnostics(resolution) {
+      var _a3;
+      if (!((_a3 = resolution.resolutionDiagnostics) == null ? void 0 : _a3.length))
         return;
-      for (const elem of list) {
-        programDiagnostics.add(elem);
-      }
+      (fileProcessingDiagnostics != null ? fileProcessingDiagnostics : fileProcessingDiagnostics = []).push({
+        kind: 2 /* ResolutionDiagnostics */,
+        diagnostics: resolution.resolutionDiagnostics
+      });
     }
-    function pullDiagnosticsFromCache(names, containingFile) {
-      var _a3;
-      if (!moduleResolutionCache)
+    function addResolutionDiagnosticsFromResolutionOrCache(containingFile, name, resolution, mode) {
+      if (host.resolveModuleNameLiterals || !host.resolveModuleNames)
+        return addResolutionDiagnostics(resolution);
+      if (!moduleResolutionCache || isExternalModuleNameRelative(name))
         return;
       const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
       const containingDir = getDirectoryPath(containingFileName);
       const redirectedReference = getRedirectReferenceForResolution(containingFile);
-      for (const n of names) {
-        const mode = getResolutionMode(n, containingFile);
-        const name = getResolutionName(n);
-        if (isExternalModuleNameRelative(name))
-          continue;
-        const diags = (_a3 = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) == null ? void 0 : _a3.resolutionDiagnostics;
-        addResolutionDiagnostics(diags);
-      }
+      const fromCache = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir);
+      if (fromCache)
+        addResolutionDiagnostics(fromCache);
     }
-    function resolveModuleNamesWorker(moduleNames, containingFile, resolutionInfo) {
+    function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
       var _a3, _b2;
       if (!moduleNames.length)
         return emptyArray;
@@ -100767,23 +100821,22 @@ ${lanes.join("\n")}
       const redirectedReference = getRedirectReferenceForResolution(containingFile);
       (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveModuleNamesWorker", { containingFileName });
       mark("beforeResolveModule");
-      const result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo);
+      const result = actualResolveModuleNamesWorker(moduleNames, containingFileName, redirectedReference, options, containingFile, reusedNames);
       mark("afterResolveModule");
       measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
       (_b2 = tracing) == null ? void 0 : _b2.pop();
-      pullDiagnosticsFromCache(moduleNames, containingFile);
       return result;
     }
-    function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, resolutionInfo) {
+    function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, reusedNames) {
       var _a3, _b2;
       if (!typeDirectiveNames.length)
         return [];
+      const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
       const containingFileName = !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
-      const redirectedReference = !isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : void 0;
-      const containingFileMode = !isString(containingFile) ? containingFile.impliedNodeFormat : void 0;
+      const redirectedReference = containingSourceFile && getRedirectReferenceForResolution(containingSourceFile);
       (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
       mark("beforeResolveTypeReference");
-      const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode, resolutionInfo);
+      const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, options, containingSourceFile, reusedNames);
       mark("afterResolveTypeReference");
       measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
       (_b2 = tracing) == null ? void 0 : _b2.pop();
@@ -100829,9 +100882,6 @@ ${lanes.join("\n")}
       }
       return libs.length + 2;
     }
-    function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) {
-      return moduleResolutionCache && resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode);
-    }
     function toPath3(fileName) {
       return toPath(fileName, currentDirectory, getCanonicalFileName);
     }
@@ -100860,6 +100910,7 @@ ${lanes.join("\n")}
       return classifiableNames;
     }
     function resolveModuleNamesReusingOldState(moduleNames, file) {
+      var _a3;
       if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
         return resolveModuleNamesWorker(moduleNames, file, void 0);
       }
@@ -100875,24 +100926,24 @@ ${lanes.join("\n")}
       let unknownModuleNames;
       let result;
       let reusedNames;
-      const predictedToResolveToAmbientModuleMarker = {};
+      const predictedToResolveToAmbientModuleMarker = emptyResolution;
       for (let i = 0; i < moduleNames.length; i++) {
         const moduleName = moduleNames[i];
         if (file === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path)) {
           const mode = getModeForUsageLocation(file, moduleName);
-          const oldResolvedModule = getResolvedModule(oldSourceFile, moduleName.text, mode);
-          if (oldResolvedModule) {
+          const oldResolution = (_a3 = oldSourceFile.resolvedModules) == null ? void 0 : _a3.get(moduleName.text, mode);
+          if (oldResolution == null ? void 0 : oldResolution.resolvedModule) {
             if (isTraceEnabled(options, host)) {
               trace(
                 host,
-                oldResolvedModule.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
+                oldResolution.resolvedModule.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
                 moduleName.text,
                 getNormalizedAbsolutePath(file.originalFileName, currentDirectory),
-                oldResolvedModule.resolvedFileName,
-                oldResolvedModule.packageId && packageIdToString(oldResolvedModule.packageId)
+                oldResolution.resolvedModule.resolvedFileName,
+                oldResolution.resolvedModule.packageId && packageIdToString(oldResolution.resolvedModule.packageId)
               );
             }
-            (result != null ? result : result = new Array(moduleNames.length))[i] = oldResolvedModule;
+            (result != null ? result : result = new Array(moduleNames.length))[i] = oldResolution;
             (reusedNames != null ? reusedNames : reusedNames = []).push(moduleName);
             continue;
           }
@@ -100912,18 +100963,14 @@ ${lanes.join("\n")}
           (unknownModuleNames != null ? unknownModuleNames : unknownModuleNames = []).push(moduleName);
         }
       }
-      const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, { names: unknownModuleNames, reusedNames }) : emptyArray;
+      const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames) : emptyArray;
       if (!result) {
         Debug.assert(resolutions.length === moduleNames.length);
         return resolutions;
       }
       let j = 0;
       for (let i = 0; i < result.length; i++) {
-        if (result[i]) {
-          if (result[i] === predictedToResolveToAmbientModuleMarker) {
-            result[i] = void 0;
-          }
-        } else {
+        if (!result[i]) {
           result[i] = resolutions[j];
           j++;
         }
@@ -100947,6 +100994,7 @@ ${lanes.join("\n")}
       }
     }
     function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
+      var _a3;
       if (structureIsReused === 0 /* Not */) {
         return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, void 0);
       }
@@ -100955,7 +101003,7 @@ ${lanes.join("\n")}
         if (oldSourceFile !== containingFile && containingFile.resolvedTypeReferenceDirectiveNames) {
           const result2 = [];
           for (const typeDirectiveName of typeDirectiveNames) {
-            const resolvedTypeReferenceDirective = containingFile.resolvedTypeReferenceDirectiveNames.get(getResolutionName(typeDirectiveName), typeDirectiveName.resolutionMode || containingFile.impliedNodeFormat);
+            const resolvedTypeReferenceDirective = containingFile.resolvedTypeReferenceDirectiveNames.get(getTypeReferenceResolutionName(typeDirectiveName), getModeForFileReference(typeDirectiveName, containingFile.impliedNodeFormat));
             result2.push(resolvedTypeReferenceDirective);
           }
           return result2;
@@ -100969,21 +101017,21 @@ ${lanes.join("\n")}
       for (let i = 0; i < typeDirectiveNames.length; i++) {
         const entry = typeDirectiveNames[i];
         if (canReuseResolutions) {
-          const typeDirectiveName = getResolutionName(entry);
+          const typeDirectiveName = getTypeReferenceResolutionName(entry);
           const mode = getModeForFileReference(entry, containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat);
-          const oldResolvedTypeReferenceDirective = getResolvedTypeReferenceDirective(oldSourceFile, typeDirectiveName, mode);
-          if (oldResolvedTypeReferenceDirective) {
+          const oldResolution = (_a3 = !isString(containingFile) ? oldSourceFile == null ? void 0 : oldSourceFile.resolvedTypeReferenceDirectiveNames : oldProgram == null ? void 0 : oldProgram.getAutomaticTypeDirectiveResolutions()) == null ? void 0 : _a3.get(typeDirectiveName, mode);
+          if (oldResolution == null ? void 0 : oldResolution.resolvedTypeReferenceDirective) {
             if (isTraceEnabled(options, host)) {
               trace(
                 host,
-                oldResolvedTypeReferenceDirective.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
+                oldResolution.resolvedTypeReferenceDirective.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
                 typeDirectiveName,
                 !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile,
-                oldResolvedTypeReferenceDirective.resolvedFileName,
-                oldResolvedTypeReferenceDirective.packageId && packageIdToString(oldResolvedTypeReferenceDirective.packageId)
+                oldResolution.resolvedTypeReferenceDirective.resolvedFileName,
+                oldResolution.resolvedTypeReferenceDirective.packageId && packageIdToString(oldResolution.resolvedTypeReferenceDirective.packageId)
               );
             }
-            (result != null ? result : result = new Array(typeDirectiveNames.length))[i] = oldResolvedTypeReferenceDirective;
+            (result != null ? result : result = new Array(typeDirectiveNames.length))[i] = oldResolution;
             (reusedNames != null ? reusedNames : reusedNames = []).push(entry);
             continue;
           }
@@ -100995,7 +101043,7 @@ ${lanes.join("\n")}
       const resolutions = resolveTypeReferenceDirectiveNamesWorker(
         unknownTypeReferenceDirectiveNames,
         containingFile,
-        { names: unknownTypeReferenceDirectiveNames, reusedNames }
+        reusedNames
       );
       if (!result) {
         Debug.assert(resolutions.length === typeDirectiveNames.length);
@@ -101031,7 +101079,7 @@ ${lanes.join("\n")}
       );
     }
     function tryReuseStructureFromOldProgram() {
-      var _a3, _b2;
+      var _a3;
       if (!oldProgram) {
         return 0 /* Not */;
       }
@@ -101141,19 +101189,19 @@ ${lanes.join("\n")}
       for (const { oldFile: oldSourceFile, newFile: newSourceFile } of modifiedSourceFiles) {
         const moduleNames = getModuleNames(newSourceFile);
         const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
-        const resolutionsChanged = hasChangesInResolutions(moduleNames, newSourceFile, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo);
+        const resolutionsChanged = hasChangesInResolutions(moduleNames, newSourceFile, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo, moduleResolutionNameAndModeGetter);
         if (resolutionsChanged) {
           structureIsReused = 1 /* SafeModules */;
-          newSourceFile.resolvedModules = zipToModeAwareCache(newSourceFile, moduleNames, resolutions);
+          newSourceFile.resolvedModules = zipToModeAwareCache(newSourceFile, moduleNames, resolutions, moduleResolutionNameAndModeGetter);
         } else {
           newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
         }
         const typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
         const typeReferenceResolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typesReferenceDirectives, newSourceFile);
-        const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, newSourceFile, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo);
+        const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, newSourceFile, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo, typeReferenceResolutionNameAndModeGetter);
         if (typeReferenceResolutionsChanged) {
           structureIsReused = 1 /* SafeModules */;
-          newSourceFile.resolvedTypeReferenceDirectiveNames = zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
+          newSourceFile.resolvedTypeReferenceDirectiveNames = zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions, typeReferenceResolutionNameAndModeGetter);
         } else {
           newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
         }
@@ -101161,9 +101209,17 @@ ${lanes.join("\n")}
       if (structureIsReused !== 2 /* Completely */) {
         return structureIsReused;
       }
-      if (changesAffectingProgramStructure(oldOptions, options) || ((_b2 = host.hasChangedAutomaticTypeDirectiveNames) == null ? void 0 : _b2.call(host))) {
+      if (changesAffectingProgramStructure(oldOptions, options)) {
         return 1 /* SafeModules */;
       }
+      if (host.hasChangedAutomaticTypeDirectiveNames) {
+        if (host.hasChangedAutomaticTypeDirectiveNames())
+          return 1 /* SafeModules */;
+      } else {
+        automaticTypeDirectiveNames = getAutomaticTypeDirectiveNames(options, host);
+        if (!arrayIsEqualTo(oldProgram.getAutomaticTypeDirectiveNames(), automaticTypeDirectiveNames))
+          return 1 /* SafeModules */;
+      }
       missingFilePaths = oldProgram.getMissingFilePaths();
       Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
       for (const newSourceFile of newSourceFiles) {
@@ -101187,6 +101243,8 @@ ${lanes.join("\n")}
       fileReasons = oldProgram.getFileIncludeReasons();
       fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
       resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
+      automaticTypeDirectiveNames = oldProgram.getAutomaticTypeDirectiveNames();
+      automaticTypeDirectiveResolutions = oldProgram.getAutomaticTypeDirectiveResolutions();
       sourceFileToPackageName = oldProgram.sourceFileToPackageName;
       redirectTargetsMap = oldProgram.redirectTargetsMap;
       usesUriStyleNodeCoreModules = oldProgram.usesUriStyleNodeCoreModules;
@@ -102130,7 +102188,8 @@ ${lanes.join("\n")}
     }
     function processTypeReferenceDirectives(file) {
       const typeDirectives = file.typeReferenceDirectives;
-      if (!typeDirectives) {
+      if (!typeDirectives.length) {
+        file.resolvedTypeReferenceDirectiveNames = void 0;
         return;
       }
       const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
@@ -102141,23 +102200,31 @@ ${lanes.join("\n")}
         setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat));
         const mode = ref.resolutionMode || file.impliedNodeFormat;
         if (mode && getEmitModuleResolutionKind(options) !== 3 /* Node16 */ && getEmitModuleResolutionKind(options) !== 99 /* NodeNext */) {
-          programDiagnostics.add(createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext));
+          (fileProcessingDiagnostics != null ? fileProcessingDiagnostics : fileProcessingDiagnostics = []).push({
+            kind: 2 /* ResolutionDiagnostics */,
+            diagnostics: [
+              createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext)
+            ]
+          });
         }
         processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });
       }
     }
-    function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
+    function processTypeReferenceDirective(typeReferenceDirective, mode, resolution, reason) {
       var _a3, _b2;
-      (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : void 0 });
-      processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
+      (_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolution.resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : void 0 });
+      processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason);
       (_b2 = tracing) == null ? void 0 : _b2.pop();
     }
-    function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
-      const previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode);
+    function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolution, reason) {
+      var _a3;
+      addResolutionDiagnostics(resolution);
+      const previousResolution = (_a3 = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode)) == null ? void 0 : _a3.resolvedTypeReferenceDirective;
       if (previousResolution && previousResolution.primary) {
         return;
       }
       let saveResolution = true;
+      const { resolvedTypeReferenceDirective } = resolution;
       if (resolvedTypeReferenceDirective) {
         if (resolvedTypeReferenceDirective.isExternalLibraryImport)
           currentNodeModulesDepth++;
@@ -102188,7 +102255,7 @@ ${lanes.join("\n")}
         addFilePreprocessingFileExplainingDiagnostic(void 0, reason, Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]);
       }
       if (saveResolution) {
-        resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective);
+        resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolution);
       }
     }
     function pathForLibFile(libFileName) {
@@ -102237,8 +102304,11 @@ ${lanes.join("\n")}
         Debug.assert(resolutions.length === moduleNames.length);
         const optionsForFile = (useSourceOfProjectReferenceRedirect ? (_a3 = getRedirectReferenceForResolution(file)) == null ? void 0 : _a3.commandLine.options : void 0) || options;
         for (let index = 0; index < moduleNames.length; index++) {
-          const resolution = resolutions[index];
-          setResolvedModule(file, moduleNames[index].text, resolution, getModeForUsageLocation(file, moduleNames[index]));
+          const resolution = resolutions[index].resolvedModule;
+          const moduleName = moduleNames[index].text;
+          const mode = getModeForUsageLocation(file, moduleNames[index]);
+          setResolvedModule(file, moduleName, resolutions[index], mode);
+          addResolutionDiagnosticsFromResolutionOrCache(file, moduleName, resolutions[index], mode);
           if (!resolution) {
             continue;
           }
@@ -102879,8 +102949,8 @@ ${lanes.join("\n")}
       if (!symlinks) {
         symlinks = createSymlinkCache(currentDirectory, getCanonicalFileName);
       }
-      if (files && resolvedTypeReferenceDirectives && !symlinks.hasProcessedResolutions()) {
-        symlinks.setSymlinksFromResolutions(files, resolvedTypeReferenceDirectives);
+      if (files && automaticTypeDirectiveResolutions && !symlinks.hasProcessedResolutions()) {
+        symlinks.setSymlinksFromResolutions(files, automaticTypeDirectiveResolutions);
       }
       return symlinks;
     }
@@ -103123,7 +103193,7 @@ ${lanes.join("\n")}
     }
     Debug.fail("should never ask for module name at index higher than possible module name");
   }
-  var ForegroundColorEscapeSequences, gutterStyleSequence, gutterSeparator, resetEscapeSequence, ellipsis, halfIndent, indent, inferredTypesContainingFile, plainJSErrors, emitSkippedWithNoDiagnostics;
+  var ForegroundColorEscapeSequences, gutterStyleSequence, gutterSeparator, resetEscapeSequence, ellipsis, halfIndent, indent, emptyResolution, moduleResolutionNameAndModeGetter, typeReferenceResolutionNameAndModeGetter, inferredTypesContainingFile, plainJSErrors, emitSkippedWithNoDiagnostics;
   var init_program = __esm({
     "src/compiler/program.ts"() {
       "use strict";
@@ -103144,6 +103214,18 @@ ${lanes.join("\n")}
       ellipsis = "...";
       halfIndent = "  ";
       indent = "    ";
+      emptyResolution = {
+        resolvedModule: void 0,
+        resolvedTypeReferenceDirective: void 0
+      };
+      moduleResolutionNameAndModeGetter = {
+        getName: getModuleResolutionName,
+        getMode: (entry, file) => getModeForUsageLocation(file, entry)
+      };
+      typeReferenceResolutionNameAndModeGetter = {
+        getName: getTypeReferenceResolutionName,
+        getMode: (entry, file) => getModeForFileReference(entry, file == null ? void 0 : file.impliedNodeFormat)
+      };
       inferredTypesContainingFile = "__inferred type names__.ts";
       plainJSErrors = /* @__PURE__ */ new Set([
         Diagnostics.Cannot_redeclare_block_scoped_variable_0.code,
@@ -103350,7 +103432,7 @@ ${lanes.join("\n")}
             }
           }
           if (sourceFile.resolvedTypeReferenceDirectiveNames) {
-            sourceFile.resolvedTypeReferenceDirectiveNames.forEach((resolvedTypeReferenceDirective) => {
+            sourceFile.resolvedTypeReferenceDirectiveNames.forEach(({ resolvedTypeReferenceDirective }) => {
               if (!resolvedTypeReferenceDirective) {
                 return;
               }
@@ -104900,9 +104982,9 @@ ${lanes.join("\n")}
       finishRecordingFilesWithChangedResolutions,
       startCachingPerDirectoryResolution,
       finishCachingPerDirectoryResolution,
-      resolveModuleNames,
-      getResolvedModuleWithFailedLookupLocationsFromCache,
-      resolveTypeReferenceDirectives,
+      resolveModuleNameLiterals,
+      resolveTypeReferenceDirectiveReferences,
+      resolveSingleModuleNameWithoutWatching,
       removeResolutionsFromProjectReferenceRedirects,
       removeResolutionsOfFile,
       hasChangedAutomaticTypeDirectiveNames: () => hasChangedAutomaticTypeDirectiveNames,
@@ -105020,14 +105102,16 @@ ${lanes.join("\n")}
       });
       hasChangedAutomaticTypeDirectiveNames = false;
     }
-    function resolveModuleName2(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
+    function resolveModuleName2(moduleName, containingFile, compilerOptions, redirectedReference, mode) {
+      var _a2;
+      const host = ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost;
       const primaryResult = resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
       if (!resolutionHost.getGlobalCache) {
         return primaryResult;
       }
       const globalCache = resolutionHost.getGlobalCache();
       if (globalCache !== void 0 && !isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && extensionIsTS(primaryResult.resolvedModule.extension))) {
-        const { resolvedModule, failedLookupLocations, affectingLocations } = loadModuleFromGlobalCache(
+        const { resolvedModule, failedLookupLocations, affectingLocations, resolutionDiagnostics } = loadModuleFromGlobalCache(
           Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName),
           resolutionHost.projectName,
           compilerOptions,
@@ -105037,49 +105121,55 @@ ${lanes.join("\n")}
         );
         if (resolvedModule) {
           primaryResult.resolvedModule = resolvedModule;
-          primaryResult.failedLookupLocations.push(...failedLookupLocations);
-          primaryResult.affectingLocations.push(...affectingLocations);
+          primaryResult.failedLookupLocations = updateResolutionField(primaryResult.failedLookupLocations, failedLookupLocations);
+          primaryResult.affectingLocations = updateResolutionField(primaryResult.affectingLocations, affectingLocations);
+          primaryResult.resolutionDiagnostics = updateResolutionField(primaryResult.resolutionDiagnostics, resolutionDiagnostics);
           return primaryResult;
         }
       }
       return primaryResult;
     }
-    function resolveTypeReferenceDirective2(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, _containingSourceFile, resolutionMode) {
-      return resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode);
+    function createModuleResolutionLoader2(containingFile, redirectedReference, options) {
+      return {
+        nameAndMode: moduleResolutionNameAndModeGetter,
+        resolve: (moduleName, resoluionMode) => resolveModuleName2(
+          moduleName,
+          containingFile,
+          options,
+          redirectedReference,
+          resoluionMode
+        )
+      };
     }
     function resolveNamesWithLocalCache({
-      names,
+      entries,
       containingFile,
+      containingSourceFile,
       redirectedReference,
+      options,
       perFileCache,
+      reusedNames,
       loader,
       getResolutionWithResolvedFileName,
       shouldRetryResolution,
-      reusedNames,
-      resolutionInfo,
-      logChanges,
-      containingSourceFile,
-      containingSourceFileMode
+      logChanges
     }) {
-      var _a2, _b, _c;
+      var _a2;
       const path = resolutionHost.toPath(containingFile);
       const resolutionsInFile = perFileCache.get(path) || perFileCache.set(path, createModeAwareCache()).get(path);
       const resolvedModules = [];
-      const compilerOptions = resolutionHost.getCompilationSettings();
       const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path);
       const program = resolutionHost.getCurrentProgram();
       const oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile);
       const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
       const seenNamesInFile = createModeAwareCache();
-      let i = 0;
-      for (const entry of containingSourceFile && resolutionInfo ? resolutionInfo.names : names) {
-        const name = getResolutionName(entry);
-        const mode = !isString(entry) ? isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode) : containingSourceFile ? getModeForResolutionAtIndex(containingSourceFile, i) : void 0;
-        i++;
+      for (const entry of entries) {
+        const name = loader.nameAndMode.getName(entry);
+        const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
         let resolution = resolutionsInFile.get(name, mode);
         if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
           const existingResolution = resolution;
-          resolution = loader(name, containingFile, compilerOptions, ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile, mode);
+          resolution = loader.resolve(name, mode);
           if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
             resolutionHost.onDiscoveredSymlink();
           }
@@ -105093,12 +105183,12 @@ ${lanes.join("\n")}
             logChanges = false;
           }
         } else {
-          const host = ((_b = resolutionHost.getCompilerHost) == null ? void 0 : _b.call(resolutionHost)) || resolutionHost;
-          if (isTraceEnabled(compilerOptions, host) && !seenNamesInFile.has(name, mode)) {
+          const host = ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost;
+          if (isTraceEnabled(options, host) && !seenNamesInFile.has(name, mode)) {
             const resolved = getResolutionWithResolvedFileName(resolution);
             trace(
               host,
-              loader === resolveModuleName2 ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved,
+              perFileCache === resolvedModuleNames ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved,
               name,
               containingFile,
               resolved == null ? void 0 : resolved.resolvedFileName,
@@ -105108,19 +105198,16 @@ ${lanes.join("\n")}
         }
         Debug.assert(resolution !== void 0 && !resolution.isInvalidated);
         seenNamesInFile.set(name, mode, true);
-        resolvedModules.push(getResolutionWithResolvedFileName(resolution));
-      }
-      if (resolutionInfo && (loader === resolveTypeReferenceDirective2 || containingSourceFile)) {
-        (_c = resolutionInfo.reusedNames) == null ? void 0 : _c.forEach((entry) => seenNamesInFile.set(
-          getResolutionName(entry),
-          !isString(entry) && isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode),
-          true
-        ));
-        reusedNames = void 0;
+        resolvedModules.push(resolution);
       }
+      reusedNames == null ? void 0 : reusedNames.forEach((entry) => seenNamesInFile.set(
+        loader.nameAndMode.getName(entry),
+        loader.nameAndMode.getMode(entry, containingSourceFile),
+        true
+      ));
       if (resolutionsInFile.size() !== seenNamesInFile.size()) {
         resolutionsInFile.forEach((resolution, name, mode) => {
-          if (!seenNamesInFile.has(name, mode) && !contains(reusedNames, name)) {
+          if (!seenNamesInFile.has(name, mode)) {
             stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
             resolutionsInFile.delete(name, mode);
           }
@@ -105145,39 +105232,53 @@ ${lanes.join("\n")}
         return oldResult.resolvedFileName === newResult.resolvedFileName;
       }
     }
-    function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) {
+    function resolveTypeReferenceDirectiveReferences(typeDirectiveReferences, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
+      var _a2;
       return resolveNamesWithLocalCache({
-        names: typeDirectiveNames,
+        entries: typeDirectiveReferences,
         containingFile,
+        containingSourceFile,
         redirectedReference,
+        options,
+        reusedNames,
         perFileCache: resolvedTypeReferenceDirectives,
-        loader: resolveTypeReferenceDirective2,
+        loader: createTypeReferenceResolutionLoader(
+          containingFile,
+          redirectedReference,
+          options,
+          ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost,
+          typeReferenceDirectiveResolutionCache
+        ),
         getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective2,
-        shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
-        containingSourceFileMode: containingFileMode,
-        resolutionInfo
+        shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0
       });
     }
-    function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile, resolutionInfo) {
+    function resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
       return resolveNamesWithLocalCache({
-        names: moduleNames,
+        entries: moduleLiterals,
         containingFile,
+        containingSourceFile,
         redirectedReference,
+        options,
+        reusedNames,
         perFileCache: resolvedModuleNames,
-        loader: resolveModuleName2,
+        loader: createModuleResolutionLoader2(
+          containingFile,
+          redirectedReference,
+          options
+        ),
         getResolutionWithResolvedFileName: getResolvedModule2,
         shouldRetryResolution: (resolution) => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
-        reusedNames,
-        resolutionInfo,
-        logChanges: logChangesWhenResolvingModule,
-        containingSourceFile
+        logChanges: logChangesWhenResolvingModule
       });
     }
-    function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
-      const cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile));
-      if (!cache)
-        return void 0;
-      return cache.get(moduleName, resolutionMode);
+    function resolveSingleModuleNameWithoutWatching(moduleName, containingFile) {
+      const path = resolutionHost.toPath(containingFile);
+      const resolutionsInFile = resolvedModuleNames.get(path);
+      const resolution = resolutionsInFile == null ? void 0 : resolutionsInFile.get(moduleName, void 0);
+      if (resolution && !resolution.isInvalidated)
+        return resolution;
+      return resolveModuleName2(moduleName, containingFile, resolutionHost.getCompilationSettings());
     }
     function isNodeModulesAtTypesDirectory(dirPath) {
       return endsWith(dirPath, "/node_modules/@types");
@@ -105256,37 +105357,39 @@ ${lanes.join("\n")}
     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)
+      if (failedLookupLocations == null ? void 0 : failedLookupLocations.length)
         resolutionsWithFailedLookups.push(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);
@@ -105404,12 +105507,14 @@ ${lanes.join("\n")}
         if (removeAtRoot) {
           removeDirectoryWatcher(rootPath);
         }
-      } else if (affectingLocations.length) {
+      } else if (affectingLocations == null ? void 0 : affectingLocations.length) {
         unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, 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) {
@@ -105531,17 +105636,19 @@ ${lanes.join("\n")}
       return invalidated;
     }
     function canInvalidateFailedLookupResolution(resolution) {
+      var _a2;
       if (canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution))
         return true;
       if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks)
         return false;
-      return resolution.failedLookupLocations.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)));
+      return (_a2 = resolution.failedLookupLocations) == null ? void 0 : _a2.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)));
     }
     function isInvalidatedFailedLookup(locationPath) {
       return (failedLookupChecks == null ? void 0 : failedLookupChecks.has(locationPath)) || firstDefinedIterator((startsWithPathChecks == null ? void 0 : startsWithPathChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => startsWith(locationPath, fileOrDirectoryPath) ? true : void 0) || firstDefinedIterator((isInDirectoryChecks == null ? void 0 : isInDirectoryChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : void 0);
     }
     function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
-      return !!affectingPathChecks && resolution.affectingLocations.some((location) => affectingPathChecks.has(location));
+      var _a2;
+      return !!affectingPathChecks && ((_a2 = resolution.affectingLocations) == null ? void 0 : _a2.some((location) => affectingPathChecks.has(location)));
     }
     function closeTypeRootsWatch() {
       clearMap(typeRootsWatches, closeFileWatcher);
@@ -106346,10 +106453,18 @@ ${lanes.join("\n")}
       configFileName ? getDirectoryPath(getNormalizedAbsolutePath(configFileName, currentDirectory)) : currentDirectory,
       false
     );
-    compilerHost.resolveModuleNames = host.resolveModuleNames ? (...args) => host.resolveModuleNames(...args) : (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile, resolutionInfo) => resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile, resolutionInfo);
-    compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ? (...args) => host.resolveTypeReferenceDirectives(...args) : (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode, resolutionInfo) => resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo);
-    compilerHost.getModuleResolutionCache = host.resolveModuleNames ? maybeBind(host, host.getModuleResolutionCache) : () => resolutionCache.getModuleResolutionCache();
-    const userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
+    compilerHost.resolveModuleNameLiterals = maybeBind(host, host.resolveModuleNameLiterals);
+    compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
+    if (!compilerHost.resolveModuleNameLiterals && !compilerHost.resolveModuleNames) {
+      compilerHost.resolveModuleNameLiterals = resolutionCache.resolveModuleNameLiterals.bind(resolutionCache);
+    }
+    compilerHost.resolveTypeReferenceDirectiveReferences = maybeBind(host, host.resolveTypeReferenceDirectiveReferences);
+    compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
+    if (!compilerHost.resolveTypeReferenceDirectiveReferences && !compilerHost.resolveTypeReferenceDirectives) {
+      compilerHost.resolveTypeReferenceDirectiveReferences = resolutionCache.resolveTypeReferenceDirectiveReferences.bind(resolutionCache);
+    }
+    compilerHost.getModuleResolutionCache = host.resolveModuleNameLiterals || host.resolveModuleNames ? maybeBind(host, host.getModuleResolutionCache) : () => resolutionCache.getModuleResolutionCache();
+    const userProvidedResolution = !!host.resolveModuleNameLiterals || !!host.resolveTypeReferenceDirectiveReferences || !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
     const customHasInvalidatedResolutions = userProvidedResolution ? maybeBind(host, host.hasInvalidatedResolutions) || returnTrue : returnFalse;
     builderProgram = readBuilderProgram(compilerOptions, compilerHost);
     synchronizeProgram();
@@ -107020,19 +107135,38 @@ ${lanes.join("\n")}
     const compilerHost = createCompilerHostFromProgramHost(host, () => state.projectCompilerOptions);
     setGetSourceFileAsHashVersioned(compilerHost);
     compilerHost.getParsedCommandLine = (fileName) => parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName));
+    compilerHost.resolveModuleNameLiterals = maybeBind(host, host.resolveModuleNameLiterals);
+    compilerHost.resolveTypeReferenceDirectiveReferences = maybeBind(host, host.resolveTypeReferenceDirectiveReferences);
     compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
     compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
     compilerHost.getModuleResolutionCache = maybeBind(host, host.getModuleResolutionCache);
-    const moduleResolutionCache = !compilerHost.resolveModuleNames ? createModuleResolutionCache(currentDirectory, getCanonicalFileName) : void 0;
-    const typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : void 0;
-    if (!compilerHost.resolveModuleNames) {
-      const loader = (moduleName, resolverMode, containingFile, redirectedReference) => resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
-      compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile, resolutionInfo) => loadWithModeAwareCache(Debug.checkEachDefined(moduleNames), Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, resolutionInfo, loader);
+    let moduleResolutionCache, typeReferenceDirectiveResolutionCache;
+    if (!compilerHost.resolveModuleNameLiterals && !compilerHost.resolveModuleNames) {
+      moduleResolutionCache = createModuleResolutionCache(currentDirectory, getCanonicalFileName);
+      compilerHost.resolveModuleNameLiterals = (moduleNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        moduleNames,
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
+        moduleResolutionCache,
+        createModuleResolutionLoader
+      );
       compilerHost.getModuleResolutionCache = () => moduleResolutionCache;
     }
-    if (!compilerHost.resolveTypeReferenceDirectives) {
-      const loader = (moduleName, containingFile, redirectedReference, containingFileMode) => resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode).resolvedTypeReferenceDirective;
-      compilerHost.resolveTypeReferenceDirectives = (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
+    if (!compilerHost.resolveTypeReferenceDirectiveReferences && !compilerHost.resolveTypeReferenceDirectives) {
+      typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
+      compilerHost.resolveTypeReferenceDirectiveReferences = (typeDirectiveNames, containingFile, redirectedReference, options2, containingSourceFile) => loadWithModeAwareCache(
+        typeDirectiveNames,
+        containingFile,
+        redirectedReference,
+        options2,
+        containingSourceFile,
+        host,
+        typeReferenceDirectiveResolutionCache,
+        createTypeReferenceResolutionLoader
+      );
     }
     compilerHost.getBuildInfo = (fileName, configFilePath) => getBuildInfo3(state, fileName, toResolvedConfigFilePath(state, configFilePath), void 0);
     const { watchFile: watchFile2, watchDirectory, writeLog } = createWatchFactory(hostWithWatch, options);
@@ -114081,13 +114215,14 @@ ${lanes.join("\n")}
     return ensurePathIsNonModuleName(combineNormal(pathA, pathB));
   }
   function getSourceFileToImport(importedModuleSymbol, importLiteral, importingSourceFile, program, host, oldToNew) {
+    var _a2;
     if (importedModuleSymbol) {
       const oldFileName = find(importedModuleSymbol.declarations, isSourceFile).fileName;
       const newFileName = oldToNew(oldFileName);
       return newFileName === void 0 ? { newFileName: oldFileName, updated: false } : { newFileName, updated: true };
     } else {
       const mode = getModeForUsageLocation(importingSourceFile, importLiteral);
-      const resolved = host.resolveModuleNames ? host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode) : program.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode);
+      const resolved = host.resolveModuleNameLiterals || !host.resolveModuleNames ? (_a2 = importingSourceFile.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, mode) : host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode);
       return getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, program.getSourceFiles());
     }
   }
@@ -116408,6 +116543,8 @@ ${lanes.join("\n")}
         getModuleResolutionCache: maybeBind(host, host.getModuleResolutionCache),
         createHash: maybeBind(host, host.createHash),
         resolveTypeReferenceDirectives: maybeBind(host, host.resolveTypeReferenceDirectives),
+        resolveModuleNameLiterals: maybeBind(host, host.resolveModuleNameLiterals),
+        resolveTypeReferenceDirectiveReferences: maybeBind(host, host.resolveTypeReferenceDirectiveReferences),
         useSourceOfProjectReferenceRedirect: maybeBind(host, host.useSourceOfProjectReferenceRedirect),
         getParsedCommandLine
       };
@@ -124604,6 +124741,7 @@ ${lanes.join("\n")}
 
   // src/services/codefixes/fixAddMissingMember.ts
   function getInfo7(sourceFile, tokenPos, errorCode, checker, program) {
+    var _a2;
     const token = getTokenAtPosition(sourceFile, tokenPos);
     const parent2 = token.parent;
     if (errorCode === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) {
@@ -124639,7 +124777,7 @@ ${lanes.join("\n")}
       return { kind: 4 /* JsxAttributes */, token, attributes, parentDeclaration: token.parent };
     }
     if (isIdentifier(token)) {
-      const type = checker.getContextualType(token);
+      const type = (_a2 = checker.getContextualType(token)) == null ? void 0 : _a2.getNonNullableType();
       if (type && getObjectFlags(type) & 16 /* Anonymous */) {
         const signature = firstOrUndefined(checker.getSignaturesOfType(type, 0 /* Call */));
         if (signature === void 0)
@@ -133509,6 +133647,7 @@ ${lanes.join("\n")}
     });
   }
   function findModuleReferences(program, sourceFiles, searchModuleSymbol) {
+    var _a2;
     const refs = [];
     const checker = program.getTypeChecker();
     for (const referencingFile of sourceFiles) {
@@ -133520,7 +133659,7 @@ ${lanes.join("\n")}
           }
         }
         for (const ref of referencingFile.typeReferenceDirectives) {
-          const referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat);
+          const referenced = (_a2 = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat)) == null ? void 0 : _a2.resolvedTypeReferenceDirective;
           if (referenced !== void 0 && referenced.resolvedFileName === searchSourceFile.fileName) {
             refs.push({ kind: "reference", referencingFile, ref });
           }
@@ -134231,7 +134370,7 @@ ${lanes.join("\n")}
       })(FindReferencesUse || {});
       ((Core2) => {
         function getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options = {}, sourceFilesSet = new Set(sourceFiles.map((f) => f.fileName))) {
-          var _a2, _b;
+          var _a2, _b, _c;
           node = getAdjustedNode(node, options);
           if (isSourceFile(node)) {
             const resolvedRef = ts_GoToDefinition_exports.getReferenceAtPosition(node, position, program);
@@ -134263,7 +134402,7 @@ ${lanes.join("\n")}
             if (!options.implementations && isStringLiteralLike(node)) {
               if (isModuleSpecifierLike(node)) {
                 const fileIncludeReasons = program.getFileIncludeReasons();
-                const referencedFileName = (_b = (_a2 = node.getSourceFile().resolvedModules) == null ? void 0 : _a2.get(node.text, getModeForUsageLocation(node.getSourceFile(), node))) == null ? void 0 : _b.resolvedFileName;
+                const referencedFileName = (_c = (_b = (_a2 = node.getSourceFile().resolvedModules) == null ? void 0 : _a2.get(node.text, getModeForUsageLocation(node.getSourceFile(), node))) == null ? void 0 : _b.resolvedModule) == null ? void 0 : _c.resolvedFileName;
                 const referencedFile = referencedFileName ? program.getSourceFile(referencedFileName) : void 0;
                 if (referencedFile) {
                   return [{ definition: { type: 4 /* String */, node }, references: getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || emptyArray }];
@@ -135508,7 +135647,7 @@ ${lanes.join("\n")}
 
   // src/services/goToDefinition.ts
   function getDefinitionAtPosition(program, sourceFile, position, searchOtherFilesOnly, stopAtAlias) {
-    var _a2;
+    var _a2, _b;
     const resolvedRef = getReferenceAtPosition(sourceFile, position, program);
     const fileReferenceDefinition = resolvedRef && [getDefinitionInfoForFileReference(resolvedRef.reference.fileName, resolvedRef.fileName, resolvedRef.unverified)] || emptyArray;
     if (resolvedRef == null ? void 0 : resolvedRef.file) {
@@ -135554,7 +135693,7 @@ ${lanes.join("\n")}
       }
     }
     if (!symbol && isModuleSpecifierLike(fallbackNode)) {
-      const ref = (_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.get(fallbackNode.text, getModeForUsageLocation(sourceFile, fallbackNode));
+      const ref = (_b = (_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.get(fallbackNode.text, getModeForUsageLocation(sourceFile, fallbackNode))) == null ? void 0 : _b.resolvedModule;
       if (ref) {
         return [{
           name: fallbackNode.text,
@@ -135632,7 +135771,7 @@ ${lanes.join("\n")}
     return getDefinitionFromSymbol(typeChecker, symbol, node);
   }
   function getReferenceAtPosition(sourceFile, position, program) {
-    var _a2, _b;
+    var _a2, _b, _c, _d;
     const referencePath = findReferenceInPosition(sourceFile.referencedFiles, position);
     if (referencePath) {
       const file = program.getSourceFileFromReference(sourceFile, referencePath);
@@ -135640,7 +135779,7 @@ ${lanes.join("\n")}
     }
     const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
     if (typeReferenceDirective) {
-      const reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat);
+      const reference = (_a2 = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat)) == null ? void 0 : _a2.resolvedTypeReferenceDirective;
       const file = reference && program.getSourceFile(reference.resolvedFileName);
       return file && { reference: typeReferenceDirective, fileName: file.fileName, file, unverified: false };
     }
@@ -135649,10 +135788,10 @@ ${lanes.join("\n")}
       const file = program.getLibFileFromReference(libReferenceDirective);
       return file && { reference: libReferenceDirective, fileName: file.fileName, file, unverified: false };
     }
-    if ((_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.size()) {
+    if ((_b = sourceFile.resolvedModules) == null ? void 0 : _b.size()) {
       const node = getTouchingToken(sourceFile, position);
       if (isModuleSpecifierLike(node) && isExternalModuleNameRelative(node.text) && sourceFile.resolvedModules.has(node.text, getModeForUsageLocation(sourceFile, node))) {
-        const verifiedFileName = (_b = sourceFile.resolvedModules.get(node.text, getModeForUsageLocation(sourceFile, node))) == null ? void 0 : _b.resolvedFileName;
+        const verifiedFileName = (_d = (_c = sourceFile.resolvedModules.get(node.text, getModeForUsageLocation(sourceFile, node))) == null ? void 0 : _c.resolvedModule) == null ? void 0 : _d.resolvedFileName;
         const fileName = verifiedFileName || resolvePath(getDirectoryPath(sourceFile.fileName), node.text);
         return {
           file: program.getSourceFile(fileName),
@@ -137882,7 +138021,8 @@ ${lanes.join("\n")}
     changes.insertNodeBefore(file, enclosingNode, ignoreSourceNewlines(newTypeNode), true);
     changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(id.name, void 0))), { leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude, trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.ExcludeWhitespace });
   }
-  function doTypedefChange(changes, program, file, name, info) {
+  function doTypedefChange(changes, context, file, name, info) {
+    var _a2;
     const { enclosingNode, selection, typeParameters } = info;
     setEmitFlags(selection, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
     const node = factory.createJSDocTypedefTag(
@@ -137904,7 +138044,7 @@ ${lanes.join("\n")}
     const jsDoc = factory.createJSDocComment(void 0, factory.createNodeArray(concatenate(templates, [node])));
     if (isJSDoc(enclosingNode)) {
       const pos = enclosingNode.getStart(file);
-      const newLineCharacter = getNewLineCharacter(program.getCompilerOptions());
+      const newLineCharacter = getNewLineOrDefaultFromHost(context.host, (_a2 = context.formatContext) == null ? void 0 : _a2.options);
       changes.insertNodeAt(file, enclosingNode.getStart(file), jsDoc, {
         suffix: newLineCharacter + newLineCharacter + file.text.slice(getPrecedingNonSpaceCharacterPosition(file.text, pos - 1), pos)
       });
@@ -137969,7 +138109,7 @@ ${lanes.join("\n")}
           return emptyArray;
         },
         getEditsForAction: function getRefactorEditsToExtractType(context, actionName2) {
-          const { file, program } = context;
+          const { file } = context;
           const info = getRangeToExtract(context);
           Debug.assert(info && !isRefactorErrorInfo(info), "Expected to find a range to extract");
           const name = getUniqueName("NewType", file);
@@ -137980,7 +138120,7 @@ ${lanes.join("\n")}
                 return doTypeAliasChange(changes, file, name, info);
               case extractToTypeDefAction.name:
                 Debug.assert(info.isJS, "Invalid actionName/JS combo");
-                return doTypedefChange(changes, program, file, name, info);
+                return doTypedefChange(changes, context, file, name, info);
               case extractToInterfaceAction.name:
                 Debug.assert(!info.isJS && !!info.typeElements, "Invalid actionName/JS combo");
                 return doInterfaceChange(changes, file, name, info);
@@ -149032,6 +149172,7 @@ ${options.prefix}` : "\n" : options.prefix
     createModuleBlock: () => createModuleBlock,
     createModuleDeclaration: () => createModuleDeclaration,
     createModuleResolutionCache: () => createModuleResolutionCache,
+    createModuleResolutionLoader: () => createModuleResolutionLoader,
     createModuleSpecifierResolutionHost: () => createModuleSpecifierResolutionHost,
     createMultiMap: () => createMultiMap,
     createNamedExports: () => createNamedExports,
@@ -149154,6 +149295,7 @@ ${options.prefix}` : "\n" : options.prefix
     createTypeQueryNode: () => createTypeQueryNode,
     createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
     createTypeReferenceNode: () => createTypeReferenceNode,
+    createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
     createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
     createUnionTypeNode: () => createUnionTypeNode,
     createUniqueName: () => createUniqueName,
@@ -149643,9 +149785,7 @@ ${options.prefix}` : "\n" : options.prefix
     getRenameLocation: () => getRenameLocation,
     getReplacementSpanForContextToken: () => getReplacementSpanForContextToken,
     getResolutionDiagnostic: () => getResolutionDiagnostic,
-    getResolutionMode: () => getResolutionMode,
     getResolutionModeOverrideForClause: () => getResolutionModeOverrideForClause,
-    getResolutionName: () => getResolutionName,
     getResolvedExternalModuleName: () => getResolvedExternalModuleName,
     getResolvedModule: () => getResolvedModule,
     getResolvedTypeReferenceDirective: () => getResolvedTypeReferenceDirective,
@@ -150464,7 +150604,6 @@ ${options.prefix}` : "\n" : options.prefix
     listFiles: () => listFiles,
     loadModuleFromGlobalCache: () => loadModuleFromGlobalCache,
     loadWithModeAwareCache: () => loadWithModeAwareCache,
-    loadWithTypeDirectiveCache: () => loadWithTypeDirectiveCache,
     makeIdentifierFromModuleName: () => makeIdentifierFromModuleName,
     makeImport: () => makeImport,
     makeImportIfNecessary: () => makeImportIfNecessary,
@@ -150496,6 +150635,7 @@ ${options.prefix}` : "\n" : options.prefix
     modifiersToFlags: () => modifiersToFlags,
     moduleOptionDeclaration: () => moduleOptionDeclaration,
     moduleResolutionIsEqualTo: () => moduleResolutionIsEqualTo,
+    moduleResolutionNameAndModeGetter: () => moduleResolutionNameAndModeGetter,
     moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations,
     moduleResolutionRespectsExports: () => moduleResolutionRespectsExports,
     moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
@@ -150872,6 +151012,7 @@ ${options.prefix}` : "\n" : options.prefix
     typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
     typeKeywords: () => typeKeywords,
     typeParameterNamePart: () => typeParameterNamePart,
+    typeReferenceResolutionNameAndModeGetter: () => typeReferenceResolutionNameAndModeGetter,
     typeToDisplayParts: () => typeToDisplayParts,
     unchangedPollThresholds: () => unchangedPollThresholds,
     unchangedTextChangeRange: () => unchangedTextChangeRange,
@@ -150987,6 +151128,7 @@ ${options.prefix}` : "\n" : options.prefix
     updatePropertyAssignment: () => updatePropertyAssignment,
     updatePropertySignature: () => updatePropertySignature,
     updateQualifiedName: () => updateQualifiedName,
+    updateResolutionField: () => updateResolutionField,
     updateRestTypeNode: () => updateRestTypeNode,
     updateReturn: () => updateReturn,
     updateSetAccessor: () => updateSetAccessor,