typescript 5.9.0-dev.20250414 → 5.9.0-dev.20250416

package/lib/typescript.js

@@ -2285,7 +2285,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.9";
-var version = `${versionMajorMinor}.0-dev.20250414`;
+var version = `${versionMajorMinor}.0-dev.20250416`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -24109,6 +24109,82 @@ function getOptionsSyntaxByValue(optionsObject, name, value) {
 function forEachOptionsSyntaxByName(optionsObject, name, callback) {
   return forEachPropertyAssignment(optionsObject, name, callback);
 }
+function getSynthesizedDeepClone(node, includeTrivia = true) {
+  const clone2 = node && getSynthesizedDeepCloneWorker(node);
+  if (clone2 && !includeTrivia) suppressLeadingAndTrailingTrivia(clone2);
+  return setParentRecursive(
+    clone2,
+    /*incremental*/
+    false
+  );
+}
+function getSynthesizedDeepCloneWithReplacements(node, includeTrivia, replaceNode) {
+  let clone2 = replaceNode(node);
+  if (clone2) {
+    setOriginalNode(clone2, node);
+  } else {
+    clone2 = getSynthesizedDeepCloneWorker(node, replaceNode);
+  }
+  if (clone2 && !includeTrivia) suppressLeadingAndTrailingTrivia(clone2);
+  return clone2;
+}
+function getSynthesizedDeepCloneWorker(node, replaceNode) {
+  const nodeClone = replaceNode ? (n) => getSynthesizedDeepCloneWithReplacements(
+    n,
+    /*includeTrivia*/
+    true,
+    replaceNode
+  ) : getSynthesizedDeepClone;
+  const nodesClone = replaceNode ? (ns) => ns && getSynthesizedDeepClonesWithReplacements(
+    ns,
+    /*includeTrivia*/
+    true,
+    replaceNode
+  ) : (ns) => ns && getSynthesizedDeepClones(ns);
+  const visited = visitEachChild(
+    node,
+    nodeClone,
+    /*context*/
+    void 0,
+    nodesClone,
+    nodeClone
+  );
+  if (visited === node) {
+    const clone2 = isStringLiteral(node) ? setOriginalNode(factory.createStringLiteralFromNode(node), node) : isNumericLiteral(node) ? setOriginalNode(factory.createNumericLiteral(node.text, node.numericLiteralFlags), node) : factory.cloneNode(node);
+    return setTextRange(clone2, node);
+  }
+  visited.parent = void 0;
+  return visited;
+}
+function getSynthesizedDeepClones(nodes, includeTrivia = true) {
+  if (nodes) {
+    const cloned = factory.createNodeArray(nodes.map((n) => getSynthesizedDeepClone(n, includeTrivia)), nodes.hasTrailingComma);
+    setTextRange(cloned, nodes);
+    return cloned;
+  }
+  return nodes;
+}
+function getSynthesizedDeepClonesWithReplacements(nodes, includeTrivia, replaceNode) {
+  return factory.createNodeArray(nodes.map((n) => getSynthesizedDeepCloneWithReplacements(n, includeTrivia, replaceNode)), nodes.hasTrailingComma);
+}
+function suppressLeadingAndTrailingTrivia(node) {
+  suppressLeadingTrivia(node);
+  suppressTrailingTrivia(node);
+}
+function suppressLeadingTrivia(node) {
+  addEmitFlagsRecursively(node, 1024 /* NoLeadingComments */, getFirstChild);
+}
+function suppressTrailingTrivia(node) {
+  addEmitFlagsRecursively(node, 2048 /* NoTrailingComments */, getLastChild);
+}
+function addEmitFlagsRecursively(node, flag, getChild) {
+  addEmitFlags(node, flag);
+  const child = getChild(node);
+  if (child) addEmitFlagsRecursively(child, flag, getChild);
+}
+function getFirstChild(node) {
+  return forEachChild(node, (child) => child);
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -50986,11 +51062,11 @@ function createTypeChecker(host) {
     typePredicateToString: (predicate, enclosingDeclaration, flags) => {
       return typePredicateToString(predicate, getParseTreeNode(enclosingDeclaration), flags);
     },
-    writeSignature: (signature, enclosingDeclaration, flags, kind, writer) => {
-      return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer);
+    writeSignature: (signature, enclosingDeclaration, flags, kind, writer, verbosityLevel, out) => {
+      return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer, verbosityLevel, out);
     },
-    writeType: (type, enclosingDeclaration, flags, writer) => {
-      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer);
+    writeType: (type, enclosingDeclaration, flags, writer, verbosityLevel, out) => {
+      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer, verbosityLevel, out);
     },
     writeSymbol: (symbol, enclosingDeclaration, meaning, flags, writer) => {
       return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
@@ -51224,7 +51300,8 @@ function createTypeChecker(host) {
     isTypeParameterPossiblyReferenced,
     typeHasCallOrConstructSignatures,
     getSymbolFlags,
-    getTypeArgumentsForResolvedSignature
+    getTypeArgumentsForResolvedSignature,
+    isLibType
   };
   function getTypeArgumentsForResolvedSignature(signature) {
     if (signature.mapper === void 0) return void 0;
@@ -54901,7 +54978,7 @@ function createTypeChecker(host) {
       return writer2;
     }
   }
-  function signatureToString(signature, enclosingDeclaration, flags = 0 /* None */, kind, writer) {
+  function signatureToString(signature, enclosingDeclaration, flags = 0 /* None */, kind, writer, verbosityLevel, out) {
     return writer ? signatureToStringWorker(writer).getText() : usingSingleLineStringWriter(signatureToStringWorker);
     function signatureToStringWorker(writer2) {
       let sigOutput;
@@ -54910,7 +54987,18 @@ function createTypeChecker(host) {
       } else {
         sigOutput = kind === 1 /* Construct */ ? 180 /* ConstructSignature */ : 179 /* CallSignature */;
       }
-      const sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */);
+      const sig = nodeBuilder.signatureToSignatureDeclaration(
+        signature,
+        sigOutput,
+        enclosingDeclaration,
+        toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */,
+        /*internalFlags*/
+        void 0,
+        /*tracker*/
+        void 0,
+        verbosityLevel,
+        out
+      );
       const printer = createPrinterWithRemoveCommentsOmitTrailingSemicolon();
       const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
       printer.writeNode(
@@ -54923,14 +55011,18 @@ function createTypeChecker(host) {
       return writer2;
     }
   }
-  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
+  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter(""), verbosityLevel, out) {
     const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
     const typeNode = nodeBuilder.typeToTypeNode(
       type,
       enclosingDeclaration,
-      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0 /* None */),
+      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0),
       /*internalFlags*/
-      void 0
+      void 0,
+      /*tracker*/
+      void 0,
+      verbosityLevel,
+      out
     );
     if (typeNode === void 0) return Debug.fail("should always get typenode");
     const printer = type !== unresolvedType ? createPrinterWithRemoveComments() : createPrinterWithDefaults();
@@ -55161,31 +55253,120 @@ function createTypeChecker(host) {
     };
     return {
       syntacticBuilderResolver,
-      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)),
-      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
-        indexInfo,
-        context,
-        /*typeNode*/
-        void 0
-      )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
-        symbol,
-        context,
-        meaning,
-        /*expectsIdentifier*/
-        false
-      )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeToTypeNodeHelper(type, context), out),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)
+      ),
+      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)
+      ),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)
+      ),
+      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)
+      ),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => indexInfoToIndexSignatureDeclarationHelper(
+          indexInfo,
+          context,
+          /*typeNode*/
+          void 0
+        )
+      ),
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => signatureToSignatureDeclarationHelper(signature, kind, context), out),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToName(
+          symbol,
+          context,
+          meaning,
+          /*expectsIdentifier*/
+          false
+        )
+      ),
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToExpression(symbol, context, meaning)
+      ),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => typeParametersToTypeParameterDeclarations(symbol, context)
+      ),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToParameterDeclaration(symbol, context)
+      ),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeParameterToDeclaration(parameter, context), out),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolTableToDeclarationStatements(symbolTable, context)
+      ),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToNode(symbol, context, meaning)
+      ),
+      symbolToDeclarations
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -55227,7 +55408,75 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext2(enclosingDeclaration, flags, internalFlags, tracker, cb) {
+    function symbolToDeclarations(symbol, meaning, flags, verbosityLevel, out) {
+      const nodes = withContext2(
+        /*enclosingDeclaration*/
+        void 0,
+        flags,
+        /*internalFlags*/
+        void 0,
+        /*tracker*/
+        void 0,
+        verbosityLevel,
+        (context) => symbolToDeclarationsWorker(symbol, context),
+        out
+      );
+      return mapDefined(nodes, (node) => {
+        switch (node.kind) {
+          case 263 /* ClassDeclaration */:
+            return simplifyClassDeclaration(node, symbol);
+          case 266 /* EnumDeclaration */:
+            return simplifyModifiers(node, isEnumDeclaration, symbol);
+          case 264 /* InterfaceDeclaration */:
+            return simplifyInterfaceDeclaration(node, symbol, meaning);
+          case 267 /* ModuleDeclaration */:
+            return simplifyModifiers(node, isModuleDeclaration, symbol);
+          default:
+            return void 0;
+        }
+      });
+    }
+    function simplifyClassDeclaration(classDecl, symbol) {
+      const classDeclarations = filter(symbol.declarations, isClassLike);
+      const originalClassDecl = classDeclarations && classDeclarations.length > 0 ? classDeclarations[0] : classDecl;
+      const modifiers = getEffectiveModifierFlags(originalClassDecl) & ~(32 /* Export */ | 128 /* Ambient */);
+      const isAnonymous = isClassExpression(originalClassDecl);
+      if (isAnonymous) {
+        classDecl = factory.updateClassDeclaration(
+          classDecl,
+          classDecl.modifiers,
+          /*name*/
+          void 0,
+          classDecl.typeParameters,
+          classDecl.heritageClauses,
+          classDecl.members
+        );
+      }
+      return factory.replaceModifiers(classDecl, modifiers);
+    }
+    function simplifyModifiers(newDecl, isDeclKind, symbol) {
+      const decls = filter(symbol.declarations, isDeclKind);
+      const declWithModifiers = decls && decls.length > 0 ? decls[0] : newDecl;
+      const modifiers = getEffectiveModifierFlags(declWithModifiers) & ~(32 /* Export */ | 128 /* Ambient */);
+      return factory.replaceModifiers(newDecl, modifiers);
+    }
+    function simplifyInterfaceDeclaration(interfaceDecl, symbol, meaning) {
+      if (!(meaning & 64 /* Interface */)) {
+        return void 0;
+      }
+      return simplifyModifiers(interfaceDecl, isInterfaceDeclaration, symbol);
+    }
+    function symbolToDeclarationsWorker(symbol, context) {
+      const type = getDeclaredTypeOfSymbol(symbol);
+      context.typeStack.push(type.id);
+      context.typeStack.push(-1);
+      const table = createSymbolTable([symbol]);
+      const statements = symbolTableToDeclarationStatements(table, context);
+      context.typeStack.pop();
+      context.typeStack.pop();
+      return statements;
+    }
+    function withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, cb, out) {
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : (internalFlags || 0 /* None */) & 4 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
@@ -55235,6 +55484,7 @@ function createTypeChecker(host) {
         flags: flags || 0 /* None */,
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
+        maxExpansionDepth: verbosityLevel ?? -1,
         encounteredError: false,
         suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
@@ -55256,13 +55506,23 @@ function createTypeChecker(host) {
         typeParameterNamesByText: void 0,
         typeParameterNamesByTextNextNameCount: void 0,
         enclosingSymbolTypes: /* @__PURE__ */ new Map(),
-        mapper: void 0
+        mapper: void 0,
+        depth: 0,
+        typeStack: [],
+        out: {
+          canIncreaseExpansionDepth: false,
+          truncated: false
+        }
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
       if (context.truncating && context.flags & 1 /* NoTruncation */) {
         context.tracker.reportTruncationError();
       }
+      if (out) {
+        out.canIncreaseExpansionDepth = context.out.canIncreaseExpansionDepth;
+        out.truncated = context.out.truncated;
+      }
       return context.encounteredError ? void 0 : resultingNode;
     }
     function addSymbolTypeToContext(context, symbol, type) {
@@ -55281,19 +55541,49 @@ function createTypeChecker(host) {
     function saveRestoreFlags(context) {
       const flags = context.flags;
       const internalFlags = context.internalFlags;
+      const depth = context.depth;
       return restore;
       function restore() {
         context.flags = flags;
         context.internalFlags = internalFlags;
+        context.depth = depth;
       }
     }
+    function checkTruncationLengthIfExpanding(context) {
+      return context.maxExpansionDepth >= 0 && checkTruncationLength(context);
+    }
     function checkTruncationLength(context) {
       if (context.truncating) return context.truncating;
       return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
     }
+    function canPossiblyExpandType(type, context) {
+      for (let i = 0; i < context.typeStack.length - 1; i++) {
+        if (context.typeStack[i] === type.id) {
+          return false;
+        }
+      }
+      return context.depth < context.maxExpansionDepth || context.depth === context.maxExpansionDepth && !context.out.canIncreaseExpansionDepth;
+    }
+    function shouldExpandType(type, context, isAlias = false) {
+      if (!isAlias && isLibType(type)) {
+        return false;
+      }
+      for (let i = 0; i < context.typeStack.length - 1; i++) {
+        if (context.typeStack[i] === type.id) {
+          return false;
+        }
+      }
+      const result = context.depth < context.maxExpansionDepth;
+      if (!result) {
+        context.out.canIncreaseExpansionDepth = true;
+      }
+      return result;
+    }
     function typeToTypeNodeHelper(type, context) {
       const restoreFlags = saveRestoreFlags(context);
+      if (type) context.typeStack.push(type.id);
       const typeNode = typeToTypeNodeWorker(type, context);
+      if (type) context.typeStack.pop();
       restoreFlags();
       return typeNode;
     }
@@ -55304,6 +55594,7 @@ function createTypeChecker(host) {
       }
       const inTypeAlias = context.flags & 8388608 /* InTypeAlias */;
       context.flags &= ~8388608 /* InTypeAlias */;
+      let expandingEnum = false;
       if (!type) {
         if (!(context.flags & 262144 /* AllowEmptyUnionOrIntersection */)) {
           context.encounteredError = true;
@@ -55371,7 +55662,11 @@ function createTypeChecker(host) {
             return Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
           }
         }
-        return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
+        if (!shouldExpandType(type, context)) {
+          return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
+        } else {
+          expandingEnum = true;
+        }
       }
       if (type.flags & 128 /* StringLiteral */) {
         context.approximateLength += type.value.length + 2;
@@ -55438,16 +55733,34 @@ function createTypeChecker(host) {
         return factory.createThisTypeNode();
       }
       if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */ || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
-        const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
-        if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */)) return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
-        if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
-          return factory.createArrayTypeNode(typeArgumentNodes[0]);
+        if (!shouldExpandType(
+          type,
+          context,
+          /*isAlias*/
+          true
+        )) {
+          const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
+          if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */)) return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
+          if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
+            return factory.createArrayTypeNode(typeArgumentNodes[0]);
+          }
+          return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
         }
