npm - @typescript-deploys/pr-build - Versions diffs - 5.0.0-pr-52282-27 → 5.0.0-pr-52667-13 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/lib/tsc.js +219 -252
package/lib/tsserver.js +276 -345
package/lib/tsserverlibrary.js +283 -352
package/lib/typescript.js +283 -352
package/lib/typingsInstaller.js +174 -186
package/package.json +1 -1

package/lib/typescript.js CHANGED Viewed

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-insiders.20230207`;
+      version = `${versionMajorMinor}.0-insiders.20230208`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -5492,7 +5492,7 @@ ${lanes.join("\n")}
     function createDirectoryWatcher(dirName, dirPath, fallbackOptions) {
       const watcher = fsWatch(
         dirName,
-        FileSystemEntryKind.Directory,
+        1 /* Directory */,
         (_eventName, relativeFileName, modifiedTime) => {
           if (!isString(relativeFileName))
             return;
@@ -5690,7 +5690,7 @@ ${lanes.join("\n")}
     }
     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;
       }
@@ -5755,7 +5755,7 @@ ${lanes.join("\n")}
         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,
@@ -17055,10 +17055,10 @@ ${lanes.join("\n")}
     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;
+    return accessKind(node) !== 0 /* Read */;
   }
   function accessKind(node) {
     const { parent: parent2 } = node;
@@ -18725,7 +18725,7 @@ ${lanes.join("\n")}
     const tag = getJSDocSatisfiesTag(node);
     return tag && tag.typeExpression && tag.typeExpression.type;
   }
-  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashAMDReferencePathRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, AccessKind, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
+  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashAMDReferencePathRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
   var init_utilities = __esm({
     "src/compiler/utilities.ts"() {
       "use strict";
@@ -18829,12 +18829,6 @@ ${lanes.join("\n")}
       base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
       carriageReturnLineFeed = "\r\n";
       lineFeed = "\n";
-      AccessKind = /* @__PURE__ */ ((AccessKind2) => {
-        AccessKind2[AccessKind2["Read"] = 0] = "Read";
-        AccessKind2[AccessKind2["Write"] = 1] = "Write";
-        AccessKind2[AccessKind2["ReadWrite"] = 2] = "ReadWrite";
-        return AccessKind2;
-      })(AccessKind || {});
       objectAllocator = {
         getNodeConstructor: () => Node4,
         getTokenConstructor: () => Token,
@@ -28302,7 +28296,7 @@ ${lanes.join("\n")}
           }
           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);
@@ -28365,7 +28359,7 @@ ${lanes.join("\n")}
               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();
@@ -29052,19 +29046,19 @@ ${lanes.join("\n")}
             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 */:
@@ -29074,13 +29068,13 @@ ${lanes.join("\n")}
                 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);
               }
@@ -29089,40 +29083,40 @@ ${lanes.join("\n")}
               } 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'.");
@@ -29166,41 +29160,41 @@ ${lanes.join("\n")}
             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;
@@ -29219,7 +29213,7 @@ ${lanes.join("\n")}
           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,
@@ -29288,38 +29282,38 @@ ${lanes.join("\n")}
         }
         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;
@@ -29429,56 +29423,56 @@ ${lanes.join("\n")}
         }
         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);
@@ -29537,7 +29531,7 @@ ${lanes.join("\n")}
           );
         }
         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());
@@ -29731,7 +29725,7 @@ ${lanes.join("\n")}
         }
         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() {
@@ -29913,7 +29907,7 @@ ${lanes.join("\n")}
         }
         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) {
@@ -30019,7 +30013,7 @@ ${lanes.join("\n")}
           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;
@@ -30087,7 +30081,7 @@ ${lanes.join("\n")}
           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 */);
@@ -30186,7 +30180,7 @@ ${lanes.join("\n")}
         function parseObjectTypeMembers() {
           let members;
           if (parseExpected(18 /* OpenBraceToken */)) {
-            members = parseList(ParsingContext.TypeMembers, parseTypeMember);
+            members = parseList(4 /* TypeMembers */, parseTypeMember);
             parseExpected(19 /* CloseBraceToken */);
           } else {
             members = createMissingList();
@@ -30240,7 +30234,7 @@ ${lanes.join("\n")}
           }
           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);
         }
@@ -30285,7 +30279,7 @@ ${lanes.join("\n")}
           const pos = getNodePos();
           return finishNode(
             factory2.createTupleTypeNode(
-              parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
+              parseBracketedList(21 /* TupleElementTypes */, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
             ),
             pos
           );
@@ -30913,10 +30907,10 @@ ${lanes.join("\n")}
         }
         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*/
@@ -30928,18 +30922,18 @@ ${lanes.join("\n")}
             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();
@@ -30951,45 +30945,45 @@ ${lanes.join("\n")}
                 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(() => {
@@ -31011,11 +31005,11 @@ ${lanes.join("\n")}
                 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) {
@@ -31035,7 +31029,7 @@ ${lanes.join("\n")}
         }
         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 */);
@@ -31048,14 +31042,14 @@ ${lanes.join("\n")}
           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();
@@ -31260,6 +31254,12 @@ ${lanes.join("\n")}
             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()) {
@@ -31463,7 +31463,7 @@ ${lanes.join("\n")}
           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)
@@ -31478,7 +31478,7 @@ ${lanes.join("\n")}
         }
         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();
@@ -31631,6 +31631,7 @@ ${lanes.join("\n")}
           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();
@@ -31806,7 +31807,7 @@ ${lanes.join("\n")}
         }
         function parseArgumentList() {
           parseExpected(20 /* OpenParenToken */);
-          const result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
+          const result = parseDelimitedList(11 /* ArgumentExpressions */, parseArgumentExpression);
           parseExpected(21 /* CloseParenToken */);
           return result;
         }
@@ -31818,7 +31819,7 @@ ${lanes.join("\n")}
             return void 0;
           }
           nextToken();
-          const typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType);
+          const typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
           if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
             return void 0;
           }
@@ -31918,7 +31919,7 @@ ${lanes.join("\n")}
           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);
         }
@@ -31979,7 +31980,7 @@ ${lanes.join("\n")}
           const openBraceParsed = parseExpected(18 /* OpenBraceToken */);
           const multiLine = scanner2.hasPrecedingLineBreak();
           const properties = parseDelimitedList(
-            ParsingContext.ObjectLiteralMembers,
+            12 /* ObjectLiteralMembers */,
             parseObjectLiteralElement,
             /*considerSemicolonAsDelimiter*/
             true
@@ -32051,7 +32052,7 @@ ${lanes.join("\n")}
           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 */) {
@@ -32209,14 +32210,14 @@ ${lanes.join("\n")}
           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() {
@@ -32225,7 +32226,7 @@ ${lanes.join("\n")}
         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);
         }
@@ -32666,14 +32667,14 @@ ${lanes.join("\n")}
         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);
         }
@@ -32731,7 +32732,7 @@ ${lanes.join("\n")}
             const savedDisallowIn = inDisallowInContext();
             setDisallowInContext(inForStatementInitializer);
             declarations = parseDelimitedList(
-              ParsingContext.VariableDeclarations,
+              8 /* VariableDeclarations */,
               inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation
             );
             setDisallowInContext(savedDisallowIn);
@@ -33134,7 +33135,7 @@ ${lanes.join("\n")}
         }
         function parseHeritageClauses() {
           if (isHeritageClause2()) {
-            return parseList(ParsingContext.HeritageClauses, parseHeritageClause);
+            return parseList(22 /* HeritageClauses */, parseHeritageClause);
           }
           return void 0;
         }
@@ -33143,7 +33144,7 @@ ${lanes.join("\n")}
           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() {
@@ -33156,13 +33157,13 @@ ${lanes.join("\n")}
           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 */);
@@ -33195,7 +33196,7 @@ ${lanes.join("\n")}
           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();
@@ -33207,7 +33208,7 @@ ${lanes.join("\n")}
           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();
@@ -33332,7 +33333,7 @@ ${lanes.join("\n")}
           if (parseExpected(18 /* OpenBraceToken */)) {
             const multiLine = scanner2.hasPrecedingLineBreak();
             const elements = parseDelimitedList(
-              ParsingContext.AssertEntries,
+              24 /* AssertEntries */,
               parseAssertEntry,
               /*considerSemicolonAsDelimiter*/
               true
@@ -33416,7 +33417,7 @@ ${lanes.join("\n")}
         }
         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() {
@@ -34865,7 +34866,7 @@ ${lanes.join("\n")}
           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) {
@@ -34884,7 +34885,7 @@ ${lanes.join("\n")}
           };
           function findHighestListElementThatStartsAtPosition(position) {
             currentArray = void 0;
-            currentArrayIndex = InvalidPosition.Value;
+            currentArrayIndex = -1 /* Value */;
             current = void 0;
             forEachChild(sourceFile, visitNode3, visitArray2);
             return;
@@ -38471,9 +38472,9 @@ ${lanes.join("\n")}
     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,
@@ -38606,27 +38607,27 @@ ${lanes.join("\n")}
     }
   }
   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;
   }
@@ -60603,24 +60604,16 @@ ${lanes.join("\n")}
         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) {
@@ -60838,9 +60831,7 @@ ${lanes.join("\n")}
     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;
@@ -63080,11 +63071,10 @@ ${lanes.join("\n")}
         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,
@@ -63209,7 +63199,7 @@ ${lanes.join("\n")}
         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) {
@@ -63739,7 +63729,17 @@ ${lanes.join("\n")}
         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;
     }
@@ -66381,7 +66381,7 @@ ${lanes.join("\n")}
           }
           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;
@@ -67096,29 +67096,18 @@ ${lanes.join("\n")}
         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]);
@@ -74874,7 +74863,7 @@ ${lanes.join("\n")}
             return leftType;
           } else {
             checkAssignmentOperator(rightType);
-            return rightType;
+            return getRegularTypeOfObjectLiteral(rightType);
           }
         case 27 /* CommaToken */:
           if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isIndirectCall(left.parent)) {
@@ -84593,7 +84582,6 @@ ${lanes.join("\n")}
         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 || {});
@@ -103260,6 +103248,9 @@ ${lanes.join("\n")}
       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;
@@ -109563,9 +109554,9 @@ ${lanes.join("\n")}
       formattedNameTempFlagsStack = [];
       formattedNameTempFlags = /* @__PURE__ */ new Map();
       privateNameTempFlagsStack = [];
-      privateNameTempFlags = TempFlags.Auto;
+      privateNameTempFlags = 0 /* Auto */;
       tempFlagsStack = [];
-      tempFlags = TempFlags.Auto;
+      tempFlags = 0 /* Auto */;
       reservedNamesStack = [];
       reservedNames = void 0;
       reservedPrivateNamesStack = [];
@@ -110534,7 +110525,7 @@ ${lanes.join("\n")}
     }
     function emitTypeLiteral(node) {
       pushPrivateNameGenerationScope(
-        TempFlags.Auto,
+        0 /* Auto */,
         /*newReservedMemberNames*/
         void 0
       );
@@ -110723,7 +110714,7 @@ ${lanes.join("\n")}
     }
     function emitObjectLiteralExpression(node) {
       pushPrivateNameGenerationScope(
-        TempFlags.Auto,
+        0 /* Auto */,
         /*newReservedMemberNames*/
         void 0
       );
@@ -111489,7 +111480,7 @@ ${lanes.join("\n")}
     }
     function emitClassDeclarationOrExpression(node) {
       pushPrivateNameGenerationScope(
-        TempFlags.Auto,
+        0 /* Auto */,
         /*newReservedMemberNames*/
         void 0
       );
@@ -111522,7 +111513,7 @@ ${lanes.join("\n")}
     }
     function emitInterfaceDeclaration(node) {
       pushPrivateNameGenerationScope(
-        TempFlags.Auto,
+        0 /* Auto */,
         /*newReservedMemberNames*/
         void 0
       );
@@ -112965,7 +112956,7 @@ ${lanes.join("\n")}
         return;
       }
       tempFlagsStack.push(tempFlags);
-      tempFlags = TempFlags.Auto;
+      tempFlags = 0 /* Auto */;
       formattedNameTempFlagsStack.push(formattedNameTempFlags);
       formattedNameTempFlags = void 0;
       reservedNamesStack.push(reservedNames);
@@ -113151,7 +113142,7 @@ ${lanes.join("\n")}
         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) {
@@ -113175,7 +113166,7 @@ ${lanes.join("\n")}
       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;
@@ -113189,7 +113180,7 @@ ${lanes.join("\n")}
         }
       }
       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);
@@ -113333,7 +113324,7 @@ ${lanes.join("\n")}
         return generateNameCached(node.name, privateName);
       }
       return makeTempVariableName(
-        TempFlags.Auto,
+        0 /* Auto */,
         /*reservedInNestedScopes*/
         false,
         privateName,
@@ -113390,7 +113381,7 @@ ${lanes.join("\n")}
           return generateNameForMethodOrAccessor(node, privateName, prefix, suffix);
         case 164 /* ComputedPropertyName */:
           return makeTempVariableName(
-            TempFlags.Auto,
+            0 /* Auto */,
             /*reserveInNestedScopes*/
             true,
             privateName,
@@ -113399,7 +113390,7 @@ ${lanes.join("\n")}
           );
         default:
           return makeTempVariableName(
-            TempFlags.Auto,
+            0 /* Auto */,
             /*reserveInNestedScopes*/
             false,
             privateName,
@@ -113414,11 +113405,11 @@ ${lanes.join("\n")}
       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,
@@ -113900,7 +113891,7 @@ ${lanes.join("\n")}
   function getEmitListItem(emit, parenthesizerRule) {
     return emit.length === 1 ? emitListItemNoParenthesizer : typeof parenthesizerRule === "object" ? emitListItemWithParenthesizerRuleSelector : emitListItemWithParenthesizerRule;
   }
-  var brackets, notImplementedResolver, createPrinterWithDefaults, createPrinterWithRemoveComments, createPrinterWithRemoveCommentsNeverAsciiEscape, createPrinterWithRemoveCommentsOmitTrailingSemicolon, TempFlags;
+  var brackets, notImplementedResolver, createPrinterWithDefaults, createPrinterWithRemoveComments, createPrinterWithRemoveCommentsNeverAsciiEscape, createPrinterWithRemoveCommentsOmitTrailingSemicolon;
   var init_emitter = __esm({
     "src/compiler/emitter.ts"() {
       "use strict";
@@ -113955,12 +113946,6 @@ ${lanes.join("\n")}
       createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true }));
       createPrinterWithRemoveCommentsNeverAsciiEscape = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, neverAsciiEscape: true }));
       createPrinterWithRemoveCommentsOmitTrailingSemicolon = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true, omitTrailingSemicolon: true }));
-      TempFlags = /* @__PURE__ */ ((TempFlags2) => {
-        TempFlags2[TempFlags2["Auto"] = 0] = "Auto";
-        TempFlags2[TempFlags2["CountMask"] = 268435455] = "CountMask";
-        TempFlags2[TempFlags2["_i"] = 268435456] = "_i";
-        return TempFlags2;
-      })(TempFlags || {});
     }
   });
@@ -126646,7 +126631,7 @@ ${lanes.join("\n")}
     );
   }
   function makeStringLiteral(text, quotePreference) {
-    return factory.createStringLiteral(text, quotePreference === QuotePreference.Single);
+    return factory.createStringLiteral(text, quotePreference === 0 /* Single */);
   }
   function quotePreferenceFromString(str, sourceFile) {
     return isStringDoubleQuoted(str, sourceFile) ? 1 /* Double */ : 0 /* Single */;
@@ -139397,13 +139382,13 @@ ${lanes.join("\n")}
       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);
@@ -139422,7 +139407,7 @@ ${lanes.join("\n")}
           }
           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");
@@ -139443,7 +139428,7 @@ ${lanes.join("\n")}
           }
           break;
         }
-        case ImportFixKind.PromoteTypeOnly:
+        case 4 /* PromoteTypeOnly */:
           break;
         default:
           Debug.assertNever(fix, `fix wasn't never - got kind ${fix.kind}`);
