@avstantso/ts 1.1.0 → 1.2.1

package/dist/_global/numeric/domain/inc-dec.d.ts

@@ -0,0 +1,52 @@
+declare namespace AVStantso.TS.Numeric.Domain {
+    /**
+     * @summary Increment numeric literal inside `Numeric.Domain`\
+     *
+     * ⚠ Result defined on `Numeric.Domain`
+     * @template N Numeric literal
+     * @see Source: https://stackoverflow.com/questions/54243431/how-can-i-produce-an-incremented-version-of-a-numeric-literal-type-in-typescript
+     * @example
+     * type nv = CheckType<Increment<never>, number>;
+     * type ud = CheckType<Increment<undefined>, unknown>;
+     * 
+     * type p10 = CheckType<Increment<10>, 11>;
+     * type p = CheckType<Increment<1>, 2>;
+     * type z = CheckType<Increment<0>, 1>;
+     * type n = CheckType<Increment<-1>, 0>;
+     * type n10 = CheckType<Increment<-10>, -9>;
+     */
+    type Increment<N extends number> = Numeric.IsNegative<N> extends false ? [
+        ...Numeric.Domain.Positive,
+        ...number[]
+    ][N] : [
+        1,
+        0,
+        ...Numeric.Domain.Negative,
+        ...number[]
+    ][Numeric.Negative.ToPositive<N>];
+    /**
+     * @summary Decrement numeric literal inside `Numeric.Domain`\
+     *
+     * ⚠ Result defined on `Numeric.Domain`
+     * @template N Numeric literal
+     * @example
+     * type nv = CheckType<Decrement<never>, number>;
+     * type ud = CheckType<Decrement<undefined>, unknown>;
+     * 
+     * type p10 = CheckType<Decrement<10>, 9>;
+     * type p = CheckType<Decrement<1>, 0>;
+     * type z = CheckType<Decrement<0>, -1>;
+     * type n = CheckType<Decrement<-1>, -2>;
+     * type n10 = CheckType<Decrement<-10>, -11>;
+     * @see Increment
+     */
+    type Decrement<N extends number> = Numeric.IsNegative<N> extends false ? [
+        -1,
+        0,
+        ...Numeric.Domain.Positive,
+        ...number[]
+    ][N] : [
+        ...Numeric.Domain.Negative,
+        ...number[]
+    ][Numeric.Negative.ToPositive<N>];
+}

package/dist/_global/numeric/domain/independent.d.ts

