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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20231127`;
+      version = `${versionMajorMinor}.0-dev.20231128`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -17329,19 +17329,19 @@ ${lanes.join("\n")}
   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));
       }
@@ -33709,8 +33709,9 @@ ${lanes.join("\n")}
         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();
@@ -34407,7 +34408,7 @@ ${lanes.join("\n")}
             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;
           }
@@ -37549,34 +37550,39 @@ ${lanes.join("\n")}
       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];
             }
           }
         }
@@ -37584,6 +37590,9 @@ ${lanes.join("\n")}
     }
     return wildcardDirectories;
   }
+  function toCanonicalKey(path, useCaseSensitiveFileNames2) {
+    return useCaseSensitiveFileNames2 ? path : toFileNameLowerCase(path);
+  }
   function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames2) {
     const match = wildcardDirectoryPattern.exec(spec);
     if (match) {
@@ -37591,13 +37600,16 @@ ${lanes.join("\n")}
       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 */
       };
     }
@@ -39790,6 +39802,9 @@ ${lanes.join("\n")}
     }
     return result;
   }
+  function isPackageJsonInfo(entry) {
+    return !!(entry == null ? void 0 : entry.contents);
+  }
   function compilerOptionValueToString(value) {
     var _a;
     if (value === null || typeof value !== "object") {
@@ -39894,7 +39909,7 @@ ${lanes.join("\n")}
   }
   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));
     }
@@ -39904,10 +39919,6 @@ ${lanes.join("\n")}
     function clear2() {
       cache = void 0;
     }
-    function entries() {
-      const iter = cache == null ? void 0 : cache.entries();
-      return iter ? arrayFrom(iter) : [];
-    }
     function getInternalMap() {
       return cache;
     }
@@ -40910,13 +40921,13 @@ ${lanes.join("\n")}
     }
     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;
@@ -40938,7 +40949,7 @@ ${lanes.join("\n")}
         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);
     }
   }
@@ -44970,8 +44981,8 @@ ${lanes.join("\n")}
     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,
@@ -44986,7 +44997,7 @@ ${lanes.join("\n")}
   }
   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,
@@ -45048,7 +45059,7 @@ ${lanes.join("\n")}
     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,
@@ -45062,7 +45073,7 @@ ${lanes.join("\n")}
     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)),
@@ -45126,16 +45137,22 @@ ${lanes.join("\n")}
     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 */) {
@@ -45160,7 +45177,7 @@ ${lanes.join("\n")}
     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;
@@ -45233,8 +45250,9 @@ ${lanes.join("\n")}
     });
     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) {
@@ -45242,30 +45260,29 @@ ${lanes.join("\n")}
       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) => {
@@ -45286,7 +45303,10 @@ ${lanes.join("\n")}
       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);
@@ -45446,7 +45466,7 @@ ${lanes.join("\n")}
     }
     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;
     }
@@ -45490,7 +45510,7 @@ ${lanes.join("\n")}
     }
     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);
@@ -45503,7 +45523,7 @@ ${lanes.join("\n")}
       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)) {
@@ -56992,9 +57012,13 @@ ${lanes.join("\n")}
     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;
@@ -110941,8 +110965,8 @@ ${lanes.join("\n")}
             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)) {
@@ -118405,8 +118429,8 @@ ${lanes.join("\n")}
       }
       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();
@@ -118488,23 +118512,10 @@ ${lanes.join("\n")}
       }
     });
   }
-  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,
@@ -118515,18 +118526,22 @@ ${lanes.join("\n")}
     );
   }
   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),
@@ -119350,7 +119365,8 @@ ${lanes.join("\n")}
       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))
@@ -119557,7 +119573,7 @@ ${lanes.join("\n")}
     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;
@@ -119676,12 +119692,10 @@ ${lanes.join("\n")}
           });
         }
       }
-      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) {
@@ -119726,8 +119740,7 @@ ${lanes.join("\n")}
       getSourceFile,
       getSourceFileByPath,
       getSourceFiles: () => files,
-      getMissingFilePaths: () => missingFilePaths,
-      // TODO: GH#18217
+      getMissingFilePaths: () => missingFileNames,
       getModuleResolutionCache: () => moduleResolutionCache,
       getFilesByNameMap: () => filesByName,
       getCompilerOptions: () => options,
@@ -120154,7 +120167,7 @@ ${lanes.join("\n")}
       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();
@@ -120294,7 +120307,7 @@ ${lanes.join("\n")}
         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);
@@ -120351,7 +120364,7 @@ ${lanes.join("\n")}
           const path = toPath3(f);
           if (getSourceFileByPath(path))
             return true;
-          if (contains(missingFilePaths, path))
+          if (missingFileNames.has(path))
             return false;
           return host.fileExists(f);
         },
@@ -121163,6 +121176,7 @@ ${lanes.join("\n")}
             addFileToFilesByName(
               file2,
               path,
+              fileName,
               /*redirectedPath*/
               void 0
             );
@@ -121235,7 +121249,7 @@ ${lanes.join("\n")}
         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);
@@ -121245,7 +121259,7 @@ ${lanes.join("\n")}
           sourceFileToPackageName.set(path, packageIdToPackageName(packageId));
         }
       }
-      addFileToFilesByName(file, path, redirectedPath);
+      addFileToFilesByName(file, path, fileName, redirectedPath);
       if (file) {
         sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
         file.fileName = fileName;
@@ -121285,14 +121299,21 @@ ${lanes.join("\n")}
       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);
@@ -121613,6 +121634,7 @@ ${lanes.join("\n")}
             /*file*/
             void 0,
             sourceFilePath,
+            refPath,
             /*redirectedPath*/
             void 0
           );
@@ -121624,6 +121646,7 @@ ${lanes.join("\n")}
         addFileToFilesByName(
           sourceFile,
           sourceFilePath,
+          refPath,
           /*redirectedPath*/
           void 0
         );
@@ -121633,6 +121656,7 @@ ${lanes.join("\n")}
         addFileToFilesByName(
           sourceFile,
           sourceFilePath,
+          refPath,
           /*redirectedPath*/
           void 0
         );
@@ -125611,8 +125635,8 @@ ${lanes.join("\n")}
     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);
@@ -125621,7 +125645,7 @@ ${lanes.join("\n")}
         resolutionHost.onChangedAutomaticTypeDirectiveNames();
         const dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(
           typeRoot,
-          typeRootPath,
+          resolutionHost.toPath(typeRoot),
           rootPath,
           rootPathComponents,
           getCurrentDirectory,
@@ -125642,7 +125666,7 @@ ${lanes.join("\n")}
       if (typeRoots) {
         mutateMap(
           typeRootsWatches,
-          arrayToMap(typeRoots, (tr) => resolutionHost.toPath(tr)),
+          new Set(typeRoots),
           {
             createNewValue: createTypeRootsWatch,
             onDeleteValue: closeFileWatcher
@@ -126609,7 +126633,11 @@ ${lanes.join("\n")}
       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();
       }
@@ -126902,8 +126930,15 @@ ${lanes.join("\n")}
         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);
@@ -126915,15 +126950,11 @@ ${lanes.join("\n")}
       }
     }
     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(
@@ -126995,7 +127026,7 @@ ${lanes.join("\n")}
       );
     }
     function watchReferencedProject(configFileName2, configPath, commandLine) {
-      var _a, _b, _c, _d, _e;
+      var _a, _b, _c, _d;
       commandLine.watcher || (commandLine.watcher = watchFile2(
         configFileName2,
         (_fileName, eventKind) => {
@@ -127010,55 +127041,50 @@ ${lanes.join("\n")}
         ((_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
       );
     }
@@ -127396,9 +127422,9 @@ ${lanes.join("\n")}
   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 };
@@ -127410,6 +127436,7 @@ ${lanes.join("\n")}
     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,
@@ -127658,7 +127685,7 @@ ${lanes.join("\n")}
       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);
@@ -127687,12 +127714,13 @@ ${lanes.join("\n")}
         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);
       }
@@ -128425,9 +128453,10 @@ ${lanes.join("\n")}
     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;
@@ -128784,7 +128813,7 @@ ${lanes.join("\n")}
       return;
     updateWatchingWildcardDirectories(
       getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath),
-      new Map(Object.entries(parsed.wildcardDirectories)),
+      parsed.wildcardDirectories,
       (dir, flags) => state.watchDirectory(
         dir,
         (fileOrDirectory) => {
@@ -128816,9 +128845,9 @@ ${lanes.join("\n")}
       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 */),
@@ -128836,11 +128865,11 @@ ${lanes.join("\n")}
       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,
@@ -134803,7 +134832,7 @@ ${lanes.join("\n")}
         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;
       });
     }
   }
@@ -135660,11 +135689,11 @@ ${lanes.join("\n")}
       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;
@@ -138237,7 +138266,7 @@ ${lanes.join("\n")}
           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))));
@@ -138315,7 +138344,7 @@ ${lanes.join("\n")}
           };
           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);
@@ -138450,7 +138479,7 @@ ${lanes.join("\n")}
   }
   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*/
@@ -165157,6 +165186,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             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);
         }
@@ -174826,6 +174859,7 @@ ${options.prefix}` : "\n" : options.prefix
           return path === options.configFilePath ? options.configFile : this.getSourceFile(path);
         }
         close() {
+          var _a;
           this.projectService.typingsCache.onProjectClosed(this);
           this.closeWatchingTypingLocations();
           this.cleanupProgram();
@@ -174842,6 +174876,12 @@ ${options.prefix}` : "\n" : options.prefix
           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;
@@ -175036,13 +175076,10 @@ ${options.prefix}` : "\n" : options.prefix
           }
         }
         /** @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 */
