@avstantso/ts 1.1.0 → 1.3.0

package/dist/_global/array/low-level.d.ts

@@ -0,0 +1,84 @@
+declare namespace AVStantso.TS.Array {
+    /**
+     * @summary Test array `I`-item out of bounds.
+     *
+     * ⛔ First `undefined` item (if exists) will be recognized as end of array ⛔
+     * @template TArr Tested array type
+     * @template I Index
+     * @template IfTrue Result, if `TArr` NOT  has `I` item
+     * @template IfFalse Result, if `TArr` has `I` item
+     * @returns `IfFalse` or `IfTrue` param
+     * @deprecated Use `TArr extends [infer F, ...infer Rest]` instead
+     * @example
+     * type n0 = CheckType<IfEnd<never, any>, never>;
+     * type n1 = CheckType<IfEnd<any, never>, never>;
+     * 
+     * type u0 = CheckType<IfEnd<undefined, any>, never>;
+     * type u1 = CheckType<IfEnd<any, undefined>, never>;
+     * 
+     * type t = CheckType<IfEnd<[], 0>, true>;
+     * type f = CheckType<IfEnd<[1], 0>, false>;
+     */
+    type IfEnd<TArr extends ArrR, I extends number, IfTrue = true, IfFalse = false> = TArr extends undefined ? never : I extends undefined ? never : TArr[I] extends undefined ? IfTrue : IfFalse;
+    /**
+     * @summary Array type length.\
+     * ⚠ Unsafe, internal
+     * @template TArr Array type
+     * @returns Length of `TArr` type
+     * @example
+     * type n = CheckType<_Length<never>, never>;
+     * type u = CheckType<_Length<undefined>, 1>; // ⚠
+     * 
+     * type r0 = CheckType<_Length<[]>, 0>;
+     * type r1 = CheckType<_Length<['A']>, 1>;
+     * type r2 = CheckType<_Length<['A' , 1]>, 2>;
+     * type r3 = CheckType<_Length<[undefined, undefined, undefined]>, 3>;
+     * type rr3 = CheckType<_Length<readonly [undefined, undefined, undefined]>, 3>;
+     */
+    type _Length<TArr extends ArrR, I extends number = 0> = TArr extends readonly [unknown, ...infer Rest] ? _Length<Rest, Increment<I>> : I;
+    /**
+     * @summary Array type length.
+     * @template TArr Array type
+     * @returns Length of `TArr` type
+     * @example
+     * type n = CheckType<Length<never>, never>;
+     * type u = CheckType<Length<undefined>, never>;
+     * 
+     * type r0 = CheckType<Length<[]>, 0>;
+     * type r1 = CheckType<Length<['A']>, 1>;
+     * type r2 = CheckType<Length<['A' , 1]>, 2>;
+     * type r3 = CheckType<Length<[undefined, undefined, undefined]>, 3>;
+     * type r4 = CheckType<Length<['' , '']>, 2>;
+     * type rr4 = CheckType<Length<readonly ['' , '']>, 2>;
+     */
+    type Length<TArr extends ArrR> = TArr extends undefined ? never : TArr extends ArrN ? _Length<TArr> : never;
+    namespace Length {
+        type _IfExeeded<TArr extends ArrR, L extends number, IfTrue = true, IfFalse = false> = TArr extends readonly [unknown, ...infer Rest] ? L extends 0 ? IfTrue : _IfExeeded<Rest, Decrement<L>, IfTrue, IfFalse> : IfFalse;
+        /**
+         * @summary Test array type length.
+         * @template TArr Tested array type
+         * @template L Length limit
+         * @template IfTrue Result, if `TArr` length exeeded `L`
+         * @template IfFalse Result, if `TArr` length NOT exeeded `L`
+         * @returns `IfFalse` or `IfTrue` param
+         * @example
+         * type n0 = CheckType<Length.IfExeeded<never, any>, never>;
+         * type n1 = CheckType<Length.IfExeeded<any, never>, never>;
+         * 
+         * type u0 = CheckType<Length.IfExeeded<undefined, any>, never>;
+         * type u1 = CheckType<Length.IfExeeded<any, undefined>, never>;
+         * 
+         * type r0f = CheckType<Length.IfExeeded<[], 0>, false>;
+         * type r1t = CheckType<Length.IfExeeded<['A'], 0>, true>;
+         * type r1f = CheckType<Length.IfExeeded<['A'], 1>, false>;
+         * type r2t = CheckType<Length.IfExeeded<['A', 1], 1>, true>;
+         * type r2f = CheckType<Length.IfExeeded<['A', 1], 600>, false>;
+         * type r3t = CheckType<Length.IfExeeded<[undefined, undefined, undefined], 2>, true>;
+         * type r3f = CheckType<Length.IfExeeded<[undefined, undefined, undefined], 3>, false>;
+         * type rr3t = CheckType<Length.IfExeeded<readonly [undefined, undefined, undefined], 2>, true>;
+         * type rr3f = CheckType<Length.IfExeeded<readonly [undefined, undefined, undefined], 3>, false>;
+         */
+        export type IfExeeded<TArr extends ArrR, L extends number, IfTrue = true, IfFalse = false> = TArr extends undefined ? never : L extends undefined ? never : TArr extends ArrN ? _IfExeeded<TArr, L, IfTrue, IfFalse> : never;
+        export {};
+    }
+}

