@avstantso/ts 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+
+## [1.2.1] - 2026-01-18
+
+### Changed
+
+- Fix publishing
+
 All notable changes to this project will be documented in this file.
 
 ## [1.1.0] - 2026-01-18

package/dist/_global/_register.d.ts

@@ -0,0 +1,80 @@
+declare namespace AVStantso {
+    namespace TS {
+        /**
+         * @summary Check extends T1 to T2. Supports `undefined === undefined`.
+         * @template T1 Tested type 1
+         * @template T2 Tested type 2
+         * @template IfTrue Result, if `T1` extends `T2`
+         * @template IfFalse Result, if NOT `T1` extends `T2`
+         * @returns `IfFalse` or `IfTrue` param
+         * @example
+         * type n0 = CheckType<Extends<never, never>, never>;
+         * type n1 = CheckType<Extends<undefined, never>, never>;
+         * type n2 = CheckType<Extends<never, undefined>, never>;
+         * 
+         * type u0 = CheckType<Extends<unknown, undefined>, false>;
+         * type u1 = CheckType<Extends<undefined, unknown>, false>;
+         * type u2 = CheckType<Extends<1, undefined>, false>;
+         * type u3 = CheckType<Extends<undefined, 2>, false>;
+         * 
+         * type e0 = CheckType<Extends<undefined, undefined>, true>;
+         * type e1 = CheckType<Extends<0, 0>, true>;
+         * type e2 = CheckType<Extends<0, number>, true>;
+         * type e3 = CheckType<Extends<'a', 'a'>, true>;
+         * type e4 = CheckType<Extends<'a', string>, true>;
+         * 
+         * type ne1 = CheckType<Extends<number, 0>, false>;
+         * type ne2 = CheckType<Extends<string, 'a'>, false>;
+         */
+        type Extends<T1, T2, IfTrue = true, IfFalse = false> = T1 extends undefined ? T2 extends undefined ? IfTrue : IfFalse : T1 extends T2 ? IfTrue : IfFalse;
+        /**
+         * @summary TypeScript helpers for arrays
+         */
+        namespace Array { }
+        /**
+         * @summary TypeScript helpers for string
+         */
+        namespace String { }
+    }
+    namespace Code {
+        /**
+         * @summary TypeScript helpers utility
+         */
+        namespace TS {
+            /**
+             * @summary [O]ne or readonly [L]ist of `T` utility
+             */
+            interface OL {
+                /**
+                 * @summary Check `candidate` includes into array or equals value.\
+                 * `true` if both `undefined` or `null`
+                 */
+                in<T, O extends T | readonly T[]>(oneOrList: O, candidate: unknown): candidate is T;
+            }
+        }
+        interface TS {
+            /**
+             * @summary Checks candidate has object key type
+             */
+            isKey<K extends AVStantso.TS.Key>(candidate: unknown): candidate is K;
+            /**
+             * @summary Flat `structure` into `depth`.\
+             * ⚠ Creates wraps for functions with extended props, `this` context will loss
+             * @param structure Structure to flat
+             * @param depth Depth of flat. Default `1`
+             */
+            flat<T extends object, Depth extends number = 1>(structure: T, depth?: Depth): AVStantso.TS.Flat<T, Depth>;
+            /**
+             * @summary [O]ne or readonly [L]ist of `T` utility
+             */
+            OL: TS.OL;
+        }
+    }
+    interface Code {
+        /**
+         * @summary TypeScript helpers utility
+         */
+        TS: Code.TS;
+    }
+    const TS: Code.TS;
+}

package/dist/_global/array/_register.d.ts

@@ -0,0 +1,28 @@
+declare namespace AVStantso {
+    namespace Code {
+        namespace TS {
+            /**
+             * @summary Array utils
+             */
+            interface Array {
+                /**
+                 * @summary Create `Array.ToKey2Key` record
+                 * @template A Array type
+                 * @param arr Array
+                 * @returns `Array.ToKey2Key` record
+                 * @example
+                 * const arr = ['x', 'y', 'z'] as const;
+                 * const rec = TS.Array.ToKey2Key(arr);
+                 * expect(rec).toStrictEqual({ x: 'x', y: 'y', z: 'z' });
+                 */
+                ToKey2Key<A extends AVStantso.TS.ArrR>(arr: A): AVStantso.TS.Array.ToKey2Key<A>;
+            }
+        }
+        interface TS {
+            /**
+             * @summary Array utils
+             */
+            Array: TS.Array;
+        }
+    }
+}

