类型体操六大套路

type p = Promise<'guang'>;

// 提取 Promise 中的 value 类型
type GetValueType<P> = P extends Promise<infer Value> ? Value : never;

type Result = GetValueType<Promise<'guang'>>; // 结果：'guang'

type GetFirst<Arr extends unknown[]> =
    Arr extends [infer First, ...unknown[]] ? First : never;

type FirstResult1 = GetFirst<[1, 2, 3]>;  // 结果：1
type FirstResult2 = GetFirst<[]>;          // 结果：never

type GetLast<Arr extends unknown[]> =
    Arr extends [...unknown[], infer Last] ? Last : never;

type LastResult = GetLast<[1, 2, 3]>;  // 结果：3

type PopArr<Arr extends unknown[]> =
    Arr extends [] ? []
        : Arr extends [...infer Rest, unknown] ? Rest : never;

type PopResult1 = PopArr<[1, 2, 3]>;  // 结果：[1, 2]
type PopResult2 = PopArr<[]>;          // 结果：[]

type ShiftArr<Arr extends unknown[]> =
    Arr extends [] ? []
        : Arr extends [unknown, ...infer Rest] ? Rest : never;

type ShiftResult = ShiftArr<[1, 2, 3]>;  // 结果：[2, 3]

type StartsWith<Str extends string, Prefix extends string> =
    Str extends `${Prefix}${string}` ? true : false;

type StartsWithResult1 = StartsWith<'abcde', 'abc'>;  // 结果：true
type StartsWithResult2 = StartsWith<'abcde', 'def'>;  // 结果：false

type ReplaceStr<
    Str extends string,
    From extends string,
    To extends string
> = Str extends `${infer Prefix}${From}${infer Suffix}`
        ? `${Prefix}${To}${Suffix}` : Str;

type ReplaceResult1 = ReplaceStr<'guang and dong', 'and', 'or'>;  // 结果：'guang or dong'
type ReplaceResult2 = ReplaceStr<'guang and dong', 'not', 'or'>;  // 结果：'guang and dong'

type TrimStrRight<Str extends string> =
    Str extends `${infer Rest}${' ' | '\n' | '\t'}`
        ? TrimStrRight<Rest> : Str;

type TrimRightResult = TrimStrRight<'guang   '>;  // 结果：'guang'

type TrimStrLeft<Str extends string> =
    Str extends `${' ' | '\n' | '\t'}${infer Rest}`
        ? TrimStrLeft<Rest> : Str;

type TrimLeftResult = TrimStrLeft<'   guang'>;  // 结果：'guang'

type TrimStr<Str extends string> = TrimStrRight<TrimStrLeft<Str>>;

type TrimResult = TrimStr<'   guang   '>;  // 结果：'guang'

type GetParameters<Func extends Function> =
    Func extends (...args: infer Args) => unknown ? Args : never;

type ParamsResult = GetParameters<(name: string, age: number) => string>;
// 结果：[string, number]

type GetReturnType<Func extends Function> =
    Func extends (...args: any[]) => infer ReturnType
        ? ReturnType : never;

type ReturnResult = GetReturnType<(name: string, age: number) => string>;
// 结果：string

class Dong {
    name: string;

    constructor() {
        this.name = "dong";
    }

    hello(this: Dong) {
        return 'hello, I\'m ' + this.name;
    }
}

type GetThisParameterType<T> =
    T extends (this: infer ThisType, ...args: any[]) => any
        ? ThisType
        : unknown;

type ThisResult = GetThisParameterType<typeof Dong.prototype.hello>;
// 结果：Dong

interface Person {
    name: string;
}

interface PersonConstructor {
    new(name: string): Person;
}

type GetInstanceType<
    ConstructorType extends new (...args: any) => any
> = ConstructorType extends new (...args: any) => infer InstanceType
        ? InstanceType
        : any;

type InstanceResult = GetInstanceType<PersonConstructor>;  // 结果：Person

type GetConstructorParameters<
    ConstructorType extends new (...args: any) => any
> = ConstructorType extends new (...args: infer ParametersType) => any
    ? ParametersType
    : never;

type ConstructorParamsResult = GetConstructorParameters<PersonConstructor>;
// 结果：[string]

type GetRefProps<Props> =
    'ref' extends keyof Props
        ? Props extends { ref?: infer Value | undefined}
            ? Value
            : never
        : never;