-        return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
+        context.depth += 1;
       }
       const objectFlags = getObjectFlags(type);
       if (objectFlags & 4 /* Reference */) {
         Debug.assert(!!(type.flags & 524288 /* Object */));
+        if (shouldExpandType(type, context)) {
+          context.depth += 1;
+          return createAnonymousTypeNode(
+            type,
+            /*forceClassExpansion*/
+            true,
+            /*forceExpansion*/
+            true
+          );
+        }
         return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
       }
       if (type.flags & 262144 /* TypeParameter */ || objectFlags & 3 /* ClassOrInterface */) {
@@ -55477,6 +55790,16 @@ function createTypeChecker(host) {
             void 0
           );
         }
+        if (objectFlags & 3 /* ClassOrInterface */ && shouldExpandType(type, context)) {
+          context.depth += 1;
+          return createAnonymousTypeNode(
+            type,
+            /*forceClassExpansion*/
+            true,
+            /*forceExpansion*/
+            true
+          );
+        }
         if (type.symbol) {
           return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
         }
@@ -55491,7 +55814,7 @@ function createTypeChecker(host) {
         type = type.origin;
       }
       if (type.flags & (1048576 /* Union */ | 2097152 /* Intersection */)) {
-        const types = type.flags & 1048576 /* Union */ ? formatUnionTypes(type.types) : type.types;
+        const types = type.flags & 1048576 /* Union */ ? formatUnionTypes(type.types, expandingEnum) : type.types;
         if (length(types) === 1) {
           return typeToTypeNodeHelper(types[0], context);
         }
@@ -55680,7 +56003,7 @@ function createTypeChecker(host) {
         }
         return result;
       }
