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

package/dist/{is-array--YjXV-Wx.d.ts → is-array-BJeHxPM3.d.ts}

@@ -1,113 +1,21 @@
-import{I as IfExtends,E as Extends,N as Not,a as NotExtends}from'./extends-Bk_SBGdT.js';import{I as If}from'./if-CvT4R7Kh.js';import{T as Trim,I as IfNot}from'./string-XA-til3C.js';import{I as IsNever}from'./never-BfayMBF9.js';import{I as IsAny}from'./any-BmdI8UbK.js';import{P as Prettify}from'./prettify-C4xLcYOP.js';
+import{O as OrArr,A as And,a as AndArr}from'./or-C6qzKt2I.js';import{E as Extends,N as Not,I as IfExtends,a as NotExtends}from'./extends-DtdRjDyU.js';import{I as If}from'./if-ChM35c_q.js';import{T as Trim,I as IfNot}from'./string-B1jlOnws.js';import{I as IsNever}from'./never-D89PbPh5.js';import{I as IsAny}from'./any-v4TsK9ES.js';import{P as Prettify}from'./prettify-3o8_Kw6b.js';
 /** -------------------------------------------------------
- * * ***And.***
+ * * ***Utility Type: `IsStringLiteral`.***
  * -------------------------------------------------------
- * Performs a **logical AND** operation between two boolean types.
- * - Returns `true` if **both** conditions extend `true`.
- * - Returns `false` otherwise.
- *
- * @template Condition1 - The first condition.
- * @template Condition2 - The second condition.
- * @example
- * ```ts
- * type Case1 = And<true, true>;
- * // ➔ true
- * type Case2 = And<false, true>;
- * // ➔ false
- * type Case3 = And<true, false>;
- * // ➔ false
- * type Case4 = And<false, false>;
- * // ➔ false
- * ```
- */
-type And<Condition1,Condition2>=IfExtends<Condition1,true,Extends<Condition2,true>>;
-/** -------------------------------------------------------
- * * ***AndArr.***
- * -------------------------------------------------------
- * Performs a **logical AND** operation across all elements in an array of boolean types.
- * - Returns `true` if **all elements** extend `true`.
- * - Returns `false` if **any element** is not `true`.
- *
- * @template Conditions - A readonly array of boolean conditions.
- * @example
- * ```ts
- * type Case1 = AndArr<[true, true, true]>;
- * // ➔ true
- * type Case2 = AndArr<[true, true, false]>;
- * // ➔ false
- * type Case3 = AndArr<[false, false, false]>;
- * // ➔ false
- * type Case4 = AndArr<[]>;
- * // ➔ true (vacuous truth)
- * ```
- */
-type AndArr<Conditions extends readonly unknown[]>=Extends<Conditions[number],true>;
-/** -------------------------------------------------------
- * * ***IsStringLiteral.***
- * -------------------------------------------------------
- * Returns a boolean whether the passed argument is literal string
- *
+ * **Returns a boolean whether the passed argument is literal string.**
  * @template T - The type value to check.
  * @example
  * type Case1 = IsStringLiteral<'a'>;    // ➔ true
  * type Case2 = IsStringLiteral<1>;      // ➔ false
  * type Case3 = IsStringLiteral<string>; // ➔ false
  */