@@ -139470,13 +139455,13 @@ ${lanes.join("\n")}
           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) {
@@ -140483,7 +140468,7 @@ ${lanes.join("\n")}
     }
     return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
   }
-  var importFixName, importFixId, errorCodes17, ImportFixKind, AddAsTypeOnly;
+  var importFixName, importFixId, errorCodes17;
   var init_importFixes = __esm({
     "src/services/codefixes/importFixes.ts"() {
       "use strict";
@@ -140542,20 +140527,6 @@ ${lanes.join("\n")}
           return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, importAdder.writeFixes));
         }
       });
-      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 || {});
-      AddAsTypeOnly = /* @__PURE__ */ ((AddAsTypeOnly2) => {
-        AddAsTypeOnly2[AddAsTypeOnly2["Allowed"] = 1] = "Allowed";
-        AddAsTypeOnly2[AddAsTypeOnly2["Required"] = 2] = "Required";
-        AddAsTypeOnly2[AddAsTypeOnly2["NotAllowed"] = 4] = "NotAllowed";
-        return AddAsTypeOnly2;
-      })(AddAsTypeOnly || {});
     }
   });
@@ -146859,19 +146830,19 @@ ${lanes.join("\n")}
       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);
@@ -146974,7 +146945,7 @@ ${lanes.join("\n")}
   }
   function keywordCompletionData(keywordFilters, filterOutTsOnlyKeywords, isNewIdentifierLocation) {
     return {
-      kind: CompletionDataKind.Keywords,
+      kind: 4 /* Keywords */,
       keywordCompletions: getKeywordCompletions(keywordFilters, filterOutTsOnlyKeywords),
       isNewIdentifierLocation
     };
@@ -147251,9 +147222,9 @@ ${lanes.join("\n")}
   }
   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;
