typescript 5.3.0-dev.20231022 → 5.3.0-dev.20231024

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-dev.20231022`;
+      version = `${versionMajorMinor}.0-dev.20231024`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -20769,8 +20769,9 @@ ${lanes.join("\n")}
       ensureUseStrict,
       liftToBlock,
       mergeLexicalEnvironment,
-      updateModifiers,
-      updateModifierLike
+      replaceModifiers,
+      replaceDecoratorsAndModifiers,
+      replacePropertyName
     };
     forEach(nodeFactoryPatchers, (fn) => fn(factory2));
     return factory2;
@@ -24278,7 +24279,7 @@ ${lanes.join("\n")}
       }
       return statements;
     }
-    function updateModifiers(node, modifiers) {
+    function replaceModifiers(node, modifiers) {
       let modifierArray;
       if (typeof modifiers === "number") {
         modifierArray = createModifiersFromModifierFlags(modifiers);
@@ -24287,9 +24288,27 @@ ${lanes.join("\n")}
       }
       return isTypeParameterDeclaration(node) ? updateTypeParameterDeclaration(node, modifierArray, node.name, node.constraint, node.default) : isParameter(node) ? updateParameterDeclaration(node, modifierArray, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) : isConstructorTypeNode(node) ? updateConstructorTypeNode1(node, modifierArray, node.typeParameters, node.parameters, node.type) : isPropertySignature(node) ? updatePropertySignature(node, modifierArray, node.name, node.questionToken, node.type) : isPropertyDeclaration(node) ? updatePropertyDeclaration2(node, modifierArray, node.name, node.questionToken ?? node.exclamationToken, node.type, node.initializer) : isMethodSignature(node) ? updateMethodSignature(node, modifierArray, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) : isMethodDeclaration(node) ? updateMethodDeclaration(node, modifierArray, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) : isConstructorDeclaration(node) ? updateConstructorDeclaration(node, modifierArray, node.parameters, node.body) : isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.type, node.body) : isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.body) : isIndexSignatureDeclaration(node) ? updateIndexSignature(node, modifierArray, node.parameters, node.type) : isFunctionExpression(node) ? updateFunctionExpression(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : isArrowFunction(node) ? updateArrowFunction(node, modifierArray, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) : isClassExpression(node) ? updateClassExpression(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isVariableStatement(node) ? updateVariableStatement(node, modifierArray, node.declarationList) : isFunctionDeclaration(node) ? updateFunctionDeclaration(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : isClassDeclaration(node) ? updateClassDeclaration(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, modifierArray, node.name, node.typeParameters, node.type) : isEnumDeclaration(node) ? updateEnumDeclaration(node, modifierArray, node.name, node.members) : isModuleDeclaration(node) ? updateModuleDeclaration(node, modifierArray, node.name, node.body) : isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, modifierArray, node.isTypeOnly, node.name, node.moduleReference) : isImportDeclaration(node) ? updateImportDeclaration(node, modifierArray, node.importClause, node.moduleSpecifier, node.attributes) : isExportAssignment(node) ? updateExportAssignment(node, modifierArray, node.expression) : isExportDeclaration(node) ? updateExportDeclaration(node, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.attributes) : Debug.assertNever(node);
     }
-    function updateModifierLike(node, modifierArray) {
+    function replaceDecoratorsAndModifiers(node, modifierArray) {
       return isParameter(node) ? updateParameterDeclaration(node, modifierArray, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) : isPropertyDeclaration(node) ? updatePropertyDeclaration2(node, modifierArray, node.name, node.questionToken ?? node.exclamationToken, node.type, node.initializer) : isMethodDeclaration(node) ? updateMethodDeclaration(node, modifierArray, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) : isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.type, node.body) : isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.body) : isClassExpression(node) ? updateClassExpression(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isClassDeclaration(node) ? updateClassDeclaration(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : Debug.assertNever(node);
     }
+    function replacePropertyName(node, name) {
+      switch (node.kind) {
+        case 177 /* GetAccessor */:
+          return updateGetAccessorDeclaration(node, node.modifiers, name, node.parameters, node.type, node.body);
+        case 178 /* SetAccessor */:
+          return updateSetAccessorDeclaration(node, node.modifiers, name, node.parameters, node.body);
+        case 174 /* MethodDeclaration */:
+          return updateMethodDeclaration(node, node.modifiers, node.asteriskToken, name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body);
+        case 173 /* MethodSignature */:
+          return updateMethodSignature(node, node.modifiers, name, node.questionToken, node.typeParameters, node.parameters, node.type);
+        case 172 /* PropertyDeclaration */:
+          return updatePropertyDeclaration2(node, node.modifiers, name, node.questionToken ?? node.exclamationToken, node.type, node.initializer);
+        case 171 /* PropertySignature */:
+          return updatePropertySignature(node, node.modifiers, name, node.questionToken, node.type);
+        case 303 /* PropertyAssignment */:
+          return updatePropertyAssignment(node, name, node.initializer);
+      }
+    }
     function asNodeArray(array) {
       return array ? createNodeArray(array) : void 0;
     }
@@ -52412,11 +52431,11 @@ ${lanes.join("\n")}
         }
         function addExportModifier(node) {
           const flags = (getEffectiveModifierFlags(node) | 1 /* Export */) & ~2 /* Ambient */;
-          return factory.updateModifiers(node, flags);
+          return factory.replaceModifiers(node, flags);
         }
         function removeExportModifier(node) {
           const flags = getEffectiveModifierFlags(node) & ~1 /* Export */;
-          return factory.updateModifiers(node, flags);
+          return factory.replaceModifiers(node, flags);
         }
         function visitSymbolTable(symbolTable2, suppressNewPrivateContext, propertyAsAlias) {
           if (!suppressNewPrivateContext) {
@@ -52657,7 +52676,7 @@ ${lanes.join("\n")}
               newModifierFlags |= 1024 /* Default */;
             }
             if (newModifierFlags) {
-              node = factory.updateModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
+              node = factory.replaceModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
             }
           }
           results.push(node);
@@ -65211,6 +65230,9 @@ ${lanes.join("\n")}
     }
     function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
       if (depth >= maxDepth) {
+        if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+          type = getMappedTargetWithSymbol(type);
+        }
         if (type.flags & 2097152 /* Intersection */) {
           return some(type.types, (t) => isDeeplyNestedType(t, stack, depth, maxDepth));
         }
@@ -65219,7 +65241,7 @@ ${lanes.join("\n")}
         let lastTypeId = 0;
         for (let i = 0; i < depth; i++) {
           const t = stack[i];
-          if (t.flags & 2097152 /* Intersection */ ? some(t.types, (u) => getRecursionIdentity(u) === identity2) : getRecursionIdentity(t) === identity2) {
+          if (hasMatchingRecursionIdentity(t, identity2)) {
             if (t.id >= lastTypeId) {
               count++;
               if (count >= maxDepth) {
@@ -65232,18 +65254,29 @@ ${lanes.join("\n")}
       }
       return false;
     }
+    function getMappedTargetWithSymbol(type) {
+      let target;
+      while ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && (target = getModifiersTypeFromMappedType(type)) && (target.symbol || target.flags & 2097152 /* Intersection */ && some(target.types, (t) => !!t.symbol))) {
+        type = target;
+      }
+      return type;
+    }
+    function hasMatchingRecursionIdentity(type, identity2) {
+      if ((getObjectFlags(type) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */) {
+        type = getMappedTargetWithSymbol(type);
+      }
+      if (type.flags & 2097152 /* Intersection */) {
+        return some(type.types, (t) => hasMatchingRecursionIdentity(t, identity2));
+      }
+      return getRecursionIdentity(type) === identity2;
+    }
     function getRecursionIdentity(type) {
       if (type.flags & 524288 /* Object */ && !isObjectOrArrayLiteralType(type)) {
         if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
           return type.node;
         }
-        if (type.symbol) {
-          if (getObjectFlags(type) & 32 /* Mapped */) {
-            type = getMappedTargetWithSymbol(type);
-          }
-          if (!(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
-            return type.symbol;
-          }
+        if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
+          return type.symbol;
         }
         if (isTupleType(type)) {
           return type.target;
@@ -65263,13 +65296,6 @@ ${lanes.join("\n")}
       }
       return type;
     }
-    function getMappedTargetWithSymbol(type) {
-      let target = type;
-      while ((getObjectFlags(target) & 96 /* InstantiatedMapped */) === 96 /* InstantiatedMapped */ && isMappedTypeWithKeyofConstraintDeclaration(target)) {
-        target = getModifiersTypeFromMappedType(target);
-      }
-      return target.symbol ? target : type;
-    }
     function isPropertyIdenticalTo(sourceProp, targetProp) {
       return compareProperties2(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
     }
@@ -100906,7 +100932,7 @@ ${lanes.join("\n")}
       hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & -32768 /* SubtreeFactsMask */ | ancestorFacts;
     }
     function isReturnVoidStatementInConstructorWithCapturedSuper(node) {
-      return (hierarchyFacts & 8192 /* ConstructorWithCapturedSuper */) !== 0 && node.kind === 253 /* ReturnStatement */ && !node.expression;
+      return (hierarchyFacts & 8192 /* ConstructorWithSuperCall */) !== 0 && node.kind === 253 /* ReturnStatement */ && !node.expression;
     }
     function isOrMayContainReturnCompletion(node) {
       return node.transformFlags & 4194304 /* ContainsHoistedDeclarationOrCompletion */ && (isReturnStatement(node) || isIfStatement(node) || isWithStatement(node) || isSwitchStatement(node) || isCaseBlock(node) || isCaseClause(node) || isDefaultClause(node) || isTryStatement(node) || isCatchClause(node) || isLabeledStatement(node) || isIterationStatement(
@@ -100916,7 +100942,7 @@ ${lanes.join("\n")}
       ) || isBlock(node));
     }
     function shouldVisitNode(node) {
-      return (node.transformFlags & 1024 /* ContainsES2015 */) !== 0 || convertedLoopState !== void 0 || hierarchyFacts & 8192 /* ConstructorWithCapturedSuper */ && isOrMayContainReturnCompletion(node) || isIterationStatement(
+      return (node.transformFlags & 1024 /* ContainsES2015 */) !== 0 || convertedLoopState !== void 0 || hierarchyFacts & 8192 /* ConstructorWithSuperCall */ && isOrMayContainReturnCompletion(node) || isIterationStatement(
         node,
         /*lookInLabeledStatements*/
         false
@@ -100949,7 +100975,7 @@ ${lanes.join("\n")}
             /*expressionResultIsUnused*/
             false
           );
-          exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
+          exitSubtree(ancestorFacts, 229376 /* FunctionSubtreeExcludes */, 0 /* None */);
           return result;
         }
         return visitorWorker(
@@ -100963,6 +100989,7 @@ ${lanes.join("\n")}
     function callExpressionVisitor(node) {
       if (node.kind === 108 /* SuperKeyword */) {
         return visitSuperKeyword(
+          node,
           /*isExpressionOfCall*/
           true
         );
@@ -101072,6 +101099,7 @@ ${lanes.join("\n")}
           return visitSpreadElement(node);
         case 108 /* SuperKeyword */:
           return visitSuperKeyword(
+            node,
             /*isExpressionOfCall*/
             false
           );
@@ -101141,7 +101169,10 @@ ${lanes.join("\n")}
       return updated;
     }
     function returnCapturedThis(node) {
-      return setOriginalNode(factory2.createReturnStatement(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)), node);
+      return setOriginalNode(factory2.createReturnStatement(createCapturedThis()), node);
+    }
+    function createCapturedThis() {
+      return factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */);
     }
     function visitReturnStatement(node) {
       if (convertedLoopState) {
@@ -101165,8 +101196,9 @@ ${lanes.join("\n")}
       return visitEachChild(node, visitor, context);
     }
     function visitThisKeyword(node) {
+      hierarchyFacts |= 65536 /* LexicalThis */;
       if (hierarchyFacts & 2 /* ArrowFunction */ && !(hierarchyFacts & 16384 /* StaticInitializer */)) {
-        hierarchyFacts |= 65536 /* CapturedLexicalThis */;
+        hierarchyFacts |= 131072 /* CapturedLexicalThis */;
       }
       if (convertedLoopState) {
         if (hierarchyFacts & 2 /* ArrowFunction */) {
@@ -101305,7 +101337,7 @@ ${lanes.join("\n")}
           void 0,
           /*dotDotDotToken*/
           void 0,
-          factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */)
+          createSyntheticSuper()
         )] : [],
         /*type*/
         void 0,
@@ -101395,7 +101427,7 @@ ${lanes.join("\n")}
         setEmitFlags(constructorFunction, 16 /* CapturesThis */);
       }
       statements.push(constructorFunction);
-      exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
+      exitSubtree(ancestorFacts, 229376 /* FunctionSubtreeExcludes */, 0 /* None */);
       convertedLoopState = savedConvertedLoopState;
     }
     function transformConstructorParameters(constructor, hasSynthesizedSuper) {
@@ -101419,103 +101451,35 @@ ${lanes.join("\n")}
       setEmitFlags(block, 3072 /* NoComments */);
       return block;
     }
-    function transformConstructorBodyWorker(prologueOut, statementsOut, statementsIn, statementOffset, superPath, superPathDepth, constructor, isDerivedClass, hasSynthesizedSuper, isFirstStatement) {
-      let mayReplaceThis = false;
-      const superStatementIndex = superPathDepth < superPath.length ? superPath[superPathDepth] : -1;
-      const leadingStatementsEnd = superStatementIndex >= 0 ? superStatementIndex : statementsIn.length;
-      if (isFirstStatement && superStatementIndex >= 0) {
-        let firstMaterialIndex = statementOffset;
-        while (isFirstStatement && firstMaterialIndex < superStatementIndex) {
-          const statement = constructor.body.statements[firstMaterialIndex];
-          if (!isUninitializedVariableStatement(statement) && !isUsingDeclarationStateVariableStatement(statement))
-            break;
-          firstMaterialIndex++;
-        }
-        isFirstStatement = superStatementIndex === firstMaterialIndex;
-      }
-      addRange(statementsOut, visitNodes2(statementsIn, visitor, isStatement, statementOffset, leadingStatementsEnd - statementOffset));
-      const superStatement = superStatementIndex >= 0 ? statementsIn[superStatementIndex] : void 0;
-      if (superStatement && isTryStatement(superStatement)) {
-        const tryBlockStatements = [];
-        mayReplaceThis = transformConstructorBodyWorker(
-          prologueOut,
-          tryBlockStatements,
-          superStatement.tryBlock.statements,
-          /*statementOffset*/
-          0,
-          superPath,
-          superPathDepth + 1,
-          constructor,
-          isDerivedClass,
-          hasSynthesizedSuper,
-          isFirstStatement
-        );
-        const tryBlockStatementsArray = factory2.createNodeArray(tryBlockStatements);
-        setTextRange(tryBlockStatementsArray, superStatement.tryBlock.statements);
-        statementsOut.push(factory2.updateTryStatement(
-          superStatement,
-          factory2.updateBlock(superStatement.tryBlock, tryBlockStatements),
-          visitNode(superStatement.catchClause, visitor, isCatchClause),
-          visitNode(superStatement.finallyBlock, visitor, isBlock)
-        ));
-      } else {
-        const superCall = superStatement && getSuperCallFromStatement(superStatement);
-        let superCallExpression;
-        if (hasSynthesizedSuper) {
-          superCallExpression = createDefaultSuperCallOrThis();
-          hierarchyFacts |= 8192 /* ConstructorWithCapturedSuper */;
-        } else if (superCall) {
-          superCallExpression = visitSuperCallInBody(superCall);
-          hierarchyFacts |= 8192 /* ConstructorWithCapturedSuper */;
-        }
-        if (isDerivedClass || superCallExpression) {
-          if (superCallExpression && superStatementIndex === statementsIn.length - 1 && !(constructor.body.transformFlags & 16384 /* ContainsLexicalThis */)) {
-            const superCall2 = cast(cast(superCallExpression, isBinaryExpression).left, isCallExpression);
-            const returnStatement = factory2.createReturnStatement(superCallExpression);
-            setCommentRange(returnStatement, getCommentRange(superCall2));
-            setEmitFlags(superCall2, 3072 /* NoComments */);
-            statementsOut.push(returnStatement);
-            return false;
-          } else {
-            if (isFirstStatement) {
-              insertCaptureThisForNode(statementsOut, constructor, superCallExpression || createActualThis());
-            } else {
-              insertCaptureThisForNode(prologueOut, constructor, createActualThis());
-              if (superCallExpression) {
-                addSuperThisCaptureThisForNode(statementsOut, superCallExpression);
-              }
-            }
-            mayReplaceThis = true;
-          }
-        } else {
-          insertCaptureThisForNodeIfNeeded(prologueOut, constructor);
-        }
-      }
-      if (superStatementIndex >= 0) {
-        addRange(statementsOut, visitNodes2(statementsIn, visitor, isStatement, superStatementIndex + 1));
-      }
-      return mayReplaceThis;
-    }
     function isUninitializedVariableStatement(node) {
       return isVariableStatement(node) && every(node.declarationList.declarations, (decl) => isIdentifier(decl.name) && !decl.initializer);
     }
-    function isUsingDeclarationStateVariableStatement(node) {
-      if (!isVariableStatement(node) || node.declarationList.declarations.length !== 1)
-        return false;
-      const varDecl = node.declarationList.declarations[0];
-      if (!isIdentifier(varDecl.name) || !varDecl.initializer)
-        return false;
-      const initializer = varDecl.initializer;
-      if (!isObjectLiteralExpression(initializer) || initializer.properties.length !== 3)
-        return false;
-      const [stackProp, errorProp, hasErrorProp] = initializer.properties;
-      if (!isPropertyAssignment(stackProp) || !isIdentifier(stackProp.name) || idText(stackProp.name) !== "stack" || !isArrayLiteralExpression(stackProp.initializer))
-        return false;
-      if (!isPropertyAssignment(errorProp) || !isIdentifier(errorProp.name) || idText(errorProp.name) !== "error" || !isVoidExpression(errorProp.initializer) || !isNumericLiteral(errorProp.initializer.expression))
-        return false;
-      if (!isPropertyAssignment(hasErrorProp) || !isIdentifier(hasErrorProp.name) || idText(hasErrorProp.name) !== "hasError" || hasErrorProp.initializer.kind !== 97 /* FalseKeyword */)
+    function containsSuperCall(node) {
+      if (isSuperCall(node)) {
+        return true;
+      }
+      if (!(node.transformFlags & 134217728 /* ContainsLexicalSuper */)) {
         return false;
-      return true;
+      }
+      switch (node.kind) {
+        case 219 /* ArrowFunction */:
+        case 218 /* FunctionExpression */:
+        case 262 /* FunctionDeclaration */:
+        case 176 /* Constructor */:
+        case 175 /* ClassStaticBlockDeclaration */:
+          return false;
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+        case 174 /* MethodDeclaration */:
+        case 172 /* PropertyDeclaration */: {
+          const named = node;
+          if (isComputedPropertyName(named.name)) {
+            return !!forEachChild(named.name, containsSuperCall);
+          }
+          return false;
+        }
+      }
+      return !!forEachChild(node, containsSuperCall);
     }
     function transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper) {
       const isDerivedClass = !!extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== 106 /* NullKeyword */;
@@ -101530,31 +101494,22 @@ ${lanes.join("\n")}
         /*statementOffset*/
         0
       );
-      const superStatementIndices = findSuperStatementIndexPath(constructor.body.statements, standardPrologueEnd);
-      if (hasSynthesizedSuper || superStatementIndices.length > 0) {
-        hierarchyFacts |= 8192 /* ConstructorWithCapturedSuper */;
+      if (hasSynthesizedSuper || containsSuperCall(constructor.body)) {
+        hierarchyFacts |= 8192 /* ConstructorWithSuperCall */;
       }
-      const mayReplaceThis = transformConstructorBodyWorker(
-        prologue,
-        statements,
-        constructor.body.statements,
-        standardPrologueEnd,
-        superStatementIndices,
-        /*superPathDepth*/
-        0,
-        constructor,
-        isDerivedClass,
-        hasSynthesizedSuper,
-        /*isFirstStatement*/
-        true
-        // NOTE: this will be recalculated inside of transformConstructorBodyWorker
-      );
+      addRange(statements, visitNodes2(constructor.body.statements, visitor, isStatement, standardPrologueEnd));
+      const mayReplaceThis = isDerivedClass || hierarchyFacts & 8192 /* ConstructorWithSuperCall */;
       addDefaultValueAssignmentsIfNeeded2(prologue, constructor);
       addRestParameterIfNeeded(prologue, constructor, hasSynthesizedSuper);
       insertCaptureNewTargetIfNeeded(prologue, constructor);
+      if (mayReplaceThis) {
+        insertCaptureThisForNode(prologue, constructor, createActualThis());
+      } else {
+        insertCaptureThisForNodeIfNeeded(prologue, constructor);
+      }
       factory2.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
       if (mayReplaceThis && !isSufficientlyCoveredByReturnStatements(constructor.body)) {
-        statements.push(factory2.createReturnStatement(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)));
+        statements.push(factory2.createReturnStatement(createCapturedThis()));
       }
       const body = factory2.createBlock(
         setTextRange(
@@ -101571,6 +101526,230 @@ ${lanes.join("\n")}
         true
       );
       setTextRange(body, constructor.body);
+      return simplifyConstructor(body, constructor.body, hasSynthesizedSuper);
+    }
+    function isCapturedThis(node) {
+      return isGeneratedIdentifier(node) && idText(node) === "_this";
+    }
+    function isSyntheticSuper(node) {
+      return isGeneratedIdentifier(node) && idText(node) === "_super";
+    }
+    function isThisCapturingVariableStatement(node) {
+      return isVariableStatement(node) && node.declarationList.declarations.length === 1 && isThisCapturingVariableDeclaration(node.declarationList.declarations[0]);
+    }
+    function isThisCapturingVariableDeclaration(node) {
+      return isVariableDeclaration(node) && isCapturedThis(node.name) && !!node.initializer;
+    }
+    function isThisCapturingAssignment(node) {
+      return isAssignmentExpression(
+        node,
+        /*excludeCompoundAssignment*/
+        true
+      ) && isCapturedThis(node.left);
+    }
+    function isTransformedSuperCall(node) {
+      return isCallExpression(node) && isPropertyAccessExpression(node.expression) && isSyntheticSuper(node.expression.expression) && isIdentifier(node.expression.name) && (idText(node.expression.name) === "call" || idText(node.expression.name) === "apply") && node.arguments.length >= 1 && node.arguments[0].kind === 110 /* ThisKeyword */;
+    }
+    function isTransformedSuperCallWithFallback(node) {
+      return isBinaryExpression(node) && node.operatorToken.kind === 57 /* BarBarToken */ && node.right.kind === 110 /* ThisKeyword */ && isTransformedSuperCall(node.left);
+    }
+    function isImplicitSuperCall(node) {
+      return isBinaryExpression(node) && node.operatorToken.kind === 56 /* AmpersandAmpersandToken */ && isBinaryExpression(node.left) && node.left.operatorToken.kind === 38 /* ExclamationEqualsEqualsToken */ && isSyntheticSuper(node.left.left) && node.left.right.kind === 106 /* NullKeyword */ && isTransformedSuperCall(node.right) && idText(node.right.expression.name) === "apply";
+    }
+    function isImplicitSuperCallWithFallback(node) {
+      return isBinaryExpression(node) && node.operatorToken.kind === 57 /* BarBarToken */ && node.right.kind === 110 /* ThisKeyword */ && isImplicitSuperCall(node.left);
+    }
+    function isThisCapturingTransformedSuperCallWithFallback(node) {
+      return isThisCapturingAssignment(node) && isTransformedSuperCallWithFallback(node.right);
+    }
+    function isThisCapturingImplicitSuperCallWithFallback(node) {
+      return isThisCapturingAssignment(node) && isImplicitSuperCallWithFallback(node.right);
+    }
+    function isTransformedSuperCallLike(node) {
+      return isTransformedSuperCall(node) || isTransformedSuperCallWithFallback(node) || isThisCapturingTransformedSuperCallWithFallback(node) || isImplicitSuperCall(node) || isImplicitSuperCallWithFallback(node) || isThisCapturingImplicitSuperCallWithFallback(node);
+    }
+    function simplifyConstructorInlineSuperInThisCaptureVariable(body) {
+      for (let i = 0; i < body.statements.length - 1; i++) {
+        const statement = body.statements[i];
+        if (!isThisCapturingVariableStatement(statement)) {
+          continue;
+        }
+        const varDecl = statement.declarationList.declarations[0];
+        if (varDecl.initializer.kind !== 110 /* ThisKeyword */) {
+          continue;
+        }
+        const thisCaptureStatementIndex = i;
+        let superCallIndex = i + 1;
+        while (superCallIndex < body.statements.length) {
+          const statement2 = body.statements[superCallIndex];
+          if (isExpressionStatement(statement2)) {
+            if (isTransformedSuperCallLike(skipOuterExpressions(statement2.expression))) {
+              break;
+            }
+          }
+          if (isUninitializedVariableStatement(statement2)) {
+            superCallIndex++;
+            continue;
+          }
+          return body;
+        }
+        const following = body.statements[superCallIndex];
+        let expression = following.expression;
+        if (isThisCapturingAssignment(expression)) {
+          expression = expression.right;
+        }
+        const newVarDecl = factory2.updateVariableDeclaration(
+          varDecl,
+          varDecl.name,
+          /*exclamationToken*/
+          void 0,
+          /*type*/
+          void 0,
+          expression
+        );
+        const newDeclList = factory2.updateVariableDeclarationList(statement.declarationList, [newVarDecl]);
+        const newVarStatement = factory2.createVariableStatement(statement.modifiers, newDeclList);
+        setOriginalNode(newVarStatement, following);
+        setTextRange(newVarStatement, following);
+        const newStatements = factory2.createNodeArray([
+          ...body.statements.slice(0, thisCaptureStatementIndex),
+          // copy statements preceding to `var _this`
+          ...body.statements.slice(thisCaptureStatementIndex + 1, superCallIndex),
+          // copy intervening temp variables
+          newVarStatement,
+          ...body.statements.slice(superCallIndex + 1)
+          // copy statements following `super.call(this, ...)`
+        ]);
+        setTextRange(newStatements, body.statements);
+        return factory2.updateBlock(body, newStatements);
+      }
+      return body;
+    }
+    function simplifyConstructorInlineSuperReturn(body, original) {
+      for (const statement of original.statements) {
+        if (statement.transformFlags & 134217728 /* ContainsLexicalSuper */ && !getSuperCallFromStatement(statement)) {
+          return body;
+        }
+      }
+      const canElideThisCapturingVariable = !(original.transformFlags & 16384 /* ContainsLexicalThis */) && !(hierarchyFacts & 65536 /* LexicalThis */) && !(hierarchyFacts & 131072 /* CapturedLexicalThis */);
+      for (let i = body.statements.length - 1; i > 0; i--) {
+        const statement = body.statements[i];
+        if (isReturnStatement(statement) && statement.expression && isCapturedThis(statement.expression)) {
+          const preceding = body.statements[i - 1];
+          let expression;
+          if (isExpressionStatement(preceding) && isThisCapturingTransformedSuperCallWithFallback(skipOuterExpressions(preceding.expression))) {
+            expression = preceding.expression;
+          } else if (canElideThisCapturingVariable && isThisCapturingVariableStatement(preceding)) {
+            const varDecl = preceding.declarationList.declarations[0];
+            if (isTransformedSuperCallLike(skipOuterExpressions(varDecl.initializer))) {
+              expression = factory2.createAssignment(
+                createCapturedThis(),
+                varDecl.initializer
+              );
+            }
+          }
+          if (!expression) {
+            break;
+          }
+          const newReturnStatement = factory2.createReturnStatement(expression);
+          setOriginalNode(newReturnStatement, preceding);
+          setTextRange(newReturnStatement, preceding);
+          const newStatements = factory2.createNodeArray([
+            ...body.statements.slice(0, i - 1),
+            // copy all statements preceding `_super.call(this, ...)`
+            newReturnStatement,
+            ...body.statements.slice(i + 1)
+            // copy all statements following `return _this;`
+          ]);
+          setTextRange(newStatements, body.statements);
+          return factory2.updateBlock(body, newStatements);
+        }
+      }
+      return body;
+    }
+    function elideUnusedThisCaptureWorker(node) {
+      if (isThisCapturingVariableStatement(node)) {
+        const varDecl = node.declarationList.declarations[0];
+        if (varDecl.initializer.kind === 110 /* ThisKeyword */) {
+          return void 0;
+        }
+      } else if (isThisCapturingAssignment(node)) {
+        return factory2.createPartiallyEmittedExpression(node.right, node);
+      }
+      switch (node.kind) {
+        case 219 /* ArrowFunction */:
+        case 218 /* FunctionExpression */:
+        case 262 /* FunctionDeclaration */:
+        case 176 /* Constructor */:
+        case 175 /* ClassStaticBlockDeclaration */:
+          return node;
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+        case 174 /* MethodDeclaration */:
+        case 172 /* PropertyDeclaration */: {
+          const named = node;
+          if (isComputedPropertyName(named.name)) {
+            return factory2.replacePropertyName(named, visitEachChild(named.name, elideUnusedThisCaptureWorker, nullTransformationContext));
+          }
+          return node;
+        }
+      }
+      return visitEachChild(node, elideUnusedThisCaptureWorker, nullTransformationContext);
+    }
+    function simplifyConstructorElideUnusedThisCapture(body, original) {
+      if (original.transformFlags & 16384 /* ContainsLexicalThis */ || hierarchyFacts & 65536 /* LexicalThis */ || hierarchyFacts & 131072 /* CapturedLexicalThis */) {
+        return body;
+      }
+      for (const statement of original.statements) {
+        if (statement.transformFlags & 134217728 /* ContainsLexicalSuper */ && !getSuperCallFromStatement(statement)) {
+          return body;
+        }
+      }
+      return factory2.updateBlock(body, visitNodes2(body.statements, elideUnusedThisCaptureWorker, isStatement));
+    }
+    function injectSuperPresenceCheckWorker(node) {
+      if (isTransformedSuperCall(node) && node.arguments.length === 2 && isIdentifier(node.arguments[1]) && idText(node.arguments[1]) === "arguments") {
+        return factory2.createLogicalAnd(
+          factory2.createStrictInequality(
+            createSyntheticSuper(),
+            factory2.createNull()
+          ),
+          node
+        );
+      }
+      switch (node.kind) {
+        case 219 /* ArrowFunction */:
+        case 218 /* FunctionExpression */:
+        case 262 /* FunctionDeclaration */:
+        case 176 /* Constructor */:
+        case 175 /* ClassStaticBlockDeclaration */:
+          return node;
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+        case 174 /* MethodDeclaration */:
+        case 172 /* PropertyDeclaration */: {
+          const named = node;
+          if (isComputedPropertyName(named.name)) {
+            return factory2.replacePropertyName(named, visitEachChild(named.name, injectSuperPresenceCheckWorker, nullTransformationContext));
+          }
+          return node;
+        }
+      }
+      return visitEachChild(node, injectSuperPresenceCheckWorker, nullTransformationContext);
+    }
+    function complicateConstructorInjectSuperPresenceCheck(body) {
+      return factory2.updateBlock(body, visitNodes2(body.statements, injectSuperPresenceCheckWorker, isStatement));
+    }
+    function simplifyConstructor(body, original, hasSynthesizedSuper) {
+      const inputBody = body;
+      body = simplifyConstructorInlineSuperInThisCaptureVariable(body);
+      body = simplifyConstructorInlineSuperReturn(body, original);
+      if (body !== inputBody) {
+        body = simplifyConstructorElideUnusedThisCapture(body, original);
+      }
+      if (hasSynthesizedSuper) {
+        body = complicateConstructorInjectSuperPresenceCheck(body);
+      }
       return body;
     }
     function isSufficientlyCoveredByReturnStatements(statement) {
@@ -101596,11 +101775,11 @@ ${lanes.join("\n")}
       return factory2.createLogicalOr(
         factory2.createLogicalAnd(
           factory2.createStrictInequality(
-            factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
+            createSyntheticSuper(),
             factory2.createNull()
           ),
           factory2.createFunctionApplyCall(
-            factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
+            createSyntheticSuper(),
             createActualThis(),
             factory2.createIdentifier("arguments")
           )
@@ -101855,24 +102034,12 @@ ${lanes.join("\n")}
       return true;
     }
     function insertCaptureThisForNodeIfNeeded(statements, node) {
-      if (hierarchyFacts & 65536 /* CapturedLexicalThis */ && node.kind !== 219 /* ArrowFunction */) {
+      if (hierarchyFacts & 131072 /* CapturedLexicalThis */ && node.kind !== 219 /* ArrowFunction */) {
         insertCaptureThisForNode(statements, node, factory2.createThis());
         return true;
       }
       return false;
     }
-    function addSuperThisCaptureThisForNode(statements, superExpression) {
-      enableSubstitutionsForCapturedThis();
-      const assignSuperExpression = factory2.createExpressionStatement(
-        factory2.createBinaryExpression(
-          factory2.createThis(),
-          64 /* EqualsToken */,
-          superExpression
-        )
-      );
-      statements.push(assignSuperExpression);
-      setCommentRange(assignSuperExpression, getOriginalNode(superExpression).parent);
-    }
     function insertCaptureThisForNode(statements, node, initializer) {
       enableSubstitutionsForCapturedThis();
       const captureThisStatement = factory2.createVariableStatement(
@@ -101880,7 +102047,7 @@ ${lanes.join("\n")}
         void 0,
         factory2.createVariableDeclarationList([
           factory2.createVariableDeclaration(
-            factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */),
+            createCapturedThis(),
             /*exclamationToken*/
             void 0,
             /*type*/
@@ -102101,7 +102268,7 @@ ${lanes.join("\n")}
     }
     function visitArrowFunction(node) {
       if (node.transformFlags & 16384 /* ContainsLexicalThis */ && !(hierarchyFacts & 16384 /* StaticInitializer */)) {
-        hierarchyFacts |= 65536 /* CapturedLexicalThis */;
+        hierarchyFacts |= 131072 /* CapturedLexicalThis */;
       }
       const savedConvertedLoopState = convertedLoopState;
       convertedLoopState = void 0;
@@ -102134,7 +102301,7 @@ ${lanes.join("\n")}
       const parameters = visitParameterList(node.parameters, visitor, context);
       const body = transformFunctionBody2(node);
       const name = hierarchyFacts & 32768 /* NewTarget */ ? factory2.getLocalName(node) : node.name;
-      exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
+      exitSubtree(ancestorFacts, 229376 /* FunctionSubtreeExcludes */, 0 /* None */);
       convertedLoopState = savedConvertedLoopState;
       return factory2.updateFunctionExpression(
         node,
@@ -102157,7 +102324,7 @@ ${lanes.join("\n")}
       const parameters = visitParameterList(node.parameters, visitor, context);
       const body = transformFunctionBody2(node);
       const name = hierarchyFacts & 32768 /* NewTarget */ ? factory2.getLocalName(node) : node.name;
-      exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
+      exitSubtree(ancestorFacts, 229376 /* FunctionSubtreeExcludes */, 0 /* None */);
       convertedLoopState = savedConvertedLoopState;
       return factory2.updateFunctionDeclaration(
         node,
@@ -102181,7 +102348,7 @@ ${lanes.join("\n")}
       if (hierarchyFacts & 32768 /* NewTarget */ && !name && (node.kind === 262 /* FunctionDeclaration */ || node.kind === 218 /* FunctionExpression */)) {
         name = factory2.getGeneratedNameForNode(node);
       }
-      exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
+      exitSubtree(ancestorFacts, 229376 /* FunctionSubtreeExcludes */, 0 /* None */);
       convertedLoopState = savedConvertedLoopState;
       return setOriginalNode(
         setTextRange(
@@ -103590,7 +103757,7 @@ ${lanes.join("\n")}
       } else {
         updated = factory2.updateSetAccessorDeclaration(node, node.modifiers, node.name, parameters, body);
       }
-      exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
+      exitSubtree(ancestorFacts, 229376 /* FunctionSubtreeExcludes */, 0 /* None */);
       convertedLoopState = savedConvertedLoopState;
       return updated;
     }
@@ -103740,13 +103907,6 @@ ${lanes.join("\n")}
         )
       );
     }
-    function visitSuperCallInBody(node) {
-      return visitCallExpressionWithPotentialCapturedThisAssignment(
-        node,
-        /*assignToCapturedThis*/
-        false
-      );
-    }
     function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) {
       if (node.transformFlags & 32768 /* ContainsRestOrSpread */ || node.expression.kind === 108 /* SuperKeyword */ || isSuperProperty(skipOuterExpressions(node.expression))) {
         const { target, thisArg } = factory2.createCallBinding(node.expression, hoistVariableDeclaration);
@@ -103783,10 +103943,13 @@ ${lanes.join("\n")}
             resultingCall,
             createActualThis()
           );
-          resultingCall = assignToCapturedThis ? factory2.createAssignment(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */), initializer) : initializer;
+          resultingCall = assignToCapturedThis ? factory2.createAssignment(createCapturedThis(), initializer) : initializer;
         }
         return setOriginalNode(resultingCall, node);
       }
+      if (isSuperCall(node)) {
+        hierarchyFacts |= 131072 /* CapturedLexicalThis */;
+      }
       return visitEachChild(node, visitor, context);
     }
     function visitNewExpression(node) {
@@ -103913,8 +104076,15 @@ ${lanes.join("\n")}
       }
       return setTextRange(expression, node);
     }
-    function visitSuperKeyword(isExpressionOfCall) {
-      return hierarchyFacts & 8 /* NonStaticClassElement */ && !isExpressionOfCall ? factory2.createPropertyAccessExpression(factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */), "prototype") : factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */);
+    function createSyntheticSuper() {
+      return factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */);
+    }
+    function visitSuperKeyword(node, isExpressionOfCall) {
+      const expression = hierarchyFacts & 8 /* NonStaticClassElement */ && !isExpressionOfCall ? factory2.createPropertyAccessExpression(setOriginalNode(createSyntheticSuper(), node), "prototype") : createSyntheticSuper();
+      setOriginalNode(expression, node);
+      setCommentRange(expression, node);
+      setSourceMapRange(expression, node);
+      return expression;
     }
     function visitMetaProperty(node) {
       if (node.keywordToken === 105 /* NewKeyword */ && node.name.escapedText === "target") {
@@ -104020,7 +104190,7 @@ ${lanes.join("\n")}
     }
     function substituteThisKeyword(node) {
       if (enabledSubstitutions & 1 /* CapturedThis */ && hierarchyFacts & 16 /* CapturesThis */) {
-        return setTextRange(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */), node);
+        return setTextRange(createCapturedThis(), node);
       }
       return node;
     }
@@ -111166,7 +111336,7 @@ ${lanes.join("\n")}
         return statement;
       }
       const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(statement) & (258047 /* All */ ^ 1 /* Export */));
-      return factory2.updateModifiers(statement, modifiers);
+      return factory2.replaceModifiers(statement, modifiers);
     }
     function updateModuleDeclarationAndKeyword(node, modifiers, name, body) {
       const updated = factory2.updateModuleDeclaration(node, modifiers, name, body);
@@ -111297,7 +111467,7 @@ ${lanes.join("\n")}
               return factory2.createVariableStatement(isNonContextualKeywordName ? void 0 : [factory2.createToken(95 /* ExportKeyword */)], factory2.createVariableDeclarationList([varDecl]));
             });
             if (!exportMappings.length) {
-              declarations = mapDefined(declarations, (declaration) => factory2.updateModifiers(declaration, 0 /* None */));
+              declarations = mapDefined(declarations, (declaration) => factory2.replaceModifiers(declaration, 0 /* None */));
             } else {
               declarations.push(factory2.createExportDeclaration(
                 /*modifiers*/
@@ -145503,7 +145673,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
     }
     fixedDeclarations == null ? void 0 : fixedDeclarations.add(getNodeId(insertionSite));
-    const cloneWithModifier = factory.updateModifiers(
+    const cloneWithModifier = factory.replaceModifiers(
       getSynthesizedDeepClone(
         insertionSite,
         /*includeTrivia*/
@@ -157086,7 +157256,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (!completionNodes.length) {
           modifiers = node.modifierFlagsCache | requiredModifiers;
         }
-        node = factory.updateModifiers(node, modifiers);
+        node = factory.replaceModifiers(node, modifiers);
         completionNodes.push(node);
       },
       body,
@@ -157112,11 +157282,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         modifiers &= ~4 /* Public */;
       }
       modifiers |= allowedAndPresent;
-      completionNodes = completionNodes.map((node) => factory.updateModifiers(node, modifiers));
+      completionNodes = completionNodes.map((node) => factory.replaceModifiers(node, modifiers));
       if (presentDecorators == null ? void 0 : presentDecorators.length) {
         const lastNode = completionNodes[completionNodes.length - 1];
         if (canHaveDecorators(lastNode)) {
-          completionNodes[completionNodes.length - 1] = factory.updateModifierLike(lastNode, presentDecorators.concat(getModifiers(lastNode) || []));
+          completionNodes[completionNodes.length - 1] = factory.replaceDecoratorsAndModifiers(lastNode, presentDecorators.concat(getModifiers(lastNode) || []));
         }
       }
       const format = 1 /* MultiLine */ | 131072 /* NoTrailingNewLine */;