@typescript-deploys/pr-build 5.1.0-pr-53489-15 → 5.1.0-pr-51328-50

package/lib/lib.es5.d.ts

@@ -332,9 +332,14 @@ interface CallableFunction extends Function {
     /**
      * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
      * @param thisArg The object to be used as the this object.
-     * @param args An array of argument values to be passed to the function.
      */
     apply<T, R>(this: (this: T) => R, thisArg: T): R;
+
+    /**
+     * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
+     * @param thisArg The object to be used as the this object.
+     * @param args An array of argument values to be passed to the function.
+     */
     apply<T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, args: A): R;
 
     /**
@@ -348,23 +353,29 @@ interface CallableFunction extends Function {
      * For a given function, creates a bound function that has the same body as the original function.
      * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
      * @param thisArg The object to be used as the this object.
-     * @param args Arguments to bind to the parameters of the function.
      */
     bind<T>(this: T, thisArg: ThisParameterType<T>): OmitThisParameter<T>;
-    bind<T, A0, A extends any[], R>(this: (this: T, arg0: A0, ...args: A) => R, thisArg: T, arg0: A0): (...args: A) => R;
-    bind<T, A0, A1, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1): (...args: A) => R;
-    bind<T, A0, A1, A2, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2): (...args: A) => R;
-    bind<T, A0, A1, A2, A3, A extends any[], R>(this: (this: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R, thisArg: T, arg0: A0, arg1: A1, arg2: A2, arg3: A3): (...args: A) => R;
-    bind<T, AX, R>(this: (this: T, ...args: AX[]) => R, thisArg: T, ...args: AX[]): (...args: AX[]) => R;
+
+    /**
+     * For a given function, creates a bound function that has the same body as the original function.
+     * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
+     * @param thisArg The object to be used as the this object.
+     * @param args Arguments to bind to the parameters of the function.
+     */
+    bind<T, A extends any[], B extends any[], R>(this: (this: T, ...args: [...A, ...B]) => R, thisArg: T, ...args: A): (...args: B) => R;
 }
 
 interface NewableFunction extends Function {
     /**
      * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
      * @param thisArg The object to be used as the this object.
-     * @param args An array of argument values to be passed to the function.
      */
     apply<T>(this: new () => T, thisArg: T): void;
+    /**
+     * Calls the function with the specified object as the this value and the elements of specified array as the arguments.
+     * @param thisArg The object to be used as the this object.
+     * @param args An array of argument values to be passed to the function.
+     */
     apply<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, args: A): void;
 
     /**
@@ -378,14 +389,16 @@ interface NewableFunction extends Function {
      * For a given function, creates a bound function that has the same body as the original function.
      * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
      * @param thisArg The object to be used as the this object.
-     * @param args Arguments to bind to the parameters of the function.
      */
     bind<T>(this: T, thisArg: any): T;
