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

package/dist/is-array--YjXV-Wx.d.ts

@@ -1,1207 +0,0 @@
-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';
-/** -------------------------------------------------------
-* * ***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>;
-/** -------------------------------------------------------
-* * ***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{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};