tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-type-factory.js

@@ -0,0 +1,2501 @@
+// Creating and interning types: object types, literals, unions, intersections, references,
+// arrays and tuples. Interning keys follow tsgo's, so identity matches.
+import { sideOf, sideOfIfAny } from './side-state.js';
+import { getNodeId, getName, getText } from './ast.js';
+import { symbolToString } from './type-printer.js';
+import { CompositeTypeMapper, instantiateTypes } from './instantiation.js';
+import { getAliasForTypeNode, getTypeArgumentsOfDeferredReference } from './checker-type-nodes.js';
+import { popTypeResolution, pushTypeResolution } from './checker-symbols.js';
+import { isGenericIndexType } from './checker-type-operators.js';
+import { compareCodePoints } from './diagnostics.js';
+import { getSymbolId } from './symbol.js';
+import { cachedTypeKey, EvolvingArrayType, IndexInfo, IndexType, IndexedAccessType, InstantiationExpressionType, InterfaceType, IntersectionType, MappedType, ObjectType, ReverseMappedType, SubstitutionType, TemplateLiteralType, TupleElementInfo, TupleType, TypeAlias, TypeReference, UnionType, ArrayTypeMapper, ArrayToSingleTypeMapper, MergedTypeMapper, SimpleTypeMapper, emptyIndexInfos, emptySignatures, emptySymbols, emptyTypes, ReferenceCache, } from './checker-types.js';
+import { getNamedMembers, getMembersOfSymbol } from './checker-symbols.js';
+import { getBaseConstraintOfType, getBaseConstraintOrType, getIndexTypeOfType, getPropertiesOfType, getTypeOfPropertyOfType, isArrayLikeType, resolveStructuredTypeMembers, hasResolvedProperties, memberResolutionFlags, membersHolder, } from './checker-members.js';
+import { getTypeOfSymbol } from './checker-symbol-types.js';
+import { getDeclaredTypeOfSymbol, getParentOfSymbol } from './checker-declared-types.js';
+import { isTypeRelatedTo, isTypeStrictSubtypeOf, isTypeSubtypeOf, isTypeDerivedFrom } from './relations.js';
+import { getIndexedAccessType, isGenericMappedType, isTypeMatchedByTemplateLiteralType, isMemberOfStringMapping, } from './checker-type-operators.js';
+import { addOptionality } from './checker-symbol-types.js';
+import { getSourceFileOfNode } from './binder-utilities.js';
+import { isPartOfTypeNode } from './transformers/alias-references.js';
+// ---- Keys
+export function typeListKey(types) {
+    let key = '';
+    for (let i = 0; i < types.length; i++)
+        key += (i === 0 ? '' : ',') + types[i].id;
+    return key;
+}
+export function aliasKey(alias) {
+    return alias === undefined ? '' : '@' + getSymbolId(alias.symbol) + ':' + typeListKey(alias.typeArguments);
+}
+function unionKey(types, origin, alias) {
+    let key;
+    if (origin === undefined)
+        key = typeListKey(types);
+    else if ((origin.flags & 134217728 /* TypeFlags.Union */) !== 0)
+        key = '|' + typeListKey(origin.types);
+    else if ((origin.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+        key = '&' + typeListKey(origin.types);
+    else
+        key = '#' + origin.id + '|' + typeListKey(types);
+    return key + aliasKey(alias);
+}
+/** The list `unionKey` spells for `types` and `origin`. */
+function unionKeyTypes(types, origin) {
+    return origin !== undefined && (origin.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0
+        ? origin.types
+        : types;
+}
+/** The kind of `unionKey`'s spelling: no origin, a union origin, an intersection origin, another origin. */
+function unionKeyKind(origin) {
+    if (origin === undefined)
+        return 0;
+    if ((origin.flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return 1;
+    if ((origin.flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+        return 2;
+    return 3;
+}
+/**
+ * A number for `unionKey(types, origin, alias)` without spelling it: two 32-bit hashes of the same
+ * parts, combined below 2^53. Equal keys hash alike; unequal keys rarely do, and a union found by
+ * hash is checked against the key (`isUnionOfKey`).
+ */
+function unionKeyHash(types, origin, alias) {
+    const kind = unionKeyKind(origin);
+    let h1 = 0x811c9dc5 ^ kind;
+    let h2 = 0x9e3779b9 + kind;
+    if (kind === 3) {
+        h1 = Math.imul(h1 ^ origin.id, 0x01000193);
+        h2 = Math.imul(h2 + origin.id, 0x85ebca6b);
+    }
+    const list = unionKeyTypes(types, origin);
+    for (let i = 0; i < list.length; i++) {
+        const id = list[i].id;
+        h1 = Math.imul(h1 ^ id, 0x01000193);
+        h2 = Math.imul(h2 + id, 0x85ebca6b) ^ (h2 >>> 15);
+    }
+    if (alias !== undefined) {
+        h1 = Math.imul(h1 ^ (getSymbolId(alias.symbol) + 0x40000000), 0x01000193);
+        for (const t of alias.typeArguments) {
+            h1 = Math.imul(h1 ^ t.id, 0x01000193);
+            h2 = Math.imul(h2 + t.id, 0x85ebca6b) ^ (h2 >>> 15);
+        }
+        h2 = Math.imul(h2 ^ alias.typeArguments.length, 0xc2b2ae35);
+    }
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x7feb352d);
+    h1 ^= h1 >>> 15;
+    return (h1 >>> 0) * 0x100000 + ((h2 ^ list.length) & 0xfffff);
+}
+/**
+ * The hash a `TypeListCache` finds `types`, `alias` and `tag` by: two 32-bit hashes of the ids,
+ * combined below 2^53. Takes the alias symbol's id as `aliasKey` would.
+ */
+export function typeListHash(types, alias, tag) {
+    let h1 = 0x811c9dc5 ^ tag;
+    let h2 = 0x9e3779b9 + tag;
+    for (let i = 0; i < types.length; i++) {
+        const id = types[i].id;
+        h1 = Math.imul(h1 ^ id, 0x01000193);
+        h2 = Math.imul(h2 + id, 0x85ebca6b) ^ (h2 >>> 15);
+    }
+    if (alias !== undefined) {
+        h1 = Math.imul(h1 ^ (getSymbolId(alias.symbol) + 0x40000000), 0x01000193);
+        for (const t of alias.typeArguments) {
+            h1 = Math.imul(h1 ^ t.id, 0x01000193);
+            h2 = Math.imul(h2 + t.id, 0x85ebca6b) ^ (h2 >>> 15);
+        }
+        h2 = Math.imul(h2 ^ alias.typeArguments.length, 0xc2b2ae35);
+    }
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x7feb352d);
+    h1 ^= h1 >>> 15;
+    return (h1 >>> 0) * 0x100000 + ((h2 ^ types.length) & 0xfffff);
+}
+/** Ids below this pack in pairs into exact numbers (`getUnionTypeEx`). */
+const UnionPairIdLimit = 1 << 24;
+function sameTypeLists(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+/** Whether `union` was created for `unionKey(types, origin, alias)`. */
+function isUnionOfKey(union, types, origin, alias) {
+    const kind = unionKeyKind(origin);
+    const own = union.origin;
+    if (unionKeyKind(own) !== kind)
+        return false;
+    if (kind === 3 && own !== origin)
+        return false;
+    if (!sameTypeLists(unionKeyTypes(union.types, own), unionKeyTypes(types, origin)))
+        return false;
+    const ownAlias = union.alias;
+    if (alias === undefined || ownAlias === undefined)
+        return alias === ownAlias;
+    return ownAlias.symbol === alias.symbol && sameTypeLists(ownAlias.typeArguments, alias.typeArguments);
+}
+// ---- Constructors
+export function newObjectType(c, objectFlags, symbol) {
+    const id = c.nextTypeId();
+    const flags = objectFlags &
+        ~(524288 /* ObjectFlags.CouldContainTypeVariablesComputed */ |
+            1048576 /* ObjectFlags.CouldContainTypeVariables */ |
+            2097152 /* ObjectFlags.MembersResolved */ |
+            -2147483648 /* ObjectFlags.SideState */);
+    if ((objectFlags & 3 /* ObjectFlags.ClassOrInterface */) !== 0) {
+        const declared = new InterfaceType(flags, id, symbol);
+        declared.checking = c;
+        return declared;
+    }
+    if ((objectFlags & 8 /* ObjectFlags.Tuple */) !== 0) {
+        const tuple = new TupleType(flags, id);
+        tuple.checking = c;
+        return tuple;
+    }
+    if ((objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
+        return new TypeReference(flags, id, symbol);
+    if ((objectFlags & 32 /* ObjectFlags.Mapped */) !== 0)
+        return new MappedType(flags, id, symbol);
+    if ((objectFlags & 1024 /* ObjectFlags.ReverseMapped */) !== 0)
+        return new ReverseMappedType(flags, id);
+    if ((objectFlags & 256 /* ObjectFlags.EvolvingArray */) !== 0)
+        return new EvolvingArrayType(flags, id);
+    if ((objectFlags & 16777216 /* ObjectFlags.InstantiationExpressionType */) !== 0)
+        return new InstantiationExpressionType(flags, id, symbol);
+    return new ObjectType(flags, id, symbol);
+}
+export function newAnonymousType(c, symbol) {
+    const type = newObjectType(c, 16 /* ObjectFlags.Anonymous */, symbol);
+    setStructuredTypeMembers(c, type, undefined, emptySignatures, emptySignatures, emptyIndexInfos);
+    return type;
+}
+export function createAnonymousType(c, symbol, members, callSignatures, constructSignatures, indexInfos) {
+    const type = newObjectType(c, 16 /* ObjectFlags.Anonymous */, symbol);
+    setStructuredTypeMembers(c, type, members, callSignatures, constructSignatures, indexInfos);
+    return type;
+}
+export function setStructuredTypeMembers(c, t, members, callSignatures, constructSignatures, indexInfos) {
+    const type = membersHolder(c, t);
+    type.objectFlags |= 2097152 /* ObjectFlags.MembersResolved */;
+    type.pendingMembers = undefined;
+    type.members = members;
+    // Resolved member lists are never modified, so every empty one shares one array.
+    const properties = getNamedMembers(c, members, type.symbol);
+    type.properties = properties.length === 0 ? emptySymbols : properties;
+    type.callSignatures = callSignatures.length === 0 ? emptySignatures : callSignatures;
+    type.constructSignatures = constructSignatures.length === 0 ? emptySignatures : constructSignatures;
+    type.indexInfos = indexInfos.length === 0 ? emptyIndexInfos : indexInfos;
+}
+export function newUnionType(c, objectFlags, types) {
+    return new UnionType(objectFlags, c.nextTypeId(), types);
+}
+export function newIntersectionType(c, objectFlags, types) {
+    return new IntersectionType(objectFlags, c.nextTypeId(), types);
+}
+export function newIndexType(c, target, indexFlags) {
+    return new IndexType(c.nextTypeId(), target, indexFlags);
+}
+export function newIndexedAccessType(c, objectType, indexType, accessFlags) {
+    return new IndexedAccessType(c.nextTypeId(), objectType, indexType, accessFlags);
+}
+export function newSubstitutionType(c, baseType, constraint) {
+    return new SubstitutionType(c.nextTypeId(), baseType, constraint);
+}
+export function newIndexInfo(keyType, valueType, isReadonly, declaration) {
+    return new IndexInfo(keyType, valueType, isReadonly, declaration, []);
+}
+/** Propagates widening, literal and non-inferrable flags from constituents. */
+export function getPropagatingFlagsOfTypes(types, excludeKinds) {
+    let result = 0;
+    for (let i = 0; i < types.length; i++) {
+        const t = types[i];
+        if ((t.flags & excludeKinds) === 0)
+            result |= t.objectFlags;
+    }
+    return result & 458752 /* ObjectFlags.PropagatingFlags */;
+}
+// ---- Literals
+export function getStringLiteralType(c, value) {
+    let type = c.stringLiteralTypes.get(value);
+    if (type === undefined) {
+        type = c.newLiteralType(1024 /* TypeFlags.StringLiteral */, value, 0, undefined);
+        c.stringLiteralTypes.set(value, type);
+    }
+    return type;
+}
+export function getNumberLiteralType(c, value) {
+    if (value !== value) {
+        let type = c.nanLiteralType;
+        if (type === undefined) {
+            type = c.newLiteralType(2048 /* TypeFlags.NumberLiteral */, 'NaN', value, undefined);
+            c.nanLiteralType = type;
+        }
+        return type;
+    }
+    // -0 and 0 are the same key in a Map, as in Go.
+    let type = c.numberLiteralTypes.get(value);
+    if (type === undefined) {
+        type = c.newLiteralType(2048 /* TypeFlags.NumberLiteral */, '', value, undefined);
+        c.numberLiteralTypes.set(value, type);
+    }
+    return type;
+}
+/** `value` is the decimal digits of the bigint, with a leading `-` when negative. */
+export function getBigIntLiteralType(c, value) {
+    let type = c.bigintLiteralTypes.get(value);
+    if (type === undefined) {
+        type = c.newLiteralType(4096 /* TypeFlags.BigIntLiteral */, value, 0, undefined);
+        c.bigintLiteralTypes.set(value, type);
+    }
+    return type;
+}
+export function getStringEnumLiteralType(c, value, enumSymbol, symbol) {
+    const key = getSymbolId(enumSymbol) + 's' + value;
+    let type = c.enumLiteralTypes.get(key);
+    if (type === undefined) {
+        type = c.newLiteralType(32768 /* TypeFlags.EnumLiteral */ | 1024 /* TypeFlags.StringLiteral */, value, 0, symbol);
+        c.enumLiteralTypes.set(key, type);
+    }
+    return type;
+}
+export function getNumberEnumLiteralType(c, value, enumSymbol, symbol) {
+    const key = getSymbolId(enumSymbol) + 'n' + (value !== value ? 'NaN' : Object.is(value, -0) ? '0' : String(value));
+    let type = c.enumLiteralTypes.get(key);
+    if (type === undefined) {
+        type = c.newLiteralType(32768 /* TypeFlags.EnumLiteral */ | 2048 /* TypeFlags.NumberLiteral */, '', value, symbol);
+        c.enumLiteralTypes.set(key, type);
+    }
+    return type;
+}
+export function isFreshLiteralType(type) {
+    if ((type.flags & 80896 /* TypeFlags.Freshable */) === 0)
+        return false;
+    // An identity test, like tsgo's: comparing ids would load the fresh type as well.
+    return type.freshType === type;
+}
+export function getFreshTypeOfLiteralType(c, type) {
+    if ((type.flags & 80896 /* TypeFlags.Freshable */) === 0)
+        return type;
+    const literal = type;
+    // The fresh twin of a literal created with one is inline; others are created on first use.
+    if (literal.freshType !== undefined)
+        return literal.freshType;
+    const side = sideOf(c, literal);
+    const existing = side.freshType;
+    if (existing !== undefined)
+        return existing;
+    const fresh = c.newLiteralType(type.flags, literal.stringValue, literal.numberValue, type.symbol);
+    fresh.regularType = literal;
+    fresh.freshType = fresh;
+    side.freshType = fresh;
+    return fresh;
+}
+export function getRegularTypeOfLiteralType(c, type) {
+    if ((type.flags & 80896 /* TypeFlags.Freshable */) !== 0)
+        return type.regularType;
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const side = sideOf(c, type);
+        let regular = side.regularType;
+        if (regular === undefined) {
+            regular = mapType(c, type, (t) => getRegularTypeOfLiteralType(c, t));
+            side.regularType = regular;
+        }
+        return regular;
+    }
+    return type;
+}
+export function isUnitType(type) {
+    return (type.flags & 97292 /* TypeFlags.Unit */) !== 0;
+}
+export function isLiteralType(type) {
+    if ((type.flags & 256 /* TypeFlags.Boolean */) !== 0)
+        return true;
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        if ((type.flags & 32768 /* TypeFlags.EnumLiteral */) !== 0)
+            return true;
+        for (const t of type.types)
+            if (!isUnitType(t))
+                return false;
+        return true;
+    }
+    return isUnitType(type);
+}
+export function getBaseTypeOfEnumLikeType(c, type) {
+    if ((type.flags & 98304 /* TypeFlags.EnumLike */) !== 0 &&
+        type.symbol !== undefined &&
+        (type.symbol.flags & 8 /* SymbolFlags.EnumMember */) !== 0)
+        return getDeclaredTypeOfSymbol(c, getParentOfSymbol(c, type.symbol));
+    return type;
+}
+export function getBaseTypeOfLiteralType(c, type) {
+    const flags = type.flags;
+    if ((flags & 98304 /* TypeFlags.EnumLike */) !== 0)
+        return getBaseTypeOfEnumLikeType(c, type);
+    if ((flags & (1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0)
+        return c.stringType;
+    if ((flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+        return c.numberType;
+    if ((flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+        return c.bigintType;
+    if ((flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0)
+        return c.booleanType;
+    if ((flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const key = cachedTypeKey(0 /* CachedTypeKind.LiteralUnionBaseType */, type.id);
+        let cached = c.cachedTypesById.get(key);
+        if (cached === undefined) {
+            cached = mapType(c, type, (t) => getBaseTypeOfLiteralType(c, t));
+            c.cachedTypesById.set(key, cached);
+        }
+        return cached;
+    }
+    return type;
+}
+export function getBaseTypeOfLiteralTypeForComparison(c, type) {
+    const flags = type.flags;
+    if ((flags & (1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0)
+        return c.stringType;
+    if ((flags & (2048 /* TypeFlags.NumberLiteral */ | 65536 /* TypeFlags.Enum */)) !== 0)
+        return c.numberType;
+    if ((flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+        return c.bigintType;
+    if ((flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0)
+        return c.booleanType;
+    if ((flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return mapType(c, type, (t) => getBaseTypeOfLiteralTypeForComparison(c, t));
+    return type;
+}
+export function getWidenedLiteralType(c, type) {
+    const flags = type.flags;
+    if ((flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return mapType(c, type, (t) => getWidenedLiteralType(c, t));
+    if (!isFreshLiteralType(type))
+        return type;
+    if ((flags & 98304 /* TypeFlags.EnumLike */) !== 0)
+        return getBaseTypeOfEnumLikeType(c, type);
+    if ((flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+        return c.stringType;
+    if ((flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+        return c.numberType;
+    if ((flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+        return c.bigintType;
+    if ((flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0)
+        return c.booleanType;
+    return type;
+}
+export function getWidenedUniqueESSymbolType(c, type) {
+    if ((type.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
+        return c.esSymbolType;
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return mapType(c, type, (t) => getWidenedUniqueESSymbolType(c, t));
+    return type;
+}
+// ---- Ordering (tsgo's CompareTypes)
+export function compareNodes(c, n1, n2) {
+    if (n1 === n2)
+        return 0;
+    if (n1 === undefined)
+        return 1;
+    if (n2 === undefined)
+        return -1;
+    const s1 = sourceFileOf(n1);
+    const s2 = sourceFileOf(n2);
+    if (s1 !== s2)
+        return (c.fileIndex.get(s1) ?? 0) - (c.fileIndex.get(s2) ?? 0);
+    return n1.pos - n2.pos;
+}
+function sourceFileOf(node) {
+    return getSourceFileOfNode(node);
+}
+export function compareSymbols(c, s1, s2) {
+    if (s1 === s2)
+        return 0;
+    if (s1 === undefined)
+        return 1;
+    if (s2 === undefined)
+        return -1;
+    if (s1.declarations.length !== 0 && s2.declarations.length !== 0) {
+        const r = compareNodes(c, s1.declarations[0], s2.declarations[0]);
+        if (r !== 0)
+            return r;
+    }
+    else if (s1.declarations.length !== 0)
+        return -1;
+    else if (s2.declarations.length !== 0)
+        return 1;
+    const r = compareCodePoints(s1.name, s2.name);
+    if (r !== 0)
+        return r;
+    if (structuralTies)
+        return 0;
+    usedIds = true;
+    return compareIds(getSymbolId(s1), getSymbolId(s2));
+}
+/**
+ * `TSC_TS_ID_ORDER` (a test of output that must not depend on the order in which types and symbols
+ * are created): `reverse` reverses, and `scramble` permutes, the order of the ids that
+ * `compareTypes` and `compareSymbols` fall back to. Intrinsic types, created in a fixed order, keep
+ * theirs.
+ */
+const idOrder = process.env.TSC_TS_ID_ORDER === 'reverse' ? 1 : process.env.TSC_TS_ID_ORDER === 'scramble' ? 2 : 0;
+/** The order of two ids as a last resort: ascending, or as `TSC_TS_ID_ORDER` chooses. */
+function compareIds(a, b) {
+    if (idOrder === 0)
+        return a - b;
+    if (idOrder === 1)
+        return b - a;
+    // A bijection on 32-bit ids (multiplication by an odd constant), so the order stays total.
+    return (Math.imul(a, 0x9e3779b1) >>> 0) - (Math.imul(b, 0x9e3779b1) >>> 0);
+}
+function getSortOrderFlags(t) {
+    if ((t.flags & (32768 /* TypeFlags.EnumLiteral */ | 65536 /* TypeFlags.Enum */)) !== 0 && (t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return 65536 /* TypeFlags.Enum */;
+    return t.flags >>> 0;
+}
+function getTypeNameSymbol(t) {
+    if (t.alias !== undefined)
+        return t.alias.symbol;
+    if ((t.flags & (524288 /* TypeFlags.TypeParameter */ | 8388608 /* TypeFlags.StringMapping */)) !== 0)
+        return t.symbol;
+    if ((t.objectFlags & (3 /* ObjectFlags.ClassOrInterface */ | 4 /* ObjectFlags.Reference */)) !== 0 &&
+        (t.flags & 1048576 /* TypeFlags.Object */) !== 0)
+        return t.symbol;
+    return undefined;
+}
+function compareTypeNames(c, t1, t2) {
+    const s1 = getTypeNameSymbol(t1);
+    const s2 = getTypeNameSymbol(t2);
+    if (s1 === s2)
+        return t1.alias !== undefined ? compareTypeLists(c, t1.alias.typeArguments, t2.alias.typeArguments) : 0;
+    if (s1 === undefined)
+        return 1;
+    if (s2 === undefined)
+        return -1;
+    return compareCodePoints(s1.name, s2.name);
+}
+function compareTypeLists(c, s1, s2) {
+    // Index the parameters directly: an alias such as `s1 ?? emptyTypes` would hold its own reference.
+    const n1 = s1 === undefined ? 0 : s1.length;
+    const n2 = s2 === undefined ? 0 : s2.length;
+    if (n1 !== n2)
+        return n1 - n2;
+    for (let i = 0; i < n1; i++) {
+        const r = compareTypes(c, s1[i], s2[i]);
+        if (r !== 0)
+            return r;
+    }
+    return 0;
+}
+function compareElementLabels(n1, n2) {
+    if (n1 === n2)
+        return 0;
+    if (n1 === undefined)
+        return -1;
+    if (n2 === undefined)
+        return 1;
+    return compareCodePoints(labelText(n1), labelText(n2));
+}
+function labelText(node) {
+    const name = getName(node);
+    return getText(name);
+}
+function compareTupleTypes(t1, t2) {
+    if (t1 === t2)
+        return 0;
+    if (t1.readonly !== t2.readonly)
+        return t1.readonly ? 1 : -1;
+    if (t1.elementInfos.length !== t2.elementInfos.length)
+        return t1.elementInfos.length - t2.elementInfos.length;
+    for (let i = 0; i < t1.elementInfos.length; i++) {
+        const r = t1.elementInfos[i].flags - t2.elementInfos[i].flags;
+        if (r !== 0)
+            return r;
+    }
+    for (let i = 0; i < t1.elementInfos.length; i++) {
+        const r = compareElementLabels(t1.elementInfos[i].labeledDeclaration, t2.elementInfos[i].labeledDeclaration);
+        if (r !== 0)
+            return r;
+    }
+    return 0;
+}
+export function compareTypeMappers(c, m1, m2) {
+    if (m1 === m2)
+        return 0;
+    if (m1 === undefined)
+        return 1;
+    if (m2 === undefined)
+        return -1;
+    const k1 = m1.kind();
+    const k2 = m2.kind();
+    if (k1 !== k2)
+        return k1 - k2;
+    switch (k1) {
+        case 1 /* TypeMapperKind.Simple */: {
+            const a = m1;
+            const b = m2;
+            const r = compareTypes(c, a.source, b.source);
+            return r !== 0 ? r : compareTypes(c, a.target, b.target);
+        }
+        case 2 /* TypeMapperKind.Array */: {
+            const a = m1;
+            const b = m2;
+            const r = compareTypeLists(c, a.sources, b.sources);
+            return r !== 0 ? r : compareTypeLists(c, a.targets, b.targets);
+        }
+        case 3 /* TypeMapperKind.Merged */: {
+            const a = m1;
+            const b = m2;
+            const r = compareTypeMappers(c, a.m1, b.m1);
+            return r !== 0 ? r : compareTypeMappers(c, a.m2, b.m2);
+        }
+    }
+    return structuralTies ? compareOtherTypeMappers(c, m1, m2) : 0;
+}
+/**
+ * With `structuralTies`: the order of two mappers of the kinds `compareTypeMappers` doesn't compare,
+ * by their parts: composite mappers by their two mappers, mappers of several sources to one target by
+ * the sources and the target.
+ */
+function compareOtherTypeMappers(c, m1, m2) {
+    const r = otherMapperRank(m1) - otherMapperRank(m2);
+    if (r !== 0)
+        return r;
+    if (m1 instanceof CompositeTypeMapper && m2 instanceof CompositeTypeMapper) {
+        const r1 = compareTypeMappers(c, m1.m1, m2.m1);
+        return r1 !== 0 ? r1 : compareTypeMappers(c, m1.m2, m2.m2);
+    }
+    if (m1 instanceof ArrayToSingleTypeMapper && m2 instanceof ArrayToSingleTypeMapper) {
+        const r1 = compareTypeLists(c, m1.sources, m2.sources);
+        return r1 !== 0 ? r1 : compareTypes(c, m1.target, m2.target);
+    }
+    return 0;
+}
+function otherMapperRank(m) {
+    return m instanceof CompositeTypeMapper ? 1 : m instanceof ArrayToSingleTypeMapper ? 2 : 3;
+}
+/**
+ * The places of the declarations that `t`'s identity reaches, breadth first: its symbol and alias, then
+ * those of its type arguments, constituents and mapper targets, as numbers ordered by file and
+ * position; those in the program's own files first, then those in declaration files. Types that
+ * differ only in a part the program wrote, such as the fields of two instantiations of a library
+ * generic, first differ where that part was written, which is the order in which checking the source
+ * creates them.
+ */
+function declarationPlaces(c, t) {
+    const places = [];
+    const libraryPlaces = [];
+    const queue = [t];
+    const seen = new Set();
+    const visit = (symbol) => {
+        if (symbol === undefined || symbol.declarations.length === 0)
+            return;
+        const node = symbol.declarations[0];
+        const file = sourceFileOf(node);
+        (file.isDeclarationFile ? libraryPlaces : places).push((c.fileIndex.get(file) ?? 0) * 0x4000000 + node.pos);
+    };
+    const mapper = (m) => {
+        if (m === undefined)
+            return;
+        if (m instanceof SimpleTypeMapper)
+            queue.push(m.target);
+        else if (m instanceof ArrayTypeMapper)
+            for (const u of m.targets)
+                queue.push(u);
+        else if (m instanceof ArrayToSingleTypeMapper)
+            queue.push(m.target);
+        else if (m instanceof MergedTypeMapper || m instanceof CompositeTypeMapper) {
+            mapper(m.m1);
+            mapper(m.m2);
+        }
+    };
+    for (let k = 0; k < queue.length && places.length < declarationPlaceLimit && k < 64; k++) {
+        const u = queue[k];
+        if (seen.has(u))
+            continue;
+        seen.add(u);
+        visit(u.symbol);
+        if (u.alias !== undefined) {
+            visit(u.alias.symbol);
+            for (const v of u.alias.typeArguments)
+                queue.push(v);
+        }
+        if ((u.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0)
+            for (const v of u.types)
+                queue.push(v);
+        if ((u.flags & 1048576 /* TypeFlags.Object */) !== 0) {
+            if ((u.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && u.node === undefined) {
+                const args = u.resolvedTypeArguments;
+                if (args !== undefined)
+                    for (const v of args)
+                        queue.push(v);
+            }
+            mapper(u.mapper);
+        }
+    }
+    for (const place of libraryPlaces)
+        places.push(place);
+    return places;
+}
+const declarationPlaceLimit = 16;
+function comparePlaces(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++)
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    return a.length - b.length;
+}
+/**
+ * While set (`inDeclarationOrder`), `compareTypes`, `compareSymbols` and `compareTypeMappers` don't fall
+ * back to ids, which follow the order in which the checker created the types, and compare all mapper
+ * kinds by their parts.
+ */
+let structuralTies = false;
+/** Set when a comparison falls back to an id (`inDeclarationOrder`). */
+let usedIds = false;
+/**
+ * The constituents of a union in the order declaration emit writes them: as in the union, except that
+ * neighbors the union orders by ids, at any depth of `compareTypes`, are ordered by their structure
+ * where that tells them apart. Ids follow the order in which the checker created the types, which
+ * with several checkers depends on the files a checker checked first, so declaration files would
+ * otherwise differ from run to run.
+ */
+export function inDeclarationOrder(c, types) {
+    let result;
+    let start = 0;
+    for (let i = 1; i <= types.length; i++) {
+        let tied = false;
+        if (i < types.length) {
+            usedIds = false;
+            compareTypes(c, types[i - 1], types[i]);
+            tied = usedIds;
+        }
+        if (tied)
+            continue;
+        // types[start..i) are neighbors ordered by ids.
+        if (i - start > 1) {
+            const run = types.slice(start, i);
+            const order = [];
+            for (let k = 0; k < run.length; k++)
+                order.push(k);
+            const places = [];
+            for (const t of run)
+                places.push(declarationPlaces(c, t));
+            structuralTies = true;
+            order.sort((a, b) => comparePlaces(places[a], places[b]) || compareTypes(c, run[a], run[b]) || a - b);
+            structuralTies = false;
+            for (let k = 0; k < order.length; k++)
+                if (order[k] !== k) {
+                    if (result === undefined)
+                        result = types.slice();
+                    result[start + k] = run[order[k]];
+                }
+        }
+        start = i;
+    }
+    return result ?? types;
+}
+function compareNumbers(a, b) {
+    // Go's cmp.Compare: NaN sorts first.
+    const an = a !== a;
+    const bn = b !== b;
+    if (an || bn)
+        return an && bn ? 0 : an ? -1 : 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/** tsgo's deterministic type order, which orders union constituents. */
+export function compareTypes(c, t1, t2) {
+    if (t1 === t2)
+        return 0;
+    let r = getSortOrderFlags(t1) - getSortOrderFlags(t2);
+    if (r !== 0)
+        return r;
+    r = compareTypeNames(c, t1, t2);
+    if (r !== 0)
+        return r;
+    const flags = t1.flags;
+    if ((flags & 394239 /* TypeFlags.Singleton */) !== 0) {
+        // Only distinguished by ids.
+    }
+    else if ((flags & 1048576 /* TypeFlags.Object */) !== 0) {
+        r = compareSymbols(c, t1.symbol, t2.symbol);
+        if (r !== 0)
+            return r;
+        if ((t1.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && (t2.objectFlags & 4 /* ObjectFlags.Reference */) !== 0) {
+            const r1 = t1;
+            const r2 = t2;
+            const target1 = r1.target;
+            const target2 = r2.target;
+            if ((target1.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0 && (target2.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0) {
+                r = compareTupleTypes(target1, target2);
+                if (r !== 0)
+                    return r;
+            }
+            if (r1.node === undefined && r2.node === undefined) {
+                r = compareTypeLists(c, r1.resolvedTypeArguments, r2.resolvedTypeArguments);
+                if (r !== 0)
+                    return r;
+            }
+            else {
+                r = compareNodes(c, r1.node, r2.node);
+                if (r !== 0)
+                    return r;
+                r = compareTypeMappers(c, r1.mapper, r2.mapper);
+                if (r !== 0)
+                    return r;
+            }
+        }
+        else if ((t1.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
+            return -1;
+        else if ((t2.objectFlags & 4 /* ObjectFlags.Reference */) !== 0)
+            return 1;
+        else {
+            r = (t1.objectFlags & 50332991 /* ObjectFlags.ObjectTypeKindMask */) - (t2.objectFlags & 50332991 /* ObjectFlags.ObjectTypeKindMask */);
+            if (r !== 0)
+                return r;
+            r = compareTypeMappers(c, t1.mapper, t2.mapper);
+            if (r !== 0)
+                return r;
+        }
+    }
+    else if ((flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const o1 = t1.origin;
+        const o2 = t2.origin;
+        if (o1 === undefined && o2 === undefined) {
+            r = compareTypeLists(c, t1.types, t2.types);
+            if (r !== 0)
+                return r;
+        }
+        else if (o1 === undefined)
+            return 1;
+        else if (o2 === undefined)
+            return -1;
+        else {
+            r = compareTypes(c, o1, o2);
+            if (r !== 0)
+                return r;
+        }
+    }
+    else if ((flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        r = compareTypeLists(c, t1.types, t2.types);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & (65536 /* TypeFlags.Enum */ | 32768 /* TypeFlags.EnumLiteral */ | 16384 /* TypeFlags.UniqueESSymbol */)) !== 0) {
+        r = compareSymbols(c, t1.symbol, t2.symbol);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 1024 /* TypeFlags.StringLiteral */) !== 0) {
+        r = compareCodePoints(t1.stringValue, t2.stringValue);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 2048 /* TypeFlags.NumberLiteral */) !== 0) {
+        r = compareNumbers(t1.numberValue, t2.numberValue);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0) {
+        const b1 = t1.stringValue === 'true';
+        const b2 = t2.stringValue === 'true';
+        if (b1 !== b2)
+            return b1 ? 1 : -1;
+    }
+    else if ((flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
+        r = compareSymbols(c, t1.symbol, t2.symbol);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 2097152 /* TypeFlags.Index */) !== 0) {
+        r = compareTypes(c, t1.target, t2.target);
+        if (r !== 0)
+            return r;
+        r = t1.indexFlags - t2.indexFlags;
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0) {
+        r = compareTypes(c, t1.objectType, t2.objectType);
+        if (r !== 0)
+            return r;
+        r = compareTypes(c, t1.indexType, t2.indexType);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 67108864 /* TypeFlags.Conditional */) !== 0) {
+        r = compareNodes(c, t1.root.node, t2.root.node);
+        if (r !== 0)
+            return r;
+        r = compareTypeMappers(c, t1.mapper, t2.mapper);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 16777216 /* TypeFlags.Substitution */) !== 0) {
+        r = compareTypes(c, t1.baseType, t2.baseType);
+        if (r !== 0)
+            return r;
+        r = compareTypes(c, t1.constraint, t2.constraint);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+        const a = t1.texts;
+        const b = t2.texts;
+        const n = Math.min(a.length, b.length);
+        for (let i = 0; i < n; i++) {
+            r = compareCodePoints(a[i], b[i]);
+            if (r !== 0)
+                return r;
+        }
+        if (a.length !== b.length)
+            return a.length - b.length;
+        r = compareTypeLists(c, t1.types, t2.types);
+        if (r !== 0)
+            return r;
+    }
+    else if ((flags & 8388608 /* TypeFlags.StringMapping */) !== 0) {
+        r = compareTypes(c, t1.target, t2.target);
+        if (r !== 0)
+            return r;
+    }
+    if ((flags & 394239 /* TypeFlags.Singleton */) !== 0)
+        return t1.id - t2.id;
+    if (structuralTies)
+        return 0;
+    usedIds = true;
+    return compareIds(t1.id, t2.id);
+}
+/** Binary search position of `t` in the sorted `types`: index if found, else `-(insertion point) - 1`. */
+export function binarySearchTypes(c, types, t) {
+    let low = 0;
+    let high = types.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        const r = compareTypes(c, types[middle], t);
+        if (r === 0)
+            return middle;
+        if (r < 0)
+            low = middle + 1;
+        else
+            high = middle - 1;
+    }
+    return ~low;
+}
+/**
+ * Sorted type lists shorter than this are searched by identity. `compareTypes` is 0 only for
+ * identical types (the last criterion is the unique id), so membership needs no ordering.
+ */
+const linearTypeSearchLimit = 16;
+/** The index of `t` in `types` at or after `from`, or -1. */
+function indexOfType(types, t, from) {
+    for (let i = from; i < types.length; i++)
+        if (types[i] === t)
+            return i;
+    return -1;
+}
+export function containsType(c, types, t) {
+    if (types.length < linearTypeSearchLimit)
+        return indexOfType(types, t, 0) >= 0;
+    return binarySearchTypes(c, types, t) >= 0;
+}
+/**
+ * Whether `t` is a constituent of `union`. Equal types are identical, so a large union tested more
+ * than once looks `t` up in a set instead of searching its sorted constituents. Most large unions
+ * are tested once; a few are tested very often.
+ */
+export function unionContainsType(c, union, t) {
+    const types = union.types;
+    if (types.length < linearTypeSearchLimit)
+        return indexOfType(types, t, 0) >= 0;
+    const side = sideOf(c, union);
+    let set = side.constituentSet;
+    if (set === undefined) {
+        if (side.membershipTests++ === 0)
+            return binarySearchTypes(c, types, t) >= 0;
+        set = new Set(types);
+        side.constituentSet = set;
+    }
+    return set.has(t);
+}
+/**
+ * Whether `union` contains every type of the sorted `types` (the constituents of another union).
+ * Both lists follow `compareTypes`, so in a small union each type is found by identity after the
+ * previous one; large unions keep `unionContainsType`.
+ */
+export function unionContainsSortedTypes(c, union, types) {
+    const targets = union.types;
+    if (targets.length >= linearTypeSearchLimit) {
+        for (const t of types)
+            if (!unionContainsType(c, union, t))
+                return false;
+        return true;
+    }
+    let next = 0;
+    for (const t of types) {
+        const index = indexOfType(targets, t, next);
+        if (index < 0)
+            return false;
+        next = index + 1;
+    }
+    return true;
+}
+/** Inserts `t` into the sorted `types`; returns false if already present. */
+export function insertType(c, types, t) {
+    const index = binarySearchTypes(c, types, t);
+    if (index >= 0)
+        return false;
+    types.splice(~index, 0, t);
+    return true;
+}
+// ---- Iterating unions
+export function someType(type, f) {
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const t of type.types)
+            if (f(t))
+                return true;
+        return false;
+    }
+    return f(type);
+}
+export function everyType(type, f) {
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const t of type.types)
+            if (!f(t))
+                return false;
+        return true;
+    }
+    return f(type);
+}
+export function everyContainedType(type, f) {
+    if ((type.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0) {
+        for (const t of type.types)
+            if (!f(t))
+                return false;
+        return true;
+    }
+    return f(type);
+}
+export function typesOf(type) {
+    return type.types;
+}
+export function mapType(c, type, f) {
+    return mapTypeEx(c, type, f, false) ?? c.neverType;
+}
+/** Maps union constituents; undefined when every constituent maps to undefined. */
+export function mapTypeEx(c, type, f, noReductions) {
+    if ((type.flags & 262144 /* TypeFlags.Never */) !== 0)
+        return type;
+    if ((type.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return f(type);
+    const union = type;
+    const origin = union.origin;
+    const types = origin !== undefined && (origin.flags & 134217728 /* TypeFlags.Union */) !== 0 ? origin.types : union.types;
+    const mapped = [];
+    let changed = false;
+    for (const s of types) {
+        const m = (s.flags & 134217728 /* TypeFlags.Union */) !== 0 ? mapTypeEx(c, s, f, noReductions) : f(s);
+        if (m !== s)
+            changed = true;
+        if (m !== undefined)
+            mapped.push(m);
+    }
+    if (!changed)
+        return type;
+    if (mapped.length === 0)
+        return undefined;
+    return getUnionTypeEx(c, mapped, noReductions ? 0 /* UnionReduction.None */ : 1 /* UnionReduction.Literal */, undefined, undefined);
+}
+export function mapTypeWithAlias(c, type, f, alias) {
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0 && alias !== undefined) {
+        const mapped = [];
+        for (const t of type.types)
+            mapped.push(f(t));
+        return getUnionTypeEx(c, mapped, 1 /* UnionReduction.Literal */, alias, undefined);
+    }
+    return mapType(c, type, f);
+}
+export function filterType(c, type, f) {
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const union = type;
+        const types = union.types;
+        // The list is copied from the first constituent removed; most filters keep every one.
+        let removed = 0;
+        while (removed < types.length && f(types[removed]))
+            removed++;
+        if (removed === types.length)
+            return type;
+        const filtered = [];
+        for (let i = 0; i < removed; i++)
+            filtered.push(types[i]);
+        for (let i = removed + 1; i < types.length; i++) {
+            const t = types[i];
+            if (f(t))
+                filtered.push(t);
+        }
+        const origin = union.origin;
+        let newOrigin;
+        if (origin !== undefined && (origin.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            const originTypes = origin.types;
+            const originFiltered = [];
+            for (const u of originTypes)
+                if ((u.flags & 134217728 /* TypeFlags.Union */) !== 0 || f(u))
+                    originFiltered.push(u);
+            if (originTypes.length - originFiltered.length === types.length - filtered.length) {
+                if (originFiltered.length === 1)
+                    return originFiltered[0];
+                newOrigin = newUnionType(c, 0 /* ObjectFlags.None */, originFiltered);
+            }
+        }
+        return getUnionTypeFromSortedList(c, filtered, union.objectFlags & (32768 /* ObjectFlags.PrimitiveUnion */ | 33554432 /* ObjectFlags.ContainsIntersections */), undefined, newOrigin);
+    }
+    return (type.flags & 262144 /* TypeFlags.Never */) !== 0 || f(type) ? type : c.neverType;
+}
+export function removeType(c, type, target) {
+    return filterType(c, type, (t) => t !== target);
+}
+export function countTypes(type) {
+    if ((type.flags & 134217728 /* TypeFlags.Union */) !== 0)
+        return type.types.length;
+    return (type.flags & 262144 /* TypeFlags.Never */) !== 0 ? 0 : 1;
+}
+// ---- Unions
+export function isErrorType(c, type) {
+    // Only `any` types with alias symbols are those from getTypeFromTypeAliasReference for failed lookups.
+    return type === c.errorType || ((type.flags & 1 /* TypeFlags.Any */) !== 0 && type.alias !== undefined);
+}
+export function getUnionType(c, types) {
+    return getUnionTypeEx(c, types, 1 /* UnionReduction.Literal */, undefined, undefined);
+}
+export function getUnionTypeEx(c, types, unionReduction, alias, origin) {
+    if (types.length === 0)
+        return c.neverType;
+    if (types.length === 1)
+        return types[0];
+    // Optimize the common case of unioning a union with some other type, like `undefined`.
+    if (types.length === 2 &&
+        origin === undefined &&
+        ((types[0].flags & 134217728 /* TypeFlags.Union */) !== 0 || (types[1].flags & 134217728 /* TypeFlags.Union */) !== 0)) {
+        let id1 = types[0].id;
+        let id2 = types[1].id;
+        if (id1 > id2) {
+            const t = id1;
+            id1 = id2;
+            id2 = t;
+        }
+        // Without an alias, both ids and the reduction pack into one exact number.
+        if (alias === undefined && id2 < UnionPairIdLimit) {
+            const id = (id1 * UnionPairIdLimit + id2) * 4 + unionReduction;
+            let result = c.unionOfUnionTypesById.get(id);
+            if (result === undefined) {
+                result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
+                c.unionOfUnionTypesById.set(id, result);
+            }
+            return result;
+        }
+        const key = id1 + ',' + id2 + ',' + unionReduction + aliasKey(alias);
+        let result = c.unionOfUnionTypes.get(key);
+        if (result === undefined) {
+            result = getUnionTypeWorker(c, types, unionReduction, alias, undefined);
+            c.unionOfUnionTypes.set(key, result);
+        }
+        return result;
+    }
+    return getUnionTypeWorker(c, types, unionReduction, alias, origin);
+}
+class TypeSet {
+    types = [];
+    includes = 0;
+    /** Index of the type added or found last, or -1. */
+    last = -1;
+}
+/**
+ * Inserts `t` into the sorted `set.types` unless present, starting next to the previous type.
+ * Constituents arrive in sorted runs (nested unions, union members mapped in order), so most
+ * inserts land at or just after the previous position; otherwise the search covers only the side
+ * of the previous position that holds `t`. The set equals binary-search insertion's: the types
+ * stay sorted under the total order `compareTypes`.
+ */
+function insertTypeNearLast(c, set, t) {
+    const types = set.types;
+    let low = 0;
+    let high = types.length - 1;
+    const last = set.last;
+    if (last >= 0) {
+        const r = compareTypes(c, types[last], t);
+        if (r === 0)
+            return;
+        if (r < 0) {
+            low = last + 1;
+            if (low <= high) {
+                const next = compareTypes(c, types[low], t);
+                if (next === 0) {
+                    set.last = low;
+                    return;
+                }
+                if (next > 0)
+                    high = low - 1;
+                else
+                    low++;
+            }
+        }
+        else
+            high = last - 1;
+    }
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        const r = compareTypes(c, types[middle], t);
+        if (r === 0) {
+            set.last = middle;
+            return;
+        }
+        if (r < 0)
+            low = middle + 1;
+        else
+            high = middle - 1;
+    }
+    types.splice(low, 0, t);
+    set.last = low;
+}
+function getUnionTypeWorker(c, types, unionReduction, alias, origin) {
+    const set = new TypeSet();
+    addTypesToUnion(c, set, types);
+    let typeSet = set.types;
+    const includes = set.includes;
+    if (unionReduction !== 0 /* UnionReduction.None */) {
+        if ((includes & 3 /* TypeFlags.AnyOrUnknown */) !== 0) {
+            if ((includes & 1 /* TypeFlags.Any */) !== 0) {
+                if ((includes & 33554432 /* TypeFlags.IncludesWildcard */) !== 0)
+                    return c.wildcardType;
+                if ((includes & 1073741824 /* TypeFlags.IncludesError */) !== 0)
+                    return c.errorType;
+                return c.anyType;
+            }
+            return c.unknownType;
+        }
+        if ((includes & 4 /* TypeFlags.Undefined */) !== 0) {
+            if (typeSet.length >= 2 && typeSet[0] === c.undefinedType && typeSet[1] === c.missingType)
+                typeSet.splice(1, 1);
+        }
+        if ((includes &
+            (65536 /* TypeFlags.Enum */ |
+                15360 /* TypeFlags.Literal */ |
+                16384 /* TypeFlags.UniqueESSymbol */ |
+                4194304 /* TypeFlags.TemplateLiteral */ |
+                8388608 /* TypeFlags.StringMapping */)) !==
+            0 ||
+            ((includes & 16 /* TypeFlags.Void */) !== 0 && (includes & 4 /* TypeFlags.Undefined */) !== 0))
+            removeRedundantLiteralTypes(c, typeSet, includes, (unionReduction & 2 /* UnionReduction.Subtype */) !== 0);
+        if ((includes & 1024 /* TypeFlags.StringLiteral */) !== 0 &&
+            (includes & (4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0)
+            removeStringLiteralsMatchedByTemplateLiterals(c, typeSet);
+        if ((includes & 536870912 /* TypeFlags.IncludesConstrainedTypeVariable */) !== 0)
+            removeConstrainedTypeVariables(c, typeSet);
+        if (unionReduction === 2 /* UnionReduction.Subtype */) {
+            const reduced = removeSubtypes(c, typeSet, (includes & 1048576 /* TypeFlags.Object */) !== 0);
+            if (reduced === undefined)
+                return c.errorType;
+            typeSet = reduced;
+        }
+        if (typeSet.length === 0) {
+            if ((includes & 8 /* TypeFlags.Null */) !== 0)
+                return (includes & 2097152 /* TypeFlags.IncludesNonWideningType */) !== 0 ? c.nullType : c.nullWideningType;
+            if ((includes & 4 /* TypeFlags.Undefined */) !== 0)
+                return (includes & 2097152 /* TypeFlags.IncludesNonWideningType */) !== 0 ? c.undefinedType : c.undefinedWideningType;
+            return c.neverType;
+        }
+    }
+    if (origin === undefined && (includes & 134217728 /* TypeFlags.Union */) !== 0) {
+        const namedUnions = [];
+        addNamedUnions(namedUnions, types);
+        const reducedTypes = [];
+        for (const t of typeSet) {
+            let inNamed = false;
+            for (const u of namedUnions)
+                if (unionContainsType(c, u, t)) {
+                    inNamed = true;
+                    break;
+                }
+            if (!inNamed)
+                reducedTypes.push(t);
+        }
+        if (alias === undefined && namedUnions.length === 1 && reducedTypes.length === 0)
+            return namedUnions[0];
+        // A denormalized origin only when the union came from named unions with no overlap.
+        let namedTypesCount = 0;
+        for (const u of namedUnions)
+            namedTypesCount += u.types.length;
+        if (namedTypesCount + reducedTypes.length === typeSet.length) {
+            for (const t of namedUnions)
+                insertType(c, reducedTypes, t);
+            origin = newUnionType(c, 0 /* ObjectFlags.None */, reducedTypes);
+        }
+    }
+    const objectFlags = ((includes & 286523411 /* TypeFlags.NotPrimitiveUnion */) !== 0 ? 0 : 32768 /* ObjectFlags.PrimitiveUnion */) |
+        ((includes & 268435456 /* TypeFlags.Intersection */) !== 0 ? 33554432 /* ObjectFlags.ContainsIntersections */ : 0);
+    return getUnionTypeFromSortedList(c, typeSet, objectFlags, alias, origin);
+}
+/** Assumes `types` is sorted and deduplicated. */
+export function getUnionTypeFromSortedList(c, types, precomputedObjectFlags, alias, origin) {
+    if (types.length === 0)
+        return c.neverType;
+    if (types.length === 1)
+        return types[0];
+    // Unions are found by a hash of their key; the spelled key is only needed when two keys share a
+    // hash, for the second one.
+    const hash = unionKeyHash(types, origin, alias);
+    let result = c.unionTypesByHash.get(hash);
+    let key;
+    if (result !== undefined && !isUnionOfKey(result, types, origin, alias)) {
+        key = unionKey(types, origin, alias);
+        result = c.unionTypes.get(key);
+    }
+    if (result === undefined) {
+        const union = newUnionType(c, precomputedObjectFlags | getPropagatingFlagsOfTypes(types, 12 /* TypeFlags.Nullable */), types);
+        union.origin = origin;
+        union.alias = alias;
+        if (types.length === 2 &&
+            (types[0].flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0 &&
+            (types[1].flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0)
+            union.flags |= 256 /* TypeFlags.Boolean */;
+        if (key === undefined)
+            c.unionTypesByHash.set(hash, union);
+        else
+            c.unionTypes.set(key, union);
+        result = union;
+    }
+    return result;
+}
+function addTypesToUnion(c, set, types) {
+    let lastType;
+    for (const t of types) {
+        if (t === lastType)
+            continue;
+        if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            const u = t;
+            if (t.alias !== undefined || u.origin !== undefined)
+                set.includes |= 134217728 /* TypeFlags.Union */;
+            addTypesToUnion(c, set, u.types);
+        }
+        else
+            addTypeToUnion(c, set, t);
+        lastType = t;
+    }
+}
+function addTypeToUnion(c, set, t) {
+    const flags = t.flags;
+    if ((flags & 262144 /* TypeFlags.Never */) !== 0)
+        return;
+    let includes = set.includes | (flags & 416808959 /* TypeFlags.IncludesMask */);
+    if ((flags & 132644864 /* TypeFlags.Instantiable */) !== 0)
+        includes |= 16777216 /* TypeFlags.IncludesInstantiable */;
+    if ((flags & 268435456 /* TypeFlags.Intersection */) !== 0 && (t.objectFlags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) !== 0)
+        includes |= 536870912 /* TypeFlags.IncludesConstrainedTypeVariable */;
+    if (t === c.wildcardType)
+        includes |= 33554432 /* TypeFlags.IncludesWildcard */;
+    if (isErrorType(c, t))
+        includes |= 1073741824 /* TypeFlags.IncludesError */;
+    if (!c.strictNullChecks && (flags & 12 /* TypeFlags.Nullable */) !== 0) {
+        if ((t.objectFlags & 65536 /* ObjectFlags.ContainsWideningType */) === 0)
+            includes |= 2097152 /* TypeFlags.IncludesNonWideningType */;
+    }
+    else
+        insertTypeNearLast(c, set, t);
+    set.includes = includes;
+}
+function addNamedUnions(namedUnions, types) {
+    for (const t of types) {
+        if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+            continue;
+        const u = t;
+        if (t.alias !== undefined || (u.origin !== undefined && (u.origin.flags & 134217728 /* TypeFlags.Union */) === 0)) {
+            if (!namedUnions.includes(t))
+                namedUnions.push(t);
+        }
+        else if (u.origin !== undefined && (u.origin.flags & 134217728 /* TypeFlags.Union */) !== 0)
+            addNamedUnions(namedUnions, u.origin.types);
+    }
+}
+function removeRedundantLiteralTypes(c, types, includes, reduceVoidUndefined) {
+    let i = types.length;
+    while (i > 0) {
+        i--;
+        const t = types[i];
+        const flags = t.flags;
+        const remove = ((flags & (1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0 &&
+            (includes & 32 /* TypeFlags.String */) !== 0) ||
+            ((flags & 2048 /* TypeFlags.NumberLiteral */) !== 0 && (includes & 64 /* TypeFlags.Number */) !== 0) ||
+            ((flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0 && (includes & 128 /* TypeFlags.BigInt */) !== 0) ||
+            ((flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0 && (includes & 512 /* TypeFlags.ESSymbol */) !== 0) ||
+            (reduceVoidUndefined && (flags & 4 /* TypeFlags.Undefined */) !== 0 && (includes & 16 /* TypeFlags.Void */) !== 0) ||
+            (isFreshLiteralType(t) && containsType(c, types, t.regularType));
+        if (remove)
+            types.splice(i, 1);
+    }
+}
+function removeStringLiteralsMatchedByTemplateLiterals(c, types) {
+    const templates = [];
+    for (const t of types)
+        if (isPatternLiteralType(c, t))
+            templates.push(t);
+    if (templates.length === 0)
+        return;
+    // Every string literal is tested against every template, and most fail the first test of
+    // inferTypesFromTemplateLiteralType: the literal starts with the template's first text, ends with
+    // its last, and is long enough for both. Apply that test here with the texts read once per
+    // template; only literals that pass it take the full match. (String mapping templates keep the
+    // full test: their start and end are empty.)
+    const starts = [];
+    const ends = [];
+    const minLengths = [];
+    for (const template of templates) {
+        if ((template.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+            const texts = template.texts;
+            const start = texts[0];
+            const end = texts[texts.length - 1];
+            starts.push(start);
+            ends.push(end);
+            minLengths.push(start.length + end.length);
+        }
+        else {
+            starts.push('');
+            ends.push('');
+            minLengths.push(0);
+        }
+    }
+    let i = types.length;
+    while (i > 0) {
+        i--;
+        const t = types[i];
+        if ((t.flags & 1024 /* TypeFlags.StringLiteral */) === 0)
+            continue;
+        const text = t.stringValue;
+        const length = text.length;
+        for (let j = 0; j < templates.length; j++) {
+            if (length < minLengths[j])
+                continue;
+            const start = starts[j];
+            if (start.length !== 0 && !text.startsWith(start))
+                continue;
+            const end = ends[j];
+            if (end.length !== 0 && !text.endsWith(end))
+                continue;
+            if (isTypeMatchedByTemplateLiteralOrStringMapping(c, t, templates[j])) {
+                types.splice(i, 1);
+                break;
+            }
+        }
+    }
+}
+function isTypeMatchedByTemplateLiteralOrStringMapping(c, t, template) {
+    if ((template.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0)
+        return isTypeMatchedByTemplateLiteralType(c, t, template);
+    return isMemberOfStringMapping(c, t, template);
+}
+function constrainedTypeVariableIndex(t) {
+    return (t.types[0].flags & 34078720 /* TypeFlags.TypeVariable */) === 0 ? 1 : 0;
+}
+function removeConstrainedTypeVariables(c, types) {
+    const typeVariables = [];
+    for (const t of types) {
+        if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && (t.objectFlags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) !== 0) {
+            const v = t.types[constrainedTypeVariableIndex(t)];
+            if (!typeVariables.includes(v))
+                typeVariables.push(v);
+        }
+    }
+    for (const typeVariable of typeVariables) {
+        const primitives = [];
+        for (const t of types) {
+            if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && (t.objectFlags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) !== 0) {
+                const index = constrainedTypeVariableIndex(t);
+                if (t.types[index] === typeVariable)
+                    insertType(c, primitives, t.types[1 - index]);
+            }
+        }
+        const constraint = getBaseConstraintOfType(c, typeVariable);
+        if (constraint !== undefined && everyType(constraint, (t) => containsType(c, primitives, t))) {
+            let i = types.length;
+            while (i > 0) {
+                i--;
+                const t = types[i];
+                if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && (t.objectFlags & 134217728 /* ObjectFlags.IsConstrainedTypeVariable */) !== 0) {
+                    const index = constrainedTypeVariableIndex(t);
+                    const parts = t.types;
+                    if (parts[index] === typeVariable && containsType(c, primitives, parts[1 - index]))
+                        types.splice(i, 1);
+                }
+            }
+            insertType(c, types, typeVariable);
+        }
+    }
+}
+function removeSubtypes(c, types, hasObjectTypes) {
+    if (types.length < 2)
+        return types;
+    const hash = typeListHash(types, undefined, 0);
+    const cached = c.subtypeReductionCache.get(hash, types, undefined, 0);
+    if (cached !== undefined)
+        return cached;
+    // The reduction removes from `types`; the key is the list before.
+    const keyTypes = types.slice();
+    let hasEmptyObject = false;
+    if (hasObjectTypes)
+        for (const t of types)
+            if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0 &&
+                !isGenericMappedType(c, t) &&
+                isEmptyResolvedType(c, t, resolveStructuredTypeMembers(c, t))) {
+                hasEmptyObject = true;
+                break;
+            }
+    const length = types.length;
+    let i = length;
+    let count = 0;
+    while (i > 0) {
+        i--;
+        const source = types[i];
+        if (!hasEmptyObject && (source.flags & 536346624 /* TypeFlags.StructuredOrInstantiable */) === 0)
+            continue;
+        // `T extends A | B` is a subtype of `A | B` but not of `A` or `B` alone.
+        if ((source.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 &&
+            (getBaseConstraintOrType(c, source).flags & 134217728 /* TypeFlags.Union */) !== 0) {
+            const others = [];
+            for (const t of types)
+                others.push(t === source ? c.neverType : t);
+            if (isTypeRelatedTo(c, source, getUnionType(c, others), c.strictSubtypeRelation))
+                types.splice(i, 1);
+            continue;
+        }
+        // A property with a unit type quickly disqualifies constituents with a different unit type.
+        let keyProperty;
+        let keyPropertyType;
+        if ((source.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */)) !== 0) {
+            for (const p of getPropertiesOfType(c, source))
+                if (isUnitType(getTypeOfSymbol(c, p))) {
+                    keyProperty = p;
+                    break;
+                }
+        }
+        if (keyProperty !== undefined)
+            keyPropertyType = getRegularTypeOfLiteralType(c, getTypeOfSymbol(c, keyProperty));
+        for (const target of types) {
+            if (source === target)
+                continue;
+            if (count === 100000) {
+                const estimatedCount = Math.trunc(count / (length - i)) * length;
+                if (estimatedCount > 1000000) {
+                    c.error(c.currentNode, 738 /* Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent */);
+                    return undefined;
+                }
+            }
+            count++;
+            if (keyProperty !== undefined &&
+                (target.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */)) !== 0) {
+                const t = getTypeOfPropertyOfType(c, target, keyProperty.name);
+                if (t !== undefined && isUnitType(t) && getRegularTypeOfLiteralType(c, t) !== keyPropertyType)
+                    continue;
+            }
+            if ((source === c.emptyObjectType || source === c.unknownEmptyObjectType) &&
+                target.symbol !== undefined &&
+                isEmptyAnonymousObjectType(c, target))
+                continue;
+            if (isTypeRelatedTo(c, source, target, c.strictSubtypeRelation) &&
+                ((getTargetType(source).objectFlags & 1 /* ObjectFlags.Class */) === 0 ||
+                    (getTargetType(target).objectFlags & 1 /* ObjectFlags.Class */) === 0 ||
+                    isTypeDerivedFrom(c, source, target))) {
+                types.splice(i, 1);
+                break;
+            }
+        }
+    }
+    c.subtypeReductionCache.set(hash, keyTypes, undefined, 0, types);
+    return types;
+}
+export function getTargetType(type) {
+    return (type.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && (type.flags & 1048576 /* TypeFlags.Object */) !== 0
+        ? type.target
+        : type;
+}
+/** Whether `t`, whose members are `resolved`, has no members. */
+export function isEmptyResolvedType(c, t, resolved) {
+    return (t !== c.anyFunctionType &&
+        !hasResolvedProperties(resolved) &&
+        resolved.callSignatures.length === 0 &&
+        resolved.constructSignatures.length === 0 &&
+        resolved.indexInfos.length === 0);
+}
+export function isEmptyAnonymousObjectType(c, t) {
+    if ((t.objectFlags & 16 /* ObjectFlags.Anonymous */) === 0 || (t.flags & 1048576 /* TypeFlags.Object */) === 0)
+        return false;
+    if ((memberResolutionFlags(c, t) & 2097152 /* ObjectFlags.MembersResolved */) !== 0 &&
+        isEmptyResolvedType(c, t, membersHolder(c, t)))
+        return true;
+    return (t.symbol !== undefined &&
+        (t.symbol.flags & 2048 /* SymbolFlags.TypeLiteral */) !== 0 &&
+        getMembersOfSymbol(c, t.symbol).size === 0);
+}
+export function isEmptyObjectType(c, t) {
+    if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0)
+        return !isGenericMappedType(c, t) && isEmptyResolvedType(c, t, resolveStructuredTypeMembers(c, t));
+    if ((t.flags & 131072 /* TypeFlags.NonPrimitive */) !== 0)
+        return true;
+    if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const u of typesOf(t))
+            if (isEmptyObjectType(c, u))
+                return true;
+        return false;
+    }
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        for (const u of typesOf(t))
+            if (!isEmptyObjectType(c, u))
+                return false;
+        return true;
+    }
+    return false;
+}
+export function isPatternLiteralPlaceholderType(c, t) {
+    if ((t.flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        let seenPlaceholder = false;
+        for (const s of typesOf(t)) {
+            if ((s.flags & (15360 /* TypeFlags.Literal */ | 12 /* TypeFlags.Nullable */)) !== 0 || isPatternLiteralPlaceholderType(c, s))
+                seenPlaceholder = true;
+            else if ((s.flags & 1048576 /* TypeFlags.Object */) === 0)
+                return false;
+        }
+        return seenPlaceholder;
+    }
+    return ((t.flags & (1 /* TypeFlags.Any */ | 32 /* TypeFlags.String */ | 64 /* TypeFlags.Number */ | 128 /* TypeFlags.BigInt */)) !== 0 ||
+        isPatternLiteralType(c, t));
+}
+export function isPatternLiteralType(c, t) {
+    if ((t.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+        for (const u of t.types)
+            if (!isPatternLiteralPlaceholderType(c, u))
+                return false;
+        return true;
+    }
+    return ((t.flags & 8388608 /* TypeFlags.StringMapping */) !== 0 && isPatternLiteralPlaceholderType(c, t.target));
+}
+export function isGenericStringLikeType(c, t) {
+    return (t.flags & (4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0 && !isPatternLiteralType(c, t);
+}
+// ---- Intersections
+export function intersectTypes(c, type1, type2) {
+    if (type1 === undefined)
+        return type2;
+    if (type2 === undefined)
+        return type1;
+    return getIntersectionType(c, [type1, type2]);
+}
+export function getIntersectionType(c, types) {
+    return getIntersectionTypeEx(c, types, 0 /* IntersectionFlags.None */, undefined);
+}
+class OrderedTypeSet {
+    values = [];
+    seen = new Set();
+    includes = 0;
+    has(t) {
+        return this.seen.has(t);
+    }
+    add(t) {
+        if (!this.seen.has(t)) {
+            this.seen.add(t);
+            this.values.push(t);
+        }
+    }
+}
+function addTypesToIntersection(c, set, types) {
+    for (const t of types)
+        addTypeToIntersection(c, set, getRegularTypeOfLiteralType(c, t));
+}
+function addTypeToIntersection(c, set, t) {
+    const flags = t.flags;
+    if ((flags & 268435456 /* TypeFlags.Intersection */) !== 0) {
+        addTypesToIntersection(c, set, t.types);
+        return;
+    }
+    if (isEmptyAnonymousObjectType(c, t)) {
+        if ((set.includes & 67108864 /* TypeFlags.IncludesEmptyObject */) === 0) {
+            set.includes |= 67108864 /* TypeFlags.IncludesEmptyObject */;
+            set.add(t);
+        }
+        return;
+    }
+    if ((flags & 3 /* TypeFlags.AnyOrUnknown */) !== 0) {
+        if (t === c.wildcardType)
+            set.includes |= 33554432 /* TypeFlags.IncludesWildcard */;
+        if (isErrorType(c, t))
+            set.includes |= 1073741824 /* TypeFlags.IncludesError */;
+    }
+    else if (c.strictNullChecks || (flags & 12 /* TypeFlags.Nullable */) === 0) {
+        if (t === c.missingType) {
+            set.includes |= 524288 /* TypeFlags.IncludesMissingType */;
+            t = c.undefinedType;
+        }
+        if (!set.has(t)) {
+            // Two distinct unit types reduce to never; NonPrimitive triggers that.
+            if ((t.flags & 97292 /* TypeFlags.Unit */) !== 0 && (set.includes & 97292 /* TypeFlags.Unit */) !== 0)
+                set.includes |= 131072 /* TypeFlags.NonPrimitive */;
+            set.add(t);
+        }
+    }
+    set.includes |= flags & 416808959 /* TypeFlags.IncludesMask */;
+}
+function disjoint(includes, kind) {
+    return (includes & kind) !== 0 && (includes & (12812284 /* TypeFlags.DisjointDomains */ & ~kind)) !== 0;
+}
+export function getIntersectionTypeEx(c, types, flags, alias) {
+    const set = new OrderedTypeSet();
+    addTypesToIntersection(c, set, types);
+    const typeSet = set.values;
+    const includes = set.includes;
+    let objectFlags = 0 /* ObjectFlags.None */;
+    if ((includes & 262144 /* TypeFlags.Never */) !== 0)
+        return typeSet.includes(c.silentNeverType) ? c.silentNeverType : c.neverType;
+    if ((c.strictNullChecks &&
+        (includes & 12 /* TypeFlags.Nullable */) !== 0 &&
+        (includes & (1048576 /* TypeFlags.Object */ | 131072 /* TypeFlags.NonPrimitive */ | 67108864 /* TypeFlags.IncludesEmptyObject */)) !== 0) ||
+        disjoint(includes, 131072 /* TypeFlags.NonPrimitive */) ||
+        disjoint(includes, 12583968 /* TypeFlags.StringLike */) ||
+        disjoint(includes, 67648 /* TypeFlags.NumberLike */) ||
+        disjoint(includes, 4224 /* TypeFlags.BigIntLike */) ||
+        disjoint(includes, 16896 /* TypeFlags.ESSymbolLike */) ||
+        disjoint(includes, 20 /* TypeFlags.VoidLike */))
+        return c.neverType;
+    if ((includes & (4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0 &&
+        (includes & 1024 /* TypeFlags.StringLiteral */) !== 0) {
+        if (extractRedundantTemplateLiterals(c, typeSet))
+            return c.neverType;
+    }
+    if ((includes & 1 /* TypeFlags.Any */) !== 0) {
+        if ((includes & 33554432 /* TypeFlags.IncludesWildcard */) !== 0)
+            return c.wildcardType;
+        if ((includes & 1073741824 /* TypeFlags.IncludesError */) !== 0)
+            return c.errorType;
+        return c.anyType;
+    }
+    if (!c.strictNullChecks && (includes & 12 /* TypeFlags.Nullable */) !== 0) {
+        if ((includes & 67108864 /* TypeFlags.IncludesEmptyObject */) !== 0)
+            return c.neverType;
+        if ((includes & 4 /* TypeFlags.Undefined */) !== 0)
+            return c.undefinedType;
+        return c.nullType;
+    }
+    if (((includes & 32 /* TypeFlags.String */) !== 0 &&
+        (includes & (1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0) ||
+        ((includes & 64 /* TypeFlags.Number */) !== 0 && (includes & 2048 /* TypeFlags.NumberLiteral */) !== 0) ||
+        ((includes & 128 /* TypeFlags.BigInt */) !== 0 && (includes & 4096 /* TypeFlags.BigIntLiteral */) !== 0) ||
+        ((includes & 512 /* TypeFlags.ESSymbol */) !== 0 && (includes & 16384 /* TypeFlags.UniqueESSymbol */) !== 0) ||
+        ((includes & 16 /* TypeFlags.Void */) !== 0 && (includes & 4 /* TypeFlags.Undefined */) !== 0) ||
+        ((includes & 67108864 /* TypeFlags.IncludesEmptyObject */) !== 0 && (includes & 13893600 /* TypeFlags.DefinitelyNonNullable */) !== 0)) {
+        if ((flags & 1 /* IntersectionFlags.NoSupertypeReduction */) === 0)
+            removeRedundantSupertypes(c, typeSet, includes);
+    }
+    if ((includes & 524288 /* TypeFlags.IncludesMissingType */) !== 0)
+        typeSet[typeSet.indexOf(c.undefinedType)] = c.missingType;
+    if (typeSet.length === 0)
+        return c.unknownType;
+    if (typeSet.length === 1)
+        return typeSet[0];
+    if (typeSet.length === 2 && (flags & 2 /* IntersectionFlags.NoConstraintReduction */) === 0) {
+        const typeVarIndex = (typeSet[0].flags & 34078720 /* TypeFlags.TypeVariable */) === 0 ? 1 : 0;
+        const typeVariable = typeSet[typeVarIndex];
+        const primitiveType = typeSet[1 - typeVarIndex];
+        if ((typeVariable.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0 &&
+            (((primitiveType.flags & (12713980 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.NonPrimitive */)) !== 0 &&
+                !isGenericStringLikeType(c, primitiveType)) ||
+                (includes & 67108864 /* TypeFlags.IncludesEmptyObject */) !== 0)) {
+            // T & P where P is a primitive, `object` or {}.
+            const constraint = getBaseConstraintOfType(c, typeVariable);
+            if (constraint !== undefined && everyType(constraint, (t) => isPrimitiveOrObjectOrEmptyType(c, t))) {
+                if (isTypeStrictSubtypeOf(c, constraint, primitiveType))
+                    return typeVariable;
+                if (!((constraint.flags & 134217728 /* TypeFlags.Union */) !== 0 &&
+                    someType(constraint, (n) => isTypeStrictSubtypeOf(c, n, primitiveType)))) {
+                    if (!isTypeStrictSubtypeOf(c, primitiveType, constraint))
+                        return c.neverType;
+                }
+                objectFlags = 134217728 /* ObjectFlags.IsConstrainedTypeVariable */;
+            }
+        }
+    }
+    // Keys without constraint reduction ignore the alias.
+    const keyAlias = (flags & 2 /* IntersectionFlags.NoConstraintReduction */) === 0 ? alias : undefined;
+    const keyTag = (flags & 2 /* IntersectionFlags.NoConstraintReduction */) === 0 ? 0 : 1;
+    const hash = typeListHash(typeSet, keyAlias, keyTag);
+    let result = c.intersectionTypes.get(hash, typeSet, keyAlias, keyTag);
+    let keyTypes = typeSet;
+    if (result === undefined) {
+        if ((includes & 134217728 /* TypeFlags.Union */) !== 0) {
+            // The distributions below change `typeSet`; the key is the list before.
+            keyTypes = typeSet.slice();
+            if (intersectUnionsOfPrimitiveTypes(c, typeSet)) {
+                // Restart with fresh flags; reduction happens at most once.
+                result = getIntersectionTypeEx(c, typeSet, flags, alias);
+            }
+            else if (everyIsUnionWithUndefined(typeSet)) {
+                let containedUndefinedType = c.undefinedType;
+                for (const t of typeSet)
+                    if (containsMissingType(c, t))
+                        containedUndefinedType = c.missingType;
+                for (let i = 0; i < typeSet.length; i++)
+                    typeSet[i] = filterType(c, typeSet[i], (t) => (t.flags & 4 /* TypeFlags.Undefined */) === 0);
+                result = getUnionTypeEx(c, [getIntersectionTypeEx(c, typeSet, flags, undefined), containedUndefinedType], 1 /* UnionReduction.Literal */, alias, undefined);
+            }
+            else if (everyIsUnionWithNull(typeSet)) {
+                for (let i = 0; i < typeSet.length; i++)
+                    typeSet[i] = filterType(c, typeSet[i], (t) => (t.flags & 8 /* TypeFlags.Null */) === 0);
+                result = getUnionTypeEx(c, [getIntersectionTypeEx(c, typeSet, flags, undefined), c.nullType], 1 /* UnionReduction.Literal */, alias, undefined);
+            }
+            else if (typeSet.length >= 3 && types.length > 2) {
+                // Divide and conquer: (A & B) & (C & D).
+                const middle = typeSet.length >> 1;
+                result = getIntersectionTypeEx(c, [
+                    getIntersectionTypeEx(c, typeSet.slice(0, middle), flags, undefined),
+                    getIntersectionTypeEx(c, typeSet.slice(middle), flags, undefined),
+                ], flags, alias);
+            }
+            else {
+                if (!checkCrossProductUnion(c, typeSet))
+                    return c.errorType;
+                const constituents = getCrossProductIntersections(c, typeSet, flags);
+                let origin;
+                if (someHasFlags(constituents, 268435456 /* TypeFlags.Intersection */) &&
+                    getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet))
+                    origin = newIntersectionType(c, 0 /* ObjectFlags.None */, typeSet);
+                result = getUnionTypeEx(c, constituents, 1 /* UnionReduction.Literal */, alias, origin);
+            }
+        }
+        else {
+            result = newIntersectionType(c, objectFlags | getPropagatingFlagsOfTypes(types, 12 /* TypeFlags.Nullable */), typeSet);
+            result.alias = alias;
+        }
+        c.intersectionTypes.set(hash, keyTypes, keyAlias, keyTag, result);
+    }
+    return result;
+}
+export function isPrimitiveOrObjectOrEmptyType(c, t) {
+    return (t.flags & (12713980 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.NonPrimitive */)) !== 0 || isEmptyAnonymousObjectType(c, t);
+}
+export function containsMissingType(c, t) {
+    return t === c.missingType || ((t.flags & 134217728 /* TypeFlags.Union */) !== 0 && typesOf(t)[0] === c.missingType);
+}
+function someHasFlags(types, flags) {
+    for (const t of types)
+        if ((t.flags & flags) !== 0)
+            return true;
+    return false;
+}
+function everyIsUnionWithUndefined(types) {
+    for (const t of types)
+        if (!isUnionWithUndefined(t))
+            return false;
+    return true;
+}
+function everyIsUnionWithNull(types) {
+    for (const t of types)
+        if (!isUnionWithNull(t))
+            return false;
+    return true;
+}
+function isUnionWithUndefined(t) {
+    return (t.flags & 134217728 /* TypeFlags.Union */) !== 0 && (typesOf(t)[0].flags & 4 /* TypeFlags.Undefined */) !== 0;
+}
+function isUnionWithNull(t) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return false;
+    const types = typesOf(t);
+    return (types[0].flags & 8 /* TypeFlags.Null */) !== 0 || (types[1].flags & 8 /* TypeFlags.Null */) !== 0;
+}
+function removeRedundantSupertypes(c, types, includes) {
+    let i = types.length;
+    while (i > 0) {
+        i--;
+        const t = types[i];
+        const remove = ((t.flags & 32 /* TypeFlags.String */) !== 0 &&
+            (includes & (1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) !== 0) ||
+            ((t.flags & 64 /* TypeFlags.Number */) !== 0 && (includes & 2048 /* TypeFlags.NumberLiteral */) !== 0) ||
+            ((t.flags & 128 /* TypeFlags.BigInt */) !== 0 && (includes & 4096 /* TypeFlags.BigIntLiteral */) !== 0) ||
+            ((t.flags & 512 /* TypeFlags.ESSymbol */) !== 0 && (includes & 16384 /* TypeFlags.UniqueESSymbol */) !== 0) ||
+            ((t.flags & 16 /* TypeFlags.Void */) !== 0 && (includes & 4 /* TypeFlags.Undefined */) !== 0) ||
+            (isEmptyAnonymousObjectType(c, t) && (includes & 13893600 /* TypeFlags.DefinitelyNonNullable */) !== 0);
+        if (remove)
+            types.splice(i, 1);
+    }
+}
+/** Removes template literals that string literals satisfy; true if the intersection is empty. */
+function extractRedundantTemplateLiterals(c, types) {
+    const literals = [];
+    for (const t of types)
+        if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+            literals.push(t);
+    let i = types.length;
+    while (i > 0) {
+        i--;
+        const t = types[i];
+        if ((t.flags & (4194304 /* TypeFlags.TemplateLiteral */ | 8388608 /* TypeFlags.StringMapping */)) === 0)
+            continue;
+        for (const t2 of literals) {
+            if (isTypeSubtypeOf(c, t2, t)) {
+                types.splice(i, 1);
+                break;
+            }
+            if (isPatternLiteralType(c, t))
+                return true;
+        }
+    }
+    return false;
+}
+function intersectUnionsOfPrimitiveTypes(c, types) {
+    let index = 0;
+    while (index < types.length && (types[index].objectFlags & 32768 /* ObjectFlags.PrimitiveUnion */) === 0)
+        index++;
+    if (index === types.length)
+        return false;
+    const unionTypes = [types[index]];
+    let i = index + 1;
+    while (i < types.length) {
+        const t = types[i];
+        if ((t.objectFlags & 32768 /* ObjectFlags.PrimitiveUnion */) !== 0) {
+            unionTypes.push(t);
+            types.splice(i, 1);
+        }
+        else
+            i++;
+    }
+    if (unionTypes.length === 1)
+        return false;
+    const checked = [];
+    const result = [];
+    for (const u of unionTypes) {
+        for (const t of typesOf(u)) {
+            if (!insertType(c, checked, t))
+                continue;
+            if (!eachUnionContains(c, unionTypes, t))
+                continue;
+            // undefinedType and missingType sort first.
+            if (t === c.undefinedType && result.length !== 0 && result[0] === c.missingType)
+                continue;
+            if (t === c.missingType && result.length !== 0 && result[0] === c.undefinedType) {
+                result[0] = c.missingType;
+                continue;
+            }
+            insertType(c, result, t);
+        }
+    }
+    types[index] = getUnionTypeFromSortedList(c, result, 32768 /* ObjectFlags.PrimitiveUnion */, undefined, undefined);
+    return true;
+}
+function eachUnionContains(c, unionTypes, t) {
+    for (const type of unionTypes) {
+        const u = type;
+        if (unionContainsType(c, u, t))
+            continue;
+        if (t === c.missingType)
+            return unionContainsType(c, u, c.undefinedType);
+        if (t === c.undefinedType)
+            return unionContainsType(c, u, c.missingType);
+        let primitive;
+        if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+            primitive = c.stringType;
+        else if ((t.flags & (65536 /* TypeFlags.Enum */ | 2048 /* TypeFlags.NumberLiteral */)) !== 0)
+            primitive = c.numberType;
+        else if ((t.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+            primitive = c.bigintType;
+        else if ((t.flags & 16384 /* TypeFlags.UniqueESSymbol */) !== 0)
+            primitive = c.esSymbolType;
+        if (primitive === undefined || !unionContainsType(c, u, primitive))
+            return false;
+    }
+    return true;
+}
+export function getCrossProductUnionSize(types) {
+    let size = 1;
+    for (const t of types) {
+        if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0)
+            size *= typesOf(t).length;
+        else if ((t.flags & 262144 /* TypeFlags.Never */) !== 0)
+            return 0;
+    }
+    return size;
+}
+export function checkCrossProductUnion(c, types) {
+    const size = getCrossProductUnionSize(types);
+    if (size >= 100000) {
+        c.error(c.currentNode, 738 /* Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent */);
+        return false;
+    }
+    return true;
+}
+function getCrossProductIntersections(c, types, flags) {
+    if (allWithoutMembersToResolve(c, types)) {
+        const intersections = [];
+        addCrossProductIntersections(c, types, flags, types.slice(), 0, undefined, intersections);
+        return intersections;
+    }
+    const count = getCrossProductUnionSize(types);
+    const intersections = [];
+    for (let i = 0; i < count; i++) {
+        const constituents = types.slice();
+        let n = i;
+        for (let j = types.length - 1; j >= 0; j--) {
+            if ((types[j].flags & 134217728 /* TypeFlags.Union */) !== 0) {
+                const sourceTypes = typesOf(types[j]);
+                const length = sourceTypes.length;
+                constituents[j] = sourceTypes[n % length];
+                n = Math.trunc(n / length);
+            }
+        }
+        const t = getIntersectionTypeEx(c, constituents, flags, undefined);
+        if ((t.flags & 262144 /* TypeFlags.Never */) === 0)
+            intersections.push(t);
+    }
+    return intersections;
+}
+/**
+ * Adds the intersections of `constituents` with each combination of the constituents of `types` from
+ * position `index` on, in the order of `getCrossProductIntersections`, except the never ones. A
+ * combination with two distinct unit types (`unit` is the one taken before `index`) is never:
+ * `addTypeToIntersection` marks it NonPrimitive, which is disjoint from the domain of the first unit
+ * type, so `getIntersectionTypeEx` returns never before it creates or caches anything. Such
+ * combinations, and every combination extending them, are skipped without calling it.
+ */
+function addCrossProductIntersections(c, types, flags, constituents, index, unit, intersections) {
+    if (index === types.length) {
+        const t = getIntersectionTypeEx(c, constituents.slice(), flags, undefined);
+        if ((t.flags & 262144 /* TypeFlags.Never */) === 0)
+            intersections.push(t);
+        return;
+    }
+    const t = types[index];
+    const candidates = (t.flags & 134217728 /* TypeFlags.Union */) !== 0 ? typesOf(t) : [t];
+    for (const candidate of candidates) {
+        const candidateUnit = getIntersectionUnitType(c, candidate);
+        if (candidateUnit !== undefined && unit !== undefined && candidateUnit !== unit)
+            continue;
+        constituents[index] = candidate;
+        addCrossProductIntersections(c, types, flags, constituents, index + 1, unit ?? candidateUnit, intersections);
+    }
+}
+/**
+ * The unit type `t` adds to an intersection (`addTypeToIntersection`), or `undefined` when it adds
+ * none: regular literal types for fresh ones, undefined for the missing type, and no nullable type
+ * without strictNullChecks.
+ */
+function getIntersectionUnitType(c, t) {
+    if ((t.flags & 97292 /* TypeFlags.Unit */) === 0)
+        return undefined;
+    if (!c.strictNullChecks && (t.flags & 12 /* TypeFlags.Nullable */) !== 0)
+        return undefined;
+    const regular = getRegularTypeOfLiteralType(c, t);
+    return regular === c.missingType ? c.undefinedType : regular;
+}
+/**
+ * Whether adding `t`, or any constituent of the union `t`, to an intersection resolves nothing:
+ * `isEmptyAnonymousObjectType` reads the members of a type literal's symbol, which binds its late
+ * bound members the first time, unless the type's members are resolved already.
+ */
+function isIntersectionConstituentWithoutMembersToResolve(c, t) {
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0)
+        return allWithoutMembersToResolve(c, typesOf(t));
+    return ((t.objectFlags & 16 /* ObjectFlags.Anonymous */) === 0 ||
+        (t.flags & 1048576 /* TypeFlags.Object */) === 0 ||
+        (memberResolutionFlags(c, t) & 2097152 /* ObjectFlags.MembersResolved */) !== 0 ||
+        t.symbol === undefined ||
+        (t.symbol.flags & 2048 /* SymbolFlags.TypeLiteral */) === 0);
+}
+function allWithoutMembersToResolve(c, types) {
+    for (const t of types)
+        if (!isIntersectionConstituentWithoutMembersToResolve(c, t))
+            return false;
+    return true;
+}
+function getConstituentCount(t) {
+    if ((t.flags & 402653184 /* TypeFlags.UnionOrIntersection */) === 0 || t.alias !== undefined)
+        return 1;
+    if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0 && t.origin !== undefined)
+        return getConstituentCount(t.origin);
+    return getConstituentCountOfTypes(typesOf(t));
+}
+function getConstituentCountOfTypes(types) {
+    let n = 0;
+    for (const t of types)
+        n += getConstituentCount(t);
+    return n;
+}
+export function getUnionOrIntersectionType(c, types, isUnion, reduction) {
+    return isUnion ? getUnionTypeEx(c, types, reduction, undefined, undefined) : getIntersectionType(c, types);
+}
+// ---- Type references, arrays and tuples
+export function createTypeReference(c, target, typeArguments) {
+    return createTypeReferenceEx(c, target, typeArguments, 0 /* ObjectFlags.None */);
+}
+export function createTypeReferenceEx(c, target, typeArguments, objectFlags) {
+    const hash = typeListHash(typeArguments, undefined, 0);
+    const generic = sideOf(c, target);
+    let references = generic.references;
+    if (references === undefined) {
+        references = new ReferenceCache();
+        generic.references = references;
+    }
+    const existing = references.get(hash, typeArguments);
+    if (existing !== undefined)
+        return existing;
+    const type = newObjectType(c, 4 /* ObjectFlags.Reference */ | objectFlags | getPropagatingFlagsOfTypes(typeArguments, 0 /* TypeFlags.None */), target.symbol);
+    type.target = target;
+    type.resolvedTypeArguments = typeArguments;
+    references.add(hash, type);
+    return type;
+}
+export function tryCreateTypeReference(c, target, typeArguments) {
+    if (typeArguments.length !== 0 && target === c.emptyGenericType)
+        return c.unknownType;
+    return createTypeReference(c, target, typeArguments);
+}
+export function createDeferredTypeReference(c, target, node, mapper, alias) {
+    if (alias === undefined) {
+        // A reference written as a type alias's whole type goes by the alias.
+        alias = getAliasForTypeNode(c, node);
+        if (alias !== undefined && mapper !== undefined)
+            alias = new TypeAlias(alias.symbol, instantiateTypes(c, alias.typeArguments, mapper));
+    }
+    const type = newObjectType(c, 4 /* ObjectFlags.Reference */, target.symbol);
+    type.alias = alias;
+    type.target = target;
+    type.mapper = mapper;
+    type.node = node;
+    return type;
+}
+export function cloneTypeReference(c, source) {
+    const type = newObjectType(c, 4 /* ObjectFlags.Reference */, source.symbol);
+    // The clone keeps its own side state: a source's lazily computed state is not the clone's.
+    type.objectFlags =
+        (source.objectFlags & ~(2097152 /* ObjectFlags.MembersResolved */ | -2147483648 /* ObjectFlags.SideState */)) |
+            (type.objectFlags & -2147483648 /* ObjectFlags.SideState */);
+    type.target = source.target;
+    type.resolvedTypeArguments = source.resolvedTypeArguments ?? sideOfIfAny(c, source)?.resolvedTypeArguments;
+    return type;
+}
+export function createTypeFromGenericGlobalType(c, genericGlobalType, typeArguments) {
+    return genericGlobalType !== c.emptyGenericType
+        ? createTypeReference(c, genericGlobalType, typeArguments)
+        : c.emptyObjectType;
+}
+export function createArrayType(c, elementType) {
+    return createTypeFromGenericGlobalType(c, c.globalArrayType, [elementType]);
+}
+export function createArrayTypeEx(c, elementType, readonly) {
+    return createTypeFromGenericGlobalType(c, readonly ? c.globalReadonlyArrayType : c.globalArrayType, [elementType]);
+}
+export function isTupleType(t) {
+    return ((t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 &&
+        (t.target.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0);
+}
+export function tupleTargetOf(t) {
+    return t.target;
+}
+export function isGenericTupleType(t) {
+    return isTupleType(t) && (tupleTargetOf(t).combinedFlags & 8 /* ElementFlags.Variadic */) !== 0;
+}
+export function isArrayType(c, t) {
+    if ((t.objectFlags & 4 /* ObjectFlags.Reference */) === 0)
+        return false;
+    const target = t.target;
+    return target === c.globalArrayType || target === c.globalReadonlyArrayType;
+}
+export function isReadonlyArrayType(c, t) {
+    return (t.objectFlags & 4 /* ObjectFlags.Reference */) !== 0 && t.target === c.globalReadonlyArrayType;
+}
+export function isArrayOrTupleType(c, t) {
+    return isArrayType(c, t) || isTupleType(t);
+}
+export function isMutableArrayOrTuple(c, t) {
+    return (isArrayType(c, t) && !isReadonlyArrayType(c, t)) || (isTupleType(t) && !tupleTargetOf(t).readonly);
+}
+export function getTypeReferenceArity(t) {
+    return t.target.typeParameterCount();
+}
+export function getElementTypes(c, t) {
+    const typeArguments = getTypeArguments(c, t);
+    const arity = getTypeReferenceArity(t);
+    return typeArguments.length === arity ? typeArguments : typeArguments.slice(0, arity);
+}
+export function getStartElementCount(t, flags) {
+    for (let i = 0; i < t.elementInfos.length; i++)
+        if ((t.elementInfos[i].flags & flags) === 0)
+            return i;
+    return t.elementInfos.length;
+}
+export function getEndElementCount(t, flags) {
+    for (let i = t.elementInfos.length; i > 0; i--)
+        if ((t.elementInfos[i - 1].flags & flags) === 0)
+            return t.elementInfos.length - i;
+    return t.elementInfos.length;
+}
+export function getTotalFixedElementCount(t) {
+    return t.fixedLength + getEndElementCount(t, 3 /* ElementFlags.Fixed */);
+}
+export function createTupleType(c, elementTypes) {
+    const infos = [];
+    for (let i = 0; i < elementTypes.length; i++)
+        infos.push(new TupleElementInfo(1 /* ElementFlags.Required */, undefined));
+    return createTupleTypeEx(c, elementTypes, infos, false);
+}
+export function createTupleTypeEx(c, elementTypes, elementInfos, readonly) {
+    const tupleTarget = getTupleTargetType(c, elementInfos, readonly);
+    if (tupleTarget === c.emptyGenericType)
+        return c.emptyObjectType;
+    if (elementTypes.length !== 0)
+        return createNormalizedTypeReference(c, tupleTarget, elementTypes);
+    return tupleTarget;
+}
+function tupleKey(elementInfos, readonly) {
+    let key = '';
+    for (const e of elementInfos) {
+        if ((e.flags & 1 /* ElementFlags.Required */) !== 0)
+            key += '#';
+        else if ((e.flags & 2 /* ElementFlags.Optional */) !== 0)
+            key += '?';
+        else if ((e.flags & 4 /* ElementFlags.Rest */) !== 0)
+            key += '.';
+        else
+            key += '*';
+        if (e.labeledDeclaration !== undefined)
+            key += getNodeId(e.labeledDeclaration);
+    }
+    return readonly ? key + '!' : key;
+}
+export function getTupleTargetType(c, elementInfos, readonly) {
+    if (elementInfos.length === 1 && (elementInfos[0].flags & 4 /* ElementFlags.Rest */) !== 0)
+        return readonly ? c.globalReadonlyArrayType : c.globalArrayType;
+    const key = tupleKey(elementInfos, readonly);
+    let type = c.tupleTypes.get(key);
+    if (type === undefined) {
+        type = createTupleTargetType(c, elementInfos, readonly);
+        c.tupleTypes.set(key, type);
+    }
+    return type;
+}
+/** `interface Tuple<T0, T1, …> extends Array<T0 | T1 | …> { 0: T0, 1: T1, … }`, without a symbol. */
+function createTupleTargetType(c, elementInfos, readonly) {
+    const arity = elementInfos.length;
+    let minLength = 0;
+    for (const e of elementInfos)
+        if ((e.flags & (1 /* ElementFlags.Required */ | 8 /* ElementFlags.Variadic */)) !== 0)
+            minLength++;
+    const typeParameters = [];
+    const members = new Map();
+    let combinedFlags = 0 /* ElementFlags.None */;
+    for (let i = 0; i < arity; i++) {
+        const typeParameter = c.newTypeParameter(undefined);
+        typeParameters.push(typeParameter);
+        const flags = elementInfos[i].flags;
+        combinedFlags |= flags;
+        if ((combinedFlags & 12 /* ElementFlags.Variable */) === 0) {
+            const property = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */ | ((flags & 2 /* ElementFlags.Optional */) !== 0 ? 16777216 /* SymbolFlags.Optional */ : 0), String(i), readonly ? 8 /* CheckFlags.Readonly */ : 0 /* CheckFlags.None */);
+            c.symbolTypes.set(getSymbolId(property), typeParameter);
+            members.set(property.name, property);
+        }
+    }
+    const fixedLength = members.size;
+    const lengthSymbol = c.newSymbolWithCheckFlags(4 /* SymbolFlags.Property */, 'length', readonly ? 8 /* CheckFlags.Readonly */ : 0 /* CheckFlags.None */);
+    if ((combinedFlags & 12 /* ElementFlags.Variable */) !== 0)
+        c.symbolTypes.set(getSymbolId(lengthSymbol), c.numberType);
+    else {
+        const literalTypes = [];
+        for (let i = minLength; i <= arity; i++)
+            literalTypes.push(getNumberLiteralType(c, i));
+        c.symbolTypes.set(getSymbolId(lengthSymbol), getUnionType(c, literalTypes));
+    }
+    members.set(lengthSymbol.name, lengthSymbol);
+    const type = newObjectType(c, 8 /* ObjectFlags.Tuple */ | 4 /* ObjectFlags.Reference */, undefined);
+    const thisType = c.newTypeParameter(undefined);
+    thisType.isThisType = true;
+    thisType.constraint = type;
+    type.thisType = thisType;
+    typeParameters.push(thisType);
+    type.allTypeParameters = typeParameters;
+    const ownParameters = type.typeParameters();
+    type.target = type;
+    type.resolvedTypeArguments = ownParameters;
+    const references = new ReferenceCache();
+    sideOf(c, type).references = references;
+    references.add(typeListHash(ownParameters, undefined, 0), type);
+    const declared = sideOf(c, type);
+    declared.declaredMembersResolved = true;
+    declared.declaredMembers = members;
+    type.elementInfos = elementInfos;
+    type.minLength = minLength;
+    type.fixedLength = fixedLength;
+    type.combinedFlags = combinedFlags;
+    type.readonly = readonly;
+    return type;
+}
+export function createNormalizedTypeReference(c, target, typeArguments) {
+    if ((target.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0)
+        return createNormalizedTupleType(c, target, typeArguments, 0 /* ObjectFlags.None */);
+    return createTypeReference(c, target, typeArguments);
+}
+export function createNormalizedTupleType(c, target, elementTypes, objectFlags) {
+    if ((target.combinedFlags & 14 /* ElementFlags.NonRequired */) === 0)
+        return createTypeReferenceEx(c, target, elementTypes, objectFlags);
+    const infos = target.elementInfos;
+    if ((target.combinedFlags & 8 /* ElementFlags.Variadic */) !== 0) {
+        for (let i = 0; i < elementTypes.length; i++) {
+            const e = elementTypes[i];
+            if (i < infos.length &&
+                (infos[i].flags & 8 /* ElementFlags.Variadic */) !== 0 &&
+                (e.flags & (262144 /* TypeFlags.Never */ | 134217728 /* TypeFlags.Union */)) !== 0) {
+                // [A, ...(X | Y)] becomes [A, ...X] | [A, ...Y].
+                const checkTypes = [];
+                for (let j = 0; j < elementTypes.length; j++)
+                    checkTypes.push(j < infos.length && (infos[j].flags & 8 /* ElementFlags.Variadic */) !== 0 ? elementTypes[j] : c.unknownType);
+                if (checkCrossProductUnion(c, checkTypes)) {
+                    return mapType(c, e, (t) => {
+                        const replaced = elementTypes.slice();
+                        replaced[i] = t;
+                        return createNormalizedTupleType(c, target, replaced, objectFlags);
+                    });
+                }
+            }
+        }
+    }
+    const n = new TupleNormalizer(c);
+    if (!n.normalize(elementTypes.slice(0, infos.length), infos))
+        return c.errorType;
+    if (elementTypes.length > infos.length)
+        n.types.push(elementTypes[infos.length]);
+    const tupleTarget = getTupleTargetType(c, n.infos, target.readonly);
+    if (tupleTarget === c.emptyGenericType)
+        return c.emptyObjectType;
+    if (n.types.length !== 0)
+        return createTypeReferenceEx(c, tupleTarget, n.types, objectFlags);
+    return tupleTarget;
+}
+/**
+ * Normalizes tuple elements to required, then optional, then one rest element, or required,
+ * rest, required; generic variadic elements may appear anywhere.
+ */
+class TupleNormalizer {
+    c;
+    types = [];
+    infos = [];
+    lastRequiredIndex = -1;
+    firstRestIndex = -1;
+    lastOptionalOrRestIndex = -1;
+    constructor(c) {
+        this.c = c;
+    }
+    normalize(elementTypes, elementInfos) {
+        const c = this.c;
+        for (let i = 0; i < elementTypes.length; i++) {
+            const t = elementTypes[i];
+            const info = elementInfos[i];
+            if ((info.flags & 8 /* ElementFlags.Variadic */) === 0) {
+                this.add(t, info);
+                continue;
+            }
+            if ((t.flags & 1 /* TypeFlags.Any */) !== 0)
+                this.add(t, new TupleElementInfo(4 /* ElementFlags.Rest */, info.labeledDeclaration));
+            else if ((t.flags & 117964800 /* TypeFlags.InstantiableNonPrimitive */) !== 0 || isGenericMappedType(c, t))
+                this.add(t, info);
+            else if (isTupleType(t)) {
+                const spreadTypes = getElementTypes(c, t);
+                if (spreadTypes.length + this.types.length >= 10000) {
+                    c.error(c.currentNode, c.currentNode !== undefined && isPartOfTypeNode(c.currentNode)
+                        ? 931 /* Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent */
+                        : 932 /* Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent */);
+                    return false;
+                }
+                const spreadInfos = tupleTargetOf(t).elementInfos;
+                for (let j = 0; j < spreadTypes.length; j++)
+                    this.add(spreadTypes[j], spreadInfos[j]);
+            }
+            else {
+                const s = (isArrayLikeType(c, t) ? getIndexTypeOfType(c, t, c.numberType) : undefined) ?? c.errorType;
+                this.add(s, new TupleElementInfo(4 /* ElementFlags.Rest */, info.labeledDeclaration));
+            }
+        }
+        // Optional elements before the last required one become required.
+        for (let i = 0; i < this.lastRequiredIndex; i++) {
+            const info = this.infos[i];
+            if ((info.flags & 2 /* ElementFlags.Optional */) !== 0)
+                this.infos[i] = new TupleElementInfo(1 /* ElementFlags.Required */, info.labeledDeclaration);
+        }
+        if (this.firstRestIndex >= 0 && this.firstRestIndex < this.lastOptionalOrRestIndex) {
+            // Elements from the first rest to the last optional or rest become one rest element.
+            const types = [];
+            for (let i = this.firstRestIndex; i <= this.lastOptionalOrRestIndex; i++) {
+                let t = this.types[i];
+                if ((this.infos[i].flags & 8 /* ElementFlags.Variadic */) !== 0)
+                    t = getIndexedAccessType(c, t, c.numberType);
+                types.push(t);
+            }
+            this.types[this.firstRestIndex] = getUnionType(c, types);
+            const count = this.lastOptionalOrRestIndex - this.firstRestIndex;
+            this.types.splice(this.firstRestIndex + 1, count);
+            this.infos.splice(this.firstRestIndex + 1, count);
+        }
+        return true;
+    }
+    add(t, info) {
+        if ((info.flags & 1 /* ElementFlags.Required */) !== 0)
+            this.lastRequiredIndex = this.types.length;
+        if ((info.flags & 4 /* ElementFlags.Rest */) !== 0 && this.firstRestIndex < 0)
+            this.firstRestIndex = this.types.length;
+        if ((info.flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) !== 0)
+            this.lastOptionalOrRestIndex = this.types.length;
+        this.types.push(addOptionality(this.c, t, true, (info.flags & 2 /* ElementFlags.Optional */) !== 0));
+        this.infos.push(info);
+    }
+}
+/** Type arguments of a reference, resolving deferred ones from their type node. */
+export function getTypeArguments(c, t) {
+    const ref = t;
+    let resolved = ref.resolvedTypeArguments;
+    if (resolved !== undefined)
+        return resolved;
+    // A deferred reference resolves its type arguments on first use.
+    const side = sideOf(c, ref);
+    resolved = side.resolvedTypeArguments;
+    if (resolved !== undefined)
+        return resolved;
+    const target = ref.target;
+    const errors = () => {
+        const result = [];
+        for (let i = 0; i < target.typeParameterCount(); i++)
+            result.push(c.errorType);
+        return result;
+    };
+    if (!pushTypeResolution(c, t, 5 /* TypeSystemPropertyName.ResolvedTypeArguments */))
+        return errors();
+    const node = ref.node;
+    let typeArguments = emptyTypes;
+    if (node !== undefined)
+        typeArguments = getTypeArgumentsOfDeferredReference(c, node, target);
+    if (popTypeResolution(c)) {
+        resolved = side.resolvedTypeArguments;
+        if (resolved === undefined) {
+            resolved = instantiateTypes(c, typeArguments, ref.mapper);
+            side.resolvedTypeArguments = resolved;
+        }
+    }
+    else {
+        resolved = side.resolvedTypeArguments;
+        if (resolved === undefined) {
+            resolved = errors();
+            side.resolvedTypeArguments = resolved;
+        }
+        const errorNode = node ?? c.currentNode;
+        if (target.symbol !== undefined)
+            c.error(errorNode, 1095 /* Diagnostics.Type_arguments_for_0_circularly_reference_themselves */, symbolToString(c, target.symbol));
+        else
+            c.error(errorNode, 1096 /* Diagnostics.Tuple_type_arguments_circularly_reference_themselves */);
+    }
+    return resolved;
+}
+// ---- Template literals
+function everyHasFlags(types, flags) {
+    for (const t of types)
+        if ((t.flags & flags) === 0)
+            return false;
+    return true;
+}
+export function getTemplateLiteralType(c, texts, types) {
+    let unionIndex = 0;
+    while (unionIndex < types.length && (types[unionIndex].flags & (262144 /* TypeFlags.Never */ | 134217728 /* TypeFlags.Union */)) === 0)
+        unionIndex++;
+    if (unionIndex < types.length) {
+        // The distribution over a union depends only on the texts and types, so it is cached; results
+        // that reported a too complex union are not, so each such use reports it.
+        const key = 'templateLiteral:' + typeListKey(types) + '|' + texts.join('\u0000');
+        const cached = c.cachedTypes.get(key);
+        if (cached !== undefined)
+            return cached;
+        if (!checkCrossProductUnion(c, types))
+            return c.errorType;
+        const result = mapType(c, types[unionIndex], (t) => {
+            const replaced = types.slice();
+            replaced[unionIndex] = t;
+            return getTemplateLiteralType(c, texts, replaced);
+        });
+        c.cachedTypes.set(key, result);
+        return result;
+    }
+    if (types.includes(c.wildcardType))
+        return c.wildcardType;
+    const builder = new TemplateBuilder(c, texts[0]);
+    if (!builder.addSpans(texts, types))
+        return c.stringType;
+    if (builder.newTypes.length === 0)
+        return getStringLiteralType(c, builder.text);
+    builder.newTexts.push(builder.text);
+    const newTexts = builder.newTexts;
+    const newTypes = builder.newTypes;
+    if (newTexts.every((t) => t === '')) {
+        if (everyHasFlags(newTypes, 32 /* TypeFlags.String */))
+            return c.stringType;
+        // `${Mapping<xxx>}` is Mapping<xxx>.
+        if (newTypes.length === 1 && isPatternLiteralType(c, newTypes[0]))
+            return newTypes[0];
+    }
+    const key = newTexts.join('\u0000') + '|' + typeListKey(newTypes);
+    let type = c.templateLiteralTypes.get(key);
+    if (type === undefined) {
+        type = new TemplateLiteralType(c.nextTypeId(), newTexts, newTypes);
+        c.templateLiteralTypes.set(key, type);
+    }
+    return type;
+}
+class TemplateBuilder {
+    c;
+    text;
+    newTypes = [];
+    newTexts = [];
+    constructor(c, text) {
+        this.c = c;
+        this.text = text;
+    }
+    addSpans(texts, types) {
+        const c = this.c;
+        for (let i = 0; i < types.length; i++) {
+            const t = types[i];
+            if ((t.flags & (15360 /* TypeFlags.Literal */ | 8 /* TypeFlags.Null */ | 4 /* TypeFlags.Undefined */)) !== 0) {
+                this.text += getTemplateStringForType(c, t) + texts[i + 1];
+            }
+            else if ((t.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0) {
+                const template = t;
+                this.text += template.texts[0];
+                if (!this.addSpans(template.texts, template.types))
+                    return false;
+                this.text += texts[i + 1];
+            }
+            else if (isGenericIndexType(c, t) || isPatternLiteralPlaceholderType(c, t)) {
+                this.newTypes.push(t);
+                this.newTexts.push(this.text);
+                this.text = texts[i + 1];
+            }
+            else
+                return false;
+        }
+        return true;
+    }
+}
+export function getTemplateStringForType(c, t) {
+    if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+        return t.stringValue;
+    if ((t.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0)
+        return numberToString(t.numberValue);
+    if ((t.flags & (8192 /* TypeFlags.BooleanLiteral */ | 4096 /* TypeFlags.BigIntLiteral */)) !== 0)
+        return t.stringValue;
+    if ((t.flags & 12 /* TypeFlags.Nullable */) !== 0)
+        return t.intrinsicName;
+    return '';
+}
+/** JavaScript's Number::toString. */
+export function numberToString(value) {
+    return String(value);
+}