@@ -147369,7 +147340,7 @@ ${lanes.join("\n")}
     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;
@@ -147904,7 +147875,7 @@ ${lanes.join("\n")}
       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;
@@ -148043,7 +148014,7 @@ ${lanes.join("\n")}
     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;
@@ -148069,13 +148040,13 @@ ${lanes.join("\n")}
       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);
@@ -150081,7 +150052,7 @@ ${lanes.join("\n")}
     }
     return charCode;
   }
-  var moduleSpecifierResolutionLimit, moduleSpecifierResolutionCacheAttemptLimit, SortText, CompletionSource, SymbolOriginInfoKind, CompletionDataKind, CompletionKind, _keywordCompletions, allKeywordsCompletions;
+  var moduleSpecifierResolutionLimit, moduleSpecifierResolutionCacheAttemptLimit, SortText, CompletionSource, SymbolOriginInfoKind, CompletionKind, _keywordCompletions, allKeywordsCompletions;
   var init_completions = __esm({
     "src/services/completions.ts"() {
       "use strict";
@@ -150133,14 +150104,6 @@ ${lanes.join("\n")}
         SymbolOriginInfoKind2[SymbolOriginInfoKind2["SymbolMemberExport"] = 6] = "SymbolMemberExport";
         return SymbolOriginInfoKind2;
       })(SymbolOriginInfoKind || {});
-      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 || {});
       CompletionKind = /* @__PURE__ */ ((CompletionKind2) => {
         CompletionKind2[CompletionKind2["ObjectPropertyDeclaration"] = 0] = "ObjectPropertyDeclaration";
         CompletionKind2[CompletionKind2["Global"] = 1] = "Global";
@@ -150199,9 +150162,9 @@ ${lanes.join("\n")}
     }
     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,
@@ -150223,7 +150186,7 @@ ${lanes.join("\n")}
         );
         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 */,