type RefResult1 = GetRefProps<{ ref?: string | undefined }>;  // 结果：string
type RefResult2 = GetRefProps<{ ref?: undefined }>;            // 结果：never
type RefResult3 = GetRefProps<{ name: string }>;               // 结果：never

type Push<Arr extends unknown[], Ele> = [...Arr, Ele];

type PushResult = Push<[1, 2, 3], 4>;  // 结果：[1, 2, 3, 4]

type Unshift<Arr extends unknown[], Ele> = [Ele, ...Arr];

type UnshiftResult = Unshift<[1, 2, 3], 0>;  // 结果：[0, 1, 2, 3]

type Zip<One extends [unknown, unknown], Other extends [unknown, unknown]> =
    One extends [infer OneFirst, infer OneSecond]
        ? Other extends [infer OtherFirst, infer OtherSecond]
            ? [[OneFirst, OtherFirst], [OneSecond, OtherSecond]] : []
                : [];

type ZipResult1 = Zip<[1, 2], ['guang', 'dong']>;
// 结果：[[1, 'guang'], [2, 'dong']]

type Zip2<One extends unknown[], Other extends unknown[]> =
    One extends [infer OneFirst, ...infer OneRest]
        ? Other extends [infer OtherFirst, ...infer OtherRest]
            ? [[OneFirst, OtherFirst], ...Zip2<OneRest, OtherRest>]: []
                : [];

type ZipResult2 = Zip2<[1, 2, 3], ['guang', 'dong', 'dong']>;
// 结果：[[1, 'guang'], [2, 'dong'], [3, 'dong']]

type CapitalizeStr<Str extends string> =
    Str extends `${infer First}${infer Rest}`
        ? `${Uppercase<First>}${Rest}` : Str;

type CapitalizeResult = CapitalizeStr<'guang'>;  // 结果：'Guang'

type CamelCase<Str extends string> =
    Str extends `${infer Left}_${infer Right}${infer Rest}`
        ? `${Left}${Uppercase<Right>}${CamelCase<Rest>}`
        : Str;

type CamelCaseResult = CamelCase<'dong_dong_dong'>;  // 结果：'dongDongDong'

type DropSubStr<Str extends string, SubStr extends string> =
    Str extends `${infer Prefix}${SubStr}${infer Suffix}`
        ? DropSubStr<`${Prefix}${Suffix}`, SubStr> : Str;

type DropResult = DropSubStr<'guang~~~dong~~~', '~~~'>;  // 结果：'guangdong'

type AppendArgument<Func extends Function, Arg> =
    Func extends (...args: infer Args) => infer ReturnType
        ? (...args: [...Args, Arg]) => ReturnType : never;

type AppendResult = AppendArgument<(name: string) => number, number>;
// 结果：(name: string, arg: number) => number

type Mapping<Obj extends object> = {
    [Key in keyof Obj]: Obj[Key]
}

type Mapping<Obj extends object> = {
    [Key in keyof Obj]: [Obj[Key], Obj[Key], Obj[Key]]
}

type MappingResult = Mapping<{ name: string; age: number }>;
// 结果：{ name: [string, string, string]; age: [number, number, number] }

type UppercaseKey<Obj extends Record<string, any>> = {
    [Key in keyof Obj as Uppercase<Key & string>]: Obj[Key]
}

type UppercaseKeyResult = UppercaseKey<{ name: string; age: number }>;
// 结果：{ NAME: string; AGE: number }

type ToReadonly<T> = {
    readonly [Key in keyof T]: T[Key];
}

type ReadonlyResult = ToReadonly<{ name: string; age: number }>;
// 结果：{ readonly name: string; readonly age: number }

type ToPartial<T> = {
    [Key in keyof T]?: T[Key]
}

type PartialResult = ToPartial<{ name: string; age: number }>;
// 结果：{ name?: string; age?: number }

type ToMutable<T> = {
    -readonly [Key in keyof T]: T[Key]
}

type MutableResult = ToMutable<{ readonly name: string; readonly age: number }>;
// 结果：{ name: string; age: number }

type ToRequired<T> = {
    [Key in keyof T]-?: T[Key]
}

type RequiredResult = ToRequired<{ name?: string; age?: number }>;
// 结果：{ name: string; age: number }

type FilterByValueType<
    Obj extends Record<string, any>,
    ValueType
