@typescript-deploys/pr-build 5.0.0-pr-52944-25 → 5.0.0-pr-49226-5

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.20230224`;
+var version = `${versionMajorMinor}.0-insiders.20230225`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6890,12 +6890,10 @@ var Diagnostics = {
   The_root_value_of_a_0_file_must_be_an_object: diag(5092, 1 /* Error */, "The_root_value_of_a_0_file_must_be_an_object_5092", "The root value of a '{0}' file must be an object."),
   Compiler_option_0_may_only_be_used_with_build: diag(5093, 1 /* Error */, "Compiler_option_0_may_only_be_used_with_build_5093", "Compiler option '--{0}' may only be used with '--build'."),
   Compiler_option_0_may_not_be_used_with_build: diag(5094, 1 /* Error */, "Compiler_option_0_may_not_be_used_with_build_5094", "Compiler option '--{0}' may not be used with '--build'."),
-  Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later: diag(5095, 1 /* Error */, "Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later_5095", "Option 'preserveValueImports' can only be used when 'module' is set to 'es2015' or later."),
+  Option_0_can_only_be_used_when_module_is_set_to_es2015_or_later: diag(5095, 1 /* Error */, "Option_0_can_only_be_used_when_module_is_set_to_es2015_or_later_5095", "Option '{0}' can only be used when 'module' is set to 'es2015' or later."),
   Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set: diag(5096, 1 /* Error */, "Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set_5096", "Option 'allowImportingTsExtensions' can only be used when either 'noEmit' or 'emitDeclarationOnly' is set."),
   An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled: diag(5097, 1 /* Error */, "An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled_5097", "An import path can only end with a '{0}' extension when 'allowImportingTsExtensions' is enabled."),
   Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler: diag(5098, 1 /* Error */, "Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler_5098", "Option '{0}' can only be used when 'moduleResolution' is set to 'node16', 'nodenext', or 'bundler'."),
-  Import_assignment_is_not_allowed_when_moduleResolution_is_set_to_bundler_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: diag(5099, 1 /* Error */, "Import_assignment_is_not_allowed_when_moduleResolution_is_set_to_bundler_Consider_using_import_Aster_5099", `Import assignment is not allowed when 'moduleResolution' is set to 'bundler'. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead.`),
-  Export_assignment_cannot_be_used_when_moduleResolution_is_set_to_bundler_Consider_using_export_default_or_another_module_format_instead: diag(5100, 1 /* Error */, "Export_assignment_cannot_be_used_when_moduleResolution_is_set_to_bundler_Consider_using_export_defau_5100", "Export assignment cannot be used when 'moduleResolution' is set to 'bundler'. Consider using 'export default' or another module format instead."),
   Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error: diag(5101, 1 /* Error */, "Flag_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecat_5101", `Flag '{0}' is deprecated and will stop functioning in TypeScript {1}. Specify compilerOption '"ignoreDeprecations": "{2}"' to silence this error.`),
   Flag_0_is_deprecated_Please_remove_it_from_your_configuration: diag(5102, 1 /* Error */, "Flag_0_is_deprecated_Please_remove_it_from_your_configuration_5102", "Flag '{0}' is deprecated. Please remove it from your configuration."),
   Invalid_value_for_ignoreDeprecations: diag(5103, 1 /* Error */, "Invalid_value_for_ignoreDeprecations_5103", "Invalid value for '--ignoreDeprecations'."),
@@ -26060,6 +26058,34 @@ var Parser;
     ))
   };
   var factory2 = createNodeFactory(1 /* NoParenthesizerRules */ | 2 /* NoNodeConverters */ | 8 /* NoOriginalNode */, baseNodeFactory);
+  var {
+    createNodeArray: factoryCreateNodeArray,
+    createNumericLiteral: factoryCreateNumericLiteral,
+    createStringLiteral: factoryCreateStringLiteral,
+    createLiteralLikeNode: factoryCreateLiteralLikeNode,
+    createIdentifier: factoryCreateIdentifier,
+    createPrivateIdentifier: factoryCreatePrivateIdentifier,
+    createToken: factoryCreateToken,
+    createArrayLiteralExpression: factoryCreateArrayLiteralExpression,
+    createObjectLiteralExpression: factoryCreateObjectLiteralExpression,
+    createPropertyAccessExpression: factoryCreatePropertyAccessExpression,
+    createPropertyAccessChain: factoryCreatePropertyAccessChain,
+    createElementAccessExpression: factoryCreateElementAccessExpression,
+    createElementAccessChain: factoryCreateElementAccessChain,
+    createCallExpression: factoryCreateCallExpression,
+    createCallChain: factoryCreateCallChain,
+    createNewExpression: factoryCreateNewExpression,
+    createParenthesizedExpression: factoryCreateParenthesizedExpression,
+    createBlock: factoryCreateBlock,
+    createVariableStatement: factoryCreateVariableStatement,
+    createExpressionStatement: factoryCreateExpressionStatement,
+    createIfStatement: factoryCreateIfStatement,
+    createWhileStatement: factoryCreateWhileStatement,
+    createForStatement: factoryCreateForStatement,
+    createForOfStatement: factoryCreateForOfStatement,
+    createVariableDeclaration: factoryCreateVariableDeclaration,
+    createVariableDeclarationList: factoryCreateVariableDeclarationList
+  } = factory2;
   var fileName;
   var sourceFlags;
   var sourceText;
@@ -26177,8 +26203,8 @@ var Parser;
           }
         }
       }
-      const expression = isArray(expressions) ? finishNode(factory2.createArrayLiteralExpression(expressions), pos) : Debug.checkDefined(expressions);
-      const statement = factory2.createExpressionStatement(expression);
+      const expression = isArray(expressions) ? finishNode(factoryCreateArrayLiteralExpression(expressions), pos) : Debug.checkDefined(expressions);
+      const statement = factoryCreateExpressionStatement(expression);
       finishNode(statement, pos);
       statements = createNodeArray([statement], pos);
       endOfFileToken = parseExpectedToken(1 /* EndOfFileToken */, Diagnostics.Unexpected_token);
@@ -26361,7 +26387,7 @@ var Parser;
       }
     }
     syntaxCursor = savedSyntaxCursor;
-    return factory2.updateSourceFile(sourceFile, setTextRange(factory2.createNodeArray(statements), sourceFile.statements));
+    return factory2.updateSourceFile(sourceFile, setTextRange(factoryCreateNodeArray(statements), sourceFile.statements));
     function containsPossibleTopLevelAwait(node) {
       return !(node.flags & 32768 /* AwaitContext */) && !!(node.transformFlags & 67108864 /* ContainsPossibleTopLevelAwait */);
     }
@@ -26802,13 +26828,13 @@ var Parser;
     const pos = getNodePos();
     const kind = token();
     nextToken();
-    return finishNode(factory2.createToken(kind), pos);
+    return finishNode(factoryCreateToken(kind), pos);
   }
   function parseTokenNodeJSDoc() {
     const pos = getNodePos();
     const kind = token();
     nextTokenJSDoc();
-    return finishNode(factory2.createToken(kind), pos);
+    return finishNode(factoryCreateToken(kind), pos);
   }
   function canParseSemicolon() {
     if (token() === 26 /* SemicolonToken */) {
@@ -26829,7 +26855,7 @@ var Parser;
     return tryParseSemicolon() || parseExpected(26 /* SemicolonToken */);
   }
   function createNodeArray(elements, pos, end, hasTrailingComma) {
-    const array = factory2.createNodeArray(elements, hasTrailingComma);
+    const array = factoryCreateNodeArray(elements, hasTrailingComma);
     setTextRangePosEnd(array, pos, end != null ? end : scanner.getStartPos());
     return array;
   }
@@ -26851,7 +26877,7 @@ var Parser;
       parseErrorAtCurrentToken(diagnosticMessage, arg0);
     }
     const pos = getNodePos();
-    const result = kind === 79 /* Identifier */ ? factory2.createIdentifier(
+    const result = kind === 79 /* Identifier */ ? factoryCreateIdentifier(
       "",
       /*originalKeywordKind*/
       void 0
@@ -26861,15 +26887,15 @@ var Parser;
       "",
       /*templateFlags*/
       void 0
-    ) : kind === 8 /* NumericLiteral */ ? factory2.createNumericLiteral(
+    ) : kind === 8 /* NumericLiteral */ ? factoryCreateNumericLiteral(
       "",
       /*numericLiteralFlags*/
       void 0
-    ) : kind === 10 /* StringLiteral */ ? factory2.createStringLiteral(
+    ) : kind === 10 /* StringLiteral */ ? factoryCreateStringLiteral(
       "",
       /*isSingleQuote*/
       void 0
-    ) : kind === 279 /* MissingDeclaration */ ? factory2.createMissingDeclaration() : factory2.createToken(kind);
+    ) : kind === 279 /* MissingDeclaration */ ? factory2.createMissingDeclaration() : factoryCreateToken(kind);
     return finishNode(result, pos);
   }
   function internIdentifier(text) {
@@ -26887,7 +26913,7 @@ var Parser;
       const text = internIdentifier(scanner.getTokenValue());
       const hasExtendedUnicodeEscape = scanner.hasExtendedUnicodeEscape();
       nextTokenWithoutCheck();
-      return finishNode(factory2.createIdentifier(text, originalKeywordKind, hasExtendedUnicodeEscape), pos);
+      return finishNode(factoryCreateIdentifier(text, originalKeywordKind, hasExtendedUnicodeEscape), pos);
     }
     if (token() === 80 /* PrivateIdentifier */) {
       parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
@@ -26958,7 +26984,7 @@ var Parser;
   }
   function parsePrivateIdentifier() {
     const pos = getNodePos();
-    const node = factory2.createPrivateIdentifier(internIdentifier(scanner.getTokenValue()));
+    const node = factoryCreatePrivateIdentifier(internIdentifier(scanner.getTokenValue()));
     nextToken();
     return finishNode(node, pos);
   }
@@ -27673,12 +27699,12 @@ var Parser;
       // never get a token like this. Instead, we would get 00 and 9 as two separate tokens.
       // We also do not need to check for negatives because any prefix operator would be part of a
       // parent unary expression.
-      kind === 8 /* NumericLiteral */ ? factory2.createNumericLiteral(scanner.getTokenValue(), scanner.getNumericLiteralFlags()) : kind === 10 /* StringLiteral */ ? factory2.createStringLiteral(
+      kind === 8 /* NumericLiteral */ ? factoryCreateNumericLiteral(scanner.getTokenValue(), scanner.getNumericLiteralFlags()) : kind === 10 /* StringLiteral */ ? factoryCreateStringLiteral(
         scanner.getTokenValue(),
         /*isSingleQuote*/
         void 0,
         scanner.hasExtendedUnicodeEscape()
-      ) : isLiteralKind(kind) ? factory2.createLiteralLikeNode(kind, scanner.getTokenValue()) : Debug.fail()
+      ) : isLiteralKind(kind) ? factoryCreateLiteralLikeNode(kind, scanner.getTokenValue()) : Debug.fail()
     );
     if (scanner.hasExtendedUnicodeEscape()) {
       node.hasExtendedUnicodeEscape = true;
@@ -28269,7 +28295,7 @@ var Parser;
     if (token() === 126 /* AbstractKeyword */) {
       const pos = getNodePos();
       nextToken();
-      const modifier = finishNode(factory2.createToken(126 /* AbstractKeyword */), pos);
+      const modifier = finishNode(factoryCreateToken(126 /* AbstractKeyword */), pos);
       modifiers = createNodeArray([modifier], pos);
     }
     return modifiers;
@@ -29326,7 +29352,7 @@ var Parser;
       return expression;
     }
     parseExpectedToken(24 /* DotToken */, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
-    return finishNode(factory2.createPropertyAccessExpression(expression, parseRightSideOfDot(
+    return finishNode(factoryCreatePropertyAccessExpression(expression, parseRightSideOfDot(
       /*allowIdentifierNames*/
       true,
       /*allowPrivateIdentifiers*/
@@ -29347,7 +29373,7 @@ var Parser;
           factory2.createJsxElement(
             lastChild.openingElement,
             lastChild.children,
-            finishNode(factory2.createJsxClosingElement(finishNode(factory2.createIdentifier(""), end, end)), end, end)
+            finishNode(factory2.createJsxClosingElement(finishNode(factoryCreateIdentifier(""), end, end)), end, end)
           ),
           lastChild.openingElement.pos,
           end
@@ -29490,7 +29516,7 @@ var Parser;
     scanJsxIdentifier();
     let expression = token() === 108 /* ThisKeyword */ ? parseTokenNode() : parseIdentifierName();
     while (parseOptional(24 /* DotToken */)) {
-      expression = finishNode(factory2.createPropertyAccessExpression(expression, parseRightSideOfDot(
+      expression = finishNode(factoryCreatePropertyAccessExpression(expression, parseRightSideOfDot(
         /*allowIdentifierNames*/
         true,
         /*allowPrivateIdentifiers*/
@@ -29641,7 +29667,7 @@ var Parser;
       true
     );
     const isOptionalChain2 = questionDotToken || tryReparseOptionalChain(expression);
-    const propertyAccess = isOptionalChain2 ? factory2.createPropertyAccessChain(expression, questionDotToken, name) : factory2.createPropertyAccessExpression(expression, name);
+    const propertyAccess = isOptionalChain2 ? factoryCreatePropertyAccessChain(expression, questionDotToken, name) : factoryCreatePropertyAccessExpression(expression, name);
     if (isOptionalChain2 && isPrivateIdentifier(propertyAccess.name)) {
       parseErrorAtRange(propertyAccess.name, Diagnostics.An_optional_chain_cannot_contain_private_identifiers);
     }
@@ -29669,7 +29695,7 @@ var Parser;
       argumentExpression = argument;
     }
     parseExpected(23 /* CloseBracketToken */);
-    const indexedAccess = questionDotToken || tryReparseOptionalChain(expression) ? factory2.createElementAccessChain(expression, questionDotToken, argumentExpression) : factory2.createElementAccessExpression(expression, argumentExpression);
+    const indexedAccess = questionDotToken || tryReparseOptionalChain(expression) ? factoryCreateElementAccessChain(expression, questionDotToken, argumentExpression) : factoryCreateElementAccessExpression(expression, argumentExpression);
     return finishNode(indexedAccess, pos);
   }
   function parseMemberExpressionRest(pos, expression, allowOptionalChain) {
@@ -29756,7 +29782,7 @@ var Parser;
           expression = expression.expression;
         }
         const argumentList = parseArgumentList();
-        const callExpr = questionDotToken || tryReparseOptionalChain(expression) ? factory2.createCallChain(expression, questionDotToken, typeArguments, argumentList) : factory2.createCallExpression(expression, typeArguments, argumentList);
+        const callExpr = questionDotToken || tryReparseOptionalChain(expression) ? factoryCreateCallChain(expression, questionDotToken, typeArguments, argumentList) : factoryCreateCallExpression(expression, typeArguments, argumentList);
         expression = finishNode(callExpr, pos);
         continue;
       }
@@ -29767,7 +29793,7 @@ var Parser;
           false,
           Diagnostics.Identifier_expected
         );
-        expression = finishNode(factory2.createPropertyAccessChain(expression, questionDotToken, name), pos);
+        expression = finishNode(factoryCreatePropertyAccessChain(expression, questionDotToken, name), pos);
       }
       break;
     }
@@ -29862,7 +29888,7 @@ var Parser;
     parseExpected(20 /* OpenParenToken */);
     const expression = allowInAnd(parseExpression);
     parseExpected(21 /* CloseParenToken */);
-    return withJSDoc(finishNode(factory2.createParenthesizedExpression(expression), pos), hasJSDoc);
+    return withJSDoc(finishNode(factoryCreateParenthesizedExpression(expression), pos), hasJSDoc);
   }
   function parseSpreadElement() {
     const pos = getNodePos();
@@ -29889,7 +29915,7 @@ var Parser;
     const multiLine = scanner.hasPrecedingLineBreak();
     const elements = parseDelimitedList(15 /* ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement);
     parseExpectedMatchingBrackets(22 /* OpenBracketToken */, 23 /* CloseBracketToken */, openBracketParsed, openBracketPosition);
-    return finishNode(factory2.createArrayLiteralExpression(elements, multiLine), pos);
+    return finishNode(factoryCreateArrayLiteralExpression(elements, multiLine), pos);
   }
   function parseObjectLiteralElement() {
     const pos = getNodePos();
@@ -29954,7 +29980,7 @@ var Parser;
       true
     );
     parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
-    return finishNode(factory2.createObjectLiteralExpression(properties, multiLine), pos);
+    return finishNode(factoryCreateObjectLiteralExpression(properties, multiLine), pos);
   }
   function parseFunctionExpression() {
     const savedDecoratorContext = inDecoratorContext();
@@ -30011,7 +30037,7 @@ var Parser;
       parseErrorAtCurrentToken(Diagnostics.Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0, getTextOfNodeFromSourceText(sourceText, expression));
     }
     const argumentList = token() === 20 /* OpenParenToken */ ? parseArgumentList() : void 0;
-    return finishNode(factory2.createNewExpression(expression, typeArguments, argumentList), pos);
+    return finishNode(factoryCreateNewExpression(expression, typeArguments, argumentList), pos);
   }
   function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
     const pos = getNodePos();
@@ -30022,7 +30048,7 @@ var Parser;
       const multiLine = scanner.hasPrecedingLineBreak();
       const statements = parseList(1 /* BlockStatements */, parseStatement);
       parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
-      const result = withJSDoc(finishNode(factory2.createBlock(statements, multiLine), pos), hasJSDoc);
+      const result = withJSDoc(finishNode(factoryCreateBlock(statements, multiLine), pos), hasJSDoc);
       if (token() === 63 /* EqualsToken */) {
         parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_whole_assignment_in_parentheses);
         nextToken();
@@ -30030,7 +30056,7 @@ var Parser;
       return result;
     } else {
       const statements = createMissingList();
-      return withJSDoc(finishNode(factory2.createBlock(
+      return withJSDoc(finishNode(factoryCreateBlock(
         statements,
         /*multiLine*/
         void 0
@@ -30079,7 +30105,7 @@ var Parser;
     parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
     const thenStatement = parseStatement();
     const elseStatement = parseOptional(91 /* ElseKeyword */) ? parseStatement() : void 0;
-    return withJSDoc(finishNode(factory2.createIfStatement(expression, thenStatement, elseStatement), pos), hasJSDoc);
+    return withJSDoc(finishNode(factoryCreateIfStatement(expression, thenStatement, elseStatement), pos), hasJSDoc);
   }
   function parseDoStatement() {
     const pos = getNodePos();
@@ -30103,7 +30129,7 @@ var Parser;
     const expression = allowInAnd(parseExpression);
     parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
     const statement = parseStatement();
-    return withJSDoc(finishNode(factory2.createWhileStatement(expression, statement), pos), hasJSDoc);
+    return withJSDoc(finishNode(factoryCreateWhileStatement(expression, statement), pos), hasJSDoc);
   }
   function parseForOrForInOrForOfStatement() {
     const pos = getNodePos();
@@ -30129,7 +30155,7 @@ var Parser;
         true
       ));
       parseExpected(21 /* CloseParenToken */);
-      node = factory2.createForOfStatement(awaitToken, initializer, expression, parseStatement());
+      node = factoryCreateForOfStatement(awaitToken, initializer, expression, parseStatement());
     } else if (parseOptional(101 /* InKeyword */)) {
       const expression = allowInAnd(parseExpression);
       parseExpected(21 /* CloseParenToken */);
@@ -30140,7 +30166,7 @@ var Parser;
       parseExpected(26 /* SemicolonToken */);
       const incrementor = token() !== 21 /* CloseParenToken */ ? allowInAnd(parseExpression) : void 0;
       parseExpected(21 /* CloseParenToken */);
-      node = factory2.createForStatement(initializer, condition, incrementor, parseStatement());
+      node = factoryCreateForStatement(initializer, condition, incrementor, parseStatement());
     }
     return withJSDoc(finishNode(node, pos), hasJSDoc);
   }
@@ -30215,7 +30241,7 @@ var Parser;
     let expression = scanner.hasPrecedingLineBreak() ? void 0 : allowInAnd(parseExpression);
     if (expression === void 0) {
       identifierCount++;
-      expression = finishNode(factory2.createIdentifier(""), getNodePos());
+      expression = finishNode(factoryCreateIdentifier(""), getNodePos());
     }
     if (!tryParseSemicolon()) {
       parseErrorForMissingSemicolonAfter(expression);
@@ -30276,7 +30302,7 @@ var Parser;
       if (!tryParseSemicolon()) {
         parseErrorForMissingSemicolonAfter(expression);
       }
-      node = factory2.createExpressionStatement(expression);
+      node = factoryCreateExpressionStatement(expression);
       if (hasParen) {
         hasJSDoc = false;
       }
@@ -30674,7 +30700,7 @@ var Parser;
     }
     const type = parseTypeAnnotation();
     const initializer = isInOrOfKeyword(token()) ? void 0 : parseInitializer();
-    const node = factory2.createVariableDeclaration(name, exclamationToken, type, initializer);
+    const node = factoryCreateVariableDeclaration(name, exclamationToken, type, initializer);
     return withJSDoc(finishNode(node, pos), hasJSDoc);
   }
   function parseVariableDeclarationList(inForStatementInitializer) {
@@ -30705,7 +30731,7 @@ var Parser;
       );
       setDisallowInContext(savedDisallowIn);
     }
-    return finishNode(factory2.createVariableDeclarationList(declarations, flags), pos);
+    return finishNode(factoryCreateVariableDeclarationList(declarations, flags), pos);
   }
   function canFollowContextualOfKeyword() {
     return nextTokenIsIdentifier() && nextToken() === 21 /* CloseParenToken */;
@@ -30716,7 +30742,7 @@ var Parser;
       false
     );
     parseSemicolon();
-    const node = factory2.createVariableStatement(modifiers, declarationList);
+    const node = factoryCreateVariableStatement(modifiers, declarationList);
     return withJSDoc(finishNode(node, pos), hasJSDoc);
   }
   function parseFunctionDeclaration(pos, hasJSDoc, modifiers) {
@@ -30945,7 +30971,7 @@ var Parser;
         return void 0;
       }
     }
-    return finishNode(factory2.createToken(kind), pos);
+    return finishNode(factoryCreateToken(kind), pos);
   }
   function parseModifiers(allowDecorators, permitConstAsModifier, stopOnStartOfClassStaticBlock) {
     const pos = getNodePos();
@@ -30982,7 +31008,7 @@ var Parser;
     if (token() === 132 /* AsyncKeyword */) {
       const pos = getNodePos();
       nextToken();
-      const modifier = finishNode(factory2.createToken(132 /* AsyncKeyword */), pos);
+      const modifier = finishNode(factoryCreateToken(132 /* AsyncKeyword */), pos);
       modifiers = createNodeArray([modifier], pos);
     }
     return modifiers;
@@ -31569,7 +31595,7 @@ var Parser;
         /*isDeclarationFile*/
         false,
         [],
-        factory2.createToken(1 /* EndOfFileToken */),
+        factoryCreateToken(1 /* EndOfFileToken */),
         0 /* None */,
         noop
       );
@@ -32230,7 +32256,7 @@ var Parser;
         let node = parseJSDocIdentifierName();
         while (parseOptional(24 /* DotToken */)) {
           const name = parseJSDocIdentifierName();
-          node = finishNode(factory2.createPropertyAccessExpression(node, name), pos);
+          node = finishNode(factoryCreatePropertyAccessExpression(node, name), pos);
         }
         return node;
       }
@@ -32521,7 +32547,7 @@ var Parser;
         const end2 = scanner.getTextPos();
         const originalKeywordKind = token();
         const text = internIdentifier(scanner.getTokenValue());
-        const result = finishNode(factory2.createIdentifier(text, originalKeywordKind), pos, end2);
+        const result = finishNode(factoryCreateIdentifier(text, originalKeywordKind), pos, end2);
         nextTokenJSDoc();
         return result;
       }
@@ -36751,10 +36777,13 @@ function getNodeResolutionFeatures(options) {
   return features;
 }
 function getConditions(options, esmMode) {
-  const conditions = esmMode || getEmitModuleResolutionKind(options) === 100 /* Bundler */ ? ["node", "import"] : ["node", "require"];
+  const conditions = esmMode || getEmitModuleResolutionKind(options) === 100 /* Bundler */ ? ["import"] : ["require"];
   if (!options.noDtsResolution) {
     conditions.push("types");
   }
+  if (getEmitModuleResolutionKind(options) !== 100 /* Bundler */) {
+    conditions.push("node");
+  }
   return concatenate(conditions, options.customConditions);
 }
 function getAutomaticTypeDirectiveNames(options, host) {
@@ -37443,7 +37472,7 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
     isConfigLookup,
     candidateIsFromPackageJsonField: false
   };
-  if (traceEnabled && getEmitModuleResolutionKind(compilerOptions) >= 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) <= 99 /* NodeNext */) {
+  if (traceEnabled && moduleResolutionSupportsPackageJsonExportsAndImports(getEmitModuleResolutionKind(compilerOptions))) {
     trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & 32 /* EsmMode */ ? "ESM" : "CJS", conditions.map((c) => `'${c}'`).join(", "));
   }
   let result;
@@ -45802,7 +45831,9 @@ function createTypeChecker(host) {
     function getSuggestedImportSource(tsExtension) {
       const importSourceWithoutExtension = removeExtension(moduleReference, tsExtension);
       if (emitModuleKindIsNonNodeESM(moduleKind) || mode === 99 /* ESNext */) {
-        return importSourceWithoutExtension + (tsExtension === ".mts" /* Mts */ ? ".mjs" : tsExtension === ".cts" /* Cts */ ? ".cjs" : ".js");
+        const preferTs = isDeclarationFileName(moduleReference) && shouldAllowImportingTsExtension(compilerOptions);
+        const ext = tsExtension === ".mts" /* Mts */ || tsExtension === ".d.mts" /* Dmts */ ? preferTs ? ".mts" : ".mjs" : tsExtension === ".cts" /* Cts */ || tsExtension === ".d.mts" /* Dmts */ ? preferTs ? ".cts" : ".cjs" : preferTs ? ".ts" : ".js";
+        return importSourceWithoutExtension + ext;
       }
       return importSourceWithoutExtension;
     }
@@ -54421,15 +54452,27 @@ function createTypeChecker(host) {
       isInJSFile(signature.declaration)
     );
   }
-  function getTypeParameterConstraintMapper(typeParameters) {
-    const typeEraser = createTypeEraser(typeParameters);
-    const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
-    let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
-    for (let i = 0; i < typeParameters.length - 1; i++) {
-      baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
+  function getBaseSignature(signature) {
+    const typeParameters = signature.typeParameters;
+    if (typeParameters) {
+      if (signature.baseSignatureCache) {
+        return signature.baseSignatureCache;
+      }
+      const typeEraser = createTypeEraser(typeParameters);
+      const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
+      let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
+      for (let i = 0; i < typeParameters.length - 1; i++) {
+        baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
+      }
+      baseConstraints = instantiateTypes(baseConstraints, typeEraser);
+      return signature.baseSignatureCache = instantiateSignature(
+        signature,
+        createTypeMapper(typeParameters, baseConstraints),
+        /*eraseTypeParameters*/
+        true
+      );
     }
-    baseConstraints = instantiateTypes(baseConstraints, typeEraser);
-    return createTypeMapper(typeParameters, baseConstraints);
+    return signature;
   }
   function getOrCreateTypeFromSignature(signature) {
     var _a2;
@@ -56954,9 +56997,9 @@ function createTypeChecker(host) {
           }
         }
         if (!checkTypeDeferred) {
-          inferTypes(context, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+          inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
         }
-        const innerMapper = combineTypeMappers(freshMapper, getMapperFromContext(context));
+        const innerMapper = combineTypeMappers(freshMapper, context.mapper);
         combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
@@ -57643,11 +57686,8 @@ function createTypeChecker(host) {
       void 0
     );
   }
-  function createBackreferenceMapper(context, inference) {
-    const inferences = context.inferences.indexOf(inference) >= 0 ? context.inferences : context.freeTypeVariables;
-    Debug.assert(inferences, "Inference for backreference mapper must exist within provided context");
-    const index = inferences.indexOf(inference);
-    const forwardInferences = inferences.slice(index);
+  function createBackreferenceMapper(context, index) {
+    const forwardInferences = context.inferences.slice(index);
     return createTypeMapper(map(forwardInferences, (i) => i.typeParameter), map(forwardInferences, () => unknownType));
   }
   function combineTypeMappers(mapper1, mapper2) {
@@ -60461,10 +60501,9 @@ function createTypeChecker(host) {
               0 /* None */,
               isRelatedToWorker
             );
-            inferTypes(ctx, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
-            const newMapper = getMapperFromContext(ctx);
-            sourceExtends = instantiateType(sourceExtends, newMapper);
-            mapper = newMapper;
+            inferTypes(ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+            sourceExtends = instantiateType(sourceExtends, ctx.mapper);
+            mapper = ctx.mapper;
           }
           if (isTypeIdenticalTo(sourceExtends, target2.extendsType) && (isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */) || isRelatedTo(target2.checkType, source2.checkType, 3 /* Both */))) {
             if (result2 = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source2), mapper), getTrueTypeFromConditionalType(target2), 3 /* Both */, reportErrors2)) {
@@ -61618,7 +61657,7 @@ function createTypeChecker(host) {
         return type.symbol;
       }
       if (isTupleType(type)) {
-        return type.target;
+        return type;
       }
     }
     if (type.flags & 262144 /* TypeParameter */) {
@@ -62302,12 +62341,7 @@ function createTypeChecker(host) {
     return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable);
   }
   function cloneInferenceContext(context, extraFlags = 0) {
-    const newContext = context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
-    if (context && context.freeTypeVariables) {
-      newContext.freeTypeVariables = map(context.freeTypeVariables, cloneInferenceInfo);
-      newContext.freeTypeVariableSourceSignatures = new Map(mapIterator(context.freeTypeVariableSourceSignatures.entries(), ([k, v]) => [k, new Map(v.entries())]));
-    }
-    return newContext;
+    return context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
   }
   function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
     const context = {
@@ -62324,29 +62358,20 @@ function createTypeChecker(host) {
     return context;
   }
   function makeFixingMapperForContext(context) {
-    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference) => () => {
+    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference, i) => () => {
       if (!inference.isFixed) {
         inferFromIntraExpressionSites(context);
         clearCachedInferences(context.inferences);
         inference.isFixed = true;
       }
-      return getInferredType(context, inference);
+      return getInferredType(context, i);
     }));
   }
   function makeNonFixingMapperForContext(context) {
-    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference) => () => {
-      return getInferredType(context, inference);
+    return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (_, i) => () => {
+      return getInferredType(context, i);
     }));
   }
-  function makeFreeTypeVariableMapperForContext(context) {
-    if (!context.freeTypeVariables)
-      return void 0;
-    const baseMapper = getTypeParameterConstraintMapper(map(context.freeTypeVariables, (i) => i.typeParameter));
-    return context.freeTypeVariables.reduceRight(
-      (previous, i) => combineTypeMappers(makeDeferredTypeMapper([i.typeParameter], [() => hasInferenceCandidatesOrDefault(i) ? getInferredType(context, i) : instantiateType(i.typeParameter, baseMapper)]), previous),
-      baseMapper
-    );
-  }
   function clearCachedInferences(inferences) {
     for (const inference of inferences) {
       if (!inference.isFixed) {
@@ -62363,7 +62388,7 @@ function createTypeChecker(host) {
       for (const { node, type } of context.intraExpressionInferenceSites) {
         const contextualType = node.kind === 171 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType(node, 2 /* NoConstraints */);
         if (contextualType) {
-          inferTypes(context, type, contextualType);
+          inferTypes(context.inferences, type, contextualType);
         }
       }
       context.intraExpressionInferenceSites = void 0;
@@ -62398,8 +62423,7 @@ function createTypeChecker(host) {
     return inferences.length ? createInferenceContextWorker(map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : void 0;
   }
   function getMapperFromContext(context) {
-    const innerContext = context && last(flattenInferenceContextAlternatives(context));
-    return innerContext && innerContext.mapper && (innerContext.freeTypeVariables ? combineTypeMappers(innerContext.mapper, makeFreeTypeVariableMapperForContext(innerContext)) : innerContext.mapper);
+    return context && context.mapper;
   }
   function couldContainTypeVariables(type) {
     const objectFlags = getObjectFlags(type);
@@ -62499,15 +62523,8 @@ function createTypeChecker(host) {
     const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
     const templateType = getTemplateTypeFromMappedType(target);
     const inference = createInferenceInfo(typeParameter);
-    const context = createInferenceContextWorker(
-      [inference],
-      /*signature*/
-      void 0,
-      0 /* None */,
-      compareTypesAssignable
-    );
-    inferTypes(context, sourceType, templateType);
-    return getInferredTypes(context, returnFalse)[0] || unknownType;
+    inferTypes([inference], sourceType, templateType);
+    return getTypeFromInference(inference) || unknownType;
   }
   function* getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {
     const properties = getPropertiesOfType(target);
@@ -62684,15 +62701,7 @@ function createTypeChecker(host) {
       pos = p;
     }
   }
-  function flattenInferenceContextAlternatives(context) {
-    return context.alternatives ? (context.alternatives.forEach((a) => mergeInferenceContexts(
-      a,
-      context,
-      /*clone*/
-      true
-    )), context.alternatives) : [context];
-  }
-  function inferTypes(context, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
+  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
     let inferencePriority = 2048 /* MaxValue */;
@@ -62701,21 +62710,7 @@ function createTypeChecker(host) {
     let sourceStack;
     let targetStack;
     let expandingFlags = 0 /* None */;
-    let useOnlyCachedAlternativeRoutes = false;
     inferFromTypes(originalSource, originalTarget);
-    useOnlyCachedAlternativeRoutes = true;
-    const group2 = forkInferenceContext();
-    spawnAlternativeInferenceContext(
-      group2,
-      () => {
-        if (length(context.freeTypeVariables)) {
-          inferFromTypes(originalSource, instantiateType(originalTarget, context.nonFixingMapper));
-        }
-      },
-      /*fork*/
-      false
-    );
-    joinInferenceContext(group2);
     function inferFromTypes(source, target) {
       if (!couldContainTypeVariables(target)) {
         return;
@@ -62776,9 +62771,6 @@ function createTypeChecker(host) {
           if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
             return;
           }
-          if (useOnlyCachedAlternativeRoutes && source === target) {
-            return;
-          }
           if (!inference.isFixed) {
             if (inference.priority === void 0 || priority < inference.priority) {
               inference.candidates = void 0;
@@ -62791,16 +62783,16 @@ function createTypeChecker(host) {
               if (contravariant && !bivariant) {
                 if (!contains(inference.contraCandidates, candidate)) {
                   inference.contraCandidates = append(inference.contraCandidates, candidate);
-                  clearCachedInferences(context.inferences);
+                  clearCachedInferences(inferences);
                 }
               } else if (!contains(inference.candidates, candidate)) {
                 inference.candidates = append(inference.candidates, candidate);
-                clearCachedInferences(context.inferences);
+                clearCachedInferences(inferences);
               }
             }
             if (!(priority & 128 /* ReturnType */) && target.flags & 262144 /* TypeParameter */ && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
               inference.topLevel = false;
-              clearCachedInferences(context.inferences);
+              clearCachedInferences(inferences);
             }
           }
           inferencePriority = Math.min(inferencePriority, priority);
@@ -62968,12 +62960,7 @@ function createTypeChecker(host) {
     }
     function getInferenceInfoForType(type) {
       if (type.flags & 8650752 /* TypeVariable */) {
-        for (const inference of context.inferences) {
-          if (type === inference.typeParameter) {
-            return inference;
-          }
-        }
-        for (const inference of context.freeTypeVariables || []) {
+        for (const inference of inferences) {
           if (type === inference.typeParameter) {
             return inference;
           }
@@ -63254,88 +63241,17 @@ function createTypeChecker(host) {
         }
       }
     }
-    function forkInferenceContext() {
-      return [];
-    }
-    function spawnAlternativeInferenceContext(group3, action, fork = true) {
-      const oldContext = context;
-      flattenInferenceContextAlternatives(context).forEach((alternative) => {
-        const newContext = fork ? cloneInferenceContext(alternative) : alternative;
-        context = newContext;
-        action();
-        context = oldContext;
-        group3.push(...flattenInferenceContextAlternatives(newContext));
-      });
-    }
-    function joinInferenceContext(group3) {
-      group3 = group3.length < 10 ? deduplicate(group3, compareInferenceContext) : group3;
-      if (group3.length === 1) {
-        mergeInferenceContexts(context, group3[0]);
-        context.freeTypeVariables = group3[0].freeTypeVariables;
-        context.freeTypeVariableSourceSignatures = group3[0].freeTypeVariableSourceSignatures;
-        context.inferredTypeParameters = group3[0].inferredTypeParameters;
-        context.flags = group3[0].flags;
-        context.alternatives = void 0;
-        return;
-      }
-      context.alternatives = group3;
-    }
-    function compareInferenceContext(a, b) {
-      return a.compareTypes === b.compareTypes && a.flags === b.flags && a.inferredTypeParameters === b.inferredTypeParameters && a.intraExpressionInferenceSites === b.intraExpressionInferenceSites && a.signature === b.signature && compareInferencesIdentical(a, a.inferences, b, b.inferences) && compareInferencesIdentical(a, a.freeTypeVariables, b, b.freeTypeVariables);
-    }
-    function compareInferencesIdentical(ctxA, a, ctxB, b) {
-      if (length(a) !== length(b))
-        return false;
-      if (length(a) === 0)
-        return true;
-      for (let i = 0; i < length(a); i++) {
-        if (a[i].typeParameter !== b[i].typeParameter || a[i].impliedArity !== b[i].impliedArity || a[i].isFixed !== b[i].isFixed || a[i].priority !== b[i].priority || a[i].topLevel !== b[i].topLevel || forEach(a, (_, i2) => getInferredType(ctxA, a[i2]) !== getInferredType(ctxB, b[i2])))
-          return false;
-      }
-      return true;
-    }
     function inferFromSignatures(source, target, kind) {
-      var _a2, _b;
       const sourceSignatures = getSignaturesOfType(source, kind);
       const targetSignatures = getSignaturesOfType(target, kind);
       const sourceLen = sourceSignatures.length;
       const targetLen = targetSignatures.length;
-      if (targetLen === 1 && sourceLen > 1) {
-        const group3 = forkInferenceContext();
-        for (let i = 0; i < sourceLen; i++) {
-          if (useOnlyCachedAlternativeRoutes && !((_b = (_a2 = context.freeTypeVariableSourceSignatures) == null ? void 0 : _a2.get(last(sourceStack))) == null ? void 0 : _b.get(sourceSignatures[i]))) {
-            continue;
-          }
-          spawnAlternativeInferenceContext(
-            group3,
-            () => inferFromSignature(sourceSignatures[i], targetSignatures[0])
-          );
-        }
-        joinInferenceContext(group3);
-      } else {
-        const len = sourceLen < targetLen ? sourceLen : targetLen;
-        for (let i = 0; i < len; i++) {
-          inferFromSignature(sourceSignatures[sourceLen - len + i], targetSignatures[targetLen - len + i]);
-        }
+      const len = sourceLen < targetLen ? sourceLen : targetLen;
+      for (let i = 0; i < len; i++) {
+        inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
       }
     }
     function inferFromSignature(source, target) {
-      target = getErasedSignature(target);
-      if (source.typeParameters) {
-        let cache = (context.freeTypeVariableSourceSignatures || (context.freeTypeVariableSourceSignatures = /* @__PURE__ */ new Map())).get(last(sourceStack));
-        if (!cache) {
-          context.freeTypeVariableSourceSignatures.set(last(sourceStack), cache = /* @__PURE__ */ new Map());
-        }
-        const cached = cache.get(source);
-        if (cached) {
-          source = cached;
-        } else {
-          const originalSignature = source;
-          source = instantiateSignature(source, makeUnaryTypeMapper(unknownType, unknownType));
-          cache.set(originalSignature, source);
-          (context.freeTypeVariables || (context.freeTypeVariables = [])).push(...map(source.typeParameters, createInferenceInfo));
-        }
-      }
       const saveBivariant = bivariant;
       const kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
       bivariant = bivariant || kind === 171 /* MethodDeclaration */ || kind === 170 /* MethodSignature */ || kind === 173 /* Constructor */;
@@ -63410,7 +63326,8 @@ function createTypeChecker(host) {
     const unwidenedType = inference.priority & 416 /* PriorityImpliesCombination */ ? getUnionType(baseCandidates, 2 /* Subtype */) : getCommonSupertype(baseCandidates);
     return getWidenedType(unwidenedType);
   }
-  function getInferredType(context, inference) {
+  function getInferredType(context, index) {
+    const inference = context.inferences[index];
     if (!inference.inferredType) {
       let inferredType;
       const signature = context.signature;
@@ -63426,7 +63343,7 @@ function createTypeChecker(host) {
         } else {
           const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
           if (defaultType) {
-            inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, inference), context.nonFixingMapper));
+            inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
           }
         }
       } else {
@@ -63446,24 +63363,12 @@ function createTypeChecker(host) {
   function getDefaultTypeArgumentType(isInJavaScriptFile) {
     return isInJavaScriptFile ? anyType : unknownType;
   }
-  function getInferredTypes(context, accept) {
-    const alternatives = flattenInferenceContextAlternatives(context);
-    let finalAlternative;
-    for (let a = alternatives.length - 1; a >= 0; a--) {
-      const context2 = alternatives[a];
-      const freeTypeVariableMapper = makeFreeTypeVariableMapperForContext(context2);
-      const result = [];
-      for (const inference of context2.inferences) {
-        result.push(instantiateType(getInferredType(context2, inference), freeTypeVariableMapper));
-      }
-      if (alternatives.length === 1 || accept(result)) {
-        return result;
-      }
-      if (!finalAlternative) {
-        finalAlternative = result;
-      }
+  function getInferredTypes(context) {
+    const result = [];
+    for (let i = 0; i < context.inferences.length; i++) {
+      result.push(getInferredType(context, i));
     }
-    return finalAlternative;
+    return result;
   }
   function getCannotFindNameDiagnosticForName(node) {
     switch (node.escapedText) {
@@ -66841,11 +66746,8 @@ function createTypeChecker(host) {
   function instantiateContextualType(contextualType, node, contextFlags) {
     if (contextualType && maybeTypeOfKind(contextualType, 465829888 /* Instantiable */)) {
       const inferenceContext = getInferenceContext(node);
-      if (inferenceContext && contextFlags & 1 /* Signature */ && some(flatMap(flattenInferenceContextAlternatives(inferenceContext), (c) => c.inferences), hasInferenceCandidatesOrDefault)) {
-        return getUnionType(map(
-          flattenInferenceContextAlternatives(inferenceContext),
-          (c) => instantiateInstantiableTypes(contextualType, c.nonFixingMapper)
-        ));
+      if (inferenceContext && contextFlags & 1 /* Signature */ && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
+        return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
       }
       if (inferenceContext == null ? void 0 : inferenceContext.returnMapper) {
         const type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
@@ -69204,23 +69106,23 @@ function createTypeChecker(host) {
   function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
     const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
     const restType = getEffectiveRestType(contextualSignature);
-    const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : getMapperFromContext(inferenceContext));
+    const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
     applyToParameterTypes(sourceSignature, signature, (source, target) => {
-      inferTypes(context, source, target);
+      inferTypes(context.inferences, source, target);
     });
     if (!inferenceContext) {
       applyToReturnTypes(contextualSignature, signature, (source, target) => {
-        inferTypes(context, source, target, 128 /* ReturnType */);
+        inferTypes(context.inferences, source, target, 128 /* ReturnType */);
       });
     }
-    return getSignatureInstantiation(signature, getInferredTypes(context, returnFalse), isInJSFile(contextualSignature.declaration));
+    return getSignatureInstantiation(signature, getInferredTypes(context), isInJSFile(contextualSignature.declaration));
   }
-  function inferJsxTypeArguments(node, signature, checkMode, context, accept) {
+  function inferJsxTypeArguments(node, signature, checkMode, context) {
     const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
     const checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
-    inferTypes(context, checkAttrType, paramType);
-    return getInferredTypes(context, accept);
+    inferTypes(context.inferences, checkAttrType, paramType);
+    return getInferredTypes(context);
   }
   function getThisArgumentType(thisArgumentNode) {
     if (!thisArgumentNode) {
@@ -69229,9 +69131,9 @@ function createTypeChecker(host) {
     const thisArgumentType = checkExpression(thisArgumentNode);
     return isOptionalChainRoot(thisArgumentNode.parent) ? getNonNullableType(thisArgumentType) : isOptionalChain(thisArgumentNode.parent) ? removeOptionalTypeMarker(thisArgumentType) : thisArgumentType;
   }
-  function inferTypeArguments(node, signature, args, checkMode, context, accept) {
+  function inferTypeArguments(node, signature, args, checkMode, context) {
     if (isJsxOpeningLikeElement(node)) {
-      return inferJsxTypeArguments(node, signature, checkMode, context, accept);
+      return inferJsxTypeArguments(node, signature, checkMode, context);
     }
     if (node.kind !== 167 /* Decorator */) {
       const skipBindingPatterns = every(signature.typeParameters, (p) => !!getDefaultFromTypeParameter(p));
@@ -69246,11 +69148,11 @@ function createTypeChecker(host) {
             const instantiatedType = instantiateType(contextualType, outerMapper);
             const contextualSignature = getSingleCallSignature(instantiatedType);
             const inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : instantiatedType;
-            inferTypes(context, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
           }
           const returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
           const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
-          inferTypes(returnContext, returnSourceType, inferenceTargetType);
+          inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
           context.returnMapper = some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : void 0;
         }
       }
@@ -69266,7 +69168,7 @@ function createTypeChecker(host) {
     const thisType = getThisTypeOfSignature(signature);
     if (thisType && couldContainTypeVariables(thisType)) {
       const thisArgumentNode = getThisArgumentOfCall(node);
-      inferTypes(context, getThisArgumentType(thisArgumentNode), thisType);
+      inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
     }
     for (let i = 0; i < argCount; i++) {
       const arg = args[i];
@@ -69274,15 +69176,15 @@ function createTypeChecker(host) {
         const paramType = getTypeAtPosition(signature, i);
         if (couldContainTypeVariables(paramType)) {
           const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
-          inferTypes(context, argType, paramType);
+          inferTypes(context.inferences, argType, paramType);
         }
       }
     }
     if (restType && couldContainTypeVariables(restType)) {
       const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
-      inferTypes(context, spreadType, restType);
+      inferTypes(context.inferences, spreadType, restType);
     }
-    return getInferredTypes(context, accept);
+    return getInferredTypes(context);
   }
   function getMutableArrayOrTupleType(type) {
     return type.flags & 1048576 /* Union */ ? mapType(type, getMutableArrayOrTupleType) : type.flags & 1 /* Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : isTupleType(type) ? createTupleType(
@@ -70049,26 +69951,6 @@ function createTypeChecker(host) {
         }
         let checkCandidate;
         let inferenceContext;
-        const acceptor = (types) => {
-          const checkCandidate2 = getSignatureInstantiation(candidate, types, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
-          if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate2, signatureHelpTrailingComma2)) {
-            return false;
-          }
-          if (getSignatureApplicabilityError(
-            node,
-            args,
-            checkCandidate2,
-            relation,
-            argCheckMode,
-            /*reportErrors*/
-            false,
-            /*containingMessageChain*/
-            void 0
-          )) {
-            return false;
-          }
-          return true;
-        };
         if (candidate.typeParameters) {
           let typeArgumentTypes;
           if (some(typeArguments)) {
@@ -70089,7 +69971,7 @@ function createTypeChecker(host) {
               /*flags*/
               isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
             );
-            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext, acceptor);
+            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
             argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
           }
           checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
@@ -70117,7 +69999,7 @@ function createTypeChecker(host) {
         if (argCheckMode) {
           argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
           if (inferenceContext) {
-            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext, acceptor);
+            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
             checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
               candidateForArgumentArityError = checkCandidate;
@@ -70227,7 +70109,7 @@ function createTypeChecker(host) {
       /*flags*/
       isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
     );
-    const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext, returnFalse);
+    const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
     return createSignatureInstantiation(candidate, typeArgumentTypes);
   }
   function getLongestCandidateIndex(candidates, argsCount) {
@@ -71495,7 +71377,7 @@ function createTypeChecker(host) {
       if (declaration.type) {
         const typeNode = getEffectiveTypeAnnotationNode(declaration);
         if (typeNode) {
-          inferTypes(inferenceContext, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
+          inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
         }
       }
     }
@@ -72207,7 +72089,7 @@ function createTypeChecker(host) {
                 instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
               }
             }
-            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, getMapperFromContext(inferenceContext)) : contextualSignature);
+            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
             assignContextualParameterTypes(signature, instantiatedContextualSignature);
           } else {
             assignNonContextualParameterTypes(signature);
@@ -73588,7 +73470,7 @@ function createTypeChecker(host) {
     return isAssertionExpression(parent) && isConstTypeReference(parent.type) || isJSDocTypeAssertion(parent) && isConstTypeReference(getJSDocTypeAssertionType(parent)) || isValidConstAssertionArgument(node) && isConstTypeParameterContext(node) || (isParenthesizedExpression(parent) || isArrayLiteralExpression(parent) || isSpreadElement(parent)) && isConstContext(parent) || (isPropertyAssignment(parent) || isShorthandPropertyAssignment(parent) || isTemplateSpan(parent)) && isConstContext(parent.parent);
   }
   function isConstTypeParameterContext(node) {
-    const contextualType = getContextualType(node, 1 /* Signature */);
+    const contextualType = getContextualType(node, 0 /* None */);
     return !!contextualType && someType(contextualType, isConstTypeVariable);
   }
   function checkExpressionForMutableLocation(node, checkMode, forceTuple) {
@@ -73653,11 +73535,10 @@ function createTypeChecker(host) {
             if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
               const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
               const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
-              const subcontext = cloneInferenceContext(context);
-              subcontext.inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
+              const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
               applyToParameterTypes(instantiatedSignature, contextualSignature, (source, target) => {
                 inferTypes(
-                  subcontext,
+                  inferences,
                   source,
                   target,
                   /*priority*/
@@ -73666,12 +73547,12 @@ function createTypeChecker(host) {
                   true
                 );
               });
-              if (some(subcontext.inferences, hasInferenceCandidates)) {
+              if (some(inferences, hasInferenceCandidates)) {
                 applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
-                  inferTypes(subcontext, source, target);
+                  inferTypes(inferences, source, target);
                 });
-                if (!hasOverlappingInferences(context.inferences, subcontext.inferences)) {
-                  mergeInferenceContexts(context, subcontext);
+                if (!hasOverlappingInferences(context.inferences, inferences)) {
+                  mergeInferences(context.inferences, inferences);
                   context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
                   return getOrCreateTypeFromSignature(instantiatedSignature);
                 }
@@ -73704,22 +73585,13 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function mergeInferences(target, source, clone2 = false) {
+  function mergeInferences(target, source) {
     for (let i = 0; i < target.length; i++) {
       if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
-        target[i] = clone2 ? {
-          ...source[i],
-          candidates: source[i].candidates && [...source[i].candidates],
-          contraCandidates: source[i].contraCandidates && [...source[i].contraCandidates]
-        } : source[i];
+        target[i] = source[i];
       }
     }
   }
-  function mergeInferenceContexts(target, source, cloneInferences = false) {
-    mergeInferences(target.inferences, source.inferences, cloneInferences);
-    target.mapper = makeFixingMapperForContext(target);
-    target.nonFixingMapper = makeNonFixingMapperForContext(target);
-  }
   function getUniqueTypeParameters(context, typeParameters) {
     const result = [];
     let oldTypeParameters;
@@ -78954,8 +78826,6 @@ function createTypeChecker(host) {
       } else {
         if (moduleKind >= 5 /* ES2015 */ && getSourceFileOfNode(node).impliedNodeFormat === void 0 && !node.isTypeOnly && !(node.flags & 16777216 /* Ambient */)) {
           grammarErrorOnNode(node, Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
-        } else if (!(node.flags & 16777216 /* Ambient */) && getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */) {
-          grammarErrorOnNode(node, Diagnostics.Import_assignment_is_not_allowed_when_moduleResolution_is_set_to_bundler_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead);
         }
       }
     }
@@ -79162,8 +79032,6 @@ function createTypeChecker(host) {
         grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
       } else if (moduleKind === 4 /* System */ && !(node.flags & 16777216 /* Ambient */)) {
         grammarErrorOnNode(node, Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system);
-      } else if (getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */ && !(node.flags & 16777216 /* Ambient */)) {
-        grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_moduleResolution_is_set_to_bundler_Consider_using_export_default_or_another_module_format_instead);
       }
     }
   }
@@ -115402,10 +115270,10 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       }
     }
     if (options.preserveValueImports && getEmitModuleKind(options) < 5 /* ES2015 */) {
-      createDiagnosticForOptionName(Diagnostics.Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later, "preserveValueImports");
+      createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_module_is_set_to_es2015_or_later, "preserveValueImports");
     }
+    const moduleKind = getEmitModuleKind(options);
     if (options.verbatimModuleSyntax) {
-      const moduleKind = getEmitModuleKind(options);
       if (moduleKind === 2 /* AMD */ || moduleKind === 3 /* UMD */ || moduleKind === 4 /* System */) {
         createDiagnosticForOptionName(Diagnostics.Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System, "verbatimModuleSyntax");
       }
@@ -115424,13 +115292,16 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
     const moduleResolution = getEmitModuleResolutionKind(options);
     if (options.resolvePackageJsonExports && !moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-      createOptionValueDiagnostic("resolvePackageJsonExports", Diagnostics.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "resolvePackageJsonExports");
+      createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "resolvePackageJsonExports");
     }
     if (options.resolvePackageJsonImports && !moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-      createOptionValueDiagnostic("resolvePackageJsonImports", Diagnostics.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "resolvePackageJsonImports");
+      createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "resolvePackageJsonImports");
     }
     if (options.customConditions && !moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-      createOptionValueDiagnostic("customConditions", Diagnostics.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "customConditions");
+      createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler, "customConditions");
+    }
+    if (moduleResolution === 100 /* Bundler */ && !emitModuleKindIsNonNodeESM(moduleKind)) {
+      createOptionValueDiagnostic("moduleResolution", Diagnostics.Option_0_can_only_be_used_when_module_is_set_to_es2015_or_later, "bundler");
     }
     if (!options.noEmit && !options.suppressOutputPathCheck) {
       const emitHost = getEmitHost();