package/dist/_global/array/map-key-value.d.ts

@@ -0,0 +1,121 @@
+declare namespace AVStantso.TS.Array {
+    /**
+     * @summary Calculate key by array of keys.
+     * @template TArr Array of keys
+     * @returns Key that includes all array items
+     * @example
+     * type n = CheckType<ToKey<never>, never>;
+     * type u = CheckType<ToKey<undefined>, unknown>;
+     * 
+     * type k0 = CheckType<ToKey<[]>, never>;
+     * type k1 = CheckType<ToKey<['a']>, 'a'>;
+     * type k2 = CheckType<ToKey<['a', 1]>, 'a' | 1>;
+     * type rk2 = CheckType<ToKey<readonly ['a', 1]>, 'a' | 1>;
+     */
+    export type ToKey<TArr extends readonly Key[]> = TArr[number];
+    /**
+     * @summary Calculate key to key record by array of keys.\
+     * ⚠ Unsafe, internal
+     * @template TArr Array of keys
+     * @returns Key to key record that includes all array items
+     * @example
+     * type n = CheckType<_ToKey2Key<never>, never>;
+     * type u = CheckType<_ToKey2Key<undefined>, {
+     *   [x: string]: Key;
+     *   [x: number]: Key;
+     *   [x: symbol]: Key;
+     * }>; // ⚠
+     * 
+     * type k0 = CheckType<_ToKey2Key<[]>, {}>; // ⚠
+     * type k1 = CheckType<_ToKey2Key<['a']>, { a: 'a' }>;
+     * type k2 = CheckType<_ToKey2Key<['a', 1]>, { a: 'a', 1: 1 }>;
+     * type rk2 = CheckType<_ToKey2Key<readonly ['a', 1]>, { a: 'a', 1: 1 }>;
+     */
+    export type _ToKey2Key<TArr extends readonly Key[], R = unknown> = TArr extends readonly [infer F extends Key, ...infer Rest extends Key[]] ? _ToKey2Key<Rest, R & {
+        [K in F]: F;
+    }> : {
+        [K in keyof R]: R[K];
+    };
+    /**
+     * @summary Calculate key to key record by array of keys.
+     * @template TArr Array of keys
+     * @returns Key to key record that includes all array items
+     * @example
+     * type n = CheckType<ToKey2Key<never>, never>;
+     * type u = CheckType<ToKey2Key<undefined>, undefined>;
+     * 
+     * type k0 = CheckType<ToKey2Key<[]>, {}>;
+     * type k1 = CheckType<ToKey2Key<['a']>, { a: 'a' }>;
+     * type k2 = CheckType<ToKey2Key<['a', 1]>, { a: 'a', 1: 1 }>;
+     * type rk2 = CheckType<ToKey2Key<readonly ['a', 1]>, { a: 'a', 1: 1 }>;
+     */
+    export type ToKey2Key<TArr extends readonly Key[]> = TArr extends undefined ? TArr : _ToKey2Key<TArr>;
+    /**
+     * @summary Calculate record of `T` with key by array of keys.
+     * @template TArr Array of keys
+     * @template T Value type
+     * @example
+     * type n = CheckType<ToRecord<never, never>, {}>;
+     * type nu1 = CheckType<ToRecord<undefined, never>, {}>;
+     * type nu2 = CheckType<ToRecord<never, undefined>, {}>;
+     * type u = CheckType<ToRecord<undefined, undefined>, {}>;
+     * 
+     * type k0 = CheckType<ToRecord<[], string>, {}>;
+     * type k1 = CheckType<ToRecord<['a'], string>, { a: string }>;
+     * type k2 = CheckType<ToRecord<['a', 1], boolean>, { a: boolean, 1: boolean }>;
+     * type rk2 = CheckType<ToRecord<readonly ['a', 1], () => 0>, { a: () => 0, 1: () => 0 }>;
+     */
+    export type ToRecord<TArr extends readonly Key[], T> = Record<TArr[number], T>;
+    type _MapFrom<Keys extends readonly Key[], Value extends number, KeyToKey extends boolean, R = unknown> = Keys extends readonly [infer F extends Key, ...infer Rest extends Key[]] ? _MapFrom<Rest, Value extends undefined ? Value : Increment<Value>, KeyToKey, R & (KeyToKey extends true ? {
+        [K in F]: Value;
+    } : {
+        [K in Value]: F;
+    })> : {
+        [K in keyof R]: R[K];
+    };
+    /**
+     * @summary Create key-value map by list of keys and first value
+     * @template Keys Array of keys
+     * @template FirstValue Value for first item
+     * @returns Key-value map structural object
+     * @example
+     * type n = CheckType<KeyValueMapFrom<never>, never>;
+     * type u = CheckType<KeyValueMapFrom<undefined>, never>;
+     * 
+     * type k0 = CheckType<KeyValueMapFrom<[]>, object>;
+     * type k1 = CheckType<KeyValueMapFrom<['a']>, { a: 0; }>;
+     * type k2 = CheckType<KeyValueMapFrom<['a', 1]>, { a: 0; 1: 1; }>;
+     * type k3 = CheckType<KeyValueMapFrom<['a', undefined, 1]>, { a: 0; 1: 2; }>;
+     * type k4 = CheckType<KeyValueMapFrom<['a', never, 1]>, { a: 0; 1: 2; }>;
+     * 
+     * type kn = CheckType<KeyValueMapFrom<['a', 1], never>, { a: never; 1: never; }>;
+     * type ku = CheckType<KeyValueMapFrom<['a', 1], undefined>, { a: undefined; 1: undefined; }>;
+     * type rku = CheckType<
+     *   KeyValueMapFrom<readonly ['a', 1], undefined>,
+     *   { a: undefined; 1: undefined; }
+     * >;
+     */
+    export type KeyValueMapFrom<Keys extends readonly Key[], FirstValue extends number = 0> = Keys extends undefined ? never : Keys extends ArrN ? _MapFrom<Keys, FirstValue, true> : never;
+    /**
+     * @summary Create value-key map by list of keys and first value
+     * @template Keys Array of keys
+     * @template FirstValue Value for first item. If is `undefined` or `never` — returns `never`
+     * @returns Value-key map structural object
+     * @see KeyValueMapFrom
+     * @example
+     * type n = CheckType<ValueKeyMapFrom<never>, never>;
+     * type u = CheckType<ValueKeyMapFrom<undefined>, never>;
+     * 
+     * type k0 = CheckType<ValueKeyMapFrom<[]>, object>;
+     * type k1 = CheckType<ValueKeyMapFrom<['a']>, { 0: 'a'; }>;
+     * type k2 = CheckType<ValueKeyMapFrom<['a', 1]>, { 0: 'a'; 1: 1; }>;
+     * type k3 = CheckType<ValueKeyMapFrom<['a', undefined, 1]>, { 0: 'a'; 1: undefined; 2: 1 }>;
+     * type k4 = CheckType<ValueKeyMapFrom<['a', never, 1]>, { 0: 'a'; 1: never; 2: 1 }>;
+     * 
+     * type kn = CheckType<ValueKeyMapFrom<['a', 1], never>, never>;
+     * type ku = CheckType<ValueKeyMapFrom<['a', 1], undefined>, never>;
+     * type rku = CheckType<ValueKeyMapFrom<readonly ['a', 1], undefined>, never>;
+     */
+    export type ValueKeyMapFrom<Keys extends readonly Key[], FirstValue extends number = 0> = Keys extends undefined ? never : FirstValue extends undefined ? never : Keys extends ArrN ? _MapFrom<Keys, FirstValue, false> : never;
+    export {};
+}