> = {
    [Key in keyof Obj
        as Obj[Key] extends ValueType ? Key : never]
        : Obj[Key]
}

type FilterResult = FilterByValueType<{ name: string; age: number; visible: boolean }, string>;
// 结果：{ name: string }

type ttt = Promise<Promise<Promise<Record<string, any>>>>;

// 完整版本
type DeepPromiseValueType<P extends Promise<unknown>> =
    P extends Promise<infer ValueType>
        ? ValueType extends Promise<unknown>
            ? DeepPromiseValueType<ValueType>
            : ValueType
        : never;

// 简化版本（不再约束类型参数必须是 Promise，少一层判断）
type DeepPromiseValueType2<T> =
    T extends Promise<infer ValueType>
        ? DeepPromiseValueType2<ValueType>
        : T;

type DeepResult = DeepPromiseValueType<Promise<Promise<Promise<Record<string, any>>>>>;
// 结果：Record<string, any>

type DeepResult2 = DeepPromiseValueType2<Promise<Promise<Promise<Record<string, any>>>>>;
// 结果：Record<string, any>

type ReverseArr<Arr extends unknown[]> =
    Arr extends [infer One, infer Two, infer Three, infer Four, infer Five]
        ? [Five, Four, Three, Two, One]
        : never;

type ReverseFixed = ReverseArr<[1, 2, 3, 4, 5]>;  // 结果：[5, 4, 3, 2, 1]

type ReverseArr<Arr extends unknown[]> =
    Arr extends [infer First, ...infer Rest]
        ? [...ReverseArr<Rest>, First]
        : Arr;

type ReverseResult = ReverseArr<[1, 2, 3, 4, 5]>;  // 结果：[5, 4, 3, 2, 1]

type IsEqual<A, B> = (A extends B ? true : false) & (B extends A ? true : false);

type Includes<Arr extends unknown[], FindItem> =
    Arr extends [infer First, ...infer Rest]
        ? IsEqual<First, FindItem> extends true
            ? true
            : Includes<Rest, FindItem>
        : false;

type IncludesResult1 = Includes<[1, 2, 3, 4, 5], 4>;  // 结果：true
type IncludesResult2 = Includes<[1, 2, 3, 4, 5], 6>;  // 结果：false

type IsEqual<A, B> = (A extends B ? true : false) & (B extends A ? true : false);

type RemoveItem<
    Arr extends unknown[],
    Item,
    Result extends unknown[] = []
> = Arr extends [infer First, ...infer Rest]
        ? IsEqual<First, Item> extends true
            ? RemoveItem<Rest, Item, Result>
            : RemoveItem<Rest, Item, [...Result, First]>
        : Result;

type RemoveResult = RemoveItem<[1, 2, 3, 4, 5], 3>;  // 结果：[1, 2, 4, 5]

type BuildArray<
    Length extends number,
    Ele = unknown,
    Arr extends unknown[] = []
> = Arr['length'] extends Length
        ? Arr
        : BuildArray<Length, Ele, [...Arr, Ele]>;

type BuildResult = BuildArray<5>;  // 结果：[unknown, unknown, unknown, unknown, unknown]
type BuildResult2 = BuildArray<3, number>;  // 结果：[number, number, number]

type ReplaceAll<
    Str extends string,
    From extends string,
    To extends string
> = Str extends `${infer Left}${From}${infer Right}`
        ? `${Left}${To}${ReplaceAll<Right, From, To>}`
        : Str;

type ReplaceAllResult = ReplaceAll<'guang and dong and dong', 'and', 'or'>;
// 结果：'guang or dong or dong'

type StringToUnion<Str extends string> =
    Str extends `${infer One}${infer Two}${infer Three}${infer Four}`
        ? One | Two | Three | Four
        : never;

type StringUnionFixed = StringToUnion<'dong'>;  // 结果：'d' | 'o' | 'n' | 'g'

type StringToUnion<Str extends string> =
    Str extends `${infer First}${infer Rest}`
        ? First | StringToUnion<Rest>
        : never;

type StringUnionResult = StringToUnion<'dongdong'>;  // 结果：'d' | 'o' | 'n' | 'g'

type ReverseStr<
    Str extends string,
    Result extends string = ''
> = Str extends `${infer First}${infer Rest}`
    ? ReverseStr<Rest, `${First}${Result}`>
    : Result;

type ReverseStrResult = ReverseStr<'abcde'>;  // 结果：'edcba'

