typescript 5.4.0-dev.20231120 → 5.4.0-dev.20231122

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231120`;
+var version = `${versionMajorMinor}.0-dev.20231122`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3661,7 +3661,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["InstantiablePrimitive"] = 406847488] = "InstantiablePrimitive";
   TypeFlags2[TypeFlags2["Instantiable"] = 465829888] = "Instantiable";
   TypeFlags2[TypeFlags2["StructuredOrInstantiable"] = 469499904] = "StructuredOrInstantiable";
-  TypeFlags2[TypeFlags2["ObjectFlagsType"] = 138117121] = "ObjectFlagsType";
+  TypeFlags2[TypeFlags2["ObjectFlagsType"] = 3899393] = "ObjectFlagsType";
   TypeFlags2[TypeFlags2["Simplifiable"] = 25165824] = "Simplifiable";
   TypeFlags2[TypeFlags2["Singleton"] = 67358815] = "Singleton";
   TypeFlags2[TypeFlags2["Narrowable"] = 536624127] = "Narrowable";
@@ -5935,6 +5935,10 @@ var Diagnostics = {
   ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled: diag(1286, 1 /* Error */, "ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled_1286", "ESM syntax is not allowed in a CommonJS module when 'verbatimModuleSyntax' is enabled."),
   A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimModuleSyntax_is_enabled: diag(1287, 1 /* Error */, "A_top_level_export_modifier_cannot_be_used_on_value_declarations_in_a_CommonJS_module_when_verbatimM_1287", "A top-level 'export' modifier cannot be used on value declarations in a CommonJS module when 'verbatimModuleSyntax' is enabled."),
   An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabled: diag(1288, 1 /* Error */, "An_import_alias_cannot_resolve_to_a_type_or_type_only_declaration_when_verbatimModuleSyntax_is_enabl_1288", "An import alias cannot resolve to a type or type-only declaration when 'verbatimModuleSyntax' is enabled."),
+  _0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: diag(1289, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_1289", "'{0}' resolves to a type-only declaration and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."),
+  _0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: diag(1290, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_1290", "'{0}' resolves to a type-only declaration and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."),
+  _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported: diag(1291, 1 /* Error */, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1291", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'import type' where '{0}' is imported."),
+  _0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default: diag(1292, 1 /* Error */, "_0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enable_1292", "'{0}' resolves to a type and must be marked type-only in this file before re-exporting when '{1}' is enabled. Consider using 'export type { {0} as default }'."),
   with_statements_are_not_allowed_in_an_async_function_block: diag(1300, 1 /* Error */, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
   await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, 1 /* Error */, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
   The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, 1 /* Error */, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
@@ -15970,7 +15974,7 @@ function getClassLikeDeclarationOfSymbol(symbol) {
   return (_a = symbol.declarations) == null ? void 0 : _a.find(isClassLike);
 }
 function getObjectFlags(type) {
-  return type.flags & 138117121 /* ObjectFlagsType */ ? type.objectFlags : 0;
+  return type.flags & 3899393 /* ObjectFlagsType */ ? type.objectFlags : 0;
 }
 function isUMDExportSymbol(symbol) {
   return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && isNamespaceExportDeclaration(symbol.declarations[0]);
@@ -18115,7 +18119,7 @@ var nullNodeConverters = {
 var nextAutoGenerateId = 0;
 var nodeFactoryPatchers = [];
 function createNodeFactory(flags, baseFactory2) {
-  const update = flags & 8 /* NoOriginalNode */ ? updateWithoutOriginal : updateWithOriginal;
+  const setOriginal = flags & 8 /* NoOriginalNode */ ? identity : setOriginalNode;
   const parenthesizerRules = memoize(() => flags & 1 /* NoParenthesizerRules */ ? nullParenthesizerRules : createParenthesizerRules(factory2));
   const converters = memoize(() => flags & 2 /* NoNodeConverters */ ? nullNodeConverters : createNodeConverters(factory2));
   const getBinaryCreateFunction = memoizeOne((operator) => (left, right) => createBinaryExpression(left, operator, right));
@@ -21613,7 +21617,7 @@ function createNodeFactory(flags, baseFactory2) {
   }
   function cloneSourceFile(source) {
     const node = source.redirectInfo ? cloneRedirectedSourceFile(source) : cloneSourceFileWorker(source);
-    setOriginalNode(node, source);
+    setOriginal(node, source);
     return node;
   }
   function cloneSourceFileWithChanges(source, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) {
@@ -21746,7 +21750,7 @@ function createNodeFactory(flags, baseFactory2) {
     const clone2 = createBaseIdentifier(node.escapedText);
     clone2.flags |= node.flags & ~16 /* Synthesized */;
     clone2.transformFlags = node.transformFlags;
-    setOriginalNode(clone2, node);
+    setOriginal(clone2, node);
     setIdentifierAutoGenerate(clone2, { ...node.emitNode.autoGenerate });
     return clone2;
   }
@@ -21757,7 +21761,7 @@ function createNodeFactory(flags, baseFactory2) {
     clone2.flowNode = node.flowNode;
     clone2.symbol = node.symbol;
     clone2.transformFlags = node.transformFlags;
-    setOriginalNode(clone2, node);
+    setOriginal(clone2, node);
     const typeArguments = getIdentifierTypeArguments(node);
     if (typeArguments)
       setIdentifierTypeArguments(clone2, typeArguments);
@@ -21767,7 +21771,7 @@ function createNodeFactory(flags, baseFactory2) {
     const clone2 = createBasePrivateIdentifier(node.escapedText);
     clone2.flags |= node.flags & ~16 /* Synthesized */;
     clone2.transformFlags = node.transformFlags;
-    setOriginalNode(clone2, node);
+    setOriginal(clone2, node);
     setIdentifierAutoGenerate(clone2, { ...node.emitNode.autoGenerate });
     return clone2;
   }
@@ -21775,7 +21779,7 @@ function createNodeFactory(flags, baseFactory2) {
     const clone2 = createBasePrivateIdentifier(node.escapedText);
     clone2.flags |= node.flags & ~16 /* Synthesized */;
     clone2.transformFlags = node.transformFlags;
-    setOriginalNode(clone2, node);
+    setOriginal(clone2, node);
     return clone2;
   }
   function cloneNode(node) {
@@ -21800,7 +21804,7 @@ function createNodeFactory(flags, baseFactory2) {
     const clone2 = !isNodeKind(node.kind) ? baseFactory2.createBaseTokenNode(node.kind) : baseFactory2.createBaseNode(node.kind);
     clone2.flags |= node.flags & ~16 /* Synthesized */;
     clone2.transformFlags = node.transformFlags;
-    setOriginalNode(clone2, node);
+    setOriginal(clone2, node);
     for (const key in node) {
       if (hasProperty(clone2, key) || !hasProperty(node, key)) {
         continue;
@@ -22325,7 +22329,7 @@ function createNodeFactory(flags, baseFactory2) {
     return typeof value === "number" ? createToken(value) : value;
   }
   function asEmbeddedStatement(statement) {
-    return statement && isNotEmittedStatement(statement) ? setTextRange(setOriginalNode(createEmptyStatement(), statement), statement) : statement;
+    return statement && isNotEmittedStatement(statement) ? setTextRange(setOriginal(createEmptyStatement(), statement), statement) : statement;
   }
   function asVariableDeclaration(variableDeclaration) {
     if (typeof variableDeclaration === "string" || variableDeclaration && !isVariableDeclaration(variableDeclaration)) {
@@ -22341,19 +22345,13 @@ function createNodeFactory(flags, baseFactory2) {
     }
     return variableDeclaration;
   }
-}
-function updateWithoutOriginal(updated, original) {
-  if (updated !== original) {
-    setTextRange(updated, original);
-  }
-  return updated;
-}
-function updateWithOriginal(updated, original) {
-  if (updated !== original) {
-    setOriginalNode(updated, original);
-    setTextRange(updated, original);
+  function update(updated, original) {
+    if (updated !== original) {
+      setOriginal(updated, original);
+      setTextRange(updated, original);
+    }
+    return updated;
   }
-  return updated;
 }
 function getDefaultTagNameForKind(kind) {
   switch (kind) {
@@ -26893,8 +26891,10 @@ var Parser;
     setTextRangePosWidth(sourceFile, 0, sourceText.length);
     setFields(sourceFile);
     if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & 67108864 /* ContainsPossibleTopLevelAwait */) {
+      const oldSourceFile = sourceFile;
       sourceFile = reparseTopLevelAwait(sourceFile);
-      setFields(sourceFile);
+      if (oldSourceFile !== sourceFile)
+        setFields(sourceFile);
     }
     return sourceFile;
     function setFields(sourceFile2) {
@@ -54197,7 +54197,12 @@ function createTypeChecker(host) {
         const checkType = type.checkType;
         const constraint = getLowerBoundOfKeyType(checkType);
         if (constraint !== checkType) {
-          return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+          return getConditionalTypeInstantiation(
+            type,
+            prependTypeMapping(type.root.checkType, constraint, type.mapper),
+            /*forConstraint*/
+            false
+          );
         }
       }
       return type;
@@ -54549,7 +54554,12 @@ function createTypeChecker(host) {
       );
       const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
       if (constraint && constraint !== type.checkType) {
-        const instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
+        const instantiated = getConditionalTypeInstantiation(
+          type,
+          prependTypeMapping(type.root.checkType, constraint, type.mapper),
+          /*forConstraint*/
+          true
+        );
         if (!(instantiated.flags & 131072 /* Never */)) {
           type.resolvedConstraintOfDistributive = instantiated;
           return instantiated;
@@ -56983,7 +56993,7 @@ function createTypeChecker(host) {
     }
   }
   function removeStringLiteralsMatchedByTemplateLiterals(types) {
-    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t) && t.types.every((t2) => !(t2.flags & 2097152 /* Intersection */) || !areIntersectedTypesAvoidingPrimitiveReduction(t2.types)));
+    const templates = filter(types, (t) => !!(t.flags & 134217728 /* TemplateLiteral */) && isPatternLiteralType(t));
     if (templates.length) {
       let i = types.length;
       while (i > 0) {
@@ -57383,19 +57393,14 @@ function createTypeChecker(host) {
   function getConstituentCountOfTypes(types) {
     return reduceLeft(types, (n, t) => n + getConstituentCount(t), 0);
   }
-  function areIntersectedTypesAvoidingPrimitiveReduction(types, primitiveFlags = 4 /* String */ | 8 /* Number */ | 64 /* BigInt */) {
-    if (types.length !== 2) {
-      return false;
-    }
-    const [t1, t2] = types;
-    return !!(t1.flags & primitiveFlags) && t2 === emptyTypeLiteralType || !!(t2.flags & primitiveFlags) && t1 === emptyTypeLiteralType;
-  }
   function getTypeFromIntersectionTypeNode(node) {
     const links = getNodeLinks(node);
     if (!links.resolvedType) {
       const aliasSymbol = getAliasSymbolForTypeNode(node);
       const types = map(node.types, getTypeFromTypeNode);
-      const noSupertypeReduction = areIntersectedTypesAvoidingPrimitiveReduction(types);
+      const emptyIndex = types.length === 2 ? types.indexOf(emptyTypeLiteralType) : -1;
+      const t = emptyIndex >= 0 ? types[1 - emptyIndex] : unknownType;
+      const noSupertypeReduction = !!(t.flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */) || t.flags & 134217728 /* TemplateLiteral */ && isPatternLiteralType(t));
       links.resolvedType = getIntersectionType(types, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), noSupertypeReduction);
     }
     return links.resolvedType;
@@ -57422,19 +57427,17 @@ function createTypeChecker(host) {
       return constraintType;
     }
     const keyTypes = [];
-    if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
-      if (!isGenericIndexType(constraintType)) {
-        const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
-        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
-      } else {
+    if (isGenericIndexType(constraintType)) {
+      if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
         return getIndexTypeForGenericType(type, indexFlags);
       }
+      forEachType(constraintType, addMemberForKeyType);
+    } else if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
+      const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
+      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
     }
-    if (isGenericIndexType(constraintType)) {
-      forEachType(constraintType, addMemberForKeyType);
-    }
     const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
     if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
       return constraintType;
@@ -57607,11 +57610,6 @@ function createTypeChecker(host) {
   }
   function createTemplateLiteralType(texts, types) {
     const type = createType(134217728 /* TemplateLiteral */);
-    type.objectFlags = getPropagatingFlagsOfTypes(
-      types,
-      /*excludeKinds*/
-      98304 /* Nullable */
-    );
     type.texts = texts;
     type.types = types;
     return type;
@@ -57906,7 +57904,15 @@ function createTypeChecker(host) {
   }
   function isPatternLiteralPlaceholderType(type) {
     if (type.flags & 2097152 /* Intersection */) {
-      return !isGenericType(type) && some(type.types, (t) => !!(t.flags & (2944 /* Literal */ | 98304 /* Nullable */)) || isPatternLiteralPlaceholderType(t));
+      let seenPlaceholder = false;
+      for (const t of type.types) {
+        if (t.flags & (2944 /* Literal */ | 98304 /* Nullable */) || isPatternLiteralPlaceholderType(t)) {
+          seenPlaceholder = true;
+        } else if (!(t.flags & 524288 /* Object */)) {
+          return false;
+        }
+      }
+      return seenPlaceholder;
     }
     return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || isPatternLiteralType(type);
   }
@@ -57923,7 +57929,7 @@ function createTypeChecker(host) {
     return !!(getGenericObjectFlags(type) & 8388608 /* IsGenericIndexType */);
   }
   function getGenericObjectFlags(type) {
-    if (type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */)) {
+    if (type.flags & 3145728 /* UnionOrIntersection */) {
       if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
         type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | reduceLeft(type.types, (flags, t) => flags | getGenericObjectFlags(t), 0);
       }
@@ -57935,7 +57941,7 @@ function createTypeChecker(host) {
       }
       return type.objectFlags & 12582912 /* IsGenericType */;
     }
-    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
+    return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
   }
   function getSimplifiedType(type, writing) {
     return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
@@ -58116,7 +58122,7 @@ function createTypeChecker(host) {
   function isDeferredType(type, checkTuples) {
     return isGenericType(type) || checkTuples && isTupleType(type) && some(getElementTypes(type), isGenericType);
   }
-  function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalType(root, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     let result;
     let extraTypes;
     let tailCount = 0;
@@ -58162,7 +58168,7 @@ function createTypeChecker(host) {
       const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
       if (!checkTypeDeferred && !isDeferredType(inferredExtendsType, checkTuples)) {
         if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
-          if (checkType.flags & 1 /* Any */) {
+          if (checkType.flags & 1 /* Any */ || forConstraint && !(inferredExtendsType.flags & 131072 /* Never */) && someType(getPermissiveInstantiation(inferredExtendsType), (t) => isTypeAssignableTo(t, getPermissiveInstantiation(checkType)))) {
             (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
           }
           const falseType2 = getTypeFromTypeNode(root.node.falseType);
@@ -58272,7 +58278,9 @@ function createTypeChecker(host) {
       links.resolvedType = getConditionalType(
         root,
         /*mapper*/
-        void 0
+        void 0,
+        /*forConstraint*/
+        false
       );
       if (outerTypeParameters) {
         root.instantiations = /* @__PURE__ */ new Map();
@@ -58961,7 +58969,7 @@ function createTypeChecker(host) {
         result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) : target.objectFlags & 32 /* Mapped */ ? instantiateMappedType(target, newMapper, newAliasSymbol, newAliasTypeArguments) : instantiateAnonymousType(target, newMapper, newAliasSymbol, newAliasTypeArguments);
         target.instantiations.set(id, result);
         const resultObjectFlags = getObjectFlags(result);
-        if (result.flags & 138117121 /* ObjectFlagsType */ && !(resultObjectFlags & 524288 /* CouldContainTypeVariablesComputed */)) {
+        if (result.flags & 3899393 /* ObjectFlagsType */ && !(resultObjectFlags & 524288 /* CouldContainTypeVariablesComputed */)) {
           const resultCouldContainTypeVariables = some(typeArguments, couldContainTypeVariables);
           if (!(getObjectFlags(result) & 524288 /* CouldContainTypeVariablesComputed */)) {
             if (resultObjectFlags & (32 /* Mapped */ | 16 /* Anonymous */ | 4 /* Reference */)) {
@@ -59127,17 +59135,17 @@ function createTypeChecker(host) {
     result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0;
     return result;
   }
-  function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
+  function getConditionalTypeInstantiation(type, mapper, forConstraint, aliasSymbol, aliasTypeArguments) {
     const root = type.root;
     if (root.outerTypeParameters) {
       const typeArguments = map(root.outerTypeParameters, (t) => getMappedType(t, mapper));
-      const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
+      const id = (forConstraint ? "C" : "") + getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
       let result = root.instantiations.get(id);
       if (!result) {
         const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
         const checkType = root.checkType;
         const distributionType = root.isDistributive ? getMappedType(checkType, newMapper) : void 0;
-        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, aliasSymbol, aliasTypeArguments);
+        result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper), forConstraint), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, forConstraint, aliasSymbol, aliasTypeArguments);
         root.instantiations.set(id, result);
       }
       return result;
@@ -59225,7 +59233,14 @@ function createTypeChecker(host) {
       );
     }
     if (flags & 16777216 /* Conditional */) {
-      return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
+      return getConditionalTypeInstantiation(
+        type,
+        combineTypeMappers(type.mapper, mapper),
+        /*forConstraint*/
+        false,
+        aliasSymbol,
+        aliasTypeArguments
+      );
     }
     if (flags & 33554432 /* Substitution */) {
       const newBaseType = instantiateType(type.baseType, mapper);
@@ -60869,7 +60884,7 @@ function createTypeChecker(host) {
         return relation === comparableRelation ? someTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */), intersectionState) : eachTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */), intersectionState);
       }
       if (target2.flags & 1048576 /* Union */) {
-        return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */) && !(target2.flags & 402784252 /* Primitive */));
+        return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 402784252 /* Primitive */) && !(target2.flags & 402784252 /* Primitive */), intersectionState);
       }
       if (target2.flags & 2097152 /* Intersection */) {
         return typeRelatedToEachType(source2, target2, reportErrors2, 2 /* Target */);
@@ -60914,7 +60929,8 @@ function createTypeChecker(host) {
           sourceType,
           target2,
           /*reportErrors*/
-          false
+          false,
+          0 /* None */
         );
         if (!related) {
           return 0 /* False */;
@@ -60923,7 +60939,7 @@ function createTypeChecker(host) {
       }
       return result2;
     }
-    function typeRelatedToSomeType(source2, target2, reportErrors2) {
+    function typeRelatedToSomeType(source2, target2, reportErrors2, intersectionState) {
       const targetTypes = target2.types;
       if (target2.flags & 1048576 /* Union */) {
         if (containsType(targetTypes, source2)) {
@@ -60941,7 +60957,10 @@ function createTypeChecker(host) {
             match,
             2 /* Target */,
             /*reportErrors*/
-            false
+            false,
+            /*headMessage*/
+            void 0,
+            intersectionState
           );
           if (related) {
             return related;
@@ -60954,7 +60973,10 @@ function createTypeChecker(host) {
           type,
           2 /* Target */,
           /*reportErrors*/
-          false
+          false,
+          /*headMessage*/
+          void 0,
+          intersectionState
         );
         if (related) {
           return related;
@@ -60968,7 +60990,10 @@ function createTypeChecker(host) {
             bestMatchingType,
             2 /* Target */,
             /*reportErrors*/
-            true
+            true,
+            /*headMessage*/
+            void 0,
+            intersectionState
           );
         }
       }
@@ -61766,13 +61791,6 @@ function createTypeChecker(host) {
               return result2;
             }
           }
-        } else {
-          const distributiveConstraint = hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
-          if (distributiveConstraint) {
-            if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
-              return result2;
-            }
-          }
         }
         const defaultConstraint = getDefaultConstraintOfConditionalType(source2);
         if (defaultConstraint) {
@@ -61780,6 +61798,13 @@ function createTypeChecker(host) {
             return result2;
           }
         }
+        const distributiveConstraint = !(targetFlags & 16777216 /* Conditional */) && hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
+        if (distributiveConstraint) {
+          resetErrorInfo(saveErrorInfo);
+          if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
+            return result2;
+          }
+        }
       } else {
         if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target2) && isEmptyObjectType(source2)) {
           return -1 /* True */;
@@ -63677,8 +63702,8 @@ function createTypeChecker(host) {
     if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
       return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
     }
-    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
-    if (type.flags & 138117121 /* ObjectFlagsType */) {
+    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
+    if (type.flags & 3899393 /* ObjectFlagsType */) {
       type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
     }
     return result;
@@ -64805,7 +64830,8 @@ function createTypeChecker(host) {
     if (hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node)) {
       const initializer = getEffectiveInitializer(declaration);
       if (initializer) {
-        return tryGetNameFromType(getTypeOfExpression(initializer));
+        const initializerType = isBindingPattern(declaration.parent) ? getTypeForBindingElement(declaration) : getTypeOfExpression(initializer);
+        return initializerType && tryGetNameFromType(initializerType);
       }
       if (isEnumMember(declaration)) {
         return getTextOfPropertyName(declaration.name);
@@ -80651,10 +80677,11 @@ function createTypeChecker(host) {
         node
       ));
       if (sym) {
+        const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(sym, 111551 /* Value */);
         markAliasReferenced(sym, id);
         if (getSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
-          if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && getTypeOnlyAliasDeclaration(sym, 111551 /* Value */)) {
+          if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && typeOnlyDeclaration) {
             error(
               id,
               node.isExportEquals ? Diagnostics.An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration : Diagnostics.An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration,
@@ -80668,6 +80695,33 @@ function createTypeChecker(host) {
             idText(id)
           );
         }
+        if (!isIllegalExportDefaultInCJS && getIsolatedModules(compilerOptions) && !(sym.flags & 111551 /* Value */)) {
+          if (sym.flags & 2097152 /* Alias */ && resolveAlias(sym) !== unknownSymbol && getSymbolFlags(
+            sym,
+            /*excludeTypeOnlyMeanings*/
+            false,
+            /*excludeLocalMeanings*/
+            true
+          ) & 788968 /* Type */ && (!typeOnlyDeclaration || getSourceFileOfNode(typeOnlyDeclaration) !== getSourceFileOfNode(node))) {
+            error(
+              id,
+              node.isExportEquals ? Diagnostics._0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported : Diagnostics._0_resolves_to_a_type_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default,
+              idText(id),
+              isolatedModulesLikeFlagName
+            );
+          } else if (typeOnlyDeclaration && getSourceFileOfNode(typeOnlyDeclaration) !== getSourceFileOfNode(node)) {
+            addTypeOnlyDeclarationRelatedInfo(
+              error(
+                id,
+                node.isExportEquals ? Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_import_type_where_0_is_imported : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_marked_type_only_in_this_file_before_re_exporting_when_1_is_enabled_Consider_using_export_type_0_as_default,
+                idText(id),
+                isolatedModulesLikeFlagName
+              ),
+              typeOnlyDeclaration,
+              idText(id)
+            );
+          }
+        }
       } else {
         checkExpressionCached(id);
       }
@@ -82062,7 +82116,11 @@ function createTypeChecker(host) {
         const exportClause = node.exportClause;
         return !!exportClause && (isNamespaceExport(exportClause) || some(exportClause.elements, isValueAliasDeclaration));
       case 277 /* ExportAssignment */:
-        return node.expression && node.expression.kind === 80 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfDeclaration(node)) : true;
+        return node.expression && node.expression.kind === 80 /* Identifier */ ? isAliasResolvedToValue(
+          getSymbolOfDeclaration(node),
+          /*excludeTypeOnlyValues*/
+          true
+        ) : true;
     }
     return false;
   }