typescript 5.0.0-dev.20230206 → 5.0.0-dev.20230207

package/lib/tsserver.js

@@ -1858,6 +1858,7 @@ __export(server_exports, {
   mutateMapSkippingNewValues: () => mutateMapSkippingNewValues,
   needsParentheses: () => needsParentheses,
   needsScopeMarker: () => needsScopeMarker,
+  newCaseClauseTracker: () => newCaseClauseTracker,
   newPrivateEnvironment: () => newPrivateEnvironment,
   noEmitNotification: () => noEmitNotification,
   noEmitSubstitution: () => noEmitSubstitution,
@@ -2286,7 +2287,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230206`;
+var version = `${versionMajorMinor}.0-dev.20230207`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7703,7 +7704,7 @@ function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFi
   function createDirectoryWatcher(dirName, dirPath, fallbackOptions) {
     const watcher = fsWatch(
       dirName,
-      FileSystemEntryKind.Directory,
+      1 /* Directory */,
       (_eventName, relativeFileName, modifiedTime) => {
         if (!isString(relativeFileName))
           return;
@@ -7903,7 +7904,7 @@ function createDirectoryWatcherSupportingRecursive({
   }
   function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
     const parentWatcher = cache.get(dirPath);
-    if (parentWatcher && fileSystemEntryExists(dirName, FileSystemEntryKind.Directory)) {
+    if (parentWatcher && fileSystemEntryExists(dirName, 1 /* Directory */)) {
       scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
       return;
     }
@@ -7968,7 +7969,7 @@ function createDirectoryWatcherSupportingRecursive({
       return false;
     let newChildWatches;
     const hasChanges = enumerateInsertsAndDeletes(
-      fileSystemEntryExists(parentDir, FileSystemEntryKind.Directory) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
+      fileSystemEntryExists(parentDir, 1 /* Directory */) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
         const childFullName = getNormalizedAbsolutePath(child, parentDir);
         return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, normalizePath(realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : void 0;
       }) : emptyArray,
@@ -10735,6 +10736,10 @@ var Diagnostics = {
   Conditions_to_set_in_addition_to_the_resolver_specific_defaults_when_resolving_imports: diag(6410, 3 /* Message */, "Conditions_to_set_in_addition_to_the_resolver_specific_defaults_when_resolving_imports_6410", "Conditions to set in addition to the resolver-specific defaults when resolving imports."),
   true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false: diag(6411, 3 /* Message */, "true_when_moduleResolution_is_node16_nodenext_or_bundler_otherwise_false_6411", "`true` when 'moduleResolution' is 'node16', 'nodenext', or 'bundler'; otherwise `false`."),
   Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_file_2_was_root_file_of_compilation_but_not_any_more: diag(6412, 3 /* Message */, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_file_2_was_root_file_of_compilation_6412", "Project '{0}' is out of date because buildinfo file '{1}' indicates that file '{2}' was root file of compilation but not any more."),
+  Entering_conditional_exports: diag(6413, 3 /* Message */, "Entering_conditional_exports_6413", "Entering conditional exports."),
+  Resolved_under_condition_0: diag(6414, 3 /* Message */, "Resolved_under_condition_0_6414", "Resolved under condition '{0}'."),
+  Failed_to_resolve_under_condition_0: diag(6415, 3 /* Message */, "Failed_to_resolve_under_condition_0_6415", "Failed to resolve under condition '{0}'."),
+  Exiting_conditional_exports: diag(6416, 3 /* Message */, "Exiting_conditional_exports_6416", "Exiting conditional exports."),
   The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, 3 /* Message */, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
   The_expected_type_comes_from_this_index_signature: diag(6501, 3 /* Message */, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
   The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, 3 /* Message */, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
@@ -19310,17 +19315,11 @@ function getCombinedLocalAndExportSymbolFlags(symbol) {
   return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags;
 }
 function isWriteOnlyAccess(node) {
-  return accessKind(node) === AccessKind.Write;
+  return accessKind(node) === 1 /* Write */;
 }
 function isWriteAccess(node) {
-  return accessKind(node) !== AccessKind.Read;
-}
-var AccessKind = /* @__PURE__ */ ((AccessKind2) => {
-  AccessKind2[AccessKind2["Read"] = 0] = "Read";
-  AccessKind2[AccessKind2["Write"] = 1] = "Write";
-  AccessKind2[AccessKind2["ReadWrite"] = 2] = "ReadWrite";
-  return AccessKind2;
-})(AccessKind || {});
+  return accessKind(node) !== 0 /* Read */;
+}
 function accessKind(node) {
   const { parent: parent2 } = node;
   if (!parent2)
@@ -30186,7 +30185,7 @@ var Parser;
     }
     sourceFlags = contextFlags;
     nextToken();
-    const statements = parseList(ParsingContext.SourceElements, parseStatement);
+    const statements = parseList(0 /* SourceElements */, parseStatement);
     Debug.assert(token() === 1 /* EndOfFileToken */);
     const endOfFileToken = addJSDocComment(parseTokenNode());
     const sourceFile = createSourceFile2(fileName, languageVersion2, scriptKind2, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator2);
@@ -30249,7 +30248,7 @@ var Parser;
         nextToken();
         while (token() !== 1 /* EndOfFileToken */) {
           const startPos = scanner2.getStartPos();
-          const statement = parseListElement(ParsingContext.SourceElements, parseStatement);
+          const statement = parseListElement(0 /* SourceElements */, parseStatement);
           statements.push(statement);
           if (startPos === scanner2.getStartPos()) {
             nextToken();
@@ -30936,19 +30935,19 @@ var Parser;
       return true;
     }
     switch (parsingContext2) {
-      case ParsingContext.SourceElements:
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauseStatements:
+      case 0 /* SourceElements */:
+      case 1 /* BlockStatements */:
+      case 3 /* SwitchClauseStatements */:
         return !(token() === 26 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement();
-      case ParsingContext.SwitchClauses:
+      case 2 /* SwitchClauses */:
         return token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
-      case ParsingContext.TypeMembers:
+      case 4 /* TypeMembers */:
         return lookAhead(isTypeMemberStart);
-      case ParsingContext.ClassMembers:
+      case 5 /* ClassMembers */:
         return lookAhead(isClassMemberStart) || token() === 26 /* SemicolonToken */ && !inErrorRecovery;
-      case ParsingContext.EnumMembers:
+      case 6 /* EnumMembers */:
         return token() === 22 /* OpenBracketToken */ || isLiteralPropertyName();
-      case ParsingContext.ObjectLiteralMembers:
+      case 12 /* ObjectLiteralMembers */:
         switch (token()) {
           case 22 /* OpenBracketToken */:
           case 41 /* AsteriskToken */:
@@ -30958,13 +30957,13 @@ var Parser;
           default:
             return isLiteralPropertyName();
         }
-      case ParsingContext.RestProperties:
+      case 18 /* RestProperties */:
         return isLiteralPropertyName();
-      case ParsingContext.ObjectBindingElements:
+      case 9 /* ObjectBindingElements */:
         return token() === 22 /* OpenBracketToken */ || token() === 25 /* DotDotDotToken */ || isLiteralPropertyName();
-      case ParsingContext.AssertEntries:
+      case 24 /* AssertEntries */:
         return isAssertionKey2();
-      case ParsingContext.HeritageClauseElement:
+      case 7 /* HeritageClauseElement */:
         if (token() === 18 /* OpenBraceToken */) {
           return lookAhead(isValidHeritageClauseObjectLiteral);
         }
@@ -30973,40 +30972,40 @@ var Parser;
         } else {
           return isIdentifier2() && !isHeritageClauseExtendsOrImplementsKeyword();
         }
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isBindingIdentifierOrPrivateIdentifierOrPattern();
-      case ParsingContext.ArrayBindingElements:
+      case 10 /* ArrayBindingElements */:
         return token() === 27 /* CommaToken */ || token() === 25 /* DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern();
-      case ParsingContext.TypeParameters:
+      case 19 /* TypeParameters */:
         return token() === 101 /* InKeyword */ || token() === 85 /* ConstKeyword */ || isIdentifier2();
-      case ParsingContext.ArrayLiteralMembers:
+      case 15 /* ArrayLiteralMembers */:
         switch (token()) {
           case 27 /* CommaToken */:
           case 24 /* DotToken */:
             return true;
         }
-      case ParsingContext.ArgumentExpressions:
+      case 11 /* ArgumentExpressions */:
         return token() === 25 /* DotDotDotToken */ || isStartOfExpression();
-      case ParsingContext.Parameters:
+      case 16 /* Parameters */:
         return isStartOfParameter(
           /*isJSDocParameter*/
           false
         );
-      case ParsingContext.JSDocParameters:
+      case 17 /* JSDocParameters */:
         return isStartOfParameter(
           /*isJSDocParameter*/
           true
         );
-      case ParsingContext.TypeArguments:
-      case ParsingContext.TupleElementTypes:
+      case 20 /* TypeArguments */:
+      case 21 /* TupleElementTypes */:
         return token() === 27 /* CommaToken */ || isStartOfType();
-      case ParsingContext.HeritageClauses:
+      case 22 /* HeritageClauses */:
         return isHeritageClause2();
-      case ParsingContext.ImportOrExportSpecifiers:
+      case 23 /* ImportOrExportSpecifiers */:
         return tokenIsIdentifierOrKeyword(token());
-      case ParsingContext.JsxAttributes:
+      case 13 /* JsxAttributes */:
         return tokenIsIdentifierOrKeyword(token()) || token() === 18 /* OpenBraceToken */;
-      case ParsingContext.JsxChildren:
+      case 14 /* JsxChildren */:
         return true;
     }
     return Debug.fail("Non-exhaustive case in 'isListElement'.");
@@ -31050,41 +31049,41 @@ var Parser;
       return true;
     }
     switch (kind) {
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauses:
-      case ParsingContext.TypeMembers:
-      case ParsingContext.ClassMembers:
-      case ParsingContext.EnumMembers:
-      case ParsingContext.ObjectLiteralMembers:
-      case ParsingContext.ObjectBindingElements:
-      case ParsingContext.ImportOrExportSpecifiers:
-      case ParsingContext.AssertEntries:
+      case 1 /* BlockStatements */:
+      case 2 /* SwitchClauses */:
+      case 4 /* TypeMembers */:
+      case 5 /* ClassMembers */:
+      case 6 /* EnumMembers */:
+      case 12 /* ObjectLiteralMembers */:
+      case 9 /* ObjectBindingElements */:
+      case 23 /* ImportOrExportSpecifiers */:
+      case 24 /* AssertEntries */:
         return token() === 19 /* CloseBraceToken */;
-      case ParsingContext.SwitchClauseStatements:
+      case 3 /* SwitchClauseStatements */:
         return token() === 19 /* CloseBraceToken */ || token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
-      case ParsingContext.HeritageClauseElement:
+      case 7 /* HeritageClauseElement */:
         return token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isVariableDeclaratorListTerminator();
-      case ParsingContext.TypeParameters:
+      case 19 /* TypeParameters */:
         return token() === 31 /* GreaterThanToken */ || token() === 20 /* OpenParenToken */ || token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
-      case ParsingContext.ArgumentExpressions:
+      case 11 /* ArgumentExpressions */:
         return token() === 21 /* CloseParenToken */ || token() === 26 /* SemicolonToken */;
-      case ParsingContext.ArrayLiteralMembers:
-      case ParsingContext.TupleElementTypes:
-      case ParsingContext.ArrayBindingElements:
+      case 15 /* ArrayLiteralMembers */:
+      case 21 /* TupleElementTypes */:
+      case 10 /* ArrayBindingElements */:
         return token() === 23 /* CloseBracketToken */;
-      case ParsingContext.JSDocParameters:
-      case ParsingContext.Parameters:
-      case ParsingContext.RestProperties:
+      case 17 /* JSDocParameters */:
+      case 16 /* Parameters */:
+      case 18 /* RestProperties */:
         return token() === 21 /* CloseParenToken */ || token() === 23 /* CloseBracketToken */;
-      case ParsingContext.TypeArguments:
+      case 20 /* TypeArguments */:
         return token() !== 27 /* CommaToken */;
-      case ParsingContext.HeritageClauses:
+      case 22 /* HeritageClauses */:
         return token() === 18 /* OpenBraceToken */ || token() === 19 /* CloseBraceToken */;
-      case ParsingContext.JsxAttributes:
+      case 13 /* JsxAttributes */:
         return token() === 31 /* GreaterThanToken */ || token() === 43 /* SlashToken */;
-      case ParsingContext.JsxChildren:
+      case 14 /* JsxChildren */:
         return token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsSlash);
       default:
         return false;
@@ -31103,7 +31102,7 @@ var Parser;
     return false;
   }
   function isInSomeParsingContext() {
-    for (let kind = 0; kind < ParsingContext.Count; kind++) {
+    for (let kind = 0; kind < 25 /* Count */; kind++) {
       if (parsingContext & 1 << kind) {
         if (isListElement2(
           kind,
@@ -31172,38 +31171,38 @@ var Parser;
   }
   function isReusableParsingContext(parsingContext2) {
     switch (parsingContext2) {
-      case ParsingContext.ClassMembers:
-      case ParsingContext.SwitchClauses:
-      case ParsingContext.SourceElements:
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauseStatements:
-      case ParsingContext.EnumMembers:
-      case ParsingContext.TypeMembers:
-      case ParsingContext.VariableDeclarations:
-      case ParsingContext.JSDocParameters:
-      case ParsingContext.Parameters:
+      case 5 /* ClassMembers */:
+      case 2 /* SwitchClauses */:
+      case 0 /* SourceElements */:
+      case 1 /* BlockStatements */:
+      case 3 /* SwitchClauseStatements */:
+      case 6 /* EnumMembers */:
+      case 4 /* TypeMembers */:
+      case 8 /* VariableDeclarations */:
+      case 17 /* JSDocParameters */:
+      case 16 /* Parameters */:
         return true;
     }
     return false;
   }
   function canReuseNode(node, parsingContext2) {
     switch (parsingContext2) {
-      case ParsingContext.ClassMembers:
+      case 5 /* ClassMembers */:
         return isReusableClassMember(node);
-      case ParsingContext.SwitchClauses:
+      case 2 /* SwitchClauses */:
         return isReusableSwitchClause(node);
-      case ParsingContext.SourceElements:
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauseStatements:
+      case 0 /* SourceElements */:
+      case 1 /* BlockStatements */:
+      case 3 /* SwitchClauseStatements */:
         return isReusableStatement(node);
-      case ParsingContext.EnumMembers:
+      case 6 /* EnumMembers */:
         return isReusableEnumMember(node);
-      case ParsingContext.TypeMembers:
+      case 4 /* TypeMembers */:
         return isReusableTypeMember(node);
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isReusableVariableDeclaration(node);
-      case ParsingContext.JSDocParameters:
-      case ParsingContext.Parameters:
+      case 17 /* JSDocParameters */:
+      case 16 /* Parameters */:
         return isReusableParameter(node);
     }
     return false;
@@ -31313,56 +31312,56 @@ var Parser;
   }
   function parsingContextErrors(context) {
     switch (context) {
-      case ParsingContext.SourceElements:
+      case 0 /* SourceElements */:
         return token() === 88 /* DefaultKeyword */ ? parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(93 /* ExportKeyword */)) : parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
-      case ParsingContext.BlockStatements:
+      case 1 /* BlockStatements */:
         return parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
-      case ParsingContext.SwitchClauses:
+      case 2 /* SwitchClauses */:
         return parseErrorAtCurrentToken(Diagnostics.case_or_default_expected);
-      case ParsingContext.SwitchClauseStatements:
+      case 3 /* SwitchClauseStatements */:
         return parseErrorAtCurrentToken(Diagnostics.Statement_expected);
-      case ParsingContext.RestProperties:
-      case ParsingContext.TypeMembers:
+      case 18 /* RestProperties */:
+      case 4 /* TypeMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Property_or_signature_expected);
-      case ParsingContext.ClassMembers:
+      case 5 /* ClassMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected);
-      case ParsingContext.EnumMembers:
+      case 6 /* EnumMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Enum_member_expected);
-      case ParsingContext.HeritageClauseElement:
+      case 7 /* HeritageClauseElement */:
         return parseErrorAtCurrentToken(Diagnostics.Expression_expected);
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_variable_declaration_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Variable_declaration_expected);
-      case ParsingContext.ObjectBindingElements:
+      case 9 /* ObjectBindingElements */:
         return parseErrorAtCurrentToken(Diagnostics.Property_destructuring_pattern_expected);
-      case ParsingContext.ArrayBindingElements:
+      case 10 /* ArrayBindingElements */:
         return parseErrorAtCurrentToken(Diagnostics.Array_element_destructuring_pattern_expected);
-      case ParsingContext.ArgumentExpressions:
+      case 11 /* ArgumentExpressions */:
         return parseErrorAtCurrentToken(Diagnostics.Argument_expression_expected);
-      case ParsingContext.ObjectLiteralMembers:
+      case 12 /* ObjectLiteralMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Property_assignment_expected);
-      case ParsingContext.ArrayLiteralMembers:
+      case 15 /* ArrayLiteralMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Expression_or_comma_expected);
-      case ParsingContext.JSDocParameters:
+      case 17 /* JSDocParameters */:
         return parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
-      case ParsingContext.Parameters:
+      case 16 /* Parameters */:
         return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_parameter_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
-      case ParsingContext.TypeParameters:
+      case 19 /* TypeParameters */:
         return parseErrorAtCurrentToken(Diagnostics.Type_parameter_declaration_expected);
-      case ParsingContext.TypeArguments:
+      case 20 /* TypeArguments */:
         return parseErrorAtCurrentToken(Diagnostics.Type_argument_expected);
-      case ParsingContext.TupleElementTypes:
+      case 21 /* TupleElementTypes */:
         return parseErrorAtCurrentToken(Diagnostics.Type_expected);
-      case ParsingContext.HeritageClauses:
+      case 22 /* HeritageClauses */:
         return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_expected);
-      case ParsingContext.ImportOrExportSpecifiers:
+      case 23 /* ImportOrExportSpecifiers */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
-      case ParsingContext.JsxAttributes:
+      case 13 /* JsxAttributes */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
-      case ParsingContext.JsxChildren:
+      case 14 /* JsxChildren */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
-      case ParsingContext.AssertEntries:
+      case 24 /* AssertEntries */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
-      case ParsingContext.Count:
+      case 25 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
       default:
         Debug.assertNever(context);
@@ -31421,7 +31420,7 @@ var Parser;
     );
   }
   function getExpectedCommaDiagnostic(kind) {
-    return kind === ParsingContext.EnumMembers ? Diagnostics.An_enum_member_name_must_be_followed_by_a_or : void 0;
+    return kind === 6 /* EnumMembers */ ? Diagnostics.An_enum_member_name_must_be_followed_by_a_or : void 0;
   }
   function createMissingList() {
     const list = createNodeArray([], getNodePos());
@@ -31615,7 +31614,7 @@ var Parser;
   }
   function parseTypeArgumentsOfTypeReference() {
     if (!scanner2.hasPrecedingLineBreak() && reScanLessThanToken() === 29 /* LessThanToken */) {
-      return parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
+      return parseBracketedList(20 /* TypeArguments */, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
     }
   }
   function parseTypeReference() {
@@ -31797,7 +31796,7 @@ var Parser;
   }
   function parseTypeParameters() {
     if (token() === 29 /* LessThanToken */) {
-      return parseBracketedList(ParsingContext.TypeParameters, parseTypeParameter, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
+      return parseBracketedList(19 /* TypeParameters */, parseTypeParameter, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
     }
   }
   function isStartOfParameter(isJSDocParameter) {
@@ -31903,7 +31902,7 @@ var Parser;
     const savedAwaitContext = inAwaitContext();
     setYieldContext(!!(flags & 1 /* Yield */));
     setAwaitContext(!!(flags & 2 /* Await */));
-    const parameters = flags & 32 /* JSDoc */ ? parseDelimitedList(ParsingContext.JSDocParameters, parseJSDocParameter) : parseDelimitedList(ParsingContext.Parameters, () => allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext));
+    const parameters = flags & 32 /* JSDoc */ ? parseDelimitedList(17 /* JSDocParameters */, parseJSDocParameter) : parseDelimitedList(16 /* Parameters */, () => allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext));
     setYieldContext(savedYieldContext);
     setAwaitContext(savedAwaitContext);
     return parameters;
@@ -31971,7 +31970,7 @@ var Parser;
     return token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 23 /* CloseBracketToken */;
   }
   function parseIndexSignatureDeclaration(pos, hasJSDoc, modifiers) {
-    const parameters = parseBracketedList(ParsingContext.Parameters, () => parseParameter(
+    const parameters = parseBracketedList(16 /* Parameters */, () => parseParameter(
       /*inOuterAwaitContext*/
       false
     ), 22 /* OpenBracketToken */, 23 /* CloseBracketToken */);
@@ -32070,7 +32069,7 @@ var Parser;
   function parseObjectTypeMembers() {
     let members;
     if (parseExpected(18 /* OpenBraceToken */)) {
-      members = parseList(ParsingContext.TypeMembers, parseTypeMember);
+      members = parseList(4 /* TypeMembers */, parseTypeMember);
       parseExpected(19 /* CloseBraceToken */);
     } else {
       members = createMissingList();
@@ -32124,7 +32123,7 @@ var Parser;
     }
     const type = parseTypeAnnotation();
     parseSemicolon();
-    const members = parseList(ParsingContext.TypeMembers, parseTypeMember);
+    const members = parseList(4 /* TypeMembers */, parseTypeMember);
     parseExpected(19 /* CloseBraceToken */);
     return finishNode(factory2.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), pos);
   }
@@ -32169,7 +32168,7 @@ var Parser;
     const pos = getNodePos();
     return finishNode(
       factory2.createTupleTypeNode(
-        parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
+        parseBracketedList(21 /* TupleElementTypes */, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
       ),
       pos
     );
@@ -32797,10 +32796,10 @@ var Parser;
   }
   function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
     const triState = isParenthesizedArrowFunctionExpression();
-    if (triState === Tristate.False) {
+    if (triState === 0 /* False */) {
       return void 0;
     }
-    return triState === Tristate.True ? parseParenthesizedArrowFunctionExpression(
+    return triState === 1 /* True */ ? parseParenthesizedArrowFunctionExpression(
       /*allowAmbiguity*/
       true,
       /*allowReturnTypeInArrowFunction*/
@@ -32812,18 +32811,18 @@ var Parser;
       return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
     }
     if (token() === 38 /* EqualsGreaterThanToken */) {
-      return Tristate.True;
+      return 1 /* True */;
     }
-    return Tristate.False;
+    return 0 /* False */;
   }
   function isParenthesizedArrowFunctionExpressionWorker() {
     if (token() === 132 /* AsyncKeyword */) {
       nextToken();
       if (scanner2.hasPrecedingLineBreak()) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       if (token() !== 20 /* OpenParenToken */ && token() !== 29 /* LessThanToken */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
     }
     const first2 = token();
@@ -32835,45 +32834,45 @@ var Parser;
           case 38 /* EqualsGreaterThanToken */:
           case 58 /* ColonToken */:
           case 18 /* OpenBraceToken */:
-            return Tristate.True;
+            return 1 /* True */;
           default:
-            return Tristate.False;
+            return 0 /* False */;
         }
       }
       if (second === 22 /* OpenBracketToken */ || second === 18 /* OpenBraceToken */) {
-        return Tristate.Unknown;
+        return 2 /* Unknown */;
       }
       if (second === 25 /* DotDotDotToken */) {
-        return Tristate.True;
+        return 1 /* True */;
       }
       if (isModifierKind(second) && second !== 132 /* AsyncKeyword */ && lookAhead(nextTokenIsIdentifier)) {
         if (nextToken() === 128 /* AsKeyword */) {
-          return Tristate.False;
+          return 0 /* False */;
         }
-        return Tristate.True;
+        return 1 /* True */;
       }
       if (!isIdentifier2() && second !== 108 /* ThisKeyword */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       switch (nextToken()) {
         case 58 /* ColonToken */:
-          return Tristate.True;
+          return 1 /* True */;
         case 57 /* QuestionToken */:
           nextToken();
           if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 63 /* EqualsToken */ || token() === 21 /* CloseParenToken */) {
-            return Tristate.True;
+            return 1 /* True */;
           }
-          return Tristate.False;
+          return 0 /* False */;
         case 27 /* CommaToken */:
         case 63 /* EqualsToken */:
         case 21 /* CloseParenToken */:
-          return Tristate.Unknown;
+          return 2 /* Unknown */;
       }
-      return Tristate.False;
+      return 0 /* False */;
     } else {
       Debug.assert(first2 === 29 /* LessThanToken */);
       if (!isIdentifier2() && token() !== 85 /* ConstKeyword */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       if (languageVariant === 1 /* JSX */) {
         const isArrowFunctionInJsx = lookAhead(() => {
@@ -32895,11 +32894,11 @@ var Parser;
           return false;
         });
         if (isArrowFunctionInJsx) {
-          return Tristate.True;
+          return 1 /* True */;
         }
-        return Tristate.False;
+        return 0 /* False */;
       }
-      return Tristate.Unknown;
+      return 2 /* Unknown */;
     }
   }
   function parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
@@ -32919,7 +32918,7 @@ var Parser;
   }
   function tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction) {
     if (token() === 132 /* AsyncKeyword */) {
-      if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === Tristate.True) {
+      if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
         const pos = getNodePos();
         const asyncModifier = parseModifiersForArrowFunction();
         const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
@@ -32932,14 +32931,14 @@ var Parser;
     if (token() === 132 /* AsyncKeyword */) {
       nextToken();
       if (scanner2.hasPrecedingLineBreak() || token() === 38 /* EqualsGreaterThanToken */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
       if (!scanner2.hasPrecedingLineBreak() && expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
-        return Tristate.True;
+        return 1 /* True */;
       }
     }
-    return Tristate.False;
+    return 0 /* False */;
   }
   function parseParenthesizedArrowFunctionExpression(allowAmbiguity, allowReturnTypeInArrowFunction) {
     const pos = getNodePos();
@@ -33347,7 +33346,7 @@ var Parser;
     const list = [];
     const listPos = getNodePos();
     const saveParsingContext = parsingContext;
-    parsingContext |= 1 << ParsingContext.JsxChildren;
+    parsingContext |= 1 << 14 /* JsxChildren */;
     while (true) {
       const child = parseJsxChild(openingTag, currentToken = scanner2.reScanJsxToken());
       if (!child)
@@ -33362,7 +33361,7 @@ var Parser;
   }
   function parseJsxAttributes() {
     const pos = getNodePos();
-    return finishNode(factory2.createJsxAttributes(parseList(ParsingContext.JsxAttributes, parseJsxAttribute)), pos);
+    return finishNode(factory2.createJsxAttributes(parseList(13 /* JsxAttributes */, parseJsxAttribute)), pos);
   }
   function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) {
     const pos = getNodePos();
@@ -33690,7 +33689,7 @@ var Parser;
   }
   function parseArgumentList() {
     parseExpected(20 /* OpenParenToken */);
-    const result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
+    const result = parseDelimitedList(11 /* ArgumentExpressions */, parseArgumentExpression);
     parseExpected(21 /* CloseParenToken */);
     return result;
   }
@@ -33702,7 +33701,7 @@ var Parser;
       return void 0;
     }
     nextToken();
-    const typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType);
+    const typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
     if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
       return void 0;
     }
@@ -33802,7 +33801,7 @@ var Parser;
     const openBracketPosition = scanner2.getTokenPos();
     const openBracketParsed = parseExpected(22 /* OpenBracketToken */);
     const multiLine = scanner2.hasPrecedingLineBreak();
-    const elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArgumentOrArrayLiteralElement);
+    const elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
     parseExpectedMatchingBrackets(22 /* OpenBracketToken */, 23 /* CloseBracketToken */, openBracketParsed, openBracketPosition);
     return finishNode(factory2.createArrayLiteralExpression(elements, multiLine), pos);
   }
@@ -33863,7 +33862,7 @@ var Parser;
     const openBraceParsed = parseExpected(18 /* OpenBraceToken */);
     const multiLine = scanner2.hasPrecedingLineBreak();
     const properties = parseDelimitedList(
-      ParsingContext.ObjectLiteralMembers,
+      12 /* ObjectLiteralMembers */,
       parseObjectLiteralElement,
       /*considerSemicolonAsDelimiter*/
       true
@@ -33935,7 +33934,7 @@ var Parser;
     const openBraceParsed = parseExpected(18 /* OpenBraceToken */, diagnosticMessage);
     if (openBraceParsed || ignoreMissingOpenBrace) {
       const multiLine = scanner2.hasPrecedingLineBreak();
-      const statements = parseList(ParsingContext.BlockStatements, parseStatement);
+      const statements = parseList(1 /* BlockStatements */, parseStatement);
       parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
       const result = withJSDoc(finishNode(factory2.createBlock(statements, multiLine), pos), hasJSDoc);
       if (token() === 63 /* EqualsToken */) {
@@ -34093,14 +34092,14 @@ var Parser;
     parseExpected(82 /* CaseKeyword */);
     const expression = allowInAnd(parseExpression);
     parseExpected(58 /* ColonToken */);
-    const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
+    const statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
     return withJSDoc(finishNode(factory2.createCaseClause(expression, statements), pos), hasJSDoc);
   }
   function parseDefaultClause() {
     const pos = getNodePos();
     parseExpected(88 /* DefaultKeyword */);
     parseExpected(58 /* ColonToken */);
-    const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
+    const statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
     return finishNode(factory2.createDefaultClause(statements), pos);
   }
   function parseCaseOrDefaultClause() {
@@ -34109,7 +34108,7 @@ var Parser;
   function parseCaseBlock() {
     const pos = getNodePos();
     parseExpected(18 /* OpenBraceToken */);
-    const clauses = parseList(ParsingContext.SwitchClauses, parseCaseOrDefaultClause);
+    const clauses = parseList(2 /* SwitchClauses */, parseCaseOrDefaultClause);
     parseExpected(19 /* CloseBraceToken */);
     return finishNode(factory2.createCaseBlock(clauses), pos);
   }
@@ -34550,14 +34549,14 @@ var Parser;
   function parseObjectBindingPattern() {
     const pos = getNodePos();
     parseExpected(18 /* OpenBraceToken */);
-    const elements = parseDelimitedList(ParsingContext.ObjectBindingElements, parseObjectBindingElement);
+    const elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement);
     parseExpected(19 /* CloseBraceToken */);
     return finishNode(factory2.createObjectBindingPattern(elements), pos);
   }
   function parseArrayBindingPattern() {
     const pos = getNodePos();
     parseExpected(22 /* OpenBracketToken */);
-    const elements = parseDelimitedList(ParsingContext.ArrayBindingElements, parseArrayBindingElement);
+    const elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement);
     parseExpected(23 /* CloseBracketToken */);
     return finishNode(factory2.createArrayBindingPattern(elements), pos);
   }
@@ -34615,7 +34614,7 @@ var Parser;
       const savedDisallowIn = inDisallowInContext();
       setDisallowInContext(inForStatementInitializer);
       declarations = parseDelimitedList(
-        ParsingContext.VariableDeclarations,
+        8 /* VariableDeclarations */,
         inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation
       );
       setDisallowInContext(savedDisallowIn);
@@ -35018,7 +35017,7 @@ var Parser;
   }
   function parseHeritageClauses() {
     if (isHeritageClause2()) {
-      return parseList(ParsingContext.HeritageClauses, parseHeritageClause);
+      return parseList(22 /* HeritageClauses */, parseHeritageClause);
     }
     return void 0;
   }
@@ -35027,7 +35026,7 @@ var Parser;
     const tok = token();
     Debug.assert(tok === 94 /* ExtendsKeyword */ || tok === 117 /* ImplementsKeyword */);
     nextToken();
-    const types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseExpressionWithTypeArguments);
+    const types = parseDelimitedList(7 /* HeritageClauseElement */, parseExpressionWithTypeArguments);
     return finishNode(factory2.createHeritageClause(tok, types), pos);
   }
   function parseExpressionWithTypeArguments() {
@@ -35040,13 +35039,13 @@ var Parser;
     return finishNode(factory2.createExpressionWithTypeArguments(expression, typeArguments), pos);
   }
   function tryParseTypeArguments() {
-    return token() === 29 /* LessThanToken */ ? parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */) : void 0;
+    return token() === 29 /* LessThanToken */ ? parseBracketedList(20 /* TypeArguments */, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */) : void 0;
   }
   function isHeritageClause2() {
     return token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
   }
   function parseClassMembers() {
-    return parseList(ParsingContext.ClassMembers, parseClassElement);
+    return parseList(5 /* ClassMembers */, parseClassElement);
   }
   function parseInterfaceDeclaration(pos, hasJSDoc, modifiers) {
     parseExpected(118 /* InterfaceKeyword */);
@@ -35079,7 +35078,7 @@ var Parser;
     const name = parseIdentifier();
     let members;
     if (parseExpected(18 /* OpenBraceToken */)) {
-      members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(ParsingContext.EnumMembers, parseEnumMember));
+      members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(6 /* EnumMembers */, parseEnumMember));
       parseExpected(19 /* CloseBraceToken */);
     } else {
       members = createMissingList();
@@ -35091,7 +35090,7 @@ var Parser;
     const pos = getNodePos();
     let statements;
     if (parseExpected(18 /* OpenBraceToken */)) {
-      statements = parseList(ParsingContext.BlockStatements, parseStatement);
+      statements = parseList(1 /* BlockStatements */, parseStatement);
       parseExpected(19 /* CloseBraceToken */);
     } else {
       statements = createMissingList();
@@ -35216,7 +35215,7 @@ var Parser;
     if (parseExpected(18 /* OpenBraceToken */)) {
       const multiLine = scanner2.hasPrecedingLineBreak();
       const elements = parseDelimitedList(
-        ParsingContext.AssertEntries,
+        24 /* AssertEntries */,
         parseAssertEntry,
         /*considerSemicolonAsDelimiter*/
         true
@@ -35300,7 +35299,7 @@ var Parser;
   }
   function parseNamedImportsOrExports(kind) {
     const pos = getNodePos();
-    const node = kind === 272 /* NamedImports */ ? factory2.createNamedImports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseImportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */)) : factory2.createNamedExports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseExportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */));
+    const node = kind === 272 /* NamedImports */ ? factory2.createNamedImports(parseBracketedList(23 /* ImportOrExportSpecifiers */, parseImportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */)) : factory2.createNamedExports(parseBracketedList(23 /* ImportOrExportSpecifiers */, parseExportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */));
     return finishNode(node, pos);
   }
   function parseExportSpecifier() {
@@ -36750,7 +36749,7 @@ var IncrementalParser;
     let currentArrayIndex = 0;
     Debug.assert(currentArrayIndex < currentArray.length);
     let current = currentArray[currentArrayIndex];
-    let lastQueriedPosition = InvalidPosition.Value;
+    let lastQueriedPosition = -1 /* Value */;
     return {
       currentNode(position) {
         if (position !== lastQueriedPosition) {
@@ -36769,7 +36768,7 @@ var IncrementalParser;
     };
     function findHighestListElementThatStartsAtPosition(position) {
       currentArray = void 0;
-      currentArrayIndex = InvalidPosition.Value;
+      currentArrayIndex = -1 /* Value */;
       current = void 0;
       forEachChild(sourceFile, visitNode3, visitArray2);
       return;
@@ -40566,9 +40565,9 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   const affectingLocations = [];
   let features = getNodeResolutionFeatures(options);
   if (resolutionMode === 99 /* ESNext */ && (getEmitModuleResolutionKind(options) === 3 /* Node16 */ || getEmitModuleResolutionKind(options) === 99 /* NodeNext */)) {
-    features |= NodeResolutionFeatures.EsmMode;
+    features |= 32 /* EsmMode */;
   }
-  const conditions = features & NodeResolutionFeatures.Exports ? getConditions(options, !!(features & NodeResolutionFeatures.EsmMode)) : [];
+  const conditions = features & 8 /* Exports */ ? getConditions(options, !!(features & 32 /* EsmMode */)) : [];
   const diagnostics = [];
   const moduleResolutionState = {
     compilerOptions: options,
@@ -40701,27 +40700,27 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   }
 }
 function getNodeResolutionFeatures(options) {
-  let features = NodeResolutionFeatures.None;
+  let features = 0 /* None */;
   switch (getEmitModuleResolutionKind(options)) {
     case 3 /* Node16 */:
-      features = NodeResolutionFeatures.Node16Default;
+      features = 30 /* Node16Default */;
       break;
     case 99 /* NodeNext */:
-      features = NodeResolutionFeatures.NodeNextDefault;
+      features = 30 /* NodeNextDefault */;
       break;
     case 100 /* Bundler */:
-      features = NodeResolutionFeatures.BundlerDefault;
+      features = 30 /* BundlerDefault */;
       break;
   }
   if (options.resolvePackageJsonExports) {
-    features |= NodeResolutionFeatures.Exports;
+    features |= 8 /* Exports */;
   } else if (options.resolvePackageJsonExports === false) {
-    features &= ~NodeResolutionFeatures.Exports;
+    features &= ~8 /* Exports */;
   }
   if (options.resolvePackageJsonImports) {
-    features |= NodeResolutionFeatures.Imports;
+    features |= 2 /* Imports */;
   } else if (options.resolvePackageJsonImports === false) {
-    features &= ~NodeResolutionFeatures.Imports;
+    features &= ~2 /* Imports */;
   }
   return features;
 }
@@ -42297,18 +42296,24 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
       )));
     } else if (typeof target === "object" && target !== null) {
       if (!Array.isArray(target)) {
+        traceIfEnabled(state, Diagnostics.Entering_conditional_exports);
         for (const condition of getOwnKeys(target)) {
           if (condition === "default" || state.conditions.indexOf(condition) >= 0 || isApplicableVersionedTypesKey(state.conditions, condition)) {
             traceIfEnabled(state, Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition);
             const subTarget = target[condition];
             const result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key);
             if (result) {
+              traceIfEnabled(state, Diagnostics.Resolved_under_condition_0, condition);
+              traceIfEnabled(state, Diagnostics.Exiting_conditional_exports);
               return result;
+            } else {
+              traceIfEnabled(state, Diagnostics.Failed_to_resolve_under_condition_0, condition);
             }
           } else {
             traceIfEnabled(state, Diagnostics.Saw_non_matching_condition_0, condition);
           }
         }
+        traceIfEnabled(state, Diagnostics.Exiting_conditional_exports);
         return void 0;
       } else {
         if (!length(target)) {
@@ -45992,7 +45997,7 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
   let redirectPathsSpecifiers;
   let relativeSpecifiers;
   for (const modulePath of modulePaths) {
-    const specifier = tryGetModuleNameAsNodeModule(
+    const specifier = modulePath.isInNodeModules ? tryGetModuleNameAsNodeModule(
       modulePath,
       info,
       importingSourceFile,
@@ -46002,7 +46007,7 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
       /*packageNameOnly*/
       void 0,
       options.overrideImportMode
-    );
+    ) : void 0;
     nodeModulesSpecifiers = append(nodeModulesSpecifiers, specifier);
     if (specifier && modulePath.isRedirect) {
       return nodeModulesSpecifiers;
@@ -52079,7 +52084,7 @@ function createTypeChecker(host) {
       if (signature.thisParameter) {
         return symbolToParameterDeclaration(signature.thisParameter, context);
       }
-      if (signature.declaration) {
+      if (signature.declaration && isInJSFile(signature.declaration)) {
         const thisTag = getJSDocThisTag(signature.declaration);
         if (thisTag && thisTag.typeExpression) {
           return factory.createParameterDeclaration(
@@ -55060,7 +55065,7 @@ function createTypeChecker(host) {
   function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
     const container = getAssignedExpandoInitializer(symbol.valueDeclaration);
     if (container) {
-      const tag = getJSDocTypeTag(container);
+      const tag = isInJSFile(container) ? getJSDocTypeTag(container) : void 0;
       if (tag && tag.typeExpression) {
         return getTypeFromTypeNode(tag.typeExpression);
       }
@@ -65907,7 +65912,17 @@ function createTypeChecker(host) {
       return propType;
     }
     if (everyType(type, isTupleType)) {
-      return mapType(type, (t) => getRestTypeOfTupleType(t) || undefinedType);
+      return mapType(type, (t) => {
+        const tupleType = t;
+        const restType = getRestTypeOfTupleType(tupleType);
+        if (!restType) {
+          return undefinedType;
+        }
+        if (compilerOptions.noUncheckedIndexedAccess && index >= tupleType.target.fixedLength + getEndElementCount(tupleType.target, 3 /* Fixed */)) {
+          return getUnionType([restType, undefinedType]);
+        }
+        return restType;
+      });
     }
     return void 0;
   }
@@ -68549,7 +68564,7 @@ function createTypeChecker(host) {
         }
         return declaredType;
       }
-      if (isVariableDeclaration(node) && node.parent.parent.kind === 246 /* ForInStatement */ && isMatchingReference(reference, node.parent.parent.expression)) {
+      if (isVariableDeclaration(node) && node.parent.parent.kind === 246 /* ForInStatement */ && (isMatchingReference(reference, node.parent.parent.expression) || optionalChainContainsReference(node.parent.parent.expression, reference))) {
         return getNonNullableTypeIfNeeded(finalizeEvolvingArrayType(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent))));
       }
       return void 0;
@@ -69235,34 +69250,29 @@ function createTypeChecker(host) {
       if (!isTypeDerivedFrom(rightType, globalFunctionType)) {
         return type;
       }
-      let targetType;
-      const prototypeProperty = getPropertyOfType(rightType, "prototype");
-      if (prototypeProperty) {
-        const prototypePropertyType = getTypeOfSymbol(prototypeProperty);
-        if (!isTypeAny(prototypePropertyType)) {
-          targetType = prototypePropertyType;
-        }
-      }
-      if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) {
+      const instanceType = mapType(rightType, getInstanceType);
+      if (isTypeAny(type) && (instanceType === globalObjectType || instanceType === globalFunctionType) || !assumeTrue && !(instanceType.flags & 524288 /* Object */ && !isEmptyAnonymousObjectType(instanceType))) {
         return type;
       }
-      if (!targetType) {
-        const constructSignatures = getSignaturesOfType(rightType, 1 /* Construct */);
-        targetType = constructSignatures.length ? getUnionType(map(constructSignatures, (signature) => getReturnTypeOfSignature(getErasedSignature(signature)))) : emptyObjectType;
-      }
-      if (!assumeTrue && rightType.flags & 1048576 /* Union */) {
-        const nonConstructorTypeInUnion = find(rightType.types, (t) => !isConstructorType(t));
-        if (!nonConstructorTypeInUnion)
-          return type;
-      }
       return getNarrowedType(
         type,
-        targetType,
+        instanceType,
         assumeTrue,
         /*checkDerived*/
         true
       );
     }
+    function getInstanceType(constructorType) {
+      const prototypePropertyType = getTypeOfPropertyOfType(constructorType, "prototype");
+      if (prototypePropertyType && !isTypeAny(prototypePropertyType)) {
+        return prototypePropertyType;
+      }
+      const constructSignatures = getSignaturesOfType(constructorType, 1 /* Construct */);
+      if (constructSignatures.length) {
+        return getUnionType(map(constructSignatures, (signature) => getReturnTypeOfSignature(getErasedSignature(signature))));
+      }
+      return emptyObjectType;
+    }
     function getNarrowedType(type, candidate, assumeTrue, checkDerived) {
       var _a3;
       const key2 = type.flags & 1048576 /* Union */ ? `N${getTypeId(type)},${getTypeId(candidate)},${(assumeTrue ? 1 : 0) | (checkDerived ? 2 : 0)}` : void 0;
@@ -105155,6 +105165,9 @@ function transformModule(context) {
     return visitEachChild(node, visitor, context);
   }
   function visitImportCallExpression(node) {
+    if (moduleKind === 0 /* None */ && languageVersion >= 7 /* ES2020 */) {
+      return visitEachChild(node, visitor, context);
+    }
     const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
     const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor, isExpression);
     const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
@@ -111459,9 +111472,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     formattedNameTempFlagsStack = [];
     formattedNameTempFlags = /* @__PURE__ */ new Map();
     privateNameTempFlagsStack = [];
-    privateNameTempFlags = TempFlags.Auto;
+    privateNameTempFlags = 0 /* Auto */;
     tempFlagsStack = [];
-    tempFlags = TempFlags.Auto;
+    tempFlags = 0 /* Auto */;
     reservedNamesStack = [];
     reservedNames = void 0;
     reservedPrivateNamesStack = [];
@@ -112430,7 +112443,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitTypeLiteral(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -112619,7 +112632,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitObjectLiteralExpression(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -113385,7 +113398,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitClassDeclarationOrExpression(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -113418,7 +113431,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitInterfaceDeclaration(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -114861,7 +114874,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       return;
     }
     tempFlagsStack.push(tempFlags);
-    tempFlags = TempFlags.Auto;
+    tempFlags = 0 /* Auto */;
     formattedNameTempFlagsStack.push(formattedNameTempFlags);
     formattedNameTempFlags = void 0;
     reservedNamesStack.push(reservedNames);
@@ -115047,7 +115060,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       case "#":
         return privateNameTempFlags;
       default:
-        return (_a2 = formattedNameTempFlags == null ? void 0 : formattedNameTempFlags.get(formattedNameKey)) != null ? _a2 : TempFlags.Auto;
+        return (_a2 = formattedNameTempFlags == null ? void 0 : formattedNameTempFlags.get(formattedNameKey)) != null ? _a2 : 0 /* Auto */;
     }
   }
   function setTempFlags(formattedNameKey, flags) {
@@ -115071,7 +115084,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     const key = formatGeneratedName(privateName, prefix, "", suffix);
     let tempFlags2 = getTempFlags(key);
     if (flags && !(tempFlags2 & flags)) {
-      const name = flags === TempFlags._i ? "_i" : "_n";
+      const name = flags === 268435456 /* _i */ ? "_i" : "_n";
       const fullName = formatGeneratedName(privateName, prefix, name, suffix);
       if (isUniqueName(fullName, privateName)) {
         tempFlags2 |= flags;
@@ -115085,7 +115098,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       }
     }
     while (true) {
-      const count = tempFlags2 & TempFlags.CountMask;
+      const count = tempFlags2 & 268435455 /* CountMask */;
       tempFlags2++;
       if (count !== 8 && count !== 13) {
         const name = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26);
@@ -115229,7 +115242,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       return generateNameCached(node.name, privateName);
     }
     return makeTempVariableName(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*reservedInNestedScopes*/
       false,
       privateName,
@@ -115286,7 +115299,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         return generateNameForMethodOrAccessor(node, privateName, prefix, suffix);
       case 164 /* ComputedPropertyName */:
         return makeTempVariableName(
-          TempFlags.Auto,
+          0 /* Auto */,
           /*reserveInNestedScopes*/
           true,
           privateName,
@@ -115295,7 +115308,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         );
       default:
         return makeTempVariableName(
-          TempFlags.Auto,
+          0 /* Auto */,
           /*reserveInNestedScopes*/
           false,
           privateName,
@@ -115310,11 +115323,11 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     const suffix = formatGeneratedNamePart(autoGenerate.suffix);
     switch (autoGenerate.flags & 7 /* KindMask */) {
       case 1 /* Auto */:
-        return makeTempVariableName(TempFlags.Auto, !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */), isPrivateIdentifier(name), prefix, suffix);
+        return makeTempVariableName(0 /* Auto */, !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */), isPrivateIdentifier(name), prefix, suffix);
       case 2 /* Loop */:
         Debug.assertNode(name, isIdentifier);
         return makeTempVariableName(
-          TempFlags._i,
+          268435456 /* _i */,
           !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */),
           /*privateName*/
           false,
@@ -115784,12 +115797,6 @@ function getOpeningBracket(format) {
 function getClosingBracket(format) {
   return brackets[format & 15360 /* BracketsMask */][1];
 }
-var TempFlags = /* @__PURE__ */ ((TempFlags2) => {
-  TempFlags2[TempFlags2["Auto"] = 0] = "Auto";
-  TempFlags2[TempFlags2["CountMask"] = 268435455] = "CountMask";
-  TempFlags2[TempFlags2["_i"] = 268435456] = "_i";
-  return TempFlags2;
-})(TempFlags || {});
 function emitListItemNoParenthesizer(node, emit, _parenthesizerRule, _index) {
   emit(node);
 }
@@ -116767,14 +116774,14 @@ var moduleResolutionNameAndModeGetter = {
 function createModuleResolutionLoader(containingFile, redirectedReference, options, host, cache) {
   return {
     nameAndMode: moduleResolutionNameAndModeGetter,
-    resolve: (moduleName, resoluionMode) => resolveModuleName(
+    resolve: (moduleName, resolutionMode) => resolveModuleName(
       moduleName,
       containingFile,
       options,
       host,
       cache,
       redirectedReference,
-      resoluionMode
+      resolutionMode
     )
   };
 }
@@ -128297,7 +128304,7 @@ function makeImport(defaultImport, namedImports, moduleSpecifier, quotePreferenc
   );
 }
 function makeStringLiteral(text, quotePreference) {
-  return factory.createStringLiteral(text, quotePreference === QuotePreference.Single);
+  return factory.createStringLiteral(text, quotePreference === 0 /* Single */);
 }
 var QuotePreference = /* @__PURE__ */ ((QuotePreference5) => {
   QuotePreference5[QuotePreference5["Single"] = 0] = "Single";
@@ -129213,7 +129220,13 @@ function createPackageJsonInfo(fileName, host) {
 function createPackageJsonImportFilter(fromFile, preferences, host) {
   const packageJsons = (host.getPackageJsonsVisibleToFile && host.getPackageJsonsVisibleToFile(fromFile.fileName) || getPackageJsonsVisibleToFile(fromFile.fileName, host)).filter((p) => p.parseable);
   let usesNodeCoreModules;
-  return { allowsImportingAmbientModule, allowsImportingSourceFile, allowsImportingSpecifier };
+  let ambientModuleCache;
+  let sourceFileCache;
+  return {
+    allowsImportingAmbientModule,
+    allowsImportingSourceFile,
+    allowsImportingSpecifier
+  };
   function moduleSpecifierIsCoveredByPackageJson(specifier) {
     const packageName = getNodeModuleRootSpecifier(specifier);
     for (const packageJson of packageJsons) {
@@ -129227,26 +129240,49 @@ function createPackageJsonImportFilter(fromFile, preferences, host) {
     if (!packageJsons.length || !moduleSymbol.valueDeclaration) {
       return true;
     }
-    const declaringSourceFile = moduleSymbol.valueDeclaration.getSourceFile();
-    const declaringNodeModuleName = getNodeModulesPackageNameFromFileName(declaringSourceFile.fileName, moduleSpecifierResolutionHost);
-    if (typeof declaringNodeModuleName === "undefined") {
-      return true;
+    if (!ambientModuleCache) {
+      ambientModuleCache = /* @__PURE__ */ new Map();
+    } else {
+      const cached = ambientModuleCache.get(moduleSymbol);
+      if (cached !== void 0) {
+        return cached;
+      }
     }
     const declaredModuleSpecifier = stripQuotes(moduleSymbol.getName());
     if (isAllowedCoreNodeModulesImport(declaredModuleSpecifier)) {
+      ambientModuleCache.set(moduleSymbol, true);
+      return true;
+    }
+    const declaringSourceFile = moduleSymbol.valueDeclaration.getSourceFile();
+    const declaringNodeModuleName = getNodeModulesPackageNameFromFileName(declaringSourceFile.fileName, moduleSpecifierResolutionHost);
+    if (typeof declaringNodeModuleName === "undefined") {
+      ambientModuleCache.set(moduleSymbol, true);
       return true;
     }
-    return moduleSpecifierIsCoveredByPackageJson(declaringNodeModuleName) || moduleSpecifierIsCoveredByPackageJson(declaredModuleSpecifier);
+    const result = moduleSpecifierIsCoveredByPackageJson(declaringNodeModuleName) || moduleSpecifierIsCoveredByPackageJson(declaredModuleSpecifier);
+    ambientModuleCache.set(moduleSymbol, result);
+    return result;
   }
   function allowsImportingSourceFile(sourceFile, moduleSpecifierResolutionHost) {
     if (!packageJsons.length) {
       return true;
     }
+    if (!sourceFileCache) {
+      sourceFileCache = /* @__PURE__ */ new Map();
+    } else {
+      const cached = sourceFileCache.get(sourceFile);
+      if (cached !== void 0) {
+        return cached;
+      }
+    }
     const moduleSpecifier = getNodeModulesPackageNameFromFileName(sourceFile.fileName, moduleSpecifierResolutionHost);
     if (!moduleSpecifier) {
+      sourceFileCache.set(sourceFile, true);
       return true;
     }
-    return moduleSpecifierIsCoveredByPackageJson(moduleSpecifier);
+    const result = moduleSpecifierIsCoveredByPackageJson(moduleSpecifier);
+    sourceFileCache.set(sourceFile, result);
+    return result;
   }
   function allowsImportingSpecifier(moduleSpecifier) {
     if (!packageJsons.length || isAllowedCoreNodeModulesImport(moduleSpecifier)) {
@@ -129466,6 +129502,64 @@ function jsxModeNeedsExplicitImport(jsx) {
 function isSourceFileFromLibrary(program, node) {
   return program.isSourceFileFromExternalLibrary(node) || program.isSourceFileDefaultLibrary(node);
 }
+function newCaseClauseTracker(checker, clauses) {
+  const existingStrings = /* @__PURE__ */ new Set();
+  const existingNumbers = /* @__PURE__ */ new Set();
+  const existingBigInts = /* @__PURE__ */ new Set();
+  for (const clause of clauses) {
+    if (!isDefaultClause(clause)) {
+      if (isLiteralExpression(clause.expression)) {
+        const expression = clause.expression;
+        switch (expression.kind) {
+          case 14 /* NoSubstitutionTemplateLiteral */:
+          case 10 /* StringLiteral */:
+            existingStrings.add(expression.text);
+            break;
+          case 8 /* NumericLiteral */:
+            existingNumbers.add(parseInt(expression.text));
+            break;
+          case 9 /* BigIntLiteral */:
+            const parsedBigInt = parseBigInt(endsWith(expression.text, "n") ? expression.text.slice(0, -1) : expression.text);
+            if (parsedBigInt) {
+              existingBigInts.add(pseudoBigIntToString(parsedBigInt));
+            }
+            break;
+        }
+      } else {
+        const symbol = checker.getSymbolAtLocation(clause.expression);
+        if (symbol && symbol.valueDeclaration && isEnumMember(symbol.valueDeclaration)) {
+          const enumValue = checker.getConstantValue(symbol.valueDeclaration);
+          if (enumValue !== void 0) {
+            addValue(enumValue);
+          }
+        }
+      }
+    }
+  }
+  return {
+    addValue,
+    hasValue
+  };
+  function addValue(value) {
+    switch (typeof value) {
+      case "string":
+        existingStrings.add(value);
+        break;
+      case "number":
+        existingNumbers.add(value);
+    }
+  }
+  function hasValue(value) {
+    switch (typeof value) {
+      case "string":
+        return existingStrings.has(value);
+      case "number":
+        return existingNumbers.has(value);
+      case "object":
+        return existingBigInts.has(pseudoBigIntToString(value));
+    }
+  }
+}
 
 // src/services/exportInfoMap.ts
 var ImportKind = /* @__PURE__ */ ((ImportKind2) => {
@@ -140714,13 +140808,13 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
     var _a2, _b;
     const { fix, symbolName: symbolName2 } = info;
     switch (fix.kind) {
-      case ImportFixKind.UseNamespace:
+      case 0 /* UseNamespace */:
         addToNamespace.push(fix);
         break;
-      case ImportFixKind.JsdocTypeImport:
+      case 1 /* JsdocTypeImport */:
         importType.push(fix);
         break;
-      case ImportFixKind.AddToExisting: {
+      case 2 /* AddToExisting */: {
         const { importClauseOrBindingPattern, importKind, addAsTypeOnly } = fix;
         const key = String(getNodeId(importClauseOrBindingPattern));
         let entry = addToExisting.get(key);
@@ -140739,7 +140833,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         }
         break;
       }
-      case ImportFixKind.AddNew: {
+      case 3 /* AddNew */: {
         const { moduleSpecifier, importKind, useRequire, addAsTypeOnly } = fix;
         const entry = getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly);
         Debug.assert(entry.useRequire === useRequire, "(Add new) Tried to add an `import` and a `require` for the same module");
@@ -140760,7 +140854,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         }
         break;
       }
-      case ImportFixKind.PromoteTypeOnly:
+      case 4 /* PromoteTypeOnly */:
         break;
       default:
         Debug.assertNever(fix, `fix wasn't never - got kind ${fix.kind}`);
@@ -140787,13 +140881,13 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         namespaceLikeImport: void 0,
         useRequire
       };
-      if (importKind === 1 /* Default */ && addAsTypeOnly === AddAsTypeOnly.Required) {
+      if (importKind === 1 /* Default */ && addAsTypeOnly === 2 /* Required */) {
         if (typeOnlyEntry)
           return typeOnlyEntry;
         newImports.set(typeOnlyKey, newEntry);
         return newEntry;
       }
-      if (addAsTypeOnly === AddAsTypeOnly.Allowed && (typeOnlyEntry || nonTypeOnlyEntry)) {
+      if (addAsTypeOnly === 1 /* Allowed */ && (typeOnlyEntry || nonTypeOnlyEntry)) {
         return typeOnlyEntry || nonTypeOnlyEntry;
       }
       if (nonTypeOnlyEntry) {
@@ -140875,20 +140969,6 @@ function createImportSpecifierResolver(importingFile, program, host, preferences
     return result && { ...result, computedWithoutCacheCount };
   }
 }
-var ImportFixKind = /* @__PURE__ */ ((ImportFixKind2) => {
-  ImportFixKind2[ImportFixKind2["UseNamespace"] = 0] = "UseNamespace";
-  ImportFixKind2[ImportFixKind2["JsdocTypeImport"] = 1] = "JsdocTypeImport";
-  ImportFixKind2[ImportFixKind2["AddToExisting"] = 2] = "AddToExisting";
-  ImportFixKind2[ImportFixKind2["AddNew"] = 3] = "AddNew";
-  ImportFixKind2[ImportFixKind2["PromoteTypeOnly"] = 4] = "PromoteTypeOnly";
-  return ImportFixKind2;
-})(ImportFixKind || {});
-var AddAsTypeOnly = /* @__PURE__ */ ((AddAsTypeOnly2) => {
-  AddAsTypeOnly2[AddAsTypeOnly2["Allowed"] = 1] = "Allowed";
-  AddAsTypeOnly2[AddAsTypeOnly2["Required"] = 2] = "Required";
-  AddAsTypeOnly2[AddAsTypeOnly2["NotAllowed"] = 4] = "NotAllowed";
-  return AddAsTypeOnly2;
-})(AddAsTypeOnly || {});
 function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
   const compilerOptions = program.getCompilerOptions();
   const exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, isJsxTagName, program, host, preferences, cancellationToken);
@@ -147674,19 +147754,19 @@ function getCompletionsAtPosition(host, program, log, sourceFile, position, pref
     return void 0;
   }
   switch (completionData.kind) {
-    case CompletionDataKind.Data:
+    case 0 /* Data */:
       const response = completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext, position);
       if (response == null ? void 0 : response.isIncomplete) {
         incompleteCompletionsCache == null ? void 0 : incompleteCompletionsCache.set(response);
       }
       return response;
-    case CompletionDataKind.JsDocTagName:
+    case 1 /* JsDocTagName */:
       return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocTagNameCompletions());
-    case CompletionDataKind.JsDocTag:
+    case 2 /* JsDocTag */:
       return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocTagCompletions());