-type IsStringLiteral<T>=If<Extends<T,string>,Extends<string,T>extends true?false:true,false>;
+type IsStringLiteral<T>=If<Extends<T,string>,Extends<string,T>extends true?false:true>;
 /** -------------------------------------------------------
- * * ***Or.***
+ * * ***Utility Type: `Push`.***
  * -------------------------------------------------------
- *
- * Computes the logical OR of two type-level boolean conditions.
- *
- * @template Condition1 - First boolean condition.
- * @template Condition2 - Second boolean condition.
- *
- * @example
- * ```ts
- * type Case1 = Or<true, true>;   // true
- * type Case2 = Or<false, true>;  // true
- * type Case3 = Or<false, false>; // false
- * type Case4 = Or<true, false>;  // true
- * ```
- *
- * @remarks
- * - Uses {@link IfExtends} to determine if either condition is `true`.
- * - Returns `true` if at least one of the two conditions is `true`.
- * - Returns `false` only if both are `false`.
- */
-type Or<Condition1,Condition2>=IfExtends<Condition1,true,true,IfExtends<Condition2,true>>;
-/** -------------------------------------------------------
- * * ***OrArr.***
- * -------------------------------------------------------
- *
- * Computes the logical OR of all elements inside a tuple or array of boolean types.
- *
- * @template Conditions - An array of boolean type elements.
- *
- * @example
- * ```ts
- * type Case1 = OrArr<[true, true, true]>;    // true
- * type Case2 = OrArr<[true, true, false]>;   // true
- * type Case3 = OrArr<[false, false, false]>; // false
- * type Case4 = OrArr<[]>;                    // false
- * ```
- *
- * @remarks
- * - Uses TypeScript's indexed access types and conditional type inference.
- * - Returns `true` if at least one element in the array is `true`.
- * - Returns `false` if all elements are `false` or array is empty.
- */
-type OrArr<Conditions extends readonly unknown[]>=true extends Conditions[number]?true:false;
-/** -------------------------------------------------------
- * * ***Push.***
- * -------------------------------------------------------
- *
- * Appends a type `U` to the end of a tuple or readonly array type `T`.
- *
- * @template T - The tuple or readonly array type to append to.
+ * **Appends a type `U` to the end of a tuple or readonly array type `T`.**
+ * @template T - The tuple or readonly array type to append U.
  * @template U - The type of the element to push.
- *
  * @example
  * ```ts
  * type Case1 = Push<[1, 2, 3, 4], 5>;
@@ -119,16 +27,14 @@ type OrArr<Conditions extends readonly unknown[]>=true extends Conditions[number
  */
 type Push<T extends readonly unknown[],U>=[...T,U];type _Repeat<T extends string,Count extends number,Result extends string="",Iteration extends unknown[]=[]>=Iteration["length"] extends Count?Result:_Repeat<T,Count,`${T}${Result}`,Push<Iteration,unknown>>;
 /** -------------------------------------------------------
- * * ***Repeat.***
+ * * ***Utility Type: `Repeat`.***
  * -------------------------------------------------------
- *
- * Repeats a string literal type `T` a specified number of times `Count`.
- * - Supports a range of `[0, 999]` due to TypeScript recursion limits.
- * - If `Count > 999`, it is automatically error `Type instantiation is excessively deep and possibly infinite.ts(2589)`.
- *
+ * **Repeats a string literal type `T` a specified number of times `Count`.**
+ * - **Behavior:**
+ *    - Supports a range of `[0, 999]` due to TypeScript recursion limits.
+ *    - If `Count > 999`, it is automatically to `any` because error `Type instantiation is excessively deep and possibly infinite.ts(2589)`.
  * @template T - The string literal to repeat.
  * @template Count - Number of times to repeat.
- *
  * @example
  * ```ts
  * type Case0 = Repeat<'x', 0>;  // ➔ ''
@@ -143,48 +49,36 @@ type Push<T extends readonly unknown[],U>=[...T,U];type _Repeat<T extends string
  */
 type Repeat<T extends string,Count extends number>=_Repeat<T,Count>;
 /** -------------------------------------------------------
- * * ***OddDigit.***
+ * * ***Utility Type: `OddDigit`.***
  * -------------------------------------------------------
- *
- * A union of string literal digits considered ***odd***.
- *
+ * **A union of string literal digits considered ***odd***.**
  * - Includes: `"1" | "3" | "5" | "7" | "9"`.
- *
  * @example
- *
  * ```ts
  * type A = OddDigit; // ➔ "1" | "3" | "5" | "7" | "9"
  * ```
  */
 type OddDigit="1"|"3"|"5"|"7"|"9";
 /** -------------------------------------------------------
- * * ***EvenDigit.***
+ * * ***Utility Type: `EvenDigit`.***
  * -------------------------------------------------------
- *
- * A union of string literal digits considered ***even***.
- *
+ * **A union of string literal digits considered ***even***.**
  * - Includes: `"0" | "2" | "4" | "6" | "8"`.
- *
  * @example
- *
  * ```ts
  * type A = EvenDigit; // ➔ "0" | "2" | "4" | "6" | "8"
  * ```
  */
 type EvenDigit="0"|"2"|"4"|"6"|"8";
 /** -------------------------------------------------------
- * * ***Integer.***
+ * * ***Utility Type: `Integer`.***
  * -------------------------------------------------------
- *
- * A type-level utility that validates if `T` is an ***integer***.
- *
- * - Returns `T` if it is an integer.
- * - Returns `never` if `T` is a ***float*** (decimal).
- *
+ * **A type-level utility that validates if `T` is an ***integer***.**
+ * - **Behavior:**
+ *    - Returns `T` if it is an integer.
+ *    - Returns `never` if `T` is a ***float*** (decimal).
  * @template T - A number type to validate.
- *
  * @example
- *
  * ```ts
  * type A = Integer<42>;   // ➔ 42
  * type B = Integer<-10>;  // ➔ -10
@@ -193,51 +87,39 @@ type EvenDigit="0"|"2"|"4"|"6"|"8";
  */
 type Integer<T extends number>=`${T}`extends`${string}.${string}`?never:T;
 /** -------------------------------------------------------
- * * ***Float.***
+ * * ***Utility Type: `Float`.***
  * -------------------------------------------------------
- *
- * A type-level utility that validates if `T` is a ***float***.
- *
- * - Returns `T` if it is a float.
- * - Returns `never` if `T` is an ***integer***.
- *
+ * **A type-level utility that validates if `T` is a ***float***.**
+ * - **Behavior:**
+ *    - Returns `T` if it is a float.
+ *    - Returns `never` if `T` is an ***integer***.
  * @template T - A number type to validate.
- *
  * @example
- *
  * ```ts
- * type A = Float<3.14>;  // ➔ 3.14
- * type B = Float<42>;    // ➔ never
+ * type A = Float<3.14>; // ➔ 3.14
+ * type B = Float<42>;   // ➔ never
  * ```
  */
 type Float<T extends number>=If<IsNever<Integer<T>>,T,never>;
 /** -------------------------------------------------------
- * * ***Negative.***
+ * * ***Utility Type: `Negative`.***
  * -------------------------------------------------------
- *
- * Extracts `T` if it is ***negative***, otherwise `never`.
- *
+ * **Extracts `T` if it is ***negative***, otherwise `never`.**
  * @template T - A number type to check.
- *
  * @example
- *
  * ```ts
- * type A = Negative<-10>;  // ➔ -10
- * type B = Negative<5>;    // ➔ never
- * type C = Negative<0>;    // ➔ never
+ * type A = Negative<-10>; // ➔ -10
+ * type B = Negative<5>;   // ➔ never
+ * type C = Negative<0>;   // ➔ never
  * ```
  */
 type Negative<T extends number>=`${T}`extends`-${string}`?T:never;
 /** -------------------------------------------------------
- * * ***Positive.***
+ * * ***Utility Type: `Positive`.***
  * -------------------------------------------------------
- *
- * Extracts `T` if it is ***positive*** (or zero), otherwise `never`.
- *
+ * **Extracts `T` if it is ***positive*** (or zero), otherwise `never`.**
  * @template T - A number type to check.
- *
  * @example
- *
  * ```ts
  * type A = Positive<10>; // ➔ 10
  * type B = Positive<0>;  // ➔ 0
@@ -246,15 +128,11 @@ type Negative<T extends number>=`${T}`extends`-${string}`?T:never;
  */
 type Positive<T extends number>=If<IsNever<Negative<T>>,T,never>;
 /** -------------------------------------------------------
- * * ***PositiveInteger.***
+ * * ***Utility Type: `PositiveInteger`.***
  * -------------------------------------------------------
- *
- * Restricts `T` to ***positive integers*** only.
- *
+ * **Restricts `T` to ***positive integers*** only.**
  * @template T - A number type.
- *
  * @example
- *
  * ```ts
  * type A = PositiveInteger<42>;   // ➔ 42
  * type B = PositiveInteger<0>;    // ➔ 0
@@ -264,15 +142,11 @@ type Positive<T extends number>=If<IsNever<Negative<T>>,T,never>;
  */
 type PositiveInteger<T extends number>=Positive<Integer<T>>;
 /** -------------------------------------------------------
- * * ***NegativeInteger.***
+ * * ***Utility Type: `NegativeInteger`.***
  * -------------------------------------------------------
- *
- * Restricts `T` to ***negative integers*** only.
- *
+ * **Restricts `T` to ***negative integers*** only.**
  * @template T - A number type.
- *
  * @example
- *
  * ```ts
  * type A = NegativeInteger<-42>;   // ➔ -42
  * type B = NegativeInteger<5>;     // ➔ never
@@ -281,15 +155,11 @@ type PositiveInteger<T extends number>=Positive<Integer<T>>;
  */
 type NegativeInteger<T extends number>=Negative<Integer<T>>;
 /** -------------------------------------------------------
- * * ***PositiveFloat.***
+ * * ***Utility Type: `PositiveFloat`.***
  * -------------------------------------------------------
- *
- * Restricts `T` to ***positive floats*** only.
- *
+ * **Restricts `T` to ***positive floats*** only.**
  * @template T - A number type.
- *
  * @example
- *
  * ```ts
  * type A = PositiveFloat<3.14>; // ➔ 3.14
  * type B = PositiveFloat<-2.5>; // ➔ never
@@ -298,15 +168,11 @@ type NegativeInteger<T extends number>=Negative<Integer<T>>;
  */
 type PositiveFloat<T extends number>=Positive<Float<T>>;
 /** -------------------------------------------------------
- * * ***NegativeFloat.***
+ * * ***Utility Type: `NegativeFloat`.***
  * -------------------------------------------------------
- *
- * Restricts `T` to ***negative floats*** only.
- *
+ * **Restricts `T` to ***negative floats*** only.**
  * @template T - A number type.
- *
  * @example
- *
  * ```ts
  * type A = NegativeFloat<-3.14>; // ➔ -3.14
  * type B = NegativeFloat<2.5>;   // ➔ never
@@ -315,15 +181,11 @@ type PositiveFloat<T extends number>=Positive<Float<T>>;
  */
 type NegativeFloat<T extends number>=Negative<Float<T>>;
 /** -------------------------------------------------------
- * * ***Even.***
+ * * ***Utility Type: `Even`.***
  * -------------------------------------------------------
- *
- * A type-level utility that extracts `T` if it is an ***even integer***.
- *
+ * **A type-level utility that extracts `T` if it is an ***even integer***.**
  * @template T - A number type to check.
- *
  * @example
- *
  * ```ts
  * type A = Even<0>;    // ➔ 0
  * type B = Even<4>;    // ➔ 4
@@ -335,33 +197,26 @@ type NegativeFloat<T extends number>=Negative<Float<T>>;
  */
 type Even<T extends number>=IfNot<IsNever<Integer<T>>,`${T}`extends`${string}${EvenDigit}`?T:never,never>;
 /** -------------------------------------------------------
- * * ***Odd.***
+ * * ***Utility Type: `Odd`.***
  * -------------------------------------------------------
- *
- * A type-level utility that extracts `T` if it is an ***odd integer***.
- *
+ * **A type-level utility that extracts `T` if it is an ***odd integer***.**
  * @template T - A number type to check.
- *
  * @example
- *
  * ```ts
- * type A = Odd<0>;    // ➔ never
- * type B = Odd<5>;    // ➔ 5
- * type C = Odd<4>;    // ➔ never
- * type D = Odd<23>;   // ➔ 23
- * type E = Odd<26>;   // ➔ never
- * type F = Odd<4.2>;  // ➔ never
+ * type A = Odd<0>;   // ➔ never
+ * type B = Odd<5>;   // ➔ 5
+ * type C = Odd<4>;   // ➔ never
+ * type D = Odd<23>;  // ➔ 23
+ * type E = Odd<26>;  // ➔ never
+ * type F = Odd<4.2>; // ➔ never
  * ```
  */
 type Odd<T extends number>=IfNot<IsNever<Integer<T>>,If<IsNever<Even<T>>,T,never>,never>;
 /** -------------------------------------------------------
- * * ***IsInteger.***
+ * * ***Utility Type: `IsInteger`.***
  * -------------------------------------------------------
- *
- * Whether `T` is an ***integer***.
- *
+ * **Whether `T` is an ***integer***.**
  * @example
- *
  * ```ts
  * type A = IsInteger<-2>;   // ➔ true
  * type B = IsInteger<0>;    // ➔ true
@@ -371,13 +226,10 @@ type Odd<T extends number>=IfNot<IsNever<Integer<T>>,If<IsNever<Even<T>>,T,never
  */
 type IsInteger<T extends number>=Not<IsNever<Integer<T>>>;
 /** -------------------------------------------------------
- * * ***IsFloat.***
+ * * ***Utility Type: `IsFloat`.***
  * -------------------------------------------------------
- *
- * Whether `T` is a ***float***.
- *
+ * **Whether `T` is a ***float***.**
  * @example
- *
  * ```ts
  * type A = IsFloat<3.14>;  // ➔ true
  * type B = IsFloat<-3.14>; // ➔ true
@@ -388,13 +240,10 @@ type IsInteger<T extends number>=Not<IsNever<Integer<T>>>;
  */
 type IsFloat<T extends number>=Not<IsNever<Float<T>>>;
 /** -------------------------------------------------------
- * * ***IsEven.***
+ * * ***Utility Type: `IsEven`.***
  * -------------------------------------------------------
- *
- * Whether `T` is ***even***.
- *
+ * **Whether `T` is ***even***.**
  * @example
- *
  * ```ts
  * type A = IsEven<0>;    // ➔ true
  * type B = IsEven<4>;    // ➔ true
@@ -406,13 +255,10 @@ type IsFloat<T extends number>=Not<IsNever<Float<T>>>;
  */
 type IsEven<T extends number>=If<IsInteger<T>,`${T}`extends`${string}${EvenDigit}`?true:false>;
 /** -------------------------------------------------------
- * * ***IsOdd.***
+ * * ***Utility Type: `IsOdd`.***
  * -------------------------------------------------------
- *
- * Whether `T` is ***odd***.
- *
+ * **Whether `T` is ***odd***.**
  * @example
- *
  * ```ts
  * type A = IsEven<0>;    // ➔ false
  * type B = IsEven<4>;    // ➔ false
@@ -424,47 +270,38 @@ type IsEven<T extends number>=If<IsInteger<T>,`${T}`extends`${string}${EvenDigit
  */
 type IsOdd<T extends number>=If<IsInteger<T>,Not<IsEven<T>>>;
 /** -------------------------------------------------------
- * * ***IsPositive.***
+ * * ***Utility Type: `IsPositive`.***
  * -------------------------------------------------------
- *
- * Whether `T` is ***positive***.
- *
+ * **Whether `T` is ***positive***.**
  * @example
- *
  * ```ts
- * type A = IsPositive<10>;    // ➔ true
- * type B = IsPositive<0>;     // ➔ true
- * type C = IsPositive<-5>;    // ➔ false
- * type D = IsPositive<3.5>;   // ➔ true
- * type E = IsPositive<-3.5>;  // ➔ false
+ * type A = IsPositive<10>;   // ➔ true
+ * type B = IsPositive<0>;    // ➔ true
+ * type C = IsPositive<-5>;   // ➔ false
+ * type D = IsPositive<3.5>;  // ➔ true
+ * type E = IsPositive<-3.5>; // ➔ false
  * ```
  */
 type IsPositive<T extends number>=Not<IsNever<Positive<T>>>;
 /** -------------------------------------------------------
- * * ***IsNegative.***
+ * * ***Utility Type: `IsNegative`.***
  * -------------------------------------------------------
- *
- * Whether `T` is ***negative***.
- *
+ * **Whether `T` is ***negative***.**
  * @example
- *
  * ```ts
- * type A = IsNegative<-10>;   // ➔ true
- * type B = IsNegative<5>;     // ➔ false
- * type C = IsNegative<0>;     // ➔ false
- * type D = IsPositive<3.5>;   // ➔ false
- * type E = IsPositive<-3.5>;  // ➔ true
+ * type A = IsNegative<-10>;  // ➔ true
+ * type B = IsNegative<5>;    // ➔ false
+ * type C = IsNegative<0>;    // ➔ false
+ * type D = IsPositive<3.5>;  // ➔ false
+ * type E = IsPositive<-3.5>; // ➔ true
  * ```
  */
 type IsNegative<T extends number>=Not<IsNever<Negative<T>>>;
 /** -------------------------------------------------------
- * * ***IsPositiveInteger.***
+ * * ***Utility Type: `IsPositiveInteger`.***
  * -------------------------------------------------------
- *
- * Whether `T` is a ***positive integer***.
- *
+ * **Whether `T` is a ***positive integer***.**
  * @example
- *
  * ```ts
  * type A = IsPositiveInteger<42>;   // ➔ true
  * type B = IsPositiveInteger<0>;    // ➔ true
@@ -474,13 +311,10 @@ type IsNegative<T extends number>=Not<IsNever<Negative<T>>>;
  */
 type IsPositiveInteger<T extends number>=Not<IsNever<PositiveInteger<T>>>;
 /** -------------------------------------------------------
- * * ***IsNegativeInteger.***
+ * * ***Utility Type: `IsNegativeInteger`.***
  * -------------------------------------------------------
- *
- * Whether `T` is a ***negative integer***.
- *
+ * **Whether `T` is a ***negative integer***.**
  * @example
- *
  * ```ts
  * type A = IsNegativeInteger<-42>;   // ➔ true
  * type B = IsNegativeInteger<5>;     // ➔ false
@@ -489,13 +323,10 @@ type IsPositiveInteger<T extends number>=Not<IsNever<PositiveInteger<T>>>;
  */
 type IsNegativeInteger<T extends number>=Not<IsNever<NegativeInteger<T>>>;
 /** -------------------------------------------------------
- * * ***IsPositiveFloat.***
+ * * ***Utility Type: `IsPositiveFloat`.***
  * -------------------------------------------------------
- *
- * Whether `T` is a ***positive float***.
- *
+ * **Whether `T` is a ***positive float***.**
  * @example
- *
  * ```ts
  * type A = IsPositiveFloat<3.14>; // ➔ true
  * type B = IsPositiveFloat<-2.5>; // ➔ false
@@ -504,13 +335,10 @@ type IsNegativeInteger<T extends number>=Not<IsNever<NegativeInteger<T>>>;
  */
 type IsPositiveFloat<T extends number>=Not<IsNever<PositiveFloat<T>>>;
 /** -------------------------------------------------------
- * * ***IsNegativeFloat.***
+ * * ***Utility Type: `IsNegativeFloat`.***
  * -------------------------------------------------------
- *
- * Whether `T` is a ***negative float***.
- *
+ * **Whether `T` is a ***negative float***.**
  * @example
- *
  * ```ts
  * type A = IsNegativeFloat<-3.14>; // ➔ true
  * type B = IsNegativeFloat<2.5>;   // ➔ false
@@ -519,228 +347,187 @@ type IsPositiveFloat<T extends number>=Not<IsNever<PositiveFloat<T>>>;
  */
 type IsNegativeFloat<T extends number>=Not<IsNever<NegativeFloat<T>>>;
 /** -------------------------------------------------------
- * * ***IfInteger.***
+ * * ***Utility Type: `IfInteger`.***
  * -------------------------------------------------------
- *
- * Conditional: `If` branch if `T` is an ***integer***.
- *
+ * **Conditional: `If` branch if `T` is an ***integer***.**
  * @example
- *
  * ```ts
- * type A = IfInteger<42>;                 // ➔ true
- * type B = IfInteger<3.14>;               // ➔ false
- * type C = IfInteger<42, "yes", "no">;    // ➔ "yes"
- * type D = IfInteger<3.14, "yes", "no">;  // ➔ "no"
+ * type A = IfInteger<42>;                // ➔ true
+ * type B = IfInteger<3.14>;              // ➔ false
+ * type C = IfInteger<42, "yes", "no">;   // ➔ "yes"
+ * type D = IfInteger<3.14, "yes", "no">; // ➔ "no"
  * ```
  */
 type IfInteger<T extends number,IfTrue=true,IfFalse=false>=If<IsInteger<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfFloat.***
