@schematics/angular 19.2.0 → 20.0.0-next.0

package/third_party/github.com/Microsoft/TypeScript/lib/typescript.js

@@ -2285,7 +2285,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.8";
-var version = "5.8.0-beta";
+var version = "5.8.2";
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6538,7 +6538,6 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
   ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
   ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
-  ObjectFlags3[ObjectFlags3["IsNarrowingType"] = 16777216] = "IsNarrowingType";
   ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
@@ -10211,7 +10210,7 @@ var Diagnostics = {
   This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_during_emit_because_it_is_not_a_relative_path: diag(2877, 1 /* Error */, "This_import_uses_a_0_extension_to_resolve_to_an_input_TypeScript_file_but_will_not_be_rewritten_duri_2877", "This import uses a '{0}' extension to resolve to an input TypeScript file, but will not be rewritten during emit because it is not a relative path."),
   This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_between_the_projects_output_files_is_not_the_same_as_the_relative_path_between_its_input_files: diag(2878, 1 /* Error */, "This_import_path_is_unsafe_to_rewrite_because_it_resolves_to_another_project_and_the_relative_path_b_2878", "This import path is unsafe to rewrite because it resolves to another project, and the relative path between the projects' output files is not the same as the relative path between its input files."),
   Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found: diag(2879, 1 /* Error */, "Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found_2879", "Using JSX fragments requires fragment factory '{0}' to be in scope, but it could not be found."),
-  Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_asserts: diag(2880, 1 /* Error */, "Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_asserts_2880", "Import assertions have been replaced by import attributes. Use 'with' instead of 'asserts'."),
+  Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert: diag(2880, 1 /* Error */, "Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert_2880", "Import assertions have been replaced by import attributes. Use 'with' instead of 'assert'."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -46162,7 +46161,7 @@ function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, node
       state2,
       packageInfo
     );
-    if (!pathAndExtension && packageInfo && (packageInfo.contents.packageJsonContent.exports === void 0 || packageInfo.contents.packageJsonContent.exports === null) && state2.features & 32 /* EsmMode */) {
+    if (!pathAndExtension && !rest && packageInfo && (packageInfo.contents.packageJsonContent.exports === void 0 || packageInfo.contents.packageJsonContent.exports === null) && state2.features & 32 /* EsmMode */) {
       pathAndExtension = loadModuleFromFile(extensions2, combinePaths(candidate2, "index.js"), onlyRecordFailures, state2);
     }
     return withPackageId(packageInfo, pathAndExtension, state2);
@@ -50987,8 +50986,8 @@ function createTypeChecker(host) {
     writeSignature: (signature, enclosingDeclaration, flags, kind, writer) => {
       return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer);
     },
-    writeType: (type, enclosingDeclaration, flags, writer, verbosityLevel, out) => {
-      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer, verbosityLevel, out);
+    writeType: (type, enclosingDeclaration, flags, writer) => {
+      return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer);
     },
     writeSymbol: (symbol, enclosingDeclaration, meaning, flags, writer) => {
       return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
@@ -51786,7 +51785,6 @@ function createTypeChecker(host) {
     [".jsx", ".jsx"],
     [".json", ".json"]
   ];
-  var narrowableReturnTypeCache = /* @__PURE__ */ new Map();
   initializeTypeChecker();
   return checker;
   function isDefinitelyReferenceToGlobalSymbolObject(node) {
@@ -54922,18 +54920,14 @@ function createTypeChecker(host) {
       return writer2;
     }
   }
-  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter(""), verbosityLevel, out) {
-    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */ || verbosityLevel !== void 0;
+  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
+    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
     const typeNode = nodeBuilder.typeToTypeNode(
       type,
       enclosingDeclaration,
-      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0),
+      toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0 /* None */),
       /*internalFlags*/
-      void 0,
-      /*tracker*/
-      void 0,
-      verbosityLevel,
-      out
+      void 0
     );
     if (typeNode === void 0) return Debug.fail("should always get typenode");
     const printer = type !== unresolvedType ? createPrinterWithRemoveComments() : createPrinterWithDefaults();
