typescript 5.4.0-dev.20231126 → 5.4.0-dev.20231128

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-dev.20231126`;
+var version = `${versionMajorMinor}.0-dev.20231128`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -15951,19 +15951,19 @@ function clearMap(map2, onDeleteValue) {
 function mutateMapSkippingNewValues(map2, newMap, options) {
   const { onDeleteValue, onExistingValue } = options;
   map2.forEach((existingValue, key) => {
-    const valueInNewMap = newMap.get(key);
-    if (valueInNewMap === void 0) {
+    var _a;
+    if (!(newMap == null ? void 0 : newMap.has(key))) {
       map2.delete(key);
       onDeleteValue(existingValue, key);
     } else if (onExistingValue) {
-      onExistingValue(existingValue, valueInNewMap, key);
+      onExistingValue(existingValue, (_a = newMap.get) == null ? void 0 : _a.call(newMap, key), key);
     }
   });
 }
 function mutateMap(map2, newMap, options) {
   mutateMapSkippingNewValues(map2, newMap, options);
   const { createNewValue } = options;
-  newMap.forEach((valueInNewMap, key) => {
+  newMap == null ? void 0 : newMap.forEach((valueInNewMap, key) => {
     if (!map2.has(key)) {
       map2.set(key, createNewValue(key, valueInNewMap));
     }
@@ -31214,8 +31214,9 @@ var Parser;
   function nextTokenIsStringLiteral() {
     return nextToken() === 11 /* StringLiteral */;
   }
-  function nextTokenIsFromKeyword() {
-    return nextToken() === 161 /* FromKeyword */;
+  function nextTokenIsFromKeywordOrEqualsToken() {
+    nextToken();
+    return token() === 161 /* FromKeyword */ || token() === 64 /* EqualsToken */;
   }
   function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
     nextToken();
@@ -31912,7 +31913,7 @@ var Parser;
       identifier = parseIdentifier();
     }
     let isTypeOnly = false;
-    if ((identifier == null ? void 0 : identifier.escapedText) === "type" && (token() !== 161 /* FromKeyword */ || isIdentifier2() && lookAhead(nextTokenIsFromKeyword)) && (isIdentifier2() || tokenAfterImportDefinitelyProducesImportDeclaration())) {
+    if ((identifier == null ? void 0 : identifier.escapedText) === "type" && (token() !== 161 /* FromKeyword */ || isIdentifier2() && lookAhead(nextTokenIsFromKeywordOrEqualsToken)) && (isIdentifier2() || tokenAfterImportDefinitelyProducesImportDeclaration())) {
       isTypeOnly = true;
       identifier = isIdentifier2() ? parseIdentifier() : void 0;
     }
@@ -36783,34 +36784,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];
           }
         }
       }
@@ -36818,6 +36824,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) {
@@ -36825,13 +36834,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 */
     };
   }
@@ -37409,6 +37421,9 @@ function getAutomaticTypeDirectiveNames(options, host) {
   }
   return result;
 }
+function isPackageJsonInfo(entry) {
+  return !!(entry == null ? void 0 : entry.contents);
+}
 function compilerOptionValueToString(value) {
   var _a;
   if (value === null || typeof value !== "object") {
@@ -37513,7 +37528,7 @@ function createCacheWithRedirects(ownOptions, optionsToRedirectsKey) {
 }
 function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
   let cache;
-  return { getPackageJsonInfo: getPackageJsonInfo2, setPackageJsonInfo, clear: clear2, entries, getInternalMap };
+  return { getPackageJsonInfo: getPackageJsonInfo2, setPackageJsonInfo, clear: clear2, getInternalMap };
   function getPackageJsonInfo2(packageJsonPath) {
     return cache == null ? void 0 : cache.get(toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
   }
@@ -37523,10 +37538,6 @@ function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
   function clear2() {
     cache = void 0;
   }
-  function entries() {
-    const iter = cache == null ? void 0 : cache.entries();
-    return iter ? arrayFrom(iter) : [];
-  }
   function getInternalMap() {
     return cache;
   }
@@ -38406,13 +38417,13 @@ function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
   }
   const existing = (_b = state.packageJsonInfoCache) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
   if (existing !== void 0) {
-    if (typeof existing !== "boolean") {
+    if (isPackageJsonInfo(existing)) {
       if (traceEnabled)
         trace(host, Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath);
       (_c = state.affectingLocations) == null ? void 0 : _c.push(packageJsonPath);
       return existing.packageDirectory === packageDirectory ? existing : { packageDirectory, contents: existing.contents };
     } else {
-      if (existing && traceEnabled)
+      if (existing.directoryExists && traceEnabled)
         trace(host, Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups, packageJsonPath);
       (_d = state.failedLookupLocations) == null ? void 0 : _d.push(packageJsonPath);
       return void 0;
@@ -38434,7 +38445,7 @@ function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
       trace(host, Diagnostics.File_0_does_not_exist, packageJsonPath);
     }
     if (state.packageJsonInfoCache && !state.packageJsonInfoCache.isReadonly)
-      state.packageJsonInfoCache.setPackageJsonInfo(packageJsonPath, directoryExists);
+      state.packageJsonInfoCache.setPackageJsonInfo(packageJsonPath, { packageDirectory, directoryExists });
     (_f = state.failedLookupLocations) == null ? void 0 : _f.push(packageJsonPath);
   }
 }
@@ -42407,7 +42418,7 @@ function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourc
 }
 function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, preferences, userPreferences, options = {}) {
   const info = getInfo(importingSourceFileName, host);
-  const modulePaths = getAllModulePaths(importingSourceFileName, toFileName2, host, userPreferences, options);
+  const modulePaths = getAllModulePaths(info, toFileName2, host, userPreferences, options);
   return firstDefined(modulePaths, (modulePath) => tryGetModuleNameAsNodeModule(
     modulePath,
     info,
@@ -42460,7 +42471,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(getInfo(importingSourceFile.fileName, host), moduleSourceFile.originalFileName, host));
   const result = computeModuleSpecifiers(
     modulePaths,
     compilerOptions,
@@ -42474,7 +42485,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)),
@@ -42538,16 +42549,22 @@ 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 };
+  return {
+    getCanonicalFileName,
+    importingSourceFileName,
+    sourceDirectory,
+    canonicalSourceDirectory: getCanonicalFileName(sourceDirectory)
+  };
 }
 function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { getAllowedEndingsInPreferredOrder: getAllowedEndingsInPrefererredOrder, relativePreference }, pathsOnly) {
   const { baseUrl, paths, rootDirs } = compilerOptions;
   if (pathsOnly && !paths) {
     return void 0;
   }
-  const { sourceDirectory, getCanonicalFileName } = info;
+  const { sourceDirectory, canonicalSourceDirectory, getCanonicalFileName } = info;
   const allowedEndings = getAllowedEndingsInPrefererredOrder(importMode);
   const relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, allowedEndings, compilerOptions) || processEnding(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), allowedEndings, compilerOptions);
   if (!baseUrl && !paths || relativePreference === 0 /* Relative */) {
@@ -42572,7 +42589,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(canonicalSourceDirectory, projectDirectory);
     const targetIsInternal = startsWith(modulePath, projectDirectory);
     if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) {
       return maybeNonRelative;
@@ -42645,8 +42662,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(info, importedFileName, host, preferences, options = {}) {
   var _a;
+  const importingFilePath = toPath(info.importingSourceFileName, 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) {
@@ -42654,30 +42672,29 @@ 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(info, importedFileName, host);
   if (cache) {
     cache.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths);
   }
   return modulePaths;
 }
-function getAllModulePathsWorker(importingFileName, importedFileName, host) {
-  const getCanonicalFileName = hostGetCanonicalFileName(host);
+function getAllModulePathsWorker(info, importedFileName, host) {
   const allFileNames = /* @__PURE__ */ new Map();
   let importedFileFromNodeModules = false;
   forEachFileNameOfModule(
-    importingFileName,
+    info.importingSourceFileName,
     importedFileName,
     host,
     /*preferSymlinks*/
     true,
     (path, isRedirect) => {
       const isInNodeModules = pathContainsNodeModules(path);
-      allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect, isInNodeModules });
+      allFileNames.set(path, { path: info.getCanonicalFileName(path), isRedirect, isInNodeModules });
       importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
     }
   );
   const sortedPaths = [];
-  for (let directory = getDirectoryPath(importingFileName); allFileNames.size !== 0; ) {
+  for (let directory = info.canonicalSourceDirectory; allFileNames.size !== 0; ) {
     const directoryStart = ensureTrailingDirectorySeparator(directory);
     let pathsInDirectory;
     allFileNames.forEach(({ path, isRedirect, isInNodeModules }, fileName) => {
@@ -42698,7 +42715,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);
@@ -42858,7 +42878,7 @@ function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory,
   }
   return processEnding(shortest, allowedEndings, compilerOptions);
 }
-function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileName, sourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
+function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileName, canonicalSourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
   if (!host.fileExists || !host.readFile) {
     return void 0;
   }
@@ -42902,7 +42922,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(canonicalSourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) {
     return void 0;
   }
   const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
@@ -42915,7 +42935,7 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
     let moduleFileToTry = path;
     let maybeBlockedByTypesVersions = false;
     const cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) == null ? void 0 : _a.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
-    if (typeof cachedPackageJson === "object" || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
+    if (isPackageJsonInfo(cachedPackageJson) || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
       const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
       const importMode = overrideMode || importingSourceFile.impliedNodeFormat;
       if (getResolvePackageJsonExports(options)) {
@@ -54502,9 +54522,13 @@ function createTypeChecker(host) {
   function getConstraintOfTypeParameter(typeParameter) {
     return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : void 0;
   }
+  function isConstMappedType(type, depth) {
+    const typeVariable = getHomomorphicTypeVariable(type);
+    return !!typeVariable && isConstTypeVariable(typeVariable, depth);
+  }
   function isConstTypeVariable(type, depth = 0) {
     var _a;
-    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 4096 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
+    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 4096 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || getObjectFlags(type) & 32 /* Mapped */ && isConstMappedType(type, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
   }
   function getConstraintOfIndexedAccess(type) {
     return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -107971,8 +107995,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)) {
@@ -115398,8 +115422,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();
@@ -115482,11 +115506,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,
@@ -115497,18 +115519,22 @@ function updateMissingFilePathsWatch(program, missingFileWatches, createMissingF
   );
 }
 function updateWatchingWildcardDirectories(existingWatchedForWildcards, wildcardDirectories, watchDirectory) {
-  mutateMap(
-    existingWatchedForWildcards,
-    wildcardDirectories,
-    {
-      // Create new watch and recursive info
-      createNewValue: createWildcardDirectoryWatcher,
-      // Close existing watch thats not needed any more
-      onDeleteValue: closeFileWatcherOf,
-      // Close existing watch that doesnt match in the flags
-      onExistingValue: updateWildcardDirectoryWatcher
-    }
-  );
+  if (wildcardDirectories) {
+    mutateMap(
+      existingWatchedForWildcards,
+      new Map(Object.entries(wildcardDirectories)),
+      {
+        // Create new watch and recursive info
+        createNewValue: createWildcardDirectoryWatcher,
+        // Close existing watch thats not needed any more
+        onDeleteValue: closeFileWatcherOf,
+        // Close existing watch that doesnt match in the flags
+        onExistingValue: updateWildcardDirectoryWatcher
+      }
+    );
+  } else {
+    clearMap(existingWatchedForWildcards, closeFileWatcherOf);
+  }
   function createWildcardDirectoryWatcher(directory, flags) {
     return {
       watcher: watchDirectory(directory, flags),
@@ -116313,7 +116339,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))
@@ -116613,7 +116640,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;
@@ -116732,12 +116759,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) {
@@ -116782,8 +116807,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,
@@ -117210,7 +117234,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(), (missingFileName) => host.fileExists(missingFileName))) {
       return 0 /* Not */;
     }
     const oldSourceFiles = oldProgram.getSourceFiles();
@@ -117350,7 +117374,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);
@@ -117407,7 +117431,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);
       },
@@ -118219,6 +118243,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           addFileToFilesByName(
             file2,
             path,
+            fileName,
             /*redirectedPath*/
             void 0
           );
@@ -118291,7 +118316,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);
@@ -118301,7 +118326,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;
@@ -118341,14 +118366,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);
@@ -118669,6 +118701,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           /*file*/
           void 0,
           sourceFilePath,
+          refPath,
           /*redirectedPath*/
           void 0
         );
@@ -118680,6 +118713,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       addFileToFilesByName(
         sourceFile,
         sourceFilePath,
+        refPath,
         /*redirectedPath*/
         void 0
       );
@@ -118689,6 +118723,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       addFileToFilesByName(
         sourceFile,
         sourceFilePath,
+        refPath,
         /*redirectedPath*/
         void 0
       );
@@ -122474,8 +122509,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function closeTypeRootsWatch() {
     clearMap(typeRootsWatches, closeFileWatcher);
   }
-  function createTypeRootsWatch(typeRootPath, typeRoot) {
-    return canWatchTypeRootPath(typeRootPath) ? resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
+  function createTypeRootsWatch(typeRoot) {
+    return canWatchTypeRootPath(typeRoot) ? resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
       const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
       if (cachedDirectoryStructureHost) {
         cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
@@ -122484,7 +122519,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       resolutionHost.onChangedAutomaticTypeDirectiveNames();
       const dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(
         typeRoot,
-        typeRootPath,
+        resolutionHost.toPath(typeRoot),
         rootPath,
         rootPathComponents,
         getCurrentDirectory,
@@ -122505,7 +122540,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     if (typeRoots) {
       mutateMap(
         typeRootsWatches,
-        arrayToMap(typeRoots, (tr) => resolutionHost.toPath(tr)),
+        new Set(typeRoots),
         {
           createNewValue: createTypeRootsWatch,
           onDeleteValue: closeFileWatcher
@@ -123434,7 +123469,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();
     }
@@ -123727,8 +123766,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);
@@ -123740,15 +123786,11 @@ function createWatchProgram(host) {
     }
   }
   function watchConfigFileWildCardDirectories() {
-    if (wildcardDirectories) {
-      updateWatchingWildcardDirectories(
-        watchedWildcardDirectories || (watchedWildcardDirectories = /* @__PURE__ */ new Map()),
-        new Map(Object.entries(wildcardDirectories)),
-        watchWildcardDirectory
-      );
-    } else if (watchedWildcardDirectories) {
-      clearMap(watchedWildcardDirectories, closeFileWatcherOf);
-    }
+    updateWatchingWildcardDirectories(
+      watchedWildcardDirectories || (watchedWildcardDirectories = /* @__PURE__ */ new Map()),
+      wildcardDirectories,
+      watchWildcardDirectory
+    );
   }
   function watchWildcardDirectory(directory, flags) {
     return watchDirectory(
@@ -123820,7 +123862,7 @@ function createWatchProgram(host) {
     );
   }
   function watchReferencedProject(configFileName2, configPath, commandLine) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     commandLine.watcher || (commandLine.watcher = watchFile2(
       configFileName2,
       (_fileName, eventKind) => {
@@ -123835,55 +123877,50 @@ function createWatchProgram(host) {
       ((_a = commandLine.parsedCommandLine) == null ? void 0 : _a.watchOptions) || watchOptions,
       WatchType.ConfigFileOfReferencedProject
     ));
-    if ((_b = commandLine.parsedCommandLine) == null ? void 0 : _b.wildcardDirectories) {
-      updateWatchingWildcardDirectories(
-        commandLine.watchedDirectories || (commandLine.watchedDirectories = /* @__PURE__ */ new Map()),
-        new Map(Object.entries((_c = commandLine.parsedCommandLine) == null ? void 0 : _c.wildcardDirectories)),
-        (directory, flags) => {
-          var _a2;
-          return watchDirectory(
-            directory,
-            (fileOrDirectory) => {
-              const fileOrDirectoryPath = toPath3(fileOrDirectory);
-              if (cachedDirectoryStructureHost) {
-                cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
-              }
-              nextSourceFileVersion(fileOrDirectoryPath);
-              const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
-              if (!(config == null ? void 0 : config.parsedCommandLine))
-                return;
-              if (isIgnoredFileFromWildCardWatching({
-                watchedDirPath: toPath3(directory),
-                fileOrDirectory,
-                fileOrDirectoryPath,
-                configFileName: configFileName2,
-                options: config.parsedCommandLine.options,
-                program: config.parsedCommandLine.fileNames,
-                currentDirectory,
-                useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
-                writeLog,
-                toPath: toPath3
-              }))
-                return;
-              if (config.updateLevel !== 2 /* Full */) {
-                config.updateLevel = 1 /* RootNamesAndUpdate */;
-                scheduleProgramUpdate();
-              }
-            },
-            flags,
-            ((_a2 = commandLine.parsedCommandLine) == null ? void 0 : _a2.watchOptions) || watchOptions,
-            WatchType.WildcardDirectoryOfReferencedProject
-          );
-        }
-      );
-    } else if (commandLine.watchedDirectories) {
-      clearMap(commandLine.watchedDirectories, closeFileWatcherOf);
-      commandLine.watchedDirectories = void 0;
-    }
+    updateWatchingWildcardDirectories(
+      commandLine.watchedDirectories || (commandLine.watchedDirectories = /* @__PURE__ */ new Map()),
+      (_b = commandLine.parsedCommandLine) == null ? void 0 : _b.wildcardDirectories,
+      (directory, flags) => {
+        var _a2;
+        return watchDirectory(
+          directory,
+          (fileOrDirectory) => {
+            const fileOrDirectoryPath = toPath3(fileOrDirectory);
+            if (cachedDirectoryStructureHost) {
+              cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
+            }
+            nextSourceFileVersion(fileOrDirectoryPath);
+            const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
+            if (!(config == null ? void 0 : config.parsedCommandLine))
+              return;
+            if (isIgnoredFileFromWildCardWatching({
+              watchedDirPath: toPath3(directory),
+              fileOrDirectory,
+              fileOrDirectoryPath,
+              configFileName: configFileName2,
+              options: config.parsedCommandLine.options,
+              program: config.parsedCommandLine.fileNames,
+              currentDirectory,
+              useCaseSensitiveFileNames: useCaseSensitiveFileNames2,
+              writeLog,
+              toPath: toPath3
+            }))
+              return;
+            if (config.updateLevel !== 2 /* Full */) {
+              config.updateLevel = 1 /* RootNamesAndUpdate */;
+              scheduleProgramUpdate();
+            }
+          },
+          flags,
+          ((_a2 = commandLine.parsedCommandLine) == null ? void 0 : _a2.watchOptions) || watchOptions,
+          WatchType.WildcardDirectoryOfReferencedProject
+        );
+      }
+    );
     updateExtendedConfigFilesWatches(
       configPath,
-      (_d = commandLine.parsedCommandLine) == null ? void 0 : _d.options,
-      ((_e = commandLine.parsedCommandLine) == null ? void 0 : _e.watchOptions) || watchOptions,
+      (_c = commandLine.parsedCommandLine) == null ? void 0 : _c.options,
+      ((_d = commandLine.parsedCommandLine) == null ? void 0 : _d.watchOptions) || watchOptions,
       WatchType.ExtendedConfigOfReferencedProject
     );
   }
@@ -124189,9 +124226,9 @@ function getBuildOrder(state) {
 function createStateBuildOrder(state) {
   const buildOrder = createBuildOrder(state, state.rootNames.map((f) => resolveProjectName(state, f)));
   state.resolvedConfigFilePaths.clear();
-  const currentProjects = new Map(
+  const currentProjects = new Set(
     getBuildOrderFromAnyBuildOrder(buildOrder).map(
-      (resolved) => [toResolvedConfigFilePath(state, resolved), true]
+      (resolved) => toResolvedConfigFilePath(state, resolved)
     )
   );
   const noopOnDelete = { onDeleteValue: noop };
@@ -124203,6 +124240,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,
@@ -124451,7 +124489,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);
@@ -124480,12 +124518,13 @@ function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath,
       config.projectReferences
     );
     if (state.watch) {
+      const internalMap = (_c = state.moduleResolutionCache) == null ? void 0 : _c.getPackageJsonInfoCache().getInternalMap();
       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]
-        )
+        internalMap && new Set(arrayFrom(
+          internalMap.values(),
+          (data) => state.host.realpath && (isPackageJsonInfo(data) || data.directoryExists) ? state.host.realpath(combinePaths(data.packageDirectory, "package.json")) : combinePaths(data.packageDirectory, "package.json")
+        ))
       );
       state.builderPrograms.set(projectPath, program);
     }
@@ -125218,9 +125257,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 && forEachKey(
+    packageJsonLookups,
+    (path) => checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName)
   );
   if (dependentPackageFileStatus)
     return dependentPackageFileStatus;
@@ -125577,7 +125617,7 @@ function watchWildCardDirectories(state, resolved, resolvedPath, parsed) {
     return;
   updateWatchingWildcardDirectories(
     getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath),
-    new Map(Object.entries(parsed.wildcardDirectories)),
+    parsed.wildcardDirectories,
     (dir, flags) => state.watchDirectory(
       dir,
       (fileOrDirectory) => {
@@ -125609,9 +125649,9 @@ function watchInputFiles(state, resolved, resolvedPath, parsed) {
     return;
   mutateMap(
     getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath),
-    arrayToMap(parsed.fileNames, (fileName) => toPath2(state, fileName)),
+    new Set(parsed.fileNames),
     {
-      createNewValue: (_path, input) => watchFile(
+      createNewValue: (input) => watchFile(
         state,
         input,
         () => invalidateProjectAndScheduleBuilds(state, resolvedPath, 0 /* Update */),
@@ -125629,11 +125669,11 @@ function watchPackageJsonFiles(state, resolved, resolvedPath, parsed) {
     return;
   mutateMap(
     getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath),
-    new Map(state.lastCachedPackageJsonLookups.get(resolvedPath)),
+    state.lastCachedPackageJsonLookups.get(resolvedPath),
     {
-      createNewValue: (path, _input) => watchFile(
+      createNewValue: (input) => watchFile(
         state,
-        path,
+        input,
         () => invalidateProjectAndScheduleBuilds(state, resolvedPath, 0 /* Update */),
         2e3 /* High */,
         parsed == null ? void 0 : parsed.watchOptions,