tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker-features.d.ts

@@ -0,0 +1,6 @@
+export interface FeatureMapEntry {
+    readonly lib: string;
+    readonly props: readonly string[];
+}
+/** Library features by global name, oldest library first. */
+export declare function getFeatureMap(): Map<string, readonly FeatureMapEntry[]>;

package/dist/api/compiler/checker-features.js

@@ -0,0 +1,354 @@
+// The library that adds each global and its members, for errors suggesting a newer `lib` setting.
+let features;
+/** Library features by global name, oldest library first. */
+export function getFeatureMap() {
+    features ??= new Map([
+        [
+            'Array',
+            [
+                { lib: 'es2015', props: ['find', 'findIndex', 'fill', 'copyWithin', 'entries', 'keys', 'values'] },
+                { lib: 'es2016', props: ['includes'] },
+                { lib: 'es2019', props: ['flat', 'flatMap'] },
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        ['Iterator', [{ lib: 'es2015', props: [] }]],
+        ['AsyncIterator', [{ lib: 'es2015', props: [] }]],
+        [
+            'ArrayBuffer',
+            [
+                {
+                    lib: 'es2024',
+                    props: ['maxByteLength', 'resizable', 'resize', 'detached', 'transfer', 'transferToFixedLength'],
+                },
+            ],
+        ],
+        [
+            'Atomics',
+            [
+                {
+                    lib: 'es2017',
+                    props: [
+                        'add',
+                        'and',
+                        'compareExchange',
+                        'exchange',
+                        'isLockFree',
+                        'load',
+                        'or',
+                        'store',
+                        'sub',
+                        'wait',
+                        'notify',
+                        'xor',
+                    ],
+                },
+                { lib: 'es2024', props: ['waitAsync'] },
+            ],
+        ],
+        [
+            'SharedArrayBuffer',
+            [
+                { lib: 'es2017', props: ['byteLength', 'slice'] },
+                { lib: 'es2024', props: ['growable', 'maxByteLength', 'grow'] },
+            ],
+        ],
+        ['AsyncIterable', [{ lib: 'es2018', props: [] }]],
+        ['AsyncIterableIterator', [{ lib: 'es2018', props: [] }]],
+        ['AsyncGenerator', [{ lib: 'es2018', props: [] }]],
+        ['AsyncGeneratorFunction', [{ lib: 'es2018', props: [] }]],
+        [
+            'RegExp',
+            [
+                { lib: 'es2015', props: ['flags', 'sticky', 'unicode'] },
+                { lib: 'es2018', props: ['dotAll'] },
+                { lib: 'es2024', props: ['unicodeSets'] },
+            ],
+        ],
+        ['RegExpConstructor', [{ lib: 'es2025', props: ['escape'] }]],
+        [
+            'Reflect',
+            [
+                {
+                    lib: 'es2015',
+                    props: [
+                        'apply',
+                        'construct',
+                        'defineProperty',
+                        'deleteProperty',
+                        'get',
+                        'getOwnPropertyDescriptor',
+                        'getPrototypeOf',
+                        'has',
+                        'isExtensible',
+                        'ownKeys',
+                        'preventExtensions',
+                        'set',
+                        'setPrototypeOf',
+                    ],
+                },
+            ],
+        ],
+        [
+            'ArrayConstructor',
+            [
+                { lib: 'es2015', props: ['from', 'of'] },
+                { lib: 'esnext', props: ['fromAsync'] },
+            ],
+        ],
+        [
+            'ObjectConstructor',
+            [
+                { lib: 'es2015', props: ['assign', 'getOwnPropertySymbols', 'keys', 'is', 'setPrototypeOf'] },
+                { lib: 'es2017', props: ['values', 'entries', 'getOwnPropertyDescriptors'] },
+                { lib: 'es2019', props: ['fromEntries'] },
+                { lib: 'es2022', props: ['hasOwn'] },
+                { lib: 'es2024', props: ['groupBy'] },
+            ],
+        ],
+        [
+            'NumberConstructor',
+            [{ lib: 'es2015', props: ['isFinite', 'isInteger', 'isNaN', 'isSafeInteger', 'parseFloat', 'parseInt'] }],
+        ],
+        [
+            'Math',
+            [
+                {
+                    lib: 'es2015',
+                    props: [
+                        'clz32',
+                        'imul',
+                        'sign',
+                        'log10',
+                        'log2',
+                        'log1p',
+                        'expm1',
+                        'cosh',
+                        'sinh',
+                        'tanh',
+                        'acosh',
+                        'asinh',
+                        'atanh',
+                        'hypot',
+                        'trunc',
+                        'fround',
+                        'cbrt',
+                    ],
+                },
+                { lib: 'es2025', props: ['f16round'] },
+            ],
+        ],
+        [
+            'Map',
+            [
+                { lib: 'es2015', props: ['entries', 'keys', 'values'] },
+                { lib: 'esnext', props: ['getOrInsert', 'getOrInsertComputed'] },
+            ],
+        ],
+        ['MapConstructor', [{ lib: 'es2024', props: ['groupBy'] }]],
+        [
+            'Set',
+            [
+                { lib: 'es2015', props: ['entries', 'keys', 'values'] },
+                {
+                    lib: 'es2025',
+                    props: [
+                        'union',
+                        'intersection',
+                        'difference',
+                        'symmetricDifference',
+                        'isSubsetOf',
+                        'isSupersetOf',
+                        'isDisjointFrom',
+                    ],
+                },
+            ],
+        ],
+        [
+            'PromiseConstructor',
+            [
+                { lib: 'es2015', props: ['all', 'race', 'reject', 'resolve'] },
+                { lib: 'es2020', props: ['allSettled'] },
+                { lib: 'es2021', props: ['any'] },
+                { lib: 'es2024', props: ['withResolvers'] },
+                { lib: 'es2025', props: ['try'] },
+            ],
+        ],
+        [
+            'Symbol',
+            [
+                { lib: 'es2015', props: ['for', 'keyFor'] },
+                { lib: 'es2019', props: ['description'] },
+            ],
+        ],
+        [
+            'WeakMap',
+            [
+                { lib: 'es2015', props: [] },
+                { lib: 'esnext', props: ['getOrInsert', 'getOrInsertComputed'] },
+            ],
+        ],
+        ['WeakSet', [{ lib: 'es2015', props: [] }]],
+        [
+            'String',
+            [
+                {
+                    lib: 'es2015',
+                    props: [
+                        'codePointAt',
+                        'includes',
+                        'endsWith',
+                        'normalize',
+                        'repeat',
+                        'startsWith',
+                        'anchor',
+                        'big',
+                        'blink',
+                        'bold',
+                        'fixed',
+                        'fontcolor',
+                        'fontsize',
+                        'italics',
+                        'link',
+                        'small',
+                        'strike',
+                        'sub',
+                        'sup',
+                    ],
+                },
+                { lib: 'es2017', props: ['padStart', 'padEnd'] },
+                { lib: 'es2019', props: ['trimStart', 'trimEnd', 'trimLeft', 'trimRight'] },
+                { lib: 'es2020', props: ['matchAll'] },
+                { lib: 'es2021', props: ['replaceAll'] },
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2024', props: ['isWellFormed', 'toWellFormed'] },
+            ],
+        ],
+        ['StringConstructor', [{ lib: 'es2015', props: ['fromCodePoint', 'raw'] }]],
+        ['DateTimeFormat', [{ lib: 'es2017', props: ['formatToParts'] }]],
+        [
+            'Promise',
+            [
+                { lib: 'es2015', props: [] },
+                { lib: 'es2018', props: ['finally'] },
+            ],
+        ],
+        ['RegExpMatchArray', [{ lib: 'es2018', props: ['groups'] }]],
+        ['RegExpExecArray', [{ lib: 'es2018', props: ['groups'] }]],
+        [
+            'Intl',
+            [
+                { lib: 'es2018', props: ['PluralRules'] },
+                { lib: 'es2020', props: ['RelativeTimeFormat', 'Locale', 'DisplayNames'] },
+                { lib: 'es2021', props: ['ListFormat', 'DateTimeFormat'] },
+                { lib: 'es2022', props: ['Segmenter'] },
+                { lib: 'es2025', props: ['DurationFormat'] },
+            ],
+        ],
+        ['NumberFormat', [{ lib: 'es2018', props: ['formatToParts'] }]],
+        [
+            'SymbolConstructor',
+            [
+                { lib: 'es2020', props: ['matchAll'] },
+                { lib: 'esnext', props: ['metadata', 'dispose', 'asyncDispose'] },
+            ],
+        ],
+        [
+            'DataView',
+            [
+                { lib: 'es2020', props: ['setBigInt64', 'setBigUint64', 'getBigInt64', 'getBigUint64'] },
+                { lib: 'es2025', props: ['setFloat16', 'getFloat16'] },
+            ],
+        ],
+        ['BigInt', [{ lib: 'es2020', props: [] }]],
+        ['RelativeTimeFormat', [{ lib: 'es2020', props: ['format', 'formatToParts', 'resolvedOptions'] }]],
+        [
+            'Int8Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'Uint8Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'Uint8ClampedArray',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'Int16Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'Uint16Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'Int32Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'Uint32Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        ['Float16Array', [{ lib: 'es2025', props: [] }]],
+        [
+            'Float32Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'Float64Array',
+            [
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'BigInt64Array',
+            [
+                { lib: 'es2020', props: [] },
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        [
+            'BigUint64Array',
+            [
+                { lib: 'es2020', props: [] },
+                { lib: 'es2022', props: ['at'] },
+                { lib: 'es2023', props: ['findLastIndex', 'findLast', 'toReversed', 'toSorted', 'toSpliced', 'with'] },
+            ],
+        ],
+        ['Error', [{ lib: 'es2022', props: ['cause'] }]],
+        ['ErrorConstructor', [{ lib: 'esnext', props: ['isError'] }]],
+        ['Uint8ArrayConstructor', [{ lib: 'esnext', props: ['fromBase64', 'fromHex'] }]],
+        ['DisposableStack', [{ lib: 'esnext', props: [] }]],
+        ['AsyncDisposableStack', [{ lib: 'esnext', props: [] }]],
+        ['Date', [{ lib: 'esnext', props: ['toTemporalInstant'] }]],
+    ]);
+    return features;
+}

package/dist/api/compiler/checker-flow.d.ts

@@ -0,0 +1,86 @@
+import type { Checker } from './checker.js';
+import { type Type } from './checker-types.js';
+export declare const enum TypeFacts {
+    None = 0,
+    TypeofEQString = 1,
+    TypeofEQNumber = 2,
+    TypeofEQBigInt = 4,
+    TypeofEQBoolean = 8,
+    TypeofEQSymbol = 16,
+    TypeofEQObject = 32,
+    TypeofEQFunction = 64,
+    TypeofEQHostObject = 128,
+    TypeofNEString = 256,
+    TypeofNENumber = 512,
+    TypeofNEBigInt = 1024,
+    TypeofNEBoolean = 2048,
+    TypeofNESymbol = 4096,
+    TypeofNEObject = 8192,
+    TypeofNEFunction = 16384,
+    TypeofNEHostObject = 32768,
+    EQUndefined = 65536,
+    EQNull = 131072,
+    EQUndefinedOrNull = 262144,
+    NEUndefined = 524288,
+    NENull = 1048576,
+    NEUndefinedOrNull = 2097152,
+    Truthy = 4194304,
+    Falsy = 8388608,
+    IsUndefined = 16777216,
+    IsNull = 33554432,
+    IsUndefinedOrNull = 50331648,
+    All = 134217727,
+    BaseStringStrictFacts = 3735041,
+    BaseStringFacts = 12582401,
+    StringStrictFacts = 16317953,
+    StringFacts = 16776705,
+    EmptyStringStrictFacts = 12123649,
+    EmptyStringFacts = 12582401,
+    NonEmptyStringStrictFacts = 7929345,
+    NonEmptyStringFacts = 16776705,
+    BaseNumberStrictFacts = 3734786,
+    BaseNumberFacts = 12582146,
+    NumberStrictFacts = 16317698,
+    NumberFacts = 16776450,
+    ZeroNumberStrictFacts = 12123394,
+    ZeroNumberFacts = 12582146,
+    NonZeroNumberStrictFacts = 7929090,
+    NonZeroNumberFacts = 16776450,
+    BaseBigIntStrictFacts = 3734276,
+    BaseBigIntFacts = 12581636,
+    BigIntStrictFacts = 16317188,
+    BigIntFacts = 16775940,
+    ZeroBigIntStrictFacts = 12122884,
+    ZeroBigIntFacts = 12581636,
+    NonZeroBigIntStrictFacts = 7928580,
+    NonZeroBigIntFacts = 16775940,
+    BaseBooleanStrictFacts = 3733256,
+    BaseBooleanFacts = 12580616,
+    BooleanStrictFacts = 16316168,
+    BooleanFacts = 16774920,
+    FalseStrictFacts = 12121864,
+    FalseFacts = 12580616,
+    TrueStrictFacts = 7927560,
+    TrueFacts = 16774920,
+    SymbolStrictFacts = 7925520,
+    SymbolFacts = 16772880,
+    ObjectStrictFacts = 7888800,
+    ObjectFacts = 16736160,
+    FunctionStrictFacts = 7880640,
+    FunctionFacts = 16728000,
+    VoidFacts = 9830144,
+    UndefinedFacts = 26607360,
+    NullFacts = 42917664,
+    EmptyObjectStrictFacts = 83427327,
+    EmptyObjectFacts = 83886079,
+    UnknownFacts = 83886079,
+    AllTypeofNE = 556800,
+    OrFactsMask = 8256,
+    AndFactsMask = 134209471
+}
+export declare function getTypeFacts(c: Checker, t: Type, mask: TypeFacts): TypeFacts;
+export declare function hasTypeFacts(c: Checker, t: Type, mask: TypeFacts): boolean;
+export declare function getTypeWithFacts(c: Checker, t: Type, include: TypeFacts): Type;
+/** Like getTypeWithFacts, but expands `unknown` and intersects instantiable types to remove nullables. */
+export declare function getAdjustedTypeWithFacts(c: Checker, t: Type, facts: TypeFacts): Type;
+export declare function getNonNullableType(c: Checker, t: Type): Type;

package/dist/api/compiler/checker-flow.js

@@ -0,0 +1,169 @@
+import { filterType, getIntersectionType, getUnionType, isEmptyObjectType, mapType, typesOf, } from './checker-type-factory.js';
+import { getResolvedMember, getBaseConstraintOfType, resolveStructuredTypeMembers } from './checker-members.js';
+import { isTypeSubtypeOf } from './relations.js';
+import { maybeTypeOfKind } from './checker-utilities.js';
+import { getGlobalTypeAliasSymbol } from './checker-symbols.js';
+import { getTypeAliasInstantiation } from './checker-type-nodes.js';
+export function getTypeFacts(c, t, mask) {
+    return getTypeFactsWorker(c, t, mask) & mask;
+}
+export function hasTypeFacts(c, t, mask) {
+    return getTypeFacts(c, t, mask) !== 0;
+}
+function getTypeFactsWorker(c, t, callerOnlyNeeds) {
+    if ((t.flags & (268435456 /* TypeFlags.Intersection */ | 132644864 /* TypeFlags.Instantiable */)) !== 0)
+        t = getBaseConstraintOfType(c, t) ?? c.unknownType;
+    const flags = t.flags;
+    const strict = c.strictNullChecks;
+    if ((flags & (32 /* TypeFlags.String */ | 8388608 /* TypeFlags.StringMapping */)) !== 0)
+        return strict ? 16317953 /* TypeFacts.StringStrictFacts */ : 16776705 /* TypeFacts.StringFacts */;
+    if ((flags & (1024 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.TemplateLiteral */)) !== 0) {
+        const isEmpty = (flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && t.stringValue === '';
+        return strict
+            ? isEmpty
+                ? 12123649 /* TypeFacts.EmptyStringStrictFacts */
+                : 7929345 /* TypeFacts.NonEmptyStringStrictFacts */
+            : isEmpty
+                ? 12582401 /* TypeFacts.EmptyStringFacts */
+                : 16776705 /* TypeFacts.NonEmptyStringFacts */;
+    }
+    if ((flags & (64 /* TypeFlags.Number */ | 65536 /* TypeFlags.Enum */)) !== 0)
+        return strict ? 16317698 /* TypeFacts.NumberStrictFacts */ : 16776450 /* TypeFacts.NumberFacts */;
+    if ((flags & 2048 /* TypeFlags.NumberLiteral */) !== 0) {
+        const isZero = t.numberValue === 0;
+        return strict
+            ? isZero
+                ? 12123394 /* TypeFacts.ZeroNumberStrictFacts */
+                : 7929090 /* TypeFacts.NonZeroNumberStrictFacts */
+            : isZero
+                ? 12582146 /* TypeFacts.ZeroNumberFacts */
+                : 16776450 /* TypeFacts.NonZeroNumberFacts */;
+    }
+    if ((flags & 128 /* TypeFlags.BigInt */) !== 0)
+        return strict ? 16317188 /* TypeFacts.BigIntStrictFacts */ : 16775940 /* TypeFacts.BigIntFacts */;
+    if ((flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0) {
+        const isZero = t.stringValue === '0';
+        return strict
+            ? isZero
+                ? 12122884 /* TypeFacts.ZeroBigIntStrictFacts */
+                : 7928580 /* TypeFacts.NonZeroBigIntStrictFacts */
+            : isZero
+                ? 12581636 /* TypeFacts.ZeroBigIntFacts */
+                : 16775940 /* TypeFacts.NonZeroBigIntFacts */;
+    }
+    if ((flags & 256 /* TypeFlags.Boolean */) !== 0)
+        return strict ? 16316168 /* TypeFacts.BooleanStrictFacts */ : 16774920 /* TypeFacts.BooleanFacts */;
+    if ((flags & 8448 /* TypeFlags.BooleanLike */) !== 0) {
+        const isFalse = t === c.falseType || t === c.regularFalseType;
+        return strict
+            ? isFalse
+                ? 12121864 /* TypeFacts.FalseStrictFacts */
+                : 7927560 /* TypeFacts.TrueStrictFacts */
+            : isFalse
+                ? 12580616 /* TypeFacts.FalseFacts */
+                : 16774920 /* TypeFacts.TrueFacts */;
+    }
+    if ((flags & 1048576 /* TypeFlags.Object */) !== 0) {
+        const possible = strict
+            ? 83427327 /* TypeFacts.EmptyObjectStrictFacts */ | 7880640 /* TypeFacts.FunctionStrictFacts */ | 7888800 /* TypeFacts.ObjectStrictFacts */
+            : 83886079 /* TypeFacts.EmptyObjectFacts */ | 16728000 /* TypeFacts.FunctionFacts */ | 16736160 /* TypeFacts.ObjectFacts */;
+        // Skip resolving members when the caller can't use the result.
+        if ((callerOnlyNeeds & possible) === 0)
+            return 0 /* TypeFacts.None */;
+        if ((t.objectFlags & 16 /* ObjectFlags.Anonymous */) !== 0 && isEmptyObjectType(c, t))
+            return strict ? 83427327 /* TypeFacts.EmptyObjectStrictFacts */ : 83886079 /* TypeFacts.EmptyObjectFacts */;
+        if (isFunctionObjectType(c, t))
+            return strict ? 7880640 /* TypeFacts.FunctionStrictFacts */ : 16728000 /* TypeFacts.FunctionFacts */;
+        return strict ? 7888800 /* TypeFacts.ObjectStrictFacts */ : 16736160 /* TypeFacts.ObjectFacts */;
+    }
+    if ((flags & 16 /* TypeFlags.Void */) !== 0)
+        return 9830144 /* TypeFacts.VoidFacts */;
+    if ((flags & 4 /* TypeFlags.Undefined */) !== 0)
+        return 26607360 /* TypeFacts.UndefinedFacts */;
+    if ((flags & 8 /* TypeFlags.Null */) !== 0)
+        return 42917664 /* TypeFacts.NullFacts */;
+    if ((flags & 16896 /* TypeFlags.ESSymbolLike */) !== 0)
+        return strict ? 7925520 /* TypeFacts.SymbolStrictFacts */ : 16772880 /* TypeFacts.SymbolFacts */;
+    if ((flags & 131072 /* TypeFlags.NonPrimitive */) !== 0)
+        return strict ? 7888800 /* TypeFacts.ObjectStrictFacts */ : 16736160 /* TypeFacts.ObjectFacts */;
+    if ((flags & 262144 /* TypeFlags.Never */) !== 0)
+        return 0 /* TypeFacts.None */;
+    if ((flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        let facts = 0 /* TypeFacts.None */;
+        for (const u of typesOf(t))
+            facts |= getTypeFactsWorker(c, u, callerOnlyNeeds);
+        return facts;
+    }
+    if ((flags & 268435456 /* TypeFlags.Intersection */) !== 0)
+        return getIntersectionTypeFacts(c, t, callerOnlyNeeds);
+    return 83886079 /* TypeFacts.UnknownFacts */;
+}
+function getIntersectionTypeFacts(c, t, callerOnlyNeeds) {
+    // With a primitive, object constituents are type tags and ignored.
+    const ignoreObjects = maybeTypeOfKind(t, 12713980 /* TypeFlags.Primitive */);
+    let ored = 0 /* TypeFacts.None */;
+    let anded = 134217727 /* TypeFacts.All */;
+    for (const u of typesOf(t)) {
+        if (ignoreObjects && (u.flags & 1048576 /* TypeFlags.Object */) !== 0)
+            continue;
+        const f = getTypeFactsWorker(c, u, callerOnlyNeeds);
+        ored |= f;
+        anded &= f;
+    }
+    return (ored & 8256 /* TypeFacts.OrFactsMask */) | (anded & 134209471 /* TypeFacts.AndFactsMask */);
+}
+function isFunctionObjectType(c, t) {
+    if ((t.objectFlags & 256 /* ObjectFlags.EvolvingArray */) !== 0)
+        return false;
+    const resolved = resolveStructuredTypeMembers(c, t);
+    return (resolved.callSignatures.length !== 0 ||
+        resolved.constructSignatures.length !== 0 ||
+        (getResolvedMember(resolved, 'bind') !== undefined && isTypeSubtypeOf(c, t, c.globalFunctionType)));
+}
+export function getTypeWithFacts(c, t, include) {
+    // Filter non-unions without a closure (as filterType would).
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return (t.flags & 262144 /* TypeFlags.Never */) !== 0 || hasTypeFacts(c, t, include) ? t : c.neverType;
+    return filterType(c, t, (u) => hasTypeFacts(c, u, include));
+}
+/** Like getTypeWithFacts, but expands `unknown` and intersects instantiable types to remove nullables. */
+export function getAdjustedTypeWithFacts(c, t, facts) {
+    let reduced = getTypeWithFacts(c, c.strictNullChecks && (t.flags & 2 /* TypeFlags.Unknown */) !== 0 ? c.unknownUnionType : t, facts);
+    if (reduced === c.unknownUnionType)
+        reduced = c.unknownType;
+    if (!c.strictNullChecks)
+        return reduced;
+    switch (facts) {
+        case 524288 /* TypeFacts.NEUndefined */:
+            return removeNullableByIntersection(c, reduced, 65536 /* TypeFacts.EQUndefined */, 131072 /* TypeFacts.EQNull */, 33554432 /* TypeFacts.IsNull */, c.nullType);
+        case 1048576 /* TypeFacts.NENull */:
+            return removeNullableByIntersection(c, reduced, 131072 /* TypeFacts.EQNull */, 65536 /* TypeFacts.EQUndefined */, 16777216 /* TypeFacts.IsUndefined */, c.undefinedType);
+        case 2097152 /* TypeFacts.NEUndefinedOrNull */:
+        case 4194304 /* TypeFacts.Truthy */:
+            return mapType(c, reduced, (u) => hasTypeFacts(c, u, 262144 /* TypeFacts.EQUndefinedOrNull */) ? getGlobalNonNullableTypeInstantiation(c, u) : u);
+    }
+    return reduced;
+}
+/** `NonNullable<T>`, or `T & {}` without the global alias. */
+function getGlobalNonNullableTypeInstantiation(c, t) {
+    const alias = getGlobalTypeAliasSymbol(c, 'NonNullable', 1, false);
+    return alias !== undefined
+        ? getTypeAliasInstantiation(c, alias, [t], undefined)
+        : getIntersectionType(c, [t, c.emptyObjectType]);
+}
+function removeNullableByIntersection(c, t, targetFacts, otherFacts, otherIncludesFacts, otherType) {
+    const facts = getTypeFacts(c, t, 65536 /* TypeFacts.EQUndefined */ | 131072 /* TypeFacts.EQNull */ | 16777216 /* TypeFacts.IsUndefined */ | 33554432 /* TypeFacts.IsNull */);
+    if ((facts & targetFacts) === 0)
+        return t;
+    const emptyAndOtherUnion = getUnionType(c, [c.emptyObjectType, otherType]);
+    return mapType(c, t, (u) => {
+        if (!hasTypeFacts(c, u, targetFacts))
+            return u;
+        if ((facts & otherIncludesFacts) === 0 && hasTypeFacts(c, u, otherFacts))
+            return getIntersectionType(c, [u, emptyAndOtherUnion]);
+        return getIntersectionType(c, [u, c.emptyObjectType]);
+    });
+}
+export function getNonNullableType(c, t) {
+    return c.strictNullChecks ? getAdjustedTypeWithFacts(c, t, 2097152 /* TypeFacts.NEUndefinedOrNull */) : t;
+}

package/dist/api/compiler/checker-functions.d.ts

@@ -0,0 +1,43 @@
+import { type Block, type Node, type ReturnStatement } from './ast.js';
+import { type Checker } from './checker.js';
+import { type Type, TypePredicate } from './checker-types.js';
+import { WideningKind } from './checker-symbol-types.js';
+import { CheckMode } from './checker-types.js';
+export declare function checkFunctionExpressionOrObjectLiteralMethod(c: Checker, node: Node, checkMode: CheckMode): Type;
+export declare function getTypeOfObjectLiteralMethod(c: Checker, node: Node, checkMode: CheckMode): Type;
+/**
+ * Checks a function's signature and body. The signature of a function expression or object literal
+ * method is checked earlier, while its contextual parameter types are assigned.
+ */
+export declare function checkFunctionLikeBody(c: Checker, node: Node): void;
+export declare function isUnwrappedReturnTypeUndefinedVoidOrAny(c: Checker, func: Node, returnType: Type): boolean;
+/**
+ * Checks a returned expression against the unwrapped return type; `node` is the return statement,
+ * or the expression body of an arrow function. Conditional expressions are checked by branch.
+ */
+export declare function checkReturnExpression(c: Checker, container: Node, unwrappedReturnType: Type, node: Node, expr: Node | undefined, exprType: Type, inConditionalExpression: boolean): void;
+/** `node` without parentheses and `satisfies`. */
+export declare function checkAwaitExpression(c: Checker, node: Node): Type;
+export declare function checkYieldExpression(c: Checker, node: Node): Type;
+/** Whether checking `node` depends on its contextual type. */
+export declare function isContextSensitive(c: Checker, node: Node): boolean;
+/**
+ * The type predicate a function without a return type annotation implies, as `x is string` for
+ * `(x: string | number) => typeof x === "string"`: its single return expression must narrow a parameter
+ * to a type in the true branch and to `never` from that type in the false branch.
+ */
+export declare function getTypePredicateFromBody(c: Checker, fn: Node): TypePredicate | undefined;
+/** The return type inferred from a function's body. */
+export declare function getReturnTypeFromBody(c: Checker, func: Node): Type;
+export declare function getReturnTypeFromBodyEx(c: Checker, func: Node, checkMode: CheckMode): Type;
+/**
+ * Whether the widened types inferred for a function report implicit `any`: without a contextual
+ * signature, or when the contextual return, yield or next type is generic.
+ */
+export declare function shouldReportErrorsFromWideningWithContextualSignature(c: Checker, declaration: Node, wideningKind: WideningKind): boolean;
+/** Collects the return statements of a function body, skipping nested functions and classes. */
+export declare class ReturnCollector {
+    readonly returns: ReturnStatement[];
+    visitStatements(block: Block): void;
+    visit(node: Node): void;
+}