@rzl-zone/utils-js 3.1.3-beta.0 → 3.2.0

package/dist/types/index.d.ts

@@ -1,11 +1,14 @@
-import{A as And,I as IsStringLiteral,P as ParseNumber,a as IsNegative,N as Negate,b as Abs,c as IsFloat,d as IsUnknown,e as IsNegativeInteger,O as Or,f as OrArr,S as Split,g as AndArr,h as IsInteger,R as Repeat,i as Push,j as IfNegative,k as IsPositive,l as IsEven,m as IsReadonlyArray,n as IfPositive}from'../is-array--YjXV-Wx.js';export{C as CharAt,E as Even,t as EvenDigit,F as Float,u as IfEven,v as IfFloat,w as IfInteger,x as IfNegativeFloat,y as IfNegativeInteger,z as IfOdd,B as IfPositiveFloat,D as IfPositiveInteger,a0 as IfUnknown,G as Integer,o as IsArray,p as IsMutableArray,H as IsNegativeFloat,J as IsOdd,K as IsPositiveFloat,L as IsPositiveInteger,Q as IsScientificNumber,M as Mutable,q as MutableExcept,r as MutableOnly,s as MutableOptions,T as Negative,U as NegativeFloat,V as NegativeInteger,W as Odd,X as OddDigit,Y as ParseScientificNumber,Z as Positive,_ as PositiveFloat,$ as PositiveInteger,a1 as UnknownifyProperties,a2 as UnknownifyPropertiesOptions}from'../is-array--YjXV-Wx.js';import{a as IsEmptyString,b as IfEmptyString,T as Trim,A as AnyString}from'../string-XA-til3C.js';export{E as EmptyString,d as IfNonEmptyString,I as IfNot,e as IsNonEmptyString,N as NonEmptyString,f as TrimLeft,g as TrimRight,h as TrimsLower,i as TrimsUpper,W as Whitespace,c as WordSeparator}from'../string-XA-til3C.js';import{I as IsAny}from'../any-BmdI8UbK.js';export{A as AnifyProperties,a as AnifyPropertiesOptions,b as IfAny}from'../any-BmdI8UbK.js';import{A as AnyFunction,T as TypedArray}from'../type-data-DDs-u2kq.js';export{a as AnObjectNonArray,B as BoxedPrimitivesTypes,D as DataTypes,b as DeepReplaceType,I as IntlObjects,N as NonPlainObject,W as WebApiObjects}from'../type-data-DDs-u2kq.js';import{I as IfExtends,N as Not,a as NotExtends,b as IsEmptyArray,P as Pop,E as Extends,c as ExtendsArr,d as IfEmptyArray}from'../extends-Bk_SBGdT.js';export{A as Arrayable,e as EmptyArray,G as GetArrayElementType,f as IfNonEmptyArray,i as IfNotExtends,g as IsNonEmptyArray,M as MutableArray,h as NonEmptyArray,j as PopOptions}from'../extends-Bk_SBGdT.js';export{F as FixNeverArrayRecursive,N as NormalizeEmptyArraysRecursive,R as RemoveEmptyArrayElements}from'../arrays-normalize-recursive-CnjYJ9xg.js';import{I as If}from'../if-CvT4R7Kh.js';import{I as IsNever,a as IfNever}from'../never-BfayMBF9.js';export{N as NeverifyProperties,b as NeverifyPropertiesOptions}from'../never-BfayMBF9.js';import{P as Prettify,a as PrettifyOptions,D as DefaultPrettifyOptions}from'../prettify-C4xLcYOP.js';export{I as IsArrayOrTuple,b as IsConstructor,c as IsFunction,d as IsPrimitive,e as IsRealPrimitive,f as Primitive}from'../prettify-C4xLcYOP.js';import{N as NonUndefined}from'../nils-DMz3kU7M.js';export{K as KeepNil,a as KeepNull,b as KeepUndef,c as Nilable,d as NonNil,e as NonNull,g as NullToUndefined,f as Nullable,h as Nullish,U as Undefinedable}from'../nils-DMz3kU7M.js';export{N as NumberRangeUnion}from'../NumberRangeUnion-DC-C3_Kq.js';import{O as OmitStrict}from'../omit-VvmIsZmX.js';type _AreAnagrams<Str1 extends string,Str2 extends string>=IsEmptyString<Str1>extends true?IsEmptyString<Str2>extends true?true:false:Str1 extends`${infer First extends string}${infer Rest1 extends string}`?Str2 extends`${infer Prev extends string}${First}${infer Rest2 extends string}`?_AreAnagrams<Rest1,`${Prev}${Rest2}`>:false:never;
+import{A as And,b as Or,O as OrArr,a as AndArr}from'../or-C6qzKt2I.js';import{I as IsStringLiteral,P as ParseNumber,a as IsNegative,N as Negate,A as Abs,b as IsFloat,c as IsUnknown,d as IsNegativeInteger,S as Split,e as IsInteger,R as Repeat,f as Push,g as IfNegative,h as IsPositive,i as IsEven,j as IsReadonlyArray,k as IfPositive}from'../is-array-BJeHxPM3.js';export{C as CharAt,E as Even,q as EvenDigit,F as Float,r as IfEven,s as IfFloat,t as IfInteger,u as IfNegativeFloat,v as IfNegativeInteger,w as IfOdd,x as IfPositiveFloat,y as IfPositiveInteger,Y as IfUnknown,z as Integer,l as IsArray,m as IsMutableArray,B as IsNegativeFloat,D as IsOdd,G as IsPositiveFloat,H as IsPositiveInteger,J as IsScientificNumber,M as Mutable,n as MutableExcept,o as MutableOnly,p as MutableOptions,K as Negative,L as NegativeFloat,O as NegativeInteger,Q as Odd,T as OddDigit,U as ParseScientificNumber,V as Positive,W as PositiveFloat,X as PositiveInteger,Z as UnknownifyProperties,_ as UnknownifyPropertiesOptions}from'../is-array-BJeHxPM3.js';import{a as IsEmptyString,b as IfEmptyString,T as Trim,A as AnyString}from'../string-B1jlOnws.js';export{E as EmptyString,d as IfNonEmptyString,I as IfNot,e as IsNonEmptyString,N as NonEmptyString,f as TrimLeft,g as TrimRight,h as TrimsLower,i as TrimsUpper,W as Whitespace,c as WordSeparator}from'../string-B1jlOnws.js';import{I as IsAny}from'../any-v4TsK9ES.js';export{A as AnifyProperties,a as AnifyPropertiesOptions,b as IfAny}from'../any-v4TsK9ES.js';import{A as AnyFunction,T as TypedArray,P as Prettify,a as PrettifyOptions,D as DefaultPrettifyOptions}from'../prettify-3o8_Kw6b.js';export{g as AnObjectNonArray,B as BoxedPrimitivesTypes,h as DataTypes,i as DeepReplaceType,j as IntlObjects,I as IsArrayOrTuple,b as IsConstructor,c as IsFunction,d as IsPrimitive,e as IsRealPrimitive,N as NonPlainObject,f as Primitive,W as WebApiObjects}from'../prettify-3o8_Kw6b.js';import{I as IfExtends,N as Not,a as NotExtends,b as IsEmptyArray,P as Pop,E as Extends,c as ExtendsArr,d as IfEmptyArray}from'../extends-DtdRjDyU.js';export{A as Arrayable,e as EmptyArray,G as GetArrayElementType,f as IfNonEmptyArray,i as IfNotExtends,g as IsNonEmptyArray,M as MutableArray,h as NonEmptyArray,j as PopOptions}from'../extends-DtdRjDyU.js';export{F as FixNeverArrayRecursive,N as NormalizeEmptyArraysRecursive,R as RemoveEmptyArrayElements}from'../arrays-normalize-recursive-BqmVuFlD.js';import{I as If}from'../if-ChM35c_q.js';import{I as IsNever,a as IfNever}from'../never-D89PbPh5.js';export{N as NeverifyProperties,b as NeverifyPropertiesOptions}from'../never-D89PbPh5.js';export{E as ExtractStrict,O as OmitStrict,a as OverrideTypes}from'../override-CL2olHE5.js';import{N as NonUndefined}from'../nils-CO8zLHSB.js';export{K as KeepNil,a as KeepNull,b as KeepUndef,c as Nilable,d as NonNil,e as NonNull,g as NullToUndefined,f as Nullable,h as Nullish,U as Undefinedable}from'../nils-CO8zLHSB.js';export{N as NumberRangeUnion}from'../NumberRangeUnion-B6bhM2s7.js';export{P as PickStrict}from'../pick-BSMX6Xe2.js';export{A as Awaitable,C as CustomPromiseType}from'../promises-LU7K00H0.js';
+/** @private ***types for {@link AreAnagrams}.*** */
+type _AreAnagrams<Str1 extends string,Str2 extends string>=IsEmptyString<Str1>extends true?IsEmptyString<Str2>extends true?true:false:Str1 extends`${infer First extends string}${infer Rest1 extends string}`?Str2 extends`${infer Prev extends string}${First}${infer Rest2 extends string}`?_AreAnagrams<Rest1,`${Prev}${Rest2}`>:false:never;
 /** -------------------------------------------------------
- * * ***AreAnagrams.***
+ * * ***Utility Type: `AreAnagrams`.***
  * -------------------------------------------------------
- * Determines whether two string literal types are ***anagrams*** of each other.
- * - Returns `true` if both strings contain exactly the same characters in any order.
- * - Returns `false` otherwise.
- *
+ * **Determines whether two string literal types are ***anagrams*** of each other.**
+ * - **Behavior:**
+ *    - Returns `true` if both strings contain exactly the same characters in
+ *      any order.
+ *    - Returns `false` otherwise.
  * @template Str1 - The first string literal.
  * @template Str2 - The second string literal.
  * @example
@@ -22,15 +25,12 @@ import{A as And,I as IsStringLiteral,P as ParseNumber,a as IsNegative,N as Negat
  */
 type AreAnagrams<Str1 extends string,Str2 extends string>=And<IsStringLiteral<Str1>,IsStringLiteral<Str2>>extends true?_AreAnagrams<Str1,Str2>:false;
 /** --------------------------------------------------
- * * ***ArgumentTypes.***
+ * * ***Utility Type: `ArgumentTypes`.***
  * --------------------------------------------------
- * Extracts the **argument types** of a given function type `F`.
- *
- * ✅ Useful when you need to infer or reuse the parameter types
+ * **Extracts the **argument types** of a given function type `F`.**
+ * - ✅ Useful when you need to infer or reuse the parameter types
  *    from an existing function signature.
- *
  * @template F - A function type from which to extract argument types.
- *
  * @example
  * ```ts
  * type Args = ArgumentTypes<(a: number, b: string) => void>;
@@ -39,12 +39,12 @@ type AreAnagrams<Str1 extends string,Str2 extends string>=And<IsStringLiteral<St
  */
 type ArgumentTypes<F extends AnyFunction>=F extends(...args:infer A)=>any?A:never;
 /** -------------------------------------------------------
- * * ***ArrayElementType.***
+ * * ***Utility Type: `ArrayElementType`.***
  * -------------------------------------------------------
- * A type-level utility that extracts the element type of an array.
- * - Works with both mutable and readonly arrays.
- * - If `T` is not an array, resolves to `never`.
- *
+ * **A type-level utility that extracts the element type of an array.**
+ * - **Behavior:**
+ *    - Works with both mutable and readonly arrays.
+ *    - If `T` is not an array, resolves to `never`.
  * @template T - The array type to extract the element type from.
  * @example
  * ```ts
@@ -56,15 +56,19 @@ type ArgumentTypes<F extends AnyFunction>=F extends(...args:infer A)=>any?A:neve
  * // ➔ never
  * ```
  */
-type ArrayElementType<T extends readonly unknown[]>=T extends Readonly<Array<infer Item>>?Item:never;type LastCharacterOptions={includeRest:boolean;};type _LastCharacter<T extends string,Options extends LastCharacterOptions={includeRest:false;},Previous extends string="">=string extends T?string:T extends`${infer First}${infer Rest}`?IsEmptyString<Rest>extends true?If<Options["includeRest"],[First,Previous],First>:_LastCharacter<Rest,Options,`${Previous}${First}`>:T;
+type ArrayElementType<T extends readonly unknown[]>=T extends Readonly<Array<infer Item>>?Item:never;
+/** ---------------------------------------------------------------------------
+ * * ***Type Options for {@link LastCharacter | `LastCharacter`}.***
+ * ---------------------------------------------------------------------------
+ */
+type LastCharacterOptions={includeRest:boolean;};type _LastCharacter<T extends string,Options extends LastCharacterOptions={includeRest:false;},Previous extends string="">=string extends T?string:T extends`${infer First}${infer Rest}`?IsEmptyString<Rest>extends true?If<Options["includeRest"],[First,Previous],First>:_LastCharacter<Rest,Options,`${Previous}${First}`>:T;
 /** -------------------------------------------------------
- * * ***LastCharacter.***
+ * * ***Utility Type: `LastCharacter`.***
  * -------------------------------------------------------
- * Accepts a string argument and returns its last character.
+ * **Accepts a string argument and returns its last character.**
  * - If the `includeRest` option is `true`, returns the last character and the rest of the string in the format: `[last, rest]`.
- *
- * @template T - The string to get the last character from
- * @template Options - Options to include the rest of the string
+ * @template T - The string to get the last character from.
+ * @template Options - Options to include the rest of the string.
  * @example
  * type Case1 = LastCharacter<'abc'>;
  * // ➔ 'c'
@@ -73,21 +77,18 @@ type ArrayElementType<T extends readonly unknown[]>=T extends Readonly<Array<inf
  */
 type LastCharacter<T extends string,Options extends LastCharacterOptions={includeRest:false;}>=IfExtends<Options,LastCharacterOptions,_LastCharacter<T,Options>,_LastCharacter<T>>;
 /** -------------------------------------------------------
- * * ***Stringify.***
- * -------------------------------------------------------
- * Converts a value of type `number`, `boolean`, `string`, `bigint`, `undefined`, or `null` into a string literal type.
- *
- * Behavior:
- * - `number` → string representation (e.g., `123` → `"123"`)
- * - `boolean` → `"true"` or `"false"`
- * - `string` → itself
- * - `bigint` → string representation with `"n"` suffix (e.g., `123n` → `"123n"`)
- * - `undefined` → `"undefined"`
- * - `null` → `"null"`
- * - Other types → `never`
- *
+ * * ***Utility Type: `Stringify`.***
+ * -------------------------------------------------------
+ * **Converts a value of type `number`, `boolean`, `string`, `bigint`, `undefined`, or `null` into a string literal type.**
+ * - **Behavior:**
+ *    - `number` ➔ string representation (e.g., `123` ➔ `"123"`)
+ *    - `boolean` ➔ `"true"` or `"false"`
+ *    - `string` ➔ itself
+ *    - `bigint` ➔ string representation with `"n"` suffix (e.g., `123n` ➔ `"123n"`)
+ *    - `undefined` ➔ `"undefined"`
+ *    - `null` ➔ `"null"`
+ *    - Other types ➔ `never`
  * @template T - The value type to stringify.
- *
  * @example
  * ```ts
  * // Boolean
@@ -121,22 +122,17 @@ type LastCharacter<T extends string,Options extends LastCharacterOptions={includ
  */
 type Stringify<T>=T extends number|boolean|string|bigint|undefined|null?T extends bigint?`${T}n`:`${T}`:never;type DecrementMap=[-1,0,1,2,3,4,5,6,7,8];type NegativeCarryMap={"-1":9;};
 /** -------------------------------------------------------
- * * ***_Decrement (Internal / Deprecated)***
+ * * ***Internal Utility Type: `_Decrement (Internal / Deprecated)`***
  * -------------------------------------------------------
- *
- * Internal type-level utility to decrement a numeric string by 1.
- *
- * **⚠️ Deprecated:** Do **not** use this directly.
- * Use the public {@link Decrement} type instead.
- *
+ * **Internal type-level utility to decrement a numeric string by 1.**
+ * - **⚠️ Deprecated:**
+ *    - Do **not** use this directly.
+ *    - Use the public {@link Decrement | **`Decrement`**} type instead.
  * - Processes the string recursively digit by digit.
  * - Handles borrow/carry using internal `DecrementMap` and `NegativeCarryMap`.
- *
  * @template Number - The numeric string to decrement.
  * @template Result - (Internal) Accumulator used during recursion.
- *
- * @deprecated Use {@link Decrement} instead.
- *
+ * @deprecated Use {@link Decrement | **`Decrement`**} instead.
  * @example
  * ```ts
  * // ❌ Avoid using _Decrement directly
@@ -148,11 +144,10 @@ type Stringify<T>=T extends number|boolean|string|bigint|undefined|null?T extend
  */
 type _Decrement<Number extends string,Result extends string="">=Number extends""?ParseNumber<Result>:ParseNumber<LastCharacter<Number>>extends infer LastDigit extends number?DecrementMap[LastDigit] extends infer Decremented extends number?Number extends`${infer Rest}${LastDigit}`?`${Decremented}`extends keyof NegativeCarryMap?_Decrement<Rest,`${NegativeCarryMap[`${Decremented}`]}${Result}`>:`${Rest}${Decremented}${Result}`extends infer FinalResult extends string?ParseNumber<FinalResult extends`0${infer FinalResultWithoutLeadingZero extends string}`?FinalResultWithoutLeadingZero extends""?FinalResult:FinalResultWithoutLeadingZero:FinalResult>:never:never:never:never;type _DecrementNegativeOrZero<T extends number>=_Increment<Stringify<T>>extends infer PositiveDecrementResult extends number?PositiveDecrementResult extends 0?PositiveDecrementResult:Negate<PositiveDecrementResult>:never;
 /** -------------------------------------------------------
- * * ***Decrement.***
+ * * ***Utility Type: `Decrement`.***
  * --------------------------------------------------------
- * A type-level utility that returns the decremented value of an integer.
- * Works for numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * **A type-level utility that returns the decremented value of an integer.**
+ * - Works for numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template T - The number type to decrement.
  * @example
  * ```ts
@@ -165,22 +160,17 @@ type _Decrement<Number extends string,Result extends string="">=Number extends""
  */
 type Decrement<T extends number>=IsNegative<T>extends true?_DecrementNegativeOrZero<Abs<T>>:T extends 0?_DecrementNegativeOrZero<T>:_Decrement<Stringify<T>>;type IncrementMap=[1,2,3,4,5,6,7,8,9,10];type LastDigitMap={10:0;};
 /** -------------------------------------------------------
- * * ***_Increment (Internal / Deprecated)***
+ * * ***Internal Utility Type: `_Increment (Internal / Deprecated)`***
  * -------------------------------------------------------
- *
- * Internal type-level utility to increment a numeric string by 1.
- *
- * **⚠️ Deprecated:** Do **not** use this directly.
- * Use the public {@link Increment} type instead.
- *
+ * **Internal type-level utility to increment a numeric string by 1.**
+ * - **⚠️ Deprecated:**
+ *    - Do **not** use this directly.
+ *    - Use the public {@link Increment | **`Increment`**} type instead.
  * - Processes the string recursively digit by digit.
  * - Handles carry-over using internal `IncrementMap` and `LastDigitMap`.
- *
  * @template Number - The numeric string to increment.
  * @template Result - (Internal) Accumulator used during recursion.
- *
- * @deprecated Use {@link Increment} instead.
- *
+ * @deprecated Use {@link Increment | **`Increment`**} instead.
  * @example
  * ```ts
  * // ❌ Avoid using _Increment directly
@@ -192,49 +182,48 @@ type Decrement<T extends number>=IsNegative<T>extends true?_DecrementNegativeOrZ
  */
 type _Increment<Number extends string,Result extends string="">=IsEmptyString<Number>extends true?ParseNumber<`1${Result}`>:LastCharacter<Number>extends`${infer LastDigit extends number}`?IncrementMap[LastDigit] extends infer Incremented extends number?Number extends`${infer Rest}${LastDigit}`?Incremented extends keyof LastDigitMap?_Increment<Rest,`${LastDigitMap[Incremented]}${Result}`>:ParseNumber<`${Rest}${Incremented}${Result}`>:never:never:never;
 /** -------------------------------------------------------
- * * ***Increment.***
+ * * ***Utility Type: `Increment`.***
  * -------------------------------------------------------
- * Accepts an integer and returns the incremented value of it. Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`
- *
+ * **Accepts an integer and returns the incremented value of it.**
+ * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`
  * @template T - The input number to increment.
  * @example
  * ```ts
- * type Case1 = Increment<1>;  // ➔ 2
+ * type Case1 = Increment<1>; // ➔ 2
  * type Case2 = Increment<-10>; // ➔ -9
  * ```
  */
 type Increment<T extends number>=IsNegative<T>extends true?_Decrement<Stringify<Abs<T>>>extends infer NegativeIncrementResult extends number?NegativeIncrementResult extends 0?NegativeIncrementResult:Negate<NegativeIncrementResult>:never:_Increment<Stringify<T>>;
 /** -------------------------------------------------------
- * * ***GetFloatNumberParts.***
+ * * ***Utility Type: `GetFloatNumberParts`.***
  * -------------------------------------------------------
- * Returns a tuple of the **whole** and **fraction** parts of a float number `T`.
- *
- * - Only works for **float numbers** (i.e., numbers with a fractional part).
- *   If `T` is not a float, the result is `never`.
- * - Preserves the sign on the whole part (e.g. `-12.25` → `[-12, 25]`).
- * - For values like `-0.x`, TypeScript normalizes `-0` to `0`,
- *   so the result will be `[0, ...]`.
- *
+ * **Returns a tuple of the **whole** and **fraction** parts of a float number `T`.**
+ * - **Behavior:**
+ *    - Only works for **float numbers** (i.e., numbers with a fractional part):
+ *      - If `T` is not a float, the result is `never`.
+ *    - Preserves the sign on the whole part (e.g. `-12.25` ➔ `[-12, 25]`).
+ *    - For values like `-0.x`, the TypeScript will normalizes `-0` to `0`,
+ *      so the result will be `[0, ...]`.
  * @template T - A float number type.
  * @example
  * ```ts
- * type A = GetFloatNumberParts<12.25>;   // ➔ [12, 25]
- * type B = GetFloatNumberParts<-12.25>;  // ➔ [-12, 25]
- * type C = GetFloatNumberParts<3.1415>;  // ➔ [3, 1415]
- * type D = GetFloatNumberParts<-0.75>;   // ➔ [0, 75]   // (-0) normalized to 0
- * type E = GetFloatNumberParts<42>;      // ➔ never     // not a float
+ * type A = GetFloatNumberParts<12.25>;  // ➔ [12, 25]
+ * type B = GetFloatNumberParts<-12.25>; // ➔ [-12, 25]
+ * type C = GetFloatNumberParts<3.1415>; // ➔ [3, 1415]
+ * type D = GetFloatNumberParts<-0.75>;  // ➔ [0, 75] (`-0` normalized to `0`)
+ * type E = GetFloatNumberParts<42>;     // ➔ never (not a float)
  * ```
  */
 type GetFloatNumberParts<T extends number>=IsFloat<T>extends true?`${T}`extends`${infer Whole extends number}.${infer Fraction extends number}`?[IsNegative<T>extends true?Whole:Whole,Fraction]:never:never;
 /** -------------------------------------------------------
- * * ***Ceil.***
+ * * ***Utility Type: `Ceil`.***
  * -------------------------------------------------------
- * A type-level utility that computes the **mathematical ceiling**
- * of a numeric literal type `T`, type version of `Math.ceil()`.
- * - If `T` is an integer, it returns `T` unchanged.
- * - If `T` is a positive float, it rounds up to the nearest integer.
- * - If `T` is a negative float, it rounds up toward zero.
- *
+ * **A type-level utility that computes the **mathematical ceiling**
+ * of a numeric literal type `T`, type version of `Math.ceil()`.**
+ * - **Behavior:**
+ *    - If `T` is an integer, it returns `T` unchanged.
+ *    - If `T` is a positive float, it rounds up to the nearest integer.
+ *    - If `T` is a negative float, it rounds up toward zero.
  * @template T - A number literal type.
  * @example
  * ```ts
@@ -248,41 +237,37 @@ type GetFloatNumberParts<T extends number>=IsFloat<T>extends true?`${T}`extends`
  */
 type Ceil<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extends [infer Whole extends number,unknown]?IsNegative<T>extends true?Negate<Whole>:Increment<Whole>:never:T;
 /** -------------------------------------------------------
- * * ***ColorCssNamed.***
+ * * ***Utility Type: `ColorCssNamed`.***
  * -------------------------------------------------------
- *
- * Represents a **named CSS color keyword**, including `transparent`.
- *
+ * **Represents a **named CSS color keyword**, including `transparent`.**
+ * @description
  * This type includes all standard color names defined in the CSS Color Module Level 4
  * specification, and ensures type safety for string values in strongly typed UI libraries,
  * themes, or design systems.
- *
- * Only recognized, browser-supported named colors are allowed.
- *
+ * - **Behavior:**
+ *    - Only recognized, browser-supported named colors are allowed.
  * @see https://developer.mozilla.org/en-US/docs/Web/CSS/named-color
  * @see https://drafts.csswg.org/css-color-4/#named-colors
- *
  * @example
  * ```ts
- * const textColor1: ColorCssNamed = "rebeccapurple"; // ✅ valid
- * const textColor2: ColorCssNamed = "navy";          // ✅ valid
- * const textColor3: ColorCssNamed = "superblue";     // ❌ Type error
+ * const textColor1: ColorCssNamed = "rebeccapurple"; // ➔ ✅ valid
+ * const textColor2: ColorCssNamed = "navy";          // ➔ ✅ valid
+ * const textColor3: ColorCssNamed = "superblue";     // ➔ ❌ Type error
  *
  * // Usage in a theme object
- * const theme = {
- *   primary: "blue" as ColorCssNamed,
- *   secondary: "goldenrod" as ColorCssNamed,
- *   highlight: "transparent" as ColorCssNamed,
+ * const theme: Record<string, ColorCssNamed> = {
+ *   primary: "blue",
+ *   secondary: "goldenrod",
+ *   highlight: "transparent",
  * };
  * ```
  */
 type ColorCssNamed="aliceblue"|"antiquewhite"|"aqua"|"aquamarine"|"azure"|"beige"|"bisque"|"black"|"blanchedalmond"|"blue"|"blueviolet"|"brown"|"burlywood"|"cadetblue"|"chartreuse"|"chocolate"|"coral"|"cornflowerblue"|"cornsilk"|"crimson"|"cyan"|"darkblue"|"darkcyan"|"darkgoldenrod"|"darkgray"|"darkgreen"|"darkgrey"|"darkkhaki"|"darkmagenta"|"darkolivegreen"|"darkorange"|"darkorchid"|"darkred"|"darksalmon"|"darkseagreen"|"darkslateblue"|"darkslategray"|"darkslategrey"|"darkturquoise"|"darkviolet"|"deeppink"|"deepskyblue"|"dimgray"|"dimgrey"|"dodgerblue"|"firebrick"|"floralwhite"|"forestgreen"|"fuchsia"|"gainsboro"|"ghostwhite"|"gold"|"goldenrod"|"gray"|"green"|"greenyellow"|"grey"|"honeydew"|"hotpink"|"indianred"|"indigo"|"ivory"|"khaki"|"lavender"|"lavenderblush"|"lawngreen"|"lemonchiffon"|"lightblue"|"lightcoral"|"lightcyan"|"lightgoldenrodyellow"|"lightgray"|"lightgreen"|"lightgrey"|"lightpink"|"lightsalmon"|"lightseagreen"|"lightskyblue"|"lightslategray"|"lightslategrey"|"lightsteelblue"|"lightyellow"|"lime"|"limegreen"|"linen"|"magenta"|"maroon"|"mediumaquamarine"|"mediumblue"|"mediumorchid"|"mediumpurple"|"mediumseagreen"|"mediumslateblue"|"mediumspringgreen"|"mediumturquoise"|"mediumvioletred"|"midnightblue"|"mintcream"|"mistyrose"|"moccasin"|"navajowhite"|"navy"|"oldlace"|"olive"|"olivedrab"|"orange"|"orangered"|"orchid"|"palegoldenrod"|"palegreen"|"paleturquoise"|"palevioletred"|"papayawhip"|"peachpuff"|"peru"|"pink"|"plum"|"powderblue"|"purple"|"rebeccapurple"|"red"|"rosybrown"|"royalblue"|"saddlebrown"|"salmon"|"sandybrown"|"seagreen"|"seashell"|"sienna"|"silver"|"skyblue"|"slateblue"|"slategray"|"slategrey"|"snow"|"springgreen"|"steelblue"|"tan"|"teal"|"thistle"|"tomato"|"transparent"|"turquoise"|"violet"|"wheat"|"white"|"whitesmoke"|"yellow"|"yellowgreen";
 /** -------------------------------------------------------
- * * ***IsEqual.***
+ * * ***Utility Type: `IsEqual`.***
  * -------------------------------------------------------
- * A type-level utility that returns a boolean indicating
- * whether the two types are ***equal***.
- *
+ * **A type-level utility that returns a boolean indicating
+ * whether the two types are ***equal***.**
  * @template T - The first type to compare.
  * @template U - The second type to compare.
  * @example
@@ -299,11 +284,10 @@ type ColorCssNamed="aliceblue"|"antiquewhite"|"aqua"|"aquamarine"|"azure"|"beige
  */
 type IsEqual<T,U>=(<F>()=>F extends T?1:2)extends<F>()=>F extends U?1:2?true:false;
 /** -------------------------------------------------------
- * * ***IsNotEqual.***
+ * * ***Utility Type: `IsNotEqual`.***
  * -------------------------------------------------------
- * A type-level utility that returns a boolean indicating
- * whether the two types are ***not equal***.
- *
+ * **A type-level utility that returns a boolean indicating
+ * whether the two types are ***not equal***.**
  * @template T - The first type to compare.
  * @template U - The second type to compare.
  * @example
@@ -316,11 +300,11 @@ type IsEqual<T,U>=(<F>()=>F extends T?1:2)extends<F>()=>F extends U?1:2?true:fal
  */
 type IsNotEqual<T,U>=Not<IsEqual<T,U>>;
 /** -------------------------------------------------------
- * * ***IfEqual.***
+ * * ***Utility Type: `IfEqual`.***
  * -------------------------------------------------------
- * Conditional: selects one of two branches depending on whether `T` and `U` are ***equal***.
+ * - **Conditional:**
+ *    - Selects one of two branches depending on whether `T` and `U` are ***equal***.
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - The first type to compare.
  * @template U - The second type to compare.
  * @template IfTrue - The branch type if condition is met. (default: `true`)
@@ -333,11 +317,11 @@ type IsNotEqual<T,U>=Not<IsEqual<T,U>>;
  */
 type IfEqual<T,U,IfTrue=true,IfFalse=false>=If<IsEqual<T,U>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfNotEqual.***