-      function createAnonymousTypeNode(type2) {
+      function createAnonymousTypeNode(type2, forceClassExpansion = false, forceExpansion = false) {
         var _a2, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
@@ -55703,15 +56026,20 @@ function createTypeChecker(host) {
           const isInstanceType = isClassInstanceSide(type2) ? 788968 /* Type */ : 111551 /* Value */;
           if (isJSConstructor(symbol.valueDeclaration)) {
             return symbolToTypeNode(symbol, context, isInstanceType);
-          } else if (symbol.flags & 32 /* Class */ && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
+          } else if (!forceExpansion && (symbol.flags & 32 /* Class */ && !forceClassExpansion && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
             symbol,
             context.enclosingDeclaration,
             isInstanceType,
             /*shouldComputeAliasesToMakeVisible*/
             false
-          ).accessibility !== 0 /* Accessible */)) || symbol.flags & (384 /* Enum */ | 512 /* ValueModule */) || shouldWriteTypeOfFunctionSymbol()) {
-            return symbolToTypeNode(symbol, context, isInstanceType);
-          } else if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
+          ).accessibility !== 0 /* Accessible */)) || symbol.flags & (384 /* Enum */ | 512 /* ValueModule */) || shouldWriteTypeOfFunctionSymbol())) {
+            if (shouldExpandType(type2, context)) {
+              context.depth += 1;
+            } else {
+              return symbolToTypeNode(symbol, context, isInstanceType);
+            }
+          }
+          if ((_b2 = context.visitedTypes) == null ? void 0 : _b2.has(typeId)) {
             const typeAlias = getTypeAliasForTypeLiteral(type2);
             if (typeAlias) {
               return symbolToTypeNode(typeAlias, context, 788968 /* Type */);
@@ -55747,7 +56075,7 @@ function createTypeChecker(host) {
         if (id && !context.symbolDepth) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
-        const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
+        const links = context.maxExpansionDepth >= 0 ? void 0 : context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
         const key = `${getTypeId(type2)}|${context.flags}|${context.internalFlags}`;
         if (links) {
           links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
@@ -56064,6 +56392,7 @@ function createTypeChecker(host) {
       }
       function createTypeNodesFromResolvedType(resolvedType) {
         if (checkTruncationLength(context)) {
+          context.out.truncated = true;
           if (context.flags & 1 /* NoTruncation */) {
             return [addSyntheticTrailingComment(factory.createNotEmittedTypeElement(), 3 /* MultiLineCommentTrivia */, "elided")];
           }
@@ -56077,6 +56406,7 @@ function createTypeChecker(host) {
             void 0
           )];
         }
+        context.typeStack.push(-1);
         const typeElements = [];
         for (const signature of resolvedType.callSignatures) {
           typeElements.push(signatureToSignatureDeclarationHelper(signature, 179 /* CallSignature */, context));
@@ -56090,10 +56420,14 @@ function createTypeChecker(host) {
         }
         const properties = resolvedType.properties;
         if (!properties) {
+          context.typeStack.pop();
           return typeElements;
         }
         let i = 0;
         for (const propertySymbol of properties) {
+          if (isExpanding(context) && propertySymbol.flags & 4194304 /* Prototype */) {
+            continue;
+          }
           i++;
           if (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */) {
             if (propertySymbol.flags & 4194304 /* Prototype */) {
@@ -56104,6 +56438,7 @@ function createTypeChecker(host) {
             }
           }
           if (checkTruncationLength(context) && i + 2 < properties.length - 1) {
+            context.out.truncated = true;
             if (context.flags & 1 /* NoTruncation */) {
               const typeElement = typeElements.pop();
               typeElements.push(addSyntheticTrailingComment(typeElement, 3 /* MultiLineCommentTrivia */, `... ${properties.length - i} more elided ...`));
@@ -56123,6 +56458,7 @@ function createTypeChecker(host) {
           }
           addPropertyToElementList(propertySymbol, context, typeElements);
         }
+        context.typeStack.pop();
         return typeElements.length ? typeElements : void 0;
       }
     }
@@ -56271,6 +56607,7 @@ function createTypeChecker(host) {
     function mapToTypeNodes(types, context, isBareList) {
       if (some(types)) {
         if (checkTruncationLength(context)) {
+          context.out.truncated = true;
           if (!isBareList) {
             return [
               context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "elided") : factory.createTypeReferenceNode(
@@ -56298,6 +56635,7 @@ function createTypeChecker(host) {
         for (const type of types) {
           i++;
           if (checkTruncationLength(context) && i + 2 < types.length - 1) {
+            context.out.truncated = true;
             result.push(
               context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, `... ${types.length - i} more elided ...`) : factory.createTypeReferenceNode(
                 `... ${types.length - i} more ...`,
@@ -56695,7 +57033,7 @@ function createTypeChecker(host) {
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
-      return typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
+      return !canPossiblyExpandType(type, context) && typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
     }
     function typeParameterToDeclaration(type, context, constraint = getConstraintOfTypeParameter(type)) {
       const constraintNode = constraint && typeToTypeNodeHelperWithPossibleReusableTypeNode(constraint, getConstraintDeclaration(type), context);
@@ -57214,12 +57552,15 @@ function createTypeChecker(host) {
         }
         let firstChar = symbolName2.charCodeAt(0);
         if (isSingleOrDoubleQuote(firstChar) && some(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
-          return factory.createStringLiteral(getSpecifierForModuleSymbol(symbol2, context));
+          const specifier = getSpecifierForModuleSymbol(symbol2, context);
+          context.approximateLength += 2 + specifier.length;
+          return factory.createStringLiteral(specifier);
         }
         if (index === 0 || canUsePropertyAccess(symbolName2, languageVersion)) {
           const identifier = setEmitFlags(factory.createIdentifier(symbolName2), 16777216 /* NoAsciiEscaping */);
           if (typeParameterNodes) setIdentifierTypeArguments(identifier, factory.createNodeArray(typeParameterNodes));
           identifier.symbol = symbol2;
+          context.approximateLength += 1 + symbolName2.length;
           return index > 0 ? factory.createPropertyAccessExpression(createExpressionFromSymbolChain(chain2, index - 1), identifier) : identifier;
         } else {
           if (firstChar === 91 /* openBracket */) {
@@ -57228,16 +57569,21 @@ function createTypeChecker(host) {
           }
           let expression;
           if (isSingleOrDoubleQuote(firstChar) && !(symbol2.flags & 8 /* EnumMember */)) {
-            expression = factory.createStringLiteral(stripQuotes(symbolName2).replace(/\\./g, (s) => s.substring(1)), firstChar === 39 /* singleQuote */);
+            const literalText = stripQuotes(symbolName2).replace(/\\./g, (s) => s.substring(1));
+            context.approximateLength += literalText.length + 2;
+            expression = factory.createStringLiteral(literalText, firstChar === 39 /* singleQuote */);
           } else if ("" + +symbolName2 === symbolName2) {
+            context.approximateLength += symbolName2.length;
             expression = factory.createNumericLiteral(+symbolName2);
           }
           if (!expression) {
             const identifier = setEmitFlags(factory.createIdentifier(symbolName2), 16777216 /* NoAsciiEscaping */);
             if (typeParameterNodes) setIdentifierTypeArguments(identifier, factory.createNodeArray(typeParameterNodes));
             identifier.symbol = symbol2;
+            context.approximateLength += symbolName2.length;
             expression = identifier;
           }
+          context.approximateLength += 2;
           return factory.createElementAccessExpression(createExpressionFromSymbolChain(chain2, index - 1), expression);
         }
       }
@@ -57266,6 +57612,10 @@ function createTypeChecker(host) {
       ), "'")));
     }
     function getPropertyNameNodeForSymbol(symbol, context) {
+      const hashPrivateName = getClonedHashPrivateName(symbol);
+      if (hashPrivateName) {
+        return hashPrivateName;
+      }
       const stringNamed = !!length(symbol.declarations) && every(symbol.declarations, isStringNamed);
       const singleQuote = !!length(symbol.declarations) && every(symbol.declarations, isSingleQuotedStringNamed);
       const isMethod = !!(symbol.flags & 8192 /* Method */);
@@ -57342,7 +57692,7 @@ function createTypeChecker(host) {
       let result;
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
       const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
-      if (decl) {
+      if (!canPossiblyExpandType(type, context) && decl) {
         const restore = addSymbolTypeToContext(context, symbol, type);
         if (isAccessor(decl)) {
           result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
@@ -57381,7 +57731,7 @@ function createTypeChecker(host) {
       let returnTypeNode;
       const returnType = getReturnTypeOfSignature(signature);
       if (!(suppressAny && isTypeAny(returnType))) {
-        if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+        if (signature.declaration && !nodeIsSynthesized(signature.declaration) && !canPossiblyExpandType(returnType, context)) {
           const declarationSymbol = getSymbolOfDeclaration(signature.declaration);
           const restore = addSymbolTypeToContext(context, declarationSymbol, returnType);
           returnTypeNode = syntacticNodeBuilder.serializeReturnTypeForSignature(signature.declaration, declarationSymbol, context);
@@ -57792,14 +58142,28 @@ function createTypeChecker(host) {
         if (!suppressNewPrivateContext) {
           deferredPrivatesStack.push(/* @__PURE__ */ new Map());
         }
-        symbolTable2.forEach((symbol) => {
+        let i = 0;
+        const symbols = Array.from(symbolTable2.values());
+        for (const symbol of symbols) {
+          i++;
+          if (checkTruncationLengthIfExpanding(context) && i + 2 < symbolTable2.size - 1) {
+            context.out.truncated = true;
+            results.push(createTruncationStatement(`... (${symbolTable2.size - i} more ...)`));
+            serializeSymbol(
+              symbols[symbols.length - 1],
+              /*isPrivate*/
+              false,
+              !!propertyAsAlias
+            );
+            break;
+          }
           serializeSymbol(
             symbol,
             /*isPrivate*/
             false,
             !!propertyAsAlias
           );
-        });
+        }
         if (!suppressNewPrivateContext) {
           deferredPrivatesStack[deferredPrivatesStack.length - 1].forEach((symbol) => {
             serializeSymbol(
@@ -57829,7 +58193,7 @@ function createTypeChecker(host) {
         }
       }
       function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias, escapedSymbolName = symbol.escapedName) {
-        var _a2, _b, _c, _d, _e, _f;
+        var _a2, _b, _c, _d, _e, _f, _g;
         const symbolName2 = unescapeLeadingUnderscores(escapedSymbolName);
         const isDefault = escapedSymbolName === "default" /* Default */;
         if (isPrivate && !(context.flags & 131072 /* AllowAnonymousIdentifier */) && isStringANonContextualKeyword(symbolName2) && !isDefault) {
@@ -57879,6 +58243,7 @@ function createTypeChecker(host) {
               const propertyAccessRequire = (_e = symbol.declarations) == null ? void 0 : _e.find(isPropertyAccessExpression);
               if (propertyAccessRequire && isBinaryExpression(propertyAccessRequire.parent) && isIdentifier(propertyAccessRequire.parent.right) && ((_f = type.symbol) == null ? void 0 : _f.valueDeclaration) && isSourceFile(type.symbol.valueDeclaration)) {
                 const alias = localName === propertyAccessRequire.parent.right.escapedText ? void 0 : propertyAccessRequire.parent.right;
+                context.approximateLength += 12 + (((_g = alias == null ? void 0 : alias.escapedText) == null ? void 0 : _g.length) ?? 0);
                 addResult(
                   factory.createExportDeclaration(
                     /*modifiers*/
@@ -57918,8 +58283,10 @@ function createTypeChecker(host) {
                   ),
                   textRange
                 );
+                context.approximateLength += 7 + name.length;
                 addResult(statement, name !== localName ? modifierFlags & ~32 /* Export */ : modifierFlags);
                 if (name !== localName && !isPrivate) {
+                  context.approximateLength += 16 + name.length + localName.length;
                   addResult(
                     factory.createExportDeclaration(
                       /*modifiers*/
@@ -57969,27 +58336,33 @@ function createTypeChecker(host) {
             for (const node of symbol.declarations) {
               const resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
               if (!resolvedModule) continue;
+              const isTypeOnly = node.isTypeOnly;
+              const specifier = getSpecifierForModuleSymbol(resolvedModule, context);
+              context.approximateLength += 17 + specifier.length;
               addResult(factory.createExportDeclaration(
                 /*modifiers*/
                 void 0,
-                /*isTypeOnly*/
-                node.isTypeOnly,
+                isTypeOnly,
                 /*exportClause*/
                 void 0,
-                factory.createStringLiteral(getSpecifierForModuleSymbol(resolvedModule, context))
+                factory.createStringLiteral(specifier)
               ), 0 /* None */);
             }
           }
         }
         if (needsPostExportDefault) {
+          const internalSymbolName = getInternalSymbolName(symbol, symbolName2);
+          context.approximateLength += 16 + internalSymbolName.length;
           addResult(factory.createExportAssignment(
             /*modifiers*/
             void 0,
             /*isExportEquals*/
             false,
-            factory.createIdentifier(getInternalSymbolName(symbol, symbolName2))
+            factory.createIdentifier(internalSymbolName)
           ), 0 /* None */);
         } else if (needsExportDeclaration) {
+          const internalSymbolName = getInternalSymbolName(symbol, symbolName2);
+          context.approximateLength += 22 + symbolName2.length + internalSymbolName.length;
           addResult(
             factory.createExportDeclaration(
               /*modifiers*/
@@ -57999,7 +58372,7 @@ function createTypeChecker(host) {
               factory.createNamedExports([factory.createExportSpecifier(
                 /*isTypeOnly*/
                 false,
-                getInternalSymbolName(symbol, symbolName2),
+                internalSymbolName,
                 symbolName2
               )])
             ),
@@ -58019,6 +58392,7 @@ function createTypeChecker(host) {
       }
       function addResult(node, additionalModifierFlags) {
         if (canHaveModifiers(node)) {
+          const oldModifierFlags = getEffectiveModifierFlags(node);
           let newModifierFlags = 0 /* None */;
           const enclosingDeclaration2 = context.enclosingDeclaration && (isJSDocTypeAlias(context.enclosingDeclaration) ? getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
           if (additionalModifierFlags & 32 /* Export */ && enclosingDeclaration2 && (isExportingScope(enclosingDeclaration2) || isModuleDeclaration(enclosingDeclaration2)) && canHaveExportModifier(node)) {
@@ -58031,8 +58405,9 @@ function createTypeChecker(host) {
             newModifierFlags |= 2048 /* Default */;
           }
           if (newModifierFlags) {
-            node = factory.replaceModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
+            node = factory.replaceModifiers(node, newModifierFlags | oldModifierFlags);
           }
+          context.approximateLength += modifiersLength(newModifierFlags | oldModifierFlags);
         }
         results.push(node);
       }
@@ -58048,12 +58423,14 @@ function createTypeChecker(host) {
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
         const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && syntacticNodeBuilder.tryReuseExistingTypeNode(context, jsdocAliasDecl.typeExpression.type) || typeToTypeNodeHelper(aliasType, context);
+        const internalSymbolName = getInternalSymbolName(symbol, symbolName2);
+        context.approximateLength += 8 + ((commentText == null ? void 0 : commentText.length) ?? 0) + internalSymbolName.length;
         addResult(
           setSyntheticLeadingComments(
             factory.createTypeAliasDeclaration(
               /*modifiers*/
               void 0,
-              getInternalSymbolName(symbol, symbolName2),
+              internalSymbolName,
               typeParamDecls,
               typeNode
             ),
@@ -58065,12 +58442,19 @@ function createTypeChecker(host) {
         context.enclosingDeclaration = oldEnclosingDecl;
       }
       function serializeInterface(symbol, symbolName2, modifierFlags) {
+        const internalSymbolName = getInternalSymbolName(symbol, symbolName2);
+        context.approximateLength += 14 + internalSymbolName.length;
         const interfaceType = getDeclaredTypeOfClassOrInterface(symbol);
         const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
         const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
         const baseTypes = getBaseTypes(interfaceType);
         const baseType = length(baseTypes) ? getIntersectionType(baseTypes) : void 0;
-        const members = flatMap(getPropertiesOfType(interfaceType), (p) => serializePropertySymbolForInterface(p, baseType));
+        const members = serializePropertySymbolsForClassOrInterface(
+          getPropertiesOfType(interfaceType),
+          /*isClass*/
+          false,
+          baseType
+        );
         const callSignatures = serializeSignatures(0 /* Call */, interfaceType, baseType, 179 /* CallSignature */);
         const constructSignatures = serializeSignatures(1 /* Construct */, interfaceType, baseType, 180 /* ConstructSignature */);
         const indexSignatures = serializeIndexSignatures(interfaceType, baseType);
@@ -58079,7 +58463,7 @@ function createTypeChecker(host) {
           factory.createInterfaceDeclaration(
             /*modifiers*/
             void 0,
-            getInternalSymbolName(symbol, symbolName2),
+            internalSymbolName,
             typeParamDecls,
             heritageClauses,
             [...indexSignatures, ...constructSignatures, ...callSignatures, ...members]
@@ -58087,6 +58471,57 @@ function createTypeChecker(host) {
           modifierFlags
         );
       }
+      function serializePropertySymbolsForClassOrInterface(props, isClass, baseType, isStatic2) {
+        const elements = [];
+        let i = 0;
+        for (const prop of props) {
+          i++;
+          if (checkTruncationLengthIfExpanding(context) && i + 2 < props.length - 1) {
+            context.out.truncated = true;
+            const placeholder = createTruncationProperty(`... ${props.length - i} more ... `, isClass);
+            elements.push(placeholder);
+            const result2 = isClass ? serializePropertySymbolForClass(props[props.length - 1], isStatic2, baseType) : serializePropertySymbolForInterface(props[props.length - 1], baseType);
+            if (isArray(result2)) {
+              elements.push(...result2);
+            } else {
+              elements.push(result2);
+            }
+            break;
+          }
+          context.approximateLength += 1;
+          const result = isClass ? serializePropertySymbolForClass(prop, isStatic2, baseType) : serializePropertySymbolForInterface(prop, baseType);
+          if (isArray(result)) {
+            elements.push(...result);
+          } else {
+            elements.push(result);
+          }
+        }
+        return elements;
+      }
+      function createTruncationProperty(dotDotDotText, isClass) {
+        if (context.flags & 1 /* NoTruncation */) {
+          return addSyntheticLeadingComment(factory.createNotEmittedTypeElement(), 3 /* MultiLineCommentTrivia */, dotDotDotText);
+        }
+        return isClass ? factory.createPropertyDeclaration(
+          /*modifiers*/
+          void 0,
+          dotDotDotText,
+          /*questionOrExclamationToken*/
+          void 0,
+          /*type*/
+          void 0,
+          /*initializer*/
+          void 0
+        ) : factory.createPropertySignature(
+          /*modifiers*/
+          void 0,
+          dotDotDotText,
+          /*questionToken*/
+          void 0,
+          /*type*/
+          void 0
+        );
+      }
       function getNamespaceMembersForSerialization(symbol) {
         let exports2 = arrayFrom(getExportsOfSymbol(symbol).values());
         const merged = getMergedSymbol(symbol);
@@ -58106,11 +58541,27 @@ function createTypeChecker(host) {
       }
       function serializeModule(symbol, symbolName2, modifierFlags) {
         const members = getNamespaceMembersForSerialization(symbol);
-        const locationMap = arrayToMultiMap(members, (m) => m.parent && m.parent === symbol ? "real" : "merged");
+        const expanding = isExpanding(context);
+        const locationMap = arrayToMultiMap(members, (m) => m.parent && m.parent === symbol || expanding ? "real" : "merged");
         const realMembers = locationMap.get("real") || emptyArray;
         const mergedMembers = locationMap.get("merged") || emptyArray;
-        if (length(realMembers)) {
-          const localName = getInternalSymbolName(symbol, symbolName2);
+        if (length(realMembers) || expanding) {
+          let localName;
+          if (expanding) {
+            const oldFlags = context.flags;
+            context.flags |= 512 /* WriteTypeParametersInQualifiedName */ | 2 /* UseOnlyExternalAliasing */;
+            localName = symbolToNode(
+              symbol,
+              context,
+              /*meaning*/
+              -1 /* All */
+            );
+            context.flags = oldFlags;
+          } else {
+            const localText = getInternalSymbolName(symbol, symbolName2);
+            localName = factory.createIdentifier(localText);
+            context.approximateLength += localText.length;
+          }
           serializeAsNamespaceDeclaration(realMembers, localName, modifierFlags, !!(symbol.flags & (16 /* Function */ | 67108864 /* Assignment */)));
         }
         if (length(mergedMembers)) {
@@ -58158,17 +58609,51 @@ function createTypeChecker(host) {
         }
       }
       function serializeEnum(symbol, symbolName2, modifierFlags) {
+        const internalSymbolName = getInternalSymbolName(symbol, symbolName2);
+        context.approximateLength += 9 + internalSymbolName.length;
+        const members = [];
+        const memberProps = filter(getPropertiesOfType(getTypeOfSymbol(symbol)), (p) => !!(p.flags & 8 /* EnumMember */));
+        let i = 0;
+        for (const p of memberProps) {
+          i++;
+          if (checkTruncationLengthIfExpanding(context) && i + 2 < memberProps.length - 1) {
+            context.out.truncated = true;
+            members.push(factory.createEnumMember(` ... ${memberProps.length - i} more ... `));
+            const last2 = memberProps[memberProps.length - 1];
+            const initializedValue = last2.declarations && last2.declarations[0] && isEnumMember(last2.declarations[0]) ? getConstantValue2(last2.declarations[0]) : void 0;
+            const initializer2 = initializedValue === void 0 ? void 0 : typeof initializedValue === "string" ? factory.createStringLiteral(initializedValue) : factory.createNumericLiteral(initializedValue);
+            const memberName2 = unescapeLeadingUnderscores(last2.escapedName);
+            const member2 = factory.createEnumMember(
+              memberName2,
+              initializer2
+            );
+            members.push(member2);
+            break;
+          }
+          const memberDecl = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) ? p.declarations[0] : void 0;
+          let initializer;
+          let initializerLength;
+          if (isExpanding(context) && memberDecl && memberDecl.initializer) {
+            initializer = getSynthesizedDeepClone(memberDecl.initializer);
+            initializerLength = memberDecl.initializer.end - memberDecl.initializer.pos;
+          } else {
+            const initializedValue = memberDecl && getConstantValue2(memberDecl);
+            initializer = initializedValue === void 0 ? void 0 : typeof initializedValue === "string" ? factory.createStringLiteral(initializedValue) : factory.createNumericLiteral(initializedValue);
+            initializerLength = (initializer == null ? void 0 : initializer.text.length) ?? 0;
+          }
+          const memberName = unescapeLeadingUnderscores(p.escapedName);
+          context.approximateLength += 4 + memberName.length + initializerLength;
+          const member = factory.createEnumMember(
+            memberName,
+            initializer
+          );
+          members.push(member);
+        }
         addResult(
           factory.createEnumDeclaration(
             factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 4096 /* Const */ : 0),
-            getInternalSymbolName(symbol, symbolName2),
-            map(filter(getPropertiesOfType(getTypeOfSymbol(symbol)), (p) => !!(p.flags & 8 /* EnumMember */)), (p) => {
-              const initializedValue = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) ? getConstantValue2(p.declarations[0]) : void 0;
-              return factory.createEnumMember(
-                unescapeLeadingUnderscores(p.escapedName),
-                initializedValue === void 0 ? void 0 : typeof initializedValue === "string" ? factory.createStringLiteral(initializedValue) : factory.createNumericLiteral(initializedValue)
-              );
-            })
+            internalSymbolName,
+            members
           ),
           modifierFlags
         );
@@ -58176,20 +58661,28 @@ function createTypeChecker(host) {
       function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
         const signatures = getSignaturesOfType(type, 0 /* Call */);
         for (const sig of signatures) {
+          context.approximateLength += 1;
           const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName) });
           addResult(setTextRange2(context, decl, getSignatureTextRangeLocation(sig)), modifierFlags);
         }
         if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
           const props = filter(getPropertiesOfType(type), isNamespaceMember);
+          context.approximateLength += localName.length;
           serializeAsNamespaceDeclaration(
             props,
-            localName,
+            factory.createIdentifier(localName),
             modifierFlags,
             /*suppressNewPrivateContext*/
             true
           );
         }
       }
+      function createTruncationStatement(dotDotDotText) {
+        if (context.flags & 1 /* NoTruncation */) {
+          return addSyntheticLeadingComment(factory.createEmptyStatement(), 3 /* MultiLineCommentTrivia */, dotDotDotText);
+        }
+        return factory.createExpressionStatement(factory.createIdentifier(dotDotDotText));
+      }
       function getSignatureTextRangeLocation(signature) {
         if (signature.declaration && signature.declaration.parent) {
           if (isBinaryExpression(signature.declaration.parent) && getAssignmentDeclarationKind(signature.declaration.parent) === 5 /* Property */) {
@@ -58202,15 +58695,18 @@ function createTypeChecker(host) {
         return signature.declaration;
       }
       function serializeAsNamespaceDeclaration(props, localName, modifierFlags, suppressNewPrivateContext) {
+        const nodeFlags = isIdentifier(localName) ? 32 /* Namespace */ : 0 /* None */;
+        const expanding = isExpanding(context);
         if (length(props)) {
-          const localVsRemoteMap = arrayToMultiMap(props, (p) => !length(p.declarations) || some(p.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)) ? "local" : "remote");
+          context.approximateLength += 14;
+          const localVsRemoteMap = arrayToMultiMap(props, (p) => !length(p.declarations) || some(p.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)) || expanding ? "local" : "remote");
           const localProps = localVsRemoteMap.get("local") || emptyArray;
           let fakespace = parseNodeFactory.createModuleDeclaration(
             /*modifiers*/
             void 0,
-            factory.createIdentifier(localName),
+            localName,
             factory.createModuleBlock([]),
-            32 /* Namespace */
+            nodeFlags
           );
           setParent(fakespace, enclosingDeclaration);
           fakespace.locals = createSymbolTable(props);
@@ -58252,6 +58748,18 @@ function createTypeChecker(host) {
             factory.createModuleBlock(exportModifierStripped)
           );
           addResult(fakespace, modifierFlags);
+        } else if (expanding) {
+          context.approximateLength += 14;
+          addResult(
+            factory.createModuleDeclaration(
+              /*modifiers*/
+              void 0,
+              localName,
+              factory.createModuleBlock([]),
+              nodeFlags
+            ),
+            modifierFlags
+          );
         }
       }
       function isNamespaceMember(p) {
@@ -58294,11 +58802,13 @@ function createTypeChecker(host) {
       }
       function serializeAsClass(symbol, localName, modifierFlags) {
         var _a2, _b;
+        context.approximateLength += 9 + localName.length;
         const originalDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isClassLike);
         const oldEnclosing = context.enclosingDeclaration;
         context.enclosingDeclaration = originalDecl || oldEnclosing;
         const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
         const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
+        forEach(localParams, (p) => context.approximateLength += symbolName(p.symbol).length);
         const classType = getTypeWithThisArgument(getDeclaredTypeOfClassOrInterface(symbol));
         const baseTypes = getBaseTypes(classType);
         const originalImplements = originalDecl && getEffectiveImplementsTypeNodes(originalDecl);
@@ -58306,20 +58816,22 @@ function createTypeChecker(host) {
         const staticType = getTypeOfSymbol(symbol);
         const isClass = !!((_b = staticType.symbol) == null ? void 0 : _b.valueDeclaration) && isClassLike(staticType.symbol.valueDeclaration);
         const staticBaseType = isClass ? getBaseConstructorTypeOfClass(staticType) : anyType;
+        context.approximateLength += (length(baseTypes) ? 8 : 0) + (length(implementsExpressions) ? 11 : 0);
         const heritageClauses = [
           ...!length(baseTypes) ? [] : [factory.createHeritageClause(96 /* ExtendsKeyword */, map(baseTypes, (b) => serializeBaseType(b, staticBaseType, localName)))],
           ...!length(implementsExpressions) ? [] : [factory.createHeritageClause(119 /* ImplementsKeyword */, implementsExpressions)]
         ];
         const symbolProps = getNonInheritedProperties(classType, baseTypes, getPropertiesOfType(classType));
-        const publicSymbolProps = filter(symbolProps, (s) => {
-          const valueDecl = s.valueDeclaration;
-          return !!valueDecl && !(isNamedDeclaration(valueDecl) && isPrivateIdentifier(valueDecl.name));
-        });
-        const hasPrivateIdentifier = some(symbolProps, (s) => {
-          const valueDecl = s.valueDeclaration;
-          return !!valueDecl && isNamedDeclaration(valueDecl) && isPrivateIdentifier(valueDecl.name);
-        });
-        const privateProperties = hasPrivateIdentifier ? [factory.createPropertyDeclaration(
+        const publicSymbolProps = filter(symbolProps, (s) => !isHashPrivate(s));
+        const hasPrivateIdentifier = some(symbolProps, isHashPrivate);
+        const privateProperties = hasPrivateIdentifier ? isExpanding(context) ? serializePropertySymbolsForClassOrInterface(
+          filter(symbolProps, isHashPrivate),
+          /*isClass*/
+          true,
+          baseTypes[0],
+          /*isStatic*/
+          false
+        ) : [factory.createPropertyDeclaration(
           /*modifiers*/
           void 0,
           factory.createPrivateIdentifier("#private"),
@@ -58330,22 +58842,27 @@ function createTypeChecker(host) {
           /*initializer*/
           void 0
         )] : emptyArray;
-        const publicProperties = flatMap(publicSymbolProps, (p) => serializePropertySymbolForClass(
-          p,
+        if (hasPrivateIdentifier && !isExpanding(context)) {
+          context.approximateLength += 9;
+        }
+        const publicProperties = serializePropertySymbolsForClassOrInterface(
+          publicSymbolProps,
+          /*isClass*/
+          true,
+          baseTypes[0],
           /*isStatic*/
-          false,
-          baseTypes[0]
-        ));
-        const staticMembers = flatMap(
+          false
+        );
+        const staticMembers = serializePropertySymbolsForClassOrInterface(
           filter(getPropertiesOfType(staticType), (p) => !(p.flags & 4194304 /* Prototype */) && p.escapedName !== "prototype" && !isNamespaceMember(p)),
-          (p) => serializePropertySymbolForClass(
-            p,
-            /*isStatic*/
-            true,
-            staticBaseType
-          )
+          /*isClass*/
+          true,
+          staticBaseType,
+          /*isStatic*/
+          true
         );
         const isNonConstructableClassLikeInJsFile = !isClass && !!symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && !some(getSignaturesOfType(staticType, 1 /* Construct */));
+        if (isNonConstructableClassLikeInJsFile) context.approximateLength += 21;
         const constructors = isNonConstructableClassLikeInJsFile ? [factory.createConstructorDeclaration(
           factory.createModifiersFromModifierFlags(2 /* Private */),
           [],
@@ -58413,6 +58930,8 @@ function createTypeChecker(host) {
             if (((_b = (_a2 = node.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.kind) === 260 /* VariableDeclaration */) {
               const specifier2 = getSpecifierForModuleSymbol(target.parent || target, context);
               const { propertyName } = node;
+              const propertyNameText = propertyName && isIdentifier(propertyName) ? idText(propertyName) : void 0;
+              context.approximateLength += 24 + localName.length + specifier2.length + ((propertyNameText == null ? void 0 : propertyNameText.length) ?? 0);
               addResult(
                 factory.createImportDeclaration(
                   /*modifiers*/
@@ -58425,7 +58944,7 @@ function createTypeChecker(host) {
                     factory.createNamedImports([factory.createImportSpecifier(
                       /*isTypeOnly*/
                       false,
-                      propertyName && isIdentifier(propertyName) ? factory.createIdentifier(idText(propertyName)) : void 0,
+                      propertyNameText ? factory.createIdentifier(propertyNameText) : void 0,
                       factory.createIdentifier(localName)
                     )])
                   ),
@@ -58452,6 +58971,7 @@ function createTypeChecker(host) {
               const initializer = node.initializer;
               const uniqueName = factory.createUniqueName(localName);
               const specifier2 = getSpecifierForModuleSymbol(target.parent || target, context);
+              context.approximateLength += 22 + specifier2.length + idText(uniqueName).length;
               addResult(
                 factory.createImportEqualsDeclaration(
                   /*modifiers*/
@@ -58463,6 +58983,7 @@ function createTypeChecker(host) {
                 ),
                 0 /* None */
               );
+              context.approximateLength += 12 + localName.length + idText(uniqueName).length + idText(initializer.name).length;
               addResult(
                 factory.createImportEqualsDeclaration(
                   /*modifiers*/
@@ -58483,6 +59004,7 @@ function createTypeChecker(host) {
               break;
             }
             const isLocalImport = !(target.flags & 512 /* ValueModule */) && !isVariableDeclaration(node);
+            context.approximateLength += 11 + localName.length + unescapeLeadingUnderscores(target.escapedName).length;
             addResult(
               factory.createImportEqualsDeclaration(
                 /*modifiers*/
@@ -58509,6 +59031,7 @@ function createTypeChecker(host) {
             const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
             const attributes = isImportDeclaration(node.parent) ? node.parent.attributes : void 0;
             const isTypeOnly = isJSDocImportTag(node.parent);
+            context.approximateLength += 14 + localName.length + 3 + (isTypeOnly ? 4 : 0);
             addResult(
               factory.createImportDeclaration(
                 /*modifiers*/
@@ -58530,6 +59053,7 @@ function createTypeChecker(host) {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
             const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent);
+            context.approximateLength += 19 + localName.length + 3 + (isTypeOnly ? 4 : 0);
             addResult(
               factory.createImportDeclaration(
                 /*modifiers*/
@@ -58548,6 +59072,7 @@ function createTypeChecker(host) {
             break;
           }
           case 280 /* NamespaceExport */:
+            context.approximateLength += 19 + localName.length + 3;
             addResult(
               factory.createExportDeclaration(
                 /*modifiers*/
@@ -58564,6 +59089,7 @@ function createTypeChecker(host) {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
             const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent.parent);
+            context.approximateLength += 19 + localName.length + 3 + (isTypeOnly ? 4 : 0);
             addResult(
               factory.createImportDeclaration(
                 /*modifiers*/
@@ -58619,6 +59145,7 @@ function createTypeChecker(host) {
         }
       }
       function serializeExportSpecifier(localName, targetName, specifier) {
+        context.approximateLength += 16 + localName.length + (localName !== targetName ? targetName.length : 0);
         addResult(
           factory.createExportDeclaration(
             /*modifiers*/
@@ -58669,6 +59196,7 @@ function createTypeChecker(host) {
           const prevDisableTrackSymbol = context.tracker.disableTrackSymbol;
           context.tracker.disableTrackSymbol = true;
           if (isExportAssignmentCompatibleSymbolName) {
+            context.approximateLength += 10;
             results.push(factory.createExportAssignment(
               /*modifiers*/
               void 0,
@@ -58682,6 +59210,7 @@ function createTypeChecker(host) {
               serializeExportSpecifier(name, getInternalSymbolName(target, symbolName(target)));
             } else {
               const varName = getUnusedName(name, symbol);
+              context.approximateLength += varName.length + 10;
               addResult(
                 factory.createImportEqualsDeclaration(
                   /*modifiers*/
@@ -58711,6 +59240,7 @@ function createTypeChecker(host) {
             serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* None */ : 32 /* Export */);
           } else {
             const flags = ((_a2 = context.enclosingDeclaration) == null ? void 0 : _a2.kind) === 267 /* ModuleDeclaration */ && (!(symbol.flags & 98304 /* Accessor */) || symbol.flags & 65536 /* SetAccessor */) ? 1 /* Let */ : 2 /* Const */;
+            context.approximateLength += varName.length + 5;
             const statement = factory.createVariableStatement(
               /*modifiers*/
               void 0,
@@ -58735,6 +59265,7 @@ function createTypeChecker(host) {
             );
           }
           if (isExportAssignmentCompatibleSymbolName) {
+            context.approximateLength += varName.length + 10;
             results.push(factory.createExportAssignment(
               /*modifiers*/
               void 0,
@@ -58769,7 +59300,7 @@ function createTypeChecker(host) {
         return function serializePropertySymbol(p, isStatic2, baseType) {
           var _a2, _b, _c, _d, _e, _f;
           const modifierFlags = getDeclarationModifierFlagsFromSymbol(p);
-          const isPrivate = !!(modifierFlags & 2 /* Private */);
+          const omitType = !!(modifierFlags & 2 /* Private */) && !isExpanding(context);
           if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) {
             return [];
           }
@@ -58798,6 +59329,7 @@ function createTypeChecker(host) {
               Debug.assert(!!setter);
               const paramSymbol = isFunctionLikeDeclaration(setter) ? getSignatureFromDeclaration(setter).parameters[0] : void 0;
               const setterDeclaration = (_b = p.declarations) == null ? void 0 : _b.find(isSetAccessor);
+              context.approximateLength += modifiersLength(flag) + 7 + (paramSymbol ? symbolName(paramSymbol).length : 5) + (omitType ? 0 : 2);
               result.push(setTextRange2(
                 context,
                 factory.createSetAccessorDeclaration(
@@ -58811,7 +59343,7 @@ function createTypeChecker(host) {
                     paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
-                    isPrivate ? void 0 : serializeTypeForDeclaration(context, setterDeclaration, getWriteTypeOfSymbol(p), p)
+                    omitType ? void 0 : serializeTypeForDeclaration(context, setterDeclaration, getWriteTypeOfSymbol(p), p)
                   )],
                   /*body*/
                   void 0
@@ -58820,15 +59352,15 @@ function createTypeChecker(host) {
               ));
             }
             if (p.flags & 32768 /* GetAccessor */) {
-              const isPrivate2 = modifierFlags & 2 /* Private */;
               const getterDeclaration = (_c = p.declarations) == null ? void 0 : _c.find(isGetAccessor);
+              context.approximateLength += modifiersLength(flag) + 8 + (omitType ? 0 : 2);
               result.push(setTextRange2(
                 context,
                 factory.createGetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
                   name,
                   [],
-                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getterDeclaration, getTypeOfSymbol(p), p),
+                  omitType ? void 0 : serializeTypeForDeclaration(context, getterDeclaration, getTypeOfSymbol(p), p),
                   /*body*/
                   void 0
                 ),
@@ -58837,13 +59369,15 @@ function createTypeChecker(host) {
             }
             return result;
           } else if (p.flags & (4 /* Property */ | 3 /* Variable */ | 98304 /* Accessor */)) {
+            const modifierFlags2 = (isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag;
+            context.approximateLength += 2 + (omitType ? 0 : 2) + modifiersLength(modifierFlags2);
             return setTextRange2(
               context,
               createProperty2(
-                factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
+                factory.createModifiersFromModifierFlags(modifierFlags2),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
-                isPrivate ? void 0 : serializeTypeForDeclaration(context, (_d = p.declarations) == null ? void 0 : _d.find(isSetAccessorDeclaration), getWriteTypeOfSymbol(p), p),
+                omitType ? void 0 : serializeTypeForDeclaration(context, (_d = p.declarations) == null ? void 0 : _d.find(isSetAccessorDeclaration), getWriteTypeOfSymbol(p), p),
                 // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
                 // interface members can't have initializers, however class members _can_
                 /*initializer*/
@@ -58855,11 +59389,13 @@ function createTypeChecker(host) {
           if (p.flags & (8192 /* Method */ | 16 /* Function */)) {
             const type = getTypeOfSymbol(p);
             const signatures = getSignaturesOfType(type, 0 /* Call */);
-            if (flag & 2 /* Private */) {
+            if (omitType) {
+              const modifierFlags2 = (isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag;
+              context.approximateLength += 1 + modifiersLength(modifierFlags2);
               return setTextRange2(
                 context,
                 createProperty2(
-                  factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
+                  factory.createModifiersFromModifierFlags(modifierFlags2),
                   name,
                   p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
                   /*type*/
@@ -58872,6 +59408,7 @@ function createTypeChecker(host) {
             }
             const results2 = [];
             for (const sig of signatures) {
+              context.approximateLength += 1;
               const decl = signatureToSignatureDeclarationHelper(
                 sig,
                 methodKind,
@@ -58890,6 +59427,25 @@ function createTypeChecker(host) {
           return Debug.fail(`Unhandled class member kind! ${p.__debugFlags || p.flags}`);
         };
       }
+      function modifiersLength(flags) {
+        let result = 0;
+        if (flags & 32 /* Export */) result += 7;
+        if (flags & 128 /* Ambient */) result += 8;
+        if (flags & 2048 /* Default */) result += 8;
+        if (flags & 4096 /* Const */) result += 6;
+        if (flags & 1 /* Public */) result += 7;
+        if (flags & 2 /* Private */) result += 8;
+        if (flags & 4 /* Protected */) result += 10;
+        if (flags & 64 /* Abstract */) result += 9;
+        if (flags & 256 /* Static */) result += 7;
+        if (flags & 16 /* Override */) result += 9;
+        if (flags & 8 /* Readonly */) result += 9;
+        if (flags & 512 /* Accessor */) result += 9;
+        if (flags & 1024 /* Async */) result += 6;
+        if (flags & 8192 /* In */) result += 3;
+        if (flags & 16384 /* Out */) result += 4;
+        return result;
+      }
       function serializePropertySymbolForInterface(p, baseType) {
         return serializePropertySymbolForInterfaceWorker(
           p,
@@ -58954,6 +59510,7 @@ function createTypeChecker(host) {
         }
         const results2 = [];
         for (const sig of signatures) {
+          context.approximateLength += 1;
           const decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
           results2.push(setTextRange2(context, decl, sig.declaration));
         }
@@ -59079,6 +59636,23 @@ function createTypeChecker(host) {
         return localName;
       }
     }
+    function isExpanding(context) {
+      return context.maxExpansionDepth !== -1;
+    }
+    function isHashPrivate(s) {
+      return !!s.valueDeclaration && isNamedDeclaration(s.valueDeclaration) && isPrivateIdentifier(s.valueDeclaration.name);
+    }
+    function getClonedHashPrivateName(s) {
+      if (s.valueDeclaration && isNamedDeclaration(s.valueDeclaration) && isPrivateIdentifier(s.valueDeclaration.name)) {
+        return factory.cloneNode(s.valueDeclaration.name);
+      }
+      return void 0;
+    }
+  }
+  function isLibType(type) {
+    var _a;
+    const symbol = (getObjectFlags(type) & 4 /* Reference */) !== 0 ? type.target.symbol : type.symbol;
+    return isTupleType(type) || !!((_a = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a.some((decl) => host.isSourceFileDefaultLibrary(getSourceFileOfNode(decl))));
   }
   function typePredicateToString(typePredicate, enclosingDeclaration, flags = 16384 /* UseAliasDefinedOutsideCurrentScope */, writer) {
     return writer ? typePredicateToStringWorker(writer).getText() : usingSingleLineStringWriter(typePredicateToStringWorker);
@@ -59097,14 +59671,14 @@ function createTypeChecker(host) {
       return writer2;
     }
   }
-  function formatUnionTypes(types) {
+  function formatUnionTypes(types, expandingEnum) {
     const result = [];
     let flags = 0;
     for (let i = 0; i < types.length; i++) {
       const t = types[i];
       flags |= t.flags;
       if (!(t.flags & 98304 /* Nullable */)) {
-        if (t.flags & (512 /* BooleanLiteral */ | 1056 /* EnumLike */)) {
+        if (t.flags & 512 /* BooleanLiteral */ || !expandingEnum && t.flags | 1056 /* EnumLike */) {
           const baseType = t.flags & 512 /* BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLikeType(t);
           if (baseType.flags & 1048576 /* Union */) {
             const count = baseType.types.length;
@@ -63187,7 +63761,7 @@ function createTypeChecker(host) {
       let hasThisParameter2 = false;
       const iife = getImmediatelyInvokedFunctionExpression(declaration);
       const isJSConstructSignature = isJSDocConstructSignature(declaration);
-      const isUntypedSignatureInJSFile = !iife && isInJSFile(declaration) && isValueSignatureDeclaration(declaration) && !hasJSDocParameterTags(declaration) && !getJSDocType(declaration) && !getContextualSignatureForFunctionLikeDeclaration(declaration);
+      const isUntypedSignatureInJSFile = !iife && isInJSFile(declaration) && isValueSignatureDeclaration(declaration) && !hasJSDocParameterTags(declaration) && !some(declaration.parameters, (p) => !!getJSDocType(p)) && !getJSDocType(declaration) && !getContextualSignatureForFunctionLikeDeclaration(declaration);
       if (isUntypedSignatureInJSFile) {
         flags |= 32 /* IsUntypedSignatureInJSFile */;
       }
@@ -92049,6 +92623,9 @@ function createTypeChecker(host) {
             tracker.trackSymbol(name, enclosing, 111551 /* Value */);
           }
         }
+      },
+      symbolToDeclarations: (symbol, meaning, flags, verbosityLevel, out) => {
+        return nodeBuilder.symbolToDeclarations(symbol, meaning, flags, verbosityLevel, out);
       }
     };
     function isImportRequiredByAugmentation(node) {
@@ -120145,7 +120722,8 @@ var notImplementedResolver = {
   getDeclarationStatementsForSourceFile: notImplemented,
   isImportRequiredByAugmentation: notImplemented,
   isDefinitelyReferenceToGlobalSymbolObject: notImplemented,
-  createLateBoundIndexSignatures: notImplemented
+  createLateBoundIndexSignatures: notImplemented,
+  symbolToDeclarations: notImplemented
 };
 var createPrinterWithDefaults = /* @__PURE__ */ memoize(() => createPrinter({}));
 var createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true }));
@@ -140280,9 +140858,9 @@ function mapToDisplayParts(writeDisplayParts) {
     displayPartWriter.clear();
   }
 }
-function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = 0 /* None */) {
+function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = 0 /* None */, verbosityLevel, out) {
   return mapToDisplayParts((writer) => {
-    typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer);
+    typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer, verbosityLevel, out);
   });
 }
 function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags = 0 /* None */) {
@@ -140290,7 +140868,7 @@ function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning
     typeChecker.writeSymbol(symbol, enclosingDeclaration, meaning, flags | 8 /* UseAliasDefinedOutsideCurrentScope */, writer);
   });
 }
-function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, flags = 0 /* None */) {
+function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, flags = 0 /* None */, verbosityLevel, out) {
   flags |= 16384 /* UseAliasDefinedOutsideCurrentScope */ | 1024 /* MultilineObjectLiterals */ | 32 /* WriteTypeArgumentsOfSignature */ | 8192 /* OmitParameterModifiers */;
   return mapToDisplayParts((writer) => {
     typechecker.writeSignature(
@@ -140299,7 +140877,9 @@ function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, f
       flags,
       /*kind*/
       void 0,
-      writer
+      writer,
+      verbosityLevel,
+      out
     );
   });
 }
@@ -140338,74 +140918,6 @@ function getPrecedingNonSpaceCharacterPosition(text, position) {
   }
   return position + 1;
 }
-function getSynthesizedDeepClone(node, includeTrivia = true) {
-  const clone2 = node && getSynthesizedDeepCloneWorker(node);
-  if (clone2 && !includeTrivia) suppressLeadingAndTrailingTrivia(clone2);
-  return setParentRecursive(
-    clone2,
-    /*incremental*/
-    false
-  );
-}
-function getSynthesizedDeepCloneWithReplacements(node, includeTrivia, replaceNode) {
-  let clone2 = replaceNode(node);
-  if (clone2) {
-    setOriginalNode(clone2, node);
-  } else {
-    clone2 = getSynthesizedDeepCloneWorker(node, replaceNode);
-  }
-  if (clone2 && !includeTrivia) suppressLeadingAndTrailingTrivia(clone2);
-  return clone2;
-}
-function getSynthesizedDeepCloneWorker(node, replaceNode) {
-  const nodeClone = replaceNode ? (n) => getSynthesizedDeepCloneWithReplacements(
-    n,
-    /*includeTrivia*/
-    true,
-    replaceNode
-  ) : getSynthesizedDeepClone;
-  const nodesClone = replaceNode ? (ns) => ns && getSynthesizedDeepClonesWithReplacements(
-    ns,
-    /*includeTrivia*/
-    true,
-    replaceNode
-  ) : (ns) => ns && getSynthesizedDeepClones(ns);
-  const visited = visitEachChild(
-    node,
-    nodeClone,
-    /*context*/
-    void 0,
-    nodesClone,
-    nodeClone
-  );
-  if (visited === node) {
-    const clone2 = isStringLiteral(node) ? setOriginalNode(factory.createStringLiteralFromNode(node), node) : isNumericLiteral(node) ? setOriginalNode(factory.createNumericLiteral(node.text, node.numericLiteralFlags), node) : factory.cloneNode(node);
-    return setTextRange(clone2, node);
-  }
-  visited.parent = void 0;
-  return visited;
-}
-function getSynthesizedDeepClones(nodes, includeTrivia = true) {
-  if (nodes) {
-    const cloned = factory.createNodeArray(nodes.map((n) => getSynthesizedDeepClone(n, includeTrivia)), nodes.hasTrailingComma);
-    setTextRange(cloned, nodes);
-    return cloned;
-  }
-  return nodes;
-}
-function getSynthesizedDeepClonesWithReplacements(nodes, includeTrivia, replaceNode) {
-  return factory.createNodeArray(nodes.map((n) => getSynthesizedDeepCloneWithReplacements(n, includeTrivia, replaceNode)), nodes.hasTrailingComma);
-}
-function suppressLeadingAndTrailingTrivia(node) {
-  suppressLeadingTrivia(node);
-  suppressTrailingTrivia(node);
-}
-function suppressLeadingTrivia(node) {
-  addEmitFlagsRecursively(node, 1024 /* NoLeadingComments */, getFirstChild);
-}
-function suppressTrailingTrivia(node) {
-  addEmitFlagsRecursively(node, 2048 /* NoTrailingComments */, getLastChild);
-}
 function copyComments(sourceNode, targetNode) {
   const sourceFile = sourceNode.getSourceFile();
   const text = sourceFile.text;
@@ -140424,14 +140936,6 @@ function hasLeadingLineBreak(node, text) {
   }
   return false;
 }
-function addEmitFlagsRecursively(node, flag, getChild) {
-  addEmitFlags(node, flag);
-  const child = getChild(node);
-  if (child) addEmitFlagsRecursively(child, flag, getChild);
-}
-function getFirstChild(node) {
-  return node.forEachChild((child) => child);
-}
 function getUniqueName(baseName, sourceFile) {
   let nameText = baseName;
   for (let i = 1; !isFileLevelUniqueName(sourceFile, nameText); i++) {
@@ -152248,7 +152752,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     synchronizeHostData();
     return ts_Completions_exports.getCompletionEntrySymbol(program, log, getValidSourceFile(fileName), position, { name, source }, host, preferences);
   }
-  function getQuickInfoAtPosition(fileName, position) {
+  function getQuickInfoAtPosition(fileName, position, verbosityLevel) {
     synchronizeHostData();
     const sourceFile = getValidSourceFile(fileName);
     const node = getTouchingPropertyName(sourceFile, position);
@@ -152264,19 +152768,41 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
         kind: "" /* unknown */,
         kindModifiers: "" /* none */,
         textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
-        displayParts: typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => typeToDisplayParts(typeChecker2, type, getContainerNode(nodeForQuickInfo))),
+        displayParts: typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => typeToDisplayParts(
+          typeChecker2,
+          type,
+          getContainerNode(nodeForQuickInfo),
+          /*flags*/
+          void 0,
+          verbosityLevel
+        )),
         documentation: type.symbol ? type.symbol.getDocumentationComment(typeChecker) : void 0,
         tags: type.symbol ? type.symbol.getJsDocTags(typeChecker) : void 0
       };
     }
-    const { symbolKind, displayParts, documentation, tags } = typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker2, symbol, sourceFile, getContainerNode(nodeForQuickInfo), nodeForQuickInfo));
+    const { symbolKind, displayParts, documentation, tags, canIncreaseVerbosityLevel } = typeChecker.runWithCancellationToken(
+      cancellationToken,
+      (typeChecker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(
+        typeChecker2,
+        symbol,
+        sourceFile,
+        getContainerNode(nodeForQuickInfo),
+        nodeForQuickInfo,
+        /*semanticMeaning*/
+        void 0,
+        /*alias*/
+        void 0,
+        verbosityLevel
+      )
+    );
     return {
       kind: symbolKind,
       kindModifiers: ts_SymbolDisplay_exports.getSymbolModifiers(typeChecker, symbol),
       textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
       displayParts,
       documentation,
-      tags
+      tags,
+      canIncreaseVerbosityLevel
     };
   }
   function preparePasteEditsForFile(fileName, copiedTextRange) {
@@ -177372,7 +177898,7 @@ function getSymbolModifiers(typeChecker, symbol) {
   }
   return modifiers.size > 0 ? arrayFrom(modifiers.values()).join(",") : "" /* none */;
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias) {
+function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias, verbosityLevel) {
   var _a;
   const displayParts = [];
   let documentation = [];
@@ -177384,6 +177910,8 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
   let documentationFromAlias;
   let tagsFromAlias;
   let hasMultipleSignatures = false;
+  const typeWriterOut = { canIncreaseExpansionDepth: false, truncated: false };
+  let symbolWasExpanded = false;
   if (location.kind === 110 /* ThisKeyword */ && !isThisExpression) {
     return { displayParts: [keywordPart(110 /* ThisKeyword */)], documentation: [], symbolKind: "primitive type" /* primitiveType */, tags: void 0 };
   }
@@ -177521,21 +178049,28 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
   }
   if (symbolFlags & 32 /* Class */ && !hasAddedSymbolInfo && !isThisExpression) {
     addAliasPrefixIfNecessary();
-    if (getDeclarationOfKind(symbol, 231 /* ClassExpression */)) {
+    const classExpression = getDeclarationOfKind(symbol, 231 /* ClassExpression */);
+    if (classExpression) {
       pushSymbolKind("local class" /* localClassElement */);
-    } else {
-      displayParts.push(keywordPart(86 /* ClassKeyword */));
+      displayParts.push(spacePart());
+    }
+    if (!tryExpandSymbol(symbol, semanticMeaning)) {
+      if (!classExpression) {
+        displayParts.push(keywordPart(86 /* ClassKeyword */));
+        displayParts.push(spacePart());
+      }
+      addFullSymbolName(symbol);
+      writeTypeParametersOfSymbol(symbol, sourceFile);
     }
-    displayParts.push(spacePart());
-    addFullSymbolName(symbol);
-    writeTypeParametersOfSymbol(symbol, sourceFile);
   }
   if (symbolFlags & 64 /* Interface */ && semanticMeaning & 2 /* Type */) {
     prefixNextMeaning();
-    displayParts.push(keywordPart(120 /* InterfaceKeyword */));
-    displayParts.push(spacePart());
-    addFullSymbolName(symbol);
-    writeTypeParametersOfSymbol(symbol, sourceFile);
+    if (!tryExpandSymbol(symbol, semanticMeaning)) {
+      displayParts.push(keywordPart(120 /* InterfaceKeyword */));
+      displayParts.push(spacePart());
+      addFullSymbolName(symbol);
+      writeTypeParametersOfSymbol(symbol, sourceFile);
+    }
   }
   if (symbolFlags & 524288 /* TypeAlias */ && semanticMeaning & 2 /* Type */) {
     prefixNextMeaning();
@@ -177546,25 +178081,43 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     displayParts.push(spacePart());
     displayParts.push(operatorPart(64 /* EqualsToken */));
     displayParts.push(spacePart());
-    addRange(displayParts, typeToDisplayParts(typeChecker, location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
+    addRange(
+      displayParts,
+      typeToDisplayParts(
+        typeChecker,
+        location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol),
+        enclosingDeclaration,
+        8388608 /* InTypeAlias */,
+        verbosityLevel,
+        typeWriterOut
+      )
+    );
   }
   if (symbolFlags & 384 /* Enum */) {
     prefixNextMeaning();
-    if (some(symbol.declarations, (d) => isEnumDeclaration(d) && isEnumConst(d))) {
-      displayParts.push(keywordPart(87 /* ConstKeyword */));
+    if (!tryExpandSymbol(symbol, semanticMeaning)) {
+      if (some(symbol.declarations, (d) => isEnumDeclaration(d) && isEnumConst(d))) {
+        displayParts.push(keywordPart(87 /* ConstKeyword */));
+        displayParts.push(spacePart());
+      }
+      displayParts.push(keywordPart(94 /* EnumKeyword */));
       displayParts.push(spacePart());
+      addFullSymbolName(
+        symbol,
+        /*enclosingDeclaration*/
+        void 0
+      );
     }
-    displayParts.push(keywordPart(94 /* EnumKeyword */));
-    displayParts.push(spacePart());
-    addFullSymbolName(symbol);
   }
   if (symbolFlags & 1536 /* Module */ && !isThisExpression) {
     prefixNextMeaning();
-    const declaration = getDeclarationOfKind(symbol, 267 /* ModuleDeclaration */);
-    const isNamespace = declaration && declaration.name && declaration.name.kind === 80 /* Identifier */;
-    displayParts.push(keywordPart(isNamespace ? 145 /* NamespaceKeyword */ : 144 /* ModuleKeyword */));
-    displayParts.push(spacePart());
-    addFullSymbolName(symbol);
+    if (!tryExpandSymbol(symbol, semanticMeaning)) {
+      const declaration = getDeclarationOfKind(symbol, 267 /* ModuleDeclaration */);
+      const isNamespace = declaration && declaration.name && declaration.name.kind === 80 /* Identifier */;
+      displayParts.push(keywordPart(isNamespace ? 145 /* NamespaceKeyword */ : 144 /* ModuleKeyword */));
+      displayParts.push(spacePart());
+      addFullSymbolName(symbol);
+    }
   }
   if (symbolFlags & 262144 /* TypeParameter */ && semanticMeaning & 2 /* Type */) {
     prefixNextMeaning();
@@ -177634,12 +178187,16 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
             declarationName,
             type,
             semanticMeaning,
-            shouldUseAliasName ? symbol : resolvedSymbol
+            shouldUseAliasName ? symbol : resolvedSymbol,
+            verbosityLevel
           );
           displayParts.push(...resolvedInfo.displayParts);
           displayParts.push(lineBreakPart());
           documentationFromAlias = resolvedInfo.documentation;
           tagsFromAlias = resolvedInfo.tags;
+          if (typeWriterOut && resolvedInfo.canIncreaseVerbosityLevel) {
+            typeWriterOut.canIncreaseExpansionDepth = true;
+          }
         } else {
           documentationFromAlias = resolvedSymbol.getContextualDocumentationComment(resolvedNode, typeChecker);
           tagsFromAlias = resolvedSymbol.getJsDocTags(typeChecker);
@@ -177705,12 +178262,33 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
           displayParts.push(spacePart());
           if (type.symbol && type.symbol.flags & 262144 /* TypeParameter */ && symbolKind !== "index" /* indexSignatureElement */) {
             const typeParameterParts = mapToDisplayParts((writer) => {
-              const param = typeChecker.typeParameterToDeclaration(type, enclosingDeclaration, symbolDisplayNodeBuilderFlags);
+              const param = typeChecker.typeParameterToDeclaration(
+                type,
+                enclosingDeclaration,
+                symbolDisplayNodeBuilderFlags,
+                /*internalFlags*/
+                void 0,
+                /*tracker*/
+                void 0,
+                verbosityLevel,
+                typeWriterOut
+              );
               getPrinter().writeNode(4 /* Unspecified */, param, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration)), writer);
             });
             addRange(displayParts, typeParameterParts);
           } else {
-            addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration));
+            addRange(
+              displayParts,
+              typeToDisplayParts(
+                typeChecker,
+                type,
+                enclosingDeclaration,
+                /*flags*/
+                void 0,
+                verbosityLevel,
+                typeWriterOut
+              )
+            );
           }
           if (isTransientSymbol(symbol) && symbol.links.target && isTransientSymbol(symbol.links.target) && symbol.links.target.links.tupleLabelDeclaration) {
             const labelDecl = symbol.links.target.links.tupleLabelDeclaration;
@@ -177775,7 +178353,14 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
   if (tags.length === 0 && tagsFromAlias) {
     tags = tagsFromAlias;
   }
-  return { displayParts, documentation, symbolKind, tags: tags.length === 0 ? void 0 : tags };
+  const canIncreaseVerbosityLevel = !typeWriterOut.truncated && typeWriterOut.canIncreaseExpansionDepth;
+  return {
+    displayParts,
+    documentation,
+    symbolKind,
+    tags: tags.length === 0 ? void 0 : tags,
+    canIncreaseVerbosityLevel: verbosityLevel !== void 0 ? canIncreaseVerbosityLevel : void 0
+  };
   function getPrinter() {
     return createPrinterWithRemoveComments();
   }
@@ -177796,6 +178381,62 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     displayParts.push(keywordPart(103 /* InKeyword */));
     displayParts.push(spacePart());
   }
+  function canExpandSymbol(symbol2, out) {
+    if (verbosityLevel === void 0) {
+      return false;
+    }
+    const type2 = symbol2.flags & (32 /* Class */ | 64 /* Interface */) ? typeChecker.getDeclaredTypeOfSymbol(symbol2) : typeChecker.getTypeOfSymbolAtLocation(symbol2, location);
+    if (!type2 || typeChecker.isLibType(type2)) {
+      return false;
+    }
+    if (0 < verbosityLevel) {
+      return true;
+    }
+    if (out) {
+      out.canIncreaseExpansionDepth = true;
+    }
+    return false;
+  }
+  function semanticToSymbolMeaning(meaning) {
+    let symbolMeaning = 0 /* None */;
+    if (meaning & 1 /* Value */) {
+      symbolMeaning |= 111551 /* Value */;
+    }
+    if (meaning & 2 /* Type */) {
+      symbolMeaning |= 788968 /* Type */;
+    }
+    if (meaning & 4 /* Namespace */) {
+      symbolMeaning |= 1920 /* Namespace */;
+    }
+    return symbolMeaning;
+  }
+  function tryExpandSymbol(symbol2, meaning) {
+    if (symbolWasExpanded) {
+      return true;
+    }
+    if (canExpandSymbol(symbol2, typeWriterOut)) {
+      const symbolMeaning = semanticToSymbolMeaning(meaning);
+      const expandedDisplayParts = mapToDisplayParts((writer) => {
+        const nodes = typeChecker.getEmitResolver().symbolToDeclarations(
+          symbol2,
+          symbolMeaning,
+          1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */,
+          verbosityLevel !== void 0 ? verbosityLevel - 1 : void 0,
+          typeWriterOut
+        );
+        const printer = getPrinter();
+        const sourceFile2 = symbol2.valueDeclaration && getSourceFileOfNode(symbol2.valueDeclaration);
+        nodes.forEach((node, i) => {
+          if (i > 0) writer.writeLine();
+          printer.writeNode(4 /* Unspecified */, node, sourceFile2, writer);
+        });
+      });
+      addRange(displayParts, expandedDisplayParts);
+      symbolWasExpanded = true;
+      return true;
+    }
+    return false;
+  }
   function addFullSymbolName(symbolToDisplay, enclosingDeclaration2) {
     let indexInfos;
     if (alias && symbolToDisplay === symbol) {
@@ -177863,7 +178504,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     }
   }
   function addSignatureDisplayParts(signature, allSignatures, flags = 0 /* None */) {
-    addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | 32 /* WriteTypeArgumentsOfSignature */));
+    addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | 32 /* WriteTypeArgumentsOfSignature */, verbosityLevel, typeWriterOut));
     if (allSignatures.length > 1) {
       displayParts.push(spacePart());
       displayParts.push(punctuationPart(21 /* OpenParenToken */));
@@ -177888,7 +178529,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     addRange(displayParts, typeParameterParts);
   }
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
+function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias, verbosityLevel) {
   return getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
     typeChecker,
     symbol,
@@ -177898,7 +178539,8 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
     /*type*/
     void 0,
     semanticMeaning,
-    alias
+    alias,
+    verbosityLevel
   );
 }
 function isLocalVariableOrFunction(symbol) {
@@ -194853,7 +195495,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
   getQuickInfoWorker(args, simplifiedResult) {
     const { file, project } = this.getFileAndProject(args);
     const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
-    const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo));
+    const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo), args.verbosityLevel);
     if (!quickInfo) {
       return void 0;
     }
@@ -194867,7 +195509,8 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         end: scriptInfo.positionToLineOffset(textSpanEnd(quickInfo.textSpan)),
         displayString,
         documentation: useDisplayParts ? this.mapDisplayParts(quickInfo.documentation, project) : displayPartsToString(quickInfo.documentation),
-        tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts)
+        tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts),
+        canIncreaseVerbosityLevel: quickInfo.canIncreaseVerbosityLevel
       };
     } else {
       return useDisplayParts ? quickInfo : {