tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/relations.js

@@ -0,0 +1,4002 @@
+// Type relations: identity, subtype, strict subtype, assignability and comparability, with
+// tsgo's result caching, recursion limits, variance measurement and error elaboration.
+import { lazyObjectFlags, sideOf, sideOfIfAny } from './side-state.js';
+import { getExpression, getName, getNodeId, getText, } from './ast.js';
+import { getSymbolNameForPrivateIdentifier } from './binder.js';
+import { getCombinedModifierFlags } from './binder-utilities.js';
+import { Diagnostic, messageElidedInCompatibilityPyramid } from './diagnostics.js';
+import { getSymbolId } from './symbol.js';
+import { isContextSensitive } from './checker-functions.js';
+import { createDiagnosticForNode } from './checker.js';
+import { cachedTypeKey, emptyTypes, newTypeMapper, SimpleTypeMapper, } from './checker-types.js';
+import { createInferenceContext, inferTypes } from './checker-inference.js';
+import { unionContainsSortedTypes, unionContainsType, createArrayTypeEx, compareTypes, containsMissingType, createTypeReference, everyType, filterType, getBaseTypeOfLiteralType, getBaseTypeOfEnumLikeType, getElementTypes, getIntersectionType, getIntersectionTypeEx, getTargetType, getTypeArguments, getTypeReferenceArity, getUnionType, getUnionTypeEx, isArrayOrTupleType, isArrayType, isEmptyAnonymousObjectType, isEmptyObjectType, isErrorType, isFreshLiteralType, isGenericTupleType, isLiteralType, isMutableArrayOrTuple, isReadonlyArrayType, isTupleType, isUnitType, someType, tupleTargetOf, typesOf, countTypes, getStartElementCount, getEndElementCount, createNormalizedTypeReference, typeListKey, getRegularTypeOfLiteralType, } from './checker-type-factory.js';
+import { findApplicableIndexInfo, getApparentType, getApplicableIndexInfo, getApplicableIndexInfoForName, getBaseConstraintOfType, getBaseConstraintOrType, getConstraintOfType, getDeclarationModifierFlagsFromSymbol, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getPropertiesOfObjectType, getPropertiesOfType, getPropertiesOfUnionOrIntersectionType, getPropertyOfObjectType, getPropertyOfType, getPropertyOfUnionOrIntersectionType, getReducedType, getSignaturesOfStructuredType, getSignaturesOfType, getTargetSymbol, getTypeOfPropertyOfType, getTypeWithThisArgument, getUnionOrIntersectionProperty, isApplicableIndexType, isArrayLikeType, isObjectLiteralType, isDiscriminantWithNeverType, isConflictingPrivateProperty, resolveStructuredTypeMembers, getResolvedMember, hasResolvedProperties, resolvedPropertiesAreOptional, } from './checker-members.js';
+import { getParentOfSymbol, getMergedSymbol, getMembersOfSymbol, getSpellingSuggestionForName, } from './checker-symbols.js';
+import { CodePoints, distanceToCandidate, utf8Length } from './spelling.js';
+import { getConstraintFromTypeParameter, getDeclaredTypeOfSymbol, getDefaultOrUnknownFromTypeParameter, fillMissingTypeArguments, getMinTypeArgumentCount, hasBaseType, hasNonCircularBaseConstraint, computeEnumMemberValues, getBaseTypes, getExtendsHeritageClauseElement, } from './checker-declared-types.js';
+import { getNonMissingTypeOfSymbol, getOptionalType, getTypeOfSymbol, isReadonlySymbol, removeMissingType, addOptionality, } from './checker-symbol-types.js';
+import { cloneTypeParameter, couldContainTypeVariables, instantiateSignatureEx, instantiateType, isTypeParameterPossiblyReferenced, getRestrictiveInstantiation, } from './instantiation.js';
+import { getJsxType, getSuggestedSymbolForNonexistentJSXAttribute, isJsxOpeningLikeElement } from './checker-jsx.js';
+import { signatureToString, symbolToString, typeToString, typePredicateToString } from './type-printer.js';
+import { getConstraintOfDistributiveConditionalType, getDefaultConstraintOfConditionalType, getConstraintTypeFromMappedType, getFalseTypeFromConditionalType, getIndexType, getIndexTypeEx, getIndexedAccessType, getIndexedAccessTypeOrUndefined, getMappedTypeModifiers, getCombinedMappedTypeOptionality, getModifiersTypeFromMappedType, getNameTypeFromMappedType, getPermissiveInstantiation, getSimplifiedType, getSubstitutionIntersection, getTemplateTypeFromMappedType, getTrueTypeFromConditionalType, getTypeParameterFromMappedType, isGenericIndexType, isGenericMappedType, isGenericObjectType, isMappedTypeGenericIndexedAccess, isTypeMatchedByTemplateLiteralType, isMemberOfStringMapping, getApparentMappedTypeKeys, shouldDeferIndexType, isMappedTypeWithKeyofConstraintDeclaration, } from './checker-type-operators.js';
+import { getCanonicalSignature, getErasedSignature, getMinArgumentCount, getNonArrayRestType, getNonCircularReturnTypeOfSignature, getParameterCount, getParameterNameAtPosition, getRestOrAnyTypeAtPosition, getReturnTypeOfSignature, getSingleCallSignature, getThisTypeOfSignature, getTypeAtPosition, getTypePredicateOfSignature, hasEffectiveRestParameter, instantiateSignatureInContextOf, isTopSignature, tryGetTypeAtPosition, } from './checker-signatures.js';
+import { getNonNullableType, getTypeFacts } from './checker-flow.js';
+import { getPropertyNameFromType, isLateBoundName, isNumericLiteralName, maybeTypeOfKind, } from './checker-utilities.js';
+/**
+ * Cached results of one relation by numeric relation key (see getRelationKey): an open-addressing
+ * table of keys and one-byte results. Keys are never 0 (packed keys are positive, interned ones
+ * negative), so 0 marks a free slot. At 3/8 to 3/4 full it takes about 16 bytes per result, where a
+ * Map takes about 40 (a 24-byte entry, its share of the bucket table and of the spare capacity);
+ * relations are most of a checker's tables on programs with many structural comparisons.
+ */
+export class Relation {
+    keys = new Float64Array(64);
+    results = new Uint8Array(64);
+    count = 0;
+    get(key) {
+        const keys = this.keys;
+        const mask = keys.length - 1;
+        for (let i = relationSlot(key) & mask;; i = (i + 1) & mask) {
+            const k = keys[i];
+            if (k === key)
+                return this.results[i];
+            if (k === 0)
+                return 0 /* RelationComparisonResult.None */;
+        }
+    }
+    set(key, result) {
+        const keys = this.keys;
+        const mask = keys.length - 1;
+        for (let i = relationSlot(key) & mask;; i = (i + 1) & mask) {
+            const k = keys[i];
+            if (k === key) {
+                this.results[i] = result;
+                return;
+            }
+            if (k === 0) {
+                keys[i] = key;
+                this.results[i] = result;
+                this.count++;
+                if (this.count * 4 > keys.length * 3)
+                    this.grow();
+                return;
+            }
+        }
+    }
+    size() {
+        return this.count;
+    }
+    grow() {
+        const oldKeys = this.keys;
+        const oldResults = this.results;
+        const keys = new Float64Array(oldKeys.length * 2);
+        const results = new Uint8Array(oldKeys.length * 2);
+        const mask = keys.length - 1;
+        for (let j = 0; j < oldKeys.length; j++) {
+            const key = oldKeys[j];
+            if (key === 0)
+                continue;
+            let i = relationSlot(key) & mask;
+            while (keys[i] !== 0)
+                i = (i + 1) & mask;
+            keys[i] = key;
+            results[i] = oldResults[j];
+        }
+        this.keys = keys;
+        this.results = results;
+    }
+}
+/**
+ * The hash of a relation key, an integer of at most 53 bits: its low 24 bits (a type id in packed
+ * keys) mixed with the rest, both small enough for int32 arithmetic.
+ */
+function relationSlot(key) {
+    const high = Math.floor(key / 16777216);
+    const low = key - high * 16777216;
+    const h = Math.imul((high | 0) ^ Math.imul(low | 0, 0x9e3779b1 | 0), 0x85ebca6b | 0);
+    return h ^ (h >>> 15);
+}
+// ---- Comparers
+/**
+ * Compares types for signature and property comparisons, and receives their error reports.
+ * Subclasses replace tsgo's comparer and error reporter callbacks.
+ */
+export class TypeComparer {
+    /** Records an elaboration; the default ignores it. */
+    report(_message, _args) { }
+}
+class RelationComparer extends TypeComparer {
+    c;
+    kind;
+    constructor(c, kind) {
+        super();
+        this.c = c;
+        this.kind = kind;
+    }
+    compare(source, target, _reportErrors) {
+        const c = this.c;
+        switch (this.kind) {
+            case 0 /* ComparerKind.Identical */:
+                return isTypeRelatedTo(c, source, target, c.identityRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+            case 1 /* ComparerKind.SubtypeOf */:
+                return isTypeRelatedTo(c, source, target, c.subtypeRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+            case 2 /* ComparerKind.Assignable */:
+                return isTypeRelatedTo(c, source, target, c.assignableRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+        }
+        return source === target ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+    }
+}
+export function getComparer(c, kind) {
+    let list = c.relationComparers;
+    if (list.length === 0) {
+        list = [
+            new RelationComparer(c, 0 /* ComparerKind.Identical */),
+            new RelationComparer(c, 1 /* ComparerKind.SubtypeOf */),
+            new RelationComparer(c, 2 /* ComparerKind.Assignable */),
+            new RelationComparer(c, 3 /* ComparerKind.Equal */),
+        ];
+        c.relationComparers = list;
+    }
+    return list[kind];
+}
+export function compareTypesIdentical(c, s, t) {
+    return isTypeRelatedTo(c, s, t, c.identityRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+}
+export function compareTypesSubtypeOf(c, s, t) {
+    return isTypeRelatedTo(c, s, t, c.subtypeRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+}
+export function compareTypesAssignable(c, s, t) {
+    return isTypeRelatedTo(c, s, t, c.assignableRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+}
+export function compareTypesEqual(_c, s, t) {
+    return s === t ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+}
+// ---- Entry points
+export function isTypeIdenticalTo(c, source, target) {
+    return isTypeRelatedTo(c, source, target, c.identityRelation);
+}
+export function isTypeAssignableTo(c, source, target) {
+    return isTypeRelatedTo(c, source, target, c.assignableRelation);
+}
+export function isTypeSubtypeOf(c, source, target) {
+    return isTypeRelatedTo(c, source, target, c.subtypeRelation);
+}
+export function isTypeStrictSubtypeOf(c, source, target) {
+    return isTypeRelatedTo(c, source, target, c.strictSubtypeRelation);
+}
+export function isTypeComparableTo(c, source, target) {
+    return isTypeRelatedTo(c, source, target, c.comparableRelation);
+}
+export function areTypesComparable(c, type1, type2) {
+    return isTypeComparableTo(c, type1, type2) || isTypeComparableTo(c, type2, type1);
+}
+export function isTypeRelatedTo(c, source, target, relation) {
+    if (isFreshLiteralType(source))
+        source = source.regularType;
+    if (isFreshLiteralType(target))
+        target = target.regularType;
+    if (source === target)
+        return true;
+    // A template literal target whose start and end texts rule out a match relates to no string
+    // literal or template literal source, under any relation. (The full check reports unreliable
+    // variance for type variables in a template literal source, so those take it.)
+    if ((target.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+        if ((source.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 &&
+            !stringLiteralTextMayMatch(source.stringValue, target))
+            return false;
+        if ((source.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0 &&
+            (relation === c.comparableRelation
+                ? templateLiteralTypesDefinitelyUnrelated(source, target)
+                : !templateLiteralTextsMayMatch(source, target)) &&
+            !someTypeCouldContainTypeVariables(c, source.types))
+            return false;
+    }
+    if (relation !== c.identityRelation) {
+        if ((relation === c.comparableRelation &&
+            (target.flags & 262144 /* TypeFlags.Never */) === 0 &&
+            isSimpleTypeRelatedTo(c, target, source, relation, undefined)) ||
+            isSimpleTypeRelatedTo(c, source, target, relation, undefined))
+            return true;
+        // A primitive against a union: the relater (in typeRelatedToSomeType) finds it related when the
+        // union contains it, and decides a union of primitives without setting up a relater. Unions of
+        // four or more primitives that membership doesn't decide take the full check, which caches them.
+        if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0 && (source.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) === 0) {
+            if (unionContainsType(c, target, source))
+                return true;
+            if ((target.objectFlags & 32768 /* ObjectFlags.PrimitiveUnion */) !== 0) {
+                if (isLiteralRelatedByPrimitiveUnionForms(c, source, target, relation))
+                    return literalRelatedToPrimitiveUnion(c, source, target);
+                const types = typesOf(target);
+                if (types.length < 4) {
+                    for (const t of types) {
+                        const u = isFreshLiteralType(t) ? t.regularType : t;
+                        if (source === u ||
+                            (relation === c.comparableRelation &&
+                                (u.flags & 262144 /* TypeFlags.Never */) === 0 &&
+                                isSimpleTypeRelatedTo(c, u, source, relation, undefined)) ||
+                            isSimpleTypeRelatedTo(c, source, u, relation, undefined))
+                            return true;
+                    }
+                    return false;
+                }
+            }
+        }
+    }
+    else if (((source.flags | target.flags) &
+        (402653184 /* TypeFlags.UnionOrIntersection */ | 33554432 /* TypeFlags.IndexedAccess */ | 67108864 /* TypeFlags.Conditional */ | 16777216 /* TypeFlags.Substitution */)) ===
+        0) {
+        // Types that can't simplify must have identical flags.
+        if (source.flags !== target.flags)
+            return false;
+        if ((source.flags & 394239 /* TypeFlags.Singleton */) !== 0)
+            return true;
+    }
+    if ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+        const related = relation.get(getRelationKey(c, source, target, 0 /* IntersectionState.None */, relation === c.identityRelation, false).key);
+        if (related !== 0 /* RelationComparisonResult.None */)
+            return (related & 1 /* RelationComparisonResult.Succeeded */) !== 0;
+    }
+    if ((source.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) !== 0 ||
+        (target.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) !== 0)
+        return checkTypeRelatedTo(c, source, target, relation, undefined, undefined, undefined);
+    return false;
+}
+/**
+ * Whether `source` is a literal that relates to the primitive union `target` only through its base
+ * primitive or its other freshness form (see literalRelatedToPrimitiveUnion).
+ */
+function isLiteralRelatedByPrimitiveUnionForms(c, source, target, relation) {
+    return (relation !== c.comparableRelation &&
+        (target.objectFlags & 32768 /* ObjectFlags.PrimitiveUnion */) !== 0 &&
+        (source.flags & 32768 /* TypeFlags.EnumLiteral */) === 0 &&
+        ((source.flags & (1024 /* TypeFlags.StringLiteral */ | 8192 /* TypeFlags.BooleanLiteral */ | 4096 /* TypeFlags.BigIntLiteral */)) !== 0 ||
+            ((relation === c.subtypeRelation || relation === c.strictSubtypeRelation) &&
+                (source.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)));
+}
+function literalRelatedToPrimitiveUnion(c, source, target) {
+    const literal = source;
+    // Typed: scriptc can't pass the narrowed LiteralType field as a Type.
+    const alternateForm = source === literal.regularType ? (literal.freshType ?? sideOfIfAny(c, literal)?.freshType) : literal.regularType;
+    let primitive;
+    if ((source.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+        primitive = c.stringType;
+    else if ((source.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+        primitive = c.numberType;
+    else if ((source.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+        primitive = c.bigintType;
+    return ((primitive !== undefined && unionContainsType(c, target, primitive)) ||
+        (alternateForm !== undefined && unionContainsType(c, target, alternateForm)));
+}
+export function isSimpleTypeRelatedTo(c, source, target, relation, reporter) {
+    // Every rule below that can succeed needs one of these target flags, one of these source flags, or
+    // the wildcard source. Most pairs (objects, type parameters, intersections) have none of them; the
+    // test is small enough to inline into callers.
+    if ((target.flags &
+        (1 /* TypeFlags.Any */ |
+            2 /* TypeFlags.Unknown */ |
+            32 /* TypeFlags.String */ |
+            1024 /* TypeFlags.StringLiteral */ |
+            64 /* TypeFlags.Number */ |
+            2048 /* TypeFlags.NumberLiteral */ |
+            128 /* TypeFlags.BigInt */ |
+            256 /* TypeFlags.Boolean */ |
+            512 /* TypeFlags.ESSymbol */ |
+            65536 /* TypeFlags.Enum */ |
+            32768 /* TypeFlags.EnumLiteral */ |
+            131072 /* TypeFlags.NonPrimitive */ |
+            134217728 /* TypeFlags.Union */)) ===
+        0 &&
+        (source.flags & (1 /* TypeFlags.Any */ | 262144 /* TypeFlags.Never */ | 4 /* TypeFlags.Undefined */ | 8 /* TypeFlags.Null */)) === 0 &&
+        source !== c.wildcardType)
+        return false;
+    return isSimpleTypeRelatedToWorker(c, source, target, relation, reporter);
+}
+function isSimpleTypeRelatedToWorker(c, source, target, relation, reporter) {
+    const s = source.flags;
+    const t = target.flags;
+    if ((t & 1 /* TypeFlags.Any */) !== 0 || (s & 262144 /* TypeFlags.Never */) !== 0 || source === c.wildcardType)
+        return true;
+    if ((t & 2 /* TypeFlags.Unknown */) !== 0 && !(relation === c.strictSubtypeRelation && (s & 1 /* TypeFlags.Any */) !== 0))
+        return true;
+    if ((t & 262144 /* TypeFlags.Never */) !== 0)
+        return false;
+    if ((s & 12583968 /* TypeFlags.StringLike */) !== 0 && (t & 32 /* TypeFlags.String */) !== 0)
+        return true;
+    if ((s & 1024 /* TypeFlags.StringLiteral */) !== 0 &&
+        (s & 32768 /* TypeFlags.EnumLiteral */) !== 0 &&
+        (t & 1024 /* TypeFlags.StringLiteral */) !== 0 &&
+        (t & 32768 /* TypeFlags.EnumLiteral */) === 0 &&
+        source.stringValue === target.stringValue)
+        return true;
+    if ((s & 67648 /* TypeFlags.NumberLike */) !== 0 && (t & 64 /* TypeFlags.Number */) !== 0)
+        return true;
+    if ((s & 2048 /* TypeFlags.NumberLiteral */) !== 0 &&
+        (s & 32768 /* TypeFlags.EnumLiteral */) !== 0 &&
+        (t & 2048 /* TypeFlags.NumberLiteral */) !== 0 &&
+        (t & 32768 /* TypeFlags.EnumLiteral */) === 0 &&
+        sameLiteralValue(source, target))
+        return true;
+    if ((s & 4224 /* TypeFlags.BigIntLike */) !== 0 && (t & 128 /* TypeFlags.BigInt */) !== 0)
+        return true;
+    if ((s & 8448 /* TypeFlags.BooleanLike */) !== 0 && (t & 256 /* TypeFlags.Boolean */) !== 0)
+        return true;
+    if ((s & 16896 /* TypeFlags.ESSymbolLike */) !== 0 && (t & 512 /* TypeFlags.ESSymbol */) !== 0)
+        return true;
+    if ((s & 65536 /* TypeFlags.Enum */) !== 0 &&
+        (t & 65536 /* TypeFlags.Enum */) !== 0 &&
+        source.symbol.name === target.symbol.name &&
+        isEnumTypeRelatedTo(c, source.symbol, target.symbol, reporter))
+        return true;
+    if ((s & 32768 /* TypeFlags.EnumLiteral */) !== 0 && (t & 32768 /* TypeFlags.EnumLiteral */) !== 0) {
+        if ((s & 134217728 /* TypeFlags.Union */) !== 0 &&
+            (t & 134217728 /* TypeFlags.Union */) !== 0 &&
+            isEnumTypeRelatedTo(c, source.symbol, target.symbol, reporter))
+            return true;
+        if ((s & 15360 /* TypeFlags.Literal */) !== 0 &&
+            (t & 15360 /* TypeFlags.Literal */) !== 0 &&
+            sameLiteralValue(source, target) &&
+            isEnumTypeRelatedTo(c, source.symbol, target.symbol, reporter))
+            return true;
+    }
+    // Without strictNullChecks, undefined and null are assignable to anything but never (and unions/intersections that may reduce to it).
+    if ((s & 4 /* TypeFlags.Undefined */) !== 0 &&
+        ((!c.strictNullChecks && (t & 402653184 /* TypeFlags.UnionOrIntersection */) === 0) ||
+            (t & (4 /* TypeFlags.Undefined */ | 16 /* TypeFlags.Void */)) !== 0))
+        return true;
+    if ((s & 8 /* TypeFlags.Null */) !== 0 &&
+        ((!c.strictNullChecks && (t & 402653184 /* TypeFlags.UnionOrIntersection */) === 0) || (t & 8 /* TypeFlags.Null */) !== 0))
+        return true;
+    if ((s & 1048576 /* TypeFlags.Object */) !== 0 &&
+        (t & 131072 /* TypeFlags.NonPrimitive */) !== 0 &&
+        !(relation === c.strictSubtypeRelation &&
+            isEmptyAnonymousObjectType(c, source) &&
+            (source.objectFlags & 8192 /* ObjectFlags.FreshLiteral */) === 0))
+        return true;
+    if (relation === c.assignableRelation || relation === c.comparableRelation) {
+        if ((s & 1 /* TypeFlags.Any */) !== 0)
+            return true;
+        // Numbers are assignable to numeric enums, for bit flags.
+        if ((s & 64 /* TypeFlags.Number */) !== 0 &&
+            ((t & 65536 /* TypeFlags.Enum */) !== 0 || ((t & 2048 /* TypeFlags.NumberLiteral */) !== 0 && (t & 32768 /* TypeFlags.EnumLiteral */) !== 0)))
+            return true;
+        if ((s & 2048 /* TypeFlags.NumberLiteral */) !== 0 &&
+            (s & 32768 /* TypeFlags.EnumLiteral */) === 0 &&
+            ((t & 65536 /* TypeFlags.Enum */) !== 0 ||
+                ((t & 2048 /* TypeFlags.NumberLiteral */) !== 0 && (t & 32768 /* TypeFlags.EnumLiteral */) !== 0 && sameLiteralValue(source, target))))
+            return true;
+        // Anything is assignable to a union of undefined, null and {}.
+        if (isUnknownLikeUnionType(c, target))
+            return true;
+    }
+    return false;
+}
+/** Whether two literal types have the same value; literals of different kinds never do. */
+function sameLiteralValue(a, b) {
+    if (((a.flags ^ b.flags) & 15360 /* TypeFlags.Literal */) !== 0)
+        return false;
+    const x = a;
+    const y = b;
+    if ((a.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+        return x.numberValue === y.numberValue || (x.numberValue !== x.numberValue && y.numberValue !== y.numberValue);
+    return x.stringValue === y.stringValue;
+}
+function someTypeIsEmptyAnonymousObject(c, types) {
+    for (const t of types)
+        if (isEmptyAnonymousObjectType(c, t))
+            return true;
+    return false;
+}
+export function isUnknownLikeUnionType(c, t) {
+    if (!c.strictNullChecks || (t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return false;
+    const side = sideOf(c, t);
+    if ((side.objectFlags & 67108864 /* ObjectFlags.IsUnknownLikeUnionComputed */) === 0) {
+        side.objectFlags |= 67108864 /* ObjectFlags.IsUnknownLikeUnionComputed */;
+        const types = typesOf(t);
+        if (types.length >= 3 &&
+            (types[0].flags & 4 /* TypeFlags.Undefined */) !== 0 &&
+            (types[1].flags & 8 /* TypeFlags.Null */) !== 0 &&
+            someTypeIsEmptyAnonymousObject(c, types))
+            side.objectFlags |= 134217728 /* ObjectFlags.IsUnknownLikeUnion */;
+    }
+    return (side.objectFlags & 134217728 /* ObjectFlags.IsUnknownLikeUnion */) !== 0;
+}
+function isEnumTypeRelatedTo(c, source, target, reporter) {
+    const sourceSymbol = (source.flags & 8 /* SymbolFlags.EnumMember */) !== 0 ? getParentOfSymbol(c, source) : source;
+    const targetSymbol = (target.flags & 8 /* SymbolFlags.EnumMember */) !== 0 ? getParentOfSymbol(c, target) : target;
+    if (sourceSymbol === targetSymbol)
+        return true;
+    if (sourceSymbol.name !== targetSymbol.name ||
+        (sourceSymbol.flags & 256 /* SymbolFlags.RegularEnum */) === 0 ||
+        (targetSymbol.flags & 256 /* SymbolFlags.RegularEnum */) === 0)
+        return false;
+    const key = getSymbolId(sourceSymbol) + ',' + getSymbolId(targetSymbol);
+    const entry = c.enumRelation.get(key) ?? 0 /* RelationComparisonResult.None */;
+    if (entry !== 0 /* RelationComparisonResult.None */ &&
+        !((entry & 2 /* RelationComparisonResult.Failed */) !== 0 && reporter !== undefined))
+        return (entry & 1 /* RelationComparisonResult.Succeeded */) !== 0;
+    const targetEnumType = getTypeOfSymbol(c, targetSymbol);
+    for (const sourceProperty of getPropertiesOfType(c, getTypeOfSymbol(c, sourceSymbol))) {
+        if ((sourceProperty.flags & 8 /* SymbolFlags.EnumMember */) === 0)
+            continue;
+        const targetProperty = getPropertyOfType(c, targetEnumType, sourceProperty.name);
+        if (targetProperty === undefined || (targetProperty.flags & 8 /* SymbolFlags.EnumMember */) === 0) {
+            if (reporter !== undefined)
+                reporter.reportError(502 /* Diagnostics.Property_0_is_missing_in_type_1 */, [
+                    symbolToString(c, sourceProperty),
+                    typeToString(c, getDeclaredTypeOfSymbol(c, targetSymbol), undefined, 1 << 6),
+                ]);
+            c.enumRelation.set(key, 2 /* RelationComparisonResult.Failed */);
+            return false;
+        }
+        const sourceDecl = sourceProperty.declarations.find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
+        const targetDecl = targetProperty.declarations.find((d) => d.kind === 306 /* SyntaxKind.EnumMember */);
+        if (sourceDecl === undefined || targetDecl === undefined)
+            continue;
+        computeEnumMemberValues(c, sourceDecl.parent);
+        computeEnumMemberValues(c, targetDecl.parent);
+        const s = c.nodeLinks(sourceDecl);
+        const t = c.nodeLinks(targetDecl);
+        const same = s.enumValueKind === t.enumValueKind &&
+            (s.enumValueKind === 0 ||
+                (s.enumValueKind === 1 ? s.enumNumberValue === t.enumNumberValue : s.enumStringValue === t.enumStringValue));
+        if (same)
+            continue;
+        if (s.enumValueKind !== 0 && t.enumValueKind !== 0) {
+            if (reporter !== undefined)
+                reporter.reportError(1111 /* Diagnostics.Each_declaration_of_0_1_differs_in_its_value_where_2_was_expected_but_3_was_given */, [
+                    symbolToString(c, targetSymbol),
+                    symbolToString(c, targetProperty),
+                    enumValueText(t.enumValueKind, t.enumNumberValue, t.enumStringValue),
+                    enumValueText(s.enumValueKind, s.enumNumberValue, s.enumStringValue),
+                ]);
+            c.enumRelation.set(key, 2 /* RelationComparisonResult.Failed */);
+            return false;
+        }
+        // One value is unknown, so assumed numeric; a string on the other side mismatches.
+        if (s.enumValueKind === 2 || t.enumValueKind === 2) {
+            if (reporter !== undefined) {
+                const known = s.enumValueKind === 2 ? s : t;
+                reporter.reportError(1112 /* Diagnostics.One_value_of_0_1_is_the_string_2_and_the_other_is_assumed_to_be_an_unknown_numeric_value */, [symbolToString(c, targetSymbol), symbolToString(c, targetProperty), JSON.stringify(known.enumStringValue)]);
+            }
+            c.enumRelation.set(key, 2 /* RelationComparisonResult.Failed */);
+            return false;
+        }
+    }
+    c.enumRelation.set(key, 1 /* RelationComparisonResult.Succeeded */);
+    return true;
+}
+function enumValueText(kind, n, s) {
+    return kind === 1 ? String(n) : JSON.stringify(s);
+}
+// ---- Keys
+export class RelationKey {
+    key = 0;
+    constrained = false;
+}
+/** Type ids below this bound pack into a numeric relation key with the intersection state. */
+const RelationKeyIdLimit = 1 << 24;
+/**
+ * A key for the string spelling of a relation, numbered per checker. Interned keys are negative, so
+ * they never collide with packed keys.
+ */
+function internRelationKey(c, text) {
+    let key = c.relationKeyIds.get(text);
+    if (key === undefined) {
+        key = -++c.relationKeyCount;
+        c.relationKeyIds.set(text, key);
+    }
+    return key;
+}
+/** An interned generic relation key (`writeTypeReference`'s tokens) and the next one with the same hash. */
+export class InternedRelationKey {
+    tokens;
+    key;
+    next = undefined;
+    constructor(tokens, key) {
+        this.tokens = tokens;
+        this.key = key;
+    }
+}
+/** `internRelationKey` for a generic relation key spelled as tokens, without building its string. */
+function internRelationKeyTokens(c, tokens) {
+    let h1 = 0x811c9dc5;
+    let h2 = 0x9e3779b9;
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        h1 = Math.imul(h1 ^ t, 0x01000193);
+        h2 = Math.imul(h2 + t, 0x85ebca6b) ^ (h2 >>> 15);
+    }
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x7feb352d);
+    h1 ^= h1 >>> 15;
+    const hash = (h1 >>> 0) * 0x100000 + ((h2 ^ tokens.length) & 0xfffff);
+    const head = c.relationKeyTokens.get(hash);
+    for (let e = head; e !== undefined; e = e.next) {
+        const other = e.tokens;
+        if (other.length !== tokens.length)
+            continue;
+        let same = true;
+        for (let i = 0; i < tokens.length; i++)
+            if (other[i] !== tokens[i]) {
+                same = false;
+                break;
+            }
+        if (same)
+            return e.key;
+    }
+    const entry = new InternedRelationKey(tokens, -++c.relationKeyCount);
+    if (head === undefined)
+        c.relationKeyTokens.set(hash, entry);
+    else {
+        entry.next = head.next;
+        head.next = entry;
+    }
+    return entry.key;
+}
+export function getRelationKey(c, source, target, intersectionState, isIdentity, ignoreConstraints) {
+    if (isIdentity && source.id > target.id) {
+        const t = source;
+        source = target;
+        target = t;
+    }
+    const result = c.relationScratchKey;
+    result.constrained = false;
+    if (isTypeReferenceWithGenericArguments(c, source) && isTypeReferenceWithGenericArguments(c, target)) {
+        const typeParameters = [];
+        const tokens = [];
+        writeTypeReference(c, source, 0, typeParameters, tokens, ignoreConstraints, result);
+        tokens.push(11 /* RelationKeyToken.Separator */);
+        writeTypeReference(c, target, 0, typeParameters, tokens, ignoreConstraints, result);
+        tokens.push(15 /* RelationKeyToken.End */ + 4 * intersectionState);
+        result.key = internRelationKeyTokens(c, tokens);
+    }
+    else {
+        // The common case packs both ids and the intersection state (two bits) into one exact number,
+        // so the relation caches need no key strings.
+        const s = source.id;
+        const t = target.id;
+        result.key =
+            s < RelationKeyIdLimit && t < RelationKeyIdLimit
+                ? (s * RelationKeyIdLimit + t) * 4 + intersectionState
+                : internRelationKey(c, 's' + s + ',' + t + ':' + intersectionState);
+    }
+    return result;
+}
+function writeTypeReference(c, ref, depth, typeParameters, tokens, ignoreConstraints, result) {
+    tokens.push(ref.target.id * 4 + 0 /* RelationKeyToken.TargetId */);
+    for (const t of ref.resolvedTypeArguments ?? getTypeArguments(c, ref)) {
+        if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+            if (ignoreConstraints || getConstraintFromTypeParameter(c, t) === undefined) {
+                let index = typeParameters.indexOf(t);
+                if (index < 0) {
+                    index = typeParameters.length;
+                    typeParameters.push(t);
+                }
+                tokens.push(index * 4 + 2 /* RelationKeyToken.TypeParameterIndex */);
+                continue;
+            }
+            result.constrained = true;
+        }
+        else if (depth < 4 && isTypeReferenceWithGenericArguments(c, t)) {
+            tokens.push(3 /* RelationKeyToken.Open */);
+            writeTypeReference(c, t, depth + 1, typeParameters, tokens, ignoreConstraints, result);
+            tokens.push(7 /* RelationKeyToken.Close */);
+            continue;
+        }
+        tokens.push(t.id * 4 + 1 /* RelationKeyToken.ArgumentId */);
+    }
+}
+function isTypeReferenceWithGenericArguments(c, t) {
+    if ((t.objectFlags & 4 /* ObjectFlags.Reference */) === 0 ||
+        (t.flags & 1048576 /* TypeFlags.Object */) === 0 ||
+        t.node !== undefined)
+        return false;
+    for (const a of getTypeArguments(c, t))
+        if ((a.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 || isTypeReferenceWithGenericArguments(c, a))
+            return true;
+    return false;
+}
+// ---- checkTypeRelatedTo
+export function checkTypeAssignableTo(c, source, target, errorNode, headMessage) {
+    return checkTypeRelatedTo(c, source, target, c.assignableRelation, errorNode, headMessage, undefined);
+}
+export function checkTypeComparableTo(c, source, target, errorNode, headMessage) {
+    return checkTypeRelatedTo(c, source, target, c.comparableRelation, errorNode, headMessage, undefined);
+}
+/**
+ * Whether `source` is related to `target`. With an `errorNode`, reports at most one error, to
+ * `diagnosticOutput` when given.
+ */
+export function checkTypeRelatedTo(c, source, target, relation, errorNode, headMessage, diagnosticOutput) {
+    // Nested checks (from resolving types during the relation) find no spare and allocate their own.
+    const r = c.spareRelater ?? new Relater(c, relation, errorNode);
+    c.spareRelater = undefined;
+    r.reset(relation, errorNode);
+    r.relationCount = Math.trunc((16000000 - relation.size()) / 8);
+    const result = r.isRelatedToEx(source, target, 3 /* RecursionFlags.Both */, errorNode !== undefined, headMessage, 0 /* IntersectionState.None */);
+    if (r.overflow) {
+        // Remember the overflow so it isn't attempted again.
+        const key = getRelationKey(c, source, target, 0 /* IntersectionState.None */, relation === c.identityRelation, false).key;
+        relation.set(key, 2 /* RelationComparisonResult.Failed */ |
+            (r.relationCount <= 0
+                ? 32 /* RelationComparisonResult.ComplexityOverflow */
+                : 64 /* RelationComparisonResult.StackDepthOverflow */));
+        const message = r.relationCount <= 0
+            ? 979 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */
+            : 499 /* Diagnostics.Excessive_stack_depth_comparing_types_0_and_1 */;
+        reportDiagnostic(c, createDiagnosticForNode(errorNode ?? c.currentNode, message, [typeToString(c, source), typeToString(c, target)]), diagnosticOutput);
+    }
+    else if (r.errorChain !== undefined) {
+        const diagnostic = createDiagnosticFromErrorChain(r.errorChain, r.errorNode, r.relatedInfo);
+        if (diagnostic !== undefined)
+            reportDiagnostic(c, diagnostic, diagnosticOutput);
+    }
+    c.spareRelater = r;
+    return result !== 0 /* Ternary.False */;
+}
+function reportDiagnostic(c, diagnostic, output) {
+    if (output !== undefined)
+        output.push(diagnostic);
+    else
+        c.addDiagnostic(diagnostic);
+}
+/**
+ * The diagnostic for an error chain, skipping elided messages; nested messages become its chain. As in tsgo, every
+ * message of the chain has the location and related information of the error, which build info records.
+ */
+function createDiagnosticFromErrorChain(chain, errorNode, relatedInfo) {
+    while (chain !== undefined && messageElidedInCompatibilityPyramid(chain.message))
+        chain = chain.next;
+    if (chain === undefined)
+        return undefined;
+    const diagnostic = createDiagnosticForNode(errorNode, chain.message, chain.args);
+    for (const info of relatedInfo)
+        diagnostic.addRelatedInfo(info);
+    let next = chain.next;
+    let parent = diagnostic;
+    while (next !== undefined) {
+        if (!messageElidedInCompatibilityPyramid(next.message)) {
+            const child = new Diagnostic(diagnostic.file, diagnostic.pos, diagnostic.end, next.message, next.args);
+            for (const info of relatedInfo)
+                child.addRelatedInfo(info);
+            parent.addMessageChain(child);
+            parent = child;
+        }
+        next = next.next;
+    }
+    return diagnostic;
+}
+class ErrorChain {
+    next;
+    message;
+    args;
+    constructor(next, message, args) {
+        this.next = next;
+        this.message = message;
+        this.args = args;
+    }
+}
+function chainDepth(chain) {
+    let depth = 0;
+    for (let e = chain; e !== undefined; e = e.next)
+        depth++;
+    return depth;
+}
+function getPropertyNameArg(arg) {
+    if (arg.length !== 0) {
+        const ch = arg.charCodeAt(0);
+        if (ch === 0x22 || ch === 0x27 || ch === 0x60)
+            return '[' + arg + ']';
+    }
+    return arg;
+}
+function addToDottedName(head, tail) {
+    if (head.startsWith('new '))
+        head = '(' + head + ')';
+    let pos = 0;
+    for (;;) {
+        if (tail.startsWith('(', pos))
+            pos++;
+        else if (tail.startsWith('new ', pos))
+            pos += 4;
+        else
+            break;
+    }
+    const prefix = tail.substring(0, pos);
+    const suffix = tail.substring(pos);
+    return suffix.startsWith('[') ? prefix + head + suffix : prefix + head + '.' + suffix;
+}
+function isConversionOrInterfaceImplementationMessage(message) {
+    return (message === 591 /* Diagnostics.Class_0_incorrectly_implements_interface_1 */ ||
+        message ===
+            852 /* Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass */ ||
+        message ===
+            528 /* Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first */ ||
+        message === 920 /* Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element */ ||
+        message === 919 /* Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element */ ||
+        message === 921 /* Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element */);
+}
+// ---- The relater
+/** The state of a relation check: its error chain, maybe-stack and recursion stacks. */
+export class Relater extends TypeComparer {
+    c;
+    relation;
+    errorNode;
+    errorChain = undefined;
+    relatedInfo = [];
+    maybeKeys = [];
+    maybeKeysSet = new Set();
+    /** Recursion stacks: the first `sourceDepth` and `targetDepth` entries are live. */
+    sourceStack = [];
+    targetStack = [];
+    sourceDepth = 0;
+    targetDepth = 0;
+    expandingFlags = 0 /* ExpandingFlags.None */;
+    overflow = false;
+    relationCount = 0;
+    /** The intersection state passed to `compare` during signature comparisons. */
+    signatureIntersectionState = 0 /* IntersectionState.None */;
+    // What `relateVariances` changes in its caller's state when it falls back to structure.
+    varianceSetsCheckFailed = false;
+    varianceCheckFailed = false;
+    varianceSetsErrorChain = false;
+    varianceErrorChain = undefined;
+    constructor(c, relation, errorNode) {
+        super();
+        this.c = c;
+        this.relation = relation;
+        this.errorNode = errorNode;
+    }
+    /** Prepares this relater for a new check, as if newly constructed. */
+    reset(relation, errorNode) {
+        this.relation = relation;
+        this.errorNode = errorNode;
+        this.errorChain = undefined;
+        if (this.relatedInfo.length !== 0)
+            this.relatedInfo = [];
+        this.maybeKeys.length = 0;
+        this.maybeKeysSet.clear();
+        this.sourceDepth = 0;
+        this.targetDepth = 0;
+        this.expandingFlags = 0 /* ExpandingFlags.None */;
+        this.overflow = false;
+        this.relationCount = 0;
+        this.signatureIntersectionState = 0 /* IntersectionState.None */;
+    }
+    compare(source, target, reportErrors) {
+        return this.isRelatedToEx(source, target, 3 /* RecursionFlags.Both */, reportErrors, undefined, this.signatureIntersectionState);
+    }
+    report(message, args) {
+        this.reportError(message, args);
+    }
+    isRelatedToSimple(source, target) {
+        return this.isRelatedToEx(source, target, 3 /* RecursionFlags.Both */, false, undefined, 0 /* IntersectionState.None */);
+    }
+    isRelatedTo(source, target, recursionFlags, reportErrors) {
+        return this.isRelatedToEx(source, target, recursionFlags, reportErrors, undefined, 0 /* IntersectionState.None */);
+    }
+    isRelatedToEx(originalSource, originalTarget, recursionFlags, reportErrors, headMessage, intersectionState) {
+        const c = this.c;
+        if (originalSource === originalTarget)
+            return -1 /* Ternary.True */;
+        // An object source and primitive target only need the simple check.
+        if ((originalSource.flags & 1048576 /* TypeFlags.Object */) !== 0 && (originalTarget.flags & 12713980 /* TypeFlags.Primitive */) !== 0) {
+            if ((this.relation === c.comparableRelation &&
+                (originalTarget.flags & 262144 /* TypeFlags.Never */) === 0 &&
+                isSimpleTypeRelatedTo(c, originalTarget, originalSource, this.relation, undefined)) ||
+                isSimpleTypeRelatedTo(c, originalSource, originalTarget, this.relation, reportErrors ? this : undefined))
+                return -1 /* Ternary.True */;
+            if (reportErrors)
+                this.reportErrorResults(originalSource, originalTarget, originalSource, originalTarget, headMessage);
+            return 0 /* Ternary.False */;
+        }
+        // Normalize: regular literals, non-deferred references, simplified types, resolved substitutions.
+        const source = getNormalizedType(c, originalSource, false);
+        let target = getNormalizedType(c, originalTarget, true);
+        if (source === target)
+            return -1 /* Ternary.True */;
+        if (this.relation === c.identityRelation) {
+            if (source.flags !== target.flags)
+                return 0 /* Ternary.False */;
+            if ((source.flags & 394239 /* TypeFlags.Singleton */) !== 0)
+                return -1 /* Ternary.True */;
+            return this.recursiveTypeRelatedTo(source, target, false, 0 /* IntersectionState.None */, recursionFlags);
+        }
+        // Fast path: a type parameter related to exactly its constraint.
+        if ((source.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && getConstraintOfType(c, source) === target)
+            return -1 /* Ternary.True */;
+        // A definitely non-nullable source against `T | null | undefined` only needs T.
+        if ((source.flags & 13893600 /* TypeFlags.DefinitelyNonNullable */) !== 0 && (target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            const types = typesOf(target);
+            let candidate;
+            if (types.length === 2 && (types[0].flags & 12 /* TypeFlags.Nullable */) !== 0)
+                candidate = types[1];
+            else if (types.length === 3 &&
+                (types[0].flags & 12 /* TypeFlags.Nullable */) !== 0 &&
+                (types[1].flags & 12 /* TypeFlags.Nullable */) !== 0)
+                candidate = types[2];
+            if (candidate !== undefined && (candidate.flags & 12 /* TypeFlags.Nullable */) === 0) {
+                target = getNormalizedType(c, candidate, true);
+                if (source === target)
+                    return -1 /* Ternary.True */;
+            }
+        }
+        if ((this.relation === c.comparableRelation &&
+            (target.flags & 262144 /* TypeFlags.Never */) === 0 &&
+            isSimpleTypeRelatedTo(c, target, source, this.relation, undefined)) ||
+            isSimpleTypeRelatedTo(c, source, target, this.relation, reportErrors ? this : undefined))
+            return -1 /* Ternary.True */;
+        if ((source.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) !== 0 ||
+            (target.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) !== 0) {
+            const isPerformingExcessPropertyChecks = (intersectionState & 2 /* IntersectionState.Target */) === 0 &&
+                isObjectLiteralType(source) &&
+                (source.objectFlags & 8192 /* ObjectFlags.FreshLiteral */) !== 0;
+            if (isPerformingExcessPropertyChecks && this.hasExcessProperties(source, target, reportErrors)) {
+                if (reportErrors)
+                    this.reportRelationError(headMessage, source, originalTarget.alias !== undefined ? originalTarget : target);
+                return 0 /* Ternary.False */;
+            }
+            const isPerformingCommonPropertyChecks = (this.relation !== c.comparableRelation || isUnitType(source)) &&
+                (intersectionState & 2 /* IntersectionState.Target */) === 0 &&
+                (source.flags & (12713980 /* TypeFlags.Primitive */ | 1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0 &&
+                source !== c.globalObjectType &&
+                (target.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0 &&
+                isWeakType(c, target) &&
+                (getPropertiesOfType(c, source).length > 0 || typeHasCallOrConstructSignatures(c, source));
+            const isComparingJsxAttributes = (source.objectFlags & 2048 /* ObjectFlags.JsxAttributes */) !== 0;
+            if (isPerformingCommonPropertyChecks && !hasCommonProperties(c, source, target, isComparingJsxAttributes)) {
+                if (reportErrors) {
+                    const sourceString = typeToString(c, originalSource.alias !== undefined ? originalSource : source);
+                    const targetString = typeToString(c, originalTarget.alias !== undefined ? originalTarget : target);
+                    const calls = getSignaturesOfType(c, source, 0 /* SignatureKind.Call */);
+                    const constructs = getSignaturesOfType(c, source, 1 /* SignatureKind.Construct */);
+                    if ((calls.length > 0 &&
+                        this.isRelatedTo(getReturnTypeOfSignature(c, calls[0]), target, 1 /* RecursionFlags.Source */, false) !==
+                            0 /* Ternary.False */) ||
+                        (constructs.length > 0 &&
+                            this.isRelatedTo(getReturnTypeOfSignature(c, constructs[0]), target, 1 /* RecursionFlags.Source */, false) !==
+                                0 /* Ternary.False */))
+                        this.reportError(714 /* Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it */, [sourceString, targetString]);
+                    else
+                        this.reportError(713 /* Diagnostics.Type_0_has_no_properties_in_common_with_type_1 */, [sourceString, targetString]);
+                }
+                return 0 /* Ternary.False */;
+            }
+            const skipCaching = ((source.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+                typesOf(source).length < 4 &&
+                (target.flags & 134217728 /* TypeFlags.Union */) === 0) ||
+                ((target.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+                    typesOf(target).length < 4 &&
+                    (source.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) === 0);
+            const result = skipCaching
+                ? this.unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState)
+                : this.recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags);
+            if (result !== 0 /* Ternary.False */)
+                return result;
+        }
+        if (reportErrors)
+            this.reportErrorResults(originalSource, originalTarget, source, target, headMessage);
+        return 0 /* Ternary.False */;
+    }
+    hasExcessProperties(source, target, reportErrors) {
+        const c = this.c;
+        if (!isExcessPropertyCheckTarget(target) ||
+            (!c.noImplicitAny && (target.objectFlags & 4096 /* ObjectFlags.JSLiteral */) !== 0))
+            return false;
+        const isComparingJsxAttributes = (source.objectFlags & 2048 /* ObjectFlags.JsxAttributes */) !== 0;
+        if ((this.relation === c.assignableRelation || this.relation === c.comparableRelation) &&
+            (isTypeSubsetOf(c, c.globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(c, target))))
+            return false;
+        let reducedTarget = target;
+        let checkTypes;
+        if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            reducedTarget =
+                findMatchingDiscriminantType(c, source, target, this) ?? filterPrimitivesIfContainsNonPrimitive(c, target);
+            checkTypes =
+                (reducedTarget.flags & 134217728 /* TypeFlags.Union */) !== 0
+                    ? typesOf(reducedTarget)
+                    : (reducedTarget.flags & 262144 /* TypeFlags.Never */) !== 0
+                        ? emptyTypes
+                        : [reducedTarget];
+        }
+        for (const prop of getPropertiesOfType(c, source)) {
+            if (!shouldCheckAsExcessProperty(prop, source.symbol) || isIgnoredJsxProperty(source, prop))
+                continue;
+            if (!isKnownProperty(c, reducedTarget, prop.name, isComparingJsxAttributes)) {
+                if (reportErrors) {
+                    // Report in terms of the object types we check in isKnownProperty, at the property.
+                    const errorTarget = filterType(c, reducedTarget, isExcessPropertyCheckTarget);
+                    const errorNode = this.errorNode;
+                    if (errorNode.kind === 293 /* SyntaxKind.JsxAttributes */ ||
+                        isJsxOpeningLikeElement(errorNode) ||
+                        (errorNode.parent !== undefined && isJsxOpeningLikeElement(errorNode.parent))) {
+                        // Attributes are checked like object literals but reported as attributes, at the attribute.
+                        const valueDeclaration = prop.valueDeclaration;
+                        if (valueDeclaration !== undefined &&
+                            valueDeclaration.kind === 292 /* SyntaxKind.JsxAttribute */ &&
+                            sameFile(valueDeclaration, errorNode))
+                            this.errorNode = getName(valueDeclaration);
+                        const propName = symbolToString(c, prop);
+                        const suggestion = getSuggestedSymbolForNonexistentJSXAttribute(c, propName, errorTarget);
+                        if (suggestion !== undefined)
+                            this.reportError(706 /* Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2 */, [
+                                propName,
+                                typeToString(c, errorTarget),
+                                symbolToString(c, suggestion),
+                            ]);
+                        else
+                            this.reportError(516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                                propName,
+                                typeToString(c, errorTarget),
+                            ]);
+                        return true;
+                    }
+                    const objectLiteralDeclaration = source.symbol !== undefined && source.symbol.declarations.length !== 0
+                        ? source.symbol.declarations[0]
+                        : undefined;
+                    const valueDeclaration = prop.valueDeclaration;
+                    let suggestion = undefined;
+                    if (valueDeclaration !== undefined &&
+                        isObjectLiteralElement(valueDeclaration) &&
+                        objectLiteralDeclaration !== undefined &&
+                        isAncestor(valueDeclaration, objectLiteralDeclaration) &&
+                        sameFile(objectLiteralDeclaration, this.errorNode)) {
+                        const name = getName(valueDeclaration);
+                        this.errorNode = name;
+                        if (name.kind === 79 /* SyntaxKind.Identifier */)
+                            suggestion = getSpellingSuggestionForName(c, getText(name), getPropertiesOfType(c, errorTarget), 111551 /* SymbolFlags.Value */);
+                    }
+                    if (suggestion !== undefined)
+                        this.reportError(715 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */, [symbolToString(c, prop), typeToString(c, errorTarget), suggestion.name]);
+                    else
+                        this.reportError(529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */, [symbolToString(c, prop), typeToString(c, errorTarget)]);
+                }
+                return true;
+            }
+            if (checkTypes !== undefined &&
+                this.isRelatedTo(getTypeOfSymbol(c, prop), getTypeOfPropertyInTypes(c, checkTypes, prop.name), 3 /* RecursionFlags.Both */, reportErrors) === 0 /* Ternary.False */) {
+                if (reportErrors)
+                    this.reportError(504 /* Diagnostics.Types_of_property_0_are_incompatible */, [symbolToString(c, prop)]);
+                return true;
+            }
+        }
+        return false;
+    }
+    unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) {
+        const c = this.c;
+        // Unions are deconstructed before intersections, and "each" before "some".
+        if ((source.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+                // A union from an intersection containing the target is related to it.
+                const sourceOrigin = source.origin;
+                if (sourceOrigin !== undefined &&
+                    (sourceOrigin.flags & 268435456 /* TypeFlags.Intersection */) !== 0 &&
+                    target.alias !== undefined &&
+                    typesOf(sourceOrigin).includes(target))
+                    return -1 /* Ternary.True */;
+                const targetOrigin = target.origin;
+                if (targetOrigin !== undefined &&
+                    (targetOrigin.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+                    source.alias !== undefined &&
+                    typesOf(targetOrigin).includes(source))
+                    return -1 /* Ternary.True */;
+            }
+            if (this.relation === c.comparableRelation)
+                return this.someTypeRelatedToType(source, target, reportErrors && (source.flags & 12713980 /* TypeFlags.Primitive */) === 0, intersectionState);
+            return this.eachTypeRelatedToType(source, target, reportErrors && (source.flags & 12713980 /* TypeFlags.Primitive */) === 0, intersectionState);
+        }
+        if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0)
+            return this.typeRelatedToSomeType(getRegularTypeOfObjectLiteral(c, source), target, reportErrors && (source.flags & 12713980 /* TypeFlags.Primitive */) === 0 && (target.flags & 12713980 /* TypeFlags.Primitive */) === 0, intersectionState);
+        if ((target.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+            return this.typeRelatedToEachType(source, target, reportErrors, 2 /* IntersectionState.Target */);
+        // For comparability with a primitive, hoist the constraints of instantiable constituents.
+        if (this.relation === c.comparableRelation && (target.flags & 12713980 /* TypeFlags.Primitive */) !== 0) {
+            const types = typesOf(source);
+            let changed = false;
+            const constraints = [];
+            for (const t of types) {
+                const u = (t.flags & 132644864 /* TypeFlags.Instantiable */) !== 0 ? (getBaseConstraintOfType(c, t) ?? c.unknownType) : t;
+                if (u !== t)
+                    changed = true;
+                constraints.push(u);
+            }
+            if (changed) {
+                const reduced = getIntersectionType(c, constraints);
+                if ((reduced.flags & 262144 /* TypeFlags.Never */) !== 0)
+                    return 0 /* Ternary.False */;
+                if ((reduced.flags & 268435456 /* TypeFlags.Intersection */) === 0) {
+                    const result = this.isRelatedTo(reduced, target, 1 /* RecursionFlags.Source */, false);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                    return this.isRelatedTo(target, reduced, 1 /* RecursionFlags.Source */, false);
+                }
+                source = reduced;
+            }
+        }
+        // Constituents related to the target, without elaboration.
+        return this.someTypeRelatedToType(source, target, false, 1 /* IntersectionState.Source */);
+    }
+    someTypeRelatedToType(source, target, reportErrors, intersectionState) {
+        const sourceTypes = typesOf(source);
+        if ((source.flags & 134217728 /* TypeFlags.Union */) !== 0 && unionContainsType(this.c, source, target))
+            return -1 /* Ternary.True */;
+        for (let i = 0; i < sourceTypes.length; i++) {
+            const related = this.isRelatedToEx(sourceTypes[i], target, 1 /* RecursionFlags.Source */, reportErrors && i === sourceTypes.length - 1, undefined, intersectionState);
+            if (related !== 0 /* Ternary.False */)
+                return related;
+        }
+        return 0 /* Ternary.False */;
+    }
+    eachTypeRelatedToType(source, target, reportErrors, intersectionState) {
+        let result = -1 /* Ternary.True */;
+        const sourceTypes = typesOf(source);
+        // Strip undefined from the target when the source can't contain it, for the correspondence fast path.
+        const strippedTarget = this.getUndefinedStrippedTargetIfNeeded(source, target);
+        const strippedTypes = (strippedTarget.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(strippedTarget) : emptyTypes;
+        for (let i = 0; i < sourceTypes.length; i++) {
+            const sourceType = sourceTypes[i];
+            if ((strippedTarget.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+                sourceTypes.length >= strippedTypes.length &&
+                sourceTypes.length % strippedTypes.length === 0) {
+                // Unions that map one another relate element-wise.
+                const related = this.isRelatedToEx(sourceType, strippedTypes[i % strippedTypes.length], 3 /* RecursionFlags.Both */, false, undefined, intersectionState);
+                if (related !== 0 /* Ternary.False */) {
+                    result &= related;
+                    continue;
+                }
+            }
+            const related = this.isRelatedToEx(sourceType, target, 1 /* RecursionFlags.Source */, reportErrors, undefined, intersectionState);
+            if (related === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+            result &= related;
+        }
+        return result;
+    }
+    getUndefinedStrippedTargetIfNeeded(source, target) {
+        if ((source.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+            (target.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+            (typesOf(source)[0].flags & 4 /* TypeFlags.Undefined */) === 0 &&
+            (typesOf(target)[0].flags & 4 /* TypeFlags.Undefined */) !== 0)
+            return filterType(this.c, target, (t) => (t.flags & 4 /* TypeFlags.Undefined */) === 0);
+        return target;
+    }
+    typeRelatedToSomeType(source, target, reportErrors, intersectionState) {
+        const c = this.c;
+        const targetTypes = typesOf(target);
+        if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            if (unionContainsType(c, target, source))
+                return -1 /* Ternary.True */;
+            if (isLiteralRelatedByPrimitiveUnionForms(c, source, target, this.relation))
+                return literalRelatedToPrimitiveUnion(c, source, target) ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+            const match = getMatchingUnionConstituentForType(c, target, source);
+            if (match !== undefined) {
+                const related = this.isRelatedToEx(source, match, 2 /* RecursionFlags.Target */, false, undefined, intersectionState);
+                if (related !== 0 /* Ternary.False */)
+                    return related;
+            }
+        }
+        for (const t of targetTypes) {
+            const related = this.isRelatedToEx(source, t, 2 /* RecursionFlags.Target */, false, undefined, intersectionState);
+            if (related !== 0 /* Ternary.False */)
+                return related;
+        }
+        if (reportErrors) {
+            // Elaborate only against a best matching constituent.
+            const best = getBestMatchingType(c, source, target, this);
+            if (best !== undefined)
+                this.isRelatedToEx(source, best, 2 /* RecursionFlags.Target */, true, undefined, intersectionState);
+        }
+        return 0 /* Ternary.False */;
+    }
+    typeRelatedToEachType(source, target, reportErrors, intersectionState) {
+        let result = -1 /* Ternary.True */;
+        for (const targetType of typesOf(target)) {
+            const related = this.isRelatedToEx(source, targetType, 2 /* RecursionFlags.Target */, reportErrors, undefined, intersectionState);
+            if (related === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+            result &= related;
+        }
+        return result;
+    }
+    eachTypeRelatedToSomeType(source, target) {
+        let result = -1 /* Ternary.True */;
+        for (const sourceType of typesOf(source)) {
+            const related = this.typeRelatedToSomeType(sourceType, target, false, 0 /* IntersectionState.None */);
+            if (related === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+            result &= related;
+        }
+        return result;
+    }
+    /**
+     * Relates possibly recursive types: uses the global cache, assumes related when already
+     * comparing the pair, assumes related for deeply nested expansions, and overflows at depth 100.
+     */
+    recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags) {
+        const c = this.c;
+        if (this.overflow)
+            return 0 /* Ternary.False */;
+        const keyInfo = getRelationKey(c, source, target, intersectionState, this.relation === c.identityRelation, false);
+        const id = keyInfo.key;
+        const constrained = keyInfo.constrained;
+        const entry = this.relation.get(id);
+        if (entry !== 0 /* RelationComparisonResult.None */) {
+            if (reportErrors &&
+                (entry & 2 /* RelationComparisonResult.Failed */) !== 0 &&
+                (entry & 96 /* RelationComparisonResult.Overflow */) === 0) {
+                // Redo the failed comparison to elaborate.
+            }
+            else {
+                c.reliabilityFlags |=
+                    entry & (8 /* RelationComparisonResult.ReportsUnmeasurable */ | 16 /* RelationComparisonResult.ReportsUnreliable */);
+                if (reportErrors && (entry & 96 /* RelationComparisonResult.Overflow */) !== 0) {
+                    const message = (entry & 32 /* RelationComparisonResult.ComplexityOverflow */) !== 0
+                        ? 979 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */
+                        : 499 /* Diagnostics.Excessive_stack_depth_comparing_types_0_and_1 */;
+                    this.reportError(message, [typeToString(c, source), typeToString(c, target)]);
+                }
+                return (entry & 1 /* RelationComparisonResult.Succeeded */) !== 0 ? -1 /* Ternary.True */ : 0 /* Ternary.False */;
+            }
+        }
+        if (this.relationCount <= 0) {
+            this.overflow = true;
+            return 0 /* Ternary.False */;
+        }
+        if (this.maybeKeysSet.has(id))
+            return 3 /* Ternary.Maybe */;
+        // Constrained keys also check the key with all type parameters unconstrained.
+        if (constrained) {
+            const broadest = getRelationKey(c, source, target, intersectionState, this.relation === c.identityRelation, true).key;
+            if (this.maybeKeysSet.has(broadest))
+                return 3 /* Ternary.Maybe */;
+        }
+        const sourceDepth = this.sourceDepth;
+        const targetDepth = this.targetDepth;
+        if (sourceDepth === 100 || targetDepth === 100) {
+            this.overflow = true;
+            return 0 /* Ternary.False */;
+        }
+        const maybeStart = this.maybeKeys.length;
+        this.maybeKeys.push(id);
+        this.maybeKeysSet.add(id);
+        const saveExpandingFlags = this.expandingFlags;
+        if ((recursionFlags & 1 /* RecursionFlags.Source */) !== 0) {
+            setStackEntry(this.sourceStack, sourceDepth, source);
+            this.sourceDepth = sourceDepth + 1;
+            if ((this.expandingFlags & 1 /* ExpandingFlags.Source */) === 0 &&
+                isDeeplyNestedType(c, source, this.sourceStack, sourceDepth + 1, 3))
+                this.expandingFlags |= 1 /* ExpandingFlags.Source */;
+        }
+        if ((recursionFlags & 2 /* RecursionFlags.Target */) !== 0) {
+            setStackEntry(this.targetStack, targetDepth, target);
+            this.targetDepth = targetDepth + 1;
+            if ((this.expandingFlags & 2 /* ExpandingFlags.Target */) === 0 &&
+                isDeeplyNestedType(c, target, this.targetStack, targetDepth + 1, 3))
+                this.expandingFlags |= 2 /* ExpandingFlags.Target */;
+        }
+        const saveReliabilityFlags = c.reliabilityFlags;
+        c.reliabilityFlags = 0;
+        const result = this.expandingFlags === 3 /* ExpandingFlags.Both */
+            ? 3 /* Ternary.Maybe */
+            : this.structuredTypeRelatedTo(source, target, reportErrors, intersectionState);
+        const propagatingVarianceFlags = c.reliabilityFlags;
+        c.reliabilityFlags |= saveReliabilityFlags;
+        this.sourceDepth = sourceDepth;
+        this.targetDepth = targetDepth;
+        this.expandingFlags = saveExpandingFlags;
+        if (result !== 0 /* Ternary.False */) {
+            if (result === -1 /* Ternary.True */ || (sourceDepth === 0 && targetDepth === 0)) {
+                // True results, and Maybe results at depth 0, succeed; Unknown is never recorded.
+                this.resetMaybeStack(maybeStart, propagatingVarianceFlags, result === -1 /* Ternary.True */ || result === 3 /* Ternary.Maybe */);
+            }
+        }
+        else {
+            // False under assumptions is false without them.
+            this.relation.set(id, 2 /* RelationComparisonResult.Failed */ | propagatingVarianceFlags);
+            this.relationCount--;
+            this.resetMaybeStack(maybeStart, propagatingVarianceFlags, false);
+        }
+        return result;
+    }
+    resetMaybeStack(maybeStart, propagatingVarianceFlags, markAllAsSucceeded) {
+        for (let i = maybeStart; i < this.maybeKeys.length; i++) {
+            this.maybeKeysSet.delete(this.maybeKeys[i]);
+            if (markAllAsSucceeded) {
+                this.relation.set(this.maybeKeys[i], 1 /* RelationComparisonResult.Succeeded */ | propagatingVarianceFlags);
+                this.relationCount--;
+            }
+        }
+        this.maybeKeys.length = maybeStart;
+    }
+    structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
+        const c = this.c;
+        const saveChain = this.errorChain;
+        const saveRelated = this.relatedInfo;
+        let result = this.structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveChain, saveRelated);
+        if (this.relation !== c.identityRelation) {
+            // The combined constraint of an intersection (or a type parameter against a union) may relate.
+            if (result === 0 /* Ternary.False */ &&
+                ((source.flags & 268435456 /* TypeFlags.Intersection */) !== 0 ||
+                    ((source.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && (target.flags & 134217728 /* TypeFlags.Union */) !== 0))) {
+                const sourceTypes = (source.flags & 268435456 /* TypeFlags.Intersection */) !== 0 ? typesOf(source) : [source];
+                const constraint = getEffectiveConstraintOfIntersection(c, sourceTypes, (target.flags & 134217728 /* TypeFlags.Union */) !== 0);
+                if (constraint !== undefined && everyType(constraint, (u) => u !== source))
+                    result = this.isRelatedToEx(constraint, target, 1 /* RecursionFlags.Source */, false, undefined, intersectionState);
+            }
+            // Intersection targets need an extra property check for nested excess properties and weak types.
+            if (result !== 0 /* Ternary.False */ &&
+                (intersectionState & 2 /* IntersectionState.Target */) === 0 &&
+                (target.flags & 268435456 /* TypeFlags.Intersection */) !== 0 &&
+                !isGenericObjectType(c, target) &&
+                (source.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0) {
+                result &= this.propertiesRelatedTo(source, target, reportErrors, undefined, false, 0 /* IntersectionState.None */);
+                if (result !== 0 /* Ternary.False */ &&
+                    isObjectLiteralType(source) &&
+                    (source.objectFlags & 8192 /* ObjectFlags.FreshLiteral */) !== 0)
+                    result &= this.indexSignaturesRelatedTo(source, target, false, reportErrors, 0 /* IntersectionState.None */);
+            }
+            else if (result !== 0 /* Ternary.False */ &&
+                isNonGenericObjectType(c, target) &&
+                !isArrayOrTupleType(c, target) &&
+                isSourceIntersectionNeedingExtraCheck(c, source, target))
+                // Source intersections check optional target properties for mismatched types.
+                result &= this.propertiesRelatedTo(source, target, reportErrors, undefined, true, intersectionState);
+        }
+        if (result !== 0 /* Ternary.False */) {
+            this.errorChain = saveChain;
+            this.relatedInfo = saveRelated;
+        }
+        return result;
+    }
+    /**
+     * Relates the type arguments of `structuredTypeRelatedToWorker`'s source and target by variance:
+     * a result when variance decides, else undefined to fall back to structure, with the caller's
+     * `varianceCheckFailed` and original error chain to update in the fields above. (A method rather
+     * than a closure over the caller's locals, which native builds would allocate on every call.)
+     */
+    relateVariances(sourceArgs, targetArgs, variances, reportErrors, intersectionState, saveChain, saveRelated) {
+        const result = this.typeArgumentsRelatedTo(sourceArgs, targetArgs, variances, reportErrors, intersectionState);
+        if (result !== 0 /* Ternary.False */)
+            return result;
+        if (someVarianceHasFlags(variances, 24 /* VarianceFlags.AllowsStructuralFallback */)) {
+            // Unmeasurable or unreliable variance: elide variance errors and compare structurally.
+            this.varianceSetsCheckFailed = false;
+            this.varianceSetsErrorChain = true;
+            this.varianceErrorChain = undefined;
+            this.errorChain = saveChain;
+            this.relatedInfo = saveRelated;
+            return undefined;
+        }
+        const allowStructuralFallback = hasCovariantVoidArgument(targetArgs, variances);
+        this.varianceSetsCheckFailed = true;
+        this.varianceCheckFailed = !allowStructuralFallback;
+        this.varianceSetsErrorChain = false;
+        if (variances.length !== 0 && !allowStructuralFallback) {
+            // With invariant parameters, compare structurally to explain why.
+            if (!(reportErrors && someVarianceIsInvariant(variances)))
+                return 0 /* Ternary.False */;
+            this.varianceSetsErrorChain = true;
+            this.varianceErrorChain = this.errorChain;
+            this.errorChain = saveChain;
+            this.relatedInfo = saveRelated;
+        }
+        return undefined;
+    }
+    structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveChain, saveRelated) {
+        const c = this.c;
+        let result = 0 /* Ternary.False */;
+        let varianceCheckFailed = false;
+        let originalErrorChain;
+        if (this.relation === c.identityRelation) {
+            // Flags are known to be identical.
+            if ((source.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+                let r = this.eachTypeRelatedToSomeType(source, target);
+                if (r !== 0 /* Ternary.False */)
+                    r &= this.eachTypeRelatedToSomeType(target, source);
+                return r;
+            }
+            if ((source.flags & 2097152 /* TypeFlags.Index */) !== 0)
+                return this.isRelatedTo(source.target, target.target, 3 /* RecursionFlags.Both */, false);
+            if ((source.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+                const s = source;
+                const t = target;
+                result = this.isRelatedTo(s.objectType, t.objectType, 3 /* RecursionFlags.Both */, false);
+                if (result !== 0 /* Ternary.False */) {
+                    result &= this.isRelatedTo(s.indexType, t.indexType, 3 /* RecursionFlags.Both */, false);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+            else if ((source.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
+                const s = source;
+                const t = target;
+                if (s.root.isDistributive === t.root.isDistributive) {
+                    result = this.isRelatedTo(s.checkType, t.checkType, 3 /* RecursionFlags.Both */, false);
+                    if (result !== 0 /* Ternary.False */)
+                        result &= this.isRelatedTo(s.extendsType, t.extendsType, 3 /* RecursionFlags.Both */, false);
+                    if (result !== 0 /* Ternary.False */)
+                        result &= this.isRelatedTo(getTrueTypeFromConditionalType(c, s), getTrueTypeFromConditionalType(c, t), 3 /* RecursionFlags.Both */, false);
+                    if (result !== 0 /* Ternary.False */)
+                        result &= this.isRelatedTo(getFalseTypeFromConditionalType(c, s), getFalseTypeFromConditionalType(c, t), 3 /* RecursionFlags.Both */, false);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+            else if ((source.flags & 16777216 /* TypeFlags.Substitution */) !== 0) {
+                const s = source;
+                const t = target;
+                result = this.isRelatedTo(s.baseType, t.baseType, 3 /* RecursionFlags.Both */, false);
+                if (result !== 0 /* Ternary.False */) {
+                    result &= this.isRelatedTo(s.constraint, t.constraint, 3 /* RecursionFlags.Both */, false);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+            else if ((source.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+                const s = source;
+                const t = target;
+                if (s.texts.length === t.texts.length && s.texts.every((x, i) => x === t.texts[i])) {
+                    result = -1 /* Ternary.True */;
+                    for (let i = 0; i < s.types.length; i++) {
+                        result &= this.isRelatedTo(s.types[i], t.types[i], 3 /* RecursionFlags.Both */, false);
+                        if (result === 0 /* Ternary.False */)
+                            return result;
+                    }
+                    return result;
+                }
+            }
+            else if ((source.flags & 8388608 /* TypeFlags.StringMapping */) !== 0) {
+                if (source.symbol === target.symbol)
+                    return this.isRelatedTo(source.target, target.target, 3 /* RecursionFlags.Both */, false);
+            }
+            if ((source.flags & 1048576 /* TypeFlags.Object */) === 0)
+                return 0 /* Ternary.False */;
+        }
+        else if ((source.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0 ||
+            (target.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+            result = this.unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState);
+            if (result !== 0 /* Ternary.False */)
+                return result;
+            // Remaining cases: instantiable source, object against union, intersection against object, union or instantiable.
+            if (!((source.flags & 132644864 /* TypeFlags.Instantiable */) !== 0 ||
+                ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 134217728 /* TypeFlags.Union */) !== 0) ||
+                ((source.flags & 268435456 /* TypeFlags.Intersection */) !== 0 &&
+                    (target.flags & (1048576 /* TypeFlags.Object */ | 134217728 /* TypeFlags.Union */ | 132644864 /* TypeFlags.Instantiable */)) !== 0)))
+                return 0 /* Ternary.False */;
+        }
+        // Alias variance probing, for object and conditional types only.
+        if ((source.flags & (1048576 /* TypeFlags.Object */ | 67108864 /* TypeFlags.Conditional */)) !== 0 &&
+            source.alias !== undefined &&
+            source.alias.typeArguments.length !== 0 &&
+            target.alias !== undefined &&
+            source.alias.symbol === target.alias.symbol &&
+            !(isMarkerType(c, source) || isMarkerType(c, target))) {
+            const variances = getAliasVariances(c, source.alias.symbol);
+            if (variances.length === 0)
+                return 1 /* Ternary.Unknown */;
+            const params = c.symbolLinks(source.alias.symbol).typeParameters ?? emptyTypes;
+            const minParams = getMinTypeArgumentCount(c, params);
+            const inJS = source.alias.symbol.valueDeclaration !== undefined &&
+                (source.alias.symbol.valueDeclaration.flags & (1 << 16)) !== 0;
+            const sourceTypes = fillMissingTypeArguments(c, source.alias.typeArguments, params, minParams, inJS);
+            const targetTypes = fillMissingTypeArguments(c, target.alias.typeArguments, params, minParams, inJS);
+            const varianceResult = this.relateVariances(sourceTypes, targetTypes, variances, reportErrors, intersectionState, saveChain, saveRelated);
+            if (varianceResult !== undefined)
+                return varianceResult;
+            result = 0 /* Ternary.False */;
+            if (this.varianceSetsCheckFailed)
+                varianceCheckFailed = this.varianceCheckFailed;
+            if (this.varianceSetsErrorChain)
+                originalErrorChain = this.varianceErrorChain;
+        }
+        // [...U] relates where U does, and U to readonly [...T] or to [...T] for mutable array constraints.
+        if (isSingleElementGenericTupleType(source) && !tupleTargetOf(source).readonly) {
+            result = this.isRelatedTo(getTypeArguments(c, source)[0], target, 1 /* RecursionFlags.Source */, false);
+            if (result !== 0 /* Ternary.False */)
+                return result;
+        }
+        if (isSingleElementGenericTupleType(target) &&
+            (tupleTargetOf(target).readonly || isMutableArrayOrTuple(c, getBaseConstraintOrType(c, source)))) {
+            result = this.isRelatedTo(source, getTypeArguments(c, target)[0], 2 /* RecursionFlags.Target */, false);
+            if (result !== 0 /* Ternary.False */)
+                return result;
+        }
+        if ((target.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+            // `{ [P in Q]: X }` relates to T when keyof T relates to Q and X to T[Q].
+            if ((source.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 &&
+                (source.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+                getNameTypeFromMappedType(c, source) === undefined &&
+                this.isRelatedTo(getIndexType(c, target), getConstraintTypeFromMappedType(c, source), 3 /* RecursionFlags.Both */, false) !== 0 /* Ternary.False */) {
+                if ((getMappedTypeModifiers(source) & 4 /* MappedTypeModifiers.IncludeOptional */) === 0) {
+                    const templateType = getTemplateTypeFromMappedType(c, source);
+                    const indexedAccessType = getIndexedAccessType(c, target, getTypeParameterFromMappedType(c, source));
+                    result = this.isRelatedTo(templateType, indexedAccessType, 3 /* RecursionFlags.Both */, reportErrors);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+            if (this.relation === c.comparableRelation && (source.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+                // Type parameters are comparable only when one extends the other.
+                const constraint = getConstraintFromTypeParameterChecked(c, source);
+                if (constraint !== undefined && someType(constraint, (u) => (u.flags & 524288 /* TypeFlags.TypeParameter */) !== 0))
+                    return this.isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, false);
+                return 0 /* Ternary.False */;
+            }
+        }
+        else if ((target.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+            if ((source.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+                // S[K] relates to T[J] when S relates to T and K to J.
+                const s = source;
+                const t = target;
+                result = this.isRelatedTo(s.objectType, t.objectType, 3 /* RecursionFlags.Both */, reportErrors);
+                if (result !== 0 /* Ternary.False */)
+                    result &= this.isRelatedTo(s.indexType, t.indexType, 3 /* RecursionFlags.Both */, reportErrors);
+                if (result !== 0 /* Ternary.False */)
+                    return result;
+                if (reportErrors)
+                    originalErrorChain = this.errorChain;
+            }
+            // S relates to T[K] when it relates to the base constraint of T[K] for writing.
+            if (this.relation === c.assignableRelation || this.relation === c.comparableRelation) {
+                const t = target;
+                const baseObjectType = getBaseConstraintOrType(c, t.objectType);
+                const baseIndexType = getBaseConstraintOrType(c, t.indexType);
+                if (!isGenericObjectType(c, baseObjectType) && !isGenericIndexType(c, baseIndexType)) {
+                    const accessFlags = (1 << 2) | (baseObjectType !== t.objectType ? 1 << 1 : 0);
+                    const constraint = getIndexedAccessTypeOrUndefined(c, baseObjectType, baseIndexType, accessFlags);
+                    if (constraint !== undefined) {
+                        if (reportErrors && originalErrorChain !== undefined) {
+                            this.errorChain = saveChain;
+                            this.relatedInfo = saveRelated;
+                        }
+                        result = this.isRelatedToEx(source, constraint, 2 /* RecursionFlags.Target */, reportErrors, undefined, intersectionState);
+                        if (result !== 0 /* Ternary.False */)
+                            return result;
+                        // Prefer the shorter of the two chains.
+                        if (reportErrors &&
+                            originalErrorChain !== undefined &&
+                            this.errorChain !== undefined &&
+                            chainDepth(originalErrorChain) <= chainDepth(this.errorChain))
+                            this.errorChain = originalErrorChain;
+                    }
+                }
+            }
+            if (reportErrors)
+                originalErrorChain = undefined;
+        }
+        else if ((target.flags & 2097152 /* TypeFlags.Index */) !== 0) {
+            const targetType = target.target;
+            // keyof S relates to keyof T when T relates to S.
+            if ((source.flags & 2097152 /* TypeFlags.Index */) !== 0) {
+                result = this.isRelatedTo(targetType, source.target, 3 /* RecursionFlags.Both */, false);
+                if (result !== 0 /* Ternary.False */)
+                    return result;
+            }
+            if (isTupleType(targetType)) {
+                result = this.isRelatedTo(source, getKnownKeysOfTupleType(c, targetType), 2 /* RecursionFlags.Target */, reportErrors);
+                if (result !== 0 /* Ternary.False */)
+                    return result;
+            }
+            else {
+                const constraint = getSimplifiedTypeOrConstraint(c, targetType);
+                if (constraint !== undefined) {
+                    // Require True so circular constraints don't produce false positives.
+                    if (this.isRelatedTo(source, getIndexTypeEx(c, constraint, target.indexFlags | 4 /* IndexFlags.NoReducibleCheck */), 2 /* RecursionFlags.Target */, reportErrors) === -1 /* Ternary.True */)
+                        return -1 /* Ternary.True */;
+                }
+                else if (isGenericMappedType(c, targetType)) {
+                    const nameType = getNameTypeFromMappedType(c, targetType);
+                    const constraintType = getConstraintTypeFromMappedType(c, targetType);
+                    // Keys missing from the constraint may still be mapped from the apparent keys of the
+                    // modifiers type; the still generic name type is kept too.
+                    const targetKeys = nameType !== undefined && isMappedTypeWithKeyofConstraintDeclaration(c, targetType)
+                        ? getUnionType(c, [getApparentMappedTypeKeys(c, nameType, targetType), nameType])
+                        : (nameType ?? constraintType);
+                    if (this.isRelatedTo(source, targetKeys, 2 /* RecursionFlags.Target */, reportErrors) === -1 /* Ternary.True */)
+                        return -1 /* Ternary.True */;
+                }
+            }
+        }
+        else if ((target.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
+            // Ten nested levels of one conditional type are assumed infinitely expanding.
+            if (isDeeplyNestedType(c, target, this.targetStack, this.targetDepth, 10))
+                return 3 /* Ternary.Maybe */;
+            const t = target;
+            if (t.root.inferTypeParameters.length === 0 &&
+                !isDistributionDependent(c, t) &&
+                !((source.flags & 67108864 /* TypeFlags.Conditional */) !== 0 && source.root === t.root)) {
+                const skipTrue = !isTypeAssignableTo(c, getPermissiveInstantiation(c, t.checkType), getPermissiveInstantiation(c, t.extendsType));
+                const skipFalse = !skipTrue &&
+                    isTypeAssignableTo(c, getRestrictiveInstantiation(c, t.checkType), getRestrictiveInstantiation(c, t.extendsType));
+                result = skipTrue
+                    ? -1 /* Ternary.True */
+                    : this.isRelatedToEx(source, getTrueTypeFromConditionalType(c, t), 2 /* RecursionFlags.Target */, false, undefined, intersectionState);
+                if (result !== 0 /* Ternary.False */) {
+                    result &= skipFalse
+                        ? -1 /* Ternary.True */
+                        : this.isRelatedToEx(source, getFalseTypeFromConditionalType(c, t), 2 /* RecursionFlags.Target */, false, undefined, intersectionState);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+        }
+        else if ((target.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+            if ((source.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+                if (this.relation === c.comparableRelation)
+                    return templateLiteralTypesDefinitelyUnrelated(source, target)
+                        ? 0 /* Ternary.False */
+                        : -1 /* Ternary.True */;
+                instantiateType(c, source, c.reportUnreliableMapper);
+            }
+            if (isTypeMatchedByTemplateLiteralType(c, source, target, (s, t) => this.isRelatedTo(s, t, 3 /* RecursionFlags.Both */, false) !== 0 /* Ternary.False */))
+                return -1 /* Ternary.True */;
+        }
+        else if ((target.flags & 8388608 /* TypeFlags.StringMapping */) !== 0) {
+            if ((source.flags & 8388608 /* TypeFlags.StringMapping */) === 0 && isMemberOfStringMapping(c, source, target))
+                return -1 /* Ternary.True */;
+        }
+        else if (isGenericMappedType(c, target) && this.relation !== c.identityRelation) {
+            const r = this.relateToGenericMappedType(source, target, reportErrors);
+            if (r !== 0 /* Ternary.False */)
+                return r;
+            originalErrorChain = this.errorChain;
+            this.errorChain = saveChain;
+            this.relatedInfo = saveRelated;
+        }
+        if ((source.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0) {
+            // Indexed access against indexed access is handled above.
+            if ((source.flags & 33554432 /* TypeFlags.IndexedAccess */) === 0 || (target.flags & 33554432 /* TypeFlags.IndexedAccess */) === 0) {
+                const constraint = getConstraintOfType(c, source) ?? c.unknownType;
+                // Try without `this` instantiation first.
+                result = this.isRelatedToEx(constraint, target, 1 /* RecursionFlags.Source */, false, undefined, intersectionState);
+                if (result !== 0 /* Ternary.False */)
+                    return result;
+                const constraintWithThis = getTypeWithThisArgument(c, constraint, source, false);
+                result = this.isRelatedToEx(constraintWithThis, target, 1 /* RecursionFlags.Source */, reportErrors && constraint !== c.unknownType && (target.flags & source.flags & 524288 /* TypeFlags.TypeParameter */) === 0, undefined, intersectionState);
+                if (result !== 0 /* Ternary.False */)
+                    return result;
+                if (isMappedTypeGenericIndexedAccess(c, source)) {
+                    const indexConstraint = getConstraintOfType(c, source.indexType);
+                    if (indexConstraint !== undefined) {
+                        result = this.isRelatedTo(getIndexedAccessType(c, source.objectType, indexConstraint), target, 1 /* RecursionFlags.Source */, reportErrors);
+                        if (result !== 0 /* Ternary.False */)
+                            return result;
+                    }
+                }
+            }
+        }
+        else if ((source.flags & 2097152 /* TypeFlags.Index */) !== 0) {
+            const sourceIndex = source;
+            const isDeferredMappedIndex = shouldDeferIndexType(c, sourceIndex.target, sourceIndex.indexFlags) &&
+                (sourceIndex.target.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0;
+            result = this.isRelatedTo(c.stringNumberSymbolType, target, 1 /* RecursionFlags.Source */, reportErrors && !isDeferredMappedIndex);
+            if (result !== 0 /* Ternary.False */)
+                return result;
+            if (isDeferredMappedIndex) {
+                // The source keys come from the name type alone; its generic part could be anything.
+                const mappedType = sourceIndex.target;
+                const nameType = getNameTypeFromMappedType(c, mappedType);
+                const sourceMappedKeys = nameType !== undefined && isMappedTypeWithKeyofConstraintDeclaration(c, mappedType)
+                    ? getApparentMappedTypeKeys(c, nameType, mappedType)
+                    : (nameType ?? getConstraintTypeFromMappedType(c, mappedType));
+                result = this.isRelatedTo(sourceMappedKeys, target, 1 /* RecursionFlags.Source */, reportErrors);
+                if (result !== 0 /* Ternary.False */)
+                    return result;
+            }
+        }
+        else if ((source.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
+            if (isDeeplyNestedType(c, source, this.sourceStack, this.sourceDepth, 10))
+                return 3 /* Ternary.Maybe */;
+            const s = source;
+            const saveErrorChain = this.errorChain;
+            if ((target.flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
+                const t = target;
+                // Related when check types relate either way, extends types are identical, and branches relate.
+                // The source's `infer` type parameters are inferred from the target's extends type.
+                let sourceExtends = s.extendsType;
+                let mapper = undefined;
+                if (s.root.inferTypeParameters.length !== 0) {
+                    const context = createInferenceContext(c, s.root.inferTypeParameters, undefined, 0 /* InferenceFlags.None */, this);
+                    inferTypes(c, context.inferences, t.extendsType, sourceExtends, 512 /* InferencePriority.NoConstraints */ | 1024 /* InferencePriority.AlwaysStrict */, false);
+                    sourceExtends = instantiateType(c, sourceExtends, context.mapper);
+                    mapper = context.mapper;
+                }
+                if (isTypeIdenticalTo(c, sourceExtends, t.extendsType) &&
+                    (this.isRelatedTo(s.checkType, t.checkType, 3 /* RecursionFlags.Both */, false) !== 0 /* Ternary.False */ ||
+                        this.isRelatedTo(t.checkType, s.checkType, 3 /* RecursionFlags.Both */, false) !== 0 /* Ternary.False */)) {
+                    result = this.isRelatedTo(instantiateType(c, getTrueTypeFromConditionalType(c, s), mapper), getTrueTypeFromConditionalType(c, t), 3 /* RecursionFlags.Both */, reportErrors);
+                    if (result !== 0 /* Ternary.False */)
+                        result &= this.isRelatedTo(getFalseTypeFromConditionalType(c, s), getFalseTypeFromConditionalType(c, t), 3 /* RecursionFlags.Both */, reportErrors);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+            // A conditional relates through its default constraint, the union of its branches.
+            const defaultConstraint = getDefaultConstraintOfConditionalType(c, s);
+            result = this.isRelatedTo(defaultConstraint, target, 1 /* RecursionFlags.Source */, reportErrors);
+            if (result !== 0 /* Ternary.False */)
+                return result;
+            // Its distributive constraint is too inaccurate to relate conditionals to each other.
+            if ((target.flags & 67108864 /* TypeFlags.Conditional */) === 0 && hasNonCircularBaseConstraint(c, s)) {
+                const distributiveConstraint = getConstraintOfDistributiveConditionalType(c, s);
+                if (distributiveConstraint !== undefined) {
+                    this.errorChain = saveErrorChain;
+                    result = this.isRelatedTo(distributiveConstraint, target, 1 /* RecursionFlags.Source */, reportErrors);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+        }
+        else if ((source.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0 && (target.flags & 1048576 /* TypeFlags.Object */) === 0) {
+            if ((target.flags & 4194304 /* TypeFlags.TemplateLiteral */) === 0) {
+                const constraint = getBaseConstraintOfType(c, source);
+                if (constraint !== undefined && constraint !== source) {
+                    result = this.isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, reportErrors);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+        }
+        else if ((source.flags & 8388608 /* TypeFlags.StringMapping */) !== 0) {
+            if ((target.flags & 8388608 /* TypeFlags.StringMapping */) !== 0) {
+                if (source.symbol !== target.symbol)
+                    return 0 /* Ternary.False */;
+                result = this.isRelatedTo(source.target, target.target, 3 /* RecursionFlags.Both */, reportErrors);
+                if (result !== 0 /* Ternary.False */)
+                    return result;
+            }
+            else {
+                const constraint = getBaseConstraintOfType(c, source);
+                if (constraint !== undefined) {
+                    result = this.isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, reportErrors);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+            }
+        }
+        else {
+            // An empty object relates to any mapped type with `?`.
+            if (this.relation !== c.subtypeRelation &&
+                this.relation !== c.strictSubtypeRelation &&
+                isPartialMappedType(target) &&
+                isEmptyObjectType(c, source))
+                return -1 /* Ternary.True */;
+            if (isGenericMappedType(c, target)) {
+                if (isGenericMappedType(c, source)) {
+                    result = this.mappedTypeRelatedTo(source, target, reportErrors);
+                    if (result !== 0 /* Ternary.False */)
+                        return result;
+                }
+                return 0 /* Ternary.False */;
+            }
+            const sourceIsPrimitive = (source.flags & 12713980 /* TypeFlags.Primitive */) !== 0;
+            if (this.relation !== c.identityRelation)
+                source = getApparentType(c, source);
+            else if (isGenericMappedType(c, source))
+                return 0 /* Ternary.False */;
+            if ((source.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+                (target.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+                (source.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+                (target.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+                source.target === target.target &&
+                !isTupleType(source) &&
+                !isMarkerType(c, source) &&
+                !isMarkerType(c, target)) {
+                if (isEmptyArrayLiteralType(c, source))
+                    return -1 /* Ternary.True */;
+                // References to the same generic type relate by variance.
+                const variances = getVariances(c, source.target);
+                if (variances.length === 0)
+                    return 1 /* Ternary.Unknown */;
+                const varianceResult = this.relateVariances(getTypeArguments(c, source), getTypeArguments(c, target), variances, reportErrors, intersectionState, saveChain, saveRelated);
+                if (varianceResult !== undefined)
+                    return varianceResult;
+                result = 0 /* Ternary.False */;
+                if (this.varianceSetsCheckFailed)
+                    varianceCheckFailed = this.varianceCheckFailed;
+                if (this.varianceSetsErrorChain)
+                    originalErrorChain = this.varianceErrorChain;
+            }
+            else if (isArrayType(c, target) &&
+                ((isReadonlyArrayType(c, target) && everyType(source, (u) => isArrayOrTupleType(c, u))) ||
+                    everyType(source, isMutableTupleType))) {
+                if (this.relation !== c.identityRelation)
+                    return this.isRelatedTo(getIndexTypeOfType(c, source, c.numberType) ?? c.anyType, getIndexTypeOfType(c, target, c.numberType) ?? c.anyType, 3 /* RecursionFlags.Both */, reportErrors);
+                return 0 /* Ternary.False */;
+            }
+            else if (isGenericTupleType(source) && isTupleType(target) && !isGenericTupleType(target)) {
+                const constraint = getBaseConstraintOrType(c, source);
+                if (constraint !== source)
+                    return this.isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, reportErrors);
+            }
+            else if ((this.relation === c.subtypeRelation || this.relation === c.strictSubtypeRelation) &&
+                isEmptyObjectType(c, target) &&
+                (target.objectFlags & 8192 /* ObjectFlags.FreshLiteral */) !== 0 &&
+                !isEmptyObjectType(c, source))
+                return 0 /* Ternary.False */;
+            // Structural comparison, including intersection sources aggregated as objects.
+            if ((source.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0 &&
+                (target.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+                const reportStructuralErrors = reportErrors && this.errorChain === saveChain && !sourceIsPrimitive;
+                result = this.propertiesRelatedTo(source, target, reportStructuralErrors, undefined, false, intersectionState);
+                if (result !== 0 /* Ternary.False */) {
+                    result &= this.signaturesRelatedTo(source, target, 0 /* SignatureKind.Call */, reportStructuralErrors, intersectionState);
+                    if (result !== 0 /* Ternary.False */) {
+                        result &= this.signaturesRelatedTo(source, target, 1 /* SignatureKind.Construct */, reportStructuralErrors, intersectionState);
+                        if (result !== 0 /* Ternary.False */)
+                            result &= this.indexSignaturesRelatedTo(source, target, sourceIsPrimitive, reportStructuralErrors, intersectionState);
+                    }
+                }
+                if (result !== 0 /* Ternary.False */) {
+                    if (!varianceCheckFailed)
+                        return result;
+                    if (originalErrorChain !== undefined)
+                        this.errorChain = originalErrorChain;
+                    else if (this.errorChain === undefined)
+                        this.errorChain = saveChain;
+                }
+            }
+            // An object source relates to a discriminated union target when every combination of its
+            // discriminant types matches some constituent. Errors come from checking each constituent.
+            if ((source.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0 &&
+                (target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+                const objectOnlyTarget = filterType(c, target, (u) => (u.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */ | 16777216 /* TypeFlags.Substitution */)) !== 0);
+                if ((objectOnlyTarget.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+                    const related = this.typeRelatedToDiscriminatedType(source, objectOnlyTarget);
+                    if (related !== 0 /* Ternary.False */)
+                        return related;
+                }
+            }
+        }
+        return 0 /* Ternary.False */;
+    }
+    typeRelatedToDiscriminatedType(source, target) {
+        const c = this.c;
+        const discriminants = [];
+        for (const p of getPropertiesOfType(c, source))
+            if (isDiscriminantProperty(c, target, p.name))
+                discriminants.push(p);
+        if (discriminants.length === 0)
+            return 0 /* Ternary.False */;
+        // Check the number of combinations before building them.
+        let combinations = 1;
+        for (const prop of discriminants) {
+            combinations *= countTypes(getNonMissingTypeOfSymbol(c, prop));
+            if (combinations > 25 || combinations === 0)
+                return 0 /* Ternary.False */;
+        }
+        const discriminantTypes = [];
+        const excludedProperties = new Set();
+        for (const prop of discriminants) {
+            const t = getNonMissingTypeOfSymbol(c, prop);
+            discriminantTypes.push((t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(t) : [t]);
+            excludedProperties.add(prop.name);
+        }
+        // Each combination of discriminant types must match one or more constituents of the target.
+        const skipOptional = c.strictNullChecks || this.relation === c.comparableRelation;
+        const matchingTypes = [];
+        const combination = discriminantTypes.map((types) => types[0]);
+        for (let i = 0; i < combinations; i++) {
+            let n = i;
+            for (let j = discriminantTypes.length - 1; j >= 0; j--) {
+                const types = discriminantTypes[j];
+                combination[j] = types[n % types.length];
+                n = Math.floor(n / types.length);
+            }
+            let hasMatch = false;
+            for (const t of target.types) {
+                let matches = true;
+                for (let k = 0; k < discriminants.length; k++) {
+                    const sourceProp = discriminants[k];
+                    const targetProp = getPropertyOfType(c, t, sourceProp.name);
+                    if (targetProp === undefined) {
+                        matches = false;
+                        break;
+                    }
+                    if (sourceProp === targetProp)
+                        continue;
+                    // The source property is compared in the context of a single discriminant type.
+                    const related = this.propertyRelatedToEx(source, target, sourceProp, targetProp, combination[k], false, 0 /* IntersectionState.None */, skipOptional);
+                    if (related === 0 /* Ternary.False */) {
+                        matches = false;
+                        break;
+                    }
+                }
+                if (!matches)
+                    continue;
+                if (!matchingTypes.includes(t))
+                    matchingTypes.push(t);
+                hasMatch = true;
+            }
+            if (!hasMatch)
+                return 0 /* Ternary.False */;
+        }
+        // The remaining non-discriminant properties of each match must relate.
+        let result = -1 /* Ternary.True */;
+        for (const t of matchingTypes) {
+            result &= this.propertiesRelatedTo(source, t, false, excludedProperties, false, 0 /* IntersectionState.None */);
+            if (result !== 0 /* Ternary.False */) {
+                result &= this.signaturesRelatedTo(source, t, 0 /* SignatureKind.Call */, false, 0 /* IntersectionState.None */);
+                if (result !== 0 /* Ternary.False */) {
+                    result &= this.signaturesRelatedTo(source, t, 1 /* SignatureKind.Construct */, false, 0 /* IntersectionState.None */);
+                    // Tuple element types are covered by their properties.
+                    if (result !== 0 /* Ternary.False */ && !(isTupleType(source) && isTupleType(t)))
+                        result &= this.indexSignaturesRelatedTo(source, t, false, false, 0 /* IntersectionState.None */);
+                }
+            }
+            if (result === 0 /* Ternary.False */)
+                return result;
+        }
+        return result;
+    }
+    relateToGenericMappedType(source, target, reportErrors) {
+        const c = this.c;
+        const keysRemapped = getNameTypeFromMappedType(c, target) !== undefined;
+        const templateType = getTemplateTypeFromMappedType(c, target);
+        const modifiers = getMappedTypeModifiers(target);
+        if ((modifiers & 8 /* MappedTypeModifiers.ExcludeOptional */) !== 0)
+            return 0 /* Ternary.False */;
+        // `{ [P in Q]: S[P] }` with source S.
+        if (!keysRemapped &&
+            (templateType.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0 &&
+            templateType.objectType === source &&
+            templateType.indexType === getTypeParameterFromMappedType(c, target))
+            return -1 /* Ternary.True */;
+        if (isGenericMappedType(c, source))
+            return 0 /* Ternary.False */;
+        const targetKeys = keysRemapped
+            ? getNameTypeFromMappedType(c, target)
+            : getConstraintTypeFromMappedType(c, target);
+        const sourceKeys = getIndexTypeEx(c, source, 2 /* IndexFlags.NoIndexSignatures */);
+        const includeOptional = (modifiers & 4 /* MappedTypeModifiers.IncludeOptional */) !== 0;
+        const filteredByApplicability = includeOptional ? getIntersectionType(c, [targetKeys, sourceKeys]) : undefined;
+        if ((includeOptional && (filteredByApplicability.flags & 262144 /* TypeFlags.Never */) === 0) ||
+            (!includeOptional && this.isRelatedTo(targetKeys, sourceKeys, 3 /* RecursionFlags.Both */, false) !== 0 /* Ternary.False */)) {
+            const typeParameter = getTypeParameterFromMappedType(c, target);
+            const nonNullComponent = filterType(c, templateType, (u) => (u.flags & 12 /* TypeFlags.Nullable */) === 0);
+            if (!keysRemapped &&
+                (nonNullComponent.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0 &&
+                nonNullComponent.indexType === typeParameter) {
+                const r = this.isRelatedTo(source, nonNullComponent.objectType, 2 /* RecursionFlags.Target */, reportErrors);
+                if (r !== 0 /* Ternary.False */)
+                    return r;
+            }
+            else {
+                let indexingType = typeParameter;
+                if (keysRemapped)
+                    indexingType = filteredByApplicability ?? targetKeys;
+                else if (filteredByApplicability !== undefined)
+                    indexingType = getIntersectionType(c, [filteredByApplicability, typeParameter]);
+                const r = this.isRelatedTo(getIndexedAccessType(c, source, indexingType), templateType, 3 /* RecursionFlags.Both */, reportErrors);
+                if (r !== 0 /* Ternary.False */)
+                    return r;
+            }
+        }
+        return 0 /* Ternary.False */;
+    }
+    typeArgumentsRelatedTo(sources, targets, variances, reportErrors, intersectionState) {
+        const c = this.c;
+        if (sources.length !== targets.length && this.relation === c.identityRelation)
+            return 0 /* Ternary.False */;
+        const length = Math.min(sources.length, targets.length);
+        let result = -1 /* Ternary.True */;
+        for (let i = 0; i < length; i++) {
+            // Without variance information, default to covariance.
+            const varianceFlags = i < variances.length ? variances[i] : 1 /* VarianceFlags.Covariant */;
+            const variance = varianceFlags & 7 /* VarianceFlags.VarianceMask */;
+            if (variance === 4 /* VarianceFlags.Independent */)
+                continue;
+            const s = sources[i];
+            const t = targets[i];
+            let related;
+            if ((varianceFlags & 8 /* VarianceFlags.Unmeasurable */) !== 0)
+                related =
+                    this.relation === c.identityRelation
+                        ? this.isRelatedTo(s, t, 3 /* RecursionFlags.Both */, false)
+                        : compareTypesIdentical(c, s, t);
+            else {
+                if (c.inVarianceComputation && (varianceFlags & 16 /* VarianceFlags.Unreliable */) !== 0)
+                    instantiateType(c, s, c.reportUnreliableMapper);
+                if (variance === 1 /* VarianceFlags.Covariant */)
+                    related = this.isRelatedToEx(s, t, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+                else if (variance === 2 /* VarianceFlags.Contravariant */)
+                    related = this.isRelatedToEx(t, s, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+                else if (variance === 3 /* VarianceFlags.Bivariant */) {
+                    // Contravariant without errors, then covariant with errors.
+                    related = this.isRelatedTo(t, s, 3 /* RecursionFlags.Both */, false);
+                    if (related === 0 /* Ternary.False */)
+                        related = this.isRelatedToEx(s, t, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+                }
+                else {
+                    // Invariant: covariant first, then contravariant.
+                    related = this.isRelatedToEx(s, t, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+                    if (related !== 0 /* Ternary.False */)
+                        related &= this.isRelatedToEx(t, s, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+                }
+            }
+            if (related === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+            result &= related;
+        }
+        return result;
+    }
+    mappedTypeRelatedTo(source, target, reportErrors) {
+        const c = this.c;
+        const modifiersRelated = this.relation === c.comparableRelation ||
+            (this.relation === c.identityRelation && getMappedTypeModifiers(source) === getMappedTypeModifiers(target)) ||
+            (this.relation !== c.identityRelation &&
+                getCombinedMappedTypeOptionality(c, source) <= getCombinedMappedTypeOptionality(c, target));
+        if (!modifiersRelated)
+            return 0 /* Ternary.False */;
+        const targetConstraint = getConstraintTypeFromMappedType(c, target);
+        const sourceConstraint = instantiateType(c, getConstraintTypeFromMappedType(c, source), getCombinedMappedTypeOptionality(c, source) < 0 ? c.reportUnmeasurableMapper : c.reportUnreliableMapper);
+        const result = this.isRelatedTo(targetConstraint, sourceConstraint, 3 /* RecursionFlags.Both */, reportErrors);
+        if (result === 0 /* Ternary.False */)
+            return 0 /* Ternary.False */;
+        const mapper = new SimpleTypeMapper(getTypeParameterFromMappedType(c, source), getTypeParameterFromMappedType(c, target));
+        const sourceName = getNameTypeFromMappedType(c, source);
+        const targetName = getNameTypeFromMappedType(c, target);
+        if ((sourceName === undefined ? undefined : instantiateType(c, sourceName, mapper)) !==
+            (targetName === undefined ? undefined : instantiateType(c, targetName, mapper)))
+            return 0 /* Ternary.False */;
+        return (result &
+            this.isRelatedTo(instantiateType(c, getTemplateTypeFromMappedType(c, source), mapper), getTemplateTypeFromMappedType(c, target), 3 /* RecursionFlags.Both */, reportErrors));
+    }
+    propertiesRelatedTo(source, target, reportErrors, excludedProperties, optionalsOnly, intersectionState) {
+        const c = this.c;
+        if (this.relation === c.identityRelation)
+            return this.propertiesIdenticalTo(source, target, excludedProperties);
+        let result = -1 /* Ternary.True */;
+        if (isTupleType(target)) {
+            const targetTuple = tupleTargetOf(target);
+            if (isArrayOrTupleType(c, source)) {
+                if (!targetTuple.readonly &&
+                    (isReadonlyArrayType(c, source) || (isTupleType(source) && tupleTargetOf(source).readonly)))
+                    return 0 /* Ternary.False */;
+                const sourceArity = getTypeReferenceArity(source);
+                const targetArity = getTypeReferenceArity(target);
+                const sourceRest = isTupleType(source) ? (tupleTargetOf(source).combinedFlags & 4 /* ElementFlags.Rest */) !== 0 : true;
+                const targetHasRestElement = (targetTuple.combinedFlags & 12 /* ElementFlags.Variable */) !== 0;
+                const sourceMinLength = isTupleType(source) ? tupleTargetOf(source).minLength : 0;
+                const targetMinLength = targetTuple.minLength;
+                if (!sourceRest && sourceArity < targetMinLength) {
+                    if (reportErrors)
+                        this.reportError(762 /* Diagnostics.Source_has_0_element_s_but_target_requires_1 */, [
+                            String(sourceArity),
+                            String(targetMinLength),
+                        ]);
+                    return 0 /* Ternary.False */;
+                }
+                if (!targetHasRestElement && targetArity < sourceMinLength) {
+                    if (reportErrors)
+                        this.reportError(763 /* Diagnostics.Source_has_0_element_s_but_target_allows_only_1 */, [
+                            String(sourceMinLength),
+                            String(targetArity),
+                        ]);
+                    return 0 /* Ternary.False */;
+                }
+                if (!targetHasRestElement && (sourceRest || targetArity < sourceArity)) {
+                    if (reportErrors) {
+                        if (sourceMinLength < targetMinLength)
+                            this.reportError(764 /* Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer */, [
+                                String(targetMinLength),
+                            ]);
+                        else
+                            this.reportError(765 /* Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more */, [
+                                String(targetArity),
+                            ]);
+                    }
+                    return 0 /* Ternary.False */;
+                }
+                const sourceTypeArguments = getTypeArguments(c, source);
+                const targetTypeArguments = getTypeArguments(c, target);
+                const targetStartCount = getStartElementCount(targetTuple, 11 /* ElementFlags.NonRest */);
+                const targetEndCount = getEndElementCount(targetTuple, 11 /* ElementFlags.NonRest */);
+                let canExcludeDiscriminants = excludedProperties !== undefined && excludedProperties.size !== 0;
+                for (let sourcePosition = 0; sourcePosition < sourceArity; sourcePosition++) {
+                    const sourceFlags = isTupleType(source)
+                        ? tupleTargetOf(source).elementInfos[sourcePosition].flags
+                        : 4 /* ElementFlags.Rest */;
+                    const sourcePositionFromEnd = sourceArity - 1 - sourcePosition;
+                    const targetPosition = targetHasRestElement && sourcePosition >= targetStartCount
+                        ? targetArity - 1 - Math.min(sourcePositionFromEnd, targetEndCount)
+                        : sourcePosition;
+                    const targetFlags = targetPosition >= 0 ? targetTuple.elementInfos[targetPosition].flags : 0 /* ElementFlags.None */;
+                    if ((targetFlags & 8 /* ElementFlags.Variadic */) !== 0 && (sourceFlags & 8 /* ElementFlags.Variadic */) === 0) {
+                        if (reportErrors)
+                            this.reportError(767 /* Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target */, [
+                                String(targetPosition),
+                            ]);
+                        return 0 /* Ternary.False */;
+                    }
+                    if ((sourceFlags & 8 /* ElementFlags.Variadic */) !== 0 && (targetFlags & 12 /* ElementFlags.Variable */) === 0) {
+                        if (reportErrors)
+                            this.reportError(768 /* Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target */, [String(sourcePosition), String(targetPosition)]);
+                        return 0 /* Ternary.False */;
+                    }
+                    if ((targetFlags & 1 /* ElementFlags.Required */) !== 0 && (sourceFlags & 1 /* ElementFlags.Required */) === 0) {
+                        if (reportErrors)
+                            this.reportError(766 /* Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target */, [
+                                String(targetPosition),
+                            ]);
+                        return 0 /* Ternary.False */;
+                    }
+                    if (canExcludeDiscriminants) {
+                        if ((sourceFlags & 12 /* ElementFlags.Variable */) !== 0 || (targetFlags & 12 /* ElementFlags.Variable */) !== 0)
+                            canExcludeDiscriminants = false;
+                        if (canExcludeDiscriminants && excludedProperties.has(String(sourcePosition)))
+                            continue;
+                    }
+                    const sourceType = removeMissingType(c, sourceTypeArguments[sourcePosition], (sourceFlags & targetFlags & 2 /* ElementFlags.Optional */) !== 0);
+                    const targetType = targetTypeArguments[targetPosition];
+                    const targetCheckType = (sourceFlags & 8 /* ElementFlags.Variadic */) !== 0 && (targetFlags & 4 /* ElementFlags.Rest */) !== 0
+                        ? createArrayTypeEx(c, targetType, false)
+                        : removeMissingType(c, targetType, (targetFlags & 2 /* ElementFlags.Optional */) !== 0);
+                    const related = this.isRelatedToEx(sourceType, targetCheckType, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+                    if (related === 0 /* Ternary.False */) {
+                        if (reportErrors && (targetArity > 1 || sourceArity > 1)) {
+                            if (targetHasRestElement &&
+                                sourcePosition >= targetStartCount &&
+                                sourcePositionFromEnd >= targetEndCount &&
+                                targetStartCount !== sourceArity - targetEndCount - 1)
+                                this.reportError(770 /* Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target */, [String(targetStartCount), String(sourceArity - targetEndCount - 1), String(targetPosition)]);
+                            else
+                                this.reportError(769 /* Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target */, [String(sourcePosition), String(targetPosition)]);
+                        }
+                        return 0 /* Ternary.False */;
+                    }
+                    result &= related;
+                }
+                return result;
+            }
+            if ((targetTuple.combinedFlags & 12 /* ElementFlags.Variable */) !== 0)
+                return 0 /* Ternary.False */;
+        }
+        const requireOptionalProperties = (this.relation === c.subtypeRelation || this.relation === c.strictSubtypeRelation) &&
+            !isObjectLiteralType(source) &&
+            !isEmptyArrayLiteralType(c, source) &&
+            !isTupleType(source);
+        const unmatchedProperty = getUnmatchedProperty(c, source, target, requireOptionalProperties, false);
+        if (unmatchedProperty !== undefined) {
+            if (reportErrors && shouldReportUnmatchedPropertyError(c, source, target))
+                this.reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties);
+            return 0 /* Ternary.False */;
+        }
+        if (isObjectLiteralType(target)) {
+            for (const sourceProp of getPropertiesOfType(c, source)) {
+                if (excludedProperties !== undefined && excludedProperties.has(sourceProp.name))
+                    continue;
+                if (getPropertyOfObjectType(c, target, sourceProp.name) === undefined) {
+                    if (reportErrors)
+                        this.reportError(516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, [
+                            symbolToString(c, sourceProp),
+                            typeToString(c, target),
+                        ]);
+                    return 0 /* Ternary.False */;
+                }
+            }
+        }
+        const numericNamesOnly = isTupleType(source) && isTupleType(target);
+        for (const targetProp of getPropertiesOfType(c, target)) {
+            if (excludedProperties !== undefined && excludedProperties.has(targetProp.name))
+                continue;
+            const name = targetProp.name;
+            if ((targetProp.flags & 4194304 /* SymbolFlags.Prototype */) === 0 &&
+                (!numericNamesOnly || isNumericLiteralName(name) || name === 'length') &&
+                (!optionalsOnly || (targetProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0)) {
+                const sourceProp = getPropertyOfType(c, source, name);
+                if (sourceProp !== undefined && sourceProp !== targetProp) {
+                    const related = this.propertyRelatedTo(source, target, sourceProp, targetProp, reportErrors, intersectionState, this.relation === c.comparableRelation);
+                    if (related === 0 /* Ternary.False */)
+                        return 0 /* Ternary.False */;
+                    result &= related;
+                }
+            }
+        }
+        return result;
+    }
+    propertyRelatedTo(source, target, sourceProp, targetProp, reportErrors, intersectionState, skipOptional) {
+        return this.propertyRelatedToEx(source, target, sourceProp, targetProp, undefined, reportErrors, intersectionState, skipOptional);
+    }
+    /** `propertyRelatedTo` with `sourcePropType` in place of the source property's type when given. */
+    propertyRelatedToEx(source, target, sourceProp, targetProp, sourcePropType, reportErrors, intersectionState, skipOptional) {
+        const c = this.c;
+        const sourcePropFlags = getDeclarationModifierFlagsFromSymbol(c, sourceProp, false);
+        const targetPropFlags = getDeclarationModifierFlagsFromSymbol(c, targetProp, false);
+        if ((sourcePropFlags & 2 /* ModifierFlags.Private */) !== 0 || (targetPropFlags & 2 /* ModifierFlags.Private */) !== 0) {
+            if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
+                if (reportErrors) {
+                    if ((sourcePropFlags & 2 /* ModifierFlags.Private */) !== 0 && (targetPropFlags & 2 /* ModifierFlags.Private */) !== 0)
+                        this.reportError(610 /* Diagnostics.Types_have_separate_declarations_of_a_private_property_0 */, [
+                            symbolToString(c, targetProp),
+                        ]);
+                    else {
+                        const sourceIsPrivate = (sourcePropFlags & 2 /* ModifierFlags.Private */) !== 0;
+                        this.reportError(503 /* Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2 */, [
+                            symbolToString(c, targetProp),
+                            typeToString(c, sourceIsPrivate ? source : target),
+                            typeToString(c, sourceIsPrivate ? target : source),
+                        ]);
+                    }
+                }
+                return 0 /* Ternary.False */;
+            }
+        }
+        else if ((targetPropFlags & 4 /* ModifierFlags.Protected */) !== 0) {
+            if (!isValidOverrideOf(c, sourceProp, targetProp)) {
+                if (reportErrors)
+                    this.reportError(611 /* Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2 */, [
+                        symbolToString(c, targetProp),
+                        typeToString(c, getDeclaringClass(c, sourceProp) ?? source),
+                        typeToString(c, getDeclaringClass(c, targetProp) ?? target),
+                    ]);
+                return 0 /* Ternary.False */;
+            }
+        }
+        else if ((sourcePropFlags & 4 /* ModifierFlags.Protected */) !== 0) {
+            if (reportErrors)
+                this.reportError(612 /* Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2 */, [
+                    symbolToString(c, targetProp),
+                    typeToString(c, source),
+                    typeToString(c, target),
+                ]);
+            return 0 /* Ternary.False */;
+        }
+        // Under strict subtype, readonly properties aren't subtypes of mutable ones.
+        if (this.relation === c.strictSubtypeRelation &&
+            isReadonlySymbol(c, sourceProp) &&
+            !isReadonlySymbol(c, targetProp))
+            return 0 /* Ternary.False */;
+        const related = this.isPropertySymbolTypeRelated(sourceProp, targetProp, sourcePropType, reportErrors, intersectionState);
+        if (related === 0 /* Ternary.False */) {
+            if (reportErrors)
+                this.reportError(504 /* Diagnostics.Types_of_property_0_are_incompatible */, [symbolToString(c, targetProp)]);
+            return 0 /* Ternary.False */;
+        }
+        if (!skipOptional &&
+            (sourceProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0 &&
+            (targetProp.flags & 106500 /* SymbolFlags.ClassMember */) !== 0 &&
+            (targetProp.flags & 16777216 /* SymbolFlags.Optional */) === 0) {
+            if (reportErrors)
+                this.reportError(505 /* Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2 */, [
+                    symbolToString(c, targetProp),
+                    typeToString(c, source),
+                    typeToString(c, target),
+                ]);
+            return 0 /* Ternary.False */;
+        }
+        return related;
+    }
+    isPropertySymbolTypeRelated(sourceProp, targetProp, sourcePropType, reportErrors, intersectionState) {
+        const c = this.c;
+        const targetIsOptional = c.strictNullChecks && (targetProp.checkFlags & 48 /* CheckFlags.Partial */) !== 0;
+        const effectiveTarget = addOptionality(c, getNonMissingTypeOfSymbol(c, targetProp), false, targetIsOptional);
+        if ((effectiveTarget.flags & (this.relation === c.strictSubtypeRelation ? 1 /* TypeFlags.Any */ : 3 /* TypeFlags.AnyOrUnknown */)) !==
+            0)
+            return -1 /* Ternary.True */;
+        const effectiveSource = sourcePropType ?? getNonMissingTypeOfSymbol(c, sourceProp);
+        return this.isRelatedToEx(effectiveSource, effectiveTarget, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+    }
+    reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties) {
+        const c = this.c;
+        // A private name of the same description in the source class is a different member.
+        const declarationName = unmatchedProperty.valueDeclaration !== undefined ? getName(unmatchedProperty.valueDeclaration) : undefined;
+        if (declarationName !== undefined &&
+            declarationName.kind === 80 /* SyntaxKind.PrivateIdentifier */ &&
+            source.symbol !== undefined &&
+            (source.symbol.flags & 32 /* SymbolFlags.Class */) !== 0) {
+            const description = getText(declarationName);
+            if (getPropertyOfType(c, source, getSymbolNameForPrivateIdentifier(source.symbol, description)) !== undefined) {
+                this.reportError(1837 /* Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2 */, [description, symbolToString(c, source.symbol), symbolToString(c, target.symbol)]);
+                return;
+            }
+        }
+        const props = getUnmatchedProperties(c, source, target, requireOptionalProperties);
+        if (props.length === 1) {
+            const names = getTypeNamesForErrorDisplay(c, source, target);
+            const propName = symbolToString(c, unmatchedProperty);
+            this.reportError(873 /* Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2 */, [
+                propName,
+                names[0],
+                names[1],
+            ]);
+            if (unmatchedProperty.declarations.length !== 0)
+                this.relatedInfo.push(createDiagnosticForNode(unmatchedProperty.declarations[0], 860 /* Diagnostics.X_0_is_declared_here */, [propName]));
+        }
+        else if (this.tryElaborateArrayLikeErrors(source, target, false)) {
+            const names = getTypeNamesForErrorDisplay(c, source, target);
+            if (props.length > 5)
+                this.reportError(872 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more */, [
+                    names[0],
+                    names[1],
+                    symbolNames(c, props.slice(0, 4)),
+                    String(props.length - 4),
+                ]);
+            else
+                this.reportError(871 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2 */, [
+                    names[0],
+                    names[1],
+                    symbolNames(c, props),
+                ]);
+        }
+    }
+    /** Mutability elaborations; false when property elaborations should be skipped. */
+    tryElaborateArrayLikeErrors(source, target, reportErrors) {
+        const c = this.c;
+        if (isTupleType(source)) {
+            if (tupleTargetOf(source).readonly && isMutableArrayOrTuple(c, target)) {
+                if (reportErrors)
+                    this.reportError(1090 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */, [
+                        typeToString(c, source),
+                        typeToString(c, target),
+                    ]);
+                return false;
+            }
+            return isArrayOrTupleType(c, target);
+        }
+        if (isReadonlyArrayType(c, source) && isMutableArrayOrTuple(c, target)) {
+            if (reportErrors)
+                this.reportError(1090 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */, [
+                    typeToString(c, source),
+                    typeToString(c, target),
+                ]);
+            return false;
+        }
+        if (isTupleType(target))
+            return isArrayType(c, source);
+        return true;
+    }
+    propertiesIdenticalTo(source, target, excludedProperties) {
+        const c = this.c;
+        if ((source.flags & 1048576 /* TypeFlags.Object */) === 0 || (target.flags & 1048576 /* TypeFlags.Object */) === 0)
+            return 0 /* Ternary.False */;
+        const exclude = (props) => excludedProperties === undefined || excludedProperties.size === 0
+            ? props
+            : props.filter((p) => !excludedProperties.has(p.name));
+        const sourceProperties = exclude(getPropertiesOfObjectType(c, source));
+        const targetProperties = exclude(getPropertiesOfObjectType(c, target));
+        if (sourceProperties.length !== targetProperties.length)
+            return 0 /* Ternary.False */;
+        let result = -1 /* Ternary.True */;
+        for (const sourceProp of sourceProperties) {
+            const targetProp = getPropertyOfObjectType(c, target, sourceProp.name);
+            if (targetProp === undefined)
+                return 0 /* Ternary.False */;
+            const related = comparePropertiesWith(c, sourceProp, targetProp, this);
+            if (related === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+            result &= related;
+        }
+        return result;
+    }
+    signaturesRelatedTo(source, target, kind, reportErrors, intersectionState) {
+        const c = this.c;
+        if (this.relation === c.identityRelation)
+            return this.signaturesIdenticalTo(source, target, kind);
+        // anyFunctionType is a subtype of every function type.
+        if (source === c.anyFunctionType)
+            return -1 /* Ternary.True */;
+        if (target === c.anyFunctionType)
+            return 0 /* Ternary.False */;
+        const sourceSignatures = getSignaturesOfType(c, source, kind);
+        const targetSignatures = getSignaturesOfType(c, target, kind);
+        if (kind === 1 /* SignatureKind.Construct */ && sourceSignatures.length !== 0 && targetSignatures.length !== 0) {
+            const sourceIsAbstract = (sourceSignatures[0].flags & 8 /* SignatureFlags.Abstract */) !== 0;
+            const targetIsAbstract = (targetSignatures[0].flags & 8 /* SignatureFlags.Abstract */) !== 0;
+            if (sourceIsAbstract && !targetIsAbstract) {
+                if (reportErrors)
+                    this.reportError(677 /* Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type */, []);
+                return 0 /* Ternary.False */;
+            }
+            if (!this.constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors))
+                return 0 /* Ternary.False */;
+        }
+        let result = -1 /* Ternary.True */;
+        if (((source.objectFlags & 64 /* ObjectFlags.Instantiated */) !== 0 &&
+            (target.objectFlags & 64 /* ObjectFlags.Instantiated */) !== 0 &&
+            source.symbol === target.symbol) ||
+            ((source.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+                (target.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+                source.target === target.target)) {
+            // Instantiations of the same type compare pairwise with erased type parameters.
+            for (let i = 0; i < targetSignatures.length && i < sourceSignatures.length; i++) {
+                const related = this.signatureRelatedTo(sourceSignatures[i], targetSignatures[i], true, reportErrors, intersectionState);
+                if (related === 0 /* Ternary.False */)
+                    return 0 /* Ternary.False */;
+                result &= related;
+            }
+        }
+        else if (sourceSignatures.length === 1 && targetSignatures.length === 1) {
+            // Single signatures erase generics only for comparability.
+            const eraseGenerics = this.relation === c.comparableRelation;
+            result = this.signatureRelatedTo(sourceSignatures[0], targetSignatures[0], eraseGenerics, reportErrors, intersectionState);
+        }
+        else {
+            outer: for (const t of targetSignatures) {
+                const saveChain = this.errorChain;
+                const saveRelated = this.relatedInfo;
+                // Elaborate only the first failure.
+                let shouldElaborateErrors = reportErrors;
+                for (const s of sourceSignatures) {
+                    const related = this.signatureRelatedTo(s, t, true, shouldElaborateErrors, intersectionState);
+                    if (related !== 0 /* Ternary.False */) {
+                        result &= related;
+                        this.errorChain = saveChain;
+                        this.relatedInfo = saveRelated;
+                        continue outer;
+                    }
+                    shouldElaborateErrors = false;
+                }
+                if (shouldElaborateErrors)
+                    this.reportError(792 /* Diagnostics.Type_0_provides_no_match_for_the_signature_1 */, [
+                        typeToString(c, source),
+                        signatureToString(c, t),
+                    ]);
+                return 0 /* Ternary.False */;
+            }
+        }
+        return result;
+    }
+    constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors) {
+        if (sourceSignature.declaration === undefined || targetSignature.declaration === undefined)
+            return true;
+        const sourceAccessibility = getCombinedModifierFlags(sourceSignature.declaration) & 6 /* ModifierFlags.NonPublicAccessibilityModifier */;
+        const targetAccessibility = getCombinedModifierFlags(targetSignature.declaration) & 6 /* ModifierFlags.NonPublicAccessibilityModifier */;
+        if (targetAccessibility === 2 /* ModifierFlags.Private */)
+            return true;
+        if (targetAccessibility === 4 /* ModifierFlags.Protected */ && sourceAccessibility !== 2 /* ModifierFlags.Private */)
+            return true;
+        if (targetAccessibility !== 4 /* ModifierFlags.Protected */ && sourceAccessibility === 0)
+            return true;
+        if (reportErrors)
+            this.reportError(806 /* Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type */, [
+                visibilityToString(sourceAccessibility),
+                visibilityToString(targetAccessibility),
+            ]);
+        return false;
+    }
+    signatureRelatedTo(source, target, erase, reportErrors, intersectionState) {
+        const c = this.c;
+        let checkMode = 0 /* SignatureCheckMode.None */;
+        if (this.relation === c.subtypeRelation)
+            checkMode = 16 /* SignatureCheckMode.StrictTopSignature */;
+        else if (this.relation === c.strictSubtypeRelation)
+            checkMode = 16 /* SignatureCheckMode.StrictTopSignature */ | 8 /* SignatureCheckMode.StrictArity */;
+        if (erase) {
+            source = getErasedSignature(c, source);
+            target = getErasedSignature(c, target);
+        }
+        const saveState = this.signatureIntersectionState;
+        this.signatureIntersectionState = intersectionState;
+        const result = compareSignaturesRelated(c, source, target, checkMode, reportErrors, this, c.reportUnreliableMapper);
+        this.signatureIntersectionState = saveState;
+        return result;
+    }
+    signaturesIdenticalTo(source, target, kind) {
+        const c = this.c;
+        const sourceSignatures = getSignaturesOfType(c, source, kind);
+        const targetSignatures = getSignaturesOfType(c, target, kind);
+        if (sourceSignatures.length !== targetSignatures.length)
+            return 0 /* Ternary.False */;
+        let result = -1 /* Ternary.True */;
+        for (let i = 0; i < sourceSignatures.length; i++) {
+            const related = compareSignaturesIdenticalWith(c, sourceSignatures[i], targetSignatures[i], false, false, false, this);
+            if (related === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+            result &= related;
+        }
+        return result;
+    }
+    indexSignaturesRelatedTo(source, target, sourceIsPrimitive, reportErrors, intersectionState) {
+        const c = this.c;
+        if (this.relation === c.identityRelation)
+            return this.indexSignaturesIdenticalTo(source, target);
+        const indexInfos = getIndexInfosOfType(c, target);
+        const targetHasStringIndex = indexInfos.some((info) => info.keyType === c.stringType);
+        let result = -1 /* Ternary.True */;
+        for (const targetInfo of indexInfos) {
+            let related;
+            if (this.relation !== c.strictSubtypeRelation &&
+                !sourceIsPrimitive &&
+                targetHasStringIndex &&
+                (targetInfo.valueType.flags & 1 /* TypeFlags.Any */) !== 0)
+                related = -1 /* Ternary.True */;
+            else if (isGenericMappedType(c, source) && targetHasStringIndex)
+                related = this.isRelatedTo(getTemplateTypeFromMappedType(c, source), targetInfo.valueType, 3 /* RecursionFlags.Both */, reportErrors);
+            else
+                related = this.typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
+            if (related === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+            result &= related;
+        }
+        return result;
+    }
+    typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState) {
+        const c = this.c;
+        const sourceInfo = getApplicableIndexInfo(c, source, targetInfo.keyType);
+        if (sourceInfo !== undefined)
+            return this.indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors, intersectionState);
+        // Intersection constituents never have inferred index signatures; under strict subtype only fresh literals do.
+        if ((intersectionState & 1 /* IntersectionState.Source */) === 0 &&
+            (this.relation !== c.strictSubtypeRelation || (source.objectFlags & 8192 /* ObjectFlags.FreshLiteral */) !== 0) &&
+            isObjectTypeWithInferableIndex(c, source))
+            return this.membersRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
+        if (reportErrors)
+            this.reportError(507 /* Diagnostics.Index_signature_for_type_0_is_missing_in_type_1 */, [
+                typeToString(c, targetInfo.keyType),
+                typeToString(c, source),
+            ]);
+        return 0 /* Ternary.False */;
+    }
+    membersRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState) {
+        const c = this.c;
+        let result = -1 /* Ternary.True */;
+        const keyType = targetInfo.keyType;
+        const props = (source.flags & 268435456 /* TypeFlags.Intersection */) !== 0
+            ? getPropertiesOfUnionOrIntersectionType(c, source)
+            : getPropertiesOfObjectType(c, source);
+        for (const prop of props) {
+            if (isIgnoredJsxProperty(source, prop))
+                continue;
+            if (!isApplicableIndexType(c, getLiteralTypeFromPropertyLazy(c, prop, 19456 /* TypeFlags.StringOrNumberLiteralOrUnique */, false), keyType))
+                continue;
+            const propType = getNonMissingTypeOfSymbol(c, prop);
+            const t = c.exactOptionalPropertyTypes ||
+                (propType.flags & 4 /* TypeFlags.Undefined */) !== 0 ||
+                keyType === c.numberType ||
+                (prop.flags & 16777216 /* SymbolFlags.Optional */) === 0
+                ? propType
+                : filterType(c, propType, (u) => (u.flags & 4 /* TypeFlags.Undefined */) === 0);
+            const related = this.isRelatedToEx(t, targetInfo.valueType, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+            if (related === 0 /* Ternary.False */) {
+                if (reportErrors)
+                    this.reportError(688 /* Diagnostics.Property_0_is_incompatible_with_index_signature */, [symbolToString(c, prop)]);
+                return 0 /* Ternary.False */;
+            }
+            result &= related;
+        }
+        for (const info of getIndexInfosOfType(c, source)) {
+            if (isApplicableIndexType(c, info.keyType, keyType)) {
+                const related = this.indexInfoRelatedTo(info, targetInfo, reportErrors, intersectionState);
+                if (related === 0 /* Ternary.False */)
+                    return 0 /* Ternary.False */;
+                result &= related;
+            }
+        }
+        return result;
+    }
+    indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors, intersectionState) {
+        const c = this.c;
+        const related = this.isRelatedToEx(sourceInfo.valueType, targetInfo.valueType, 3 /* RecursionFlags.Both */, reportErrors, undefined, intersectionState);
+        if (related === 0 /* Ternary.False */ && reportErrors) {
+            if (sourceInfo.keyType === targetInfo.keyType)
+                this.reportError(777 /* Diagnostics.X_0_index_signatures_are_incompatible */, [typeToString(c, sourceInfo.keyType)]);
+            else
+                this.reportError(508 /* Diagnostics.X_0_and_1_index_signatures_are_incompatible */, [
+                    typeToString(c, sourceInfo.keyType),
+                    typeToString(c, targetInfo.keyType),
+                ]);
+        }
+        return related;
+    }
+    indexSignaturesIdenticalTo(source, target) {
+        const c = this.c;
+        const sourceInfos = getIndexInfosOfType(c, source);
+        const targetInfos = getIndexInfosOfType(c, target);
+        if (sourceInfos.length !== targetInfos.length)
+            return 0 /* Ternary.False */;
+        for (const targetInfo of targetInfos) {
+            const sourceInfo = getIndexInfoOfType(c, source, targetInfo.keyType);
+            if (!(sourceInfo !== undefined &&
+                this.isRelatedTo(sourceInfo.valueType, targetInfo.valueType, 3 /* RecursionFlags.Both */, false) !== 0 /* Ternary.False */ &&
+                sourceInfo.isReadonly === targetInfo.isReadonly))
+                return 0 /* Ternary.False */;
+        }
+        return -1 /* Ternary.True */;
+    }
+    // ---- Error reporting
+    reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
+        const c = this.c;
+        if (originalSource.alias !== undefined || getSingleBaseForNonAugmentingSubtype(c, originalSource) !== undefined)
+            source = originalSource;
+        if (originalTarget.alias !== undefined || getSingleBaseForNonAugmentingSubtype(c, originalTarget) !== undefined)
+            target = originalTarget;
+        if ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 1048576 /* TypeFlags.Object */) !== 0)
+            this.tryElaborateArrayLikeErrors(source, target, true);
+        if ((source.flags & 1048576 /* TypeFlags.Object */) !== 0 && (target.flags & 12713980 /* TypeFlags.Primitive */) !== 0)
+            this.tryElaborateErrorsForPrimitivesAndObjects(source, target);
+        else if (source.symbol !== undefined && (source.flags & 1048576 /* TypeFlags.Object */) !== 0 && c.globalObjectType === source)
+            this.reportError(828 /* Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead */, []);
+        else if ((source.objectFlags & 2048 /* ObjectFlags.JsxAttributes */) !== 0 && (target.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+            // Attributes failing JSX.IntrinsicAttributes or JSX.IntrinsicClassAttributes report that member's error alone.
+            const targetTypes = typesOf(target);
+            const errorNode = this.errorNode;
+            const intrinsicAttributes = getJsxType(c, 'IntrinsicAttributes', errorNode);
+            const intrinsicClassAttributes = getJsxType(c, 'IntrinsicClassAttributes', errorNode);
+            if (!isErrorType(c, intrinsicAttributes) &&
+                !isErrorType(c, intrinsicClassAttributes) &&
+                (targetTypes.includes(intrinsicAttributes) || targetTypes.includes(intrinsicClassAttributes)))
+                return;
+        }
+        else if ((originalTarget.flags & 268435456 /* TypeFlags.Intersection */) !== 0 &&
+            (lazyObjectFlags(c, originalTarget) & 67108864 /* ObjectFlags.IsNeverIntersection */) !== 0) {
+            const props = getPropertiesOfUnionOrIntersectionType(c, originalTarget);
+            let message = 1848 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents */;
+            let prop;
+            for (const p of props) {
+                if (isDiscriminantWithNeverType(c, p)) {
+                    prop = p;
+                    break;
+                }
+            }
+            if (prop === undefined) {
+                message =
+                    1849 /* Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some */;
+                for (const p of props) {
+                    if (isConflictingPrivateProperty(p)) {
+                        prop = p;
+                        break;
+                    }
+                }
+            }
+            if (prop !== undefined)
+                this.reportError(message, [typeToString(c, originalTarget, undefined, 1 << 29), symbolToString(c, prop)]);
+        }
+        this.reportRelationError(headMessage, source, target);
+        if ((source.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
+            source.symbol !== undefined &&
+            source.symbol.declarations.length !== 0 &&
+            getConstraintOfType(c, source) === undefined) {
+            const syntheticParam = cloneTypeParameter(c, source);
+            syntheticParam.constraint = instantiateType(c, target, new SimpleTypeMapper(source, syntheticParam));
+            if (hasNonCircularBaseConstraint(c, syntheticParam)) {
+                this.relatedInfo.push(createDiagnosticForNode(source.symbol.declarations[0], 473 /* Diagnostics.This_type_parameter_might_need_an_extends_0_constraint */, [typeToString(c, target)]));
+            }
+        }
+    }
+    tryElaborateErrorsForPrimitivesAndObjects(source, target) {
+        const c = this.c;
+        if ((source === c.globalStringType && target === c.stringType) ||
+            (source === c.globalNumberType && target === c.numberType) ||
+            (source === c.globalBooleanType && target === c.booleanType))
+            this.reportError(824 /* Diagnostics.X_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible */, [
+                typeToString(c, target),
+                typeToString(c, source),
+            ]);
+    }
+    reportRelationError(message, source, target) {
+        const c = this.c;
+        const names = getTypeNamesForErrorDisplay(c, source, target);
+        const sourceType = names[0];
+        const targetType = names[1];
+        let generalizedSourceType = sourceType;
+        let generalizedSource = source;
+        // `never` targets keep the literal, for assertNever.
+        if ((target.flags & 262144 /* TypeFlags.Never */) === 0 &&
+            isLiteralType(source) &&
+            !typeCouldHaveTopLevelSingletonTypes(c, target)) {
+            generalizedSource = getBaseTypeOfLiteralType(c, source);
+            generalizedSourceType = typeToString(c, generalizedSource, undefined, 1 << 6);
+        }
+        const targetFlags = (target.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0 && (source.flags & 33554432 /* TypeFlags.IndexedAccess */) === 0
+            ? target.objectType.flags
+            : target.flags;
+        if ((targetFlags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
+            target !== c.markerSuperTypeForCheck &&
+            target !== c.markerSubTypeForCheck) {
+            const constraint = getBaseConstraintOfType(c, target);
+            if (constraint !== undefined && isTypeAssignableTo(c, generalizedSource, constraint))
+                this.reportError(1150 /* Diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2 */, [generalizedSourceType, targetType, typeToString(c, constraint)]);
+            else if (constraint !== undefined && isTypeAssignableTo(c, source, constraint))
+                this.reportError(1150 /* Diagnostics.X_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2 */, [sourceType, targetType, typeToString(c, constraint)]);
+            else {
+                // Reported once.
+                this.errorChain = undefined;
+                this.reportError(1157 /* Diagnostics.X_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1 */, [
+                    targetType,
+                    generalizedSourceType,
+                ]);
+            }
+        }
+        if (message === undefined) {
+            if (this.relation === c.comparableRelation)
+                message = 812 /* Diagnostics.Type_0_is_not_comparable_to_type_1 */;
+            else if (sourceType === targetType)
+                message =
+                    851 /* Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated */;
+            else if (c.exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(c, source, target).length !== 0)
+                message =
+                    549 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties */;
+            else {
+                if ((source.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && (target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+                    const suggested = getSuggestedTypeForNonexistentStringLiteralType(c, source, target);
+                    if (suggested !== undefined) {
+                        this.reportError(951 /* Diagnostics.Type_0_is_not_assignable_to_type_1_Did_you_mean_2 */, [
+                            generalizedSourceType,
+                            targetType,
+                            typeToString(c, suggested),
+                        ]);
+                        return;
+                    }
+                }
+                message = 500 /* Diagnostics.Type_0_is_not_assignable_to_type_1 */;
+            }
+        }
+        else if (message === 521 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 */ &&
+            c.exactOptionalPropertyTypes &&
+            getExactOptionalUnassignableProperties(c, source, target).length !== 0)
+            message =
+                553 /* Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties */;
+        switch (this.getChainMessage(0)) {
+            // Suppressed after an excess property error.
+            case 529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */:
+            case 715 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */:
+                return;
+            case 979 /* Diagnostics.Excessive_complexity_comparing_types_0_and_1 */:
+            case 499 /* Diagnostics.Excessive_stack_depth_comparing_types_0_and_1 */:
+            case 1090 /* Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1 */:
+                if (this.chainArgsMatch(generalizedSourceType, targetType, undefined))
+                    return;
+                break;
+            case 873 /* Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2 */:
+                if (!isConversionOrInterfaceImplementationMessage(message) &&
+                    this.chainArgsMatch(undefined, generalizedSourceType, targetType))
+                    return;
+                break;
+            case 872 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more */:
+            case 871 /* Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2 */:
+                if (!isConversionOrInterfaceImplementationMessage(message) &&
+                    this.chainArgsMatch(generalizedSourceType, targetType, undefined))
+                    return;
+                break;
+        }
+        this.reportError(message, [generalizedSourceType, targetType]);
+    }
+    reportError(message, args) {
+        if (message === 504 /* Diagnostics.Types_of_property_0_are_incompatible */) {
+            switch (this.getChainMessage(0)) {
+                case 529 /* Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1 */:
+                case 715 /* Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2 */:
+                    return;
+            }
+            // A property followed by a return type incompatibility becomes one message for `x()`.
+            let arg = '';
+            switch (this.getChainMessage(1)) {
+                case 469 /* Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */:
+                    arg = getPropertyNameArg(args[0]) + '()';
+                    break;
+                case 470 /* Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */:
+                    arg = 'new ' + getPropertyNameArg(args[0]) + '()';
+                    break;
+                case 467 /* Diagnostics.Call_signature_return_types_0_and_1_are_incompatible */:
+                    arg = getPropertyNameArg(args[0]) + '(...)';
+                    break;
+                case 468 /* Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible */:
+                    arg = 'new ' + getPropertyNameArg(args[0]) + '(...)';
+                    break;
+            }
+            if (arg !== '') {
+                message = 466 /* Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types */;
+                args = [arg];
+                this.errorChain = this.errorChain.next.next;
+            }
+            // Nested property incompatibilities become one message for `x.y`.
+            switch (this.getChainMessage(1)) {
+                case 504 /* Diagnostics.Types_of_property_0_are_incompatible */:
+                case 465 /* Diagnostics.The_types_of_0_are_incompatible_between_these_types */:
+                case 466 /* Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types */: {
+                    const head = getPropertyNameArg(args[0]);
+                    const tail = getPropertyNameArg(this.errorChain.next.args[0]);
+                    const dotted = addToDottedName(head, tail);
+                    this.errorChain = this.errorChain.next.next;
+                    if (message === 504 /* Diagnostics.Types_of_property_0_are_incompatible */)
+                        message = 465 /* Diagnostics.The_types_of_0_are_incompatible_between_these_types */;
+                    this.reportError(message, [dotted]);
+                    return;
+                }
+            }
+        }
+        this.errorChain = new ErrorChain(this.errorChain, message, args);
+    }
+    getChainMessage(index) {
+        let e = this.errorChain;
+        while (e !== undefined) {
+            if (index === 0)
+                return e.message;
+            e = e.next;
+            index--;
+        }
+        return undefined;
+    }
+    /** Whether the head's arguments match, with undefined as a wildcard. */
+    chainArgsMatch(a0, a1, a2) {
+        const args = this.errorChain.args;
+        return ((a0 === undefined || args[0] === a0) &&
+            (a1 === undefined || args[1] === a1) &&
+            (a2 === undefined || args[2] === a2));
+    }
+}
+function visibilityToString(flags) {
+    if (flags === 2 /* ModifierFlags.Private */)
+        return 'private';
+    if (flags === 4 /* ModifierFlags.Protected */)
+        return 'protected';
+    return 'public';
+}
+// ---- Helpers
+export function getNormalizedType(c, t, writing) {
+    for (;;) {
+        let n;
+        if (isFreshLiteralType(t))
+            n = t.regularType;
+        else if (isGenericTupleType(t))
+            n = getNormalizedTupleType(c, t, writing);
+        else if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && (t.flags & 1048576 /* TypeFlags.Object */) !== 0)
+            n =
+                t.node !== undefined
+                    ? createTypeReference(c, t.target, getTypeArguments(c, t))
+                    : (getSingleBaseForNonAugmentingSubtype(c, t) ?? t);
+        else if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0)
+            n = getNormalizedUnionOrIntersectionType(c, t, writing);
+        else if ((t.flags & 16777216 /* TypeFlags.Substitution */) !== 0)
+            n = writing ? t.baseType : getSubstitutionIntersection(c, t);
+        else if ((t.flags & 102760448 /* TypeFlags.Simplifiable */) !== 0)
+            n = getSimplifiedType(c, t, writing);
+        else
+            return t;
+        if (n === t)
+            return n;
+        t = n;
+    }
+}
+/** The one base of a class or interface reference that declares no members of its own, which it relates as. */
+export function getSingleBaseForNonAugmentingSubtype(c, t) {
+    if ((t.objectFlags & 4 /* ObjectFlags.Reference */) === 0 || (t.flags & 1048576 /* TypeFlags.Object */) === 0)
+        return undefined;
+    const reference = t;
+    if ((reference.target.objectFlags & 3 /* ObjectFlags.ClassOrInterface */) === 0)
+        return undefined;
+    const target = reference.target;
+    const key = cachedTypeKey(3 /* CachedTypeKind.EquivalentBaseType */, t.id);
+    const side = sideOf(c, t);
+    if ((side.objectFlags & 134217728 /* ObjectFlags.IdenticalBaseTypeCalculated */) !== 0)
+        return c.cachedTypesById.get(key);
+    side.objectFlags |= 134217728 /* ObjectFlags.IdenticalBaseTypeCalculated */;
+    if ((target.objectFlags & 1 /* ObjectFlags.Class */) !== 0) {
+        // Only base types named by simple qualified names; others may refer back to the class.
+        const declaration = target.symbol?.valueDeclaration;
+        const baseTypeNode = declaration !== undefined ? getExtendsHeritageClauseElement(declaration) : undefined;
+        if (baseTypeNode !== undefined) {
+            const expression = getExpression(baseTypeNode);
+            if (expression.kind !== 79 /* SyntaxKind.Identifier */ && expression.kind !== 212 /* SyntaxKind.PropertyAccessExpression */)
+                return undefined;
+        }
+    }
+    const bases = getBaseTypes(c, target);
+    if (bases.length !== 1)
+        return undefined;
+    // Members of its own may subtype members of the base, which needs a structural comparison.
+    if (t.symbol !== undefined && getMembersOfSymbol(c, t.symbol).size !== 0)
+        return undefined;
+    const typeParameters = target.typeParameters();
+    const typeArguments = getTypeArguments(c, t);
+    let instantiatedBase = typeParameters.length === 0
+        ? bases[0]
+        : instantiateType(c, bases[0], newTypeMapper(typeParameters.slice(), typeArguments.slice(0, typeParameters.length)));
+    if (typeArguments.length > typeParameters.length)
+        instantiatedBase = getTypeWithThisArgument(c, instantiatedBase, typeArguments[typeArguments.length - 1], false);
+    c.cachedTypesById.set(key, instantiatedBase);
+    return instantiatedBase;
+}
+function getNormalizedUnionOrIntersectionType(c, t, writing) {
+    const reduced = getReducedType(c, t);
+    if (reduced !== t)
+        return reduced;
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && shouldNormalizeIntersection(c, t)) {
+        // Distributes `Partial<T>[K] & ({} | null)` and the like.
+        const types = typesOf(t);
+        let changed = false;
+        const normalized = [];
+        for (const u of types) {
+            const n = getNormalizedType(c, u, writing);
+            if (n !== u)
+                changed = true;
+            normalized.push(n);
+        }
+        if (changed)
+            return getIntersectionType(c, normalized);
+    }
+    return t;
+}
+function shouldNormalizeIntersection(c, t) {
+    let hasInstantiable = false;
+    let hasNullableOrEmpty = false;
+    for (const u of typesOf(t)) {
+        hasInstantiable = hasInstantiable || (u.flags & 132644864 /* TypeFlags.Instantiable */) !== 0;
+        hasNullableOrEmpty = hasNullableOrEmpty || (u.flags & 12 /* TypeFlags.Nullable */) !== 0 || isEmptyAnonymousObjectType(c, u);
+        if (hasInstantiable && hasNullableOrEmpty)
+            return true;
+    }
+    return false;
+}
+function getNormalizedTupleType(c, t, writing) {
+    const elements = getElementTypes(c, t);
+    let changed = false;
+    const normalized = [];
+    for (const e of elements) {
+        const n = (e.flags & 102760448 /* TypeFlags.Simplifiable */) !== 0 ? getSimplifiedType(c, e, writing) : e;
+        if (n !== e)
+            changed = true;
+        normalized.push(n);
+    }
+    return changed ? createNormalizedTypeReference(c, t.target, normalized) : t;
+}
+export function isWeakType(c, t) {
+    if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+        const resolved = resolveStructuredTypeMembers(c, t);
+        return (resolved.callSignatures.length === 0 &&
+            resolved.constructSignatures.length === 0 &&
+            resolved.indexInfos.length === 0 &&
+            hasResolvedProperties(resolved) &&
+            resolvedPropertiesAreOptional(resolved));
+    }
+    if ((t.flags & 16777216 /* TypeFlags.Substitution */) !== 0)
+        return isWeakType(c, t.baseType);
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (!isWeakType(c, u))
+                return false;
+        return true;
+    }
+    return false;
+}
+function hasCommonProperties(c, source, target, isComparingJsxAttributes) {
+    for (const prop of getPropertiesOfType(c, source))
+        if (isKnownProperty(c, target, prop.name, isComparingJsxAttributes))
+            return true;
+    return false;
+}
+/** Whether `name` is known anywhere in `targetType`: declared, covered by an index signature, or in some constituent. */
+export function isKnownProperty(c, targetType, name, isComparingJsxAttributes) {
+    if ((targetType.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+        if (getPropertyOfObjectType(c, targetType, name) !== undefined ||
+            getApplicableIndexInfoForName(c, targetType, name) !== undefined ||
+            (isLateBoundName(name) && getIndexInfoOfType(c, targetType, c.stringType) !== undefined) ||
+            (isComparingJsxAttributes && name.includes('-')))
+            return true;
+    }
+    if ((targetType.flags & 16777216 /* TypeFlags.Substitution */) !== 0)
+        return isKnownProperty(c, targetType.baseType, name, isComparingJsxAttributes);
+    if ((targetType.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0 && isExcessPropertyCheckTarget(targetType))
+        for (const t of typesOf(targetType))
+            if (isKnownProperty(c, t, name, isComparingJsxAttributes))
+                return true;
+    return false;
+}
+function isExcessPropertyCheckTarget(t) {
+    if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0)
+        return (t.objectFlags & 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */) === 0;
+    if ((t.flags & 131072 /* TypeFlags.NonPrimitive */) !== 0)
+        return true;
+    if ((t.flags & 16777216 /* TypeFlags.Substitution */) !== 0)
+        return isExcessPropertyCheckTarget(t.baseType);
+    if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const u of typesOf(t))
+            if (isExcessPropertyCheckTarget(u))
+                return true;
+        return false;
+    }
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (!isExcessPropertyCheckTarget(u))
+                return false;
+        return true;
+    }
+    return false;
+}
+function shouldCheckAsExcessProperty(prop, container) {
+    return (prop.valueDeclaration !== undefined &&
+        container !== undefined &&
+        container.valueDeclaration !== undefined &&
+        prop.valueDeclaration.parent === container.valueDeclaration);
+}
+function isIgnoredJsxProperty(source, prop) {
+    return (source.objectFlags & 2048 /* ObjectFlags.JsxAttributes */) !== 0 && prop.name.includes('-');
+}
+function isObjectLiteralElement(node) {
+    switch (node.kind) {
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 305 /* SyntaxKind.SpreadAssignment */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            return true;
+    }
+    return false;
+}
+function isAncestor(node, ancestor) {
+    for (let n = node; n !== undefined; n = n.parent)
+        if (n === ancestor)
+            return true;
+    return false;
+}
+function rootOf(node) {
+    let n = node;
+    while (n.parent !== undefined)
+        n = n.parent;
+    return n;
+}
+function sameFile(a, b) {
+    return b !== undefined && rootOf(a) === rootOf(b);
+}
+export function isTypeSubsetOf(c, source, target) {
+    return (source === target ||
+        (source.flags & 262144 /* TypeFlags.Never */) !== 0 ||
+        ((target.flags & 134217728 /* TypeFlags.Union */) !== 0 && isTypeSubsetOfUnion(c, source, target)));
+}
+function isTypeSubsetOfUnion(c, source, target) {
+    const union = target;
+    if ((source.flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return unionContainsSortedTypes(c, union, typesOf(source));
+    if ((source.flags & 98304 /* TypeFlags.EnumLike */) !== 0 && getBaseTypeOfEnumLikeType(c, source) === target)
+        return true;
+    return unionContainsType(c, union, source);
+}
+function getTypeOfPropertyInTypes(c, types, name) {
+    const propTypes = [];
+    for (const t of types)
+        propTypes.push(getTypeOfPropertyInType(c, t, name));
+    return getUnionType(c, propTypes);
+}
+function getTypeOfPropertyInType(c, t, name) {
+    t = getApparentType(c, t);
+    const prop = (t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0
+        ? getPropertyOfUnionOrIntersectionType(c, t, name, false)
+        : getPropertyOfObjectType(c, t, name);
+    if (prop !== undefined)
+        return getTypeOfSymbol(c, prop);
+    const indexInfo = getApplicableIndexInfoForName(c, t, name);
+    return indexInfo !== undefined ? indexInfo.valueType : c.undefinedType;
+}
+export function getRegularTypeOfObjectLiteral(c, t) {
+    return getRegularTypeOfObjectLiteralLazy(c, t);
+}
+import { getRegularTypeOfObjectLiteral as getRegularTypeOfObjectLiteralLazy, getLiteralTypeFromPropertyForRelations as getLiteralTypeFromPropertyLazy, } from './checker-literals.js';
+function filterPrimitivesIfContainsNonPrimitive(c, t) {
+    if (typesOf(t).some((u) => (u.flags & 131072 /* TypeFlags.NonPrimitive */) !== 0)) {
+        const result = filterType(c, t, (u) => (u.flags & 12713980 /* TypeFlags.Primitive */) === 0);
+        if ((result.flags & 262144 /* TypeFlags.Never */) === 0)
+            return result;
+    }
+    return t;
+}
+function findMatchingDiscriminantType(c, source, target, relater) {
+    if ((target.flags & 134217728 /* TypeFlags.Union */) === 0 || (source.flags & (268435456 /* TypeFlags.Intersection */ | 1048576 /* TypeFlags.Object */)) === 0)
+        return undefined;
+    const match = getMatchingUnionConstituentForType(c, target, source);
+    if (match !== undefined)
+        return match;
+    const discriminants = [];
+    for (const p of getPropertiesOfType(c, source))
+        if (isDiscriminantProperty(c, target, p.name))
+            discriminants.push(p);
+    if (discriminants.length === 0)
+        return undefined;
+    const discriminated = discriminateTypeByDiscriminants(c, target, discriminants, relater);
+    return discriminated !== target ? discriminated : undefined;
+}
+/**
+ * The constituents of the union `target` whose types of each discriminant property the source's
+ * values relate to (discriminateTypeByDiscriminableItems). Primitive and never constituents are left
+ * out. A discriminant that no remaining constituent matches is ignored, so the result is never empty.
+ */
+function discriminateTypeByDiscriminants(c, target, discriminants, relater) {
+    const types = typesOf(target);
+    const include = [];
+    for (const t of types)
+        include.push((t.flags & 12713980 /* TypeFlags.Primitive */) === 0 && (getReducedType(c, t).flags & 262144 /* TypeFlags.Never */) === 0
+            ? -1 /* Ternary.True */
+            : 0 /* Ternary.False */);
+    for (const prop of discriminants) {
+        let matched = false;
+        for (let i = 0; i < types.length; i++) {
+            if (include[i] === 0 /* Ternary.False */)
+                continue;
+            const targetType = getTypeOfPropertyOrIndexSignatureOfType(c, types[i], prop.name);
+            if (targetType === undefined)
+                continue;
+            if (someType(getTypeOfSymbol(c, prop), (s) => relater.isRelatedToSimple(s, targetType) !== 0 /* Ternary.False */))
+                matched = true;
+            else
+                include[i] = 3 /* Ternary.Maybe */;
+        }
+        // Without a match the discriminant is ignored.
+        for (let i = 0; i < types.length; i++)
+            if (include[i] === 3 /* Ternary.Maybe */)
+                include[i] = matched ? 0 /* Ternary.False */ : -1 /* Ternary.True */;
+    }
+    if (!include.includes(0 /* Ternary.False */))
+        return target;
+    const filtered = [];
+    for (let i = 0; i < types.length; i++)
+        if (include[i] === -1 /* Ternary.True */)
+            filtered.push(types[i]);
+    const result = getUnionTypeEx(c, filtered, 0 /* UnionReduction.None */, undefined, undefined);
+    return (result.flags & 262144 /* TypeFlags.Never */) === 0 ? result : target;
+}
+function getTypeOfPropertyOrIndexSignatureOfType(c, t, name) {
+    const propType = getTypeOfPropertyOfType(c, t, name);
+    if (propType !== undefined)
+        return propType;
+    const info = getApplicableIndexInfoForName(c, t, name);
+    return info !== undefined ? getOptionalType(c, info.valueType, true) : undefined;
+}
+export function isDiscriminantProperty(c, t, name) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return false;
+    const prop = getUnionOrIntersectionProperty(c, t, name, false);
+    if (prop === undefined || (prop.checkFlags & 2 /* CheckFlags.SyntheticProperty */) === 0)
+        return false;
+    if ((prop.checkFlags & 2097152 /* CheckFlags.IsDiscriminantComputed */) === 0) {
+        prop.checkFlags |= 2097152 /* CheckFlags.IsDiscriminantComputed */;
+        if ((prop.checkFlags & 192 /* CheckFlags.NonUniformAndLiteral */) === 192 /* CheckFlags.NonUniformAndLiteral */ &&
+            !isGenericTypeLocal(c, getTypeOfSymbol(c, prop)))
+            prop.checkFlags |= 4194304 /* CheckFlags.IsDiscriminant */;
+    }
+    return (prop.checkFlags & 4194304 /* CheckFlags.IsDiscriminant */) !== 0;
+}
+import { isGenericType as isGenericTypeLocal } from './checker-type-operators.js';
+/** The constituent selected by a key property's unit type; not computed yet. */
+export function getMatchingUnionConstituentForType(_c, _unionType, _t) {
+    return undefined;
+}
+/** The constituent of the union `target` that `source` most likely meant, for error elaboration. */
+export function getBestMatchingTypeForElaboration(c, source, target) {
+    return getBestMatchingType(c, source, target, new Relater(c, c.assignableRelation, undefined));
+}
+function getBestMatchingType(c, source, target, relater) {
+    return (findMatchingDiscriminantType(c, source, target, relater) ??
+        findMatchingTypeReferenceOrTypeAliasReference(source, target) ??
+        findBestTypeForObjectLiteral(c, source, target) ??
+        findBestTypeForInvokable(c, source, target, 0 /* SignatureKind.Call */) ??
+        findBestTypeForInvokable(c, source, target, 1 /* SignatureKind.Construct */) ??
+        findMostOverlappyType(c, source, target));
+}
+function findMatchingTypeReferenceOrTypeAliasReference(source, unionTarget) {
+    const sourceObjectFlags = source.objectFlags;
+    if ((sourceObjectFlags & (4 /* ObjectFlags.Reference */ | 16 /* ObjectFlags.Anonymous */)) === 0 ||
+        (source.flags & 1048576 /* TypeFlags.Object */) === 0 ||
+        (unionTarget.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return undefined;
+    for (const target of typesOf(unionTarget)) {
+        if ((target.flags & 1048576 /* TypeFlags.Object */) === 0)
+            continue;
+        const overlap = sourceObjectFlags & target.objectFlags;
+        if ((overlap & 4 /* ObjectFlags.Reference */) !== 0 &&
+            source.target === target.target)
+            return target;
+        if ((overlap & 16 /* ObjectFlags.Anonymous */) !== 0 &&
+            source.alias !== undefined &&
+            target.alias !== undefined &&
+            source.alias.symbol === target.alias.symbol)
+            return target;
+    }
+    return undefined;
+}
+function findBestTypeForInvokable(c, source, unionTarget, kind) {
+    if (getSignaturesOfType(c, source, kind).length === 0)
+        return undefined;
+    for (const t of typesOf(unionTarget))
+        if (getSignaturesOfType(c, t, kind).length !== 0)
+            return t;
+    return undefined;
+}
+function findMostOverlappyType(c, source, unionTarget) {
+    if ((source.flags & (12713980 /* TypeFlags.Primitive */ | 14680064 /* TypeFlags.InstantiablePrimitive */)) !== 0)
+        return undefined;
+    let bestMatch;
+    let matchingCount = 0;
+    for (const target of typesOf(unionTarget)) {
+        if ((target.flags & (12713980 /* TypeFlags.Primitive */ | 14680064 /* TypeFlags.InstantiablePrimitive */)) !== 0)
+            continue;
+        const overlap = getIntersectionType(c, [getIndexType(c, source), getIndexType(c, target)]);
+        if ((overlap.flags & 2097152 /* TypeFlags.Index */) !== 0)
+            return target;
+        if (isUnitType(overlap) || (overlap.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            const length = (overlap.flags & 134217728 /* TypeFlags.Union */) !== 0 ? countUnitTypes(typesOf(overlap)) : 1;
+            if (length >= matchingCount) {
+                bestMatch = target;
+                matchingCount = length;
+            }
+        }
+    }
+    return bestMatch;
+}
+function symbolNames(c, symbols) {
+    const names = [];
+    for (const s of symbols)
+        names.push(symbolToString(c, s));
+    return names.join(', ');
+}
+function countUnitTypes(types) {
+    let count = 0;
+    for (const t of types)
+        if (isUnitType(t))
+            count++;
+    return count;
+}
+function findBestTypeForObjectLiteral(c, source, unionTarget) {
+    if ((source.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) !== 0 && someType(unionTarget, (t) => isArrayLikeType(c, t)))
+        for (const t of typesOf(unionTarget))
+            if (!isArrayLikeType(c, t))
+                return t;
+    return undefined;
+}
+function shouldReportUnmatchedPropertyError(c, source, target) {
+    const calls = getSignaturesOfStructuredType(c, source, 0 /* SignatureKind.Call */);
+    const constructs = getSignaturesOfStructuredType(c, source, 1 /* SignatureKind.Construct */);
+    const properties = getPropertiesOfObjectType(c, source);
+    if ((calls.length !== 0 || constructs.length !== 0) && properties.length === 0)
+        return ((getSignaturesOfType(c, target, 0 /* SignatureKind.Call */).length !== 0 && calls.length !== 0) ||
+            (getSignaturesOfType(c, target, 1 /* SignatureKind.Construct */).length !== 0 && constructs.length !== 0));
+    return true;
+}
+function isStaticPrivateIdentifierProperty(prop) {
+    const d = prop.valueDeclaration;
+    if (d === undefined)
+        return false;
+    const name = getName(d);
+    return (name !== undefined &&
+        name.kind === 80 /* SyntaxKind.PrivateIdentifier */ &&
+        (getCombinedModifierFlags(d) & 256 /* ModifierFlags.Static */) !== 0);
+}
+export function getUnmatchedProperty(c, source, target, requireOptionalProperties, matchDiscriminantProperties) {
+    for (const targetProp of getPropertiesOfType(c, target))
+        if (isUnmatchedProperty(c, source, targetProp, requireOptionalProperties, matchDiscriminantProperties))
+            return targetProp;
+    return undefined;
+}
+/** Whether `getUnmatchedProperty` reports `targetProp`, a property of the target. */
+export function isUnmatchedProperty(c, source, targetProp, requireOptionalProperties, matchDiscriminantProperties) {
+    if (isStaticPrivateIdentifierProperty(targetProp))
+        return false;
+    if (!requireOptionalProperties &&
+        ((targetProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0 || (targetProp.checkFlags & 48 /* CheckFlags.Partial */) !== 0))
+        return false;
+    const sourceProp = getPropertyOfType(c, source, targetProp.name);
+    if (sourceProp === undefined)
+        return true;
+    if (!matchDiscriminantProperties)
+        return false;
+    // A unit-typed (discriminant) property whose literal differs in the source is unmatched.
+    const targetType = getTypeOfSymbol(c, targetProp);
+    if ((targetType.flags & 97292 /* TypeFlags.Unit */) === 0)
+        return false;
+    const sourceType = getTypeOfSymbol(c, sourceProp);
+    return !((sourceType.flags & 1 /* TypeFlags.Any */) !== 0 ||
+        getRegularTypeOfLiteralType(c, sourceType) === getRegularTypeOfLiteralType(c, targetType));
+}
+export function getUnmatchedProperties(c, source, target, requireOptionalProperties) {
+    const result = [];
+    for (const targetProp of getPropertiesOfType(c, target)) {
+        if (isStaticPrivateIdentifierProperty(targetProp))
+            continue;
+        if (requireOptionalProperties ||
+            ((targetProp.flags & 16777216 /* SymbolFlags.Optional */) === 0 && (targetProp.checkFlags & 48 /* CheckFlags.Partial */) === 0))
+            if (getPropertyOfType(c, source, targetProp.name) === undefined)
+                result.push(targetProp);
+    }
+    return result;
+}
+function getDeclaringClass(c, prop) {
+    return prop.parent !== undefined && (prop.parent.flags & 32 /* SymbolFlags.Class */) !== 0
+        ? getDeclaredTypeOfSymbol(c, getParentOfSymbol(c, prop))
+        : undefined;
+}
+/** Whether `sourceProp`'s class derives from `targetProp`'s, for protected members. */
+/** Whether every protected constituent of `targetProp` is declared in a base of a class declaring `sourceProp`. */
+function isValidOverrideOf(c, sourceProp, targetProp) {
+    return !forEachProperty(c, targetProp, (tp) => (getDeclarationModifierFlagsFromSymbol(c, tp, false) & 4 /* ModifierFlags.Protected */) !== 0 &&
+        !isPropertyInClassDerivedFrom(c, sourceProp, getDeclaringClass(c, tp)));
+}
+/** Whether some underlying property of `prop` is declared in a class deriving from `baseClass`. */
+function isPropertyInClassDerivedFrom(c, prop, baseClass) {
+    return forEachProperty(c, prop, (sp) => {
+        const sourceClass = getDeclaringClass(c, sp);
+        return sourceClass !== undefined && baseClass !== undefined && hasBaseType(c, sourceClass, baseClass);
+    });
+}
+/** Calls `callback` with a property, or with the underlying properties of a synthetic one, until it returns true. */
+function forEachProperty(c, prop, callback) {
+    if ((prop.checkFlags & 6 /* CheckFlags.Synthetic */) === 0)
+        return callback(prop);
+    const containingType = c.symbolContainingTypes.get(getSymbolId(prop));
+    if (containingType === undefined)
+        return false;
+    for (const t of typesOf(containingType)) {
+        const p = getPropertyOfType(c, t, prop.name);
+        if (p !== undefined && forEachProperty(c, p, callback))
+            return true;
+    }
+    return false;
+}
+export function isObjectTypeWithInferableIndex(c, t) {
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (!isObjectTypeWithInferableIndex(c, u))
+                return false;
+        return true;
+    }
+    return ((t.symbol !== undefined &&
+        (t.symbol.flags &
+            (4096 /* SymbolFlags.ObjectLiteral */ | 2048 /* SymbolFlags.TypeLiteral */ | 384 /* SymbolFlags.Enum */ | 512 /* SymbolFlags.ValueModule */)) !==
+            0 &&
+        (t.symbol.flags & 32 /* SymbolFlags.Class */) === 0 &&
+        !typeHasCallOrConstructSignatures(c, t)) ||
+        (t.objectFlags & (4096 /* ObjectFlags.JSLiteral */ | 8388608 /* ObjectFlags.ObjectRestType */)) !== 0 ||
+        // A reverse mapped type has an inferable index when its source does.
+        ((t.objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0 &&
+            t.source !== undefined &&
+            isObjectTypeWithInferableIndex(c, t.source)));
+}
+export function typeHasCallOrConstructSignatures(c, t) {
+    if ((t.flags & 403701760 /* TypeFlags.StructuredType */) === 0)
+        return false;
+    const resolved = resolveStructuredTypeMembers(c, t);
+    return resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0;
+}
+/** Both names of the pair, fully qualified when they print the same. */
+export function getTypeNamesForErrorDisplay(c, left, right) {
+    // The type of an expression that isn't context sensitive prints as written there.
+    let leftStr = typeToString(c, left, contextFreeExpressionDeclaration(c, left));
+    let rightStr = typeToString(c, right, contextFreeExpressionDeclaration(c, right));
+    if (leftStr === rightStr) {
+        leftStr = typeToString(c, left, undefined, 1 << 6);
+        rightStr = typeToString(c, right, undefined, 1 << 6);
+    }
+    return [leftStr, rightStr];
+}
+function contextFreeExpressionDeclaration(c, t) {
+    const declaration = t.symbol?.valueDeclaration;
+    if (declaration === undefined)
+        return undefined;
+    switch (declaration.kind) {
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 227 /* SyntaxKind.BinaryExpression */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+            return isContextSensitive(c, declaration) ? undefined : declaration;
+    }
+    return undefined;
+}
+function typeCouldHaveTopLevelSingletonTypes(c, t) {
+    if ((t.flags & 256 /* TypeFlags.Boolean */) !== 0)
+        return false;
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (typeCouldHaveTopLevelSingletonTypes(c, u))
+                return true;
+        return false;
+    }
+    if ((t.flags & 132644864 /* TypeFlags.Instantiable */) !== 0) {
+        const constraint = getConstraintOfType(c, t);
+        if (constraint !== undefined && constraint !== t)
+            return typeCouldHaveTopLevelSingletonTypes(c, constraint);
+    }
+    return isUnitType(t) || (t.flags & (4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0;
+}
+/**
+ * Puts `t` at `stack[depth]`. Recursion stacks keep their entries from `depth` on as stale slots,
+ * which avoids releasing an entry on every pop.
+ */
+export function setStackEntry(stack, depth, t) {
+    if (depth < stack.length)
+        stack[depth] = t;
+    else
+        stack.push(t);
+}
+/**
+ * Deeply nested: `maxDepth` or more same-identity types in `stack[0..depth)`, each newer than the
+ * last.
+ */
+export function isDeeplyNestedType(c, t, stack, depth, maxDepth) {
+    if (depth < maxDepth)
+        return false;
+    if ((t.objectFlags & 96 /* ObjectFlags.InstantiatedMapped */) === 96 /* ObjectFlags.InstantiatedMapped */ &&
+        (t.flags & 1048576 /* TypeFlags.Object */) !== 0)
+        t = getMappedTargetWithSymbol(c, t);
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+        for (const u of typesOf(t))
+            if (isDeeplyNestedType(c, u, stack, depth, maxDepth))
+                return true;
+    const identity = getRecursionIdentity(t);
+    let count = 0;
+    let lastTypeId = 0;
+    for (let i = 0; i < depth; i++) {
+        const s = stack[i];
+        if (hasMatchingRecursionIdentity(c, s, identity)) {
+            if (s.id >= lastTypeId) {
+                count++;
+                if (count >= maxDepth)
+                    return true;
+            }
+            lastTypeId = s.id;
+        }
+    }
+    return false;
+}
+function getMappedTargetWithSymbol(c, t) {
+    for (;;) {
+        if ((t.objectFlags & 96 /* ObjectFlags.InstantiatedMapped */) === 96 /* ObjectFlags.InstantiatedMapped */ &&
+            (t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+            const target = getModifiersTypeFromMappedType(c, t);
+            if (target.symbol !== undefined ||
+                ((target.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && typesOf(target).some((u) => u.symbol !== undefined))) {
+                t = target;
+                continue;
+            }
+        }
+        return t;
+    }
+}
+function hasMatchingRecursionIdentity(c, t, identity) {
+    if ((t.objectFlags & 96 /* ObjectFlags.InstantiatedMapped */) === 96 /* ObjectFlags.InstantiatedMapped */ &&
+        (t.flags & 1048576 /* TypeFlags.Object */) !== 0)
+        t = getMappedTargetWithSymbol(c, t);
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (hasMatchingRecursionIdentity(c, u, identity))
+                return true;
+        return false;
+    }
+    return getRecursionIdentity(t) === identity;
+}
+/** An identity shared by instantiations of a type, so infinitely expanding instantiations can be detected. */
+export function getRecursionIdentity(t) {
+    if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+        (t.objectFlags & (128 /* ObjectFlags.ObjectLiteral */ | 16384 /* ObjectFlags.ArrayLiteral */)) === 0) {
+        if ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && t.node !== undefined)
+            return nodeRecursionId(t.node);
+        if (t.symbol !== undefined &&
+            !((t.objectFlags & 16 /* ObjectFlags.Anonymous */) !== 0 && (t.symbol.flags & 32 /* SymbolFlags.Class */) !== 0) &&
+            (t.objectFlags & 1073741824 /* ObjectFlags.FromTypeNode */) === 0)
+            return symbolRecursionId(t.symbol);
+        if (isTupleType(t) && (t.objectFlags & 1073741824 /* ObjectFlags.FromTypeNode */) === 0)
+            return typeRecursionId(t.target);
+    }
+    if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && t.symbol !== undefined)
+        return symbolRecursionId(t.symbol);
+    if ((t.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+        let objectType = t.objectType;
+        while ((objectType.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0)
+            objectType = objectType.objectType;
+        return typeRecursionId(objectType);
+    }
+    if ((t.flags & 67108864 /* TypeFlags.Conditional */) !== 0)
+        return nodeRecursionId(t.root.node);
+    return typeRecursionId(t);
+}
+function nodeRecursionId(node) {
+    return getNodeId(node) * 4 + 1;
+}
+function symbolRecursionId(symbol) {
+    return getSymbolId(symbol) * 4 + 2;
+}
+function typeRecursionId(t) {
+    return t.id * 4 + 3;
+}
+// ---- Variance
+export function isMarkerType(c, t) {
+    return c.markerTypes.has(t);
+}
+export function getVariances(c, t) {
+    // Arrays and tuples are covariant.
+    if (t === c.globalArrayType || t === c.globalReadonlyArrayType || (t.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0)
+        return c.arrayVariances;
+    return getVariancesWorker(c, t.symbol, t.typeParameters());
+}
+export function getAliasVariances(c, symbol) {
+    return getVariancesWorker(c, symbol, c.symbolLinks(symbol).typeParameters ?? emptyTypes);
+}
+/**
+ * The measured variance of each type parameter, from relating marker instantiations; empty when
+ * requested recursively.
+ */
+function getVariancesWorker(c, symbol, typeParameters) {
+    const links = c.symbolLinks(symbol);
+    if (links.variances !== undefined)
+        return links.variances;
+    const oldVarianceComputation = c.inVarianceComputation;
+    const saveResolutionStart = c.resolutionStart;
+    if (!c.inVarianceComputation) {
+        c.inVarianceComputation = true;
+        c.resolutionStart = c.resolutionDepth;
+    }
+    links.variances = [];
+    const variances = [];
+    for (const tp of typeParameters) {
+        const modifiers = getTypeParameterModifiers(tp);
+        let variance;
+        if ((modifiers & 16384 /* ModifierFlags.Out */) !== 0)
+            variance = (modifiers & 8192 /* ModifierFlags.In */) !== 0 ? 0 /* VarianceFlags.Invariant */ : 1 /* VarianceFlags.Covariant */;
+        else if ((modifiers & 8192 /* ModifierFlags.In */) !== 0)
+            variance = 2 /* VarianceFlags.Contravariant */;
+        else {
+            const saveReliabilityFlags = c.reliabilityFlags;
+            c.reliabilityFlags = 0;
+            const typeWithSuper = createMarkerType(c, symbol, tp, c.markerSuperType);
+            const typeWithSub = createMarkerType(c, symbol, tp, c.markerSubType);
+            variance =
+                (isTypeAssignableTo(c, typeWithSub, typeWithSuper) ? 1 /* VarianceFlags.Covariant */ : 0) |
+                    (isTypeAssignableTo(c, typeWithSuper, typeWithSub) ? 2 /* VarianceFlags.Contravariant */ : 0);
+            // Bivariance may mean the parameter is unwitnessed.
+            if (variance === 3 /* VarianceFlags.Bivariant */ &&
+                isTypeAssignableTo(c, createMarkerType(c, symbol, tp, c.markerOtherType), typeWithSuper))
+                variance = 4 /* VarianceFlags.Independent */;
+            if ((c.reliabilityFlags & 8 /* RelationComparisonResult.ReportsUnmeasurable */) !== 0)
+                variance |= 8 /* VarianceFlags.Unmeasurable */;
+            if ((c.reliabilityFlags & 16 /* RelationComparisonResult.ReportsUnreliable */) !== 0)
+                variance |= 16 /* VarianceFlags.Unreliable */;
+            c.reliabilityFlags = saveReliabilityFlags;
+        }
+        variances.push(variance);
+    }
+    if (!oldVarianceComputation) {
+        c.inVarianceComputation = false;
+        c.resolutionStart = saveResolutionStart;
+    }
+    links.variances = variances;
+    return variances;
+}
+export function createMarkerType(c, symbol, source, target) {
+    const mapper = new SimpleTypeMapper(source, target);
+    const t = getDeclaredTypeOfSymbol(c, symbol);
+    if (isErrorType(c, t))
+        return t;
+    const typeArguments = [];
+    const typeParameters = (symbol.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0
+        ? (c.symbolLinks(symbol).typeParameters ?? emptyTypes)
+        : t.typeParameters();
+    for (const p of typeParameters)
+        typeArguments.push(instantiateType(c, p, mapper));
+    const result = (symbol.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0
+        ? getTypeAliasInstantiation(c, symbol, typeArguments, undefined)
+        : createTypeReference(c, t, typeArguments);
+    c.markerTypes.add(result);
+    return result;
+}
+import { getTypeAliasInstantiation } from './checker-type-nodes.js';
+export function getTypeParameterModifiers(tp) {
+    let flags = 0;
+    if (tp.symbol !== undefined)
+        for (const d of tp.symbol.declarations)
+            flags |= getCombinedModifierFlags(d);
+    return flags & (8192 /* ModifierFlags.In */ | 16384 /* ModifierFlags.Out */ | 4096 /* ModifierFlags.Const */);
+}
+function someVarianceHasFlags(variances, flags) {
+    for (const v of variances)
+        if ((v & flags) !== 0)
+            return true;
+    return false;
+}
+function someVarianceIsInvariant(variances) {
+    for (const v of variances)
+        if ((v & 7 /* VarianceFlags.VarianceMask */) === 0 /* VarianceFlags.Invariant */)
+            return true;
+    return false;
+}
+function hasCovariantVoidArgument(typeArguments, variances) {
+    for (let i = 0; i < variances.length; i++)
+        if ((variances[i] & 7 /* VarianceFlags.VarianceMask */) === 1 /* VarianceFlags.Covariant */ &&
+            (typeArguments[i].flags & 16 /* TypeFlags.Void */) !== 0)
+            return true;
+    return false;
+}
+// ---- Misc structural helpers
+function getEffectiveConstraintOfIntersection(c, types, targetIsUnion) {
+    let constraints;
+    let hasDisjointDomainType = false;
+    for (const t of types) {
+        if ((t.flags & 132644864 /* TypeFlags.Instantiable */) !== 0) {
+            // Follow constraints known not to be circular.
+            let constraint = getConstraintOfType(c, t);
+            while (constraint !== undefined &&
+                (constraint.flags & (524288 /* TypeFlags.TypeParameter */ | 2097152 /* TypeFlags.Index */ | 67108864 /* TypeFlags.Conditional */)) !== 0)
+                constraint = getConstraintOfType(c, constraint);
+            if (constraint !== undefined) {
+                if (constraints === undefined)
+                    constraints = [];
+                constraints.push(constraint);
+                if (targetIsUnion)
+                    constraints.push(t);
+            }
+        }
+        else if ((t.flags & 12812284 /* TypeFlags.DisjointDomains */) !== 0 || isEmptyAnonymousObjectType(c, t))
+            hasDisjointDomainType = true;
+    }
+    if (constraints !== undefined && (targetIsUnion || hasDisjointDomainType)) {
+        if (hasDisjointDomainType)
+            for (const t of types)
+                if ((t.flags & 12812284 /* TypeFlags.DisjointDomains */) !== 0 || isEmptyAnonymousObjectType(c, t))
+                    constraints.push(t);
+        return getNormalizedType(c, getIntersectionTypeEx(c, constraints, 2 /* IntersectionFlags.NoConstraintReduction */, undefined), false);
+    }
+    return undefined;
+}
+function isSourceIntersectionNeedingExtraCheck(c, source, target) {
+    return ((source.flags & 268435456 /* TypeFlags.Intersection */) !== 0 &&
+        (getApparentType(c, source).flags & 403701760 /* TypeFlags.StructuredType */) !== 0 &&
+        !typesOf(source).some((t) => t === target || (t.objectFlags & 262144 /* ObjectFlags.NonInferrableType */) !== 0));
+}
+function isNonGenericObjectType(c, t) {
+    return (t.flags & 1048576 /* TypeFlags.Object */) !== 0 && !isGenericMappedType(c, t);
+}
+function isSingleElementGenericTupleType(t) {
+    return isGenericTupleType(t) && tupleTargetOf(t).elementInfos.length === 1;
+}
+function isMutableTupleType(t) {
+    return isTupleType(t) && !tupleTargetOf(t).readonly;
+}
+function getConstraintFromTypeParameterChecked(c, t) {
+    return getConstraintOfType(c, t);
+}
+function getKnownKeysOfTupleType(c, t) {
+    const target = tupleTargetOf(t);
+    const keys = [];
+    for (let i = 0; i < target.fixedLength; i++)
+        keys.push(getStringLiteralTypeLocal(c, String(i)));
+    keys.push(getIndexType(c, target.readonly ? c.globalReadonlyArrayType : c.globalArrayType));
+    return getUnionType(c, keys);
+}
+import { getStringLiteralType as getStringLiteralTypeLocal } from './checker-type-factory.js';
+function getSimplifiedTypeOrConstraint(c, t) {
+    const simplified = getSimplifiedType(c, t, false);
+    return simplified !== t ? simplified : getConstraintOfType(c, t);
+}
+function isDistributionDependent(c, t) {
+    const root = t.root;
+    const node = root.node;
+    return (root.isDistributive &&
+        (isTypeParameterPossiblyReferenced(c, root.checkType, node.trueType) ||
+            isTypeParameterPossiblyReferenced(c, root.checkType, node.falseType)));
+}
+function templateLiteralTypesDefinitelyUnrelated(source, target) {
+    const sourceStart = source.texts[0];
+    const targetStart = target.texts[0];
+    const sourceEnd = source.texts[source.texts.length - 1];
+    const targetEnd = target.texts[target.texts.length - 1];
+    return (!(sourceStart.length <= targetStart.length
+        ? targetStart.startsWith(sourceStart)
+        : sourceStart.startsWith(targetStart)) ||
+        !(sourceEnd.length <= targetEnd.length ? targetEnd.endsWith(sourceEnd) : sourceEnd.endsWith(targetEnd)));
+}
+/**
+ * Whether `source` starts and ends with the start and end texts of `target`, which a template literal
+ * source needs to match `target` (see inferFromLiteralPartsToTemplateLiteral) or to be identical to it.
+ */
+function templateLiteralTextsMayMatch(source, target) {
+    return (source.texts[0].startsWith(target.texts[0]) &&
+        source.texts[source.texts.length - 1].endsWith(target.texts[target.texts.length - 1]));
+}
+/**
+ * Whether string literal `text` passes inferTypesFromTemplateLiteralType's start and end text test
+ * against `target`, which it needs to match `target`.
+ */
+function stringLiteralTextMayMatch(text, target) {
+    const start = target.texts[0];
+    const end = target.texts[target.texts.length - 1];
+    return text.length >= start.length + end.length && text.startsWith(start) && text.endsWith(end);
+}
+function someTypeCouldContainTypeVariables(c, types) {
+    for (const t of types)
+        if (couldContainTypeVariables(c, t))
+            return true;
+    return false;
+}
+function isPartialMappedType(t) {
+    return ((t.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 &&
+        (t.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+        (getMappedTypeModifiers(t) & 4 /* MappedTypeModifiers.IncludeOptional */) !== 0);
+}
+export function isEmptyArrayLiteralType(c, t) {
+    if (!isArrayType(c, t))
+        return false;
+    const elementType = getTypeArguments(c, t)[0];
+    return c.strictNullChecks ? elementType === c.implicitNeverType : elementType === c.undefinedWideningType;
+}
+export function compareProperties(c, sourceProp, targetProp, compare) {
+    return comparePropertiesWith(c, sourceProp, targetProp, getComparer(c, compare));
+}
+/** Public properties match on name, optionality and type; non-public ones must share a declaration. */
+function comparePropertiesWith(c, sourceProp, targetProp, comparer) {
+    if (sourceProp === targetProp)
+        return -1 /* Ternary.True */;
+    const sourceAccessibility = getDeclarationModifierFlagsFromSymbol(c, sourceProp, false) & 6 /* ModifierFlags.NonPublicAccessibilityModifier */;
+    const targetAccessibility = getDeclarationModifierFlagsFromSymbol(c, targetProp, false) & 6 /* ModifierFlags.NonPublicAccessibilityModifier */;
+    if (sourceAccessibility !== targetAccessibility)
+        return 0 /* Ternary.False */;
+    if (sourceAccessibility !== 0) {
+        if (getTargetSymbol(c, sourceProp) !== getTargetSymbol(c, targetProp))
+            return 0 /* Ternary.False */;
+    }
+    else if ((sourceProp.flags & 16777216 /* SymbolFlags.Optional */) !== (targetProp.flags & 16777216 /* SymbolFlags.Optional */))
+        return 0 /* Ternary.False */;
+    if (isReadonlySymbol(c, sourceProp) !== isReadonlySymbol(c, targetProp))
+        return 0 /* Ternary.False */;
+    return comparer.compare(getNonMissingTypeOfSymbol(c, sourceProp), getNonMissingTypeOfSymbol(c, targetProp), false);
+}
+// ---- Signatures
+export function isSignatureAssignableTo(c, source, target, ignoreReturnTypes) {
+    return (compareSignaturesRelated(c, source, target, ignoreReturnTypes ? 4 /* SignatureCheckMode.IgnoreReturnTypes */ : 0 /* SignatureCheckMode.None */, false, getComparer(c, 2 /* ComparerKind.Assignable */), undefined) !== 0 /* Ternary.False */);
+}
+export function compareSignaturesRelated(c, source, target, checkMode, reportErrors, comparer, reportUnreliableMarkers) {
+    if (source === target)
+        return -1 /* Ternary.True */;
+    if (!((checkMode & 16 /* SignatureCheckMode.StrictTopSignature */) !== 0 && isTopSignature(c, source)) &&
+        isTopSignature(c, target))
+        return -1 /* Ternary.True */;
+    if ((checkMode & 16 /* SignatureCheckMode.StrictTopSignature */) !== 0 &&
+        isTopSignature(c, source) &&
+        !isTopSignature(c, target))
+        return 0 /* Ternary.False */;
+    const targetCount = getParameterCount(c, target);
+    const sourceHasMoreParameters = !hasEffectiveRestParameter(c, target) &&
+        ((checkMode & 8 /* SignatureCheckMode.StrictArity */) !== 0
+            ? hasEffectiveRestParameter(c, source) || getParameterCount(c, source) > targetCount
+            : getMinArgumentCount(c, source) > targetCount);
+    if (sourceHasMoreParameters) {
+        if (reportErrors && (checkMode & 8 /* SignatureCheckMode.StrictArity */) === 0)
+            comparer.report(969 /* Diagnostics.Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1 */, [
+                String(getMinArgumentCount(c, source)),
+                String(targetCount),
+            ]);
+        return 0 /* Ternary.False */;
+    }
+    if (source.typeParameters.length !== 0 && source.typeParameters !== target.typeParameters) {
+        target = getCanonicalSignature(c, target);
+        source = instantiateSignatureInContextOf(c, source, target, comparer);
+    }
+    const sourceCount = getParameterCount(c, source);
+    const sourceRestType = getNonArrayRestType(c, source);
+    const targetRestType = getNonArrayRestType(c, target);
+    if ((sourceRestType !== undefined || targetRestType !== undefined) && reportUnreliableMarkers !== undefined)
+        instantiateType(c, sourceRestType ?? targetRestType, reportUnreliableMarkers);
+    const kind = target.declaration !== undefined ? target.declaration.kind : 0 /* SyntaxKind.Unknown */;
+    const strictVariance = (checkMode & 3 /* SignatureCheckMode.Callback */) === 0 &&
+        c.strictFunctionTypes &&
+        kind !== 175 /* SyntaxKind.MethodDeclaration */ &&
+        kind !== 174 /* SyntaxKind.MethodSignature */ &&
+        kind !== 177 /* SyntaxKind.Constructor */;
+    let result = -1 /* Ternary.True */;
+    const sourceThisType = getThisTypeOfSignature(c, source);
+    if (sourceThisType !== undefined && sourceThisType !== c.voidType) {
+        const targetThisType = getThisTypeOfSignature(c, target);
+        if (targetThisType !== undefined) {
+            // void sources are assignable to anything.
+            let related = !strictVariance ? comparer.compare(sourceThisType, targetThisType, false) : 0 /* Ternary.False */;
+            if (related === 0 /* Ternary.False */)
+                related = comparer.compare(targetThisType, sourceThisType, reportErrors);
+            if (related === 0 /* Ternary.False */) {
+                if (reportErrors)
+                    comparer.report(818 /* Diagnostics.The_this_types_of_each_signature_are_incompatible */, []);
+                return 0 /* Ternary.False */;
+            }
+            result &= related;
+        }
+    }
+    const hasRest = sourceRestType !== undefined || targetRestType !== undefined;
+    const paramCount = hasRest ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
+    const restIndex = hasRest ? paramCount - 1 : -1;
+    for (let i = 0; i < paramCount; i++) {
+        const sourceType = i === restIndex ? getRestOrAnyTypeAtPosition(c, source, i) : tryGetTypeAtPosition(c, source, i);
+        const targetType = i === restIndex ? getRestOrAnyTypeAtPosition(c, target, i) : tryGetTypeAtPosition(c, target, i);
+        if (sourceType === undefined ||
+            targetType === undefined ||
+            (sourceType === targetType && (checkMode & 8 /* SignatureCheckMode.StrictArity */) === 0))
+            continue;
+        // Callback parameters relate covariantly; other parameters bivariantly unless strict.
+        const sourceSig = (checkMode & 3 /* SignatureCheckMode.Callback */) === 0 && !isInstantiatedGenericParameter(c, source, i)
+            ? getSingleCallSignature(c, getNonNullableType(c, sourceType))
+            : undefined;
+        const targetSig = (checkMode & 3 /* SignatureCheckMode.Callback */) === 0 && !isInstantiatedGenericParameter(c, target, i)
+            ? getSingleCallSignature(c, getNonNullableType(c, targetType))
+            : undefined;
+        const callbacks = sourceSig !== undefined &&
+            targetSig !== undefined &&
+            getTypePredicateOfSignature(c, sourceSig) === undefined &&
+            getTypePredicateOfSignature(c, targetSig) === undefined &&
+            getTypeFacts(c, sourceType, 50331648 /* TypeFacts.IsUndefinedOrNull */) ===
+                getTypeFacts(c, targetType, 50331648 /* TypeFacts.IsUndefinedOrNull */);
+        let related;
+        if (callbacks)
+            related = compareSignaturesRelated(c, targetSig, sourceSig, (checkMode & 8 /* SignatureCheckMode.StrictArity */) |
+                (strictVariance ? 2 /* SignatureCheckMode.StrictCallback */ : 1 /* SignatureCheckMode.BivariantCallback */), reportErrors, comparer, reportUnreliableMarkers);
+        else {
+            related =
+                (checkMode & 3 /* SignatureCheckMode.Callback */) === 0 && !strictVariance
+                    ? comparer.compare(sourceType, targetType, false)
+                    : 0 /* Ternary.False */;
+            if (related === 0 /* Ternary.False */)
+                related = comparer.compare(targetType, sourceType, reportErrors);
+        }
+        // With strict arity, `(x: number | undefined) => void` is a subtype of `(x?: number | undefined) => void`.
+        if (related !== 0 /* Ternary.False */ &&
+            (checkMode & 8 /* SignatureCheckMode.StrictArity */) !== 0 &&
+            i >= getMinArgumentCount(c, source) &&
+            i < getMinArgumentCount(c, target) &&
+            comparer.compare(sourceType, targetType, false) !== 0 /* Ternary.False */)
+            related = 0 /* Ternary.False */;
+        if (related === 0 /* Ternary.False */) {
+            if (reportErrors)
+                comparer.report(506 /* Diagnostics.Types_of_parameters_0_and_1_are_incompatible */, [
+                    getParameterNameAtPosition(c, source, i),
+                    getParameterNameAtPosition(c, target, i),
+                ]);
+            return 0 /* Ternary.False */;
+        }
+        result &= related;
+    }
+    if ((checkMode & 4 /* SignatureCheckMode.IgnoreReturnTypes */) === 0) {
+        // In-flight return type resolutions use `any`.
+        const targetReturnType = getNonCircularReturnTypeOfSignature(c, target);
+        if (targetReturnType === c.voidType || targetReturnType === c.anyType)
+            return result;
+        const sourceReturnType = getNonCircularReturnTypeOfSignature(c, source);
+        const targetTypePredicate = getTypePredicateOfSignature(c, target);
+        if (targetTypePredicate !== undefined) {
+            const sourceTypePredicate = getTypePredicateOfSignature(c, source);
+            if (sourceTypePredicate !== undefined)
+                result &= compareTypePredicateRelatedTo(c, sourceTypePredicate, targetTypePredicate, reportErrors, comparer);
+            else if (targetTypePredicate.kind === 1 /* TypePredicateKind.Identifier */ ||
+                targetTypePredicate.kind === 0 /* TypePredicateKind.This */) {
+                if (reportErrors)
+                    comparer.report(174 /* Diagnostics.Signature_0_must_be_a_type_predicate */, [signatureToString(c, source)]);
+                return 0 /* Ternary.False */;
+            }
+        }
+        else {
+            // Callback return types relate bivariantly to keep containing types covariant.
+            let related = (checkMode & 1 /* SignatureCheckMode.BivariantCallback */) !== 0
+                ? comparer.compare(targetReturnType, sourceReturnType, false)
+                : 0 /* Ternary.False */;
+            if (related === 0 /* Ternary.False */)
+                related = comparer.compare(sourceReturnType, targetReturnType, reportErrors);
+            result &= related;
+            if (result === 0 /* Ternary.False */ && reportErrors) {
+                // Markers for chain reduction in reportError; elided from output.
+                const construct = (source.flags & 4 /* SignatureFlags.Construct */) !== 0;
+                const message = source.parameters.length === 0 && target.parameters.length === 0
+                    ? construct
+                        ? 470 /* Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */
+                        : 469 /* Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1 */
+                    : construct
+                        ? 468 /* Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible */
+                        : 467 /* Diagnostics.Call_signature_return_types_0_and_1_are_incompatible */;
+                comparer.report(message, [typeToString(c, sourceReturnType), typeToString(c, targetReturnType)]);
+            }
+        }
+    }
+    return result;
+}
+function isInstantiatedGenericParameter(c, signature, pos) {
+    if (signature.target === undefined)
+        return false;
+    const t = tryGetTypeAtPosition(c, signature.target, pos);
+    return t !== undefined && isGenericTypeLocal(c, t);
+}
+function compareTypePredicateRelatedTo(c, source, target, reportErrors, comparer) {
+    if (source.kind !== target.kind) {
+        if (reportErrors) {
+            comparer.report(678 /* Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard */, []);
+            comparer.report(176 /* Diagnostics.Type_predicate_0_is_not_assignable_to_1 */, [
+                typePredicateToString(c, source),
+                typePredicateToString(c, target),
+            ]);
+        }
+        return 0 /* Ternary.False */;
+    }
+    if ((source.kind === 1 /* TypePredicateKind.Identifier */ || source.kind === 3 /* TypePredicateKind.AssertsIdentifier */) &&
+        source.parameterIndex !== target.parameterIndex) {
+        if (reportErrors) {
+            comparer.report(177 /* Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1 */, [
+                source.parameterName,
+                target.parameterName,
+            ]);
+            comparer.report(176 /* Diagnostics.Type_predicate_0_is_not_assignable_to_1 */, [
+                typePredicateToString(c, source),
+                typePredicateToString(c, target),
+            ]);
+        }
+        return 0 /* Ternary.False */;
+    }
+    let related;
+    if (source.type === target.type)
+        related = -1 /* Ternary.True */;
+    else if (source.type !== undefined && target.type !== undefined)
+        related = comparer.compare(source.type, target.type, reportErrors);
+    else
+        related = 0 /* Ternary.False */;
+    if (related === 0 /* Ternary.False */ && reportErrors)
+        comparer.report(176 /* Diagnostics.Type_predicate_0_is_not_assignable_to_1 */, [
+            typePredicateToString(c, source),
+            typePredicateToString(c, target),
+        ]);
+    return related;
+}
+export function compareSignaturesIdentical(c, source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compare) {
+    return compareSignaturesIdenticalWith(c, source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, getComparer(c, compare));
+}
+function compareSignaturesIdenticalWith(c, source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, comparer) {
+    if (source === target)
+        return -1 /* Ternary.True */;
+    if (!isMatchingSignature(c, source, target, partialMatch))
+        return 0 /* Ternary.False */;
+    if (source.typeParameters.length !== target.typeParameters.length)
+        return 0 /* Ternary.False */;
+    // Matching constraints and defaults let us instantiate the source with the target's type parameters.
+    if (target.typeParameters.length !== 0) {
+        const mapper = newTypeMapper(source.typeParameters, target.typeParameters);
+        for (let i = 0; i < target.typeParameters.length; i++) {
+            const s = source.typeParameters[i];
+            const t = target.typeParameters[i];
+            if (s === t)
+                continue;
+            if (comparer.compare(instantiateType(c, getConstraintFromTypeParameter(c, s) ?? c.unknownType, mapper), getConstraintFromTypeParameter(c, t) ?? c.unknownType, false) === 0 /* Ternary.False */ ||
+                comparer.compare(instantiateType(c, getDefaultOrUnknownFromTypeParameter(c, s), mapper), getDefaultOrUnknownFromTypeParameter(c, t), false) === 0 /* Ternary.False */)
+                return 0 /* Ternary.False */;
+        }
+        source = instantiateSignatureEx(c, source, mapper, true);
+    }
+    let result = -1 /* Ternary.True */;
+    if (!ignoreThisTypes) {
+        const sourceThisType = getThisTypeOfSignature(c, source);
+        if (sourceThisType !== undefined) {
+            const targetThisType = getThisTypeOfSignature(c, target);
+            if (targetThisType !== undefined) {
+                const related = comparer.compare(sourceThisType, targetThisType, false);
+                if (related === 0 /* Ternary.False */)
+                    return 0 /* Ternary.False */;
+                result &= related;
+            }
+        }
+    }
+    const count = getParameterCount(c, target);
+    for (let i = 0; i < count; i++) {
+        const related = comparer.compare(getTypeAtPosition(c, target, i), getTypeAtPosition(c, source, i), false);
+        if (related === 0 /* Ternary.False */)
+            return 0 /* Ternary.False */;
+        result &= related;
+    }
+    if (!ignoreReturnTypes) {
+        const sourceTypePredicate = getTypePredicateOfSignature(c, source);
+        const targetTypePredicate = getTypePredicateOfSignature(c, target);
+        if (sourceTypePredicate !== undefined || targetTypePredicate !== undefined) {
+            if (sourceTypePredicate === undefined ||
+                targetTypePredicate === undefined ||
+                sourceTypePredicate.kind !== targetTypePredicate.kind ||
+                sourceTypePredicate.parameterIndex !== targetTypePredicate.parameterIndex)
+                return 0 /* Ternary.False */;
+            if (sourceTypePredicate.type !== targetTypePredicate.type) {
+                if (sourceTypePredicate.type === undefined || targetTypePredicate.type === undefined)
+                    return 0 /* Ternary.False */;
+                result &= comparer.compare(sourceTypePredicate.type, targetTypePredicate.type, false);
+            }
+        }
+        else
+            result &= comparer.compare(getReturnTypeOfSignature(c, source), getReturnTypeOfSignature(c, target), false);
+    }
+    return result;
+}
+function isMatchingSignature(c, source, target, partialMatch) {
+    const sourceParameterCount = getParameterCount(c, source);
+    const targetParameterCount = getParameterCount(c, target);
+    const sourceMinArgumentCount = getMinArgumentCount(c, source);
+    const targetMinArgumentCount = getMinArgumentCount(c, target);
+    if (sourceParameterCount === targetParameterCount &&
+        sourceMinArgumentCount === targetMinArgumentCount &&
+        hasEffectiveRestParameter(c, source) === hasEffectiveRestParameter(c, target))
+        return true;
+    return partialMatch && sourceMinArgumentCount <= targetMinArgumentCount;
+}
+/**
+ * Whether `source` derives from `target` in the inheritance hierarchy, ignoring type parameters;
+ * `{}`, Object and Function are less derived than object-like types.
+ */
+export function isTypeDerivedFrom(c, source, target) {
+    if ((source.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const t of typesOf(source))
+            if (!isTypeDerivedFrom(c, t, target))
+                return false;
+        return true;
+    }
+    if ((target.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const t of typesOf(target))
+            if (isTypeDerivedFrom(c, source, t))
+                return true;
+        return false;
+    }
+    if ((source.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const t of typesOf(source))
+            if (isTypeDerivedFrom(c, t, target))
+                return true;
+        return false;
+    }
+    if ((source.flags & 117964800 /* TypeFlags.InstantiableNonPrimitive */) !== 0)
+        return isTypeDerivedFrom(c, getBaseConstraintOfType(c, source) ?? c.unknownType, target);
+    if (isEmptyAnonymousObjectType(c, target))
+        return (source.flags & (1048576 /* TypeFlags.Object */ | 131072 /* TypeFlags.NonPrimitive */)) !== 0;
+    if (target === c.globalObjectType)
+        return (source.flags & (1048576 /* TypeFlags.Object */ | 131072 /* TypeFlags.NonPrimitive */)) !== 0 && !isEmptyAnonymousObjectType(c, source);
+    if (target === c.globalFunctionType)
+        return (source.flags & 1048576 /* TypeFlags.Object */) !== 0 && isFunctionObjectType(c, source);
+    return (hasBaseType(c, source, getTargetType(target)) ||
+        (isArrayType(c, target) &&
+            !isReadonlyArrayType(c, target) &&
+            isTypeDerivedFrom(c, source, c.globalReadonlyArrayType)));
+}
+function isFunctionObjectType(c, t) {
+    if ((t.objectFlags & 256 /* ObjectFlags.EvolvingArray */) !== 0)
+        return false;
+    const resolved = resolveStructuredTypeMembers(c, t);
+    return (resolved.callSignatures.length !== 0 ||
+        resolved.constructSignatures.length !== 0 ||
+        (getResolvedMember(resolved, 'bind') !== undefined && isTypeSubtypeOf(c, t, c.globalFunctionType)));
+}
+export { findApplicableIndexInfo, getMergedSymbol, typeListKey, getPropertyNameFromType };
+/** The target properties that accept `undefined` only through `?`, under exactOptionalPropertyTypes. */
+export function getExactOptionalUnassignableProperties(c, source, target) {
+    if (isTupleType(source) && isTupleType(target))
+        return [];
+    const result = [];
+    for (const targetProp of getPropertiesOfType(c, target))
+        if (isExactOptionalPropertyMismatch(c, getTypeOfPropertyOfType(c, source, targetProp.name), getTypeOfSymbol(c, targetProp)))
+            result.push(targetProp);
+    return result;
+}
+/**
+ * Whether `source` may be `undefined` where the optional property type `target` takes it only by being
+ * missing, under exactOptionalPropertyTypes.
+ */
+export function isExactOptionalPropertyMismatch(c, source, target) {
+    return (source !== undefined &&
+        target !== undefined &&
+        maybeTypeOfKind(source, 4 /* TypeFlags.Undefined */) &&
+        containsMissingType(c, target));
+}
+/** The string literal member of `target` closest to the string literal `source`. */
+function getSuggestedTypeForNonexistentStringLiteralType(c, source, target) {
+    const value = source.stringValue;
+    const valueCodePoints = new CodePoints();
+    valueCodePoints.set(value);
+    const maximumLengthDifference = Math.max(2, Math.floor(valueCodePoints.length * 0.34));
+    let bestDistance = Math.floor(valueCodePoints.length * 0.4) + 0.9;
+    let best = undefined;
+    const lowerValue = value.toLowerCase();
+    for (const t of typesOf(target)) {
+        if ((t.flags & 1024 /* TypeFlags.StringLiteral */) === 0)
+            continue;
+        const name = t.stringValue;
+        const nameLength = utf8Length(name);
+        if (name === '' || Math.abs(nameLength - valueCodePoints.length) > maximumLengthDifference || name === value)
+            continue;
+        if (nameLength < 3 && name.toLowerCase() !== lowerValue)
+            continue;
+        const distance = distanceToCandidate(valueCodePoints, name, bestDistance);
+        if (distance < 0)
+            continue;
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = t;
+        }
+        else if (best === undefined || compareTypes(c, t, best) < 0)
+            best = t;
+    }
+    return best;
+}