package/dist/_global/array/arr-n.d.ts

@@ -0,0 +1,21 @@
+declare namespace AVStantso.TS {
+    /**
+     * @summary Any array on `N` optional items.\
+     * ⚠ Please use for check, not for define\
+     * `998` is empiric max length
+     * @example
+     * type unlim0 = CheckType<Arr extends ArrN ? true : false, false>;
+     * type unlim1 = CheckType<number[] extends ArrN ? true : false, false>;
+     * type unlim2 = CheckType<string[] extends ArrN ? true : false, false>;
+     * 
+     * type lim0 = CheckType<[] extends ArrN ? true : false, true>;
+     * type lim1 = CheckType<[number] extends ArrN ? true : false, true>;
+     * type lim2 = CheckType<[number, never, undefined] extends ArrN ? true : false, true>;
+     */
+    type ArrN = readonly [...Array.Create.Optional<998, any>];
+    /**
+     * @summary Array of `N` items or [`M`]ore.\
+     * `998` is empiric max length for `N`
+     */
+    type ArrM<T = any, N extends number = 2> = [...Array.Create<N, T>, ...T[]];
+}

package/dist/_global/array/create.d.ts

@@ -0,0 +1,59 @@
+declare namespace AVStantso.TS.Array {
+    type _Create<L extends number, Item, Opt extends boolean, R extends Item[] = [], I extends number = 0> = I extends L ? R : _Create<L, Item, Opt, Opt extends true ? [...R, Item?] : [...R, Item], Increment<I>>;
+    /**
+     * @summary Creates array of `Item` with specified length `L`
+     * @template L Length
+     * @template Item Item type
+     * @returns `[Item × L]`
+     * @example
+     * type n = CheckType<Create<never, any>, never>;
+     * type u = CheckType<Create<undefined, any>, never>;
+     * 
+     * type a5x3 = CheckType<Create<5, 3>, [3, 3, 3, 3, 3]>;
+     * type a2xABC = CheckType<Create<2, 'ABC'>, ['ABC', 'ABC']>;
+     */
+    export type Create<L extends number, Item> = L extends undefined ? never : _Create<L, Item, false>;
+    export namespace Create {
+        /**
+         * @summary Create array of optional `Item` with specified length `L`
+         * @template L Length
+         * @template Item Item type
+         * @returns `[Item? × L]`
+         * @example
+         * type n = CheckType<Optional<never, any>, never>;
+         * type u = CheckType<Optional<undefined, any>, never>;
+         * 
+         * type a5x3 = CheckType<Optional<5, 3>, [3?, 3?, 3?, 3?, 3?]>;
+         * type a2xABC = CheckType<Optional<2, 'ABC'>, ['ABC'?, 'ABC'?]>;
+         */
+        type Optional<L extends number, Item> = L extends undefined ? never : _Create<L, Item, true>;
+    }
+    type _Numbers<L extends number, R extends number[] = [], I extends number = 0> = L extends I ? R : _Numbers<L, [...R, I], Increment<I>>;
+    /**
+     * @summary Creates numeric literals array.
+     * @template L Length
+     * @returns Numeric literals array
+     * @example
+     * type n = CheckType<Numbers<never>, never>;
+     * type u = CheckType<Numbers<undefined>, never>;
+     * 
+     * type a0 = CheckType<Numbers<0>, []>;
+     * type a3 = CheckType<Numbers<3>, [0, 1, 2]>;
+     */
+    export type Numbers<L extends number> = L extends undefined ? never : _Numbers<L>;
+    type _Letters<L extends number, R extends string[] = [], I extends number = 0> = L extends I ? R : _Letters<L, [...R, TS.Letters[I]], Increment<I>>;
+    /**
+     * @summary Creates letters literals array with length `L`
+     * @template L Length
+     * @returns Letters literals array
+     * @example
+     * type n = CheckType<Letters<never>, never>;
+     * type u = CheckType<Letters<undefined>, never>;
+     * 
+     * type a0 = CheckType<Letters<0>, []>;
+     * type a3 = CheckType<Letters<3>, ['A', 'B', 'C']>;
+     * type a26 = CheckType<Letters<26>, TS.Letters>;
+     */
+    export type Letters<L extends number> = L extends undefined ? never : _Letters<L>;
+    export {};
+}