+ * * ***Utility Type: `IfFloat`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is a ***float***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is a ***float***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfFloat<3.14>;                // ➔ true
- * type B = IfFloat<42>;                  // ➔ false
- * type C = IfFloat<3.14, "yes", "no">;   // ➔ "yes"
- * type D = IfFloat<42, "yes", "no">;     // ➔ "no"
+ * type A = IfFloat<3.14>;              // ➔ true
+ * type B = IfFloat<42>;                // ➔ false
+ * type C = IfFloat<3.14, "yes", "no">; // ➔ "yes"
+ * type D = IfFloat<42, "yes", "no">;   // ➔ "no"
  * ```
  */
 type IfFloat<T extends number,IfTrue=true,IfFalse=false>=If<IsFloat<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfEven.***
+ * * ***Utility Type: `IfEven`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is ***even***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is ***even***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfEven<4>;                 // ➔ true
- * type B = IfEven<5>;                 // ➔ false
- * type C = IfEven<4, "even", "odd">;  // ➔ "even"
- * type D = IfEven<5, "even", "odd">;  // ➔ "odd"
+ * type A = IfEven<4>;                // ➔ true
+ * type B = IfEven<5>;                // ➔ false
+ * type C = IfEven<4, "even", "odd">; // ➔ "even"
+ * type D = IfEven<5, "even", "odd">; // ➔ "odd"
  * ```
  */
 type IfEven<T extends number,IfTrue=true,IfFalse=false>=If<IsEven<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfOdd.***