package/dist/_global/array/min-max-sort.d.ts

@@ -0,0 +1,244 @@
+declare namespace AVStantso.TS.Array {
+    type _ExtremumIndex<TArr extends readonly string[] | readonly number[], IsMin extends boolean, TRest extends readonly string[] | readonly number[] = TArr, R extends number = undefined, I extends number = 0> = TRest extends readonly [
+        infer F extends string | number,
+        ...infer Rest extends string[] | number[]
+    ] ? _ExtremumIndex<TArr, IsMin, Rest, R extends undefined ? 0 : F extends undefined ? R : _LT_GT<[F, TArr[R], I, R], IsMin>, Increment<I>> : R;
+    type _Extremum<TArr extends readonly string[] | readonly number[], IsMin extends boolean, ReturnIdx extends boolean, R extends number = _ExtremumIndex<TArr, IsMin>> = ReturnIdx extends true ? R : TArr[R];
+    type Extremum<TArr extends readonly string[] | readonly number[], IsMin extends boolean, ReturnIdx extends boolean> = TArr extends [] ? undefined : TArr extends ArrN ? _Extremum<TArr, IsMin, ReturnIdx> : never;
+    /**
+     * @summary Find array minimal item.
+     * @template TArr Array to find
+     * @returns Minimal item. `undefined` for empty array
+     * @example
+     * type n = CheckType<Min<never>, never>;
+     * type u = CheckType<Min<undefined>, never>;
+     * 
+     * type z = CheckType<Min<[]>, undefined>;
+     * 
+     * type n0 = CheckType<Min<[1]>, 1>;
+     * type n1 = CheckType<Min<[2, 1]>, 1>;
+     * type n2 = CheckType<Min<[2, undefined, 1]>, 1>;
+     * 
+     * type s0 = CheckType<Min<['a']>, 'a'>;
+     * type s1 = CheckType<Min<['b', 'a']>, 'a'>;
+     * type s2 = CheckType<Min<['b', undefined, 'a']>, 'a'>;
+     * type rs2 = CheckType<Min<readonly ['b', undefined, 'a']>, 'a'>;
+     */
+    export type Min<TArr extends readonly string[] | readonly number[]> = TArr extends undefined ? never : Extremum<TArr, true, false>;
+    export namespace Min {
+        /**
+         * @summary Find array minimal item index.
+         * @template TArr Array to find
+         * @returns Minimal item index. `undefined` for empty array
+         * @example
+         * type n = CheckType<Min.Index<never>, never>;
+         * type u = CheckType<Min.Index<undefined>, never>;
+         * 
+         * type z = CheckType<Min.Index<[]>, undefined>;
+         * 
+         * type n0 = CheckType<Min.Index<[1]>, 0>;
+         * type n1 = CheckType<Min.Index<[2, 1]>, 1>;
+         * type n2 = CheckType<Min.Index<[1, 2]>, 0>;
+         * type n3 = CheckType<Min<[2, undefined, 1]>, 1>;
+         * 
+         * type s0 = CheckType<Min.Index<['a']>, 0>;
+         * type s1 = CheckType<Min.Index<['b', 'a']>, 1>;
+         * type s2 = CheckType<Min.Index<['b', undefined, 'a']>, 2>;
+         * type rs2 = CheckType<Min.Index<readonly ['b', undefined, 'a']>, 2>;
+         */
+        type Index<TArr extends readonly string[] | readonly number[]> = TArr extends undefined ? never : Extremum<TArr, true, true>;
+    }
+    /**
+     * @summary Find array maximal item.
+     * @template TArr Array to find
+     * @returns Maximal item. `undefined` for empty array
+     * @example
+     * type n = CheckType<Max<never>, never>;
+     * type u = CheckType<Max<undefined>, never>;
+     * 
+     * type z = CheckType<Max<[]>, undefined>;
+     * 
+     * type n0 = CheckType<Max<[1]>, 1>;
+     * type n1 = CheckType<Max<[2, 1]>, 2>;
+     * type n2 = CheckType<Max<[2, undefined, 1]>, 2>;
+     * 
+     * type s0 = CheckType<Max<['a']>, 'a'>;
+     * type s1 = CheckType<Max<['b', 'a']>, 'b'>;
+     * type s2 = CheckType<Max<['b', undefined, 'a']>, 'b'>;
+     * type rs2 = CheckType<Max<readonly ['b', undefined, 'a']>, 'b'>;
+     */
+    export type Max<TArr extends readonly string[] | readonly number[]> = TArr extends undefined ? never : Extremum<TArr, false, false>;
+    export namespace Max {
+        /**
+         * @summary Find array maximal item index.
+         * @template TArr Array to find
+         * @returns Maximal item index. `undefined` for empty array
+         * @example
+         * type n = CheckType<Max.Index<never>, never>;
+         * type u = CheckType<Max.Index<undefined>, never>;
+         * 
+         * type z = CheckType<Max.Index<[]>, undefined>;
+         * 
+         * type n0 = CheckType<Max.Index<[1]>, 0>;
+         * type n1 = CheckType<Max.Index<[2, 1]>, 0>;
+         * type n2 = CheckType<Max.Index<[1, 2]>, 1>;
+         * type n3 = CheckType<Max.Index<[1, undefined, 2]>, 2>;
+         * 
+         * type s0 = CheckType<Max.Index<['a']>, 0>;
+         * type s1 = CheckType<Max.Index<['b', 'a']>, 0>;
+         * type s2 = CheckType<Max.Index<['b', undefined, 'a']>, 0>;
+         * type rs2 = CheckType<Max.Index<readonly ['b', undefined, 'a']>, 0>;
+         */
+        type Index<TArr extends readonly string[] | readonly number[]> = TArr extends undefined ? never : Extremum<TArr, false, true>;
+    }
+    type _Sort<TArr extends ArrR, Asc extends boolean, L extends number, I extends number = 0, R extends Arr = []> = I extends L ? [...R, ...TArr] : TArr extends readonly [infer F, infer S, ...infer Rest] ? _LT_GT<[F, S, [F, S], [S, F]], Asc> extends readonly [infer _F, infer _S] ? _Sort<[_S, ...Rest], Asc, L, I, [...R, _F]> : never : _Sort<[...R, ...TArr], Asc, L, Increment<I>>;
+    type _SortPairs<TArr extends readonly Sort.Pair[], Asc extends boolean, L extends number, I extends number = 0, R extends readonly Sort.Pair[] = []> = I extends L ? [...R, ...TArr] : TArr extends readonly [
+        infer F extends Sort.Pair,
+        infer S extends Sort.Pair,
+        ...infer Rest extends Sort.Pair[]
+    ] ? _LT_GT<[F[0], S[0], [F, S], [S, F]], Asc, Asc> extends readonly [
+        infer _F extends Sort.Pair,
+        infer _S extends Sort.Pair
+    ] ? _SortPairs<[_S, ...Rest], Asc, L, I, [...R, _F]> : never : _SortPairs<[...R, ...TArr], Asc, L, Increment<I>>;
+    type _SortCheck<TArr extends readonly string[] | readonly number[] | readonly Sort.Pair<string>[] | readonly Sort.Pair<number>[], Asc extends boolean, L extends number = Length<TArr>> = L extends 0 | 1 ? TArr : TArr extends readonly string[] | readonly number[] ? _Sort<TArr, Asc, Increment<L>> : TArr extends readonly Sort.Pair<string>[] | readonly Sort.Pair<number>[] ? Asc extends true ? _SortPairs<TArr, Asc, Increment<L>> : _SortPairs<_Reverse<TArr>, Asc, Increment<L>> : never;
+    /**
+     * @summary Sort array items.
+     * @template TArr Array to sort
+     * @template Asc Is ascending sort order
+     * @example
+     * type dn = [1, 4, 5, 3, 2, 78, 1];
+     * type ds = ['abc', 'eb', '', '1', 'ab', ' '];
+     * type dpn = [
+     *   [1, symbol],
+     *   [4, () => null],
+     *   [5, []],
+     *   [3, { n: number }],
+     *   [2, Buffer],
+     *   [78, 45],
+     *   [1, never]
+     * ];
+     * type dps = [
+     *   ['abc', symbol],
+     *   ['eb', () => null],
+     *   [ '', []],
+     *   ['1', { n: number }],
+     *   ['ab', Buffer],
+     *   [' ', 45]
+     * ];
+     * @example
+     * type n = CheckType<Sort<never>, never>;
+     * type u = CheckType<Sort<undefined>, never>;
+     * 
+     * type n_asc = CheckType<Sort<dn>, [1, 1, 2, 3, 4, 5, 78]>;
+     * type n_desc = CheckType<Sort<dn, false>, [78, 5, 4, 3, 2, 1, 1]>;
+     * 
+     * type s_asc = CheckType<Sort<ds>, ['', ' ', '1', 'ab', 'abc', 'eb']>;
+     * type s_desc = CheckType<Sort<ds, false>, ['eb', 'abc', 'ab', '1', ' ', '']>;
+     * 
+     * type rs_asc = CheckType<Sort<readonly [...ds]>, ['', ' ', '1', 'ab', 'abc', 'eb']>;
+     * type rs_desc = CheckType<Sort<readonly [...ds], false>, ['eb', 'abc', 'ab', '1', ' ', '']>;
+     * 
+     * type n_pasc = CheckType<
+     *   Sort<dpn>, [
+     *     [1, symbol],
+     *     [1, never],
+     *     [2, Buffer],
+     *     [3, { n: number; }],
+     *     [4, () => null],
+     *     [5, []],
+     *     [78, 45]
+     *   ]>;
+     * type n_pdesc = CheckType<
+     *   Sort<dpn, false>, [
+     *     [78, 45],
+     *     [5, []],
+     *     [4, () => null],
+     *     [3, { n: number; }],
+     *     [2, Buffer],
+     *     [1, never],
+     *     [1, symbol]
+     *   ]>;
+     * 
+     * type s_pasc = CheckType<
+     *   Sort<dps>, [
+     *     ['', []],
+     *     [' ', 45],
+     *     ['1', { n: number; }],
+     *     ['ab', Buffer],
+     *     ['abc', symbol],
+     *     ['eb', () => null]
+     *   ]>;
+     * 
+     * type s_pdesc = CheckType<
+     *   Sort<dps, false>, [
+     *     ['eb', () => null],
+     *     ['abc', symbol],
+     *     ['ab', Buffer],
+     *     ['1', { n: number; }],
+     *     [' ', 45],
+     *     ['', []]
+     *   ]>;
+     */
+    export type Sort<TArr extends readonly string[] | readonly number[] | readonly Sort.Pair<string>[] | readonly Sort.Pair<number>[], Asc extends boolean = true> = TArr extends undefined ? never : TArr extends ArrN ? _SortCheck<TArr, Asc> : never;
+    export namespace Sort {
+        /**
+         * @summary Pair key-data for sort any data by key
+         */
+        type Pair<K extends number | string = number | string> = [K, any];
+        /**
+         * @summary Sort array items descending.
+         * @template TArr Array to sort
+         * @example
+         * type dn = [1, 4, 5, 3, 2, 78, 1];
+         * type ds = ['abc', 'eb', '', '1', 'ab', ' '];
+         * type dpn = [
+         *   [1, symbol],
+         *   [4, () => null],
+         *   [5, []],
+         *   [3, { n: number }],
+         *   [2, Buffer],
+         *   [78, 45],
+         *   [1, never]
+         * ];
+         * type dps = [
+         *   ['abc', symbol],
+         *   ['eb', () => null],
+         *   [ '', []],
+         *   ['1', { n: number }],
+         *   ['ab', Buffer],
+         *   [' ', 45]
+         * ];
+         * @example
+         * type n = CheckType<Sort.Desc<never>, never>;
+         * type u = CheckType<Sort.Desc<undefined>, never>;
+         * 
+         * type n_desc = CheckType<Sort.Desc<dn>, [78, 5, 4, 3, 2, 1, 1]>;
+         * 
+         * type s_desc = CheckType<Sort.Desc<ds>, ['eb', 'abc', 'ab', '1', ' ', '']>;
+         * type rs_desc = CheckType<Sort.Desc<readonly [...ds]>, ['eb', 'abc', 'ab', '1', ' ', '']>;
+         * 
+         * type n_pdesc = CheckType<
+         *   Sort.Desc<dpn>, [
+         *     [78, 45],
+         *     [5, []],
+         *     [4, () => null],
+         *     [3, { n: number; }],
+         *     [2, Buffer],
+         *     [1, never],
+         *     [1, symbol]
+         *   ]>;
+         * 
+         * type s_pdesc = CheckType<
+         *   Sort.Desc<dps>, [
+         *     ['eb', () => null],
+         *     ['abc', symbol],
+         *     ['ab', Buffer],
+         *     ['1', { n: number; }],
+         *     [' ', 45],
+         *     ['', []]
+         *   ]>;
+         */
+        type Desc<TArr extends readonly string[] | readonly number[] | readonly Sort.Pair<string>[] | readonly Sort.Pair<number>[]> = _SortCheck<TArr, false>;
+    }
+    export {};
+}

