type Tuple<N extends number, T extends unknown[] = []> = T["length"] extends N ? T : Tuple<N, [...T, 0]>;
type ToNumber<T> = T extends number ? T : never;
type Reverse<T extends string, Acc extends string = ""> = T extends `${infer L}${infer R}` ? Reverse<R, `${L}${Acc}`> : `${T}${Acc}`;

type AddDigit<A extends number, B extends number, C extends number = 0, Acc extends unknown[] = [...Tuple<A>, ...Tuple<B>, ...Tuple<C>]> =
  Acc extends [...Tuple<10>, ...infer Rest]
  ? { digit: ToNumber<Rest["length"]>, carry: 1 }
  : { digit: ToNumber<Acc["length"]>, carry: 0 };

type SumImpl<A extends string, B extends string, C extends number = 0, Acc extends string = ""> =
  A extends `${infer A1 extends number}${infer ARest}`
  ? B extends `${infer B1 extends number}${infer BRest}`
  ? SumImpl<ARest, BRest, AddDigit<A1, B1, C>["carry"], `${Acc}${AddDigit<A1, B1, C>["digit"]}`>
  : SumImpl<ARest, "", AddDigit<A1, 0, C>["carry"], `${Acc}${AddDigit<A1, 0, C>["digit"]}`>
  : B extends `${infer B1 extends number}${infer BRest}`
  ? SumImpl<"", BRest, AddDigit<0, B1, C>["carry"], `${Acc}${AddDigit<0, B1, C>["digit"]}`>
  : `${Acc}${C extends 1 ? "1" : ""}`;

type Sum<A extends string | number | bigint, B extends string | number | bigint> =
  Reverse<SumImpl<Reverse<`${A}`>, Reverse<`${B}`>>>;


type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
type PadZero<S extends string, Acc extends string = ""> = S extends `${infer _}${infer R}` ? PadZero<R, `${Acc}0`> : Acc;
type TrimZero<S extends string> = S extends `0${infer R}` ? R extends "" ? "0" : TrimZero<R> : S;

type MulOneByOne<A extends number, B extends number, Count extends unknown[] = [], Acc extends unknown[] = []> =
  Count["length"] extends B
  ? ToNumber<Acc["length"]>
  : MulOneByOne<A, B, [...Count, 0], [...Acc, ...Tuple<A>]>;

type MulManyByOne<A extends string, B extends Digit, Acc extends string = "0"> =
  A extends `${infer A1 extends Digit}${infer ARest}`
  ? MulManyByOne<ARest, B, Sum<Acc, `${MulOneByOne<A1, B>}${PadZero<ARest>}`>>
  : TrimZero<Acc>;

type MulManyByMany<A extends string, B extends string, Acc extends string = "0"> =
  A extends `${infer A1 extends Digit}${infer ARest}`
  ? MulManyByMany<ARest, B, Sum<Acc, `${MulManyByOne<B, A1>}${PadZero<ARest>}`>>
  : TrimZero<Acc>;

type Multiply<A extends string | number | bigint, B extends string | number | bigint> = MulManyByMany<`${A}`, `${B}`>;

import type { Equal, Expect } from '@type-challenges/utils'

type cases = [
  Expect<Equal<Multiply<2, 3>, '6'>>,
  Expect<Equal<Multiply<3, '5'>, '15'>>,
  Expect<Equal<Multiply<'4', 10>, '40'>>,
  Expect<Equal<Multiply<0, 16>, '0'>>,
  Expect<Equal<Multiply<'13', '21'>, '273'>>,
  Expect<Equal<Multiply<'43423', 321543n>, '13962361689'>>,
  Expect<Equal<Multiply<9999, 1>, '9999'>>,
  Expect<Equal<Multiply<4325234, '39532'>, '170985150488'>>,
  Expect<Equal<Multiply<100_000n, '1'>, '100000'>>,
  Expect<Equal<Multiply<259, 9125385>, '2363474715'>>,
  Expect<Equal<Multiply<9, 99>, '891'>>,
  Expect<Equal<Multiply<315, '100'>, '31500'>>,
  Expect<Equal<Multiply<11n, 13n>, '143'>>,
  Expect<Equal<Multiply<728, 0>, '0'>>,
  Expect<Equal<Multiply<'0', 213>, '0'>>,
  Expect<Equal<Multiply<0, '0'>, '0'>>,
]