@typescript-deploys/pr-build 5.7.0-pr-56941-53 → 5.8.0-pr-52972-10

package/lib/_tsc.js

@@ -17,8 +17,8 @@ and limitations under the License.
 "use strict";
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-insiders.20241007`;
+var versionMajorMinor = "5.8";
+var version = `${versionMajorMinor}.0-insiders.20241127`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3680,7 +3680,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
   ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
   ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
-  ObjectFlags3[ObjectFlags3["IsNarrowedType"] = 16777216] = "IsNarrowedType";
+  ObjectFlags3[ObjectFlags3["IsNarrowingType"] = 16777216] = "IsNarrowingType";
   ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
   ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
@@ -15068,7 +15068,7 @@ function tryGetModuleSpecifierFromDeclaration(node) {
   }
 }
 function shouldRewriteModuleSpecifier(specifier, compilerOptions) {
-  return !!compilerOptions.rewriteRelativeImportExtensions && pathIsRelative(specifier) && !isDeclarationFileName(specifier);
+  return !!compilerOptions.rewriteRelativeImportExtensions && pathIsRelative(specifier) && !isDeclarationFileName(specifier) && hasTSFileExtension(specifier);
 }
 function getExternalModuleName(node) {
   switch (node.kind) {
@@ -15158,12 +15158,12 @@ function canHaveFlowNode(node) {
     case 80 /* Identifier */:
     case 110 /* ThisKeyword */:
     case 108 /* SuperKeyword */:
-    case 212 /* ElementAccessExpression */:
-    case 211 /* PropertyAccessExpression */:
-    case 218 /* FunctionExpression */:
     case 166 /* QualifiedName */:
     case 236 /* MetaProperty */:
+    case 212 /* ElementAccessExpression */:
+    case 211 /* PropertyAccessExpression */:
     case 208 /* BindingElement */:
+    case 218 /* FunctionExpression */:
     case 219 /* ArrowFunction */:
     case 174 /* MethodDeclaration */:
     case 177 /* GetAccessor */:
@@ -16086,7 +16086,7 @@ function hasInvalidEscape(template) {
 }
 var doubleQuoteEscapedCharsRegExp = /[\\"\u0000-\u001f\u2028\u2029\u0085]/g;
 var singleQuoteEscapedCharsRegExp = /[\\'\u0000-\u001f\u2028\u2029\u0085]/g;
-var backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u001f\u2028\u2029\u0085]/g;
+var backtickQuoteEscapedCharsRegExp = /\r\n|[\\`\u0000-\u0009\u000b-\u001f\u2028\u2029\u0085]/g;
 var escapedCharsMap = new Map(Object.entries({
   "	": "\\t",
   "\v": "\\v",
@@ -17377,6 +17377,13 @@ function getLastChild(node) {
   });
   return lastChild;
 }
+function addToSeen(seen, key) {
+  if (seen.has(key)) {
+    return false;
+  }
+  seen.add(key);
+  return true;
+}
 function isTypeNodeKind(kind) {
   return kind >= 182 /* FirstTypeNode */ && kind <= 205 /* LastTypeNode */ || kind === 133 /* AnyKeyword */ || kind === 159 /* UnknownKeyword */ || kind === 150 /* NumberKeyword */ || kind === 163 /* BigIntKeyword */ || kind === 151 /* ObjectKeyword */ || kind === 136 /* BooleanKeyword */ || kind === 154 /* StringKeyword */ || kind === 155 /* SymbolKeyword */ || kind === 116 /* VoidKeyword */ || kind === 157 /* UndefinedKeyword */ || kind === 146 /* NeverKeyword */ || kind === 141 /* IntrinsicKeyword */ || kind === 233 /* ExpressionWithTypeArguments */ || kind === 312 /* JSDocAllType */ || kind === 313 /* JSDocUnknownType */ || kind === 314 /* JSDocNullableType */ || kind === 315 /* JSDocNonNullableType */ || kind === 316 /* JSDocOptionalType */ || kind === 317 /* JSDocFunctionType */ || kind === 318 /* JSDocVariadicType */;
 }
@@ -22447,6 +22454,8 @@ function createNodeFactory(flags, baseFactory2) {
     node.colonToken = colonToken ?? createToken(59 /* ColonToken */);
     node.whenFalse = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenFalse);
     node.transformFlags |= propagateChildFlags(node.condition) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.whenTrue) | propagateChildFlags(node.colonToken) | propagateChildFlags(node.whenFalse);
