TS类型编程实现的Times33哈希.ts

type NumberOf<T extends string> = T extends `${infer N extends number}` ? N : never;
type ReversedString<
    T extends string,
    R extends string = ''>
    = (T extends `${infer N}${infer B}`
        ? ReversedString<B, `${N}${R}`>
        : R
    );
type Zeroless<
    T extends string>
    = (T extends `${infer N}0`
        ? Zeroless<N>
        : T extends '' ? '0' : T
    );
type SigVary = [9, 0, 1, 2, 3, 4, 5, 6, 7, 8];
type SigNumber = SigVary[number];
type DecreasedString<
    N extends string,
    B extends string = ''>
    = (N extends `0${infer N}`
        ? DecreasedString<N, `${B}9`>
        : (N extends `${infer S extends SigNumber}${infer N}`
            ? `${B}${SigVary[S]}${N}`
            : `${B}${N}`
        )
    );
type Decreased<N extends number> = NumberOf<ReversedString<Zeroless<DecreasedString<ReversedString<`${N}`>>>>>;
type Limited<
    S extends string,
    C extends number = 64,
    R extends string = ''>
    = string extends S ? never :
    (C extends 0
        ? R
        : (S extends `${infer N}${infer T}`
            ? Limited<T, Decreased<C>, `${R}${N}`>
            : R
        )
    );
type Bin = 0 | 1;
type BStrMap = {
    M000: [0, 0];
    M001: [1, 0]; M010: [1, 0]; M100: [1, 0];
    M011: [0, 1]; M101: [0, 1]; M110: [0, 1];
    M111: [1, 1];
};
type AddBin<
    A extends string,
    B extends string,
    J extends [Bin | '', Bin] = ['', 0],
    R extends string = ''>
    = string extends A | B ? never :
    (`${A}_${B}` extends `${infer LA extends Bin}${infer KA}_${infer LB extends Bin}${infer KB}`
        ? AddBin<KA, KB, BStrMap[`M${J[1]}${LA}${LB}`], `${R}${J[0]}`>
        : ('' | J extends A | B | [0, 0]
            ? `${R}0${A}${B}`
            : AddBin<`${A}0`, `${B}0`, J, R>
        )
    );
type BNumMap = [
    '0000', '0001', '0010', '0011', '0100',
    '0101', '0110', '0111', '1000', '1001',
];
type Times33<
    K extends string,
    S extends number | string>
    = string extends K | S ? never :
    (`${S}` extends `${infer N extends SigNumber}${infer T}`
        ? Times33<AddBin<`${BNumMap[N]}0${K}`, K>, T>
        : K
    );
type HashInfo = { k: string; s: number; }
type Hash<I extends HashInfo> = {
    k: Limited<Times33<I['k'], I['s']>>;
    s: Decreased<I['s']>;
}
type HashInfoInit = {
    k: '0100000101010110010101000110010101100011011010000100111001001111';
    s: 1000000000000;
}
type Recursed<
    N extends number,
    I extends HashInfo = HashInfoInit>
    = (N extends 0
        ? I
        : Recursed<Decreased<N>, Hash<I>>
    );
type A = Hash<HashInfoInit>
type B = Recursed<31>
type C = Recursed<100>