package/dist/_global/array/derivative.d.ts

@@ -0,0 +1,197 @@
+declare namespace AVStantso.TS.Array {
+    /**
+     * @summary Create array type with addition if not exists.
+     * @template TArr Array type
+     * @template Item Item to add
+     * @returns New array type with addition
+     * @example
+     * type n0 = CheckType<AddUnique<never, any>, never>;
+     * type n1 = CheckType<AddUnique<any, never>, never>;
+     * 
+     * type u0 = CheckType<AddUnique<undefined, any>, never>;
+     * 
+     * type t = CheckType<AddUnique<[2, 3], 1>, [2, 3, 1]>;
+     * type f = CheckType<AddUnique<[1, 2, 3], 1>, [1, 2, 3]>;
+     * type tu = CheckType<AddUnique<[1, 2, 3], undefined>, [1, 2, 3, undefined]>;
+     * type rtu = CheckType<AddUnique<readonly [1, 2, 3], undefined>, [1, 2, 3, undefined]>;
+     */
+    export type AddUnique<TArr extends ArrR, Item> = TArr extends undefined ? never : [Item] extends [never] ? never : IfHasItem<TArr, Item> extends false ? [...TArr, Item] : TArr;
+    type _MergeUnique<TArr1 extends ArrR, TArr2 extends ArrR> = TArr2 extends readonly [infer F, ...infer Rest] ? _MergeUnique<IfHasItem<TArr1, F> extends true ? TArr1 : [...TArr1, F], Rest> : TArr1;
+    /**
+     * @summary Create merged array type from two arrays without duplicates from `TArr2`.
+     * @template TArr1 Array type
+     * @template TArr2 Array type
+     * @returns New merged array without duplicates from `TArr2`
+     * @example
+     * type n0 = CheckType<MergeUnique<never, any>, never>;
+     * type n1 = CheckType<MergeUnique<any, never>, never>;
+     * 
+     * type u0 = CheckType<MergeUnique<undefined, any>, never>;
+     * type u1 = CheckType<MergeUnique<any, undefined>, never>;
+     * 
+     * type A = CheckType<MergeUnique<[6, 1, 4], [1, 2, 3, 1, 4, 2, 5]>, [6, 1, 4, 2, 3, 5]>;
+     * type AU = CheckType<
+     *   MergeUnique<[6, 1, 4], [1, 2, undefined, 1, 4, 2, undefined]>,
+     *   [6, 1, 4, 2, undefined]
+     * >;
+     * type rAU = CheckType<
+     *   MergeUnique<readonly [6, 1, 4], readonly [1, 2, undefined, 1, 4, 2, undefined]>,
+     *   [6, 1, 4, 2, undefined]
+     * >;
+     */
+    export type MergeUnique<TArr1 extends ArrR, TArr2 extends ArrR> = TArr1 extends undefined ? never : TArr2 extends undefined ? never : TArr1 extends ArrN ? TArr2 extends ArrN ? _MergeUnique<TArr1, TArr2> : never : never;
+    type _FilterUnique<TArr extends ArrR, R extends Arr = []> = TArr extends readonly [infer F, ...infer Rest] ? _FilterUnique<Rest, IfHasItem<R, F> extends true ? R : [...R, F]> : R;
+    /**
+     * @summary Create array type from array without duplicates.
+     * @template TArr Array type
+     * @returns New array without duplicates
+     * @example
+     * type n = CheckType<FilterUnique<never>, never>;
+     * type u = CheckType<FilterUnique<undefined>,never>;
+     * 
+     * type A = CheckType<FilterUnique<[1, 2, 3, 1, 4, 2, 5]>, [1, 2, 3, 4, 5]>;
+     * type AU = CheckType<
+     *   FilterUnique<[1, 2, 3, undefined, 1, 4, undefined, 5]>,
+     *   [1, 2, 3, undefined, 4, 5]
+     * >;
+     * type rAU = CheckType<
+     *   FilterUnique<readonly [1, 2, 3, undefined, 1, 4, undefined, 5]>,
+     *   [1, 2, 3, undefined, 4, 5]
+     * >;
+     */
+    export type FilterUnique<TArr extends ArrR> = TArr extends undefined ? never : TArr extends ArrN ? _FilterUnique<TArr> : never;
+    type _Sub<TArr extends ArrR, Start extends number, End extends number, I extends number = 0, R extends Arr = [], Ignore extends boolean = I extends Start ? false : true> = TArr extends readonly [infer F, ...infer Rest] ? I extends End ? R : Ignore extends true ? _Sub<Rest, Start, End, Increment<I>, R> : _Sub<Rest, Start, End, Increment<I>, [...R, F], false> : R;
+    type _SubCheck<TArr extends ArrR, Start extends number, End extends number, S extends number = Start extends undefined ? 0 : Numeric.IsNegative<Start, 0, Start>> = End extends undefined ? _Sub<TArr, S, End> : GT<S, Increment<End>> extends true ? never : _Sub<TArr, S, Increment<End>>;
+    /**
+     * @summary Create sub array type.
+     * @template TArr Array type
+     * @template Start Start index for copy. `undefined` or negative — from start of array
+     * @template End End index for copy. `undefined` — to end of array
+     * @returns Array type with copied items types or `never` if `Start > End`
+     * @example
+     * type n0 = CheckType<Sub<never, any>, never>;
+     * type n1 = CheckType<Sub<any, never>, never>;
+     * type n2 = CheckType<Sub<any, any, never>, never>;
+     * type u = CheckType<Sub<undefined, any>, never>;
+     * 
+     * type A = CheckType<Sub<[1, 2, 3, undefined, 5, 6], 2, 4>, [3, undefined, 5]>;
+     * type S = CheckType<Sub<[1, 2, 3, 4, 5, 6], undefined, undefined>, [1, 2, 3, 4, 5, 6]>;
+     * 
+     * type negaiveS = CheckType<Sub<[1, 2, 3, 4, 5, 6], -2, 4>, [1, 2, 3, 4, 5]>;
+     * type EltS = CheckType<Sub<[1, 2, 3, 4, 5, 6], 4, 2>, never>;
+     * type rEltS = CheckType<Sub<readonly [1, 2, 3, 4, 5, 6], 4, 2>, never>;
+     */
+    export type Sub<TArr extends ArrR, Start extends number = undefined, End extends number = undefined> = TArr extends undefined ? never : [Start] extends [never] ? never : [End] extends [never] ? never : Start | End extends undefined ? TArr : TArr extends ArrN ? _SubCheck<TArr, Start, End> : never;
+    type _Remove<TArr extends ArrR, Start extends number, End extends number, S extends number = Start extends undefined ? 0 : Numeric.IsNegative<Start, 0, Start>, E extends number = End extends undefined ? undefined : GT<S, End, never, End>> = [E] extends [never] ? never : E extends undefined ? Sub<TArr, 0, Decrement<S>> : [...Sub<TArr, 0, Decrement<S>>, ...Sub<TArr, Increment<E>>];
+    /**
+     * @summary Create new array type witout removed section.
+     * @template TArr Array type
+     * @template Start Start index for remove. `undefined` or negative — from start of array
+     * @template End End index for remove. `undefined` — to end of array
+     * @returns Array type with copied items types, except removed items or `never` if `Start > End`
+     * @example
+     * type n0 = CheckType<Remove<never, any>, never>;
+     * type n1 = CheckType<Remove<any, never>, never>;
+     * type n2 = CheckType<Remove<any, any, never>, never>;
+     * type u = CheckType<Remove<undefined, any>, never>;
+     * 
+     * type A = CheckType<Remove<[1, 2, 3, 4, 5, 6], 2, 4>, [1, 2, 6]>;
+     * type S = CheckType<Remove<[1, 2, 3, 4, 5, 6], undefined, undefined>, []>;
+     * 
+     * type negaiveS = CheckType<Remove<[1, 2, 3, 4, 5, 6], -2, 4>, [6]>;
+     * type EltS = CheckType<Remove<[1, 2, 3, 4, 5, 6], 4, 2>, never>;
+     * 
+     * type U = CheckType<Remove<[1, 2, 3, undefined, 5, undefined], 2, 4>, [1, 2, undefined]>;
+     * type rU = CheckType<
+     *   Remove<readonly [1, 2, 3, undefined, 5, undefined], 2, 4>,
+     *   [1, 2, undefined]
+     * >;
+     */
+    export type Remove<TArr extends ArrR, Start extends number, End extends number = undefined> = TArr extends undefined ? never : [Start] extends [never] ? never : [End] extends [never] ? never : Start | End extends undefined ? [] : _Remove<TArr, Start extends undefined ? 0 : Start, End>;
+    /**
+     * @summary Reverse `TArr` array type. ⚠ Unsafe, internal
+     * @template TArr Array to reverse
+     * @returns Reversed array
+     * @example
+     * type n = CheckType<_Reverse<never>, never>;
+     * type u = CheckType<_Reverse<undefined>, [unknown]>; // ⚠
+     * 
+     * type a0 = CheckType<_Reverse<[1, 2, 3]>, [3, 2, 1]>;
+     * type a2 = CheckType<_Reverse<[1, undefined, 3, 'a']>, ['a', 3, undefined, 1]>;
+     * type ra2 = CheckType<_Reverse<readonly [1, undefined, 3, 'a']>, ['a', 3, undefined, 1]>;
+     */
+    export type _Reverse<TArr extends ArrR, R extends Arr = []> = TArr extends readonly [infer F, ...infer Rest] ? _Reverse<Rest, [F, ...R]> : R;
+    /**
+     * @summary Reverse `TArr` array type.
+     * @template TArr Array to reverse
+     * @returns Reversed array
+     * @example
+     * type n = CheckType<Reverse<never>, never>;
+     * type u = CheckType<Reverse<undefined>, never>;
+     * 
+     * type a0 = CheckType<Reverse<[1, 2, 3]>, [3, 2, 1]>;
+     * type a2 = CheckType<Reverse<[1, undefined, 3, 'a']>, ['a', 3, undefined, 1]>;
+     * type ra2 = CheckType<Reverse<readonly [1, undefined, 3, 'a']>, ['a', 3, undefined, 1]>;
+     */
+    export type Reverse<TArr extends ArrR> = TArr extends undefined ? never : TArr extends ArrN ? _Reverse<TArr> : never;
+    /**
+     * @summary Join `TArr` array type to `string`. ⚠ Unsafe, internal
+     * @template TArr Array to join
+     * @returns Joined string
+     * @example
+     * type n = CheckType<_Join<never>, never>;
+     * type u = CheckType<_Join<undefined>, string>; // ⚠
+     * 
+     * type nn = CheckType<_Join<[1, 2, 3]>, '123'>;
+     * type rss = CheckType<_Join<readonly ['a', 1, true, 123456789012345]>, 'a1true123456789012345'>;
+     */
+    export type _Join<TArr extends readonly (TS.String.Possible)[], R extends string = ''> = TArr extends readonly [
+        infer F extends TS.String.Possible,
+        ...infer Rest extends (TS.String.Possible)[]
+    ] ? _Join<Rest, `${R}${F}`> : R;
+    /**
+     * @summary Join `TArr` array type to `string`
+     * @template TArr Array to join
+     * @returns Joined string
+     * @example
+     * type n = CheckType<Join<never>, never>;
+     * type u = CheckType<Join<undefined>, undefined>;
+     * 
+     * type nn = CheckType<Join<[1, 2, 3]>, '123'>;
+     * type rss = CheckType<Join<readonly ['a', 1, true, 123456789012345]>, 'a1true123456789012345'>;
+     */
+    export type Join<TArr extends readonly (TS.String.Possible)[]> = TArr extends undefined ? TArr : TArr extends ArrN ? _Join<TArr> : never;
+    /**
+     * @summary Cast all `TArr` items to `Item` type. ⚠ Unsafe, internal
+     * @template TArr Array to cast
+     * @template Item Item type to cast. Defaults `any`
+     * @returns Array of `Extract<TArr[I], Item>`
+     * @example
+     * type n = CheckType<_Cast<never, any>, never>;
+     * type u = CheckType<_Cast<undefined, any>, [unknown]>; // ⚠
+     * 
+     * type a0 = CheckType<_Cast<[1, 2, 3]>, [1, 2, 3]>;
+     * type a1 = CheckType<_Cast<[1, 2, 3], number>, [1, 2, 3]>;
+     * type a2 = CheckType<_Cast<[1, 2, 3], string>, [never, never, never]>;
+     * type a3 = CheckType<_Cast<[1, undefined, 3], string>, [never, undefined, never]>;
+     * type ra3 = CheckType<_Cast<readonly [1, undefined, 3], string>, [never, undefined, never]>;
+     */
+    export type _Cast<TArr extends ArrR, Item = any, R extends Item[] = []> = TArr extends readonly [infer F, ...infer Rest] ? _Cast<Rest, Item, [...R, Extract<F, Item>]> : R;
+    /**
+     * @summary Cast all `TArr` items to `Item` type.
+     * @template TArr Array to cast
+     * @template Item Item type to cast. Defaults `any`
+     * @returns Array of `Extract<TArr[I], Item>`
+     * @example
+     * type n = CheckType<Cast<never, any>, never>;
+     * type u = CheckType<Cast<undefined, any>, never>;
+     * 
+     * type a0 = CheckType<Cast<[1, 2, 3]>, [1, 2, 3]>;
+     * type a1 = CheckType<Cast<[1, 2, 3], number>, [1, 2, 3]>;
+     * type a2 = CheckType<Cast<[1, 2, 3], string>, [never, never, never]>;
+     * type a3 = CheckType<Cast<[1, undefined, 3], string>, [never, undefined, never]>;
+     * type ra3 = CheckType<Cast<readonly [1, undefined, 3], string>, [never, undefined, never]>;
+     */
+    export type Cast<TArr extends ArrR, Item = any> = TArr extends undefined ? never : TArr extends ArrN ? _Cast<TArr, Item> : never;
+    export {};
+}