type DeepReadonly<Obj extends Record<string, any>> =
    Obj extends any
        ? {
            readonly [Key in keyof Obj]:
                Obj[Key] extends object
                    ? Obj[Key] extends Function
                        ? Obj[Key]
                        : DeepReadonly<Obj[Key]>
                    : Obj[Key]
        }
        : never;

type obj = {
    a: {
        b: {
            c: {
                f: () => 'dong',
                d: {
                    e: {
                        guang: string
                    }
                }
            }
        }
    }
}

type DeepReadonlyResult = DeepReadonly<obj>;
// 结果：{ readonly a: { readonly b: { readonly c: { readonly f: () => 'dong'; readonly d: { readonly e: { readonly guang: string } } } } } }

type len1 = [unknown, unknown, unknown]['length'];  // 结果：3
type len2 = [unknown, unknown]['length'];            // 结果：2
type len3 = []['length'];                            // 结果：0

type BuildArray<
    Length extends number,
    Ele = unknown,
    Arr extends unknown[] = []
> = Arr['length'] extends Length
        ? Arr
        : BuildArray<Length, Ele, [...Arr, Ele]>;

type Add<Num1 extends number, Num2 extends number> =
    [...BuildArray<Num1>, ...BuildArray<Num2>]['length'];

type AddResult = Add<32, 18>;  // 结果：50

type Subtract<Num1 extends number, Num2 extends number> =
    BuildArray<Num1> extends [...arr1: BuildArray<Num2>, ...arr2: infer Rest]
        ? Rest['length']
        : never;

type SubtractResult = Subtract<32, 18>;  // 结果：14

type Multiply<
    Num1 extends number,
    Num2 extends number,
    ResultArr extends unknown[] = []
> = Num2 extends 0 ? ResultArr['length']
        : Multiply<Num1, Subtract<Num2, 1>, [...BuildArray<Num1>, ...ResultArr]>;

type MultiplyResult = Multiply<3, 4>;  // 结果：12

type Divide<
    Num1 extends number,
    Num2 extends number,
    CountArr extends unknown[] = []
> = Num1 extends 0 ? CountArr['length']
        : Divide<Subtract<Num1, Num2>, Num2, [unknown, ...CountArr]>;

type DivideResult = Divide<9, 3>;  // 结果：3

type StrLen<
    Str extends string,
    CountArr extends unknown[] = []
> = Str extends `${string}${infer Rest}`
    ? StrLen<Rest, [...CountArr, unknown]>
    : CountArr['length']

type StrLenResult = StrLen<'guang dong'>;  // 结果：9

type GreaterThan<
    Num1 extends number,
    Num2 extends number,
    CountArr extends unknown[] = []
> = Num1 extends Num2
    ? false
    : CountArr['length'] extends Num2
        ? true
        : CountArr['length'] extends Num1
            ? false
            : GreaterThan<Num1, Num2, [...CountArr, unknown]>;

type GreaterThanResult1 = GreaterThan<3, 4>;  // 结果：false
type GreaterThanResult2 = GreaterThan<6, 4>;  // 结果：true

type FibonacciLoop<
    PrevArr extends unknown[],
    CurrentArr extends unknown[],
    IndexArr extends unknown[] = [],
    Num extends number = 1
> = IndexArr['length'] extends Num
    ? CurrentArr['length']
    : FibonacciLoop<CurrentArr, [...PrevArr, ...CurrentArr], [...IndexArr, unknown], Num>

type Fibonacci<Num extends number> = FibonacciLoop<[1], [], [], Num>;

type FibResult = Fibonacci<8>;  // 结果：21

type Union = 'a' | 'b' | 'c';

// 想把其中的 a 大写
type UppercaseA<Item extends string> =
    Item extends 'a' ? Uppercase<Item> : Item;

type UppercaseAResult = UppercaseA<'a' | 'b' | 'c'>;
// 结果：'A' | 'b' | 'c'

type StrResult = `${'a' | 'b' | 'c'}___`;
// 结果：'a___' | 'b___' | 'c___'

type Camelcase<Str extends string> =
    Str extends `${infer Left}_${infer Right}${infer Rest}`
    ? `${Left}${Uppercase<Right>}${Camelcase<Rest>}`
    : Str;

type CamelcaseArr<
  Arr extends unknown[]