+ * * ***Utility Type: `IfOdd`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is ***odd***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is ***odd***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfOdd<5>;                 // ➔ true
- * type B = IfOdd<4>;                 // ➔ false
- * type C = IfOdd<5, "odd", "even">;  // ➔ "odd"
- * type D = IfOdd<4, "odd", "even">;  // ➔ "even"
+ * type A = IfOdd<5>;                // ➔ true
+ * type B = IfOdd<4>;                // ➔ false
+ * type C = IfOdd<5, "odd", "even">; // ➔ "odd"
+ * type D = IfOdd<4, "odd", "even">; // ➔ "even"
  * ```
  */
 type IfOdd<T extends number,IfTrue=true,IfFalse=false>=If<IsOdd<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfPositive.***
+ * * ***Utility Type: `IfPositive`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is ***positive***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is ***positive***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfPositive<10>;                 // ➔ true
- * type B = IfPositive<-5>;                 // ➔ false
- * type C = IfPositive<10, "yes", "no">;    // ➔ "yes"
- * type D = IfPositive<-5, "yes", "no">;    // ➔ "no"
+ * type A = IfPositive<10>;              // ➔ true
+ * type B = IfPositive<-5>;              // ➔ false
+ * type C = IfPositive<10, "yes", "no">; // ➔ "yes"
+ * type D = IfPositive<-5, "yes", "no">; // ➔ "no"
  * ```
  */
 type IfPositive<T extends number,IfTrue=true,IfFalse=false>=If<IsPositive<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfNegative.***
+ * * ***Utility Type: `IfNegative`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is ***negative***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is ***negative***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfNegative<-10>;                 // ➔ true
- * type B = IfNegative<5>;                   // ➔ false
- * type C = IfNegative<-10, "yes", "no">;    // ➔ "yes"
- * type D = IfNegative<5, "yes", "no">;      // ➔ "no"
+ * type A = IfNegative<-10>;              // ➔ true
+ * type B = IfNegative<5>;                // ➔ false
+ * type C = IfNegative<-10, "yes", "no">; // ➔ "yes"
+ * type D = IfNegative<5, "yes", "no">;   // ➔ "no"
  * ```
  */
 type IfNegative<T extends number,IfTrue=true,IfFalse=false>=If<IsNegative<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfPositiveInteger.***
+ * * ***Utility Type: `IfPositiveInteger`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is a ***positive integer***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is a ***positive integer***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfPositiveInteger<42>;                 // ➔ true
- * type B = IfPositiveInteger<-5>;                 // ➔ false
- * type C = IfPositiveInteger<42, "yes", "no">;    // ➔ "yes"
- * type D = IfPositiveInteger<-5, "yes", "no">;    // ➔ "no"
+ * type A = IfPositiveInteger<42>;              // ➔ true
+ * type B = IfPositiveInteger<-5>;              // ➔ false
+ * type C = IfPositiveInteger<42, "yes", "no">; // ➔ "yes"
+ * type D = IfPositiveInteger<-5, "yes", "no">; // ➔ "no"
  * ```
  */
 type IfPositiveInteger<T extends number,IfTrue=true,IfFalse=false>=If<IsPositiveInteger<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfNegativeInteger.***
+ * * ***Utility Type: `IfNegativeInteger`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is a ***negative integer***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is a ***negative integer***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfNegativeInteger<-42>;                 // ➔ true
- * type B = IfNegativeInteger<5>;                   // ➔ false
- * type C = IfNegativeInteger<-42, "yes", "no">;    // ➔ "yes"
- * type D = IfNegativeInteger<5, "yes", "no">;      // ➔ "no"
+ * type A = IfNegativeInteger<-42>;              // ➔ true
+ * type B = IfNegativeInteger<5>;                // ➔ false
+ * type C = IfNegativeInteger<-42, "yes", "no">; // ➔ "yes"
+ * type D = IfNegativeInteger<5, "yes", "no">;   // ➔ "no"
  * ```
  */
 type IfNegativeInteger<T extends number,IfTrue=true,IfFalse=false>=If<IsNegativeInteger<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfPositiveFloat.***
+ * * ***Utility Type: `IfPositiveFloat`.***
  * -------------------------------------------------------
- *
- * Conditional: selects one of two branches depending on whether `T` is a ***positive float***.
- *
+ * **Conditional: selects one of two branches depending on whether `T` is a ***positive float***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
- *
  * ```ts
- * type A = IfPositiveFloat<3.14>;                 // ➔ true
- * type B = IfPositiveFloat<-2.5>;                 // ➔ false
- * type C = IfPositiveFloat<3.14, "yes", "no">;    // ➔ "yes"
- * type D = IfPositiveFloat<-2.5, "yes", "no">;    // ➔ "no"
+ * type A = IfPositiveFloat<3.14>;              // ➔ true
+ * type B = IfPositiveFloat<-2.5>;              // ➔ false
+ * type C = IfPositiveFloat<3.14, "yes", "no">; // ➔ "yes"
+ * type D = IfPositiveFloat<-2.5, "yes", "no">; // ➔ "no"
  * ```
  */
 type IfPositiveFloat<T extends number,IfTrue=true,IfFalse=false>=If<IsPositiveFloat<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***IfNegativeFloat.***
+ * * ***Utility Type: `IfNegativeFloat`.***
  * -------------------------------------------------------
- * Conditional: selects one of two branches depending on whether `T` is a ***negative float***.
+ * **Conditional: selects one of two branches depending on whether `T` is a ***negative float***.**
  * - Defaults: `IfTrue = true`, `IfFalse = false`.
- *
  * @template T - A number type.
- * @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
  * ```ts