@@ -150245,15 +150208,15 @@ ${lanes.join("\n")}
   }
   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);
@@ -150455,7 +150418,7 @@ ${lanes.join("\n")}
     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) {
@@ -150971,7 +150934,7 @@ ${lanes.join("\n")}
   function isRequireCallArgument(node) {
     return isCallExpression(node.parent) && firstOrUndefined(node.parent.arguments) === node && isIdentifier(node.parent.expression) && node.parent.expression.escapedText === "require";
   }
-  var kindPrecedence, StringLiteralCompletionKind, ReferenceKind, tripleSlashDirectiveFragmentRegex, nodeModulesDependencyKeys;
+  var kindPrecedence, tripleSlashDirectiveFragmentRegex, nodeModulesDependencyKeys;
   var init_stringCompletions = __esm({
     "src/services/stringCompletions.ts"() {
       "use strict";
@@ -150982,17 +150945,6 @@ ${lanes.join("\n")}
         ["script" /* scriptElement */]: 1,
         ["external module name" /* externalModuleName */]: 2
       };
-      StringLiteralCompletionKind = /* @__PURE__ */ ((StringLiteralCompletionKind2) => {
-        StringLiteralCompletionKind2[StringLiteralCompletionKind2["Paths"] = 0] = "Paths";
-        StringLiteralCompletionKind2[StringLiteralCompletionKind2["Properties"] = 1] = "Properties";
-        StringLiteralCompletionKind2[StringLiteralCompletionKind2["Types"] = 2] = "Types";
-        return StringLiteralCompletionKind2;
-      })(StringLiteralCompletionKind || {});
-      ReferenceKind = /* @__PURE__ */ ((ReferenceKind2) => {
-        ReferenceKind2[ReferenceKind2["Filename"] = 0] = "Filename";
-        ReferenceKind2[ReferenceKind2["ModuleSpecifier"] = 1] = "ModuleSpecifier";
-        return ReferenceKind2;
-      })(ReferenceKind || {});
       tripleSlashDirectiveFragmentRegex = /^(\/\/\/\s*<reference\s+(path|types)\s*=\s*(?:'|"))([^\3"]*)$/;
       nodeModulesDependencyKeys = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
     }
@@ -152343,7 +152295,7 @@ ${lanes.join("\n")}
           ) || 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(
@@ -152399,14 +152351,14 @@ ${lanes.join("\n")}
           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) {
@@ -159472,10 +159424,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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 {
@@ -159541,7 +159493,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     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 */;
   }
   function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParameterUsages, substitutions }, exposedVariableDeclarations, range, context) {
     const checker = context.program.getTypeChecker();
@@ -159574,7 +159526,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         typeNode
       );
       parameters.push(paramDecl);
-      if (usage.usage === Usage.Write) {
+      if (usage.usage === 2 /* Write */) {
         (writes || (writes = [])).push(usage);
       }
       callArguments.push(factory.createIdentifier(name));
@@ -160532,7 +160484,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
   function isStringLiteralJsxAttribute(node) {
     return isStringLiteral(node) && node.parent && isJsxAttribute(node.parent);
   }
-  var refactorName11, extractConstantAction, extractFunctionAction, Messages, RangeFacts, SpecialScope, Usage;
+  var refactorName11, extractConstantAction, extractFunctionAction, Messages, RangeFacts;
   var init_extractSymbol = __esm({
     "src/services/refactors/extractSymbol.ts"() {
       "use strict";
@@ -160595,16 +160547,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         RangeFacts2[RangeFacts2["InStaticRegion"] = 32] = "InStaticRegion";
         return RangeFacts2;
       })(RangeFacts || {});
-      SpecialScope = /* @__PURE__ */ ((SpecialScope2) => {
-        SpecialScope2[SpecialScope2["Module"] = 0] = "Module";
-        SpecialScope2[SpecialScope2["Global"] = 1] = "Global";
-        return SpecialScope2;
-      })(SpecialScope || {});
-      Usage = /* @__PURE__ */ ((Usage2) => {
-        Usage2[Usage2["Read"] = 1] = "Read";
-        Usage2[Usage2["Write"] = 2] = "Write";
-        return Usage2;
-      })(Usage || {});
     }
   });
@@ -161036,7 +160978,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     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));
   }
   function getCandidateOrTypeInfo({ invocation, argumentCount }, checker, sourceFile, startingToken, onlyUseSyntacticOwners) {
     switch (invocation.kind) {
@@ -161508,16 +161450,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     });
     return { name: typeParameter.symbol.name, documentation: typeParameter.symbol.getDocumentationComment(checker), displayParts, isOptional: false, isRest: false };
   }