-    case CompletionDataKind.JsDocParameterName:
+    case 3 /* JsDocParameterName */:
       return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocParameterNameCompletions(completionData.tag));
-    case CompletionDataKind.Keywords:
+    case 4 /* Keywords */:
       return specificKeywordCompletionInfo(completionData.keywordCompletions, completionData.isNewIdentifierLocation);
     default:
       return Debug.assertNever(completionData);
@@ -147789,7 +147869,7 @@ function specificKeywordCompletionInfo(entries, isNewIdentifierLocation) {
 }
 function keywordCompletionData(keywordFilters, filterOutTsOnlyKeywords, isNewIdentifierLocation) {
   return {
-    kind: CompletionDataKind.Keywords,
+    kind: 4 /* Keywords */,
     keywordCompletions: getKeywordCompletions(keywordFilters, filterOutTsOnlyKeywords),
     isNewIdentifierLocation
   };
@@ -148019,64 +148099,6 @@ function getExhaustiveCaseSnippets(caseBlock, sourceFile, preferences, options,
   }
   return void 0;
 }
-function newCaseClauseTracker(checker, clauses) {
-  const existingStrings = /* @__PURE__ */ new Set();
-  const existingNumbers = /* @__PURE__ */ new Set();
-  const existingBigInts = /* @__PURE__ */ new Set();
-  for (const clause of clauses) {
-    if (!isDefaultClause(clause)) {
-      if (isLiteralExpression(clause.expression)) {
-        const expression = clause.expression;
-        switch (expression.kind) {
-          case 14 /* NoSubstitutionTemplateLiteral */:
-          case 10 /* StringLiteral */:
-            existingStrings.add(expression.text);
-            break;
-          case 8 /* NumericLiteral */:
-            existingNumbers.add(parseInt(expression.text));
-            break;
-          case 9 /* BigIntLiteral */:
-            const parsedBigInt = parseBigInt(endsWith(expression.text, "n") ? expression.text.slice(0, -1) : expression.text);
-            if (parsedBigInt) {
-              existingBigInts.add(pseudoBigIntToString(parsedBigInt));
-            }
-            break;
-        }
-      } else {
-        const symbol = checker.getSymbolAtLocation(clause.expression);
-        if (symbol && symbol.valueDeclaration && isEnumMember(symbol.valueDeclaration)) {
-          const enumValue = checker.getConstantValue(symbol.valueDeclaration);
-          if (enumValue !== void 0) {
-            addValue(enumValue);
-          }
-        }
-      }
-    }
-  }
-  return {
-    addValue,
-    hasValue
-  };
-  function addValue(value) {
-    switch (typeof value) {
-      case "string":
-        existingStrings.add(value);
-        break;
-      case "number":
-        existingNumbers.add(value);
-    }
-  }
-  function hasValue(value) {
-    switch (typeof value) {
-      case "string":
-        return existingStrings.has(value);
-      case "number":
-        return existingNumbers.has(value);
-      case "object":
-        return existingBigInts.has(pseudoBigIntToString(value));
-    }
-  }
-}
 function typeNodeToExpression(typeNode, languageVersion, quotePreference) {
   switch (typeNode.kind) {
     case 180 /* TypeReference */:
@@ -148124,9 +148146,9 @@ function entityNameToExpression(entityName, languageVersion, quotePreference) {
 }
 function isMemberCompletionKind(kind) {
   switch (kind) {
-    case CompletionKind.ObjectPropertyDeclaration:
-    case CompletionKind.MemberLike:
-    case CompletionKind.PropertyAccess:
+    case 0 /* ObjectPropertyDeclaration */:
+    case 3 /* MemberLike */:
+    case 2 /* PropertyAccess */:
       return true;
     default:
       return false;
@@ -148242,7 +148264,7 @@ function createCompletionEntry(symbol, sortText, replacementToken, contextToken,
   if ((origin == null ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
     hasAction = true;
   }
-  if (preferences.includeCompletionsWithClassMemberSnippets && preferences.includeCompletionsWithInsertText && completionKind === CompletionKind.MemberLike && isClassLikeMemberCompletion(symbol, location, sourceFile)) {
+  if (preferences.includeCompletionsWithClassMemberSnippets && preferences.includeCompletionsWithInsertText && completionKind === 3 /* MemberLike */ && isClassLikeMemberCompletion(symbol, location, sourceFile)) {
     let importAdder;
     ({ insertText, isSnippet, importAdder, replacementSpan } = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, position, contextToken, formatContext));
     sortText = SortText.ClassMemberSnippets;
@@ -148777,7 +148799,7 @@ function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, con
     const symbol = symbols[i];
     const origin = symbolToOriginInfoMap == null ? void 0 : symbolToOriginInfoMap[i];
     const info = getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, !!jsxIdentifierExpected);
-    if (!info || uniques.get(info.name) && (!origin || !originIsObjectLiteralMethod(origin)) || kind === CompletionKind.Global && symbolToSortTextMap && !shouldIncludeSymbol(symbol, symbolToSortTextMap)) {
+    if (!info || uniques.get(info.name) && (!origin || !originIsObjectLiteralMethod(origin)) || kind === 1 /* Global */ && symbolToSortTextMap && !shouldIncludeSymbol(symbol, symbolToSortTextMap)) {
       continue;
     }
     const { name, needsConvertPropertyAccess } = info;
@@ -148916,7 +148938,7 @@ function getSymbolCompletionFromEntryId(program, log, sourceFile, position, entr
   if (!completionData) {
     return { type: "none" };
   }
-  if (completionData.kind !== CompletionDataKind.Data) {
+  if (completionData.kind !== 0 /* Data */) {
     return { type: "request", request: completionData };
   }
   const { symbols, literals, location, completionKind, symbolToOriginInfoMap, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation } = completionData;
@@ -148942,13 +148964,13 @@ function getCompletionEntryDetails(program, log, sourceFile, position, entryId,
     case "request": {
       const { request } = symbolCompletion;
       switch (request.kind) {
-        case CompletionDataKind.JsDocTagName:
+        case 1 /* JsDocTagName */:
           return ts_JsDoc_exports.getJSDocTagNameCompletionDetails(name);
-        case CompletionDataKind.JsDocTag:
+        case 2 /* JsDocTag */:
           return ts_JsDoc_exports.getJSDocTagCompletionDetails(name);
-        case CompletionDataKind.JsDocParameterName:
+        case 3 /* JsDocParameterName */:
           return ts_JsDoc_exports.getJSDocParameterNameCompletionDetails(name);
-        case CompletionDataKind.Keywords:
+        case 4 /* Keywords */:
           return some(request.keywordCompletions, (c) => c.name === name) ? createSimpleDetails(name, "keyword" /* keyword */, 5 /* keyword */) : void 0;
         default:
           return Debug.assertNever(request);
@@ -149090,14 +149112,6 @@ function getCompletionEntrySymbol(program, log, sourceFile, position, entryId, h
   const completion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences);
   return completion.type === "symbol" ? completion.symbol : void 0;
 }
-var CompletionDataKind = /* @__PURE__ */ ((CompletionDataKind2) => {
-  CompletionDataKind2[CompletionDataKind2["Data"] = 0] = "Data";
-  CompletionDataKind2[CompletionDataKind2["JsDocTagName"] = 1] = "JsDocTagName";
-  CompletionDataKind2[CompletionDataKind2["JsDocTag"] = 2] = "JsDocTag";
-  CompletionDataKind2[CompletionDataKind2["JsDocParameterName"] = 3] = "JsDocParameterName";
-  CompletionDataKind2[CompletionDataKind2["Keywords"] = 4] = "Keywords";
-  return CompletionDataKind2;
-})(CompletionDataKind || {});
 var CompletionKind = /* @__PURE__ */ ((CompletionKind2) => {
   CompletionKind2[CompletionKind2["ObjectPropertyDeclaration"] = 0] = "ObjectPropertyDeclaration";
   CompletionKind2[CompletionKind2["Global"] = 1] = "Global";
@@ -151030,9 +151044,9 @@ function convertStringLiteralCompletions(completion, contextToken, sourceFile, h
   }
   const optionalReplacementSpan = createTextSpanFromStringLiteralLikeContent(contextToken);
   switch (completion.kind) {
-    case StringLiteralCompletionKind.Paths:
+    case 0 /* Paths */:
       return convertPathCompletions(completion.paths);
-    case StringLiteralCompletionKind.Properties: {
+    case 1 /* Properties */: {
       const entries = createSortedArray();
       getCompletionEntriesFromSymbols(
         completion.symbols,
@@ -151054,7 +151068,7 @@ function convertStringLiteralCompletions(completion, contextToken, sourceFile, h
       );
       return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan, entries };
     }
-    case StringLiteralCompletionKind.Types: {
+    case 2 /* Types */: {
       const entries = completion.types.map((type) => ({
         name: type.value,
         kindModifiers: "" /* none */,
@@ -151076,16 +151090,16 @@ function getStringLiteralCompletionDetails(name, sourceFile, position, contextTo
 }
 function stringLiteralCompletionDetails(name, location, completion, sourceFile, checker, cancellationToken) {
   switch (completion.kind) {
-    case StringLiteralCompletionKind.Paths: {
+    case 0 /* Paths */: {
       const match = find(completion.paths, (p) => p.name === name);
       return match && createCompletionDetails(name, kindModifiersFromExtension(match.extension), match.kind, [textPart(name)]);
     }
-    case StringLiteralCompletionKind.Properties: {
+    case 1 /* Properties */: {
       const match = find(completion.symbols, (s) => s.name === name);
       return match && createCompletionDetailsForSymbol(match, checker, sourceFile, location, cancellationToken);
     }
-    case StringLiteralCompletionKind.Types:
-      return find(completion.types, (t) => t.value === name) ? createCompletionDetails(name, "" /* none */, "type" /* typeElement */, [textPart(name)]) : void 0;
+    case 2 /* Types */:
+      return find(completion.types, (t) => t.value === name) ? createCompletionDetails(name, "" /* none */, "string" /* string */, [textPart(name)]) : void 0;
     default:
       return Debug.assertNever(completion);
   }
@@ -151130,12 +151144,6 @@ function kindModifiersFromExtension(extension) {
       return Debug.assertNever(extension);
   }
 }
-var StringLiteralCompletionKind = /* @__PURE__ */ ((StringLiteralCompletionKind2) => {
-  StringLiteralCompletionKind2[StringLiteralCompletionKind2["Paths"] = 0] = "Paths";
-  StringLiteralCompletionKind2[StringLiteralCompletionKind2["Properties"] = 1] = "Properties";
-  StringLiteralCompletionKind2[StringLiteralCompletionKind2["Types"] = 2] = "Types";
-  return StringLiteralCompletionKind2;
-})(StringLiteralCompletionKind || {});
 function getStringLiteralCompletionEntries(sourceFile, node, position, typeChecker, compilerOptions, host, preferences) {
   const parent2 = walkUpParentheses(node.parent);
   switch (parent2.kind) {
@@ -151193,6 +151201,10 @@ function getStringLiteralCompletionEntries(sourceFile, node, position, typeCheck
     case 275 /* ExportDeclaration */:
     case 280 /* ExternalModuleReference */:
       return { kind: 0 /* Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };
+    case 292 /* CaseClause */:
+      const tracker = newCaseClauseTracker(typeChecker, node.parent.parent.clauses);
+      const literals = fromContextualType().types.filter((literal) => !tracker.hasValue(literal.value));
+      return { kind: 2 /* Types */, types: literals, isNewIdentifier: false };
     default:
       return fromContextualType();
   }
@@ -151288,7 +151300,7 @@ function getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, comp
   const mode = isStringLiteralLike(node) ? getModeForUsageLocation(sourceFile, node) : void 0;
   const scriptPath = sourceFile.path;
   const scriptDirectory = getDirectoryPath(scriptPath);
-  const extensionOptions = getExtensionOptions(compilerOptions, ReferenceKind.ModuleSpecifier, sourceFile, typeChecker, preferences, mode);
+  const extensionOptions = getExtensionOptions(compilerOptions, 1 /* ModuleSpecifier */, sourceFile, typeChecker, preferences, mode);
   return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, extensionOptions) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, compilerOptions, host, extensionOptions, typeChecker);
 }
 function getExtensionOptions(compilerOptions, referenceKind, importingSourceFile, typeChecker, preferences, resolutionMode) {
@@ -151360,11 +151372,6 @@ function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment
     exclude
   ).values()));
 }
-var ReferenceKind = /* @__PURE__ */ ((ReferenceKind2) => {
-  ReferenceKind2[ReferenceKind2["Filename"] = 0] = "Filename";
-  ReferenceKind2[ReferenceKind2["ModuleSpecifier"] = 1] = "ModuleSpecifier";
-  return ReferenceKind2;
-})(ReferenceKind || {});
 function getCompletionEntriesForDirectoryFragment(fragment, scriptDirectory, extensionOptions, host, moduleSpecifierIsRelative, exclude, result = createNameAndKindSet()) {
   var _a2;
   if (fragment === void 0) {
@@ -153134,7 +153141,7 @@ var Core;
     ) || originalSymbol;
     const searchMeaning = node ? getIntersectingMeaningFromDeclarations(node, symbol) : 7 /* All */;
     const result = [];
-    const state = new State(sourceFiles, sourceFilesSet, node ? getSpecialSearchKind(node) : SpecialSearchKind.None, checker, cancellationToken, searchMeaning, options, result);
+    const state = new State(sourceFiles, sourceFilesSet, node ? getSpecialSearchKind(node) : 0 /* None */, checker, cancellationToken, searchMeaning, options, result);
     const exportSpecifier = !isForRenameWithPrefixAndSuffixText(options) || !symbol.declarations ? void 0 : find(symbol.declarations, isExportSpecifier);
     if (exportSpecifier) {
       getReferencesAtExportSpecifier(
@@ -153190,14 +153197,14 @@ var Core;
     switch (node.kind) {
       case 173 /* Constructor */:
       case 135 /* ConstructorKeyword */:
-        return SpecialSearchKind.Constructor;
+        return 1 /* Constructor */;
       case 79 /* Identifier */:
         if (isClassLike(node.parent)) {
           Debug.assert(node.parent.name === node);
-          return SpecialSearchKind.Class;
+          return 2 /* Class */;
         }
       default:
-        return SpecialSearchKind.None;
+        return 0 /* None */;
     }
   }
   function skipPastExportOrImportSpecifierOrUnion(symbol, node, checker, useLocalSymbolForExportSpecifier) {
@@ -160126,10 +160133,10 @@ function getPossibleExtractions(targetRange, context) {
     const scopeDescription = isFunctionLikeDeclaration(scope) ? getDescriptionForFunctionLikeDeclaration(scope) : isClassLike(scope) ? getDescriptionForClassLikeDeclaration(scope) : getDescriptionForModuleLikeDeclaration(scope);
     let functionDescription;
     let constantDescription;
-    if (scopeDescription === SpecialScope.Global) {
+    if (scopeDescription === 1 /* Global */) {
       functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "global"]);
       constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "global"]);
-    } else if (scopeDescription === SpecialScope.Module) {
+    } else if (scopeDescription === 0 /* Module */) {
       functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "module"]);
       constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "module"]);
     } else {
@@ -160195,13 +160202,8 @@ function getDescriptionForClassLikeDeclaration(scope) {
   return scope.kind === 260 /* ClassDeclaration */ ? scope.name ? `class '${scope.name.text}'` : "anonymous class declaration" : scope.name ? `class expression '${scope.name.text}'` : "anonymous class expression";
 }
 function getDescriptionForModuleLikeDeclaration(scope) {
-  return scope.kind === 265 /* ModuleBlock */ ? `namespace '${scope.parent.name.getText()}'` : scope.externalModuleIndicator ? SpecialScope.Module : SpecialScope.Global;
+  return scope.kind === 265 /* ModuleBlock */ ? `namespace '${scope.parent.name.getText()}'` : scope.externalModuleIndicator ? 0 /* Module */ : 1 /* Global */;
 }
-var SpecialScope = /* @__PURE__ */ ((SpecialScope2) => {
-  SpecialScope2[SpecialScope2["Module"] = 0] = "Module";
-  SpecialScope2[SpecialScope2["Global"] = 1] = "Global";
-  return SpecialScope2;
-})(SpecialScope || {});
 function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParameterUsages, substitutions }, exposedVariableDeclarations, range, context) {
   const checker = context.program.getTypeChecker();
   const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
@@ -160233,7 +160235,7 @@ function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParame
       typeNode
     );
     parameters.push(paramDecl);
-    if (usage.usage === Usage.Write) {
+    if (usage.usage === 2 /* Write */) {
       (writes || (writes = [])).push(usage);
     }
     callArguments.push(factory.createIdentifier(name));
@@ -160885,11 +160887,6 @@ function isReadonlyArray(v) {
 function getEnclosingTextRange(targetRange, sourceFile) {
   return isReadonlyArray(targetRange.range) ? { pos: first(targetRange.range).getStart(sourceFile), end: last(targetRange.range).getEnd() } : targetRange.range;
 }
-var Usage = /* @__PURE__ */ ((Usage2) => {
-  Usage2[Usage2["Read"] = 1] = "Read";
-  Usage2[Usage2["Write"] = 2] = "Write";
-  return Usage2;
-})(Usage || {});
 function collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFile, checker, cancellationToken) {
   const allTypeParameterUsages = /* @__PURE__ */ new Map();
   const usagesPerScope = [];
@@ -161538,13 +161535,8 @@ function getSignatureHelpItems(program, sourceFile, position, triggerReason, can
   if (!candidateInfo) {
     return isSourceFileJS(sourceFile) ? createJSSignatureHelpItems(argumentInfo, program, cancellationToken) : void 0;
   }
-  return typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => candidateInfo.kind === CandidateOrTypeKind.Candidate ? createSignatureHelpItems(candidateInfo.candidates, candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker2) : createTypeHelpItems(candidateInfo.symbol, argumentInfo, sourceFile, typeChecker2));
+  return typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => candidateInfo.kind === 0 /* Candidate */ ? createSignatureHelpItems(candidateInfo.candidates, candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker2) : createTypeHelpItems(candidateInfo.symbol, argumentInfo, sourceFile, typeChecker2));
 }
-var CandidateOrTypeKind = /* @__PURE__ */ ((CandidateOrTypeKind2) => {
-  CandidateOrTypeKind2[CandidateOrTypeKind2["Candidate"] = 0] = "Candidate";
-  CandidateOrTypeKind2[CandidateOrTypeKind2["Type"] = 1] = "Type";
-  return CandidateOrTypeKind2;
-})(CandidateOrTypeKind || {});
 function getCandidateOrTypeInfo({ invocation, argumentCount }, checker, sourceFile, startingToken, onlyUseSyntacticOwners) {
   switch (invocation.kind) {
     case 0 /* Call */: {
@@ -165955,7 +165947,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
       if (currentTokenInfo.leadingTrivia) {
         processTrivia(currentTokenInfo.leadingTrivia, parent2, childContextNode, dynamicIndentation);
       }
-      let lineAction = LineAction.None;
+      let lineAction = 0 /* None */;
       const isTokenInRange = rangeContainsRange(originalRange, currentTokenInfo.token);
       const tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos);
       if (isTokenInRange) {
@@ -165963,11 +165955,11 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
         const savePreviousRange = previousRange;
         lineAction = processRange(currentTokenInfo.token, tokenStart, parent2, childContextNode, dynamicIndentation);
         if (!rangeHasError) {
-          if (lineAction === LineAction.None) {
+          if (lineAction === 0 /* None */) {
             const prevEndLine = savePreviousRange && sourceFile.getLineAndCharacterOfPosition(savePreviousRange.end).line;
             indentToken = lastTriviaWasNewLine && tokenStart.line !== prevEndLine;
           } else {
-            indentToken = lineAction === LineAction.LineAdded;
+            indentToken = lineAction === 1 /* LineAdded */;
           }
         }
       }
@@ -165993,7 +165985,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
           );
         }
         if (tokenIndentation !== -1 /* Unknown */ && indentNextTokenOrTrivia) {
-          insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAction === LineAction.LineAdded);
+          insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAction === 1 /* LineAdded */);
           lastIndentedLine = tokenStart.line;
           indentationOnLastIndentedLine = tokenIndentation;
         }
@@ -166040,7 +166032,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
   }
   function processRange(range, rangeStart, parent2, contextNode, dynamicIndentation) {
     const rangeHasError = rangeContainsError(range);
-    let lineAction = LineAction.None;
+    let lineAction = 0 /* None */;
     if (!rangeHasError) {
       if (!previousRange) {
         const originalStart = sourceFile.getLineAndCharacterOfPosition(originalRange.pos);
@@ -166059,13 +166051,13 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
     formattingContext.updateContext(previousItem, previousParent2, currentItem, currentParent, contextNode);
     const rules = getRules(formattingContext);
     let trimTrailingWhitespaces = formattingContext.options.trimTrailingWhitespace !== false;
-    let lineAction = LineAction.None;
+    let lineAction = 0 /* None */;
     if (rules) {
       forEachRight(rules, (rule2) => {
         lineAction = applyRuleEdits(rule2, previousItem, previousStartLine, currentItem, currentStartLine);
         if (dynamicIndentation) {
           switch (lineAction) {
-            case LineAction.LineRemoved:
+            case 2 /* LineRemoved */:
               if (currentParent.getStart(sourceFile) === currentItem.pos) {
                 dynamicIndentation.recomputeIndentation(
                   /*lineAddedByFormatting*/
@@ -166074,7 +166066,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
                 );
               }
               break;
-            case LineAction.LineAdded:
+            case 1 /* LineAdded */:
               if (currentParent.getStart(sourceFile) === currentItem.pos) {
                 dynamicIndentation.recomputeIndentation(
                   /*lineAddedByFormatting*/
@@ -166084,7 +166076,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
               }
               break;
             default:
-              Debug.assert(lineAction === LineAction.None);
+              Debug.assert(lineAction === 0 /* None */);
           }
         }
         trimTrailingWhitespaces = trimTrailingWhitespaces && !(rule2.action & 16 /* DeleteSpace */) && rule2.flags !== 1 /* CanDeleteNewLines */;
@@ -166231,11 +166223,11 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
     const onLaterLine = currentStartLine !== previousStartLine;
     switch (rule2.action) {
       case 1 /* StopProcessingSpaceActions */:
-        return LineAction.None;
+        return 0 /* None */;
       case 16 /* DeleteSpace */:
         if (previousRange2.end !== currentRange.pos) {
           recordDelete(previousRange2.end, currentRange.pos - previousRange2.end);
-          return onLaterLine ? LineAction.LineRemoved : LineAction.None;
+          return onLaterLine ? 2 /* LineRemoved */ : 0 /* None */;
         }
         break;
       case 32 /* DeleteToken */:
@@ -166243,36 +166235,30 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
         break;
       case 8 /* InsertNewLine */:
         if (rule2.flags !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) {
-          return LineAction.None;
+          return 0 /* None */;
         }
         const lineDelta = currentStartLine - previousStartLine;
         if (lineDelta !== 1) {
           recordReplace(previousRange2.end, currentRange.pos - previousRange2.end, getNewLineOrDefaultFromHost(host, options));
-          return onLaterLine ? LineAction.None : LineAction.LineAdded;
+          return onLaterLine ? 0 /* None */ : 1 /* LineAdded */;
         }
         break;
       case 4 /* InsertSpace */:
         if (rule2.flags !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) {
-          return LineAction.None;
+          return 0 /* None */;
         }
         const posDelta = currentRange.pos - previousRange2.end;
         if (posDelta !== 1 || sourceFile.text.charCodeAt(previousRange2.end) !== 32 /* space */) {
           recordReplace(previousRange2.end, currentRange.pos - previousRange2.end, " ");
-          return onLaterLine ? LineAction.LineRemoved : LineAction.None;
+          return onLaterLine ? 2 /* LineRemoved */ : 0 /* None */;
         }
         break;
       case 64 /* InsertTrailingSemicolon */:
         recordInsert(previousRange2.end, ";");
     }
-    return LineAction.None;
+    return 0 /* None */;
   }
 }
-var LineAction = /* @__PURE__ */ ((LineAction2) => {
-  LineAction2[LineAction2["None"] = 0] = "None";
-  LineAction2[LineAction2["LineAdded"] = 1] = "LineAdded";
-  LineAction2[LineAction2["LineRemoved"] = 2] = "LineRemoved";
-  return LineAction2;
-})(LineAction || {});
 function getRangeOfEnclosingComment(sourceFile, position, precedingToken, tokenAtPosition = getTokenAtPosition(sourceFile, position)) {
   const jsdoc = findAncestor(tokenAtPosition, isJSDoc);
   if (jsdoc)
@@ -166495,7 +166481,7 @@ var SmartIndenter;
       )) {
         const currentStart = getStartLineAndCharacterForNode(current, sourceFile);
         const nextTokenKind = nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile);
-        const indentationDelta = nextTokenKind !== NextTokenKind.Unknown ? assumeNewLineBeforeCloseBrace && nextTokenKind === NextTokenKind.CloseBrace ? options.indentSize : 0 : lineAtPosition !== currentStart.line ? options.indentSize : 0;
+        const indentationDelta = nextTokenKind !== 0 /* Unknown */ ? assumeNewLineBeforeCloseBrace && nextTokenKind === 2 /* CloseBrace */ ? options.indentSize : 0 : lineAtPosition !== currentStart.line ? options.indentSize : 0;
         return getIndentationForNodeWorker(
           current,
           currentStart,
@@ -168748,6 +168734,7 @@ __export(ts_exports3, {
   mutateMapSkippingNewValues: () => mutateMapSkippingNewValues,
   needsParentheses: () => needsParentheses,
   needsScopeMarker: () => needsScopeMarker,
+  newCaseClauseTracker: () => newCaseClauseTracker,
   newPrivateEnvironment: () => newPrivateEnvironment,
   noEmitNotification: () => noEmitNotification,
   noEmitSubstitution: () => noEmitSubstitution,
@@ -176380,6 +176367,10 @@ function getPerProjectReferences(projects, defaultProject, initialLocation, isFo
           continue;
         if (isLocationProjectReferenceRedirect(project, location))
           continue;
+        updateProjectIfDirty(project);
+        if (!project.containsFile(toNormalizedPath(location.fileName))) {
+          continue;
+        }
         const projectResults = searchPosition(project, location);
         resultsMap.set(project, projectResults != null ? projectResults : emptyArray2);
         searchedProjectKeys.add(getProjectKey(project));
@@ -182692,6 +182683,7 @@ start(initializeNodeSystem(), require("os").platform());
   mutateMapSkippingNewValues,
   needsParentheses,
   needsScopeMarker,
+  newCaseClauseTracker,
   newPrivateEnvironment,
   noEmitNotification,
   noEmitSubstitution,