@@ -55160,127 +55154,31 @@ function createTypeChecker(host) {
     };
     return {
       syntacticBuilderResolver,
-      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, out) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeToTypeNodeHelper(type, context), out),
-      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)
-      ),
-      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)
-      ),
-      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)
-      ),
-      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)
-      ),
-      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => indexInfoToIndexSignatureDeclarationHelper(
-          indexInfo,
-          context,
-          /*typeNode*/
-          void 0
-        )
-      ),
-      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => signatureToSignatureDeclarationHelper(signature, kind, context)
-      ),
-      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToName(
-          symbol,
-          context,
-          meaning,
-          /*expectsIdentifier*/
-          false
-        )
-      ),
-      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToExpression(symbol, context, meaning)
-      ),
-      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => typeParametersToTypeParameterDeclarations(symbol, context)
-      ),
-      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToParameterDeclaration(symbol, context)
-      ),
-      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolTableToDeclarationStatements(symbolTable, context)
-      ),
-      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(
-        enclosingDeclaration,
-        flags,
-        internalFlags,
-        tracker,
-        /*verbosityLevel*/
-        void 0,
-        (context) => symbolToNode(symbol, context, meaning)
-      )
+      typeToTypeNode: (type, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeToTypeNodeHelper(type, context)),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      serializeTypeForExpression: (expr, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfExpression(expr, context)),
+      serializeTypeForDeclaration: (declaration, symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, symbol, context)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => syntacticNodeBuilder.serializeReturnTypeForSignature(signature, getSymbolOfDeclaration(signature), context)),
+      indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
+        indexInfo,
+        context,
+        /*typeNode*/
+        void 0
+      )),
+      signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
+      symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToName(
+        symbol,
+        context,
+        meaning,
+        /*expectsIdentifier*/
+        false
+      )),
+      symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
+      symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
+      symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
+      typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
+      symbolToNode: (symbol, meaning, enclosingDeclaration, flags, internalFlags, tracker) => withContext2(enclosingDeclaration, flags, internalFlags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -55322,7 +55220,7 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext2(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, cb, out) {
+    function withContext2(enclosingDeclaration, flags, internalFlags, tracker, cb) {
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : (internalFlags || 0 /* None */) & 4 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
@@ -55330,7 +55228,6 @@ function createTypeChecker(host) {
         flags: flags || 0 /* None */,
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
-        unfoldDepth: verbosityLevel ?? -1,
         encounteredError: false,
         suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
@@ -55352,18 +55249,13 @@ function createTypeChecker(host) {
         typeParameterNamesByText: void 0,
         typeParameterNamesByTextNextNameCount: void 0,
         enclosingSymbolTypes: /* @__PURE__ */ new Map(),
-        mapper: void 0,
-        depth: 0,
-        couldUnfoldMore: false
+        mapper: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
       if (context.truncating && context.flags & 1 /* NoTruncation */) {
         context.tracker.reportTruncationError();
       }
-      if (out) {
-        out.couldUnfoldMore = context.couldUnfoldMore;
-      }
       return context.encounteredError ? void 0 : resultingNode;
     }
     function addSymbolTypeToContext(context, symbol, type) {
@@ -55382,36 +55274,16 @@ 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 checkTruncationLength(context) {
       if (context.truncating) return context.truncating;
       return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
     }
-    function couldUnfoldType(type, context) {
-      var _a;
-      if ((_a = context.visitedTypes) == null ? void 0 : _a.has(type.id)) {
-        return false;
-      }
-      return context.depth < context.unfoldDepth || context.depth === context.unfoldDepth && !context.couldUnfoldMore;
-    }
-    function canUnfoldType(type, context) {
-      var _a;
-      if ((_a = context.visitedTypes) == null ? void 0 : _a.has(type.id)) {
-        return false;
-      }
-      const result = context.depth < context.unfoldDepth;
-      if (!result) {
-        context.couldUnfoldMore = true;
-      }
-      return result;
-    }
     function typeToTypeNodeHelper(type, context) {
       const restoreFlags = saveRestoreFlags(context);
       const typeNode = typeToTypeNodeWorker(type, context);
@@ -55559,27 +55431,16 @@ function createTypeChecker(host) {
         return factory.createThisTypeNode();
       }
       if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */ || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
-        if (!canUnfoldType(type, context)) {
-          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);
+        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]);
         }
-        context.depth += 1;
+        return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
       }
       const objectFlags = getObjectFlags(type);
       if (objectFlags & 4 /* Reference */) {
         Debug.assert(!!(type.flags & 524288 /* Object */));
-        if (canUnfoldType(type, context)) {
-          context.depth += 1;
-          return createAnonymousTypeNode(
-            type,
-            /*forceClassExpansion*/
-            true
-          );
-        }
         return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
       }
       if (type.flags & 262144 /* TypeParameter */ || objectFlags & 3 /* ClassOrInterface */) {
@@ -55609,14 +55470,6 @@ function createTypeChecker(host) {
             void 0
           );
         }
-        if (objectFlags & 3 /* ClassOrInterface */ && canUnfoldType(type, context)) {
-          context.depth += 1;
-          return createAnonymousTypeNode(
-            type,
-            /*forceClassExpansion*/
-            true
-          );
-        }
         if (type.symbol) {
           return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
         }
@@ -55820,7 +55673,7 @@ function createTypeChecker(host) {
         }
         return result;
       }
-      function createAnonymousTypeNode(type2, forceClassExpansion = false) {
+      function createAnonymousTypeNode(type2) {
         var _a2, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
@@ -55843,7 +55696,7 @@ 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 */ && !forceClassExpansion && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
+          } else if (symbol.flags & 32 /* Class */ && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
             symbol,
             context.enclosingDeclaration,
             isInstanceType,
@@ -55887,7 +55740,7 @@ function createTypeChecker(host) {
         if (id && !context.symbolDepth) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
-        const links = context.unfoldDepth >= 0 ? void 0 : context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
+        const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
         const key = `${getTypeId(type2)}|${context.flags}|${context.internalFlags}`;
         if (links) {
           links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
@@ -56834,7 +56687,7 @@ function createTypeChecker(host) {
       return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
     }
     function typeToTypeNodeHelperWithPossibleReusableTypeNode(type, typeNode, context) {
-      return !couldUnfoldType(type, context) && typeNode && getTypeFromTypeNode2(context, typeNode) === type && syntacticNodeBuilder.tryReuseExistingTypeNode(context, typeNode) || typeToTypeNodeHelper(type, context);
+      return 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);
@@ -57481,7 +57334,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 (!couldUnfoldType(type, context) && decl) {
+      if (decl) {
         if (isAccessor(decl)) {
           result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
         } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) {
@@ -64193,14 +64046,11 @@ function createTypeChecker(host) {
   function isNoInferType(type) {
     return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
   }
-  function isNarrowingSubstitutionType(type) {
-    return !!(type.flags & 33554432 /* Substitution */ && type.objectFlags & 16777216 /* IsNarrowingType */);
+  function getSubstitutionType(baseType, constraint) {
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
   }
-  function getSubstitutionType(baseType, constraint, isNarrowed) {
-    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint, isNarrowed);
-  }
-  function getOrCreateSubstitutionType(baseType, constraint, isNarrowed) {
-    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}${isNarrowed ? ">N" : ""}`;
+  function getOrCreateSubstitutionType(baseType, constraint) {
+    const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
       return cached;
@@ -64208,9 +64058,6 @@ function createTypeChecker(host) {
     const result = createType(33554432 /* Substitution */);
     result.baseType = baseType;
     result.constraint = constraint;
-    if (isNarrowed) {
-      result.objectFlags |= 16777216 /* IsNarrowingType */;
-    }
     substitutionTypes.set(id, result);
     return result;
   }
@@ -66416,7 +66263,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -66433,11 +66280,10 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
-      const effectiveCheckType = forNarrowing && isNarrowingSubstitutionType(checkType) ? checkType.constraint : checkType;
       const checkTypeNode = skipTypeParentheses(root.node.checkType);
       const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
       const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
-      const checkTypeDeferred = isDeferredType(effectiveCheckType, checkTuples);
+      const checkTypeDeferred = isDeferredType(checkType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
         const context = createInferenceContext(
@@ -66456,8 +66302,8 @@ function createTypeChecker(host) {
       }
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
-        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (effectiveCheckType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(effectiveCheckType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (effectiveCheckType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(effectiveCheckType)))) {
+        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
+          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -66474,7 +66320,7 @@ function createTypeChecker(host) {
           result = instantiateType(falseType2, mapper);
           break;
         }
-        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(effectiveCheckType), getRestrictiveInstantiation(inferredExtendsType))) {
+        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
           const trueType2 = getTypeFromTypeNode(root.node.trueType);
           const trueMapper = combinedMapper || mapper;
           if (canTailRecurse(trueType2, trueMapper)) {
@@ -67440,39 +67286,8 @@ function createTypeChecker(host) {
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
-        let distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
-        let narrowingBaseType;
-        const forNarrowing = distributionType && isNarrowingSubstitutionType(distributionType) && isNarrowableConditionalType(type, mapper);
-        if (forNarrowing) {
-          narrowingBaseType = distributionType.baseType;
-          distributionType = getReducedType(distributionType.constraint);
-        }
-        if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
-          if (narrowingBaseType) {
-            result = mapTypeToIntersection(
-              distributionType,
-              (t) => getConditionalType(
-                root,
-                prependTypeMapping(checkType, getSubstitutionType(
-                  narrowingBaseType,
-                  t,
-                  /*isNarrowed*/
-                  true
-                ), newMapper),
-                forConstraint,
-                /*aliasSymbol*/
-                void 0,
-                /*aliasTypeArguments*/
-                void 0,
-                forNarrowing
-              )
-            );
-          } else {
-            result = mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments);
-          }
-        } else {
-          result = getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing);
-        }
+        const distributionType = root.isDistributive ? getReducedType(getMappedType(checkType, newMapper)) : void 0;
+        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
         root.instantiations.set(id, result);
       }
       return result;
@@ -68615,12 +68430,10 @@ function createTypeChecker(host) {
   function shouldNormalizeIntersection(type) {
     let hasInstantiable = false;
     let hasNullableOrEmpty = false;
-    let hasSubstitution = false;
     for (const t of type.types) {
       hasInstantiable || (hasInstantiable = !!(t.flags & 465829888 /* Instantiable */));
       hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 98304 /* Nullable */) || isEmptyAnonymousObjectType(t));
-      hasSubstitution || (hasSubstitution = isNarrowingSubstitutionType(t));
-      if (hasInstantiable && hasNullableOrEmpty || hasSubstitution) return true;
+      if (hasInstantiable && hasNullableOrEmpty) return true;
     }
     return false;
   }
@@ -73780,18 +73593,6 @@ function createTypeChecker(host) {
     }
     return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
   }
-  function mapTypeToIntersection(type, mapper) {
-    if (type.flags & 131072 /* Never */) {
-      return type;
-    }
-    if (!(type.flags & 1048576 /* Union */)) {
-      return mapper(type);
-    }
-    const origin = type.origin;
-    const types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types;
-    const mappedTypes = types.map((t) => t.flags & 1048576 /* Union */ ? mapTypeToIntersection(t, mapper) : mapper(t));
-    return getIntersectionType(mappedTypes);
-  }
   function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
     return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
   }
@@ -75376,11 +75177,11 @@ function createTypeChecker(host) {
     ));
     return contextualType && !isGenericType(contextualType);
   }
-  function getNarrowableTypeForReference(type, reference, checkMode, forReturnTypeNarrowing) {
+  function getNarrowableTypeForReference(type, reference, checkMode) {
     if (isNoInferType(type)) {
       type = type.baseType;
     }
-    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (forReturnTypeNarrowing || isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
+    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
   function isExportOrExportExpression(location) {
@@ -76507,16 +76308,9 @@ function createTypeChecker(host) {
   function getContextualTypeForReturnExpression(node, contextFlags) {
     const func = getContainingFunction(node);
     if (func) {
-      const functionFlags = getFunctionFlags(func);
-      const links = getNodeLinks(node);
-      if (links.contextualReturnType) {
-        if (functionFlags & 2 /* Async */) {
-          return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
-        }
-        return links.contextualReturnType;
-      }
       let contextualReturnType = getContextualReturnType(func, contextFlags);
       if (contextualReturnType) {
+        const functionFlags = getFunctionFlags(func);
         if (functionFlags & 1 /* Generator */) {
           const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
           if (contextualReturnType.flags & 1048576 /* Union */) {
@@ -77214,13 +77008,6 @@ function createTypeChecker(host) {
     if (index >= 0) {
       return contextualTypes[index];
     }
-    const links = getNodeLinks(node);
-    if (links.contextualReturnType) {
-      if (node.flags & 65536 /* AwaitContext */) {
-        return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
-      }
-      return links.contextualReturnType;
-    }
     const { parent: parent2 } = node;
     switch (parent2.kind) {
       case 260 /* VariableDeclaration */:
@@ -88209,199 +87996,7 @@ function createTypeChecker(host) {
     ) : exprType;
     const effectiveExpr = expr && getEffectiveCheckNode(expr);
     const errorNode = inReturnStatement && !inConditionalExpression ? node : effectiveExpr;
-    if (!(unwrappedReturnType.flags & (8388608 /* IndexedAccess */ | 16777216 /* Conditional */)) || !couldContainTypeVariables(unwrappedReturnType)) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
-      return;
-    }
-    if (checkTypeAssignableTo(
-      unwrappedExprType,
-      unwrappedReturnType,
-      /*errorNode*/
-      void 0
-    )) {
-      return;
-    }
-    let narrowPosition = node;
-    let narrowFlowNode = inReturnStatement && node.flowNode;
-    if (expr && isConditionalExpression(expr.parent)) {
-      narrowFlowNode = expr.parent.whenTrue === expr ? expr.parent.flowNodeWhenTrue : expr.parent.flowNodeWhenFalse;
-      narrowPosition = expr;
-    }
-    if (!narrowFlowNode) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
-      return;
-    }
-    const allTypeParameters = appendTypeParameters(getOuterTypeParameters(
-      container,
-      /*includeThisTypes*/
-      false
-    ), getEffectiveTypeParameterDeclarations(container));
-    const narrowableTypeParameters = allTypeParameters && getNarrowableTypeParameters(allTypeParameters);
-    if (!narrowableTypeParameters || !narrowableTypeParameters.length || !isNarrowableReturnType(unwrappedReturnType)) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
-      return;
-    }
-    const narrowedTypeParameters = [];
-    const narrowedTypes = [];
-    for (const [typeParam, symbol, reference] of narrowableTypeParameters) {
-      const narrowReference = factory.cloneNode(reference);
-      narrowReference.id = void 0;
-      getNodeLinks(narrowReference).resolvedSymbol = symbol;
-      setParent(narrowReference, narrowPosition.parent);
-      narrowReference.flowNode = narrowFlowNode;
-      const initialType = getNarrowableTypeForReference(
-        typeParam,
-        narrowReference,
-        /*checkMode*/
-        void 0,
-        /*forReturnTypeNarrowing*/
-        true
-      );
-      if (initialType === typeParam) {
-        continue;
-      }
-      const flowType = getFlowTypeOfReference(narrowReference, initialType);
-      const exprType2 = getTypeFromFlowType(flowType);
-      if (exprType2.flags & 3 /* AnyOrUnknown */ || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
-        continue;
-      }
-      const narrowedType = getSubstitutionType(
-        typeParam,
-        exprType2,
-        /*isNarrowed*/
-        true
-      );
-      narrowedTypeParameters.push(typeParam);
-      narrowedTypes.push(narrowedType);
-    }
-    const narrowMapper = createTypeMapper(narrowedTypeParameters, narrowedTypes);
-    const narrowedReturnType = instantiateType(
-      unwrappedReturnType,
-      narrowMapper
-    );
-    if (expr) {
-      const links = getNodeLinks(expr);
-      if (!links.contextualReturnType) {
-        links.contextualReturnType = narrowedReturnType;
-      }
-    }
-    const narrowedExprType = expr ? checkExpression(expr) : undefinedType;
-    const narrowedUnwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
-      narrowedExprType,
-      /*withAlias*/
-      false,
-      node,
-      Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-    ) : narrowedExprType;
-    checkTypeAssignableToAndOptionallyElaborate(narrowedUnwrappedExprType, narrowedReturnType, errorNode, effectiveExpr);
-  }
-  function getNarrowableTypeParameters(candidates) {
-    const narrowableParams = [];
-    for (const typeParam of candidates) {
-      const constraint = getConstraintOfTypeParameter(typeParam);
-      if (!constraint || !(constraint.flags & 1048576 /* Union */)) continue;
-      if (typeParam.symbol && typeParam.symbol.declarations && typeParam.symbol.declarations.length === 1) {
-        const declaration = typeParam.symbol.declarations[0];
-        const container = isJSDocTemplateTag(declaration.parent) ? getJSDocHost(declaration.parent) : declaration.parent;
-        if (!isFunctionLike(container)) continue;
-        let reference;
-        let hasInvalidReference = false;
-        for (const paramDecl of container.parameters) {
-          const typeNode = getEffectiveTypeAnnotationNode(paramDecl);
-          if (!typeNode) continue;
-          if (isTypeParameterReferenced(typeParam, typeNode)) {
-            let candidateReference;
-            if (isTypeReferenceNode(typeNode) && isReferenceToTypeParameter(typeParam, typeNode) && (candidateReference = getValidParameterReference(paramDecl, constraint))) {
-              if (reference) {
-                hasInvalidReference = true;
-                break;
-              }
-              reference = candidateReference;
-            } else {
-              hasInvalidReference = true;
-              break;
-            }
-          }
-        }
-        if (!hasInvalidReference && reference) {
-          const symbol = getResolvedSymbol(reference);
-          if (symbol !== unknownSymbol) narrowableParams.push([typeParam, symbol, reference]);
-        }
-      }
-    }
-    return narrowableParams;
-    function getValidParameterReference(paramDecl, constraint) {
-      if (!isIdentifier(paramDecl.name)) return;
-      const isOptional = !!paramDecl.questionToken || isJSDocOptionalParameter(paramDecl);
-      if (isOptional && !containsUndefinedType(constraint)) return;
-      return paramDecl.name;
-    }
-    function isReferenceToTypeParameter(typeParam, node) {
-      return getTypeFromTypeReference(node) === typeParam;
-    }
-    function isTypeParameterReferenced(typeParam, node) {
-      return isReferenced(node);
-      function isReferenced(node2) {
-        if (isTypeReferenceNode(node2)) {
-          return isReferenceToTypeParameter(typeParam, node2);
-        }
-        if (isTypeQueryNode(node2)) {
-          return isTypeParameterPossiblyReferenced(typeParam, node2);
-        }
-        return !!forEachChild(node2, isReferenced);
-      }
-    }
-  }
-  function isNarrowableReturnType(returnType) {
-    return isConditionalType(returnType) ? isNarrowableConditionalType(returnType) : !!(returnType.indexType.flags & 262144 /* TypeParameter */);
-  }
-  function isNarrowableConditionalType(type, mapper) {
-    const typeArguments = mapper && map(type.root.outerTypeParameters, (t) => {
-      const mapped = getMappedType(t, mapper);
-      if (isNarrowingSubstitutionType(mapped)) {
-        return mapped.baseType;
-      }
-      return mapped;
-    });
-    const id = `${type.id}:${getTypeListId(typeArguments)}`;
-    let result = narrowableReturnTypeCache.get(id);
-    if (result === void 0) {
-      const nonNarrowingMapper = type.root.outerTypeParameters && typeArguments && createTypeMapper(type.root.outerTypeParameters, typeArguments);
-      const instantiatedType = instantiateType(type, nonNarrowingMapper);
-      result = isConditionalType(instantiatedType) && isNarrowableConditionalTypeWorker(instantiatedType);
-      narrowableReturnTypeCache.set(id, result);
-    }
-    return result;
-  }
-  function isNarrowableConditionalTypeWorker(type) {
-    if (!type.root.isDistributive) {
-      return false;
-    }
-    if (type.root.inferTypeParameters) {
-      return false;
-    }
-    if (!(type.checkType.flags & 262144 /* TypeParameter */)) {
-      return false;
-    }
-    const constraintType = getConstraintOfTypeParameter(type.checkType);
-    if (!constraintType || !(constraintType.flags & 1048576 /* Union */)) {
-      return false;
-    }
-    if (!everyType(type.extendsType, (extendsType) => some(
-      constraintType.types,
-      (constraintType2) => isTypeIdenticalTo(constraintType2, extendsType)
-    ))) {
-      return false;
-    }
-    const trueType2 = getTrueTypeFromConditionalType(type);
-    const isValidTrueType = isConditionalType(trueType2) ? isNarrowableConditionalType(trueType2) : true;
-    if (!isValidTrueType) return false;
-    const falseType2 = getFalseTypeFromConditionalType(type);
-    const isValidFalseType = isConditionalType(falseType2) ? isNarrowableConditionalType(falseType2) : falseType2 === neverType;
-    return isValidFalseType;
-  }
-  function isConditionalType(type) {
-    return !!(type.flags & 16777216 /* Conditional */);
+    checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
   }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
@@ -90011,7 +89606,7 @@ function createTypeChecker(host) {
         );
       }
       if (moduleKind === 199 /* NodeNext */ && !isImportAttributes2) {
-        return grammarErrorOnFirstToken(node, Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_asserts);
+        return grammarErrorOnFirstToken(node, Diagnostics.Import_assertions_have_been_replaced_by_import_attributes_Use_with_instead_of_assert);
       }
       if (declaration.moduleSpecifier && getEmitSyntaxForModuleSpecifierExpression(declaration.moduleSpecifier) === 1 /* CommonJS */) {
         return grammarErrorOnNode(
@@ -90078,11 +89673,10 @@ function createTypeChecker(host) {
       return;
     }
     checkGrammarModifiers(node);
-    const isImportEquals = isInternalModuleImportEqualsDeclaration(node);
-    if (compilerOptions.erasableSyntaxOnly && isImportEquals && !(node.flags & 33554432 /* Ambient */)) {
+    if (compilerOptions.erasableSyntaxOnly && !(node.flags & 33554432 /* Ambient */)) {
       error2(node, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled);
     }
-    if (isImportEquals || checkExternalImportOrExportDeclaration(node)) {
+    if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
       checkImportBinding(node);
       markLinkedReferences(node, 6 /* ExportImportEquals */);
       if (node.moduleReference.kind !== 283 /* ExternalModuleReference */) {
@@ -90202,6 +89796,9 @@ function createTypeChecker(host) {
     if (checkGrammarModuleElementContext(node, illegalContextMessage)) {
       return;
     }
+    if (compilerOptions.erasableSyntaxOnly && node.isExportEquals && !(node.flags & 33554432 /* Ambient */)) {
+      error2(node, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled);
+    }
     const container = node.parent.kind === 307 /* SourceFile */ ? node.parent : node.parent.parent;
     if (container.kind === 267 /* ModuleDeclaration */ && !isAmbientModule(container)) {
       if (node.isExportEquals) {
@@ -91199,7 +90796,7 @@ function createTypeChecker(host) {
         name,
         meaning,
         /*ignoreErrors*/
-        false,
+        true,
         /*dontResolveAlias*/
         true
       );
@@ -91209,7 +90806,9 @@ function createTypeChecker(host) {
       return resolveEntityName(
         name,
         /*meaning*/
-        1 /* FunctionScopedVariable */
+        1 /* FunctionScopedVariable */,
+        /*ignoreErrors*/
+        true
       );
     }
     return void 0;
@@ -91394,7 +90993,12 @@ function createTypeChecker(host) {
   }
   function getShorthandAssignmentValueSymbol(location) {
     if (location && location.kind === 304 /* ShorthandPropertyAssignment */) {
-      return resolveEntityName(location.name, 111551 /* Value */ | 2097152 /* Alias */);
+      return resolveEntityName(
+        location.name,
+        111551 /* Value */ | 2097152 /* Alias */,
+        /*ignoreErrors*/
+        true
+      );
     }
     return void 0;
   }
@@ -91403,10 +91007,20 @@ function createTypeChecker(host) {
       const name = node.propertyName || node.name;
       return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : name.kind === 11 /* StringLiteral */ ? void 0 : (
         // Skip for invalid syntax like this: export { "x" }
-        resolveEntityName(name, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)
+        resolveEntityName(
+          name,
+          111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
+          /*ignoreErrors*/
+          true
+        )
       );
     } else {
-      return resolveEntityName(node, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */);
+      return resolveEntityName(
+        node,
+        111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
+        /*ignoreErrors*/
+        true
+      );
     }
   }
   function getTypeOfNode(node) {
@@ -117054,7 +116668,7 @@ function transformECMAScriptModule(context) {
         if (node === (importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim[0])) {
           return visitImportOrRequireCall(importsAndRequiresToRewriteOrShim.shift());
         }
-        break;
+      // fallthrough
       default:
         if ((importsAndRequiresToRewriteOrShim == null ? void 0 : importsAndRequiresToRewriteOrShim.length) && rangeContainsRange(node, importsAndRequiresToRewriteOrShim[0])) {
           return visitEachChild(node, visitor, context);
@@ -140640,9 +140254,9 @@ function mapToDisplayParts(writeDisplayParts) {
     displayPartWriter.clear();
   }
 }
-function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = 0 /* None */, verbosityLevel, out) {
+function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = 0 /* None */) {
   return mapToDisplayParts((writer) => {
-    typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer, verbosityLevel, out);
+    typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer);
   });
 }
 function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags = 0 /* None */) {
@@ -147254,7 +146868,7 @@ function getUsageInfo(oldFile, toMove, checker, existingTargetLocals = /* @__PUR
   const unusedImportsFromOldFile = /* @__PURE__ */ new Set();
   for (const statement of toMove) {
     forEachReference(statement, checker, enclosingRange, (symbol, isValidTypeOnlyUseSite) => {
-      if (!symbol.declarations) {
+      if (!some(symbol.declarations)) {
         return;
       }
       if (existingTargetLocals.has(skipAlias(symbol, checker))) {
@@ -152607,7 +152221,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     synchronizeHostData();
     return ts_Completions_exports.getCompletionEntrySymbol(program, log, getValidSourceFile(fileName), position, { name, source }, host, preferences);
   }
-  function getQuickInfoAtPosition(fileName, position, verbosityLevel) {
+  function getQuickInfoAtPosition(fileName, position) {
     synchronizeHostData();
     const sourceFile = getValidSourceFile(fileName);
     const node = getTouchingPropertyName(sourceFile, position);
@@ -152623,41 +152237,19 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
         kind: "" /* unknown */,
         kindModifiers: "" /* none */,
         textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
-        displayParts: typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => typeToDisplayParts(
-          typeChecker2,
-          type,
-          getContainerNode(nodeForQuickInfo),
-          /*flags*/
-          void 0,
-          verbosityLevel
-        )),
+        displayParts: typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => typeToDisplayParts(typeChecker2, type, getContainerNode(nodeForQuickInfo))),
         documentation: type.symbol ? type.symbol.getDocumentationComment(typeChecker) : void 0,
         tags: type.symbol ? type.symbol.getJsDocTags(typeChecker) : void 0
       };
     }
-    const { symbolKind, displayParts, documentation, tags, canIncreaseVerbosityLevel } = typeChecker.runWithCancellationToken(
-      cancellationToken,
-      (typeChecker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(
-        typeChecker2,
-        symbol,
-        sourceFile,
-        getContainerNode(nodeForQuickInfo),
-        nodeForQuickInfo,
-        /*semanticMeaning*/
-        void 0,
-        /*alias*/
-        void 0,
-        verbosityLevel
-      )
-    );
+    const { symbolKind, displayParts, documentation, tags } = typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker2, symbol, sourceFile, getContainerNode(nodeForQuickInfo), nodeForQuickInfo));
     return {
       kind: symbolKind,
       kindModifiers: ts_SymbolDisplay_exports.getSymbolModifiers(typeChecker, symbol),
       textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
       displayParts,
       documentation,
-      tags,
-      canIncreaseVerbosityLevel
+      tags
     };
   }
   function preparePasteEditsForFile(fileName, copiedTextRange) {
@@ -177733,7 +177325,7 @@ function getSymbolModifiers(typeChecker, symbol) {
   }
   return modifiers.size > 0 ? arrayFrom(modifiers.values()).join(",") : "" /* none */;
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias, verbosityLevel) {
+function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias) {
   var _a;
   const displayParts = [];
   let documentation = [];
@@ -177745,7 +177337,6 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
   let documentationFromAlias;
   let tagsFromAlias;
   let hasMultipleSignatures = false;
-  const typeWriterOut = verbosityLevel !== void 0 ? { couldUnfoldMore: false } : void 0;
   if (location.kind === 110 /* ThisKeyword */ && !isThisExpression) {
     return { displayParts: [keywordPart(110 /* ThisKeyword */)], documentation: [], symbolKind: "primitive type" /* primitiveType */, tags: void 0 };
   }
@@ -177905,17 +177496,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     displayParts.push(spacePart());
     displayParts.push(operatorPart(64 /* EqualsToken */));
     displayParts.push(spacePart());
-    addRange(
-      displayParts,
-      typeToDisplayParts(
-        typeChecker,
-        location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol),
-        enclosingDeclaration,
-        8388608 /* InTypeAlias */,
-        verbosityLevel,
-        typeWriterOut
-      )
-    );
+    addRange(displayParts, typeToDisplayParts(typeChecker, location.parent && isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
   }
   if (symbolFlags & 384 /* Enum */) {
     prefixNextMeaning();
@@ -178074,32 +177655,12 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
           displayParts.push(spacePart());
           if (type.symbol && type.symbol.flags & 262144 /* TypeParameter */ && symbolKind !== "index" /* indexSignatureElement */) {
             const typeParameterParts = mapToDisplayParts((writer) => {
-              const param = typeChecker.typeParameterToDeclaration(
-                type,
-                enclosingDeclaration,
-                symbolDisplayNodeBuilderFlags,
-                /*internalFlags*/
-                void 0,
-                /*tracker*/
-                void 0,
-                verbosityLevel
-              );
+              const param = typeChecker.typeParameterToDeclaration(type, enclosingDeclaration, symbolDisplayNodeBuilderFlags);
               getPrinter().writeNode(4 /* Unspecified */, param, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration)), writer);
             });
             addRange(displayParts, typeParameterParts);
           } else {
-            addRange(
-              displayParts,
-              typeToDisplayParts(
-                typeChecker,
-                type,
-                enclosingDeclaration,
-                /*flags*/
-                void 0,
-                verbosityLevel,
-                typeWriterOut
-              )
-            );
+            addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration));
           }
           if (isTransientSymbol(symbol) && symbol.links.target && isTransientSymbol(symbol.links.target) && symbol.links.target.links.tupleLabelDeclaration) {
             const labelDecl = symbol.links.target.links.tupleLabelDeclaration;
@@ -178164,13 +177725,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
   if (tags.length === 0 && tagsFromAlias) {
     tags = tagsFromAlias;
   }
-  return {
-    displayParts,
-    documentation,
-    symbolKind,
-    tags: tags.length === 0 ? void 0 : tags,
-    canIncreaseVerbosityLevel: typeWriterOut == null ? void 0 : typeWriterOut.couldUnfoldMore
-  };
+  return { displayParts, documentation, symbolKind, tags: tags.length === 0 ? void 0 : tags };
   function getPrinter() {
     return createPrinterWithRemoveComments();
   }
@@ -178283,7 +177838,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
     addRange(displayParts, typeParameterParts);
   }
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias, verbosityLevel) {
+function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
   return getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
     typeChecker,
     symbol,
@@ -178293,8 +177848,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
     /*type*/
     void 0,
     semanticMeaning,
-    alias,
-    verbosityLevel
+    alias
   );
 }
 function isLocalVariableOrFunction(symbol) {
@@ -195244,7 +194798,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
   getQuickInfoWorker(args, simplifiedResult) {
     const { file, project } = this.getFileAndProject(args);
     const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
-    const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo), args.verbosityLevel);
+    const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo));
     if (!quickInfo) {
       return void 0;
     }
@@ -195258,8 +194812,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
         end: scriptInfo.positionToLineOffset(textSpanEnd(quickInfo.textSpan)),
         displayString,
         documentation: useDisplayParts ? this.mapDisplayParts(quickInfo.documentation, project) : displayPartsToString(quickInfo.documentation),
-        tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts),
-        canIncreaseVerbosityLevel: quickInfo.canIncreaseVerbosityLevel
+        tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts)
       };
     } else {
       return useDisplayParts ? quickInfo : {