=== tests/cases/conformance/types/literal/templateLiteralTypes4.ts ===
// infer from number
type TNumber0 = "100" extends `${infer N extends number}` ? N : never; // 100
>TNumber0 : 100

type TNumber1 = "-100" extends `${infer N extends number}` ? N : never; // -100
>TNumber1 : -100

type TNumber2 = "1.1" extends `${infer N extends number}` ? N : never; // 1.1
>TNumber2 : 1.1

type TNumber3 = "8e-11" extends `${infer N extends number}` ? N : never; // 8e-11 (0.00000000008)
>TNumber3 : 8e-11

type TNumber4 = "0x10" extends `${infer N extends number}` ? N : never; // number (not round-trippable)
>TNumber4 : number

type TNumber5 = "0o10" extends `${infer N extends number}` ? N : never; // number (not round-trippable)
>TNumber5 : number

type TNumber6 = "0b10" extends `${infer N extends number}` ? N : never; // number (not round-trippable)
>TNumber6 : number

type TNumber7 = "10e2" extends `${infer N extends number}` ? N : never; // number (not round-trippable)
>TNumber7 : number

type TNumber8 = "abcd" extends `${infer N extends number}` ? N : never; // never
>TNumber8 : never

// infer from bigint
type TBigInt0 = "100" extends `${infer N extends bigint}` ? N : never; // 100n
>TBigInt0 : 100n

type TBigInt1 = "-100" extends `${infer N extends bigint}` ? N : never; // -100n
>TBigInt1 : -100n

type TBigInt2 = "0x10" extends `${infer N extends bigint}` ? N : never; // bigint (not round-trippable)
>TBigInt2 : bigint

type TBigInt3 = "0o10" extends `${infer N extends bigint}` ? N : never; // bigint (not round-trippable)
>TBigInt3 : bigint

type TBigInt4 = "0b10" extends `${infer N extends bigint}` ? N : never; // bigint (not round-trippable)
>TBigInt4 : bigint

type TBigInt5 = "1.1" extends `${infer N extends bigint}` ? N : never; // never
>TBigInt5 : never

type TBigInt6 = "10e2" extends `${infer N extends bigint}` ? N : never; // never
>TBigInt6 : never

type TBigInt7 = "abcd" extends `${infer N extends bigint}` ? N : never; // never
>TBigInt7 : never

// infer from boolean
type TBoolean0 = "true" extends `${infer T extends boolean}` ? T : never; // true
>TBoolean0 : true

type TBoolean1 = "false" extends `${infer T extends boolean}` ? T : never; // false
>TBoolean1 : false

type TBoolean2 = "abcd" extends `${infer T extends boolean}` ? T : never; // never
>TBoolean2 : never

// infer from null
type TNull0 = "null" extends `${infer T extends null}` ? T : never; // null
>TNull0 : null
>null : null

type TNull1 = "abcd" extends `${infer T extends null}` ? T : never; // never
>TNull1 : never
>null : null

// infer from undefined
type TUndefined0 = "undefined" extends `${infer T extends undefined}` ? T : never; // undefined
>TUndefined0 : undefined

type TUndefined1 = "abcd" extends `${infer T extends undefined}` ? T : never; // never
>TUndefined1 : never

// infer from literal enums
const enum StringLiteralEnum { Zero = "0", True = "true", False = "false", Undefined = "undefined", Null = "null" }
>StringLiteralEnum : StringLiteralEnum
>Zero : StringLiteralEnum.Zero
>"0" : "0"
>True : StringLiteralEnum.True
>"true" : "true"
>False : StringLiteralEnum.False
>"false" : "false"
>Undefined : StringLiteralEnum.Undefined
>"undefined" : "undefined"
>Null : StringLiteralEnum.Null
>"null" : "null"

type TStringLiteralEnum0 = "0" extends `${infer T extends StringLiteralEnum}` ? T : never; // StringLiteralEnum.Zero
>TStringLiteralEnum0 : StringLiteralEnum.Zero

const enum NumberLiteralEnum { Zero, One }
>NumberLiteralEnum : NumberLiteralEnum
>Zero : NumberLiteralEnum.Zero
>One : NumberLiteralEnum.One

type TNumberLiteralEnum0 = "0" extends `${infer T extends NumberLiteralEnum}` ? T : never; // NumberLiteralEnum.Zero
>TNumberLiteralEnum0 : NumberLiteralEnum.Zero

