typescript 5.4.0-dev.20231127 → 5.4.0-dev.20231128

package/lib/tsserver.js

@@ -1643,6 +1643,7 @@ __export(server_exports, {
   isOuterExpression: () => isOuterExpression,
   isOutermostOptionalChain: () => isOutermostOptionalChain,
   isOverrideModifier: () => isOverrideModifier,
+  isPackageJsonInfo: () => isPackageJsonInfo,
   isPackedArrayLiteral: () => isPackedArrayLiteral,
   isParameter: () => isParameter,
   isParameterDeclaration: () => isParameterDeclaration,
@@ -2294,7 +2295,6 @@ __export(server_exports, {
   updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
   updateLanguageServiceSourceFile: () => updateLanguageServiceSourceFile,
   updateMissingFilePathsWatch: () => updateMissingFilePathsWatch,
-  updatePackageJsonWatch: () => updatePackageJsonWatch,
   updateResolutionField: () => updateResolutionField,
   updateSharedExtendedConfigFileWatcher: () => updateSharedExtendedConfigFileWatcher,
   updateSourceFile: () => updateSourceFile,
@@ -2331,7 +2331,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231127`;
+var version = `${versionMajorMinor}.0-dev.20231128`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -20031,19 +20031,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));
     }
@@ -35640,8 +35640,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();
@@ -36338,7 +36339,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;
     }
@@ -41244,34 +41245,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];
           }
         }
       }
@@ -41279,6 +41285,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) {
@@ -41286,13 +41295,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 */
     };
   }
@@ -41935,6 +41947,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") {
@@ -42039,7 +42054,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));
   }
@@ -42049,10 +42064,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;
   }
@@ -43069,13 +43080,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;
@@ -43097,7 +43108,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);
   }
 }
@@ -47108,8 +47119,8 @@ function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourc
   return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getPreferences({}, compilerOptions, importingSourceFile), {}, options);
 }
 function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeModulesFileName, host, preferences, options = {}) {
-  const info = getInfo(importingSourceFile.path, host);
-  const modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences, options);
+  const info = getInfo(importingSourceFile.fileName, host);
+  const modulePaths = getAllModulePaths(info, nodeModulesFileName, host, preferences, options);
   return firstDefined(modulePaths, (modulePath) => tryGetModuleNameAsNodeModule(
     modulePath,
     info,
@@ -47124,7 +47135,7 @@ function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeMod
 }
 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,
@@ -47186,7 +47197,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,
@@ -47200,7 +47211,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)),
@@ -47264,16 +47275,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 */) {
@@ -47298,7 +47315,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;
@@ -47371,8 +47388,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) {
@@ -47380,30 +47398,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) => {
@@ -47424,7 +47441,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);
@@ -47584,7 +47604,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;
   }
@@ -47628,7 +47648,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);
@@ -47641,7 +47661,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)) {
@@ -59228,9 +59248,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;
@@ -112868,8 +112892,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)) {
@@ -120306,8 +120330,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();
@@ -120395,23 +120419,10 @@ function cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, t
     }
   });
 }
-function updatePackageJsonWatch(lookups, packageJsonWatches, createPackageJsonWatch) {
-  const newMap = new Map(lookups);
-  mutateMap(
-    packageJsonWatches,
-    newMap,
-    {
-      createNewValue: createPackageJsonWatch,
-      onDeleteValue: closeFileWatcher
-    }
-  );
-}
 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,
@@ -120422,18 +120433,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),
@@ -121271,7 +121286,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))
@@ -121575,7 +121591,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;
@@ -121694,12 +121710,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) {
@@ -121744,8 +121758,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,
@@ -122172,7 +122185,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();
@@ -122312,7 +122325,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);
@@ -122369,7 +122382,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);
       },
@@ -123181,6 +123194,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           addFileToFilesByName(
             file2,
             path,
+            fileName,
             /*redirectedPath*/
             void 0
           );
@@ -123253,7 +123267,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);
@@ -123263,7 +123277,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;
@@ -123303,14 +123317,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);
@@ -123631,6 +123652,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           /*file*/
           void 0,
           sourceFilePath,
+          refPath,
           /*redirectedPath*/
           void 0
         );
@@ -123642,6 +123664,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       addFileToFilesByName(
         sourceFile,
         sourceFilePath,
+        refPath,
         /*redirectedPath*/
         void 0
       );
@@ -123651,6 +123674,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       addFileToFilesByName(
         sourceFile,
         sourceFilePath,
+        refPath,
         /*redirectedPath*/
         void 0
       );
@@ -127471,8 +127495,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);
@@ -127481,7 +127505,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       resolutionHost.onChangedAutomaticTypeDirectiveNames();
       const dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(
         typeRoot,
-        typeRootPath,
+        resolutionHost.toPath(typeRoot),
         rootPath,
         rootPathComponents,
         getCurrentDirectory,
@@ -127502,7 +127526,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     if (typeRoots) {
       mutateMap(
         typeRootsWatches,
-        arrayToMap(typeRoots, (tr) => resolutionHost.toPath(tr)),
+        new Set(typeRoots),
         {
           createNewValue: createTypeRootsWatch,
           onDeleteValue: closeFileWatcher
@@ -128456,7 +128480,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();
     }
@@ -128749,8 +128777,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);
@@ -128762,15 +128797,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(
@@ -128842,7 +128873,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) => {
@@ -128857,55 +128888,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
     );
   }
@@ -129232,9 +129258,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 };
@@ -129246,6 +129272,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,
@@ -129500,7 +129527,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);
@@ -129529,12 +129556,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);
     }
@@ -130267,9 +130295,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;
@@ -130626,7 +130655,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) => {
@@ -130658,9 +130687,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 */),
@@ -130678,11 +130707,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,
@@ -136465,7 +136494,7 @@ function updateImports(program, changeTracker, oldToNew, newToOld, host, getCano
       if ((importedModuleSymbol == null ? void 0 : importedModuleSymbol.declarations) && importedModuleSymbol.declarations.some((d) => isAmbientModule(d)))
         return void 0;
       const toImport = oldFromNew !== void 0 ? getSourceFileToImportFromResolved(importLiteral, resolveModuleName(importLiteral.text, oldImportFromPath, program.getCompilerOptions(), host), oldToNew, allFiles) : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew);
-      return toImport !== void 0 && (toImport.updated || importingSourceFileMoved && pathIsRelative(importLiteral.text)) ? ts_moduleSpecifiers_exports.updateModuleSpecifier(program.getCompilerOptions(), sourceFile, getCanonicalFileName(newImportFromPath), toImport.newFileName, createModuleSpecifierResolutionHost(program, host), importLiteral.text) : void 0;
+      return toImport !== void 0 && (toImport.updated || importingSourceFileMoved && pathIsRelative(importLiteral.text)) ? ts_moduleSpecifiers_exports.updateModuleSpecifier(program.getCompilerOptions(), sourceFile, newImportFromPath, toImport.newFileName, createModuleSpecifierResolutionHost(program, host), importLiteral.text) : void 0;
     });
   }
 }
@@ -137304,11 +137333,11 @@ function getSourceMapper(host) {
     const fileFromCache = sourceFileLike.get(path);
     if (fileFromCache !== void 0)
       return fileFromCache ? fileFromCache : void 0;
-    if (!host.readFile || host.fileExists && !host.fileExists(path)) {
+    if (!host.readFile || host.fileExists && !host.fileExists(fileName)) {
       sourceFileLike.set(path, false);
       return void 0;
     }
-    const text = host.readFile(path);
+    const text = host.readFile(fileName);
     const file = text ? createSourceFileLike(text) : false;
     sourceFileLike.set(path, file);
     return file ? file : void 0;
@@ -139861,7 +139890,7 @@ function getTargetFileImportsAndAddExportInOldFile(oldFile, targetFile, importsT
         const resolved = program.getResolvedModule(oldFile, moduleSpecifier.text, getModeForUsageLocation(oldFile, moduleSpecifier));
         const fileName = (_a = resolved == null ? void 0 : resolved.resolvedModule) == null ? void 0 : _a.resolvedFileName;
         if (fileName && targetSourceFile) {
-          const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), targetSourceFile, targetSourceFile.path, fileName, createModuleSpecifierResolutionHost(program, host));
+          const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), targetSourceFile, targetSourceFile.fileName, fileName, createModuleSpecifierResolutionHost(program, host));
           append(copiedOldImports, filterImport(i, makeStringLiteral(newModuleSpecifier, quotePreference), (name) => importsToCopy.has(checker.getSymbolAtLocation(name))));
         } else {
           append(copiedOldImports, filterImport(i, factory.createStringLiteral(moduleSpecifierFromImport(i).text), (name) => importsToCopy.has(checker.getSymbolAtLocation(name))));
@@ -139939,7 +139968,7 @@ function updateImportsInOtherFiles(changes, program, host, oldFile, movedSymbols
         };
         deleteUnusedImports(sourceFile, importNode, changes, shouldMove);
         const pathToTargetFileWithExtension = resolvePath(getDirectoryPath(oldFile.path), targetFileName);
-        const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.path, pathToTargetFileWithExtension, createModuleSpecifierResolutionHost(program, host));
+        const newModuleSpecifier = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFileWithExtension, createModuleSpecifierResolutionHost(program, host));
         const newImportDeclaration = filterImport(importNode, makeStringLiteral(newModuleSpecifier, quotePreference), shouldMove);
         if (newImportDeclaration)
           changes.insertNodeAfter(sourceFile, statement, newImportDeclaration);
@@ -140074,7 +140103,7 @@ function createOldFileImportsFromTargetFile(sourceFile, targetFileNeedExport, ta
 }
 function makeImportOrRequire(sourceFile, defaultImport, imports, targetFileNameWithExtension, program, host, useEs6Imports, quotePreference) {
   const pathToTargetFile = resolvePath(getDirectoryPath(sourceFile.path), targetFileNameWithExtension);
-  const pathToTargetFileWithCorrectExtension = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.path, pathToTargetFile, createModuleSpecifierResolutionHost(program, host));
+  const pathToTargetFileWithCorrectExtension = getModuleSpecifier(program.getCompilerOptions(), sourceFile, sourceFile.fileName, pathToTargetFile, createModuleSpecifierResolutionHost(program, host));
   if (useEs6Imports) {
     const specifiers = imports.map((i) => factory.createImportSpecifier(
       /*isTypeOnly*/
@@ -165814,6 +165843,10 @@ function provideInlayHints(context) {
           parts.push({ text: tokenToString(node.operator) });
           visitForDisplayParts(node.operand);
           break;
+        case 197 /* ThisType */:
+          Debug.assertNode(node, isThisTypeNode);
+          parts.push({ text: "this" });
+          break;
         default:
           Debug.failBadSyntaxKind(node);
       }
@@ -174501,6 +174534,7 @@ __export(ts_exports2, {
   isOuterExpression: () => isOuterExpression,
   isOutermostOptionalChain: () => isOutermostOptionalChain,
   isOverrideModifier: () => isOverrideModifier,
+  isPackageJsonInfo: () => isPackageJsonInfo,
   isPackedArrayLiteral: () => isPackedArrayLiteral,
   isParameter: () => isParameter,
   isParameterDeclaration: () => isParameterDeclaration,
@@ -175152,7 +175186,6 @@ __export(ts_exports2, {
   updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
   updateLanguageServiceSourceFile: () => updateLanguageServiceSourceFile,
   updateMissingFilePathsWatch: () => updateMissingFilePathsWatch,
-  updatePackageJsonWatch: () => updatePackageJsonWatch,
   updateResolutionField: () => updateResolutionField,
   updateSharedExtendedConfigFileWatcher: () => updateSharedExtendedConfigFileWatcher,
   updateSourceFile: () => updateSourceFile,
@@ -177498,6 +177531,7 @@ var Project3 = class _Project {
     return path === options.configFilePath ? options.configFile : this.getSourceFile(path);
   }
   close() {
+    var _a;
     this.projectService.typingsCache.onProjectClosed(this);
     this.closeWatchingTypingLocations();
     this.cleanupProgram();
@@ -177514,6 +177548,12 @@ var Project3 = class _Project {
     this.resolutionCache.clear();
     this.resolutionCache = void 0;
     this.cachedUnresolvedImportsPerFile = void 0;
+    (_a = this.packageJsonWatches) == null ? void 0 : _a.forEach((watcher) => {
+      watcher.projects.delete(this);
+      watcher.close();
+    });
+    this.packageJsonWatches = void 0;
+    this.moduleSpecifierCache.clear();
     this.moduleSpecifierCache = void 0;
     this.directoryStructureHost = void 0;
     this.exportMapCache = void 0;
@@ -177708,13 +177748,10 @@ var Project3 = class _Project {
     }
   }
   /** @internal */
-  onPackageJsonChange(packageJsonPath) {
-    var _a;
-    if ((_a = this.packageJsonsForAutoImport) == null ? void 0 : _a.has(packageJsonPath)) {
-      this.moduleSpecifierCache.clear();
-      if (this.autoImportProviderHost) {
-        this.autoImportProviderHost.markAsDirty();
-      }
+  onPackageJsonChange() {
+    this.moduleSpecifierCache.clear();
+    if (this.autoImportProviderHost) {
+      this.autoImportProviderHost.markAsDirty();
     }
   }
   /** @internal */
@@ -177929,7 +177966,7 @@ var Project3 = class _Project {
         this.program,
         this.missingFilesMap || (this.missingFilesMap = /* @__PURE__ */ new Map()),
         // Watch the missing files
-        (missingFilePath) => this.addMissingFileWatcher(missingFilePath)
+        (missingFilePath, missingFileName) => this.addMissingFileWatcher(missingFilePath, missingFileName)
       );
       if (this.generatedFilesMap) {
         const outPath = outFile(this.compilerOptions);
@@ -178043,7 +178080,7 @@ var Project3 = class _Project {
       }
     }
   }
-  addMissingFileWatcher(missingFilePath) {
+  addMissingFileWatcher(missingFilePath, missingFileName) {
     var _a;
     if (isConfiguredProject(this)) {
       const configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(missingFilePath);
@@ -178051,7 +178088,7 @@ var Project3 = class _Project {
         return noopFileWatcher;
     }
     const fileWatcher = this.projectService.watchFactory.watchFile(
-      missingFilePath,
+      getNormalizedAbsolutePath(missingFileName, this.currentDirectory),
       (fileName, eventKind) => {
         if (isConfiguredProject(this)) {
           this.getCachedDirectoryStructureHost().addOrDeleteFile(fileName, missingFilePath, eventKind);
@@ -178388,7 +178425,7 @@ var Project3 = class _Project {
   getPackageJsonsVisibleToFile(fileName, rootDir) {
     if (this.projectService.serverMode !== 0 /* Semantic */)
       return emptyArray2;
-    return this.projectService.getPackageJsonsVisibleToFile(fileName, rootDir);
+    return this.projectService.getPackageJsonsVisibleToFile(fileName, this, rootDir);
   }
   /** @internal */
   getNearestAncestorDirectoryWithPackageJson(fileName) {
@@ -178396,9 +178433,7 @@ var Project3 = class _Project {
   }
   /** @internal */
   getPackageJsonsForAutoImport(rootDir) {
-    const packageJsons = this.getPackageJsonsVisibleToFile(combinePaths(this.currentDirectory, inferredTypesContainingFile), rootDir);
-    this.packageJsonsForAutoImport = new Set(packageJsons.map((p) => p.fileName));
-    return packageJsons;
+    return this.getPackageJsonsVisibleToFile(combinePaths(this.currentDirectory, inferredTypesContainingFile), rootDir);
   }
   /** @internal */
   getPackageJsonCache() {
@@ -178484,7 +178519,7 @@ var Project3 = class _Project {
   }
   /** @internal */
   watchNodeModulesForPackageJsonChanges(directoryPath) {
-    return this.projectService.watchPackageJsonsInNodeModules(this.toPath(directoryPath), this);
+    return this.projectService.watchPackageJsonsInNodeModules(directoryPath, this);
   }
   /** @internal */
   getIncompleteCompletionsCache() {
@@ -180060,18 +180095,20 @@ var _ProjectService = class _ProjectService {
    * @internal
    */
   watchWildcardDirectory(directory, flags, configFileName, config) {
-    return this.watchFactory.watchDirectory(
+    let watcher = this.watchFactory.watchDirectory(
       directory,
       (fileOrDirectory) => {
         const fileOrDirectoryPath = this.toPath(fileOrDirectory);
         const fsResult = config.cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
-        if (getBaseFileName(fileOrDirectoryPath) === "package.json" && !isInsideNodeModules(fileOrDirectoryPath) && (fsResult && fsResult.fileExists || !fsResult && this.host.fileExists(fileOrDirectoryPath))) {
-          this.logger.info(`Config: ${configFileName} Detected new package.json: ${fileOrDirectory}`);
-          this.onAddPackageJson(fileOrDirectoryPath);
+        if (getBaseFileName(fileOrDirectoryPath) === "package.json" && !isInsideNodeModules(fileOrDirectoryPath) && (fsResult && fsResult.fileExists || !fsResult && this.host.fileExists(fileOrDirectory))) {
+          const file = this.getNormalizedAbsolutePath(fileOrDirectory);
+          this.logger.info(`Config: ${configFileName} Detected new package.json: ${file}`);
+          this.packageJsonCache.addOrUpdate(file, fileOrDirectoryPath);
+          this.watchPackageJsonFile(file, fileOrDirectoryPath, result);
         }
         const configuredProjectForConfig = this.findConfiguredProjectByProjectName(configFileName);
         if (isIgnoredFileFromWildCardWatching({
-          watchedDirPath: directory,
+          watchedDirPath: this.toPath(directory),
           fileOrDirectory,
           fileOrDirectoryPath,
           configFileName,
@@ -180116,6 +180153,22 @@ var _ProjectService = class _ProjectService {
       WatchType.WildcardDirectory,
       configFileName
     );
+    const result = {
+      packageJsonWatches: void 0,
+      close() {
+        var _a;
+        if (watcher) {
+          watcher.close();
+          watcher = void 0;
+          (_a = result.packageJsonWatches) == null ? void 0 : _a.forEach((watcher2) => {
+            watcher2.projects.delete(result);
+            watcher2.close();
+          });
+          result.packageJsonWatches = void 0;
+        }
+      }
+    };
+    return result;
   }
   /** @internal */
   delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalConfigFilePath, loadReason) {
@@ -180860,7 +180913,7 @@ var _ProjectService = class _ProjectService {
       config.watchedDirectoriesStale = false;
       updateWatchingWildcardDirectories(
         config.watchedDirectories || (config.watchedDirectories = /* @__PURE__ */ new Map()),
-        new Map(Object.entries(config.parsedCommandLine.wildcardDirectories)),
+        config.parsedCommandLine.wildcardDirectories,
         // Create new directory watcher
         (directory, flags) => this.watchWildcardDirectory(directory, flags, configFileName, config)
       );
@@ -180942,7 +180995,7 @@ var _ProjectService = class _ProjectService {
           if (value.info) {
             project.removeFile(
               value.info,
-              project.fileExists(path),
+              project.fileExists(value.info.fileName),
               /*detachFromProject*/
               true
             );
@@ -181174,7 +181227,7 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
   watchClosedScriptInfo(info) {
     Debug.assert(!info.fileWatcher);
     if (!info.isDynamicOrHasMixedContent() && (!this.globalCacheLocationDirectoryPath || !startsWith(info.path, this.globalCacheLocationDirectoryPath))) {
-      const indexOfNodeModules = info.path.indexOf("/node_modules/");
+      const indexOfNodeModules = info.fileName.indexOf("/node_modules/");
       if (!this.host.getModifiedTime || indexOfNodeModules === -1) {
         info.fileWatcher = this.watchFactory.watchFile(
           info.fileName,
@@ -181185,12 +181238,12 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
         );
       } else {
         info.mTime = this.getModifiedTime(info);
-        info.fileWatcher = this.watchClosedScriptInfoInNodeModules(info.path.substr(0, indexOfNodeModules));
+        info.fileWatcher = this.watchClosedScriptInfoInNodeModules(info.fileName.substring(0, indexOfNodeModules));
       }
     }
   }
-  createNodeModulesWatcher(dir) {
-    const watcher = this.watchFactory.watchDirectory(
+  createNodeModulesWatcher(dir, dirPath) {
+    let watcher = this.watchFactory.watchDirectory(
       dir,
       (fileOrDirectory) => {
         var _a;
@@ -181199,14 +181252,14 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
           return;
         const basename = getBaseFileName(fileOrDirectoryPath);
         if (((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size) && (basename === "package.json" || basename === "node_modules")) {
-          result.affectedModuleSpecifierCacheProjects.forEach((projectName) => {
-            var _a2, _b;
-            (_b = (_a2 = this.findProject(projectName)) == null ? void 0 : _a2.getModuleSpecifierCache()) == null ? void 0 : _b.clear();
+          result.affectedModuleSpecifierCacheProjects.forEach((project) => {
+            var _a2;
+            (_a2 = project.getModuleSpecifierCache()) == null ? void 0 : _a2.clear();
           });
         }
         if (result.refreshScriptInfoRefCount) {
-          if (dir === fileOrDirectoryPath) {
-            this.refreshScriptInfosInDirectory(dir);
+          if (dirPath === fileOrDirectoryPath) {
+            this.refreshScriptInfosInDirectory(dirPath);
           } else {
             const info = this.getScriptInfoForPath(fileOrDirectoryPath);
             if (info) {
@@ -181228,30 +181281,35 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
       affectedModuleSpecifierCacheProjects: void 0,
       close: () => {
         var _a;
-        if (!result.refreshScriptInfoRefCount && !((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size)) {
+        if (watcher && !result.refreshScriptInfoRefCount && !((_a = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.size)) {
           watcher.close();
-          this.nodeModulesWatchers.delete(dir);
+          watcher = void 0;
+          this.nodeModulesWatchers.delete(dirPath);
         }
       }
     };
-    this.nodeModulesWatchers.set(dir, result);
+    this.nodeModulesWatchers.set(dirPath, result);
     return result;
   }
   /** @internal */
   watchPackageJsonsInNodeModules(dir, project) {
-    const watcher = this.nodeModulesWatchers.get(dir) || this.createNodeModulesWatcher(dir);
-    (watcher.affectedModuleSpecifierCacheProjects || (watcher.affectedModuleSpecifierCacheProjects = /* @__PURE__ */ new Set())).add(project.getProjectName());
+    var _a;
+    const dirPath = this.toPath(dir);
+    const watcher = this.nodeModulesWatchers.get(dirPath) || this.createNodeModulesWatcher(dir, dirPath);
+    Debug.assert(!((_a = watcher.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.has(project)));
+    (watcher.affectedModuleSpecifierCacheProjects || (watcher.affectedModuleSpecifierCacheProjects = /* @__PURE__ */ new Set())).add(project);
     return {
       close: () => {
-        var _a;
-        (_a = watcher.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a.delete(project.getProjectName());
+        var _a2;
+        (_a2 = watcher.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a2.delete(project);
         watcher.close();
       }
     };
   }
   watchClosedScriptInfoInNodeModules(dir) {
     const watchDir = dir + "/node_modules";
-    const watcher = this.nodeModulesWatchers.get(watchDir) || this.createNodeModulesWatcher(watchDir);
+    const watchDirPath = this.toPath(watchDir);
+    const watcher = this.nodeModulesWatchers.get(watchDirPath) || this.createNodeModulesWatcher(watchDir, watchDirPath);
     watcher.refreshScriptInfoRefCount++;
     return {
       close: () => {
@@ -181261,7 +181319,7 @@ All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
     };
   }
   getModifiedTime(info) {
-    return (this.host.getModifiedTime(info.path) || missingFileModifiedTime).getTime();
+    return (this.host.getModifiedTime(info.fileName) || missingFileModifiedTime).getTime();
   }
   refreshScriptInfo(info) {
     const mTime = this.getModifiedTime(info);
@@ -181525,10 +181583,9 @@ Dynamic files must always be opened with service's current directory or service
           });
         }
         if (includePackageJsonAutoImports !== args.preferences.includePackageJsonAutoImports) {
-          this.invalidateProjectPackageJson(
-            /*packageJsonPath*/
-            void 0
-          );
+          this.forEachProject((project) => {
+            project.onAutoImportProviderSettingsChanged();
+          });
         }
       }
       if (args.extraFileExtensions) {
@@ -182447,10 +182504,9 @@ Dynamic files must always be opened with service's current directory or service
     this.currentPluginConfigOverrides.set(args.pluginName, args.configuration);
   }
   /** @internal */
-  getPackageJsonsVisibleToFile(fileName, rootDir) {
+  getPackageJsonsVisibleToFile(fileName, project, rootDir) {
     const packageJsonCache = this.packageJsonCache;
     const rootPath = rootDir && this.toPath(rootDir);
-    const filePath = this.toPath(fileName);
     const result = [];
     const processDirectory = (directory) => {
       switch (packageJsonCache.directoryHasPackageJson(directory)) {
@@ -182459,7 +182515,7 @@ Dynamic files must always be opened with service's current directory or service
           return processDirectory(directory);
         case -1 /* True */:
           const packageJsonFileName = combinePaths(directory, "package.json");
-          this.watchPackageJsonFile(packageJsonFileName);
+          this.watchPackageJsonFile(packageJsonFileName, this.toPath(packageJsonFileName), project);
           const info = packageJsonCache.getInDirectory(directory);
           if (info)
             result.push(info);
@@ -182468,13 +182524,13 @@ Dynamic files must always be opened with service's current directory or service
         return true;
       }
     };
-    forEachAncestorDirectory(getDirectoryPath(filePath), processDirectory);
+    forEachAncestorDirectory(getDirectoryPath(fileName), processDirectory);
     return result;
   }
   /** @internal */
   getNearestAncestorDirectoryWithPackageJson(fileName) {
     return forEachAncestorDirectory(fileName, (directory) => {
-      switch (this.packageJsonCache.directoryHasPackageJson(this.toPath(directory))) {
+      switch (this.packageJsonCache.directoryHasPackageJson(directory)) {
         case -1 /* True */:
           return directory;
         case 0 /* False */:
@@ -182485,41 +182541,54 @@ Dynamic files must always be opened with service's current directory or service
     });
   }
   /** @internal */
-  watchPackageJsonFile(path) {
-    const watchers = this.packageJsonFilesMap || (this.packageJsonFilesMap = /* @__PURE__ */ new Map());
-    if (!watchers.has(path)) {
-      this.invalidateProjectPackageJson(path);
-      watchers.set(
-        path,
-        this.watchFactory.watchFile(
-          path,
-          (fileName, eventKind) => {
-            const path2 = this.toPath(fileName);
-            switch (eventKind) {
-              case 0 /* Created */:
-                return Debug.fail();
-              case 1 /* Changed */:
-                this.packageJsonCache.addOrUpdate(path2);
-                this.invalidateProjectPackageJson(path2);
-                break;
-              case 2 /* Deleted */:
-                this.packageJsonCache.delete(path2);
-                this.invalidateProjectPackageJson(path2);
-                watchers.get(path2).close();
-                watchers.delete(path2);
-            }
-          },
-          250 /* Low */,
-          this.hostConfiguration.watchOptions,
-          WatchType.PackageJson
-        )
+  watchPackageJsonFile(file, path, project) {
+    Debug.assert(project !== void 0);
+    let result = (this.packageJsonFilesMap ?? (this.packageJsonFilesMap = /* @__PURE__ */ new Map())).get(path);
+    if (!result) {
+      let watcher = this.watchFactory.watchFile(
+        file,
+        (fileName, eventKind) => {
+          switch (eventKind) {
+            case 0 /* Created */:
+              return Debug.fail();
+            case 1 /* Changed */:
+              this.packageJsonCache.addOrUpdate(fileName, path);
+              this.onPackageJsonChange(result);
+              break;
+            case 2 /* Deleted */:
+              this.packageJsonCache.delete(path);
+              this.onPackageJsonChange(result);
+              result.projects.clear();
+              result.close();
+          }
+        },
+        250 /* Low */,
+        this.hostConfiguration.watchOptions,
+        WatchType.PackageJson
       );
+      result = {
+        projects: /* @__PURE__ */ new Set(),
+        close: () => {
+          var _a;
+          if (result.projects.size || !watcher)
+            return;
+          watcher.close();
+          watcher = void 0;
+          (_a = this.packageJsonFilesMap) == null ? void 0 : _a.delete(path);
+          this.packageJsonCache.invalidate(path);
+        }
+      };
+      this.packageJsonFilesMap.set(path, result);
     }
+    result.projects.add(project);
+    (project.packageJsonWatches ?? (project.packageJsonWatches = /* @__PURE__ */ new Set())).add(result);
   }
   /** @internal */
-  onAddPackageJson(path) {
-    this.packageJsonCache.addOrUpdate(path);
-    this.watchPackageJsonFile(path);
+  onPackageJsonChange(result) {
+    result.projects.forEach((project) => {
+      var _a;
+      return (_a = project.onPackageJsonChange) == null ? void 0 : _a.call(project);
+    });
   }
   /** @internal */
   includePackageJsonAutoImports() {
@@ -182533,19 +182602,6 @@ Dynamic files must always be opened with service's current directory or service
     }
   }
   /** @internal */
-  invalidateProjectPackageJson(packageJsonPath) {
-    this.configuredProjects.forEach(invalidate);
-    this.inferredProjects.forEach(invalidate);
-    this.externalProjects.forEach(invalidate);
-    function invalidate(project) {
-      if (packageJsonPath) {
-        project.onPackageJsonChange(packageJsonPath);
-      } else {
-        project.onAutoImportProviderSettingsChanged();
-      }
-    }
-  }
-  /** @internal */
   getIncompleteCompletionsCache() {
     return this.incompleteCompletionsCache || (this.incompleteCompletionsCache = createIncompleteCompletionsCache());
   }
@@ -182603,9 +182659,10 @@ function createModuleSpecifierCache(host) {
         for (const p of modulePaths) {
           if (p.isInNodeModules) {
             const nodeModulesPath = p.path.substring(0, p.path.indexOf(nodeModulesPathPart) + nodeModulesPathPart.length - 1);
-            if (!(containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.has(nodeModulesPath))) {
+            const key2 = host.toPath(nodeModulesPath);
+            if (!(containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.has(key2))) {
               (containedNodeModulesWatchers || (containedNodeModulesWatchers = /* @__PURE__ */ new Map())).set(
-                nodeModulesPath,
+                key2,
                 host.watchNodeModulesForPackageJsonChanges(nodeModulesPath)
               );
             }
@@ -182644,7 +182701,7 @@ function createModuleSpecifierCache(host) {
       }
     },
     clear() {
-      containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.forEach((watcher) => watcher.close());
+      containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.forEach(closeFileWatcher);
       cache == null ? void 0 : cache.clear();
       containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.clear();
       currentKey = void 0;
@@ -182679,34 +182736,38 @@ function createPackageJsonCache(host) {
   const directoriesWithoutPackageJson = /* @__PURE__ */ new Map();
   return {
     addOrUpdate,
-    forEach: packageJsons.forEach.bind(packageJsons),
-    get: packageJsons.get.bind(packageJsons),
+    invalidate,
     delete: (fileName) => {
       packageJsons.delete(fileName);
       directoriesWithoutPackageJson.set(getDirectoryPath(fileName), true);
     },
     getInDirectory: (directory) => {
-      return packageJsons.get(combinePaths(directory, "package.json")) || void 0;
+      return packageJsons.get(host.toPath(combinePaths(directory, "package.json"))) || void 0;
     },
-    directoryHasPackageJson,
+    directoryHasPackageJson: (directory) => directoryHasPackageJson(host.toPath(directory)),
     searchDirectoryAndAncestors: (directory) => {
       forEachAncestorDirectory(directory, (ancestor) => {
-        if (directoryHasPackageJson(ancestor) !== 3 /* Maybe */) {
+        const ancestorPath = host.toPath(ancestor);
+        if (directoryHasPackageJson(ancestorPath) !== 3 /* Maybe */) {
           return true;
         }
-        const packageJsonFileName = host.toPath(combinePaths(ancestor, "package.json"));
+        const packageJsonFileName = combinePaths(ancestor, "package.json");
         if (tryFileExists(host, packageJsonFileName)) {
-          addOrUpdate(packageJsonFileName);
+          addOrUpdate(packageJsonFileName, combinePaths(ancestorPath, "package.json"));
         } else {
-          directoriesWithoutPackageJson.set(ancestor, true);
+          directoriesWithoutPackageJson.set(ancestorPath, true);
         }
       });
     }
   };
-  function addOrUpdate(fileName) {
+  function addOrUpdate(fileName, path) {
     const packageJsonInfo = Debug.checkDefined(createPackageJsonInfo(fileName, host.host));
-    packageJsons.set(fileName, packageJsonInfo);
-    directoriesWithoutPackageJson.delete(getDirectoryPath(fileName));
+    packageJsons.set(path, packageJsonInfo);
+    directoriesWithoutPackageJson.delete(getDirectoryPath(path));
+  }
+  function invalidate(path) {
+    packageJsons.delete(path);
+    directoriesWithoutPackageJson.delete(getDirectoryPath(path));
   }
   function directoryHasPackageJson(directory) {
     return packageJsons.has(combinePaths(directory, "package.json")) ? -1 /* True */ : directoriesWithoutPackageJson.has(directory) ? 0 /* False */ : 3 /* Maybe */;
@@ -189264,6 +189325,7 @@ start(initializeNodeSystem(), require("os").platform());
   isOuterExpression,
   isOutermostOptionalChain,
   isOverrideModifier,
+  isPackageJsonInfo,
   isPackedArrayLiteral,
   isParameter,
   isParameterDeclaration,
@@ -189915,7 +189977,6 @@ start(initializeNodeSystem(), require("os").platform());
   updateErrorForNoInputFiles,
   updateLanguageServiceSourceFile,
   updateMissingFilePathsWatch,
-  updatePackageJsonWatch,
   updateResolutionField,
   updateSharedExtendedConfigFileWatcher,
   updateSourceFile,