+ * * ***Utility Type: `IfNotEqual`.***
  * -------------------------------------------------------
- * Conditional: selects one of two branches depending on whether `T` and `U` are ***not equal***.
+ * - **Conditional:**
+ *    - Selects one of two branches depending on whether `T` and `U` are ***not equal***.
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - The first type to compare.
  * @template U - The second type to compare.
  * @template IfTrue - The branch type if condition is met. (default: `true`)
@@ -352,14 +336,13 @@ type IfEqual<T,U,IfTrue=true,IfFalse=false>=If<IsEqual<T,U>,IfTrue,IfFalse>;
  */
 type IfNotEqual<T,U,IfTrue=true,IfFalse=false>=If<IsNotEqual<T,U>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IsExactly.***
+ * * ***Utility Type: `IsExactly`.***
  * -------------------------------------------------------
- * A strict equality check between two types `A` and `B`
- * that does **not** collapse when one of them is `any`.
- *
- * - Returns `true` only if `A` and `B` are **mutually assignable**.
- * - Returns `false` if either `A` or `B` is `any`.
- *
+ * **A strict equality check between two types `A` and `B`
+ * that does **not** collapse when one of them is `any`.**
+ * - **Behavior:**
+ *    - Returns `true` only if `A` and `B` are **mutually assignable**.
+ *    - Returns `false` if either `A` or `B` is `any`.
  * @template A - The first type to compare.
  * @template B - The second type to compare.
  * @example
@@ -368,18 +351,18 @@ type IfNotEqual<T,U,IfTrue=true,IfFalse=false>=If<IsNotEqual<T,U>,IfTrue,IfFalse
  * type B = IsExactly<string, any>;    // ➔ false
  * type C = IsExactly<42, number>;     // ➔ false
  * type D = IsExactly<never, never>;   // ➔ true
+ * type E = IsExactly<any, any>;       // ➔ false
  * ```
  */
 type IsExactly<A,B>=IsAny<A>extends true?false:IsAny<B>extends true?false:(<T>()=>T extends A?1:2)extends<T>()=>T extends B?1:2?(<T>()=>T extends B?1:2)extends<T>()=>T extends A?1:2?true:false:false;
 /** -------------------------------------------------------
- * * ***IsGeneralArray.***
+ * * ***Utility Type: `IsGeneralArray`.***
  * -------------------------------------------------------
- * Checks if `T` is a **general array type** (`X[]` or `ReadonlyArray<X>`)
- * instead of a tuple literal.
- *
- * - Returns `true` for `string[]`, `(number | boolean)[]`, `any[]`, etc.
- * - Returns `false` for tuples like `[]`, `[1, 2, 3]`, or `[string, number]`.
- *
+ * **Checks if `T` is a **general array type** (`X[]` or `ReadonlyArray<X>`)
+ * instead of a tuple literal.**
+ * - **Behavior:**
+ *    - Returns `true` for `string[]`, `(number | boolean)[]`, `any[]`, etc.
+ *    - Returns `false` for tuples like `[]`, `[1, 2, 3]`, or `[string, number]`.
  * @template T - The type to check.
  * @example
  * ```ts