- * type A = IfNegativeFloat<-3.14>;                 // ➔ true
- * type B = IfNegativeFloat<2.5>;                   // ➔ false
- * type C = IfNegativeFloat<-3.14, "yes", "no">;    // ➔ "yes"
- * type D = IfNegativeFloat<2.5, "yes", "no">;      // ➔ "no"
+ * type A = IfNegativeFloat<-3.14>;              // ➔ true
+ * type B = IfNegativeFloat<2.5>;                // ➔ false
+ * type C = IfNegativeFloat<-3.14, "yes", "no">; // ➔ "yes"
+ * type D = IfNegativeFloat<2.5, "yes", "no">;   // ➔ "no"
  * ```
  */
 type IfNegativeFloat<T extends number,IfTrue=true,IfFalse=false>=If<IsNegativeFloat<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
- * * ***ParseNumber.***
+ * * ***Utility Type: `ParseNumber`.***
  * --------------------------------------------------------
- * Converts a string or property key literal into a ***number literal***.
- * - Supports decimal numbers only.
- * - Automatically trims whitespace.
- * - Returns the number literal if valid.
- * - Supports scientific notation strings (e.g., `"2e-3"`, `"-5e2"`, `"2E-3"`, `"-5E2"`).
- *   - **Note:** TypeScript cannot represent very small (<1e-6) or very large (>1e15)
- *     numbers as literal types. In such cases, scientific notation strings return `0`.
- * - Returns `0` for strings representing hexadecimal (`0x...`), octal (`0o...`), or binary (`0b...`) if they are string literals.
+ * **Converts a string or property key literal into a ***number literal***.**
+ * - **Behavior:**
+ *    - Supports decimal numbers only.
+ *    - Automatically trims whitespace.
+ *    - Returns the number literal if valid.
+ *    - Supports scientific notation strings (e.g., `"2e-3"`, `"-5e2"`, `"2E-3"`, `"-5E2"`).
+ *      - **Note:**
+ *         - TypeScript cannot represent very small (`< 1e-6`) or very large (`> 1e15`)
+ *           numbers as literal types:
+ *           - In such cases, scientific notation strings return `0`.
+ *    - Returns `0` for strings representing hexadecimal (`0x...`), octal (`0o...`), or
+ *      binary (`0b...`) if they are string literals.
  * - Returns `never` for non-numeric strings or unsupported formats.
- *
  * @template T - A string, number, or symbol (property key).
  * @example
  * ```ts
@@ -805,93 +592,79 @@ type IfNegativeFloat<T extends number,IfTrue=true,IfFalse=false>=If<IsNegativeFl
  */
 type ParseNumber<T extends PropertyKey|bigint>=T extends bigint?T:If<number extends T?false:true,IfExtends<OrArr<[ Extends<`-0`,Trim<Extract<T,PropertyKey>>>,Extends<-0,T>,Extends<T,`${"-" | ""}${"0"}.`>]>,true,0,T extends`${"-" | ""}0${"x" | "b" | "o"}${number}`?0:Trim<Extract<T,PropertyKey>>extends`${infer NumT extends number | string}`?T extends`${infer N extends number}.`?N:NumT extends string?ParseScientificNumber<NumT>:NumT:Trim<Extract<T,PropertyKey>>extends number?T:never>,never>;
 /** -------------------------------------------------------
- * * ***IsScientificNumber.***
- * -------------------------------------------------------
- *
- * Checks if a string literal `T` represents a **scientific number**.
- *
- * A scientific number is defined as a number in the form of:
- * - Optional negative sign (`-`)
- * - Mantissa (digits, can be integer or decimal)
- * - Exponent indicated by `e` or `E`
- * - Exponent value (digits, optional negative sign)
- *
- * **Important:** TypeScript cannot detect numeric literals in scientific notation
- * at type-level because number literals are normalized to decimals.
- * Only string literals like `"2.5E3"` or `"-1e-5"` can be detected.
- *
+ * * ***Utility Type: `IsScientificNumber`.***
+ * -------------------------------------------------------
+ * **Checks if a string literal `T` represents a **scientific number**.**
+ * - **A scientific number is defined as a number in the form of:**
+ *    - Optional negative sign (`-`).
+ *    - Mantissa (digits, can be integer or decimal).
+ *    - Exponent indicated by `e` or `E`.
+ *    - Exponent value (digits, optional negative sign).
+ *    - **Important:**
+ *       - TypeScript cannot detect numeric literals in scientific notation
+ *         at type-level because number literals are normalized to decimals:
+ *         - Only string literals like `"2.5E3"` or `"-1e-5"` can be detected.
  * @template T - A string literal to check.
- *
  * @example
  * ```ts
- * type A = IsScientificNumber<"1e5">;     // true
- * type B = IsScientificNumber<"-1e-5">;   // true
- * type C = IsScientificNumber<"2.5E3">;   // true
- * type D = IsScientificNumber<"42">;      // false
- * type E = IsScientificNumber<"-0.42">;   // false
- * type F = IsScientificNumber<string>;    // false
+ * type A = IsScientificNumber<"1e5">;   // ➔ true
+ * type B = IsScientificNumber<"-1e-5">; // ➔ true
+ * type C = IsScientificNumber<"2.5E3">; // ➔ true
+ * type D = IsScientificNumber<"42">;    // ➔ false
+ * type E = IsScientificNumber<"-0.42">; // ➔ false
+ * type F = IsScientificNumber<string>;  // ➔ false
  * ```
- *
  * @remarks
- * - Uses template literal types and conditional type {@link Extends}.
+ * - Uses template literal types and conditional type {@link Extends | **`Extends`**}.
  * - Returns `true` if `T` is scientific number string literal, otherwise `false`.
  * - Returns `boolean` if `T` is generic `string`.
  */
 type IsScientificNumber<T extends string>=Extends<T,`${"-" | ""}${number}${"e" | "E"}${number}`>;
-/**
- * Helper for {@link ParseScientificNumber}
- */
+/** * ***Helper for {@link ParseScientificNumber | **`ParseScientificNumber`**}.*** */
 type BuildTuple<L extends number,T extends unknown[]=[]>=T["length"] extends L?T:BuildTuple<L,[...T,unknown]>;
