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

package/lib/typescript.d.ts

@@ -6594,6 +6594,7 @@ declare namespace ts {
         readonly insertSpaceBeforeTypeAnnotation?: boolean;
         readonly indentMultiLineObjectLiteralBeginningOnBlankLine?: boolean;
         readonly semicolons?: SemicolonPreference;
+        readonly indentSwitchCase?: boolean;
     }
     interface DefinitionInfo extends DocumentSpan {
         kind: ScriptElementKind;

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230412`;
+      version = `${versionMajorMinor}.0-dev.20230414`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6737,11 +6737,11 @@ ${lanes.join("\n")}
     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;
@@ -20595,7 +20595,7 @@ ${lanes.join("\n")}
     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) {
@@ -22105,7 +22105,7 @@ ${lanes.join("\n")}
           node.transformFlags |= 1024 /* ContainsES2015 */;
           break;
         case 102 /* ImportKeyword */:
-          node.transformFlags |= 4 /* ContainsESNext */;
+          node.transformFlags |= 32 /* ContainsES2020 */;
           break;
         default:
           return Debug.assertNever(keywordToken);
@@ -22633,7 +22633,7 @@ ${lanes.join("\n")}
     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;
     }
@@ -47200,11 +47200,6 @@ ${lanes.join("\n")}
           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(
@@ -64032,40 +64027,31 @@ ${lanes.join("\n")}
       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 */) {
@@ -69369,8 +69355,7 @@ ${lanes.join("\n")}
             (s) => [() => undefinedType, s.escapedName]
           )
         ),
-        isTypeAssignableTo,
-        contextualType
+        isTypeAssignableTo
       );
     }
     function discriminateContextualTypeByJSXAttributes(node, contextualType) {
@@ -69389,8 +69374,7 @@ ${lanes.join("\n")}
             (s) => [() => undefinedType, s.escapedName]
           )
         ),
-        isTypeAssignableTo,
-        contextualType
+        isTypeAssignableTo
       );
     }
     function getApparentTypeOfContextualType(node, contextFlags) {
@@ -85404,7 +85388,7 @@ ${lanes.join("\n")}
       }
       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) {
@@ -85414,14 +85398,10 @@ ${lanes.join("\n")}
         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;
+            }
           }
         }
       }
@@ -121201,60 +121181,62 @@ ${lanes.join("\n")}
     }
     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 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 canWatchAtTypes(atTypes, rootPath) {
-    const dirPath = getDirectoryPath(getDirectoryPath(atTypes));
-    return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
+  function canWatchAtTypes(atTypes) {
+    return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(getDirectoryPath(atTypes));
   }
-  function isInDirectoryPath(dir, file) {
-    if (dir === void 0 || file.length <= dir.length) {
+  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,
@@ -121264,45 +121246,58 @@ ${lanes.join("\n")}
       }
     }
     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 getDirectoryOfFailedLookupWatch(dirComponents, dirPathComponents, length2, nonRecursive) {
+    return {
+      dir: getPathFromPathComponents(dirComponents, length2),
+      dirPath: getPathFromPathComponents(dirPathComponents, length2),
+      nonRecursive
+    };
   }
-  function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath, rootPath, filterCustomPath) {
-    if (isInDirectoryPath(rootPath, typeRootPath)) {
+  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;
@@ -121334,13 +121329,11 @@ ${lanes.join("\n")}
       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,
@@ -121374,7 +121367,6 @@ ${lanes.join("\n")}
     function clear2() {
       clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
       clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
-      customFailedLookupPaths.clear();
       nonRelativeExternalModuleResolutions.clear();
       closeTypeRootsWatch();
       resolvedModuleNames.clear();
@@ -121654,9 +121646,6 @@ ${lanes.join("\n")}
     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) {
@@ -121697,15 +121686,11 @@ ${lanes.join("\n")}
             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;
@@ -121840,20 +121825,11 @@ ${lanes.join("\n")}
             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 {
@@ -121951,10 +121927,10 @@ ${lanes.join("\n")}
           (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);
@@ -122001,7 +121977,7 @@ ${lanes.join("\n")}
       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;
@@ -122022,6 +121998,8 @@ ${lanes.join("\n")}
           typeRoot,
           typeRootPath,
           rootPath,
+          rootPathComponents,
+          getCurrentDirectory,
           (dirPath2) => directoryWatchesOfFailedLookups.has(dirPath2)
         );
         if (dirPath) {
@@ -122052,7 +122030,7 @@ ${lanes.join("\n")}
     function canWatchTypeRootPath(typeRoot) {
       if (resolutionHost.getCompilationSettings().typeRoots)
         return true;
-      return canWatchAtTypes(resolutionHost.toPath(typeRoot), rootPath);
+      return canWatchAtTypes(resolutionHost.toPath(typeRoot));
     }
   }
   function resolutionIsSymlink(resolution) {
@@ -125997,7 +125975,8 @@ ${lanes.join("\n")}
       placeOpenBraceOnNewLineForFunctions: false,
       placeOpenBraceOnNewLineForControlBlocks: false,
       semicolons: "ignore" /* Ignore */,
-      trimTrailingWhitespace: true
+      trimTrailingWhitespace: true,
+      indentSwitchCase: true
     };
   }
   var ScriptSnapshot, PackageJsonDependencyGroup, PackageJsonAutoImportPreference, LanguageServiceMode, emptyOptions, SemanticClassificationFormat, OrganizeImportsMode, CompletionTriggerKind, InlayHintKind, HighlightSpanKind, IndentStyle, SemicolonPreference, testFormatSettings, SymbolDisplayPartKind, CompletionInfoFlags, OutliningSpanKind, OutputFileType, EndOfLineState, TokenClass, ScriptElementKind, ScriptElementKindModifier, ClassificationTypeNames, ClassificationType;
@@ -127250,7 +127229,13 @@ ${lanes.join("\n")}
               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);
           }
@@ -155362,7 +155347,7 @@ ${lanes.join("\n")}
         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);
@@ -155372,7 +155357,8 @@ ${lanes.join("\n")}
         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;
@@ -155392,6 +155378,7 @@ ${lanes.join("\n")}
         ), (propertySymbol) => getDefinitionFromSymbol(typeChecker, propertySymbol, node));
       }
     }
+    return emptyArray;
   }
   function getDefinitionFromOverriddenMember(typeChecker, node) {
     const classElement = findAncestor(node, isClassElement);
@@ -168116,6 +168103,7 @@ ${options.prefix}` : "\n" : options.prefix
         }
         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 */:
@@ -168131,9 +168119,6 @@ ${options.prefix}` : "\n" : options.prefix
             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 */:
@@ -168162,7 +168147,11 @@ ${options.prefix}` : "\n" : options.prefix
             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 */:
@@ -169444,6 +169433,7 @@ ${options.prefix}` : "\n" : options.prefix
     getRootDeclaration: () => getRootDeclaration,
     getRootDirectoryOfResolutionCache: () => getRootDirectoryOfResolutionCache,
     getRootLength: () => getRootLength,
+    getRootPathSplitLength: () => getRootPathSplitLength,
     getScriptKind: () => getScriptKind,
     getScriptKindFromFileName: () => getScriptKindFromFileName,
     getScriptTargetFeatures: () => getScriptTargetFeatures,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230412`;
+var version = `${versionMajorMinor}.0-dev.20230414`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4851,11 +4851,11 @@ function getPathComponents(path2, currentDirectory = "") {
   path2 = combinePaths(currentDirectory, path2);
   return pathComponents(path2, getRootLength(path2));
 }
-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(path2) {
   return path2.indexOf("\\") !== -1 ? path2.replace(backslashRegExp, directorySeparator) : path2;
@@ -12942,7 +12942,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) {
@@ -14452,7 +14452,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);
@@ -14980,7 +14980,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;
   }

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.1.0-dev.20230412",
+    "version": "5.1.0-dev.20230414",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -113,5 +113,5 @@
         "node": "14.21.1",
         "npm": "8.19.3"
     },
-    "gitHead": "2db688e36ff57ee1d4f730e124ac340379eae4f0"
+    "gitHead": "3445e58815bae0c1c3752e9d364b56f548fa5634"
 }