type-plus 8.0.0-beta.0 → 8.0.0-beta.2

package/ts/math/numeric_struct.ts

@@ -1,656 +0,0 @@
-import type { Tail } from '../tuple/tail.js'
-import type { PadStart } from '../tuple/tuple_plus.pad_start.js'
-import type { Add as NumericAdd } from './add.js'
-import type { ToNegative } from './math_plus.to_negative.js'
-
-/**
- * Internal numeric representation to perform math operations.
- *
- * NumericStruct: `[Type, DigitsStruct]`
- * DigitsStruct: `[Sign, Digits, Exponent]`
- *
- * It is similar to the floating point representation with some minor differences.
- *
- * @template Type Type of the value, either `number` or `bigint`.
- * It captures the original type of the value,
- * so that at the end of the operation,
- * the value can be adjusted accordingly.
- *
- * @template Sign Sign of the value, either `+` or `-`.
- *
- * @template Digits Digits of the value.
- * It is a tuple of digits,
- * where each digits can range from 0 to 9 during input,
- * and range from -10 to 89 during operation.
- * The max 89 comes from multiplication:
- *
- * ```
- * 99 * 9
- * => [[    9,  9], 0]
- * *  [        [9], 0]
- * => [[   81, 81], 0]
- * => [[   89,  1], 0]
- * => [[ 8, 9,  1], 0]
- * ```
- *
- * While -10 comes from subtraction:
- *
- * ```
- * 100 - 99 = 1
- * => [[  1,  0,  0], 0]
- * -  [[      9,  9], 0]
- * => [[  1, -9, -9], 0]
- * => [[  1,-10,  1], 0] // here, as in intermediate step
- * => [[  0,  0,  1], 0]
- * => [[1], 0]
- * => 1
- * ```
- *
- *
- * Unlike floating point numbers, the digits length is not limited.
- *
- * @template Exponent Exponent is the negative exponent of the number.
- *
- * ```
- * 1.23 = 123e^-2 = [[1, 2, 3], 2]
- * 0.0123 = 123e^-4 = [[1, 2, 3], 4]
- * ```
- *
- * There are 2 kinds of `NumericStruct`:
- * - Normalized: The `NumericStruct` is clean and can be converted to/from `number` or `bigint`
- * - Not normalized: The `DigitsStruct` within the `NumericStruct` is normalized,
- *   but may need to convert between `number` and `bigint`.\
- *   e.g. bigint + float => float (if possible), number + number => bigint (too big)
- *
- * During operations, the `DigitsStruct` can be not normalized,
- * but each operation should always normalize the `DigitsStruct` before returning.
- * Each operations assume the input `DigitsStruct` is normalized.
- *
- * All operations are performed in similar way:
- *
- * value -> NormalizedNumericStruct -> operation(NormalizedDigitsStruct) -> NormalizedNumericStruct -> Value
- *
- * This allows the operations to be composable.
- * */
-export type NumericStruct = ['bigint' | 'number', DigitsStruct]
-// These are used to reference the NumericStruct values
-export type TYPE = 0
-export type DIGITS_STRUCT = 1
-
-export namespace NumericStruct {
-	/**
-	 * Creates a `NumericStruct` from number or bigint `N`.
-	 */
-	export type FromNumeric<N extends number | bigint, Fail = never> = N extends number
-		? number extends N
-		? Fail
-		: ['number', DigitsStruct.FromNumber<N>]
-		: N extends bigint
-		? bigint extends N
-		? Fail
-		: ['bigint', DigitsStruct.FromBigint<N>]
-		: never
-
-	/**
-	 * Converts a `NumericStruct` to a number or bigint.
-	 *
-	 * It includes the normalization of the `NumericStruct`.
-	 */
-	export type ToNumeric<M extends NumericStruct> = DigitsStruct.ToString<
-		M[DIGITS_STRUCT]
-	> extends infer S extends string
-		? M[TYPE] extends 'bigint'
-		? StringToBigint<S, StringToNumber<S, `The value '${S}' cannot be represented as bigint or number`>>
-		: StringToNumber<S, StringToBigint<S, `The value '${S}' cannot be represented as bigint or number`>>
-		: never
-
-	export type Add<A extends NumericStruct, B extends NumericStruct> = [
-		A[TYPE],
-		DigitsStruct.Add<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
-	]
-
-	export type Subtract<A extends NumericStruct, B extends NumericStruct> = [
-		A[TYPE],
-		DigitsStruct.Subtract<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
-	]
-
-	export type Multiply<A extends NumericStruct, B extends NumericStruct> = [
-		A[TYPE],
-		DigitsStruct.Multiply<A[DIGITS_STRUCT], B[DIGITS_STRUCT]>
-	]
-}
-
-// TODO: move into `NumericHelpers`
-type StringToBigint<S extends string, Fail> = S extends `${infer N extends bigint}` ? N : Fail
-
-// TODO: move into `NumericHelpers`
-export type StringToNumber<S extends string, Fail> = S extends `${infer N extends number}`
-	? number extends N
-	? Fail
-	: N
-	: Fail
-
-export type DigitsStruct = [Sign: '+' | '-', Digits: number[], Exponent: number]
-// These are used to reference the DigitsStruct values
-export type SIGN = 0
-export type DIGITS = 1
-export type EXPONENT = 2
-
-export namespace DigitsStruct {
-	/**
-	 * Creates a `DigitsStruct` from number `N`.
-	 *
-	 * @template N Number to create `DigitsStruct` from.
-	 */
-	export type FromNumber<N extends number> = `${N}` extends `-${infer R}`
-		? R extends `${infer W}.${infer F}`
-		? [DigitArray.FromString<W>, DigitArray.FromString<F>] extends [
-			infer WA extends number[],
-			infer FA extends number[]
-		]
-		? ['-', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']]
-		: never
-		: ['-', DigitArray.FromString<R>, 0]
-		: `${N}` extends `${infer W}.${infer F}`
-		? [DigitArray.FromString<W>, DigitArray.FromString<F>] extends [
-			infer WA extends number[],
-			infer FA extends number[]
-		]
-		? ['+', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']]
-		: never
-		: ['+', DigitArray.FromString<`${N}`>, 0]
-
-	/**
-	 * Creates a `DigitsStruct` from bigint `N`.
-	 *
-	 * @template N Number to create `DigitsStruct` from.
-	 */
-	export type FromBigint<N extends bigint> = `${N}` extends `-${infer R}`
-		? ['-', DigitArray.FromString<R>, 0]
-		: ['+', DigitArray.FromString<`${N}`>, 0]
-
-	/**
-	 * Converts a `DigitsStruct` to string.
-	 *
-	 * @template D A normalized `DigitsStruct`.
-	 */
-	export type ToString<D extends DigitsStruct> = (
-		PadStart<D[DIGITS], D[EXPONENT], 0> extends infer Padded extends number[]
-		? Padded['length'] extends D[EXPONENT]
-		? DigitArray.ToString<[0, '.', ...DigitArray.TrimTrailingZeros<Padded>]>
-		: SplitFloat<Padded, D[EXPONENT]> extends [infer W extends number[], infer F extends number[]]
-		? F extends []
-		? DigitArray.ToString<W>
-		: DigitArray.ToString<[...W, '.', ...DigitArray.TrimTrailingZeros<F>]>
-		: never
-		: never
-	) extends infer R
-		? R extends '0'
-		? R
-		: R extends string
-		? D[SIGN] extends '-'
-		? `-${R}`
-		: R
-		: never
-		: never
-
-	/**
-	 * Splits DigitArray into the whole number and the fractional part.
-	 *
-	 * @note cannot use `ArrayPlus.SplitAt` as it causes infinite loop.
-	 */
-	type SplitFloat<A extends number[], I extends number, F extends number[] = []> = I extends 0
-		? [A, []]
-		: F['length'] extends I
-		? [A, F]
-		: A extends [...infer H extends number[], infer T extends number]
-		? SplitFloat<H, I, [T, ...F]>
-		: never
-
-	/**
-	 * Normalizes a `DigitsStruct`.
-	 *
-	 * The normalization two two things:
-	 *
-	 * - if the first digit is negative, it will flip the sign.
-	 * - carry digits if the digit is negative or greater than 9.
-	 */
-	export type Normalize<
-		N extends DigitsStruct,
-		R extends DigitsStruct = ['+', [], 0]
-	> = `${N[DIGITS][0]}` extends `-${number}`
-		? Normalize<FlipSign<N>, R>
-		: [N[SIGN], DigitArray.CarryDigits<N[DIGITS]>, N[EXPONENT]]
-
-	type FlipSign<
-		D extends DigitsStruct,
-		I extends number[] = D[DIGITS],
-		R extends number[] = []
-	> = I extends []
-		? D[SIGN] extends '-'
-		? ['+', R, D[EXPONENT]]
-		: ['-', R, D[EXPONENT]]
-		: I extends [infer H extends number, ...infer T extends number[]]
-		? FlipSign<D, T, [...R, Digit.FlipSign<H>]>
-		: never
-
-	/**
-	 * Add `A` and `B`.
-	 *
-	 * @template A A normalized `DigitsStruct`.
-	 * @template B B normalized `DigitsStruct`.
-	 */
-	export type Add<A extends DigitsStruct, B extends DigitsStruct> = Balance<A, B> extends [
-		infer BA extends DigitsStruct,
-		infer BB extends DigitsStruct
-	]
-		? [BA[SIGN], BB[SIGN]] extends ['+', '+']
-		? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-		: [BA[SIGN], BB[SIGN]] extends ['+', '-']
-		? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-		: [BA[SIGN], BB[SIGN]] extends ['-', '+']
-		? Normalize<['+', DigitArray.Subtract<BB[DIGITS], BA[DIGITS]>, BB[EXPONENT]]>
-		: [BA[SIGN], BB[SIGN]] extends ['-', '-']
-		? Normalize<['-', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-		: never
-		: never
-
-	export type Subtract<A extends DigitsStruct, B extends DigitsStruct> = Balance<A, B> extends [
-		infer BA extends DigitsStruct,
-		infer BB extends DigitsStruct
-	]
-		? [BA[SIGN], BB[SIGN]] extends ['+', '+']
-		? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-		: [BA[SIGN], BB[SIGN]] extends ['+', '-']
-		? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-		: [BA[SIGN], BB[SIGN]] extends ['-', '+']
-		? Normalize<['-', DigitArray.Add<BB[DIGITS], BA[DIGITS]>, BA[EXPONENT]]>
-		: [BA[SIGN], BB[SIGN]] extends ['-', '-']
-		? Normalize<['-', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-		: never
-		: never
-
-	export type Multiply<A extends DigitsStruct, B extends DigitsStruct> = NumericAdd<
-		A[EXPONENT],
-		B[EXPONENT]
-	> extends infer Exp extends number
-		? [A[SIGN], B[SIGN]] extends ['+', '+']
-		? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
-		: [A[SIGN], B[SIGN]] extends ['+', '-']
-		? Normalize<['-', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
-		: [A[SIGN], B[SIGN]] extends ['-', '+']
-		? Normalize<['-', DigitArray.Multiply<B[DIGITS], A[DIGITS]>, Exp]>
-		: [A[SIGN], B[SIGN]] extends ['-', '-']
-		? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
-		: never
-		: never
-
-	/**
-	 * Balance the two structs for add/subtract.
-	 */
-	export type Balance<A extends DigitsStruct, B extends DigitsStruct> = GetBalancePadding<
-		A[EXPONENT],
-		B[EXPONENT]
-	> extends [infer Pads extends number[], infer Longer]
-		? Longer extends 'A'
-		? [A, [B[SIGN], DigitArray.TrimLeadingZeros<[...B[DIGITS], ...Pads]>, A[EXPONENT]]]
-		: [[A[SIGN], DigitArray.TrimLeadingZeros<[...A[DIGITS], ...Pads]>, B[EXPONENT]], B]
-		: never
-
-	type GetBalancePadding<
-		A extends number,
-		B extends number,
-		C extends number[] = [],
-		R extends number[] = []
-	> = A extends B
-		? [[], 'A']
-		: R extends []
-		? // have not reach min yet
-		C['length'] extends A
-		? GetBalancePadding<A, B, [0, ...C], [0]>
-		: C['length'] extends B
-		? GetBalancePadding<A, B, [0, ...C], [0, ...R]>
-		: GetBalancePadding<A, B, [0, ...C], []>
-		: C['length'] extends A
-		? [R, 'A']
-		: C['length'] extends B
-		? [R, 'B']
-		: GetBalancePadding<A, B, [0, ...C], [0, ...R]>
-
-	/**
-	 * This is used to align the `NumberStruct` during `Add/Subtract`.
-	 */
-	export type GetMinPadEnd<
-		A extends number,
-		B extends number,
-		R extends number[] = []
-	> = R['length'] extends A ? [R, 'B'] : R['length'] extends B ? [R, 'A'] : GetMinPadEnd<A, B, [0, ...R]>
-}
-
-export namespace DigitArray {
-	export type FromString<S extends string> = S extends `1${infer L}`
-		? [1, ...FromString<L>]
-		: S extends `2${infer L}`
-		? [2, ...FromString<L>]
-		: S extends `3${infer L}`
-		? [3, ...FromString<L>]
-		: S extends `4${infer L}`
-		? [4, ...FromString<L>]
-		: S extends `5${infer L}`
-		? [5, ...FromString<L>]
-		: S extends `6${infer L}`
-		? [6, ...FromString<L>]
-		: S extends `7${infer L}`
-		? [7, ...FromString<L>]
-		: S extends `8${infer L}`
-		? [8, ...FromString<L>]
-		: S extends `9${infer L}`
-		? [9, ...FromString<L>]
-		: S extends `0${infer L}`
-		? [0, ...FromString<L>]
-		: S extends `-1${infer L}`
-		? [-1, ...FromString<L>]
-		: S extends `-2${infer L}`
-		? [-2, ...FromString<L>]
-		: S extends `-3${infer L}`
-		? [-3, ...FromString<L>]
-		: S extends `-4${infer L}`
-		? [-4, ...FromString<L>]
-		: S extends `-5${infer L}`
-		? [-5, ...FromString<L>]
-		: S extends `-6${infer L}`
-		? [-6, ...FromString<L>]
-		: S extends `-7${infer L}`
-		? [-7, ...FromString<L>]
-		: S extends `-8${infer L}`
-		? [-8, ...FromString<L>]
-		: S extends `-9${infer L}`
-		? [-9, ...FromString<L>]
-		: S extends `-0${infer L}`
-		? [-0, ...FromString<L>]
-		: []
-
-	export type ToString<A extends Array<number | string>> = number extends A['length']
-		? ''
-		: A['length'] extends 0
-		? ''
-		: `${A[0]}${ToString<Tail<A>>}`
-
-	/**
-	 * [0, 0, -1] => [-1]
-	 *
-	 * This is used in various places so that there will be less computation,
-	 * and the sign bit can be handled properly.
-	 */
-	export type TrimLeadingZeros<T extends number[]> = T extends [0]
-		? T
-		: T extends [0, ...infer Tail extends number[]]
-		? TrimLeadingZeros<Tail>
-		: T
-	export type TrimTrailingZeros<T extends number[]> = T extends [0]
-		? T
-		: T extends [...infer Tail extends number[], 0]
-		? TrimTrailingZeros<Tail>
-		: T
-
-	export type Add<A extends number[], B extends number[], R extends number[] = []> = A extends []
-		? B extends []
-		? R
-		: B extends [...infer BH extends number[], infer BL extends number]
-		? Add<[], BH, [BL, ...R]>
-		: never
-		: B extends []
-		? A extends [...infer AH extends number[], infer AL extends number]
-		? Add<AH, [], [AL, ...R]>
-		: never
-		: [A, B] extends [
-			[...infer AH extends number[], infer AL extends number],
-			[...infer BH extends number[], infer BL extends number]
-		]
-		? Add<AH, BH, [Digit.Add<AL, BL>, ...R]>
-		: never
-
-	export type Subtract<A extends number[], B extends number[], R extends number[] = []> = A extends []
-		? B extends []
-		? TrimLeadingZeros<R>
-		: B extends [...infer BH extends number[], infer BL extends number]
-		? Subtract<[], BH, [ToNegative<BL>, ...R]>
-		: never
-		: B extends []
-		? A extends [...infer AH extends number[], infer AL extends number]
-		? Subtract<AH, [], [AL, ...R]>
-		: never
-		: [A, B] extends [
-			[...infer AH extends number[], infer AL extends number],
-			[...infer BH extends number[], infer BL extends number]
-		]
-		? Subtract<AH, BH, [Digit.Subtract<AL, BL>, ...R]>
-		: never
-
-	export type Multiply<A extends number[], B extends number[], R extends number[][] = []> = B extends []
-		? RecursiveAdd<R>
-		: B extends [infer Head extends number, ...infer Tail extends number[]]
-		? Multiply<A, Tail, [...R, CarryDigits<MultiplyArray<A, Head, Zeros<Tail['length']>>>]>
-		: never
-
-	type Zeros<N extends number, R extends number[] = []> = R['length'] extends N ? R : Zeros<N, [0, ...R]>
-
-	type MultiplyArray<
-		A extends number[],
-		B extends number,
-		Pad extends number[],
-		R extends number[] = []
-	> = B extends 0
-		? [0]
-		: B extends 1
-		? [...A, ...Pad]
-		: A extends []
-		? [...R, ...Pad]
-		: A extends [infer H extends number, ...infer T extends number[]]
-		? MultiplyArray<T, B, Pad, [...R, Digit.Multiply<H, B>]>
-		: never
-
-	/**
-	 * Recursively add digit arrays.
-	 *
-	 * This is used in multiplication.
-	 */
-	type RecursiveAdd<E extends number[][], R extends number[] = []> = E extends []
-		? R
-		: E extends [infer H extends number[], ...infer T extends number[][]]
-		? RecursiveAdd<T, CarryDigits<Add<R, H>>>
-		: never
-
-	export type CarryDigits<N extends number[], R extends number[] = []> = N extends []
-		? TrimLeadingZeros<R>
-		: N extends [infer Tail extends number]
-		? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}`
-		? CarryDigits<[], [T1, T2, ...R]>
-		: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
-		? `-${T1}` extends `${infer NT extends number}`
-		? CarryDigits<[], [NT, T2, ...R]>
-		: never
-		: CarryDigits<[], [Tail, ...R]>
-		: N extends [infer Head extends number, infer Tail extends number]
-		? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}`
-		? CarryDigits<[Digit.Add<Head, T1>], [T2, ...R]>
-		: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
-		? `-${T1}` extends `${infer NT extends number}`
-		? CarryDigits<[Digit.Add<Head, NT>], [T2, ...R]>
-		: never
-		: `${Tail}` extends `-${number}`
-		? CarryDigits<[Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]>
-		: CarryDigits<[Head], [Tail, ...R]>
-		: N extends [...infer Heads extends number[], infer Head extends number, infer Tail extends number]
-		? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}`
-		? CarryDigits<[...Heads, Digit.Add<Head, T1>], [T2, ...R]>
-		: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
-		? `-${T1}` extends `${infer NT extends number}`
-		? CarryDigits<[...Heads, Digit.Add<Head, NT>], [T2, ...R]>
-		: never
-		: `${Tail}` extends `-${number}`
-		? CarryDigits<[...Heads, Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]>
-		: CarryDigits<[...Heads, Head], [Tail, ...R]>
-		: never
-}
-
-export namespace Digit {
-	/**
-	 * Adds two `Digit`.
-	 *
-	 * add: A: 0 - 9, B: 0 - 9
-	 * normalize: [81, 81] -> [81 + 8, 1]
-	 */
-	export type Add<A extends number, B extends number> = `${A}` extends `-${infer AD extends number}`
-		? `${B}` extends `-${infer BD extends number}`
-		? ToNegative<PositiveEntryAdd<AD, BD>>
-		: Subtract<B, AD>
-		: `${B}` extends `-${infer BD extends number}`
-		? Subtract<A, BD>
-		: PositiveEntryAdd<A, B>
-
-	export type FlipSign<T extends number> = T extends 0
-		? 0
-		: `${T}` extends `-${infer R extends number}`
-		? R
-		: `-${T}` extends `${infer R extends number}`
-		? R
-		: never
-
-	type PositiveEntryAdd<A extends number, B extends number> = [
-		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-		[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
-		[2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
-		[3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
-		[4, 5, 6, 7, 8, 9, 10, 11, 12, 13],
-		[5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
-		[6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
-		[7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
-		[8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
-		[9, 10, 11, 12, 13, 14, 15, 16, 17, 18],
-		[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
-		[11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
-		[12, 13, 14, 15, 16, 17, 18, 19, 20, 21],
-		[13, 14, 15, 16, 17, 18, 19, 20, 21, 22],
-		[14, 15, 16, 17, 18, 19, 20, 21, 22, 23],
-		[15, 16, 17, 18, 19, 20, 21, 22, 23, 24],
-		[16, 17, 18, 19, 20, 21, 22, 23, 24, 25],
-		[17, 18, 19, 20, 21, 22, 23, 24, 25, 26],
-		[18, 19, 20, 21, 22, 23, 24, 25, 26, 27],
-		[19, 20, 21, 22, 23, 24, 25, 26, 27, 28],
-		[20, 21, 22, 23, 24, 25, 26, 27, 28, 29],
-		[21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
-		[22, 23, 24, 25, 26, 27, 28, 29, 30, 31],
-		[23, 24, 25, 26, 27, 28, 29, 30, 31, 32],
-		[24, 25, 26, 27, 28, 29, 30, 31, 32, 33],
-		[25, 26, 27, 28, 29, 30, 31, 32, 33, 34],
-		[26, 27, 28, 29, 30, 31, 32, 33, 34, 35],
-		[27, 28, 29, 30, 31, 32, 33, 34, 35, 36],
-		[28, 29, 30, 31, 32, 33, 34, 35, 36, 37],
-		[29, 30, 31, 32, 33, 34, 35, 36, 37, 38],
-		[30, 31, 32, 33, 34, 35, 36, 37, 38, 39],
-		[31, 32, 33, 34, 35, 36, 37, 38, 39, 40],
-		[32, 33, 34, 35, 36, 37, 38, 39, 40, 41],
-		[33, 34, 35, 36, 37, 38, 39, 40, 41, 42],
-		[34, 35, 36, 37, 38, 39, 40, 41, 42, 43],
-		[35, 36, 37, 38, 39, 40, 41, 42, 43, 44],
-		[36, 37, 38, 39, 40, 41, 42, 43, 44, 45],
-		[37, 38, 39, 40, 41, 42, 43, 44, 45, 46],
-		[38, 39, 40, 41, 42, 43, 44, 45, 46, 47],
-		[39, 40, 41, 42, 43, 44, 45, 46, 47, 48],
-		[40, 41, 42, 43, 44, 45, 46, 47, 48, 49],
-		[41, 42, 43, 44, 45, 46, 47, 48, 49, 50],
-		[42, 43, 44, 45, 46, 47, 48, 49, 50, 51],
-		[43, 44, 45, 46, 47, 48, 49, 50, 51, 52],
-		[44, 45, 46, 47, 48, 49, 50, 51, 52, 53],
-		[45, 46, 47, 48, 49, 50, 51, 52, 53, 54],
-		[46, 47, 48, 49, 50, 51, 52, 53, 54, 55],
-		[47, 48, 49, 50, 51, 52, 53, 54, 55, 56],
-		[48, 49, 50, 51, 52, 53, 54, 55, 56, 57],
-		[49, 50, 51, 52, 53, 54, 55, 56, 57, 58],
-		[50, 51, 52, 53, 54, 55, 56, 57, 58, 59],
-		[51, 52, 53, 54, 55, 56, 57, 58, 59, 60],
-		[52, 53, 54, 55, 56, 57, 58, 59, 60, 61],
-		[53, 54, 55, 56, 57, 58, 59, 60, 61, 62],
-		[54, 55, 56, 57, 58, 59, 60, 61, 62, 63],
-		[55, 56, 57, 58, 59, 60, 61, 62, 63, 64],
-		[56, 57, 58, 59, 60, 61, 62, 63, 64, 65],
-		[57, 58, 59, 60, 61, 62, 63, 64, 65, 66],
-		[58, 59, 60, 61, 62, 63, 64, 65, 66, 67],
-		[59, 60, 61, 62, 63, 64, 65, 66, 67, 68],
-		[60, 61, 62, 63, 64, 65, 66, 67, 68, 69],
-		[61, 62, 63, 64, 65, 66, 67, 68, 69, 70],
-		[62, 63, 64, 65, 66, 67, 68, 69, 70, 71],
-		[63, 64, 65, 66, 67, 68, 69, 70, 71, 72],
-		[64, 65, 66, 67, 68, 69, 70, 71, 72, 73],
-		[65, 66, 67, 68, 69, 70, 71, 72, 73, 74],
-		[66, 67, 68, 69, 70, 71, 72, 73, 74, 75],
-		[67, 68, 69, 70, 71, 72, 73, 74, 75, 76],
-		[68, 69, 70, 71, 72, 73, 74, 75, 76, 77],
-		[69, 70, 71, 72, 73, 74, 75, 76, 77, 78],
-		[70, 71, 72, 73, 74, 75, 76, 77, 78, 79],
-		[71, 72, 73, 74, 75, 76, 77, 78, 79, 80],
-		[72, 73, 74, 75, 76, 77, 78, 79, 80, 81],
-		[73, 74, 75, 76, 77, 78, 79, 80, 81, 82],
-		[74, 75, 76, 77, 78, 79, 80, 81, 82, 83],
-		[75, 76, 77, 78, 79, 80, 81, 82, 83, 84],
-		[76, 77, 78, 79, 80, 81, 82, 83, 84, 85],
-		[77, 78, 79, 80, 81, 82, 83, 84, 85, 86],
-		[78, 79, 80, 81, 82, 83, 84, 85, 86, 87],
-		[79, 80, 81, 82, 83, 84, 85, 86, 87, 88],
-		[80, 81, 82, 83, 84, 85, 86, 87, 88, 89],
-		[81, 82, 83, 84, 85, 86, 87, 88, 89, 90]
-	][A][B]
-
-	/**
-	 * Subtract two positive numbers.
-	 * The number range from 0 to 81.
-	 */
-	export type Subtract<A extends number, B extends number> = [`${A}`, `${B}`] extends [
-		`${number}${infer A2 extends number}`,
-		`${number}${infer B2 extends number}`
-	]
-		? Subtract<A2, B2>
-		: `${A}` extends `${number}${infer A2 extends number}`
-		? Subtract<A2, B>
-		: `${B}` extends `${number}${infer B2 extends number}`
-		? Subtract<A, B2>
-		: SingleDigitSubtract<A, B>
-
-	export type SingleDigitSubtract<A extends number, B extends number> = [
-		[0, -1, -2, -3, -4, -5, -6, -7, -8, -9],
-		[1, 0, -1, -2, -3, -4, -5, -6, -7, -8],
-		[2, 1, 0, -1, -2, -3, -4, -5, -6, -7],
-		[3, 2, 1, 0, -1, -2, -3, -4, -5, -6],
-		[4, 3, 2, 1, 0, -1, -2, -3, -4, -5],
-		[5, 4, 3, 2, 1, 0, -1, -2, -3, -4],
-		[6, 5, 4, 3, 2, 1, 0, -1, -2, -3],
-		[7, 6, 5, 4, 3, 2, 1, 0, -1, -2],
-		[8, 7, 6, 5, 4, 3, 2, 1, 0, -1],
-		[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
-	][A][B]
-
-	export type Plus10 = { [k in number]: number } & {
-		'-1': 9,
-		'-2': 8,
-		'-3': 7,
-		'-4': 6,
-		'-5': 5,
-		'-6': 4,
-		'-7': 3,
-		'-8': 2,
-		'-9': 1
-	}
-	export type Multiply<A extends number, B extends number> = [
-		[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-		[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-		[0, 2, 4, 6, 8, 10, 12, 14, 16, 18],
-		[0, 3, 6, 9, 12, 15, 18, 21, 24, 27],
-		[0, 4, 8, 12, 16, 20, 24, 28, 32, 36],
-		[0, 5, 10, 15, 20, 25, 30, 35, 40, 45],
-		[0, 6, 12, 18, 24, 30, 36, 42, 48, 54],
-		[0, 7, 14, 21, 28, 35, 42, 49, 56, 63],
-		[0, 8, 16, 24, 32, 40, 48, 56, 64, 72],
-		[0, 9, 18, 27, 36, 45, 54, 63, 72, 81]
-	][A][B]
-}

package/ts/mix_types/any_or_never_type.ts

@@ -1,38 +0,0 @@
-import type { AnyType } from '../any/any_type.js'
-import type { NeverType } from '../never/never_type.js'
-
-/**
- * Parse `T` to ensure it is either exactly `any` or exactly `never`.
- *
- * 🌪️ *filter*
- * 🩳 *shortcut*
- *
- * @example
- * ```ts
- * type R = AnyOrNeverType<any> // any
- * type R = AnyOrNeverType<never> // never
- * type R = AnyOrNeverType<never, 1, 2> // 1
- *
- * type R = AnyOrNeverType<unknown> // never
- * type R = AnyOrNeverType<unknown, 1, 2> // 2
- * type R = AnyOrNeverType<string | boolean> // never
- * ```
- */
-export type AnyOrNeverType<T, Then = T, Else = never> = NeverType<T, Then, AnyType<T, Then, Else>>
-
-/**
- * Validate if `T` is either exactly `any` or exactly `never`.
- *
- * 🎭 *validate*
- * 🩳 *shortcut*
- *
- * @example
- * ```ts
- * type R = IsAnyOrNever<any> // true
- * type R = IsAnyOrNever<never> // true
- *
- * type R = IsAnyOrNever<1> // false
- * type R = IsAnyOrNever<unknown> // false
- * ```
- */
-export type IsAnyOrNever<T, Then = true, Else = false> = NeverType<T, Then, AnyType<T, Then, Else>>