> = Arr extends [infer Item, ...infer RestArr]
  ? [Camelcase<Item & string>, ...CamelcaseArr<RestArr>]
  : [];

type CamelcaseArrResult = CamelcaseArr<['guang_dong', 'hello_world']>;
// 结果：['guangDong', 'helloWorld']

type CamelcaseUnion<Item extends string> =
  Item extends `${infer Left}_${infer Right}${infer Rest}`
    ? `${Left}${Uppercase<Right>}${CamelcaseUnion<Rest>}`
    : Item;

type CamelcaseUnionResult = CamelcaseUnion<'guang_dong' | 'hello_world'>;
// 结果：'guangDong' | 'helloWorld'

type IsUnion<A, B = A> =
    A extends A
        ? [B] extends [A]
            ? false
            : true
        : never

type IsUnionResult1 = IsUnion<'a' | 'b' | 'c'>;  // 结果：true
type IsUnionResult2 = IsUnion<'a'>;               // 结果：false

type TestUnion<A, B = A> = A extends A ? { a: A, b: B } : never;

type TestUnionResult = TestUnion<'a' | 'b' | 'c'>;
// 结果：{ a: 'a', b: 'a' | 'b' | 'c' } | { a: 'b', b: 'a' | 'b' | 'c' } | { a: 'c', b: 'a' | 'b' | 'c' }

type BEM<
    Block extends string,
    Element extends string[],
    Modifiers extends string[]
> = `${Block}__${Element[number]}--${Modifiers[number]}`;

type BEMResult = BEM<'guang', ['aaa', 'bbb'], ['warning', 'success']>;
// 结果：'guang__aaa--warning' | 'guang__aaa--success' | 'guang__bbb--warning' | 'guang__bbb--success'

type Combination<A extends string, B extends string> =
    | A
    | B
    | `${A}${B}`
    | `${B}${A}`;

type AllCombinations<A extends string, B extends string = A> =
    A extends A
        ? Combination<A, AllCombinations<Exclude<B, A>>>
        : never;

type AllCombinationsResult = AllCombinations<'A' | 'B'>;
// 结果：'A' | 'B' | 'AB' | 'BA'

type IsAny<T> = 'dong' extends ('guang' & T) ? true : false;

type IsAnyResult1 = IsAny<any>;     // 结果：true
type IsAnyResult2 = IsAny<string>;  // 结果：false
type IsAnyResult3 = IsAny<never>;   // 结果：false

// 不完善的写法
type IsEqual<A, B> = (A extends B ? true : false) & (B extends A ? true : false);

type IsEqualBad = IsEqual<any, string>;  // 结果：boolean（期望 false）

type IsEqual2<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
    ? true : false;

type IsEqualResult1 = IsEqual2<any, string>;  // 结果：false
type IsEqualResult2 = IsEqual2<string, string>;  // 结果：true
type IsEqualResult3 = IsEqual2<any, any>;  // 结果：true

type TestNever<T> = T extends number ? 1 : 2;

type TestNeverResult = TestNever<never>;  // 结果：never（不是 2）

type IsNever<T> = [T] extends [never] ? true : false;

type IsNeverResult1 = IsNever<never>;   // 结果：true
type IsNeverResult2 = IsNever<string>;  // 结果：false

type TestAny<T> = T extends number ? 1 : 2;

type TestAnyResult = TestAny<any>;  // 结果：1 | 2（不是 1 也不是 2）

type TupleLen = [1, 2, 3]['length'];  // 结果：3（数字字面量）
type ArrayLen = number[]['length'];    // 结果：number