-/**
- * Helper for {@link ParseScientificNumber}
- */
+/** * ***Helper for {@link ParseScientificNumber | **`ParseScientificNumber`**}.*** */
 type _DecrementParseScientific<N extends number>=BuildTuple<N>extends [ infer _,...infer Rest]?Rest["length"]:never;
 /** -------------------------------------------------------
- * * ***ParseScientificNumber***
+ * * ***Utility Type: `ParseScientificNumber`.***
  * -------------------------------------------------------
- *
- * Converts a numeric string in scientific notation (e.g., `"2e-3"`, `"-5e2"`)
- * into a literal number type.
- *
- * **Important:** TypeScript cannot represent very small or very large numbers
- * as literal types. In such cases, this utility will return `0`.
- *
+ * **Converts a numeric string in scientific notation (e.g., `"2e-3"`, `"-5e2"`)
+ * into a literal number type.**
+ * - **Important:**
+ *    - TypeScript cannot represent very small or very large numbers
+ *      as literal types:
+ *      - In such cases, this utility will return `0`.
  * @template T - A numeric string to parse. Can be in:
- * - Positive or negative scientific notation (e.g., `"1e3"`, `"-2e-2"`)
- * - Regular number literal (e.g., `"42"`, `"-5"`)
- *
+ * - Positive or negative scientific notation (e.g., `"1e3"`, `"-2e-2"`).
+ * - Regular number literal (e.g., `"42"`, `"-5"`).
  * @example
  * ```ts
- * type A1 = ParseScientificNumber<"2e-3">;    // 0.002
- * type A2 = ParseScientificNumber<"-2e-3">;   // -0.002
- * type A3 = ParseScientificNumber<"5e2">;     // 500
- * type A4 = ParseScientificNumber<"-5e2">;    // -500
- * type A5 = ParseScientificNumber<"2e-7">;    // 0 (TypeScript cannot represent literal)
- * type A6 = ParseScientificNumber<"5e21">;    // 0 (TypeScript cannot represent literal)
- * type A7 = ParseScientificNumber<"42">;      // 42
- * type A8 = ParseScientificNumber<"-42">;     // -42
+ * type A1 = ParseScientificNumber<"2e-3">;  // ➔ 0.002
+ * type A2 = ParseScientificNumber<"-2e-3">; // ➔ -0.002
+ * type A3 = ParseScientificNumber<"5e2">;   // ➔ 500
+ * type A4 = ParseScientificNumber<"-5e2">;  // ➔ -500
+ * type A5 = ParseScientificNumber<"2e-7">;  // ➔ 0 (TypeScript cannot represent literal)
+ * type A6 = ParseScientificNumber<"5e21">;  // ➔ 0 (TypeScript cannot represent literal)
+ * type A7 = ParseScientificNumber<"42">;    // ➔ 42
+ * type A8 = ParseScientificNumber<"-42">;   // ➔ -42
  * ```
- *
  * @remarks
  * - Uses type-level string manipulation to handle scientific notation.
- * - Negative exponents are adjusted with {@link _DecrementParseScientific} and {@link Repeat}.
+ * - Negative exponents are adjusted with {@link _DecrementParseScientific | **`_DecrementParseScientific`**} and
+ *  {@link Repeat | **`Repeat`**}.
  * - Returns `0` if TypeScript cannot infer the exact numeric literal.
  */
 type ParseScientificNumber<T extends string>=T extends`-${infer Mantissa}${"e" | "E"}-${infer Exp extends number}`?`-${"0."}${Repeat<"0", _DecrementParseScientific<Exp>>}${Mantissa}`extends`${infer N extends number}`?number extends N?0:N:never:T extends`${infer Mantissa}${"e" | "E"}-${infer Exp extends number}`?`0.${Repeat<"0", _DecrementParseScientific<Exp>>}${Mantissa}`extends`${infer N extends number}`?number extends N?0:N:never:T extends`-${infer Mantissa}${"e" | "E"}${infer Exp extends number}`?`-${Mantissa}${Repeat<"0", Exp>}`extends`${infer N extends number}`?number extends N?0:N:never:T extends`${infer Mantissa}${"e" | "E"}${infer Exp extends number}`?`${Mantissa}${Repeat<"0", Exp>}`extends`${infer N extends number}`?number extends N?0:N:never:T extends`${infer N extends number}`?number extends N?0:N:never;
 /** -------------------------------------------------------
- * * ***Abs.***
+ * * ***Utility Type: `Abs`.***
  * -------------------------------------------------------
- *
- * Computes the ***absolute value*** of `T`.
- *
- * - Accepts `number` literals or numeric `string` literals.
- * - Returns the ***absolute value*** as a `number`.
- * - If `T` is not a valid number (e.g., hex, binary, octal, or non-numeric string), the result is `never`.
- *
+ * **Computes the ***absolute value*** of `T`.**
+ * - **Behavior:**
+ *    - Accepts `number` literals or numeric `string` literals.
+ *    - Returns the ***absolute value*** as a `number`.
+ *    - If `T` is not a valid number, ***`like`***:
+ *      - `hex`, `binary`, `octal`, or `non-numeric string` will return `never`.
  * @template T - A number type or string literal representing a number.
- *
  * @example
- *
  * ```ts
  * type A = Abs<-42>;   // ➔ 42
  * type B = Abs<10>;    // ➔ 10
@@ -909,19 +682,16 @@ type ParseScientificNumber<T extends string>=T extends`-${infer Mantissa}${"e" |
  */
 type Abs<T extends PropertyKey|bigint>=`${Exclude<T, symbol>}`extends`-${infer PositiveT extends number}`?ParseNumber<PositiveT>:ParseNumber<T>;
 /** -------------------------------------------------------
- * * ***Negate.***
+ * * ***Utility Type: `Negate`.***
  * -------------------------------------------------------
- *
- * Produces the ***negated value*** of `T` (multiplies by `-1`).
- *
- * - Only supports valid **number literals** or **numeric-strings**.
- * - Invalid numeric-strings (e.g. `"1a"`, `"abc"`, hex, binary, octal)
- *   or non-numeric types (e.g. `string`, `number`, `symbol`) will return `0`.
- *
+ * **Produces the ***negated value*** of `T` (multiplies by `-1`).**
+ * - **Behavior:**
+ *    - Only supports valid **number literals** or **numeric-strings**.
+ *    - Invalid numeric-strings (***like***: `"1a"`, `"abc"`, `hex`, `binary`, `octal`)
+ *      or `non-numeric` types, ***`like`***:
+ *      - `string`, `number`, `symbol` will return `0`.
  * @template T - A number type or numeric-string.
- *
  * @example
- *
  * ```ts
  * type A = Negate<5>;     // ➔ -5
  * type B = Negate<-10>;   // ➔ -10
@@ -942,56 +712,54 @@ type Abs<T extends PropertyKey|bigint>=`${Exclude<T, symbol>}`extends`-${infer P
  */
 type Negate<T extends PropertyKey>=ParseNumber<`-${Abs<ParseNumber<T>>}`>;
 /** -------------------------------------------------------
- * * ***Split***
+ * * ***Utility Type: `Split`***
  * -------------------------------------------------------
- *
- * A type-level utility that mimics `String.prototype.split()`.
+ * **A type-level utility that mimics `String.prototype.split()`.**
+ * @description
  * Splits a string literal `Str` into a tuple of substrings,
  * using `Del` as the delimiter.
- *
- * - If `Del` is the empty string `""`, the result is a tuple of characters.
- * - If `Del` is not found in `Str`, the result is a tuple with the original string.
- * - Works only with string literals. If `Str` is just `string`, the result is `string[]`.
- *
+ * - **Behavior:**
+ *    - If `Del` is the empty string `""`, the result is a tuple of characters.
+ *    - If `Del` is not found in `Str`, the result is a tuple with the original string.
+ *    - Works only with string literals. If `Str` is just `string`, the result is `string[]`.
  * @template Str - The input string literal to be split.
  * @template Del - The delimiter used to split the string.
  *                 Defaults to `""` (character-level split).
- *
- * #### Constraints
+ * @constraints
  * - `Str` must be a string literal to get precise results.
  * - `Del` can be a string or number (numbers are converted to strings).
- *
- * #### Examples
+ * @example
  * ```ts
  * // ✅ Split into characters
- * type A = Split<"abc">;           // ["a", "b", "c"]
+ * type A = Split<"abc">; // ➔ ["a", "b", "c"]
  *
  * // ✅ Split by a comma
- * type B = Split<"a,b,c", ",">;    // ["a", "b", "c"]
+ * type B = Split<"a,b,c", ",">; // ➔ ["a", "b", "c"]
  *
  * // ✅ Split by multi-char delimiter
- * type C = Split<"2025-08-22", "-">;  // ["2025", "08", "22"]
+ * type C = Split<"2025-08-22", "-">; // ➔ ["2025", "08", "22"]
  *
- * // ✅ Delimiter not found → returns whole string
- * type D = Split<"hello", "|">;    // ["hello"]
+ * // ✅ Delimiter not found ➔ returns whole string
+ * type D = Split<"hello", "|">; // ➔ ["hello"]
  *
  * // ⚠️ Non-literal string
- * type E = Split<string, ",">;     // string[]
+ * type E = Split<string, ",">; // string[]
  * ```
  */