// infer from non-literal enums
const enum NonLiteralEnum { Zero = NumberLiteralEnum.Zero, One = NumberLiteralEnum.One }
>NonLiteralEnum : NonLiteralEnum
>Zero : NonLiteralEnum
>NumberLiteralEnum.Zero : NumberLiteralEnum.Zero
>NumberLiteralEnum : typeof NumberLiteralEnum
>Zero : NumberLiteralEnum.Zero
>One : NonLiteralEnum
>NumberLiteralEnum.One : NumberLiteralEnum.One
>NumberLiteralEnum : typeof NumberLiteralEnum
>One : NumberLiteralEnum.One

type TNonLiteralEnum0 = "0" extends `${infer T extends NonLiteralEnum}` ? T : never; // 0
>TNonLiteralEnum0 : 0

// infer using priority:
//     string > template-literal > (string-literal | string-literal-enum) >
//     number > enum > (number-literal | number-literal-enum) >
//     bigint > bigint-literal > 
//     boolean > (boolean-literal | undefined | null)

// #region string
// string > string-literal-enum
type PString00 = "0" extends `${infer T extends string | StringLiteralEnum}` ? T : never; // "0"
>PString00 : "0"

// string > number
type PString01 = "0" extends `${infer T extends string | number}` ? T : never; // "0"
>PString01 : "0"

// string > enum
type PString02 = "0" extends `${infer T extends string | NonLiteralEnum}` ? T : never; // "0"
>PString02 : "0"

// string > (number-literal | number-literal-enum)
type PString03 = "0" extends `${infer T extends string | 0}` ? T : never; // "0"
>PString03 : "0"

type PString04 = "0" extends `${infer T extends string | NumberLiteralEnum}` ? T : never; // "0"
>PString04 : "0"

// string > bigint
type PString05 = "0" extends `${infer T extends string | bigint}` ? T : never; // "0"
>PString05 : "0"

// string > bigint-literal
type PString06 = "0" extends `${infer T extends string | 0n}` ? T : never; // "0"
>PString06 : "0"

// string > boolean
type PString07 = "true" extends `${infer T extends string | boolean}` ? T : never; // "true"
>PString07 : "true"

type PString08 = "false" extends `${infer T extends string | boolean}` ? T : never; // "false"
>PString08 : "false"

// string > (boolean-literal | undefined | null)
type PString09 = "true" extends `${infer T extends string | true}` ? T : never; // "true"
>PString09 : "true"
>true : true

type PString10 = "false" extends `${infer T extends string | false}` ? T : never; // "false"
>PString10 : "false"
>false : false

type PString11 = "undefined" extends `${infer T extends string | undefined}` ? T : never; // "undefined"
>PString11 : "undefined"

type PString12 = "null" extends `${infer T extends string | null}` ? T : never; // "null"
>PString12 : "null"
>null : null

// #endregion string

// #region template-literal
// template-literal > number
type PTemplate00 = "10" extends `${infer T extends `1${string}` | number}` ? T : never; // "10"
>PTemplate00 : "10"

// template-literal > enum
type PTemplate01 = "10" extends `${infer T extends `1${string}` | NonLiteralEnum}` ? T : never; // "10"
>PTemplate01 : "10"

// template-literal > (number-literal | number-literal-enum)
type PTemplate02 = "10" extends `${infer T extends `1${string}` | 10}` ? T : never; // "10"
>PTemplate02 : "10"

type PTemplate03 = "10" extends `${infer T extends `1${string}` | NumberLiteralEnum}` ? T : never; // "10"
>PTemplate03 : "10"

// template-literal > bigint
type PTemplate04 = "10" extends `${infer T extends `1${string}` | bigint}` ? T : never; // "10"
>PTemplate04 : "10"

// template-literal > bigint-literal
type PTemplate05 = "10" extends `${infer T extends `1${string}` | 10n}` ? T : never; // "10"
>PTemplate05 : "10"

// template-literal > boolean
type PTemplate06 = "true" extends `${infer T extends `${string}e` | boolean}` ? T : never; // "true"
>PTemplate06 : "true"

type PTemplate07 = "false" extends `${infer T extends `${string}e` | boolean}` ? T : never; // "false"
>PTemplate07 : "false"

