typescript 5.5.0-dev.20240318 → 5.5.0-dev.20240319

package/lib/typescript.js

@@ -159,6 +159,7 @@ __export(typescript_exports, {
   SignatureCheckMode: () => SignatureCheckMode,
   SignatureFlags: () => SignatureFlags,
   SignatureHelp: () => ts_SignatureHelp_exports,
+  SignatureInfo: () => SignatureInfo,
   SignatureKind: () => SignatureKind,
   SmartSelectionRange: () => ts_SmartSelectionRange_exports,
   SnippetKind: () => SnippetKind,
@@ -2325,7 +2326,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240318`;
+var version = `${versionMajorMinor}.0-dev.20240319`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -38176,6 +38177,7 @@ var libEntries = [
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
   ["esnext.object", "lib.esnext.object.d.ts"],
+  ["esnext.regexp", "lib.esnext.regexp.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -52508,6 +52510,18 @@ function createTypeChecker(host) {
     return {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
       typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
+      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(
+        context,
+        type,
+        symbol,
+        enclosingDeclaration,
+        /*includePrivateSymbol*/
+        void 0,
+        /*bundled*/
+        void 0,
+        addUndefined
+      )),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -52529,6 +52543,50 @@ function createTypeChecker(host) {
       symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker, bundled) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context, bundled)),
       symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
+    function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
+      if (expr) {
+        const typeNode = isAssertionExpression(expr) ? expr.type : isJSDocTypeAssertion(expr) ? getJSDocTypeAssertionType(expr) : void 0;
+        if (typeNode && !isConstTypeReference(typeNode)) {
+          const result = tryReuseExistingTypeNode(context, typeNode, type, expr.parent, addUndefined);
+          if (result) {
+            return result;
+          }
+        }
+      }
+      if (addUndefined) {
+        type = getOptionalType(type);
+      }
+      return typeToTypeNodeHelper(type, context);
+    }
+    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined, includePrivateSymbol, bundled) {
+      const originalType = type;
+      if (addUndefined) {
+        type = getOptionalType(type);
+      }
+      const clone2 = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2, includePrivateSymbol, bundled);
+      if (clone2) {
+        if (addUndefined && !someType(getTypeFromTypeNode(typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
+          return factory.createUnionTypeNode([clone2, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
+        }
+        return clone2;
+      }
+      if (addUndefined && originalType !== type) {
+        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2, includePrivateSymbol, bundled);
+        if (cloneMissingUndefined) {
+          return factory.createUnionTypeNode([cloneMissingUndefined, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
+        }
+      }
+      return void 0;
+    }
+    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, includePrivateSymbol, bundled, annotationType) {
+      if (typeNodeIsEquivalentToType(existing, host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
+        const result = tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled);
+        if (result) {
+          return result;
+        }
+      }
+      return void 0;
+    }
     function symbolToNode(symbol, context, meaning) {
       if (context.flags & 1073741824 /* WriteComputedProps */) {
         if (symbol.valueDeclaration) {
@@ -52970,8 +53028,8 @@ function createTypeChecker(host) {
           if (isInstantiationExpressionType) {
             const instantiationExpressionType = type2;
             const existing = instantiationExpressionType.node;
-            if (isTypeQueryNode(existing) && getTypeFromTypeNode(existing) === type2) {
-              const typeNode = serializeExistingTypeNode(context, existing);
+            if (isTypeQueryNode(existing)) {
+              const typeNode = tryReuseExistingNonParameterTypeNode(context, existing, type2);
               if (typeNode) {
                 return typeNode;
               }
@@ -53777,11 +53835,9 @@ function createTypeChecker(host) {
     }
     function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
-      let parameterType = getTypeOfSymbol(parameterSymbol);
-      if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
-        parameterType = getOptionalType(parameterType);
-      }
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
+      const parameterType = getTypeOfSymbol(parameterSymbol);
+      const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports, addUndefined);
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
@@ -54371,16 +54427,15 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
+    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled, addUndefined) {
+      var _a;
       if (!isErrorType(type) && enclosingDeclaration) {
         const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
-            const result2 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
-            if (result2) {
-              return result2;
-            }
+          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined, includePrivateSymbol, bundled);
+          if (result2) {
+            return result2;
           }
         }
       }
@@ -54388,16 +54443,17 @@ function createTypeChecker(host) {
       if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) {
         context.flags |= 1048576 /* AllowUniqueESSymbolType */;
       }
-      const result = typeToTypeNodeHelper(type, context);
+      const decl = symbol.valueDeclaration ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
+      const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
+      const result = expressionOrTypeToTypeNode(context, expr, type, addUndefined);
       context.flags = oldFlags;
       return result;
     }
-    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type) {
-      const typeFromTypeNode = getTypeFromTypeNode(typeNode);
+    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type, typeFromTypeNode = getTypeFromTypeNode(typeNode)) {
       if (typeFromTypeNode === type) {
         return true;
       }
-      if (isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) {
+      if (annotatedDeclaration && (isParameter(annotatedDeclaration) || isPropertyDeclaration(annotatedDeclaration)) && annotatedDeclaration.questionToken) {
         return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode;
       }
       return false;
@@ -54409,11 +54465,9 @@ function createTypeChecker(host) {
         if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
           const annotated = getTypeFromTypeNode(annotation);
           const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
-          if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
-            const result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled);
-            if (result) {
-              return result;
-            }
+          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, includePrivateSymbol, bundled, thisInstantiated);
+          if (result) {
+            return result;
           }
         }
       }
@@ -54442,7 +54496,9 @@ function createTypeChecker(host) {
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
-          introducesError = true;
+          if (!isDeclarationName(node)) {
+            introducesError = true;
+          }
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, -1 /* All */);
           includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
@@ -54456,7 +54512,7 @@ function createTypeChecker(host) {
       }
       return { introducesError, node };
     }
-    function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
         cancellationToken.throwIfCancellationRequested();
       }
@@ -54580,6 +54636,31 @@ function createTypeChecker(host) {
             node.isTypeOf
           );
         }
+        if (isParameter(node)) {
+          if (!node.type && !node.initializer) {
+            return factory.updateParameterDeclaration(
+              node,
+              /*modifiers*/
+              void 0,
+              node.dotDotDotToken,
+              visitEachChild(
+                node.name,
+                visitExistingNodeTreeSymbols,
+                /*context*/
+                void 0
+              ),
+              node.questionToken,
+              factory.createKeywordTypeNode(133 /* AnyKeyword */),
+              /*initializer*/
+              void 0
+            );
+          }
+        }
+        if (isPropertySignature(node)) {
+          if (!node.type && !node.initializer) {
+            return factory.updatePropertySignature(node, node.modifiers, node.name, node.questionToken, factory.createKeywordTypeNode(133 /* AnyKeyword */));
+          }
+        }
         if (isEntityName(node) || isEntityNameExpression(node)) {
           const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
           hadError = hadError || introducesError;
@@ -54587,7 +54668,7 @@ function createTypeChecker(host) {
             return result;
           }
         }
-        if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
+        if (file && isTupleTypeNode(node) && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
           setEmitFlags(node, 1 /* SingleLine */);
         }
         return visitEachChild(
@@ -55111,7 +55192,15 @@ function createTypeChecker(host) {
         context.flags |= 8388608 /* InTypeAlias */;
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
-        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled) || typeToTypeNodeHelper(aliasType, context);
+        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && tryReuseExistingNonParameterTypeNode(
+          context,
+          jsdocAliasDecl.typeExpression.type,
+          aliasType,
+          /*host*/
+          void 0,
+          includePrivateSymbol,
+          bundled
+        ) || typeToTypeNodeHelper(aliasType, context);
         addResult(
           setSyntheticLeadingComments(
             factory.createTypeAliasDeclaration(
@@ -55344,7 +55433,15 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => serializeExistingTypeNode(context, a, includePrivateSymbol, bundled) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
+            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(
+              context,
+              a,
+              getTypeFromTypeNode(a),
+              /*host*/
+              void 0,
+              includePrivateSymbol,
+              bundled
+            ) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -55803,8 +55900,10 @@ function createTypeChecker(host) {
         }
       }
       function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) {
+        var _a2;
         const ctxSrc = getSourceFileOfNode(context.enclosingDeclaration);
-        return getObjectFlags(typeToSerialize) & (16 /* Anonymous */ | 32 /* Mapped */) && !length(getIndexInfosOfType(typeToSerialize)) && !isClassInstanceSide(typeToSerialize) && // While a class instance is potentially representable as a NS, prefer printing a reference to the instance type and serializing the class
+        return getObjectFlags(typeToSerialize) & (16 /* Anonymous */ | 32 /* Mapped */) && !some((_a2 = typeToSerialize.symbol) == null ? void 0 : _a2.declarations, isTypeNode) && // If the type comes straight from a type node, we shouldn't try to break it up
+        !length(getIndexInfosOfType(typeToSerialize)) && !isClassInstanceSide(typeToSerialize) && // While a class instance is potentially representable as a NS, prefer printing a reference to the instance type and serializing the class
         !!(length(filter(getPropertiesOfType(typeToSerialize), isNamespaceMember)) || length(getSignaturesOfType(typeToSerialize, 0 /* Call */))) && !length(getSignaturesOfType(typeToSerialize, 1 /* Construct */)) && // TODO: could probably serialize as function + ns + class, now that that's OK
         !getDeclarationWithTypeAnnotation(hostSymbol, enclosingDeclaration) && !(typeToSerialize.symbol && some(typeToSerialize.symbol.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && !some(getPropertiesOfType(typeToSerialize), (p) => isLateBoundName(p.escapedName)) && !some(getPropertiesOfType(typeToSerialize), (p) => some(p.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && every(getPropertiesOfType(typeToSerialize), (p) => {
           if (!isIdentifierText(symbolName(p), languageVersion)) {
@@ -59678,13 +59777,16 @@ function createTypeChecker(host) {
       const constraint = getConstraintTypeFromMappedType(type);
       if (constraint.flags & 4194304 /* Index */) {
         const baseConstraint = getBaseConstraintOfType(constraint.type);
-        if (baseConstraint && everyType(baseConstraint, isArrayOrTupleType)) {
+        if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
           return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
         }
       }
     }
     return type;
   }
+  function isArrayOrTupleOrIntersection(type) {
+    return !!(type.flags & 2097152 /* Intersection */) && every(type.types, isArrayOrTupleType);
+  }
   function isMappedTypeGenericIndexedAccess(type) {
     let objectType;
     return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
@@ -64076,29 +64178,28 @@ function createTypeChecker(host) {
     if (typeVariable) {
       const mappedTypeVariable = instantiateType(typeVariable, mapper);
       if (typeVariable !== mappedTypeVariable) {
-        return mapTypeWithAlias(
-          getReducedType(mappedTypeVariable),
-          (t) => {
-            if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
-              if (!type.declaration.nameType) {
-                let constraint;
-                if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
-                  return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
-                }
-                if (isTupleType(t)) {
-                  return instantiateMappedTupleType(t, type, typeVariable, mapper);
-                }
-              }
-              return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
-            }
-            return t;
-          },
-          aliasSymbol,
-          aliasTypeArguments
-        );
+        return mapTypeWithAlias(getReducedType(mappedTypeVariable), instantiateConstituent, aliasSymbol, aliasTypeArguments);
       }
     }
     return instantiateType(getConstraintTypeFromMappedType(type), mapper) === wildcardType ? wildcardType : instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments);
+    function instantiateConstituent(t) {
+      if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
+        if (!type.declaration.nameType) {
+          let constraint;
+          if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
+            return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
+          }
+          if (isTupleType(t)) {
+            return instantiateMappedTupleType(t, type, typeVariable, mapper);
+          }
+          if (isArrayOrTupleOrIntersection(t)) {
+            return getIntersectionType(map(t.types, instantiateConstituent));
+          }
+        }
+        return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
+      }
+      return t;
+    }
   }
   function getModifiedReadonlyState(state, modifiers) {
     return modifiers & 1 /* IncludeReadonly */ ? true : modifiers & 2 /* ExcludeReadonly */ ? false : state;
@@ -69001,7 +69102,9 @@ function createTypeChecker(host) {
     return false;
   }
   function inferTypesFromTemplateLiteralType(source, target) {
-    return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, getStringLikeTypeForType) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
+    return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, (s, i) => {
+      return isTypeAssignableTo(getBaseConstraintOrType(s), getBaseConstraintOrType(target.types[i])) ? s : getStringLikeTypeForType(s);
+    }) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
   }
   function isTypeMatchedByTemplateLiteralType(source, target) {
     const inferences = inferTypesFromTemplateLiteralType(source, target);
@@ -87634,14 +87737,34 @@ function createTypeChecker(host) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
-    let type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
-    if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol) {
-      flags |= 1048576 /* AllowUniqueESSymbolType */;
-    }
-    if (addUndefined) {
-      type = getOptionalType(type);
+    const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
+    return nodeBuilder.serializeTypeForDeclaration(type, symbol, addUndefined, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+  }
+  function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
+    return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
+  }
+  function getPossibleTypeNodeReuseExpression(declaration) {
+    var _a;
+    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarations((_a = getSymbolOfDeclaration(declaration.parent)) == null ? void 0 : _a.declarations, declaration.parent).getAccessor) : void 0;
+  }
+  function getSingleReturnExpression(declaration) {
+    let candidateExpr;
+    if (declaration && !nodeIsMissing(declaration.body)) {
+      const body = declaration.body;
+      if (body && isBlock(body)) {
+        forEachReturnStatement(body, (s) => {
+          if (!candidateExpr) {
+            candidateExpr = s.expression;
+          } else {
+            candidateExpr = void 0;
+            return true;
+          }
+        });
+      } else {
+        candidateExpr = body;
+      }
     }
-    return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return candidateExpr;
   }
   function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
     const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
@@ -87653,7 +87776,15 @@ function createTypeChecker(host) {
     if (typePredicate) {
       return nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
     }
-    return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.expressionOrTypeToTypeNode(
+      getPossibleTypeNodeReuseExpression(signatureDeclaration),
+      getReturnTypeOfSignature(signature),
+      /*addUndefined*/
+      void 0,
+      enclosingDeclaration,
+      flags | 1024 /* MultilineObjectLiterals */,
+      tracker
+    );
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
@@ -87661,7 +87792,15 @@ function createTypeChecker(host) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const type = getWidenedType(getRegularTypeOfExpression(expr));
-    return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.expressionOrTypeToTypeNode(
+      expr,
+      type,
+      /*addUndefined*/
+      void 0,
+      enclosingDeclaration,
+      flags | 1024 /* MultilineObjectLiterals */,
+      tracker
+    );
   }
   function hasGlobalName(name) {
     return globals.has(escapeLeadingUnderscores(name));
@@ -113368,10 +113507,10 @@ function transformDeclarations(context) {
             return newFile;
           }
           needsDeclare = true;
-          const updated2 = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
+          const updated = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
           return factory2.updateSourceFile(
             sourceFile,
-            transformAndReplaceLatePaintedStatements(updated2),
+            transformAndReplaceLatePaintedStatements(updated),
             /*isDeclarationFile*/
             true,
             /*referencedFiles*/
@@ -113435,7 +113574,7 @@ function transformDeclarations(context) {
         combinedStatements = setTextRange(factory2.createNodeArray([...combinedStatements, createEmptyExports(factory2)]), combinedStatements);
       }
     }
-    const updated = factory2.updateSourceFile(
+    return factory2.updateSourceFile(
       node,
       combinedStatements,
       /*isDeclarationFile*/
@@ -113445,8 +113584,6 @@ function transformDeclarations(context) {
       node.hasNoDefaultLib,
       getLibReferences()
     );
-    updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit;
-    return updated;
     function getLibReferences() {
       return arrayFrom(libs2.keys(), (lib) => ({ fileName: lib, pos: -1, end: -1 }));
     }
@@ -124816,6 +124953,12 @@ function getFileEmitOutput(program, sourceFile, emitOnlyDtsFiles, cancellationTo
     outputFiles.push({ name: fileName, writeByteOrderMark, text });
   }
 }
+var SignatureInfo = /* @__PURE__ */ ((SignatureInfo2) => {
+  SignatureInfo2[SignatureInfo2["ComputedDts"] = 0] = "ComputedDts";
+  SignatureInfo2[SignatureInfo2["StoredSignatureAtEmit"] = 1] = "StoredSignatureAtEmit";
+  SignatureInfo2[SignatureInfo2["UsedVersion"] = 2] = "UsedVersion";
+  return SignatureInfo2;
+})(SignatureInfo || {});
 var BuilderState;
 ((BuilderState2) => {
   function createManyToManyPathMap() {
@@ -124953,12 +125096,11 @@ var BuilderState;
   }
   BuilderState2.canReuseOldState = canReuseOldState;
   function create(newProgram, oldState, disableUseFileVersionAsSignature) {
-    var _a, _b, _c;
+    var _a, _b;
     const fileInfos = /* @__PURE__ */ new Map();
     const options = newProgram.getCompilerOptions();
     const isOutFile = options.outFile;
     const referencedMap = options.module !== 0 /* None */ && !isOutFile ? createManyToManyPathMap() : void 0;
-    const exportedModulesMap = referencedMap ? createManyToManyPathMap() : void 0;
     const useOldState = canReuseOldState(referencedMap, oldState);
     newProgram.getTypeChecker();
     for (const sourceFile of newProgram.getSourceFiles()) {
@@ -124970,13 +125112,6 @@ var BuilderState;
         if (newReferences) {
           referencedMap.set(sourceFile.resolvedPath, newReferences);
         }
-        if (useOldState) {
-          const oldUncommittedExportedModules = (_c = oldState.oldExportedModulesMap) == null ? void 0 : _c.get(sourceFile.resolvedPath);
-          const exportedModules = oldUncommittedExportedModules === void 0 ? oldState.exportedModulesMap.getValues(sourceFile.resolvedPath) : oldUncommittedExportedModules || void 0;
-          if (exportedModules) {
-            exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
-          }
-        }
       }
       fileInfos.set(sourceFile.resolvedPath, {
         version: version2,
@@ -124989,7 +125124,6 @@ var BuilderState;
     return {
       fileInfos,
       referencedMap,
-      exportedModulesMap,
       useFileVersionAsSignature: !disableUseFileVersionAsSignature && !useOldState
     };
   }
@@ -125000,7 +125134,7 @@ var BuilderState;
   }
   BuilderState2.releaseCache = releaseCache2;
   function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, host) {
-    var _a, _b;
+    var _a;
     const result = getFilesAffectedByWithOldState(
       state,
       programOfThisState,
@@ -125009,7 +125143,6 @@ var BuilderState;
       host
     );
     (_a = state.oldSignatures) == null ? void 0 : _a.clear();
-    (_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
     return result;
   }
   BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
@@ -125063,24 +125196,16 @@ var BuilderState;
     const prevSignature = info.signature;
     let latestSignature;
     if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
-      computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, (signature, sourceFiles) => {
+      computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, (signature) => {
         latestSignature = signature;
-        if (latestSignature !== prevSignature) {
-          updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
-        }
+        if (host.storeSignatureInfo)
+          (state.signatureInfo ?? (state.signatureInfo = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, 0 /* ComputedDts */);
       });
     }
     if (latestSignature === void 0) {
       latestSignature = sourceFile.version;
-      if (state.exportedModulesMap && latestSignature !== prevSignature) {
-        (state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
-        const references = state.referencedMap ? state.referencedMap.getValues(sourceFile.resolvedPath) : void 0;
-        if (references) {
-          state.exportedModulesMap.set(sourceFile.resolvedPath, references);
-        } else {
-          state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
-        }
-      }
+      if (host.storeSignatureInfo)
+        (state.signatureInfo ?? (state.signatureInfo = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, 2 /* UsedVersion */);
     }
     (state.oldSignatures || (state.oldSignatures = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, prevSignature || false);
     (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(sourceFile.resolvedPath);
@@ -125088,28 +125213,6 @@ var BuilderState;
     return latestSignature !== prevSignature;
   }
   BuilderState2.updateShapeSignature = updateShapeSignature;
-  function updateExportedModules(state, sourceFile, exportedModulesFromDeclarationEmit) {
-    if (!state.exportedModulesMap)
-      return;
-    (state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
-    const exportedModules = getExportedModules(exportedModulesFromDeclarationEmit);
-    if (exportedModules) {
-      state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
-    } else {
-      state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
-    }
-  }
-  BuilderState2.updateExportedModules = updateExportedModules;
-  function getExportedModules(exportedModulesFromDeclarationEmit) {
-    let exportedModules;
-    exportedModulesFromDeclarationEmit == null ? void 0 : exportedModulesFromDeclarationEmit.forEach(
-      (symbol) => getReferencedFilesFromImportedModuleSymbol(symbol).forEach(
-        (path) => (exportedModules ?? (exportedModules = /* @__PURE__ */ new Set())).add(path)
-      )
-    );
-    return exportedModules;
-  }
-  BuilderState2.getExportedModules = getExportedModules;
   function getAllDependencies(state, programOfThisState, sourceFile) {
     const compilerOptions = programOfThisState.getCompilerOptions();
     if (compilerOptions.outFile) {
@@ -125484,7 +125587,7 @@ function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) {
   Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath));
 }
 function getNextAffectedFile(state, cancellationToken, host) {
-  var _a, _b;
+  var _a;
   while (true) {
     const { affectedFiles } = state;
     if (affectedFiles) {
@@ -125508,7 +125611,6 @@ function getNextAffectedFile(state, cancellationToken, host) {
       state.changedFilesSet.delete(state.currentChangedFilePath);
       state.currentChangedFilePath = void 0;
       (_a = state.oldSignatures) == null ? void 0 : _a.clear();
-      (_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
       state.affectedFiles = void 0;
     }
     const nextKey = state.changedFilesSet.keys().next();
@@ -125669,7 +125771,7 @@ function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, hos
 }
 function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host) {
   var _a;
-  if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
+  if (!state.referencedMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
     return;
   if (!isChangedSignature(state, affectedFile.resolvedPath))
     return;
@@ -125692,7 +125794,7 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
     }
   }
   const seenFileAndExportsOfFile = /* @__PURE__ */ new Set();
-  (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _a.forEach((exportedFromPath) => {
+  (_a = state.referencedMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _a.forEach((exportedFromPath) => {
     if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, host))
       return true;
     const references = state.referencedMap.getKeys(exportedFromPath);
@@ -125706,27 +125808,17 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
   });
 }
 function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host) {
-  var _a, _b;
+  var _a;
   if (!tryAddToSet(seenFileAndExportsOfFile, filePath))
     return void 0;
   if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host))
     return true;
   handleDtsMayChangeOf(state, filePath, cancellationToken, host);
-  (_a = state.exportedModulesMap.getKeys(filePath)) == null ? void 0 : _a.forEach(
-    (exportedFromPath) => handleDtsMayChangeOfFileAndExportsOfFile(
-      state,
-      exportedFromPath,
-      seenFileAndExportsOfFile,
-      cancellationToken,
-      host
-    )
-  );
-  (_b = state.referencedMap.getKeys(filePath)) == null ? void 0 : _b.forEach(
-    (referencingFilePath) => !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file
-    handleDtsMayChangeOf(
-      // Dont add to seen since this is not yet done with the export removal
+  (_a = state.referencedMap.getKeys(filePath)) == null ? void 0 : _a.forEach(
+    (referencingFilePath) => handleDtsMayChangeOfFileAndExportsOfFile(
       state,
       referencingFilePath,
+      seenFileAndExportsOfFile,
       cancellationToken,
       host
     )
@@ -125841,18 +125933,6 @@ function getBuildInfo2(state) {
       toFileIdListId(state.referencedMap.getValues(key))
     ]);
   }
-  let exportedModulesMap;
-  if (state.exportedModulesMap) {
-    exportedModulesMap = mapDefined(arrayFrom(state.exportedModulesMap.keys()).sort(compareStringsCaseSensitive), (key) => {
-      var _a2;
-      const oldValue = (_a2 = state.oldExportedModulesMap) == null ? void 0 : _a2.get(key);
-      if (oldValue === void 0)
-        return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
-      if (oldValue)
-        return [toFileId(key), toFileIdListId(oldValue)];
-      return void 0;
-    });
-  }
   const semanticDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.semanticDiagnosticsPerFile);
   let affectedFilesPendingEmit;
   if ((_a = state.affectedFilesPendingEmit) == null ? void 0 : _a.size) {
@@ -125891,7 +125971,6 @@ function getBuildInfo2(state) {
     options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
     fileIdsList,
     referencedMap,
-    exportedModulesMap,
     semanticDiagnosticsPerFile,
     emitDiagnosticsPerFile,
     affectedFilesPendingEmit,
@@ -126211,7 +126290,7 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
     if (!getEmitDeclarations(state.compilerOptions))
       return writeFile2 || maybeBind(host, host.writeFile);
     return (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
-      var _a, _b, _c, _d;
+      var _a, _b, _c;
       if (isDeclarationFileName(fileName)) {
         if (!state.compilerOptions.outFile) {
           Debug.assert((sourceFiles == null ? void 0 : sourceFiles.length) === 1);
@@ -126230,10 +126309,8 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
               if (!((_a = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a.length))
                 emitSignature = signature;
               if (signature !== file.version) {
-                if (host.storeFilesChangingSignatureDuringEmit)
-                  (state.filesChangingSignature ?? (state.filesChangingSignature = /* @__PURE__ */ new Set())).add(file.resolvedPath);
-                if (state.exportedModulesMap)
-                  BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
+                if (host.storeSignatureInfo)
+                  (state.signatureInfo ?? (state.signatureInfo = /* @__PURE__ */ new Map())).set(file.resolvedPath, 1 /* StoredSignatureAtEmit */);
                 if (state.affectedFiles) {
                   const existing = (_b = state.oldSignatures) == null ? void 0 : _b.get(file.resolvedPath);
                   if (existing === void 0)
@@ -126241,14 +126318,13 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
                   info.signature = signature;
                 } else {
                   info.signature = signature;
-                  (_c = state.oldExportedModulesMap) == null ? void 0 : _c.clear();
                 }
               }
             }
           }
           if (state.compilerOptions.composite) {
             const filePath = sourceFiles[0].resolvedPath;
-            emitSignature = handleNewSignature((_d = state.emitSignatures) == null ? void 0 : _d.get(filePath), emitSignature);
+            emitSignature = handleNewSignature((_c = state.emitSignatures) == null ? void 0 : _c.get(filePath), emitSignature);
             if (!emitSignature)
               return;
             (state.emitSignatures ?? (state.emitSignatures = /* @__PURE__ */ new Map())).set(filePath, emitSignature);
@@ -126440,7 +126516,6 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
       fileInfos,
       compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
       referencedMap: toManyToManyPathMap(program.referencedMap),
-      exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
       semanticDiagnosticsPerFile: toPerFileDiagnostics(program.semanticDiagnosticsPerFile),
       emitDiagnosticsPerFile: toPerFileDiagnostics(program.emitDiagnosticsPerFile),
       hasReusableDiagnostic: true,
@@ -128110,7 +128185,7 @@ function createCompilerHostFromProgramHost(host, getCompilerOptions, directorySt
     getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
     createHash: maybeBind(host, host.createHash),
     readDirectory: maybeBind(host, host.readDirectory),
-    storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
+    storeSignatureInfo: host.storeSignatureInfo,
     jsDocParsingMode: host.jsDocParsingMode
   };
   return compilerHost;
@@ -128177,7 +128252,7 @@ function createProgramHost(system, createProgram2) {
     writeFile: (path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
     createHash: maybeBind(system, system.createHash),
     createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
-    storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
+    storeSignatureInfo: system.storeSignatureInfo,
     now: maybeBind(system, system.now)
   };
 }
@@ -128283,7 +128358,7 @@ function createIncrementalCompilerHost(options, system = sys) {
     system
   );
   host.createHash = maybeBind(system, system.createHash);
-  host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
+  host.storeSignatureInfo = system.storeSignatureInfo;
   setGetSourceFileAsHashVersioned(host);
   changeCompilerHostLikeToUseCache(host, (fileName) => toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName));
   return host;
@@ -139133,15 +139208,25 @@ registerRefactor(refactorName3, {
     extractToTypeDefAction.kind
   ],
   getAvailableActions: function getRefactorActionsToExtractType(context) {
-    const info = getRangeToExtract(context, context.triggerReason === "invoked");
+    const { info, affectedTextRange } = getRangeToExtract(context, context.triggerReason === "invoked");
     if (!info)
       return emptyArray;
     if (!isRefactorErrorInfo(info)) {
-      return [{
+      const refactorInfo = [{
         name: refactorName3,
         description: getLocaleSpecificMessage(Diagnostics.Extract_type),
         actions: info.isJS ? [extractToTypeDefAction] : append([extractToTypeAliasAction], info.typeElements && extractToInterfaceAction)
       }];
+      return refactorInfo.map((info2) => ({
+        ...info2,
+        actions: info2.actions.map((action) => ({
+          ...action,
+          range: affectedTextRange ? {
+            start: { line: getLineAndCharacterOfPosition(context.file, affectedTextRange.pos).line, offset: getLineAndCharacterOfPosition(context.file, affectedTextRange.pos).character },
+            end: { line: getLineAndCharacterOfPosition(context.file, affectedTextRange.end).line, offset: getLineAndCharacterOfPosition(context.file, affectedTextRange.end).character }
+          } : void 0
+        }))
+      }));
     }
     if (context.preferences.provideRefactorNotApplicableReason) {
       return [{
@@ -139158,7 +139243,7 @@ registerRefactor(refactorName3, {
   },
   getEditsForAction: function getRefactorEditsToExtractType(context, actionName2) {
     const { file } = context;
-    const info = getRangeToExtract(context);
+    const { info } = getRangeToExtract(context);
     Debug.assert(info && !isRefactorErrorInfo(info), "Expected to find a range to extract");
     const name = getUniqueName("NewType", file);
     const edits = ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
@@ -139194,14 +139279,14 @@ function getRangeToExtract(context, considerEmptySpans = true) {
   const isCursorRequest = range.pos === range.end && considerEmptySpans;
   const firstType = getFirstTypeAt(file, startPosition, range, isCursorRequest);
   if (!firstType || !isTypeNode(firstType))
-    return { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) };
+    return { info: { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) }, affectedTextRange: void 0 };
   const checker = context.program.getTypeChecker();
   const enclosingNode = getEnclosingNode(firstType, isJS);
   if (enclosingNode === void 0)
-    return { error: getLocaleSpecificMessage(Diagnostics.No_type_could_be_extracted_from_this_type_node) };
+    return { info: { error: getLocaleSpecificMessage(Diagnostics.No_type_could_be_extracted_from_this_type_node) }, affectedTextRange: void 0 };
   const expandedFirstType = getExpandedSelectionNode(firstType, enclosingNode);
   if (!isTypeNode(expandedFirstType))
-    return { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) };
+    return { info: { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) }, affectedTextRange: void 0 };
   const typeList = [];
   if ((isUnionTypeNode(expandedFirstType.parent) || isIntersectionTypeNode(expandedFirstType.parent)) && range.end > firstType.end) {
     addRange(
@@ -139212,11 +139297,11 @@ function getRangeToExtract(context, considerEmptySpans = true) {
     );
   }
   const selection = typeList.length > 1 ? typeList : expandedFirstType;
-  const typeParameters = collectTypeParameters(checker, selection, enclosingNode, file);
+  const { typeParameters, affectedTextRange } = collectTypeParameters(checker, selection, enclosingNode, file);
   if (!typeParameters)
-    return { error: getLocaleSpecificMessage(Diagnostics.No_type_could_be_extracted_from_this_type_node) };
+    return { info: { error: getLocaleSpecificMessage(Diagnostics.No_type_could_be_extracted_from_this_type_node) }, affectedTextRange: void 0 };
   const typeElements = flattenTypeLiteralNodeReference(checker, selection);
-  return { isJS, selection, enclosingNode, typeParameters, typeElements };
+  return { info: { isJS, selection, enclosingNode, typeParameters, typeElements }, affectedTextRange };
 }
 function getFirstTypeAt(file, startPosition, range, isCursorRequest) {
   const currentNodes = [
@@ -139270,12 +139355,12 @@ function rangeContainsSkipTrivia(r1, node, file) {
 function collectTypeParameters(checker, selection, enclosingNode, file) {
   const result = [];
   const selectionArray = toArray(selection);
-  const selectionRange = { pos: selectionArray[0].pos, end: selectionArray[selectionArray.length - 1].end };
+  const selectionRange = { pos: selectionArray[0].getStart(file), end: selectionArray[selectionArray.length - 1].end };
   for (const t of selectionArray) {
     if (visitor(t))
-      return void 0;
+      return { typeParameters: void 0, affectedTextRange: void 0 };
   }
-  return result;
+  return { typeParameters: result, affectedTextRange: selectionRange };
   function visitor(node) {
     if (isTypeReferenceNode(node)) {
       if (isIdentifier(node.typeName)) {
@@ -139641,7 +139726,12 @@ registerRefactor(refactorName5, {
   getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
     const statements = getStatementsToMove(context);
     if (context.preferences.allowTextChangesInNewFiles && statements) {
-      return [{ name: refactorName5, description, actions: [moveToNewFileAction] }];
+      const file = context.file;
+      const affectedTextRange = {
+        start: { line: getLineAndCharacterOfPosition(file, statements.all[0].getStart(file)).line, offset: getLineAndCharacterOfPosition(file, statements.all[0].getStart(file)).character },
+        end: { line: getLineAndCharacterOfPosition(file, last(statements.all).end).line, offset: getLineAndCharacterOfPosition(file, last(statements.all).end).character }
+      };
+      return [{ name: refactorName5, description, actions: [{ ...moveToNewFileAction, range: affectedTextRange }] }];
     }
     if (context.preferences.provideRefactorNotApplicableReason) {
       return [{ name: refactorName5, description, actions: [{ ...moveToNewFileAction, notApplicableReason: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_statement_or_statements) }] }];
@@ -139747,12 +139837,12 @@ var moveToFileAction = {
 registerRefactor(refactorNameForMoveToFile, {
   kinds: [moveToFileAction.kind],
   getAvailableActions: function getRefactorActionsToMoveToFile(context, interactiveRefactorArguments) {
+    const file = context.file;
     const statements = getStatementsToMove(context);
     if (!interactiveRefactorArguments) {
       return emptyArray;
     }
     if (context.endPosition !== void 0) {
-      const file = context.file;
       const startNodeAncestor = findAncestor(getTokenAtPosition(file, context.startPosition), isBlockLike);
       const endNodeAncestor = findAncestor(getTokenAtPosition(file, context.endPosition), isBlockLike);
       if (startNodeAncestor && !isSourceFile(startNodeAncestor) && endNodeAncestor && !isSourceFile(endNodeAncestor)) {
@@ -139760,7 +139850,11 @@ registerRefactor(refactorNameForMoveToFile, {
       }
     }
     if (context.preferences.allowTextChangesInNewFiles && statements) {
-      return [{ name: refactorNameForMoveToFile, description: description2, actions: [moveToFileAction] }];
+      const affectedTextRange = {
+        start: { line: getLineAndCharacterOfPosition(file, statements.all[0].getStart(file)).line, offset: getLineAndCharacterOfPosition(file, statements.all[0].getStart(file)).character },
+        end: { line: getLineAndCharacterOfPosition(file, last(statements.all).end).line, offset: getLineAndCharacterOfPosition(file, last(statements.all).end).character }
+      };
+      return [{ name: refactorNameForMoveToFile, description: description2, actions: [{ ...moveToFileAction, range: affectedTextRange }] }];
     }
     if (context.preferences.provideRefactorNotApplicableReason) {
       return [{ name: refactorNameForMoveToFile, description: description2, actions: [{ ...moveToFileAction, notApplicableReason: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_statement_or_statements) }] }];
@@ -142318,7 +142412,7 @@ function getRefactorActionsToExtractSymbol(context) {
     }
     return errors;
   }
-  const extractions = getPossibleExtractions(targetRange, context);
+  const { affectedTextRange, extractions } = getPossibleExtractions(targetRange, context);
   if (extractions === void 0) {
     return emptyArray;
   }
@@ -142338,7 +142432,11 @@ function getRefactorActionsToExtractSymbol(context) {
           functionActions.push({
             description: description3,
             name: `function_scope_${i}`,
-            kind: extractFunctionAction.kind
+            kind: extractFunctionAction.kind,
+            range: {
+              start: { line: getLineAndCharacterOfPosition(context.file, affectedTextRange.pos).line, offset: getLineAndCharacterOfPosition(context.file, affectedTextRange.pos).character },
+              end: { line: getLineAndCharacterOfPosition(context.file, affectedTextRange.end).line, offset: getLineAndCharacterOfPosition(context.file, affectedTextRange.end).character }
+            }
           });
         }
       } else if (!innermostErrorFunctionAction) {
@@ -142358,7 +142456,11 @@ function getRefactorActionsToExtractSymbol(context) {
           constantActions.push({
             description: description3,
             name: `constant_scope_${i}`,
-            kind: extractConstantAction.kind
+            kind: extractConstantAction.kind,
+            range: {
+              start: { line: getLineAndCharacterOfPosition(context.file, affectedTextRange.pos).line, offset: getLineAndCharacterOfPosition(context.file, affectedTextRange.pos).character },
+              end: { line: getLineAndCharacterOfPosition(context.file, affectedTextRange.end).line, offset: getLineAndCharacterOfPosition(context.file, affectedTextRange.end).character }
+            }
           });
         }
       } else if (!innermostErrorConstantAction) {
@@ -142797,7 +142899,7 @@ function getConstantExtractionAtIndex(targetRange, context, requestedChangesInde
   return extractConstantInScope(expression, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], targetRange.facts, context);
 }
 function getPossibleExtractions(targetRange, context) {
-  const { scopes, readsAndWrites: { functionErrorsPerScope, constantErrorsPerScope } } = getPossibleExtractionsWorker(targetRange, context);
+  const { scopes, affectedTextRange, readsAndWrites: { functionErrorsPerScope, constantErrorsPerScope } } = getPossibleExtractionsWorker(targetRange, context);
   const extractions = scopes.map((scope, i) => {
     const functionDescriptionPart = getDescriptionForFunctionInScope(scope);
     const constantDescriptionPart = getDescriptionForConstantInScope(scope);
@@ -142828,7 +142930,7 @@ function getPossibleExtractions(targetRange, context) {
       }
     };
   });
-  return extractions;
+  return { affectedTextRange, extractions };
 }
 function getPossibleExtractionsWorker(targetRange, context) {
   const { file: sourceFile } = context;
@@ -142842,7 +142944,7 @@ function getPossibleExtractionsWorker(targetRange, context) {
     context.program.getTypeChecker(),
     context.cancellationToken
   );
-  return { scopes, readsAndWrites };
+  return { scopes, affectedTextRange: enclosingTextRange, readsAndWrites };
 }
 function getDescriptionForFunctionInScope(scope) {
   return isFunctionLikeDeclaration(scope) ? "inner function" : isClassLike(scope) ? "method" : "function";
@@ -173559,6 +173661,7 @@ __export(ts_exports2, {
   SignatureCheckMode: () => SignatureCheckMode,
   SignatureFlags: () => SignatureFlags,
   SignatureHelp: () => ts_SignatureHelp_exports,
+  SignatureInfo: () => SignatureInfo,
   SignatureKind: () => SignatureKind,
   SmartSelectionRange: () => ts_SmartSelectionRange_exports,
   SnippetKind: () => SnippetKind,
@@ -186056,7 +186159,8 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
   getApplicableRefactors(args) {
     const { file, project } = this.getFileAndProject(args);
     const scriptInfo = project.getScriptInfoForNormalizedPath(file);
-    return project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind, args.includeInteractiveActions);
+    const result = project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind, args.includeInteractiveActions);
+    return result.map((result2) => ({ ...result2, actions: result2.actions.map((action) => ({ ...action, range: action.range ? { start: convertToLocation({ line: action.range.start.line, character: action.range.start.offset }), end: convertToLocation({ line: action.range.end.line, character: action.range.end.offset }) } : void 0 })) }));
   }
   getEditsForRefactor(args, simplifiedResult) {
     const { file, project } = this.getFileAndProject(args);
@@ -187759,6 +187863,7 @@ if (typeof console !== "undefined") {
   SignatureCheckMode,
   SignatureFlags,
   SignatureHelp,
+  SignatureInfo,
   SignatureKind,
   SmartSelectionRange,
   SnippetKind,