@@ -391,28 +374,26 @@ type IsExactly<A,B>=IsAny<A>extends true?false:IsAny<B>extends true?false:(<T>()
  */
 type IsGeneralArray<T>=T extends readonly unknown[]?number extends T["length"]?true:false:false;
 /** -------------------------------------------------------
- * * ***IsBaseType.***
- * -------------------------------------------------------
- * Determines whether a type `T` is considered a **base / keyword / built-in type**
- * rather than a literal, tuple, or specific instance.
- *
- * ✅ Considered base types:
- * - Special keywords: `any`, `unknown`, `never`, `null`, `undefined`, `void`
- * - Primitive keywords: `string`, `number`, `boolean`, `bigint`, `symbol`
- * - Function keyword `Function` and alias `AnyFunction`
- * - General arrays (`X[]`, `ReadonlyArray<X>`) and `TypedArray`
- * - Common built-ins: `Date`, `RegExp`, `Error`
- * - Generic containers: `Promise<any>`, `Map<any,any>`, `WeakMap<object,any>`, `Set<any>`, `WeakSet<object>`
- * - Buffers & views: `ArrayBuffer`, `SharedArrayBuffer`, `DataView`
- * - `object` keyword and `{}` (empty object type)
- *
- * ❌ Not considered base types:
- * - Literal values (`"foo"`, `123`, `true`)
- * - Union literals (`"a" | "b"`)
- * - Tuples (`[1, 2, 3]`, `[]`)
- * - Specific object shapes (`{ a: 1 }`, `{ x: string }`)
- * - Functions with explicit structure (`() => {}`, `(x: number) => string`)
- *
+ * * ***Utility Type: `IsBaseType`.***
+ * -------------------------------------------------------
+ * **Determines whether a type `T` is considered a **base / keyword / built-in type**
+ * rather than a literal, tuple, or specific instance.**
+ * - **Behavior:**
+ *    - ***✅ Considered base types:***
+ *        - Special keywords: `any`, `unknown`, `never`, `null`, `undefined`, `void`
+ *        - Primitive keywords: `string`, `number`, `boolean`, `bigint`, `symbol`
+ *        - Function keyword `Function` and alias `AnyFunction`
+ *        - General arrays (`X[]`, `ReadonlyArray<X>`) and `TypedArray`
+ *        - Common built-ins: `Date`, `RegExp`, `Error`
+ *        - Generic containers: `Promise<any>`, `Map<any,any>`, `WeakMap<object,any>`, `Set<any>`, `WeakSet<object>`
+ *        - Buffers & views: `ArrayBuffer`, `SharedArrayBuffer`, `DataView`
+ *        - `object` keyword and `{}` (empty object type)
+ *    - ***❌ Not considered base types:***
+ *        - Literal values (`"foo"`, `123`, `true`)
+ *        - Union literals (`"a" | "b"`)
+ *        - Tuples (`[1, 2, 3]`, `[]`)
+ *        - Specific object shapes (`{ a: 1 }`, `{ x: string }`)
+ *        - Functions with explicit structure (`() => {}`, `(x: number) => string`)
  * @template T - The type to evaluate.
  * @example
  * ```ts
@@ -460,20 +441,16 @@ type IsBaseType<T>=IsAny<T>extends true?true:IsUnknown<T>extends true?true:IsNev
  */
 type Includes$1<S extends string,Sub extends string>=S extends`${infer _}${Sub}${infer _}`?true:false;
 /** -------------------------------------------------------
- * * ***ReplaceAll.***
+ * * ***Utility Type: `ReplaceAll`.***
  * -------------------------------------------------------
- * A **type-level utility** that replaces all occurrences of a given string (or array of strings)
- * `Pivot` in a string `T` with `ReplaceBy`.
- *
- * - Supports:
- *   - Replacing a single substring
- *   - Replacing multiple substrings (Pivot as array)
- *   - Guards against infinite recursion if `ReplaceBy` contains any value in Pivot
- *
+ * **A **type-level utility** that replaces all occurrences of a given string (or array of strings) `Pivot` in a string `T` with `ReplaceBy`.**
+ * - **Supports:**
+ *    - Replacing a single substring.
+ *    - Replacing multiple substrings (Pivot as array).
+ *    - Guards against infinite recursion if `ReplaceBy` contains any value in Pivot.
  * @template T - The string to process.
  * @template Pivot - A string or readonly array of strings to replace.
  * @template ReplaceBy - The string to replace Pivot with.
- *
  * @example
  * ```ts
  * // Single pivot string
@@ -492,17 +469,15 @@ type Includes$1<S extends string,Sub extends string>=S extends`${infer _}${Sub}$
  * type Case4 = ReplaceAll<'abc', 'a', 'a'>;
  * // ➔ string
  * ```
- *
  * @remarks
  * - Works recursively to replace all instances.
  * - If Pivot is empty (`""`) or empty array (`[]`), returns `T` unchanged.
  */
 type ReplaceAll<T extends string,Pivot extends string|readonly string[],ReplaceBy extends string>=Pivot extends""|[]?T:Includes$1<ReplaceBy,Pivot extends string?Pivot:never>extends true?string:Pivot extends readonly [infer First extends string,...infer Rest extends string[]]?ReplaceAll<ReplaceAll<T,First,ReplaceBy>,Rest,ReplaceBy>:Pivot extends string?T extends`${infer A}${Pivot}${infer B}`?ReplaceAll<`${A}${ReplaceBy}${B}`,Pivot,ReplaceBy>:T:T;
 /** -------------------------------------------------------
- * * ***IsTuple.***
+ * * ***Utility Type: `IsTuple`.***
  * -------------------------------------------------------
- * Returns a boolean whether the first array argument is fixed length tuple.
- *
+ * **Returns a boolean whether the first array argument is fixed length tuple.**
  * @template T - The array to check.
  * @example
  * type Case1 = IsTuple<[1, 2, 3]>; // ➔ true
@@ -510,13 +485,14 @@ type ReplaceAll<T extends string,Pivot extends string|readonly string[],ReplaceB
  */
 type IsTuple<T extends readonly unknown[]>=NotExtends<number,T["length"]>;
 /** -------------------------------------------------------
- * * ***IfTuple.***
+ * * ***Utility Type: `IfTuple`.***
  * -------------------------------------------------------
- * Returns the second argument if the first array argument is fixed length tuple (defaults to `true`), otherwise returns the third argument (defaults to `false`).
- *
+ * **Returns the second argument if the first array argument is fixed length
+ * tuple (defaults to `true`), otherwise returns the third argument (defaults
+ * to `false`).**
  * @template T - The array to check.
- * @template IfTrue - The branch type if condition is met. (default: `true`)
- * @template IfFalse - The branch type if condition is not met. (default: `false`)
+ * @template IfTrue - The branch type if condition is met. (default: `true`).
+ * @template IfFalse - The branch type if condition is not met. (default: `false`).
  * @example
  * type Case1 = IfTuple<[1, 2, 3], 'valid'>;
  * // ➔ 'valid'
@@ -525,44 +501,35 @@ type IsTuple<T extends readonly unknown[]>=NotExtends<number,T["length"]>;
  */
 type IfTuple<T extends readonly unknown[],IfTrue=true,IfFalse=false>=If<IsTuple<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***RemoveLeading.***
+ * * ***Utility Type: `RemoveLeading`.***
  * -------------------------------------------------------
- *
- * Accepts a string type `T` and **recursively removes leading characters**
- * specified in `Characters`.
- *
+ * **Accepts a string type `T` and **recursively removes leading characters**
+ * specified in `Characters`.**
  * @template T - The string to process.
  * @template Characters - The characters to remove from the start.
- *
  * @example
  * ```ts
  * type Case1 = RemoveLeading<'aaabc', 'a'>;
  * // ➔ 'bc' (all leading 'a' removed).
- *
  * type Case2 = RemoveLeading<'abc', 'd'>;
  * // ➔ 'abc' (no 'd' at start, unchanged).
- *
  * type Case3 = RemoveLeading<'aaa', 'a'>;
  * // ➔ '' (all 'a' removed).
- *
  * type Case4 = RemoveLeading<'aaa', 'aa'>;
  * // ➔ 'a' (matches 'aa' once, then remaining 'a').
  * ```
  */
 type RemoveLeading<T extends string,Characters extends string>=T extends`${Characters}${infer Rest extends string}`?IsEmptyString<Rest>extends true?Rest:RemoveLeading<Rest,Characters>:T;type SubDecrementMap={"-9":-10;"-8":-9;"-7":-8;"-6":-7;"-5":-6;"-4":-5;"-3":-4;"-2":-3;"-1":-2;"0":-1;"1":0;"2":1;"3":2;"4":3;"5":4;"6":5;"7":6;"8":7;"9":8;};type SubNegativeCarryMap={"-10":0;"-9":1;"-8":2;"-7":3;"-6":4;"-5":5;"-4":6;"-3":7;"-2":8;"-1":9;};type SubMap={0:[0,-1,-2,-3,-4,-5,-6,-7,-8,-9];1:[1,0,-1,-2,-3,-4,-5,-6,-7,-8];2:[2,1,0,-1,-2,-3,-4,-5,-6,-7];3:[3,2,1,0,-1,-2,-3,-4,-5,-6];4:[4,3,2,1,0,-1,-2,-3,-4,-5];5:[5,4,3,2,1,0,-1,-2,-3,-4];6:[6,5,4,3,2,1,0,-1,-2,-3];7:[7,6,5,4,3,2,1,0,-1,-2];8:[8,7,6,5,4,3,2,1,0,-1];9:[9,8,7,6,5,4,3,2,1,0];};type _RemoveLeadingZeros<T extends string>=ParseNumber<RemoveLeading<T,"0">extends infer WithoutLeadingZeros extends string?IfEmptyString<WithoutLeadingZeros,"0",WithoutLeadingZeros>:never>;type _Sub<Num1 extends string,Num2 extends string,NegativeCarry extends 0|1=0,Result extends string="">=IsEmptyString<Num2>extends true?NegativeCarry extends 0?`${Num1}${Result}`:`${Decrement<ParseNumber<Num1>>}${Result}`:LastCharacter<Num1>extends`${infer Num1LastDigit extends keyof SubMap & number}`?LastCharacter<Num2>extends`${infer Num2LastDigit extends keyof SubMap[Num1LastDigit] & number}`?`${SubMap[Num1LastDigit][Num2LastDigit]}`extends infer DigitsSub extends keyof SubDecrementMap?(NegativeCarry extends 1?Stringify<SubDecrementMap[DigitsSub]>:DigitsSub)extends infer DigitsSubWithCarry extends string?Num1 extends`${infer Num1Rest}${Num1LastDigit}`?Num2 extends`${infer Num2Rest}${Num2LastDigit}`?DigitsSubWithCarry extends keyof SubNegativeCarryMap?_Sub<Num1Rest,Num2Rest,1,`${SubNegativeCarryMap[DigitsSubWithCarry]}${Result}`>:_Sub<Num1Rest,Num2Rest,0,`${DigitsSubWithCarry}${Result}`>:never:never:never:never:never:never;
 /** -------------------------------------------------------
- * * ***Sub.***
+ * * ***Utility Type: `Sub`.***
  * -------------------------------------------------------
- * Computes the subtraction of two integers at the **type level**.
- *
- * Behavior:
- * - Handles positive and negative numbers.
- * - Supports numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * - Internally performs string-based arithmetic to handle carries/borrows.
- *
+ * **Computes the subtraction of two integers at the **type level**.**
+ * - **Behavior:**
+ *    - Handles positive and negative numbers.
+ *    - Supports numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
+ *    - Internally performs string-based arithmetic to handle carries/borrows.
  * @template Num1 - First number (minuend).
  * @template Num2 - Second number (subtrahend).
- *
  * @example
  * ```ts
  * // Positive numbers
@@ -584,12 +551,11 @@ type RemoveLeading<T extends string,Characters extends string>=T extends`${Chara
  */
 type Sub<Num1 extends number,Num2 extends number>=IsNegativeInteger<Num1>extends true?IsNegativeInteger<Num2>extends true?IsLowerThan<Num1,Num2>extends true?Negate<_RemoveLeadingZeros<_Sub<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>>:_RemoveLeadingZeros<_Sub<Stringify<Abs<Num2>>,Stringify<Abs<Num1>>>>:Sum<Abs<Num1>,Num2>extends infer Result extends number?Negate<Result>:never:IsNegativeInteger<Num2>extends true?Sum<Num1,Abs<Num2>>:IsLowerThan<Num1,Num2>extends true?Negate<_RemoveLeadingZeros<_Sub<Stringify<Num2>,Stringify<Num1>>>>:_RemoveLeadingZeros<_Sub<Stringify<Num1>,Stringify<Num2>>>;type SumIncrementMap=[ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19];type SumLastDigitMap={10:0;11:1;12:2;13:3;14:4;15:5;16:6;17:7;18:8;19:9;};type SumMap={0:[0,1,2,3,4,5,6,7,8,9];1:[1,2,3,4,5,6,7,8,9,10];2:[2,3,4,5,6,7,8,9,10,11];3:[3,4,5,6,7,8,9,10,11,12];4:[4,5,6,7,8,9,10,11,12,13];5:[5,6,7,8,9,10,11,12,13,14];6:[6,7,8,9,10,11,12,13,14,15];7:[7,8,9,10,11,12,13,14,15,16];8:[8,9,10,11,12,13,14,15,16,17];9:[9,10,11,12,13,14,15,16,17,18];};
 /** -------------------------------------------------------
- * * ***_Sum.***
+ * * ***Private Utility Type: `_Sum`.***
  * -------------------------------------------------------
- * Internal helper type for summing two integer numbers represented as strings.
- * Performs digit-by-digit addition with carry handling.
- *
- * @deprecated This is internal helper, use `Sum` instead.
+ * **Internal helper type for summing two integer numbers represented as strings.**
+ * - Performs digit-by-digit addition with carry handling.
+ * @deprecated This is internal helper, use {@link Sum | **`Sum`**} instead.
  * @template Num1 - First number as string.
  * @template Num2 - Second number as string.
  * @template Carry - Carry flag (0 or 1), defaults to 0.
@@ -597,14 +563,13 @@ type Sub<Num1 extends number,Num2 extends number>=IsNegativeInteger<Num1>extends
  */
 type _Sum<Num1 extends string,Num2 extends string,Carry extends 0|1=0,Result extends string="">=IsEmptyString<Num1>extends true?Carry extends 0?ParseNumber<`${Num2}${Result}`>:_Increment<Num2,Result>:IsEmptyString<Num2>extends true?Carry extends 0?ParseNumber<`${Num1}${Result}`>:_Increment<Num1,Result>:LastCharacter<Num1>extends`${infer Num1LastDigit extends keyof SumMap & number}`?LastCharacter<Num2>extends`${infer Num2LastDigit extends keyof SumMap[Num1LastDigit] & number}`?SumMap[Num1LastDigit][Num2LastDigit] extends infer DigitsSum extends number?(Carry extends 1?SumIncrementMap[DigitsSum]:DigitsSum)extends infer DigitsSumWithCarry extends number?Num1 extends`${infer Num1Rest}${Num1LastDigit}`?Num2 extends`${infer Num2Rest}${Num2LastDigit}`?DigitsSumWithCarry extends keyof SumLastDigitMap?_Sum<Num1Rest,Num2Rest,1,`${SumLastDigitMap[DigitsSumWithCarry]}${Result}`>:_Sum<Num1Rest,Num2Rest,0,`${DigitsSumWithCarry}${Result}`>:never:never:never:never:never:never;
 /** -------------------------------------------------------
- * * ***Sum.***
+ * * ***Utility Type: `Sum`.***
  * -------------------------------------------------------
- * Adds two integers at the type level. Handles positive and negative numbers.
- * Supports numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * **Adds two integers at the type level. Handles positive and negative numbers.**
+ * - Supports numbers in the range:
+ *   - `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template Num1 - First number.
  * @template Num2 - Second number.
- *
  * @example
  * ```ts
  * // Positive + positive
@@ -624,16 +589,14 @@ type Sum<Num1 extends number,Num2 extends number>=IsNegativeInteger<Num1>extends
 /** @ts-expect-error this still safe not to much deep */
 _SumArr<Rest,Sum<CurrentSum,Num1>>;type _SumArr<T extends readonly number[],CurrentSum extends number=0>=IsEmptyArray<T>extends true?CurrentSum:Pop<T,{includeRemoved:true;}>extends infer PopResult?IsNever<PopResult>extends true?CurrentSum:PopResult extends [infer Rest extends number[],infer Num1 extends number]?_safeSumArr<Rest,CurrentSum,Num1>:never:CurrentSum;
 /** -------------------------------------------------------
- * * ***SumArr.***
+ * * ***Utility Type: `SumArr`.***
  * -------------------------------------------------------
- * Accepts a tuple of numbers and returns their sum.
- *
- * Behavior:
- * - Only works on tuple types (not general arrays).
- * - Supports numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * **Accepts a tuple of numbers and returns their sum.**
+ * - **Behavior:**
+ *    - Only works on tuple types (not general arrays).
+ *    - Supports numbers in the range:
+ *      -`[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template T - Tuple of numbers to sum.
- *
  * @example
  * ```ts
  * // Sum all elements in a tuple
@@ -647,13 +610,11 @@ type SumArr<T extends readonly number[]>=IsTuple<T>extends true?_SumArr<T>:never
 /** @ts-expect-error this still safe not to much deep */
 type _safeSum<Parts extends [string[],string[],string[],string[]]=[[],[],[],[]]>=Sum<Sum<Parts[0]["length"],Parts[1]["length"]>,Sum<Parts[2]["length"],Parts[3]["length"]>>;type _StringLength<S extends string,Parts extends [string[],string[],string[],string[]]=[[],[],[],[]]>=S extends""?_safeSum<Parts>:S extends`${infer C1 extends string}${infer Rest1 extends string}`?Rest1 extends`${infer C2 extends string}${infer Rest2 extends string}`?Rest2 extends`${infer C3 extends string}${infer Rest3 extends string}`?Rest3 extends`${infer C4 extends string}${infer Rest4 extends string}`?_StringLength<Rest4,[ [...Parts[0],C1],[...Parts[1],C2],[...Parts[2],C3],[...Parts[3],C4]]>:_StringLength<Rest3,[ [...Parts[0],C1],[...Parts[1],C2],[...Parts[2],C3],Parts[3]]>:_StringLength<Rest2,[[...Parts[0],C1],[...Parts[1],C2],Parts[2],Parts[3]]>:_StringLength<Rest1,[[...Parts[0],C1],Parts[1],Parts[2],Parts[3]]>:_StringLength<S,Parts>;
 /** -------------------------------------------------------
- * * ***StringLength.***
+ * * ***Utility Type: `StringLength`.***
  * -------------------------------------------------------
- * Returns the length of a string at the type level.
- * Supports string length in range `[0, 3968]`.
- *
+ * **Returns the length of a string at the type level.**
+ * - Supports string length in range `[0, 3968]`.
  * @template S - The string to measure.
- *
  * @example
  * ```ts
  * type Case1 = StringLength<''>;
@@ -664,21 +625,18 @@ type _safeSum<Parts extends [string[],string[],string[],string[]]=[[],[],[],[]]>
  */
 type StringLength<S extends string>=_StringLength<S>;
 /** -------------------------------------------------------
- * * ***CompareStringLength.***
+ * * ***Utility Type: `CompareStringLength`.***
  * -------------------------------------------------------
- * Compares the lengths of two strings and returns one of three possible type values:
- * - `IfStr1Shorter` if the first string is shorter.
- * - `IfStr2Shorter` if the second string is shorter.
- * - `IfEqual` if both strings have the same length.
- *
- * Defaults to `never` if not provided.
- *
+ * - **Compares the lengths of two strings and returns one of three possible type values:**
+ *    - `IfStr1Shorter` if the first string is shorter.
+ *    - `IfStr2Shorter` if the second string is shorter.
+ *    - `IfEqual` if both strings have the same length.
+ * - Defaults to `never` if not provided.
  * @template Str1 - First string.
  * @template Str2 - Second string.
  * @template IfStr1Shorter - Type to return if Str1 is shorter (default `never`).
  * @template IfStr2Shorter - Type to return if Str2 is shorter (default `never`).
  * @template IfEqual - Type to return if both strings have equal length (default `never`).
- *
  * @example
  * ```ts
  * type Case1 = CompareStringLength<'a', 'ab', 'first shorter'>;
@@ -691,13 +649,11 @@ type StringLength<S extends string>=_StringLength<S>;
  */
 type CompareStringLength<Str1 extends string,Str2 extends string,IfStr1Shorter=never,IfStr2Shorter=never,IfEqual=never>=IsEmptyString<Str1>extends true?IsEmptyString<Str2>extends true?IfEqual:IfStr1Shorter:IsEmptyString<Str2>extends true?IfStr2Shorter:Str1 extends`${string}${infer Str1Rest extends string}`?Str2 extends`${string}${infer Str2Rest extends string}`?CompareStringLength<Str1Rest,Str2Rest,IfStr1Shorter,IfStr2Shorter,IfEqual>:never:never;
 /** -------------------------------------------------------
- * * ***IsShorterString.***
+ * * ***Utility Type: `IsShorterString`.***
  * -------------------------------------------------------
- * Returns `true` if the first string is shorter than the second string; otherwise `false`.
- *
+ * **Returns `true` if the first string is shorter than the second string; otherwise `false`.**
  * @template Str1 - First string.
  * @template Str2 - Second string.
- *
  * @example
  * ```ts
  * type Case1 = IsShorterString<'a', 'ab'>;
@@ -708,13 +664,11 @@ type CompareStringLength<Str1 extends string,Str2 extends string,IfStr1Shorter=n
  */
 type IsShorterString<Str1 extends string,Str2 extends string>=CompareStringLength<Str1,Str2,true,false,false>;
 /** -------------------------------------------------------
- * * ***IsLongerString.***
+ * * ***Utility Type: `IsLongerString`.***
  * -------------------------------------------------------
- * Returns `true` if the first string is longer than the second string; otherwise `false`.
- *
+ * **Returns `true` if the first string is longer than the second string; otherwise `false`.**
  * @template Str1 - First string.
  * @template Str2 - Second string.
- *
  * @example
  * ```ts
  * type Case1 = IsLongerString<'ab', 'a'>; // ➔ true
@@ -723,13 +677,11 @@ type IsShorterString<Str1 extends string,Str2 extends string>=CompareStringLengt
  */
 type IsLongerString<Str1 extends string,Str2 extends string>=CompareStringLength<Str1,Str2,false,true,false>;
 /** -------------------------------------------------------
- * * ***IsSameLengthString.***
+ * * ***Utility Type: `IsSameLengthString`.***
  * -------------------------------------------------------
- * Returns `true` if two strings have the same length; otherwise `false`.
- *
+ * **Returns `true` if two strings have the same length; otherwise `false`.**
  * @template Str1 - First string.
  * @template Str2 - Second string.
- *
  * @example
  * ```ts
  * type Case1 = IsSameLengthString<'ab', 'ab'>;  // ➔ true
@@ -738,57 +690,48 @@ type IsLongerString<Str1 extends string,Str2 extends string>=CompareStringLength
  */
 type IsSameLengthString<Str1 extends string,Str2 extends string>=CompareStringLength<Str1,Str2,false,false,true>;
 /** -------------------------------------------------------
- * Options for {@link NumberLength}.
+ * * ***Type Options for {@link NumberLength | **`NumberLength`**}.***
  */
 type TypeNumberLengthOptions={
-/** Removes the leading minus `-` from negative numbers.
- *
- * Default: `true`.
+/** * ***Removes the leading minus `-` from negative numbers, default: `true`.***
  *
  * @default true
  */
 stripSign?:boolean;
-/** Removes the decimal point `.` from floats.
- *
- * Default: `true`.
+/** * ***Removes the decimal point `.` from floats, default: `true`.***
  *
  * @default true
  */
 stripDot?:boolean;
-/** Removes the trailing `n` from BigInt literals.
- *
- * Default: `true`.
+/** * ***Removes the trailing `n` from BigInt literals, default: `true`.***
  *
  * @default true
  */
 stripBigInt?:boolean;};
 /** -------------------------------------------------------
- * Default options for {@link NumberLength} (all true).
+ * * ***Default options for {@link NumberLength | **`NumberLength`**} (all `true`).***
  */
 type DefaultNumberLengthOptions={stripSign:true;stripDot:true;stripBigInt:true;};
 /** -------------------------------------------------------
- * Merge provided options with defaults for {@link NumberLength}.
+ * * ***Merge provided options with defaults for {@link NumberLength | **`NumberLength`**}.***
  */
 type MergeOptions<Opts extends TypeNumberLengthOptions>={[K in keyof DefaultNumberLengthOptions]:K extends keyof Opts?Opts[K]:DefaultNumberLengthOptions[K];};
 /** -------------------------------------------------------
- * * ***NumberLength.***
+ * * ***Utility Type: `NumberLength`.***
  * -------------------------------------------------------
- * A type-level utility that returns the **number of digits/characters**
- * of a numeric literal type, with optional cleaning.
- *
- * Supports:
- * - Integers (positive & negative)
- * - Floats (`.` optionally removed)
- * - Scientific notation (`e`/`E`, TypeScript normalizes to number)
- * - BigInts (`n` suffix optionally removed)
- *
+ * **A type-level utility that returns the **number of digits/characters**
+ * of a numeric literal type, with optional cleaning.**
+ * - **Supports:**
+ *    - Integers (positive & negative).
+ *    - Floats (`.` optionally removed).
+ *    - Scientific notation (`e`/`E`, TypeScript normalizes to number).
+ *    - BigInts (`n` suffix optionally removed).
  * @template T - A numeric literal (`number` or `bigint`).
  * @template Options - Optional configuration (default: all `true`):
- * - `stripSign` → Removes the leading `-` (default `true`)
- * - `stripDot` → Removes the decimal point `.` (default `true`)
- * - `stripBigInt` → Removes trailing `n` (default `true`)
- *
- * ---
+ * - `stripSign` ➔ Removes the leading `-` (default `true`).
+ * - `stripDot` ➔ Removes the decimal point `.` (default `true`).
+ * - `stripBigInt` ➔ Removes trailing `n` (default `true`).
+ * @example
  * #### ✅ _Valid Examples:_
  * ```ts
  * // Integers
@@ -816,7 +759,6 @@ type MergeOptions<Opts extends TypeNumberLengthOptions>={[K in keyof DefaultNumb
  * type N = NumberLength<-123n, { stripBigInt: false, stripSign: false }>;
  * // ➔ 5 (minus & n kept ➔ -123n)
  * ```
- *
  * ---
  * #### ❌ _Invalid Examples:_
  * ```ts
@@ -829,7 +771,6 @@ type MergeOptions<Opts extends TypeNumberLengthOptions>={[K in keyof DefaultNumb
  * type Invalid7 = NumberLength<unknown>;  // ➔ never
  * type Invalid8 = NumberLength<never>;    // ➔ never
  * ```
- *
  * ---
  * @remarks
  * - Uses type-level string manipulation to "clean" numeric literal according to options.
@@ -839,26 +780,21 @@ type MergeOptions<Opts extends TypeNumberLengthOptions>={[K in keyof DefaultNumb
  */
 type NumberLength<T extends number|bigint,Options extends Partial<TypeNumberLengthOptions>=DefaultNumberLengthOptions>=If<OrArr<[IsBaseType<T>,Extends<T,string>,Not<Extends<T,number|bigint>>]>>extends true?never:StringLength<ReplaceAll<Stringify<T>,[ MergeOptions<Options>["stripSign"] extends true?"-":"",MergeOptions<Options>["stripDot"] extends true?".":"",MergeOptions<Options>["stripBigInt"] extends true?"n":""],"">>;
 /** -------------------------------------------------------
- * * ***CompareNumberLength.***
+ * * ***Utility Type: `CompareNumberLength`.***
  * -------------------------------------------------------
- *
- * Compares the **number of digits** of two numeric literal types.
- *
- * Returns:
- * - `IfNum1Shorter` if the first number has fewer digits than the second (default: `never`).
- * - `IfNum2Shorter` if the second number has fewer digits than the first (default: `never`).
- * - `IfEqual` if both numbers have the same number of digits (default: `never`).
- *
- * **Important:** This utility only works with **literal numbers**.
- * Using non-literal numbers (`number`) will return `never`.
- *
+ * **Compares the **number of digits** of two numeric literal types.**
+ * - **Returns:**
+ *    - `IfNum1Shorter` if the first number has fewer digits than the second (default: `never`).
+ *    - `IfNum2Shorter` if the second number has fewer digits than the first (default: `never`).
+ *    - `IfEqual` if both numbers have the same number of digits (default: `never`).
+ * - **Important:**
+ *    - This utility only works with **literal numbers**.
+ *    - Using non-literal numbers (`number`) will return `never`.
  * @template Num1 - The first number literal to compare.
  * @template Num2 - The second number literal to compare.
  * @template IfNum1Shorter - Return type if the first number is shorter (default: `never`).
  * @template IfNum2Shorter - Return type if the second number is shorter (default: `never`).
  * @template IfEqual - Return type if both numbers have the same length (default: `never`).
- *
- * ---
  * @example
  * ```ts
  * // First number shorter than second
@@ -883,30 +819,24 @@ type NumberLength<T extends number|bigint,Options extends Partial<TypeNumberLeng
  * type Case4 = CompareNumberLength<NumA, NumB, 'first shorter', 'first longer', 'equal'>;
  * // ➔ never
  * ```
- *
  * ---
  * @remarks
- * - Internally uses {@link Stringify} and {@link CompareStringLength}.
- * - Works for positive, negative, and floating-point literal numbers.
+ * - Internally uses {@link Stringify | **`Stringify`**} and {@link CompareStringLength | **`CompareStringLength`**}.
+ * - Works for `positive`, `negative`, and `floating-point literal numbers`.
  */
 type CompareNumberLength<Num1 extends number,Num2 extends number,IfNum1Shorter=never,IfNum2Shorter=never,IfEqual=never>=If<Or<Extends<number,Num1>,Extends<number,Num2>>>extends true?never:CompareStringLength<Stringify<Num1>,Stringify<Num2>,IfNum1Shorter,IfNum2Shorter,IfEqual>;
 /** -------------------------------------------------------
- * * ***IsShorterNumber.***
+ * * ***Utility Type: `IsShorterNumber`.***
  * -------------------------------------------------------
- *
- * Compares the number of digits of two numeric literal types and returns a **boolean**.
- *
- * Returns:
- * - `true` if the first number has fewer digits than the second.
- * - `false` otherwise (including when numbers have equal length).
- *
- * **Important:** This utility only works with **literal numbers**.
- * Using non-literal numbers (`number`) will return `never`.
- *
+ * **Compares the number of digits of two numeric literal types and returns a **boolean**.**
+ * - **Returns:**
+ *    - `true` if the first number has fewer digits than the second.
+ *    - `false` otherwise (including when numbers have equal length).
+ * - **Important:**
+ *    - This utility only works with **literal numbers**.
+ *    - Using non-literal numbers (`number`) will return `never`.
  * @template Num1 - The first number literal to compare.
  * @template Num2 - The second number literal to compare.
- *
- * ---
  * @example
  * ```ts
  * // Literal numbers
@@ -925,28 +855,24 @@ type CompareNumberLength<Num1 extends number,Num2 extends number,IfNum1Shorter=n
  * type Case4 = IsShorterNumber<NumA, NumB>;
  * // ➔ never
  * ```
- *
+ * ---
  * @remarks
- * - Internally uses {@link CompareNumberLength}.
- * - Works for positive, negative, and floating-point literal numbers.
+ * - Internally uses {@link CompareNumberLength | **`CompareNumberLength`**}.
+ * - Works for `positive`, `negative`, and `floating-point literal numbers`.
  */
 type IsShorterNumber<Num1 extends number,Num2 extends number>=CompareNumberLength<Num1,Num2,true,false,false>;
 /** -------------------------------------------------------
- * * ***IsLongerNumber.***
+ * * ***Utility Type: `IsLongerNumber`.***
  * -------------------------------------------------------
- *
- * Compares the number of digits of two numeric literal types and returns a **boolean**.
- *
- * Returns:
- * - `true` if the first number has more digits than the second.
- * - `false` otherwise (including when numbers have equal length).
- *
- * **Important:** Only works with **literal numbers**. Non-literal numbers (`number`) return `never`.
- *
+ * **Compares the number of digits of two numeric literal types and returns a **boolean**.**
+ * - **Returns:**
+ *    - `true` if the first number has more digits than the second.
+ *    - `false` otherwise (including when numbers have equal length).
+ * - **Important:**
+ *    - Only works with **literal numbers**.
+ *    - Non-literal numbers (`number`) return `never`.
  * @template Num1 - The first number literal to compare.
  * @template Num2 - The second number literal to compare.
- *
- * ---
  * @example
  * ```ts
  * type Case1 = IsLongerNumber<10, 1>;
@@ -964,28 +890,24 @@ type IsShorterNumber<Num1 extends number,Num2 extends number>=CompareNumberLengt
  * type Case4 = IsLongerNumber<NumA, NumB>;
  * // ➔ never
  * ```
- *
+ * ---
  * @remarks
- * - Internally uses {@link CompareNumberLength}.
- * - Works for positive, negative, and floating-point literal numbers.
+ * - Internally uses {@link CompareNumberLength | **`CompareNumberLength`**}.
+ * - Works for `positive`, `negative`, and `floating-point literal numbers`.
  */
 type IsLongerNumber<Num1 extends number,Num2 extends number>=CompareNumberLength<Num1,Num2,false,true,false>;
 /** -------------------------------------------------------
- * * ***IsSameLengthNumber.***
+ * * ***Utility Type: `IsSameLengthNumber`.***
  * -------------------------------------------------------
- *
- * Compares the number of digits of two numeric literal types and returns a **boolean**.
- *
- * Returns:
- * - `true` if the numbers have the same number of digits.
- * - `false` otherwise.
- *
- * **Important:** Only works with **literal numbers**. Non-literal numbers (`number`) return `never`.
- *
+ * **Compares the number of digits of two numeric literal types and returns a **boolean**.**
+ * - **Returns:**
+ *    - `true` if the numbers have the same number of digits.
+ *    - `false` otherwise.
+ * - **Important:**
+ *    - Only works with **literal numbers**.
+ *    - Non-literal numbers (`number`) return `never`.
  * @template Num1 - The first number literal to compare.
  * @template Num2 - The second number literal to compare.
- *
- * ---
  * @example
  * ```ts
  * type Case1 = IsSameLengthNumber<10, 10>;
@@ -1000,37 +922,33 @@ type IsLongerNumber<Num1 extends number,Num2 extends number>=CompareNumberLength
  * type Case3 = IsSameLengthNumber<NumA, NumB>;
  * // ➔ never
  * ```
- *
+ * ---
  * @remarks
- * - Internally uses {@link CompareNumberLength}.
- * - Works for positive, negative, and floating-point literal numbers.
+ * - Internally uses {@link CompareNumberLength | **`CompareNumberLength`**}.
+ * - Works for `positive`, `negative`, and `floating-point literal numbers`.
  */
 type IsSameLengthNumber<Num1 extends number,Num2 extends number>=CompareNumberLength<Num1,Num2,false,false,true>;type LowerThanMap={"0":["1","2","3","4","5","6","7","8","9"];"1":["2","3","4","5","6","7","8","9"];"2":["3","4","5","6","7","8","9"];"3":["4","5","6","7","8","9"];"4":["5","6","7","8","9"];"5":["6","7","8","9"];"6":["7","8","9"];"7":["8","9"];"8":["9"];"9":[];};type _IsLowerThan<Num1 extends string,Num2 extends string>=Num1 extends`${infer Num1Character extends keyof LowerThanMap}${infer Num1Rest extends string}`?Num2 extends`${infer Num2Character extends string}${infer Num2Rest extends string}`?IsEqual<Num1Character,Num2Character>extends true?_IsLowerThan<Num1Rest,Num2Rest>:Num2Character extends LowerThanMap[Num1Character][number]?true:false:true:false;
 /** -------------------------------------------------------
- * * ***IsLowerThan.***
+ * * ***Utility Type: `IsLowerThan`.***
  * -------------------------------------------------------
- * Returns a boolean indicating whether `Num1` is strictly lower than `Num2`.
+ * **Returns a boolean indicating whether `Num1` is strictly lower than `Num2`.**
  * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @template Num1 - The first integer to compare.
  * @template Num2 - The second integer to compare.
- *
  * @example
  * type Case1 = IsLowerThan<1, 10>;  // ➔ true
  * type Case2 = IsLowerThan<1, -10>; // ➔ false
  */
 type IsLowerThan<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>extends true?false:IsNegative<Num1>extends true?IsNegative<Num2>extends false?true:CompareNumberLength<Num1,Num2,false,true,Not<_IsLowerThan<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>>:IsNegative<Num2>extends true?false:CompareNumberLength<Num1,Num2,true,false,_IsLowerThan<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>;
 /** -------------------------------------------------------
- * * ***IfLowerThan.***
+ * * ***Utility Type: `IfLowerThan`.***
  * -------------------------------------------------------
- * Returns `IfTrue` if `Num1` is lower than `Num2`, otherwise returns `IfFalse`.
+ * **Returns `IfTrue` if `Num1` is lower than `Num2`, otherwise returns `IfFalse`.**
  * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @template Num1 - The first integer to compare.
  * @template Num2 - The second integer to compare.
  * @template IfTrue - Value to return if `Num1 < Num2`.
  * @template IfFalse - Value to return if `Num1 >= Num2`.
- *
  * @example
  * type Case1 = IfLowerThan<1, 10, 'valid'>;
  * // ➔ 'valid'
@@ -1039,11 +957,10 @@ type IsLowerThan<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>exte
  */
 type IfLowerThan<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=If<IsLowerThan<Num1,Num2>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IsLowerOrEqual.***
+ * * ***Utility Type: `IsLowerOrEqual`.***
  * -------------------------------------------------------
- * Returns a boolean indicating whether `Num1` is lower than or equal to `Num2`.
+ * **Returns a boolean indicating whether `Num1` is lower than or equal to `Num2`.**
  * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @template Num1 - The first integer to compare.
  * @template Num2 - The second integer to compare.
  * @example
@@ -1054,11 +971,12 @@ type IfLowerThan<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=fal
  */
 type IsLowerOrEqual<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>extends true?true:IsLowerThan<Num1,Num2>;
 /** -------------------------------------------------------
- * * ***IfLowerOrEqual.***
+ * * ***Utility Type: `IfLowerOrEqual`.***
  * -------------------------------------------------------
- * Returns the third argument if the first argument (integer) is lower than the second argument (integer) or equal (defaults to `true`), otherwise returns the fourth argument (defaults to `false`).
+ * **Returns the third argument if the first argument (integer) is lower than
+ * the second argument (integer) or equal (defaults to `true`), otherwise returns
+ * the fourth argument (defaults to `false`).**
  * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @template Num1 - The first integer to compare.
  * @template Num2 - The second integer to compare.
  * @template IfTrue - Value to return if `Num1 <= Num2`.
@@ -1071,11 +989,12 @@ type IsLowerOrEqual<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>e
  */
 type IfLowerOrEqual<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=If<IsEqual<Num1,Num2>extends true?true:IsLowerThan<Num1,Num2>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IsGreaterThan.***
+ * * ***Utility Type: `IsGreaterThan`.***
  * -------------------------------------------------------
- * Returns a boolean indicating whether the first integer is ***greater than*** the second integer.
- * Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * **Returns a boolean indicating whether the first integer
+ * is ***greater than*** the second integer.**
+ * - **Behavior:**
+ *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template Num1 - The first integer.
  * @template Num2 - The second integer.
  * @example
@@ -1086,12 +1005,14 @@ type IfLowerOrEqual<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=
  */
 type IsGreaterThan<Num1 extends number,Num2 extends number>=IsLowerThan<Num2,Num1>;
 /** -------------------------------------------------------
- * * ***IfGreaterThan.***
+ * * ***Utility Type: `IfGreaterThan`.***
  * -------------------------------------------------------
- * Conditional: returns the third argument if the first integer is ***greater than*** the second integer, otherwise returns the fourth argument.
- * - Defaults: `IfTrue = true`, `IfFalse = false`.
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * - **Conditional:**
+ *    - Returns the third argument if the first integer is ***greater than*** the
+ *      second integer, otherwise returns the fourth argument.
+ * - **Behavior:**
+ *    - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template Num1 - The first integer.
  * @template Num2 - The second integer.
  * @template IfTrue - The branch type if condition is met. (default: `true`)
@@ -1106,12 +1027,12 @@ type IsGreaterThan<Num1 extends number,Num2 extends number>=IsLowerThan<Num2,Num
  */
 type IfGreaterThan<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=IfLowerThan<Num2,Num1,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IsGreaterOrEqual.***
+ * * ***Utility Type: `IsGreaterOrEqual`.***
  * -------------------------------------------------------
- *
- * Returns a boolean indicating whether the first integer is ***greater than or equal*** to the second integer.
- * Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * **Returns a boolean indicating whether the first integer
+ * is ***greater than or equal*** to the second integer.**
+ * - **Behavior:**
+ *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template Num1 - The first integer.
  * @template Num2 - The second integer.
  * @example
@@ -1123,13 +1044,14 @@ type IfGreaterThan<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=f
  */
 type IsGreaterOrEqual<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>extends true?true:IsGreaterThan<Num1,Num2>;
 /** -------------------------------------------------------
- * * ***IfGreaterOrEqual.***
+ * * ***Utility Type: `IfGreaterOrEqual`.***
  * -------------------------------------------------------
- *
- * Conditional: returns the third argument if the first integer is ***greater than or equal*** to the second integer, otherwise returns the fourth argument.
- * - Defaults: `IfTrue = true`, `IfFalse = false`.
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * - **Conditional:**
+ *    - Returns the third argument if the first integer is ***greater than or
+ *      equal*** to the second integer, otherwise returns the fourth argument.
+ * - **Behavior:**
+ *    - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template Num1 - The first integer.
  * @template Num2 - The second integer.
  * @template IfTrue - The branch type if condition is met. (default: `true`)
@@ -1145,71 +1067,59 @@ type IsGreaterOrEqual<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2
  * ```
  */
 type IfGreaterOrEqual<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=If<IsEqual<Num1,Num2>extends true?true:IsGreaterThan<Num1,Num2>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***IsBetweenOptions***
- * -------------------------------------------------------
- *
- * Options to configure whether the borders of the interval are included
- * when using {@link IsBetween}.
- *
- * @property minIncluded - Whether to include the lower border (`Min`) in the comparison.
- *   @default true
- * @property maxIncluded - Whether to include the upper border (`Max`) in the comparison.
- *   @default true
- *
- * @example
- * ```ts
- * type Opt1 = IsBetweenOptions;
- * // ➔ { minIncluded?: boolean; maxIncluded?: boolean }
- * ```
+/** ---------------------------------------------------------------------------
+ * * ***Type Options for {@link IsBetween | `IsBetween`}.***
+ * ---------------------------------------------------------------------------
+ * **Options to configure whether the borders of the interval are included
+ * when using {@link IsBetween | **`IsBetween`**}.**
  */
 type IsBetweenOptions={
-/** Whether to include the lower border (`Min`) in the comparison.
+/** * ***Whether to include the lower border (`Min`) in the comparison.***
  *
- * - `true` → include `Min` (default)
- * - `false` → exclude `Min`
+ * - `true` ➔ include `Min` (**default**).
+ * - `false` ➔ exclude `Min`.
  *
  * @default true
  */
 minIncluded?:boolean;
-/** Whether to include the upper border (`Max`) in the comparison.
+/** * ***Whether to include the upper border (`Max`) in the comparison.***
  *
- * - `true` → include `Max` (default)
- * - `false` → exclude `Max`
+ * - `true` ➔ include `Max` (**default**).
+ * - `false` ➔ exclude `Max`.
  *
  * @default true
  */
 maxIncluded?:boolean;};
 /** -------------------------------------------------------
- * * ***IsBetween.***
+ * * ***Utility Type: `IsBetween`.***
  * -------------------------------------------------------
- * Returns a boolean whether the first integer argument is between the second and the third integer argument, by default, borders of the interval are included, which can be modified by the second argument.
- * - `minIncluded`, `maxIncluded` options show whether to include the lower and the higher borders respectively. Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * **Returns a boolean whether the first integer argument is between the second and the third integer argument, by default, borders of the interval are included, which can be modified by the second argument.**
+ * - **Behavior:**
+ *    - `minIncluded`, `maxIncluded` options show whether to include the lower and the higher borders
+ *       respectively.
+ *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @example
- * // truthy
  * type Case1 = IsBetween<1, 1, 10>;
  * // ➔ true
- *
- * // falsy
  * type Case2 = IsBetween<1, 1, 10, {minIncluded: false}>;
  * // ➔ false
  * type Case3 = IsBetween<10, 1, 10, {maxIncluded: false}>;
  * // ➔ false
  */
 type IsBetween<Num extends number,Min extends number,Max extends number,Options extends IsBetweenOptions={minIncluded:true;maxIncluded:true;}>=IsEqual<Num,Min>extends true?Options["minIncluded"]:IsEqual<Num,Max>extends true?Options["maxIncluded"]:And<IsGreaterThan<Num,Min>,IsLowerThan<Num,Max>>;type _IsValidRGBParameter<T extends number>=IsInteger<T>extends true?IsBetween<T,0,255>:false;
-/** Configuration options for a type-level utility `RGB` | `IsRGB` | `IfRGB`. */
+/** * ***Configuration options for a type-level utility
+ * {@link RGB | `RGB`} | {@link IsRGB | `IsRGB` } | {@link IfRGB | `IfRGB` }.*** */
 type RGBOptions={
-/** Separator character(s) used between the RGB components (`r`, `g`, `b`).
+/** * ***Separator character(s) used between the RGB components (`r`, `g`, `b`).***
  *
- * For example:
- * - `", "` → `"rgb(23, 242, 0)"`
- * - `","` → `"rgb(23,242,0)"`
+ * - **For example:**
+ *    - `","` ➔ `"rgb(23,242,0)"`.
+ *    - `", "` ➔ `"rgb(23, 242, 0)"`.
  *
  * @default ", "
  */
 separator:string;};
-/** Default configuration for the `RGBOptions`.
+/** * ***Default configuration for the {@link RGBOptions | `RGBOptions`}.***
  *
  * @example
  * ```ts
@@ -1218,20 +1128,19 @@ separator:string;};
  * ```
  */
 type DefaultRGBOptions={
-/**
- * Default separator for RGB components.
+/** * ***Default separator for RGB components.***
  *
- * Produces strings like `"rgb(23, 242, 0)"`.
+ * **Produces strings like `"rgb(23, 242, 0)"`.**
  */
 separator:", ";};
 /** -------------------------------------------------------
- * * ***RGB.***
+ * * ***Utility Type: `RGB`.***
  * -------------------------------------------------------
- * A type-level utility that validates an **RGB color string**.
- * - Accepts `rgb(r, g, b)` format with customizable separators.
- * - Each parameter `r`, `g`, `b` must be an integer between `0` and `255`.
- * - Returns `T` if valid, otherwise `never`.
- *
+ * **A type-level utility that validates an **RGB color string**.**
+ * - **Behavior:**
+ *    - Accepts `rgb(r, g, b)` format with customizable separators.
+ *    - Each parameter `r`, `g`, `b` must be an integer between `0` and `255`.
+ *    - Returns `T` if valid, otherwise `never`.
  * @template T - A string to check.
  * @template Options - Options with `separator` (defaults to `", "`).
  * @example
@@ -1246,11 +1155,10 @@ separator:", ";};
  */
 type RGB<T extends string,Options extends RGBOptions=DefaultRGBOptions>=T extends`rgb(${infer R extends number}${Options["separator"]}${infer G extends number}${Options["separator"]}${infer B extends number})`?AndArr<[ _IsValidRGBParameter<R>,_IsValidRGBParameter<G>,_IsValidRGBParameter<B>]>extends true?T:never:never;
 /** -------------------------------------------------------
- * * ***IsRGB.***
+ * * ***Utility Type: `IsRGB`.***
  * -------------------------------------------------------
- * A type-level utility that checks if a string is a valid **RGB color**.
+ * **A type-level utility that checks if a string is a valid **RGB color**.**
  * - Returns `true` if valid, otherwise `false`.
- *
  * @template T - A string to check.
  * @template Options - Options with `separator` (defaults to `", "`).
  * @example
@@ -1265,11 +1173,10 @@ type RGB<T extends string,Options extends RGBOptions=DefaultRGBOptions>=T extend
  */
 type IsRGB<T extends string,Options extends RGBOptions=DefaultRGBOptions>=Not<IsNever<RGB<T,Options>>>;
 /** -------------------------------------------------------
- * * ***IfRGB.***
+ * * ***Utility Type: `IfRGB`.***
  * -------------------------------------------------------
- * A conditional type that returns `IfTrue` if `T` is a valid **RGB color**,
- * otherwise returns `IfFalse`.
- *
+ * **A conditional type that returns `IfTrue` if `T` is a valid **RGB color**,
+ * otherwise returns `IfFalse`.**
  * @template T - A string to check.
  * @template IfTrue - Return type if valid (defaults to `true`).
  * @template IfFalse - Return type if invalid (defaults to `false`).
@@ -1288,13 +1195,13 @@ type IsRGB<T extends string,Options extends RGBOptions=DefaultRGBOptions>=Not<Is
  */
 type IfRGB<T extends string,IfTrue=true,IfFalse=false,Options extends RGBOptions=DefaultRGBOptions>=If<IsRGB<T,Options>,IfTrue,IfFalse>;type _ValidHEXCharacters=["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"];type _AllowedHEXLength=3|4|6|8;
 /** -------------------------------------------------------
- * * ***HEX.***
+ * * ***Utility Type: `HEX`.***
  * -------------------------------------------------------
- * A type-level utility that validates a **HEX color string**.
- * - Accepts `#RGB`, `#RGBA`, `#RRGGBB`, or `#RRGGBBAA` formats.
- * - Characters must be `[0-9A-F]` (case-insensitive).
- * - Returns `T` if valid, otherwise `never`.
- *
+ * **A type-level utility that validates a **HEX color string**.**
+ * - **Behavior:**
+ *    - Accepts `#RGB`, `#RGBA`, `#RRGGBB`, or `#RRGGBBAA` formats.
+ *    - Characters must be `[0-9A-F]` (**case-insensitive**).
+ *    - Returns `T` if valid, otherwise `never`.
  * @template T - A string to check.
  * @example
  * ```ts
@@ -1308,11 +1215,10 @@ type IfRGB<T extends string,IfTrue=true,IfFalse=false,Options extends RGBOptions
  */
 type HEX<T extends string>=(Uppercase<T>extends`#${infer HEXWithoutHashTag extends string}`?StringLength<HEXWithoutHashTag>extends _AllowedHEXLength?ExtendsArr<Split<HEXWithoutHashTag,"">,_ValidHEXCharacters[number]>:false:false)extends true?T:never;
 /** -------------------------------------------------------
- * * ***IsHEX.***
+ * * ***Utility Type: `IsHEX`.***
  * -------------------------------------------------------
- * A type-level utility that checks if a string is a valid **HEX color**.
+ * **A type-level utility that checks if a string is a valid **HEX color**.**
  * - Returns `true` if valid, otherwise `false`.
- *
  * @template T - A string to check.
  * @example
  * ```ts
@@ -1322,11 +1228,10 @@ type HEX<T extends string>=(Uppercase<T>extends`#${infer HEXWithoutHashTag exten
  */
 type IsHEX<T extends string>=Not<IsNever<HEX<T>>>;
 /** -------------------------------------------------------
- * * ***IfHEX.***
+ * * ***Utility Type: `IfHEX`.***
  * -------------------------------------------------------
- * A conditional type that returns `IfTrue` if `T` is a valid **HEX color**,
- * otherwise returns `IfFalse`.
- *
+ * **A conditional type that returns `IfTrue` if `T` is a valid **HEX color**,
+ * otherwise returns `IfFalse`.**
  * @template T - A string to check.
  * @template IfTrue - Return type if valid (defaults to `true`).
  * @template IfFalse - Return type if invalid (defaults to `false`).
@@ -1343,18 +1248,19 @@ type IsHEX<T extends string>=Not<IsNever<HEX<T>>>;
  * ```
  */
 type IfHEX<T extends string,IfTrue=true,IfFalse=false>=If<IsHEX<T>,IfTrue,IfFalse>;
-/** Configuration options for a type-level utility `HSL` | `IsHSL` | `IfHSL`. */
+/** * ***Configuration options for a type-level utility
+ * {@link HSL | `HSL` } | {@link IsHSL | `IsHSL` } | {@link IfHSL | `IfHSL` }.*** */
 type HSLOptions={
-/** Separator character(s) used between the HSL components (`h`, `s`, `l`).
+/** * ***Separator character(s) used between the HSL components (`h`, `s`, `l`).***
  *
- * For example:
- * - `", "` → `"hsl(180, 100%, 50%)"`
- * - `","` → `"hsl(180,100%,50%)"`
+ * - **For example:**
+ *    - `","` ➔ `"hsl(180,100%,50%)"`.
+ *    - `", "` ➔ `"hsl(180, 100%, 50%)"`.
  *
  * @default ", "
  */
 separator:string;};
-/** Default configuration for the `HSLOptions`.
+/** * ***Default configuration for the {@link HSLOptions | `HSLOptions`}.***
  *
  * @example
  * ```ts
@@ -1363,19 +1269,19 @@ separator:string;};
  * ```
  */
 type DefaultHSLOptions={
-/** Default separator for HSL components.
+/** * ***Default separator for HSL components.***
  *
- * Produces strings like `"hsl(180, 100%, 50%)"`.
+ * **Produces strings like `"hsl(180, 100%, 50%)"`.**
  */
 separator:", ";};
 /** -------------------------------------------------------
- * * ***HSL.***
+ * * ***Utility Type: `HSL`.***
  * -------------------------------------------------------
- * A type-level utility that validates an **HSL color string**.
- * - Accepts `hsl(h, s%, l%)` format with customizable separators.
- * - `h` must be an integer, `s` and `l` must be integers between `0` and `100`.
- * - Returns `T` if valid, otherwise `never`.
- *
+ * **A type-level utility that validates an **HSL color string**.**
+ * - **Behavior:**
+ *    - Accepts `hsl(h, s%, l%)` format with customizable separators.
+ *    - `h` must be an integer, `s` and `l` must be integers between `0` and `100`.
+ *    - Returns `T` if valid, otherwise `never`.
  * @template T - A string to check.
  * @template Options - Options with `separator` (defaults to `", "`).
  * @example
@@ -1390,11 +1296,10 @@ separator:", ";};
  */
 type HSL<T extends string,Options extends HSLOptions=DefaultHSLOptions>=(T extends`hsl(${infer H extends number}${Options["separator"]}${infer S extends number}%${Options["separator"]}${infer L extends number}%)`?AndArr<[IsInteger<H>,IsInteger<S>,IsInteger<L>]>extends true?AndArr<[IsBetween<S,0,100>,IsBetween<L,0,100>]>:false:false)extends true?T:never;
 /** -------------------------------------------------------
- * * ***IsHSL.***
+ * * ***Utility Type: `IsHSL`.***
  * -------------------------------------------------------
- * A type-level utility that checks if a string is a valid **HSL color**.
+ * **A type-level utility that checks if a string is a valid **HSL color**.**
  * - Returns `true` if valid, otherwise `false`.
- *
  * @template T - A string to check.
  * @template Options - Options with `separator` (defaults to `", "`).
  * @example
@@ -1409,11 +1314,10 @@ type HSL<T extends string,Options extends HSLOptions=DefaultHSLOptions>=(T exten
  */
 type IsHSL<T extends string,Options extends HSLOptions=DefaultHSLOptions>=Not<IsNever<HSL<T,Options>>>;
 /** -------------------------------------------------------
- * * ***IfHSL.***
+ * * ***Utility Type: `IfHSL`.***
  * -------------------------------------------------------
- * A conditional type that returns `IfTrue` if `T` is a valid **HSL color**,
- * otherwise returns `IfFalse`.
- *
+ * **A conditional type that returns `IfTrue` if `T` is a valid **HSL color**,
+ * otherwise returns `IfFalse`.**
  * @template T - A string to check.
  * @template IfTrue - Return type if valid (defaults to `true`).
  * @template IfFalse - Return type if invalid (defaults to `false`).
@@ -1429,18 +1333,17 @@ type IsHSL<T extends string,Options extends HSLOptions=DefaultHSLOptions>=Not<Is
  * ```
  */
 type IfHSL<T extends string,IfTrue=true,IfFalse=false,Options extends HSLOptions=DefaultHSLOptions>=If<IsHSL<T,Options>,IfTrue,IfFalse>;
-/** High-level configuration for color parsing utilities.
+/** * ***High-level configuration for {@link Color | `Color`} parsing utilities.***
  *
- * Allows customizing **RGB** and **HSL** parsing behavior independently.
+ * **Allows customizing **RGB** and **HSL** parsing behavior independently.**
  */
 type ColorOptions={
-/** Options for handling RGB color strings.
- *
- * - Controls parsing and formatting behavior of RGB values.
- * - By default uses {@link DefaultRGBOptions}.
+/** * ***Options for handling RGB color strings.***
  *
+ * - **Behavior:**
+ *    - Controls parsing and formatting behavior of RGB values.
+ *    - By default uses {@link DefaultRGBOptions | **`DefaultRGBOptions`**}.
  * @default DefaultRGBOptions
- *
  * @example
  * ```ts
  * type Opt = ColorOptions["rgbOptions"];
@@ -1452,13 +1355,12 @@ type ColorOptions={
  * ```
  */
 rgbOptions?:RGBOptions;
-/** Options for handling HSL color strings.
- *
- * - Controls parsing and formatting behavior of HSL values.
- * - By default uses {@link DefaultHSLOptions}.
+/** * ***Options for handling HSL color strings.***
  *
+ * - **Behavior:**
+ *    - Controls parsing and formatting behavior of HSL values.
+ *    - By default uses {@link DefaultHSLOptions | **`DefaultHSLOptions`**}.
  * @default DefaultHSLOptions
- *
  * @example
  * ```ts
  * type Opt = ColorOptions["hslOptions"];
@@ -1470,7 +1372,7 @@ rgbOptions?:RGBOptions;
  * ```
  */
 hslOptions?:HSLOptions;};
-/** Default configuration for the `ColorOptions`.
+/** * ***Default configuration for the {@link ColorOptions |`ColorOptions`}.***
  *
  * @example
  * ```ts
@@ -1479,11 +1381,11 @@ hslOptions?:HSLOptions;};
  * ```
  */
 type DefaultColorOptions={
-/** Default configuration for `RGBOptions`.
- *
- * - Provides the default separator for RGB strings.
- * - By default: `", "`
+/** * ***Default configuration for `RGBOptions`.***
  *
+ * - **Behavior:**
+ *    - Provides the default separator for RGB strings.
+ *    - By default: `", "`
  * @example
  * ```ts
  * type RGBOpt = DefaultColorOptions["rgbOptions"];
@@ -1491,11 +1393,11 @@ type DefaultColorOptions={
  * ```
  */
 rgbOptions:DefaultRGBOptions;
-/** Default configuration for `HSLOptions`.
- *
- * - Provides the default separator for HSL strings.
- * - By default: `", "`
+/** * ***Default configuration for `HSLOptions`.***
  *
+ * - **Behavior:**
+ *    - Provides the default separator for HSL strings.
+ *    - By default: `", "`
  * @example
  * ```ts
  * type HSLOpt = DefaultColorOptions["hslOptions"];
@@ -1504,16 +1406,15 @@ rgbOptions:DefaultRGBOptions;
  */
 hslOptions:DefaultHSLOptions;};type ResolveRGBOptions<O extends ColorOptions>=O["rgbOptions"] extends RGBOptions?O["rgbOptions"]:DefaultRGBOptions;type ResolveHSLOptions<O extends ColorOptions>=O["hslOptions"] extends HSLOptions?O["hslOptions"]:DefaultHSLOptions;
 /** -------------------------------------------------------
- * * ***Color.***
+ * * ***Utility Type: `Color`.***
  * -------------------------------------------------------
- * A type-level utility that validates a string as a **Color** in:
- * - RGB
- * - HEX
- * - HSL
- *
+ * - **A type-level utility that validates a string as a **Color** in:**
+ *    - **`RGB`**.
+ *    - **`HEX`**.
+ *    - **`HSL`**.
  * @returns {T} Returns `T` if valid, otherwise `never`.
  * @template T - A string to check.
- * @template Options - Options to pass down to RGB/HSL validation.
+ * @template Options - Options to pass down to `RGB`/`HSL` validation.
  * @example
  * ```ts
  * type A = Color<"rgb(23, 242, 0)">;
@@ -1522,17 +1423,16 @@ hslOptions:DefaultHSLOptions;};type ResolveRGBOptions<O extends ColorOptions>=O[
  * // ➔ never
  * type C = Color<"#000000">;
  * // ➔ "#000000"
- * type D = Color<"hsl(100,34%,56%)", { hslOptions: { separator: "," } }>;
+ * type D = Color<"hsl(100,34%,56%)", { hslOptions: { separator: "," }}>;
  * // ➔ "hsl(100,34%,56%)"
  * ```
  */
 type Color<T extends string,Options extends ColorOptions=DefaultColorOptions>=HEX<T>|HSL<T,ResolveHSLOptions<Options>>|RGB<T,ResolveRGBOptions<Options>>;
 /** -------------------------------------------------------
- * * ***IsColor.***
+ * * ***Utility Type: `IsColor`.***
  * -------------------------------------------------------
- * A type-level utility that checks if a string is a valid **Color**
- * (RGB | HEX | HSL).
- *
+ * **A type-level utility that checks if a string is a valid **Color**
+ * (`RGB` | `HEX` | `HSL`).**
  * @returns {T} - Returns `true` if valid, otherwise `false`.
  * @template T - A string to check.
  * @template Options - Options to pass down to RGB/HSL validation.
@@ -1550,18 +1450,17 @@ type Color<T extends string,Options extends ColorOptions=DefaultColorOptions>=HE
  */
 type IsColor<T extends string,Options extends ColorOptions=DefaultColorOptions>=Not<IsNever<Color<T,Options>>>;
 /** -------------------------------------------------------
- * * ***IfColor.***
+ * * ***Utility Type: `IfColor`.***
  * -------------------------------------------------------
- * A conditional type that returns `IfTrue` if `T` is a valid **Color**
- * (RGB | HEX | HSL), otherwise returns `IfFalse`.
- *
+ * **A conditional type that returns `IfTrue` if `T` is a valid **Color**
+ * (`RGB` | `HEX` | `HSL`), otherwise returns `IfFalse`.**
  * @template T - A string to check.
  * @template IfTrue - Return type if valid (defaults to `true`).
  * @template IfFalse - Return type if invalid (defaults to `false`).
  * @template Options - Options to pass down to RGB/HSL validation.
  * @example
  * ```ts
- * type A = IfColor<"rgb(23, 242, 0)", { rgbOptions: { separator: ", " } }, "valid">;
+ * type A = IfColor<"rgb(23, 242, 0)", { rgbOptions: { separator: ", " }}, "valid">;
  * // ➔ "valid"
  * type B = IfColor<"rgb(324, 123, 3)", DefaultColorOptions, "valid","invalid">;
  * // ➔ "invalid"
@@ -1571,10 +1470,9 @@ type IsColor<T extends string,Options extends ColorOptions=DefaultColorOptions>=
  */
 type IfColor<T extends string,Options extends ColorOptions=DefaultColorOptions,IfTrue=true,IfFalse=false>=If<IsColor<T,Options>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***Concat.***
+ * * ***Utility Type: `Concat`.***
  * -------------------------------------------------------
- * A type-level utility that concatenates `two arrays` into `one`.
- *
+ * **A type-level utility that concatenates `two arrays` into `one`.**
  * @template T - The first array type.
  * @template U - The second array type, or a single element.
  * @example
@@ -1593,30 +1491,25 @@ type IfColor<T extends string,Options extends ColorOptions=DefaultColorOptions,I
  */
 type Concat<T extends readonly unknown[],U>=[ ...T,...(U extends readonly unknown[]?U:[U])];
 /** -------------------------------------------------------
- * * ***DigitsTuple.***
- * -------------------------------------------------------
- * A **type-level utility** that converts a numeric literal (number or bigint) into a
- * structured representation of its digits.
- *
- * - The resulting type is an **object** with the following properties:
- *   - `negative`: boolean flag indicating if the number is negative.
- *   - `bigint`: boolean flag indicating if the value is a bigint.
- *   - `float`: boolean flag indicating if the value is a floating-point number.
- *   - `digits`: a tuple of digits (each as a `number`), with decimal points and
- *     bigint suffix `n` removed.
- *
- * - Works with:
- *   - Positive integers
- *   - Negative integers
- *   - Zero and negative zero
- *   - Floating-point numbers (decimal points are ignored)
- *   - BigInt values
- *
+ * * ***Utility Type: `DigitsTuple`.***
+ * -------------------------------------------------------
+ * **A **type-level utility** that converts a numeric literal (number or bigint) into
+ * a structured representation of its digits.**
+ * - **The resulting type is an **object** with the following properties:**
+ *    - `negative`: boolean flag indicating if the number is negative.
+ *    - `bigint`: boolean flag indicating if the value is a bigint.
+ *    - `float`: boolean flag indicating if the value is a floating-point number.
+ *    - `digits`: a tuple of digits (each as a `number`), with decimal points and
+ *      bigint suffix `n` removed.
+ * - **Works with:**
+ *    - Positive integers
+ *    - Negative integers
+ *    - Zero and negative zero
+ *    - Floating-point numbers (decimal points are ignored)
+ *    - BigInt values
  * **Note:** TypeScript automatically normalizes scientific notation numeric literals
- * (e.g., `5e3` → `5000`), so the `digits` tuple will reflect the expanded value.
- *
+ * (e.g., `5e3` ➔ `5000`), so the `digits` tuple will reflect the expanded value.
  * @template T - A numeric literal type (`number` or `bigint`) to convert.
- *
  * @example
  * ```ts
  * // Single digit
@@ -1650,31 +1543,27 @@ type Concat<T extends readonly unknown[],U>=[ ...T,...(U extends readonly unknow
  * // ➔ { negative: true; bigint: true; float: false; digits: [9, 8, 7, 6, 5] }
  *
  * // Scientific notation numeric literals (auto-expanded)
- * type J = DigitsTuple<5e3>;      // 5e3 → 5000
+ * type J = DigitsTuple<5e3>; // `5e3` is same like `5000`
  * // ➔ { negative: false; bigint: false; float: false; digits: [5, 0, 0, 0] }
- * type K = DigitsTuple<-2.5e2>;   // -2.5e2 → -250
+ * type K = DigitsTuple<-2.5e2>; // `-2.5e2` is same like `-250`
  * // ➔ { negative: true; bigint: false; float: true; digits: [2, 5, 0] }
  * ```
  */
 type DigitsTuple<T extends number|bigint>={negative:`${T}`extends`-${string}`?true:false;float:IsFloat<Extract<T,number>>extends true?true:false;bigint:T extends bigint?true:false;digits:Split<ReplaceAll<Stringify<Abs<T>>,[".","n"],"">>extends infer R?{[K in keyof R]:R[K] extends string?ParseNumber<R[K]>:never;}:never;};
 /** -------------------------------------------------------
- * * ***ReturnItselfIfExtends***
+ * * ***Utility Type: `ReturnItselfIfExtends`.***
  * -------------------------------------------------------
- *
- * A conditional type that returns:
- * - `Else` if `T` extends `Base`,
- * - `T` itself if `T` does **not** extend `Base`,
- * - `IfANever` if `T` is `never`.
- *
- * This utility is useful when you want to **narrow types by extension**,
+ * **This utility is useful when you want to **narrow types by extension**,
  * replacing them with a fallback if they match a given base constraint,
- * while preserving them otherwise.
- *
+ * while preserving them otherwise.**
+ * - **A conditional type that returns:**
+ *    - `Else` if `T` extends `Base`.
+ *    - `T` itself if `T` does extend `Base`.
+ *    - `IfANever` if `T` is `never`.
  * @template T - The type to check.
  * @template Base - The base type to test against.
  * @template Else - The type to return if `T` extends `Base`.
  * @template IfANever - The type to return if `T` or `Base` is `never` (default: `never`).
- *
  * @example
  * ```ts
  * type Case1 = ReturnItselfIfExtends<1, number, 2>
@@ -1693,22 +1582,18 @@ type DigitsTuple<T extends number|bigint>={negative:`${T}`extends`-${string}`?tr
  */
 type ReturnItselfIfExtends<T,Base,Else,IfANever=never>=IfNever<If<Extends<Or<Base,T>,true>,never>,IfANever,T extends Base?T:Else>;
 /** -------------------------------------------------------
- * * ***ReturnItselfIfNotExtends***
+ * * ***Utility Type: `ReturnItselfIfNotExtends`.***
  * -------------------------------------------------------
- *
- * A conditional type that returns:
- * - `Else` if `T` extends `Base`,
- * - `T` itself if `T` does **not** extend `Base`,
- * - `IfANever` if `T` is `never`.
- *
- * This utility is useful for preserving a type unless it matches
- * a broader constraint, in which case it is replaced with a fallback.
- *
+ * **This utility is useful for preserving a type unless it matches
+ * a broader constraint, in which case it is replaced with a fallback.**
+ * - **A conditional type that returns:**
+ *    - `Else` if `T` extends `Base`.
+ *    - `T` itself if `T` does **not** extend `Base`.
+ *    - `IfANever` if `T` is `never`.
  * @template T - The type to check.
  * @template Base - The base type to test against.
  * @template Else - The type to return if `T` extends `Base`.
  * @template IfANever - The type to return if `T` or `Base` is `never` (default: `never`).
- *
  * @example
  * ```ts
  * type Case1 = ReturnItselfIfNotExtends<'1', number, 2>
@@ -1725,14 +1610,15 @@ type ReturnItselfIfExtends<T,Base,Else,IfANever=never>=IfNever<If<Extends<Or<Bas
  */
 type ReturnItselfIfNotExtends<T,Base,Else,IfANever=never>=IfNever<If<Extends<Or<Base,T>,true>,never>,IfANever,T extends Base?Else:T>;type MultiplicationMap={0:[0,0,0,0,0,0,0,0,0,0];1:[0,1,2,3,4,5,6,7,8,9];2:[0,2,4,6,8,10,12,14,16,18];3:[0,3,6,9,12,15,18,21,24,27];4:[0,4,8,12,16,20,24,28,32,36];5:[0,5,10,15,20,25,30,35,40,45];6:[0,6,12,18,24,30,36,42,48,54];7:[0,7,14,21,28,35,42,49,56,63];8:[0,8,16,24,32,40,48,56,64,72];9:[0,9,18,27,36,45,54,63,72,81];};type _MultiSingle<Num1 extends string,DigitOfNum2 extends keyof MultiplicationMap,Carry extends number=0,Result extends string="">=IsEmptyString<Num1>extends true?ReturnItselfIfNotExtends<RemoveLeading<`${Carry}${Result}`,"0">,"","0">:IsEqual<Num1,0>extends true?"0":IsEqual<DigitOfNum2,0>extends true?"0":LastCharacter<Num1,{includeRest:true;}>extends [ infer Num1LastCharacter extends string,infer Num1Rest extends string]?Stringify<Sum<MultiplicationMap[DigitOfNum2][ParseNumber<Num1LastCharacter>& keyof MultiplicationMap[DigitOfNum2]],Carry>>extends infer Multiplied extends string?LastCharacter<Multiplied,{includeRest:true;}>extends [ infer MultipliedLastDigit extends string,infer MultipliedRest extends string]?_MultiSingle<Num1Rest,DigitOfNum2,If<IsNever<ParseNumber<MultipliedRest>>,0,ParseNumber<MultipliedRest>>,`${MultipliedLastDigit}${Result}`>:never:never:never;type _Multi<Num1 extends string,Num2 extends string,Result extends string="",Iteration extends unknown[]=[]>=IsEmptyString<Num2>extends true?Result:LastCharacter<Num2,{includeRest:true;}>extends [ infer Num2LastCharacter extends string,infer Num2Rest extends string]?ParseNumber<Num2LastCharacter>extends infer Num2Digit extends keyof MultiplicationMap?_Multi<Num1,Num2Rest,Stringify<_Sum<Result,ReturnItselfIfNotExtends<RemoveLeading<`${_MultiSingle<Num1, Num2Digit>}${Repeat<"0", Iteration["length"]>}`,"0">,"","0">>>,Push<Iteration,unknown>>:never:Result;
 /** -------------------------------------------------------
- * * ***Multi.***
+ * * ***Utility Type: `Multi`.***
  * -------------------------------------------------------
- * Accepts two integers and returns their **multiplication**.
- *
- * - Works with integers within the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * - Handles negative numbers automatically.
- * - Uses internal type-level recursion to simulate multiplication of digit strings.
- *
+ * **Accepts two integers and returns their **multiplication**.**
+ * - **Behavior:**
+ *    - Handles negative numbers automatically.
+ *    - Uses internal type-level recursion to simulate multiplication of
+ *      digit strings.
+ *    - Works with integers within the range:
+ *      - `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template Num1 - The first integer (can be negative).
  * @template Num2 - The second integer (can be negative).
  * @example
@@ -1744,20 +1630,19 @@ type ReturnItselfIfNotExtends<T,Base,Else,IfANever=never>=IfNever<If<Extends<Or<
  * type Case5 = Multi<123, 45>; // ➔ 5535
  * ```
  * @note
- * Internal helpers:
- * - `_Multi` ➔ Recursively multiplies digit strings and accumulates the result.
- * - `_MultiSingle` ➔ Multiplies a string-number with a single digit, handling carry.
+ * - ***Internal helpers:***
+ *     - `_Multi` ➔ Recursively multiplies digit strings and accumulates the result.
+ *     - `_MultiSingle` ➔ Multiplies a string-number with a single digit, handling carry.
  */
 type Multi<Num1 extends number,Num2 extends number>=IsEqual<Num1,0>extends true?0:IsEqual<Num2,0>extends true?0:ParseNumber<_Multi<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>extends infer Result extends number?IfNegative<Num1,IfNegative<Num2,Result,Negate<Result>>,IfNegative<Num2,Negate<Result>,Result>>:never;type _FindQuotient<Dividend extends number,Divisor extends number,CurrentQuotient extends number>=Multi<Divisor,CurrentQuotient>extends infer Product extends number?IsEqual<Dividend,Product>extends true?CurrentQuotient:IsLowerThan<Dividend,Product>extends true?_FindQuotient<Dividend,Divisor,Decrement<CurrentQuotient>>:CurrentQuotient:never;type _Div<Dividend extends string,Divisor extends number,Result extends string="",CurrentDividend extends string="",IterationsWithoutDivision extends number=0,HadFirstDivision extends boolean=false>=Or<IsEmptyString<CurrentDividend>,IsLowerThan<ParseNumber<CurrentDividend>,Divisor>>extends true?IsEmptyString<Dividend>extends true?ParseNumber<If<And<HadFirstDivision,IsNotEqual<IterationsWithoutDivision,0>>,`${Result}0`,Result>>:Dividend extends`${infer FirstDigit extends string}${infer Rest extends string}`?_Div<Rest,Divisor,If<And<HadFirstDivision,IsNotEqual<IterationsWithoutDivision,0>>,`${Result}0`,Result>,IfEqual<CurrentDividend,"0",FirstDigit,`${CurrentDividend}${FirstDigit}`>,Increment<IterationsWithoutDivision>,HadFirstDivision>:never:_FindQuotient<ParseNumber<CurrentDividend>,Divisor,10>extends infer Quotient extends number?IsNever<Quotient>extends true?ParseNumber<Result>:Sub<ParseNumber<CurrentDividend>,Multi<Quotient,Divisor>>extends infer Remainder extends number?_Div<Dividend,Divisor,`${Result}${Quotient}`,IfGreaterThan<Remainder,0,`${Remainder}`,"">,0,true>:never:never;
 /** -------------------------------------------------------
- * * ***Div.***
+ * * ***Utility Type: `Div`.***
  * -------------------------------------------------------
- * A type-level utility that returns the integer division of two numbers.
- * Handles negative numbers correctly and returns `never` if dividing by zero.
- *
- * - Returns `0` if the absolute value of dividend is smaller than divisor.
- * - Preserves the sign according to standard integer division rules.
- *
+ * **A type-level utility that returns the integer division of two numbers.
+ * Handles negative numbers correctly and returns `never` if dividing by zero.**
+ * - **Behavior:**
+ *    - Returns `0` if the absolute value of dividend is smaller than divisor.
+ *    - Preserves the sign according to standard integer division rules.
  * @template Dividend - The dividend number.
  * @template Divisor - The divisor number.
  * @example
@@ -1774,14 +1659,15 @@ type Multi<Num1 extends number,Num2 extends number>=IsEqual<Num1,0>extends true?
  */
 type Div<Dividend extends number,Divisor extends number>=IsEqual<Divisor,0>extends true?never:IsEqual<Dividend,0>extends true?0:IsEqual<Dividend,Divisor>extends true?1:IsLowerThan<Abs<Dividend>,Abs<Divisor>>extends true?0:_Div<Stringify<Abs<Dividend>>,Abs<Divisor>>extends infer Quotient extends number?If<Or<And<IsNegative<Dividend>,IsNegative<Divisor>>,And<IsPositive<Dividend>,IsPositive<Divisor>>>,Quotient,Negate<Quotient>>:never;
 /** -------------------------------------------------------
- * * ***Dot.***
+ * * ***Utility Type: `Dot`.***
  * -------------------------------------------------------
- * A type-level utility that concatenates two string literals with a `.`.
- * - If the `Trims` flag is `true` (default), leading and trailing spaces in both strings are trimmed before concatenation.
- * - If the second string literal is empty, it returns the first string literal.
- * - If the first string literal is empty, it returns the second string literal.
- * - Otherwise, it returns `${T}.${U}` (trimmed if `Trims` is `true`).
- *
+ * **A type-level utility that concatenates two string literals with a `.`.**
+ * - **Behavior:**
+ *    - If the `Trims` flag is `true` (default), leading and trailing spaces in
+ *      both strings are trimmed before concatenation.
+ *    - If the second string literal is empty, it returns the first string literal.
+ *    - If the first string literal is empty, it returns the second string literal.
+ *    - Otherwise, it returns `${T}.${U}` (trimmed if `Trims` is `true`).
  * @template T - The first string literal.
  * @template U - The second string literal.
  * @template Trims - Whether to trim whitespace from the inputs before concatenation (default: `true`).
@@ -1801,13 +1687,13 @@ type Div<Dividend extends number,Divisor extends number>=IsEqual<Divisor,0>exten
  */
 type Dot<T extends string,U extends string,Trims extends boolean=true>=Extends<Trims,true>extends true?""extends Trim<U>?Trim<T>:""extends Trim<T>?`${Trim<U>}`:`${Trim<T>}.${Trim<U>}`:""extends U?T:`${T}.${U}`;
 /** -------------------------------------------------------
- * * ***DotArray.***
+ * * ***Utility Type: `DotArray`.***
  * -------------------------------------------------------
- * A type-level utility that concatenates an array of string literals with a `.`.
- * - Skips empty strings in the array.
- * - If `Trims` is `true` (default), trims whitespace from each element.
- * - Returns a single string literal.
- *
+ * **A type-level utility that concatenates an array of string literals with a `.`.**
+ * - **Behavior:**
+ *    - Skips empty strings in the array.
+ *    - If `Trims` is `true` (default), trims whitespace from each element.
+ *    - Returns a single string literal.
  * @template Arr - An array of string literals.
  * @template Trims - Whether to trim whitespace from each element (default: `true`).
  * @example
@@ -1826,11 +1712,10 @@ type Dot<T extends string,U extends string,Trims extends boolean=true>=Extends<T
  */
 type DotArray<Arr extends string[],Trims extends boolean=true>=Arr extends [ infer Head extends string,...infer Tail extends string[]]?Head extends""?DotArray<Tail,Trims>:`${Trims extends true ? Trim<Head> : Head}${Tail extends [] ? "" : `.${DotArray<Tail,Trims>}`}`:"";
 /** -------------------------------------------------------
- * * ***EndsWith.***
+ * * ***Utility Type: `EndsWith`.***
  * -------------------------------------------------------
- * A type-level utility that returns a boolean indicating
- * whether the first string literal ends with the ***second one***.
- *
+ * **A type-level utility that returns a boolean indicating
+ * whether the first string literal ends with the ***second one***.**
  * @template T - The string to check.
  * @template C - The ***ending string*** to match.
  * @example
@@ -1843,16 +1728,13 @@ type DotArray<Arr extends string[],Trims extends boolean=true>=Arr extends [ inf
  */
 type EndsWith<T extends string,C extends string>=T extends`${infer _}${C}`?true:false;
 /** --------------------------------------------------
- * * ***ExcludeStrict.***
+ * * ***Utility Type: `ExcludeStrict`.***
  * --------------------------------------------------
- * Performs a stricter version of `Exclude<T, U>` with improved type narrowing.
- *
- * ✅ Especially useful in generic libraries or utility types
+ * **Performs a stricter version of `Exclude<T, U>` with improved type narrowing.**
+ * - ✅ Especially useful in generic libraries or utility types
  *    where standard `Exclude` may collapse or widen types unintentionally.
- *
  * @template T - The full union or set of types.
  * @template U - The type(s) to be excluded from `T`.
- *
  * @example
  * ```ts
  * type A = 'a' | 'b' | 'c';
@@ -1862,12 +1744,12 @@ type EndsWith<T extends string,C extends string>=T extends`${infer _}${C}`?true:
  */
 type ExcludeStrict<T,U extends T>=T extends unknown?0 extends(U extends T?([T] extends [U]?0:never):never)?never:T:never;type _Factorial<T extends number,CurrentNum extends number=1,CurrentProduct extends number=1>=IsEqual<T,CurrentNum>extends true?Multi<CurrentProduct,CurrentNum>:_Factorial<T,Increment<CurrentNum>,Multi<CurrentProduct,CurrentNum>>;
 /** -------------------------------------------------------
- * * ***Factorial.***
+ * * ***Utility Type: `Factorial`.***
  * -------------------------------------------------------
- * Accepts an integer argument and returns its ***mathematical factorial***.
- * - Valid range: `[0, 21]`
- * - Negative numbers or `number` type result in `never`.
- *
+ * **Accepts an integer argument and returns its ***mathematical factorial***.**
+ * - **Behavior:**
+ *    - Valid range: `[0, 21]`.
+ *    - Negative numbers or `number` type result in `never`.
  * @template T - The integer to compute factorial for.
  * @example
  * ```ts
@@ -1883,12 +1765,13 @@ type ExcludeStrict<T,U extends T>=T extends unknown?0 extends(U extends T?([T] e
  */
 type Factorial<T extends number>=number extends T?never:IsNegative<T>extends true?never:IsEqual<T,0>extends true?1:_Factorial<T>;
 /** -------------------------------------------------------
- * * ***Fibonacci.***
+ * * ***Utility Type: `Fibonacci`.***
  * -------------------------------------------------------
- * A type-level utility that computes the ***Fibonacci number*** at a given index `T`.
- * - Returns `never` for negative numbers.
- * - Supports indices in the range `[0, 78]` due to TypeScript recursion limits.
- *
+ * **A type-level utility that computes the ***Fibonacci number*** at a given
+ * index `T`.**
+ * - **Behavior:**
+ *    - Returns `never` for negative numbers.
+ *    - Supports indices in the range `[0, 78]` due to TypeScript recursion limits.
  * @template T - The index of the Fibonacci sequence.
  * @example
  * ```ts
@@ -1901,29 +1784,17 @@ type Factorial<T extends number>=number extends T?never:IsNegative<T>extends tru
  * ```
  */
 type Fibonacci<T extends number>=IsNegative<T>extends true?never:IsLowerThan<T,2>extends true?T:Fibonacci<Decrement<T>>extends infer NMinusOne extends number?Fibonacci<Sub<T,2>>extends infer NMinusTwo extends number?Sum<NMinusOne,NMinusTwo>:never:never;
-/** -------------------------------------------------------
- * * ***FirstCharacterOptions***
- * -------------------------------------------------------
- *
- * Configuration options for the {@link FirstCharacter} type-level utility.
- *
- * @default
- * ```ts
- * { includeRest: false }
- * ```
- *
- * @example
- * ```ts
- * type Opt1 = FirstCharacterOptions;
- * // ➔ { includeRest: boolean }
- * ```
+/** ---------------------------------------------------------------------------
+ * * ***Type Options for {@link FirstCharacter | `FirstCharacter`}.***
+ * ---------------------------------------------------------------------------
+ * **Configuration options for the {@link FirstCharacter | `FirstCharacter`} type-level utility.**
  */
 type FirstCharacterOptions={
-/** Whether to include the rest of the string in the result tuple.
- *
- * - `true` → returns `[first character, rest of string]`
- * - `false` → returns only the first character
+/** * ***Whether to include the rest of the string in the result tuple.***
  *
+ * - **Behavior:**
+ *    - `true` ➔ returns `[first character, rest of string]`.
+ *    - `false` ➔ returns only the first character.
  * @default false
  * @example
  * ```ts
@@ -1933,12 +1804,13 @@ type FirstCharacterOptions={
  */
 includeRest:boolean;};
 /** -------------------------------------------------------
- * * ***FirstCharacter.***
+ * * ***Utility Type: `FirstCharacter`.***
  * -------------------------------------------------------
- * Accepts a string literal and returns its first character.
- * - If `Options["includeRest"]` is `true`, it returns a tuple: `[first character, rest of string]`.
- * - Otherwise, it returns only the first character.
- *
+ * **Accepts a string literal and returns its first character.**
+ * - **Behavior:**
+ *    - If `Options["includeRest"]` is `true`, it returns a
+ *      tuple: `[first character, rest of string]`.
+ *    - Otherwise, it returns only the first character.
  * @template T - The string literal to process.
  * @template Options - Configuration options (default: `{ includeRest: false }`).
  *   - `includeRest: boolean` — Whether to include the rest of the string in a tuple.
@@ -1956,21 +1828,18 @@ includeRest:boolean;};
  */
 type FirstCharacter<T extends string,Options extends FirstCharacterOptions={includeRest:false;}>=T extends`${infer First extends string}${infer Rest extends string}`?If<Options["includeRest"],[First,Rest],First>:never;
 /** -------------------------------------------------------
- * * ***FirstDigit.***
+ * * ***Utility Type: `FirstDigit`.***
  * -------------------------------------------------------
- * Extracts the **first digit** of a given number `T`.
- *
+ * **Extracts the **first digit** of a given number `T`.**
+ * - **Behavior:**
+ *    - Works with integers and decimals.
+ *    - Handles negative numbers (`-123` ➔ `-1`).
+ *    - Handles `0` and `-0` correctly (always returns `0`).
+ *    - Works with bigint literals too.
  * @template T - A number or bigint to extract the first digit from.
  * @template Options - Optional settings.
  * - `alwaysPositive?: boolean` (default: `false`)
  *   If `true`, the result is always positive regardless of the sign.
- *
- * ### Behavior
- * - Works with integers and decimals.
- * - Handles negative numbers (`-123` → `-1`).
- * - Handles `0` and `-0` correctly (always returns `0`).
- * - Works with bigint literals too.
- *
  * @example
  * ```ts
  * type A = FirstDigit<0>;      // ➔ 0
@@ -1995,10 +1864,10 @@ type FirstDigit<T extends number|bigint,Options extends{
  */
 alwaysPositive?:boolean;}={alwaysPositive:false;}>=DigitsTuple<T>["digits"] extends readonly [infer First extends number,...unknown[]]?Options["alwaysPositive"] extends true?First:DigitsTuple<T>["negative"] extends true?Negate<First>:First:never;
 /** -------------------------------------------------------
- * * ***Floor.***
+ * * ***Utility Type: `Floor`.***
  * -------------------------------------------------------
- * Type-level equivalent of `Math.floor()`. Returns the ***floored value*** of the passed number.
- *
+ * **Type-level equivalent of `Math.floor()`.**
+ * - Returns the ***floored value*** of the passed number.
  * @template T - A number type.
  * @example
  * ```ts
@@ -2010,15 +1879,12 @@ alwaysPositive?:boolean;}={alwaysPositive:false;}>=DigitsTuple<T>["digits"] exte
  */
 type Floor<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extends [infer Whole extends number,unknown]?IsNegative<T>extends true?Negate<Increment<Whole>>:Whole:never:T;
 /** --------------------------------------------------
- * * ***Identity.***
+ * * ***Utility Type: `Identity`.***
  * --------------------------------------------------
- * Identity utility type that preserves the structure and inference of type `T`.
- *
- * ✅ Commonly used to force TypeScript to expand a mapped or intersection type
+ * **Identity utility type that preserves the structure and inference of type `T`.**
+ * - ✅ Commonly used to force TypeScript to expand a mapped or intersection type
  *    into a more readable and usable shape.
- *
  * @template T - The type to preserve and normalize.
- *
  * @example
  * ```ts
  * type A = { a: string; b: number };
@@ -2026,7 +1892,12 @@ type Floor<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extend
  * // ➔ { a: string; b: number }
  * ```
  */