// template-literal > (boolean-literal | undefined | null)
type PTemplate08 = "true" extends `${infer T extends `${"t"}${string}` | true}` ? T : never; // "true"
>PTemplate08 : "true"
>true : true

type PTemplate09 = "false" extends `${infer T extends `${"f"}${string}` | false}` ? T : never; // "false"
>PTemplate09 : "false"
>false : false

type PTemplate10 = "undefined" extends `${infer T extends `${"u"}${string}` | undefined}` ? T : never; // "undefined"
>PTemplate10 : "undefined"

type PTemplate11 = "null" extends `${infer T extends `${"n"}${string}` | null}` ? T : never; // "null"
>PTemplate11 : "null"
>null : null

// #endregion template-literal

// #region string-literal
// string-literal > number
type PStringLiteral00 = "0" extends `${infer T extends "0" | number}` ? T : never; // "0"
>PStringLiteral00 : "0"

// string-literal > enum
type PStringLiteral01 = "0" extends `${infer T extends "0" | NonLiteralEnum}` ? T : never; // "0"
>PStringLiteral01 : "0"

// string-literal > (number-literal | number-literal-enum)
type PStringLiteral02 = "0" extends `${infer T extends "0" | 0}` ? T : never; // "0"
>PStringLiteral02 : "0"

type PStringLiteral03 = "0" extends `${infer T extends "0" | NumberLiteralEnum}` ? T : never; // "0"
>PStringLiteral03 : "0"

// string-literal > bigint
type PStringLiteral04 = "0" extends `${infer T extends "0" | bigint}` ? T : never; // "0"
>PStringLiteral04 : "0"

// string-literal > bigint-literal
type PStringLiteral05 = "0" extends `${infer T extends "0" | 0n}` ? T : never; // "0"
>PStringLiteral05 : "0"

// string-literal > boolean
type PStringLiteral06 = "true" extends `${infer T extends "true" | "false" | boolean}` ? T : never; // "true"
>PStringLiteral06 : "true"

type PStringLiteral07 = "false" extends `${infer T extends "true" | "false" | boolean}` ? T : never; // "false"
>PStringLiteral07 : "false"

// string-literal > (boolean-literal | undefined | null)
type PStringLiteral08 = "true" extends `${infer T extends "true" | true}` ? T : never; // "true"
>PStringLiteral08 : "true"
>true : true

type PStringLiteral09 = "false" extends `${infer T extends "false" | false}` ? T : never; // "false"
>PStringLiteral09 : "false"
>false : false

type PStringLiteral10 = "undefined" extends `${infer T extends "undefined" | undefined}` ? T : never; // "undefined"
>PStringLiteral10 : "undefined"

type PStringLiteral11 = "null" extends `${infer T extends "null" | null}` ? T : never; // "null"
>PStringLiteral11 : "null"
>null : null

// #endregion string-literal

// #region string-literal-enum
// string-literal-enum > number
type PStringLiteralEnum00 = "0" extends `${infer T extends StringLiteralEnum | number}` ? T : never; // StringLiteralEnum.Zero
>PStringLiteralEnum00 : StringLiteralEnum.Zero

// string-literal-enum > enum
type PStringLiteralEnum01 = "0" extends `${infer T extends StringLiteralEnum | NonLiteralEnum}` ? T : never; // StringLiteralEnum.Zero
>PStringLiteralEnum01 : StringLiteralEnum.Zero

// string-literal-enum > (number-literal | number-literal-enum)
type PStringLiteralEnum02 = "0" extends `${infer T extends StringLiteralEnum | 0}` ? T : never; // StringLiteralEnum.Zero
>PStringLiteralEnum02 : StringLiteralEnum.Zero

type PStringLiteralEnum03 = "0" extends `${infer T extends StringLiteralEnum | NumberLiteralEnum}` ? T : never; // StringLiteralEnum.Zero
>PStringLiteralEnum03 : StringLiteralEnum.Zero

// string-literal-enum > bigint
type PStringLiteralEnum04 = "0" extends `${infer T extends StringLiteralEnum | bigint}` ? T : never; // StringLiteralEnum.Zero
>PStringLiteralEnum04 : StringLiteralEnum.Zero

// string-literal-enum > bigint-literal
type PStringLiteralEnum05 = "0" extends `${infer T extends StringLiteralEnum | 0n}` ? T : never; // StringLiteralEnum.Zero
>PStringLiteralEnum05 : StringLiteralEnum.Zero

