@typescript-deploys/pr-build 5.3.0-pr-56161-5 → 5.3.0-pr-55774-4

package/lib/tsserver.js

@@ -2328,7 +2328,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-insiders.20231020`;
+var version = `${versionMajorMinor}.0-insiders.20231024`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -22955,8 +22955,9 @@ function createNodeFactory(flags, baseFactory2) {
     ensureUseStrict,
     liftToBlock,
     mergeLexicalEnvironment,
-    updateModifiers,
-    updateModifierLike
+    replaceModifiers,
+    replaceDecoratorsAndModifiers,
+    replacePropertyName
   };
   forEach(nodeFactoryPatchers, (fn) => fn(factory2));
   return factory2;
@@ -26464,7 +26465,7 @@ function createNodeFactory(flags, baseFactory2) {
     }
     return statements;
   }
-  function updateModifiers(node, modifiers) {
+  function replaceModifiers(node, modifiers) {
     let modifierArray;
     if (typeof modifiers === "number") {
       modifierArray = createModifiersFromModifierFlags(modifiers);
@@ -26473,9 +26474,27 @@ function createNodeFactory(flags, baseFactory2) {
     }
     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;
   }
@@ -54645,11 +54664,11 @@ function createTypeChecker(host) {
       }
       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) {
@@ -54890,7 +54909,7 @@ function createTypeChecker(host) {
             newModifierFlags |= 1024 /* Default */;
           }
           if (newModifierFlags) {
-            node = factory.updateModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
+            node = factory.replaceModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
           }
         }
         results.push(node);
@@ -58852,7 +58871,13 @@ function createTypeChecker(host) {
     const templateModifiers = getMappedTypeModifiers(type);
     const include = keyofStringsOnly ? 128 /* StringLiteral */ : 8576 /* StringOrNumberLiteralOrUnique */;
     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
-      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, include, keyofStringsOnly, addMemberForKeyType);
+      if (nameType && isTupleType(modifiersType)) {
+        forEachType(getUnionType(getElementTypes(modifiersType).map((_, i) => getStringLiteralType("" + i))), addMemberForKeyType);
+      } else if (isArrayType(modifiersType)) {
+        addMemberForKeyType(numberType);
+      } else {
+        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, include, keyofStringsOnly, addMemberForKeyType);
+      }
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
     }
@@ -60661,7 +60686,7 @@ function createTypeChecker(host) {
         if (constraint) {
           constraints = append(constraints, constraint);
         }
-      } else if (type.flags & 262144 /* TypeParameter */ && parent2.kind === 200 /* MappedType */ && node === parent2.type) {
+      } else if (type.flags & 262144 /* TypeParameter */ && parent2.kind === 200 /* MappedType */ && (node === parent2.type || node === parent2.nameType)) {
         const mappedType = getTypeFromTypeNode(parent2);
         if (getTypeParameterFromMappedType(mappedType) === getActualTypeVariable(type)) {
           const typeParameter = getHomomorphicTypeVariable(mappedType);
@@ -67444,6 +67469,9 @@ function createTypeChecker(host) {
   }
   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));
       }
@@ -67452,7 +67480,7 @@ function createTypeChecker(host) {
       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) {
@@ -67465,18 +67493,29 @@ function createTypeChecker(host) {
     }
     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;
@@ -67496,13 +67535,6 @@ function createTypeChecker(host) {
     }
     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 */;
   }
@@ -84402,7 +84434,7 @@ function createTypeChecker(host) {
       error2(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
       const text = getTextOfPropertyName(member.name);
-      if (isNumericLiteralName(text)) {
+      if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
         error2(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
       }
     }
@@ -102878,7 +102910,7 @@ function transformES2015(context) {
     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(
@@ -102888,7 +102920,7 @@ function transformES2015(context) {
     ) || 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
@@ -102921,7 +102953,7 @@ function transformES2015(context) {
           /*expressionResultIsUnused*/
           false
         );
-        exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
+        exitSubtree(ancestorFacts, 229376 /* FunctionSubtreeExcludes */, 0 /* None */);
         return result;
       }
       return visitorWorker(
@@ -102935,6 +102967,7 @@ function transformES2015(context) {
   function callExpressionVisitor(node) {
     if (node.kind === 108 /* SuperKeyword */) {
       return visitSuperKeyword(
+        node,
         /*isExpressionOfCall*/
         true
       );
@@ -103044,6 +103077,7 @@ function transformES2015(context) {
         return visitSpreadElement(node);
       case 108 /* SuperKeyword */:
         return visitSuperKeyword(
+          node,
           /*isExpressionOfCall*/
           false
         );
@@ -103113,7 +103147,10 @@ function transformES2015(context) {
     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) {
@@ -103137,8 +103174,9 @@ function transformES2015(context) {
     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 */) {
@@ -103277,7 +103315,7 @@ function transformES2015(context) {
         void 0,
         /*dotDotDotToken*/
         void 0,
-        factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */)
+        createSyntheticSuper()
       )] : [],
       /*type*/
       void 0,
@@ -103367,7 +103405,7 @@ function transformES2015(context) {
       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) {
@@ -103391,103 +103429,35 @@ function transformES2015(context) {
     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 */;
@@ -103502,31 +103472,22 @@ function transformES2015(context) {
       /*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(
@@ -103543,6 +103504,230 @@ function transformES2015(context) {
       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) {
@@ -103568,11 +103753,11 @@ function transformES2015(context) {
     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")
         )
@@ -103827,24 +104012,12 @@ function transformES2015(context) {
     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(
@@ -103852,7 +104025,7 @@ function transformES2015(context) {
       void 0,
       factory2.createVariableDeclarationList([
         factory2.createVariableDeclaration(
-          factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */),
+          createCapturedThis(),
           /*exclamationToken*/
           void 0,
           /*type*/
@@ -104073,7 +104246,7 @@ function transformES2015(context) {
   }
   function visitArrowFunction(node) {
     if (node.transformFlags & 16384 /* ContainsLexicalThis */ && !(hierarchyFacts & 16384 /* StaticInitializer */)) {
-      hierarchyFacts |= 65536 /* CapturedLexicalThis */;
+      hierarchyFacts |= 131072 /* CapturedLexicalThis */;
     }
     const savedConvertedLoopState = convertedLoopState;
     convertedLoopState = void 0;
@@ -104106,7 +104279,7 @@ function transformES2015(context) {
     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,
@@ -104129,7 +104302,7 @@ function transformES2015(context) {
     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,
@@ -104153,7 +104326,7 @@ function transformES2015(context) {
     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(
@@ -105562,7 +105735,7 @@ function transformES2015(context) {
     } 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;
   }
@@ -105712,13 +105885,6 @@ function transformES2015(context) {
       )
     );
   }
-  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);
@@ -105755,10 +105921,13 @@ function transformES2015(context) {
           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) {
@@ -105885,8 +106054,15 @@ function transformES2015(context) {
     }
     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") {
@@ -105992,7 +106168,7 @@ function transformES2015(context) {
   }
   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;
   }
@@ -113090,7 +113266,7 @@ function transformDeclarations(context) {
       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);
@@ -113221,7 +113397,7 @@ function transformDeclarations(context) {
             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*/
@@ -146896,7 +147072,7 @@ function makeChange2(changeTracker, sourceFile, insertionSite, fixedDeclarations
     }
   }
   fixedDeclarations == null ? void 0 : fixedDeclarations.add(getNodeId(insertionSite));
-  const cloneWithModifier = factory.updateModifiers(
+  const cloneWithModifier = factory.replaceModifiers(
     getSynthesizedDeepClone(
       insertionSite,
       /*includeTrivia*/
@@ -149961,7 +150137,8 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
         defaultImport,
         namedImports && arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
         namespaceLikeImport,
-        compilerOptions
+        compilerOptions,
+        preferences
       );
       newDeclarations = combine(newDeclarations, declarations);
     });
@@ -150666,7 +150843,8 @@ function codeActionForFixWorker(changes, sourceFile, symbolName2, fix, includeSy
           defaultImport,
           namedImports,
           namespaceLikeImport,
-          program.getCompilerOptions()
+          program.getCompilerOptions(),
+          preferences
         ),
         /*blankLineBetween*/
         true,
@@ -150798,7 +150976,7 @@ function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImpor
     const newSpecifiers = stableSort(
       namedImports.map(
         (namedImport) => factory.createImportSpecifier(
-          (!clause.isTypeOnly || promoteFromTypeOnly2) && needsTypeOnly(namedImport),
+          (!clause.isTypeOnly || promoteFromTypeOnly2) && shouldUseTypeOnly(namedImport, preferences),
           /*propertyName*/
           void 0,
           factory.createIdentifier(namedImport.name)
@@ -150862,21 +151040,24 @@ function getImportTypePrefix(moduleSpecifier, quotePreference) {
 function needsTypeOnly({ addAsTypeOnly }) {
   return addAsTypeOnly === 2 /* Required */;
 }
-function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport, compilerOptions) {
+function shouldUseTypeOnly(info, preferences) {
+  return needsTypeOnly(info) || !!preferences.preferTypeOnlyAutoImports && info.addAsTypeOnly !== 4 /* NotAllowed */;
+}
+function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport, compilerOptions, preferences) {
   const quotedModuleSpecifier = makeStringLiteral(moduleSpecifier, quotePreference);
   let statements;
   if (defaultImport !== void 0 || (namedImports == null ? void 0 : namedImports.length)) {
-    const topLevelTypeOnly = (!defaultImport || needsTypeOnly(defaultImport)) && every(namedImports, needsTypeOnly) || compilerOptions.verbatimModuleSyntax && (defaultImport == null ? void 0 : defaultImport.addAsTypeOnly) !== 4 /* NotAllowed */ && !some(namedImports, (i) => i.addAsTypeOnly === 4 /* NotAllowed */);
+    const topLevelTypeOnly = (!defaultImport || needsTypeOnly(defaultImport)) && every(namedImports, needsTypeOnly) || (compilerOptions.verbatimModuleSyntax || preferences.preferTypeOnlyAutoImports) && (defaultImport == null ? void 0 : defaultImport.addAsTypeOnly) !== 4 /* NotAllowed */ && !some(namedImports, (i) => i.addAsTypeOnly === 4 /* NotAllowed */);
     statements = combine(
       statements,
       makeImport(
         defaultImport && factory.createIdentifier(defaultImport.name),
         namedImports == null ? void 0 : namedImports.map(
-          ({ addAsTypeOnly, name }) => factory.createImportSpecifier(
-            !topLevelTypeOnly && addAsTypeOnly === 2 /* Required */,
+          (namedImport) => factory.createImportSpecifier(
+            !topLevelTypeOnly && shouldUseTypeOnly(namedImport, preferences),
             /*propertyName*/
             void 0,
-            factory.createIdentifier(name)
+            factory.createIdentifier(namedImport.name)
           )
         ),
         moduleSpecifier,
@@ -150889,14 +151070,14 @@ function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImp
     const declaration = namespaceLikeImport.importKind === 3 /* CommonJS */ ? factory.createImportEqualsDeclaration(
       /*modifiers*/
       void 0,
-      needsTypeOnly(namespaceLikeImport),
+      shouldUseTypeOnly(namespaceLikeImport, preferences),
       factory.createIdentifier(namespaceLikeImport.name),
       factory.createExternalModuleReference(quotedModuleSpecifier)
     ) : factory.createImportDeclaration(
       /*modifiers*/
       void 0,
       factory.createImportClause(
-        needsTypeOnly(namespaceLikeImport),
+        shouldUseTypeOnly(namespaceLikeImport, preferences),
         /*name*/
         void 0,
         factory.createNamespaceImport(factory.createIdentifier(namespaceLikeImport.name))
@@ -157856,7 +158037,7 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
       if (!completionNodes.length) {
         modifiers = node.modifierFlagsCache | requiredModifiers;
       }
-      node = factory.updateModifiers(node, modifiers);
+      node = factory.replaceModifiers(node, modifiers);
       completionNodes.push(node);
     },
     body,
@@ -157882,11 +158063,11 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
       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 */;