-  var CandidateOrTypeKind, signatureHelpNodeBuilderFlags, separatorDisplayParts;
+  var signatureHelpNodeBuilderFlags, separatorDisplayParts;
   var init_signatureHelp = __esm({
     "src/services/signatureHelp.ts"() {
       "use strict";
       init_ts4();
-      CandidateOrTypeKind = /* @__PURE__ */ ((CandidateOrTypeKind2) => {
-        CandidateOrTypeKind2[CandidateOrTypeKind2["Candidate"] = 0] = "Candidate";
-        CandidateOrTypeKind2[CandidateOrTypeKind2["Type"] = 1] = "Type";
-        return CandidateOrTypeKind2;
-      })(CandidateOrTypeKind || {});
       signatureHelpNodeBuilderFlags = 8192 /* OmitParameterModifiers */ | 70221824 /* IgnoreErrors */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
       separatorDisplayParts = [punctuationPart(27 /* CommaToken */), spacePart()];
     }
@@ -165522,7 +165459,7 @@ ${options.prefix}` : "\n" : options.prefix
         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) {
@@ -165530,11 +165467,11 @@ ${options.prefix}` : "\n" : options.prefix
           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 */;
             }
           }
         }
@@ -165560,7 +165497,7 @@ ${options.prefix}` : "\n" : options.prefix
             );
           }
           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;
           }
@@ -165607,7 +165544,7 @@ ${options.prefix}` : "\n" : options.prefix
     }
     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);
