@avstantso/ts 1.0.3 → 1.1.0

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

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

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

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

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

package/dist/_global/comparisons.d.ts

@@ -1,85 +0,0 @@
-declare namespace AVStantso.TS {
-    type Args<Item1 = unknown, Item2 = Item1, IfTrue = unknown, IfFalse = unknown> = [Item1, Item2, IfTrue, IfFalse];
-    namespace Number {
-        type _LT_For<Ag extends Args<number>, I extends number = 0> = I extends Ag[0] ? Ag[2] : I extends Ag[1] ? Ag[3] : _LT_For<Ag, Increment<I>>;
-        type _LT_Digit<Ag extends Args<Arr>> = Ag[0] extends [`${infer AF extends number}`, ...infer ARest] ? Ag[1] extends [`${infer BF extends number}`, ...infer BRest] ? AF extends BF ? _LT_Digit<[ARest, BRest, Ag[2], Ag[3]]> : _LT_For<[AF, BF, Ag[2], Ag[3]]> : never : never;
-        type _LT_Length<Ag extends Args<number>, LA extends number = TS.String._Length<`${Ag[0]}`>, LB extends number = TS.String._Length<`${Ag[1]}`>> = LA extends LB ? _LT_Digit<[
-            TS.String._SplitToChars<`${Ag[0]}`>,
-            TS.String._SplitToChars<`${Ag[1]}`>,
-            Ag[2],
-            Ag[3]
-        ]> : _LT_For<[LA, LB, Ag[2], Ag[3]]>;
-        type _LT_Sign<Ag extends Args<number>> = `${Ag[0]}` extends `-${infer A extends number}` ? `${Ag[1]}` extends `-${infer B extends number}` ? _LT_Length<[B, A, Ag[2], Ag[3]]> : Ag[2] : `${Ag[1]}` extends `-${number}` ? Ag[3] : _LT_Length<Ag>;
-    }
-    namespace String {
-        type _LT<Ag extends Args<string>> = Ag[0] extends `${infer AC}${infer AE}` ? Ag[1] extends `${infer BC}${infer BE}` ? AC extends BC ? _LT<[AE, BE, Ag[2], Ag[3]]> : Number._LT_Length<[ASCII.Code<AC>, ASCII.Code<BC>, Ag[2], Ag[3]]> : Ag[3] : Ag[2];
-    }
-    /**
-     * @summary Low-level test `Eq===true ? A <= B : A < B`
-     * @template Ag Arguments `[A, B, IfTrue, IfFalse]`
-     * @template Eq `true` — `<=`, `false` — `<`
-     * @returns `Ag[2] | Ag[3]`
-     * @example
-     * type nt = CheckType<_LT<[1, 2, true, false]>, true>;
-     * type st = CheckType<_LT<['a', 'b', true, false]>, true>;
-     * type nf = CheckType<_LT<[2, 1, true, false]>, false>;
-     * type sf = CheckType<_LT<['c', 'b', true, false]>, false>;
-     * 
-     * type n_large_p = CheckType<_LT<[9999998, 9999999, true, false]>, true>;
-     * type n_large_n = CheckType<_LT<[-9999999, -9999998, true, false]>, true>;
-     */
-    export type _LT<Ag extends Args, Eq extends boolean = false> = Ag[0] extends Ag[1] ? Eq extends true ? Ag[2] : Ag[3] : Ag extends [number, number, unknown, unknown] ? Number._LT_Sign<Ag> : Ag extends [string, string, unknown, unknown] ? String._LT<Ag> : never;
-    /**
-     * @summary Low-level test `Eq===true ? IsLT===true ? A <= B : A => B : IsLT ? A < B : A > B`
-     * @template Ag Arguments `[A, B, IfTrue, IfFalse]`
-     * @template IsLT `true` — `<`, `false` — `>`
-     * @template Eq `true` — `<=`, `false` — `<`
-     * @returns `Ag[2] | Ag[3]`
-     * @example
-     * type nt = CheckType<_LT_GT<[1, 2, true, false], true>, true>;
-     * type st = CheckType<_LT_GT<['a', 'b', true, false], true>, true>;
-     * type nf = CheckType<_LT_GT<[2, 1, true, false], true>, false>;
-     * type sf = CheckType<_LT_GT<['c', 'b', true, false], true>, false>;
-     * 
-     * type n_large_p = CheckType<_LT_GT<[9999998, 9999999, true, false], true>, true>;
-     * type n_large_n = CheckType<_LT_GT<[-9999999, -9999998, true, false], true>, true>;
-     */
-    export type _LT_GT<Ag extends Args, IsLT extends boolean, Eq extends boolean = false> = _LT<IsLT extends true ? Ag : [Ag[1], Ag[0], Ag[2], Ag[3]], Eq>;
-    /**
-     * @summary Test `A < B`
-     * @template A argument for comparision
-     * @template B argument for comparision
-     * @template IfTrue Result, if `A < B`
-     * @template IfFalse Result, if `A >= B`
-     * @returns `IfFalse` or `IfTrue` param
-     */
-    export type LT<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[A, B, IfTrue, IfFalse]>;
-    /**
-     * @summary Test `A <= B`
-     * @template A argument for comparision
-     * @template B argument for comparision
-     * @template IfTrue Result, if `A <= B`
-     * @template IfFalse Result, if `A > B`
-     * @returns `IfFalse` or `IfTrue` param
-     */
-    export type LTE<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[A, B, IfTrue, IfFalse], true>;
-    /**
-     * @summary Test `A > B`
-     * @template A argument for comparision
-     * @template B argument for comparision
-     * @template IfTrue Result, if `A > B`
-     * @template IfFalse Result, if `A <= B`
-     * @returns `IfFalse` or `IfTrue` param
-     */
-    export type GT<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[B, A, IfTrue, IfFalse]>;
-    /**
-     * @summary Test `A >= B`
-     * @template A argument for comparision
-     * @template B argument for comparision
-     * @template IfTrue Result, if `A >= B`
-     * @template IfFalse Result, if `A < B`
-     * @returns `IfFalse` or `IfTrue` param
-     */
-    export type GTE<A extends number | string, B extends number | string, IfTrue = true, IfFalse = false> = _LT<[B, A, IfTrue, IfFalse], true>;
-    export {};
-}

package/dist/_global/func.d.ts

@@ -1,17 +0,0 @@
-declare namespace AVStantso.TS.Func {
-    /**
-     * @summary Nested function type
-     * @template Depth nesting depth
-     * @example
-     * type n = CheckType<Nested<never>, never>;
-     * type u = CheckType<Nested<undefined>, (...params: Arr) => unknown>;
-     * 
-     * type r0 = CheckType<Nested<0>, (...params: Arr) => unknown>;
-     * type r1 = CheckType<Nested<1>, (...params: Arr) => (...params: Arr) => unknown>;
-     * type r2 = CheckType<
-     *   Nested<2>,
-     *   (...params: Arr) => (...params: Arr) => (...params: Arr) => unknown
-     * >;
-     */
-    type Nested<Depth extends number = 1, R = unknown, P extends Arr = Arr> = Depth extends 0 ? Func<R, P> : Func<Nested<Decrement<Depth>, R, P>>;
-}

package/dist/_global/index.d.ts

@@ -1,14 +0,0 @@
-import './_register';
-import './func';
-import './union';
-import './array';
-import './ascii';
-import './boolean';
-import './comparisons';
-import './numeric';
-import './string';
-import './literal';
-import './structure';
-import './resolve';
-import './type';
-import './utility';