type NotEqual<A, B> =
    (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
    ? false : true;

type IsTuple<T> =
    T extends [...params: infer Eles]
        ? NotEqual<Eles['length'], number>
        : false

type IsTupleResult1 = IsTuple<[1, 2, 3]>;  // 结果：true
type IsTupleResult2 = IsTuple<number[]>;    // 结果：false
type IsTupleResult3 = IsTuple<string>;      // 结果：false

type UnionToIntersection<U> =
    (U extends U ? (x: U) => unknown : never) extends (x: infer R) => unknown
        ? R
        : never

type UnionToIntersectionResult = UnionToIntersection<'a' | 'b' | 'c'>;
// 结果：'a' & 'b' & 'c'

type GetOptional<Obj extends Record<string, any>> = {
    [
        Key in keyof Obj
            as {} extends Pick<Obj, Key> ? Key : never
    ] : Obj[Key];
}

type GetOptionalResult = GetOptional<{ name: string; age?: number; visible?: boolean }>;
// 结果：{ age?: number; visible?: boolean }

type isRequired<Key extends keyof Obj, Obj> =
    {} extends Pick<Obj, Key> ? never : Key;

type GetRequired<Obj extends Record<string, any>> = {
    [Key in keyof Obj as isRequired<Key, Obj>]: Obj[Key]
}

type GetRequiredResult = GetRequired<{ name: string; age?: number; visible?: boolean }>;
// 结果：{ name: string }

type Obj1 = { a: 'aaa' | undefined };  // a 不是可选索引
type Obj2 = { a?: 'aaa' | undefined };  // a 是可选索引

type Dong = {
  [key: string]: any;   // 可索引签名，代表可以添加任意个 string 类型的索引
  sleep(): void;        // 具体的索引
}

type RemoveIndexSignature<Obj extends Record<string, any>> = {
  [
      Key in keyof Obj
          as Key extends `${infer Str}`? Str : never
  ]: Obj[Key]
}

type RemoveIndexSignatureResult = RemoveIndexSignature<{
    [key: string]: any;
    sleep(): void;
    eat(): void;
}>;
// 结果：{ sleep: () => void; eat: () => void }

class Dong {
  public name: string;
  protected age: number;
  private hobbies: string[];

  constructor() {
    this.name = 'dong';
    this.age = 20;
    this.hobbies = ['sleep', 'eat'];
  }
}

type DongKeys = keyof Dong;  // 结果：'name'（只有 public 的）

type ClassPublicProps<Obj extends Record<string, any>> = {
    [Key in keyof Obj]: Obj[Key]
}

type PublicPropsResult = ClassPublicProps<Dong>;
// 结果：{ name: string }

// 默认推导
const obj = { name: 'guang' };
// 推导结果：{ name: string }（不是字面量类型）

const arr = [1, 2, 3];
// 推导结果：number[]（不是元组字面量类型）

const obj = { name: 'guang' } as const;
// 推导结果：{ readonly name: 'guang' }

const arr = [1, 2, 3] as const;
// 推导结果：readonly [1, 2, 3]

// 不加 readonly 匹配不出来
type ReverseArr<Arr extends unknown[]> =
    Arr extends [infer First, ...infer Rest]
        ? [...ReverseArr<Rest>, First]
        : Arr;

type ReverseBad = ReverseArr<readonly [1, 2, 3]>;  // 结果：readonly [1, 2, 3]（匹配失败）

// 加上 readonly 才能正常匹配
type ReverseArr2<Arr extends readonly unknown[]> =
    Arr extends readonly [infer First, ...infer Rest]
        ? readonly [...ReverseArr2<Rest>, First]
        : Arr;

type ReverseGood = ReverseArr2<readonly [1, 2, 3]>;  // 结果：readonly [3, 2, 1]

// 合并值：如果两个值是同一个就返回一个，否则构造数组
type MergeValues<One, Other> =
    One extends Other
        ? One
        : Other extends unknown[]
            ? [One, ...Other]
            : [One, Other];

// 合并两个索引类型
type MergeParams<
    OneParam extends Record<string, any>,
    OtherParam extends Record<string, any>
> = {
  [Key in keyof OneParam | keyof OtherParam]:
    Key extends keyof OneParam
        ? Key extends keyof OtherParam
            ? MergeValues<OneParam[Key], OtherParam[Key]>
            : OneParam[Key]
        : Key extends keyof OtherParam
            ? OtherParam[Key]
            : never
}

// 解析单个 query param（模式匹配做提取 + 重新构造做变换）
type ParseParam<Param extends string> =
    Param extends `${infer Key}=${infer Value}`
        ? {
            [K in Key]: Value
        } : {};

// 递归解析 query string（递归复用做循环）
type ParseQueryString<Str extends string> =
    Str extends `${infer Param}&${infer Rest}`
        ? MergeParams<ParseParam<Param>, ParseQueryString<Rest>>
        : ParseParam<Str>;

type ParseResult = ParseQueryString<'a=1&b=2&c=3&d=4'>;
// 结果：{ a: '1'; b: '2'; c: '3'; d: '4' }

type ParseResult2 = ParseQueryString<'a=1&b=2&a=3'>;
// 结果：{ a: ['1', '3']; b: '2' }