-type Identity<T>={[P in keyof T]:T[P];};type ShiftOptions={
+type Identity<T>={[P in keyof T]:T[P];};
+/** ---------------------------------------------------------------------------
+ * * ***Type Options for {@link Shift | `Shift`}.***
+ * ---------------------------------------------------------------------------
+ */
+type ShiftOptions={
 /**
  * If `true`, return both the rest of the array and the removed element
  * as a tuple `[Rest, Removed]`.
@@ -2037,19 +1908,16 @@ type Identity<T>={[P in keyof T]:T[P];};type ShiftOptions={
  */
 includeRemoved:boolean;};
 /** -------------------------------------------------------
- * * ***Shift.***
+ * * ***Utility Type: `Shift`.***
  * -------------------------------------------------------
- * Removes the first element from the array type `T`.
- *
- * Behavior:
- * - By default (`includeRemoved: false`), returns the array without the first element.
- * - If `includeRemoved: true`, returns a tuple `[Rest, Removed]`:
- *   - `Rest`: the remaining array
- *   - `Removed`: the removed first element
- *
+ * **Removes the first element from the array type `T`.**
+ * - **Behavior:**
+ *    - By default (`includeRemoved: false`), returns the array without the first element.
+ *    - If `includeRemoved: true`, returns a tuple `[Rest, Removed]`:
+ *      - `Rest`: the remaining array.
+ *      - `Removed`: the removed first element.
  * @template T - The array type to operate on.
  * @template Options - Optional flags. Default `{ includeRemoved: false }`.
- *
  * @example
  * ```ts
  * // Default: just remove first element
@@ -2067,26 +1935,23 @@ includeRemoved:boolean;};
  */
 type Shift<T extends readonly unknown[],Options extends ShiftOptions={includeRemoved:false;}>=T extends readonly [infer Removed,...infer Rest extends readonly unknown[]]?If<Options["includeRemoved"],[Rest,Removed],Rest>:never;
 /** -------------------------------------------------------
- * * ***Includes.***
+ * * ***Utility Type: `Includes`.***
  * -------------------------------------------------------
- * Returns a boolean whether the second argument is in the first array argument.
- *
+ * **Returns a boolean whether the second argument is in the first array argument.**
  * @template T - The array to check.
  * @template Pivot - The value to look for.
  * @example
  * ```ts
- * // true
- * type Case1 = Includes<[1, 2, 3], 1>;  // ➔ true
- * // false
- * type Case2 = Includes<[1, 2, 3], 4>;  // ➔ false
+ * type Case1 = Includes<[1, 2, 3], 1>; // ➔ true
+ * type Case2 = Includes<[1, 2, 3], 4>; // ➔ false
  * ```
  */
 type Includes<T extends readonly unknown[],Pivot>=IsEmptyArray<T>extends true?false:Shift<T,{includeRemoved:true;}>extends [ infer Rest extends readonly unknown[],infer Removed]?IfEqual<Pivot,Removed,true,Includes<Rest,Pivot>>:false;type _IndexOfArray<T extends readonly unknown[],Pivot,Index extends number=0>=T extends readonly [infer First,...infer Rest extends unknown[]]?IsEqual<First,Pivot>extends true?Index:_IndexOfArray<Rest,Pivot,Increment<Index>>:-1;type _IndexOfString<T extends string,Pivot,Index extends number=0>=T extends`${infer First}${infer Rest extends string}`?IsEqual<First,Pivot>extends true?Index:_IndexOfString<Rest,Pivot,Increment<Index>>:-1;
 /** -------------------------------------------------------
- * * ***IndexOf.***
+ * * ***Utility Type: `IndexOf`.***
  * --------------------------------------------------------
- * Type version of `Array.prototype.indexOf()` and `String.prototype.indexOf()`. Returns the index of the second argument in the first argument.
- *
+ * **Type version of `Array.prototype.indexOf()` and `String.prototype.indexOf()`.**
+ * - Returns the index of the second argument in the first argument.
  * @example
  * ```ts
  * type Case1 = IndexOf<[1, 2, 3], 2>; // ➔ 1
@@ -2097,30 +1962,27 @@ type Includes<T extends readonly unknown[],Pivot>=IsEmptyArray<T>extends true?fa
  */
 type IndexOf<T extends readonly unknown[]|string,Pivot extends T extends string?string:unknown>=T extends string?IsStringLiteral<T>extends true?_IndexOfString<T,Pivot>:never:T extends readonly unknown[]?IsTuple<T>extends true?_IndexOfArray<T,Pivot>:never:never;
 /** -------------------------------------------------------
- * * ***IsArrayIndex.***
+ * * ***Utility Type: `IsArrayIndex`.***
  * -------------------------------------------------------
- * Returns a boolean whether the passed argument is a valid array index.
- *
+ * **Returns a boolean whether the passed argument is a valid array index.**
  * @example
  * ```ts
- * // truthy
  * type Case1 = IsArrayIndex<1>;   // ➔ true
  * type Case2 = IsArrayIndex<'1'>; // ➔ true
- *
- * // falsy
  * type Case3 = IsArrayIndex<-1>;  // ➔ false
  * type Case4 = IsArrayIndex<"a">; // ➔ false
  * ```
  */
 type IsArrayIndex<T>=T extends number?And<IsInteger<T>,IsGreaterOrEqual<T,0>>:T extends string?ParseNumber<T>extends infer NumT extends number?Not<IsNever<NumT>>extends true?And<IsInteger<NumT>,IsGreaterOrEqual<NumT,0>>:false:false:never;
 /** -------------------------------------------------------
- * * ***Mod.***
+ * * ***Utility Type: `Mod`.***
  * -------------------------------------------------------
- * Returns the **remainder** of the division of two numbers (`Dividend % Divisor`).
- *
- * - Computes the remainder using type-level arithmetic: `Dividend - (Divisor * (Dividend / Divisor))`.
- * - Works with integers within the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
+ * **Returns the **remainder** of the division of two numbers (`Dividend % Divisor`).**
+ * - **Behavior:**
+ *    - Computes the remainder using type-level arithmetic:
+ *      - `Dividend - (Divisor * (Dividend / Divisor))`.
+ *    - Works with integers within the range:
+ *      - `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
  * @template Dividend - The dividend (numerator).
  * @template Divisor - The divisor (denominator).
  * @example
@@ -2133,113 +1995,114 @@ type IsArrayIndex<T>=T extends number?And<IsInteger<T>,IsGreaterOrEqual<T,0>>:T
  */
 type Mod<Dividend extends number,Divisor extends number>=Div<Dividend,Divisor>extends infer Quotient extends number?Multi<Quotient,Divisor>extends infer Product extends number?Sub<Dividend,Product>:never:never;
 /** -------------------------------------------------------
- * * ***IsDivisibleByTwo.***
+ * * ***Utility Type: `IsDivisibleByTwo`.***
  * -------------------------------------------------------
- * Accepts an integer argument and returns a boolean whether it is divisible by two.
+ * **Accepts an integer argument and returns a boolean whether it is divisible by two.**
  *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @example
  * // truthy
  * type Case1 = IsDivisibleByTwo<4>;  // ➔ true
- * type Case2 = IsDivisibleByTwo<-4>; // ➔ true
+ * type Case2 = IsDivisibleByTwo<-6>; // ➔ true
  *
  * // falsy
- * type Case3 = IsDivisibleByTwo<-1>; // ➔ false
+ * type Case3 = IsDivisibleByTwo<3>;  // ➔ false
+ * type Case4 = IsDivisibleByTwo<-5>; // ➔ false
  */
 type IsDivisibleByTwo<T extends number>=IsEven<T>;type DivisibleByThreeMap={3:true;6:true;9:true;};type _IsDivisibleByThree<T extends number>=DigitsTuple<Abs<T>>["digits"] extends infer Digits extends readonly number[]?IsEqual<Digits["length"],1>extends true?Digits[0] extends keyof DivisibleByThreeMap?true:false:SumArr<Digits>extends infer DigitsSum extends number?IfLowerThan<DigitsSum,3>extends true?false:_IsDivisibleByThree<DigitsSum>:never:never;
 /** -------------------------------------------------------
- * * ***IsDivisibleByThree.***
+ * * ***Utility Type: `IsDivisibleByThree`.***
  * -------------------------------------------------------
- * Accepts an integer argument and returns a boolean whether it is divisible by three.
+ * **Accepts an integer argument and returns a boolean whether it is divisible by three.**
  *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @example
  * // truthy
  * type Case1 = IsDivisibleByThree<123>;  // ➔ true
- * type Case2 = IsDivisibleByThree<-123>; // ➔ true
+ * type Case2 = IsDivisibleByThree<-126>; // ➔ true
  *
  * // falsy
- * type Case3 = IsDivisibleByThree<124>; // ➔ false
+ * type Case3 = IsDivisibleByThree<124>;  // ➔ false
+ * type Case4 = IsDivisibleByThree<-128>; // ➔ false
  */
 type IsDivisibleByThree<T extends number>=_IsDivisibleByThree<T>;
 /** -------------------------------------------------------
- * * ***IsDivisibleByFive.***
+ * * ***Utility Type: `IsDivisibleByFive`.***
  * -------------------------------------------------------
- * Accepts an integer argument and returns a boolean whether it is divisible by five.
+ * **Accepts an integer argument and returns a boolean whether it is divisible by five.**
  *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @example
  * // truthy
  * type Case1 = IsDivisibleByFive<125>;  // ➔ true
- * type Case2 = IsDivisibleByFive<-125>; // ➔ true
+ * type Case2 = IsDivisibleByFive<-115>; // ➔ true
  *
  * // falsy
- * type Case3 = IsDivisibleByFive<-13>; // ➔ false
+ * type Case3 = IsDivisibleByFive<13>;  // ➔ false
+ * type Case4 = IsDivisibleByFive<-17>; // ➔ false
  */
 type IsDivisibleByFive<T extends number>=EndsWith<Stringify<T>,"0"|"5">;
 /** -------------------------------------------------------
- * * ***IsDivisibleBySix.***
+ * * ***Utility Type: `IsDivisibleBySix`.***
  * -------------------------------------------------------
- * Accepts an integer argument and returns a boolean whether it is divisible by six.
+ * **Accepts an integer argument and returns a boolean whether it is divisible by six.**
  *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @example
  * // truthy
  * type Case1 = IsDivisibleBySix<126>;  // ➔ true
- * type Case2 = IsDivisibleBySix<-126>; // ➔ true
+ * type Case2 = IsDivisibleBySix<-156>; // ➔ true
  *
  * // falsy
- * type Case3 = IsDivisibleBySix<124>; // ➔ false
+ * type Case3 = IsDivisibleBySix<124>;  // ➔ false
+ * type Case4 = IsDivisibleBySix<-139>; // ➔ false
  */
 type IsDivisibleBySix<T extends number>=And<IsDivisibleByTwo<T>,IsDivisibleByThree<T>>;
 /** -------------------------------------------------------
- * * ***IsDivisibleByTen.***
+ * * ***Utility Type: `IsDivisibleByTen`.***
  * -------------------------------------------------------
- * Accepts an integer argument and returns a boolean whether it is divisible by ten.
+ * **Accepts an integer argument and returns a boolean whether it is divisible by ten.**
  *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @example
  * // truthy
- * type Case1 = IsDivisibleByTen<100>;  // ➔ true
- * type Case2 = IsDivisibleByTen<-100>; // ➔ true
+ * type Case1 = IsDivisibleByTen<100>; // ➔ true
+ * type Case2 = IsDivisibleByTen<-80>; // ➔ true
  *
  * // falsy
  * type Case3 = IsDivisibleByTen<101>; // ➔ false
+ * type Case4 = IsDivisibleByTen<-72>; // ➔ false
  */
 type IsDivisibleByTen<T extends number>=EndsWith<Stringify<T>,"0">;
 /** -------------------------------------------------------
- * * ***IsDivisibleByHundred.***
+ * * ***Utility Type: `IsDivisibleByHundred`.***
  * -------------------------------------------------------
- * Accepts an integer argument and returns a boolean whether it is divisible by hundred.
+ * **Accepts an integer argument and returns a boolean whether it is divisible by hundred.**
  *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @example
  * // truthy
  * type Case1 = IsDivisibleByHundred<100>;  // ➔ true
- * type Case2 = IsDivisibleByHundred<-100>; // ➔ true
+ * type Case2 = IsDivisibleByHundred<-300>; // ➔ true
  *
  * // falsy
- * type Case3 = IsDivisibleByHundred<101>; // ➔ false
+ * type Case3 = IsDivisibleByHundred<101>;  // ➔ false
+ * type Case4 = IsDivisibleByHundred<-210>; // ➔ false
  */
 type IsDivisibleByHundred<T extends number>=EndsWith<Stringify<T>,"00">;
 /** -------------------------------------------------------
- * * ***IsDivisible.***
+ * * ***Utility Type: `IsDivisible`.***
  * -------------------------------------------------------
- * Returns a boolean whether the first integer argument is divisible by the second integer argument.
- *
+ * **Returns a boolean whether the first integer argument is divisible by the
+ * second integer argument.**
  * @example
  * // truthy
  * type Case1 = IsDivisible<1024, 2>; // ➔ true
+ * type Case2 = IsDivisible<2034, 3>; // ➔ true
  *
  * // falsy
- * type Case2 = IsDivisible<1023, 2>; // ➔ false
+ * type Case3 = IsDivisible<1023, 2>; // ➔ false
+ * type Case4 = IsDivisible<3034, 3>; // ➔ false
  */
 type IsDivisible<Dividend extends number,Divisor extends number>=IsEqual<Mod<Dividend,Divisor>,0>;
 /** -------------------------------------------------------
- * * ***IsLetter.***
+ * * ***Utility Type: `IsLetter`.***
  * -------------------------------------------------------
- * Returns a boolean whether the passed argument is a letter (Only for letters that have both upper and lower case)
- *
+ * **Returns a boolean whether the passed argument is a letter (Only for letters that have both upper and lower case).**
  * @template T - The string to check.
  * @example
  * type Case1 = IsLetter<'a'>; // ➔ true
@@ -2247,10 +2110,9 @@ type IsDivisible<Dividend extends number,Divisor extends number>=IsEqual<Mod<Div
  */
 type IsLetter<T extends string>=Uppercase<T>extends Lowercase<T>?false:true;type _IsUnion<T,U=T>=IsNever<T>extends true?false:T extends U?Not<IsNever<Exclude<U,T>>>:false;
 /** -------------------------------------------------------
- * * ***IsUnion.***
+ * * ***Utility Type: `IsUnion`.***
  * -------------------------------------------------------
- * Returns a boolean whether the passed argument is a union.
- *
+ * **Returns a boolean whether the passed argument is a union.**
  * @template T - The type to check.
  * @example
  * type Case1 = IsUnion<'a' | 'b'>;
@@ -2260,12 +2122,11 @@ type IsLetter<T extends string>=Uppercase<T>extends Lowercase<T>?false:true;type
  */
 type IsUnion<T>=_IsUnion<T,T>;
 /** -------------------------------------------------------
- * * ***Join.***
+ * * ***Utility Type: `Join`.***
  * -------------------------------------------------------
- * Type version of `Array.prototype.join()`.
+ * **Type version of `Array.prototype.join()`.**
  * - Joins the first array argument by the second argument.
- *
- * @template T - The array to join
+ * @template T - The array to join.
  * @template Glue - The string or number to join with, defaultValue: `""`.
  * @example
  * type Case0 = Join<["p", "e", "a", "r"]>;
@@ -2281,15 +2142,13 @@ type IsUnion<T>=_IsUnion<T,T>;
  */
 type Join<T extends readonly(string|number)[],Glue extends string|number="">=IsTuple<T>extends true?T extends readonly [ infer First extends string|number,...infer Rest extends readonly(string|number)[]]?IfEmptyArray<Rest,First,`${First}${Glue}${Join<Rest, Glue>}`>:never:never;
 /** --------------------------------------------------
- * * ***AnyRecord.***
+ * * ***Utility Type: `AnyRecord`.***
  * --------------------------------------------------
- * Represents an object with arbitrary string keys and values of **any** type.
- *
- * ⚠️ Use with caution — `any` disables type safety. Prefer stricter typing when possible.
- *
- * ✅ Commonly used as a fallback for flexible key-value structures
+ * **Represents an object with arbitrary string keys and values of **any** type.**
+ * - ⚠️ **Use with caution — `any`** disables type safety.
+ *    - Prefer stricter like {@link UnknownRecord | **`UnknownRecord`**} typing when possible.
+ * - ✅ Commonly used as a fallback for flexible key-value structures
  *    such as query parameters, configuration maps, or JSON-like data.
- *
  * @example
  * ```ts
  * const config: AnyRecord = {
@@ -2301,16 +2160,13 @@ type Join<T extends readonly(string|number)[],Glue extends string|number="">=IsT
  */
 type AnyRecord=Record<string,any>;
 /** --------------------------------------------------
- * * ***UnknownRecord.***
+ * * ***Utility Type: `UnknownRecord`.***
  * --------------------------------------------------
- * Represents an object with arbitrary string keys and values of **unknown** type.
- *
- * ✅ Safer alternative to `AnyRecord` — forces explicit type narrowing
- *    before values can be used, maintaining type safety.
- *
- * ✅ Suitable for working with untyped external data sources
- *    (e.g., JSON APIs, parsed configs) where values must be validated first.
- *
+ * **Represents an object with arbitrary string keys and values of **unknown** type.**
+ * - ✅ Safer alternative to `AnyRecord` — forces explicit type narrowing
+ *   before values can be used, maintaining type safety.
+ * - ✅ Suitable for working with untyped external data sources
+ *   (e.g., JSON APIs, parsed configs) where values must be validated first.
  * @example
  * ```ts
  * const data: UnknownRecord = JSON.parse("{}");
@@ -2319,17 +2175,22 @@ type AnyRecord=Record<string,any>;
  * if (typeof data.id === "string") {
  *   console.log(data.id.toUpperCase());
  * }
+ *
+ * // Or:
+ * const unknownObject: UnknownRecord = {
+ *   mode: "dark",
+ *   retries: 3,
+ *   debug: true,
+ * };
  * ```
  */
 type UnknownRecord=Record<string,unknown>;
 /** -------------------------------------------------------
- * * ***AnyStringRecord.***
+ * * ***Utility Type: `AnyStringRecord`.***
  * -------------------------------------------------------
- *
- * Same as **{@link AnyString}** but uses `Record<never, never>` as the intersection.
- * This approach is often more reliable in preserving literal types
- * in generic inference scenarios.
- *
+ * **Same as **{@link AnyString | **`AnyString`**}** but uses `Record<never, never>` as the intersection.**
+ * - This approach is often more reliable in preserving literal types
+ *   in generic inference scenarios.
  * @example
  * ```ts
  * declare function acceptsAnyStringRecord<T extends AnyStringRecord>(value: T): T;
@@ -2343,39 +2204,36 @@ type UnknownRecord=Record<string,unknown>;
  */
 type AnyStringRecord=Record<never,never>& string;
 /** -------------------------------------------------------
- * * ***LooseLiteral.***
+ * * ***Utility Type: `LooseLiteral`.***
  * -------------------------------------------------------
- *
- * Improves the autocompletion and inference of **loose literal types**.
- *
+ * **Improves the autocompletion and inference of **loose literal types**.**
+ * @description
  * Ensures that specified literal types are preserved while still
  * allowing assignment of a broader base type.
- *
- * Useful in scenarios where:
- * - You want to accept **specific literal values** but still allow
- *   any value of a base type (like `string` or `number`).
- * - You want stricter typing in generics while preserving literals.
- *
+ * - **Useful in scenarios where:**
+ *    - You want to accept **specific literal values** but still allow
+ *      any value of a base type (like `string` or `number`).
+ *    - You want stricter typing in generics while preserving literals.
  * @template Literal - The literal type(s) to preserve.
  * @template BaseType - The base type to extend when not matching literal.
- *
  * @example
  * ```ts
  * type T0 = LooseLiteral<"a" | "b" | "c", string>;
  * // ➔ "a" | "b" | "c" | (string & {})
  *
  * declare function acceptsLoose<T extends LooseLiteral<"x" | "y", string>>(value: T): T;
- * const a = acceptsLoose("x"); // "x"
- * const b = acceptsLoose("any string"); // string
+ * const a = acceptsLoose("x");
+ * // ➔ "x"
+ * const b = acceptsLoose("any string");
+ * // ➔ string
  * ```
  */
 type LooseLiteral<Literal,BaseType>=Literal|(BaseType & AnyStringRecord);
 /** -------------------------------------------------------
- * * ***Max.***
+ * * ***Utility Type: `Max`.***
  * -------------------------------------------------------
- * Accepts two integers and returns the **maximum** among them.
+ * **Accepts two integers and returns the **maximum** among them.**
  *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @template Num1 - First integer to compare.
  * @template Num2 - Second integer to compare.
  * @example
@@ -2385,20 +2243,20 @@ type LooseLiteral<Literal,BaseType>=Literal|(BaseType & AnyStringRecord);
  * ```
  */
 type Max<Num1 extends number,Num2 extends number>=IfLowerThan<Num1,Num2,Num2,Num1>;
-/**
- * Recursively computes the maximum number in a tuple of integers.
+/** * ***Recursively computes the maximum number in a tuple of integers.***
  *
+ * @private ***Private internal type for {@link MaxArr | **`MaxArr`**}.***
  * @template T - Tuple of numbers to process.
  * @template CurrentMax - Current maximum value, defaults to the first element of T.
  */
 type _MaxArr<T extends readonly number[],CurrentMax extends number=ReturnItselfIfNotExtends<T[0],undefined,never>>=IsEmptyArray<T>extends true?CurrentMax:Shift<T,{includeRemoved:true;}>extends [ infer Rest extends number[],infer First extends number]?_MaxArr<Rest,Max<First,CurrentMax>>:never;
 /** -------------------------------------------------------
- * * ***MaxArr.***
+ * * ***Utility Type: `MaxArr`.***
  * -------------------------------------------------------
- * Accepts a tuple of integers and returns the **maximum** among its elements.
- * Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
- * @template T - Tuple of numbers to evaluate. Only tuples are supported; arrays of unknown length will return `never`.
+ * **Accepts a tuple of integers and returns the **maximum** among its elements.**
+ * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
+ * @template T - Tuple of numbers to evaluate.
+ * - Only tuples are supported; arrays of unknown length will return `never`.
  * @example
  * ```ts
  * type Case1 = MaxArr<[1, 2, 4, 10]>; // ➔ 10
@@ -2408,14 +2266,12 @@ type _MaxArr<T extends readonly number[],CurrentMax extends number=ReturnItselfI
  */
 type MaxArr<T extends readonly number[]>=IsTuple<T>extends true?_MaxArr<T>:never;
 /** -------------------------------------------------------
- * * ***DeepMergeArrayUnion.***
+ * * ***Utility Type: `DeepMergeArrayUnion`.***
  * -------------------------------------------------------
- * Recursively merges element types of nested arrays inside an array type,
- * **preserving the nested array structure**.
- *
+ * **Recursively merges element types of nested arrays inside an array type,
+ * **preserving the nested array structure**.**
  * - Converts an array of nested arrays into a union of its element types,
  *   while keeping the nested arrays intact.
- *
  * @template T - The outer array type.
  * @returns The nested array type with merged element types.
  * @example
@@ -2431,11 +2287,10 @@ type MaxArr<T extends readonly number[]>=IsTuple<T>extends true?_MaxArr<T>:never
  */
 type DeepMergeArrayUnion<T extends any[]>=T extends(infer U)[]?U extends any[]?DeepMergeArrayUnionHelper<U>[]:U[]:never;type DeepMergeArrayUnionHelper<T>=T extends(infer U)[]?DeepMergeArrayUnionHelper<U>|Exclude<T,any[]>:T;
 /** -------------------------------------------------------
- * * ***Min.***
+ * * ***Utility Type: `Min`.***
  * -------------------------------------------------------
- * Accepts two integers and returns the **minimum** among them.
+ * **Accepts two integers and returns the **minimum** among them.**
  * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @template Num1 - First integer.
  * @template Num2 - Second integer.
  * @example
@@ -2445,19 +2300,18 @@ type DeepMergeArrayUnion<T extends any[]>=T extends(infer U)[]?U extends any[]?D
  * ```
  */
 type Min<Num1 extends number,Num2 extends number>=IfLowerThan<Num1,Num2,Num1,Num2>;
-/**
- * Helper type for computing the minimum of a tuple of numbers recursively.
+/** * ***Helper type for computing the minimum of a tuple of numbers recursively.***
  *
+ * @private ***Private internal type for {@link MinArr | **`MinArr`**}.***
  * @template T - Array of numbers
  * @template CurrentMin - Current minimum in recursion
  */
 type _MinArr<T extends readonly number[],CurrentMin extends number=ReturnItselfIfNotExtends<T[0],undefined,never>>=IsEmptyArray<T>extends true?CurrentMin:Shift<T,{includeRemoved:true;}>extends [ infer Rest extends number[],infer First extends number]?_MinArr<Rest,Min<First,CurrentMin>>:never;
 /** -------------------------------------------------------
- * * ***MinArr.***
+ * * ***Utility Type: `MinArr`.***
  * -------------------------------------------------------
- * Accepts an array of integers and returns the **minimum** among its elements.
+ * **Accepts an array of integers and returns the **minimum** among its elements.**
  * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *
  * @template T - Tuple of numbers.
  * @example
  * ```ts
@@ -2467,12 +2321,10 @@ type _MinArr<T extends readonly number[],CurrentMin extends number=ReturnItselfI
  */
 type MinArr<T extends readonly number[]>=IsTuple<T>extends true?_MinArr<T>:never;
 /** -------------------------------------------------------
- * * ***NonNullableObject.***
+ * * ***Utility Type: `NonNullableObject`.***
  * -------------------------------------------------------
- * Makes all properties of the object type `T` non-nullable.
- *
+ * **Makes all properties of the object type `T` non-nullable.**
  * @template T - Object type to transform.
- *
  * @example
  * ```ts
  * type A = NonNullableObject<{ a: string | null; b: number | undefined }>;
@@ -2481,13 +2333,11 @@ type MinArr<T extends readonly number[]>=IsTuple<T>extends true?_MinArr<T>:never
  */
 type NonNullableObject<T>={[K in keyof T]:NonNullable<T[K]>;};
 /** -------------------------------------------------------
- * * ***NonNullableObjectOnly.***
+ * * ***Utility Type: `NonNullableObjectOnly`.***
  * -------------------------------------------------------
- * Makes only the specified properties `K` of the object type `T` non-nullable.
- *
+ * **Makes only the specified properties `K` of the object type `T` non-nullable.**
  * @template T - Object type to transform.
  * @template K - Keys of `T` to make non-nullable.
- *
  * @example
  * ```ts
  * type A = NonNullableObjectOnly<
@@ -2499,13 +2349,11 @@ type NonNullableObject<T>={[K in keyof T]:NonNullable<T[K]>;};
  */
 type NonNullableObjectOnly<T,K extends keyof T>=Prettify<Pick<T,Exclude<keyof T,K>>&{[P in K]:NonNullable<T[P]>;}>;
 /** -------------------------------------------------------
- * * ***NonNullableObjectExcept.***
+ * * ***Utility Type: `NonNullableObjectExcept`.***
  * -------------------------------------------------------
- * Makes all properties of the object type `T` non-nullable except for the specified properties `K`.
- *
+ * **Makes all properties of the object type `T` non-nullable except for the specified properties `K`.**
  * @template T - Object type to transform.
  * @template K - Keys of `T` to leave unchanged.
- *
  * @example
  * ```ts
  * type A = NonNullableObjectExcept<
@@ -2517,62 +2365,48 @@ type NonNullableObjectOnly<T,K extends keyof T>=Prettify<Pick<T,Exclude<keyof T,
  */
 type NonNullableObjectExcept<T,K extends keyof T>=Prettify<Pick<T,K>&{[P in Exclude<keyof T,K>]:NonNullable<T[P]>;}>;
 /** --------------------------------------------------
- * * ***Generate a union type of numbers within a specified range (optimized recursive batching).***
+ * * ***Internal Utility Type for: {@link NumberRangeLimit | `NumberRangeLimit`}.***
  * --------------------------------------------------
- *
  * @template From - Starting number of the range (inclusive).
  * @template To - Ending number of the range (inclusive).
  * @template Result - Internal accumulator for recursion (do not set manually).
- *
+ */
+type _NumberRangeLimit<From extends number,To extends number,Result extends number[]=[From]>=IsGreaterThan<From,To>extends true?[...Result,To][number] extends infer R extends number?R extends R?IsGreaterThan<R,To>extends true?never:R:never:never:_NumberRangeLimit<Sum<From,7>,To,[ ...Result,From,Sum<From,1>,Sum<From,2>,Sum<From,3>,Sum<From,4>,Sum<From,5>,Sum<From,6>]>;
+/** --------------------------------------------------
+ * * ***Utility Type: `NumberRangeLimit`.***
+ * --------------------------------------------------
+ * **Generate a union type of numbers within a specified range (optimized recursive batching).**
  * @description
  * Produces a **numeric union type** from `From` to `To` (inclusive),
- * using *batched recursive expansion* (adds up to 7 numbers at a time).
+ * using ***batched recursive expansion*** (**adds up to `7` numbers at a time**).
  *
- * This batching allows generating larger ranges efficiently without
+ * This batching allows generating **larger ranges** (`≥ 101`) efficiently without
  * hitting TypeScript’s recursion limits too quickly.
- *
  * - ✅ Optimized for **performance** (fewer recursive steps).
  * - ⚠️ Supports up to `To = 999` safely.
- * - ⚙️ Best used when you need **arbitrary ranges** within `0–999`.
- *
+ * - ⚙️ Best used for **larger ranges** (`≥ 101`) or when you need **arbitrary ranges** within `0–999`.
+ * - ℹ️ For **smaller ranges** (`≤ 100`) or when readability matters use {@link NumberRangeUnion | **`NumberRangeUnion`**} instead.
+ * @template From - Starting number of the range (inclusive).
+ * @template To - Ending number of the range (inclusive).
  * @example
  * ```ts
  * type RangeA = NumberRangeLimit<5, 8>;
- * //    ^? 5 | 6 | 7 | 8
- *
+ * // ➔ 5 | 6 | 7 | 8
  * type RangeB = NumberRangeLimit<10, 15>;
- * //    ^? 10 | 11 | 12 | 13 | 14 | 15
- * ```
- */
-type NumberRangeLimit<From extends number,To extends number,Result extends number[]=[From]>=IsGreaterThan<From,To>extends true?[...Result,To][number] extends infer R extends number?R extends R?IsGreaterThan<R,To>extends true?never:R:never:never:NumberRangeLimit<Sum<From,7>,To,[ ...Result,From,Sum<From,1>,Sum<From,2>,Sum<From,3>,Sum<From,4>,Sum<From,5>,Sum<From,6>]>;
-/** --------------------------------------------------
- * * ***OverrideTypes.***
- * --------------------------------------------------
- * Overrides properties in type `T` with properties from type `U`, based on matching keys.
- *
- * ✅ Ensures the result retains all properties from `T`, but values from `U` override corresponding keys.
- *
- * @template T - The base object type to override.
- * @template U - The object type containing overriding properties.
- *
- * @example
- * ```ts
- * type A = { a: number; b: string };
- * type B = { b: boolean };
- * type C = OverrideTypes<A, B>;
- * // ➔ { a: number; b: boolean }
+ * // ➔ 10 | 11 | 12 | 13 | 14 | 15
+ * type RangeC = NumberRangeLimit<8, 8>;
+ * // ➔ 8
+ * type RangeD = NumberRangeLimit<20, 10>;
+ * // ➔ 10
  * ```
  */
-type OverrideTypes<T,U extends Partial<Record<keyof T,unknown>>>=OmitStrict<T,Extract<keyof U,keyof T>>& U extends infer U?{[K in keyof U]:U[K];}:never;type _IsPalindrome<T extends string>=IsEmptyString<T>extends true?true:Not<IsStringLiteral<T>>extends true?false:T extends`${infer First extends string}${infer Rest extends string}`?IsEmptyString<Rest>extends true?true:Rest extends`${infer NewRest extends string}${First}`?_IsPalindrome<NewRest>:false:false;
+type NumberRangeLimit<From extends number,To extends number>=_NumberRangeLimit<From,To>;type _IsPalindrome<T extends string>=IsEmptyString<T>extends true?true:Not<IsStringLiteral<T>>extends true?false:T extends`${infer First extends string}${infer Rest extends string}`?IsEmptyString<Rest>extends true?true:Rest extends`${infer NewRest extends string}${First}`?_IsPalindrome<NewRest>:false:false;
 /** -------------------------------------------------------
- * * ***IsPalindrome.***
+ * * ***Utility Type: `IsPalindrome`.***
  * -------------------------------------------------------
- *
- * Determines if a string or number is a **palindrome** at type-level.
- * A palindrome reads the same forwards and backwards (e.g., `"racecar"`).
- *
+ * **Determines if a string or number is a **palindrome** at type-level.
+ * A palindrome reads the same forwards and backwards (e.g., `"racecar"`).**
  * @template T - A string or number to check.
- *
  * @example
  * ```ts
  * type T0 = IsPalindrome<"racecar">; // true
@@ -2580,28 +2414,25 @@ type OverrideTypes<T,U extends Partial<Record<keyof T,unknown>>>=OmitStrict<T,Ex
  * type T2 = IsPalindrome<12321>;     // true
  * type T3 = IsPalindrome<12345>;     // false
  * ```
- *
  * @remarks
- * - Converts numbers to strings using {@link Stringify}.
- * - Uses {@link IsEmptyString}, {@link IsStringLiteral}, and {@link Not} for type-level logic.
+ * - Converts numbers to strings using {@link Stringify | **`Stringify`**}.
+ * - Uses {@link IsEmptyString | **`IsEmptyString`**},
+ *   {@link IsStringLiteral | **`IsStringLiteral`**},
+ *   and {@link Not | **`Not`**} for type-level logic.
  * - Returns `true` if the input is a palindrome, otherwise `false`.
  */
 type IsPalindrome<T extends string|number>=_IsPalindrome<Stringify<T>>;
 /** -------------------------------------------------------
- * * ***UnionToIntersection.***
+ * * ***Utility Type: `UnionToIntersection`.***
  * -------------------------------------------------------
- *
- * Converts a union type into an **intersection**.
- *
- * 📖 Reference: ***[StackOverflow](https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type/50375286#50375286).***
- *
+ * **Converts a union type into an **intersection**.**
+ * @description
+ * 📖 Reference: ***[`StackOverflow`](https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type/50375286#50375286).***
  * @template U - The union type to be converted.
- *
  * @example
  * ```ts
  * type A = UnionToIntersection<{ a: string } | { b: number }>;
  * // ➔ { a: string } & { b: number }
- *
  * type B = UnionToIntersection<
  *   { a: string } | { b: number } | { c: boolean }
  * >;
@@ -2610,31 +2441,28 @@ type IsPalindrome<T extends string|number>=_IsPalindrome<Stringify<T>>;
  */
 type UnionToIntersection<U>=(U extends any?(k:U)=>void:never)extends(k:infer I)=>void?I:never;
 /** -------------------------------------------------------
- * * ***PrettifyUnionIntersection.***
+ * * ***Utility Type: `PrettifyUnionIntersection`.***
  * -------------------------------------------------------
- *
- * Converts a union type into an **intersection** using ***{@link UnionToIntersection}***, and then
- * applies ***{@link Prettify}*** to simplify the resulting intersection
- * for better readability in IntelliSense and tooltips.
- *
+ * **Converts a union type into an **intersection** using ***{@link UnionToIntersection | `UnionToIntersection`}***, and then
+ * applies ***{@link Prettify | `Prettify`}*** to simplify the resulting intersection
+ * for better readability in IntelliSense and tooltips.**
+ * @description
  * Useful when the raw intersection of union types produces
  * deeply nested or hard-to-read structures.
- *
  * @template T - The union type to be converted.
  * @template Options - Optional formatting options for `Prettify`.
- *
  * @example
  * ```ts
- * // Basic union → intersection
+ * // Basic union ➔ intersection
  * type A = { a: string } | { b: number };
  * type B = PrettifyUnionIntersection<A>;
- * // ➔ ^? { a: string } & { b: number }
+ * // ➔ { a: string } & { b: number }
  * // final result become ➔ { a: string b: number }
  *
  * // Larger union
  * type C = { a: string } | { b: number } | { c: boolean };
  * type D = PrettifyUnionIntersection<C>;
- * // ➔ ^? { a: string } & { b: number } & { c: boolean }
+ * // ➔ { a: string } & { b: number } & { c: boolean }
  * // final result become ➔ { a: string b: number c: boolean }
  *
  * // With PrettifyOptions (custom formatting)
@@ -2655,15 +2483,12 @@ type RequiredKeysOf<U>=Exclude<keyof U,OptionalKeys<U>>;
 /** Force re-evaluation / cleaner display */
 
 /** -------------------------------------------------------
- * * ***PartialOnly.***
+ * * ***Utility Type: `PartialOnly`.***
  * -------------------------------------------------------
- *
- * Make only the specified properties in `T` **optional**,
- * while keeping all other properties required.
- *
+ * **Make only the specified properties in `T` **optional**, while keeping all
+ * other properties required.**
  * @template T - The object type to transform.
  * @template K - Keys of `T` that should become optional.
- *
  * @example
  * ```ts
  * // Only "a" is optional, "b" and "c" remain required
@@ -2690,20 +2515,17 @@ type RequiredKeysOf<U>=Exclude<keyof U,OptionalKeys<U>>;
  */
 type PartialOnly<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?T:PrettifyUnionIntersection<{[P in Exclude<RequiredKeys<T>,Extract<keyof T,K>>]-?:T[P];}&{[P in Exclude<OptionalKeys<T>,Extract<keyof T,K>>]+?:CleanOptional$1<T[P]>;}&{[P in Extract<keyof T,K>]+?:CleanOptional$1<T[P]>;}>;
 /** -------------------------------------------------------
- * * ***PartialExcept.***
+ * * ***Utility Type: `PartialExcept`.***
  * -------------------------------------------------------
- *
- * Make all properties in `T` **optional**,
- * except for the ones specified in `K`, which remain as-is.
- *
- * - If a property in `K` is originally required → it stays required.
- * - If a property in `K` is originally optional → it stays optional.
- * - All other properties become optional.
- * - Duplicate `undefined` types are cleaned up automatically.
- *
+ * **Make all properties in `T` **optional**, except for the ones specified
+ * in `K`, which remain as-is.**
+ * - **Behavior:**
+ *    - If a property in `K` is originally required ➔ it stays required.
+ *    - If a property in `K` is originally optional ➔ it stays optional.
+ *    - All other properties become optional.
+ *    - Duplicate `undefined` types are cleaned up automatically.
  * @template T - The object type to transform.
  * @template K - Keys of `T` that should remain as-is (not forced optional).
- *
  * @example
  * ```ts
  * // "a" remains required, "b" and "c" become optional
@@ -2719,7 +2541,7 @@ type PartialOnly<T extends object,K extends keyof T|AnyString>=IsNever<K>extends
  * type T2 = PartialExcept<{ a: string; b?: number; c: boolean }, "a" | "b">;
  * // ➔ { a: string; b?: number; c?: boolean }
  *
- * // none of the keys match → everything optional
+ * // none of the keys match ➔ everything optional
  * type T3 = PartialExcept<{ a: string; b: number; c: boolean }, "x">;
  * // ➔ { a?: string; b?: number; c?: boolean }
  * ```
@@ -2731,31 +2553,74 @@ type PartialOnly<T extends object,K extends keyof T|AnyString>=IsNever<K>extends
  */
 type PartialExcept<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?Partial<T>:PrettifyUnionIntersection<Identity<{[P in RequiredKeysOf<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>>]-?:CleanOptional$1<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>[P]>;}&{[P in OptionalKeys<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>>]+?:CleanOptional$1<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>[P]>;}>>;
 /** -------------------------------------------------------
- * * ***OverWritable***
+ * * ***Utility Type: `ValueOf`.***
  * -------------------------------------------------------
- *
- * Option type to signal that some properties can be overwritten
- * when applying default options.
- *
+ * **Gets the types of all property values in an object `T`.**
+ * @template T - The object type.
+ * @example
+ * ```ts
+ * type Case1 = ValueOf<{ a: string, b: number }>;
+ * // ➔ string | number
+ * ```
+ */
+type ValueOf<T>=T[keyof T];
+/** -------------------------------------------------------
+ * * ***Utility Type: `ValueOfOnly`.***
+ * -------------------------------------------------------
+ * **Gets the types of properties in object `T` specified by `K`.**
+ * @template T - The object type.
+ * @template K - Keys of `T` to extract values from.
+ * @example
+ * ```ts
+ * type Case1 = ValueOfOnly<{ a: string, b: number }, "a">;
+ * // ➔ string
+ * ```
+ */
+type ValueOfOnly<T,K extends keyof T>=T[K];
+/** -------------------------------------------------------
+ * * ***Utility Type: `ValueOfExcept`.***
+ * -------------------------------------------------------
+ * **Gets the types of properties in object `T` **except** for keys in `K`.**
+ * @template T - The object type.
+ * @template K - Keys of `T` to exclude.
+ * @example
+ * ```ts
+ * type Case1 = ValueOfExcept<{ a: string, b: number }, "a">;
+ * // ➔ number
+ * ```
+ */
+type ValueOfExcept<T,K extends keyof T>=T[keyof Omit<T,K>];
+/** -------------------------------------------------------
+ * * ***Utility Type: `ValueOfArray`.***
+ * -------------------------------------------------------
+ * **Gets the types of elements in a tuple or array `T`.**
+ * @template T - The tuple or array type.
+ * @example
+ * ```ts
+ * type Case1 = ValueOfArray<[string, number]>;
+ * // ➔ string | number
+ * ```
+ */
+type ValueOfArray<T extends readonly unknown[]>=T[number];
+/** -------------------------------------------------------
+ * * ***Utility Type: `OverWritable`.***
+ * -------------------------------------------------------
+ * **Option type to signal that some properties can be overwritten when
+ * applying default options.**
  * @property overwriteDefault - If true, all options in the passed `Options`
  *   object will **overwrite** defaults, even if rules say otherwise.
  */
 type OverWritable={
-/**
- * If true, all options in the passed `Options` object will **overwrite** defaults, even if rules say otherwise, defaultValue: `false`.
+/** If true, all options in the passed `Options` object will **overwrite** defaults, even if rules say otherwise, defaultValue: `false`.
  *
  * @default false
  */
 overwriteDefault?:boolean;};
 /** -------------------------------------------------------
- * * ***ApplyDefaultOptions***
+ * * ***Utility Type: `ApplyDefaultOptions`.***
  * -------------------------------------------------------
- *
- * @deprecated  ⚠️ ***Internal utility only. Do **not** use directly in application code***.
- *
- * Type-level utility that merges a user-specified `Options` object
- * with a `DefaultOptions` object using a set of `OverwriteRules`.
- *
+ * **Type-level utility that merges a user-specified `Options` object
+ * with a `DefaultOptions` object using a set of `OverwriteRules`.**
  * @template BaseOptions - The base type of all options.
  * @template Options - User-specified options that may override defaults.
  * @template DefaultOptions - Default values for options.
@@ -2763,14 +2628,12 @@ overwriteDefault?:boolean;};
  *   should always allow overwriting defaults.
  * @template OverwriteDefault - If true, all options in `Options`
  *   overwrite defaults regardless of rules.
- *
  * @remarks
  * - Recursively applies defaults for nested objects.
  * - Only objects that are non-nullable and non-unknown are recursively merged.
  * - If a property is **not an object** or recursion is not needed,
  *   it either takes the value from `Options` or merges `Options[K] | DefaultOptions[K]`.
  * - Helps safely build strongly typed configuration objects with defaults.
- *
  * @example
  * ```ts
  * type Base = {
@@ -2793,91 +2656,69 @@ overwriteDefault?:boolean;};
  * //   b: boolean;
  * // }
  * ```
- *
  */
 type ApplyDefaultOptions<BaseOptions,Options extends BaseOptions,DefaultOptions extends BaseOptions,OverwriteRules,OverwriteDefault extends boolean=false>=Prettify<{[K in keyof BaseOptions]-?:K extends keyof Options?AndArr<[ Extends<NonNullable<BaseOptions[K]>,object>,Not<IsNever<DefaultOptions[K]>>,Not<IsUnknown<BaseOptions[K]>>]>extends true?ApplyDefaultOptions<NonNullable<BaseOptions[K]>,Extract<Options[K],NonNullable<BaseOptions[K]>>,Extract<DefaultOptions[K],NonNullable<BaseOptions[K]>>,OverwriteRules[K & keyof OverwriteRules],OverwriteDefault>&{tra:"test";}:Or<IsEqual<OverwriteDefault,true>,And<Extends<K,keyof OverwriteRules>,Extends<OverwriteRules[K & keyof OverwriteRules],true>>>extends true?Options[K]:Options[K]|DefaultOptions[K]:DefaultOptions[K];}>;
-/** -------------------------------------------------------
- * * ***ValueOf.***
- * -------------------------------------------------------
- * Gets the types of all property values in an object `T`.
- *
- * @template T - The object type.
- *
- * @example
- * ```ts
- * type Case1 = ValueOf<{ a: string, b: number }>;
- * // ➔ string | number
- * ```
+/** --------------------------------------------------------------
+ * * ***Options for {@link PathToFields | **`PathToFields`**} type-level utility.***
+ * --------------------------------------------------------------
+ * @template ignoredTypes - Types to ignore completely.
+ * @template stopTypes - Types at which recursion stops and returns `[]`.
+ * @template limit - Max recursion depth.
+ * @template format - Output format, `"dot"` or `"array"`.
+ * @template ignoredKeys - Keys to ignore when generating paths.
+ * @template arrayIndexing - Options for handling array paths.
  */
-type ValueOf<T>=T[keyof T];
-/** -------------------------------------------------------
- * * ***ValueOfOnly.***
- * -------------------------------------------------------
- * Gets the types of properties in object `T` specified by `K`.
+type PathToFieldsOptions=Prettify<OverWritable &{
+/** Types to ignored completely (default: `undefined`).
  *
- * @template T - The object type.
- * @template K - Keys of `T` to extract values from.
+ * @default undefined
+ */
+ignoredTypes?:unknown;
+/** Types at which recursion stops (default: `undefined`).
  *
- * @example
- * ```ts
- * type Case1 = ValueOfOnly<{ a: string, b: number }, "a">;
- * // ➔ string
- * ```
+ * @default undefined
  */
-type ValueOfOnly<T,K extends keyof T>=T[K];
-/** -------------------------------------------------------
- * * ***ValueOfExcept.***
- * -------------------------------------------------------
- * Gets the types of properties in object `T` **except** for keys in `K`.
+stopTypes?:unknown;
+/** Max recursion depth (default: `10`).
  *
- * @template T - The object type.
- * @template K - Keys of `T` to exclude.
+ * @default 10
+ */
+limit?:number;
+/** Format Output Options:
+ * - `"dot"` ➔ dot-notation strings, default output (`"a.b.c"`).
+ * - `"array"` ➔ array of path segments (`["a", "b", "c"]`).
  *
- * @example
- * ```ts
- * type Case1 = ValueOfExcept<{ a: string, b: number }, "a">;
- * // ➔ number
- * ```
+ * @default "dot"
  */
-type ValueOfExcept<T,K extends keyof T>=T[keyof Omit<T,K>];
-/** -------------------------------------------------------
- * * ***ValueOfArray.***
- * -------------------------------------------------------
- * Gets the types of elements in a tuple or array `T`.
+format?:"dot"|"array";
+/** Keys to skip when generating paths (default: `undefined`).
  *
- * @template T - The tuple or array type.
+ * @default undefined
+ */
+ignoredKeys?:PropertyKey;
+/** Options for array Indexing (default: `{ exactIndexes: false }`).
  *
- * @example
- * ```ts
- * type Case1 = ValueOfArray<[string, number]>;
- * // ➔ string | number
- * ```
+ * When `arrayIndexing.exactIndexes = true` ➔ outputs exact tuple indexes (`"arr.0"`), otherwise generic `"arr.${number}"`.
+ * @default undefined
  */
-type ValueOfArray<T extends readonly unknown[]>=T[number];
-/** --------------------------------------------------------------
- * * ***Options for {@link PathToFields} type-level utility.***
- * --------------------------------------------------------------
+arrayIndexing?:{
+/** Options for array Exact Indexing (default: `false`).
  *
- * @template ignoredTypes - Types to ignore completely.
- * @template stopTypes - Types at which recursion stops and returns `[]`.
- * @template limit - Max recursion depth.
- * @template format - Output format, `"dot"` or `"array"`.
- * @template ignoredKeys - Keys to ignore when generating paths.
- * @template arrayIndexing - Options for handling array paths.
+ * When `exactIndexes = true` ➔ outputs exact tuple indexes (`"arr.0"`), otherwise generic `"arr.${number}"`.
+ * - For increase limit indexing, you can set `limit` options, default
+ *   limit is: `10`.
+ * @default false
  */
-type PathToFieldsOptions=OverWritable &{ignoredTypes?:unknown;stopTypes?:unknown;limit?:number;format?:"dot"|"array";ignoredKeys?:PropertyKey;arrayIndexing?:{exactIndexes:boolean;};};
+exactIndexes:boolean;};},{recursive:true;}>;
 /** * ***Default options for {@link PathToFields}.*** */
 type DefaultPathToFieldsOptions={ignoredTypes:never;stopTypes:string|number|boolean|symbol|Date|AnyFunction;format:"dot";limit:10;ignoredKeys:never;arrayIndexing:{exactIndexes:false;};};type OverwriteRules={limit:true;format:true;arrayIndexing:{exactIndexes:true;};};type Booleanize<T>=T extends true?true:false;type _PathToFieldsArray<T extends readonly unknown[],Options extends PathToFieldsOptions,Iteration extends number=0>=And<IsTuple<T>,IsEqual<Booleanize<Options["arrayIndexing"] extends{exactIndexes:infer E;}?E:false>,true>>extends true?ValueOfArray<{[K in keyof T]:IsArrayIndex<K>extends true?[K,..._PathToFields<T[K],Options,Increment<Iteration>>]:never;}>:ArrayElementType<T>extends infer ElementType?[`${number}`,...(ElementType extends ElementType?_PathToFields<ElementType,Options,Increment<Iteration>>:never)]:never;type _PathToFields<T,Options extends PathToFieldsOptions,Iteration extends number=0>=T extends Options["ignoredTypes"]?never:T extends Options["stopTypes"]?[]:IsEqual<Iteration,Options["limit"]>extends true?never:T extends readonly unknown[]?_PathToFieldsArray<T,Options,Iteration>:ValueOf<{[K in Exclude<keyof T,symbol|Options["ignoredKeys"]>]:NonNullable<T[K]>extends infer NonNullableFields?NonNullableFields extends readonly unknown[]?[K,..._PathToFieldsArray<NonNullableFields,Options,Iteration>]:[K,..._PathToFields<NonNullableFields,Options,Increment<Iteration>>]:never;}>;
 /** -------------------------------------------------------
- * * ***PathToFields.***
+ * * ***Utility Type: `PathToFields`.***
  * -------------------------------------------------------
- *
- * Generates **all possible property paths** within a type `T`.
- * Supports nested objects, arrays, tuples, and optional configuration.
- *
+ * **Generates **all possible property paths** within a type `T`.
+ * Supports nested objects, arrays, tuples, and optional configuration.**
  * @template T - Object type to extract paths from.
- * @template Options - Optional configuration. See {@link PathToFieldsOptions}.
- *
+ * @template Options - Optional configuration.
  * @example
  * ```ts
  * // Nested object
@@ -2909,113 +2750,42 @@ type DefaultPathToFieldsOptions={ignoredTypes:never;stopTypes:string|number|bool
  * >;
  * // Result: "settings" | "nested.inner"
  * ```
- *
  * @remarks
- * - `Options.format = "dot"` → dot-notation strings, default output (`"a.b.c"`).
- * - `Options.format = "array"` → array of path segments (`["a", "b", "c"]`).
- * - `Options.limit` → max recursion depth (default 10).
- * - `Options.stopTypes` → types at which recursion stops.
- * - `Options.ignoredTypes` → types ignored completely.
- * - `Options.ignoredKeys` → keys to skip when generating paths.
- * - `Options.arrayIndexing.exactIndexes = true` → outputs exact tuple indexes (`"arr.0"`), otherwise generic `"arr.${number}"`.
- */
-type PathToFields<T,Options extends PathToFieldsOptions &{overwriteDefault?:boolean;}=never>=(IsNever<Options>extends true?DefaultPathToFieldsOptions:ApplyDefaultOptions<Omit<PathToFieldsOptions,keyof OverWritable>,Options,DefaultPathToFieldsOptions,OverwriteRules,PathToFieldsOptions["overwriteDefault"] extends boolean?PathToFieldsOptions["overwriteDefault"]:false>)extends infer MergedOptions extends PathToFieldsOptions?_PathToFields<T,MergedOptions>extends infer Paths extends readonly(string|number)[]?IsEqual<MergedOptions["format"],"dot">extends true?Paths extends Paths?Join<Paths,".">:never:Paths:never:never;
-/** --------------------------------------------------
- * * ***PickStrict.***
- * --------------------------------------------------
- * Utility type that behaves exactly like the native `Pick<T, K>`,
- * but can help with type inference and IDE autocomplete in stricter scenarios.
- *
- * @template T - The base object type.
- * @template K - The keys from `T` to be picked.
- *
- * @example
- * ```ts
- * type A = { a: number; b: string; c: boolean };
- * type B = PickStrict<A, 'a' | 'c'>;
- * // ➔ { a: number; c: boolean }
- * ```
+ * - `Options.format = "dot"` ➔ dot-notation strings, default output (`"a.b.c"`).
+ * - `Options.format = "array"` ➔ array of path segments (`["a", "b", "c"]`).
+ * - `Options.limit` ➔ max recursion depth (default 10).
+ * - `Options.stopTypes` ➔ types at which recursion stops.
+ * - `Options.ignoredTypes` ➔ types ignored completely.
+ * - `Options.ignoredKeys` ➔ keys to skip when generating paths.
+ * - `Options.arrayIndexing.exactIndexes = true` ➔ outputs exact tuple indexes (`"arr.0"`), otherwise generic `"arr.${number}"`.
  */
