@typescript-deploys/pr-build 5.6.0-pr-58829-3 → 5.6.0-pr-58729-60

package/lib/lib.es5.d.ts

@@ -1672,6 +1672,11 @@ type Uncapitalize<S extends string> = intrinsic;
  */
 type NoInfer<T> = intrinsic;
 
+/**
+ * Marker for deferred callbacks
+ */
+type Deferred<T extends (...args: any) => any> = intrinsic;
+
 /**
  * Marker for contextual 'this' type
  */

package/lib/tsc.js

@@ -1644,7 +1644,7 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
         __tsDebuggerDisplay: {
           value() {
             const flowHeader = this.flags & 2 /* Start */ ? "FlowStart" : this.flags & 4 /* BranchLabel */ ? "FlowBranchLabel" : this.flags & 8 /* LoopLabel */ ? "FlowLoopLabel" : this.flags & 16 /* Assignment */ ? "FlowAssignment" : this.flags & 32 /* TrueCondition */ ? "FlowTrueCondition" : this.flags & 64 /* FalseCondition */ ? "FlowFalseCondition" : this.flags & 128 /* SwitchClause */ ? "FlowSwitchClause" : this.flags & 256 /* ArrayMutation */ ? "FlowArrayMutation" : this.flags & 512 /* Call */ ? "FlowCall" : this.flags & 1024 /* ReduceLabel */ ? "FlowReduceLabel" : this.flags & 1 /* Unreachable */ ? "FlowUnreachable" : "UnknownFlow";
-            const remainingFlags = this.flags & ~(2048 /* Referenced */ - 1);
+            const remainingFlags = this.flags & ~(4096 /* Referenced */ - 1);
             return `${flowHeader}${remainingFlags ? ` (${formatFlowFlags(remainingFlags)})` : ""}`;
           }
         },
