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

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230207`;
+var version = `${versionMajorMinor}.0-insiders.20230208`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4256,7 +4256,7 @@ function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFi
   function createDirectoryWatcher(dirName, dirPath, fallbackOptions) {
     const watcher = fsWatch(
       dirName,
-      FileSystemEntryKind.Directory,
+      1 /* Directory */,
       (_eventName, relativeFileName, modifiedTime) => {
         if (!isString(relativeFileName))
           return;
@@ -4456,7 +4456,7 @@ function createDirectoryWatcherSupportingRecursive({
   }
   function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
     const parentWatcher = cache.get(dirPath);
-    if (parentWatcher && fileSystemEntryExists(dirName, FileSystemEntryKind.Directory)) {
+    if (parentWatcher && fileSystemEntryExists(dirName, 1 /* Directory */)) {
       scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
       return;
     }
@@ -4521,7 +4521,7 @@ function createDirectoryWatcherSupportingRecursive({
       return false;
     let newChildWatches;
     const hasChanges = enumerateInsertsAndDeletes(
-      fileSystemEntryExists(parentDir, FileSystemEntryKind.Directory) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
+      fileSystemEntryExists(parentDir, 1 /* Directory */) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
         const childFullName = getNormalizedAbsolutePath(child, parentDir);
         return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, normalizePath(realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : void 0;
       }) : emptyArray,
@@ -4552,11 +4552,6 @@ function createDirectoryWatcherSupportingRecursive({
     return stringContains(toCanonicalFilePath(path), searchPath);
   }
 }
-var FileSystemEntryKind = /* @__PURE__ */ ((FileSystemEntryKind2) => {
-  FileSystemEntryKind2[FileSystemEntryKind2["File"] = 0] = "File";
-  FileSystemEntryKind2[FileSystemEntryKind2["Directory"] = 1] = "Directory";
-  return FileSystemEntryKind2;
-})(FileSystemEntryKind || {});
 function createFileWatcherCallback(callback) {
   return (_fileName, eventKind, modifiedTime) => callback(eventKind === 1 /* Changed */ ? "change" : "rename", "", modifiedTime);
 }
@@ -15345,17 +15340,11 @@ function getCombinedLocalAndExportSymbolFlags(symbol) {
   return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags;
 }
 function isWriteOnlyAccess(node) {
-  return accessKind(node) === AccessKind.Write;
+  return accessKind(node) === 1 /* Write */;
 }
 function isWriteAccess(node) {
-  return accessKind(node) !== AccessKind.Read;
-}
-var AccessKind = /* @__PURE__ */ ((AccessKind2) => {
-  AccessKind2[AccessKind2["Read"] = 0] = "Read";
-  AccessKind2[AccessKind2["Write"] = 1] = "Write";
-  AccessKind2[AccessKind2["ReadWrite"] = 2] = "ReadWrite";
-  return AccessKind2;
-})(AccessKind || {});
+  return accessKind(node) !== 0 /* Read */;
+}
 function accessKind(node) {
   const { parent } = node;
   if (!parent)
@@ -25875,7 +25864,7 @@ var Parser;
     }
     sourceFlags = contextFlags;
     nextToken();
-    const statements = parseList(ParsingContext.SourceElements, parseStatement);
+    const statements = parseList(0 /* SourceElements */, parseStatement);
     Debug.assert(token() === 1 /* EndOfFileToken */);
     const endOfFileToken = addJSDocComment(parseTokenNode());
     const sourceFile = createSourceFile2(fileName, languageVersion2, scriptKind2, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator2);
@@ -25938,7 +25927,7 @@ var Parser;
         nextToken();
         while (token() !== 1 /* EndOfFileToken */) {
           const startPos = scanner.getStartPos();
-          const statement = parseListElement(ParsingContext.SourceElements, parseStatement);
+          const statement = parseListElement(0 /* SourceElements */, parseStatement);
           statements.push(statement);
           if (startPos === scanner.getStartPos()) {
             nextToken();
@@ -26625,19 +26614,19 @@ var Parser;
       return true;
     }
     switch (parsingContext2) {
-      case ParsingContext.SourceElements:
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauseStatements:
+      case 0 /* SourceElements */:
+      case 1 /* BlockStatements */:
+      case 3 /* SwitchClauseStatements */:
         return !(token() === 26 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement();
-      case ParsingContext.SwitchClauses:
+      case 2 /* SwitchClauses */:
         return token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
-      case ParsingContext.TypeMembers:
+      case 4 /* TypeMembers */:
         return lookAhead(isTypeMemberStart);
-      case ParsingContext.ClassMembers:
+      case 5 /* ClassMembers */:
         return lookAhead(isClassMemberStart) || token() === 26 /* SemicolonToken */ && !inErrorRecovery;
-      case ParsingContext.EnumMembers:
+      case 6 /* EnumMembers */:
         return token() === 22 /* OpenBracketToken */ || isLiteralPropertyName();
-      case ParsingContext.ObjectLiteralMembers:
+      case 12 /* ObjectLiteralMembers */:
         switch (token()) {
           case 22 /* OpenBracketToken */:
           case 41 /* AsteriskToken */:
@@ -26647,13 +26636,13 @@ var Parser;
           default:
             return isLiteralPropertyName();
         }
-      case ParsingContext.RestProperties:
+      case 18 /* RestProperties */:
         return isLiteralPropertyName();
-      case ParsingContext.ObjectBindingElements:
+      case 9 /* ObjectBindingElements */:
         return token() === 22 /* OpenBracketToken */ || token() === 25 /* DotDotDotToken */ || isLiteralPropertyName();
-      case ParsingContext.AssertEntries:
+      case 24 /* AssertEntries */:
         return isAssertionKey2();
-      case ParsingContext.HeritageClauseElement:
+      case 7 /* HeritageClauseElement */:
         if (token() === 18 /* OpenBraceToken */) {
           return lookAhead(isValidHeritageClauseObjectLiteral);
         }
@@ -26662,40 +26651,40 @@ var Parser;
         } else {
           return isIdentifier2() && !isHeritageClauseExtendsOrImplementsKeyword();
         }
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isBindingIdentifierOrPrivateIdentifierOrPattern();
-      case ParsingContext.ArrayBindingElements:
+      case 10 /* ArrayBindingElements */:
         return token() === 27 /* CommaToken */ || token() === 25 /* DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern();
-      case ParsingContext.TypeParameters:
+      case 19 /* TypeParameters */:
         return token() === 101 /* InKeyword */ || token() === 85 /* ConstKeyword */ || isIdentifier2();
-      case ParsingContext.ArrayLiteralMembers:
+      case 15 /* ArrayLiteralMembers */:
         switch (token()) {
           case 27 /* CommaToken */:
           case 24 /* DotToken */:
             return true;
         }
-      case ParsingContext.ArgumentExpressions:
+      case 11 /* ArgumentExpressions */:
         return token() === 25 /* DotDotDotToken */ || isStartOfExpression();
-      case ParsingContext.Parameters:
+      case 16 /* Parameters */:
         return isStartOfParameter(
           /*isJSDocParameter*/
           false
         );
-      case ParsingContext.JSDocParameters:
+      case 17 /* JSDocParameters */:
         return isStartOfParameter(
           /*isJSDocParameter*/
           true
         );
-      case ParsingContext.TypeArguments:
-      case ParsingContext.TupleElementTypes:
+      case 20 /* TypeArguments */:
+      case 21 /* TupleElementTypes */:
         return token() === 27 /* CommaToken */ || isStartOfType();
-      case ParsingContext.HeritageClauses:
+      case 22 /* HeritageClauses */:
         return isHeritageClause2();
-      case ParsingContext.ImportOrExportSpecifiers:
+      case 23 /* ImportOrExportSpecifiers */:
         return tokenIsIdentifierOrKeyword(token());
-      case ParsingContext.JsxAttributes:
+      case 13 /* JsxAttributes */:
         return tokenIsIdentifierOrKeyword(token()) || token() === 18 /* OpenBraceToken */;
-      case ParsingContext.JsxChildren:
+      case 14 /* JsxChildren */:
         return true;
     }
     return Debug.fail("Non-exhaustive case in 'isListElement'.");
@@ -26739,41 +26728,41 @@ var Parser;
       return true;
     }
     switch (kind) {
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauses:
-      case ParsingContext.TypeMembers:
-      case ParsingContext.ClassMembers:
-      case ParsingContext.EnumMembers:
-      case ParsingContext.ObjectLiteralMembers:
-      case ParsingContext.ObjectBindingElements:
-      case ParsingContext.ImportOrExportSpecifiers:
-      case ParsingContext.AssertEntries:
+      case 1 /* BlockStatements */:
+      case 2 /* SwitchClauses */:
+      case 4 /* TypeMembers */:
+      case 5 /* ClassMembers */:
+      case 6 /* EnumMembers */:
+      case 12 /* ObjectLiteralMembers */:
+      case 9 /* ObjectBindingElements */:
+      case 23 /* ImportOrExportSpecifiers */:
+      case 24 /* AssertEntries */:
         return token() === 19 /* CloseBraceToken */;
-      case ParsingContext.SwitchClauseStatements:
+      case 3 /* SwitchClauseStatements */:
         return token() === 19 /* CloseBraceToken */ || token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
-      case ParsingContext.HeritageClauseElement:
+      case 7 /* HeritageClauseElement */:
         return token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isVariableDeclaratorListTerminator();
-      case ParsingContext.TypeParameters:
+      case 19 /* TypeParameters */:
         return token() === 31 /* GreaterThanToken */ || token() === 20 /* OpenParenToken */ || token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
-      case ParsingContext.ArgumentExpressions:
+      case 11 /* ArgumentExpressions */:
         return token() === 21 /* CloseParenToken */ || token() === 26 /* SemicolonToken */;
-      case ParsingContext.ArrayLiteralMembers:
-      case ParsingContext.TupleElementTypes:
-      case ParsingContext.ArrayBindingElements:
+      case 15 /* ArrayLiteralMembers */:
+      case 21 /* TupleElementTypes */:
+      case 10 /* ArrayBindingElements */:
         return token() === 23 /* CloseBracketToken */;
-      case ParsingContext.JSDocParameters:
-      case ParsingContext.Parameters:
-      case ParsingContext.RestProperties:
+      case 17 /* JSDocParameters */:
+      case 16 /* Parameters */:
+      case 18 /* RestProperties */:
         return token() === 21 /* CloseParenToken */ || token() === 23 /* CloseBracketToken */;
-      case ParsingContext.TypeArguments:
+      case 20 /* TypeArguments */:
         return token() !== 27 /* CommaToken */;
-      case ParsingContext.HeritageClauses:
+      case 22 /* HeritageClauses */:
         return token() === 18 /* OpenBraceToken */ || token() === 19 /* CloseBraceToken */;
-      case ParsingContext.JsxAttributes:
+      case 13 /* JsxAttributes */:
         return token() === 31 /* GreaterThanToken */ || token() === 43 /* SlashToken */;
-      case ParsingContext.JsxChildren:
+      case 14 /* JsxChildren */:
         return token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsSlash);
       default:
         return false;
@@ -26792,7 +26781,7 @@ var Parser;
     return false;
   }
   function isInSomeParsingContext() {
-    for (let kind = 0; kind < ParsingContext.Count; kind++) {
+    for (let kind = 0; kind < 25 /* Count */; kind++) {
       if (parsingContext & 1 << kind) {
         if (isListElement(
           kind,
@@ -26861,38 +26850,38 @@ var Parser;
   }
   function isReusableParsingContext(parsingContext2) {
     switch (parsingContext2) {
-      case ParsingContext.ClassMembers:
-      case ParsingContext.SwitchClauses:
-      case ParsingContext.SourceElements:
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauseStatements:
-      case ParsingContext.EnumMembers:
-      case ParsingContext.TypeMembers:
-      case ParsingContext.VariableDeclarations:
-      case ParsingContext.JSDocParameters:
-      case ParsingContext.Parameters:
+      case 5 /* ClassMembers */:
+      case 2 /* SwitchClauses */:
+      case 0 /* SourceElements */:
+      case 1 /* BlockStatements */:
+      case 3 /* SwitchClauseStatements */:
+      case 6 /* EnumMembers */:
+      case 4 /* TypeMembers */:
+      case 8 /* VariableDeclarations */:
+      case 17 /* JSDocParameters */:
+      case 16 /* Parameters */:
         return true;
     }
     return false;
   }
   function canReuseNode(node, parsingContext2) {
     switch (parsingContext2) {
-      case ParsingContext.ClassMembers:
+      case 5 /* ClassMembers */:
         return isReusableClassMember(node);
-      case ParsingContext.SwitchClauses:
+      case 2 /* SwitchClauses */:
         return isReusableSwitchClause(node);
-      case ParsingContext.SourceElements:
-      case ParsingContext.BlockStatements:
-      case ParsingContext.SwitchClauseStatements:
+      case 0 /* SourceElements */:
+      case 1 /* BlockStatements */:
+      case 3 /* SwitchClauseStatements */:
         return isReusableStatement(node);
-      case ParsingContext.EnumMembers:
+      case 6 /* EnumMembers */:
         return isReusableEnumMember(node);
-      case ParsingContext.TypeMembers:
+      case 4 /* TypeMembers */:
         return isReusableTypeMember(node);
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isReusableVariableDeclaration(node);
-      case ParsingContext.JSDocParameters:
-      case ParsingContext.Parameters:
+      case 17 /* JSDocParameters */:
+      case 16 /* Parameters */:
         return isReusableParameter(node);
     }
     return false;
@@ -27002,56 +26991,56 @@ var Parser;
   }
   function parsingContextErrors(context) {
     switch (context) {
-      case ParsingContext.SourceElements:
+      case 0 /* SourceElements */:
         return token() === 88 /* DefaultKeyword */ ? parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(93 /* ExportKeyword */)) : parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
-      case ParsingContext.BlockStatements:
+      case 1 /* BlockStatements */:
         return parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
-      case ParsingContext.SwitchClauses:
+      case 2 /* SwitchClauses */:
         return parseErrorAtCurrentToken(Diagnostics.case_or_default_expected);
-      case ParsingContext.SwitchClauseStatements:
+      case 3 /* SwitchClauseStatements */:
         return parseErrorAtCurrentToken(Diagnostics.Statement_expected);
-      case ParsingContext.RestProperties:
-      case ParsingContext.TypeMembers:
+      case 18 /* RestProperties */:
+      case 4 /* TypeMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Property_or_signature_expected);
-      case ParsingContext.ClassMembers:
+      case 5 /* ClassMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected);
-      case ParsingContext.EnumMembers:
+      case 6 /* EnumMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Enum_member_expected);
-      case ParsingContext.HeritageClauseElement:
+      case 7 /* HeritageClauseElement */:
         return parseErrorAtCurrentToken(Diagnostics.Expression_expected);
-      case ParsingContext.VariableDeclarations:
+      case 8 /* VariableDeclarations */:
         return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_variable_declaration_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Variable_declaration_expected);
-      case ParsingContext.ObjectBindingElements:
+      case 9 /* ObjectBindingElements */:
         return parseErrorAtCurrentToken(Diagnostics.Property_destructuring_pattern_expected);
-      case ParsingContext.ArrayBindingElements:
+      case 10 /* ArrayBindingElements */:
         return parseErrorAtCurrentToken(Diagnostics.Array_element_destructuring_pattern_expected);
-      case ParsingContext.ArgumentExpressions:
+      case 11 /* ArgumentExpressions */:
         return parseErrorAtCurrentToken(Diagnostics.Argument_expression_expected);
-      case ParsingContext.ObjectLiteralMembers:
+      case 12 /* ObjectLiteralMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Property_assignment_expected);
-      case ParsingContext.ArrayLiteralMembers:
+      case 15 /* ArrayLiteralMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Expression_or_comma_expected);
-      case ParsingContext.JSDocParameters:
+      case 17 /* JSDocParameters */:
         return parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
-      case ParsingContext.Parameters:
+      case 16 /* Parameters */:
         return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_parameter_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
-      case ParsingContext.TypeParameters:
+      case 19 /* TypeParameters */:
         return parseErrorAtCurrentToken(Diagnostics.Type_parameter_declaration_expected);
-      case ParsingContext.TypeArguments:
+      case 20 /* TypeArguments */:
         return parseErrorAtCurrentToken(Diagnostics.Type_argument_expected);
-      case ParsingContext.TupleElementTypes:
+      case 21 /* TupleElementTypes */:
         return parseErrorAtCurrentToken(Diagnostics.Type_expected);
-      case ParsingContext.HeritageClauses:
+      case 22 /* HeritageClauses */:
         return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_expected);
-      case ParsingContext.ImportOrExportSpecifiers:
+      case 23 /* ImportOrExportSpecifiers */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
-      case ParsingContext.JsxAttributes:
+      case 13 /* JsxAttributes */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
-      case ParsingContext.JsxChildren:
+      case 14 /* JsxChildren */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
-      case ParsingContext.AssertEntries:
+      case 24 /* AssertEntries */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
-      case ParsingContext.Count:
+      case 25 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
       default:
         Debug.assertNever(context);
@@ -27110,7 +27099,7 @@ var Parser;
     );
   }
   function getExpectedCommaDiagnostic(kind) {
-    return kind === ParsingContext.EnumMembers ? Diagnostics.An_enum_member_name_must_be_followed_by_a_or : void 0;
+    return kind === 6 /* EnumMembers */ ? Diagnostics.An_enum_member_name_must_be_followed_by_a_or : void 0;
   }
   function createMissingList() {
     const list = createNodeArray([], getNodePos());
@@ -27304,7 +27293,7 @@ var Parser;
   }
   function parseTypeArgumentsOfTypeReference() {
     if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29 /* LessThanToken */) {
-      return parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
+      return parseBracketedList(20 /* TypeArguments */, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
     }
   }
   function parseTypeReference() {
@@ -27486,7 +27475,7 @@ var Parser;
   }
   function parseTypeParameters() {
     if (token() === 29 /* LessThanToken */) {
-      return parseBracketedList(ParsingContext.TypeParameters, parseTypeParameter, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
+      return parseBracketedList(19 /* TypeParameters */, parseTypeParameter, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
     }
   }
   function isStartOfParameter(isJSDocParameter) {
@@ -27592,7 +27581,7 @@ var Parser;
     const savedAwaitContext = inAwaitContext();
     setYieldContext(!!(flags & 1 /* Yield */));
     setAwaitContext(!!(flags & 2 /* Await */));
-    const parameters = flags & 32 /* JSDoc */ ? parseDelimitedList(ParsingContext.JSDocParameters, parseJSDocParameter) : parseDelimitedList(ParsingContext.Parameters, () => allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext));
+    const parameters = flags & 32 /* JSDoc */ ? parseDelimitedList(17 /* JSDocParameters */, parseJSDocParameter) : parseDelimitedList(16 /* Parameters */, () => allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext));
     setYieldContext(savedYieldContext);
     setAwaitContext(savedAwaitContext);
     return parameters;
@@ -27660,7 +27649,7 @@ var Parser;
     return token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 23 /* CloseBracketToken */;
   }
   function parseIndexSignatureDeclaration(pos, hasJSDoc, modifiers) {
-    const parameters = parseBracketedList(ParsingContext.Parameters, () => parseParameter(
+    const parameters = parseBracketedList(16 /* Parameters */, () => parseParameter(
       /*inOuterAwaitContext*/
       false
     ), 22 /* OpenBracketToken */, 23 /* CloseBracketToken */);
@@ -27759,7 +27748,7 @@ var Parser;
   function parseObjectTypeMembers() {
     let members;
     if (parseExpected(18 /* OpenBraceToken */)) {
-      members = parseList(ParsingContext.TypeMembers, parseTypeMember);
+      members = parseList(4 /* TypeMembers */, parseTypeMember);
       parseExpected(19 /* CloseBraceToken */);
     } else {
       members = createMissingList();
@@ -27813,7 +27802,7 @@ var Parser;
     }
     const type = parseTypeAnnotation();
     parseSemicolon();
-    const members = parseList(ParsingContext.TypeMembers, parseTypeMember);
+    const members = parseList(4 /* TypeMembers */, parseTypeMember);
     parseExpected(19 /* CloseBraceToken */);
     return finishNode(factory2.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), pos);
   }
@@ -27858,7 +27847,7 @@ var Parser;
     const pos = getNodePos();
     return finishNode(
       factory2.createTupleTypeNode(
-        parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
+        parseBracketedList(21 /* TupleElementTypes */, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
       ),
       pos
     );
@@ -28486,10 +28475,10 @@ var Parser;
   }
   function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
     const triState = isParenthesizedArrowFunctionExpression();
-    if (triState === Tristate.False) {
+    if (triState === 0 /* False */) {
       return void 0;
     }
-    return triState === Tristate.True ? parseParenthesizedArrowFunctionExpression(
+    return triState === 1 /* True */ ? parseParenthesizedArrowFunctionExpression(
       /*allowAmbiguity*/
       true,
       /*allowReturnTypeInArrowFunction*/
@@ -28501,18 +28490,18 @@ var Parser;
       return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
     }
     if (token() === 38 /* EqualsGreaterThanToken */) {
-      return Tristate.True;
+      return 1 /* True */;
     }
-    return Tristate.False;
+    return 0 /* False */;
   }
   function isParenthesizedArrowFunctionExpressionWorker() {
     if (token() === 132 /* AsyncKeyword */) {
       nextToken();
       if (scanner.hasPrecedingLineBreak()) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       if (token() !== 20 /* OpenParenToken */ && token() !== 29 /* LessThanToken */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
     }
     const first2 = token();
@@ -28524,45 +28513,45 @@ var Parser;
           case 38 /* EqualsGreaterThanToken */:
           case 58 /* ColonToken */:
           case 18 /* OpenBraceToken */:
-            return Tristate.True;
+            return 1 /* True */;
           default:
-            return Tristate.False;
+            return 0 /* False */;
         }
       }
       if (second === 22 /* OpenBracketToken */ || second === 18 /* OpenBraceToken */) {
-        return Tristate.Unknown;
+        return 2 /* Unknown */;
       }
       if (second === 25 /* DotDotDotToken */) {
-        return Tristate.True;
+        return 1 /* True */;
       }
       if (isModifierKind(second) && second !== 132 /* AsyncKeyword */ && lookAhead(nextTokenIsIdentifier)) {
         if (nextToken() === 128 /* AsKeyword */) {
-          return Tristate.False;
+          return 0 /* False */;
         }
-        return Tristate.True;
+        return 1 /* True */;
       }
       if (!isIdentifier2() && second !== 108 /* ThisKeyword */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       switch (nextToken()) {
         case 58 /* ColonToken */:
-          return Tristate.True;
+          return 1 /* True */;
         case 57 /* QuestionToken */:
           nextToken();
           if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 63 /* EqualsToken */ || token() === 21 /* CloseParenToken */) {
-            return Tristate.True;
+            return 1 /* True */;
           }
-          return Tristate.False;
+          return 0 /* False */;
         case 27 /* CommaToken */:
         case 63 /* EqualsToken */:
         case 21 /* CloseParenToken */:
-          return Tristate.Unknown;
+          return 2 /* Unknown */;
       }
-      return Tristate.False;
+      return 0 /* False */;
     } else {
       Debug.assert(first2 === 29 /* LessThanToken */);
       if (!isIdentifier2() && token() !== 85 /* ConstKeyword */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       if (languageVariant === 1 /* JSX */) {
         const isArrowFunctionInJsx = lookAhead(() => {
@@ -28584,11 +28573,11 @@ var Parser;
           return false;
         });
         if (isArrowFunctionInJsx) {
-          return Tristate.True;
+          return 1 /* True */;
         }
-        return Tristate.False;
+        return 0 /* False */;
       }
-      return Tristate.Unknown;
+      return 2 /* Unknown */;
     }
   }
   function parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
@@ -28608,7 +28597,7 @@ var Parser;
   }
   function tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction) {
     if (token() === 132 /* AsyncKeyword */) {
-      if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === Tristate.True) {
+      if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
         const pos = getNodePos();
         const asyncModifier = parseModifiersForArrowFunction();
         const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
@@ -28621,14 +28610,14 @@ var Parser;
     if (token() === 132 /* AsyncKeyword */) {
       nextToken();
       if (scanner.hasPrecedingLineBreak() || token() === 38 /* EqualsGreaterThanToken */) {
-        return Tristate.False;
+        return 0 /* False */;
       }
       const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
       if (!scanner.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();
@@ -28833,6 +28822,12 @@ var Parser;
       case 114 /* VoidKeyword */:
         return parseVoidExpression();
       case 29 /* LessThanToken */:
+        if (languageVariant === 1 /* JSX */ && token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) {
+          return parseJsxElementOrSelfClosingElementOrFragment(
+            /*inExpressionContext*/
+            true
+          );
+        }
         return parseTypeAssertion();
       case 133 /* AwaitKeyword */:
         if (isAwaitExpression2()) {
@@ -29036,7 +29031,7 @@ var Parser;
     const list = [];
     const listPos = getNodePos();
     const saveParsingContext = parsingContext;
-    parsingContext |= 1 << ParsingContext.JsxChildren;
+    parsingContext |= 1 << 14 /* JsxChildren */;
     while (true) {
       const child = parseJsxChild(openingTag, currentToken = scanner.reScanJsxToken());
       if (!child)
@@ -29051,7 +29046,7 @@ var Parser;
   }
   function parseJsxAttributes() {
     const pos = getNodePos();
-    return finishNode(factory2.createJsxAttributes(parseList(ParsingContext.JsxAttributes, parseJsxAttribute)), pos);
+    return finishNode(factory2.createJsxAttributes(parseList(13 /* JsxAttributes */, parseJsxAttribute)), pos);
   }
   function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) {
     const pos = getNodePos();
@@ -29204,6 +29199,7 @@ var Parser;
     return finishNode(factory2.createJsxJsxClosingFragment(), pos);
   }
   function parseTypeAssertion() {
+    Debug.assert(scriptKind === 3 /* TS */ || scriptKind === 4 /* TSX */, "Type assertions should never be parsed outside of TS/TSX; they should either be comparisons or JSX.");
     const pos = getNodePos();
     parseExpected(29 /* LessThanToken */);
     const type = parseType();
@@ -29379,7 +29375,7 @@ var Parser;
   }
   function parseArgumentList() {
     parseExpected(20 /* OpenParenToken */);
-    const result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
+    const result = parseDelimitedList(11 /* ArgumentExpressions */, parseArgumentExpression);
     parseExpected(21 /* CloseParenToken */);
     return result;
   }
@@ -29391,7 +29387,7 @@ var Parser;
       return void 0;
     }
     nextToken();
-    const typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType);
+    const typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
     if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
       return void 0;
     }
@@ -29491,7 +29487,7 @@ var Parser;
     const openBracketPosition = scanner.getTokenPos();
     const openBracketParsed = parseExpected(22 /* OpenBracketToken */);
     const multiLine = scanner.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);
   }
@@ -29552,7 +29548,7 @@ var Parser;
     const openBraceParsed = parseExpected(18 /* OpenBraceToken */);
     const multiLine = scanner.hasPrecedingLineBreak();
     const properties = parseDelimitedList(
-      ParsingContext.ObjectLiteralMembers,
+      12 /* ObjectLiteralMembers */,
       parseObjectLiteralElement,
       /*considerSemicolonAsDelimiter*/
       true
@@ -29624,7 +29620,7 @@ var Parser;
     const openBraceParsed = parseExpected(18 /* OpenBraceToken */, diagnosticMessage);
     if (openBraceParsed || ignoreMissingOpenBrace) {
       const multiLine = scanner.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 */) {
@@ -29782,14 +29778,14 @@ var Parser;
     parseExpected(82 /* CaseKeyword */);
     const expression = allowInAnd(parseExpression);
     parseExpected(58 /* ColonToken */);
-    const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
+    const statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
     return withJSDoc(finishNode(factory2.createCaseClause(expression, statements), pos), hasJSDoc);
   }
   function parseDefaultClause() {
     const pos = getNodePos();
     parseExpected(88 /* DefaultKeyword */);
     parseExpected(58 /* ColonToken */);
-    const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
+    const statements = parseList(3 /* SwitchClauseStatements */, parseStatement);
     return finishNode(factory2.createDefaultClause(statements), pos);
   }
   function parseCaseOrDefaultClause() {
@@ -29798,7 +29794,7 @@ var Parser;
   function parseCaseBlock() {
     const pos = getNodePos();
     parseExpected(18 /* OpenBraceToken */);
-    const clauses = parseList(ParsingContext.SwitchClauses, parseCaseOrDefaultClause);
+    const clauses = parseList(2 /* SwitchClauses */, parseCaseOrDefaultClause);
     parseExpected(19 /* CloseBraceToken */);
     return finishNode(factory2.createCaseBlock(clauses), pos);
   }
@@ -30239,14 +30235,14 @@ var Parser;
   function parseObjectBindingPattern() {
     const pos = getNodePos();
     parseExpected(18 /* OpenBraceToken */);
-    const elements = parseDelimitedList(ParsingContext.ObjectBindingElements, parseObjectBindingElement);
+    const elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement);
     parseExpected(19 /* CloseBraceToken */);
     return finishNode(factory2.createObjectBindingPattern(elements), pos);
   }
   function parseArrayBindingPattern() {
     const pos = getNodePos();
     parseExpected(22 /* OpenBracketToken */);
-    const elements = parseDelimitedList(ParsingContext.ArrayBindingElements, parseArrayBindingElement);
+    const elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement);
     parseExpected(23 /* CloseBracketToken */);
     return finishNode(factory2.createArrayBindingPattern(elements), pos);
   }
@@ -30304,7 +30300,7 @@ var Parser;
       const savedDisallowIn = inDisallowInContext();
       setDisallowInContext(inForStatementInitializer);
       declarations = parseDelimitedList(
-        ParsingContext.VariableDeclarations,
+        8 /* VariableDeclarations */,
         inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation
       );
       setDisallowInContext(savedDisallowIn);
@@ -30707,7 +30703,7 @@ var Parser;
   }
   function parseHeritageClauses() {
     if (isHeritageClause2()) {
-      return parseList(ParsingContext.HeritageClauses, parseHeritageClause);
+      return parseList(22 /* HeritageClauses */, parseHeritageClause);
     }
     return void 0;
   }
@@ -30716,7 +30712,7 @@ var Parser;
     const tok = token();
     Debug.assert(tok === 94 /* ExtendsKeyword */ || tok === 117 /* ImplementsKeyword */);
     nextToken();
-    const types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseExpressionWithTypeArguments);
+    const types = parseDelimitedList(7 /* HeritageClauseElement */, parseExpressionWithTypeArguments);
     return finishNode(factory2.createHeritageClause(tok, types), pos);
   }
   function parseExpressionWithTypeArguments() {
@@ -30729,13 +30725,13 @@ var Parser;
     return finishNode(factory2.createExpressionWithTypeArguments(expression, typeArguments), pos);
   }
   function tryParseTypeArguments() {
-    return token() === 29 /* LessThanToken */ ? parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */) : void 0;
+    return token() === 29 /* LessThanToken */ ? parseBracketedList(20 /* TypeArguments */, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */) : void 0;
   }
   function isHeritageClause2() {
     return token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
   }
   function parseClassMembers() {
-    return parseList(ParsingContext.ClassMembers, parseClassElement);
+    return parseList(5 /* ClassMembers */, parseClassElement);
   }
   function parseInterfaceDeclaration(pos, hasJSDoc, modifiers) {
     parseExpected(118 /* InterfaceKeyword */);
@@ -30768,7 +30764,7 @@ var Parser;
     const name = parseIdentifier();
     let members;
     if (parseExpected(18 /* OpenBraceToken */)) {
-      members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(ParsingContext.EnumMembers, parseEnumMember));
+      members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(6 /* EnumMembers */, parseEnumMember));
       parseExpected(19 /* CloseBraceToken */);
     } else {
       members = createMissingList();
@@ -30780,7 +30776,7 @@ var Parser;
     const pos = getNodePos();
     let statements;
     if (parseExpected(18 /* OpenBraceToken */)) {
-      statements = parseList(ParsingContext.BlockStatements, parseStatement);
+      statements = parseList(1 /* BlockStatements */, parseStatement);
       parseExpected(19 /* CloseBraceToken */);
     } else {
       statements = createMissingList();
@@ -30905,7 +30901,7 @@ var Parser;
     if (parseExpected(18 /* OpenBraceToken */)) {
       const multiLine = scanner.hasPrecedingLineBreak();
       const elements = parseDelimitedList(
-        ParsingContext.AssertEntries,
+        24 /* AssertEntries */,
         parseAssertEntry,
         /*considerSemicolonAsDelimiter*/
         true
@@ -30989,7 +30985,7 @@ var Parser;
   }
   function parseNamedImportsOrExports(kind) {
     const pos = getNodePos();
-    const node = kind === 272 /* NamedImports */ ? factory2.createNamedImports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseImportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */)) : factory2.createNamedExports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseExportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */));
+    const node = kind === 272 /* NamedImports */ ? factory2.createNamedImports(parseBracketedList(23 /* ImportOrExportSpecifiers */, parseImportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */)) : factory2.createNamedExports(parseBracketedList(23 /* ImportOrExportSpecifiers */, parseExportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */));
     return finishNode(node, pos);
   }
   function parseExportSpecifier() {
@@ -32439,7 +32435,7 @@ var IncrementalParser;
     let currentArrayIndex = 0;
     Debug.assert(currentArrayIndex < currentArray.length);
     let current = currentArray[currentArrayIndex];
-    let lastQueriedPosition = InvalidPosition.Value;
+    let lastQueriedPosition = -1 /* Value */;
     return {
       currentNode(position) {
         if (position !== lastQueriedPosition) {
@@ -32458,7 +32454,7 @@ var IncrementalParser;
     };
     function findHighestListElementThatStartsAtPosition(position) {
       currentArray = void 0;
-      currentArrayIndex = InvalidPosition.Value;
+      currentArrayIndex = -1 /* Value */;
       current = void 0;
       forEachChild(sourceFile, visitNode3, visitArray2);
       return;
@@ -36187,9 +36183,9 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   const affectingLocations = [];
   let features = getNodeResolutionFeatures(options);
   if (resolutionMode === 99 /* ESNext */ && (getEmitModuleResolutionKind(options) === 3 /* Node16 */ || getEmitModuleResolutionKind(options) === 99 /* NodeNext */)) {
-    features |= NodeResolutionFeatures.EsmMode;
+    features |= 32 /* EsmMode */;
   }
-  const conditions = features & NodeResolutionFeatures.Exports ? getConditions(options, !!(features & NodeResolutionFeatures.EsmMode)) : [];
+  const conditions = features & 8 /* Exports */ ? getConditions(options, !!(features & 32 /* EsmMode */)) : [];
   const diagnostics = [];
   const moduleResolutionState = {
     compilerOptions: options,
@@ -36322,27 +36318,27 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
   }
 }
 function getNodeResolutionFeatures(options) {
-  let features = NodeResolutionFeatures.None;
+  let features = 0 /* None */;
   switch (getEmitModuleResolutionKind(options)) {
     case 3 /* Node16 */:
-      features = NodeResolutionFeatures.Node16Default;
+      features = 30 /* Node16Default */;
       break;
     case 99 /* NodeNext */:
-      features = NodeResolutionFeatures.NodeNextDefault;
+      features = 30 /* NodeNextDefault */;
       break;
     case 100 /* Bundler */:
-      features = NodeResolutionFeatures.BundlerDefault;
+      features = 30 /* BundlerDefault */;
       break;
   }
   if (options.resolvePackageJsonExports) {
-    features |= NodeResolutionFeatures.Exports;
+    features |= 8 /* Exports */;
   } else if (options.resolvePackageJsonExports === false) {
-    features &= ~NodeResolutionFeatures.Exports;
+    features &= ~8 /* Exports */;
   }
   if (options.resolvePackageJsonImports) {
-    features |= NodeResolutionFeatures.Imports;
+    features |= 2 /* Imports */;
   } else if (options.resolvePackageJsonImports === false) {
-    features &= ~NodeResolutionFeatures.Imports;
+    features &= ~2 /* Imports */;
   }
   return features;
 }
@@ -36910,19 +36906,6 @@ function resolveJSModule(moduleName, initialDir, host) {
   }
   return resolvedModule.resolvedFileName;
 }
-var NodeResolutionFeatures = /* @__PURE__ */ ((NodeResolutionFeatures2) => {
-  NodeResolutionFeatures2[NodeResolutionFeatures2["None"] = 0] = "None";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["Imports"] = 2] = "Imports";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["SelfName"] = 4] = "SelfName";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["Exports"] = 8] = "Exports";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["ExportsPatternTrailers"] = 16] = "ExportsPatternTrailers";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["AllFeatures"] = 30] = "AllFeatures";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["Node16Default"] = 30] = "Node16Default";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["NodeNextDefault"] = 30 /* AllFeatures */] = "NodeNextDefault";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["BundlerDefault"] = 30] = "BundlerDefault";
-  NodeResolutionFeatures2[NodeResolutionFeatures2["EsmMode"] = 32] = "EsmMode";
-  return NodeResolutionFeatures2;
-})(NodeResolutionFeatures || {});
 function node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
   return nodeNextModuleNameResolverWorker(
     30 /* Node16Default */,
@@ -42122,7 +42105,6 @@ var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
   SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
   SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
   SignatureCheckMode3[SignatureCheckMode3["StrictArity"] = 8] = "StrictArity";
-  SignatureCheckMode3[SignatureCheckMode3["StrictTopSignature"] = 16] = "StrictTopSignature";
   SignatureCheckMode3[SignatureCheckMode3["Callback"] = 3] = "Callback";
   return SignatureCheckMode3;
 })(SignatureCheckMode || {});
@@ -58230,24 +58212,16 @@ function createTypeChecker(host) {
       void 0
     ) !== 0 /* False */;
   }
-  function isTopSignature(s) {
-    if (!s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && signatureHasRestParameter(s)) {
-      const paramType = getTypeOfParameter(s.parameters[0]);
-      const restType = isArrayType(paramType) ? getTypeArguments(paramType)[0] : paramType;
-      return !!(restType.flags & (1 /* Any */ | 131072 /* Never */) && getReturnTypeOfSignature(s).flags & 3 /* AnyOrUnknown */);
-    }
-    return false;
+  function isAnySignature(s) {
+    return !s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && signatureHasRestParameter(s) && (getTypeOfParameter(s.parameters[0]) === anyArrayType || isTypeAny(getTypeOfParameter(s.parameters[0]))) && isTypeAny(getReturnTypeOfSignature(s));
   }
   function compareSignaturesRelated(source, target, checkMode, reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
     if (source === target) {
       return -1 /* True */;
     }
-    if (!(checkMode & 16 /* StrictTopSignature */ && isTopSignature(source)) && isTopSignature(target)) {
+    if (isAnySignature(target)) {
       return -1 /* True */;
     }
-    if (checkMode & 16 /* StrictTopSignature */ && isTopSignature(source) && !isTopSignature(target)) {
-      return 0 /* False */;
-    }
     const targetCount = getParameterCount(target);
     const sourceHasMoreParameters = !hasEffectiveRestParameter(target) && (checkMode & 8 /* StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
     if (sourceHasMoreParameters) {
@@ -58465,9 +58439,7 @@ function createTypeChecker(host) {
   function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {
     const s = source.flags;
     const t = target.flags;
-    if (t & 1 /* Any */ || s & 131072 /* Never */ || source === wildcardType)
-      return true;
-    if (t & 2 /* Unknown */ && !(relation === strictSubtypeRelation && s & 1 /* Any */))
+    if (t & 3 /* AnyOrUnknown */ || s & 131072 /* Never */ || source === wildcardType)
       return true;
     if (t & 131072 /* Never */)
       return false;
@@ -60707,11 +60679,10 @@ function createTypeChecker(host) {
       return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
     }
     function signatureRelatedTo(source2, target2, erase, reportErrors2, intersectionState, incompatibleReporter) {
-      const checkMode = relation === subtypeRelation ? 16 /* StrictTopSignature */ : relation === strictSubtypeRelation ? 16 /* StrictTopSignature */ | 8 /* StrictArity */ : 0 /* None */;
       return compareSignaturesRelated(
         erase ? getErasedSignature(source2) : source2,
         erase ? getErasedSignature(target2) : target2,
-        checkMode,
+        relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0,
         reportErrors2,
         reportError,
         incompatibleReporter,
@@ -60836,7 +60807,7 @@ function createTypeChecker(host) {
       if (sourceInfo) {
         return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2, intersectionState);
       }
-      if (!(intersectionState & 1 /* Source */) && (relation !== strictSubtypeRelation || getObjectFlags(source2) & 8192 /* FreshLiteral */) && isObjectTypeWithInferableIndex(source2)) {
+      if (!(intersectionState & 1 /* Source */) && isObjectTypeWithInferableIndex(source2)) {
         return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
       }
       if (reportErrors2) {
@@ -61366,7 +61337,17 @@ function createTypeChecker(host) {
       return propType;
     }
     if (everyType(type, isTupleType)) {
-      return mapType(type, (t) => getRestTypeOfTupleType(t) || undefinedType);
+      return mapType(type, (t) => {
+        const tupleType = t;
+        const restType = getRestTypeOfTupleType(tupleType);
+        if (!restType) {
+          return undefinedType;
+        }
+        if (compilerOptions.noUncheckedIndexedAccess && index >= tupleType.target.fixedLength + getEndElementCount(tupleType.target, 3 /* Fixed */)) {
+          return getUnionType([restType, undefinedType]);
+        }
+        return restType;
+      });
     }
     return void 0;
   }
@@ -64008,7 +63989,7 @@ function createTypeChecker(host) {
         }
         return declaredType;
       }
-      if (isVariableDeclaration(node) && node.parent.parent.kind === 246 /* ForInStatement */ && isMatchingReference(reference, node.parent.parent.expression)) {
+      if (isVariableDeclaration(node) && node.parent.parent.kind === 246 /* ForInStatement */ && (isMatchingReference(reference, node.parent.parent.expression) || optionalChainContainsReference(node.parent.parent.expression, reference))) {
         return getNonNullableTypeIfNeeded(finalizeEvolvingArrayType(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent))));
       }
       return void 0;
@@ -64723,29 +64704,18 @@ function createTypeChecker(host) {
       return (_a3 = getCachedType(key2)) != null ? _a3 : setCachedType(key2, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived));
     }
     function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
+      const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
       if (!assumeTrue) {
-        if (checkDerived) {
-          return filterType(type, (t) => !isTypeDerivedFrom(t, candidate));
-        }
-        const trueType2 = getNarrowedType(
-          type,
-          candidate,
-          /*assumeTrue*/
-          true,
-          /*checkDerived*/
-          false
-        );
-        return filterType(type, (t) => !isTypeSubsetOf(t, trueType2));
+        return filterType(type, (t) => !isRelated(t, candidate));
       }
       if (type.flags & 3 /* AnyOrUnknown */) {
         return candidate;
       }
-      const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
       const keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : void 0;
       const narrowedType = mapType(candidate, (c) => {
         const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
         const matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
-        const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) && !isTypeIdenticalTo(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
+        const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
         return directlyRelated.flags & 131072 /* Never */ ? mapType(type, (t) => maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) : directlyRelated;
       });
       return !(narrowedType.flags & 131072 /* Never */) ? narrowedType : isTypeSubtypeOf(candidate, type) ? candidate : isTypeAssignableTo(type, candidate) ? type : isTypeAssignableTo(candidate, type) ? candidate : getIntersectionType([type, candidate]);
@@ -72501,7 +72471,7 @@ function createTypeChecker(host) {
           return leftType;
         } else {
           checkAssignmentOperator(rightType);
-          return rightType;
+          return getRegularTypeOfObjectLiteral(rightType);
         }
       case 27 /* CommaToken */:
         if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isIndirectCall(left.parent)) {
@@ -100449,6 +100419,9 @@ function transformModule(context) {
     return visitEachChild(node, visitor, context);
   }
   function visitImportCallExpression(node) {
+    if (moduleKind === 0 /* None */ && languageVersion >= 7 /* ES2020 */) {
+      return visitEachChild(node, visitor, context);
+    }
     const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
     const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor, isExpression);
     const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
@@ -106742,9 +106715,9 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     formattedNameTempFlagsStack = [];
     formattedNameTempFlags = /* @__PURE__ */ new Map();
     privateNameTempFlagsStack = [];
-    privateNameTempFlags = TempFlags.Auto;
+    privateNameTempFlags = 0 /* Auto */;
     tempFlagsStack = [];
-    tempFlags = TempFlags.Auto;
+    tempFlags = 0 /* Auto */;
     reservedNamesStack = [];
     reservedNames = void 0;
     reservedPrivateNamesStack = [];
@@ -107713,7 +107686,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitTypeLiteral(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -107902,7 +107875,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitObjectLiteralExpression(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -108668,7 +108641,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitClassDeclarationOrExpression(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -108701,7 +108674,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   }
   function emitInterfaceDeclaration(node) {
     pushPrivateNameGenerationScope(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*newReservedMemberNames*/
       void 0
     );
@@ -110144,7 +110117,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       return;
     }
     tempFlagsStack.push(tempFlags);
-    tempFlags = TempFlags.Auto;
+    tempFlags = 0 /* Auto */;
     formattedNameTempFlagsStack.push(formattedNameTempFlags);
     formattedNameTempFlags = void 0;
     reservedNamesStack.push(reservedNames);
@@ -110330,7 +110303,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       case "#":
         return privateNameTempFlags;
       default:
-        return (_a2 = formattedNameTempFlags == null ? void 0 : formattedNameTempFlags.get(formattedNameKey)) != null ? _a2 : TempFlags.Auto;
+        return (_a2 = formattedNameTempFlags == null ? void 0 : formattedNameTempFlags.get(formattedNameKey)) != null ? _a2 : 0 /* Auto */;
     }
   }
   function setTempFlags(formattedNameKey, flags) {
@@ -110354,7 +110327,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     const key = formatGeneratedName(privateName, prefix, "", suffix);
     let tempFlags2 = getTempFlags(key);
     if (flags && !(tempFlags2 & flags)) {
-      const name = flags === TempFlags._i ? "_i" : "_n";
+      const name = flags === 268435456 /* _i */ ? "_i" : "_n";
       const fullName = formatGeneratedName(privateName, prefix, name, suffix);
       if (isUniqueName(fullName, privateName)) {
         tempFlags2 |= flags;
@@ -110368,7 +110341,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       }
     }
     while (true) {
-      const count = tempFlags2 & TempFlags.CountMask;
+      const count = tempFlags2 & 268435455 /* CountMask */;
       tempFlags2++;
       if (count !== 8 && count !== 13) {
         const name = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26);
@@ -110512,7 +110485,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       return generateNameCached(node.name, privateName);
     }
     return makeTempVariableName(
-      TempFlags.Auto,
+      0 /* Auto */,
       /*reservedInNestedScopes*/
       false,
       privateName,
@@ -110569,7 +110542,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         return generateNameForMethodOrAccessor(node, privateName, prefix, suffix);
       case 164 /* ComputedPropertyName */:
         return makeTempVariableName(
-          TempFlags.Auto,
+          0 /* Auto */,
           /*reserveInNestedScopes*/
           true,
           privateName,
@@ -110578,7 +110551,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         );
       default:
         return makeTempVariableName(
-          TempFlags.Auto,
+          0 /* Auto */,
           /*reserveInNestedScopes*/
           false,
           privateName,
@@ -110593,11 +110566,11 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     const suffix = formatGeneratedNamePart(autoGenerate.suffix);
     switch (autoGenerate.flags & 7 /* KindMask */) {
       case 1 /* Auto */:
-        return makeTempVariableName(TempFlags.Auto, !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */), isPrivateIdentifier(name), prefix, suffix);
+        return makeTempVariableName(0 /* Auto */, !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */), isPrivateIdentifier(name), prefix, suffix);
       case 2 /* Loop */:
         Debug.assertNode(name, isIdentifier);
         return makeTempVariableName(
-          TempFlags._i,
+          268435456 /* _i */,
           !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */),
           /*privateName*/
           false,
@@ -111067,12 +111040,6 @@ function getOpeningBracket(format) {
 function getClosingBracket(format) {
   return brackets[format & 15360 /* BracketsMask */][1];
 }
-var TempFlags = /* @__PURE__ */ ((TempFlags2) => {
-  TempFlags2[TempFlags2["Auto"] = 0] = "Auto";
-  TempFlags2[TempFlags2["CountMask"] = 268435455] = "CountMask";
-  TempFlags2[TempFlags2["_i"] = 268435456] = "_i";
-  return TempFlags2;
-})(TempFlags || {});
 function emitListItemNoParenthesizer(node, emit, _parenthesizerRule, _index) {
   emit(node);
 }