package/dist/_global/array/find.d.ts

@@ -0,0 +1,89 @@
+declare namespace AVStantso.TS.Array {
+    type _IndexOf<TArr extends ArrR, Item, I extends number = 0> = TArr extends readonly [infer F, ...infer Rest] ? Extends<F, Item> extends true ? I : _IndexOf<Rest, Item, Increment<I>> : undefined;
+    /**
+     * @summary Find index of type in array type.
+     * @template TArr Tested array type
+     * @template Item Tested item type
+     * @template I Start index
+     * @returns Number literal or `undefined` if not found
+     * @example
+     * type n0 = CheckType<IndexOf<never, any, any>, never>;
+     * type n1 = CheckType<IndexOf<any, never, any>, never>;
+     * type n2 = CheckType<IndexOf<any, any, never>, never>;
+     * 
+     * type u0 = CheckType<IndexOf<undefined, any, any>, never>;
+     * type u1 = CheckType<IndexOf<any, any, undefined>, never>;
+     * 
+     * type et = CheckType<IndexOf<readonly [1, 2, 3], 2>, 1>;
+     * type etu = CheckType<IndexOf<[undefined, undefined, 'x'], undefined>, 0>;
+     * type eu = CheckType<IndexOf<[undefined, undefined, 'x'], 'x'>, 2>;
+     * type es = CheckType<IndexOf<[undefined, undefined, 'x'], string>, 2>;
+     * type ef = CheckType<IndexOf<[1, 2, 3], 4>, undefined>;
+     */
+    export type IndexOf<TArr extends ArrR, Item, I extends number = 0> = TArr extends undefined ? never : [Item] extends [never] ? never : I extends undefined ? never : TArr extends ArrN ? _IndexOf<TArr, Item, I> : never;
+    type _IfHasItem<TArr extends ArrR, Item, IfTrue = true, IfFalse = false, I extends number = IndexOf<TArr, Item>> = [I] extends [never] ? never : I extends undefined ? IfFalse : IfTrue;
+    /**
+     * @summary Test array type has item.
+     * @template TArr Tested array type
+     * @template Item Tested item type
+     * @template IfTrue Result, if `TArr` has `Item`
+     * @template IfFalse Result, if `TArr` NOT has `Item`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type n0 = CheckType<IfHasItem<never, any>, never>;
+     * type n1 = CheckType<IfHasItem<any, never>, never>;
+     * 
+     * type u0 = CheckType<IfHasItem<undefined, any>, never>;
+     * 
+     * type e = CheckType<IfHasItem<[1, 2, 3], 2>, true>;
+     * type n = CheckType<IfHasItem<[1, 2, 3], 4>, false>;
+     * type eu = CheckType<IfHasItem<[1, undefined, 3, 4], 4>, true>;
+     * type euu = CheckType<IfHasItem<[1, undefined, 3, 4], undefined>, true>;
+     * type reuu = CheckType<IfHasItem<readonly [1, undefined, 3, 4], undefined>, true>;
+     */
+    export type IfHasItem<TArr extends ArrR, Item, IfTrue = true, IfFalse = false> = _IfHasItem<TArr, Item, IfTrue, IfFalse>;
+    type _IfEach<TArr extends ArrR, Item, IfTrue = true, IfFalse = false, I extends number = 0> = TArr extends readonly [infer F, ...infer Rest] ? Extends<F, Item> extends true ? _IfEach<Rest, Item, IfTrue, IfFalse, Increment<I>> : IfFalse : IfTrue;
+    /**
+     * @summary Test array type each item extends `Item`.
+     * @template TArr Tested array type
+     * @template Item Tested item type
+     * @template IfTrue Result, if each item of `TArr` extends `Item`
+     * @template IfFalse Result, if NOT each item of `TArr` extends `Item`
+     * @returns `IfFalse` or `IfTrue` param
+     * @example
+     * type n0 = CheckType<IfEach<never, any>, never>;
+     * type n1 = CheckType<IfEach<any, never>, never>;
+     * 
+     * type u0 = CheckType<IfEach<undefined, any>, never>;
+     * 
+     * type t = CheckType<IfEach<[2, 2, 2], 2>, true>;
+     * type f = CheckType<IfEach<[1, 2, 3], 3>, false>;
+     * 
+     * type fu = CheckType<IfEach<[undefined, undefined, 3], 3>, false>;
+     * type tu = CheckType<IfEach<[undefined, undefined, undefined], undefined>, true>;
+     * type rtu = CheckType<IfEach<readonly [undefined, undefined, undefined], undefined>, true>;
+     */
+    export type IfEach<TArr extends ArrR, Item, IfTrue = true, IfFalse = false> = TArr extends undefined ? never : [Item] extends [never] ? never : TArr extends ArrN ? _IfEach<TArr, Item, IfTrue, IfFalse> : never;
+    type _CountOf<TArr extends ArrR, Item, R extends number = 0> = TArr extends readonly [infer F, ...infer Rest] ? _CountOf<Rest, Item, Extends<F, Item, Increment<R>, R>> : R;
+    /**
+     * @summary Calculate count of items who extends `Item` in array `TArr`.
+     * @template TArr Tested array type
+     * @template Item Tested item type
+     * @returns Count of items who extends `Item` in array
+     * @example
+     * type n0 = CheckType<CountOf<never, any>, never>;
+     * type n1 = CheckType<CountOf<any, never>, never>;
+     * 
+     * type u0 = CheckType<CountOf<undefined, any>, never>;
+     * 
+     * type r0 = CheckType<CountOf<[1, 2, 3], 4>, 0>;
+     * type r1 = CheckType<CountOf<[1, 2, 3], 3>, 1>;
+     * type r3 = CheckType<CountOf<[2, 2, 2], 2>, 3>;
+     * type z0 = CheckType<CountOf<[], 4>, 0>;
+     * 
+     * type cu = CheckType<CountOf<['z', undefined, undefined], undefined>, 2>;
+     * type rcu = CheckType<CountOf<readonly ['z', undefined, undefined], undefined>, 2>;
+     */
+    export type CountOf<TArr extends ArrR, Item> = TArr extends undefined ? never : [Item] extends [never] ? never : TArr extends ArrN ? _CountOf<TArr, Item> : never;
+    export {};
+}

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

@@ -0,0 +1,8 @@
+import './_register';
+import './create';
+import './arr-n';
+import './low-level';
+import './derivative';
+import './find';
+import './map-key-value';
+import './min-max-sort';

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 {};
+    }
+}