@@ -0,0 +1,203 @@
+declare namespace AVStantso.TS.Numeric {
+    /**
+     * @summary Test a number `N` is a positive number
+     * @template N Tested number
+     * @template IfTrue Result, if `N` is a positive number
+     * @template IfFalse Result, if `N` is a negative number or `0` or `undefined`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type nv = CheckType<IsPositive<never>, never>;
+     * type uf = CheckType<IsPositive<undefined>, false>;
+     * 
+     * type p = CheckType<IsPositive<1>, true>;
+     * type z = CheckType<IsPositive<0>, false>;
+     * type n = CheckType<IsPositive<-1>, false>;
+     */
+    export type IsPositive<N extends number, IfTrue = true, IfFalse = false> = N extends undefined | 0 ? IfFalse : `${N}` extends `-${string}` ? IfFalse : IfTrue;
+    /**
+     * @summary Test a number `N` is a negative number
+     * @template N Tested number
+     * @template IfTrue Result, if `N` is a negative number
+     * @template IfFalse Result, if `N` is a positive number or `0` or `undefined`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type nv = CheckType<IsNegative<never>, never>;
+     * type uf = CheckType<IsNegative<undefined>, false>;
+     * 
+     * type p = CheckType<IsNegative<1>, false>;
+     * type z = CheckType<IsNegative<0>, false>;
+     * type n = CheckType<IsNegative<-1>, true>;
+     */
+    export type IsNegative<N extends number, IfTrue = true, IfFalse = false> = N extends undefined | 0 ? IfFalse : `${N}` extends `-${string}` ? IfTrue : IfFalse;
+    /**
+     * @summary Positive numbers types.
+     */
+    export namespace Positive {
+        /**
+         * @summary Get negative of absolute value of numeric literal.
+         *
+         * Negative numbers not change.
+         * @example
+         * type nv = CheckType<ToNegative<never>, never>;
+         * type ud = CheckType<ToNegative<undefined>, undefined>;
+         * 
+         * type z = CheckType<ToNegative<0>, 0>;
+         * 
+         * type p1 = CheckType<ToNegative<1>, -1>;
+         * type p255 = CheckType<ToNegative<255>, -255>;
+         * type p999 = CheckType<ToNegative<999>, -999>;
+         * 
+         * type n1 = CheckType<ToNegative<-1>, -1>;
+         * type n255 = CheckType<ToNegative<-255>, -255>;
+         * type n999 = CheckType<ToNegative<-999>, -999>;
+         */
+        type ToNegative<N extends number> = N extends undefined | 0 ? N : `-${N}` extends `${infer R extends number}` ? R : N;
+    }
+    /**
+     * @summary Negative numbers types.
+     */
+    export namespace Negative {
+        /**
+         * @summary Get absolute value of negative numeric literal.
+         *
+         * Positive numbers not change.
+         *
+         * ⚠ Is low-level type! Use `Numeric.Abs` instead
+         * @example
+         * type nv = CheckType<ToPositive<never>, never>;
+         * type ud = CheckType<ToPositive<undefined>, undefined>;
+         * 
+         * type z = CheckType<ToPositive<0>, 0>;
+         * 
+         * type p1 = CheckType<ToPositive<1>, 1>;
+         * type p255 = CheckType<ToPositive<255>, 255>;
+         * type p999 = CheckType<ToPositive<999>, 999>;
+         * 
+         * type n1 = CheckType<ToPositive<-1>, 1>;
+         * type n255 = CheckType<ToPositive<-255>, 255>;
+         * type n999 = CheckType<ToPositive<-999>, 999>;
+         */
+        type ToPositive<N extends number> = N extends undefined | 0 ? N : `${N}` extends `-${infer R extends number}` ? R : N;
+    }
+    /**
+     * @summary With `N` param returns sign of `N`.
+     *
+     * Without `N` param returns sign union `-1 | 0 | 1`
+     * @template N Number
+     * @example
+     * type s = CheckType<Sign, -1 | 0 | 1>;
+     * type p = CheckType<Sign<10>, 1>;
+     * type z = CheckType<Sign<0>, 0>;
+     * type n = CheckType<Sign<-10>, -1>;
+     */
+    export type Sign<N extends number = undefined> = N extends undefined ? -1 | 0 | 1 : N extends 0 ? 0 : IsNegative<N, -1, 1>;
+    /**
+     * @summary Digits
+     */
+    export namespace Digits {
+        /**
+         * @summary Digits 10 map
+         */
+        type Map = {
+            '0': 0;
+            '1': 1;
+            '2': 2;
+            '3': 3;
+            '4': 4;
+            '5': 5;
+            '6': 6;
+            '7': 7;
+            '8': 8;
+            '9': 9;
+        };
+        /**
+         * @summary Is odd digit map
+         */
+        type IsOdd = {
+            '0': false;
+            '1': true;
+            '2': false;
+            '3': true;
+            '4': false;
+            '5': true;
+            '6': false;
+            '7': true;
+            '8': false;
+            '9': true;
+        };
+        /**
+         * @summary Digits 16
+         */
+        namespace Hex {
+            /**
+             * @summary Digits 16 map
+             */
+            type Map = Digits.Map & {
+                'A': 'A';
+                'B': 'B';
+                'C': 'C';
+                'D': 'D';
+                'E': 'E';
+                'F': 'F';
+            };
+        }
+        type Hex = keyof Hex.Map;
+    }
+    export type Digits = keyof Digits.Map;
+    type _IsOdd<S extends string> = S extends `${infer C}${infer E}` ? E extends '' ? Digits.IsOdd[Extract<C, keyof Digits.IsOdd>] : _IsOdd<E> : never;
+    /**
+     * @summary Test a number is a odd number
+     * @template N Tested number
+     * @template IfTrue Result, if `N` is a odd number
+     * @template IfFalse Result, if `N` is a even number or `0` or `undefined`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type o = CheckType<IsOdd<11>, true>;
+     * type e = CheckType<IsOdd<32>, false>;
+     */
+    export type IsOdd<N extends number, IfTrue = true, IfFalse = false> = N extends undefined ? never : (`${N}` extends `-${infer S}` ? _IsOdd<S> : _IsOdd<`${N}`>) extends true ? IfTrue : IfFalse;
+    /**
+     * @summary Test a number is a even number
+     * @template N Tested number
+     * @template IfTrue Result, if `N` is a even number
+     * @template IfFalse Result, if `N` is a odd number or `0` or `undefined`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type o = CheckType<IsEven<11>, false>;
+     * type e = CheckType<IsEven<32>, true>;
+     */
+    export type IsEven<N extends number, IfTrue = true, IfFalse = false> = N extends undefined ? IfFalse : (`${N}` extends `-${infer S}` ? _IsOdd<S> : _IsOdd<`${N}`>) extends true ? IfFalse : IfTrue;
+    type _IsNumber<S extends string> = S extends '' ? false : S extends `${infer C}${infer E}` ? C extends Digits ? E extends '' ? true : _IsNumber<E> : false : never;
+    /**
+     * @summary Test a string `S` is a number in string
+     * @template S Tested string
+     * @template IfTrue Result, if `S` is a number in string
+     * @template IfFalse Result, if `S` is NOT a number in string or `undefined`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type pn = CheckType<IsNumber<'1000'>, true>;
+     * type s = CheckType<IsNumber<'abc'>, false>;
+     * type nn = CheckType<IsNumber<'-1'>, true>;
+     * type nnn = CheckType<IsNumber<'--1'>, false>;
+     */
+    export type IsNumber<S extends string, IfTrue = true, IfFalse = false> = S extends undefined ? IfFalse : (`${S}` extends `-${infer V}` ? _IsNumber<V> : _IsNumber<S>) extends true ? IfTrue : IfFalse;
+    /**
+     * @summary Parse string `S` for extract number from it
+     * @example
+     * type nv = CheckType<Parse<never>, never>;
+     * type ud = CheckType<Parse<undefined>, undefined>;
+     * type nan = CheckType<Parse<'abc'>, never>;
+     * 
+     * type z = CheckType<Parse<'0'>, 0>;
+     * 
+     * type p1 = CheckType<Parse<'1'>, 1>;
+     * type p255 = CheckType<Parse<'255'>, 255>;
+     * type p999 = CheckType<Parse<'999'>, 999>;
+     * 
+     * type n1 = CheckType<Parse<'-1'>, -1>;
+     * type n255 = CheckType<Parse<'-255'>, -255>;
+     * type n999 = CheckType<Parse<'-999'>, -999>;
+     */
+    export type Parse<S extends string> = S extends undefined ? S : `${S}` extends `${infer N extends number}` ? N : never;
+    export {};
+}