// string-literal-enum > boolean
type PStringLiteralEnum06 = "true" extends `${infer T extends StringLiteralEnum | boolean}` ? T : never; // StringLiteralEnum.True
>PStringLiteralEnum06 : StringLiteralEnum.True

type PStringLiteralEnum07 = "false" extends `${infer T extends StringLiteralEnum | boolean}` ? T : never; // StringLiteralEnum.False
>PStringLiteralEnum07 : StringLiteralEnum.False

// string-literal-enum > (boolean-literal | undefined | null)
type PStringLiteralEnum08 = "true" extends `${infer T extends StringLiteralEnum | true}` ? T : never; // StringLiteralEnum.True
>PStringLiteralEnum08 : StringLiteralEnum.True
>true : true

type PStringLiteralEnum09 = "false" extends `${infer T extends StringLiteralEnum | false}` ? T : never; // StringLiteralEnum.False
>PStringLiteralEnum09 : StringLiteralEnum.False
>false : false

type PStringLiteralEnum10 = "undefined" extends `${infer T extends StringLiteralEnum | undefined}` ? T : never; // StringLiteralEnum.Undefined
>PStringLiteralEnum10 : StringLiteralEnum.Undefined

type PStringLiteralEnum11 = "null" extends `${infer T extends StringLiteralEnum | null}` ? T : never; // StringLiteralEnum.Null
>PStringLiteralEnum11 : StringLiteralEnum.Null
>null : null

// #endregion string-literal-enum

// #region number
// number > enum
type PNumber0 = "0" extends `${infer T extends number | NonLiteralEnum}` ? T : never; // 0
>PNumber0 : 0

// number > number-literal-enum
type PNumber1 = "0" extends `${infer T extends number | NumberLiteralEnum}` ? T : never; // 0
>PNumber1 : 0

// number > bigint
type PNumber2 = "0" extends `${infer T extends number | bigint}` ? T : never; // 0
>PNumber2 : 0

// number > bigint-literal
type PNumber3 = "0" extends `${infer T extends number | 0n}` ? T : never; // 0
>PNumber3 : 0

// #endregion number

// #region enum
// enum > number-literal-enum
type PEnum0 = "0" extends `${infer T extends NonLiteralEnum | NumberLiteralEnum}` ? T : never; // 0
>PEnum0 : 0

// enum > bigint
type PEnum1 = "0" extends `${infer T extends NonLiteralEnum | bigint}` ? T : never; // 0
>PEnum1 : 0

// enum > bigint-literal
type PEnum2 = "0" extends `${infer T extends NonLiteralEnum | 0n}` ? T : never; // 0
>PEnum2 : 0

// #endregion enum

// #region number-literal
// number-literal > bigint
type PNumberLiteral0 = "0" extends `${infer T extends 0 | bigint}` ? T : never; // 0
>PNumberLiteral0 : 0

// number-literal > bigint-literal
type PNumberLiteral1 = "0" extends `${infer T extends 0 | 0n}` ? T : never; // 0
>PNumberLiteral1 : 0

// #endregion number-literal

// #region number-literal-enum
// number-literal-enum > bigint
type PNumberLiteralEnum0 = "0" extends `${infer T extends NumberLiteralEnum | bigint}` ? T : never; // NumberLiteralEnum.Zero
>PNumberLiteralEnum0 : NumberLiteralEnum.Zero

// number-literal-enum > bigint-literal
type PNumberLiteralEnum1 = "0" extends `${infer T extends NumberLiteralEnum | 0n}` ? T : never; // NumberLiteralEnum.Zero
>PNumberLiteralEnum1 : NumberLiteralEnum.Zero

// #endregion number-literal-enum

// non-matchable constituents are excluded
type PExclude0 = "0" extends `${infer T extends "1" | number}` ? T : never; // 0
>PExclude0 : 0

type PExclude1 = "0" extends `${infer T extends `1${string}` | number}` ? T : never; // 0
>PExclude1 : 0

type PExclude2 = "0" extends `${infer T extends 1 | bigint}` ? T : never; // 0n
>PExclude2 : 0n

type PExclude3 = "0" extends `${infer T extends NumberLiteralEnum.One | bigint}` ? T : never; // 0n
>PExclude3 : 0n
>NumberLiteralEnum : any