-type Split<Str extends string,Del extends string|number="">=string extends Str?string[]:""extends Str?[]:Str extends`${infer T}${Del}${infer U}`?[T,...Split<U,Del>]:[Str];type _CharAt<I extends string,N extends number|`${number}`,_S extends string[]=Split<I,"">>=IfExtends<And<Extends<IsPositive<ParseNumber<N>>,true>,Extends<And<Extends<N,keyof _S>,Extends<IsStringLiteral<I>,true>>,true>>,true,_S[Extract<N,keyof _S>],undefined>;
+type Split<Str extends string,Del extends string|number="">=string extends Str?string[]:""extends Str?[]:Str extends`${infer T}${Del}${infer U}`?[T,...Split<U,Del>]:[Str];
+/** @private ***types for {@link CharAt}.*** */
+type _CharAt<I extends string,N extends number|`${number}`,_S extends string[]=Split<I,"">>=IfExtends<And<Extends<IsPositive<ParseNumber<N>>,true>,Extends<And<Extends<N,keyof _S>,Extends<IsStringLiteral<I>,true>>,true>>,true,_S[Extract<N,keyof _S>],undefined>;
 /** -------------------------------------------------------
- * * ***CharAt.***
+ * * ***Utility Type: `CharAt`.***
  * -------------------------------------------------------
- * A type-level utility that extracts the character at a given index `N`
- * from a string literal type `I`.
- * - If the index is out of range, the result is `undefined`.
- * - If `I` is not a literal string (just `string`), the result is `undefined`.
- * - Only **positive indices** are supported (`0` and above`).
- *
+ * **A type-level utility that extracts the character at a given index `N`
+ * from a string literal type `I`.**
+ * - **Behavior:**
+ *    - If the index is out of range, the result is `undefined`.
+ *    - If `I` is not a literal string (just `string`), the result is `undefined`.
+ *    - Only **positive indices** are supported (`0` and above`).
  * @template I - The input string literal to extract the character from.
  * @template N - The zero-based index of the character to retrieve.
- *               Can be a `number` or a stringified number (e.g. `2` or "2").
  * @example
  * ```ts
  * // ✅ Basic usage
@@ -999,7 +767,7 @@ type Split<Str extends string,Del extends string|number="">=string extends Str?s
  * type B = CharAt<"hello", 1>; // ➔ "e"
  * type C = CharAt<"hello", 4>; // ➔ "o"
  *
- * // ✅ Index out of range → undefined
+ * // ⚠️ Index out of range ➔ undefined
  * type D = CharAt<"hello", 5>; // ➔ undefined
  * type E = CharAt<"abc", 99>;  // ➔ undefined
  *
@@ -1009,7 +777,7 @@ type Split<Str extends string,Del extends string|number="">=string extends Str?s
  * type H = CharAt<"testing", "6">; // ➔ "g"
  * type I = CharAt<"testing", "7">; // ➔ undefined
  *
- * // ⚠️ Non-literal strings → undefined
+ * // ⚠️ Non-literal strings ➔ undefined
  * type J = CharAt<string, 2>; // ➔ undefined
  *
  * // ⚠️ Negative indices are not supported
@@ -1018,12 +786,10 @@ type Split<Str extends string,Del extends string|number="">=string extends Str?s
  */
 type CharAt<I extends string,N extends number|`${number}`>=_CharAt<I,N>;
 /** -------------------------------------------------------
- * * ***IsUnknown.***
+ * * ***Utility Type: `IsUnknown`.***
  * -------------------------------------------------------
- * Returns a boolean indicating whether the given type `T` is `unknown`.
- *
+ * **Returns a boolean indicating whether the given type `T` is `unknown`.**
  * @template T - The type to check.
- *
  * @example
  * ```ts
  * type TrueResult = IsUnknown<unknown>;  // ➔ true
@@ -1033,14 +799,13 @@ type CharAt<I extends string,N extends number|`${number}`>=_CharAt<I,N>;
  */
 type IsUnknown<T>=IsAny<T>extends true?false:[unknown] extends [T]?true:false;
 /** -------------------------------------------------------
- * * ***IfUnknown.***
+ * * ***Utility Type: `IfUnknown`.***
  * -------------------------------------------------------
- * Conditional type: returns `IfTrue` if `T` is `unknown`, otherwise returns `IfFalse`.
- *
+ * - **Conditional type:**
+ *    - Returns `IfTrue` if `T` is `unknown`, otherwise returns `IfFalse`.
  * @template T - The type to check.
  * @template IfTrue - The type returned if `T` is `unknown` (default: `true`).
  * @template IfFalse - The type returned if `T` is not `unknown` (default: `false`).
- *
  * @example
  * ```ts
  * type Result1 = IfUnknown<unknown, "foo", "bar">; // ➔ "foo"
@@ -1048,11 +813,9 @@ type IsUnknown<T>=IsAny<T>extends true?false:[unknown] extends [T]?true:false;
  * ```
  */
 type IfUnknown<T,IfTrue=true,IfFalse=false>=If<IsUnknown<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***UnknownifyPropertiesOptions.***