@@ -3451,8 +3451,9 @@ var FlowFlags = /* @__PURE__ */ ((FlowFlags2) => {
   FlowFlags2[FlowFlags2["ArrayMutation"] = 256] = "ArrayMutation";
   FlowFlags2[FlowFlags2["Call"] = 512] = "Call";
   FlowFlags2[FlowFlags2["ReduceLabel"] = 1024] = "ReduceLabel";
-  FlowFlags2[FlowFlags2["Referenced"] = 2048] = "Referenced";
-  FlowFlags2[FlowFlags2["Shared"] = 4096] = "Shared";
+  FlowFlags2[FlowFlags2["LambdaArgs"] = 2048] = "LambdaArgs";
+  FlowFlags2[FlowFlags2["Referenced"] = 4096] = "Referenced";
+  FlowFlags2[FlowFlags2["Shared"] = 8192] = "Shared";
   FlowFlags2[FlowFlags2["Label"] = 12] = "Label";
   FlowFlags2[FlowFlags2["Condition"] = 96] = "Condition";
   return FlowFlags2;
@@ -3672,10 +3673,11 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
   ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
   ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
-  ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
   ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
+  ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
+  ObjectFlags3[ObjectFlags3["DeferredCallback"] = 268435456] = "DeferredCallback";
   ObjectFlags3[ObjectFlags3["IsGenericTypeComputed"] = 2097152] = "IsGenericTypeComputed";
   ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
   ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
@@ -7551,8 +7553,6 @@ var Diagnostics = {
   Default_exports_can_t_be_inferred_with_isolatedDeclarations: diag(9037, 1 /* Error */, "Default_exports_can_t_be_inferred_with_isolatedDeclarations_9037", "Default exports can't be inferred with --isolatedDeclarations."),
   Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations: diag(9038, 1 /* Error */, "Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations_9038", "Computed property names on class or object literals cannot be inferred with --isolatedDeclarations."),
   Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations: diag(9039, 1 /* Error */, "Type_containing_private_name_0_can_t_be_used_with_isolatedDeclarations_9039", "Type containing private name '{0}' can't be used with --isolatedDeclarations."),
-  keyof_type_must_have_an_operand_type: diag(9040, 1 /* Error */, "keyof_type_must_have_an_operand_type_9040", "`keyof` type must have an operand type."),
-  A_satisfies_keyof_computed_property_name_must_be_exactly_a_single_string_number_or_unique_symbol_literal_type: diag(9041, 1 /* Error */, "A_satisfies_keyof_computed_property_name_must_be_exactly_a_single_string_number_or_unique_symbol_lit_9041", "A `satisfies keyof` computed property name must be exactly a single string, number, or unique symbol literal type."),
   JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17e3, 1 /* Error */, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
   JSX_elements_cannot_have_multiple_attributes_with_the_same_name: diag(17001, 1 /* Error */, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."),
   Expected_corresponding_JSX_closing_tag_for_0: diag(17002, 1 /* Error */, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."),
@@ -19368,8 +19368,15 @@ function hasInferredType(node) {
       return false;
   }
 }
-function isSatisfiesKeyofExpression(node) {
-  return node.kind === 238 /* SatisfiesExpression */ && node.type.kind === 143 /* KeyOfKeyword */ && isEntityNameExpression(node.expression);
+function getLambdaArgument(node) {
+  switch (node.kind) {
+    case 218 /* FunctionExpression */:
+    case 219 /* ArrowFunction */:
+      return !hasSyntacticModifier(node, 1024 /* Async */) && !node.asteriskToken ? node : void 0;
+    case 217 /* ParenthesizedExpression */:
+      return getLambdaArgument(node.expression);
+  }
+  return void 0;
 }
 
 // src/compiler/factory/baseNodeFactory.ts
@@ -30557,8 +30564,7 @@ var Parser;
   function parseTypeOperator(operator) {
     const pos = getNodePos();
     parseExpected(operator);
-    const arg = operator !== 143 /* KeyOfKeyword */ || isStartOfType() ? parseTypeOperatorOrHigher() : void 0;
-    return finishNode(arg ? factory2.createTypeOperatorNode(operator, arg) : factory2.createKeywordTypeNode(143 /* KeyOfKeyword */), pos);
+    return finishNode(factory2.createTypeOperatorNode(operator, parseTypeOperatorOrHigher()), pos);
   }
   function tryParseConstraintOfInferType() {
     if (parseOptional(96 /* ExtendsKeyword */)) {
@@ -41239,6 +41245,7 @@ function createBinder() {
   var activeLabelList;
   var hasExplicitReturn;
   var hasFlowEffects;
+  var hasFlowMutation;
   var emitFlags;
   var inStrictMode;
   var inAssignmentPattern = false;
@@ -41311,6 +41318,7 @@ function createBinder() {
     activeLabelList = void 0;
     hasExplicitReturn = false;
     hasFlowEffects = false;
+    hasFlowMutation = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
   }
@@ -41569,7 +41577,9 @@ function createBinder() {
       const saveExceptionTarget = currentExceptionTarget;
       const saveActiveLabelList = activeLabelList;
       const saveHasExplicitReturn = hasExplicitReturn;
-      const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 1024 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
+      const isRegularFunctionExpression = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 1024 /* Async */) && !node.asteriskToken;
+      const isImmediatelyInvoked = isRegularFunctionExpression && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
+      const isLambdaArgument = isRegularFunctionExpression && walkUpParenthesizedExpressions(node.parent).kind === 213 /* CallExpression */;
       if (!isImmediatelyInvoked) {
         currentFlow = createFlowNode(
           2 /* Start */,
@@ -41582,7 +41592,7 @@ function createBinder() {
           currentFlow.node = node;
         }
       }
-      currentReturnTarget = isImmediatelyInvoked || node.kind === 176 /* Constructor */ || isInJSFile(node) && (node.kind === 262 /* FunctionDeclaration */ || node.kind === 218 /* FunctionExpression */) ? createBranchLabel() : void 0;
+      currentReturnTarget = isImmediatelyInvoked || isLambdaArgument || node.kind === 176 /* Constructor */ || isInJSFile(node) && (node.kind === 262 /* FunctionDeclaration */ || node.kind === 218 /* FunctionExpression */) ? createBranchLabel() : void 0;
       currentExceptionTarget = void 0;
       currentBreakTarget = void 0;
       currentContinueTarget = void 0;
@@ -41602,7 +41612,7 @@ function createBinder() {
       if (currentReturnTarget) {
         addAntecedent(currentReturnTarget, currentFlow);
         currentFlow = finishFlowLabel(currentReturnTarget);
-        if (node.kind === 176 /* Constructor */ || node.kind === 175 /* ClassStaticBlockDeclaration */ || isInJSFile(node) && (node.kind === 262 /* FunctionDeclaration */ || node.kind === 218 /* FunctionExpression */)) {
+        if (isLambdaArgument && hasFlowMutation || node.kind === 176 /* Constructor */ || node.kind === 175 /* ClassStaticBlockDeclaration */ || isInJSFile(node) && (node.kind === 262 /* FunctionDeclaration */ || node.kind === 218 /* FunctionExpression */)) {
           node.returnFlowNode = currentFlow;
         }
       }
@@ -41882,7 +41892,7 @@ function createBinder() {
     return createFlowNode(1024 /* ReduceLabel */, { target, antecedents }, antecedent);
   }
   function setFlowNodeReferenced(flow) {
-    flow.flags |= flow.flags & 2048 /* Referenced */ ? 4096 /* Shared */ : 2048 /* Referenced */;
+    flow.flags |= flow.flags & 4096 /* Referenced */ ? 8192 /* Shared */ : 4096 /* Referenced */;
   }
   function addAntecedent(label, antecedent) {
     if (!(antecedent.flags & 1 /* Unreachable */) && !contains(label.antecedent, antecedent)) {
@@ -41913,6 +41923,7 @@ function createBinder() {
   function createFlowMutation(flags, antecedent, node) {
     setFlowNodeReferenced(antecedent);
     hasFlowEffects = true;
+    if (node.kind !== 260 /* VariableDeclaration */ && node.kind !== 208 /* BindingElement */) hasFlowMutation = true;
     const result = createFlowNode(flags, node, antecedent);
     if (currentExceptionTarget) {
       addAntecedent(currentExceptionTarget, result);
@@ -41924,6 +41935,10 @@ function createBinder() {
     hasFlowEffects = true;
     return createFlowNode(512 /* Call */, node, antecedent);
   }
+  function createFlowLambdaArgs(antecedent, node) {
+    setFlowNodeReferenced(antecedent);
+    return createFlowNode(2048 /* LambdaArgs */, node, antecedent);
+  }
   function finishFlowLabel(flow) {
     const antecedents = flow.antecedent;
     if (!antecedents) {
@@ -42585,10 +42600,22 @@ function createBinder() {
         bindEach(node.arguments);
         bind(node.expression);
       } else {
-        bindEachChild(node);
+        bind(node.expression);
+        bindEach(node.typeArguments);
+        let hasLambdaArgs = false;
+        for (const arg of node.arguments) {
+          const saveHasFlowMutation = hasFlowMutation;
+          hasFlowMutation = false;
+          bind(arg);
+          hasLambdaArgs || (hasLambdaArgs = !!getLambdaArgument(arg) && hasFlowMutation);
+          hasFlowMutation || (hasFlowMutation = saveHasFlowMutation);
+        }
         if (node.expression.kind === 108 /* SuperKeyword */) {
           currentFlow = createFlowCall(currentFlow, node);
         }
+        if (hasLambdaArgs) {
+          currentFlow = createFlowLambdaArgs(currentFlow, node);
+        }
       }
     }
     if (node.expression.kind === 211 /* PropertyAccessExpression */) {
@@ -45128,7 +45155,8 @@ var intrinsicTypeKinds = new Map(Object.entries({
   Lowercase: 1 /* Lowercase */,
   Capitalize: 2 /* Capitalize */,
   Uncapitalize: 3 /* Uncapitalize */,
-  NoInfer: 4 /* NoInfer */
+  NoInfer: 4 /* NoInfer */,
+  Deferred: 5 /* Deferred */
 }));
 var SymbolLinks = class {
 };
@@ -46092,6 +46120,7 @@ function createTypeChecker(host) {
   var flowLoopStart = 0;
   var flowLoopCount = 0;
   var sharedFlowCount = 0;
+  var mutationFlowCount = 0;
   var flowAnalysisDisabled = false;
   var flowInvocationCount = 0;
   var lastFlowNode;
@@ -46123,6 +46152,8 @@ function createTypeChecker(host) {
   var flowLoopTypes = [];
   var sharedFlowNodes = [];
   var sharedFlowTypes = [];
+  var mutationFlowNodes = [];
+  var mutationFlowStates = [];
   var flowNodeReachable = [];
   var flowNodePostSuper = [];
   var potentialThisCollisions = [];
@@ -49165,7 +49196,7 @@ function createTypeChecker(host) {
   }
   function getMeaningOfEntityNameReference(entityName) {
     let meaning;
-    if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */ || entityName.parent.kind === 182 /* TypePredicate */ && entityName.parent.parameterName === entityName || isSatisfiesKeyofExpression(entityName.parent)) {
+    if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */ || entityName.parent.kind === 182 /* TypePredicate */ && entityName.parent.parameterName === entityName) {
       meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
     } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */ || entityName.parent.kind === 166 /* QualifiedName */ && entityName.parent.left === entityName || entityName.parent.kind === 211 /* PropertyAccessExpression */ && entityName.parent.expression === entityName || entityName.parent.kind === 212 /* ElementAccessExpression */ && entityName.parent.expression === entityName) {
       meaning = 1920 /* Namespace */;
@@ -50278,7 +50309,7 @@ function createTypeChecker(host) {
                 trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context);
               }
             } else {
-              trackComputedName(isEntityNameExpression(decl.name.expression) ? decl.name.expression : decl.name.expression.expression, saveEnclosingDeclaration, context);
+              trackComputedName(decl.name.expression, saveEnclosingDeclaration, context);
             }
           }
         } else {
@@ -50775,7 +50806,7 @@ function createTypeChecker(host) {
         return elideInitializerAndSetEmitFlags(node);
         function elideInitializerAndSetEmitFlags(node2) {
           if (context.tracker.canTrackSymbol && isComputedPropertyName(node2) && isLateBindableName(node2)) {
-            trackComputedName(isEntityNameExpression(node2.expression) ? node2.expression : node2.expression.expression, context.enclosingDeclaration, context);
+            trackComputedName(node2.expression, context.enclosingDeclaration, context);
           }
           let visited = visitEachChild(
             node2,
@@ -55725,10 +55756,7 @@ function createTypeChecker(host) {
     if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
       return false;
     }
-    let expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
-    if (isSatisfiesExpression(expr) && expr.type.kind === 143 /* KeyOfKeyword */) {
-      expr = expr.expression;
-    }
+    const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
     return isEntityNameExpression(expr) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
   }
   function isLateBoundName(name) {
@@ -58299,7 +58327,7 @@ function createTypeChecker(host) {
     if (type === intrinsicMarkerType) {
       const typeKind = intrinsicTypeKinds.get(symbol.escapedName);
       if (typeKind !== void 0 && typeArguments && typeArguments.length === 1) {
-        return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]);
+        return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : typeKind === 5 /* Deferred */ ? getDeferredCallbackType(typeArguments[0], aliasSymbol, aliasTypeArguments) : getStringMappingType(symbol, typeArguments[0]);
       }
     }
     const links = getSymbolLinks(symbol);
@@ -58311,6 +58339,25 @@ function createTypeChecker(host) {
     }
     return instantiation;
   }
+  function getDeferredCallbackType(type, aliasSymbol, aliasTypeArguments) {
+    if (type.flags & 524288 /* Object */) {
+      const key = `F${getTypeId(type)}${getAliasId(aliasSymbol, aliasTypeArguments)}`;
+      return getCachedType(key) ?? setCachedType(key, createDeferredCallbackType(type, aliasSymbol, aliasTypeArguments));
+    }
+    return type;
+  }
+  function createDeferredCallbackType(type, aliasSymbol, aliasTypeArguments) {
+    const resolved = resolveStructuredTypeMembers(type);
+    const result = createObjectType(16 /* Anonymous */ | 268435456 /* DeferredCallback */, type.symbol);
+    result.members = resolved.members;
+    result.properties = resolved.properties;
+    result.callSignatures = resolved.callSignatures;
+    result.constructSignatures = resolved.constructSignatures;
+    result.indexInfos = resolved.indexInfos;
+    result.aliasSymbol = aliasSymbol;
+    result.aliasTypeArguments = aliasTypeArguments;
+    return result;
+  }
   function getTypeFromTypeAliasReference(node, symbol) {
     if (getCheckFlags(symbol) & 1048576 /* Unresolved */) {
       const typeArguments = typeArgumentsFromTypeReferenceNode(node);
@@ -61094,13 +61141,6 @@ function createTypeChecker(host) {
     type.escapedName = `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}`;
     return type;
   }
-  function getUniqueESSymbolTypeForSymbol(symbol) {
-    const links = getSymbolLinks(symbol);
-    if (!links.uniqueESSymbolType) {
-      links.uniqueESSymbolType = createUniqueESSymbolType(symbol);
-    }
-    return links.uniqueESSymbolType;
-  }
   function getESSymbolLikeTypeForNode(node) {
     if (isInJSFile(node) && isJSDocTypeExpression(node)) {
       const host2 = getJSDocHost(node);
@@ -61111,7 +61151,8 @@ function createTypeChecker(host) {
     if (isValidESSymbolDeclaration(node)) {
       const symbol = isCommonJsExportPropertyAssignment(node) ? getSymbolOfNode(node.left) : getSymbolOfNode(node);
       if (symbol) {
-        return getUniqueESSymbolTypeForSymbol(symbol);
+        const links = getSymbolLinks(symbol);
+        return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
       }
     }
     return esSymbolType;
@@ -61179,12 +61220,6 @@ function createTypeChecker(host) {
       !!node.questionToken
     ));
   }
-  function getTypeFromKeyofKeywordTypeNode(node) {
-    if (!isSatisfiesExpression(node.parent) || !isComputedPropertyName(node.parent.parent)) {
-      error(node, Diagnostics.keyof_type_must_have_an_operand_type);
-    }
-    return stringNumberSymbolType;
-  }
   function getTypeFromTypeNode(node) {
     return getConditionalFlowTypeOfType(getTypeFromTypeNodeWorker(node), node);
   }
@@ -61280,8 +61315,6 @@ function createTypeChecker(host) {
       case 211 /* PropertyAccessExpression */:
         const symbol = getSymbolAtLocation(node);
         return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
-      case 143 /* KeyOfKeyword */:
-        return getTypeFromKeyofKeywordTypeNode(node);
       default:
         return errorType;
     }
@@ -68138,7 +68171,7 @@ function createTypeChecker(host) {
         return lastFlowNodeReachable;
       }
       const flags = flow.flags;
-      if (flags & 4096 /* Shared */) {
+      if (flags & 8192 /* Shared */) {
         if (!noCacheCheck) {
           const id = getFlowNodeId(flow);
           const reachable = flowNodeReachable[id];
@@ -68150,7 +68183,7 @@ function createTypeChecker(host) {
         }
         noCacheCheck = false;
       }
-      if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */)) {
+      if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */ | 2048 /* LambdaArgs */)) {
         flow = flow.antecedent;
       } else if (flags & 512 /* Call */) {
         const signature = getEffectsSignature(flow.node);
@@ -68205,7 +68238,7 @@ function createTypeChecker(host) {
   function isPostSuperFlowNode(flow, noCacheCheck) {
     while (true) {
       const flags = flow.flags;
-      if (flags & 4096 /* Shared */) {
+      if (flags & 8192 /* Shared */) {
         if (!noCacheCheck) {
           const id = getFlowNodeId(flow);
           const postSuper = flowNodePostSuper[id];
@@ -68217,7 +68250,7 @@ function createTypeChecker(host) {
         }
         noCacheCheck = false;
       }
-      if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */ | 128 /* SwitchClause */)) {
+      if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */ | 128 /* SwitchClause */ | 2048 /* LambdaArgs */)) {
         flow = flow.antecedent;
       } else if (flags & 512 /* Call */) {
         if (flow.node.expression.kind === 108 /* SuperKeyword */) {
@@ -68271,6 +68304,7 @@ function createTypeChecker(host) {
   function getFlowTypeOfReference(reference, declaredType, initialType = declaredType, flowContainer, flowNode = ((_a) => (_a = tryCast(reference, canHaveFlowNode)) == null ? void 0 : _a.flowNode)()) {
     let key;
     let isKeySet = false;
+    let inLambdaArg = false;
     let flowDepth = 0;
     if (flowAnalysisDisabled) {
       return errorType;
@@ -68280,8 +68314,10 @@ function createTypeChecker(host) {
     }
     flowInvocationCount++;
     const sharedFlowStart = sharedFlowCount;
+    const mutationFlowStart = mutationFlowCount;
     const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
     sharedFlowCount = sharedFlowStart;
+    mutationFlowCount = mutationFlowStart;
     const resultType = getObjectFlags(evolvedType) & 256 /* EvolvingArray */ && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
     if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 235 /* NonNullExpression */ && !(resultType.flags & 131072 /* Never */) && getTypeWithFacts(resultType, 2097152 /* NEUndefinedOrNull */).flags & 131072 /* Never */) {
       return declaredType;
@@ -68306,7 +68342,7 @@ function createTypeChecker(host) {
       let sharedFlow;
       while (true) {
         const flags = flow.flags;
-        if (flags & 4096 /* Shared */) {
+        if (flags & 8192 /* Shared */) {
           for (let i = sharedFlowStart; i < sharedFlowCount; i++) {
             if (sharedFlowNodes[i] === flow) {
               flowDepth--;
@@ -68344,6 +68380,8 @@ function createTypeChecker(host) {
             flow = flow.antecedent;
             continue;
           }
+        } else if (flags & 2048 /* LambdaArgs */) {
+          type = getTypeAtFlowLambdaArgs(flow);
         } else if (flags & 1024 /* ReduceLabel */) {
           const target = flow.node.target;
           const saveAntecedents = target.antecedent;
@@ -68352,13 +68390,13 @@ function createTypeChecker(host) {
           target.antecedent = saveAntecedents;
         } else if (flags & 2 /* Start */) {
           const container = flow.node;
-          if (container && container !== flowContainer && reference.kind !== 211 /* PropertyAccessExpression */ && reference.kind !== 212 /* ElementAccessExpression */ && !(reference.kind === 110 /* ThisKeyword */ && container.kind !== 219 /* ArrowFunction */)) {
+          if (container && container !== flowContainer && !inLambdaArg && reference.kind !== 211 /* PropertyAccessExpression */ && reference.kind !== 212 /* ElementAccessExpression */ && !(reference.kind === 110 /* ThisKeyword */ && container.kind !== 219 /* ArrowFunction */)) {
             flow = container.flowNode;
             continue;
           }
           type = initialType;
         } else {
-          type = convertAutoToAny(declaredType);
+          type = inLambdaArg ? initialType : convertAutoToAny(declaredType);
         }
         if (sharedFlow) {
           sharedFlowNodes[sharedFlowCount] = sharedFlow;
@@ -68462,6 +68500,117 @@ function createTypeChecker(host) {
       }
       return void 0;
     }
+    function getTypeAtFlowLambdaArgs(flow) {
+      const flowType = getTypeAtFlowNode(flow.antecedent);
+      const saveInitialType = initialType;
+      initialType = getTypeFromFlowType(flowType);
+      let lambdaTypes;
+      if (initialType !== declaredType) {
+        const saveInLambdaArg = inLambdaArg;
+        inLambdaArg = true;
+        const args = flow.node.arguments;
+        let signatures;
+        for (let i = 0; i < args.length; i++) {
+          const lambda = getLambdaArgument(args[i]);
+          if (lambda && lambda.returnFlowNode && isMutationFlowNode(
+            lambda.returnFlowNode,
+            /*noCacheCheck*/
+            false
+          )) {
+            signatures ?? (signatures = getSignaturesOfType(getTypeOfExpression(flow.node.expression), 0 /* Call */));
+            if (!some(signatures, (sig) => !!(getObjectFlags(getTypeAtPosition(sig, i)) & 268435456 /* DeferredCallback */))) {
+              const lambdaType = getTypeFromFlowType(getTypeAtFlowNode(lambda.returnFlowNode));
+              if (lambdaType !== initialType) {
+                lambdaTypes ?? (lambdaTypes = [initialType]);
+                lambdaTypes.push(lambdaType);
+              }
+            }
+          }
+        }
+        inLambdaArg = saveInLambdaArg;
+      }
+      initialType = saveInitialType;
+      return lambdaTypes ? createFlowType(getUnionOrEvolvingArrayType(lambdaTypes, 1 /* Literal */), isIncomplete(flowType)) : flowType;
+    }
+    function isMutationFlowNode(flow, noCacheCheck) {
+      while (true) {
+        const flags = flow.flags;
+        if (flags & 8192 /* Shared */) {
+          if (!noCacheCheck) {
+            let cached = getMutationStateForFlowNode(flow);
+            if (cached === void 0) {
+              setMutationStateForFlowNode(flow, cached = isMutationFlowNode(
+                flow,
+                /*noCacheCheck*/
+                true
+              ));
+            }
+            return cached;
+          }
+          noCacheCheck = false;
+        }
+        if (flags & 16 /* Assignment */) {
+          if (isOrContainsMatchingReference(reference, flow.node)) {
+            return true;
+          }
+        } else if (flags & 4 /* BranchLabel */) {
+          return some(flow.antecedent, (f) => isMutationFlowNode(
+            f,
+            /*noCacheCheck*/
+            false
+          ));
+        } else if (flags & 8 /* LoopLabel */) {
+          let cached = getMutationStateForFlowNode(flow);
+          if (cached === void 0) {
+            const index = setMutationStateForFlowNode(flow, false);
+            cached = mutationFlowStates[index] = some(flow.antecedent, (f) => isMutationFlowNode(
+              f,
+              /*noCacheCheck*/
+              false
+            ));
+          }
+          return cached;
+        } else if (flags & 256 /* ArrayMutation */) {
+          if (declaredType === autoType || declaredType === autoArrayType) {
+            const node = flow.node;
+            const expr = node.kind === 213 /* CallExpression */ ? node.expression.expression : node.left.expression;
+            if (isMatchingReference(reference, getReferenceCandidate(expr))) {
+              return true;
+            }
+          }
+        } else if (flags & 2048 /* LambdaArgs */) {
+          const mutation = some(flow.node.arguments, (arg) => {
+            const lambda = getLambdaArgument(arg);
+            return !!(lambda && lambda.returnFlowNode && isMutationFlowNode(
+              lambda.returnFlowNode,
+              /*noCacheCheck*/
+              false
+            ));
+          });
+          if (mutation) {
+            return true;
+          }
+        } else if (!(flags & (512 /* Call */ | 96 /* Condition */ | 128 /* SwitchClause */ | 1024 /* ReduceLabel */))) {
+          return false;
+        }
+        flow = flow.antecedent;
+      }
+    }
+    function getMutationStateForFlowNode(flow) {
+      for (let i = mutationFlowStart; i < mutationFlowCount; i++) {
+        if (mutationFlowNodes[i] === flow) {
+          return mutationFlowStates[i];
+        }
+      }
+      return void 0;
+    }
+    function setMutationStateForFlowNode(flow, state) {
+      const index = mutationFlowCount;
+      mutationFlowNodes[index] = flow;
+      mutationFlowStates[index] = state;
+      mutationFlowCount++;
+      return index;
+    }
     function getTypeAtFlowArrayMutation(flow) {
       if (declaredType === autoType || declaredType === autoArrayType) {
         const node = flow.node;
@@ -73466,20 +73615,7 @@ function createTypeChecker(host) {
       }
     }
     const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
-    const result = checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
-    if (!isErrorType(result)) {
-      return result;
-    }
-    if (isEntityNameExpression(indexExpression)) {
-      const fallback = getResolvedEntityNameUniqueSymbolType(indexExpression);
-      if (fallback) {
-        const indexedAccessType2 = getIndexedAccessTypeOrUndefined(objectType, fallback, accessFlags) || errorType;
-        if (!isErrorType(indexedAccessType2) && !(indexedAccessType2.flags & 8388608 /* IndexedAccess */ && indexedAccessType2.objectType === objectType && indexedAccessType2.indexType === fallback)) {
-          return getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType2, indexExpression, checkMode);
-        }
-      }
-    }
-    return result;
+    return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
   }
   function callLikeExpressionMayHaveTypeArguments(node) {
     return isCallOrNewExpression(node) || isTaggedTemplateExpression(node) || isJsxOpeningLikeElement(node);
@@ -75727,49 +75863,13 @@ function createTypeChecker(host) {
     checkSourceElement(node.type);
     return checkSatisfiesExpressionWorker(node.expression, node.type);
   }
-  function getResolvedEntityNameUniqueSymbolType(expression) {
-    const links = getNodeLinks(expression);
-    if (!links.uniqueSymbollFallback) {
-      let resolved = resolveEntityName(
-        expression,
-        111551 /* Value */ | 1048576 /* ExportValue */,
-        /*ignoreErrors*/
-        true
-      );
-      if (!resolved || resolved === unknownSymbol) {
-        resolved = resolveEntityName(
-          expression,
-          111551 /* Value */ | 1048576 /* ExportValue */,
-          /*ignoreErrors*/
-          true,
-          /*dontResolveAlias*/
-          true
-        );
-      }
-      if (resolved) {
-        links.uniqueSymbollFallback = getUniqueESSymbolTypeForSymbol(resolved);
-      } else {
-        links.uniqueSymbollFallback = false;
-      }
-    }
-    return links.uniqueSymbollFallback || void 0;
-  }
   function checkSatisfiesExpressionWorker(expression, target, checkMode) {
     const exprType = checkExpression(expression, checkMode);
-    const errorNode = findAncestor(target.parent, (n) => n.kind === 238 /* SatisfiesExpression */ || n.kind === 350 /* JSDocSatisfiesTag */);
-    if (target.kind === 143 /* KeyOfKeyword */ && isComputedPropertyName(expression.parent.parent)) {
-      if (!(exprType.flags & 8576 /* StringOrNumberLiteralOrUnique */)) {
-        error(expression, Diagnostics.A_satisfies_keyof_computed_property_name_must_be_exactly_a_single_string_number_or_unique_symbol_literal_type);
-        if (isEntityNameExpression(expression)) {
-          return getResolvedEntityNameUniqueSymbolType(expression) || exprType;
-        }
-      }
-      return exprType;
-    }
     const targetType = getTypeFromTypeNode(target);
     if (isErrorType(targetType)) {
       return targetType;
     }
+    const errorNode = findAncestor(target.parent, (n) => n.kind === 238 /* SatisfiesExpression */ || n.kind === 350 /* JSDocSatisfiesTag */);
     checkTypeAssignableToAndOptionallyElaborate(exprType, targetType, errorNode, expression, Diagnostics.Type_0_does_not_satisfy_the_expected_type_1);
     return exprType;
   }
@@ -111595,7 +111695,7 @@ function transformDeclarations(context) {
       if (isDeclarationAndNotVisible(input)) return;
       if (hasDynamicName(input)) {
         if (isolatedDeclarations) {
-          if (!resolver.isDefinitelyReferenceToGlobalSymbolObject(input.name.expression) && !isSatisfiesKeyofExpression(input.name.expression)) {
+          if (!resolver.isDefinitelyReferenceToGlobalSymbolObject(input.name.expression)) {
             if (isClassDeclaration(input.parent) || isObjectLiteralExpression(input.parent)) {
               context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations));
               return;
@@ -111607,7 +111707,7 @@ function transformDeclarations(context) {
               return;
             }
           }
-        } else if (!resolver.isLateBound(getParseTreeNode(input)) || !(isEntityNameExpression(input.name.expression) || isSatisfiesKeyofExpression(input.name.expression))) {
+        } else if (!resolver.isLateBound(getParseTreeNode(input)) || !isEntityNameExpression(input.name.expression)) {
           return;
         }
       }
@@ -111878,10 +111978,7 @@ function transformDeclarations(context) {
     return cleanup(visitEachChild(input, visitDeclarationSubtree, context));
     function cleanup(returnValue) {
       if (returnValue && canProduceDiagnostic && hasDynamicName(input)) {
-        const updated = checkName(input, returnValue);
-        if (updated) {
-          returnValue = updated;
-        }
+        checkName(input);
       }
       if (isEnclosingDeclaration(input)) {
         enclosingDeclaration = previousEnclosingDeclaration;
@@ -112390,7 +112487,7 @@ function transformDeclarations(context) {
       }
     }
   }
-  function checkName(node, returnValue) {
+  function checkName(node) {
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
       oldDiag = getSymbolAccessibilityDiagnostic;
@@ -112400,21 +112497,11 @@ function transformDeclarations(context) {
     Debug.assert(hasDynamicName(node));
     const decl = node;
     const entityName = decl.name.expression;
-    const nameExpr = isEntityNameExpression(entityName) ? entityName : entityName.expression;
-    checkEntityNameVisibility(nameExpr, enclosingDeclaration);
-    let result = returnValue;
-    if (returnValue && nameExpr !== entityName) {
-      const updated = factory2.updateComputedPropertyName(decl.name, nameExpr);
-      result = factory2.cloneNode(returnValue);
-      result.name = updated;
-    }
+    checkEntityNameVisibility(entityName, enclosingDeclaration);
     if (!suppressNewDiagnosticContexts) {
       getSymbolAccessibilityDiagnostic = oldDiag;
     }
     errorNameNode = void 0;
-    if (result !== returnValue) {
-      return result;
-    }
   }
   function shouldStripInternal(node) {
     return !!stripInternal && !!node && isInternalDeclaration(node, currentSourceFile);