package/dist/_global/ascii.d.ts

@@ -0,0 +1,84 @@
+declare namespace AVStantso {
+    const ASCII_Control_Characters: readonly ["␀", "␁", "␂", "␃", "␄", "␅", "␆", "␇", "␈", "␉", "␊", "␋", "␌", "␍", "␎", "␏", "␐", "␑", "␒", "␓", "␔", "␕", "␖", "␗", "␘", "␙", "␚", "␛", "␜", "␝", "␞", "␟"];
+    const ASCII_Printable_Characters_Letters_Upper: readonly ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"];
+    const ASCII_Printable_Characters_Letters_Lower: readonly ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
+    const ASCII_Printable_Characters: readonly [" ", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?", "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]", "^", "_", "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "␡"];
+    const ASCII_Extended_Codes: readonly ["€", "Unused0", "‚", "ƒ", "„", "…", "†", "‡", "ˆ", "‰", "Š", "‹", "Œ", "Unused1", "Ž", "Unused2", "Unused3", "‘", "’", "“", "”", "•", "–", "—", "˜", "™", "š", "›", "œ", "Unused4", "ž", "Ÿ", "NBSP", "¡", "¢", "£", "¤", "¥", "¦", "§", "¨", "©", "ª", "«", "¬", "SHY", "®", "¯", "°", "±", "²", "³", "´", "µ", "¶", "·", "¸", "¹", "º", "»", "¼", "½", "¾", "¿", "À", "Á", "Â", "Ã", "Ä", "Å", "Æ", "Ç", "È", "É", "Ê", "Ë", "Ì", "Í", "Î", "Ï", "Ð", "Ñ", "Ò", "Ó", "Ô", "Õ", "Ö", "×", "Ø", "Ù", "Ú", "Û", "Ü", "Ý", "Þ", "ß", "à", "á", "â", "ã", "ä", "å", "æ", "ç", "è", "é", "ê", "ë", "ì", "í", "î", "ï", "ð", "ñ", "ò", "ó", "ô", "õ", "ö", "÷", "ø", "ù", "ú", "û", "ü", "ý", "þ", "ÿ"];
+    export namespace TS {
+        /**
+         * @summary English letters
+         */
+        namespace Letters {
+            type Upper = typeof ASCII_Printable_Characters_Letters_Upper;
+            type Lower = typeof ASCII_Printable_Characters_Letters_Lower;
+        }
+        type Letters<IsUpper extends boolean = true> = IsUpper extends true ? Letters.Upper : Letters.Lower;
+        /**
+         * @summary English letter
+         */
+        namespace Letter {
+            type Upper = Letters.Upper[number];
+            type Lower = Letters.Lower[number];
+        }
+        type Letter<IsUpper extends boolean = true> = IsUpper extends true ? Letter.Upper : Letter.Lower;
+        /**
+         * @summary `ASCII` characters
+         * @see https://www.ascii-code.com/
+         */
+        type ASCII = readonly [
+            ...ASCII.Control,
+            ...ASCII.Printable,
+            ...ASCII.Extended
+        ];
+        namespace ASCII {
+            /**
+             * @summary ASCII control characters (character code `0-31`)
+             */
+            type Control = typeof ASCII_Control_Characters;
+            /**
+             * @summary ASCII printable characters (character code `32-127`)
+             */
+            type Printable = typeof ASCII_Printable_Characters;
+            /**
+             * @summary The extended ASCII codes (character code `128-255`)
+             */
+            type Extended = typeof ASCII_Extended_Codes;
+            /**
+             * @summary ASCII characters map char-code
+             */
+            namespace Map {
+                /**
+                 * @summary ASCII control characters (character code `0-31`)
+                 */
+                type Control = Array.KeyValueMapFrom<ASCII.Control>;
+                /**
+                 * @summary ASCII printable characters (character code `32-127`)
+                 */
+                type Printable = Array.KeyValueMapFrom<ASCII.Printable, 32>;
+                /**
+                 * @summary The extended ASCII codes (character code `128-255`)
+                 */
+                type Extended = Array.KeyValueMapFrom<ASCII.Extended, 128>;
+            }
+            type Map = Array.KeyValueMapFrom<ASCII>;
+            type _Code<S extends string, R extends number = Extract<ASCII.Map[Extract<S, keyof ASCII.Map>], number>> = R;
+            /**
+             * @summary Gets `ASCII` characters code by `S`. `never` if `S` is not a character.
+             */
+            type Code<S extends string> = _Code<S>;
+            /**
+             * @summary ASCII character union
+             */
+            type Character = Array.ToKey<ASCII>;
+        }
+    }
+    export namespace Code {
+        interface TS {
+            /**
+             * @summary `ASCII` characters array
+             */
+            ASCII: AVStantso.TS.ASCII;
+        }
+    }
+    export {};
+}

