@typescript-deploys/pr-build 5.9.0-pr-61505-16 → 5.9.0-pr-61589-2

package/lib/_tsc.js

@@ -18,15 +18,11 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.9";
-var version = `${versionMajorMinor}.0-insiders.20250401`;
+var version = `${versionMajorMinor}.0-insiders.20250417`;
 
 // src/compiler/core.ts
 var emptyArray = [];
 var emptyMap = /* @__PURE__ */ new Map();
-var voidMap = /* @__PURE__ */ new Map();
-voidMap.set = function() {
-  return this;
-};
 function length(array) {
   return array !== void 0 ? array.length : 0;
 }
@@ -20017,6 +20013,82 @@ function getOptionsSyntaxByValue(optionsObject, name, value) {
 function forEachOptionsSyntaxByName(optionsObject, name, callback) {
   return forEachPropertyAssignment(optionsObject, name, callback);
 }
+function getSynthesizedDeepClone(node, includeTrivia = true) {
+  const clone = node && getSynthesizedDeepCloneWorker(node);
+  if (clone && !includeTrivia) suppressLeadingAndTrailingTrivia(clone);
+  return setParentRecursive(
+    clone,
+    /*incremental*/
+    false
+  );
+}
+function getSynthesizedDeepCloneWithReplacements(node, includeTrivia, replaceNode) {
+  let clone = replaceNode(node);
+  if (clone) {
+    setOriginalNode(clone, node);
+  } else {
+    clone = getSynthesizedDeepCloneWorker(node, replaceNode);
+  }
+  if (clone && !includeTrivia) suppressLeadingAndTrailingTrivia(clone);
+  return clone;
+}
+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 clone = isStringLiteral(node) ? setOriginalNode(factory.createStringLiteralFromNode(node), node) : isNumericLiteral(node) ? setOriginalNode(factory.createNumericLiteral(node.text, node.numericLiteralFlags), node) : factory.cloneNode(node);
+    return setTextRange(clone, 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() {
@@ -46380,11 +46452,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);
@@ -46618,7 +46690,8 @@ function createTypeChecker(host) {
     isTypeParameterPossiblyReferenced,
     typeHasCallOrConstructSignatures,
     getSymbolFlags,
-    getTypeArgumentsForResolvedSignature
+    getTypeArgumentsForResolvedSignature,
+    isLibType
   };
   function getTypeArgumentsForResolvedSignature(signature) {
     if (signature.mapper === void 0) return void 0;
@@ -46822,7 +46895,6 @@ function createTypeChecker(host) {
   var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
   var numericStringType = getTemplateLiteralType(["", ""], [numberType]);
   var restrictiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t, () => "(restrictive mapper)");
-  restrictiveMapper.instantiations = voidMap;
   var permissiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? wildcardType : t, () => "(permissive mapper)");
   var uniqueLiteralType = createIntrinsicType(
     131072 /* Never */,
@@ -46842,7 +46914,6 @@ function createTypeChecker(host) {
     }
     return t;
   }, () => "(unmeasurable reporter)");
-  reportUnreliableMapper.instantiations = voidMap;
   var reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
     if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
       outofbandVarianceMarkerHandler(
@@ -46852,7 +46923,6 @@ function createTypeChecker(host) {
     }
     return t;
   }, () => "(unreliable reporter)");