package/dist/_global/numeric/domain/index.d.ts

@@ -0,0 +1,4 @@
+import './independent';
+import './generated';
+import './describes';
+import './inc-dec';

package/dist/_global/numeric/inc-dec.d.ts

@@ -0,0 +1,50 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Increment numeric literal inside `Numeric.Domain.Positive`
+     *
+     * ⚠ Result defined on `Numeric.Domain.Positive`
+     * @template N Numeric literal
+     * @see Numeric.Domain.Increment
+     * @example
+     * type nv = CheckType<Increment<never>, number>;
+     * 
+     * // Loading...
+     * // type ud = CheckType<Increment<undefined>, unknown>;
+     * 
+     * type z = CheckType<Increment<0>, 1>;
+     * type p1 = CheckType<Increment<1>, 2>;
+     * type p255 = CheckType<Increment<255>, 256>;
+     * 
+     * // Loading...
+     * //type n = CheckType<Increment<-1>, number>;
+     */
+    type Increment<N extends number> = [
+        ...Numeric.Domain.Positive,
+        ...number[]
+    ][N];
+    /**
+     * @summary Decrement numeric literal inside positive `Numeric.Domain.Positive`
+     *
+     * ⚠ Result defined on `Numeric.Domain.Positive`
+     * @template N Numeric literal
+     * @example
+     * type nv = CheckType<Decrement<never>, number>;
+     * 
+     * // Loading...
+     * // type ud = CheckType<Decrement<undefined>, unknown>;
+     * 
+     * type z = CheckType<Decrement<0>, -1>;
+     * type p1 = CheckType<Decrement<1>, 0>;
+     * type p255 = CheckType<Decrement<255>, 254>;
+     * 
+     * // Loading...
+     * //type n = CheckType<Decrement<-1>, number>;
+     * @see Numeric.Domain.Decrement
+     */
+    type Decrement<N extends number> = [
+        -1,
+        0,
+        ...Numeric.Domain.Positive,
+        ...number[]
+    ][N];
+}