@@ -165626,13 +165563,13 @@ ${options.prefix}` : "\n" : options.prefix
       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*/
@@ -165641,7 +165578,7 @@ ${options.prefix}` : "\n" : options.prefix
                   );
                 }
                 break;
-              case LineAction.LineAdded:
+              case 1 /* LineAdded */:
                 if (currentParent.getStart(sourceFile) === currentItem.pos) {
                   dynamicIndentation.recomputeIndentation(
                     /*lineAddedByFormatting*/
@@ -165651,7 +165588,7 @@ ${options.prefix}` : "\n" : options.prefix
                 }
                 break;
               default:
-                Debug.assert(lineAction === LineAction.None);
+                Debug.assert(lineAction === 0 /* None */);
             }
           }
           trimTrailingWhitespaces = trimTrailingWhitespaces && !(rule2.action & 16 /* DeleteSpace */) && rule2.flags !== 1 /* CanDeleteNewLines */;
@@ -165798,11 +165735,11 @@ ${options.prefix}` : "\n" : options.prefix
       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 */:
@@ -165810,28 +165747,28 @@ ${options.prefix}` : "\n" : options.prefix
           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 */;
     }
   }
   function getRangeOfEnclosingComment(sourceFile, position, precedingToken, tokenAtPosition = getTokenAtPosition(sourceFile, position)) {
@@ -165957,18 +165894,12 @@ ${options.prefix}` : "\n" : options.prefix
       return remainder ? spacesString + repeatString(" ", remainder) : spacesString;
     }
   }
-  var LineAction, internedSizes, internedTabsIndentation, internedSpacesIndentation;
+  var internedSizes, internedTabsIndentation, internedSpacesIndentation;
   var init_formatting = __esm({
     "src/services/formatting/formatting.ts"() {
       "use strict";
       init_ts4();
       init_ts_formatting();
-      LineAction = /* @__PURE__ */ ((LineAction2) => {
-        LineAction2[LineAction2["None"] = 0] = "None";
-        LineAction2[LineAction2["LineAdded"] = 1] = "LineAdded";
-        LineAction2[LineAction2["LineRemoved"] = 2] = "LineRemoved";
-        return LineAction2;
-      })(LineAction || {});
     }
   });
@@ -166072,7 +166003,7 @@ ${options.prefix}` : "\n" : options.prefix
             )) {
               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,