-  reportUnmeasurableMapper.instantiations = voidMap;
   var emptyObjectType = createAnonymousType(
     /*symbol*/
     void 0,
@@ -50298,7 +50368,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;
@@ -50307,7 +50377,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(
@@ -50320,14 +50401,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();
@@ -50406,7 +50491,6 @@ function createTypeChecker(host) {
       },
       isOptionalParameter,
       isUndefinedIdentifierExpression(node) {
-        Debug.assert(isExpressionNode(node));
         return getSymbolAtLocation(node) === undefinedSymbol;
       },
       isEntityNameVisible(context, entityName, shouldComputeAliasToMakeVisible) {
@@ -50558,31 +50642,120 @@ function createTypeChecker(host) {
     };
     return {
       syntacticBuilderResolver,
-      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
-      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)),
-      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
-        indexInfo,
-        context,
-        /*typeNode*/
-        void 0
-      )),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
-        symbol,
-        context,
-        meaning,
-        /*expectsIdentifier*/
-        false
-      )),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeToTypeNodeHelper(type, context), out),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)
+      ),
+      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)
+      ),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)
+      ),
+      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)
+      ),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => indexInfoToIndexSignatureDeclarationHelper(
+          indexInfo,
+          context,
+          /*typeNode*/
+          void 0
+        )
+      ),
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => signatureToSignatureDeclarationHelper(signature, kind, context), out),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToName(
+          symbol,
+          context,
+          meaning,
+          /*expectsIdentifier*/
+          false
+        )
+      ),
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToExpression(symbol, context, meaning)
+      ),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => typeParametersToTypeParameterDeclarations(symbol, context)
+      ),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToParameterDeclaration(symbol, context)
+      ),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeParameterToDeclaration(parameter, context), out),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolTableToDeclarationStatements(symbolTable, context)
+      ),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => symbolToNode(symbol, context, meaning)
+      ),
+      symbolToDeclarations
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -50624,7 +50797,75 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext(enclosingDeclaration, flags, internalFlags, tracker, cb) {
+    function symbolToDeclarations(symbol, meaning, flags, verbosityLevel, out) {
+      const nodes = withContext(
+        /*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 withContext(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,
@@ -50632,6 +50873,7 @@ function createTypeChecker(host) {
         flags: flags || 0 /* None */,
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
+        maxExpansionDepth: verbosityLevel ?? -1,
         encounteredError: false,
         suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
@@ -50653,13 +50895,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) {
@@ -50678,19 +50930,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;
     }
@@ -50701,6 +50983,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;
@@ -50768,7 +51051,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;
@@ -50835,16 +51122,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 */) {
@@ -50874,6 +51179,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 */);
         }
@@ -50888,7 +51203,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);
         }
@@ -51077,7 +51392,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;
@@ -51100,15 +51415,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 */);
@@ -51144,7 +51464,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());
@@ -51461,6 +51781,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")];
           }
@@ -51474,6 +51795,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));
@@ -51487,10 +51809,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 */) {
@@ -51501,6 +51827,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 ...`));
@@ -51520,6 +51847,7 @@ function createTypeChecker(host) {
           }
           addPropertyToElementList(propertySymbol, context, typeElements);
         }
+        context.typeStack.pop();
         return typeElements.length ? typeElements : void 0;
       }
     }
@@ -51668,6 +51996,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(
@@ -51695,6 +52024,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 ...`,
@@ -52092,7 +52422,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);
@@ -52611,12 +52941,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 */) {
@@ -52625,16 +52958,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);
         }
       }
@@ -52663,6 +53001,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 */);
@@ -52739,7 +53081,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);
@@ -52778,7 +53120,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);
@@ -53189,14 +53531,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(
@@ -53226,7 +53582,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) {
@@ -53276,6 +53632,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*/
@@ -53315,8 +53672,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*/
@@ -53366,27 +53725,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*/
@@ -53396,7 +53761,7 @@ function createTypeChecker(host) {
               factory.createNamedExports([factory.createExportSpecifier(
                 /*isTypeOnly*/
                 false,
-                getInternalSymbolName(symbol, symbolName2),
+                internalSymbolName,
                 symbolName2
               )])
             ),
@@ -53416,6 +53781,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)) {
@@ -53428,8 +53794,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);
       }
@@ -53445,12 +53812,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
             ),
@@ -53462,12 +53831,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);
@@ -53476,7 +53852,7 @@ function createTypeChecker(host) {
           factory.createInterfaceDeclaration(
             /*modifiers*/
             void 0,
-            getInternalSymbolName(symbol, symbolName2),
+            internalSymbolName,
             typeParamDecls,
             heritageClauses,
             [...indexSignatures, ...constructSignatures, ...callSignatures, ...members]
@@ -53484,6 +53860,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);
@@ -53503,11 +53930,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)) {
@@ -53555,17 +53998,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
         );
@@ -53573,20 +54050,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 */) {
@@ -53599,15 +54084,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);
@@ -53649,6 +54137,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) {
@@ -53691,11 +54191,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);
@@ -53703,20 +54205,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"),
@@ -53727,22 +54231,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 */),
           [],
@@ -53810,6 +54319,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*/
@@ -53822,7 +54333,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)
                     )])
                   ),
