@avstantso/ts 1.0.4 → 1.1.0

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

@@ -1,52 +0,0 @@
-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

@@ -1,203 +0,0 @@
-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

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

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

@@ -1,50 +0,0 @@
-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

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

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

@@ -1,257 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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 {};
-}