package/dist/_global/numeric/index.d.ts

@@ -0,0 +1,3 @@
+import './domain';
+import './inc-dec';
+import './math';

package/dist/_global/numeric/math.d.ts

@@ -0,0 +1,257 @@
+declare namespace AVStantso.TS.Numeric {
+    /**
+     * @summary Absolute value of numeric literal.
+     * @example
+     * type nv = CheckType<Abs<never>, never>;
+     * type ud = CheckType<Abs<undefined>, undefined>;
+     * 
+     * type z = CheckType<Abs<0>, 0>;
+     * 
+     * type p1 = CheckType<Abs<1>, 1>;
+     * type p255 = CheckType<Abs<255>, 255>;
+     * type p999 = CheckType<Abs<999>, 999>;
+     * 
+     * type n1 = CheckType<Abs<-1>, 1>;
+     * type n255 = CheckType<Abs<-255>, 255>;
+     * type n999 = CheckType<Abs<-999>, 999>;
+     */
+    export type Abs<N extends number> = Negative.ToPositive<N>;
+    /**
+     * @summary Invert value of numeric literal. `Positive ⇔ Negative`
+     * @example
+     * type nv = CheckType<Invert<never>, never>;
+     * type ud = CheckType<Invert<undefined>, undefined>;
+     * 
+     * type z = CheckType<Invert<0>, 0>;
+     * 
+     * type p1 = CheckType<Invert<1>, -1>;
+     * type p255 = CheckType<Invert<255>, -255>;
+     * type p999 = CheckType<Invert<999>, -999>;
+     * 
+     * type n1 = CheckType<Invert<-1>, 1>;
+     * type n255 = CheckType<Invert<-255>, 255>;
+     * type n999 = CheckType<Invert<-999>, 999>;
+     */
+    export type Invert<N extends number> = N extends undefined | 0 ? N : `${N}` extends `-${infer V extends number}` ? V : `-${N}` extends `${infer V extends number}` ? V : never;
+    /**
+     * @summary Digits x 2: `[<Current digit>, <Next digit coef>]`
+     */
+    type Dx2 = [number, number];
+    /**
+     * @summary `X, Y, Abs<X>, Abs<Y>, Sign<X>, Sign<Y>`
+     */
+    type Args = [number, number, number, number, number, number];
+    namespace Args {
+        /**
+         * @returns `[Abs<N>, Sign<N>]`
+         */
+        export type ABSG<N extends number> = N extends 0 ? [0, 0] : `${N}` extends `-${infer V extends number}` ? [V, -1] : [N, 1];
+        export type From<X extends number, Y extends number, absgX extends [number, number] = ABSG<X>, absgY extends [number, number] = ABSG<Y>> = [
+            X,
+            Y,
+            absgX[0],
+            absgY[0],
+            absgX[1],
+            absgY[1]
+        ];
+        export type Exchange<A extends Args> = [A[1], A[0], A[3], A[2], A[5], A[4]];
+        type _SignsMultTable = [
+            [
+                1,
+                0,
+                -1
+            ],
+            [
+                0,
+                0,
+                0
+            ],
+            [
+                -1,
+                0,
+                1
+            ]
+        ];
+        export type SignsMult<A extends Args> = _SignsMultTable[Domain.Increment<A[4]>][Domain.Increment<A[5]>];
+        export {};
+    }
+    namespace _SummDiff {
+        namespace For {
+            type Up<X extends number, Y extends number> = 0 extends X | Y ? X extends 0 ? Y : Y extends 0 ? X : never : Up<Domain.Increment<X>, Domain.Decrement<Y>>;
+        }
+        /**
+         * @summary Empiric limit `999` in difference
+         * @deprecated Difficult to use due to limit
+         */
+        export type For<X extends number, Y extends number> = IsNegative<Y> extends true ? For.Up<Y, X> : For.Up<X, Y>;
+        export type Digits<Xd extends string[], Yd extends string[], IsMinus extends boolean, R extends Dx2[] = []> = Xd extends [`${infer fX extends number}`, ...infer restX extends string[]] ? Yd extends [`${infer fY extends number}`, ...infer restY extends string[]] ? Digits<restX, restY, IsMinus, [
+            ...R,
+            IsMinus extends true ? Domain.Diffs.Calc<fX, fY> : Domain.Summs.Calc<fX, fY>
+        ]> : Digits<restX, [], IsMinus, [...R, [fX, 0]]> : Yd extends [`${infer fY extends number}`, ...infer restY extends string[]] ? Digits<[
+        ], restY, IsMinus, [
+            ...R,
+            IsMinus extends true ? Domain.Diffs.Calc<0, fY> : Domain.Summs.Calc<0, fY>
+        ]> : R;
+        export type Unzero<S extends string> = S extends `${infer F}${infer Rest}` ? F extends '0' ? Unzero<Rest> : S : '0';
+        export {};
+    }
+    namespace Summ {
+        type CombineStep<D extends Dx2[], F extends Dx2, R extends string, N extends number, C extends Dx2 = Domain.Summs.Calc<F[0], Abs<N>>, NN extends number = Domain.Summs.Calc<C[1], F[1]>[0], V extends number | string = D extends [unknown, ...unknown[]] ? C[0] : NN extends 1 ? `1${C[0]}` : C[0]> = Combine<D, `${V}${R}`, NN>;
+        type Combine<D extends Dx2[], R extends string = '', N extends number = 0> = D extends [infer F extends Dx2, ...infer Rest extends Dx2[]] ? CombineStep<Rest, F, R, N> : N extends -1 ? `-${R}` : R;
+        type Calculate<A extends Args, Xd extends string[] = TS.Array._Reverse<TS.String._SplitToChars<`${A[2]}`>>, Yd extends string[] = TS.Array._Reverse<TS.String._SplitToChars<`${A[3]}`>>, D extends Dx2[] = _SummDiff.Digits<Xd, Yd, false>, C extends string = Combine<D>, U extends string = _SummDiff.Unzero<C>, R extends number = `${U}` extends `${infer R extends number}` ? R : never> = [R, U, C, D];
+        export type Represent<A extends Args, NeedInvert extends boolean, Debug extends boolean = false, R extends TS.Arr = [...Calculate<A>, NeedInvert]> = Debug extends true ? R : NeedInvert extends true ? Invert<R[0]> : R[0];
+        export type Switch<A extends Args, Debug extends boolean = false> = A[4] | A[5] extends -1 ? Represent<A, true, Debug> : -1 extends A[4] | A[5] ? Diff.Switch.Inner<A, Debug> : Represent<A, false, Debug>;
+        export {};
+    }
+    /**
+     * @summary Calculate `X + Y`.
+     * @example
+     * type nv = CheckType<Summ<never, never>, never>;
+     * type ud = CheckType<Summ<undefined, undefined>, undefined>;
+     * 
+     * type p = CheckType<Summ<8, 3>, 11>;
+     * type z = CheckType<Summ<0, 3>, 3>;
+     * type n = CheckType<Summ<-8, 3>, -5>;
+     * 
+     * type p20997 = CheckType<Summ<20000, 997>, 20997>;
+     * type p1010 = CheckType<Summ<1001, 9>, 1010>;
+     */
+    export type Summ<X extends number, Y extends number> = X extends undefined | 0 ? Y : Y extends undefined | 0 ? X : Summ.Switch<Args.From<X, Y>>;
+    namespace Summ {
+    }
+    namespace Diff {
+        type CombineStep<D extends Dx2[], F extends Dx2, R extends string, N extends number, C extends Dx2 = Domain.Diffs.Calc<F[0], Invert<N>>, NN extends number = F[1] extends -1 ? Domain.Decrement<C[1]> : F[1] extends 1 ? Increment<C[1]> : C[1]> = Combine<D, `${C[0]}${R}`, NN>;
+        type Combine<D extends Dx2[], R extends string = '', N extends number = 0> = D extends [infer F extends Dx2, ...infer Rest extends Dx2[]] ? CombineStep<Rest, F, R, N> : N extends -1 ? `-${R}` : R;
+        type Calculate<A extends Args, Xd extends string[] = TS.Array._Reverse<TS.String._SplitToChars<`${A[2]}`>>, Yd extends string[] = TS.Array._Reverse<TS.String._SplitToChars<`${A[3]}`>>, D extends [number, number][] = _SummDiff.Digits<Xd, Yd, true>, C extends string = Combine<D>, U extends string = _SummDiff.Unzero<C>, R extends number = `${U}` extends `${infer R extends number}` ? R : never> = [R, U, C, D];
+        type Represent<A extends Args, Debug extends boolean = false, NeedInvert extends boolean = _LT<[A[2], A[3], true, false]>, R extends Arr = [...Calculate<NeedInvert extends true ? Args.Exchange<A> : A>, NeedInvert]> = Debug extends true ? R : NeedInvert extends true ? Invert<R[0]> : R[0];
+        export namespace Switch {
+            type Inner<A extends Args, Debug extends boolean = false> = Represent<A[4] extends -1 ? Args.Exchange<A> : A, Debug>;
+        }
+        export type Switch<A extends Args, Debug extends boolean = false> = A[4] extends A[5] ? Switch.Inner<A, Debug> : -1 extends A[4] | A[5] ? Summ.Represent<A, A[4] extends -1 ? true : false, Debug> : never;
+        export {};
+    }
+    /**
+     * @summary Calculate `X - Y`.
+     * @example
+     * type nv = CheckType<Diff<never, never>, never>;
+     * type ud = CheckType<Diff<undefined, undefined>, undefined>;
+     * 
+     * type p = CheckType<Diff<8, 3>, 5>;
+     * type z = CheckType<Diff<0, 3>, -3>;
+     * type n = CheckType<Diff<-8, 3>, -11>;
+     * 
+     * type p19003 = CheckType<Diff<20000, 997>, 19003>;
+     * type p992 = CheckType<Diff<1001, 9>, 992>;
+     */
+    export type Diff<X extends number, Y extends number> = X extends undefined | 0 ? Invert<Y> : Y extends undefined | 0 ? X : Diff.Switch<Args.From<X, Y>>;
+    namespace Diff {
+    }
+    namespace Multiply {
+        type Calculate<A extends Args, R extends number = A[2], I extends number = A[3]> = I extends 1 ? R : Calculate<A, Summ.Represent<[R, A[2], R, A[2], 1, 1], false>, Decrement<I>>;
+        export type Represent<A extends Args, Debug extends boolean = false, NeedInvert extends boolean = A[4] extends A[5] ? false : true, R extends Arr = [Calculate<A>, NeedInvert]> = Debug extends true ? R : NeedInvert extends true ? Invert<R[0]> : R[0];
+        export type Switch<A extends Args, Debug extends boolean = false> = Represent<_LT<[A[2], A[3], true, false]> extends true ? Args.Exchange<A> : A, Debug>;
+        export {};
+    }
+    /**
+     * @summary Calculate `X * Y`.
+     *
+     * ⚠ One of `X` or `Y` must be defined on `[-1000, 1000]`.\
+     * ⚠ Out of this range: `Type instantiation is excessively deep and possibly infinite.ts(2589)`
+     * @example
+     * type nv = CheckType<Multiply<never, never>, never>;
+     * type ud = CheckType<Multiply<undefined, undefined>, undefined>;
+     * 
+     * type p = CheckType<Multiply<8, 3>, 24>;
+     * type z = CheckType<Multiply<0, 3>, 0>;
+     * type n = CheckType<Multiply<-8, 3>, -24>;
+     * 
+     * type p_900000000 = CheckType<Multiply<900000, -1000>, -900000000>;
+     * type p9009 = CheckType<Multiply<1001, 9>, 9009>;
+     */
+    export type Multiply<X extends number, Y extends number> = X extends undefined | 0 ? X : Y extends undefined | 0 ? Y : Multiply.Switch<Args.From<X, Y>>;
+    namespace Multiply {
+    }
+    namespace Div {
+        type Calculate<A extends Args, Rest extends number = A[2], R extends number = 0> = _LT<[Rest, A[3], true, false]> extends true ? Rest extends 0 ? R : [R, Rest] : Calculate<A, Diff.Switch.Inner<[Rest, A[3], Rest, A[3], 1, 1], false>, Increment<R>>;
+        type Represent<A extends Args, Debug extends boolean = false, NeedInvert extends boolean = A[4] extends A[5] ? false : true, R extends Arr = [Calculate<A>, NeedInvert]> = Debug extends true ? R : NeedInvert extends true ? R[0] extends [infer Q extends number, infer M extends number] ? [Invert<Q>, Invert<M>] : Invert<R[0]> : R[0];
+        export type Switch<A extends Args, Debug extends boolean = false> = 0 extends A[2] | A[3] ? A[3] extends 0 ? never : 0 : A[3] extends 1 ? A[0] : A[2] extends A[3] ? Args.SignsMult<A> : _LT<[A[2], A[3], true, false]> extends true ? null : Represent<A, Debug>;
+        export {};
+    }
+    /**
+     * @summary Calculate `X / Y`.
+     *
+     * ⚠ Result must be defined on `[-1000, 1000]`.\
+     * ⚠ Out of this range: `Type instantiation is excessively deep and possibly infinite.ts(2589)`
+     * @returns `namber` if integer division, else `[namber, namber]`
+     * @example
+     * type nv = CheckType<Div<never, never>, never>;
+     * type ud = CheckType<Div<undefined, undefined>, undefined>;
+     * 
+     * type x = CheckType<Div<8, 0>, never>;
+     * type z = CheckType<Div<0, 3>, 0>;
+     * 
+     * type not_int = CheckType<Div<1, 3>, null>;
+     * 
+     * type p_1_1 = CheckType<Div<1, 1>, 1>;
+     * type p_1_2 = CheckType<Div<2, 1>, 2>;
+     * type p_1_3 = CheckType<Div<3, 1>, 3>;
+     * 
+     * type p_8_1 = CheckType<Div<8, 1>, 8>;
+     * type p_8_2 = CheckType<Div<8, 2>, 4>;
+     * type p_8_3 = CheckType<Div<8, 3>, [2, 2]>;
+     * 
+     * type e1 = CheckType<Div<-68899, -68899>, 1>;
+     * type e2 = CheckType<Div<456734, -456734>, -1>;
+     * 
+     * type n_m34_7 = CheckType<Div<-34, 7>, [-4, -6]>;
+     * type n_34_m7 = CheckType<Div<34, -7>, [-4, -6]>;
+     * type n_m34_m7 = CheckType<Div<-34, -7>, [4, 6]>;
+     * 
+     * type l_max = CheckType<Div<999999, 1000>, [999, 999]>;
+     * // // @ts-ignore Type instantiation is excessively deep and possibly infinite.ts(2589)
+     * // type l_under = CheckType<Div<1000000, 1000>, 1000>;
+     */
+    export type Div<X extends number, Y extends number> = X extends undefined | 0 ? X : Y extends undefined ? Y : Div.Switch<Args.From<X, Y>>;
+    namespace Div {
+    }
+    namespace Power {
+        type Switch<A extends Args, X extends number[] = Domain.Power[A[2]], R extends number = X extends undefined ? undefined : X[A[3]]> = R extends undefined ? null : A[4] extends -1 ? IsEven<A[3]> extends true ? R : Invert<R> : R;
+    }
+    /**
+     * @summary Calculate `X ^ E`. If `E` is negotive — `never`
+     *
+     * ⚠ Result defined on `Numeric.Domain.Power`.
+     * @example
+     * type nv = CheckType<Power<never, never>, never>;
+     * type ud = CheckType<Power<undefined, undefined>, undefined>;
+     * 
+     * type zx = CheckType<Power<0, 10>, 0>;
+     * type ze = CheckType<Power<10, 0>, 1>;
+     * 
+     * type p2_1 = CheckType<Power<2, 1>, 2>;
+     * type p2_2 = CheckType<Power<2, 2>, 4>;
+     * type p2_9 = CheckType<Power<2, 9>, 512>;
+     * type p2_12 = CheckType<Power<2, 12>, 4096>;
+     * 
+     * type p3_1 = CheckType<Power<3, 1>, 3>;
+     * type p3_2 = CheckType<Power<3, 2>, 9>;
+     * type p3_6 = CheckType<Power<3, 6>, 729>;
+     * type p3_7 = CheckType<Power<3, 7>, 2187>;
+     * 
+     * type n2_1 = CheckType<Power<-2, 1>, -2>;
+     * type n2_2 = CheckType<Power<-2, 2>, 4>;
+     * type n2_9 = CheckType<Power<-2, 9>, -512>;
+     * type n2_12 = CheckType<Power<-2, 12>, 4096>;
+     * 
+     * type n3_1 = CheckType<Power<-3, 1>, -3>;
+     * type n3_2 = CheckType<Power<-3, 2>, 9>;
+     * type n3_6 = CheckType<Power<-3, 6>, 729>;
+     * type n3_7 = CheckType<Power<-3, 7>, -2187>;
+     * 
+     * type n10_15 = CheckType<Power<10, 15>, 1000000000000000>;
+     */
+    export type Power<X extends number, E extends number> = X extends undefined ? X : E extends undefined ? E : IsNegative<E> extends true ? null : Power.Switch<Args.From<X, E>>;
+    namespace Power {
+    }
+    export {};
+}