type PExclude4 = "100000000000000000000000" extends `${infer T extends number | bigint}` ? T : never; // 100000000000000000000000n
>PExclude4 : 100000000000000000000000n

// infer to prefix from string
type TPrefix0 = "100" extends `${infer T extends number}${string}` ? T : never; // 1
>TPrefix0 : 1

type TPrefix1 = "trueabc" extends `${infer T extends boolean}${string}` ? T : never; // boolean (T only receives 't', not the whole string)
>TPrefix1 : boolean

type TPrefix2 = `100:${string}` extends `${infer T extends number}:${string}` ? T : never; // 100 (T receives '100' because it scans until ':')
>TPrefix2 : 100

// can use union w/multiple branches to extract each possibility
type ExtractPrimitives<T extends string> =
>ExtractPrimitives : ExtractPrimitives<T>

    | T
    | (T extends `${infer U extends number}` ? U : never)
    | (T extends `${infer U extends bigint}` ? U : never)
    | (T extends `${infer U extends boolean | null | undefined}` ? U : never)
>null : null

    ;

type TExtract0 = ExtractPrimitives<"100">; // "100" | 100 | 100n
>TExtract0 : "100" | 100 | 100n

type TExtract1 = ExtractPrimitives<"1.1">; // "1.1" | 1.1
>TExtract1 : "1.1" | 1.1

type TExtract2 = ExtractPrimitives<"true">; // "true" | true
>TExtract2 : true | "true"



// example use case (based on old TypedObjects proposal):

// Use constrained `infer` in template literal to get ordinal indices as numbers:
type IndexFor<S extends string> = S extends `${infer N extends number}` ? N : never;
>IndexFor : IndexFor<S>

type IndicesOf<T> = IndexFor<Extract<keyof T, string>>; // ordinal indices as number literals
>IndicesOf : IndicesOf<T>

interface FieldDefinition {
    readonly name: string;
>name : string

    readonly type: "i8" | "i16" | "i32" | "i64" | "u8" | "u16" | "u32" | "u64" | "f32" | "f64";
>type : "i8" | "i16" | "i32" | "i64" | "u8" | "u16" | "u32" | "u64" | "f32" | "f64"
}

type FieldType<T extends FieldDefinition["type"]> =
>FieldType : FieldType<T>

    T extends "i8" | "i16" | "i32" | "u8" | "u16" | "u32" | "f32" | "f64" ? number :
    T extends "f32" | "f64" ? bigint :
    never;

// Generates named members like `{ x: number, y: bigint }` from `[{ name: "x", type: "i32" }, { name: "y", type: "i64" }]`
type TypedObjectNamedMembers<TDef extends readonly FieldDefinition[]> = {
>TypedObjectNamedMembers : TypedObjectNamedMembers<TDef>

    [P in TDef[number]["name"]]: FieldType<Extract<TDef[number], { readonly name: P }>["type"]>;
>name : P

};

// Generates ordinal members like `{ 0: number, 1: bigint }` from `[{ name: "x", type: "i32" }, { name: "y", type: "i64" }]`
type TypedObjectOrdinalMembers<TDef extends readonly FieldDefinition[]> = {
>TypedObjectOrdinalMembers : TypedObjectOrdinalMembers<TDef>

    [I in Extract<keyof TDef, `${number}`>]: FieldType<Extract<TDef[I], FieldDefinition>["type"]>;
};

// Default members
interface TypedObjectMembers<TDef extends readonly FieldDefinition[]> {
    // get/set a field by name
    get<K extends TDef[number]["name"]>(key: K): FieldType<Extract<TDef[number], { readonly name: K }>["type"]>;
>get : <K extends TDef[number]["name"]>(key: K) => FieldType<Extract<TDef[number], {    readonly name: K;}>["type"]>
>key : K
>name : K

    set<K extends TDef[number]["name"]>(key: K, value: FieldType<Extract<TDef[number], { readonly name: K }>["type"]>): void;
>set : <K extends TDef[number]["name"]>(key: K, value: FieldType<Extract<TDef[number], {    readonly name: K;}>["type"]>) => void
>key : K
>value : FieldType<Extract<TDef[number], { readonly name: K; }>["type"]>
>name : K

    // get/set a field by index
    getIndex<I extends IndicesOf<TDef>>(index: I): FieldType<Extract<TDef[I], FieldDefinition>["type"]>;
>getIndex : <I extends IndexFor<Extract<keyof TDef, string>>>(index: I) => FieldType<Extract<TDef[I], FieldDefinition>["type"]>
>index : I

