@typescript-deploys/pr-build 5.4.0-pr-56434-11 → 5.4.0-pr-56476-3

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20231117`;
+var version = `${versionMajorMinor}.0-insiders.20231121`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -972,23 +972,6 @@ function compareStringsCaseSensitive(a, b) {
 function getStringComparer(ignoreCase) {
   return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive;
 }
-var createUIStringComparer = (() => {
-  return createIntlCollatorStringComparer;
-  function compareWithCallback(a, b, comparer) {
-    if (a === b)
-      return 0 /* EqualTo */;
-    if (a === void 0)
-      return -1 /* LessThan */;
-    if (b === void 0)
-      return 1 /* GreaterThan */;
-    const value = comparer(a, b);
-    return value < 0 ? -1 /* LessThan */ : value > 0 ? 1 /* GreaterThan */ : 0 /* EqualTo */;
-  }
-  function createIntlCollatorStringComparer(locale) {
-    const comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare;
-    return (a, b) => compareWithCallback(a, b, comparer);
-  }
-})();
 var uiComparerCaseSensitive;
 var uiLocale;
 function setUILocale(value) {
@@ -5952,6 +5935,10 @@ var Diagnostics = {
   ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled: diag(1286, 1 /* Error */, "ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled_1286", "ESM syntax is not allowed in a CommonJS module when 'verbatimModuleSyntax' is enabled."),
   A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled: diag(1287, 1 /* Error */, "A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimM_1287", "A top-level 'export' modifier cannot be used on value declarations in a CommonJS module when 'verbatimModuleSyntax' is enabled."),
   An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabled: diag(1288, 1 /* Error */, "An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabl_1288", "An import alias cannot resolve to a type or type-only declaration when 'verbatimModuleSyntax' is enabled."),
+  _0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: diag(1289, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_1289", "'{0}' resolves to a type-only declaration and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."),
+  _0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: diag(1290, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_1290", "'{0}' resolves to a type-only declaration and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."),
+  _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: diag(1291, 1 /* Error */, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1291", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."),
+  _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: diag(1292, 1 /* Error */, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1292", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."),
   with_statements_are_not_allowed_in_an_async_function_block: diag(1300, 1 /* Error */, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
   await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, 1 /* Error */, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
   The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, 1 /* Error */, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
@@ -36800,34 +36787,39 @@ function specToDiagnostic(spec, disallowTrailingRecursion) {
     return [Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
   }
 }
-function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExcludeSpecs: exclude }, path, useCaseSensitiveFileNames2) {
-  const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
+function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExcludeSpecs: exclude }, basePath, useCaseSensitiveFileNames2) {
+  const rawExcludeRegex = getRegularExpressionForWildcard(exclude, basePath, "exclude");
   const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames2 ? "" : "i");
   const wildcardDirectories = {};
+  const wildCardKeyToPath = /* @__PURE__ */ new Map();
   if (include !== void 0) {
     const recursiveKeys = [];
     for (const file of include) {
-      const spec = normalizePath(combinePaths(path, file));
+      const spec = normalizePath(combinePaths(basePath, file));
       if (excludeRegex && excludeRegex.test(spec)) {
         continue;
       }
       const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2);
       if (match) {
-        const { key, flags } = match;
-        const existingFlags = wildcardDirectories[key];
+        const { key, path, flags } = match;
+        const existingPath = wildCardKeyToPath.get(key);
+        const existingFlags = existingPath !== void 0 ? wildcardDirectories[existingPath] : void 0;
         if (existingFlags === void 0 || existingFlags < flags) {
-          wildcardDirectories[key] = flags;
+          wildcardDirectories[existingPath !== void 0 ? existingPath : path] = flags;
+          if (existingPath === void 0)
+            wildCardKeyToPath.set(key, path);
           if (flags === 1 /* Recursive */) {
             recursiveKeys.push(key);
           }
         }
       }
     }
-    for (const key in wildcardDirectories) {
-      if (hasProperty(wildcardDirectories, key)) {
+    for (const path in wildcardDirectories) {
+      if (hasProperty(wildcardDirectories, path)) {
         for (const recursiveKey of recursiveKeys) {
-          if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames2)) {
-            delete wildcardDirectories[key];
+          const key = toCanonicalKey(path, useCaseSensitiveFileNames2);
+          if (key !== recursiveKey && containsPath(recursiveKey, key, basePath, !useCaseSensitiveFileNames2)) {
+            delete wildcardDirectories[path];
           }
         }
       }
@@ -36835,6 +36827,9 @@ function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExclu
   }
   return wildcardDirectories;
 }
+function toCanonicalKey(path, useCaseSensitiveFileNames2) {
+  return useCaseSensitiveFileNames2 ? path : toFileNameLowerCase(path);
+}
 function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
   const match = wildcardDirectoryPattern.exec(spec);
   if (match) {
@@ -36842,13 +36837,16 @@ function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
     const starWildcardIndex = spec.indexOf("*");
     const lastDirectorySeperatorIndex = spec.lastIndexOf(directorySeparator);
     return {
-      key: useCaseSensitiveFileNames2 ? match[0] : toFileNameLowerCase(match[0]),
+      key: toCanonicalKey(match[0], useCaseSensitiveFileNames2),
+      path: match[0],
       flags: questionWildcardIndex !== -1 && questionWildcardIndex < lastDirectorySeperatorIndex || starWildcardIndex !== -1 && starWildcardIndex < lastDirectorySeperatorIndex ? 1 /* Recursive */ : 0 /* None */
     };
   }
   if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
+    const path = removeTrailingDirectorySeparator(spec);
     return {
-      key: removeTrailingDirectorySeparator(useCaseSensitiveFileNames2 ? spec : toFileNameLowerCase(spec)),
+      key: toCanonicalKey(path, useCaseSensitiveFileNames2),
+      path,
       flags: 1 /* Recursive */
     };
   }
@@ -37530,22 +37528,50 @@ function createCacheWithRedirects(ownOptions, optionsToRedirectsKey) {
 }
 function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
   let cache;
-  return { getPackageJsonInfo: getPackageJsonInfo2, setPackageJsonInfo, clear: clear2, entries, getInternalMap };
+  let canonicalPathToCacheKey;
+  return { getPackageJsonInfo: getPackageJsonInfo2, setPackageJsonInfo, deletePackageJsonInfo, clear: clear2, entries };
   function getPackageJsonInfo2(packageJsonPath) {
-    return cache == null ? void 0 : cache.get(toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
+    if (!cache)
+      return void 0;
+    const absolute = getNormalizedAbsolutePath(packageJsonPath, currentDirectory);
+    const result = cache.get(absolute);
+    if (result !== void 0)
+      return result;
+    if (!canonicalPathToCacheKey)
+      return void 0;
+    const path = getCanonicalFileName(absolute);
+    if (path === absolute)
+      return void 0;
+    const cacheKey = canonicalPathToCacheKey.get(path);
+    return cacheKey !== void 0 ? cache.get(cacheKey) : void 0;
   }
   function setPackageJsonInfo(packageJsonPath, info) {
-    (cache || (cache = /* @__PURE__ */ new Map())).set(toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info);
+    const absolute = getNormalizedAbsolutePath(packageJsonPath, currentDirectory);
+    (cache || (cache = /* @__PURE__ */ new Map())).set(absolute, info);
+    const path = getCanonicalFileName(absolute);
+    if (path !== absolute) {
+      (canonicalPathToCacheKey ?? (canonicalPathToCacheKey = /* @__PURE__ */ new Map())).set(path, absolute);
+    }
+  }
+  function deletePackageJsonInfo(packageJsonPath) {
+    if (!cache)
+      return;
+    const absolute = getNormalizedAbsolutePath(packageJsonPath, currentDirectory);
+    cache.delete(absolute);
+    if (canonicalPathToCacheKey) {
+      const path = getCanonicalFileName(absolute);
+      const cacheKey = canonicalPathToCacheKey.get(path);
+      if (cacheKey !== void 0) {
+        cache.delete(cacheKey);
+        canonicalPathToCacheKey.delete(path);
+      }
+    }
   }
   function clear2() {
     cache = void 0;
   }
   function entries() {
-    const iter = cache == null ? void 0 : cache.entries();
-    return iter ? arrayFrom(iter) : [];
-  }
-  function getInternalMap() {
-    return cache;
+    return cache == null ? void 0 : cache.entries();
   }
 }
 function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
@@ -42477,7 +42503,7 @@ function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions
   if (!moduleSourceFile)
     return { moduleSpecifiers: emptyArray, computedWithoutCache };
   computedWithoutCache = true;
-  modulePaths || (modulePaths = getAllModulePathsWorker(importingSourceFile.path, moduleSourceFile.originalFileName, host));
+  modulePaths || (modulePaths = getAllModulePathsWorker(importingSourceFile.fileName, moduleSourceFile.originalFileName, host));
   const result = computeModuleSpecifiers(
     modulePaths,
     compilerOptions,
@@ -42491,7 +42517,7 @@ function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions
   return { moduleSpecifiers: result, computedWithoutCache };
 }
 function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options = {}, forAutoImport) {
-  const info = getInfo(importingSourceFile.path, host);
+  const info = getInfo(importingSourceFile.fileName, host);
   const preferences = getPreferences(userPreferences, compilerOptions, importingSourceFile);
   const existingSpecifier = forEach(modulePaths, (modulePath) => forEach(
     host.getFileIncludeReasons().get(toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)),
@@ -42555,6 +42581,7 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
   return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? pathsSpecifiers : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? redirectPathsSpecifiers : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? nodeModulesSpecifiers : Debug.checkDefined(relativeSpecifiers);
 }
 function getInfo(importingSourceFileName, host) {
+  importingSourceFileName = getNormalizedAbsolutePath(importingSourceFileName, host.getCurrentDirectory());
   const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true);
   const sourceDirectory = getDirectoryPath(importingSourceFileName);
   return { getCanonicalFileName, importingSourceFileName, sourceDirectory };
@@ -42589,7 +42616,7 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
   if (relativePreference === 3 /* ExternalNonRelative */ && !pathIsRelative(maybeNonRelative)) {
     const projectDirectory = compilerOptions.configFilePath ? toPath(getDirectoryPath(compilerOptions.configFilePath), host.getCurrentDirectory(), info.getCanonicalFileName) : info.getCanonicalFileName(host.getCurrentDirectory());
     const modulePath = toPath(moduleFileName, projectDirectory, getCanonicalFileName);
-    const sourceIsInternal = startsWith(sourceDirectory, projectDirectory);
+    const sourceIsInternal = startsWith(info.getCanonicalFileName(sourceDirectory), projectDirectory);
     const targetIsInternal = startsWith(modulePath, projectDirectory);
     if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) {
       return maybeNonRelative;
@@ -42662,8 +42689,9 @@ function forEachFileNameOfModule(importingFileName, importedFileName, host, pref
   });
   return result || (preferSymlinks ? forEach(targets, (p) => shouldFilterIgnoredPaths && containsIgnoredPath(p) ? void 0 : cb(p, p === referenceRedirect)) : void 0);
 }
-function getAllModulePaths(importingFilePath, importedFileName, host, preferences, options = {}) {
+function getAllModulePaths(importingFileName, importedFileName, host, preferences, options = {}) {
   var _a;
+  const importingFilePath = toPath(importingFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
   const importedFilePath = toPath(importedFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
   const cache = (_a = host.getModuleSpecifierCache) == null ? void 0 : _a.call(host);
   if (cache) {
@@ -42671,7 +42699,7 @@ function getAllModulePaths(importingFilePath, importedFileName, host, preference
     if (cached == null ? void 0 : cached.modulePaths)
       return cached.modulePaths;
   }
-  const modulePaths = getAllModulePathsWorker(importingFilePath, importedFileName, host);
+  const modulePaths = getAllModulePathsWorker(importingFileName, importedFileName, host);
   if (cache) {
     cache.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths);
   }
@@ -42694,7 +42722,7 @@ function getAllModulePathsWorker(importingFileName, importedFileName, host) {
     }
   );
   const sortedPaths = [];
-  for (let directory = getDirectoryPath(importingFileName); allFileNames.size !== 0; ) {
+  for (let directory = getDirectoryPath(getCanonicalFileName(importingFileName)); allFileNames.size !== 0; ) {
     const directoryStart = ensureTrailingDirectorySeparator(directory);
     let pathsInDirectory;
     allFileNames.forEach(({ path, isRedirect, isInNodeModules }, fileName) => {
@@ -42715,7 +42743,10 @@ function getAllModulePathsWorker(importingFileName, importedFileName, host) {
     directory = newDirectory;
   }
   if (allFileNames.size) {
-    const remainingPaths = arrayFrom(allFileNames.values());
+    const remainingPaths = arrayFrom(
+      allFileNames.entries(),
+      ([fileName, { isRedirect, isInNodeModules }]) => ({ path: fileName, isRedirect, isInNodeModules })
+    );
     if (remainingPaths.length > 1)
       remainingPaths.sort(comparePathsByRedirectAndNumberOfDirectorySeparators);
     sortedPaths.push(...remainingPaths);
@@ -42919,7 +42950,7 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
   }
   const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation();
   const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex));
-  if (!(startsWith(sourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) {
+  if (!(startsWith(getCanonicalFileName(sourceDirectory), pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) {
     return void 0;
   }
   const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
@@ -54214,7 +54245,12 @@ function createTypeChecker(host) {
         const checkType = type.checkType;
         const constraint = getLowerBoundOfKeyType(checkType);
         if (constraint !== checkType) {
-          return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+          return getConditionalTypeInstantiation(
+            type,
+            prependTypeMapping(type.root.checkType, constraint, type.mapper),
+            /*forConstraint*/
+            false
+          );
         }
       }
       return type;
@@ -54566,7 +54602,12 @@ function createTypeChecker(host) {
       );
       const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
       if (constraint && constraint !== type.checkType) {
-        const instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+        const instantiated = getConditionalTypeInstantiation(
+          type,
+          prependTypeMapping(type.root.checkType, constraint, type.mapper),
+          /*forConstraint*/
+          true
+        );
         if (!(instantiated.flags & 131072 /* Never */)) {
           type.resolvedConstraintOfDistributive = instantiated;
           return instantiated;
@@ -57434,19 +57475,17 @@ function createTypeChecker(host) {
       return constraintType;
     }
     const keyTypes = [];
-    if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
-      if (!isGenericIndexType(constraintType)) {
-        const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
-        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
-      } else {
+    if (isGenericIndexType(constraintType)) {
+      if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
         return getIndexTypeForGenericType(type, indexFlags);
       }
+      forEachType(constraintType, addMemberForKeyType);
+    } else if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
+      const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
+      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
     }
-    if (isGenericIndexType(constraintType)) {
-      forEachType(constraintType, addMemberForKeyType);
-    }
     const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
     if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
       return constraintType;
@@ -58131,7 +58170,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -58177,7 +58216,7 @@ function createTypeChecker(host) {
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
         if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (checkType.flags & 1 /* Any */) {
+          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -58287,7 +58326,9 @@ function createTypeChecker(host) {
       links.resolvedType = getConditionalType(
         root,
         /*mapper*/
-        void 0
+        void 0,
+        /*forConstraint*/
+        false
       );
       if (outerTypeParameters) {
         root.instantiations = /* @__PURE__ */ new Map();
@@ -59142,17 +59183,17 @@ function createTypeChecker(host) {
     result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0;
     return result;
   }
-  function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalTypeInstantiation(type, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     const root = type.root;
     if (root.outerTypeParameters) {
       const typeArguments = map(root.outerTypeParameters, (t) => getMappedType(t, mapper));
-      const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
+      const id = (forConstraint ? "C" : "") + getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
       let result = root.instantiations.get(id);
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
         const distributionType = root.isDistributive ? getMappedType(checkType, newMapper) : void 0;
-        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, aliasSymbol, aliasTypeArguments);
+        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
         root.instantiations.set(id, result);
       }
       return result;
@@ -59240,7 +59281,14 @@ function createTypeChecker(host) {
       );
     }
     if (flags & 16777216 /* Conditional */) {
-      return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
+      return getConditionalTypeInstantiation(
+        type,
+        combineTypeMappers(type.mapper, mapper),
+        /*forConstraint*/
+        false,
+        aliasSymbol,
+        aliasTypeArguments
+      );
     }
     if (flags & 33554432 /* Substitution */) {
       const newBaseType = instantiateType(type.baseType, mapper);
@@ -60884,7 +60932,7 @@ function createTypeChecker(host) {
         return relation === comparableRelation ? someTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */), intersectionState) : eachTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */), intersectionState);
       }
       if (target2.flags & 1048576 /* Union */) {
-        return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */) && !(target2.flags & 402784252 /* Primitive */));
+        return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */) && !(target2.flags & 402784252 /* Primitive */), intersectionState);
       }
       if (target2.flags & 2097152 /* Intersection */) {
         return typeRelatedToEachType(source2, target2, reportErrors2, 2 /* Target */);
@@ -60929,7 +60977,8 @@ function createTypeChecker(host) {
           sourceType,
           target2,
           /*reportErrors*/
-          false
+          false,
+          0 /* None */
         );
         if (!related) {
           return 0 /* False */;
@@ -60938,7 +60987,7 @@ function createTypeChecker(host) {
       }
       return result2;
     }
-    function typeRelatedToSomeType(source2, target2, reportErrors2) {
+    function typeRelatedToSomeType(source2, target2, reportErrors2, intersectionState) {
       const targetTypes = target2.types;
       if (target2.flags & 1048576 /* Union */) {
         if (containsType(targetTypes, source2)) {
@@ -60956,7 +61005,10 @@ function createTypeChecker(host) {
             match,
             2 /* Target */,
             /*reportErrors*/
-            false
+            false,
+            /*headMessage*/
+            void 0,
+            intersectionState
           );
           if (related) {
             return related;
@@ -60969,7 +61021,10 @@ function createTypeChecker(host) {
           type,
           2 /* Target */,
           /*reportErrors*/
-          false
+          false,
+          /*headMessage*/
+          void 0,
+          intersectionState
         );
         if (related) {
           return related;
@@ -60983,7 +61038,10 @@ function createTypeChecker(host) {
             bestMatchingType,
             2 /* Target */,
             /*reportErrors*/
-            true
+            true,
+            /*headMessage*/
+            void 0,
+            intersectionState
           );
         }
       }
@@ -61781,13 +61839,6 @@ function createTypeChecker(host) {
               return result2;
             }
           }
-        } else {
-          const distributiveConstraint = hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
-          if (distributiveConstraint) {
-            if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
-              return result2;
-            }
-          }
         }
         const defaultConstraint = getDefaultConstraintOfConditionalType(source2);
         if (defaultConstraint) {
@@ -61795,6 +61846,13 @@ function createTypeChecker(host) {
             return result2;
           }
         }
+        const distributiveConstraint = !(targetFlags & 16777216 /* Conditional */) && hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
+        if (distributiveConstraint) {
+          resetErrorInfo(saveErrorInfo);
+          if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
+            return result2;
+          }
+        }
       } else {
         if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target2) && isEmptyObjectType(source2)) {
           return -1 /* True */;
@@ -80666,10 +80724,11 @@ function createTypeChecker(host) {
         node
       ));
       if (sym) {
+        const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(sym, 111551 /* Value */);
         markAliasReferenced(sym, id);
         if (getSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
-          if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && getTypeOnlyAliasDeclaration(sym, 111551 /* Value */)) {
+          if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && typeOnlyDeclaration) {
             error(
               id,
               node.isExportEquals ? Diagnostics.An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration : Diagnostics.An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration,
@@ -80683,6 +80742,33 @@ function createTypeChecker(host) {
             idText(id)
           );
         }
+        if (!isIllegalExportDefaultInCJS && getIsolatedModules(compilerOptions) && !(sym.flags & 111551 /* Value */)) {
+          if (sym.flags & 2097152 /* Alias */ && resolveAlias(sym) !== unknownSymbol && getSymbolFlags(
+            sym,
+            /*excludeTypeOnlyMeanings*/
+            false,
+            /*excludeLocalMeanings*/
+            true
+          ) & 788968 /* Type */ && (!typeOnlyDeclaration || getSourceFileOfNode(typeOnlyDeclaration) !== getSourceFileOfNode(node))) {
+            error(
+              id,
+              node.isExportEquals ? Diagnostics._0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported : Diagnostics._0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default,
+              idText(id),
+              isolatedModulesLikeFlagName
+            );
+          } else if (typeOnlyDeclaration && getSourceFileOfNode(typeOnlyDeclaration) !== getSourceFileOfNode(node)) {
+            addTypeOnlyDeclarationRelatedInfo(
+              error(
+                id,
+                node.isExportEquals ? Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default,
+                idText(id),
+                isolatedModulesLikeFlagName
+              ),
+              typeOnlyDeclaration,
+              idText(id)
+            );
+          }
+        }
       } else {
         checkExpressionCached(id);
       }
@@ -82077,7 +82163,11 @@ function createTypeChecker(host) {
         const exportClause = node.exportClause;
         return !!exportClause && (isNamespaceExport(exportClause) || some(exportClause.elements, isValueAliasDeclaration));
       case 277 /* ExportAssignment */:
-        return node.expression && node.expression.kind === 80 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfDeclaration(node)) : true;
+        return node.expression && node.expression.kind === 80 /* Identifier */ ? isAliasResolvedToValue(
+          getSymbolOfDeclaration(node),
+          /*excludeTypeOnlyValues*/
+          true
+        ) : true;
     }
     return false;
   }
@@ -82095,7 +82185,7 @@ function createTypeChecker(host) {
     }
     const target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol));
     if (target === unknownSymbol) {
-      return true;
+      return !excludeTypeOnlyValues || !getTypeOnlyAliasDeclaration(symbol);
     }
     return !!(getSymbolFlags(
       symbol,
@@ -107928,8 +108018,8 @@ function transformDeclarations(context) {
           const specifier = getModuleSpecifier(
             options,
             currentSourceFile,
-            toPath(outputFilePath2, host.getCurrentDirectory(), host.getCanonicalFileName),
-            toPath(declFileName, host.getCurrentDirectory(), host.getCanonicalFileName),
+            getNormalizedAbsolutePath(outputFilePath2, host.getCurrentDirectory()),
+            getNormalizedAbsolutePath(declFileName, host.getCurrentDirectory()),
             host
           );
           if (!pathIsRelative(specifier)) {
@@ -115355,8 +115445,8 @@ function createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensi
     }
     const baseName = getBaseNameOfFileName(fileOrDirectory);
     const fsQueryResult = {
-      fileExists: host.fileExists(fileOrDirectoryPath),
-      directoryExists: host.directoryExists(fileOrDirectoryPath)
+      fileExists: host.fileExists(fileOrDirectory),
+      directoryExists: host.directoryExists(fileOrDirectory)
     };
     if (fsQueryResult.directoryExists || hasEntry(parentResult.sortedAndCanonicalizedDirectories, getCanonicalFileName(baseName))) {
       clearCache();
@@ -115439,11 +115529,9 @@ function cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, t
   });
 }
 function updateMissingFilePathsWatch(program, missingFileWatches, createMissingFileWatch) {
-  const missingFilePaths = program.getMissingFilePaths();
-  const newMissingFilePathMap = arrayToMap(missingFilePaths, identity, returnTrue);
   mutateMap(
     missingFileWatches,
-    newMissingFilePathMap,
+    program.getMissingFilePaths(),
     {
       // Watch the missing files
       createNewValue: createMissingFileWatch,
@@ -116270,7 +116358,8 @@ function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion,
     return false;
   if (program.getSourceFiles().some(sourceFileNotUptoDate))
     return false;
-  if (program.getMissingFilePaths().some(fileExists))
+  const missingPaths = program.getMissingFilePaths();
+  if (missingPaths && forEachEntry(missingPaths, fileExists))
     return false;
   const currentOptions = program.getCompilerOptions();
   if (!compareDataObjects(currentOptions, newOptions))
@@ -116570,7 +116659,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   let redirectTargetsMap = createMultiMap();
   let usesUriStyleNodeCoreModules = false;
   const filesByName = /* @__PURE__ */ new Map();
-  let missingFilePaths;
+  let missingFileNames = /* @__PURE__ */ new Map();
   const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? /* @__PURE__ */ new Map() : void 0;
   let resolvedProjectReferences;
   let projectReferenceRedirects;
@@ -116689,12 +116778,10 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         });
       }
     }
-    missingFilePaths = arrayFrom(mapDefinedIterator(filesByName.entries(), ([path, file]) => file === void 0 ? path : void 0));
     files = stableSort(processingDefaultLibFiles, compareDefaultLibFiles).concat(processingOtherFiles);
     processingDefaultLibFiles = void 0;
     processingOtherFiles = void 0;
   }
-  Debug.assert(!!missingFilePaths);
   if (oldProgram && host.onReleaseOldSourceFile) {
     const oldSourceFiles = oldProgram.getSourceFiles();
     for (const oldSourceFile of oldSourceFiles) {
@@ -116739,8 +116826,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     getSourceFile,
     getSourceFileByPath,
     getSourceFiles: () => files,
-    getMissingFilePaths: () => missingFilePaths,
-    // TODO: GH#18217
+    getMissingFilePaths: () => missingFileNames,
     getModuleResolutionCache: () => moduleResolutionCache,
     getFilesByNameMap: () => filesByName,
     getCompilerOptions: () => options,
@@ -117167,7 +117253,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     const newSourceFiles = [];
     const modifiedSourceFiles = [];
     structureIsReused = 2 /* Completely */;
-    if (oldProgram.getMissingFilePaths().some((missingFilePath) => host.fileExists(missingFilePath))) {
+    if (forEachEntry(oldProgram.getMissingFilePaths(), (missingFilePath) => host.fileExists(missingFilePath))) {
       return 0 /* Not */;
     }
     const oldSourceFiles = oldProgram.getSourceFiles();
@@ -117307,7 +117393,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       if (!arrayIsEqualTo(oldProgram.getAutomaticTypeDirectiveNames(), automaticTypeDirectiveNames))
         return 1 /* SafeModules */;
     }
-    missingFilePaths = oldProgram.getMissingFilePaths();
+    missingFileNames = oldProgram.getMissingFilePaths();
     Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
     for (const newSourceFile of newSourceFiles) {
       filesByName.set(newSourceFile.path, newSourceFile);
@@ -117364,7 +117450,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         const path = toPath3(f);
         if (getSourceFileByPath(path))
           return true;
-        if (contains(missingFilePaths, path))
+        if (missingFileNames.has(path))
           return false;
         return host.fileExists(f);
       },
@@ -118176,6 +118262,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           addFileToFilesByName(
             file2,
             path,
+            fileName,
             /*redirectedPath*/
             void 0
           );
@@ -118248,7 +118335,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       if (fileFromPackageId) {
         const dupFile = createRedirectedSourceFile(fileFromPackageId, file, fileName, path, toPath3(fileName), originalFileName, sourceFileOptions);
         redirectTargetsMap.add(fileFromPackageId.path, fileName);
-        addFileToFilesByName(dupFile, path, redirectedPath);
+        addFileToFilesByName(dupFile, path, fileName, redirectedPath);
         addFileIncludeReason(dupFile, reason);
         sourceFileToPackageName.set(path, packageIdToPackageName(packageId));
         processingOtherFiles.push(dupFile);
@@ -118258,7 +118345,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         sourceFileToPackageName.set(path, packageIdToPackageName(packageId));
       }
     }
-    addFileToFilesByName(file, path, redirectedPath);
+    addFileToFilesByName(file, path, fileName, redirectedPath);
     if (file) {
       sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
       file.fileName = fileName;
@@ -118298,14 +118385,21 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     if (file)
       fileReasons.add(file.path, reason);
   }
-  function addFileToFilesByName(file, path, redirectedPath) {
+  function addFileToFilesByName(file, path, fileName, redirectedPath) {
     if (redirectedPath) {
-      filesByName.set(redirectedPath, file);
-      filesByName.set(path, file || false);
+      updateFilesByNameMap(fileName, redirectedPath, file);
+      updateFilesByNameMap(fileName, path, file || false);
     } else {
-      filesByName.set(path, file);
+      updateFilesByNameMap(fileName, path, file);
     }
   }
+  function updateFilesByNameMap(fileName, path, file) {
+    filesByName.set(path, file);
+    if (file !== void 0)
+      missingFileNames.delete(path);
+    else
+      missingFileNames.set(path, fileName);
+  }
   function getProjectReferenceRedirect(fileName) {
     const referencedProject = getProjectReferenceRedirectProject(fileName);
     return referencedProject && getProjectReferenceOutputName(referencedProject, fileName);
@@ -118626,6 +118720,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           /*file*/
           void 0,
           sourceFilePath,
+          refPath,
           /*redirectedPath*/
           void 0
         );
@@ -118637,6 +118732,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       addFileToFilesByName(
         sourceFile,
         sourceFilePath,
+        refPath,
         /*redirectedPath*/
         void 0
       );
@@ -118646,6 +118742,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       addFileToFilesByName(
         sourceFile,
         sourceFilePath,
+        refPath,
         /*redirectedPath*/
         void 0
       );
@@ -122147,7 +122244,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       const watcher = {
         watcher: canWatchAffectingLocation(resolutionHost.toPath(locationToWatch)) ? resolutionHost.watchAffectingFileLocation(locationToWatch, (fileName, eventKind) => {
           cachedDirectoryStructureHost == null ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, resolutionHost.toPath(locationToWatch), eventKind);
-          invalidateAffectingFileWatcher(locationToWatch, moduleResolutionCache.getPackageJsonInfoCache().getInternalMap());
+          invalidateAffectingFileWatcher(locationToWatch, moduleResolutionCache.getPackageJsonInfoCache());
           resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
         }) : noopFileWatcher,
         resolutions: isSymlink ? 0 : resolutions,
@@ -122187,7 +122284,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     if (watcher == null ? void 0 : watcher.files)
       (affectingPathChecksForFile ?? (affectingPathChecksForFile = /* @__PURE__ */ new Set())).add(path);
     (_a = watcher == null ? void 0 : watcher.symlinks) == null ? void 0 : _a.forEach((path2) => invalidateAffectingFileWatcher(path2, packageJsonMap));
-    packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path));
+    packageJsonMap.deletePackageJsonInfo(path);
   }
   function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
     const program = resolutionHost.getCurrentProgram();
@@ -122372,9 +122469,14 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
   }
   function invalidatePackageJsonMap() {
-    const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
+    const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().entries();
     if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
-      packageJsonMap.forEach((_value, path) => isInvalidatedFailedLookup(path) ? packageJsonMap.delete(path) : void 0);
+      for (const key of packageJsonMap) {
+        const path = resolutionHost.toPath(key[0]);
+        if (isInvalidatedFailedLookup(path)) {
+          moduleResolutionCache.getPackageJsonInfoCache().deletePackageJsonInfo(key[0]);
+        }
+      }
     }
   }
   function invalidateResolutionsOfFailedLookupLocations() {
@@ -123391,7 +123493,11 @@ function createWatchProgram(host) {
     const oldProgram = getCurrentProgram();
     builderProgram = createProgram2(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
     resolutionCache.finishCachingPerDirectoryResolution(builderProgram.getProgram(), oldProgram);
-    updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = /* @__PURE__ */ new Map()), watchMissingFilePath);
+    updateMissingFilePathsWatch(
+      builderProgram.getProgram(),
+      missingFilesMap || (missingFilesMap = /* @__PURE__ */ new Map()),
+      watchMissingFilePath
+    );
     if (needsUpdateInTypeRootWatch) {
       resolutionCache.updateTypeRootsWatch();
     }
@@ -123684,8 +123790,15 @@ function createWatchProgram(host) {
       cachedDirectoryStructureHost.addOrDeleteFile(fileName, path, eventKind);
     }
   }
-  function watchMissingFilePath(missingFilePath) {
-    return (parsedConfigs == null ? void 0 : parsedConfigs.has(missingFilePath)) ? noopFileWatcher : watchFilePath(missingFilePath, missingFilePath, onMissingFileChange, 500 /* Medium */, watchOptions, WatchType.MissingFile);
+  function watchMissingFilePath(missingFilePath, missingFileName) {
+    return (parsedConfigs == null ? void 0 : parsedConfigs.has(missingFilePath)) ? noopFileWatcher : watchFilePath(
+      missingFilePath,
+      missingFileName,
+      onMissingFileChange,
+      500 /* Medium */,
+      watchOptions,
+      WatchType.MissingFile
+    );
   }
   function onMissingFileChange(fileName, eventKind, missingFilePath) {
     updateCachedSystemWithFile(fileName, missingFilePath, eventKind);
@@ -124160,6 +124273,7 @@ function createStateBuildOrder(state) {
   mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete);
   mutateMapSkippingNewValues(state.buildInfoCache, currentProjects, noopOnDelete);
   mutateMapSkippingNewValues(state.outputTimeStamps, currentProjects, noopOnDelete);
+  mutateMapSkippingNewValues(state.lastCachedPackageJsonLookups, currentProjects, noopOnDelete);
   if (state.watch) {
     mutateMapSkippingNewValues(
       state.allWatchedConfigFiles,
@@ -124408,7 +124522,7 @@ function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath,
     return withProgramOrUndefined(action) || emptyArray;
   }
   function createProgram2() {
-    var _a, _b;
+    var _a, _b, _c;
     Debug.assert(program === void 0);
     if (state.options.dry) {
       reportStatus(state, Diagnostics.A_non_dry_build_would_build_project_0, project);
@@ -124437,12 +124551,16 @@ function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath,
       config.projectReferences
     );
     if (state.watch) {
+      const entries = (_c = state.moduleResolutionCache) == null ? void 0 : _c.getPackageJsonInfoCache().entries();
       state.lastCachedPackageJsonLookups.set(
         projectPath,
-        state.moduleResolutionCache && map(
-          state.moduleResolutionCache.getPackageJsonInfoCache().entries(),
-          ([path, data]) => [state.host.realpath && data ? toPath2(state, state.host.realpath(path)) : path, data]
-        )
+        entries && new Map(arrayFrom(
+          entries,
+          ([path, data]) => {
+            path = state.host.realpath && data ? state.host.realpath(path) : path;
+            return [toPath2(state, path), path];
+          }
+        ))
       );
       state.builderPrograms.set(projectPath, program);
     }
@@ -125175,9 +125293,10 @@ function getUpToDateStatusWorker(state, project, resolvedPath) {
   const extendedConfigStatus = forEach(project.options.configFile.extendedSourceFiles || emptyArray, (configFile) => checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName));
   if (extendedConfigStatus)
     return extendedConfigStatus;
-  const dependentPackageFileStatus = forEach(
-    state.lastCachedPackageJsonLookups.get(resolvedPath) || emptyArray,
-    ([path]) => checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName)
+  const packageJsonLookups = state.lastCachedPackageJsonLookups.get(resolvedPath);
+  const dependentPackageFileStatus = packageJsonLookups && forEachEntry(
+    packageJsonLookups,
+    (path) => checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName)
   );
   if (dependentPackageFileStatus)
     return dependentPackageFileStatus;
@@ -125588,9 +125707,9 @@ function watchPackageJsonFiles(state, resolved, resolvedPath, parsed) {
     getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath),
     new Map(state.lastCachedPackageJsonLookups.get(resolvedPath)),
     {
-      createNewValue: (path, _input) => watchFile(
+      createNewValue: (_path, input) => watchFile(
         state,
-        path,
+        input,
         () => invalidateProjectAndScheduleBuilds(state, resolvedPath, 0 /* Update */),
         2e3 /* High */,
         parsed == null ? void 0 : parsed.watchOptions,