-    bind<A0, A extends any[], R>(this: new (arg0: A0, ...args: A) => R, thisArg: any, arg0: A0): new (...args: A) => R;
-    bind<A0, A1, A extends any[], R>(this: new (arg0: A0, arg1: A1, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1): new (...args: A) => R;
-    bind<A0, A1, A2, A extends any[], R>(this: new (arg0: A0, arg1: A1, arg2: A2, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1, arg2: A2): new (...args: A) => R;
-    bind<A0, A1, A2, A3, A extends any[], R>(this: new (arg0: A0, arg1: A1, arg2: A2, arg3: A3, ...args: A) => R, thisArg: any, arg0: A0, arg1: A1, arg2: A2, arg3: A3): new (...args: A) => R;
-    bind<AX, R>(this: new (...args: AX[]) => R, thisArg: any, ...args: AX[]): new (...args: AX[]) => R;
+
+    /**
+     * For a given function, creates a bound function that has the same body as the original function.
+     * The this object of the bound function is associated with the specified object, and has the specified initial parameters.
+     * @param thisArg The object to be used as the this object.
+     * @param args Arguments to bind to the parameters of the function.
+     */
+    bind<A extends any[], B extends any[], R>(this: new (...args: [...A, ...B]) => R, thisArg: any, ...args: A): new (...args: B) => R;
 }
 
 interface IArguments {

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230412`;
+var version = `${versionMajorMinor}.0-insiders.20230413`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5294,6 +5294,10 @@ 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;
 }
@@ -5442,11 +5446,11 @@ function getPathComponents(path, currentDirectory = "") {
   path = combinePaths(currentDirectory, path);
   return pathComponents(path, getRootLength(path));
 }
-function getPathFromPathComponents(pathComponents2) {
+function getPathFromPathComponents(pathComponents2, length2) {
   if (pathComponents2.length === 0)
     return "";
   const root = pathComponents2[0] && ensureTrailingDirectorySeparator(pathComponents2[0]);
-  return root + pathComponents2.slice(1).join(directorySeparator);
+  return root + pathComponents2.slice(1, length2).join(directorySeparator);
 }
 function normalizeSlashes(path) {
   return path.indexOf("\\") !== -1 ? path.replace(backslashRegExp, directorySeparator) : path;
@@ -7741,7 +7745,8 @@ var Diagnostics = {
   _0_is_possibly_null_or_undefined: diag(18049, 1 /* Error */, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."),
   The_value_0_cannot_be_used_here: diag(18050, 1 /* Error */, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here."),
   Compiler_option_0_cannot_be_given_an_empty_string: diag(18051, 1 /* Error */, "Compiler_option_0_cannot_be_given_an_empty_string_18051", "Compiler option '{0}' cannot be given an empty string."),
-  Non_abstract_class_0_does_not_implement_all_abstract_members_of_1: diag(18052, 1 /* Error */, "Non_abstract_class_0_does_not_implement_all_abstract_members_of_1_18052", "Non-abstract class '{0}' does not implement all abstract members of '{1}'")
+  Non_abstract_class_0_does_not_implement_all_abstract_members_of_1: diag(18052, 1 /* Error */, "Non_abstract_class_0_does_not_implement_all_abstract_members_of_1_18052", "Non-abstract class '{0}' does not implement all abstract members of '{1}'"),
+  Its_type_0_is_not_a_valid_JSX_element_type: diag(18053, 1 /* Error */, "Its_type_0_is_not_a_valid_JSX_element_type_18053", "Its type '{0}' is not a valid JSX element type.")
 };
 
 // src/compiler/scanner.ts
@@ -18559,7 +18564,7 @@ function createNodeFactory(flags, baseFactory2) {
   function createBigIntLiteral(value) {
     const node = createBaseToken(10 /* BigIntLiteral */);
     node.text = typeof value === "string" ? value : pseudoBigIntToString(value) + "n";
-    node.transformFlags |= 4 /* ContainsESNext */;
+    node.transformFlags |= 32 /* ContainsES2020 */;
     return node;
   }
   function createBaseStringLiteral(text, isSingleQuote) {
@@ -20069,7 +20074,7 @@ function createNodeFactory(flags, baseFactory2) {
         node.transformFlags |= 1024 /* ContainsES2015 */;
         break;
       case 102 /* ImportKeyword */:
-        node.transformFlags |= 4 /* ContainsESNext */;
+        node.transformFlags |= 32 /* ContainsES2020 */;
         break;
       default:
         return Debug.assertNever(keywordToken);
@@ -20597,7 +20602,7 @@ function createNodeFactory(flags, baseFactory2) {
   function createNamespaceExport(name) {
     const node = createBaseDeclaration(279 /* NamespaceExport */);
     node.name = name;
-    node.transformFlags |= propagateChildFlags(node.name) | 4 /* ContainsESNext */;
+    node.transformFlags |= propagateChildFlags(node.name) | 32 /* ContainsES2020 */;
     node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
     return node;
   }
@@ -44749,11 +44754,6 @@ function createTypeChecker(host) {
         diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
       } else if (result.flags & 256 /* RegularEnum */) {
         diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-      } else {
-        Debug.assert(!!(result.flags & 128 /* ConstEnum */));
-        if (shouldPreserveConstEnums(compilerOptions)) {
-          diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
-        }
       }
       if (diagnosticMessage) {
         addRelatedInfo(
@@ -54064,35 +54064,7 @@ function createTypeChecker(host) {
     return emptyArray;
   }
   function getSignaturesOfType(type, kind) {
-    const result = getSignaturesOfStructuredType(getReducedApparentType(type), kind);
-    if (kind === 0 /* Call */ && !length(result) && type.flags & 1048576 /* Union */) {
-      if (type.arrayFallbackSignatures) {
-        return type.arrayFallbackSignatures;
-      }
-      let memberName;
-      if (everyType(type, (t) => {
-        var _a2;
-        return !!((_a2 = t.symbol) == null ? void 0 : _a2.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
-      })) {
-        const arrayArg = mapType(type, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
-        const arrayType = createArrayType(arrayArg, someType(type, (t) => isReadonlyArraySymbol(t.symbol.parent)));
-        return type.arrayFallbackSignatures = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
-      }
-      type.arrayFallbackSignatures = result;
-    }
-    return result;
-  }
-  function isArrayOrTupleSymbol(symbol) {
-    if (!symbol || !globalArrayType.symbol || !globalReadonlyArrayType.symbol) {
-      return false;
-    }
-    return !!getSymbolIfSameReference(symbol, globalArrayType.symbol) || !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
-  }
-  function isReadonlyArraySymbol(symbol) {
-    if (!symbol || !globalReadonlyArrayType.symbol) {
-      return false;
-    }
-    return !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
+    return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
   }
   function findIndexInfo(indexInfos, keyType) {
     return find(indexInfos, (info) => info.keyType === keyType);
@@ -68196,6 +68168,12 @@ function createTypeChecker(host) {
       return getUnionType([jsxElementType, nullType]);
     }
   }
+  function getJsxElementTypeTypeAt(location) {
+    const type = getJsxType(JsxNames.ElementType, location);
+    if (isErrorType(type))
+      return void 0;
+    return type;
+  }
   function getJsxIntrinsicTagNamesAt(location) {
     const intrinsics = getJsxType(JsxNames.IntrinsicElements, location);
     return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
@@ -68258,7 +68236,22 @@ function createTypeChecker(host) {
       const jsxOpeningLikeNode = node;
       const sig = getResolvedSignature(jsxOpeningLikeNode);
       checkDeprecatedSignature(sig, node);
-      checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(jsxOpeningLikeNode), getReturnTypeOfSignature(sig), jsxOpeningLikeNode);
+      const elementTypeConstraint = getJsxElementTypeTypeAt(jsxOpeningLikeNode);
+      if (elementTypeConstraint !== void 0) {
+        const tagName = jsxOpeningLikeNode.tagName;
+        const tagType = isJsxIntrinsicIdentifier(tagName) ? getStringLiteralType(tagName.escapedText) : checkExpression(tagName);
+        checkTypeRelatedTo(tagType, elementTypeConstraint, assignableRelation, tagName, Diagnostics.Its_type_0_is_not_a_valid_JSX_element_type, () => {
+          const componentName = getTextOfNode(tagName);
+          return chainDiagnosticMessages(
+            /*details*/
+            void 0,
+            Diagnostics._0_cannot_be_used_as_a_JSX_component,
+            componentName
+          );
+        });
+      } else {
+        checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(jsxOpeningLikeNode), getReturnTypeOfSignature(sig), jsxOpeningLikeNode);
+      }
     }
   }
   function isKnownProperty(targetType, name, isComparingJsxAttributes) {
@@ -83017,6 +83010,7 @@ var JsxNames;
   JsxNames2.ElementAttributesPropertyNameContainer = "ElementAttributesProperty";
   JsxNames2.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute";
   JsxNames2.Element = "Element";
+  JsxNames2.ElementType = "ElementType";
   JsxNames2.IntrinsicAttributes = "IntrinsicAttributes";
   JsxNames2.IntrinsicClassAttributes = "IntrinsicClassAttributes";
   JsxNames2.LibraryManagedAttributes = "LibraryManagedAttributes";
@@ -118132,60 +118126,62 @@ function removeIgnoredPath(path) {
   }
   return some(ignoredPaths, (searchPath) => stringContains(path, searchPath)) ? void 0 : path;
 }
-function canWatchDirectoryOrFile(dirPath) {
-  const rootLength = getRootLength(dirPath);
-  if (dirPath.length === rootLength) {
-    return false;
-  }
-  let nextDirectorySeparator = dirPath.indexOf(directorySeparator, rootLength);
-  if (nextDirectorySeparator === -1) {
-    return false;
-  }
-  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);
+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 (isNonDirectorySeparatorRoot && pathPartForUserCheck.search(/users\//i) !== 0) {
-    return true;
+  if (isDosStyle && !pathComponents2[userCheckIndex].match(/^users$/i)) {
+    return userCheckIndex;
   }
-  for (let searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) {
-    searchIndex = dirPath.indexOf(directorySeparator, searchIndex) + 1;
-    if (searchIndex === 0) {
-      return false;
-    }
-  }
-  return true;
+  return userCheckIndex + 2;
 }
-function canWatchAtTypes(atTypes, rootPath) {
-  const dirPath = getDirectoryPath(getDirectoryPath(atTypes));
-  return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
+function canWatchDirectoryOrFile(pathComponents2, length2) {
+  if (length2 === void 0)
+    length2 = pathComponents2.length;
+  if (length2 <= 2)
+    return false;
+  const perceivedOsRootLength = perceivedOsRootLengthForWatching(pathComponents2, length2);
+  return length2 > perceivedOsRootLength + 1;
 }
-function isInDirectoryPath(dir, file) {
-  if (dir === void 0 || file.length <= dir.length) {
+function canWatchAtTypes(atTypes) {
+  return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes));
+}
+function isInDirectoryPath(dirComponents, fileOrDirComponents) {
+  if (fileOrDirComponents.length < fileOrDirComponents.length)
     return false;
+  for (let i = 0; i < dirComponents.length; i++) {
+    if (fileOrDirComponents[i] !== dirComponents[i])
+      return false;
   }
-  return startsWith(file, dir) && file[dir.length] === directorySeparator;
+  return true;
+}
+function canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(fileOrDirPath) {
+  return canWatchDirectoryOrFile(getPathComponents(fileOrDirPath));
 }
 function canWatchAffectingLocation(filePath) {
-  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)
-      };
+  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));
     } else {
       return {
         dir: rootDir,
@@ -118195,45 +118191,55 @@ function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLoo
     }
   }
   return getDirectoryToWatchFromFailedLookupLocationDirectory(
-    getDirectoryPath(getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory())),
-    getDirectoryPath(failedLookupLocationPath),
-    rootPath
+    failedLookupComponents,
+    failedLookupPathComponents,
+    failedLookupPathComponents.length - 1,
+    perceivedOsRootLength,
+    nodeModulesIndex,
+    rootPathComponents
   );
 }
-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;
+function getDirectoryToWatchFromFailedLookupLocationDirectory(dirComponents, dirPathComponents, dirPathComponentsLength, perceivedOsRootLength, nodeModulesIndex, rootPathComponents) {
+  if (nodeModulesIndex !== -1) {
+    return getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, nodeModulesIndex + 1);
   }
   let nonRecursive = true;
-  let subDirectoryPath, subDirectory;
-  if (rootPath !== void 0) {
-    while (!isInDirectoryPath(dirPath, rootPath)) {
-      const parentPath = getDirectoryPath(dirPath);
-      if (parentPath === dirPath) {
-        break;
-      }
+  let length2 = dirPathComponentsLength;
+  for (let i = 0; i < dirPathComponentsLength; i++) {
+    if (dirPathComponents[i] !== rootPathComponents[i]) {
       nonRecursive = false;
-      subDirectoryPath = dirPath;
-      subDirectory = dir;
-      dirPath = parentPath;
-      dir = getDirectoryPath(dir);
+      length2 = Math.max(i + 1, perceivedOsRootLength + 1);
+      break;
     }
   }
-  return canWatchDirectoryOrFile(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive } : void 0;
+  return getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, length2, nonRecursive);
 }
-function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, filterCustomPath) {
-  if (isInDirectoryPath(rootPath, typeRootPath)) {
+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)) {
     return rootPath;
   }
-  const toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(typeRoot, typeRootPath, 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
+  );
   return toWatch && filterCustomPath(toWatch.dirPath) ? toWatch.dirPath : void 0;
 }
 function getRootDirectoryOfResolutionCache(rootDirForResolution, getCurrentDirectory) {
-  return rootDirForResolution && removeTrailingDirectorySeparator(getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory()));
+  const normalized = getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory());
+  return !isDiskPathRoot(normalized) ? removeTrailingDirectorySeparator(normalized) : normalized;
 }
 function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
   let filesWithChangedSetOfUnresolvedImports;
@@ -118265,13 +118271,11 @@ 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 = rootDir && resolutionHost.toPath(rootDir);
-  const rootSplitLength = rootPath !== void 0 ? rootPath.split(directorySeparator).length : 0;
+  const rootPath = resolutionHost.toPath(rootDir);
+  const rootPathComponents = getPathComponents(rootPath);
   const typeRootsWatches = /* @__PURE__ */ new Map();
   return {
     getModuleResolutionCache: () => moduleResolutionCache,
@@ -118305,7 +118309,6 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function clear2() {
     clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
     clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
-    customFailedLookupPaths.clear();
     nonRelativeExternalModuleResolutions.clear();
     closeTypeRootsWatch();
     resolvedModuleNames.clear();
@@ -118585,9 +118588,6 @@ 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) {
@@ -118628,15 +118628,11 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           failedLookupLocationPath,
           rootDir,
           rootPath,
-          rootSplitLength,
+          rootPathComponents,
           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;
@@ -118771,20 +118767,11 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           failedLookupLocationPath,
           rootDir,
           rootPath,
-          rootSplitLength,
+          rootPathComponents,
           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 {
@@ -118882,10 +118869,10 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         (failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
         (startsWithPathChecks || (startsWithPathChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
       } else {
-        if (!isPathWithDefaultFailedLookupExtension(fileOrDirectoryPath) && !customFailedLookupPaths.has(fileOrDirectoryPath)) {
+        if (isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) {
           return false;
         }
-        if (isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) {
+        if (fileExtensionIs(fileOrDirectoryPath, ".map")) {
           return false;
         }
         (failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
@@ -118932,7 +118919,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()) || [], (fileOrDirectoryPath) => isInDirectoryPath(fileOrDirectoryPath, locationPath) ? 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()) || [], (dirPath) => locationPath.length > dirPath.length && startsWith(locationPath, dirPath) && (isDiskPathRoot(dirPath) || locationPath[dirPath.length] === directorySeparator) ? true : void 0);
   }
   function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
     var _a2;
@@ -118953,6 +118940,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         typeRoot,
         typeRootPath,
         rootPath,
+        rootPathComponents,
+        getCurrentDirectory,
         (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2)
       );
       if (dirPath) {
@@ -118983,7 +118972,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function canWatchTypeRootPath(typeRoot) {
     if (resolutionHost.getCompilationSettings().typeRoots)
       return true;
-    return canWatchAtTypes(resolutionHost.toPath(typeRoot), rootPath);
+    return canWatchAtTypes(resolutionHost.toPath(typeRoot));
   }
 }
 function resolutionIsSymlink(resolution) {