@@ -175257,7 +175294,7 @@ ${options.prefix}` : "\n" : options.prefix
               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);
@@ -175371,7 +175408,7 @@ ${options.prefix}` : "\n" : options.prefix
             }
           }
         }
-        addMissingFileWatcher(missingFilePath) {
+        addMissingFileWatcher(missingFilePath, missingFileName) {
           var _a;
           if (isConfiguredProject(this)) {
             const configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(missingFilePath);
@@ -175379,7 +175416,7 @@ ${options.prefix}` : "\n" : options.prefix
               return noopFileWatcher;
           }
           const fileWatcher = this.projectService.watchFactory.watchFile(
-            missingFilePath,
+            getNormalizedAbsolutePath(missingFileName, this.currentDirectory),
             (fileName, eventKind) => {
               if (isConfiguredProject(this)) {
                 this.getCachedDirectoryStructureHost().addOrDeleteFile(fileName, missingFilePath, eventKind);
@@ -175716,7 +175753,7 @@ ${options.prefix}` : "\n" : options.prefix
         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) {
@@ -175724,9 +175761,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         /** @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() {
@@ -175812,7 +175847,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         /** @internal */
         watchNodeModulesForPackageJsonChanges(directoryPath) {
-          return this.projectService.watchPackageJsonsInNodeModules(this.toPath(directoryPath), this);
+          return this.projectService.watchPackageJsonsInNodeModules(directoryPath, this);
         }
         /** @internal */
         getIncompleteCompletionsCache() {
@@ -177387,18 +177422,20 @@ ${options.prefix}` : "\n" : options.prefix
          * @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,
@@ -177443,6 +177480,22 @@ ${options.prefix}` : "\n" : options.prefix
             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) {
@@ -178187,7 +178240,7 @@ ${options.prefix}` : "\n" : options.prefix
             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)
             );
@@ -178269,7 +178322,7 @@ ${options.prefix}` : "\n" : options.prefix
                 if (value.info) {
                   project.removeFile(
                     value.info,
-                    project.fileExists(path),
+                    project.fileExists(value.info.fileName),
                     /*detachFromProject*/
                     true
                   );
@@ -178501,7 +178554,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,
@@ -178512,12 +178565,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;
@@ -178526,14 +178579,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) {
@@ -178555,30 +178608,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: () => {
@@ -178588,7 +178646,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);
@@ -178852,10 +178910,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) {
@@ -179774,10 +179831,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)) {
@@ -179786,7 +179842,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);
@@ -179795,13 +179851,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 */:
@@ -179812,41 +179868,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() {
@@ -179860,19 +179929,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());
         }
@@ -179905,9 +179961,10 @@ Dynamic files must always be opened with service's current directory or service
           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)
                 );
               }
