@rzl-zone/utils-js 3.0.2-beta.2 → 3.1.0

package/dist/is-array-Ckm_47hw.d.ts

@@ -1,1557 +0,0 @@
-import{I as If}from'./if-CvT4R7Kh.js';import{I as IsNever}from'./never-BfayMBF9.js';import{I as IfExtends,E as Extends,N as Not,a as NotExtends}from'./extends-Mp81Hq9-.js';import{I as IsAny}from'./any-BmdI8UbK.js';import{P as Prettify}from'./prettify-C4xLcYOP.js';
-/** -------------------------------------------------------
-* * ***And.***
-* -------------------------------------------------------
-* 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
-*
-* @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>;
-/** -------------------------------------------------------
-* * ***IfNot.***
-* -------------------------------------------------------
-*
-* Conditional: returns the second argument if the first argument is `false`, otherwise returns the third argument.
-* - Defaults: `IfTrue = true`, `IfFalse = false`.
-*
-* @template Condition - The boolean condition to check.
-* @template IfTrue - The branch type if condition is `false`. (default: `true`)
-* @template IfFalse - The branch type if condition is `true`. (default: `false`)
-*
-* ### Examples
-* ```ts
-* type A = IfNot<false, "valid">;
-* // ➔ "valid"
-* type B = IfNot<false, "valid", "invalid">;
-* // ➔ "invalid"
-* ```
-*/
-type IfNot<Condition,IfTrue=true,IfFalse=false>=If<Condition,IfFalse,IfTrue>;
-/** -------------------------------------------------------
-* * ***WordSeparator.***
-* -------------------------------------------------------
-* A type-level utility that defines all valid ***word separators***.
-* - Can be a space `" "`, a dash `"-"`, or an underscore `"_"`.
-*
-* @example
-* ```ts
-* type A = WordSeparator; // ➔ " " | "-" | "_"
-* ```
-*/
-type WordSeparator=" "|"-"|"_";
-/** --------------------------------------------------
-* * ***Whitespace.***
-* --------------------------------------------------
-* Represents common whitespace characters.
-*
-* ✅ Used as the default trimming characters in string utility types.
-*
-* @example
-* type W = Whitespace;
-* // ➔ " " | "\t" | "\r" | "\n"
-*/
-type Whitespace=" "|"\t"|"\r"|"\n";
-/** **Helper Internal.** */
-type SafeKeyTrimming<T>=Exclude<T,symbol>;
-/** --------------------------------------------------
-* * ***TrimLeft.***
-* --------------------------------------------------
-* Recursively trims specified characters (default: **{@link Whitespace}**)
-* from the **start (left)** of a string.
-*
-* @template Text - The string to trim.
-* @template Chars - The characters to remove (default: `Whitespace`).
-*
-* @example
-* type T1 = TrimLeft<"\n  hello", " " | "\n">;
-* // ➔ "hello"
-*
-* type T2 = TrimLeft<"  world">;
-* // ➔ "world"
-*
-* type T3 = TrimLeft<"  world ">;
-* // ➔ "world "
-*/
-type TrimLeft<Text extends PropertyKey,Chars extends PropertyKey=Whitespace>=Text extends`${SafeKeyTrimming<Chars>}${infer Rest}`?TrimLeft<Rest,Chars>:Text;
-/** --------------------------------------------------
-* * ***TrimRight.***
-* --------------------------------------------------
-* Recursively trims specified characters (default: **{@link Whitespace}**)
-* from the **end (right)** of a string.
-*
-* @template Text - The string to trim.
-* @template Chars - The characters to remove (default: `Whitespace`).
-*
-* @example
-* type T1 = TrimRight<"hello  \t", " " | "\t">;
-* // ➔ "hello"
-*
-* type T2 = TrimRight<"world  ">;
-* // ➔ "world"
-*
-* type T2 = TrimRight<" world  ">;
-* // ➔ " world"
-*/
-type TrimRight<Text extends PropertyKey,Chars extends PropertyKey=Whitespace>=Text extends`${infer Rest}${SafeKeyTrimming<Chars>}`?TrimRight<Rest,Chars>:Text;
-/** --------------------------------------------------
-* * ***Trim.***
-* --------------------------------------------------
-* Trims specified characters (default: **{@link Whitespace}**)
-* from **both the start and end** of a string.
-*
-* @template Text - The string to trim.
-* @template Chars - The characters to remove (default: `Whitespace`).
-*
-* @example
-* type T1 = Trim<"  hello  ", " ">;
-* // ➔ "hello"
-*
-* type T2 = Trim<"\n  world \t">;
-* // ➔ "world"
-*/
-type Trim<Text extends PropertyKey,Chars extends PropertyKey=Whitespace>=TrimRight<TrimLeft<Text,Chars>,Chars>;
-/** -------------------------------------------------------
-* * ***TrimsLower***
-* -------------------------------------------------------
-* Trims leading & trailing whitespace from a string and
-* converts it to **lowercase**.
-*
-* Utilizes **{@link Trim}** to remove whitespace and **{@link Lowercase}** to convert the string to lowercase.
-*
-* @template S - The input string to transform.
-*
-* @example
-* ```ts
-* type T1 = TrimsLower<"  HeLLo \n">;
-* // ➔ "hello"
-*
-* type T2 = TrimsLower<"  WoRLD  ">;
-* // ➔ "world"
-* ```
-*/
-type TrimsLower<S extends string>=Lowercase<Trim<S>>;
-/** -------------------------------------------------------
-* * ***TrimsUpper***
-* -------------------------------------------------------
-* Trims leading & trailing whitespace from a string and
-* converts it to **uppercase**.
-*
-* Utilizes **{@link Trim}** to remove whitespace and **{@link Uppercase}** to convert the string to uppercase.
-*
-* @template S - The input string to transform.
-*
-* @example
-* ```ts
-* type T1 = TrimsUpper<"  HeLLo \n">;
-* // ➔ "HELLO"
-*
-* type T2 = TrimsUpper<"  WoRLD  ">;
-* // ➔ "WORLD"
-* ```
-*/
-type TrimsUpper<S extends string>=Uppercase<Trim<S>>;
-/** -------------------------------------------------------
-* * ***AnyString.***
-* -------------------------------------------------------
-*
-* A utility type that represents **any string value** while
-* preventing unwanted widening of string literals to `string`.
-*
-* 🔹 This is achieved by intersecting `string` with `{}`,
-* ensuring that the type remains assignable to `string`
-* but is treated as a unique type in generic constraints.
-*
-* 📌 Useful in scenarios where:
-* - You want to accept **any string**, but still preserve
-*   literal types in inference.
-* - You need stricter typing than just `string`.
-*
-* @example
-* ```ts
-* declare function acceptsAnyString<T extends AnyString>(value: T): T;
-*
-* // Preserves literal
-* const a = acceptsAnyString("hello");
-* // ➔ "hello"
-*
-* // Also allows generic string
-* const b = acceptsAnyString(String("world"));
-* // ➔ string
-* ```
-*/
-type AnyString={}& string;
-/** -------------------------------------------------------
-* * ***EmptyString.***
-* -------------------------------------------------------
-* Returns the type `T` only if it is the empty string `""`.
-* Optionally trims whitespace before checking.
-*
-* Behavior:
-* - If `WithTrim` is `true` (default), trims `T` before checking.
-* - If `T` is the general `string` type, returns `never`.
-* - If `T` is empty (after optional trimming), returns `T` or `Trim<T>`.
-*
-* @template T - The string type to check.
-* @template WithTrim - Whether to trim whitespace before checking (default `true`).
-*
-* @example
-* ```ts
-* // Basic empty string
-* type Case1 = EmptyString<"">;
-* // ➔ ""
-*
-* // Non-empty string
-* type Case2 = EmptyString<"abc">;
-* // ➔ never
-*
-* // General string type
-* type Case3 = EmptyString<string>;
-* // ➔ never
-*
-* // With leading/trailing whitespace
-* type Case4 = EmptyString<"  ", true>;
-* // ➔ "" (trimmed)
-* type Case5 = EmptyString<"  ", false>;
-* // ➔ never (not trimmed)
-* ```
-*/
-type EmptyString<T extends string,WithTrim extends boolean=true>=""extends(WithTrim extends true?Trim<T>:T)?string extends(WithTrim extends true?Trim<T>:T)?never:WithTrim extends true?Trim<T>:T:never;
-/** -------------------------------------------------------
-* * ***NonEmptyString.***
-* -------------------------------------------------------
-* Returns the type `T` only if it is a non-empty string.
-* Optionally trims whitespace before checking.
-*
-* Behavior:
-* - If `WithTrim` is `true` (default), trims `T` before checking.
-* - If `T` is the general `string` type, returns `string`.
-* - If `T` is empty (after optional trimming), returns `never`.
-*
-* @template T - The string type to check.
-* @template WithTrim - Whether to trim whitespace before checking (default `true`).
-*
-* @example
-* ```ts
-* // Non-empty string
-* type Case1 = NonEmptyString<"abc">; // ➔ "abc"
-*
-* // Empty string
-* type Case2 = NonEmptyString<"">; // ➔ never
-*
-* // General string type
-* type Case3 = NonEmptyString<string>; // ➔ string
-*
-* // String with whitespace
-* type Case4 = NonEmptyString<"  ", true>; // ➔ never (trimmed to empty)
-* type Case5 = NonEmptyString<"  ", false>; // ➔ "  " (not trimmed)
-* ```
-*/
-type NonEmptyString<T extends string,WithTrim extends boolean=true>=string extends T?string:If<IsNever<EmptyString<T,WithTrim>>,WithTrim extends true?Trim<T>:T,never>;
-/** -------------------------------------------------------
-* * ***IsEmptyString.***
-* -------------------------------------------------------
-* Returns `true` if `T` is exactly the empty string `""`.
-* Optionally trims whitespace before checking.
-*
-* Behavior:
-* - If `WithTrim` is `true` (default), trims `T` before checking.
-* - If `T` is empty after optional trimming, returns `true`.
-* - Otherwise, returns `false`.
-*
-* @template T - The string type to check.
-* @template WithTrim - Whether to trim whitespace before checking (default `true`).
-*
-* @example
-* ```ts
-* type Case1 = IsEmptyString<"">;
-* // ➔ true
-* type Case2 = IsEmptyString<"abc">;
-* // ➔ false
-* type Case3 = IsEmptyString<"  ", true>;
-* // ➔ true (trimmed)
-* type Case4 = IsEmptyString<"  ", false>;
-* // ➔ false (not trimmed)
-* ```
-*/
-type IsEmptyString<T extends string,WithTrim extends boolean=true>=IfNot<IsNever<EmptyString<T,WithTrim>>>;
-/** -------------------------------------------------------
-* * ***IsNonEmptyString.***
-* -------------------------------------------------------
-* Returns `true` if `T` is a non-empty string.
-* Optionally trims whitespace before checking.
-*
-* Behavior:
-* - If `WithTrim` is `true` (default), trims `T` before checking.
-* - Returns `true` if `T` is non-empty after optional trimming.
-* - Returns `false` if `T` is empty (after trimming if `WithTrim=true`).
-*
-* @template T - The string type to check.
-* @template WithTrim - Whether to trim whitespace before checking (default `true`).
-*
-* @example
-* ```ts
-* type Case1 = IsNonEmptyString<"abc">;
-* // ➔ true
-* type Case2 = IsNonEmptyString<"">;
-* // ➔ false
-* type Case3 = IsNonEmptyString<"  ", true>;
-* // ➔ false (trimmed)
-* type Case4 = IsNonEmptyString<"  ", false>;
-* // ➔ true (not trimmed)
-* ```
-*/
-type IsNonEmptyString<T extends string,WithTrim extends boolean=true>=IfNot<IsNever<NonEmptyString<T,WithTrim>>>;
-/** -------------------------------------------------------
-* * ***IfEmptyString.***
-* -------------------------------------------------------
-* Conditional type: returns `IfTrue` if `T` is an empty string `""`,
-* otherwise returns `IfFalse`. Optionally trims whitespace before checking.
-*
-* @template T - The string type to check.
-* @template IfTrue - Type returned if `T` is empty (default `true`).
-* @template IfFalse - Type returned if `T` is not empty (default `false`).
-* @template WithTrim - Whether to trim whitespace before checking (default `true`).
-*
-* @example
-* ```ts
-* type Case1 = IfEmptyString<"">;
-* // ➔ true
-* type Case2 = IfEmptyString<"abc">;
-* // ➔ false
-* type Case3 = IfEmptyString<"", "yes", "no">;
-* // ➔ "yes"
-* type Case4 = IfEmptyString<"abc", "yes", "no">;
-* // ➔ "no"
-* type Case5 = IfEmptyString<"  ", "yes", "no", true>;
-* // ➔ "yes" (trimmed)
-* type Case6 = IfEmptyString<"  ", "yes", "no", false>;
-* // ➔ "no" (not trimmed)
-* ```
-*/
-type IfEmptyString<T extends string,IfTrue=true,IfFalse=false,WithTrim extends boolean=true>=IfNot<IsNever<EmptyString<T,WithTrim>>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfNonEmptyString.***
-* -------------------------------------------------------
-* Conditional type: returns `IfTrue` if `T` is a non-empty string,
-* otherwise returns `IfFalse`. Optionally trims whitespace before checking.
-*
-* @template T - The string type to check.
-* @template IfTrue - Type returned if `T` is non-empty (default `true`).
-* @template IfFalse - Type returned if `T` is empty (default `false`).
-* @template WithTrim - Whether to trim whitespace before checking (default `true`).
-*
-* @example
-* ```ts
-* type Case1 = IfNonEmptyString<"abc">;
-* // ➔ true
-* type Case2 = IfNonEmptyString<"">;
-* // ➔ false
-* type Case3 = IfNonEmptyString<"abc", "yes", "no">;
-* // ➔ "yes"
-* type Case4 = IfNonEmptyString<"", "yes", "no">;
-* // ➔ "no"
-* type Case5 = IfNonEmptyString<"  ", "yes", "no", true>;
-* // ➔ "no" (trimmed)
-* type Case6 = IfNonEmptyString<"  ", "yes", "no", false>;
-* // ➔ "yes" (not trimmed)
-* ```
-*/
-type IfNonEmptyString<T extends string,IfTrue=true,IfFalse=false,WithTrim extends boolean=true>=IfNot<IsNever<NonEmptyString<T,WithTrim>>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***Or.***
-* -------------------------------------------------------
-*
-* 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.
-* @template U - The type of the element to push.
-*
-* @example
-* ```ts
-* type Case1 = Push<[1, 2, 3, 4], 5>;
-* // ➔ [1, 2, 3, 4, 5]
-*
-* type Case2 = Push<["a", "b"], "c">;
-* // ➔ ["a", "b", "c"]
-* ```
-*/
-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.***
-* -------------------------------------------------------
-*
-* 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)`.
-*
-* @template T - The string literal to repeat.
-* @template Count - Number of times to repeat.
-*
-* @example
-* ```ts
-* type Case0 = Repeat<'x', 0>;  // ➔ ''
-* type Case1 = Repeat<'x', 1>;  // ➔ 'x'
-* type Case2 = Repeat<'x', 5>;  // ➔ 'xxxxx'
-* type Case3 = Repeat<'ab', 3>; // ➔ 'ababab'
-*
-* // ❌ Invalid:
-* type Case1000 = Repeat<'x', 1000>;
-* // ➔ same as any (because: TypeScript recursion limits)
-* ```
-*/
-type Repeat<T extends string,Count extends number>=_Repeat<T,Count>;
-/** -------------------------------------------------------
-* * ***OddDigit.***
-* -------------------------------------------------------
-*
-* 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.***
-* -------------------------------------------------------
-*
-* 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.***
-* -------------------------------------------------------
-*
-* 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).
-*
-* @template T - A number type to validate.
-*
-* @example
-*
-* ```ts
-* type A = Integer<42>;   // ➔ 42
-* type B = Integer<-10>;  // ➔ -10
-* type C = Integer<3.14>; // ➔ never
-* ```
-*/
-type Integer<T extends number>=`${T}`extends`${string}.${string}`?never:T;
-/** -------------------------------------------------------
-* * ***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***.
-*
-* @template T - A number type to validate.
-*
-* @example
-*
-* ```ts
-* type A = Float<3.14>;  // ➔ 3.14
-* type B = Float<42>;    // ➔ never
-* ```
-*/
-type Float<T extends number>=If<IsNever<Integer<T>>,T,never>;
-/** -------------------------------------------------------
-* * ***Negative.***
-* -------------------------------------------------------
-*
-* 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 Negative<T extends number>=`${T}`extends`-${string}`?T:never;
-/** -------------------------------------------------------
-* * ***Positive.***
-* -------------------------------------------------------
-*
-* 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
-* type C = Positive<-5>; // ➔ never
-* ```
-*/
-type Positive<T extends number>=If<IsNever<Negative<T>>,T,never>;
-/** -------------------------------------------------------
-* * ***PositiveInteger.***
-* -------------------------------------------------------
-*
-* Restricts `T` to ***positive integers*** only.
-*
-* @template T - A number type.
-*
-* @example
-*
-* ```ts
-* type A = PositiveInteger<42>;   // ➔ 42
-* type B = PositiveInteger<0>;    // ➔ 0
-* type C = PositiveInteger<-5>;   // ➔ never
-* type D = PositiveInteger<3.14>; // ➔ never
-* ```
-*/
-type PositiveInteger<T extends number>=Positive<Integer<T>>;
-/** -------------------------------------------------------
-* * ***NegativeInteger.***
-* -------------------------------------------------------
-*
-* Restricts `T` to ***negative integers*** only.
-*
-* @template T - A number type.
-*
-* @example
-*
-* ```ts
-* type A = NegativeInteger<-42>;   // ➔ -42
-* type B = NegativeInteger<5>;     // ➔ never
-* type C = NegativeInteger<-3.14>; // ➔ never
-* ```
-*/
-type NegativeInteger<T extends number>=Negative<Integer<T>>;
-/** -------------------------------------------------------
-* * ***PositiveFloat.***
-* -------------------------------------------------------
-*
-* 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
-* type C = PositiveFloat<5>;    // ➔ never
-* ```
-*/
-type PositiveFloat<T extends number>=Positive<Float<T>>;
-/** -------------------------------------------------------
-* * ***NegativeFloat.***
-* -------------------------------------------------------
-*
-* 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
-* type C = NegativeFloat<-5>;    // ➔ never
-* ```
-*/
-type NegativeFloat<T extends number>=Negative<Float<T>>;
-/** -------------------------------------------------------
-* * ***Even.***
-* -------------------------------------------------------
-*
-* 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
-* type C = Even<5>;    // ➔ never
-* type D = Even<24>;   // ➔ 24
-* type E = Even<27>;   // ➔ never
-* type F = Even<3.14>; // ➔ never
-* ```
-*/
-type Even<T extends number>=IfNot<IsNever<Integer<T>>,`${T}`extends`${string}${EvenDigit}`?T:never,never>;
-/** -------------------------------------------------------
-* * ***Odd.***
-* -------------------------------------------------------
-*
-* 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 Odd<T extends number>=IfNot<IsNever<Integer<T>>,If<IsNever<Even<T>>,T,never>,never>;
-/** -------------------------------------------------------
-* * ***IsInteger.***
-* -------------------------------------------------------
-*
-* Whether `T` is an ***integer***.
-*
-* @example
-*
-* ```ts
-* type A = IsInteger<-2>;   // ➔ true
-* type B = IsInteger<0>;    // ➔ true
-* type C = IsInteger<42>;   // ➔ true
-* type D = IsInteger<3.14>; // ➔ false
-* ```
-*/
-type IsInteger<T extends number>=Not<IsNever<Integer<T>>>;
-/** -------------------------------------------------------
-* * ***IsFloat.***
-* -------------------------------------------------------
-*
-* Whether `T` is a ***float***.
-*
-* @example
-*
-* ```ts
-* type A = IsFloat<3.14>;  // ➔ true
-* type B = IsFloat<-3.14>; // ➔ true
-* type C = IsFloat<0>;     // ➔ false
-* type D = IsFloat<42>;    // ➔ false
-* type E = IsFloat<-42>;   // ➔ false
-* ```
-*/
-type IsFloat<T extends number>=Not<IsNever<Float<T>>>;
-/** -------------------------------------------------------
-* * ***IsEven.***
-* -------------------------------------------------------
-*
-* Whether `T` is ***even***.
-*
-* @example
-*
-* ```ts
-* type A = IsEven<0>;    // ➔ true
-* type B = IsEven<4>;    // ➔ true
-* type C = IsEven<5>;    // ➔ false
-* type D = IsEven<24>;   // ➔ true
-* type E = IsEven<27>;   // ➔ false
-* type F = IsEven<3.14>; // ➔ false
-* ```
-*/
-type IsEven<T extends number>=If<IsInteger<T>,`${T}`extends`${string}${EvenDigit}`?true:false>;
-/** -------------------------------------------------------
-* * ***IsOdd.***
-* -------------------------------------------------------
-*
-* Whether `T` is ***odd***.
-*
-* @example
-*
-* ```ts
-* type A = IsEven<0>;    // ➔ false
-* type B = IsEven<4>;    // ➔ false
-* type C = IsEven<5>;    // ➔ true
-* type D = IsEven<24>;   // ➔ false
-* type E = IsEven<27>;   // ➔ true
-* type F = IsEven<3.14>; // ➔ true
-* ```
-*/
-type IsOdd<T extends number>=If<IsInteger<T>,Not<IsEven<T>>>;
-/** -------------------------------------------------------
-* * ***IsPositive.***
-* -------------------------------------------------------
-*
-* 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 IsPositive<T extends number>=Not<IsNever<Positive<T>>>;
-/** -------------------------------------------------------
-* * ***IsNegative.***
-* -------------------------------------------------------
-*
-* 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 IsNegative<T extends number>=Not<IsNever<Negative<T>>>;
-/** -------------------------------------------------------
-* * ***IsPositiveInteger.***
-* -------------------------------------------------------
-*
-* Whether `T` is a ***positive integer***.
-*
-* @example
-*
-* ```ts
-* type A = IsPositiveInteger<42>;   // ➔ true
-* type B = IsPositiveInteger<0>;    // ➔ true
-* type C = IsPositiveInteger<-5>;   // ➔ false
-* type D = IsPositiveInteger<3.14>; // ➔ false
-* ```
-*/
-type IsPositiveInteger<T extends number>=Not<IsNever<PositiveInteger<T>>>;
-/** -------------------------------------------------------
-* * ***IsNegativeInteger.***
-* -------------------------------------------------------
-*
-* Whether `T` is a ***negative integer***.
-*
-* @example
-*
-* ```ts
-* type A = IsNegativeInteger<-42>;   // ➔ true
-* type B = IsNegativeInteger<5>;     // ➔ false
-* type C = IsNegativeInteger<-3.14>; // ➔ false
-* ```
-*/
-type IsNegativeInteger<T extends number>=Not<IsNever<NegativeInteger<T>>>;
-/** -------------------------------------------------------
-* * ***IsPositiveFloat.***
-* -------------------------------------------------------
-*
-* Whether `T` is a ***positive float***.
-*
-* @example
-*
-* ```ts
-* type A = IsPositiveFloat<3.14>; // ➔ true
-* type B = IsPositiveFloat<-2.5>; // ➔ false
-* type C = IsPositiveFloat<5>;    // ➔ false
-* ```
-*/
-type IsPositiveFloat<T extends number>=Not<IsNever<PositiveFloat<T>>>;
-/** -------------------------------------------------------
-* * ***IsNegativeFloat.***
-* -------------------------------------------------------
-*
-* Whether `T` is a ***negative float***.
-*
-* @example
-*
-* ```ts
-* type A = IsNegativeFloat<-3.14>; // ➔ true
-* type B = IsNegativeFloat<2.5>;   // ➔ false
-* type C = IsNegativeFloat<-5>;    // ➔ false
-* ```
-*/
-type IsNegativeFloat<T extends number>=Not<IsNever<NegativeFloat<T>>>;
-/** -------------------------------------------------------
-* * ***IfInteger.***
-* -------------------------------------------------------
-*
-* 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 IfInteger<T extends number,IfTrue=true,IfFalse=false>=If<IsInteger<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfFloat.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfFloat<T extends number,IfTrue=true,IfFalse=false>=If<IsFloat<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfEven.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfEven<T extends number,IfTrue=true,IfFalse=false>=If<IsEven<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfOdd.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfOdd<T extends number,IfTrue=true,IfFalse=false>=If<IsOdd<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfPositive.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfPositive<T extends number,IfTrue=true,IfFalse=false>=If<IsPositive<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfNegative.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfNegative<T extends number,IfTrue=true,IfFalse=false>=If<IsNegative<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfPositiveInteger.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfPositiveInteger<T extends number,IfTrue=true,IfFalse=false>=If<IsPositiveInteger<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfNegativeInteger.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfNegativeInteger<T extends number,IfTrue=true,IfFalse=false>=If<IsNegativeInteger<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfPositiveFloat.***
-* -------------------------------------------------------
-*
-* 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`)
-*
-* @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 IfPositiveFloat<T extends number,IfTrue=true,IfFalse=false>=If<IsPositiveFloat<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***IfNegativeFloat.***
-* -------------------------------------------------------
-* 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`)
-* @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 IfNegativeFloat<T extends number,IfTrue=true,IfFalse=false>=If<IsNegativeFloat<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***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.
-* - Returns `never` for non-numeric strings or unsupported formats.
-*
-* @template T - A string, number, or symbol (property key).
-* @example
-* ```ts
-* // Number:
-* type A = ParseNumber<0>;     // ➔ 0
-* type B = ParseNumber<-0>;    // ➔ 0
-* type C = ParseNumber<-0.>;   // ➔ 0
-* type D = ParseNumber<42>;    // ➔ 42
-* type E = ParseNumber<0.42>;  // ➔ 0.42
-* type F = ParseNumber<-5>;    // ➔ -5
-* type G = ParseNumber<-2.5>;  // ➔ -2.5
-* type H = ParseNumber<2.5e3>; // ➔ 2500
-* type I = ParseNumber<-2.5e3>;// ➔ -2500
-* type J = ParseNumber<5e3>;   // ➔ 5000
-* type K = ParseNumber<-5e3>;  // ➔ -5000
-* type L = ParseNumber<5e21>;  // ➔ 5e+21
-* type M = ParseNumber<5e-3>;  // ➔ 0.005
-* type N = ParseNumber<5e-21>; // ➔ 5e-21
-* type O = ParseNumber<-5e-3>; // ➔ -0.005
-*
-* // Numeric String:
-* type A = ParseNumber<"0">;     // ➔ 0
-* type B = ParseNumber<"-0">;    // ➔ 0
-* type C = ParseNumber<"42">;    // ➔ 42
-* type D = ParseNumber<"0.42">;  // ➔ 0.42
-* type E = ParseNumber<"-42">;   // ➔ -42
-* type F = ParseNumber<"-0.42">; // ➔ -0.42
-* type G = ParseNumber<" 42 ">;  // ➔ 42
-* type H = ParseNumber<" -42 ">; // ➔ -1
-*
-* // Scientific notation string:
-* type S1 = ParseNumber<"2e3">;    // ➔  2000
-* type S2 = ParseNumber<"-2e3">;   // ➔  -2000
-* type S3 = ParseNumber<"2e-3">;   // ➔  0.002
-* type S4 = ParseNumber<"-2e-3">;  // ➔  -0.002
-* type S5 = ParseNumber<"2.5e3">;  // ➔  0
-* type S6 = ParseNumber<"2.5e-3">; // ➔  0
-* type S7 = ParseNumber<"2e-7">;   // ➔  0 (too small include "-2e-7" for TypeScript literal)
-* type S8 = ParseNumber<"5e21">;   // ➔  0 (too large include "-5e21" for TypeScript literal)
-*
-* // Number representing hexadecimal, octal or binary:
-* type A = ParseNumber<"011">;    // ➔ 9 (same as octal but deprecated)
-* type B = ParseNumber<"0o11">;   // ➔ 9 (octal)
-* type C = ParseNumber<"-0o11">;  // ➔ -9 (octal)
-* type D = ParseNumber<"0x12">;   // ➔ 18 (hexadecimal)
-* type E = ParseNumber<"-0x12">;  // ➔ -18 (hexadecimal)
-* type F = ParseNumber<"0b111">;  // ➔ 7 (binary)
-* type G = ParseNumber<"-0b111">; // ➔ -7 (binary)
-*
-* // String representing hexadecimal, octal or binary:
-* type A = ParseNumber<"0x2A">;     // ➔ 0 (hex on string not supported)
-* type B = ParseNumber<"0o52">;     // ➔ 0 (octal on string not supported)
-* type C = ParseNumber<"0b101010">; // ➔ 0 (binary on string not supported)
-*
-* // Never Result
-* type A = ParseNumber<string>; // ➔ never
-* type B = ParseNumber<number>; // ➔ never
-* type C = ParseNumber<"abc">;  // ➔ never
-* type D = ParseNumber<"a1">;   // ➔ never
-* type E = ParseNumber<"3b">;   // ➔ never
-* ```
-*/
-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.
-*
-* @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
-* ```
-*
-* @remarks
-* - Uses template literal types and conditional type {@link 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}
-*/
-type BuildTuple<L extends number,T extends unknown[]=[]>=T["length"] extends L?T:BuildTuple<L,[...T,unknown]>;
-/**
-* Helper for {@link ParseScientificNumber}
-*/
-type _DecrementParseScientific<N extends number>=BuildTuple<N>extends [ infer _,...infer Rest]?Rest["length"]:never;
-/** -------------------------------------------------------
-* * ***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`.
-*
-* @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"`)
-*
-* @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
-* ```
-*
-* @remarks
-* - Uses type-level string manipulation to handle scientific notation.
-* - Negative exponents are adjusted with {@link _DecrementParseScientific} and {@link 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.***
-* -------------------------------------------------------
-*
-* 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`.
-*
-* @template T - A number type or string literal representing a number.
-*
-* @example
-*
-* ```ts
-* type A = Abs<-42>;   // ➔ 42
-* type B = Abs<10>;    // ➔ 10
-* type C = Abs<"11">;  // ➔ 11
-* type D = Abs<"-11">; // ➔ 11
-*
-* // Not a number
-* type Invalid1 = Abs<"1a">;    // ➔ never
-* type Invalid2 = Abs<"a1">;    // ➔ never
-* type Invalid3 = Abs<"a1a">;   // ➔ never
-* type Invalid4 = Abs<"abc">;   // ➔ never
-* type Invalid5 = Abs<string>;  // ➔ never
-* type Invalid6 = Abs<number>;  // ➔ never
-* ```
-*/
-type Abs<T extends PropertyKey|bigint>=`${Exclude<T, symbol>}`extends`-${infer PositiveT extends number}`?ParseNumber<PositiveT>:ParseNumber<T>;
-/** -------------------------------------------------------
-* * ***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`.
-*
-* @template T - A number type or numeric-string.
-*
-* @example
-*
-* ```ts
-* type A = Negate<5>;     // ➔ -5
-* type B = Negate<-10>;   // ➔ -10
-* type C = Negate<0>;     // ➔ 0
-* type D = Negate<-0>;    // ➔ 0
-* type E = Negate<"123">; // ➔ -123
-*
-* // Not a number or numeric-string:
-* type Invalid1 = Negate<string>;  // ➔ 0
-* type Invalid2 = Negate<number>;  // ➔ 0
-* type Invalid3 = Negate<"abc">;   // ➔ 0
-* type Invalid4 = Negate<"1a">;    // ➔ 0
-* type Invalid5 = Negate<"2b">;    // ➔ 0
-* type Invalid6 = Negate<"0x1f">;  // ➔ 0
-* type Invalid7 = Negate<"0b101">; // ➔ 0
-* type Invalid8 = Negate<"0o77">;  // ➔ 0
-* ```
-*/
-type Negate<T extends PropertyKey>=ParseNumber<`-${Abs<ParseNumber<T>>}`>;
-/** -------------------------------------------------------
-* * ***Split***
-* -------------------------------------------------------
-*
-* A type-level utility that mimics `String.prototype.split()`.
-* 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[]`.
-*
-* @template Str - The input string literal to be split.
-* @template Del - The delimiter used to split the string.
-*                 Defaults to `""` (character-level split).
-*
-* #### Constraints
-* - `Str` must be a string literal to get precise results.
-* - `Del` can be a string or number (numbers are converted to strings).
-*
-* #### Examples
-* ```ts
-* // ✅ Split into characters
-* type A = Split<"abc">;           // ["a", "b", "c"]
-*
-* // ✅ Split by a comma
-* type B = Split<"a,b,c", ",">;    // ["a", "b", "c"]
-*
-* // ✅ Split by multi-char delimiter
-* type C = Split<"2025-08-22", "-">;  // ["2025", "08", "22"]
-*
-* // ✅ Delimiter not found → returns whole string
-* type D = Split<"hello", "|">;    // ["hello"]
-*
-* // ⚠️ Non-literal 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>;
-/** -------------------------------------------------------
-* * ***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`).
-*
-* @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
-* type A = CharAt<"hello", 0>; // ➔ "h"
-* type B = CharAt<"hello", 1>; // ➔ "e"
-* type C = CharAt<"hello", 4>; // ➔ "o"
-*
-* // ✅ Index out of range → undefined
-* type D = CharAt<"hello", 5>; // ➔ undefined
-* type E = CharAt<"abc", 99>;  // ➔ undefined
-*
-* // ✅ Stringified index also works
-* type F = CharAt<"testing", "0">; // ➔ "t"
-* type G = CharAt<"testing", "2">; // ➔ "s"
-* type H = CharAt<"testing", "6">; // ➔ "g"
-* type I = CharAt<"testing", "7">; // ➔ undefined
-*
-* // ⚠️ Non-literal strings → undefined
-* type J = CharAt<string, 2>; // ➔ undefined
-*
-* // ⚠️ Negative indices are not supported
-* type K = CharAt<"abc", -1>; // ➔ undefined
-* ```
-*/
-type CharAt<I extends string,N extends number|`${number}`>=_CharAt<I,N>;
-/** -------------------------------------------------------
-* * ***IsUnknown.***
-* -------------------------------------------------------
-* Returns a boolean indicating whether the given type `T` is `unknown`.
-*
-* @template T - The type to check.
-*
-* @example
-* ```ts
-* type TrueResult = IsUnknown<unknown>;  // ➔ true
-* type FalseResult1 = IsUnknown<any>;    // ➔ false
-* type FalseResult2 = IsUnknown<string>; // ➔ false
-* ```
-*/
-type IsUnknown<T>=IsAny<T>extends true?false:[unknown] extends [T]?true:false;
-/** -------------------------------------------------------
-* * ***IfUnknown.***
-* -------------------------------------------------------
-* 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"
-* type Result2 = IfUnknown<string, "foo", "bar">;  // ➔ "bar"
-* ```
-*/
-type IfUnknown<T,IfTrue=true,IfFalse=false>=If<IsUnknown<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
-* * ***UnknownifyPropertiesOptions.***
-* -------------------------------------------------------
-* Options for `UnknownifyProperties`.
-*
-* @property makeOptional - If `true`, all properties become optional.
-*/
-type UnknownifyPropertiesOptions={
-/**
-* If `true`, all properties of the object become optional.
-*
-* DefaultValue: `false`.
-*
-* @default false
-* @example
-* ```ts
-* type A = { a: string; b: number };
-*
-* type B = UnknownifyProperties<A, { makeOptional: true }>;
-* // ➔ { a?: unknown; b?: unknown }
-* ```
-*/
-makeOptional:boolean;};
-/** -------------------------------------------------------
-* * ***UnknownifyProperties.***
-* -------------------------------------------------------
-* Transforms all properties of an object type `T` to `unknown`.
-* 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`.
-*
-* @example
-* ```ts
-* type Opt1 = MutableOptions;
-* // ➔ { recursive: boolean }
-* ```
-*/
-type MutableOptions={
-/** Whether to make nested objects mutable recursively.
-*
-* - If `true`, all nested objects will also have their `readonly` removed.
-* - Default value: `false`.
-*
-* @default false
-*/
-recursive:boolean;};
-/** -------------------------------------------------------
-* * ***Mutable.***
-* -------------------------------------------------------
-* 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.***
-* -------------------------------------------------------
-* 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.***
-* -------------------------------------------------------
-* 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.***
-* -------------------------------------------------------
-* Returns a boolean whether the passed argument is an array.
-*
-* @example
-* type Case1 = IsArray<[]>;
-* // ➔ true
-* type Case2 = IsArray<string>;
-* // ➔ false
-*/
-type IsArray<T>=AndArr<[ Not<IsAny<T>>,Not<IsNever<T>>,Extends<T,readonly unknown[]>]>;
-/** -------------------------------------------------------
-* * ***IsMutableArray.***
-* -------------------------------------------------------
-* Returns a boolean whether the passed argument is a mutable array.
-*
-* @example
-* type Case1 = IsMutableArray<[]>;
-* // ➔ true
-* type Case2 = IsMutableArray<readonly []>;
-* // ➔ false
-*/
-type IsMutableArray<T>=And<IsArray<T>,NotExtends<Readonly<T>,T>>;
-/** -------------------------------------------------------
-* * ***IsReadonlyArray.***
-* -------------------------------------------------------
-* 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{NegativeFloat as $,And as A,IfFloat as B,CharAt as C,IfInteger as D,Even as E,Float as F,IfNegativeFloat as G,IfNegativeInteger as H,IsStringLiteral as I,IfOdd as J,IfPositiveFloat as K,IfPositiveInteger as L,Mutable as M,Negate as N,Or as O,ParseNumber as P,Integer as Q,Repeat as R,Split as S,Trim as T,IsNegativeFloat as U,IsOdd as V,Whitespace as W,IsPositiveFloat as X,IsPositiveInteger as Y,IsScientificNumber as Z,Negative as _,IsEmptyString as a,NegativeInteger as a0,Odd as a1,OddDigit as a2,ParseScientificNumber as a3,Positive as a4,PositiveFloat as a5,PositiveInteger as a6,EmptyString as a7,IfNonEmptyString as a8,IsNonEmptyString as a9,NonEmptyString as aa,TrimLeft as ab,TrimRight as ac,TrimsLower as ad,TrimsUpper as ae,IfUnknown as af,UnknownifyProperties as ag,UnknownifyPropertiesOptions as ah,IsNegative as b,Abs as c,IsFloat as d,IsUnknown as e,IsNegativeInteger as f,IfEmptyString as g,OrArr as h,AndArr as i,IsInteger as j,Push as k,IfNegative as l,IsPositive as m,IsEven as n,AnyString as o,IsReadonlyArray as p,IfPositive as q,WordSeparator as r,IfNot as s,IsArray as t,IsMutableArray as u,MutableExcept as v,MutableOnly as w,MutableOptions as x,EvenDigit as y,IfEven as z};