package/dist/_global/boolean.d.ts

@@ -0,0 +1,74 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary If `Condition` is `true` returns `IfTrue` else `IfFalse`
+     * @template Condition Condition
+     * @template IfTrue Result, if `Condition` is `true`
+     * @template IfFalse Result, if `Condition` is NOT `true`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type nv = CheckType<If<never>, never>;
+     * type u = CheckType<If<undefined>, false>;
+     * type nl = CheckType<If<null>, false>;
+     * type f = CheckType<If<false>, false>;
+     * type t = CheckType<If<true>, true>;
+     * type a = CheckType<If<any>, boolean>;
+     */
+    type If<Condition extends boolean, IfTrue = true, IfFalse = false> = Condition extends undefined ? IfFalse : Condition extends true ? IfTrue : IfFalse;
+    namespace If {
+    }
+    /**
+     * @summary If all `Conditions` in array is `true` returns `IfTrue` else `IfFalse`
+     * @template Conditions Conditions array
+     * @template IfTrue Result, if all `Conditions` is `true`
+     * @template IfFalse Result, if any item of `Conditions` is NOT `true`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type n = CheckType<And<never>, never>;
+     * type u = CheckType<And<undefined>, never>;
+     * type u2 = CheckType<And<[true, undefined, true]>, false>;
+     * type f = CheckType<And<[true, true, false]>, false>;
+     * type t = CheckType<And<[true, true, true]>, true>;
+     * type tr = CheckType<And<readonly [true, true, true]>, true>;
+     */
+    type And<Conditions extends readonly boolean[], IfTrue = true, IfFalse = false> = Array.IfEach<Conditions, true, IfTrue, IfFalse>;
+    namespace And {
+    }
+    /**
+     * @summary If one or more `Conditions` in array is `true` returns `IfTrue` else `IfFalse`
+     * @template Conditions Conditions array
+     * @template IfTrue Result, if any item of `Conditions` is `true`
+     * @template IfFalse Result, if all `Conditions` is NOT `true`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type n = CheckType<Or<never>, never>;
+     * type u = CheckType<Or<undefined>, never>;
+     * type u2 = CheckType<Or<[false, undefined, true]>, true>;
+     * type f = CheckType<Or<[false, false, false]>, false>;
+     * type t = CheckType<Or<[true, true, false]>, true>;
+     * type tr = CheckType<Or<readonly [true, true, false]>, true>;
+     */
+    type Or<Conditions extends readonly boolean[], IfTrue = true, IfFalse = false> = Array.IfHasItem<Conditions, true, IfTrue, IfFalse>;
+    namespace Or {
+    }
+    /**
+     * @summary If only one item of `Conditions` in array is `true` returns `IfTrue` else `IfFalse`
+     * @template Conditions Conditions array
+     * @template IfTrue Result, if only one item of `Conditions` is `true`
+     * @template IfFalse Result, if each item of `Conditions` is NOT `true` or more one item of `Conditions` is `true`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type n = CheckType<Xor<never>, never>;
+     * type u = CheckType<Xor<undefined>, never>;
+     * type u2 = CheckType<Xor<[false, undefined, true]>, true>;
+     * type fff = CheckType<Xor<[false, false, false]>, false>;
+     * type ttf = CheckType<Xor<[true, true, false]>, false>;
+     * type tff = CheckType<Xor<[true, false, false]>, true>;
+     * type ftf = CheckType<Xor<[false, true, false]>, true>;
+     * type fft = CheckType<Xor<[false, false, true]>, true>;
+     * type ttt = CheckType<Xor<[true, true, false]>, false>;
+     * type tr = CheckType<Xor<readonly [true, true, false]>, false>;
+     */
+    type Xor<Conditions extends readonly boolean[], IfTrue = true, IfFalse = false> = Conditions extends undefined ? never : Array.CountOf<Conditions, true> extends 1 ? IfTrue : IfFalse;
+    namespace Xor {
+    }
+}