    setIndex<I extends IndicesOf<TDef>>(index: I, value: FieldType<Extract<TDef[I], FieldDefinition>["type"]>): void;
>setIndex : <I extends IndexFor<Extract<keyof TDef, string>>>(index: I, value: FieldType<Extract<TDef[I], FieldDefinition>["type"]>) => void
>index : I
>value : FieldType<Extract<TDef[I], FieldDefinition>["type"]>
}

type TypedObject<TDef extends readonly FieldDefinition[]> =
>TypedObject : TypedObject<TDef>

    & TypedObjectMembers<TDef>
    & TypedObjectNamedMembers<TDef>
    & TypedObjectOrdinalMembers<TDef>;

// NOTE: type would normally be created from something like `const Point = TypedObject([...])` from which we would infer the type
type Point = TypedObject<[
>Point : TypedObjectMembers<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }]> & TypedObjectNamedMembers<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }]> & TypedObjectOrdinalMembers<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }]>

    { name: "x", type: "f64" },
>name : "x"
>type : "f64"

    { name: "y", type: "f64" },
>name : "y"
>type : "f64"

]>;

declare const p: Point;
>p : Point

p.getIndex(0); // ok, 0 is a valid index
>p.getIndex(0) : number
>p.getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
>p : Point
>getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
>0 : 0

p.getIndex(1); // ok, 1 is a valid index
>p.getIndex(1) : number
>p.getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
>p : Point
>getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
>1 : 1

p.getIndex(2); // error, 2 is not a valid index
>p.getIndex(2) : number
>p.getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
>p : Point
>getIndex : <I extends 0 | 1>(index: I) => FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>
>2 : 2

p.setIndex(0, 0); // ok, 0 is a valid index
>p.setIndex(0, 0) : void
>p.setIndex : <I extends 0 | 1>(index: I, value: FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>) => void
>p : Point
>setIndex : <I extends 0 | 1>(index: I, value: FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>) => void
>0 : 0
>0 : 0

p.setIndex(1, 0); // ok, 1 is a valid index
>p.setIndex(1, 0) : void
>p.setIndex : <I extends 0 | 1>(index: I, value: FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>) => void
>p : Point
>setIndex : <I extends 0 | 1>(index: I, value: FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>) => void
>1 : 1
>0 : 0

p.setIndex(2, 3); // error, 2 is not a valid index
>p.setIndex(2, 3) : void
>p.setIndex : <I extends 0 | 1>(index: I, value: FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>) => void
>p : Point
>setIndex : <I extends 0 | 1>(index: I, value: FieldType<Extract<[{ name: "x"; type: "f64"; }, { name: "y"; type: "f64"; }][I], FieldDefinition>["type"]>) => void
>2 : 2
>3 : 3

// function inference
declare function f1<T extends string | number>(s: `**${T}**`): T;
>f1 : <T extends string | number>(s: `**${T}**`) => T
>s : `**${T}**`

f1("**123**"); // "123"
>f1("**123**") : "123"
>f1 : <T extends string | number>(s: `**${T}**`) => T
>"**123**" : "**123**"

declare function f2<T extends number>(s: `**${T}**`): T;
>f2 : <T extends number>(s: `**${T}**`) => T
>s : `**${T}**`

f2("**123**"); // 123
>f2("**123**") : 123
>f2 : <T extends number>(s: `**${T}**`) => T
>"**123**" : "**123**"

declare function f3<T extends bigint>(s: `**${T}**`): T;
>f3 : <T extends bigint>(s: `**${T}**`) => T
>s : `**${T}**`

f3("**123**"); // 123n
>f3("**123**") : 123n
>f3 : <T extends bigint>(s: `**${T}**`) => T
>"**123**" : "**123**"

declare function f4<T extends boolean>(s: `**${T}**`): T;
>f4 : <T extends boolean>(s: `**${T}**`) => T
>s : `**${T}**`

f4("**true**"); // true | "true"
>f4("**true**") : true
>f4 : <T extends boolean>(s: `**${T}**`) => T
>"**true**" : "**true**"

f4("**false**"); // false | "false"
>f4("**false**") : false
>f4 : <T extends boolean>(s: `**${T}**`) => T
>"**false**" : "**false**"