-type PickStrict<T,K extends keyof T>=Pick<T,K>;type _Pow<Num extends number,Factor extends number,CurrentProduct extends number=1,Iteration extends unknown[]=[]>=IsEqual<Iteration["length"],Factor>extends true?CurrentProduct:_Pow<Num,Factor,Multi<CurrentProduct,Num>,Push<Iteration,unknown>>;
+type PathToFields<T,Options extends PathToFieldsOptions=never>=(IsNever<Options>extends true?DefaultPathToFieldsOptions:ApplyDefaultOptions<Omit<PathToFieldsOptions,keyof OverWritable>,Options,DefaultPathToFieldsOptions,OverwriteRules,PathToFieldsOptions["overwriteDefault"] extends boolean?PathToFieldsOptions["overwriteDefault"]:false>)extends infer MergedOptions extends PathToFieldsOptions?_PathToFields<T,MergedOptions>extends infer Paths extends readonly(string|number)[]?IsEqual<MergedOptions["format"],"dot">extends true?Paths extends Paths?Join<Paths,".">:never:Paths:never:never;type _Pow<Num extends number,Factor extends number,CurrentProduct extends number=1,Iteration extends unknown[]=[]>=IsEqual<Iteration["length"],Factor>extends true?CurrentProduct:_Pow<Num,Factor,Multi<CurrentProduct,Num>,Push<Iteration,unknown>>;
 /** -------------------------------------------------------
- * * ***Pow.***
+ * * ***Utility Type: `Pow`.***
  * -------------------------------------------------------
- *
- * Returns a type-level **exponentiation** result: raises the first integer parameter (`Num`)
- * to the power of the second integer parameter (`Factor`).
- *
+ * **Returns a type-level **exponentiation** result:**
+ *   - Raises the first integer parameter (`Num`) to the power of the second
+ *     integer parameter (`Factor`).
  * @template Num - The base number (integer).
  * @template Factor - The exponent number (integer, >= 0).
- *
  * @example
  * ```ts
- * // 100
  * type Case1 = Pow<10, 2>
- *
- * // 1
+ * // ➔ 100
  * type Case2 = Pow<5, 0>
- *
- * // 8
+ * // ➔ 1
  * type Case3 = Pow<2, 3>
+ * // ➔ 8
  * ```
  */
 type Pow<Num extends number,Factor extends number>=_Pow<Num,Factor>;
