@avstantso/ts 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+
+## [1.3.0] - 2026-01-31
+
+### Changed
+
+- Fix `String.Cases`, `FilterUnique` -> `Filter + Filter.Unique`
+- Add `String` generic — caster to string with default, `ASCII.Letter` unions
+
+## [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/README.md

@@ -8,7 +8,7 @@ Advanced TypeScript type system utilities and helpers for creating powerful gene
 ## Features
 
 - **Type-level arithmetic** - Increment, decrement, addition, subtraction, multiplication, division, and power operations on numeric literals
-- **Advanced array types** - Create, manipulate, sort, filter, and transform array types with utilities like `Create`, `Sort`, `FilterUnique`, `Reverse`, `Join`
+- **Advanced array types** - Create, manipulate, sort, filter, and transform array types with utilities like `Create`, `Sort`, `Filter`, `Filter.Unique`, `Reverse`, `Join`
 - **String manipulation types** - String length, case conversions (camelCase, PascalCase, snake_case, kebab-case), trimming, replacement, and pattern matching
 - **Union utilities** - Convert unions to intersections, tuples, test for union types, and more
 - **Structure (object) utilities** - Deep type manipulation, key/value extraction, flattening, reversing, splitting, and combining
@@ -421,7 +421,31 @@ type WithUndefined = TS.Array.MergeUnique<[6, 1, 4], [1, 2, undefined, 1, 4, 2,
 // [6, 1, 4, 2, undefined]
 ```
 
-#### `TS.Array.FilterUnique<TArr>`
+#### `TS.Array.Filter<TArr, TFilter = undefined>`
+
+Create array type from array without items matching the filter.
+
+**Type Parameters:**
+- `TArr` - Array type to filter
+- `TFilter` - Items to exclude (single item or array of items). Defaults to `undefined`
+
+**Example:**
+```typescript
+import { TS } from '@avstantso/ts';
+
+// Filter out specific value
+type NoOnes = TS.Array.Filter<[1, 2, 3, 1, 4, 2, 5], 1>; // [2, 3, 4, 2, 5]
+
+// Filter out multiple values
+type Filtered = TS.Array.Filter<[1, 2, 3, undefined, 1, 4, undefined, 5], [2, 3, undefined]>;
+// [1, 1, 4, 5]
+
+// Default: filter undefined values
+type NoUndefined = TS.Array.Filter<[1, 2, 3, undefined, 1, 4, undefined, 5]>;
+// [1, 2, 3, 1, 4, 5]
+```
+
+##### `TS.Array.Filter.Unique<TArr>`
 
 Create array type from array without duplicates.
 
@@ -429,8 +453,8 @@ Create array type from array without duplicates.
 ```typescript
 import { TS } from '@avstantso/ts';
 
-type Unique = TS.Array.FilterUnique<[1, 2, 3, 1, 4, 2, 5]>; // [1, 2, 3, 4, 5]
-type WithUndefined = TS.Array.FilterUnique<[1, 2, 3, undefined, 1, 4, undefined, 5]>;
+type Unique = TS.Array.Filter.Unique<[1, 2, 3, 1, 4, 2, 5]>; // [1, 2, 3, 4, 5]
+type WithUndefined = TS.Array.Filter.Unique<[1, 2, 3, undefined, 1, 4, undefined, 5]>;
 // [1, 2, 3, undefined, 4, 5]
 ```
 
@@ -700,6 +724,26 @@ English uppercase letters array type: `['A', 'B', 'C', ..., 'Z']`.
 
 English lowercase letters array type: `['a', 'b', 'c', ..., 'z']`.
 
+#### `TS.ASCII.Letter<IsUpper = true>`
+
+English letter union type generic by case.
+
+**Example:**
+```typescript
+import { TS } from '@avstantso/ts';
+
+type Upper = TS.ASCII.Letter<true>; // 'A' | 'B' | ... | 'Z'
+type Lower = TS.ASCII.Letter<false>; // 'a' | 'b' | ... | 'z'
+```
+
+##### `TS.ASCII.Letter.Upper`
+
+Union of English uppercase letters: `'A' | 'B' | 'C' | ... | 'Z'`.
+
+##### `TS.ASCII.Letter.Lower`
+
+Union of English lowercase letters: `'a' | 'b' | 'c' | ... | 'z'`.
+
 #### `TS.ASCII`
 
 Readonly array type of all ASCII characters (character codes 0-255).
@@ -828,6 +872,29 @@ type StrGreaterEq = TS.Comparisons.GTE<'b', 'b'>; // true
 
 String type manipulation utilities.
 
+### `TS.String<T, D = ''>`
+
+Cast a value to string literal type with a default fallback.
+
+**Type Parameters:**
+- `T` - Value to convert to string
+- `D` - Default value if `T` cannot be converted to string (default: `''`)
+
+**Returns:** String literal type or `D` if conversion not possible
+
+**Example:**
+```typescript
+import { TS } from '@avstantso/ts';
+
+type FromString = TS.String<'abcd'>; // 'abcd'
+type FromNumber = TS.String<123>; // '123'
+type FromBoolean = TS.String<true>; // 'true'
+type FromFalse = TS.String<false>; // 'false'
+
+// With default fallback
+type WithDefault = TS.String<object, 'fallback'>; // 'fallback'
+```
+
 ### Basic String Types
 
 #### `TS.String.Possible`
@@ -1025,6 +1092,12 @@ type Pascal = TS.String.Case<'p', Phrase>; // 'OhJingleBellsJingleBellsJingleAll
 type Snake = TS.String.Case<'s', Phrase>; // 'oh_jingle_bells_jingle_bells_jingle_all_the_way'
 type SnakeUp = TS.String.Case<'S', Phrase>; // 'OH_JINGLE_BELLS_JINGLE_BELLS_JINGLE_ALL_THE_WAY'
 type Kebab = TS.String.Case<'k', Phrase>; // 'oh-jingle-bells-jingle-bells-jingle-all-the-way'
+
+// Handles consecutive uppercase letters correctly
+type XMLCamel = TS.String.Case<'c', 'XMLHttpRequest'>; // 'xmlHttpRequest'
+type XMLPascal = TS.String.Case<'p', 'XMLHttpRequest'>; // 'XmlHttpRequest'
+type XMLSnake = TS.String.Case<'s', 'XMLHttpRequest'>; // 'xml_http_request'
+type XMLKebab = TS.String.Case<'k', 'XMLHttpRequest'>; // 'xml-http-request'
 ```
 
 ##### `TS.String.Case.Settings.Removes`

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,229 @@
+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;
+    export namespace Filter {
+        type _Unique<TArr extends ArrR, R extends Arr = []> = TArr extends readonly [infer F, ...infer Rest] ? _Unique<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<Filter.Unique<never>, never>;
+         * type u = CheckType<Filter.Unique<undefined>,never>;
+         * 
+         * type A = CheckType<Filter.Unique<[1, 2, 3, 1, 4, 2, 5]>, [1, 2, 3, 4, 5]>;
+         * type AU = CheckType<
+         *   Filter.Unique<[1, 2, 3, undefined, 1, 4, undefined, 5]>,
+         *   [1, 2, 3, undefined, 4, 5]
+         * >;
+         * type rAU = CheckType<
+         *   Filter.Unique<readonly [1, 2, 3, undefined, 1, 4, undefined, 5]>,
+         *   [1, 2, 3, undefined, 4, 5]
+         * >;
+         */
+        export type Unique<TArr extends ArrR> = TArr extends undefined ? never : TArr extends ArrN ? _Unique<TArr> : never;
+        export {};
+    }
+    type _Filter<TArr extends ArrR, TFArr extends ArrR, R extends Arr = []> = TArr extends readonly [infer F, ...infer Rest] ? _Filter<Rest, TFArr, IfHasItem<TFArr, F> extends true ? R : [...R, F]> : R;
+    /**
+     * @summary Create array type from array without items from filter.
+     * @template TArr Array type
+     * @template TFilter Array of items or one item to exclude. Default filter `undefined` values
+     * @returns New filtered array
+     * @example
+     * type n0 = CheckType<Filter<never, any>, never>;
+     * type n1 = CheckType<Filter<any, never>, never>;
+     * type u0 = CheckType<Filter<undefined, any>, never>;
+     * type u1 = CheckType<Filter<any, undefined>, [] | [unknown]>;
+     * 
+     * type A = CheckType<Filter<[1, 2, 3, 1, 4, 2, 5], 1>, [2, 3, 4, 2, 5]>;
+     * type AU = CheckType<
+     *   Filter<[1, 2, 3, undefined, 1, 4, undefined, 5], [2, 3, undefined]>,
+     *   [1, 1, 4, 5]
+     * >;
+     * type rAU = CheckType<
+     *   Filter<readonly [1, 2, 3, undefined, 1, 4, undefined, 5], readonly [4, undefined]>,
+     *   [1, 2, 3, 1, 5]
+     * >;
+     * type AUd = CheckType<
+     *   Filter<[1, 2, 3, undefined, 1, 4, undefined, 5]>,
+     *   [1, 2, 3, 1, 4, 5]
+     * >;
+     */
+    export type Filter<TArr extends ArrR, TFilter = undefined> = TArr extends undefined ? never : TArr extends ArrN ? TFilter extends undefined ? _Filter<TArr, [TFilter]> : TFilter extends ArrN ? _Filter<TArr, TFilter> : _Filter<TArr, [TFilter]> : never;
+    export namespace Filter {
+    }
+    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';