@@ -53849,6 +54360,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*/
@@ -53860,6 +54372,7 @@ function createTypeChecker(host) {
                 ),
                 0 /* None */
               );
+              context.approximateLength += 12 + localName.length + idText(uniqueName).length + idText(initializer.name).length;
               addResult(
                 factory.createImportEqualsDeclaration(
                   /*modifiers*/
@@ -53880,6 +54393,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*/
@@ -53906,6 +54420,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*/
@@ -53927,6 +54442,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*/
@@ -53945,6 +54461,7 @@ function createTypeChecker(host) {
             break;
           }
           case 280 /* NamespaceExport */:
+            context.approximateLength += 19 + localName.length + 3;
             addResult(
               factory.createExportDeclaration(
                 /*modifiers*/
@@ -53961,6 +54478,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*/
@@ -54016,6 +54534,7 @@ function createTypeChecker(host) {
         }
       }
       function serializeExportSpecifier(localName, targetName, specifier) {
+        context.approximateLength += 16 + localName.length + (localName !== targetName ? targetName.length : 0);
         addResult(
           factory.createExportDeclaration(
             /*modifiers*/
@@ -54066,6 +54585,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,
@@ -54079,6 +54599,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*/
@@ -54108,6 +54629,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,
@@ -54132,6 +54654,7 @@ function createTypeChecker(host) {
             );
           }
           if (isExportAssignmentCompatibleSymbolName) {
+            context.approximateLength += varName.length + 10;
             results.push(factory.createExportAssignment(
               /*modifiers*/
               void 0,
@@ -54166,7 +54689,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 [];
           }
@@ -54195,6 +54718,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(
@@ -54208,7 +54732,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
@@ -54217,15 +54741,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
                 ),
@@ -54234,13 +54758,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*/
@@ -54252,11 +54778,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*/
@@ -54269,6 +54797,7 @@ function createTypeChecker(host) {
             }
             const results2 = [];
             for (const sig of signatures) {
+              context.approximateLength += 1;
               const decl = signatureToSignatureDeclarationHelper(
                 sig,
                 methodKind,
@@ -54287,6 +54816,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,
@@ -54351,6 +54899,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));
         }
@@ -54476,6 +55025,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);
@@ -54494,14 +55060,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;
@@ -58584,7 +59150,7 @@ function createTypeChecker(host) {
       let hasThisParameter = 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 */;
       }
@@ -61698,7 +62264,7 @@ function createTypeChecker(host) {
           context.nonFixingMapper = combineTypeMappers(context.nonFixingMapper, mapper);
         }
         if (!checkTypeDeferred) {
-          inferTypes(context, context.inferences, checkType, extendsType, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+          inferTypes(context.inferences, checkType, extendsType, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
         }
         combinedMapper = mapper ? combineTypeMappers(context.mapper, mapper) : context.mapper;
       }
@@ -62707,7 +63273,7 @@ function createTypeChecker(host) {
     ) : type;
   }
   function instantiateTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
-    var _a, _b;
+    var _a;
     if (!couldContainTypeVariables(type)) {
       return type;
     }
@@ -62716,16 +63282,10 @@ function createTypeChecker(host) {
       error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
       return errorType;
     }
-    const key = type.id + getAliasId(aliasSymbol, aliasTypeArguments);
-    const cached = (mapper.instantiations ?? (mapper.instantiations = /* @__PURE__ */ new Map())).get(key);
-    if (cached) {
-      return cached;
-    }
     totalInstantiationCount++;
     instantiationCount++;
     instantiationDepth++;
     const result = instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments);
-    (_b = mapper.instantiations) == null ? void 0 : _b.set(key, result);
     instantiationDepth--;
     return result;
   }
@@ -65348,7 +65908,7 @@ function createTypeChecker(host) {
               0 /* None */,
               isRelatedToWorker
             );
-            inferTypes(ctx, ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+            inferTypes(ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
             sourceExtends = instantiateType(sourceExtends, ctx.mapper);
             mapper = ctx.mapper;
           }
@@ -67228,7 +67788,7 @@ function createTypeChecker(host) {
       map(context.inferences, (inference, i) => () => {
         if (!inference.isFixed) {
           inferFromIntraExpressionSites(context);
-          clearCachedInferences(context, context.inferences);
+          clearCachedInferences(context.inferences);
           inference.isFixed = true;
         }
         return getInferredType(context, i);
@@ -67243,10 +67803,7 @@ function createTypeChecker(host) {
       })
     );
   }
-  function clearCachedInferences(context, inferences) {
-    if (context) {
-      context.nonFixingMapper.instantiations = void 0;
-    }
+  function clearCachedInferences(inferences) {
     for (const inference of inferences) {
       if (!inference.isFixed) {
         inference.inferredType = void 0;
@@ -67261,7 +67818,7 @@ function createTypeChecker(host) {
       for (const { node, type } of context.intraExpressionInferenceSites) {
         const contextualType = node.kind === 174 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType(node, 2 /* NoConstraints */);
         if (contextualType) {
-          inferTypes(context, context.inferences, type, contextualType);
+          inferTypes(context.inferences, type, contextualType);
         }
       }
       context.intraExpressionInferenceSites = void 0;
@@ -67405,13 +67962,7 @@ function createTypeChecker(host) {
     const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
     const templateType = getTemplateTypeFromMappedType(target);
     const inference = createInferenceInfo(typeParameter);
-    inferTypes(
-      /*context*/
-      void 0,
-      [inference],
-      sourceType,
-      templateType
-    );
+    inferTypes([inference], sourceType, templateType);
     return getTypeFromInference(inference) || unknownType;
   }
   function inferReverseMappedType(source, target, constraint) {
@@ -67613,7 +68164,7 @@ function createTypeChecker(host) {
   function isTupleOfSelf(typeParameter, type) {
     return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1");
   }
-  function inferTypes(context, inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
+  function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
     let inferencePriority = 2048 /* MaxValue */;
@@ -67704,16 +68255,16 @@ function createTypeChecker(host) {
               if (contravariant && !bivariant) {
                 if (!contains(inference.contraCandidates, candidate)) {
                   inference.contraCandidates = append(inference.contraCandidates, candidate);
-                  clearCachedInferences(context, inferences);
+                  clearCachedInferences(inferences);
                 }
               } else if (!contains(inference.candidates, candidate)) {
                 inference.candidates = append(inference.candidates, candidate);
-                clearCachedInferences(context, inferences);
+                clearCachedInferences(inferences);
               }
             }
             if (!(priority & 128 /* ReturnType */) && target.flags & 262144 /* TypeParameter */ && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
               inference.topLevel = false;
-              clearCachedInferences(context, inferences);
+              clearCachedInferences(inferences);
             }
           }
           inferencePriority = Math.min(inferencePriority, priority);
@@ -68279,7 +68830,6 @@ function createTypeChecker(host) {
         const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
         if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
           inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint;
-          context.nonFixingMapper.instantiations = void 0;
         }
       }
     }
@@ -70295,15 +70845,31 @@ function createTypeChecker(host) {
       }
       const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
       const keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : void 0;
-      const narrowedType = mapType(candidate, (c) => {
-        const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
-        const matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
-        const directlyRelated = mapType(
-          matching || type,
-          checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeStrictSubtypeOf(t, c) ? t : isTypeStrictSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : isTypeSubtypeOf(c, t) ? c : neverType
-        );
-        return directlyRelated.flags & 131072 /* Never */ ? mapType(type, (t) => maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) : directlyRelated;
-      });
+      let matchedCandidates = [];
+      let narrowedType = mapType(type, (t) => mapType(
+        candidate,
+        (c) => {
+          if (keyPropertyName) {
+            const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
+            if (!discriminant || getConstituentTypeForKeyType(type, discriminant) !== t) {
+              return neverType;
+            }
+          }
+          const directlyRelated = checkDerived ? isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : isTypeStrictSubtypeOf(t, c) ? t : isTypeStrictSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : isTypeSubtypeOf(c, t) ? c : neverType;
+          if (!(directlyRelated.flags & 131072 /* Never */)) {
+            matchedCandidates = appendIfUnique(matchedCandidates, c);
+          }
+          return directlyRelated;
+        }
+      ));
+      if (matchedCandidates.length !== countTypes(candidate)) {
+        narrowedType = getUnionType([
+          narrowedType,
+          mapType(candidate, (c) => {
+            return !containsType(matchedCandidates, c) ? mapType(type, (t) => maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) : neverType;
+          })
+        ]);
+      }
       return !(narrowedType.flags & 131072 /* Never */) ? narrowedType : isTypeSubtypeOf(candidate, type) ? candidate : isTypeAssignableTo(type, candidate) ? type : isTypeAssignableTo(candidate, type) ? candidate : getIntersectionType([type, candidate]);
     }
     function narrowTypeByCallExpression(type, callExpression, assumeTrue) {
@@ -74854,11 +75420,11 @@ function createTypeChecker(host) {
     const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
     const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
     applyToParameterTypes(sourceSignature, signature, (source, target) => {
-      inferTypes(context, context.inferences, source, target);
+      inferTypes(context.inferences, source, target);
     });
     if (!inferenceContext) {
       applyToReturnTypes(contextualSignature, signature, (source, target) => {
-        inferTypes(context, context.inferences, source, target, 128 /* ReturnType */);
+        inferTypes(context.inferences, source, target, 128 /* ReturnType */);
       });
     }
     return getSignatureInstantiation(signature, getInferredTypes(context), isInJSFile(contextualSignature.declaration));
@@ -74866,7 +75432,7 @@ function createTypeChecker(host) {
   function inferJsxTypeArguments(node, signature, checkMode, context) {
     const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
     const checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
-    inferTypes(context, context.inferences, checkAttrType, paramType);
+    inferTypes(context.inferences, checkAttrType, paramType);
     return getInferredTypes(context);
   }
   function getThisArgumentType(thisArgumentNode) {
@@ -74893,11 +75459,11 @@ function createTypeChecker(host) {
             const instantiatedType = instantiateType(contextualType, outerMapper);
             const contextualSignature = getSingleCallSignature(instantiatedType);
             const inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : instantiatedType;
-            inferTypes(context, context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
+            inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
           }
           const returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
           const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
-          inferTypes(returnContext, returnContext.inferences, returnSourceType, inferenceTargetType);
+          inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
           context.returnMapper = some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : void 0;
         }
       }
@@ -74913,7 +75479,7 @@ function createTypeChecker(host) {
     const thisType = getThisTypeOfSignature(signature);
     if (thisType && couldContainTypeVariables(thisType)) {
       const thisArgumentNode = getThisArgumentOfCall(node);
-      inferTypes(context, context.inferences, getThisArgumentType(thisArgumentNode), thisType);
+      inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
     }
     for (let i = 0; i < argCount; i++) {
       const arg = args[i];
@@ -74921,13 +75487,13 @@ function createTypeChecker(host) {
         const paramType = getTypeAtPosition(signature, i);
         if (couldContainTypeVariables(paramType)) {
           const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
-          inferTypes(context, context.inferences, argType, paramType);
+          inferTypes(context.inferences, argType, paramType);
         }
       }
     }
     if (restType && couldContainTypeVariables(restType)) {
       const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
-      inferTypes(context, context.inferences, spreadType, restType);
+      inferTypes(context.inferences, spreadType, restType);
     }
     return getInferredTypes(context);
   }
@@ -77300,14 +77866,14 @@ function createTypeChecker(host) {
           isOptionalDeclaration(declaration)
         );
         const target = getTypeAtPosition(context, i);
-        inferTypes(inferenceContext, inferenceContext.inferences, source, target);
+        inferTypes(inferenceContext.inferences, source, target);
       }
     }
     const typeNode = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
     if (typeNode) {
       const source = getTypeFromTypeNode(typeNode);
       const target = getReturnTypeOfSignature(context);
-      inferTypes(inferenceContext, inferenceContext.inferences, source, target);
+      inferTypes(inferenceContext.inferences, source, target);
     }
   }
   function assignContextualParameterTypes(signature, context) {
@@ -79723,7 +80289,6 @@ function createTypeChecker(host) {
               const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
               applyToParameterTypes(instantiatedSignature, contextualSignature, (source, target) => {
                 inferTypes(
-                  context,
                   inferences,
                   source,
                   target,
@@ -79735,7 +80300,7 @@ function createTypeChecker(host) {
               });
               if (some(inferences, hasInferenceCandidates)) {
                 applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
-                  inferTypes(context, inferences, source, target);
+                  inferTypes(inferences, source, target);
                 });
                 if (!hasOverlappingInferences(context.inferences, inferences)) {
                   mergeInferences(context.inferences, inferences);
@@ -87463,6 +88028,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) {
@@ -115366,7 +115934,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 }));