-/** --------------------------------------------------
- * * ***Awaitable.***
- * --------------------------------------------------
- * Represents a type that can be awaited:
- * either a plain value `T` or a `PromiseLike<T>`.
- *
- * @template T - The inner value type.
- *
- * @example
- * ```ts
- * async function wrap<T>(v: Awaitable<T>): Promise<T> {
- *   return await v;
- * }
- *
- * const a = wrap(42);           // Promise<number>
- * const b = wrap(Promise.resolve("hi")); // Promise<string>
- * ```
- */
-type Awaitable<T>=T|PromiseLike<T>;
-/** --------------------------------------------------
- * * ***CustomPromise.***
- * --------------------------------------------------
- * A custom extension of the native `Promise` type that allows explicit typing
- * for both the resolved (`onSuccess`) and rejected (`onError`) values.
- *
- * ✅ Useful for strongly typing both success and error cases in async operations.
- *    Example: server actions, RPC, or custom async wrappers.
- *
- * @template onSuccess - The type of the resolved value when fulfilled.
- * @template onError - The type of the rejection reason when rejected. Defaults to `any`.
- *
- * @example
- * ```ts
- * const fetchUser = (): CustomPromise<User, ApiError> => {
- *   return customRequest().catch(err => {
- *     handleError(err); // `err` is typed as ApiError
- *     return fallbackUser;
- *   });
- * };
- *
- * fetchUser().then(user => {
- *   // ➔ user is typed as User
- * });
- * ```
- */
-type CustomPromise<onSuccess,onError=any>={catch<TResult=never>(onrejected?:((reason:onError)=>TResult|PromiseLike<TResult>)|undefined|null):Promise<onSuccess|TResult>;}& Promise<onSuccess>;
 /** -------------------------------------------------------
- * * ***ReadonlyOnly.***
+ * * ***Utility Type: `ReadonlyOnly`.***
  * -------------------------------------------------------
- *
- * Makes the specified keys `K` of an object type `T` readonly,
- * while leaving the other properties mutable.
- *
+ * **Makes the specified keys `K` of an object type `T` readonly,
+ * while leaving the other properties mutable.**
  * @template T - The object type.
  * @template K - Keys of `T` to make readonly.
- *
  * @example
  * ```ts
  * type T0 = ReadonlyOnly<{ a: string; b: number }, 'a'>;
@@ -3027,15 +2797,12 @@ type CustomPromise<onSuccess,onError=any>={catch<TResult=never>(onrejected?:((re
  */
 type ReadonlyOnly<T extends object,K extends keyof T>=Prettify<Pick<T,Exclude<keyof T,K>>&{readonly [P in K]:T[P];}>;
 /** -------------------------------------------------------
- * * ***ReadonlyExcept.***
+ * * ***Utility Type: `ReadonlyExcept`.***
  * -------------------------------------------------------
- *
- * Makes all properties of an object type `T` readonly,
- * except for the specified keys `K` which remain mutable.
- *
+ * **Makes all properties of an object type `T` readonly,
+ * except for the specified keys `K` which remain mutable.**
  * @template T - The object type.
  * @template K - Keys of `T` to remain mutable.
- *
  * @example
  * ```ts
  * type T0 = ReadonlyExcept<{ a: string; b: number }, 'a'>;
@@ -3047,14 +2814,11 @@ type ReadonlyOnly<T extends object,K extends keyof T>=Prettify<Pick<T,Exclude<ke
  */
 type ReadonlyExcept<T extends object,K extends keyof T>=Prettify<Pick<T,K>&{readonly [P in Exclude<keyof T,K>]:T[P];}>;
 /** -------------------------------------------------------
- * * ***RemoveIndexSignature.***
+ * * ***Utility Type: `RemoveIndexSignature`.***
  * -------------------------------------------------------
- *
- * Removes **index signatures** (e.g., `[key: string]: any`) from an object type `T`,
- * leaving only explicitly declared properties.
- *
+ * **Removes **index signatures** (e.g., `[key: string]: any`) from an object
+ * type `T`, leaving only explicitly declared properties.**
  * @template T - The object type to process.
- *
  * @example
  * ```ts
  * type Case1 = RemoveIndexSignature<{ [key: string]: number | string; a: string }>;
@@ -3069,44 +2833,35 @@ type ReadonlyExcept<T extends object,K extends keyof T>=Prettify<Pick<T,K>&{read
  */
 type RemoveIndexSignature<T>={[Key in keyof T as Key extends`${infer _}`?Key:never]:T[Key];};
 /** -------------------------------------------------------
- * * ***Replace.***
+ * * ***Utility Type: `Replace`.***
  * -------------------------------------------------------
- *
- * Replaces the **first occurrence** of a substring (`Pivot`)
- * inside a string (`T`) with another substring (`ReplaceBy`).
- *
+ * **Replaces the **first occurrence** of a substring (`Pivot`)
+ * inside a string (`T`) with another substring (`ReplaceBy`).**
  * @template T - The source string.
  * @template Pivot - The substring to replace.
  * @template ReplaceBy - The substring that replaces `Pivot`.
- *
  * @example
  * ```ts
  * type Case1 = Replace<'remove me me', 'me', 'him'>;
  * // ➔ 'remove him me'
- *
  * type Case2 = Replace<'remove me me', 'us', 'him'>;
  * // ➔ 'remove me me'
- *
  * type Case3 = Replace<'aaaa', 'a', 'b'>;
  * // ➔ 'baaa'
- *
  * type Case4 = Replace<'hello', 'x', 'y'>;
  * // ➔ 'hello' (no match found)
  * ```
  */
 type Replace<T extends string,Pivot extends string,ReplaceBy extends string>=T extends`${infer A}${Pivot}${infer B}`?`${A}${ReplaceBy}${B}`:T;
 /** --------------------------------------------------
- * * ***ReplaceToPartial.***
+ * * ***Utility Type: `ReplaceToPartial`.***
  * --------------------------------------------------
- * Replaces specified keys in a type with a new value type, making them optional.
- *
- * ✅ Useful when certain properties in a type should allow partial overrides
- *    while keeping the rest of the structure intact.
- *
+ * **Replaces specified keys in a type with a new value type, making them optional.**
+ * - ✅ Useful when certain properties in a type should allow partial overrides
+ *   while keeping the rest of the structure intact.
  * @template TypeToBeChecked - The original object type.
  * @template KeyToBeReplaced - The keys in the original type to be replaced.
  * @template NewValueToUse - The new type to assign to the replaced keys.
- *
  * @example
  * ```ts
  * type A = { name: string; age: number };
@@ -3116,19 +2871,16 @@ type Replace<T extends string,Pivot extends string,ReplaceBy extends string>=T e
  */
 type ReplaceToPartial<TypeToBeChecked,KeyToBeReplaced extends keyof TypeToBeChecked,NewValueToUse>=Identity<Pick<TypeToBeChecked,Exclude<keyof TypeToBeChecked,KeyToBeReplaced>>&{[P in KeyToBeReplaced]?:NewValueToUse;}>;
 /** --------------------------------------------------
- * * ***ReplaceToRequired.***
+ * * ***Utility Type: `ReplaceToRequired`.***
  * --------------------------------------------------
- * Replaces specified keys in a type with a new value type, making them required.
- *
- * ✅ Useful when redefining a property’s type while ensuring it's required.
- *
+ * **Replaces specified keys in a type with a new value type, making them required.**
+ * - ✅ Useful when redefining a property’s type while ensuring it's required.
  * @template TypeToBeChecked - The original object type.
  * @template KeyToBeReplaced - The keys in the original type to be replaced.
  * @template NewValueToUse - The new type to assign to the replaced keys.
- *
  * @example
  * ```ts
- * type A = { name?: string|string[]; age: number };
+ * type A = { name?: string | string[]; age: number };
  * type B = ReplaceToRequired<A, 'name', string>;
  * // ➔ { name: string; age: number }
  * ```
@@ -3139,13 +2891,11 @@ type ReplaceToRequired<TypeToBeChecked,KeyToBeReplaced extends keyof TypeToBeChe
 /** Remove duplicate `undefined` from a type */
 type CleanOptional<T>=[T] extends [undefined]?undefined:T;
 /** -------------------------------------------------------
- * * ***RequiredOnly.***
+ * * ***Utility Type: `RequiredOnly`.***
  * -------------------------------------------------------
- * Make only the specified properties in `T` **required**, while keeping the rest unchanged (remain optional if optional).
- *
+ * **Make only the specified properties in `T` **required**, while keeping the rest unchanged (remain optional if optional).**
  * @template T - The object type to transform.
  * @template K - Keys of `T` that should become required.
- *
  * @example
  * ```ts
  * // Only "a" is required, "b" and "c" remain optional
@@ -3171,13 +2921,11 @@ type CleanOptional<T>=[T] extends [undefined]?undefined:T;
  */
 type RequiredOnly<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?T:PrettifyUnionIntersection<{[P in Exclude<keyof T,K>]?:CleanOptional<T[P]>;}&{[P in Extract<keyof T,K>]-?:NonUndefined<CleanOptional<T[P]>>;}>;
 /** -------------------------------------------------------
- * * ***RequiredExcept.***
+ * * ***Utility Type: `RequiredExcept`.***
  * -------------------------------------------------------
- * Make **all properties** in `T` required, except the specified keys which remain optional.
- *
+ * **Make **all properties** in `T` required, except the specified keys which remain optional.**
  * @template T - The object type to transform.
  * @template K - Keys of `T` that should remain optional.
- *
  * @example
  * ```ts
  * // All required except "a"
@@ -3204,24 +2952,21 @@ type RequiredOnly<T extends object,K extends keyof T|AnyString>=IsNever<K>extend
  */
 type RequiredExcept<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?Required<T>:PrettifyUnionIntersection<{[P in Exclude<keyof T,K>]-?:NonUndefined<CleanOptional<T[P]>>;}&{[P in Extract<keyof T,K>]?:CleanOptional<T[P]>;}>;type _Reverse<T extends readonly unknown[],Result extends readonly unknown[]=[]>=T extends readonly [infer First,...infer Rest]?_Reverse<Rest,[First,...Result]>:Result;type FilterByType$1<T extends readonly unknown[],U>=T extends readonly [ infer Head,...infer Tail]?Head extends U?[Head,...FilterByType$1<Tail,U>]:FilterByType$1<Tail,U>:[];type Grouped<T extends readonly unknown[]>=[ ...FilterByType$1<T,number>,...FilterByType$1<T,string>,...FilterByType$1<T,boolean>,...FilterByType$1<T,Exclude<T[number],number|string|boolean>>];type MaybeReadonly<T extends readonly unknown[],R extends readonly unknown[]>=IsTuple<T>extends true?(IsReadonlyArray<T>extends true?Readonly<R>:R):R;
 /** -------------------------------------------------------
- * * ***Reverse.***
- * -------------------------------------------------------
- * Returns a new tuple or readonly array type with the elements in reverse order.
- *
- * Behavior:
- * 1. **Tuple**: The reversed result preserves tuple properties,
- *    including `readonly` if applicable.
- *      - Elements are **grouped in this order before reversing**:
- *    `number`, `string`, `boolean`, then any other types.
- * 2. **Normal array (non-tuple)**: The type is returned as-is (no reversal).
- *
- * Notes:
- * - Supports arbitrary types in the tuple, including objects, Date, symbol, etc.
- * - Grouping ensures that numbers, strings, and booleans are reversed in logical groups,
- *   while other types remain at the end in their original order before reverse.
- *
+ * * ***Utility Type: `Reverse`.***
+ * -------------------------------------------------------
+ * **Returns a new tuple or readonly array type with the elements in reverse order.**
+ * - **Behavior:**
+ *    1. **Tuple**: The reversed result preserves tuple properties,
+ *       including `readonly` if applicable.
+ *         - Elements are **grouped in this order before reversing**:
+ *       `number`, `string`, `boolean`, then any other types.
+ *    2. **Normal array (non-tuple)**: The type is returned as-is (no reversal).
+ * - ℹ️ **Notes:**
+ *    - Supports arbitrary types in the tuple, including objects, Date, symbol, etc.
+ *    - Grouping ensures that numbers, strings, and booleans are reversed in logical
+ *      groups, while other types remain at the end in their original order before
+ *      reverse.
  * @template T - The array or tuple type to reverse.
- *
  * @example
  * ```ts
  * // Mutable tuple of numbers
@@ -3275,19 +3020,16 @@ type RequiredExcept<T extends object,K extends keyof T|AnyString>=IsNever<K>exte
  */
 type Reverse<T extends readonly unknown[]>=T extends readonly [ unknown,...unknown[]]?_Reverse<Grouped<T>>extends infer R extends readonly unknown[]?MaybeReadonly<T,R>:never:T;
 /** -------------------------------------------------------
- * * ***Round.***
+ * * ***Utility Type: `Round`.***
  * -------------------------------------------------------
- * Type-level version of `Math.round()`.
- * Returns the value of a number rounded to the **nearest integer**.
- *
- * Behavior:
- * - If `T` is a float, it rounds to the nearest whole number:
- *   - Fraction ≥ 0.5 → rounds up
- *   - Fraction < 0.5 → rounds down
- * - If `T` is already an integer, it returns `T` as-is.
- *
+ * **Type-level version of `Math.round()`.
+ * Returns the value of a number rounded to the **nearest integer**.**
+ * - **Behavior:**
+ *    - If `T` is a float, it rounds to the nearest whole number:
+ *      - Fraction `≥ 0.5` ➔ rounds up.
+ *      - Fraction `< 0.5` ➔ rounds down.
+ *    - If `T` is already an integer, it returns `T` as-is.
  * @template T - The number type to round.
- *
  * @example
  * ```ts
  * // Positive float
@@ -3309,22 +3051,20 @@ type Reverse<T extends readonly unknown[]>=T extends readonly [ unknown,...unkno
  */
 type Round<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extends [ infer Whole extends number,infer Fraction extends number]?IsGreaterThan<FirstDigit<Fraction>,4>extends true?Increment<Whole>:Whole:never:T;type SliceRemovedItemValue=Record<"__type-rzl_internal__",symbol>;type FilterRemoved<T extends readonly unknown[],Result extends unknown[]=[]>=T extends readonly [infer First,...infer Rest extends unknown[]]?FilterRemoved<Rest,First extends SliceRemovedItemValue?Result:Push<Result,First>>:Result;
 /** -------------------------------------------------------
- * * ***Slice.***
+ * * ***Utility Type: `Slice`.***
  * -------------------------------------------------------
- * Type-level version of `Array.prototype.slice()`.
+ * **Type-level version of `Array.prototype.slice()`.**
+ * @description
  * Returns a shallow copy of a portion of an array, selected from `Start` to `End` (not including `End`).
- *
- * Behavior:
- * - `Start` defaults to `0`.
- * - `End` defaults to `T["length"]`.
- * - Negative indices are interpreted as `T["length"] + index`.
- * - If `Start >= T["length"]` or `End <= Start`, returns an empty array `[]`.
- * - If the full range is selected, returns `T` as-is.
- *
+ * - **Behavior:**
+ *    - `Start` defaults to `0`.
+ *    - `End` defaults to `T["length"]`.
+ *    - Negative indices are interpreted as `T["length"] + index`.
+ *    - If `Start >= T["length"]` or `End <= Start`, returns an empty array `[]`.
+ *    - If the full range is selected, returns `T` as-is.
  * @template T - The array type to slice.
  * @template Start - The start index (inclusive). Defaults to `0`.
  * @template End - The end index (exclusive). Defaults to `T["length"]`.
- *
  * @example
  * ```ts
  * // Slice from index 1 to end
@@ -3354,19 +3094,16 @@ type Round<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extend
  */
 type Slice<T extends readonly unknown[],Start extends number=0,End extends number=T["length"]>=(IsEmptyArray<T>extends true?"self":IsGreaterOrEqual<Start,T["length"]>extends true?"empty":IsNegative<End>extends true?IsGreaterOrEqual<Abs<End>,T["length"]>extends true?"empty":[IfPositive<Start,Start,Sum<T["length"],Start>>,Sum<T["length"],End>]:And<Or<IsEqual<Start,0>,IsGreaterOrEqual<Abs<Start>,T["length"]>>,IsGreaterOrEqual<End,T["length"]>>extends true?"self":[IfPositive<Start,Start,Sum<T["length"],Start>>,End])extends infer Indexes?Indexes extends"self"?T:Indexes extends"empty"?[]:Indexes extends [infer NewStart extends number,infer NewEnd extends number]?IfGreaterOrEqual<NewStart,NewEnd>extends true?[]:FilterRemoved<{[K in keyof T]:IsArrayIndex<K>extends true?If<And<IsGreaterOrEqual<ParseNumber<K>,NewStart>,IsLowerThan<ParseNumber<K>,NewEnd>>,T[K],SliceRemovedItemValue>:T[K];}>:T:T;
 /** -------------------------------------------------------
- * * ***Swap.***
+ * * ***Utility Type: `Swap`.***
  * -------------------------------------------------------
- * Swaps the positions of two elements in a tuple at the type level.
- *
- * Behavior:
- * - Only works on tuple types. Non-tuple arrays are returned as-is.
- * - Validates that `FromIndex` and `ToIndex` are within bounds of the tuple.
- * - If `FromIndex` and `ToIndex` are equal, the tuple remains unchanged.
- *
+ * **Swaps the positions of two elements in a tuple at the type level.**
+ * - **Behavior:**
+ *    - Only works on tuple types. Non-tuple arrays are returned as-is.
+ *    - Validates that `FromIndex` and `ToIndex` are within bounds of the tuple.
+ *    - If `FromIndex` and `ToIndex` are equal, the tuple remains unchanged.
  * @template T - The tuple type.
  * @template FromIndex - The index of the first element to swap.
  * @template ToIndex - The index of the second element to swap.
- *
  * @example
  * ```ts
  * // Swap first and last element
@@ -3388,16 +3125,13 @@ type Slice<T extends readonly unknown[],Start extends number=0,End extends numbe
  */
 type Swap<T extends readonly unknown[],FromIndex extends number,ToIndex extends number>=IsTuple<T>extends true?And<IsBetween<FromIndex,0,T["length"]>,IsBetween<ToIndex,0,T["length"]>>extends true?T[FromIndex] extends infer From?T[ToIndex] extends infer To?{[K in keyof T]:ParseNumber<K>extends infer NumK?IsEqual<FromIndex,NumK>extends true?To:IsEqual<ToIndex,NumK>extends true?From:T[K]:never;}:never:never:never:T;type _SortSingle<Result extends readonly number[],PivotIndex extends number,CurrentIndex extends number>=IsEqual<PivotIndex,CurrentIndex>extends true?Result:Increment<CurrentIndex>extends infer NextCurrentIndex extends number?_SortSingle<IsGreaterThan<Result[CurrentIndex],Result[NextCurrentIndex]>extends true?Swap<Result,CurrentIndex,NextCurrentIndex>extends infer NewResult extends readonly number[]?NewResult:Result:Result,PivotIndex,NextCurrentIndex>:never;type _Sort<T extends readonly number[],CurrentIndex extends number>=IsLowerOrEqual<CurrentIndex,0>extends true?T:_SortSingle<T,CurrentIndex,0>extends infer NewT extends readonly number[]?_Sort<NewT,Decrement<CurrentIndex>>:T;
 /** -------------------------------------------------------
- * * ***Sort.***
+ * * ***Utility Type: `Sort`.***
  * -------------------------------------------------------
- * Type-level function that sorts a **tuple of numbers** in **ascending order**.
- *
- * Behavior:
- * - Tuples with length `< 2` are returned as-is.
- * - Works only on **tuple literal types**, not on general arrays (`number[]`).
- *
+ * **Type-level function that sorts a **tuple of numbers** in **ascending order**.**
+ * - **Behavior:**
+ *    - Tuples with length `< 2` are returned as-is.
+ *    - Works only on **tuple literal types**, not on general arrays (`number[]`).
  * @template T - Tuple of numbers to sort.
- *
  * @example
  * ```ts
  * // Sort positive numbers
@@ -3423,18 +3157,15 @@ type Swap<T extends readonly unknown[],FromIndex extends number,ToIndex extends
  */
 type Sort<T extends readonly number[]>=IsLowerThan<T["length"],2>extends true?T:_Sort<T,Decrement<T["length"]>>;
 /** -------------------------------------------------------
- * * ***StartsWith.***
+ * * ***Utility Type: `StartsWith`.***
  * -------------------------------------------------------
- * Type-level utility that determines whether a string `Str`
- * starts with the substring `Pivot`.
- *
- * Behavior:
- * - Supports `Pivot` as either `string` or `number`.
- * - Returns `true` if `Str` starts with `Pivot`, otherwise `false`.
- *
+ * **Type-level utility that determines whether a string `Str`
+ * starts with the substring `Pivot`.**
+ * - **Behavior:**
+ *    - Supports `Pivot` as either `string` or `number`.
+ *    - Returns `true` if `Str` starts with `Pivot`, otherwise `false`.
  * @template Str - The string to check.
  * @template Pivot - The substring or number to check as the prefix.
- *
  * @example
  * ```ts
  * // Check string prefix
@@ -3461,28 +3192,25 @@ type Sort<T extends readonly number[]>=IsLowerThan<T["length"],2>extends true?T:
  */
 type StartsWith<Str extends string,Pivot extends string|number>=Str extends`${Pivot}${string}`?true:false;
 /** -------------------------------------------------------
- * * ***Switch.***
+ * * ***Utility Type: `Switch`.***
  * -------------------------------------------------------
- * Type-level version of a `switch` statement.
- *
- * Behavior:
- * - Checks if `Condition` exists as a key in `Cases`.
- * - Returns the corresponding value if the key exists.
- * - Returns `Default` if the key does not exist.
- *
+ * **Type-level version of a `switch` statement.**
+ * - **Behavior:**
+ *    - Checks if `Condition` exists as a key in `Cases`.
+ *    - Returns the corresponding value if the key exists.
+ *    - Returns `Default` if the key does not exist.
  * @template Condition - The value to match against case keys.
  * @template Cases - An object mapping keys to corresponding values.
  * @template Default - The default value returned if `Condition` is not a key in `Cases` (defaults to `never`).
- *
  * @example
  * ```ts
  * const a = 'const';
  *
- * // Matches 'const' key → 'bar'
+ * // Matches 'const' key ➔ 'bar'
  * type Result1 = Switch<typeof a, { number: 'foo', const: 'bar' }, 'foobar'>;
  * // ➔ 'bar'
  *
- * // Condition not present → returns default
+ * // Condition not present ➔ returns default
  * type Result2 = Switch<'other', { number: 'foo', const: 'bar' }, 'default'>;
  * // ➔ 'default'
  *
@@ -3493,22 +3221,19 @@ type StartsWith<Str extends string,Pivot extends string|number>=Str extends`${Pi
  */
 type Switch<Condition extends PropertyKey,Cases extends Record<PropertyKey,unknown>,Default=never>=Condition extends keyof Cases?Cases[Condition]:Default;
 /** -------------------------------------------------------
- * * ***ToPrimitive.***
- * -------------------------------------------------------
- * Converts a literal type to its corresponding primitive type.
- *
- * Behavior:
- * - `string literal` → `string`
- * - `number literal` → `number`
- * - `boolean literal` → `boolean`
- * - `bigint literal` → `bigint`
- * - `symbol literal` → `symbol`
- * - `null` → `null`
- * - `undefined` → `undefined`
- * - Objects → recursively converts all properties to their primitive types
- *
+ * * ***Utility Type: `ToPrimitive`.***
+ * -------------------------------------------------------
+ * **Converts a literal type to its corresponding primitive type.**
+ * - **Behavior:**
+ *    - `string literal` ➔ `string`.
+ *    - `number literal` ➔ `number`.
+ *    - `boolean literal` ➔ `boolean`.
+ *    - `bigint literal` ➔ `bigint`.
+ *    - `symbol literal` ➔ `symbol`.
+ *    - `null` ➔ `null`.
+ *    - `undefined` ➔ `undefined`.
+ *    - Objects ➔ recursively converts all properties to their primitive types.
  * @template T - The literal type to convert to a primitive type.
- *
  * @example
  * ```ts
  * // Number literal
@@ -3544,19 +3269,17 @@ type Switch<Condition extends PropertyKey,Cases extends Record<PropertyKey,unkno
  */
 type ToPrimitive<T>=T extends string?string:T extends number?number:T extends null?null:T extends undefined?undefined:T extends boolean?boolean:T extends bigint?bigint:T extends symbol?symbol:{[K in keyof T]:ToPrimitive<T[K]>;};
 /** -------------------------------------------------------
- * * ***Trunc.***
+ * * ***Utility Type: `Trunc`.***
  * -------------------------------------------------------
- * Type version of `Math.trunc()`. Returns the **integer part** of a number
- * by removing any fractional digits.
- *
- * Behavior:
- * - If `T` is a floating-point number, returns the integer part.
- * - Preserves the sign for negative numbers.
- * - If `T` is already an integer, returns `T`.
- * - If `T` is `number` (general type), returns `T`.
- *
+ * **Type version of `Math.trunc()`.**
+ * @description
+ * Returns the **integer part** of a number by removing any fractional digits.
+ * - **Behavior:**
+ *     - If `T` is a floating-point number, returns the integer part.
+ *     - Preserves the sign for negative numbers.
+ *     - If `T` is already an integer, returns `T`.
+ *     - If `T` is `number` (general type), returns `T`.
  * @template T - The number type to truncate.
- *
  * @example
  * ```ts
  * // Positive float
@@ -3578,17 +3301,14 @@ type ToPrimitive<T>=T extends string?string:T extends number?number:T extends nu
  */
 type Trunc<T extends number>=number extends T?T:IsFloat<T>extends true?GetFloatNumberParts<T>[0] extends infer IntegerPart extends number?IsNegative<T>extends true?Negate<IntegerPart>:IntegerPart:never:T;type FilterByType<T extends readonly unknown[],U>=T extends readonly [ infer Head,...infer Tail]?Head extends U?[Head,...FilterByType<Tail,U>]:FilterByType<Tail,U>:[];type GroupedKeys<T extends readonly PropertyKey[]>=[ ...FilterByType<T,symbol>,...FilterByType<T,string>,...FilterByType<T,number>];
 /** -------------------------------------------------------
- * * ***TupleToObject.***
+ * * ***Utility Type: `TupleToObject`.***
  * -------------------------------------------------------
- * Accepts a tuple of `string`, `number`, or `symbol` and returns an object type
- * where each key **and its value** are the elements of the tuple.
- *
- * Behavior:
- * - Tuple elements must extend `PropertyKey` (`string | number | symbol`).
- * - The resulting object has keys and values identical to the tuple elements.
- *
+ * **Accepts a tuple of `string`, `number`, or `symbol` and returns an object type
+ * where each key **and its value** are the elements of the tuple.**
+ * - **Behavior:**
+ *    - Tuple elements must extend `PropertyKey` (`string | number | symbol`).
+ *    - The resulting object has keys and values identical to the tuple elements.
  * @template T - The tuple of property keys.
- *
  * @example
  * ```ts
  * // Tuple of strings
@@ -3606,13 +3326,11 @@ type Trunc<T extends number>=number extends T?T:IsFloat<T>extends true?GetFloatN
  */
 type TupleToObject<T extends readonly PropertyKey[]>={[K in GroupedKeys<T>[number]]:K;};
 /** -------------------------------------------------------
- * * ***Unshift.***
+ * * ***Utility Type: `Unshift`.***
  * -------------------------------------------------------
- * Adds the specified element `U` to the **beginning** of the tuple/array `T`.
- *
+ * **Adds the specified element `U` to the **beginning** of the tuple/array `T`.**
  * @template T - The original tuple or array.
  * @template U - The element to add at the start.
- *
  * @example
  * ```ts
  * // Adding string to a tuple
@@ -3624,4 +3342,4 @@ type TupleToObject<T extends readonly PropertyKey[]>={[K in GroupedKeys<T>[numbe
  * // ➔ [1]
  * ```
  */
