typescript 5.1.0-dev.20230412 → 5.1.0-dev.20230414

package/lib/tsserver.js

@@ -980,6 +980,7 @@ __export(server_exports, {
   getRootDeclaration: () => getRootDeclaration,
   getRootDirectoryOfResolutionCache: () => getRootDirectoryOfResolutionCache,
   getRootLength: () => getRootLength,
+  getRootPathSplitLength: () => getRootPathSplitLength,
   getScriptKind: () => getScriptKind,
   getScriptKindFromFileName: () => getScriptKindFromFileName,
   getScriptTargetFeatures: () => getScriptTargetFeatures,
@@ -2293,7 +2294,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230412`;
+var version = `${versionMajorMinor}.0-dev.20230414`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -8937,11 +8938,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;
@@ -22747,7 +22748,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) {
@@ -24257,7 +24258,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);
@@ -24785,7 +24786,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;
   }
@@ -49399,11 +49400,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(
@@ -66231,40 +66227,31 @@ function createTypeChecker(host) {
     return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
   }
   function getBestMatchingType(source, target, isRelatedTo = compareTypesAssignable) {
-    return findMatchingDiscriminantType(
-      source,
-      target,
-      isRelatedTo,
-      /*skipPartial*/
-      true
-    ) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
+    return findMatchingDiscriminantType(source, target, isRelatedTo) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
   }
-  function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
-    const discriminable = target.types.map((_) => void 0);
+  function discriminateTypeByDiscriminableItems(target, discriminators, related) {
+    const types = target.types;
+    const include = types.map((t) => t.flags & 402784252 /* Primitive */ ? 0 /* False */ : -1 /* True */);
     for (const [getDiscriminatingType, propertyName] of discriminators) {
-      const targetProp = getUnionOrIntersectionProperty(target, propertyName);
-      if (skipPartial && targetProp && getCheckFlags(targetProp) & 16 /* ReadPartial */) {
-        continue;
+      let matched = false;
+      for (let i = 0; i < types.length; i++) {
+        if (include[i]) {
+          const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+          if (targetType && related(getDiscriminatingType(), targetType)) {
+            matched = true;
+          } else {
+            include[i] = 3 /* Maybe */;
+          }
+        }
       }
-      let i = 0;
-      for (const type of target.types) {
-        const targetType = getTypeOfPropertyOfType(type, propertyName);
-        if (targetType && related(getDiscriminatingType(), targetType)) {
-          discriminable[i] = discriminable[i] === void 0 ? true : discriminable[i];
-        } else {
-          discriminable[i] = false;
+      for (let i = 0; i < types.length; i++) {
+        if (include[i] === 3 /* Maybe */) {
+          include[i] = matched ? 0 /* False */ : -1 /* True */;
         }
-        i++;
       }
     }
-    const match = discriminable.indexOf(
-      /*searchElement*/
-      true
-    );
-    if (match === -1) {
-      return defaultValue;
-    }
-    return getUnionType(target.types.filter((_, index) => discriminable[index]));
+    const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i])) : target;
+    return filtered.flags & 131072 /* Never */ ? target : filtered;
   }
   function isWeakType(type) {
     if (type.flags & 524288 /* Object */) {
@@ -71568,8 +71555,7 @@ function createTypeChecker(host) {
           (s) => [() => undefinedType, s.escapedName]
         )
       ),
-      isTypeAssignableTo,
-      contextualType
+      isTypeAssignableTo
     );
   }
   function discriminateContextualTypeByJSXAttributes(node, contextualType) {
@@ -71588,8 +71574,7 @@ function createTypeChecker(host) {
           (s) => [() => undefinedType, s.escapedName]
         )
       ),
-      isTypeAssignableTo,
-      contextualType
+      isTypeAssignableTo
     );
   }
   function getApparentTypeOfContextualType(node, contextFlags) {
@@ -87603,7 +87588,7 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
+  function findMatchingDiscriminantType(source, target, isRelatedTo) {
     if (target.flags & 1048576 /* Union */ && source.flags & (2097152 /* Intersection */ | 524288 /* Object */)) {
       const match = getMatchingUnionConstituentForType(target, source);
       if (match) {
@@ -87613,14 +87598,10 @@ function createTypeChecker(host) {
       if (sourceProperties) {
         const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
         if (sourcePropertiesFiltered) {
-          return discriminateTypeByDiscriminableItems(
-            target,
-            map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]),
-            isRelatedTo,
-            /*defaultValue*/
-            void 0,
-            skipPartial
-          );
+          const discriminated = discriminateTypeByDiscriminableItems(target, map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]), isRelatedTo);
+          if (discriminated !== target) {
+            return discriminated;
+          }
         }
       }
     }
@@ -123037,60 +123018,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);
-  }
-  if (isNonDirectorySeparatorRoot && pathPartForUserCheck.search(/users\//i) !== 0) {
-    return true;
+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;
   }
-  for (let searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) {
-    searchIndex = dirPath.indexOf(directorySeparator, searchIndex) + 1;
-    if (searchIndex === 0) {
-      return false;
-    }
+  if (isDosStyle && !pathComponents2[userCheckIndex].match(/^users$/i)) {
+    return userCheckIndex;
   }
-  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,
@@ -123100,45 +123083,58 @@ 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 getRootPathSplitLength(rootPath) {
+  return rootPath.split(directorySeparator).length - (hasTrailingDirectorySeparator(rootPath) ? 1 : 0);
 }
 function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
   let filesWithChangedSetOfUnresolvedImports;
@@ -123170,13 +123166,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,
@@ -123210,7 +123204,6 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function clear2() {
     clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
     clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
-    customFailedLookupPaths.clear();
     nonRelativeExternalModuleResolutions.clear();
     closeTypeRootsWatch();
     resolvedModuleNames.clear();
@@ -123490,9 +123483,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) {
@@ -123533,15 +123523,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;
@@ -123676,20 +123662,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 {
@@ -123787,10 +123764,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);
@@ -123837,7 +123814,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;
@@ -123858,6 +123835,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         typeRoot,
         typeRootPath,
         rootPath,
+        rootPathComponents,
+        getCurrentDirectory,
         (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2)
       );
       if (dirPath) {
@@ -123888,7 +123867,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) {
@@ -127746,7 +127725,8 @@ function getDefaultFormatCodeSettings(newLineCharacter) {
     placeOpenBraceOnNewLineForFunctions: false,
     placeOpenBraceOnNewLineForControlBlocks: false,
     semicolons: "ignore" /* Ignore */,
-    trimTrailingWhitespace: true
+    trimTrailingWhitespace: true,
+    indentSwitchCase: true
   };
 }
 var testFormatSettings = getDefaultFormatCodeSettings("\n");
@@ -128924,7 +128904,13 @@ function findPrecedingToken(position, sourceFile, startNode2, excludeJsdoc) {
             sourceFile,
             n.kind
           );
-          return candidate2 && findRightmostToken(candidate2, sourceFile);
+          if (candidate2) {
+            if (!excludeJsdoc && isJSDocCommentContainingNode(candidate2) && candidate2.getChildren(sourceFile).length) {
+              return find2(candidate2);
+            }
+            return findRightmostToken(candidate2, sourceFile);
+          }
+          return void 0;
         } else {
           return find2(child);
         }
@@ -156196,7 +156182,7 @@ function getDefinitionAtPosition(program, sourceFile, position, searchOtherFiles
       false,
       failedAliasResolution
     )) : emptyArray;
-    return concatenate(definitions, getDefinitionFromObjectLiteralElement(typeChecker, node) || emptyArray);
+    return concatenate(definitions, getDefinitionFromObjectLiteralElement(typeChecker, node));
   }
   if (isPropertyName(node) && isBindingElement(parent2) && isObjectBindingPattern(parent2.parent) && node === (parent2.propertyName || parent2.name)) {
     const name = getNameFromPropertyName(node);
@@ -156206,7 +156192,8 @@ function getDefinitionAtPosition(program, sourceFile, position, searchOtherFiles
       return prop && getDefinitionFromSymbol(typeChecker, prop, node);
     });
   }
-  return concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution));
+  const objectLiteralElementDefinition = getDefinitionFromObjectLiteralElement(typeChecker, node);
+  return concatenate(fileReferenceDefinition, objectLiteralElementDefinition.length ? objectLiteralElementDefinition : getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution));
 }
 function symbolMatchesSignature(s, calledDeclaration) {
   var _a2;
@@ -156226,6 +156213,7 @@ function getDefinitionFromObjectLiteralElement(typeChecker, node) {
       ), (propertySymbol) => getDefinitionFromSymbol(typeChecker, propertySymbol, node));
     }
   }
+  return emptyArray;
 }
 function getDefinitionFromOverriddenMember(typeChecker, node) {
   const classElement = findAncestor(node, isClassElement);
@@ -168608,6 +168596,7 @@ var SmartIndenter;
   }
   SmartIndenter2.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn;
   function nodeWillIndentChild(settings, parent2, child, sourceFile, indentByDefault) {
+    var _a2;
     const childKind = child ? child.kind : 0 /* Unknown */;
     switch (parent2.kind) {
       case 243 /* ExpressionStatement */:
@@ -168623,9 +168612,6 @@ var SmartIndenter;
       case 186 /* TypeLiteral */:
       case 199 /* MappedType */:
       case 188 /* TupleType */:
-      case 268 /* CaseBlock */:
-      case 295 /* DefaultClause */:
-      case 294 /* CaseClause */:
       case 216 /* ParenthesizedExpression */:
       case 210 /* PropertyAccessExpression */:
       case 212 /* CallExpression */:
@@ -168654,7 +168640,11 @@ var SmartIndenter;
       case 280 /* ExportSpecifier */:
       case 275 /* ImportSpecifier */:
       case 171 /* PropertyDeclaration */:
+      case 294 /* CaseClause */:
+      case 295 /* DefaultClause */:
         return true;
+      case 268 /* CaseBlock */:
+        return (_a2 = settings.indentSwitchCase) != null ? _a2 : true;
       case 259 /* VariableDeclaration */:
       case 301 /* PropertyAssignment */:
       case 225 /* BinaryExpression */:
@@ -169683,6 +169673,7 @@ __export(ts_exports2, {
   getRootDeclaration: () => getRootDeclaration,
   getRootDirectoryOfResolutionCache: () => getRootDirectoryOfResolutionCache,
   getRootLength: () => getRootLength,
+  getRootPathSplitLength: () => getRootPathSplitLength,
   getScriptKind: () => getScriptKind,
   getScriptKindFromFileName: () => getScriptKindFromFileName,
   getScriptTargetFeatures: () => getScriptTargetFeatures,
@@ -172807,7 +172798,7 @@ var Project3 = class {
     this.globalCacheResolutionModuleName = ts_JsTyping_exports.nonRelativeModuleNameForTypingCache;
     this.projectName = projectName;
     this.directoryStructureHost = directoryStructureHost;
-    this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory || "");
+    this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory);
     this.getCanonicalFileName = this.projectService.toCanonicalFileName;
     this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds);
     if (!this.compilerOptions) {
@@ -172844,7 +172835,7 @@ var Project3 = class {
     this.realpath = maybeBind(host, host.realpath);
     this.resolutionCache = createResolutionCache(
       this,
-      currentDirectory && this.currentDirectory,
+      this.currentDirectory,
       /*logChangesWhenResolvingModule*/
       true
     );
@@ -174230,7 +174221,7 @@ var Project3 = class {
   getNoDtsResolutionProject(rootFileNames) {
     Debug.assert(this.projectService.serverMode === 0 /* Semantic */);
     if (!this.noDtsResolutionProject) {
-      this.noDtsResolutionProject = new AuxiliaryProject(this.projectService, this.documentRegistry, this.getCompilerOptionsForNoDtsResolutionProject());
+      this.noDtsResolutionProject = new AuxiliaryProject(this.projectService, this.documentRegistry, this.getCompilerOptionsForNoDtsResolutionProject(), this.currentDirectory);
     }
     enumerateInsertsAndDeletes(
       rootFileNames.map(toNormalizedPath),
@@ -174383,7 +174374,7 @@ var InferredProject2 = class extends Project3 {
   }
 };
 var AuxiliaryProject = class extends Project3 {
-  constructor(projectService, documentRegistry, compilerOptions) {
+  constructor(projectService, documentRegistry, compilerOptions, currentDirectory) {
     super(
       projectService.newAuxiliaryProjectName(),
       4 /* Auxiliary */,
@@ -174399,8 +174390,7 @@ var AuxiliaryProject = class extends Project3 {
       /*watchOptions*/
       void 0,
       projectService.host,
-      /*currentDirectory*/
-      void 0
+      currentDirectory
     );
   }
   isOrphan() {
@@ -176020,7 +176010,7 @@ var _ProjectService = class {
     Debug.checkDefined(configFileExistenceInfo.watcher);
     if ((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) {
       if (this.configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo)) {
-        if (!canWatchDirectoryOrFile(getDirectoryPath(canonicalConfigFilePath))) {
+        if (!canWatchDirectoryOrFile(getPathComponents(getDirectoryPath(canonicalConfigFilePath)))) {
           configFileExistenceInfo.watcher.close();
           configFileExistenceInfo.watcher = noopConfigFileWatcher;
         }
@@ -176080,7 +176070,7 @@ var _ProjectService = class {
         this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo);
       }
       (configFileExistenceInfo.openFilesImpactedByConfigFile || (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Map())).set(info.path, true);
-      configFileExistenceInfo.watcher || (configFileExistenceInfo.watcher = canWatchDirectoryOrFile(getDirectoryPath(canonicalConfigFilePath)) ? this.watchFactory.watchFile(
+      configFileExistenceInfo.watcher || (configFileExistenceInfo.watcher = canWatchDirectoryOrFile(getPathComponents(getDirectoryPath(canonicalConfigFilePath))) ? this.watchFactory.watchFile(
         configFileName,
         (_filename, eventKind) => this.onConfigFileChanged(canonicalConfigFilePath, eventKind),
         2e3 /* High */,
@@ -176709,15 +176699,14 @@ var _ProjectService = class {
       return this.inferredProjects[0];
     }
     return this.createInferredProject(
-      /*currentDirectory*/
-      void 0,
+      "",
       /*isSingleInferredProject*/
       true
     );
   }
   getOrCreateSingleInferredWithoutProjectRoot(currentDirectory) {
     Debug.assert(!this.useSingleInferredProject);
-    const expectedCurrentDirectory = this.toCanonicalFileName(this.getNormalizedAbsolutePath(currentDirectory || ""));
+    const expectedCurrentDirectory = this.toCanonicalFileName(this.getNormalizedAbsolutePath(currentDirectory));
     for (const inferredProject of this.inferredProjects) {
       if (!inferredProject.projectRootPath && inferredProject.isOrphan() && inferredProject.canonicalCurrentDirectory === expectedCurrentDirectory) {
         return inferredProject;
@@ -184118,6 +184107,7 @@ start(initializeNodeSystem(), require("os").platform());
   getRootDeclaration,
   getRootDirectoryOfResolutionCache,
   getRootLength,
+  getRootPathSplitLength,
   getScriptKind,
   getScriptKindFromFileName,
   getScriptTargetFeatures,