@typescript-deploys/pr-build 5.0.0-pr-52282-27 → 5.0.0-pr-52667-13

package/lib/tsserver.js

@@ -2287,7 +2287,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230207`;
+var version = `${versionMajorMinor}.0-insiders.20230208`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7704,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;
@@ -7904,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;
     }
@@ -7969,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,
@@ -19315,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)
@@ -30191,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);
@@ -30254,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();
@@ -30941,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 */:
@@ -30963,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);
         }
@@ -30978,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'.");
@@ -31055,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;
@@ -31108,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,
@@ -31177,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;
@@ -31318,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);
@@ -31426,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());
@@ -31620,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() {
@@ -31802,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) {
@@ -31908,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;
@@ -31976,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 */);
@@ -32075,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();
@@ -32129,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);
   }
@@ -32174,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
     );
@@ -32802,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*/
@@ -32817,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();
@@ -32840,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(() => {
@@ -32900,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) {
@@ -32924,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 */);
@@ -32937,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();
@@ -33149,6 +33143,12 @@ var Parser;
       case 114 /* VoidKeyword */:
         return parseVoidExpression();
       case 29 /* LessThanToken */:
+        if (languageVariant === 1 /* JSX */ && token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) {
+          return parseJsxElementOrSelfClosingElementOrFragment(
+            /*inExpressionContext*/
+            true
+          );
+        }
         return parseTypeAssertion();
       case 133 /* AwaitKeyword */:
         if (isAwaitExpression2()) {
@@ -33352,7 +33352,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)
@@ -33367,7 +33367,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();
@@ -33520,6 +33520,7 @@ var Parser;
     return finishNode(factory2.createJsxJsxClosingFragment(), pos);
   }
   function parseTypeAssertion() {
+    Debug.assert(scriptKind === 3 /* TS */ || scriptKind === 4 /* TSX */, "Type assertions should never be parsed outside of TS/TSX; they should either be comparisons or JSX.");
     const pos = getNodePos();
     parseExpected(29 /* LessThanToken */);
     const type = parseType();
@@ -33695,7 +33696,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;
   }
@@ -33707,7 +33708,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;
     }
@@ -33807,7 +33808,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);
   }
@@ -33868,7 +33869,7 @@ var Parser;
     const openBraceParsed = parseExpected(18 /* OpenBraceToken */);
     const multiLine = scanner2.hasPrecedingLineBreak();
     const properties = parseDelimitedList(
-      ParsingContext.ObjectLiteralMembers,
+      12 /* ObjectLiteralMembers */,
       parseObjectLiteralElement,
       /*considerSemicolonAsDelimiter*/
       true
@@ -33940,7 +33941,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 */) {
@@ -34098,14 +34099,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() {
@@ -34114,7 +34115,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);
   }
@@ -34555,14 +34556,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);
   }
@@ -34620,7 +34621,7 @@ var Parser;
       const savedDisallowIn = inDisallowInContext();
       setDisallowInContext(inForStatementInitializer);
       declarations = parseDelimitedList(
-        ParsingContext.VariableDeclarations,
+        8 /* VariableDeclarations */,
         inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation
       );
       setDisallowInContext(savedDisallowIn);
@@ -35023,7 +35024,7 @@ var Parser;
   }
   function parseHeritageClauses() {
     if (isHeritageClause2()) {
-      return parseList(ParsingContext.HeritageClauses, parseHeritageClause);
+      return parseList(22 /* HeritageClauses */, parseHeritageClause);
     }
     return void 0;
   }
@@ -35032,7 +35033,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() {
@@ -35045,13 +35046,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 */);
@@ -35084,7 +35085,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();
@@ -35096,7 +35097,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();
@@ -35221,7 +35222,7 @@ var Parser;
     if (parseExpected(18 /* OpenBraceToken */)) {
       const multiLine = scanner2.hasPrecedingLineBreak();
       const elements = parseDelimitedList(
-        ParsingContext.AssertEntries,
+        24 /* AssertEntries */,
         parseAssertEntry,
         /*considerSemicolonAsDelimiter*/
         true
@@ -35305,7 +35306,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() {
@@ -36755,7 +36756,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) {
@@ -36774,7 +36775,7 @@ var IncrementalParser;
     };
     function findHighestListElementThatStartsAtPosition(position) {
       currentArray = void 0;
-      currentArrayIndex = InvalidPosition.Value;
+      currentArrayIndex = -1 /* Value */;
       current = void 0;
       forEachChild(sourceFile, visitNode3, visitArray2);
       return;
@@ -40571,9 +40572,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,
@@ -40706,27 +40707,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;
 }
@@ -46686,7 +46687,6 @@ var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
   SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
   SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
   SignatureCheckMode3[SignatureCheckMode3["StrictArity"] = 8] = "StrictArity";
-  SignatureCheckMode3[SignatureCheckMode3["StrictTopSignature"] = 16] = "StrictTopSignature";
   SignatureCheckMode3[SignatureCheckMode3["Callback"] = 3] = "Callback";
   return SignatureCheckMode3;
 })(SignatureCheckMode || {});
@@ -62794,24 +62794,16 @@ function createTypeChecker(host) {
       void 0
     ) !== 0 /* False */;
   }
-  function isTopSignature(s) {
-    if (!s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && signatureHasRestParameter(s)) {
-      const paramType = getTypeOfParameter(s.parameters[0]);
-      const restType = isArrayType(paramType) ? getTypeArguments(paramType)[0] : paramType;
-      return !!(restType.flags & (1 /* Any */ | 131072 /* Never */) && getReturnTypeOfSignature(s).flags & 3 /* AnyOrUnknown */);
-    }
-    return false;
+  function isAnySignature(s) {
+    return !s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && signatureHasRestParameter(s) && (getTypeOfParameter(s.parameters[0]) === anyArrayType || isTypeAny(getTypeOfParameter(s.parameters[0]))) && isTypeAny(getReturnTypeOfSignature(s));
   }
   function compareSignaturesRelated(source, target, checkMode, reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
     if (source === target) {
       return -1 /* True */;
     }
-    if (!(checkMode & 16 /* StrictTopSignature */ && isTopSignature(source)) && isTopSignature(target)) {
+    if (isAnySignature(target)) {
       return -1 /* True */;
     }
-    if (checkMode & 16 /* StrictTopSignature */ && isTopSignature(source) && !isTopSignature(target)) {
-      return 0 /* False */;
-    }
     const targetCount = getParameterCount(target);
     const sourceHasMoreParameters = !hasEffectiveRestParameter(target) && (checkMode & 8 /* StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
     if (sourceHasMoreParameters) {
@@ -63029,9 +63021,7 @@ function createTypeChecker(host) {
   function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {
     const s = source.flags;
     const t = target.flags;
-    if (t & 1 /* Any */ || s & 131072 /* Never */ || source === wildcardType)
-      return true;
-    if (t & 2 /* Unknown */ && !(relation === strictSubtypeRelation && s & 1 /* Any */))
+    if (t & 3 /* AnyOrUnknown */ || s & 131072 /* Never */ || source === wildcardType)
       return true;
     if (t & 131072 /* Never */)
       return false;
@@ -65271,11 +65261,10 @@ function createTypeChecker(host) {
       return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
     }
     function signatureRelatedTo(source2, target2, erase, reportErrors2, intersectionState, incompatibleReporter) {
-      const checkMode = relation === subtypeRelation ? 16 /* StrictTopSignature */ : relation === strictSubtypeRelation ? 16 /* StrictTopSignature */ | 8 /* StrictArity */ : 0 /* None */;
       return compareSignaturesRelated(
         erase ? getErasedSignature(source2) : source2,
         erase ? getErasedSignature(target2) : target2,
-        checkMode,
+        relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0,
         reportErrors2,
         reportError,
         incompatibleReporter,
@@ -65400,7 +65389,7 @@ function createTypeChecker(host) {
       if (sourceInfo) {
         return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2, intersectionState);
       }
-      if (!(intersectionState & 1 /* Source */) && (relation !== strictSubtypeRelation || getObjectFlags(source2) & 8192 /* FreshLiteral */) && isObjectTypeWithInferableIndex(source2)) {
+      if (!(intersectionState & 1 /* Source */) && isObjectTypeWithInferableIndex(source2)) {
         return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
       }
       if (reportErrors2) {
@@ -65930,7 +65919,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;
   }
@@ -68572,7 +68571,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;
@@ -69287,29 +69286,18 @@ function createTypeChecker(host) {
       return (_a3 = getCachedType(key2)) != null ? _a3 : setCachedType(key2, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived));
     }
     function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
+      const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
       if (!assumeTrue) {
-        if (checkDerived) {
-          return filterType(type, (t) => !isTypeDerivedFrom(t, candidate));
-        }
-        const trueType2 = getNarrowedType(
-          type,
-          candidate,
-          /*assumeTrue*/
-          true,
-          /*checkDerived*/
-          false
-        );
-        return filterType(type, (t) => !isTypeSubsetOf(t, trueType2));
+        return filterType(type, (t) => !isRelated(t, candidate));
       }
       if (type.flags & 3 /* AnyOrUnknown */) {
         return candidate;
       }
-      const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
       const keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : void 0;
       const narrowedType = mapType(candidate, (c) => {
         const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
         const matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
-        const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) && !isTypeIdenticalTo(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
+        const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
         return directlyRelated.flags & 131072 /* Never */ ? mapType(type, (t) => maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) : directlyRelated;
       });
       return !(narrowedType.flags & 131072 /* Never */) ? narrowedType : isTypeSubtypeOf(candidate, type) ? candidate : isTypeAssignableTo(type, candidate) ? type : isTypeAssignableTo(candidate, type) ? candidate : getIntersectionType([type, candidate]);
@@ -77065,7 +77053,7 @@ function createTypeChecker(host) {
           return leftType;
         } else {
           checkAssignmentOperator(rightType);
-          return rightType;
+          return getRegularTypeOfObjectLiteral(rightType);
         }
       case 27 /* CommaToken */:
         if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isIndirectCall(left.parent)) {
@@ -105184,6 +105172,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;
@@ -111488,9 +111479,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 = [];
@@ -112459,7 +112450,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitTypeLiteral(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -112648,7 +112639,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitObjectLiteralExpression(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -113414,7 +113405,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitClassDeclarationOrExpression(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -113447,7 +113438,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitInterfaceDeclaration(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -114890,7 +114881,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       return;
     }
     tempFlagsStack.push(tempFlags);
-    tempFlags = TempFlags.Auto;
+    tempFlags = 0 /* Auto */;
     formattedNameTempFlagsStack.push(formattedNameTempFlags);
     formattedNameTempFlags = void 0;
     reservedNamesStack.push(reservedNames);
@@ -115076,7 +115067,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) {
@@ -115100,7 +115091,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;
@@ -115114,7 +115105,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);
@@ -115258,7 +115249,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       return generateNameCached(node.name, privateName);
     }
     return makeTempVariableName(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*reservedInNestedScopes*/
       false,
       privateName,
@@ -115315,7 +115306,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         return generateNameForMethodOrAccessor(node, privateName, prefix, suffix);
       case 164 /* ComputedPropertyName */:
         return makeTempVariableName(
-          TempFlags.Auto,
+          0 /* Auto */,
           /*reserveInNestedScopes*/
           true,
           privateName,
@@ -115324,7 +115315,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         );
       default:
         return makeTempVariableName(
-          TempFlags.Auto,
+          0 /* Auto */,
           /*reserveInNestedScopes*/
           false,
           privateName,
@@ -115339,11 +115330,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,
@@ -115813,12 +115804,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);
 }
@@ -128326,7 +128311,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";
@@ -140830,13 +140815,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);
@@ -140855,7 +140840,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");
@@ -140876,7 +140861,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}`);
@@ -140903,13 +140888,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) {
@@ -140991,20 +140976,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);
@@ -147790,19 +147761,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);
@@ -147905,7 +147876,7 @@ function specificKeywordCompletionInfo(entries, isNewIdentifierLocation) {
 }
 function keywordCompletionData(keywordFilters, filterOutTsOnlyKeywords, isNewIdentifierLocation) {
   return {
-    kind: CompletionDataKind.Keywords,
+    kind: 4 /* Keywords */,
     keywordCompletions: getKeywordCompletions(keywordFilters, filterOutTsOnlyKeywords),
     isNewIdentifierLocation
   };
@@ -148182,9 +148153,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;
@@ -148300,7 +148271,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;
@@ -148835,7 +148806,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;
@@ -148974,7 +148945,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;
@@ -149000,13 +148971,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);
@@ -149148,14 +149119,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";
@@ -151088,9 +151051,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,
@@ -151112,7 +151075,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 */,
@@ -151134,15 +151097,15 @@ 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:
+    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);
@@ -151188,12 +151151,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) {
@@ -151350,7 +151307,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) {
@@ -151422,11 +151379,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) {
@@ -153196,7 +153148,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(
@@ -153252,14 +153204,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) {
@@ -160188,10 +160140,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 {
@@ -160257,13 +160209,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());
@@ -160295,7 +160242,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));
@@ -160947,11 +160894,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 = [];
@@ -161600,13 +161542,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 */: {
@@ -166017,7 +165954,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) {
@@ -166025,11 +165962,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 */;
           }
         }
       }
@@ -166055,7 +165992,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;
         }
@@ -166102,7 +166039,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);
@@ -166121,13 +166058,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*/
@@ -166136,7 +166073,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
                 );
               }
               break;
-            case LineAction.LineAdded:
+            case 1 /* LineAdded */:
               if (currentParent.getStart(sourceFile) === currentItem.pos) {
                 dynamicIndentation.recomputeIndentation(
                   /*lineAddedByFormatting*/
@@ -166146,7 +166083,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 */;
@@ -166293,11 +166230,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 */:
@@ -166305,36 +166242,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)
@@ -166557,7 +166488,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,