-type Unshift<T extends readonly unknown[],U>=[U,...T];export{Abs,And,AndArr,AnyFunction,type AnyRecord,AnyString,type AnyStringRecord,type AreAnagrams,type ArgumentTypes,type ArrayElementType,type Awaitable,type Ceil,type Color,type ColorCssNamed,type ColorOptions,type CompareNumberLength,type CompareStringLength,type Concat,type CustomPromise,type Decrement,type DeepMergeArrayUnion,type DefaultColorOptions,type DefaultHSLOptions,type DefaultNumberLengthOptions,type DefaultPathToFieldsOptions,DefaultPrettifyOptions,type DefaultRGBOptions,type DigitsTuple,type Div,type Dot,type DotArray,type EndsWith,type ExcludeStrict,Extends,ExtendsArr,type Factorial,type Fibonacci,type FirstCharacter,type FirstCharacterOptions,type FirstDigit,type Floor,type GetFloatNumberParts,type HEX,type HSL,type HSLOptions,type Identity,If,type IfColor,IfEmptyArray,IfEmptyString,type IfEqual,IfExtends,type IfGreaterOrEqual,type IfGreaterThan,type IfHEX,type IfHSL,type IfLowerOrEqual,type IfLowerThan,IfNegative,IfNever,type IfNotEqual,IfPositive,type IfRGB,type IfTuple,type Includes,type Increment,type IndexOf,IsAny,type IsArrayIndex,type IsBaseType,type IsBetween,type IsBetweenOptions,type IsColor,type IsDivisible,type IsDivisibleByFive,type IsDivisibleByHundred,type IsDivisibleBySix,type IsDivisibleByTen,type IsDivisibleByThree,type IsDivisibleByTwo,IsEmptyArray,IsEmptyString,type IsEqual,IsEven,type IsExactly,IsFloat,type IsGreaterOrEqual,type IsGreaterThan,type IsHEX,type IsHSL,IsInteger,type IsLetter,type IsLongerNumber,type IsLongerString,type IsLowerOrEqual,type IsLowerThan,IsNegative,IsNegativeInteger,IsNever,type IsNotEqual,type IsPalindrome,IsPositive,type IsRGB,IsReadonlyArray,type IsSameLengthNumber,type IsSameLengthString,type IsShorterNumber,type IsShorterString,IsStringLiteral,type IsTuple,type IsUnion,IsUnknown,type Join,type LastCharacter,type LastCharacterOptions,type LooseLiteral,type Max,type MaxArr,type Min,type MinArr,type Mod,type Multi,Negate,type NonNullableObject,type NonNullableObjectExcept,type NonNullableObjectOnly,NonUndefined,Not,NotExtends,type NumberLength,type NumberRangeLimit,OmitStrict,Or,OrArr,type OverrideTypes,ParseNumber,type PartialExcept,type PartialOnly,type PathToFields,type PathToFieldsOptions,type PickStrict,Pop,type Pow,Prettify,PrettifyOptions,type PrettifyUnionIntersection,Push,type RGB,type RGBOptions,type ReadonlyExcept,type ReadonlyOnly,type RemoveIndexSignature,type RemoveLeading,Repeat,type Replace,type ReplaceAll,type ReplaceToPartial,type ReplaceToRequired,type RequiredExcept,type RequiredOnly,type ReturnItselfIfExtends,type ReturnItselfIfNotExtends,type Reverse,type Round,type Shift,type ShiftOptions,type Slice,type Sort,Split,type StartsWith,type StringLength,type Stringify,type Sub,type Sum,type SumArr,type Swap,type Switch,type ToPrimitive,Trim,type Trunc,type TupleToObject,type TypeNumberLengthOptions,TypedArray,type UnionToIntersection,type UnknownRecord,type Unshift,type ValueOf,type ValueOfArray,type ValueOfExcept,type ValueOfOnly};
+type Unshift<T extends readonly unknown[],U>=[U,...T];export{Abs,And,AndArr,AnyFunction,type AnyRecord,AnyString,type AnyStringRecord,type AreAnagrams,type ArgumentTypes,type ArrayElementType,type Ceil,type Color,type ColorCssNamed,type ColorOptions,type CompareNumberLength,type CompareStringLength,type Concat,type Decrement,type DeepMergeArrayUnion,type DefaultColorOptions,type DefaultHSLOptions,type DefaultNumberLengthOptions,type DefaultPathToFieldsOptions,DefaultPrettifyOptions,type DefaultRGBOptions,type DigitsTuple,type Div,type Dot,type DotArray,type EndsWith,type ExcludeStrict,Extends,ExtendsArr,type Factorial,type Fibonacci,type FirstCharacter,type FirstCharacterOptions,type FirstDigit,type Floor,type GetFloatNumberParts,type HEX,type HSL,type HSLOptions,type Identity,If,type IfColor,IfEmptyArray,IfEmptyString,type IfEqual,IfExtends,type IfGreaterOrEqual,type IfGreaterThan,type IfHEX,type IfHSL,type IfLowerOrEqual,type IfLowerThan,IfNegative,IfNever,type IfNotEqual,IfPositive,type IfRGB,type IfTuple,type Includes,type Increment,type IndexOf,IsAny,type IsArrayIndex,type IsBaseType,type IsBetween,type IsBetweenOptions,type IsColor,type IsDivisible,type IsDivisibleByFive,type IsDivisibleByHundred,type IsDivisibleBySix,type IsDivisibleByTen,type IsDivisibleByThree,type IsDivisibleByTwo,IsEmptyArray,IsEmptyString,type IsEqual,IsEven,type IsExactly,IsFloat,type IsGreaterOrEqual,type IsGreaterThan,type IsHEX,type IsHSL,IsInteger,type IsLetter,type IsLongerNumber,type IsLongerString,type IsLowerOrEqual,type IsLowerThan,IsNegative,IsNegativeInteger,IsNever,type IsNotEqual,type IsPalindrome,IsPositive,type IsRGB,IsReadonlyArray,type IsSameLengthNumber,type IsSameLengthString,type IsShorterNumber,type IsShorterString,IsStringLiteral,type IsTuple,type IsUnion,IsUnknown,type Join,type LastCharacter,type LastCharacterOptions,type LooseLiteral,type Max,type MaxArr,type Min,type MinArr,type Mod,type Multi,Negate,type NonNullableObject,type NonNullableObjectExcept,type NonNullableObjectOnly,NonUndefined,Not,NotExtends,type NumberLength,type NumberRangeLimit,Or,OrArr,ParseNumber,type PartialExcept,type PartialOnly,type PathToFields,type PathToFieldsOptions,Pop,type Pow,Prettify,PrettifyOptions,type PrettifyUnionIntersection,Push,type RGB,type RGBOptions,type ReadonlyExcept,type ReadonlyOnly,type RemoveIndexSignature,type RemoveLeading,Repeat,type Replace,type ReplaceAll,type ReplaceToPartial,type ReplaceToRequired,type RequiredExcept,type RequiredOnly,type ReturnItselfIfExtends,type ReturnItselfIfNotExtends,type Reverse,type Round,type Shift,type ShiftOptions,type Slice,type Sort,Split,type StartsWith,type StringLength,type Stringify,type Sub,type Sum,type SumArr,type Swap,type Switch,type ToPrimitive,Trim,type Trunc,type TupleToObject,type TypeNumberLengthOptions,TypedArray,type UnionToIntersection,type UnknownRecord,type Unshift,type ValueOf,type ValueOfArray,type ValueOfExcept,type ValueOfOnly};