typescript 5.6.0-dev.20240626 → 5.6.0-dev.20240627

package/lib/typescript.js

@@ -1019,6 +1019,8 @@ __export(typescript_exports, {
   getResolvePackageJsonExports: () => getResolvePackageJsonExports,
   getResolvePackageJsonImports: () => getResolvePackageJsonImports,
   getResolvedExternalModuleName: () => getResolvedExternalModuleName,
+  getResolvedModuleFromResolution: () => getResolvedModuleFromResolution,
+  getResolvedTypeReferenceDirectiveFromResolution: () => getResolvedTypeReferenceDirectiveFromResolution,
   getRestIndicatorOfBindingOrAssignmentElement: () => getRestIndicatorOfBindingOrAssignmentElement,
   getRestParameterElementType: () => getRestParameterElementType,
   getRightMostAssignedExpression: () => getRightMostAssignedExpression,
@@ -2377,7 +2379,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240626`;
+var version = `${versionMajorMinor}.0-dev.20240627`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -16341,6 +16343,12 @@ function projectReferenceIsEqualTo(oldRef, newRef) {
 function moduleResolutionIsEqualTo(oldResolution, newResolution) {
   return oldResolution === newResolution || oldResolution.resolvedModule === newResolution.resolvedModule || !!oldResolution.resolvedModule && !!newResolution.resolvedModule && oldResolution.resolvedModule.isExternalLibraryImport === newResolution.resolvedModule.isExternalLibraryImport && oldResolution.resolvedModule.extension === newResolution.resolvedModule.extension && oldResolution.resolvedModule.resolvedFileName === newResolution.resolvedModule.resolvedFileName && oldResolution.resolvedModule.originalPath === newResolution.resolvedModule.originalPath && packageIdIsEqual(oldResolution.resolvedModule.packageId, newResolution.resolvedModule.packageId) && oldResolution.alternateResult === newResolution.alternateResult;
 }
+function getResolvedModuleFromResolution(resolution) {
+  return resolution.resolvedModule;
+}
+function getResolvedTypeReferenceDirectiveFromResolution(resolution) {
+  return resolution.resolvedTypeReferenceDirective;
+}
 function createModuleNotFoundChain(sourceFile, host, moduleReference, mode, packageName) {
   var _a;
   const alternateResult = (_a = host.getResolvedModule(sourceFile, moduleReference, mode)) == null ? void 0 : _a.alternateResult;
@@ -91777,6 +91785,7 @@ function createTypeChecker(host) {
                 }
               case 7 /* ES2022 */:
               case 99 /* ESNext */:
+              case 200 /* Preserve */:
               case 4 /* System */:
                 if (languageVersion >= 4 /* ES2017 */) {
                   break;
@@ -124793,12 +124802,18 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   }
   function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
     var _a2, _b2;
-    if (!moduleNames.length) return emptyArray;
     const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
     const redirectedReference = getRedirectReferenceForResolution(containingFile);
     (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Program, "resolveModuleNamesWorker", { containingFileName });
     mark("beforeResolveModule");
-    const result = actualResolveModuleNamesWorker(moduleNames, containingFileName, redirectedReference, options, containingFile, reusedNames);
+    const result = actualResolveModuleNamesWorker(
+      moduleNames,
+      containingFileName,
+      redirectedReference,
+      options,
+      containingFile,
+      reusedNames
+    );
     mark("afterResolveModule");
     measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
     (_b2 = tracing) == null ? void 0 : _b2.pop();
@@ -124806,13 +124821,19 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   }
   function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, reusedNames) {
     var _a2, _b2;
-    if (!typeDirectiveNames.length) return [];
     const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
     const containingFileName = !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
     const redirectedReference = containingSourceFile && getRedirectReferenceForResolution(containingSourceFile);
     (_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
     mark("beforeResolveTypeReference");
-    const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, options, containingSourceFile, reusedNames);
+    const result = actualResolveTypeReferenceDirectiveNamesWorker(
+      typeDirectiveNames,
+      containingFileName,
+      redirectedReference,
+      options,
+      containingSourceFile,
+      reusedNames
+    );
     mark("afterResolveTypeReference");
     measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
     (_b2 = tracing) == null ? void 0 : _b2.pop();
@@ -124882,144 +124903,123 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
     return classifiableNames;
   }
-  function resolveModuleNamesReusingOldState(moduleNames, file) {
-    if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
-      return resolveModuleNamesWorker(
-        moduleNames,
-        file,
-        /*reusedNames*/
-        void 0
-      );
-    }
-    let unknownModuleNames;
-    let result;
-    let reusedNames;
-    const predictedToResolveToAmbientModuleMarker = emptyResolution;
-    const oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
-    for (let i = 0; i < moduleNames.length; i++) {
-      const moduleName = moduleNames[i];
-      if (file === oldSourceFile && !hasInvalidatedResolutions(file.path)) {
-        const oldResolution = oldProgram == null ? void 0 : oldProgram.getResolvedModule(file, moduleName.text, getModeForUsageLocation2(file, moduleName));
-        if (oldResolution == null ? void 0 : oldResolution.resolvedModule) {
-          if (isTraceEnabled(options, host)) {
-            trace(
-              host,
-              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),
-              oldResolution.resolvedModule.resolvedFileName,
-              oldResolution.resolvedModule.packageId && packageIdToString(oldResolution.resolvedModule.packageId)
-            );
-          }
-          (result ?? (result = new Array(moduleNames.length)))[i] = oldResolution;
-          (reusedNames ?? (reusedNames = [])).push(moduleName);
-          continue;
-        }
-      }
-      let resolvesToAmbientModuleInNonModifiedFile = false;
-      if (contains(file.ambientModuleNames, moduleName.text)) {
-        resolvesToAmbientModuleInNonModifiedFile = true;
-        if (isTraceEnabled(options, host)) {
-          trace(host, Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName.text, getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
-        }
-      } else {
-        resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName);
-      }
-      if (resolvesToAmbientModuleInNonModifiedFile) {
-        (result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
-      } else {
-        (unknownModuleNames ?? (unknownModuleNames = [])).push(moduleName);
+  function resolveModuleNamesReusingOldState(moduleNames, containingFile) {
+    return resolveNamesReusingOldState({
+      entries: moduleNames,
+      containingFile,
+      containingSourceFile: containingFile,
+      redirectedReference: getRedirectReferenceForResolution(containingFile),
+      nameAndModeGetter: moduleResolutionNameAndModeGetter,
+      resolutionWorker: resolveModuleNamesWorker,
+      getResolutionFromOldProgram: (name, mode) => oldProgram == null ? void 0 : oldProgram.getResolvedModule(containingFile, name, mode),
+      getResolved: getResolvedModuleFromResolution,
+      canReuseResolutionsInFile: () => containingFile === (oldProgram == null ? void 0 : oldProgram.getSourceFile(containingFile.fileName)) && !hasInvalidatedResolutions(containingFile.path),
+      isEntryResolvingToAmbientModule: moduleNameResolvesToAmbientModule
+    });
+  }
+  function moduleNameResolvesToAmbientModule(moduleName, file) {
+    if (contains(file.ambientModuleNames, moduleName.text)) {
+      if (isTraceEnabled(options, host)) {
+        trace(host, Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName.text, getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
       }
+      return true;
+    } else {
+      return moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, file);
     }
-    const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames) : emptyArray;
-    if (!result) {
-      Debug.assert(resolutions.length === moduleNames.length);
-      return resolutions;
+  }
+  function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, file) {
+    var _a2;
+    const resolutionToFile = (_a2 = oldProgram == null ? void 0 : oldProgram.getResolvedModule(file, moduleName.text, getModeForUsageLocation2(file, moduleName))) == null ? void 0 : _a2.resolvedModule;
+    const resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName);
+    if (resolutionToFile && resolvedFile) {
+      return false;
     }
-    let j = 0;
-    for (let i = 0; i < result.length; i++) {
-      if (!result[i]) {
-        result[i] = resolutions[j];
-        j++;
-      }
+    const unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName.text);
+    if (!unmodifiedFile) {
+      return false;
     }
-    Debug.assert(j === resolutions.length);
-    return result;
-    function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName) {
-      var _a2;
-      const resolutionToFile = (_a2 = oldProgram == null ? void 0 : oldProgram.getResolvedModule(file, moduleName.text, getModeForUsageLocation2(file, moduleName))) == null ? void 0 : _a2.resolvedModule;
-      const resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName);
-      if (resolutionToFile && resolvedFile) {
-        return false;
-      }
-      const unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName.text);
-      if (!unmodifiedFile) {
-        return false;
-      }
-      if (isTraceEnabled(options, host)) {
-        trace(host, Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName.text, unmodifiedFile);
-      }
-      return true;
+    if (isTraceEnabled(options, host)) {
+      trace(host, Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName.text, unmodifiedFile);
     }
+    return true;
   }
   function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
-    var _a2;
-    if (structureIsReused === 0 /* Not */) {
-      return resolveTypeReferenceDirectiveNamesWorker(
-        typeDirectiveNames,
+    const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
+    return resolveNamesReusingOldState({
+      entries: typeDirectiveNames,
+      containingFile,
+      containingSourceFile,
+      redirectedReference: containingSourceFile && getRedirectReferenceForResolution(containingSourceFile),
+      nameAndModeGetter: typeReferenceResolutionNameAndModeGetter,
+      resolutionWorker: resolveTypeReferenceDirectiveNamesWorker,
+      getResolutionFromOldProgram: (name, mode) => {
+        var _a2;
+        return containingSourceFile ? oldProgram == null ? void 0 : oldProgram.getResolvedTypeReferenceDirective(containingSourceFile, name, mode) : (_a2 = oldProgram == null ? void 0 : oldProgram.getAutomaticTypeDirectiveResolutions()) == null ? void 0 : _a2.get(name, mode);
+      },
+      getResolved: getResolvedTypeReferenceDirectiveFromResolution,
+      canReuseResolutionsInFile: () => containingSourceFile ? containingSourceFile === (oldProgram == null ? void 0 : oldProgram.getSourceFile(containingSourceFile.fileName)) && !hasInvalidatedResolutions(containingSourceFile.path) : !hasInvalidatedResolutions(toPath3(containingFile))
+    });
+  }
+  function resolveNamesReusingOldState({
+    entries,
+    containingFile,
+    containingSourceFile,
+    redirectedReference,
+    nameAndModeGetter,
+    resolutionWorker,
+    getResolutionFromOldProgram,
+    getResolved,
+    canReuseResolutionsInFile,
+    isEntryResolvingToAmbientModule
+  }) {
+    if (!entries.length) return emptyArray;
+    if (structureIsReused === 0 /* Not */ && (!isEntryResolvingToAmbientModule || !containingSourceFile.ambientModuleNames.length)) {
+      return resolutionWorker(
+        entries,
         containingFile,
         /*reusedNames*/
         void 0
       );
     }
-    let unknownTypeReferenceDirectiveNames;
+    let unknownEntries;
+    let unknownEntryIndices;
     let result;
     let reusedNames;
-    const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
-    const oldSourceFile = !isString(containingFile) ? oldProgram && oldProgram.getSourceFile(containingFile.fileName) : void 0;
-    const canReuseResolutions = !isString(containingFile) ? containingFile === oldSourceFile && !hasInvalidatedResolutions(containingFile.path) : !hasInvalidatedResolutions(toPath3(containingFile));
-    for (let i = 0; i < typeDirectiveNames.length; i++) {
-      const entry = typeDirectiveNames[i];
-      if (canReuseResolutions) {
-        const typeDirectiveName = getTypeReferenceResolutionName(entry);
-        const mode = getModeForFileReference(entry, containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat);
-        const oldResolution = !isString(containingFile) ? oldProgram == null ? void 0 : oldProgram.getResolvedTypeReferenceDirective(containingFile, typeDirectiveName, mode) : (_a2 = oldProgram == null ? void 0 : oldProgram.getAutomaticTypeDirectiveResolutions()) == null ? void 0 : _a2.get(typeDirectiveName, mode);
-        if (oldResolution == null ? void 0 : oldResolution.resolvedTypeReferenceDirective) {
+    const reuseResolutions = canReuseResolutionsInFile();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (reuseResolutions) {
+        const name = nameAndModeGetter.getName(entry);
+        const mode = nameAndModeGetter.getMode(entry, containingSourceFile, (redirectedReference == null ? void 0 : redirectedReference.commandLine.options) ?? options);
+        const oldResolution = getResolutionFromOldProgram(name, mode);
+        const oldResolved = oldResolution && getResolved(oldResolution);
+        if (oldResolved) {
           if (isTraceEnabled(options, host)) {
             trace(
               host,
-              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,
-              oldResolution.resolvedTypeReferenceDirective.resolvedFileName,
-              oldResolution.resolvedTypeReferenceDirective.packageId && packageIdToString(oldResolution.resolvedTypeReferenceDirective.packageId)
+              resolutionWorker === resolveModuleNamesWorker ? oldResolved.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 : oldResolved.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,
+              name,
+              containingSourceFile ? getNormalizedAbsolutePath(containingSourceFile.originalFileName, currentDirectory) : containingFile,
+              oldResolved.resolvedFileName,
+              oldResolved.packageId && packageIdToString(oldResolved.packageId)
             );
           }
-          (result ?? (result = new Array(typeDirectiveNames.length)))[i] = oldResolution;
+          (result ?? (result = new Array(entries.length)))[i] = oldResolution;
           (reusedNames ?? (reusedNames = [])).push(entry);
           continue;
         }
       }
-      (unknownTypeReferenceDirectiveNames ?? (unknownTypeReferenceDirectiveNames = [])).push(entry);
-    }
-    if (!unknownTypeReferenceDirectiveNames) return result || emptyArray;
-    const resolutions = resolveTypeReferenceDirectiveNamesWorker(
-      unknownTypeReferenceDirectiveNames,
-      containingFile,
-      reusedNames
-    );
-    if (!result) {
-      Debug.assert(resolutions.length === typeDirectiveNames.length);
-      return resolutions;
-    }
-    let j = 0;
-    for (let i = 0; i < result.length; i++) {
-      if (!result[i]) {
-        result[i] = resolutions[j];
-        j++;
+      if (isEntryResolvingToAmbientModule == null ? void 0 : isEntryResolvingToAmbientModule(entry, containingFile)) {
+        (result ?? (result = new Array(entries.length)))[i] = emptyResolution;
+      } else {
+        (unknownEntries ?? (unknownEntries = [])).push(entry);
+        (unknownEntryIndices ?? (unknownEntryIndices = [])).push(i);
       }
     }
-    Debug.assert(j === resolutions.length);
+    if (!unknownEntries) return result;
+    const resolutions = resolutionWorker(unknownEntries, containingFile, reusedNames);
+    if (!result) return resolutions;
+    resolutions.forEach((resolution, index) => result[unknownEntryIndices[index]] = resolution);
     return result;
   }
   function canReuseProjectReferences() {
@@ -129716,12 +129716,6 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     clear: clear2,
     onChangesAffectModuleResolution
   };
-  function getResolvedModule(resolution) {
-    return resolution.resolvedModule;
-  }
-  function getResolvedTypeReferenceDirective(resolution) {
-    return resolution.resolvedTypeReferenceDirective;
-  }
   function clear2() {
     clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
     clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
@@ -129803,7 +129797,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         stopWatchFailedLookupLocationOfResolution(
           resolution,
           resolutionHost.toPath(getInferredLibraryNameResolveFrom(resolutionHost.getCompilationSettings(), getCurrentDirectory(), libFileName)),
-          getResolvedModule
+          getResolvedModuleFromResolution
         );
         resolvedLibraries.delete(libFileName);
       }
@@ -129983,7 +129977,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         getModuleResolutionHost(resolutionHost),
         typeReferenceDirectiveResolutionCache
       ),
-      getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
+      getResolutionWithResolvedFileName: getResolvedTypeReferenceDirectiveFromResolution,
       shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
       deferWatchingNonRelativeResolution: false
     });
@@ -130004,7 +129998,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         resolutionHost,
         moduleResolutionCache
       ),
-      getResolutionWithResolvedFileName: getResolvedModule,
+      getResolutionWithResolvedFileName: getResolvedModuleFromResolution,
       shouldRetryResolution: (resolution) => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
       logChanges: logChangesWhenResolvingModule,
       deferWatchingNonRelativeResolution: true
@@ -130022,17 +130016,17 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         libraryName,
         resolution,
         path,
-        getResolvedModule,
+        getResolvedModuleFromResolution,
         /*deferWatchingNonRelativeResolution*/
         false
       );
       resolvedLibraries.set(libFileName, resolution);
       if (existingResolution) {
-        stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolvedModule);
+        stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolvedModuleFromResolution);
       }
     } else {
       if (isTraceEnabled(options, host)) {
-        const resolved = getResolvedModule(resolution);
+        const resolved = getResolvedModuleFromResolution(resolution);
         trace(
           host,
           (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,
@@ -130071,27 +130065,20 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     return endsWith(dirPath, "/node_modules/@types");
   }
   function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution) {
-    var _a;
-    if (resolution.refCount) {
-      resolution.refCount++;
-      Debug.assertIsDefined(resolution.files);
-    } else {
-      resolution.refCount = 1;
-      Debug.assert(!((_a = resolution.files) == null ? void 0 : _a.size));
-      if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
-        watchFailedLookupLocationOfResolution(resolution);
-      } else {
-        nonRelativeExternalModuleResolutions.add(name, resolution);
-      }
-      const resolved = getResolutionWithResolvedFileName(resolution);
-      if (resolved && resolved.resolvedFileName) {
-        const key = resolutionHost.toPath(resolved.resolvedFileName);
-        let resolutions = resolvedFileToResolution.get(key);
-        if (!resolutions) resolvedFileToResolution.set(key, resolutions = /* @__PURE__ */ new Set());
-        resolutions.add(resolution);
-      }
-    }
     (resolution.files ?? (resolution.files = /* @__PURE__ */ new Set())).add(filePath);
+    if (resolution.files.size !== 1) return;
+    if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
+      watchFailedLookupLocationOfResolution(resolution);
+    } else {
+      nonRelativeExternalModuleResolutions.add(name, resolution);
+    }
+    const resolved = getResolutionWithResolvedFileName(resolution);
+    if (resolved && resolved.resolvedFileName) {
+      const key = resolutionHost.toPath(resolved.resolvedFileName);
+      let resolutions = resolvedFileToResolution.get(key);
+      if (!resolutions) resolvedFileToResolution.set(key, resolutions = /* @__PURE__ */ new Set());
+      resolutions.add(resolution);
+    }
   }
   function watchFailedLookupLocation(failedLookupLocation, setAtRoot) {
     const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
@@ -130116,7 +130103,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     return setAtRoot;
   }
   function watchFailedLookupLocationOfResolution(resolution) {
-    Debug.assert(!!resolution.refCount);
+    var _a;
+    Debug.assert(!!((_a = resolution.files) == null ? void 0 : _a.size));
     const { failedLookupLocations, affectingLocations, alternateResult } = resolution;
     if (!(failedLookupLocations == null ? void 0 : failedLookupLocations.length) && !(affectingLocations == null ? void 0 : affectingLocations.length) && !alternateResult) return;
     if ((failedLookupLocations == null ? void 0 : failedLookupLocations.length) || alternateResult) resolutionsWithFailedLookups.add(resolution);
@@ -130142,7 +130130,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     watchAffectingLocationsOfResolution(resolution, !(failedLookupLocations == null ? void 0 : failedLookupLocations.length) && !alternateResult);
   }
   function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
-    Debug.assert(!!resolution.refCount);
+    var _a;
+    Debug.assert(!!((_a = resolution.files) == null ? void 0 : _a.size));
     const { affectingLocations } = resolution;
     if (!(affectingLocations == null ? void 0 : affectingLocations.length)) return;
     if (addToResolutionsWithOnlyAffectingLocations) resolutionsWithOnlyAffectingLocations.add(resolution);
@@ -130329,10 +130318,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   }
   function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName, syncDirWatcherRemove) {
     Debug.checkDefined(resolution.files).delete(filePath);
-    resolution.refCount--;
-    if (resolution.refCount) {
-      return;
-    }
+    if (resolution.files.size) return;
+    resolution.files = void 0;
     const resolved = getResolutionWithResolvedFileName(resolution);
     if (resolved && resolved.resolvedFileName) {
       const key = resolutionHost.toPath(resolved.resolvedFileName);
@@ -130397,8 +130384,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     resolvedProjectReference.commandLine.fileNames.forEach((f) => removeResolutionsOfFile(resolutionHost.toPath(f)));
   }
   function removeResolutionsOfFile(filePath, syncDirWatcherRemove) {
-    removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule, syncDirWatcherRemove);
-    removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective, syncDirWatcherRemove);
+    removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModuleFromResolution, syncDirWatcherRemove);
+    removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirectiveFromResolution, syncDirWatcherRemove);
   }
   function invalidateResolutions(resolutions, canInvalidate) {
     if (!resolutions) return false;
@@ -179640,6 +179627,8 @@ __export(ts_exports2, {
   getResolvePackageJsonExports: () => getResolvePackageJsonExports,
   getResolvePackageJsonImports: () => getResolvePackageJsonImports,
   getResolvedExternalModuleName: () => getResolvedExternalModuleName,
+  getResolvedModuleFromResolution: () => getResolvedModuleFromResolution,
+  getResolvedTypeReferenceDirectiveFromResolution: () => getResolvedTypeReferenceDirectiveFromResolution,
   getRestIndicatorOfBindingOrAssignmentElement: () => getRestIndicatorOfBindingOrAssignmentElement,
   getRestParameterElementType: () => getRestParameterElementType,
   getRightMostAssignedExpression: () => getRightMostAssignedExpression,
@@ -181136,20 +181125,19 @@ __export(ts_server_exports3, {
   LogLevel: () => LogLevel2,
   Msg: () => Msg,
   OpenFileInfoTelemetryEvent: () => OpenFileInfoTelemetryEvent,
-  Project: () => Project3,
+  Project: () => Project2,
   ProjectInfoTelemetryEvent: () => ProjectInfoTelemetryEvent,
   ProjectKind: () => ProjectKind,
   ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent,
   ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent,
   ProjectLoadingStartEvent: () => ProjectLoadingStartEvent,
-  ProjectService: () => ProjectService3,
+  ProjectService: () => ProjectService2,
   ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent,
   ScriptInfo: () => ScriptInfo,
   ScriptVersionCache: () => ScriptVersionCache,
   Session: () => Session3,
   TextStorage: () => TextStorage,
   ThrottledOperations: () => ThrottledOperations,
-  TypingsCache: () => TypingsCache,
   TypingsInstallerAdapter: () => TypingsInstallerAdapter,
   allFilesAreJsOrDts: () => allFilesAreJsOrDts,
   allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
@@ -182489,102 +182477,6 @@ function failIfInvalidLocation(location) {
   Debug.assert(location.offset > 0, `Expected offset to be non-${location.offset === 0 ? "zero" : "negative"}`);
 }
 
-// src/server/typingsCache.ts
-var nullTypingsInstaller = {
-  isKnownTypesPackageName: returnFalse,
-  // Should never be called because we never provide a types registry.
-  installPackage: notImplemented,
-  enqueueInstallTypingsRequest: noop,
-  attach: noop,
-  onProjectClosed: noop,
-  globalTypingsCacheLocation: void 0
-  // TODO: GH#18217
-};
-function setIsEqualTo(arr1, arr2) {
-  if (arr1 === arr2) {
-    return true;
-  }
-  if ((arr1 || emptyArray2).length === 0 && (arr2 || emptyArray2).length === 0) {
-    return true;
-  }
-  const set = /* @__PURE__ */ new Map();
-  let unique = 0;
-  for (const v of arr1) {
-    if (set.get(v) !== true) {
-      set.set(v, true);
-      unique++;
-    }
-  }
-  for (const v of arr2) {
-    const isSet = set.get(v);
-    if (isSet === void 0) {
-      return false;
-    }
-    if (isSet === true) {
-      set.set(v, false);
-      unique--;
-    }
-  }
-  return unique === 0;
-}
-function typeAcquisitionChanged(opt1, opt2) {
-  return opt1.enable !== opt2.enable || !setIsEqualTo(opt1.include, opt2.include) || !setIsEqualTo(opt1.exclude, opt2.exclude);
-}
-function compilerOptionsChanged(opt1, opt2) {
-  return getAllowJSCompilerOption(opt1) !== getAllowJSCompilerOption(opt2);
-}
-function unresolvedImportsChanged(imports1, imports2) {
-  if (imports1 === imports2) {
-    return false;
-  }
-  return !arrayIsEqualTo(imports1, imports2);
-}
-var TypingsCache = class {
-  constructor(installer) {
-    this.installer = installer;
-    this.perProjectCache = /* @__PURE__ */ new Map();
-  }
-  isKnownTypesPackageName(name) {
-    return this.installer.isKnownTypesPackageName(name);
-  }
-  installPackage(options) {
-    return this.installer.installPackage(options);
-  }
-  enqueueInstallTypingsForProject(project, unresolvedImports, forceRefresh) {
-    const typeAcquisition = project.getTypeAcquisition();
-    if (!typeAcquisition || !typeAcquisition.enable) {
-      return;
-    }
-    const entry = this.perProjectCache.get(project.getProjectName());
-    if (forceRefresh || !entry || typeAcquisitionChanged(typeAcquisition, entry.typeAcquisition) || compilerOptionsChanged(project.getCompilationSettings(), entry.compilerOptions) || unresolvedImportsChanged(unresolvedImports, entry.unresolvedImports)) {
-      this.perProjectCache.set(project.getProjectName(), {
-        compilerOptions: project.getCompilationSettings(),
-        typeAcquisition,
-        typings: entry ? entry.typings : emptyArray2,
-        unresolvedImports,
-        poisoned: true
-      });
-      this.installer.enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
-    }
-  }
-  updateTypingsForProject(projectName, compilerOptions, typeAcquisition, unresolvedImports, newTypings) {
-    const typings = sort(newTypings);
-    this.perProjectCache.set(projectName, {
-      compilerOptions,
-      typeAcquisition,
-      typings,
-      unresolvedImports,
-      poisoned: false
-    });
-    return !typeAcquisition || !typeAcquisition.enable ? emptyArray2 : typings;
-  }
-  onProjectClosed(project) {
-    if (this.perProjectCache.delete(project.getProjectName())) {
-      this.installer.onProjectClosed(project);
-    }
-  }
-};
-
 // src/server/project.ts
 var ProjectKind = /* @__PURE__ */ ((ProjectKind2) => {
   ProjectKind2[ProjectKind2["Inferred"] = 0] = "Inferred";
@@ -182659,7 +182551,46 @@ function hasNoTypeScriptSource(fileNames) {
 function isGeneratedFileWatcher(watch) {
   return watch.generatedFilePath !== void 0;
 }
-var Project3 = class _Project {
+function setIsEqualTo(arr1, arr2) {
+  if (arr1 === arr2) {
+    return true;
+  }
+  if ((arr1 || emptyArray2).length === 0 && (arr2 || emptyArray2).length === 0) {
+    return true;
+  }
+  const set = /* @__PURE__ */ new Map();
+  let unique = 0;
+  for (const v of arr1) {
+    if (set.get(v) !== true) {
+      set.set(v, true);
+      unique++;
+    }
+  }
+  for (const v of arr2) {
+    const isSet = set.get(v);
+    if (isSet === void 0) {
+      return false;
+    }
+    if (isSet === true) {
+      set.set(v, false);
+      unique--;
+    }
+  }
+  return unique === 0;
+}
+function typeAcquisitionChanged(opt1, opt2) {
+  return opt1.enable !== opt2.enable || !setIsEqualTo(opt1.include, opt2.include) || !setIsEqualTo(opt1.exclude, opt2.exclude);
+}
+function compilerOptionsChanged(opt1, opt2) {
+  return getAllowJSCompilerOption(opt1) !== getAllowJSCompilerOption(opt2);
+}
+function unresolvedImportsChanged(imports1, imports2) {
+  if (imports1 === imports2) {
+    return false;
+  }
+  return !arrayIsEqualTo(imports1, imports2);
+}
+var Project2 = class _Project {
   /** @internal */
   constructor(projectName, projectKind, projectService, documentRegistry, hasExplicitListOfFiles, lastFileExceededProgramSize, compilerOptions, compileOnSaveEnabled, watchOptions, directoryStructureHost, currentDirectory) {
     this.projectKind = projectKind;
@@ -182822,18 +182753,15 @@ var Project3 = class _Project {
     return { pluginConfigEntry, resolvedModule, errorLogs };
   }
   isKnownTypesPackageName(name) {
-    return this.typingsCache.isKnownTypesPackageName(name);
+    return this.projectService.typingsInstaller.isKnownTypesPackageName(name);
   }
   installPackage(options) {
-    return this.typingsCache.installPackage({ ...options, projectName: this.projectName, projectRootPath: this.toPath(this.currentDirectory) });
+    return this.projectService.typingsInstaller.installPackage({ ...options, projectName: this.projectName, projectRootPath: this.toPath(this.currentDirectory) });
   }
   /** @internal */
   getGlobalTypingsCacheLocation() {
     return this.getGlobalCache();
   }
-  get typingsCache() {
-    return this.projectService.typingsCache;
-  }
   /** @internal */
   getSymlinkCache() {
     if (!this.symlinks) {
@@ -183236,7 +183164,8 @@ var Project3 = class _Project {
   }
   close() {
     var _a;
-    this.projectService.typingsCache.onProjectClosed(this);
+    if (this.typingsCache) this.projectService.typingsInstaller.onProjectClosed(this);
+    this.typingsCache = void 0;
     this.closeWatchingTypingLocations();
     this.cleanupProgram();
     forEach(this.externalFiles, (externalFile) => this.detachScriptInfoIfNotRoot(externalFile));
@@ -183501,7 +183430,7 @@ var Project3 = class _Project {
       if (hasNewProgram || changedFiles.length) {
         this.lastCachedUnresolvedImportsList = getUnresolvedImports(this.program, this.cachedUnresolvedImportsPerFile);
       }
-      this.projectService.typingsCache.enqueueInstallTypingsForProject(this, this.lastCachedUnresolvedImportsList, hasAddedorRemovedFiles);
+      this.enqueueInstallTypingsForProject(hasAddedorRemovedFiles);
     } else {
       this.lastCachedUnresolvedImportsList = void 0;
     }
@@ -183519,7 +183448,29 @@ var Project3 = class _Project {
     return !hasNewProgram;
   }
   /** @internal */
-  updateTypingFiles(typingFiles) {
+  enqueueInstallTypingsForProject(forceRefresh) {
+    const typeAcquisition = this.getTypeAcquisition();
+    if (!typeAcquisition || !typeAcquisition.enable || this.projectService.typingsInstaller === nullTypingsInstaller) {
+      return;
+    }
+    const entry = this.typingsCache;
+    if (forceRefresh || !entry || typeAcquisitionChanged(typeAcquisition, entry.typeAcquisition) || compilerOptionsChanged(this.getCompilationSettings(), entry.compilerOptions) || unresolvedImportsChanged(this.lastCachedUnresolvedImportsList, entry.unresolvedImports)) {
+      this.typingsCache = {
+        compilerOptions: this.getCompilationSettings(),
+        typeAcquisition,
+        unresolvedImports: this.lastCachedUnresolvedImportsList
+      };
+      this.projectService.typingsInstaller.enqueueInstallTypingsRequest(this, typeAcquisition, this.lastCachedUnresolvedImportsList);
+    }
+  }
+  /** @internal */
+  updateTypingFiles(compilerOptions, typeAcquisition, unresolvedImports, newTypings) {
+    this.typingsCache = {
+      compilerOptions,
+      typeAcquisition,
+      unresolvedImports
+    };
+    const typingFiles = !typeAcquisition || !typeAcquisition.enable ? emptyArray2 : sort(newTypings);
     if (enumerateInsertsAndDeletes(
       typingFiles,
       this.typingFiles,
@@ -184305,7 +184256,7 @@ function extractUnresolvedImportsFromSourceFile(program, file, ambientModules, c
     return unresolvedImports || emptyArray2;
   });
 }
-var InferredProject2 = class extends Project3 {
+var InferredProject2 = class extends Project2 {
   /** @internal */
   constructor(projectService, documentRegistry, compilerOptions, watchOptions, projectRootPath, currentDirectory, typeAcquisition) {
     super(
@@ -184399,7 +184350,7 @@ var InferredProject2 = class extends Project3 {
     };
   }
 };
-var AuxiliaryProject = class extends Project3 {
+var AuxiliaryProject = class extends Project2 {
   constructor(projectService, documentRegistry, compilerOptions, currentDirectory) {
     super(
       projectService.newAuxiliaryProjectName(),
@@ -184426,7 +184377,7 @@ var AuxiliaryProject = class extends Project3 {
     return;
   }
 };
-var _AutoImportProviderProject = class _AutoImportProviderProject extends Project3 {
+var _AutoImportProviderProject = class _AutoImportProviderProject extends Project2 {
   /** @internal */
   constructor(hostProject, initialRootNames, documentRegistry, compilerOptions) {
     super(
@@ -184693,7 +184644,7 @@ _AutoImportProviderProject.compilerOptionsOverrides = {
   noLib: true
 };
 var AutoImportProviderProject = _AutoImportProviderProject;
-var ConfiguredProject2 = class extends Project3 {
+var ConfiguredProject2 = class extends Project2 {
   /** @internal */
   constructor(configFileName, canonicalConfigFilePath, projectService, documentRegistry, cachedDirectoryStructureHost, pendingUpdateReason) {
     super(
@@ -184898,7 +184849,7 @@ var ConfiguredProject2 = class extends Project3 {
     updateErrorForNoInputFiles(fileNames, this.getConfigFilePath(), this.getCompilerOptions().configFile.configFileSpecs, this.projectErrors, this.canConfigFileJsonReportNoInputFiles);
   }
 };
-var ExternalProject = class extends Project3 {
+var ExternalProject = class extends Project2 {
   /** @internal */
   constructor(externalProjectName, projectService, documentRegistry, compilerOptions, lastFileExceededProgramSize, compileOnSaveEnabled, projectFilePath, watchOptions) {
     super(
@@ -185105,6 +185056,16 @@ function findProjectByName(projectName, projects) {
     }
   }
 }
+var nullTypingsInstaller = {
+  isKnownTypesPackageName: returnFalse,
+  // Should never be called because we never provide a types registry.
+  installPackage: notImplemented,
+  enqueueInstallTypingsRequest: noop,
+  attach: noop,
+  onProjectClosed: noop,
+  globalTypingsCacheLocation: void 0
+  // TODO: GH#18217
+};
 var noopConfigFileWatcher = { close: noop };
 function getConfigFileNameFromCache(info, cache) {
   if (!cache) return void 0;
@@ -185525,7 +185486,6 @@ var _ProjectService = class _ProjectService {
       this.logger.info("No types map provided; using the default");
     }
     this.typingsInstaller.attach(this);
-    this.typingsCache = new TypingsCache(this.typingsInstaller);
     this.hostConfiguration = {
       formatCodeOptions: getDefaultFormatCodeSettings(this.host.newLine),
       preferences: emptyOptions,
@@ -185618,12 +185578,15 @@ var _ProjectService = class _ProjectService {
     }
     switch (response.kind) {
       case ActionSet:
-        project.updateTypingFiles(this.typingsCache.updateTypingsForProject(response.projectName, response.compilerOptions, response.typeAcquisition, response.unresolvedImports, response.typings));
+        project.updateTypingFiles(
+          response.compilerOptions,
+          response.typeAcquisition,
+          response.unresolvedImports,
+          response.typings
+        );
         return;
       case ActionInvalidate:
-        this.typingsCache.enqueueInstallTypingsForProject(
-          project,
-          project.lastCachedUnresolvedImportsList,
+        project.enqueueInstallTypingsForProject(
           /*forceRefresh*/
           true
         );
@@ -188357,7 +188320,7 @@ Dynamic files must always be opened with service's current directory or service
       return;
     }
     if (this.host.importPlugin) {
-      const importPromise = Project3.importServicePluginAsync(
+      const importPromise = Project2.importServicePluginAsync(
         pluginConfigEntry,
         searchPaths,
         this.host,
@@ -188371,7 +188334,7 @@ Dynamic files must always be opened with service's current directory or service
     }
     this.endEnablePlugin(
       project,
-      Project3.importServicePluginSync(
+      Project2.importServicePluginSync(
         pluginConfigEntry,
         searchPaths,
         this.host,
@@ -188560,7 +188523,7 @@ Dynamic files must always be opened with service's current directory or service
 };
 /** Makes a filename safe to insert in a RegExp */
 _ProjectService.filenameEscapeRegexp = /[-/\\^$*+?.()|[\]{}]/g;
-var ProjectService3 = _ProjectService;
+var ProjectService2 = _ProjectService;
 function createIncompleteCompletionsCache() {
   let info;
   return {
@@ -189928,7 +189891,7 @@ var Session3 = class _Session {
       canUseWatchEvents: opts.canUseWatchEvents,
       incrementalVerifier: opts.incrementalVerifier
     };
-    this.projectService = new ProjectService3(settings);
+    this.projectService = new ProjectService2(settings);
     this.projectService.setPerformanceEventHandler(this.performanceEventHandler.bind(this));
     this.gcTimer = new GcTimer(
       this.host,
@@ -193093,20 +193056,19 @@ __export(ts_server_exports4, {
   LogLevel: () => LogLevel2,
   Msg: () => Msg,
   OpenFileInfoTelemetryEvent: () => OpenFileInfoTelemetryEvent,
-  Project: () => Project3,
+  Project: () => Project2,
   ProjectInfoTelemetryEvent: () => ProjectInfoTelemetryEvent,
   ProjectKind: () => ProjectKind,
   ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent,
   ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent,
   ProjectLoadingStartEvent: () => ProjectLoadingStartEvent,
-  ProjectService: () => ProjectService3,
+  ProjectService: () => ProjectService2,
   ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent,
   ScriptInfo: () => ScriptInfo,
   ScriptVersionCache: () => ScriptVersionCache,
   Session: () => Session3,
   TextStorage: () => TextStorage,
   ThrottledOperations: () => ThrottledOperations,
-  TypingsCache: () => TypingsCache,
   TypingsInstallerAdapter: () => TypingsInstallerAdapter,
   allFilesAreJsOrDts: () => allFilesAreJsOrDts,
   allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
@@ -194162,6 +194124,8 @@ if (typeof console !== "undefined") {
   getResolvePackageJsonExports,
   getResolvePackageJsonImports,
   getResolvedExternalModuleName,
+  getResolvedModuleFromResolution,
+  getResolvedTypeReferenceDirectiveFromResolution,
   getRestIndicatorOfBindingOrAssignmentElement,
   getRestParameterElementType,
   getRightMostAssignedExpression,