- * -------------------------------------------------------
- * Options for `UnknownifyProperties`.
- *
+/** ---------------------------------------------------------------------------
+ * * ***Type Options for {@link UnknownifyProperties | `UnknownifyProperties`}.***
+ * ---------------------------------------------------------------------------
  * @property makeOptional - If `true`, all properties become optional.
  */
 type UnknownifyPropertiesOptions={
@@ -1065,43 +828,33 @@ type UnknownifyPropertiesOptions={
  * @example
  * ```ts
  * type A = { a: string; b: number };
- *
  * type B = UnknownifyProperties<A, { makeOptional: true }>;
  * // ➔ { a?: unknown; b?: unknown }
  * ```
  */
 makeOptional:boolean;};
 /** -------------------------------------------------------
- * * ***UnknownifyProperties.***
+ * * ***Utility Type: `UnknownifyProperties`.***
  * -------------------------------------------------------
- * Transforms all properties of an object type `T` to `unknown`.
- * Optionally, makes all properties optional based on `Options`.
- *
+ * **Transforms all properties of an object type `T` to `unknown`.**
+ * @description Optionally, makes all properties optional based on `Options`.
  * @template T - The object type to transform.
  * @template Options - Configuration options (default: `{ makeOptional: false }`).
  *
  * @example
  * ```ts
  * type A = { a: string; b: number };
- *
  * type Result1 = UnknownifyProperties<A>;
  * // ➔ { a: unknown; b: unknown }
- *
  * type Result2 = UnknownifyProperties<A, { makeOptional: true }>;
  * // ➔ { a?: unknown; b?: unknown }
  * ```
  */
 type UnknownifyProperties<T extends object,Options extends UnknownifyPropertiesOptions={makeOptional:false;}>={[K in keyof T]:unknown;}extends infer Result?If<Options["makeOptional"],Partial<Result>,Result>:never;
-/** -------------------------------------------------------
- * * ***MutableOptions***
- * -------------------------------------------------------
- *
- * Configuration options for the ***{@link Mutable}*** type utilities.
- *
- * @property recursive - Whether to make nested objects mutable recursively.
- *   - If `true`, all nested objects will also have their `readonly` removed.
- *   - Default: `false`.
- *
+/** ---------------------------------------------------------------------------
+ * * ***Options for {@link Mutable | `Mutable`}.***
+ * ---------------------------------------------------------------------------
+ * **Configuration options for the ***{@link Mutable | **`Mutable`**}*** type utilities.**
  * @example
  * ```ts
  * type Opt1 = MutableOptions;
@@ -1109,71 +862,65 @@ type UnknownifyProperties<T extends object,Options extends UnknownifyPropertiesO
  * ```
  */
 type MutableOptions={
-/** Whether to make nested objects mutable recursively.
+/** * ***Whether to make nested objects mutable recursively.***
  *
- * - If `true`, all nested objects will also have their `readonly` removed.
- * - Default value: `false`.
+ * - **Behavior:**
+ *    - If `true`, all nested objects will also have their `readonly` removed.
+ *    - Default value: `false`.
  *
  * @default false
  */
 recursive:boolean;};
 /** -------------------------------------------------------
- * * ***Mutable.***
+ * * ***Utility Type: `Mutable`.***
  * -------------------------------------------------------
- * Removes `readonly` from all properties of the passed type `T`.
+ * **Removes `readonly` from all properties of the passed type `T`.**
  * - If `Options["recursive"]` is `true`, nested objects are also made mutable.
- *
  * @template T - The type to make mutable.
  * @template Options - Configuration options. Default: `{ recursive: false }`.
  * @example
  * ```ts
  * type Case1 = Mutable<{ readonly a: { readonly b: string } }>;
  * // ➔ { a: { b: string } } (non-recursive by default)
- *
  * type Case2 = Mutable<{ readonly a: { readonly b: string } }, { recursive: true }>;
  * // ➔ { a: { b: string } } (nested properties also mutable)
  * ```
  */
 type Mutable<T,Options extends MutableOptions={recursive:false;}>=Prettify<{-readonly [K in keyof T]:And<Options["recursive"],Extends<T[K],object>>extends true?Mutable<T[K],Options>:T[K];}>;
 /** -------------------------------------------------------
- * * ***MutableOnly.***
+ * * ***Utility Type: `MutableOnly`.***
  * -------------------------------------------------------
- * Removes `readonly` only from the specified keys `K` of type `T`.
- *
+ * **Removes `readonly` only from the specified keys `K` of type `T`.**
  * @template T - The type to modify.
  * @template K - Keys to make mutable.
  * @example
  * ```ts
  * type Case1 = MutableOnly<{ readonly a: string; readonly b: string }, "a">;
  * // ➔ { a: string; readonly b: string }
- *
  * type Case2 = MutableOnly<{ readonly a: string; readonly b: string }, "a" | "b">;
  * // ➔ { a: string; b: string }
  * ```
  */
 type MutableOnly<T,K extends keyof T>=Prettify<Pick<T,Exclude<keyof T,K>>&{-readonly [P in K]:T[P];}>;
 /** -------------------------------------------------------
- * * ***MutableExcept.***
+ * * ***Utility Type: `MutableExcept`.***
  * -------------------------------------------------------
- * Removes `readonly` from all properties of `T` **except** the specified keys `K`.
- *
+ * **Removes `readonly` from all properties of `T` **except** the specified keys `K`.**
  * @template T - The type to modify.
  * @template K - Keys to keep as readonly.
  * @example
  * ```ts
  * type Case1 = MutableExcept<{ readonly a: string; readonly b: string }, "b">;
  * // ➔ { a: string; readonly b: string }
- *
  * type Case2 = MutableExcept<{ a: string; readonly b: string }, "a">;
  * // ➔ { a: string; b: string } (all except "a" made mutable)
  * ```
  */
 type MutableExcept<T,K extends keyof T>=Prettify<Pick<T,K>&{-readonly [P in Exclude<keyof T,K>]:T[P];}>;
 /** -------------------------------------------------------
- * * ***IsArray.***
+ * * ***Utility Type: `IsArray`.***
  * -------------------------------------------------------
- * Returns a boolean whether the passed argument is an array.
- *
+ * **Returns a boolean whether the passed argument is an array.**
  * @example
  * type Case1 = IsArray<[]>;
  * // ➔ true
@@ -1182,10 +929,9 @@ type MutableExcept<T,K extends keyof T>=Prettify<Pick<T,K>&{-readonly [P in Excl
  */
 type IsArray<T>=AndArr<[ Not<IsAny<T>>,Not<IsNever<T>>,Extends<T,readonly unknown[]>]>;
 /** -------------------------------------------------------
- * * ***IsMutableArray.***
+ * * ***Utility Type: `IsMutableArray`.***
  * -------------------------------------------------------
- * Returns a boolean whether the passed argument is a mutable array.
- *
+ * **Returns a boolean whether the passed argument is a mutable array.**
  * @example
  * type Case1 = IsMutableArray<[]>;
  * // ➔ true
@@ -1194,14 +940,13 @@ type IsArray<T>=AndArr<[ Not<IsAny<T>>,Not<IsNever<T>>,Extends<T,readonly unknow
  */
 type IsMutableArray<T>=And<IsArray<T>,NotExtends<Readonly<T>,T>>;
 /** -------------------------------------------------------
- * * ***IsReadonlyArray.***
+ * * ***Utility Type: `IsReadonlyArray`.***
  * -------------------------------------------------------
- * Returns a boolean whether the passed argument is a read-only array.
- *
+ * **Returns a boolean whether the passed argument is a read-only array.**
  * @example
  * type Case1 = IsReadonlyArray<readonly []>;
  * // ➔ true
  * type Case2 = IsReadonlyArray<[]>;
  * // ➔ false
  */
-type IsReadonlyArray<T>=And<IsArray<T>,NotExtends<T,Mutable<T>>>;export type{PositiveInteger as $,And as A,IfPositiveFloat as B,CharAt as C,IfPositiveInteger as D,Even as E,Float as F,Integer as G,IsNegativeFloat as H,IsStringLiteral as I,IsOdd as J,IsPositiveFloat as K,IsPositiveInteger as L,Mutable as M,Negate as N,Or as O,ParseNumber as P,IsScientificNumber as Q,Repeat as R,Split as S,Negative as T,NegativeFloat as U,NegativeInteger as V,Odd as W,OddDigit as X,ParseScientificNumber as Y,Positive as Z,PositiveFloat as _,IsNegative as a,IfUnknown as a0,UnknownifyProperties as a1,UnknownifyPropertiesOptions as a2,Abs as b,IsFloat as c,IsUnknown as d,IsNegativeInteger as e,OrArr as f,AndArr as g,IsInteger as h,Push as i,IfNegative as j,IsPositive as k,IsEven as l,IsReadonlyArray as m,IfPositive as n,IsArray as o,IsMutableArray as p,MutableExcept as q,MutableOnly as r,MutableOptions as s,EvenDigit as t,IfEven as u,IfFloat as v,IfInteger as w,IfNegativeFloat as x,IfNegativeInteger as y,IfOdd as z};
+type IsReadonlyArray<T>=And<IsArray<T>,NotExtends<T,Mutable<T>>>;export type{Abs as A,IsNegativeFloat as B,CharAt as C,IsOdd as D,Even as E,Float as F,IsPositiveFloat as G,IsPositiveInteger as H,IsStringLiteral as I,IsScientificNumber as J,Negative as K,NegativeFloat as L,Mutable as M,Negate as N,NegativeInteger as O,ParseNumber as P,Odd as Q,Repeat as R,Split as S,OddDigit as T,ParseScientificNumber as U,Positive as V,PositiveFloat as W,PositiveInteger as X,IfUnknown as Y,UnknownifyProperties as Z,UnknownifyPropertiesOptions as _,IsNegative as a,IsFloat as b,IsUnknown as c,IsNegativeInteger as d,IsInteger as e,Push as f,IfNegative as g,IsPositive as h,IsEven as i,IsReadonlyArray as j,IfPositive as k,IsArray as l,IsMutableArray as m,MutableExcept as n,MutableOnly as o,MutableOptions as p,EvenDigit as q,IfEven as r,IfFloat as s,IfInteger as t,IfNegativeFloat as u,IfNegativeInteger as v,IfOdd as w,IfPositiveFloat as x,IfPositiveInteger as y,Integer as z};