package/dist/_global/resolve.d.ts

@@ -0,0 +1,45 @@
+declare namespace AVStantso.TS {
+    type _Resolve<T, Debug extends boolean, L = {} extends T ? never : Extract<Literal, T>, O = Exclude<T, Literal>, R = ([L] extends [never] ? L : Literal.Map[Extract<L, Literal>]) | O> = Debug extends true ? {
+        T: T;
+        L: L;
+        O: O;
+        R: R;
+    } : R;
+    namespace _Resolve {
+        type Switch<T, Debug extends boolean> = T extends Type.Def ? (T extends {
+            T: unknown;
+        } ? HasString<T['T']> extends true ? Exclude<T['T'], Literal> : _Resolve<T['T'], Debug> : never) | (T extends {
+            L: Literal;
+        } ? _Resolve<T['L'], Debug> : never) : HasString<T> extends true ? Exclude<T, Literal> : _Resolve<T, Debug>;
+    }
+    /**
+     * @summary Resolve `Literal` in type union `T` as its satisfied types.
+     * With type `string` literals NOT supported
+     * @example
+     * type nv = CheckType<Resolve<never>, never>;
+     * type ud = CheckType<Resolve<undefined>, unknown>;
+     * 
+     * // ⛔ literals NOT supported:
+     * type ts = CheckType<Resolve<string | 'function'>, string>;
+     * 
+     * type r0 = CheckType<Resolve<'bigint' | 'string'>, string | bigint>;
+     * 
+     * type r1 = CheckType<Resolve<bigint>, bigint>;
+     * 
+     * type r2 = CheckType<Resolve<'bigint' | 'string' | boolean>, string | bigint | boolean>;
+     * 
+     * type r3 = CheckType<Resolve<{ T: Function; L: 'boolean' }>, boolean | Function>;
+     * 
+     * type r4 = CheckType<Resolve<{}>, {}>;
+     * 
+     * type r5 = CheckType<Resolve<{ T: string; L: 'string' | 'boolean' }>, string | boolean>;
+     * 
+     * type r6 = CheckType<Resolve<{ T: string; L: 'function' }>, string | Function>;
+     * 
+     * type r7 = CheckType<Resolve<{ L: 'function' }>, Function>;
+     * 
+     * type r8 = CheckType<Resolve<{ T: Function }>, Function>;
+     */
+    export type Resolve<T> = _Resolve.Switch<T, false>;
+    export {};
+}