@@ -179946,7 +180003,7 @@ Dynamic files must always be opened with service's current directory or service
         }
       },
       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;
@@ -179987,34 +180044,38 @@ Dynamic files must always be opened with service's current directory or service
     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 */;
@@ -186032,6 +186093,7 @@ ${e.message}`;
     isOuterExpression: () => isOuterExpression,
     isOutermostOptionalChain: () => isOutermostOptionalChain,
     isOverrideModifier: () => isOverrideModifier,
+    isPackageJsonInfo: () => isPackageJsonInfo,
     isPackedArrayLiteral: () => isPackedArrayLiteral,
     isParameter: () => isParameter,
     isParameterDeclaration: () => isParameterDeclaration,
@@ -186683,7 +186745,6 @@ ${e.message}`;
     updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
     updateLanguageServiceSourceFile: () => updateLanguageServiceSourceFile,
     updateMissingFilePathsWatch: () => updateMissingFilePathsWatch,
-    updatePackageJsonWatch: () => updatePackageJsonWatch,
     updateResolutionField: () => updateResolutionField,
     updateSharedExtendedConfigFileWatcher: () => updateSharedExtendedConfigFileWatcher,
     updateSourceFile: () => updateSourceFile,
@@ -188444,6 +188505,7 @@ ${e.message}`;
     isOuterExpression: () => isOuterExpression,
     isOutermostOptionalChain: () => isOutermostOptionalChain,
     isOverrideModifier: () => isOverrideModifier,
+    isPackageJsonInfo: () => isPackageJsonInfo,
     isPackedArrayLiteral: () => isPackedArrayLiteral,
     isParameter: () => isParameter,
     isParameterDeclaration: () => isParameterDeclaration,
@@ -189095,7 +189157,6 @@ ${e.message}`;
     updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
     updateLanguageServiceSourceFile: () => updateLanguageServiceSourceFile,
     updateMissingFilePathsWatch: () => updateMissingFilePathsWatch,
-    updatePackageJsonWatch: () => updatePackageJsonWatch,
     updateResolutionField: () => updateResolutionField,
     updateSharedExtendedConfigFileWatcher: () => updateSharedExtendedConfigFileWatcher,
     updateSourceFile: () => updateSourceFile,