@typescript-deploys/pr-build 5.7.0-pr-57718-9 → 5.8.0-pr-57838-3

package/lib/_tsc.js

@@ -17,8 +17,8 @@ and limitations under the License.
 "use strict";
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-insiders.20241031`;
+var versionMajorMinor = "5.8";
+var version = `${versionMajorMinor}.0-insiders.20241130`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3680,6 +3680,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
   ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
   ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
+  ObjectFlags3[ObjectFlags3["IsNarrowingType"] = 16777216] = "IsNarrowingType";
   ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
@@ -15067,7 +15068,7 @@ function tryGetModuleSpecifierFromDeclaration(node) {
   }
 }
 function shouldRewriteModuleSpecifier(specifier, compilerOptions) {
-  return !!compilerOptions.rewriteRelativeImportExtensions && pathIsRelative(specifier) && !isDeclarationFileName(specifier);
+  return !!compilerOptions.rewriteRelativeImportExtensions && pathIsRelative(specifier) && !isDeclarationFileName(specifier) && hasTSFileExtension(specifier);
 }
 function getExternalModuleName(node) {
   switch (node.kind) {
@@ -22453,6 +22454,8 @@ function createNodeFactory(flags, baseFactory2) {
     node.colonToken = colonToken ?? createToken(59 /* ColonToken */);
     node.whenFalse = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenFalse);
     node.transformFlags |= propagateChildFlags(node.condition) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.whenTrue) | propagateChildFlags(node.colonToken) | propagateChildFlags(node.whenFalse);
+    node.flowNodeWhenFalse = void 0;
+    node.flowNodeWhenTrue = void 0;
     return node;
   }
   function updateConditionalExpression(node, condition, questionToken, whenTrue, colonToken, whenFalse) {
@@ -24256,7 +24259,7 @@ function createNodeFactory(flags, baseFactory2) {
   function isIgnorableParen(node) {
     return isParenthesizedExpression(node) && nodeIsSynthesized(node) && nodeIsSynthesized(getSourceMapRange(node)) && nodeIsSynthesized(getCommentRange(node)) && !some(getSyntheticLeadingComments(node)) && !some(getSyntheticTrailingComments(node));
   }
-  function restoreOuterExpressions(outerExpression, innerExpression, kinds = 31 /* All */) {
+  function restoreOuterExpressions(outerExpression, innerExpression, kinds = 63 /* All */) {
     if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
       return updateOuterExpression(
         outerExpression,
@@ -24302,7 +24305,7 @@ function createNodeFactory(flags, baseFactory2) {
     }
   }
   function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers = false) {
-    const callee = skipOuterExpressions(expression, 31 /* All */);
+    const callee = skipOuterExpressions(expression, 63 /* All */);
     let thisArg;
     let target;
     if (isSuperProperty(callee)) {
@@ -27171,7 +27174,7 @@ function getJSDocTypeAssertionType(node) {
   Debug.assertIsDefined(type);
   return type;
 }
-function isOuterExpression(node, kinds = 31 /* All */) {
+function isOuterExpression(node, kinds = 63 /* All */) {
   switch (node.kind) {
     case 217 /* ParenthesizedExpression */:
       if (kinds & -2147483648 /* ExcludeJSDocTypeAssertion */ && isJSDocTypeAssertion(node)) {
@@ -27180,8 +27183,9 @@ function isOuterExpression(node, kinds = 31 /* All */) {
       return (kinds & 1 /* Parentheses */) !== 0;
     case 216 /* TypeAssertionExpression */:
     case 234 /* AsExpression */:
-    case 238 /* SatisfiesExpression */:
       return (kinds & 2 /* TypeAssertions */) !== 0;
+    case 238 /* SatisfiesExpression */:
+      return (kinds & (2 /* TypeAssertions */ | 32 /* Satisfies */)) !== 0;
     case 233 /* ExpressionWithTypeArguments */:
       return (kinds & 16 /* ExpressionsWithTypeArguments */) !== 0;
     case 235 /* NonNullExpression */:
@@ -27191,13 +27195,13 @@ function isOuterExpression(node, kinds = 31 /* All */) {
   }
   return false;
 }
-function skipOuterExpressions(node, kinds = 31 /* All */) {
+function skipOuterExpressions(node, kinds = 63 /* All */) {
   while (isOuterExpression(node, kinds)) {
     node = node.expression;
   }
   return node;
 }
-function walkUpOuterExpressions(node, kinds = 31 /* All */) {
+function walkUpOuterExpressions(node, kinds = 63 /* All */) {
   let parent = node.parent;
   while (isOuterExpression(parent, kinds)) {
     parent = parent.parent;
@@ -36099,6 +36103,7 @@ var libEntries = [
   ["esnext.regexp", "lib.es2024.regexp.d.ts"],
   ["esnext.string", "lib.es2024.string.d.ts"],
   ["esnext.iterator", "lib.esnext.iterator.d.ts"],
+  ["esnext.promise", "lib.esnext.promise.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -41908,6 +41913,7 @@ function createBinder() {
   var preSwitchCaseFlow;
   var activeLabelList;
   var hasExplicitReturn;
+  var inReturnPosition;
   var hasFlowEffects;
   var emitFlags;
   var inStrictMode;
@@ -41980,6 +41986,7 @@ function createBinder() {
     currentExceptionTarget = void 0;
     activeLabelList = void 0;
     hasExplicitReturn = false;
+    inReturnPosition = false;
     hasFlowEffects = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
@@ -42216,6 +42223,8 @@ function createBinder() {
     const saveContainer = container;
     const saveThisParentContainer = thisParentContainer;
     const savedBlockScopeContainer = blockScopeContainer;
+    const savedInReturnPosition = inReturnPosition;
+    if (node.kind === 219 /* ArrowFunction */ && node.body.kind !== 241 /* Block */) inReturnPosition = true;
     if (containerFlags & 1 /* IsContainer */) {
       if (node.kind !== 219 /* ArrowFunction */) {
         thisParentContainer = container;
@@ -42293,6 +42302,7 @@ function createBinder() {
     } else {
       bindChildren(node);
     }
+    inReturnPosition = savedInReturnPosition;
     container = saveContainer;
     thisParentContainer = saveThisParentContainer;
     blockScopeContainer = savedBlockScopeContainer;
@@ -42744,7 +42754,10 @@ function createBinder() {
     currentFlow = finishFlowLabel(postIfLabel);
   }
   function bindReturnOrThrow(node) {
+    const savedInReturnPosition = inReturnPosition;
+    inReturnPosition = true;
     bind(node.expression);
+    inReturnPosition = savedInReturnPosition;
     if (node.kind === 253 /* ReturnStatement */) {
       hasExplicitReturn = true;
       if (currentReturnTarget) {
@@ -43105,10 +43118,16 @@ function createBinder() {
     hasFlowEffects = false;
     bindCondition(node.condition, trueLabel, falseLabel);
     currentFlow = finishFlowLabel(trueLabel);
+    if (inReturnPosition) {
+      node.flowNodeWhenTrue = currentFlow;
+    }
     bind(node.questionToken);
     bind(node.whenTrue);
     addAntecedent(postExpressionLabel, currentFlow);
     currentFlow = finishFlowLabel(falseLabel);
+    if (inReturnPosition) {
+      node.flowNodeWhenFalse = currentFlow;
+    }
     bind(node.colonToken);
     bind(node.whenFalse);
     addAntecedent(postExpressionLabel, currentFlow);
@@ -46165,8 +46184,8 @@ function createTypeChecker(host) {
     writeSignature: (signature, enclosingDeclaration, flags, kind, writer) => {
       return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer);
     },
-    writeType: (type, enclosingDeclaration, flags, writer) => {
-      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer);
+    writeType: (type, enclosingDeclaration, flags, writer, verbosityLevel, out) => {
+      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer, verbosityLevel, out);
     },
     writeSymbol: (symbol, enclosingDeclaration, meaning, flags, writer) => {
       return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
@@ -46952,6 +46971,7 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
+  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -47815,9 +47835,9 @@ function createTypeChecker(host) {
           const containerKind = grandparent.parent.kind;
           if (containerKind === 264 /* InterfaceDeclaration */ && heritageKind === 96 /* ExtendsKeyword */) {
             error(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types, unescapeLeadingUnderscores(name));
-          } else if (containerKind === 263 /* ClassDeclaration */ && heritageKind === 96 /* ExtendsKeyword */) {
+          } else if (isClassLike(grandparent.parent) && heritageKind === 96 /* ExtendsKeyword */) {
             error(errorLocation, Diagnostics.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values, unescapeLeadingUnderscores(name));
-          } else if (containerKind === 263 /* ClassDeclaration */ && heritageKind === 119 /* ImplementsKeyword */) {
+          } else if (isClassLike(grandparent.parent) && heritageKind === 119 /* ImplementsKeyword */) {
             error(errorLocation, Diagnostics.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types, unescapeLeadingUnderscores(name));
           }
         } else {
@@ -49690,7 +49710,7 @@ function createTypeChecker(host) {
     const links = getSymbolLinks(symbol);
     const cache = links.accessibleChainCache || (links.accessibleChainCache = /* @__PURE__ */ new Map());
     const firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, (_, __, ___, node) => node);
-    const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation && getNodeId(firstRelevantLocation)}|${meaning}`;
+    const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation ? getNodeId(firstRelevantLocation) : 0}|${meaning}`;
     if (cache.has(key)) {
       return cache.get(key);
     }
@@ -50087,14 +50107,18 @@ function createTypeChecker(host) {
       return writer2;
     }
   }
-  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
-    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
+  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter(""), verbosityLevel, out) {
+    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */ || verbosityLevel !== void 0;
     const typeNode = nodeBuilder.typeToTypeNode(
       type,
       enclosingDeclaration,
-      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0 /* None */),
+      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0),
       /*internalFlags*/
-      void 0
+      void 0,
+      /*tracker*/
+      void 0,
+      verbosityLevel,
+      out
     );
     if (typeNode === void 0) return Debug.fail("should always get typenode");
     const printer = type !== unresolvedType ? createPrinterWithRemoveComments() : createPrinterWithDefaults();
@@ -50234,12 +50258,7 @@ function createTypeChecker(host) {
       enterNewScope(context, node) {
         if (isFunctionLike(node) || isJSDocSignature(node)) {
           const signature = getSignatureFromDeclaration(node);
-          const expandedParams = getExpandedParameters(
-            signature,
-            /*skipUnionExpanding*/
-            true
-          )[0];
-          return enterNewScope(context, node, expandedParams, signature.typeParameters);
+          return enterNewScope(context, node, signature.parameters, signature.typeParameters);
         } else {
           const typeParameters = isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
           return enterNewScope(
@@ -50326,31 +50345,127 @@ function createTypeChecker(host) {
     };
     return {
       syntacticBuilderResolver,
-      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)),
-      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
-        indexInfo,
-        context,
-        /*typeNode*/
-        void 0
-      )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
-        symbol,
-        context,
-        meaning,
-        /*expectsIdentifier*/
-        false
-      )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeToTypeNodeHelper(type, context), out),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)
+      ),
+      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)
+      ),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)
+      ),
+      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)
+      ),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => indexInfoToIndexSignatureDeclarationHelper(
+          indexInfo,
+          context,
+          /*typeNode*/
+          void 0
+        )
+      ),
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => signatureToSignatureDeclarationHelper(signature, kind, context)
+      ),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToName(
+          symbol,
+          context,
+          meaning,
+          /*expectsIdentifier*/
+          false
+        )
+      ),
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToExpression(symbol, context, meaning)
+      ),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => typeParametersToTypeParameterDeclarations(symbol, context)
+      ),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToParameterDeclaration(symbol, context)
+      ),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolTableToDeclarationStatements(symbolTable, context)
+      ),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToNode(symbol, context, meaning)
+      )
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -50392,7 +50507,7 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext(enclosingDeclaration, flags, internalFlags, tracker, cb) {
+    function withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, cb, out) {
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : (internalFlags || 0 /* None */) & 4 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
@@ -50400,6 +50515,7 @@ function createTypeChecker(host) {
         flags: flags || 0 /* None */,
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
+        unfoldDepth: verbosityLevel ?? -1,
         encounteredError: false,
         suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
@@ -50421,13 +50537,18 @@ function createTypeChecker(host) {
         typeParameterNamesByText: void 0,
         typeParameterNamesByTextNextNameCount: void 0,
         enclosingSymbolTypes: /* @__PURE__ */ new Map(),
-        mapper: void 0
+        mapper: void 0,
+        depth: 0,
+        couldUnfoldMore: false
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
       if (context.truncating && context.flags & 1 /* NoTruncation */) {
         context.tracker.reportTruncationError();
       }
+      if (out) {
+        out.couldUnfoldMore = context.couldUnfoldMore;
+      }
       return context.encounteredError ? void 0 : resultingNode;
     }
     function addSymbolTypeToContext(context, symbol, type) {
@@ -50446,16 +50567,36 @@ function createTypeChecker(host) {
     function saveRestoreFlags(context) {
       const flags = context.flags;
       const internalFlags = context.internalFlags;
+      const depth = context.depth;
       return restore;
       function restore() {
         context.flags = flags;
         context.internalFlags = internalFlags;
+        context.depth = depth;
       }
     }
     function checkTruncationLength(context) {
       if (context.truncating) return context.truncating;
       return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
     }
+    function couldUnfoldType(type, context) {
+      var _a;
+      if ((_a = context.visitedTypes) == null ? void 0 : _a.has(type.id)) {
+        return false;
+      }
+      return context.depth < context.unfoldDepth || context.depth === context.unfoldDepth && !context.couldUnfoldMore;
+    }
+    function canUnfoldType(type, context) {
+      var _a;
+      if ((_a = context.visitedTypes) == null ? void 0 : _a.has(type.id)) {
+        return false;
+      }
+      const result = context.depth < context.unfoldDepth;
+      if (!result) {
+        context.couldUnfoldMore = true;
+      }
+      return result;
+    }
     function typeToTypeNodeHelper(type, context) {
       const restoreFlags = saveRestoreFlags(context);
       const typeNode = typeToTypeNodeWorker(type, context);
@@ -50603,16 +50744,27 @@ function createTypeChecker(host) {
         return factory.createThisTypeNode();
       }
       if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */ || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
-        const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
-        if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */)) return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
-        if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
-          return factory.createArrayTypeNode(typeArgumentNodes[0]);
+        if (!canUnfoldType(type, context)) {
+          const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
+          if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */)) return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
+          if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
+            return factory.createArrayTypeNode(typeArgumentNodes[0]);
+          }
+          return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
         }
-        return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
+        context.depth += 1;
       }
       const objectFlags = getObjectFlags(type);
       if (objectFlags & 4 /* Reference */) {
         Debug.assert(!!(type.flags & 524288 /* Object */));
+        if (canUnfoldType(type, context)) {
+          context.depth += 1;
+          return createAnonymousTypeNode(
+            type,
+            /*forceClassExpansion*/
+            true
+          );
+        }
         return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
       }
       if (type.flags & 262144 /* TypeParameter */ || objectFlags & 3 /* ClassOrInterface */) {
@@ -50642,6 +50794,14 @@ function createTypeChecker(host) {
             void 0
           );
         }
+        if (objectFlags & 3 /* ClassOrInterface */ && canUnfoldType(type, context)) {
+          context.depth += 1;
+          return createAnonymousTypeNode(
+            type,
+            /*forceClassExpansion*/
+            true
+          );
+        }
         if (type.symbol) {
           return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
         }
@@ -50845,7 +51005,7 @@ function createTypeChecker(host) {
         }
         return result;
       }
-      function createAnonymousTypeNode(type2) {
+      function createAnonymousTypeNode(type2, forceClassExpansion = false) {
         var _a2, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
@@ -50868,7 +51028,7 @@ function createTypeChecker(host) {
           const isInstanceType = isClassInstanceSide(type2) ? 788968 /* Type */ : 111551 /* Value */;
           if (isJSConstructor(symbol.valueDeclaration)) {
             return symbolToTypeNode(symbol, context, isInstanceType);
-          } else if (symbol.flags & 32 /* Class */ && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
+          } else if (symbol.flags & 32 /* Class */ && !forceClassExpansion && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
             symbol,
             context.enclosingDeclaration,
             isInstanceType,
@@ -50912,7 +51072,7 @@ function createTypeChecker(host) {
         if (id && !context.symbolDepth) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
-        const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
+        const links = context.unfoldDepth >= 0 ? void 0 : context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
         const key = `${getTypeId(type2)}|${context.flags}|${context.internalFlags}`;
         if (links) {
           links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
@@ -51827,7 +51987,7 @@ function createTypeChecker(host) {
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
-      return typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
+      return !couldUnfoldType(type, context) && typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
     }
     function typeParameterToDeclaration(type, context, constraint = getConstraintOfTypeParameter(type)) {
       const constraintNode = constraint && typeToTypeNodeHelperWithPossibleReusableTypeNode(constraint, getConstraintDeclaration(type), context);
@@ -52461,7 +52621,7 @@ function createTypeChecker(host) {
       let result;
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
       const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
-      if (decl) {
+      if (!couldUnfoldType(type, context) && decl) {
         if (isAccessor(decl)) {
           result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
         } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) {
@@ -55256,7 +55416,6 @@ function createTypeChecker(host) {
       const flags = 4 /* Property */ | (e.initializer ? 16777216 /* Optional */ : 0);
       const symbol = createSymbol(flags, text);
       symbol.links.type = getTypeFromBindingElement(e, includePatternInType, reportErrors2);
-      symbol.links.bindingElement = e;
       members.set(symbol.escapedName, symbol);
     });
     const result = createAnonymousType(
@@ -59184,11 +59343,14 @@ function createTypeChecker(host) {
   function isNoInferType(type) {
     return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
   }
-  function getSubstitutionType(baseType, constraint) {
-    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
+  function isNarrowingSubstitutionType(type) {
+    return !!(type.flags & 33554432 /* Substitution */ && type.objectFlags & 16777216 /* IsNarrowingType */);
+  }
+  function getSubstitutionType(baseType, constraint, isNarrowed) {
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint, isNarrowed);
   }
-  function getOrCreateSubstitutionType(baseType, constraint) {
-    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
+  function getOrCreateSubstitutionType(baseType, constraint, isNarrowed) {
+    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}${isNarrowed ? ">N" : ""}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
       return cached;
@@ -59196,6 +59358,9 @@ function createTypeChecker(host) {
     const result = createType(33554432 /* Substitution */);
     result.baseType = baseType;
     result.constraint = constraint;
+    if (isNarrowed) {
+      result.objectFlags |= 16777216 /* IsNarrowingType */;
+    }
     substitutionTypes.set(id, result);
     return result;
   }
@@ -61398,7 +61563,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -61415,10 +61580,11 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
+      const effectiveCheckType = forNarrowing && isNarrowingSubstitutionType(checkType) ? checkType.constraint : checkType;
       const checkTypeNode = skipTypeParentheses(root.node.checkType);
       const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
       const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
-      const checkTypeDeferred = isDeferredType(checkType, checkTuples);
+      const checkTypeDeferred = isDeferredType(effectiveCheckType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
         const context = createInferenceContext(
@@ -61437,8 +61603,8 @@ function createTypeChecker(host) {
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
-        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
+        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (effectiveCheckType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(effectiveCheckType), getPermissiveInstantiation(inferredExtendsType)))) {
+          if (effectiveCheckType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(effectiveCheckType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -61455,7 +61621,7 @@ function createTypeChecker(host) {
           result = instantiateType(falseType2, mapper);
           break;
         }
-        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
+        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(effectiveCheckType), getRestrictiveInstantiation(inferredExtendsType))) {
           const trueType2 = getTypeFromTypeNode(root.node.trueType);
           const trueMapper = combinedMapper || mapper;
           if (canTailRecurse(trueType2, trueMapper)) {
@@ -62421,8 +62587,39 @@ function createTypeChecker(host) {
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
-        const distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
-        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
+        let distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
+        let narrowingBaseType;
+        const forNarrowing = distributionType && isNarrowingSubstitutionType(distributionType) && isNarrowableConditionalType(type, mapper);
+        if (forNarrowing) {
+          narrowingBaseType = distributionType.baseType;
+          distributionType = getReducedType(distributionType.constraint);
+        }
+        if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
+          if (narrowingBaseType) {
+            result = mapTypeToIntersection(
+              distributionType,
+              (t) => getConditionalType(
+                root,
+                prependTypeMapping(checkType, getSubstitutionType(
+                  narrowingBaseType,
+                  t,
+                  /*isNarrowed*/
+                  true
+                ), newMapper),
+                forConstraint,
+                /*aliasSymbol*/
+                void 0,
+                /*aliasTypeArguments*/
+                void 0,
+                forNarrowing
+              )
+            );
+          } else {
+            result = mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments);
+          }
+        } else {
+          result = getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing);
+        }
         root.instantiations.set(id, result);
       }
       return result;
@@ -63565,10 +63762,12 @@ function createTypeChecker(host) {
   function shouldNormalizeIntersection(type) {
     let hasInstantiable = false;
     let hasNullableOrEmpty = false;
+    let hasSubstitution = false;
     for (const t of type.types) {
       hasInstantiable || (hasInstantiable = !!(t.flags & 465829888 /* Instantiable */));
       hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 98304 /* Nullable */) || isEmptyAnonymousObjectType(t));
-      if (hasInstantiable && hasNullableOrEmpty) return true;
+      hasSubstitution || (hasSubstitution = isNarrowingSubstitutionType(t));
+      if (hasInstantiable && hasNullableOrEmpty || hasSubstitution) return true;
     }
     return false;
   }
@@ -64660,15 +64859,15 @@ function createTypeChecker(host) {
       }
       return result2;
     }
-    function getApparentMappedTypeKeys(nameType, targetType) {
-      const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
+    function getApparentMappedTypeKeys(nameType, mappedType) {
+      const modifiersType = getApparentType(getModifiersTypeFromMappedType(mappedType));
       const mappedKeys = [];
       forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
         modifiersType,
         8576 /* StringOrNumberLiteralOrUnique */,
         /*stringsOnly*/
         false,
-        (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
+        (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(mappedType.mapper, getTypeParameterFromMappedType(mappedType), t)))
       );
       return getUnionType(mappedKeys);
     }
@@ -65033,7 +65232,15 @@ function createTypeChecker(host) {
         if (isDeferredMappedIndex) {
           const mappedType = source2.type;
           const nameType = getNameTypeFromMappedType(mappedType);
-          const sourceMappedKeys = nameType && isMappedTypeWithKeyofConstraintDeclaration(mappedType) ? getApparentMappedTypeKeys(nameType, mappedType) : nameType || getConstraintTypeFromMappedType(mappedType);
+          let sourceMappedKeys;
+          if (nameType && isMappedTypeWithKeyofConstraintDeclaration(mappedType)) {
+            sourceMappedKeys = getApparentMappedTypeKeys(nameType, mappedType);
+            if (sourceMappedKeys.flags & 131072 /* Never */) {
+              sourceMappedKeys = stringNumberSymbolType;
+            }
+          } else {
+            sourceMappedKeys = nameType || getConstraintTypeFromMappedType(mappedType);
+          }
           if (result2 = isRelatedTo(sourceMappedKeys, target2, 1 /* Source */, reportErrors2)) {
             return result2;
           }
@@ -68727,6 +68934,18 @@ function createTypeChecker(host) {
     }
     return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
   }
+  function mapTypeToIntersection(type, mapper) {
+    if (type.flags & 131072 /* Never */) {
+      return type;
+    }
+    if (!(type.flags & 1048576 /* Union */)) {
+      return mapper(type);
+    }
+    const origin = type.origin;
+    const types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types;
+    const mappedTypes = types.map((t) => t.flags & 1048576 /* Union */ ? mapTypeToIntersection(t, mapper) : mapper(t));
+    return getIntersectionType(mappedTypes);
+  }
   function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
     return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
   }
@@ -70309,11 +70528,11 @@ function createTypeChecker(host) {
     ));
     return contextualType && !isGenericType(contextualType);
   }
-  function getNarrowableTypeForReference(type, reference, checkMode) {
+  function getNarrowableTypeForReference(type, reference, checkMode, forReturnTypeNarrowing) {
     if (isNoInferType(type)) {
       type = type.baseType;
     }
-    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
+    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (forReturnTypeNarrowing || isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
   function isExportOrExportExpression(location) {
@@ -70466,7 +70685,7 @@ function createTypeChecker(host) {
         jsxFactorySym = resolveName(
           jsxFactoryLocation,
           jsxFactoryNamespace,
-          compilerOptions.jsx === 1 /* Preserve */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
+          compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
           jsxFactoryRefErr,
           /*isUse*/
           true
@@ -70485,7 +70704,7 @@ function createTypeChecker(host) {
           resolveName(
             jsxFactoryLocation,
             localJsxNamespace,
-            compilerOptions.jsx === 1 /* Preserve */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
+            compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
             jsxFactoryRefErr,
             /*isUse*/
             true
@@ -71438,9 +71657,16 @@ function createTypeChecker(host) {
   function getContextualTypeForReturnExpression(node, contextFlags) {
     const func = getContainingFunction(node);
     if (func) {
+      const functionFlags = getFunctionFlags(func);
+      const links = getNodeLinks(node);
+      if (links.contextualReturnType) {
+        if (functionFlags & 2 /* Async */) {
+          return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
+        }
+        return links.contextualReturnType;
+      }
       let contextualReturnType = getContextualReturnType(func, contextFlags);
       if (contextualReturnType) {
-        const functionFlags = getFunctionFlags(func);
         if (functionFlags & 1 /* Generator */) {
           const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
           if (contextualReturnType.flags & 1048576 /* Union */) {
@@ -72138,6 +72364,13 @@ function createTypeChecker(host) {
     if (index >= 0) {
       return contextualTypes[index];
     }
+    const links = getNodeLinks(node);
+    if (links.contextualReturnType) {
+      if (node.flags & 65536 /* AwaitContext */) {
+        return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
+      }
+      return links.contextualReturnType;
+    }
     const { parent } = node;
     switch (parent.kind) {
       case 260 /* VariableDeclaration */:
@@ -74814,8 +75047,8 @@ function createTypeChecker(host) {
     }
   }
   function getEffectiveCheckNode(argument) {
-    argument = skipParentheses(argument);
-    return isSatisfiesExpression(argument) ? skipParentheses(argument.expression) : argument;
+    const flags = isInJSFile(argument) ? 1 /* Parentheses */ | 32 /* Satisfies */ | -2147483648 /* ExcludeJSDocTypeAssertion */ : 1 /* Parentheses */ | 32 /* Satisfies */;
+    return skipOuterExpressions(argument, flags);
   }
   function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) {
     const errorOutputContainer = { errors: void 0, skipLogging: true };
@@ -75240,11 +75473,16 @@ function createTypeChecker(host) {
     if (!result) {
       result = chooseOverload(candidates, assignableRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
     }
+    const links = getNodeLinks(node);
+    if (links.resolvedSignature !== resolvingSignature && !candidatesOutArray) {
+      Debug.assert(links.resolvedSignature);
+      return links.resolvedSignature;
+    }
     if (result) {
       return result;
     }
     result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
-    getNodeLinks(node).resolvedSignature = result;
+    links.resolvedSignature = result;
     if (reportErrors2) {
       if (!headMessage && isInstanceof) {
         headMessage = Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method;
@@ -76009,7 +76247,7 @@ function createTypeChecker(host) {
     const jsxFactorySymbol = getJsxNamespaceContainerForImplicitImport(node) ?? resolveName(
       node,
       jsxFragmentFactoryName,
-      compilerOptions.jsx === 1 /* Preserve */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
+      compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
       /*nameNotFoundMessage*/
       jsxFactoryRefErr,
       /*isUse*/
@@ -76128,12 +76366,9 @@ function createTypeChecker(host) {
       resolutionStart = resolutionTargets.length;
     }
     links.resolvedSignature = resolvingSignature;
-    let result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* Normal */);
+    const result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* Normal */);
     resolutionStart = saveResolutionStart;
     if (result !== resolvingSignature) {
-      if (links.resolvedSignature !== resolvingSignature) {
-        result = links.resolvedSignature;
-      }
       links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
     }
     return result;
@@ -77661,7 +77896,7 @@ function createTypeChecker(host) {
     });
   }
   function checkIfExpressionRefinesParameter(func, expr, param, initType) {
-    const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode(
+    const antecedent = canHaveFlowNode(expr) && expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode(
       2 /* Start */,
       /*node*/
       void 0,
@@ -77809,19 +78044,7 @@ function createTypeChecker(host) {
         const exprType = checkExpression(node.body);
         const returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags);
         if (returnOrPromisedType) {
-          const effectiveCheckNode = getEffectiveCheckNode(node.body);
-          if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */) {
-            const awaitedType = checkAwaitedType(
-              exprType,
-              /*withAlias*/
-              false,
-              effectiveCheckNode,
-              Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-            );
-            checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, effectiveCheckNode, effectiveCheckNode);
-          } else {
-            checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, effectiveCheckNode, effectiveCheckNode);
-          }
+          checkReturnExpression(node, returnOrPromisedType, node.body, node.body, exprType);
         }
       }
     }
@@ -77904,7 +78127,7 @@ function createTypeChecker(host) {
     return false;
   }
   function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) {
-    const node = skipOuterExpressions(expr, 6 /* Assertions */ | 1 /* Parentheses */);
+    const node = skipOuterExpressions(expr, 38 /* Assertions */ | 1 /* Parentheses */);
     if (node.kind !== 80 /* Identifier */ && !isAccessExpression(node)) {
       error(expr, invalidReferenceMessage);
       return false;
@@ -78555,7 +78778,7 @@ function createTypeChecker(host) {
       if (isBinaryExpression(right) && (right.operatorToken.kind === 57 /* BarBarToken */ || right.operatorToken.kind === 56 /* AmpersandAmpersandToken */)) {
         grammarErrorOnNode(right, Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, tokenToString(right.operatorToken.kind), tokenToString(operatorToken.kind));
       }
-      const leftTarget = skipOuterExpressions(left, 31 /* All */);
+      const leftTarget = skipOuterExpressions(left, 63 /* All */);
       const nullishSemantics = getSyntacticNullishnessSemantics(leftTarget);
       if (nullishSemantics !== 3 /* Sometimes */) {
         if (node.parent.kind === 226 /* BinaryExpression */) {
@@ -78575,7 +78798,9 @@ function createTypeChecker(host) {
     switch (node.kind) {
       case 223 /* AwaitExpression */:
       case 213 /* CallExpression */:
+      case 215 /* TaggedTemplateExpression */:
       case 212 /* ElementAccessExpression */:
+      case 236 /* MetaProperty */:
       case 214 /* NewExpression */:
       case 211 /* PropertyAccessExpression */:
       case 229 /* YieldExpression */:
@@ -78591,6 +78816,8 @@ function createTypeChecker(host) {
           case 56 /* AmpersandAmpersandToken */:
           case 77 /* AmpersandAmpersandEqualsToken */:
             return 3 /* Sometimes */;
+          case 28 /* CommaToken */:
+            return getSyntacticNullishnessSemantics(node.right);
         }
         return 2 /* Never */;
       case 227 /* ConditionalExpression */:
@@ -83043,7 +83270,6 @@ function createTypeChecker(host) {
     }
     const signature = getSignatureFromDeclaration(container);
     const returnType = getReturnTypeOfSignature(signature);
-    const functionFlags = getFunctionFlags(container);
     if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
       const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
       if (container.kind === 178 /* SetAccessor */) {
@@ -83051,26 +83277,249 @@ function createTypeChecker(host) {
           error(node, Diagnostics.Setters_cannot_return_a_value);
         }
       } else if (container.kind === 176 /* Constructor */) {
-        if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
+        const exprType2 = node.expression ? checkExpressionCached(node.expression) : undefinedType;
+        if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType2, returnType, node, node.expression)) {
           error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
         }
       } else if (getReturnTypeFromAnnotation(container)) {
-        const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
-        const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
-          exprType,
-          /*withAlias*/
-          false,
-          node,
-          Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-        ) : exprType;
-        if (unwrappedReturnType) {
-          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
-        }
+        const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(container)) ?? returnType;
+        checkReturnExpression(container, unwrappedReturnType, node, node.expression, exprType);
       }
     } else if (container.kind !== 176 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
       error(node, Diagnostics.Not_all_code_paths_return_a_value);
     }
   }
+  function checkReturnExpression(container, unwrappedReturnType, node, expr, exprType, inConditionalExpression = false) {
+    const excludeJSDocTypeAssertions = isInJSFile(node);
+    const functionFlags = getFunctionFlags(container);
+    if (expr) {
+      const unwrappedExpr = skipParentheses(expr, excludeJSDocTypeAssertions);
+      if (isConditionalExpression(unwrappedExpr)) {
+        checkReturnExpression(
+          container,
+          unwrappedReturnType,
+          node,
+          unwrappedExpr.whenTrue,
+          checkExpression(unwrappedExpr.whenTrue),
+          /*inConditionalExpression*/
+          true
+        );
+        checkReturnExpression(
+          container,
+          unwrappedReturnType,
+          node,
+          unwrappedExpr.whenFalse,
+          checkExpression(unwrappedExpr.whenFalse),
+          /*inConditionalExpression*/
+          true
+        );
+        return;
+      }
+    }
+    const inReturnStatement = node.kind === 253 /* ReturnStatement */;
+    const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
+      exprType,
+      /*withAlias*/
+      false,
+      node,
+      Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
+    ) : exprType;
+    const effectiveExpr = expr && getEffectiveCheckNode(expr);
+    const errorNode = inReturnStatement && !inConditionalExpression ? node : effectiveExpr;
+    if (!(unwrappedReturnType.flags & (8388608 /* IndexedAccess */ | 16777216 /* Conditional */)) || !couldContainTypeVariables(unwrappedReturnType)) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+      return;
+    }
+    if (checkTypeAssignableTo(
+      unwrappedExprType,
+      unwrappedReturnType,
+      /*errorNode*/
+      void 0
+    )) {
+      return;
+    }
+    let narrowPosition = node;
+    let narrowFlowNode = inReturnStatement && node.flowNode;
+    if (expr && isConditionalExpression(expr.parent)) {
+      narrowFlowNode = expr.parent.whenTrue === expr ? expr.parent.flowNodeWhenTrue : expr.parent.flowNodeWhenFalse;
+      narrowPosition = expr;
+    }
+    if (!narrowFlowNode) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+      return;
+    }
+    const allTypeParameters = appendTypeParameters(getOuterTypeParameters(
+      container,
+      /*includeThisTypes*/
+      false
+    ), getEffectiveTypeParameterDeclarations(container));
+    const narrowableTypeParameters = allTypeParameters && getNarrowableTypeParameters(allTypeParameters);
+    if (!narrowableTypeParameters || !narrowableTypeParameters.length || !isNarrowableReturnType(unwrappedReturnType)) {
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
+      return;
+    }
+    const narrowedTypeParameters = [];
+    const narrowedTypes = [];
+    for (const [typeParam, symbol, reference] of narrowableTypeParameters) {
+      const narrowReference = factory.cloneNode(reference);
+      narrowReference.id = void 0;
+      getNodeLinks(narrowReference).resolvedSymbol = symbol;
+      setParent(narrowReference, narrowPosition.parent);
+      narrowReference.flowNode = narrowFlowNode;
+      const initialType = getNarrowableTypeForReference(
+        typeParam,
+        narrowReference,
+        /*checkMode*/
+        void 0,
+        /*forReturnTypeNarrowing*/
+        true
+      );
+      if (initialType === typeParam) {
+        continue;
+      }
+      const flowType = getFlowTypeOfReference(narrowReference, initialType);
+      const exprType2 = getTypeFromFlowType(flowType);
+      if (exprType2.flags & 3 /* AnyOrUnknown */ || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
+        continue;
+      }
+      const narrowedType = getSubstitutionType(
+        typeParam,
+        exprType2,
+        /*isNarrowed*/
+        true
+      );
+      narrowedTypeParameters.push(typeParam);
+      narrowedTypes.push(narrowedType);
+    }
+    const narrowMapper = createTypeMapper(narrowedTypeParameters, narrowedTypes);
+    const narrowedReturnType = instantiateType(
+      unwrappedReturnType,
+      narrowMapper
+    );
+    if (expr) {
+      const links = getNodeLinks(expr);
+      if (!links.contextualReturnType) {
+        links.contextualReturnType = narrowedReturnType;
+      }
+    }
+    const narrowedExprType = expr ? checkExpression(expr) : undefinedType;
+    const narrowedUnwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
+      narrowedExprType,
+      /*withAlias*/
+      false,
+      node,
+      Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
+    ) : narrowedExprType;
+    checkTypeAssignableToAndOptionallyElaborate(narrowedUnwrappedExprType, narrowedReturnType, errorNode, effectiveExpr);
+  }
+  function getNarrowableTypeParameters(candidates) {
+    const narrowableParams = [];
+    for (const typeParam of candidates) {
+      const constraint = getConstraintOfTypeParameter(typeParam);
+      if (!constraint || !(constraint.flags & 1048576 /* Union */)) continue;
+      if (typeParam.symbol && typeParam.symbol.declarations && typeParam.symbol.declarations.length === 1) {
+        const declaration = typeParam.symbol.declarations[0];
+        const container = isJSDocTemplateTag(declaration.parent) ? getJSDocHost(declaration.parent) : declaration.parent;
+        if (!isFunctionLike(container)) continue;
+        let reference;
+        let hasInvalidReference = false;
+        for (const paramDecl of container.parameters) {
+          const typeNode = getEffectiveTypeAnnotationNode(paramDecl);
+          if (!typeNode) continue;
+          if (isTypeParameterReferenced(typeParam, typeNode)) {
+            let candidateReference;
+            if (isTypeReferenceNode(typeNode) && isReferenceToTypeParameter(typeParam, typeNode) && (candidateReference = getValidParameterReference(paramDecl, constraint))) {
+              if (reference) {
+                hasInvalidReference = true;
+                break;
+              }
+              reference = candidateReference;
+            } else {
+              hasInvalidReference = true;
+              break;
+            }
+          }
+        }
+        if (!hasInvalidReference && reference) {
+          const symbol = getResolvedSymbol(reference);
+          if (symbol !== unknownSymbol) narrowableParams.push([typeParam, symbol, reference]);
+        }
+      }
+    }
+    return narrowableParams;
+    function getValidParameterReference(paramDecl, constraint) {
+      if (!isIdentifier(paramDecl.name)) return;
+      const isOptional = !!paramDecl.questionToken || isJSDocOptionalParameter(paramDecl);
+      if (isOptional && !containsUndefinedType(constraint)) return;
+      return paramDecl.name;
+    }
+    function isReferenceToTypeParameter(typeParam, node) {
+      return getTypeFromTypeReference(node) === typeParam;
+    }
+    function isTypeParameterReferenced(typeParam, node) {
+      return isReferenced(node);
+      function isReferenced(node2) {
+        if (isTypeReferenceNode(node2)) {
+          return isReferenceToTypeParameter(typeParam, node2);
+        }
+        if (isTypeQueryNode(node2)) {
+          return isTypeParameterPossiblyReferenced(typeParam, node2);
+        }
+        return !!forEachChild(node2, isReferenced);
+      }
+    }
+  }
+  function isNarrowableReturnType(returnType) {
+    return isConditionalType(returnType) ? isNarrowableConditionalType(returnType) : !!(returnType.indexType.flags & 262144 /* TypeParameter */);
+  }
+  function isNarrowableConditionalType(type, mapper) {
+    const typeArguments = mapper && map(type.root.outerTypeParameters, (t) => {
+      const mapped = getMappedType(t, mapper);
+      if (isNarrowingSubstitutionType(mapped)) {
+        return mapped.baseType;
+      }
+      return mapped;
+    });
+    const id = `${type.id}:${getTypeListId(typeArguments)}`;
+    let result = narrowableReturnTypeCache.get(id);
+    if (result === void 0) {
+      const nonNarrowingMapper = type.root.outerTypeParameters && typeArguments && createTypeMapper(type.root.outerTypeParameters, typeArguments);
+      const instantiatedType = instantiateType(type, nonNarrowingMapper);
+      result = isConditionalType(instantiatedType) && isNarrowableConditionalTypeWorker(instantiatedType);
+      narrowableReturnTypeCache.set(id, result);
+    }
+    return result;
+  }
+  function isNarrowableConditionalTypeWorker(type) {
+    if (!type.root.isDistributive) {
+      return false;
+    }
+    if (type.root.inferTypeParameters) {
+      return false;
+    }
+    if (!(type.checkType.flags & 262144 /* TypeParameter */)) {
+      return false;
+    }
+    const constraintType = getConstraintOfTypeParameter(type.checkType);
+    if (!constraintType || !(constraintType.flags & 1048576 /* Union */)) {
+      return false;
+    }
+    if (!everyType(type.extendsType, (extendsType) => some(
+      constraintType.types,
+      (constraintType2) => isTypeIdenticalTo(constraintType2, extendsType)
+    ))) {
+      return false;
+    }
+    const trueType2 = getTrueTypeFromConditionalType(type);
+    const isValidTrueType = isConditionalType(trueType2) ? isNarrowableConditionalType(trueType2) : true;
+    if (!isValidTrueType) return false;
+    const falseType2 = getFalseTypeFromConditionalType(type);
+    const isValidFalseType = isConditionalType(falseType2) ? isNarrowableConditionalType(falseType2) : falseType2 === neverType;
+    return isValidFalseType;
+  }
+  function isConditionalType(type) {
+    return !!(type.flags & 16777216 /* Conditional */);
+  }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
       if (node.flags & 65536 /* AwaitContext */) {
@@ -93044,7 +93493,7 @@ function transformTypeScript(context) {
     return updated;
   }
   function visitParenthesizedExpression(node) {
-    const innerExpression = skipOuterExpressions(node.expression, ~(6 /* Assertions */ | 16 /* ExpressionsWithTypeArguments */));
+    const innerExpression = skipOuterExpressions(node.expression, ~(38 /* Assertions */ | 16 /* ExpressionsWithTypeArguments */));
     if (isAssertionExpression(innerExpression) || isSatisfiesExpression(innerExpression)) {
       const expression = visitNode(node.expression, visitor, isExpression);
       Debug.assert(expression);
@@ -131999,18 +132448,21 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     return failed;
   }
   function typeFromFunctionLikeExpression(fnNode, context) {
-    const oldNoInferenceFallback = context.noInferenceFallback;
-    context.noInferenceFallback = true;
-    createReturnFromSignature(
+    const returnType = createReturnFromSignature(
       fnNode,
       /*symbol*/
       void 0,
       context
     );
-    reuseTypeParameters(fnNode.typeParameters, context);
-    fnNode.parameters.map((p) => ensureParameter(p, context));
-    context.noInferenceFallback = oldNoInferenceFallback;
-    return notImplemented2;
+    const typeParameters = reuseTypeParameters(fnNode.typeParameters, context);
+    const parameters = fnNode.parameters.map((p) => ensureParameter(p, context));
+    return syntacticResult(
+      factory.createFunctionTypeNode(
+        typeParameters,
+        parameters,
+        returnType
+      )
+    );
   }
   function canGetTypeFromArrayLiteral(arrayLiteral, context, isConstContext) {
     if (!isConstContext) {