@typescript-deploys/pr-build 5.1.0-pr-53591-4 → 5.1.0-pr-53739-12

package/lib/lib.es5.d.ts

@@ -1832,7 +1832,7 @@ interface DataView {
 
 interface DataViewConstructor {
     readonly prototype: DataView;
-    new(buffer: ArrayBufferLike, byteOffset?: number, byteLength?: number): DataView;
+    new(buffer: ArrayBufferLike & { BYTES_PER_ELEMENT?: never }, byteOffset?: number, byteLength?: number): DataView;
 }
 declare var DataView: DataViewConstructor;
 

package/lib/tsc.js

@@ -5294,10 +5294,6 @@ function isAnyDirectorySeparator(charCode) {
 function isRootedDiskPath(path) {
   return getEncodedRootLength(path) > 0;
 }
-function isDiskPathRoot(path) {
-  const rootLength = getEncodedRootLength(path);
-  return rootLength > 0 && rootLength === path.length;
-}
 function pathIsAbsolute(path) {
   return getEncodedRootLength(path) !== 0;
 }
@@ -5446,11 +5442,11 @@ function getPathComponents(path, currentDirectory = "") {
   path = combinePaths(currentDirectory, path);
   return pathComponents(path, getRootLength(path));
 }
-function getPathFromPathComponents(pathComponents2, length2) {
+function getPathFromPathComponents(pathComponents2) {
   if (pathComponents2.length === 0)
     return "";
   const root = pathComponents2[0] && ensureTrailingDirectorySeparator(pathComponents2[0]);
-  return root + pathComponents2.slice(1, length2).join(directorySeparator);
+  return root + pathComponents2.slice(1).join(directorySeparator);
 }
 function normalizeSlashes(path) {
   return path.indexOf("\\") !== -1 ? path.replace(backslashRegExp, directorySeparator) : path;
@@ -42572,6 +42568,7 @@ function isInstantiatedModule(node, preserveConstEnums) {
   const moduleState = getModuleInstanceState(node);
   return moduleState === 1 /* Instantiated */ || preserveConstEnums && moduleState === 2 /* ConstEnumOnly */;
 }
+var UNION_CROSS_PRODUCT_SIZE_LIMIT = 1e5;
 function createTypeChecker(host) {
   var getPackagesMap = memoize(() => {
     var map2 = /* @__PURE__ */ new Map();
@@ -51744,7 +51741,12 @@ function createTypeChecker(host) {
     if (!links.type) {
       Debug.assertIsDefined(links.deferralParent);
       Debug.assertIsDefined(links.deferralConstituents);
-      links.type = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents);
+      const operation = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType : getIntersectionType;
+      let result = operation(links.deferralConstituents);
+      for (const part of links.deferredMismatchedParts || emptyArray) {
+        result = operation([result, getTypeOfSymbol(part)]);
+      }
+      links.type = result;
     }
     return links.type;
   }
@@ -51752,8 +51754,12 @@ function createTypeChecker(host) {
     const links = getSymbolLinks(symbol);
     if (!links.writeType && links.deferralWriteConstituents) {
       Debug.assertIsDefined(links.deferralParent);
-      Debug.assertIsDefined(links.deferralConstituents);
-      links.writeType = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralWriteConstituents) : getIntersectionType(links.deferralWriteConstituents);
+      const operation = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType : getIntersectionType;
+      let result = operation(links.deferralWriteConstituents);
+      for (const part of links.deferredMismatchedParts || emptyArray) {
+        result = operation([result, getTypeOfSymbol(part)]);
+      }
+      links.writeType = result;
     }
     return links.writeType;
   }
@@ -53790,7 +53796,7 @@ function createTypeChecker(host) {
     return getReducedType(getApparentType(getReducedType(type)));
   }
   function createUnionOrIntersectionProperty(containingType, name, skipObjectFunctionPropertyAugment) {
-    var _a2, _b, _c;
+    var _a2, _b, _c, _d;
     let singleProp;
     let propSet;
     let indexTypes;
@@ -53872,8 +53878,9 @@ function createTypeChecker(host) {
     let declarations;
     let firstType;
     let nameType;
-    const propTypes = [];
+    let propTypes = [];
     let writeTypes;
+    let deferredMismatchedParts;
     let firstValueDeclaration;
     let hasNonUniformValueDeclaration = false;
     for (const prop of props) {
@@ -53883,6 +53890,24 @@ function createTypeChecker(host) {
         hasNonUniformValueDeclaration = true;
       }
       declarations = addRange(declarations, prop.declarations);
+      if (getCheckFlags(prop) & 65536 /* DeferredType */) {
+        checkFlags |= getCheckFlags(prop) & (131072 /* HasNeverType */ | 64 /* HasNonUniformType */ | 128 /* HasLiteralType */);
+        if (!nameType) {
+          nameType = getSymbolLinks(prop).nameType;
+        }
+        if ((((_d = getSymbolLinks(prop).deferralParent) == null ? void 0 : _d.flags) & 3145728 /* UnionOrIntersection */) === (containingType.flags & 3145728 /* UnionOrIntersection */)) {
+          const deferredWriteTypes = getSymbolLinks(prop).deferralWriteConstituents;
+          if (deferredWriteTypes) {
+            writeTypes = concatenate(!writeTypes ? propTypes.slice() : writeTypes, deferredWriteTypes);
+          }
+          propTypes = concatenate(propTypes, getSymbolLinks(prop).deferralConstituents);
+          deferredMismatchedParts = concatenate(deferredMismatchedParts, getSymbolLinks(prop).deferredMismatchedParts);
+          break;
+        } else {
+          deferredMismatchedParts = append(deferredMismatchedParts, prop);
+          break;
+        }
+      }
       const type = getTypeOfSymbol(prop);
       if (!firstType) {
         firstType = type;
@@ -53913,11 +53938,12 @@ function createTypeChecker(host) {
     }
     result.declarations = declarations;
     result.links.nameType = nameType;
-    if (propTypes.length > 2) {
+    if (propTypes.length > 2 || deferredMismatchedParts) {
       result.links.checkFlags |= 65536 /* DeferredType */;
       result.links.deferralParent = containingType;
       result.links.deferralConstituents = propTypes;
       result.links.deferralWriteConstituents = writeTypes;
+      result.links.deferredMismatchedParts = deferredMismatchedParts;
     } else {
       result.links.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
       if (writeTypes) {
@@ -56274,7 +56300,7 @@ function createTypeChecker(host) {
   function getIntersectionType(types, aliasSymbol, aliasTypeArguments, noSupertypeReduction) {
     const typeMembershipMap = /* @__PURE__ */ new Map();
     const includes = addTypesToIntersection(typeMembershipMap, 0, types);
-    const typeSet = arrayFrom(typeMembershipMap.values());
+    let typeSet = arrayFrom(typeMembershipMap.values());
     if (includes & 131072 /* Never */) {
       return contains(typeSet, silentNeverType) ? silentNeverType : neverType;
     }
@@ -56306,6 +56332,8 @@ function createTypeChecker(host) {
     const id = getTypeListId(typeSet) + getAliasId(aliasSymbol, aliasTypeArguments);
     let result = intersectionTypes.get(id);
     if (!result) {
+      const originalSet = typeSet;
+      let runningResult;
       if (includes & 1048576 /* Union */) {
         if (intersectUnionsOfPrimitiveTypes(typeSet)) {
           result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
@@ -56317,12 +56345,32 @@ function createTypeChecker(host) {
           removeFromEach(typeSet, 65536 /* Null */);
           result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
         } else {
+          if (getCrossProductUnionSize(typeSet) >= UNION_CROSS_PRODUCT_SIZE_LIMIT && every(typeSet, (t) => !!(t.flags & 1048576 /* Union */) || !!(t.flags & 402784252 /* Primitive */))) {
+            if (typeSet.length > 2 || some(typeSet, (t) => getReducedType(t) !== t)) {
+              runningResult = getReducedType(typeSet[0]);
+              for (let i = 1; i < typeSet.length; i++) {
+                const reducedElem = getReducedType(typeSet[i]);
+                runningResult = reducedElem.flags & 402784252 /* Primitive */ && everyType(runningResult, (t) => !!(t.flags & 524288 /* Object */)) ? neverType : getReducedType(intersectTypes(runningResult, reducedElem));
+                if (i === typeSet.length - 1 || isTypeAny(runningResult) || runningResult.flags & 131072 /* Never */) {
+                  return runningResult;
+                }
+                if (!(runningResult.flags & 1048576 /* Union */) || runningResult.types.length > typeSet.length) {
+                  typeSet = typeSet.slice(i + 1);
+                  break;
+                }
+              }
+            }
+          }
           if (!checkCrossProductUnion(typeSet)) {
             return errorType;
           }
           const constituents = getCrossProductIntersections(typeSet);
-          const origin = some(constituents, (t) => !!(t.flags & 2097152 /* Intersection */)) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : void 0;
-          result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
+          if (runningResult && runningResult !== typeSet[0]) {
+            result = getIntersectionType([runningResult, getUnionType(constituents, 1 /* Literal */)], aliasSymbol, aliasTypeArguments);
+          } else {
+            const origin = some(constituents, (t) => !!(t.flags & 2097152 /* Intersection */)) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, originalSet) : void 0;
+            result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
+          }
         }
       } else {
         result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
@@ -56337,7 +56385,7 @@ function createTypeChecker(host) {
   function checkCrossProductUnion(types) {
     var _a2;
     const size = getCrossProductUnionSize(types);
-    if (size >= 1e5) {
+    if (size >= UNION_CROSS_PRODUCT_SIZE_LIMIT) {
       (_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "checkCrossProductUnion_DepthLimit", { typeIds: types.map((t) => t.id), size });
       error(currentNode, Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
       return false;
@@ -118112,62 +118160,60 @@ function removeIgnoredPath(path) {
   }
   return some(ignoredPaths, (searchPath) => stringContains(path, searchPath)) ? void 0 : path;
 }
-function perceivedOsRootLengthForWatching(pathComponents2, length2) {
-  if (length2 <= 1)
-    return 1;
-  let userCheckIndex = 1;
-  let isDosStyle = pathComponents2[0].search(/[a-zA-Z]:/) === 0;
-  if (pathComponents2[0] !== directorySeparator && !isDosStyle && // Non dos style paths
-  pathComponents2[1].search(/[a-zA-Z]\$$/) === 0) {
-    if (length2 === 2)
-      return 2;
-    userCheckIndex = 2;
-    isDosStyle = true;
-  }
-  if (isDosStyle && !pathComponents2[userCheckIndex].match(/^users$/i)) {
-    return userCheckIndex;
-  }
-  return userCheckIndex + 2;
-}
-function canWatchDirectoryOrFile(pathComponents2, length2) {
-  if (length2 === void 0)
-    length2 = pathComponents2.length;
-  if (length2 <= 2)
+function canWatchDirectoryOrFile(dirPath) {
+  const rootLength = getRootLength(dirPath);
+  if (dirPath.length === rootLength) {
     return false;
-  const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents2, length2);
-  return length2 > perceivedOsRootLength + 1;
-}
-function canWatchAtTypes(atTypes) {
-  return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes));
-}
-function isInDirectoryPath(dirComponents, fileOrDirComponents) {
-  if (fileOrDirComponents.length < fileOrDirComponents.length)
+  }
+  let nextDirectorySeparator = dirPath.indexOf(directorySeparator, rootLength);
+  if (nextDirectorySeparator === -1) {
     return false;
-  for (let i = 0; i < dirComponents.length; i++) {
-    if (fileOrDirComponents[i] !== dirComponents[i])
+  }
+  let pathPartForUserCheck = dirPath.substring(rootLength, nextDirectorySeparator + 1);
+  const isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47 /* slash */;
+  if (isNonDirectorySeparatorRoot && dirPath.search(/[a-zA-Z]:/) !== 0 && // Non dos style paths
+  pathPartForUserCheck.search(/[a-zA-Z]\$\//) === 0) {
+    nextDirectorySeparator = dirPath.indexOf(directorySeparator, nextDirectorySeparator + 1);
+    if (nextDirectorySeparator === -1) {
       return false;
+    }
+    pathPartForUserCheck = dirPath.substring(rootLength + pathPartForUserCheck.length, nextDirectorySeparator + 1);
+  }
+  if (isNonDirectorySeparatorRoot && pathPartForUserCheck.search(/users\//i) !== 0) {
+    return true;
+  }
+  for (let searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) {
+    searchIndex = dirPath.indexOf(directorySeparator, searchIndex) + 1;
+    if (searchIndex === 0) {
+      return false;
+    }
   }
   return true;
 }
-function canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(fileOrDirPath) {
-  return canWatchDirectoryOrFile(getPathComponents(fileOrDirPath));
+function canWatchAtTypes(atTypes, rootPath) {
+  const dirPath = getDirectoryPath(getDirectoryPath(atTypes));
+  return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
+}
+function isInDirectoryPath(dir, file) {
+  if (dir === void 0 || file.length <= dir.length) {
+    return false;
+  }
+  return startsWith(file, dir) && file[dir.length] === directorySeparator;
 }
 function canWatchAffectingLocation(filePath) {
-  return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(filePath);
-}
-function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath, rootDir, rootPath, rootPathComponents, getCurrentDirectory) {
-  const failedLookupPathComponents = getPathComponents(failedLookupLocationPath);
-  failedLookupLocation = isRootedDiskPath(failedLookupLocation) ? normalizePath(failedLookupLocation) : getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory());
-  const failedLookupComponents = getPathComponents(failedLookupLocation);
-  const perceivedOsRootLength = perceivedOsRootLengthForWatching(failedLookupPathComponents, failedLookupPathComponents.length);
-  if (failedLookupPathComponents.length <= perceivedOsRootLength + 1)
-    return void 0;
-  const nodeModulesIndex = failedLookupPathComponents.indexOf("node_modules");
-  if (nodeModulesIndex !== -1 && nodeModulesIndex + 1 <= perceivedOsRootLength + 1)
-    return void 0;
-  if (isInDirectoryPath(rootPathComponents, failedLookupPathComponents)) {
-    if (failedLookupPathComponents.length > rootPathComponents.length + 1) {
-      return getDirectoryOfFailedLookupWatch(failedLookupComponents, failedLookupPathComponents, Math.max(rootPathComponents.length + 1, perceivedOsRootLength + 1));
+  return canWatchDirectoryOrFile(filePath);
+}
+function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath, rootDir, rootPath, rootSplitLength, getCurrentDirectory) {
+  if (isInDirectoryPath(rootPath, failedLookupLocationPath)) {
+    failedLookupLocation = isRootedDiskPath(failedLookupLocation) ? normalizePath(failedLookupLocation) : getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory());
+    const failedLookupPathSplit = failedLookupLocationPath.split(directorySeparator);
+    const failedLookupSplit = failedLookupLocation.split(directorySeparator);
+    Debug.assert(failedLookupSplit.length === failedLookupPathSplit.length, `FailedLookup: ${failedLookupLocation} failedLookupLocationPath: ${failedLookupLocationPath}`);
+    if (failedLookupPathSplit.length > rootSplitLength + 1) {
+      return {
+        dir: failedLookupSplit.slice(0, rootSplitLength + 1).join(directorySeparator),
+        dirPath: failedLookupPathSplit.slice(0, rootSplitLength + 1).join(directorySeparator)
+      };
     } else {
       return {
         dir: rootDir,
@@ -118177,55 +118223,45 @@ function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLoo
     }
   }
   return getDirectoryToWatchFromFailedLookupLocationDirectory(
-    failedLookupComponents,
-    failedLookupPathComponents,
-    failedLookupPathComponents.length - 1,
-    perceivedOsRootLength,
-    nodeModulesIndex,
-    rootPathComponents
+    getDirectoryPath(getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory())),
+    getDirectoryPath(failedLookupLocationPath),
+    rootPath
   );
 }
-function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dirPathComponents, dirPathComponentsLength, perceivedOsRootLength, nodeModulesIndex, rootPathComponents) {
-  if (nodeModulesIndex !== -1) {
-    return getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, nodeModulesIndex + 1);
+function getDirectoryToWatchFromFailedLookupLocationDirectory(dir, dirPath, rootPath) {
+  while (pathContainsNodeModules(dirPath)) {
+    dir = getDirectoryPath(dir);
+    dirPath = getDirectoryPath(dirPath);
+  }
+  if (isNodeModulesDirectory(dirPath)) {
+    return canWatchDirectoryOrFile(getDirectoryPath(dirPath)) ? { dir, dirPath } : void 0;
   }
   let nonRecursive = true;
-  let length2 = dirPathComponentsLength;
-  for (let i = 0; i < dirPathComponentsLength; i++) {
-    if (dirPathComponents[i] !== rootPathComponents[i]) {
+  let subDirectoryPath, subDirectory;
+  if (rootPath !== void 0) {
+    while (!isInDirectoryPath(dirPath, rootPath)) {
+      const parentPath = getDirectoryPath(dirPath);
+      if (parentPath === dirPath) {
+        break;
+      }
       nonRecursive = false;
-      length2 = Math.max(i + 1, perceivedOsRootLength + 1);
-      break;
+      subDirectoryPath = dirPath;
+      subDirectory = dir;
+      dirPath = parentPath;
+      dir = getDirectoryPath(dir);
     }
   }
-  return getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, length2, nonRecursive);
+  return canWatchDirectoryOrFile(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive } : void 0;
 }
-function getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, length2, nonRecursive) {
-  return {
-    dir: getPathFromPathComponents(dirComponents, length2),
-    dirPath: getPathFromPathComponents(dirPathComponents, length2),
-    nonRecursive
-  };
-}
-function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, rootPathComponents, getCurrentDirectory, filterCustomPath) {
-  const typeRootPathComponents = getPathComponents(typeRootPath);
-  if (isInDirectoryPath(rootPathComponents, typeRootPathComponents)) {
+function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, filterCustomPath) {
+  if (isInDirectoryPath(rootPath, typeRootPath)) {
     return rootPath;
   }
-  typeRoot = isRootedDiskPath(typeRoot) ? normalizePath(typeRoot) : getNormalizedAbsolutePath(typeRoot, getCurrentDirectory());
-  const toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(
-    getPathComponents(typeRoot),
-    typeRootPathComponents,
-    typeRootPathComponents.length,
-    perceivedOsRootLengthForWatching(typeRootPathComponents, typeRootPathComponents.length),
-    typeRootPathComponents.indexOf("node_modules"),
-    rootPathComponents
-  );
+  const toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(typeRoot, typeRootPath, rootPath);
   return toWatch && filterCustomPath(toWatch.dirPath) ? toWatch.dirPath : void 0;
 }
 function getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory) {
-  const normalized = getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory());
-  return !isDiskPathRoot(normalized) ? removeTrailingDirectorySeparator(normalized) : normalized;
+  return rootDirForResolution && removeTrailingDirectorySeparator(getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory()));
 }
 function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
   let filesWithChangedSetOfUnresolvedImports;
@@ -118257,11 +118293,13 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     resolutionHost.getCompilationSettings(),
     moduleResolutionCache.getPackageJsonInfoCache()
   );
+  const failedLookupDefaultExtensions = [".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */, ".json" /* Json */];
+  const customFailedLookupPaths = /* @__PURE__ */ new Map();
   const directoryWatchesOfFailedLookups = /* @__PURE__ */ new Map();
   const fileWatchesOfAffectingLocations = /* @__PURE__ */ new Map();
   const rootDir = getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory);
-  const rootPath = resolutionHost.toPath(rootDir);
-  const rootPathComponents = getPathComponents(rootPath);
+  const rootPath = rootDir && resolutionHost.toPath(rootDir);
+  const rootSplitLength = rootPath !== void 0 ? rootPath.split(directorySeparator).length : 0;
   const typeRootsWatches = /* @__PURE__ */ new Map();
   return {
     getModuleResolutionCache: () => moduleResolutionCache,
@@ -118295,6 +118333,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function clear2() {
     clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
     clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
+    customFailedLookupPaths.clear();
     nonRelativeExternalModuleResolutions.clear();
     closeTypeRootsWatch();
     resolvedModuleNames.clear();
@@ -118574,6 +118613,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function isNodeModulesAtTypesDirectory(dirPath) {
     return endsWith(dirPath, "/node_modules/@types");
   }
+  function isPathWithDefaultFailedLookupExtension(path) {
+    return fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
+  }
   function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName) {
     var _a2, _b;
     if (resolution.refCount) {
@@ -118614,11 +118656,15 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           failedLookupLocationPath,
           rootDir,
           rootPath,
-          rootPathComponents,
+          rootSplitLength,
           getCurrentDirectory
         );
         if (toWatch) {
           const { dir, dirPath, nonRecursive } = toWatch;
+          if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) {
+            const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
+            customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
+          }
           if (dirPath === rootPath) {
             Debug.assert(nonRecursive);
             setAtRoot = true;
@@ -118753,11 +118799,20 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           failedLookupLocationPath,
           rootDir,
           rootPath,
-          rootPathComponents,
+          rootSplitLength,
           getCurrentDirectory
         );
         if (toWatch) {
           const { dirPath } = toWatch;
+          const refCount = customFailedLookupPaths.get(failedLookupLocationPath);
+          if (refCount) {
+            if (refCount === 1) {
+              customFailedLookupPaths.delete(failedLookupLocationPath);
+            } else {
+              Debug.assert(refCount > 1);
+              customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1);
+            }
+          }
           if (dirPath === rootPath) {
             removeAtRoot = true;
           } else {
@@ -118855,10 +118910,10 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         (failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
         (startsWithPathChecks || (startsWithPathChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
       } else {
-        if (isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) {
+        if (!isPathWithDefaultFailedLookupExtension(fileOrDirectoryPath) && !customFailedLookupPaths.has(fileOrDirectoryPath)) {
           return false;
         }
-        if (fileExtensionIs(fileOrDirectoryPath, ".map")) {
+        if (isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) {
           return false;
         }
         (failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
@@ -118905,7 +118960,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     return (_a2 = resolution.failedLookupLocations) == null ? void 0 : _a2.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)));
   }
   function isInvalidatedFailedLookup(locationPath) {
-    return (failedLookupChecks == null ? void 0 : failedLookupChecks.has(locationPath)) || firstDefinedIterator((startsWithPathChecks == null ? void 0 : startsWithPathChecks.keys()) || [], (fileOrDirectoryPath) => startsWith(locationPath, fileOrDirectoryPath) ? true : void 0) || firstDefinedIterator((isInDirectoryChecks == null ? void 0 : isInDirectoryChecks.keys()) || [], (dirPath) => locationPath.length > dirPath.length && startsWith(locationPath, dirPath) && (isDiskPathRoot(dirPath) || locationPath[dirPath.length] === directorySeparator) ? true : void 0);
+    return (failedLookupChecks == null ? void 0 : failedLookupChecks.has(locationPath)) || firstDefinedIterator((startsWithPathChecks == null ? void 0 : startsWithPathChecks.keys()) || [], (fileOrDirectoryPath) => startsWith(locationPath, fileOrDirectoryPath) ? true : void 0) || firstDefinedIterator((isInDirectoryChecks == null ? void 0 : isInDirectoryChecks.keys()) || [], (fileOrDirectoryPath) => isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : void 0);
   }
   function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
     var _a2;
@@ -118926,8 +118981,6 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         typeRoot,
         typeRootPath,
         rootPath,
-        rootPathComponents,
-        getCurrentDirectory,
         (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2)
       );
       if (dirPath) {
@@ -118958,7 +119011,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function canWatchTypeRootPath(typeRoot) {
     if (resolutionHost.getCompilationSettings().typeRoots)
       return true;
-    return canWatchAtTypes(resolutionHost.toPath(typeRoot));
+    return canWatchAtTypes(resolutionHost.toPath(typeRoot), rootPath);
   }
 }
 function resolutionIsSymlink(resolution) {