+    node.flowNodeWhenFalse = void 0;
+    node.flowNodeWhenTrue = void 0;
     return node;
   }
   function updateConditionalExpression(node, condition, questionToken, whenTrue, colonToken, whenFalse) {
@@ -24250,7 +24259,7 @@ function createNodeFactory(flags, baseFactory2) {
   function isIgnorableParen(node) {
     return isParenthesizedExpression(node) && nodeIsSynthesized(node) && nodeIsSynthesized(getSourceMapRange(node)) && nodeIsSynthesized(getCommentRange(node)) && !some(getSyntheticLeadingComments(node)) && !some(getSyntheticTrailingComments(node));
   }
-  function restoreOuterExpressions(outerExpression, innerExpression, kinds = 31 /* All */) {
+  function restoreOuterExpressions(outerExpression, innerExpression, kinds = 63 /* All */) {
     if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
       return updateOuterExpression(
         outerExpression,
@@ -24296,7 +24305,7 @@ function createNodeFactory(flags, baseFactory2) {
     }
   }
   function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers = false) {
-    const callee = skipOuterExpressions(expression, 31 /* All */);
+    const callee = skipOuterExpressions(expression, 63 /* All */);
     let thisArg;
     let target;
     if (isSuperProperty(callee)) {
@@ -26006,13 +26015,23 @@ var importStarHelper = {
   dependencies: [createBindingHelper, setModuleDefaultHelper],
   priority: 2,
   text: `
-            var __importStar = (this && this.__importStar) || function (mod) {
-                if (mod && mod.__esModule) return mod;
-                var result = {};
-                if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-                __setModuleDefault(result, mod);
-                return result;
-            };`
+            var __importStar = (this && this.__importStar) || (function () {
+                var ownKeys = function(o) {
+                    ownKeys = Object.getOwnPropertyNames || function (o) {
+                        var ar = [];
+                        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+                        return ar;
+                    };
+                    return ownKeys(o);
+                };
+                return function (mod) {
+                    if (mod && mod.__esModule) return mod;
+                    var result = {};
+                    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+                    __setModuleDefault(result, mod);
+                    return result;
+                };
+            })();`
 };
 var importDefaultHelper = {
   name: "typescript:commonjsimportdefault",
@@ -27155,7 +27174,7 @@ function getJSDocTypeAssertionType(node) {
   Debug.assertIsDefined(type);
   return type;
 }
-function isOuterExpression(node, kinds = 31 /* All */) {
+function isOuterExpression(node, kinds = 63 /* All */) {
   switch (node.kind) {
     case 217 /* ParenthesizedExpression */:
       if (kinds & -2147483648 /* ExcludeJSDocTypeAssertion */ && isJSDocTypeAssertion(node)) {
@@ -27164,8 +27183,9 @@ function isOuterExpression(node, kinds = 31 /* All */) {
       return (kinds & 1 /* Parentheses */) !== 0;
     case 216 /* TypeAssertionExpression */:
     case 234 /* AsExpression */:
-    case 238 /* SatisfiesExpression */:
       return (kinds & 2 /* TypeAssertions */) !== 0;
+    case 238 /* SatisfiesExpression */:
+      return (kinds & (2 /* TypeAssertions */ | 32 /* Satisfies */)) !== 0;
     case 233 /* ExpressionWithTypeArguments */:
       return (kinds & 16 /* ExpressionsWithTypeArguments */) !== 0;
     case 235 /* NonNullExpression */:
@@ -27175,13 +27195,13 @@ function isOuterExpression(node, kinds = 31 /* All */) {
   }
   return false;
 }
-function skipOuterExpressions(node, kinds = 31 /* All */) {
+function skipOuterExpressions(node, kinds = 63 /* All */) {
   while (isOuterExpression(node, kinds)) {
     node = node.expression;
   }
   return node;
 }
-function walkUpOuterExpressions(node, kinds = 31 /* All */) {
+function walkUpOuterExpressions(node, kinds = 63 /* All */) {
   let parent = node.parent;
   while (isOuterExpression(parent, kinds)) {
     parent = parent.parent;
@@ -29532,10 +29552,12 @@ var Parser;
       case 90 /* DefaultKeyword */:
         return nextTokenCanFollowDefaultKeyword();
       case 126 /* StaticKeyword */:
+        nextToken();
+        return canFollowModifier();
       case 139 /* GetKeyword */:
       case 153 /* SetKeyword */:
         nextToken();
-        return canFollowModifier();
+        return canFollowGetOrSetKeyword();
       default:
         return nextTokenIsOnSameLineAndCanFollowModifier();
     }
@@ -29553,6 +29575,9 @@ var Parser;
   function canFollowModifier() {
     return token() === 23 /* OpenBracketToken */ || token() === 19 /* OpenBraceToken */ || token() === 42 /* AsteriskToken */ || token() === 26 /* DotDotDotToken */ || isLiteralPropertyName();
   }
+  function canFollowGetOrSetKeyword() {
+    return token() === 23 /* OpenBracketToken */ || isLiteralPropertyName();
+  }
   function nextTokenCanFollowDefaultKeyword() {
     nextToken();
     return token() === 86 /* ClassKeyword */ || token() === 100 /* FunctionKeyword */ || token() === 120 /* InterfaceKeyword */ || token() === 60 /* AtToken */ || token() === 128 /* AbstractKeyword */ && lookAhead(nextTokenIsClassKeywordOnSameLine) || token() === 134 /* AsyncKeyword */ && lookAhead(nextTokenIsFunctionKeywordOnSameLine);
@@ -36078,6 +36103,7 @@ var libEntries = [
   ["esnext.regexp", "lib.es2024.regexp.d.ts"],
   ["esnext.string", "lib.es2024.string.d.ts"],
   ["esnext.iterator", "lib.esnext.iterator.d.ts"],
+  ["esnext.promise", "lib.esnext.promise.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -38163,7 +38189,7 @@ function convertToTSConfig(configParseResult, configFileName, host) {
   const providedKeys = new Set(optionMap.keys());
   const impliedCompilerOptions = {};
   for (const option in computedOptions) {
-    if (!providedKeys.has(option) && some(computedOptions[option].dependencies, (dep) => providedKeys.has(dep))) {
+    if (!providedKeys.has(option) && optionDependsOn(option, providedKeys)) {
       const implied = computedOptions[option].computeValue(configParseResult.options);
       const defaultValue = computedOptions[option].computeValue({});
       if (implied !== defaultValue) {
@@ -38174,6 +38200,17 @@ function convertToTSConfig(configParseResult, configFileName, host) {
   assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
   return config;
 }
+function optionDependsOn(option, dependsOn) {
+  const seen = /* @__PURE__ */ new Set();
+  return optionDependsOnRecursive(option);
+  function optionDependsOnRecursive(option2) {
+    var _a;
+    if (addToSeen(seen, option2)) {
+      return some((_a = computedOptions[option2]) == null ? void 0 : _a.dependencies, (dep) => dependsOn.has(dep) || optionDependsOnRecursive(dep));
+    }
+    return false;
+  }
+}
 function optionMapToObject(optionMap) {
   return Object.fromEntries(optionMap);
 }
@@ -40474,25 +40511,28 @@ function nodeModuleNameResolverWorker(features, moduleName, containingDirectory,
       return toSearchResult({ resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) });
     }
     if (!isExternalModuleNameRelative(moduleName)) {
-      let resolved2;
       if (features & 2 /* Imports */ && startsWith(moduleName, "#")) {
-        resolved2 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
-      }
-      if (!resolved2 && features & 4 /* SelfName */) {
-        resolved2 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        const resolved3 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        if (resolved3) {
+          return resolved3.value && { value: { resolved: resolved3.value, isExternalLibraryImport: false } };
+        }
       }
-      if (!resolved2) {
-        if (moduleName.includes(":")) {
-          if (traceEnabled) {
-            trace(host, Diagnostics.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
-          }
-          return void 0;
+      if (features & 4 /* SelfName */) {
+        const resolved3 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        if (resolved3) {
+          return resolved3.value && { value: { resolved: resolved3.value, isExternalLibraryImport: false } };
         }
+      }
+      if (moduleName.includes(":")) {
         if (traceEnabled) {
-          trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
+          trace(host, Diagnostics.Skipping_module_0_that_looks_like_an_absolute_URI_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
         }
-        resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
+        return void 0;
       }
+      if (traceEnabled) {
+        trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
+      }
+      let resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state2, cache, redirectedReference);
       if (extensions2 & 4 /* Declaration */) {
         resolved2 ?? (resolved2 = resolveFromTypeRoot(moduleName, state2));
       }
@@ -40920,7 +40960,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec
       mainExport = scope.contents.packageJsonContent.exports["."];
     }
     if (mainExport) {
-      const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(
+      const loadModuleFromTargetExportOrImport = getLoadModuleFromTargetExportOrImport(
         extensions,
         state,
         cache,
@@ -40930,7 +40970,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec
         /*isImports*/
         false
       );
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         mainExport,
         "",
         /*pattern*/
@@ -40948,7 +40988,7 @@ function loadModuleFromExports(scope, extensions, subpath, state, cache, redirec
         void 0
       );
     }
-    const result = loadModuleFromImportsOrExports(
+    const result = loadModuleFromExportsOrImports(
       extensions,
       state,
       cache,
@@ -41002,7 +41042,7 @@ function loadModuleFromImports(extensions, moduleName, directory, state, cache,
       void 0
     );
   }
-  const result = loadModuleFromImportsOrExports(
+  const result = loadModuleFromExportsOrImports(
     extensions,
     state,
     cache,
@@ -41037,11 +41077,11 @@ function comparePatternKeys(a, b) {
   if (b.length > a.length) return 1 /* GreaterThan */;
   return 0 /* EqualTo */;
 }
-function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
-  const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
+function loadModuleFromExportsOrImports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
+  const loadModuleFromTargetExportOrImport = getLoadModuleFromTargetExportOrImport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
   if (!endsWith(moduleName, directorySeparator) && !moduleName.includes("*") && hasProperty(lookupTable, moduleName)) {
     const target = lookupTable[moduleName];
-    return loadModuleFromTargetImportOrExport(
+    return loadModuleFromTargetExportOrImport(
       target,
       /*subpath*/
       "",
@@ -41056,7 +41096,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe
       const target = lookupTable[potentialTarget];
       const starPos = potentialTarget.indexOf("*");
       const subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos));
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         target,
         subpath,
         /*pattern*/
@@ -41066,7 +41106,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe
     } else if (endsWith(potentialTarget, "*") && startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) {
       const target = lookupTable[potentialTarget];
       const subpath = moduleName.substring(potentialTarget.length - 1);
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         target,
         subpath,
         /*pattern*/
@@ -41076,7 +41116,7 @@ function loadModuleFromImportsOrExports(extensions, state, cache, redirectedRefe
     } else if (startsWith(moduleName, potentialTarget)) {
       const target = lookupTable[potentialTarget];
       const subpath = moduleName.substring(potentialTarget.length);
-      return loadModuleFromTargetImportOrExport(
+      return loadModuleFromTargetExportOrImport(
         target,
         subpath,
         /*pattern*/
@@ -41096,9 +41136,9 @@ function hasOneAsterisk(patternKey) {
   const firstStar = patternKey.indexOf("*");
   return firstStar !== -1 && firstStar === patternKey.lastIndexOf("*");
 }
-function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
-  return loadModuleFromTargetImportOrExport;
-  function loadModuleFromTargetImportOrExport(target, subpath, pattern, key) {
+function getLoadModuleFromTargetExportOrImport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
+  return loadModuleFromTargetExportOrImport;
+  function loadModuleFromTargetExportOrImport(target, subpath, pattern, key) {
     if (typeof target === "string") {
       if (!pattern && subpath.length > 0 && !endsWith(target, "/")) {
         if (state.traceEnabled) {
@@ -41188,7 +41228,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
           if (condition === "default" || state.conditions.includes(condition) || isApplicableVersionedTypesKey(state.conditions, condition)) {
             traceIfEnabled(state, Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition);
             const subTarget = target[condition];
-            const result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key);
+            const result = loadModuleFromTargetExportOrImport(subTarget, subpath, pattern, key);
             if (result) {
               traceIfEnabled(state, Diagnostics.Resolved_under_condition_0, condition);
               traceIfEnabled(state, Diagnostics.Exiting_conditional_exports);
@@ -41213,7 +41253,7 @@ function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirec
           );
         }
         for (const elem of target) {
-          const result = loadModuleFromTargetImportOrExport(elem, subpath, pattern, key);
+          const result = loadModuleFromTargetExportOrImport(elem, subpath, pattern, key);
           if (result) {
             return result;
           }
@@ -41873,7 +41913,7 @@ function createBinder() {
   var preSwitchCaseFlow;
   var activeLabelList;
   var hasExplicitReturn;
-  var inReturnStatement;
+  var inReturnPosition;
   var hasFlowEffects;
   var emitFlags;
   var inStrictMode;
@@ -41946,7 +41986,7 @@ function createBinder() {
     currentExceptionTarget = void 0;
     activeLabelList = void 0;
     hasExplicitReturn = false;
-    inReturnStatement = false;
+    inReturnPosition = false;
     hasFlowEffects = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
@@ -42183,6 +42223,8 @@ function createBinder() {
     const saveContainer = container;
     const saveThisParentContainer = thisParentContainer;
     const savedBlockScopeContainer = blockScopeContainer;
+    const savedInReturnPosition = inReturnPosition;
+    if (node.kind === 219 /* ArrowFunction */ && node.body.kind !== 241 /* Block */) inReturnPosition = true;
     if (containerFlags & 1 /* IsContainer */) {
       if (node.kind !== 219 /* ArrowFunction */) {
         thisParentContainer = container;
@@ -42260,6 +42302,7 @@ function createBinder() {
     } else {
       bindChildren(node);
     }
+    inReturnPosition = savedInReturnPosition;
     container = saveContainer;
     thisParentContainer = saveThisParentContainer;
     blockScopeContainer = savedBlockScopeContainer;
@@ -42711,10 +42754,10 @@ function createBinder() {
     currentFlow = finishFlowLabel(postIfLabel);
   }
   function bindReturnOrThrow(node) {
-    const oldInReturnStatement = inReturnStatement;
-    inReturnStatement = true;
+    const savedInReturnPosition = inReturnPosition;
+    inReturnPosition = true;
     bind(node.expression);
-    inReturnStatement = oldInReturnStatement;
+    inReturnPosition = savedInReturnPosition;
     if (node.kind === 253 /* ReturnStatement */) {
       hasExplicitReturn = true;
       if (currentReturnTarget) {
@@ -43075,14 +43118,14 @@ function createBinder() {
     hasFlowEffects = false;
     bindCondition(node.condition, trueLabel, falseLabel);
     currentFlow = finishFlowLabel(trueLabel);
-    if (inReturnStatement) {
+    if (inReturnPosition) {
       node.flowNodeWhenTrue = currentFlow;
     }
     bind(node.questionToken);
     bind(node.whenTrue);
     addAntecedent(postExpressionLabel, currentFlow);
     currentFlow = finishFlowLabel(falseLabel);
-    if (inReturnStatement) {
+    if (inReturnPosition) {
       node.flowNodeWhenFalse = currentFlow;
     }
     bind(node.colonToken);
@@ -45017,31 +45060,29 @@ function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFi
         return { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true };
       }
     }
-    if (!specifier) {
-      const local = getLocalModuleSpecifier(
-        modulePath.path,
-        info,
-        compilerOptions,
-        host,
-        options.overrideImportMode || importingSourceFile.impliedNodeFormat,
-        preferences,
-        /*pathsOnly*/
-        modulePath.isRedirect
-      );
-      if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) {
-        continue;
-      }
-      if (modulePath.isRedirect) {
-        redirectPathsSpecifiers = append(redirectPathsSpecifiers, local);
-      } else if (pathIsBareSpecifier(local)) {
-        if (pathContainsNodeModules(local)) {
-          relativeSpecifiers = append(relativeSpecifiers, local);
-        } else {
-          pathsSpecifiers = append(pathsSpecifiers, local);
-        }
-      } else if (forAutoImport || !importedFileIsInNodeModules || modulePath.isInNodeModules) {
+    const local = getLocalModuleSpecifier(
+      modulePath.path,
+      info,
+      compilerOptions,
+      host,
+      options.overrideImportMode || importingSourceFile.impliedNodeFormat,
+      preferences,
+      /*pathsOnly*/
+      modulePath.isRedirect || !!specifier
+    );
+    if (!local || forAutoImport && isExcludedByRegex(local, preferences.excludeRegexes)) {
+      continue;
+    }
+    if (modulePath.isRedirect) {
+      redirectPathsSpecifiers = append(redirectPathsSpecifiers, local);
+    } else if (pathIsBareSpecifier(local)) {
+      if (pathContainsNodeModules(local)) {
         relativeSpecifiers = append(relativeSpecifiers, local);
+      } else {
+        pathsSpecifiers = append(pathsSpecifiers, local);
       }
+    } else if (forAutoImport || !importedFileIsInNodeModules || modulePath.isInNodeModules) {
+      relativeSpecifiers = append(relativeSpecifiers, local);
     }
   }
   return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? { kind: "paths", moduleSpecifiers: pathsSpecifiers, computedWithoutCache: true } : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? { kind: "redirect", moduleSpecifiers: redirectPathsSpecifiers, computedWithoutCache: true } : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? { kind: "node_modules", moduleSpecifiers: nodeModulesSpecifiers, computedWithoutCache: true } : { kind: "relative", moduleSpecifiers: relativeSpecifiers ?? emptyArray, computedWithoutCache: true };
@@ -45087,7 +45128,7 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
     importMode,
     prefersTsExtension(allowedEndings)
   );
-  const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) : void 0;
+  const fromPaths = pathsOnly || fromPackageJsonImports === void 0 ? paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, baseDirectory, getCanonicalFileName, host, compilerOptions) : void 0;
   if (pathsOnly) {
     return fromPaths;
   }
@@ -45301,10 +45342,11 @@ function tryGetModuleNameFromAmbientModule(moduleSymbol, checker) {
     return ambientModuleDeclare.name.text;
   }
 }
-function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
+function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, baseDirectory, getCanonicalFileName, host, compilerOptions) {
   for (const key in paths) {
     for (const patternText2 of paths[key]) {
-      const pattern = normalizePath(patternText2);
+      const normalized = normalizePath(patternText2);
+      const pattern = getRelativePathIfInSameVolume(normalized, baseDirectory, getCanonicalFileName) ?? normalized;
       const indexOfStar = pattern.indexOf("*");
       const candidates = allowedEndings.map((ending) => ({
         ending,
@@ -45633,6 +45675,8 @@ function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileNa
           subModuleName,
           versionPaths.paths,
           allowedEndings,
+          packageRootPath,
+          getCanonicalFileName,
           host,
           options
         );
@@ -46140,8 +46184,8 @@ function createTypeChecker(host) {
     writeSignature: (signature, enclosingDeclaration, flags, kind, writer) => {
       return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer);
     },
-    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);
@@ -47791,9 +47835,9 @@ function createTypeChecker(host) {
           const containerKind = grandparent.parent.kind;
           if (containerKind === 264 /* InterfaceDeclaration */ && heritageKind === 96 /* ExtendsKeyword */) {
             error(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_It_can_only_extend_other_named_object_types, unescapeLeadingUnderscores(name));
-          } else if (containerKind === 263 /* ClassDeclaration */ && heritageKind === 96 /* ExtendsKeyword */) {
+          } else if (isClassLike(grandparent.parent) && heritageKind === 96 /* ExtendsKeyword */) {
             error(errorLocation, Diagnostics.A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values, unescapeLeadingUnderscores(name));
-          } else if (containerKind === 263 /* ClassDeclaration */ && heritageKind === 119 /* ImplementsKeyword */) {
+          } else if (isClassLike(grandparent.parent) && heritageKind === 119 /* ImplementsKeyword */) {
             error(errorLocation, Diagnostics.A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types, unescapeLeadingUnderscores(name));
           }
         } else {
@@ -49666,7 +49710,7 @@ function createTypeChecker(host) {
     const links = getSymbolLinks(symbol);
     const cache = links.accessibleChainCache || (links.accessibleChainCache = /* @__PURE__ */ new Map());
     const firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, (_, __, ___, node) => node);
-    const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation && getNodeId(firstRelevantLocation)}|${meaning}`;
+    const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation ? getNodeId(firstRelevantLocation) : 0}|${meaning}`;
     if (cache.has(key)) {
       return cache.get(key);
     }
@@ -50063,14 +50107,18 @@ function createTypeChecker(host) {
       return writer2;
     }
   }
-  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
-    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
+  function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter(""), verbosityLevel, out) {
+    const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */ || verbosityLevel !== void 0;
     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();
@@ -50210,12 +50258,7 @@ function createTypeChecker(host) {
       enterNewScope(context, node) {
         if (isFunctionLike(node) || isJSDocSignature(node)) {
           const signature = getSignatureFromDeclaration(node);
-          const expandedParams = getExpandedParameters(
-            signature,
-            /*skipUnionExpanding*/
-            true
-          )[0];
-          return enterNewScope(context, node, expandedParams, signature.typeParameters);
+          return enterNewScope(context, node, signature.parameters, signature.typeParameters);
         } else {
           const typeParameters = isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
           return enterNewScope(
@@ -50291,6 +50334,9 @@ function createTypeChecker(host) {
           }
         }
         let annotationType = getTypeFromTypeNodeWithoutContext(existing);
+        if (isErrorType(annotationType)) {
+          return true;
+        }
         if (requiresAddingUndefined && annotationType) {
           annotationType = getOptionalType(annotationType, !isParameter(node));
         }
@@ -50299,31 +50345,127 @@ 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) => withContext(
+        enclosingDeclaration,
+        flags,
+        internalFlags,
+        tracker,
+        /*verbosityLevel*/
+        void 0,
+        (context) => signatureToSignatureDeclarationHelper(signature, kind, context)
+      ),
+      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) => withContext(enclosingDeclaration, flags, internalFlags, tracker, verbosityLevel, (context) => typeParameterToDeclaration(parameter, context)),
+      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)
+      )
     };
     function getTypeFromTypeNode2(context, node, noMappedTypes) {
       const type = getTypeFromTypeNodeWithoutContext(node);
@@ -50365,7 +50507,7 @@ function createTypeChecker(host) {
       }
       return symbolToExpression(symbol, context, meaning);
     }
-    function withContext(enclosingDeclaration, flags, internalFlags, tracker, cb) {
+    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,
@@ -50373,6 +50515,7 @@ function createTypeChecker(host) {
         flags: flags || 0 /* None */,
         internalFlags: internalFlags || 0 /* None */,
         tracker: void 0,
+        unfoldDepth: verbosityLevel ?? -1,
         encounteredError: false,
         suppressReportInferenceFallback: false,
         reportedDiagnostic: false,
@@ -50394,13 +50537,18 @@ function createTypeChecker(host) {
         typeParameterNamesByText: void 0,
         typeParameterNamesByTextNextNameCount: void 0,
         enclosingSymbolTypes: /* @__PURE__ */ new Map(),
-        mapper: void 0
+        mapper: void 0,
+        depth: 0,
+        couldUnfoldMore: 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.couldUnfoldMore = context.couldUnfoldMore;
+      }
       return context.encounteredError ? void 0 : resultingNode;
     }
     function addSymbolTypeToContext(context, symbol, type) {
@@ -50419,16 +50567,36 @@ 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);
@@ -50576,16 +50744,27 @@ 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 (!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);
         }
-        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 (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 */) {
@@ -50615,6 +50794,14 @@ 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 */);
         }
@@ -50818,7 +51005,7 @@ function createTypeChecker(host) {
         }
         return result;
       }
-      function createAnonymousTypeNode(type2) {
+      function createAnonymousTypeNode(type2, forceClassExpansion = false) {
         var _a2, _b2;
         const typeId = type2.id;
         const symbol = type2.symbol;
@@ -50841,7 +51028,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 */ && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
+          } else if (symbol.flags & 32 /* Class */ && !forceClassExpansion && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(
             symbol,
             context.enclosingDeclaration,
             isInstanceType,
@@ -50885,7 +51072,7 @@ function createTypeChecker(host) {
         if (id && !context.symbolDepth) {
           context.symbolDepth = /* @__PURE__ */ new Map();
         }
-        const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
+        const links = context.unfoldDepth >= 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());
@@ -51317,7 +51504,7 @@ function createTypeChecker(host) {
         const signatures = getSignaturesOfType(filterType(propertyType, (t) => !(t.flags & 32768 /* Undefined */)), 0 /* Call */);
         for (const signature of signatures) {
           const methodDeclaration = signatureToSignatureDeclarationHelper(signature, 173 /* MethodSignature */, context, { name: propertyName, questionToken: optionalToken });
-          typeElements.push(preserveCommentsOn(methodDeclaration));
+          typeElements.push(preserveCommentsOn(methodDeclaration, signature.declaration || propertySymbol.valueDeclaration));
         }
         if (signatures.length || !optionalToken) {
           return;
@@ -51352,8 +51539,8 @@ function createTypeChecker(host) {
         optionalToken,
         propertyTypeNode
       );
-      typeElements.push(preserveCommentsOn(propertySignature));
-      function preserveCommentsOn(node) {
+      typeElements.push(preserveCommentsOn(propertySignature, propertySymbol.valueDeclaration));
+      function preserveCommentsOn(node, range) {
         var _a2;
         const jsdocPropertyTag = (_a2 = propertySymbol.declarations) == null ? void 0 : _a2.find((d) => d.kind === 348 /* JSDocPropertyTag */);
         if (jsdocPropertyTag) {
@@ -51361,8 +51548,8 @@ function createTypeChecker(host) {
           if (commentText) {
             setSyntheticLeadingComments(node, [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
           }
-        } else if (propertySymbol.valueDeclaration) {
-          setCommentRange2(context, node, propertySymbol.valueDeclaration);
+        } else if (range) {
+          setCommentRange2(context, node, range);
         }
         return node;
       }
@@ -51800,7 +51987,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 !couldUnfoldType(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);
@@ -52434,7 +52621,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 (!couldUnfoldType(type, context) && decl) {
         if (isAccessor(decl)) {
           result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
         } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) {
@@ -55229,7 +55416,6 @@ function createTypeChecker(host) {
       const flags = 4 /* Property */ | (e.initializer ? 16777216 /* Optional */ : 0);
       const symbol = createSymbol(flags, text);
       symbol.links.type = getTypeFromBindingElement(e, includePatternInType, reportErrors2);
-      symbol.links.bindingElement = e;
       members.set(symbol.escapedName, symbol);
     });
     const result = createAnonymousType(
@@ -55474,7 +55660,7 @@ function createTypeChecker(host) {
       const getter = getDeclarationOfKind(symbol, 177 /* GetAccessor */);
       const setter = getDeclarationOfKind(symbol, 178 /* SetAccessor */);
       const accessor = tryCast(getDeclarationOfKind(symbol, 172 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
-      let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && accessor.initializer && getWidenedTypeForVariableLikeDeclaration(
+      let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && getWidenedTypeForVariableLikeDeclaration(
         accessor,
         /*reportErrors*/
         true
@@ -57156,12 +57342,20 @@ function createTypeChecker(host) {
     const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType) || unknownType, readonlyMask && indexInfo.isReadonly)] : emptyArray;
     const members = createSymbolTable();
     const limitedConstraint = getLimitedConstraint(type);
+    const nameType = getNameTypeFromMappedType(type.mappedType);
     for (const prop of getPropertiesOfType(type.source)) {
-      if (limitedConstraint) {
+      if (limitedConstraint || nameType) {
         const propertyNameType = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
-        if (!isTypeAssignableTo(propertyNameType, limitedConstraint)) {
+        if (limitedConstraint && !isTypeAssignableTo(propertyNameType, limitedConstraint)) {
           continue;
         }
+        if (nameType) {
+          const nameMapper = appendTypeMapping(type.mappedType.mapper, getTypeParameterFromMappedType(type.mappedType), propertyNameType);
+          const instantiatedNameType = instantiateType(nameType, nameMapper);
+          if (instantiatedNameType.flags & 131072 /* Never */) {
+            continue;
+          }
+        }
       }
       const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
       const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
@@ -59158,7 +59352,7 @@ function createTypeChecker(host) {
     return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
   }
   function isNarrowingSubstitutionType(type) {
-    return !!(type.flags & 33554432 /* Substitution */ && type.objectFlags & 16777216 /* IsNarrowedType */);
+    return !!(type.flags & 33554432 /* Substitution */ && type.objectFlags & 16777216 /* IsNarrowingType */);
   }
   function getSubstitutionType(baseType, constraint, isNarrowed) {
     return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint, isNarrowed);
@@ -59173,7 +59367,7 @@ function createTypeChecker(host) {
     result.baseType = baseType;
     result.constraint = constraint;
     if (isNarrowed) {
-      result.objectFlags |= 16777216 /* IsNarrowedType */;
+      result.objectFlags |= 16777216 /* IsNarrowingType */;
     }
     substitutionTypes.set(id, result);
     return result;
@@ -61626,7 +61820,7 @@ function createTypeChecker(host) {
     const links = getNodeLinks(node);
     if (!links.resolvedType) {
       const aliasSymbol = getAliasSymbolForTypeNode(node);
-      if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
+      if (!node.symbol || getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
         links.resolvedType = emptyTypeLiteralType;
       } else {
         let type = createObjectType(16 /* Anonymous */, node.symbol);
@@ -62409,32 +62603,27 @@ function createTypeChecker(host) {
           distributionType = getReducedType(distributionType.constraint);
         }
         if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
-          const mapperCallback = narrowingBaseType ? (t) => getConditionalType(
-            root,
-            prependTypeMapping(checkType, getSubstitutionType(
-              narrowingBaseType,
-              t,
-              /*isNarrowed*/
-              true
-            ), newMapper),
-            forConstraint,
-            /*aliasSymbol*/
-            void 0,
-            /*aliasTypeArguments*/
-            void 0,
-            forNarrowing
-          ) : (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint);
           if (narrowingBaseType) {
-            result = mapType(
+            result = mapTypeToIntersection(
               distributionType,
-              mapperCallback,
-              /*noReductions*/
-              void 0,
-              /*toIntersection*/
-              true
+              (t) => getConditionalType(
+                root,
+                prependTypeMapping(checkType, getSubstitutionType(
+                  narrowingBaseType,
+                  t,
+                  /*isNarrowed*/
+                  true
+                ), newMapper),
+                forConstraint,
+                /*aliasSymbol*/
+                void 0,
+                /*aliasTypeArguments*/
+                void 0,
+                forNarrowing
+              )
             );
           } else {
-            result = mapTypeWithAlias(distributionType, mapperCallback, aliasSymbol, aliasTypeArguments);
+            result = mapTypeWithAlias(distributionType, (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments);
           }
         } else {
           result = getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments, forNarrowing);
@@ -62551,9 +62740,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function isGenericIndexedOrConditionalReturnType(type) {
-    return !!(type.flags & (8388608 /* IndexedAccess */ | 16777216 /* Conditional */) && couldContainTypeVariables(type));
-  }
   function instantiateReverseMappedType(type, mapper) {
     const innerMappedType = instantiateType(type.mappedType, mapper);
     if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
@@ -67797,10 +67983,13 @@ function createTypeChecker(host) {
       if (isGenericMappedType(source) && isGenericMappedType(target)) {
         inferFromGenericMappedTypes(source, target);
       }
-      if (getObjectFlags(target) & 32 /* Mapped */ && !target.declaration.nameType) {
-        const constraintType = getConstraintTypeFromMappedType(target);
-        if (inferToMappedType(source, target, constraintType)) {
-          return;
+      if (getObjectFlags(target) & 32 /* Mapped */) {
+        const mappedType = target;
+        if (getMappedTypeNameTypeKind(mappedType) !== 2 /* Remapping */) {
+          const constraintType = getConstraintTypeFromMappedType(mappedType);
+          if (inferToMappedType(source, mappedType, constraintType)) {
+            return;
+          }
         }
       }
       if (!typesDefinitelyUnrelated(source, target)) {
@@ -68724,7 +68913,7 @@ function createTypeChecker(host) {
   function countTypes(type) {
     return type.flags & 1048576 /* Union */ ? type.types.length : 1;
   }
-  function mapType(type, mapper, noReductions, toIntersection) {
+  function mapType(type, mapper, noReductions) {
     if (type.flags & 131072 /* Never */) {
       return type;
     }
@@ -68746,7 +68935,19 @@ function createTypeChecker(host) {
         }
       }
     }
-    return changed ? mappedTypes && (toIntersection ? getIntersectionType(mappedTypes) : getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */)) : type;
+    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);
@@ -70099,12 +70300,14 @@ function createTypeChecker(host) {
         case 80 /* Identifier */:
           if (!isMatchingReference(reference, expr) && inlineLevel < 5) {
             const symbol = getResolvedSymbol(expr);
-            const inlineExpression = getNarrowableInlineExpression(symbol);
-            if (inlineExpression && isConstantReference(reference)) {
-              inlineLevel++;
-              const result = narrowType(type, inlineExpression, assumeTrue);
-              inlineLevel--;
-              return result;
+            if (isConstantVariable(symbol)) {
+              const declaration = symbol.valueDeclaration;
+              if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isConstantReference(reference)) {
+                inlineLevel++;
+                const result = narrowType(type, declaration.initializer, assumeTrue);
+                inlineLevel--;
+                return result;
+              }
             }
           }
         // falls through
@@ -70139,14 +70342,6 @@ function createTypeChecker(host) {
       return type;
     }
   }
-  function getNarrowableInlineExpression(symbol) {
-    if (isConstantVariable(symbol)) {
-      const declaration = symbol.valueDeclaration;
-      if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer) {
-        return declaration.initializer;
-      }
-    }
-  }
   function getTypeOfSymbolAtLocation(symbol, location) {
     symbol = getExportSymbolOfValueSymbolIfExported(symbol);
     if (location.kind === 80 /* Identifier */ || location.kind === 81 /* PrivateIdentifier */) {
@@ -70493,7 +70688,7 @@ function createTypeChecker(host) {
         jsxFactorySym = resolveName(
           jsxFactoryLocation,
           jsxFactoryNamespace,
-          compilerOptions.jsx === 1 /* Preserve */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
+          compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
           jsxFactoryRefErr,
           /*isUse*/
           true
@@ -70512,7 +70707,7 @@ function createTypeChecker(host) {
           resolveName(
             jsxFactoryLocation,
             localJsxNamespace,
-            compilerOptions.jsx === 1 /* Preserve */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
+            compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
             jsxFactoryRefErr,
             /*isUse*/
             true
@@ -74855,8 +75050,8 @@ function createTypeChecker(host) {
     }
   }
   function getEffectiveCheckNode(argument) {
-    argument = skipParentheses(argument);
-    return isSatisfiesExpression(argument) ? skipParentheses(argument.expression) : argument;
+    const flags = isInJSFile(argument) ? 1 /* Parentheses */ | 32 /* Satisfies */ | -2147483648 /* ExcludeJSDocTypeAssertion */ : 1 /* Parentheses */ | 32 /* Satisfies */;
+    return skipOuterExpressions(argument, flags);
   }
   function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) {
     const errorOutputContainer = { errors: void 0, skipLogging: true };
@@ -75281,11 +75476,16 @@ function createTypeChecker(host) {
     if (!result) {
       result = chooseOverload(candidates, assignableRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
     }
+    const links = getNodeLinks(node);
+    if (links.resolvedSignature !== resolvingSignature && !candidatesOutArray) {
+      Debug.assert(links.resolvedSignature);
+      return links.resolvedSignature;
+    }
     if (result) {
       return result;
     }
     result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
-    getNodeLinks(node).resolvedSignature = result;
+    links.resolvedSignature = result;
     if (reportErrors2) {
       if (!headMessage && isInstanceof) {
         headMessage = Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method;
@@ -76050,7 +76250,7 @@ function createTypeChecker(host) {
     const jsxFactorySymbol = getJsxNamespaceContainerForImplicitImport(node) ?? resolveName(
       node,
       jsxFragmentFactoryName,
-      compilerOptions.jsx === 1 /* Preserve */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
+      compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */ ? 111551 /* Value */ & ~384 /* Enum */ : 111551 /* Value */,
       /*nameNotFoundMessage*/
       jsxFactoryRefErr,
       /*isUse*/
@@ -76169,12 +76369,9 @@ function createTypeChecker(host) {
       resolutionStart = resolutionTargets.length;
     }
     links.resolvedSignature = resolvingSignature;
-    let result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* Normal */);
+    const result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* Normal */);
     resolutionStart = saveResolutionStart;
     if (result !== resolvingSignature) {
-      if (links.resolvedSignature !== resolvingSignature) {
-        result = links.resolvedSignature;
-      }
       links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
     }
     return result;
@@ -77702,7 +77899,7 @@ function createTypeChecker(host) {
     });
   }
   function checkIfExpressionRefinesParameter(func, expr, param, initType) {
-    const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode(
+    const antecedent = canHaveFlowNode(expr) && expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode(
       2 /* Start */,
       /*node*/
       void 0,
@@ -77850,19 +78047,7 @@ function createTypeChecker(host) {
         const exprType = checkExpression(node.body);
         const returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags);
         if (returnOrPromisedType) {
-          const effectiveCheckNode = getEffectiveCheckNode(node.body);
-          if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */) {
-            const awaitedType = checkAwaitedType(
-              exprType,
-              /*withAlias*/
-              false,
-              effectiveCheckNode,
-              Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
-            );
-            checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, effectiveCheckNode, effectiveCheckNode);
-          } else {
-            checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, effectiveCheckNode, effectiveCheckNode);
-          }
+          checkReturnExpression(node, returnOrPromisedType, node.body, node.body, exprType);
         }
       }
     }
@@ -77945,7 +78130,7 @@ function createTypeChecker(host) {
     return false;
   }
   function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) {
-    const node = skipOuterExpressions(expr, 6 /* Assertions */ | 1 /* Parentheses */);
+    const node = skipOuterExpressions(expr, 38 /* Assertions */ | 1 /* Parentheses */);
     if (node.kind !== 80 /* Identifier */ && !isAccessExpression(node)) {
       error(expr, invalidReferenceMessage);
       return false;
@@ -78596,7 +78781,7 @@ function createTypeChecker(host) {
       if (isBinaryExpression(right) && (right.operatorToken.kind === 57 /* BarBarToken */ || right.operatorToken.kind === 56 /* AmpersandAmpersandToken */)) {
         grammarErrorOnNode(right, Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, tokenToString(right.operatorToken.kind), tokenToString(operatorToken.kind));
       }
-      const leftTarget = skipOuterExpressions(left, 31 /* All */);
+      const leftTarget = skipOuterExpressions(left, 63 /* All */);
       const nullishSemantics = getSyntacticNullishnessSemantics(leftTarget);
       if (nullishSemantics !== 3 /* Sometimes */) {
         if (node.parent.kind === 226 /* BinaryExpression */) {
@@ -78616,7 +78801,9 @@ function createTypeChecker(host) {
     switch (node.kind) {
       case 223 /* AwaitExpression */:
       case 213 /* CallExpression */:
+      case 215 /* TaggedTemplateExpression */:
       case 212 /* ElementAccessExpression */:
+      case 236 /* MetaProperty */:
       case 214 /* NewExpression */:
       case 211 /* PropertyAccessExpression */:
       case 229 /* YieldExpression */:
@@ -78632,6 +78819,8 @@ function createTypeChecker(host) {
           case 56 /* AmpersandAmpersandToken */:
           case 77 /* AmpersandAmpersandEqualsToken */:
             return 3 /* Sometimes */;
+          case 28 /* CommaToken */:
+            return getSyntacticNullishnessSemantics(node.right);
         }
         return 2 /* Never */;
       case 227 /* ConditionalExpression */:
@@ -82618,7 +82807,7 @@ function createTypeChecker(host) {
       return anyIterationTypes;
     }
     if (!(type.flags & 1048576 /* Union */)) {
-      const errorOutputContainer = errorNode ? { errors: void 0 } : void 0;
+      const errorOutputContainer = errorNode ? { errors: void 0, skipLogging: true } : void 0;
       const iterationTypes2 = getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer);
       if (iterationTypes2 === noIterationTypes) {
         if (errorNode) {
@@ -82786,11 +82975,27 @@ function createTypeChecker(host) {
     if (isTypeAny(methodType)) {
       return noCache ? anyIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
     }
-    const signatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0;
-    if (!some(signatures)) {
+    const allSignatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0;
+    const validSignatures = filter(allSignatures, (sig) => getMinArgumentCount(sig) === 0);
+    if (!some(validSignatures)) {
+      if (errorNode && some(allSignatures)) {
+        checkTypeAssignableTo(
+          type,
+          resolver.getGlobalIterableType(
+            /*reportErrors*/
+            true
+          ),
+          errorNode,
+          /*headMessage*/
+          void 0,
+          /*containingMessageChain*/
+          void 0,
+          errorOutputContainer
+        );
+      }
       return noCache ? noIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
     }
-    const iteratorType = getIntersectionType(map(signatures, getReturnTypeOfSignature));
+    const iteratorType = getIntersectionType(map(validSignatures, getReturnTypeOfSignature));
     const iterationTypes = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache) ?? noIterationTypes;
     return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
   }
@@ -83069,32 +83274,52 @@ function createTypeChecker(host) {
     const signature = getSignatureFromDeclaration(container);
     const returnType = getReturnTypeOfSignature(signature);
     if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
+      const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
       if (container.kind === 178 /* SetAccessor */) {
         if (node.expression) {
           error(node, Diagnostics.Setters_cannot_return_a_value);
         }
       } else if (container.kind === 176 /* Constructor */) {
-        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
-        if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
+        const exprType2 = node.expression ? checkExpressionCached(node.expression) : undefinedType;
+        if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType2, returnType, node, node.expression)) {
           error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
         }
       } else if (getReturnTypeFromAnnotation(container)) {
-        checkReturnStatementExpression(container, returnType, node, node.expression);
+        const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(container)) ?? returnType;
+        checkReturnExpression(container, unwrappedReturnType, node, node.expression, exprType);
       }
     } else if (container.kind !== 176 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
       error(node, Diagnostics.Not_all_code_paths_return_a_value);
     }
   }
-  function checkReturnStatementExpression(container, returnType, node, expr) {
+  function checkReturnExpression(container, unwrappedReturnType, node, expr, exprType, inConditionalExpression = false) {
+    const excludeJSDocTypeAssertions = isInJSFile(node);
     const functionFlags = getFunctionFlags(container);
-    const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
     if (expr) {
-      const unwrappedExpr = skipParentheses(expr);
+      const unwrappedExpr = skipParentheses(expr, excludeJSDocTypeAssertions);
       if (isConditionalExpression(unwrappedExpr)) {
-        return checkReturnConditionalExpression(container, returnType, node, unwrappedExpr);
+        checkReturnExpression(
+          container,
+          unwrappedReturnType,
+          node,
+          unwrappedExpr.whenTrue,
+          checkExpression(unwrappedExpr.whenTrue),
+          /*inConditionalExpression*/
+          true
+        );
+        checkReturnExpression(
+          container,
+          unwrappedReturnType,
+          node,
+          unwrappedExpr.whenFalse,
+          checkExpression(unwrappedExpr.whenFalse),
+          /*inConditionalExpression*/
+          true
+        );
+        return;
       }
     }
-    const exprType = expr ? checkExpressionCached(expr) : undefinedType;
+    const inReturnStatement = node.kind === 253 /* ReturnStatement */;
     const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
       exprType,
       /*withAlias*/
@@ -83102,7 +83327,12 @@ function createTypeChecker(host) {
       node,
       Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
     ) : exprType;
-    const errorNode = node.expression && isConditionalExpression(skipParentheses(node.expression)) ? expr : node;
+    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,
@@ -83111,8 +83341,14 @@ function createTypeChecker(host) {
     )) {
       return;
     }
-    if (!isGenericIndexedOrConditionalReturnType(unwrappedReturnType)) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, expr);
+    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(
@@ -83122,20 +83358,12 @@ function createTypeChecker(host) {
     ), getEffectiveTypeParameterDeclarations(container));
     const narrowableTypeParameters = allTypeParameters && getNarrowableTypeParameters(allTypeParameters);
     if (!narrowableTypeParameters || !narrowableTypeParameters.length || !isNarrowableReturnType(unwrappedReturnType)) {
-      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, expr);
+      checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, errorNode, effectiveExpr);
       return;
     }
-    let narrowPosition = node;
-    let narrowFlowNode = 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, expr);
-      return;
-    }
-    const narrowed = mapDefined(narrowableTypeParameters, ([typeParam, symbol, reference]) => {
+    const narrowedTypeParameters = [];
+    const narrowedTypes = [];
+    for (const [typeParam, symbol, reference] of narrowableTypeParameters) {
       const narrowReference = factory.cloneNode(reference);
       narrowReference.id = void 0;
       getNodeLinks(narrowReference).resolvedSymbol = symbol;
@@ -83150,12 +83378,12 @@ function createTypeChecker(host) {
         true
       );
       if (initialType === typeParam) {
-        return void 0;
+        continue;
       }
       const flowType = getFlowTypeOfReference(narrowReference, initialType);
       const exprType2 = getTypeFromFlowType(flowType);
-      if (isTypeAny(exprType2) || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
-        return void 0;
+      if (exprType2.flags & 3 /* AnyOrUnknown */ || isErrorType(exprType2) || exprType2 === typeParam || exprType2 === mapType(typeParam, getBaseConstraintOrType)) {
+        continue;
       }
       const narrowedType = getSubstitutionType(
         typeParam,
@@ -83163,9 +83391,10 @@ function createTypeChecker(host) {
         /*isNarrowed*/
         true
       );
-      return [typeParam, narrowedType];
-    });
-    const narrowMapper = createTypeMapper(narrowed.map(([tp, _]) => tp), narrowed.map(([_, t]) => t));
+      narrowedTypeParameters.push(typeParam);
+      narrowedTypes.push(narrowedType);
+    }
+    const narrowMapper = createTypeMapper(narrowedTypeParameters, narrowedTypes);
     const narrowedReturnType = instantiateType(
       unwrappedReturnType,
       narrowMapper
@@ -83184,12 +83413,7 @@ function createTypeChecker(host) {
       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, expr);
-  }
-  function checkReturnConditionalExpression(container, returnType, node, expr) {
-    checkExpression(expr.condition);
-    checkReturnStatementExpression(container, returnType, node, expr.whenTrue);
-    checkReturnStatementExpression(container, returnType, node, expr.whenFalse);
+    checkTypeAssignableToAndOptionallyElaborate(narrowedUnwrappedExprType, narrowedReturnType, errorNode, effectiveExpr);
   }
   function getNarrowableTypeParameters(candidates) {
     const narrowableParams = [];
@@ -83197,12 +83421,13 @@ function createTypeChecker(host) {
       const constraint = getConstraintOfTypeParameter(typeParam);
       if (!constraint || !(constraint.flags & 1048576 /* Union */)) continue;
       if (typeParam.symbol && typeParam.symbol.declarations && typeParam.symbol.declarations.length === 1) {
-        const container = typeParam.symbol.declarations[0].parent;
+        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 = paramDecl.type;
+          const typeNode = getEffectiveTypeAnnotationNode(paramDecl);
           if (!typeNode) continue;
           if (isTypeParameterReferenced(typeParam, typeNode)) {
             let candidateReference;
@@ -83212,10 +83437,10 @@ function createTypeChecker(host) {
                 break;
               }
               reference = candidateReference;
-              continue;
+            } else {
+              hasInvalidReference = true;
+              break;
             }
-            hasInvalidReference = true;
-            break;
           }
         }
         if (!hasInvalidReference && reference) {
@@ -83227,7 +83452,8 @@ function createTypeChecker(host) {
     return narrowableParams;
     function getValidParameterReference(paramDecl, constraint) {
       if (!isIdentifier(paramDecl.name)) return;
-      if (paramDecl.questionToken && !containsUndefinedType(constraint)) return;
+      const isOptional = !!paramDecl.questionToken || isJSDocOptionalParameter(paramDecl);
+      if (isOptional && !containsUndefinedType(constraint)) return;
       return paramDecl.name;
     }
     function isReferenceToTypeParameter(typeParam, node) {
@@ -83288,10 +83514,11 @@ function createTypeChecker(host) {
       return false;
     }
     const trueType2 = getTrueTypeFromConditionalType(type);
-    const falseType2 = getFalseTypeFromConditionalType(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 isValidTrueType && isValidFalseType;
+    return isValidFalseType;
   }
   function isConditionalType(type) {
     return !!(type.flags & 16777216 /* Conditional */);
@@ -84224,6 +84451,9 @@ function createTypeChecker(host) {
   }
   function checkInterfaceDeclaration(node) {
     if (!checkGrammarModifiers(node)) checkGrammarInterfaceDeclaration(node);
+    if (!allowBlockDeclarations(node.parent)) {
+      grammarErrorOnNode(node, Diagnostics._0_declarations_can_only_be_declared_inside_a_block, "interface");
+    }
     checkTypeParameters(node.typeParameters);
     addLazyDiagnostic(() => {
       checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0);
@@ -84258,6 +84488,9 @@ function createTypeChecker(host) {
   function checkTypeAliasDeclaration(node) {
     checkGrammarModifiers(node);
     checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
+    if (!allowBlockDeclarations(node.parent)) {
+      grammarErrorOnNode(node, Diagnostics._0_declarations_can_only_be_declared_inside_a_block, "type");
+    }
     checkExportsOnMergedDeclarations(node);
     checkTypeParameters(node.typeParameters);
     if (node.type.kind === 141 /* IntrinsicKeyword */) {
@@ -86644,7 +86877,7 @@ function createTypeChecker(host) {
     const typeNode = getNonlocalEffectiveTypeAnnotationNode(parameter);
     if (!typeNode) return false;
     const type = getTypeFromTypeNode(typeNode);
-    return containsUndefinedType(type);
+    return isErrorType(type) || containsUndefinedType(type);
   }
   function requiresAddingImplicitUndefined(parameter, enclosingDeclaration) {
     return (isRequiredInitializedParameter(parameter, enclosingDeclaration) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
@@ -88670,7 +88903,7 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function allowLetAndConstDeclarations(parent) {
+  function allowBlockDeclarations(parent) {
     switch (parent.kind) {
       case 245 /* IfStatement */:
       case 246 /* DoStatement */:
@@ -88681,12 +88914,12 @@ function createTypeChecker(host) {
       case 250 /* ForOfStatement */:
         return false;
       case 256 /* LabeledStatement */:
-        return allowLetAndConstDeclarations(parent.parent);
+        return allowBlockDeclarations(parent.parent);
     }
     return true;
   }
   function checkGrammarForDisallowedBlockScopedVariableStatement(node) {
-    if (!allowLetAndConstDeclarations(node.parent)) {
+    if (!allowBlockDeclarations(node.parent)) {
       const blockScopeKind = getCombinedNodeFlagsCached(node.declarationList) & 7 /* BlockScoped */;
       if (blockScopeKind) {
         const keyword = blockScopeKind === 1 /* Let */ ? "let" : blockScopeKind === 2 /* Const */ ? "const" : blockScopeKind === 4 /* Using */ ? "using" : blockScopeKind === 6 /* AwaitUsing */ ? "await using" : Debug.fail("Unknown BlockScope flag");
@@ -91292,9 +91525,9 @@ function getDecoratorsOfParameters(node) {
   }
   return decorators;
 }
-function getAllDecoratorsOfClass(node) {
+function getAllDecoratorsOfClass(node, useLegacyDecorators) {
   const decorators = getDecorators(node);
-  const parameters = getDecoratorsOfParameters(getFirstConstructorWithBody(node));
+  const parameters = useLegacyDecorators ? getDecoratorsOfParameters(getFirstConstructorWithBody(node)) : void 0;
   if (!some(decorators) && !some(parameters)) {
     return void 0;
   }
@@ -91308,18 +91541,27 @@ function getAllDecoratorsOfClassElement(member, parent, useLegacyDecorators) {
     case 177 /* GetAccessor */:
     case 178 /* SetAccessor */:
       if (!useLegacyDecorators) {
-        return getAllDecoratorsOfMethod(member);
+        return getAllDecoratorsOfMethod(
+          member,
+          /*useLegacyDecorators*/
+          false
+        );
       }
-      return getAllDecoratorsOfAccessors(member, parent);
+      return getAllDecoratorsOfAccessors(
+        member,
+        parent,
+        /*useLegacyDecorators*/
+        true
+      );
     case 174 /* MethodDeclaration */:
-      return getAllDecoratorsOfMethod(member);
+      return getAllDecoratorsOfMethod(member, useLegacyDecorators);
     case 172 /* PropertyDeclaration */:
       return getAllDecoratorsOfProperty(member);
     default:
       return void 0;
   }
 }
-function getAllDecoratorsOfAccessors(accessor, parent) {
+function getAllDecoratorsOfAccessors(accessor, parent, useLegacyDecorators) {
   if (!accessor.body) {
     return void 0;
   }
@@ -91329,7 +91571,7 @@ function getAllDecoratorsOfAccessors(accessor, parent) {
     return void 0;
   }
   const decorators = getDecorators(firstAccessorWithDecorators);
-  const parameters = getDecoratorsOfParameters(setAccessor);
+  const parameters = useLegacyDecorators ? getDecoratorsOfParameters(setAccessor) : void 0;
   if (!some(decorators) && !some(parameters)) {
     return void 0;
   }
@@ -91340,12 +91582,12 @@ function getAllDecoratorsOfAccessors(accessor, parent) {
     setDecorators: setAccessor && getDecorators(setAccessor)
   };
 }
-function getAllDecoratorsOfMethod(method) {
+function getAllDecoratorsOfMethod(method, useLegacyDecorators) {
   if (!method.body) {
     return void 0;
   }
   const decorators = getDecorators(method);
-  const parameters = getDecoratorsOfParameters(method);
+  const parameters = useLegacyDecorators ? getDecoratorsOfParameters(method) : void 0;
   if (!some(decorators) && !some(parameters)) {
     return void 0;
   }
@@ -93254,7 +93496,7 @@ function transformTypeScript(context) {
     return updated;
   }
   function visitParenthesizedExpression(node) {
-    const innerExpression = skipOuterExpressions(node.expression, ~(6 /* Assertions */ | 16 /* ExpressionsWithTypeArguments */));
+    const innerExpression = skipOuterExpressions(node.expression, ~(38 /* Assertions */ | 16 /* ExpressionsWithTypeArguments */));
     if (isAssertionExpression(innerExpression) || isSatisfiesExpression(innerExpression)) {
       const expression = visitNode(node.expression, visitor, isExpression);
       Debug.assert(expression);
@@ -96979,7 +97221,11 @@ function transformLegacyDecorators(context) {
     }
   }
   function generateConstructorDecorationExpression(node) {
-    const allDecorators = getAllDecoratorsOfClass(node);
+    const allDecorators = getAllDecoratorsOfClass(
+      node,
+      /*useLegacyDecorators*/
+      true
+    );
     const decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators);
     if (!decoratorExpressions) {
       return void 0;
@@ -97491,7 +97737,11 @@ function transformESDecorators(context) {
     let syntheticConstructor;
     let heritageClauses;
     let shouldTransformPrivateStaticElementsInClass = false;
-    const classDecorators = transformAllDecoratorsOfDeclaration(getAllDecoratorsOfClass(node));
+    const classDecorators = transformAllDecoratorsOfDeclaration(getAllDecoratorsOfClass(
+      node,
+      /*useLegacyDecorators*/
+      false
+    ));
     if (classDecorators) {
       classInfo2.classDecoratorsName = factory2.createUniqueName("_classDecorators", 16 /* Optimistic */ | 32 /* FileLevel */);
       classInfo2.classDescriptorName = factory2.createUniqueName("_classDescriptor", 16 /* Optimistic */ | 32 /* FileLevel */);
@@ -116986,15 +117236,88 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     return false;
   }
   function parenthesizeExpressionForNoAsi(node) {
-    if (!commentsDisabled && isPartiallyEmittedExpression(node) && willEmitLeadingNewLine(node)) {
-      const parseNode = getParseTreeNode(node);
-      if (parseNode && isParenthesizedExpression(parseNode)) {
-        const parens = factory.createParenthesizedExpression(node.expression);
-        setOriginalNode(parens, node);
-        setTextRange(parens, parseNode);
-        return parens;
+    if (!commentsDisabled) {
+      switch (node.kind) {
+        case 355 /* PartiallyEmittedExpression */:
+          if (willEmitLeadingNewLine(node)) {
+            const parseNode = getParseTreeNode(node);
+            if (parseNode && isParenthesizedExpression(parseNode)) {
+              const parens = factory.createParenthesizedExpression(node.expression);
+              setOriginalNode(parens, node);
+              setTextRange(parens, parseNode);
+              return parens;
+            }
+            return factory.createParenthesizedExpression(node);
+          }
+          return factory.updatePartiallyEmittedExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression)
+          );
+        case 211 /* PropertyAccessExpression */:
+          return factory.updatePropertyAccessExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.name
+          );
+        case 212 /* ElementAccessExpression */:
+          return factory.updateElementAccessExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.argumentExpression
+          );
+        case 213 /* CallExpression */:
+          return factory.updateCallExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.typeArguments,
+            node.arguments
+          );
+        case 215 /* TaggedTemplateExpression */:
+          return factory.updateTaggedTemplateExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.tag),
+            node.typeArguments,
+            node.template
+          );
+        case 225 /* PostfixUnaryExpression */:
+          return factory.updatePostfixUnaryExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.operand)
+          );
+        case 226 /* BinaryExpression */:
+          return factory.updateBinaryExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.left),
+            node.operatorToken,
+            node.right
+          );
+        case 227 /* ConditionalExpression */:
+          return factory.updateConditionalExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.condition),
+            node.questionToken,
+            node.whenTrue,
+            node.colonToken,
+            node.whenFalse
+          );
+        case 234 /* AsExpression */:
+          return factory.updateAsExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.type
+          );
+        case 238 /* SatisfiesExpression */:
+          return factory.updateSatisfiesExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression),
+            node.type
+          );
+        case 235 /* NonNullExpression */:
+          return factory.updateNonNullExpression(
+            node,
+            parenthesizeExpressionForNoAsi(node.expression)
+          );
       }
-      return factory.createParenthesizedExpression(node);
     }
     return node;
   }
@@ -132128,18 +132451,21 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     return failed;
   }
   function typeFromFunctionLikeExpression(fnNode, context) {
-    const oldNoInferenceFallback = context.noInferenceFallback;
-    context.noInferenceFallback = true;
-    createReturnFromSignature(
+    const returnType = createReturnFromSignature(
       fnNode,
       /*symbol*/
       void 0,
       context
     );
-    reuseTypeParameters(fnNode.typeParameters, context);
-    fnNode.parameters.map((p) => ensureParameter(p, context));
-    context.noInferenceFallback = oldNoInferenceFallback;
-    return notImplemented2;
+    const typeParameters = reuseTypeParameters(fnNode.typeParameters, context);
+    const parameters = fnNode.parameters.map((p) => ensureParameter(p, context));
+    return syntacticResult(
+      factory.createFunctionTypeNode(
+        typeParameters,
+        parameters,
+        returnType
+      )
+    );
   }
   function canGetTypeFromArrayLiteral(arrayLiteral, context, isConstContext) {
     if (!isConstContext) {