@typescript-deploys/pr-build 5.1.0-pr-53903-8 → 5.1.0-pr-53943-7

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230418`;
+var version = `${versionMajorMinor}.0-insiders.20230420`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -32360,7 +32360,9 @@ var Parser;
         const usedBrace = parseOptional(19 /* OpenBraceToken */);
         const pos = getNodePos();
         const expression = parsePropertyAccessEntityNameExpression();
+        scanner.setInJSDocType(true);
         const typeArguments = tryParseTypeArguments();
+        scanner.setInJSDocType(false);
         const node = factory2.createExpressionWithTypeArguments(expression, typeArguments);
         const res = finishNode(node, pos);
         if (usedBrace) {
@@ -37140,13 +37142,12 @@ function createModuleOrTypeReferenceResolutionCache(currentDirectory, getCanonic
     nonRelativeNameResolutionCache.update(options2);
   }
 }
-function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options) {
+function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache) {
   const result = createModuleOrTypeReferenceResolutionCache(
     currentDirectory,
     getCanonicalFileName,
     options,
-    /*packageJsonInfoCache*/
-    void 0,
+    packageJsonInfoCache,
     getOriginalOrResolvedModuleFileName
   );
   result.getOrCreateCacheForModuleName = (nonRelativeName, mode, redirectedReference) => result.getOrCreateCacheForNonRelativeName(nonRelativeName, mode, redirectedReference);
@@ -37161,6 +37162,12 @@ function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanoni
     getOriginalOrResolvedTypeReferenceFileName
   );
 }
+function getOptionsForLibraryResolution(options) {
+  return { moduleResolution: 2 /* Node10 */, traceResolution: options.traceResolution };
+}
+function resolveLibrary(libraryName, resolveFrom, compilerOptions, host, cache) {
+  return resolveModuleName(libraryName, resolveFrom, getOptionsForLibraryResolution(compilerOptions), host, cache);
+}
 function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
   var _a, _b, _c;
   const traceEnabled = isTraceEnabled(compilerOptions, host);
@@ -66937,7 +66944,6 @@ function createTypeChecker(host) {
       case 9 /* NumericLiteral */:
       case 10 /* BigIntLiteral */:
       case 15 /* NoSubstitutionTemplateLiteral */:
-      case 227 /* TemplateExpression */:
       case 112 /* TrueKeyword */:
       case 97 /* FalseKeyword */:
       case 106 /* NullKeyword */:
@@ -67224,18 +67230,10 @@ function createTypeChecker(host) {
   function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) {
     const managedSym = getJsxLibraryManagedAttributes(ns);
     if (managedSym) {
-      const declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
       const ctorType = getStaticTypeOfReferencedJsxConstructor(context);
-      if (managedSym.flags & 524288 /* TypeAlias */) {
-        const params = getSymbolLinks(managedSym).typeParameters;
-        if (length(params) >= 2) {
-          const args = fillMissingTypeArguments([ctorType, attributesType], params, 2, isInJSFile(context));
-          return getTypeAliasInstantiation(managedSym, args);
-        }
-      }
-      if (length(declaredManagedType.typeParameters) >= 2) {
-        const args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, isInJSFile(context));
-        return createTypeReference(declaredManagedType, args);
+      const result = instantiateAliasOrInterfaceWithDefaults(managedSym, isInJSFile(context), ctorType, attributesType);
+      if (result) {
+        return result;
       }
     }
     return attributesType;
@@ -68122,6 +68120,9 @@ function createTypeChecker(host) {
   function getJsxLibraryManagedAttributes(jsxNamespace) {
     return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* Type */);
   }
+  function getJsxElementTypeSymbol(jsxNamespace) {
+    return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.ElementType, 788968 /* Type */);
+  }
   function getJsxElementPropertiesName(jsxNamespace) {
     return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
   }
@@ -68228,11 +68229,32 @@ function createTypeChecker(host) {
     }
   }
   function getJsxElementTypeTypeAt(location) {
-    const type = getJsxType(JsxNames.ElementType, location);
-    if (isErrorType(type))
+    const ns = getJsxNamespaceAt(location);
+    if (!ns)
+      return void 0;
+    const sym = getJsxElementTypeSymbol(ns);
+    if (!sym)
+      return void 0;
+    const type = instantiateAliasOrInterfaceWithDefaults(sym, isInJSFile(location));
+    if (!type || isErrorType(type))
       return void 0;
     return type;
   }
+  function instantiateAliasOrInterfaceWithDefaults(managedSym, inJs, ...typeArguments) {
+    const declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
+    if (managedSym.flags & 524288 /* TypeAlias */) {
+      const params = getSymbolLinks(managedSym).typeParameters;
+      if (length(params) >= typeArguments.length) {
+        const args = fillMissingTypeArguments(typeArguments, params, typeArguments.length, inJs);
+        return length(args) === 0 ? declaredManagedType : getTypeAliasInstantiation(managedSym, args);
+      }
+    }
+    if (length(declaredManagedType.typeParameters) >= typeArguments.length) {
+      const args = fillMissingTypeArguments(typeArguments, declaredManagedType.typeParameters, typeArguments.length, inJs);
+      return createTypeReference(declaredManagedType, args);
+    }
+    return void 0;
+  }
   function getJsxIntrinsicTagNamesAt(location) {
     const intrinsics = getJsxType(JsxNames.IntrinsicElements, location);
     return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
@@ -113128,6 +113150,25 @@ function forEachProjectReference(projectReferences, resolvedProjectReferences, c
   }
 }
 var inferredTypesContainingFile = "__inferred type names__.ts";
+function getInferredLibraryNameResolveFrom(options, currentDirectory, libFileName) {
+  const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : currentDirectory;
+  return combinePaths(containingDirectory, `__lib_node_modules_lookup_${libFileName}__.ts`);
+}
+function getLibraryNameFromLibFileName(libFileName) {
+  const components = libFileName.split(".");
+  let path = components[1];
+  let i = 2;
+  while (components[i] && components[i] !== "d") {
+    path += (i === 2 ? "/" : "-") + components[i];
+    i++;
+  }
+  return "@typescript/lib-" + path;
+}
+function getLibFileNameFromLibReference(libReference) {
+  const libName = toFileNameLowerCase(libReference.fileName);
+  const libFileName = libMap.get(libName);
+  return { libName, libFileName };
+}
 function isReferencedFile(reason) {
   switch (reason == null ? void 0 : reason.kind) {
     case 3 /* Import */:
@@ -113171,7 +113212,7 @@ function getReferencedFileLocation(getSourceFileByPath, ref) {
   }
   return { file, pos, end, packageId };
 }
-function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences) {
+function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences) {
   if (!program || (hasChangedAutomaticTypeDirectiveNames == null ? void 0 : hasChangedAutomaticTypeDirectiveNames()))
     return false;
   if (!arrayIsEqualTo(program.getRootFileNames(), rootFileNames))
@@ -113186,6 +113227,8 @@ function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion,
   const currentOptions = program.getCompilerOptions();
   if (!compareDataObjects(currentOptions, newOptions))
     return false;
+  if (program.resolvedLibReferences && forEachEntry(program.resolvedLibReferences, (_value, libFileName) => hasInvalidatedLibResolutions(libFileName)))
+    return false;
   if (currentOptions.configFile && newOptions.configFile)
     return currentOptions.configFile.text === newOptions.configFile.text;
   return true;
@@ -113368,6 +113411,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   let fileProcessingDiagnostics;
   let automaticTypeDirectiveNames;
   let automaticTypeDirectiveResolutions;
+  let resolvedLibReferences;
+  let resolvedLibProcessing;
   const maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
   let currentNodeModulesDepth = 0;
   const modulesWithElidedImports = /* @__PURE__ */ new Map();
@@ -113455,6 +113500,14 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       createTypeReferenceResolutionLoader
     );
   }
+  const hasInvalidatedLibResolutions = host.hasInvalidatedLibResolutions || returnFalse;
+  let actualResolveLibrary;
+  if (host.resolveLibrary) {
+    actualResolveLibrary = host.resolveLibrary.bind(host);
+  } else {
+    const libraryResolutionCache = createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
+    actualResolveLibrary = (libraryName, resolveFrom, options2) => resolveLibrary(libraryName, resolveFrom, options2, host, libraryResolutionCache);
+  }
   const packageIdToSourceFile = /* @__PURE__ */ new Map();
   let sourceFileToPackageName = /* @__PURE__ */ new Map();
   let redirectTargetsMap = createMultiMap();
@@ -113621,6 +113674,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     );
   }
   oldProgram = void 0;
+  resolvedLibProcessing = void 0;
   const program = {
     getRootFileNames: () => rootNames,
     getSourceFile,
@@ -113662,6 +113716,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     sourceFileToPackageName,
     redirectTargetsMap,
     usesUriStyleNodeCoreModules,
+    resolvedLibReferences,
     isEmittedFile,
     getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics2,
     getProjectReferences,
@@ -114150,6 +114205,9 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     if (changesAffectingProgramStructure(oldOptions, options)) {
       return 1 /* SafeModules */;
     }
+    if (oldProgram.resolvedLibReferences && forEachEntry(oldProgram.resolvedLibReferences, (resolution, libFileName) => pathForLibFileWorker(libFileName).actual !== resolution.actual)) {
+      return 1 /* SafeModules */;
+    }
     if (host.hasChangedAutomaticTypeDirectiveNames) {
       if (host.hasChangedAutomaticTypeDirectiveNames())
         return 1 /* SafeModules */;
@@ -114186,6 +114244,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     sourceFileToPackageName = oldProgram.sourceFileToPackageName;
     redirectTargetsMap = oldProgram.redirectTargetsMap;
     usesUriStyleNodeCoreModules = oldProgram.usesUriStyleNodeCoreModules;
+    resolvedLibReferences = oldProgram.resolvedLibReferences;
     return 2 /* Completely */;
   }
   function getEmitHost(writeFileCallback) {
@@ -114295,7 +114354,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     if (!options.lib) {
       return equalityComparer(file.fileName, getDefaultLibraryFileName());
     } else {
-      return some(options.lib, (libFileName) => equalityComparer(file.fileName, pathForLibFile(libFileName)));
+      return some(options.lib, (libFileName) => equalityComparer(file.fileName, resolvedLibReferences.get(libFileName).actual));
     }
   }
   function getTypeChecker() {
@@ -114886,11 +114945,10 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
   }
   function getLibFileFromReference(ref) {
-    const libName = toFileNameLowerCase(ref.fileName);
-    const libFileName = libMap.get(libName);
-    if (libFileName) {
-      return getSourceFile(pathForLibFile(libFileName));
-    }
+    var _a2;
+    const { libFileName } = getLibFileNameFromLibReference(ref);
+    const actualFileName = libFileName && ((_a2 = resolvedLibReferences == null ? void 0 : resolvedLibReferences.get(libFileName)) == null ? void 0 : _a2.actual);
+    return actualFileName !== void 0 ? getSourceFile(actualFileName) : void 0;
   }
   function getSourceFileFromReference(referencingFile, ref) {
     return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), getSourceFile);
@@ -115315,25 +115373,55 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
   }
   function pathForLibFile(libFileName) {
-    const components = libFileName.split(".");
-    let path = components[1];
-    let i = 2;
-    while (components[i] && components[i] !== "d") {
-      path += (i === 2 ? "/" : "-") + components[i];
-      i++;
-    }
-    const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : currentDirectory;
-    const resolveFrom = combinePaths(containingDirectory, `__lib_node_modules_lookup_${libFileName}__.ts`);
-    const localOverrideModuleResult = resolveModuleName("@typescript/lib-" + path, resolveFrom, { moduleResolution: 2 /* Node10 */, traceResolution: options.traceResolution }, host, moduleResolutionCache);
-    if (localOverrideModuleResult == null ? void 0 : localOverrideModuleResult.resolvedModule) {
-      return localOverrideModuleResult.resolvedModule.resolvedFileName;
-    }
-    return combinePaths(defaultLibraryPath, libFileName);
+    const existing = resolvedLibReferences == null ? void 0 : resolvedLibReferences.get(libFileName);
+    if (existing)
+      return existing.actual;
+    const result = pathForLibFileWorker(libFileName);
+    (resolvedLibReferences ?? (resolvedLibReferences = /* @__PURE__ */ new Map())).set(libFileName, result);
+    return result.actual;
+  }
+  function pathForLibFileWorker(libFileName) {
+    var _a2, _b2, _c2, _d2, _e2;
+    const existing = resolvedLibProcessing == null ? void 0 : resolvedLibProcessing.get(libFileName);
+    if (existing)
+      return existing;
+    if (structureIsReused !== 0 /* Not */ && oldProgram && !hasInvalidatedLibResolutions(libFileName)) {
+      const oldResolution = (_a2 = oldProgram.resolvedLibReferences) == null ? void 0 : _a2.get(libFileName);
+      if (oldResolution) {
+        if (oldResolution.resolution && isTraceEnabled(options, host)) {
+          const libraryName2 = getLibraryNameFromLibFileName(libFileName);
+          const resolveFrom2 = getInferredLibraryNameResolveFrom(options, currentDirectory, libFileName);
+          trace(
+            host,
+            oldResolution.resolution.resolvedModule ? oldResolution.resolution.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 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved,
+            libraryName2,
+            getNormalizedAbsolutePath(resolveFrom2, currentDirectory),
+            (_b2 = oldResolution.resolution.resolvedModule) == null ? void 0 : _b2.resolvedFileName,
+            ((_c2 = oldResolution.resolution.resolvedModule) == null ? void 0 : _c2.packageId) && packageIdToString(oldResolution.resolution.resolvedModule.packageId)
+          );
+        }
+        (resolvedLibProcessing ?? (resolvedLibProcessing = /* @__PURE__ */ new Map())).set(libFileName, oldResolution);
+        return oldResolution;
+      }
+    }
+    const libraryName = getLibraryNameFromLibFileName(libFileName);
+    const resolveFrom = getInferredLibraryNameResolveFrom(options, currentDirectory, libFileName);
+    (_d2 = tracing) == null ? void 0 : _d2.push(tracing.Phase.Program, "resolveLibrary", { resolveFrom });
+    mark("beforeResolveLibrary");
+    const resolution = actualResolveLibrary(libraryName, resolveFrom, options, libFileName);
+    mark("afterResolveLibrary");
+    measure("ResolveLibrary", "beforeResolveLibrary", "afterResolveLibrary");
+    (_e2 = tracing) == null ? void 0 : _e2.pop();
+    const result = {
+      resolution,
+      actual: resolution.resolvedModule ? resolution.resolvedModule.resolvedFileName : combinePaths(defaultLibraryPath, libFileName)
+    };
+    (resolvedLibProcessing ?? (resolvedLibProcessing = /* @__PURE__ */ new Map())).set(libFileName, result);
+    return result;
   }
   function processLibReferenceDirectives(file) {
     forEach(file.libReferenceDirectives, (libReference, index) => {
-      const libName = toFileNameLowerCase(libReference.fileName);
-      const libFileName = libMap.get(libName);
+      const { libName, libFileName } = getLibFileNameFromLibReference(libReference);
       if (libFileName) {
         processRootFile(
           pathForLibFile(libFileName),
@@ -118300,7 +118388,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   let failedLookupChecks;
   let startsWithPathChecks;
   let isInDirectoryChecks;
-  let allResolutionsAreInvalidated = false;
+  let allModuleAndTypeResolutionsAreInvalidated = false;
   const getCurrentDirectory = memoize(() => resolutionHost.getCurrentDirectory());
   const cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost();
   const resolvedModuleNames = /* @__PURE__ */ new Map();
@@ -118316,6 +118404,13 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     resolutionHost.getCompilationSettings(),
     moduleResolutionCache.getPackageJsonInfoCache()
   );
+  const resolvedLibraries = /* @__PURE__ */ new Map();
+  const libraryResolutionCache = createModuleResolutionCache(
+    getCurrentDirectory(),
+    resolutionHost.getCanonicalFileName,
+    getOptionsForLibraryResolution(resolutionHost.getCompilationSettings()),
+    moduleResolutionCache.getPackageJsonInfoCache()
+  );
   const directoryWatchesOfFailedLookups = /* @__PURE__ */ new Map();
   const fileWatchesOfAffectingLocations = /* @__PURE__ */ new Map();
   const rootDir = getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory);
@@ -118332,6 +118427,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     finishCachingPerDirectoryResolution,
     resolveModuleNameLiterals,
     resolveTypeReferenceDirectiveReferences,
+    resolveLibrary: resolveLibrary2,
     resolveSingleModuleNameWithoutWatching,
     removeResolutionsFromProjectReferenceRedirects,
     removeResolutionsOfFile,
@@ -118367,16 +118463,18 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     isInDirectoryChecks = void 0;
     affectingPathChecks = void 0;
     affectingPathChecksForFile = void 0;
-    allResolutionsAreInvalidated = false;
+    allModuleAndTypeResolutionsAreInvalidated = false;
     moduleResolutionCache.clear();
     typeReferenceDirectiveResolutionCache.clear();
     moduleResolutionCache.update(resolutionHost.getCompilationSettings());
     typeReferenceDirectiveResolutionCache.update(resolutionHost.getCompilationSettings());
+    libraryResolutionCache.clear();
     impliedFormatPackageJsons.clear();
+    resolvedLibraries.clear();
     hasChangedAutomaticTypeDirectiveNames = false;
   }
   function onChangesAffectModuleResolution() {
-    allResolutionsAreInvalidated = true;
+    allModuleAndTypeResolutionsAreInvalidated = true;
     moduleResolutionCache.clearAllExceptPackageJsonInfoCache();
     typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();
     moduleResolutionCache.update(resolutionHost.getCompilationSettings());
@@ -118397,24 +118495,45 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);
     return !!value && !!value.length;
   }
-  function createHasInvalidatedResolutions(customHasInvalidatedResolutions) {
+  function createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidatedLibResolutions) {
     invalidateResolutionsOfFailedLookupLocations();
     const collected = filesWithInvalidatedResolutions;
     filesWithInvalidatedResolutions = void 0;
-    return (path) => customHasInvalidatedResolutions(path) || allResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path);
+    return {
+      hasInvalidatedResolutions: (path) => customHasInvalidatedResolutions(path) || allModuleAndTypeResolutionsAreInvalidated || !!(collected == null ? void 0 : collected.has(path)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path),
+      hasInvalidatedLibResolutions: (libFileName) => {
+        var _a;
+        return customHasInvalidatedLibResolutions(libFileName) || !!((_a = resolvedLibraries == null ? void 0 : resolvedLibraries.get(libFileName)) == null ? void 0 : _a.isInvalidated);
+      }
+    };
   }
   function startCachingPerDirectoryResolution() {
     moduleResolutionCache.clearAllExceptPackageJsonInfoCache();
     typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();
+    libraryResolutionCache.clearAllExceptPackageJsonInfoCache();
     nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
     nonRelativeExternalModuleResolutions.clear();
   }
+  function cleanupLibResolutionWatching(newProgram) {
+    resolvedLibraries.forEach((resolution, libFileName) => {
+      var _a;
+      if (!((_a = newProgram == null ? void 0 : newProgram.resolvedLibReferences) == null ? void 0 : _a.has(libFileName))) {
+        stopWatchFailedLookupLocationOfResolution(
+          resolution,
+          resolutionHost.toPath(getInferredLibraryNameResolveFrom(newProgram.getCompilerOptions(), getCurrentDirectory(), libFileName)),
+          getResolvedModule2
+        );
+        resolvedLibraries.delete(libFileName);
+      }
+    });
+  }
   function finishCachingPerDirectoryResolution(newProgram, oldProgram) {
     filesWithInvalidatedNonRelativeUnresolvedImports = void 0;
-    allResolutionsAreInvalidated = false;
+    allModuleAndTypeResolutionsAreInvalidated = false;
     nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
     nonRelativeExternalModuleResolutions.clear();
     if (newProgram !== oldProgram) {
+      cleanupLibResolutionWatching(newProgram);
       newProgram == null ? void 0 : newProgram.getSourceFiles().forEach((newFile) => {
         var _a;
         const expected = isExternalOrCommonJsModule(newFile) ? ((_a = newFile.packageJsonLocations) == null ? void 0 : _a.length) ?? 0 : 0;
@@ -118523,7 +118642,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       const name = loader.nameAndMode.getName(entry);
       const mode = loader.nameAndMode.getMode(entry, containingSourceFile);
       let resolution = resolutionsInFile.get(name, mode);
-      if (!seenNamesInFile.has(name, mode) && (allResolutionsAreInvalidated || unmatchedRedirects || !resolution || resolution.isInvalidated || // If the name is unresolved import that was invalidated, recalculate
+      if (!seenNamesInFile.has(name, mode) && (allModuleAndTypeResolutionsAreInvalidated || unmatchedRedirects || !resolution || resolution.isInvalidated || // If the name is unresolved import that was invalidated, recalculate
       hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution))) {
         const existingResolution = resolution;
         resolution = loader.resolve(name, mode);
@@ -118632,6 +118751,41 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       // Defer non relative resolution watch because we could be using ambient modules
     });
   }
+  function resolveLibrary2(libraryName, resolveFrom, options, libFileName) {
+    var _a;
+    const host = ((_a = resolutionHost.getCompilerHost) == null ? void 0 : _a.call(resolutionHost)) || resolutionHost;
+    let resolution = resolvedLibraries == null ? void 0 : resolvedLibraries.get(libFileName);
+    if (!resolution || resolution.isInvalidated) {
+      const existingResolution = resolution;
+      resolution = resolveLibrary(libraryName, resolveFrom, options, host, libraryResolutionCache);
+      const path = resolutionHost.toPath(resolveFrom);
+      watchFailedLookupLocationsOfExternalModuleResolutions(
+        libraryName,
+        resolution,
+        path,
+        getResolvedModule2,
+        /*deferWatchingNonRelativeResolution*/
+        false
+      );
+      resolvedLibraries.set(libFileName, resolution);
+      if (existingResolution) {
+        stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolvedModule2);
+      }
+    } else {
+      if (isTraceEnabled(options, host)) {
+        const resolved = getResolvedModule2(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,
+          libraryName,
+          resolveFrom,
+          resolved == null ? void 0 : resolved.resolvedFileName,
+          (resolved == null ? void 0 : resolved.packageId) && packageIdToString(resolved.packageId)
+        );
+      }
+    }
+    return resolution;
+  }
   function resolveSingleModuleNameWithoutWatching(moduleName, containingFile) {
     const path = resolutionHost.toPath(containingFile);
     const resolutionsInFile = resolvedModuleNames.get(path);
@@ -118954,9 +119108,12 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   }
   function invalidateResolutionsOfFailedLookupLocations() {
     var _a;
-    if (allResolutionsAreInvalidated) {
+    if (allModuleAndTypeResolutionsAreInvalidated) {
       affectingPathChecksForFile = void 0;
       invalidatePackageJsonMap();
+      if (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks || affectingPathChecks) {
+        invalidateResolutions(resolvedLibraries, canInvalidateFailedLookupResolution);
+      }
       failedLookupChecks = void 0;
       startsWithPathChecks = void 0;
       isInDirectoryChecks = void 0;
@@ -119833,9 +119990,11 @@ function createWatchProgram(host) {
   if (!compilerHost.resolveTypeReferenceDirectiveReferences && !compilerHost.resolveTypeReferenceDirectives) {
     compilerHost.resolveTypeReferenceDirectiveReferences = resolutionCache.resolveTypeReferenceDirectiveReferences.bind(resolutionCache);
   }
+  compilerHost.resolveLibrary = !host.resolveLibrary ? resolutionCache.resolveLibrary.bind(resolutionCache) : host.resolveLibrary.bind(host);
   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;
+  const customHasInvalidLibResolutions = host.resolveLibrary ? maybeBind(host, host.hasInvalidatedLibResolutions) || returnTrue : returnFalse;
   builderProgram = readBuilderProgram(compilerOptions, compilerHost);
   synchronizeProgram();
   watchConfigFileWildCardDirectories();
@@ -119900,7 +120059,7 @@ function createWatchProgram(host) {
         resolutionCache.onChangesAffectModuleResolution();
       }
     }
-    const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions);
+    const { hasInvalidatedResolutions, hasInvalidatedLibResolutions } = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions, customHasInvalidLibResolutions);
     const {
       originalReadFile,
       originalFileExists,
@@ -119909,7 +120068,7 @@ function createWatchProgram(host) {
       originalWriteFile,
       readFileWithCache
     } = changeCompilerHostLikeToUseCache(compilerHost, toPath3);
-    if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path) => getSourceVersion(path, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+    if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, (path) => getSourceVersion(path, readFileWithCache), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
       if (hasChangedConfigFileParsingErrors) {
         if (reportFileChangeDetectedOnCreateProgram) {
           reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
@@ -119930,7 +120089,7 @@ function createWatchProgram(host) {
       if (reportFileChangeDetectedOnCreateProgram) {
         reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
       }
-      createNewProgram(hasInvalidatedResolutions);
+      createNewProgram(hasInvalidatedResolutions, hasInvalidatedLibResolutions);
     }
     reportFileChangeDetectedOnCreateProgram = false;
     if (host.afterProgramCreate && program !== builderProgram) {
@@ -119943,7 +120102,7 @@ function createWatchProgram(host) {
     compilerHost.writeFile = originalWriteFile;
     return builderProgram;
   }
-  function createNewProgram(hasInvalidatedResolutions) {
+  function createNewProgram(hasInvalidatedResolutions, hasInvalidatedLibResolutions) {
     writeLog("CreatingProgramWith::");
     writeLog(`  roots: ${JSON.stringify(rootFileNames)}`);
     writeLog(`  options: ${JSON.stringify(compilerOptions)}`);
@@ -119954,6 +120113,7 @@ function createWatchProgram(host) {
     hasChangedConfigFileParsingErrors = false;
     resolutionCache.startCachingPerDirectoryResolution();
     compilerHost.hasInvalidatedResolutions = hasInvalidatedResolutions;
+    compilerHost.hasInvalidatedLibResolutions = hasInvalidatedLibResolutions;
     compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
     const oldProgram = getCurrentProgram();
     builderProgram = createProgram2(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
@@ -120506,6 +120666,7 @@ function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, optio
   compilerHost.getParsedCommandLine = (fileName) => parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName));
   compilerHost.resolveModuleNameLiterals = maybeBind(host, host.resolveModuleNameLiterals);
   compilerHost.resolveTypeReferenceDirectiveReferences = maybeBind(host, host.resolveTypeReferenceDirectiveReferences);
+  compilerHost.resolveLibrary = maybeBind(host, host.resolveLibrary);
   compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
   compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
   compilerHost.getModuleResolutionCache = maybeBind(host, host.getModuleResolutionCache);
@@ -120543,6 +120704,23 @@ function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, optio
       createTypeReferenceResolutionLoader
     );
   }
+  let libraryResolutionCache;
+  if (!compilerHost.resolveLibrary) {
+    libraryResolutionCache = createModuleResolutionCache(
+      compilerHost.getCurrentDirectory(),
+      compilerHost.getCanonicalFileName,
+      /*options*/
+      void 0,
+      moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()
+    );
+    compilerHost.resolveLibrary = (libraryName, resolveFrom, options2) => resolveLibrary(
+      libraryName,
+      resolveFrom,
+      options2,
+      host,
+      libraryResolutionCache
+    );
+  }
   compilerHost.getBuildInfo = (fileName, configFilePath) => getBuildInfo3(
     state,
     fileName,
@@ -120574,6 +120752,7 @@ function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, optio
     compilerHost,
     moduleResolutionCache,
     typeReferenceDirectiveResolutionCache,
+    libraryResolutionCache,
     // Mutable state
     buildOrder: void 0,
     readFileWithCache: (f) => host.readFile(f),
@@ -120791,7 +120970,7 @@ function enableCache(state) {
 function disableCache(state) {
   if (!state.cache)
     return;
-  const { cache, host, compilerHost, extendedConfigCache, moduleResolutionCache, typeReferenceDirectiveResolutionCache } = state;
+  const { cache, host, compilerHost, extendedConfigCache, moduleResolutionCache, typeReferenceDirectiveResolutionCache, libraryResolutionCache } = state;
   host.readFile = cache.originalReadFile;
   host.fileExists = cache.originalFileExists;
   host.directoryExists = cache.originalDirectoryExists;
@@ -120802,6 +120981,7 @@ function disableCache(state) {
   extendedConfigCache.clear();
   moduleResolutionCache == null ? void 0 : moduleResolutionCache.clear();
   typeReferenceDirectiveResolutionCache == null ? void 0 : typeReferenceDirectiveResolutionCache.clear();
+  libraryResolutionCache == null ? void 0 : libraryResolutionCache.clear();
   state.cache = void 0;
 }
 function clearProjectStatus(state, resolved) {