@rzl-zone/utils-js 3.3.0 → 3.4.0

package/dist/types/index.d.ts

@@ -1,3345 +0,0 @@
-import{A as And,b as Or,O as OrArr,a as AndArr}from'../or-C6qzKt2I.js';import{I as IsStringLiteral,P as ParseNumber,a as IsNegative,N as Negate,A as Abs,b as IsFloat,c as IsUnknown,d as IsNegativeInteger,S as Split,e as IsInteger,R as Repeat,f as Push,g as IfNegative,h as IsPositive,i as IsEven,j as IsReadonlyArray,k as IfPositive}from'../is-array-BJeHxPM3.js';export{C as CharAt,E as Even,q as EvenDigit,F as Float,r as IfEven,s as IfFloat,t as IfInteger,u as IfNegativeFloat,v as IfNegativeInteger,w as IfOdd,x as IfPositiveFloat,y as IfPositiveInteger,Y as IfUnknown,z as Integer,l as IsArray,m as IsMutableArray,B as IsNegativeFloat,D as IsOdd,G as IsPositiveFloat,H as IsPositiveInteger,J as IsScientificNumber,M as Mutable,n as MutableExcept,o as MutableOnly,p as MutableOptions,K as Negative,L as NegativeFloat,O as NegativeInteger,Q as Odd,T as OddDigit,U as ParseScientificNumber,V as Positive,W as PositiveFloat,X as PositiveInteger,Z as UnknownifyProperties,_ as UnknownifyPropertiesOptions}from'../is-array-BJeHxPM3.js';import{a as IsEmptyString,b as IfEmptyString,T as Trim,A as AnyString}from'../string-B1jlOnws.js';export{E as EmptyString,d as IfNonEmptyString,I as IfNot,e as IsNonEmptyString,N as NonEmptyString,f as TrimLeft,g as TrimRight,h as TrimsLower,i as TrimsUpper,W as Whitespace,c as WordSeparator}from'../string-B1jlOnws.js';import{I as IsAny}from'../any-v4TsK9ES.js';export{A as AnifyProperties,a as AnifyPropertiesOptions,b as IfAny}from'../any-v4TsK9ES.js';import{A as AnyFunction,T as TypedArray,P as Prettify,a as PrettifyOptions,D as DefaultPrettifyOptions}from'../prettify-3o8_Kw6b.js';export{g as AnObjectNonArray,B as BoxedPrimitivesTypes,h as DataTypes,i as DeepReplaceType,j as IntlObjects,I as IsArrayOrTuple,b as IsConstructor,c as IsFunction,d as IsPrimitive,e as IsRealPrimitive,N as NonPlainObject,f as Primitive,W as WebApiObjects}from'../prettify-3o8_Kw6b.js';import{I as IfExtends,N as Not,a as NotExtends,b as IsEmptyArray,P as Pop,E as Extends,c as ExtendsArr,d as IfEmptyArray}from'../extends-DtdRjDyU.js';export{A as Arrayable,e as EmptyArray,G as GetArrayElementType,f as IfNonEmptyArray,i as IfNotExtends,g as IsNonEmptyArray,M as MutableArray,h as NonEmptyArray,j as PopOptions}from'../extends-DtdRjDyU.js';export{F as FixNeverArrayRecursive,N as NormalizeEmptyArraysRecursive,R as RemoveEmptyArrayElements}from'../arrays-normalize-recursive-BqmVuFlD.js';import{I as If}from'../if-ChM35c_q.js';import{I as IsNever,a as IfNever}from'../never-D89PbPh5.js';export{N as NeverifyProperties,b as NeverifyPropertiesOptions}from'../never-D89PbPh5.js';export{E as ExtractStrict,O as OmitStrict,a as OverrideTypes}from'../override-CL2olHE5.js';import{N as NonUndefined}from'../nils-CO8zLHSB.js';export{K as KeepNil,a as KeepNull,b as KeepUndef,c as Nilable,d as NonNil,e as NonNull,g as NullToUndefined,f as Nullable,h as Nullish,U as Undefinedable}from'../nils-CO8zLHSB.js';export{N as NumberRangeUnion}from'../NumberRangeUnion-B6bhM2s7.js';export{P as PickStrict}from'../pick-BSMX6Xe2.js';export{A as Awaitable,C as CustomPromiseType}from'../promises-LU7K00H0.js';
-/** @private ***types for {@link AreAnagrams}.*** */
-type _AreAnagrams<Str1 extends string,Str2 extends string>=IsEmptyString<Str1>extends true?IsEmptyString<Str2>extends true?true:false:Str1 extends`${infer First extends string}${infer Rest1 extends string}`?Str2 extends`${infer Prev extends string}${First}${infer Rest2 extends string}`?_AreAnagrams<Rest1,`${Prev}${Rest2}`>:false:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `AreAnagrams`.***
- * -------------------------------------------------------
- * **Determines whether two string literal types are ***anagrams*** of each other.**
- * - **Behavior:**
- *    - Returns `true` if both strings contain exactly the same characters in
- *      any order.
- *    - Returns `false` otherwise.
- * @template Str1 - The first string literal.
- * @template Str2 - The second string literal.
- * @example
- * ```ts
- * type Case1 = AreAnagrams<"name", "eman">;
- * // ➔ true
- * type Case2 = AreAnagrams<"name", "emand">;
- * // ➔ false
- * type Case3 = AreAnagrams<"abc", "cba">;
- * // ➔ true
- * type Case4 = AreAnagrams<"abc", "abcd">;
- * // ➔ false
- * ```
- */
-type AreAnagrams<Str1 extends string,Str2 extends string>=And<IsStringLiteral<Str1>,IsStringLiteral<Str2>>extends true?_AreAnagrams<Str1,Str2>:false;
-/** --------------------------------------------------
- * * ***Utility Type: `ArgumentTypes`.***
- * --------------------------------------------------
- * **Extracts the **argument types** of a given function type `F`.**
- * - ✅ Useful when you need to infer or reuse the parameter types
- *    from an existing function signature.
- * @template F - A function type from which to extract argument types.
- * @example
- * ```ts
- * type Args = ArgumentTypes<(a: number, b: string) => void>;
- * // ➔ [number, string]
- * ```
- */
-type ArgumentTypes<F extends AnyFunction>=F extends(...args:infer A)=>any?A:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `ArrayElementType`.***
- * -------------------------------------------------------
- * **A type-level utility that extracts the element type of an array.**
- * - **Behavior:**
- *    - Works with both mutable and readonly arrays.
- *    - If `T` is not an array, resolves to `never`.
- * @template T - The array type to extract the element type from.
- * @example
- * ```ts
- * type A = ArrayElementType<string[]>;
- * // ➔ string
- * type B = ArrayElementType<readonly ("a" | "b")[]>;
- * // ➔ "a" | "b"
- * type C = ArrayElementType<number>;
- * // ➔ never
- * ```
- */
-type ArrayElementType<T extends readonly unknown[]>=T extends Readonly<Array<infer Item>>?Item:never;
-/** ---------------------------------------------------------------------------
- * * ***Type Options for {@link LastCharacter | `LastCharacter`}.***
- * ---------------------------------------------------------------------------
- */
-type LastCharacterOptions={includeRest:boolean;};type _LastCharacter<T extends string,Options extends LastCharacterOptions={includeRest:false;},Previous extends string="">=string extends T?string:T extends`${infer First}${infer Rest}`?IsEmptyString<Rest>extends true?If<Options["includeRest"],[First,Previous],First>:_LastCharacter<Rest,Options,`${Previous}${First}`>:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `LastCharacter`.***
- * -------------------------------------------------------
- * **Accepts a string argument and returns its last character.**
- * - If the `includeRest` option is `true`, returns the last character and the rest of the string in the format: `[last, rest]`.
- * @template T - The string to get the last character from.
- * @template Options - Options to include the rest of the string.
- * @example
- * type Case1 = LastCharacter<'abc'>;
- * // ➔ 'c'
- * type Case2 = LastCharacter<'abc', { includeRest: true }>;
- * // ➔ ['c', 'ab']
- */
-type LastCharacter<T extends string,Options extends LastCharacterOptions={includeRest:false;}>=IfExtends<Options,LastCharacterOptions,_LastCharacter<T,Options>,_LastCharacter<T>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `Stringify`.***
- * -------------------------------------------------------
- * **Converts a value of type `number`, `boolean`, `string`, `bigint`, `undefined`, or `null` into a string literal type.**
- * - **Behavior:**
- *    - `number` ➔ string representation (e.g., `123` ➔ `"123"`)
- *    - `boolean` ➔ `"true"` or `"false"`
- *    - `string` ➔ itself
- *    - `bigint` ➔ string representation with `"n"` suffix (e.g., `123n` ➔ `"123n"`)
- *    - `undefined` ➔ `"undefined"`
- *    - `null` ➔ `"null"`
- *    - Other types ➔ `never`
- * @template T - The value type to stringify.
- * @example
- * ```ts
- * // Boolean
- * type Result1 = Stringify<true>;
- * // ➔ "true"
- *
- * // Number
- * type Result2 = Stringify<123>;
- * // ➔ "123"
- *
- * // BigInt
- * type Result3 = Stringify<123n>;
- * // ➔ "123n"
- *
- * // String
- * type Result4 = Stringify<"hello">;
- * // ➔ "hello"
- *
- * // Undefined
- * type Result5 = Stringify<undefined>;
- * // ➔ "undefined"
- *
- * // Null
- * type Result6 = Stringify<null>;
- * // ➔ "null"
- *
- * // Other type
- * type Result7 = Stringify<{}>;
- * // ➔ never
- * ```
- */
-type Stringify<T>=T extends number|boolean|string|bigint|undefined|null?T extends bigint?`${T}n`:`${T}`:never;type DecrementMap=[-1,0,1,2,3,4,5,6,7,8];type NegativeCarryMap={"-1":9;};
-/** -------------------------------------------------------
- * * ***Internal Utility Type: `_Decrement (Internal / Deprecated)`***
- * -------------------------------------------------------
- * **Internal type-level utility to decrement a numeric string by 1.**
- * - **⚠️ Deprecated:**
- *    - Do **not** use this directly.
- *    - Use the public {@link Decrement | **`Decrement`**} type instead.
- * - Processes the string recursively digit by digit.
- * - Handles borrow/carry using internal `DecrementMap` and `NegativeCarryMap`.
- * @template Number - The numeric string to decrement.
- * @template Result - (Internal) Accumulator used during recursion.
- * @deprecated Use {@link Decrement | **`Decrement`**} instead.
- * @example
- * ```ts
- * // ❌ Avoid using _Decrement directly
- * type R1 = _Decrement<"23">;
- *
- * // ✅ Use Decrement instead
- * type R2 = Decrement<"23">; // ➔ 22
- * ```
- */
-type _Decrement<Number extends string,Result extends string="">=Number extends""?ParseNumber<Result>:ParseNumber<LastCharacter<Number>>extends infer LastDigit extends number?DecrementMap[LastDigit] extends infer Decremented extends number?Number extends`${infer Rest}${LastDigit}`?`${Decremented}`extends keyof NegativeCarryMap?_Decrement<Rest,`${NegativeCarryMap[`${Decremented}`]}${Result}`>:`${Rest}${Decremented}${Result}`extends infer FinalResult extends string?ParseNumber<FinalResult extends`0${infer FinalResultWithoutLeadingZero extends string}`?FinalResultWithoutLeadingZero extends""?FinalResult:FinalResultWithoutLeadingZero:FinalResult>:never:never:never:never;type _DecrementNegativeOrZero<T extends number>=_Increment<Stringify<T>>extends infer PositiveDecrementResult extends number?PositiveDecrementResult extends 0?PositiveDecrementResult:Negate<PositiveDecrementResult>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Decrement`.***
- * --------------------------------------------------------
- * **A type-level utility that returns the decremented value of an integer.**
- * - Works for numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template T - The number type to decrement.
- * @example
- * ```ts
- * type A = Decrement<6>;   // ➔ 5
- * type B = Decrement<0>;   // ➔ -1
- * type C = Decrement<-6>;  // ➔ -7
- * type D = Decrement<123>; // ➔ 122
- * type E = Decrement<-1>;  // ➔ -2
- * ```
- */
-type Decrement<T extends number>=IsNegative<T>extends true?_DecrementNegativeOrZero<Abs<T>>:T extends 0?_DecrementNegativeOrZero<T>:_Decrement<Stringify<T>>;type IncrementMap=[1,2,3,4,5,6,7,8,9,10];type LastDigitMap={10:0;};
-/** -------------------------------------------------------
- * * ***Internal Utility Type: `_Increment (Internal / Deprecated)`***
- * -------------------------------------------------------
- * **Internal type-level utility to increment a numeric string by 1.**
- * - **⚠️ Deprecated:**
- *    - Do **not** use this directly.
- *    - Use the public {@link Increment | **`Increment`**} type instead.
- * - Processes the string recursively digit by digit.
- * - Handles carry-over using internal `IncrementMap` and `LastDigitMap`.
- * @template Number - The numeric string to increment.
- * @template Result - (Internal) Accumulator used during recursion.
- * @deprecated Use {@link Increment | **`Increment`**} instead.
- * @example
- * ```ts
- * // ❌ Avoid using _Increment directly
- * type R1 = _Increment<"23">;
- *
- * // ✅ Use Increment instead
- * type R2 = Increment<"23">; // ➔ 24
- * ```
- */
-type _Increment<Number extends string,Result extends string="">=IsEmptyString<Number>extends true?ParseNumber<`1${Result}`>:LastCharacter<Number>extends`${infer LastDigit extends number}`?IncrementMap[LastDigit] extends infer Incremented extends number?Number extends`${infer Rest}${LastDigit}`?Incremented extends keyof LastDigitMap?_Increment<Rest,`${LastDigitMap[Incremented]}${Result}`>:ParseNumber<`${Rest}${Incremented}${Result}`>:never:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Increment`.***
- * -------------------------------------------------------
- * **Accepts an integer and returns the incremented value of it.**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`
- * @template T - The input number to increment.
- * @example
- * ```ts
- * type Case1 = Increment<1>; // ➔ 2
- * type Case2 = Increment<-10>; // ➔ -9
- * ```
- */
-type Increment<T extends number>=IsNegative<T>extends true?_Decrement<Stringify<Abs<T>>>extends infer NegativeIncrementResult extends number?NegativeIncrementResult extends 0?NegativeIncrementResult:Negate<NegativeIncrementResult>:never:_Increment<Stringify<T>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `GetFloatNumberParts`.***
- * -------------------------------------------------------
- * **Returns a tuple of the **whole** and **fraction** parts of a float number `T`.**
- * - **Behavior:**
- *    - Only works for **float numbers** (i.e., numbers with a fractional part):
- *      - If `T` is not a float, the result is `never`.
- *    - Preserves the sign on the whole part (e.g. `-12.25` ➔ `[-12, 25]`).
- *    - For values like `-0.x`, the TypeScript will normalizes `-0` to `0`,
- *      so the result will be `[0, ...]`.
- * @template T - A float number type.
- * @example
- * ```ts
- * type A = GetFloatNumberParts<12.25>;  // ➔ [12, 25]
- * type B = GetFloatNumberParts<-12.25>; // ➔ [-12, 25]
- * type C = GetFloatNumberParts<3.1415>; // ➔ [3, 1415]
- * type D = GetFloatNumberParts<-0.75>;  // ➔ [0, 75] (`-0` normalized to `0`)
- * type E = GetFloatNumberParts<42>;     // ➔ never (not a float)
- * ```
- */
-type GetFloatNumberParts<T extends number>=IsFloat<T>extends true?`${T}`extends`${infer Whole extends number}.${infer Fraction extends number}`?[IsNegative<T>extends true?Whole:Whole,Fraction]:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Ceil`.***
- * -------------------------------------------------------
- * **A type-level utility that computes the **mathematical ceiling**
- * of a numeric literal type `T`, type version of `Math.ceil()`.**
- * - **Behavior:**
- *    - If `T` is an integer, it returns `T` unchanged.
- *    - If `T` is a positive float, it rounds up to the nearest integer.
- *    - If `T` is a negative float, it rounds up toward zero.
- * @template T - A number literal type.
- * @example
- * ```ts
- * type A = Ceil<1.2>;  // ➔ 2
- * type B = Ceil<1.9>;  // ➔ 2
- * type C = Ceil<5>;    // ➔ 5
- * type D = Ceil<-1.2>; // ➔ -1
- * type E = Ceil<-1.9>; // ➔ -1
- * type F = Ceil<-5>;   // ➔ -5
- * ```
- */
-type Ceil<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extends [infer Whole extends number,unknown]?IsNegative<T>extends true?Negate<Whole>:Increment<Whole>:never:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `ColorCssNamed`.***
- * -------------------------------------------------------
- * **Represents a **named CSS color keyword**, including `transparent`.**
- * @description
- * This type includes all standard color names defined in the CSS Color Module Level 4
- * specification, and ensures type safety for string values in strongly typed UI libraries,
- * themes, or design systems.
- * - **Behavior:**
- *    - Only recognized, browser-supported named colors are allowed.
- * @see https://developer.mozilla.org/en-US/docs/Web/CSS/named-color
- * @see https://drafts.csswg.org/css-color-4/#named-colors
- * @example
- * ```ts
- * const textColor1: ColorCssNamed = "rebeccapurple"; // ➔ ✅ valid
- * const textColor2: ColorCssNamed = "navy";          // ➔ ✅ valid
- * const textColor3: ColorCssNamed = "superblue";     // ➔ ❌ Type error
- *
- * // Usage in a theme object
- * const theme: Record<string, ColorCssNamed> = {
- *   primary: "blue",
- *   secondary: "goldenrod",
- *   highlight: "transparent",
- * };
- * ```
- */
-type ColorCssNamed="aliceblue"|"antiquewhite"|"aqua"|"aquamarine"|"azure"|"beige"|"bisque"|"black"|"blanchedalmond"|"blue"|"blueviolet"|"brown"|"burlywood"|"cadetblue"|"chartreuse"|"chocolate"|"coral"|"cornflowerblue"|"cornsilk"|"crimson"|"cyan"|"darkblue"|"darkcyan"|"darkgoldenrod"|"darkgray"|"darkgreen"|"darkgrey"|"darkkhaki"|"darkmagenta"|"darkolivegreen"|"darkorange"|"darkorchid"|"darkred"|"darksalmon"|"darkseagreen"|"darkslateblue"|"darkslategray"|"darkslategrey"|"darkturquoise"|"darkviolet"|"deeppink"|"deepskyblue"|"dimgray"|"dimgrey"|"dodgerblue"|"firebrick"|"floralwhite"|"forestgreen"|"fuchsia"|"gainsboro"|"ghostwhite"|"gold"|"goldenrod"|"gray"|"green"|"greenyellow"|"grey"|"honeydew"|"hotpink"|"indianred"|"indigo"|"ivory"|"khaki"|"lavender"|"lavenderblush"|"lawngreen"|"lemonchiffon"|"lightblue"|"lightcoral"|"lightcyan"|"lightgoldenrodyellow"|"lightgray"|"lightgreen"|"lightgrey"|"lightpink"|"lightsalmon"|"lightseagreen"|"lightskyblue"|"lightslategray"|"lightslategrey"|"lightsteelblue"|"lightyellow"|"lime"|"limegreen"|"linen"|"magenta"|"maroon"|"mediumaquamarine"|"mediumblue"|"mediumorchid"|"mediumpurple"|"mediumseagreen"|"mediumslateblue"|"mediumspringgreen"|"mediumturquoise"|"mediumvioletred"|"midnightblue"|"mintcream"|"mistyrose"|"moccasin"|"navajowhite"|"navy"|"oldlace"|"olive"|"olivedrab"|"orange"|"orangered"|"orchid"|"palegoldenrod"|"palegreen"|"paleturquoise"|"palevioletred"|"papayawhip"|"peachpuff"|"peru"|"pink"|"plum"|"powderblue"|"purple"|"rebeccapurple"|"red"|"rosybrown"|"royalblue"|"saddlebrown"|"salmon"|"sandybrown"|"seagreen"|"seashell"|"sienna"|"silver"|"skyblue"|"slateblue"|"slategray"|"slategrey"|"snow"|"springgreen"|"steelblue"|"tan"|"teal"|"thistle"|"tomato"|"transparent"|"turquoise"|"violet"|"wheat"|"white"|"whitesmoke"|"yellow"|"yellowgreen";
-/** -------------------------------------------------------
- * * ***Utility Type: `IsEqual`.***
- * -------------------------------------------------------
- * **A type-level utility that returns a boolean indicating
- * whether the two types are ***equal***.**
- * @template T - The first type to compare.
- * @template U - The second type to compare.
- * @example
- * ```ts
- * type A = IsEqual<string, string>;
- *  // ➔ true
- * type B = IsEqual<1, 4>;
- *  // ➔ false
- * type C = IsEqual<true, false>;
- *  // ➔ false
- * type D = IsEqual<any, any>;
- *  // ➔ true
- * ```
- */
-type IsEqual<T,U>=(<F>()=>F extends T?1:2)extends<F>()=>F extends U?1:2?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsNotEqual`.***
- * -------------------------------------------------------
- * **A type-level utility that returns a boolean indicating
- * whether the two types are ***not equal***.**
- * @template T - The first type to compare.
- * @template U - The second type to compare.
- * @example
- * ```ts
- * type A = IsNotEqual<1, 4>;
- * // ➔ true
- * type B = IsNotEqual<string, string>;
- * // ➔ false
- * ```
- */
-type IsNotEqual<T,U>=Not<IsEqual<T,U>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfEqual`.***
- * -------------------------------------------------------
- * - **Conditional:**
- *    - Selects one of two branches depending on whether `T` and `U` are ***equal***.
- * - Defaults: `IfTrue = true`, `IfFalse = false`.
- * @template T - The first type to compare.
- * @template U - The second type to compare.
- * @template IfTrue - The branch type if condition is met. (default: `true`)
- * @template IfFalse - The branch type if condition is not met. (default: `false`)
- * @example
- * ```ts
- * type A = IfEqual<string, string, "valid">;      // ➔ "valid"
- * type B = IfEqual<1, 4, "valid", "invalid">;    // ➔ "invalid"
- * ```
- */
-type IfEqual<T,U,IfTrue=true,IfFalse=false>=If<IsEqual<T,U>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfNotEqual`.***
- * -------------------------------------------------------
- * - **Conditional:**
- *    - Selects one of two branches depending on whether `T` and `U` are ***not equal***.
- * - Defaults: `IfTrue = true`, `IfFalse = false`.
- * @template T - The first type to compare.
- * @template U - The second type to compare.
- * @template IfTrue - The branch type if condition is met. (default: `true`)
- * @template IfFalse - The branch type if condition is not met. (default: `false`)
- * @example
- * ```ts
- * type A = IfNotEqual<1, 4, "valid">;
- * // ➔ "valid"
- * type B = IfNotEqual<string, string, "valid", "invalid">;
- * // ➔ "invalid"
- * ```
- */
-type IfNotEqual<T,U,IfTrue=true,IfFalse=false>=If<IsNotEqual<T,U>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsExactly`.***
- * -------------------------------------------------------
- * **A strict equality check between two types `A` and `B`
- * that does **not** collapse when one of them is `any`.**
- * - **Behavior:**
- *    - Returns `true` only if `A` and `B` are **mutually assignable**.
- *    - Returns `false` if either `A` or `B` is `any`.
- * @template A - The first type to compare.
- * @template B - The second type to compare.
- * @example
- * ```ts
- * type A = IsExactly<string, string>; // ➔ true
- * type B = IsExactly<string, any>;    // ➔ false
- * type C = IsExactly<42, number>;     // ➔ false
- * type D = IsExactly<never, never>;   // ➔ true
- * type E = IsExactly<any, any>;       // ➔ false
- * ```
- */
-type IsExactly<A,B>=IsAny<A>extends true?false:IsAny<B>extends true?false:(<T>()=>T extends A?1:2)extends<T>()=>T extends B?1:2?(<T>()=>T extends B?1:2)extends<T>()=>T extends A?1:2?true:false:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsGeneralArray`.***
- * -------------------------------------------------------
- * **Checks if `T` is a **general array type** (`X[]` or `ReadonlyArray<X>`)
- * instead of a tuple literal.**
- * - **Behavior:**
- *    - Returns `true` for `string[]`, `(number | boolean)[]`, `any[]`, etc.
- *    - Returns `false` for tuples like `[]`, `[1, 2, 3]`, or `[string, number]`.
- * @template T - The type to check.
- * @example
- * ```ts
- * type A = IsGeneralArray<string[]>;  // ➔ true
- * type B = IsGeneralArray<[]>;        // ➔ false
- * type C = IsGeneralArray<[1, 2, 3]>; // ➔ false
- * type D = IsGeneralArray<ReadonlyArray<number>>; // ➔ true
- * ```
- */
-type IsGeneralArray<T>=T extends readonly unknown[]?number extends T["length"]?true:false:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsBaseType`.***
- * -------------------------------------------------------
- * **Determines whether a type `T` is considered a **base / keyword / built-in type**
- * rather than a literal, tuple, or specific instance.**
- * - **Behavior:**
- *    - ***✅ Considered base types:***
- *        - Special keywords: `any`, `unknown`, `never`, `null`, `undefined`, `void`
- *        - Primitive keywords: `string`, `number`, `boolean`, `bigint`, `symbol`
- *        - Function keyword `Function` and alias `AnyFunction`
- *        - General arrays (`X[]`, `ReadonlyArray<X>`) and `TypedArray`
- *        - Common built-ins: `Date`, `RegExp`, `Error`
- *        - Generic containers: `Promise<any>`, `Map<any,any>`, `WeakMap<object,any>`, `Set<any>`, `WeakSet<object>`
- *        - Buffers & views: `ArrayBuffer`, `SharedArrayBuffer`, `DataView`
- *        - `object` keyword and `{}` (empty object type)
- *    - ***❌ Not considered base types:***
- *        - Literal values (`"foo"`, `123`, `true`)
- *        - Union literals (`"a" | "b"`)
- *        - Tuples (`[1, 2, 3]`, `[]`)
- *        - Specific object shapes (`{ a: 1 }`, `{ x: string }`)
- *        - Functions with explicit structure (`() => {}`, `(x: number) => string`)
- * @template T - The type to evaluate.
- * @example
- * ```ts
- * // Special keywords
- * type A = IsBaseType<any>;     // ➔ true
- * type B = IsBaseType<unknown>; // ➔ true
- * type C = IsBaseType<never>;   // ➔ true
- *
- * // Primitives
- * type PS1 = IsBaseType<string>;  // ➔ true
- * type PS2 = IsBaseType<"hi">;    // ➔ false
- * type PN1 = IsBaseType<number>;  // ➔ true
- * type PN2 = IsBaseType<42>;      // ➔ false
- * type PB1 = IsBaseType<boolean>; // ➔ true
- * type PB2 = IsBaseType<true>;    // ➔ false
- * type PB3 = IsBaseType<false>;   // ➔ false
- * type PBi1 = IsBaseType<bigint>; // ➔ true
- * type PBi2 = IsBaseType<123n>;   // ➔ false
- *
- * // Functions
- * type H = IsBaseType<Function>;    // ➔ true
- * type I = IsBaseType<AnyFunction>; // ➔ true
- * type J = IsBaseType<() => {}>;    // ➔ false
- *
- * // Arrays
- * type K = IsBaseType<[]>;       // ➔ false
- * type L = IsBaseType<string[]>; // ➔ true
- * type M = IsBaseType<(string | number)[]>; // ➔ true
- *
- * // Built-ins
- * type N = IsBaseType<Date>;         // ➔ true
- * type O = IsBaseType<new Date()>;   // ➔ false
- * type P = IsBaseType<Promise<any>>; // ➔ true
- * type Q = IsBaseType<Promise<42>>;  // ➔ false
- *
- * // Objects
- * type R = IsBaseType<object>;   // ➔ true
- * type S = IsBaseType<{ a: 1 }>; // ➔ false
- * type T = IsBaseType<{}>;       // ➔ true
- * ```
- */
-type IsBaseType<T>=IsAny<T>extends true?true:IsUnknown<T>extends true?true:IsNever<T>extends true?true:IsExactly<T,null>extends true?true:IsExactly<T,undefined>extends true?true:IsExactly<T,void>extends true?true:IsExactly<T,string>extends true?true:IsExactly<T,number>extends true?true:IsExactly<T,boolean>extends true?true:IsExactly<T,bigint>extends true?true:IsExactly<T,symbol>extends true?true:IsExactly<T,Function>extends true?true:IsExactly<T,AnyFunction>extends true?true:IsGeneralArray<T>extends true?true:IsExactly<T,TypedArray>extends true?true:IsExactly<T,Date>extends true?true:IsExactly<T,RegExp>extends true?true:IsExactly<T,Error>extends true?true:T extends Promise<infer U>?IsBaseType<U>extends true?true:false:T extends Map<infer K,infer V>?IsBaseType<K>extends true?IsBaseType<V>extends true?true:false:false:T extends WeakMap<infer K,infer V>?K extends object?IsBaseType<V>extends true?true:false:false:T extends Set<infer U>?IsBaseType<U>extends true?true:false:T extends WeakSet<infer U>?U extends object?true:false:IsExactly<T,ArrayBuffer>extends true?true:IsExactly<T,SharedArrayBuffer>extends true?true:IsExactly<T,DataView>extends true?true:IsExactly<T,{}>extends true?true:[ T] extends [object]?[object] extends [T]?true:false:false;
-/**
- * Helper for {@link ReplaceAll}
- */
-type Includes$1<S extends string,Sub extends string>=S extends`${infer _}${Sub}${infer _}`?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `ReplaceAll`.***
- * -------------------------------------------------------
- * **A **type-level utility** that replaces all occurrences of a given string (or array of strings) `Pivot` in a string `T` with `ReplaceBy`.**
- * - **Supports:**
- *    - Replacing a single substring.
- *    - Replacing multiple substrings (Pivot as array).
- *    - Guards against infinite recursion if `ReplaceBy` contains any value in Pivot.
- * @template T - The string to process.
- * @template Pivot - A string or readonly array of strings to replace.
- * @template ReplaceBy - The string to replace Pivot with.
- * @example
- * ```ts
- * // Single pivot string
- * type Case1 = ReplaceAll<'remove me me', 'me', 'him'>;
- * // ➔ 'remove him him'
- *
- * // Pivot as array
- * type Case2 = ReplaceAll<'remove me remove me', ['me', 'remove'], 'him'>;
- * // ➔ 'him him him him'
- *
- * // Pivot not found
- * type Case3 = ReplaceAll<'hello world', 'foo', 'bar'>;
- * // ➔ 'hello world'
- *
- * // ReplaceBy contains pivot (guard against infinite recursion)
- * type Case4 = ReplaceAll<'abc', 'a', 'a'>;
- * // ➔ string
- * ```
- * @remarks
- * - Works recursively to replace all instances.
- * - If Pivot is empty (`""`) or empty array (`[]`), returns `T` unchanged.
- */
-type ReplaceAll<T extends string,Pivot extends string|readonly string[],ReplaceBy extends string>=Pivot extends""|[]?T:Includes$1<ReplaceBy,Pivot extends string?Pivot:never>extends true?string:Pivot extends readonly [infer First extends string,...infer Rest extends string[]]?ReplaceAll<ReplaceAll<T,First,ReplaceBy>,Rest,ReplaceBy>:Pivot extends string?T extends`${infer A}${Pivot}${infer B}`?ReplaceAll<`${A}${ReplaceBy}${B}`,Pivot,ReplaceBy>:T:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsTuple`.***
- * -------------------------------------------------------
- * **Returns a boolean whether the first array argument is fixed length tuple.**
- * @template T - The array to check.
- * @example
- * type Case1 = IsTuple<[1, 2, 3]>; // ➔ true
- * type Case2 = IsTuple<number[]>;  // ➔ false
- */
-type IsTuple<T extends readonly unknown[]>=NotExtends<number,T["length"]>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfTuple`.***
- * -------------------------------------------------------
- * **Returns the second argument if the first array argument is fixed length
- * tuple (defaults to `true`), otherwise returns the third argument (defaults
- * to `false`).**
- * @template T - The array to check.
- * @template IfTrue - The branch type if condition is met. (default: `true`).
- * @template IfFalse - The branch type if condition is not met. (default: `false`).
- * @example
- * type Case1 = IfTuple<[1, 2, 3], 'valid'>;
- * // ➔ 'valid'
- * type Case2 = IfTuple<number[], 'valid', 'invalid'>;
- * // ➔ 'invalid'
- */
-type IfTuple<T extends readonly unknown[],IfTrue=true,IfFalse=false>=If<IsTuple<T>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `RemoveLeading`.***
- * -------------------------------------------------------
- * **Accepts a string type `T` and **recursively removes leading characters**
- * specified in `Characters`.**
- * @template T - The string to process.
- * @template Characters - The characters to remove from the start.
- * @example
- * ```ts
- * type Case1 = RemoveLeading<'aaabc', 'a'>;
- * // ➔ 'bc' (all leading 'a' removed).
- * type Case2 = RemoveLeading<'abc', 'd'>;
- * // ➔ 'abc' (no 'd' at start, unchanged).
- * type Case3 = RemoveLeading<'aaa', 'a'>;
- * // ➔ '' (all 'a' removed).
- * type Case4 = RemoveLeading<'aaa', 'aa'>;
- * // ➔ 'a' (matches 'aa' once, then remaining 'a').
- * ```
- */
-type RemoveLeading<T extends string,Characters extends string>=T extends`${Characters}${infer Rest extends string}`?IsEmptyString<Rest>extends true?Rest:RemoveLeading<Rest,Characters>:T;type SubDecrementMap={"-9":-10;"-8":-9;"-7":-8;"-6":-7;"-5":-6;"-4":-5;"-3":-4;"-2":-3;"-1":-2;"0":-1;"1":0;"2":1;"3":2;"4":3;"5":4;"6":5;"7":6;"8":7;"9":8;};type SubNegativeCarryMap={"-10":0;"-9":1;"-8":2;"-7":3;"-6":4;"-5":5;"-4":6;"-3":7;"-2":8;"-1":9;};type SubMap={0:[0,-1,-2,-3,-4,-5,-6,-7,-8,-9];1:[1,0,-1,-2,-3,-4,-5,-6,-7,-8];2:[2,1,0,-1,-2,-3,-4,-5,-6,-7];3:[3,2,1,0,-1,-2,-3,-4,-5,-6];4:[4,3,2,1,0,-1,-2,-3,-4,-5];5:[5,4,3,2,1,0,-1,-2,-3,-4];6:[6,5,4,3,2,1,0,-1,-2,-3];7:[7,6,5,4,3,2,1,0,-1,-2];8:[8,7,6,5,4,3,2,1,0,-1];9:[9,8,7,6,5,4,3,2,1,0];};type _RemoveLeadingZeros<T extends string>=ParseNumber<RemoveLeading<T,"0">extends infer WithoutLeadingZeros extends string?IfEmptyString<WithoutLeadingZeros,"0",WithoutLeadingZeros>:never>;type _Sub<Num1 extends string,Num2 extends string,NegativeCarry extends 0|1=0,Result extends string="">=IsEmptyString<Num2>extends true?NegativeCarry extends 0?`${Num1}${Result}`:`${Decrement<ParseNumber<Num1>>}${Result}`:LastCharacter<Num1>extends`${infer Num1LastDigit extends keyof SubMap & number}`?LastCharacter<Num2>extends`${infer Num2LastDigit extends keyof SubMap[Num1LastDigit] & number}`?`${SubMap[Num1LastDigit][Num2LastDigit]}`extends infer DigitsSub extends keyof SubDecrementMap?(NegativeCarry extends 1?Stringify<SubDecrementMap[DigitsSub]>:DigitsSub)extends infer DigitsSubWithCarry extends string?Num1 extends`${infer Num1Rest}${Num1LastDigit}`?Num2 extends`${infer Num2Rest}${Num2LastDigit}`?DigitsSubWithCarry extends keyof SubNegativeCarryMap?_Sub<Num1Rest,Num2Rest,1,`${SubNegativeCarryMap[DigitsSubWithCarry]}${Result}`>:_Sub<Num1Rest,Num2Rest,0,`${DigitsSubWithCarry}${Result}`>:never:never:never:never:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Sub`.***
- * -------------------------------------------------------
- * **Computes the subtraction of two integers at the **type level**.**
- * - **Behavior:**
- *    - Handles positive and negative numbers.
- *    - Supports numbers in the range `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- *    - Internally performs string-based arithmetic to handle carries/borrows.
- * @template Num1 - First number (minuend).
- * @template Num2 - Second number (subtrahend).
- * @example
- * ```ts
- * // Positive numbers
- * type Case1 = Sub<10, 2>;  // ➔ 8
- *
- * // Num1 smaller than Num2
- * type Case2 = Sub<2, 10>;  // ➔ -8
- *
- * // Subtract negative number
- * type Case3 = Sub<2, -10>; // ➔ 12
- *
- * // Subtract from negative number
- * type Case4 = Sub<-2, 10>; // ➔ -12
- *
- * // Both negative
- * type Case5 = Sub<-5, -2>; // ➔ -3
- * type Case6 = Sub<-2, -5>; // ➔ 3
- * ```
- */
-type Sub<Num1 extends number,Num2 extends number>=IsNegativeInteger<Num1>extends true?IsNegativeInteger<Num2>extends true?IsLowerThan<Num1,Num2>extends true?Negate<_RemoveLeadingZeros<_Sub<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>>:_RemoveLeadingZeros<_Sub<Stringify<Abs<Num2>>,Stringify<Abs<Num1>>>>:Sum<Abs<Num1>,Num2>extends infer Result extends number?Negate<Result>:never:IsNegativeInteger<Num2>extends true?Sum<Num1,Abs<Num2>>:IsLowerThan<Num1,Num2>extends true?Negate<_RemoveLeadingZeros<_Sub<Stringify<Num2>,Stringify<Num1>>>>:_RemoveLeadingZeros<_Sub<Stringify<Num1>,Stringify<Num2>>>;type SumIncrementMap=[ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19];type SumLastDigitMap={10:0;11:1;12:2;13:3;14:4;15:5;16:6;17:7;18:8;19:9;};type SumMap={0:[0,1,2,3,4,5,6,7,8,9];1:[1,2,3,4,5,6,7,8,9,10];2:[2,3,4,5,6,7,8,9,10,11];3:[3,4,5,6,7,8,9,10,11,12];4:[4,5,6,7,8,9,10,11,12,13];5:[5,6,7,8,9,10,11,12,13,14];6:[6,7,8,9,10,11,12,13,14,15];7:[7,8,9,10,11,12,13,14,15,16];8:[8,9,10,11,12,13,14,15,16,17];9:[9,10,11,12,13,14,15,16,17,18];};
-/** -------------------------------------------------------
- * * ***Private Utility Type: `_Sum`.***
- * -------------------------------------------------------
- * **Internal helper type for summing two integer numbers represented as strings.**
- * - Performs digit-by-digit addition with carry handling.
- * @deprecated This is internal helper, use {@link Sum | **`Sum`**} instead.
- * @template Num1 - First number as string.
- * @template Num2 - Second number as string.
- * @template Carry - Carry flag (0 or 1), defaults to 0.
- * @template Result - Accumulated result string, defaults to empty string.
- */
-type _Sum<Num1 extends string,Num2 extends string,Carry extends 0|1=0,Result extends string="">=IsEmptyString<Num1>extends true?Carry extends 0?ParseNumber<`${Num2}${Result}`>:_Increment<Num2,Result>:IsEmptyString<Num2>extends true?Carry extends 0?ParseNumber<`${Num1}${Result}`>:_Increment<Num1,Result>:LastCharacter<Num1>extends`${infer Num1LastDigit extends keyof SumMap & number}`?LastCharacter<Num2>extends`${infer Num2LastDigit extends keyof SumMap[Num1LastDigit] & number}`?SumMap[Num1LastDigit][Num2LastDigit] extends infer DigitsSum extends number?(Carry extends 1?SumIncrementMap[DigitsSum]:DigitsSum)extends infer DigitsSumWithCarry extends number?Num1 extends`${infer Num1Rest}${Num1LastDigit}`?Num2 extends`${infer Num2Rest}${Num2LastDigit}`?DigitsSumWithCarry extends keyof SumLastDigitMap?_Sum<Num1Rest,Num2Rest,1,`${SumLastDigitMap[DigitsSumWithCarry]}${Result}`>:_Sum<Num1Rest,Num2Rest,0,`${DigitsSumWithCarry}${Result}`>:never:never:never:never:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Sum`.***
- * -------------------------------------------------------
- * **Adds two integers at the type level. Handles positive and negative numbers.**
- * - Supports numbers in the range:
- *   - `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - First number.
- * @template Num2 - Second number.
- * @example
- * ```ts
- * // Positive + positive
- * type Case1 = Sum<4, 9>;   // ➔ 13
- *
- * // Negative + positive
- * type Case2 = Sum<-4, 9>;  // ➔ 5
- *
- * // Positive + negative
- * type Case3 = Sum<4, -9>;  // ➔ -5
- *
- * // Negative + negative
- * type Case4 = Sum<-4, -9>; // ➔ -13
- * ```
- */
-type Sum<Num1 extends number,Num2 extends number>=IsNegativeInteger<Num1>extends true?IsNegativeInteger<Num2>extends true?Negate<_Sum<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>:Sub<Num2,Abs<Num1>>:IsNegativeInteger<Num2>extends true?Sub<Num1,Abs<Num2>>:_Sum<Stringify<Num1>,Stringify<Num2>>;type _safeSumArr<Rest extends number[],CurrentSum extends number,Num1 extends number>=
-/** @ts-expect-error this still safe not to much deep */
-_SumArr<Rest,Sum<CurrentSum,Num1>>;type _SumArr<T extends readonly number[],CurrentSum extends number=0>=IsEmptyArray<T>extends true?CurrentSum:Pop<T,{includeRemoved:true;}>extends infer PopResult?IsNever<PopResult>extends true?CurrentSum:PopResult extends [infer Rest extends number[],infer Num1 extends number]?_safeSumArr<Rest,CurrentSum,Num1>:never:CurrentSum;
-/** -------------------------------------------------------
- * * ***Utility Type: `SumArr`.***
- * -------------------------------------------------------
- * **Accepts a tuple of numbers and returns their sum.**
- * - **Behavior:**
- *    - Only works on tuple types (not general arrays).
- *    - Supports numbers in the range:
- *      -`[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template T - Tuple of numbers to sum.
- * @example
- * ```ts
- * // Sum all elements in a tuple
- * type Case1 = SumArr<[1, 2, 3, 4]>;  // ➔ 10
- *
- * // Tuple with negative number
- * type Case2 = SumArr<[1, 2, 3, -4]>; // ➔ 2
- * ```
- */
-type SumArr<T extends readonly number[]>=IsTuple<T>extends true?_SumArr<T>:never;
-/** @ts-expect-error this still safe not to much deep */
-type _safeSum<Parts extends [string[],string[],string[],string[]]=[[],[],[],[]]>=Sum<Sum<Parts[0]["length"],Parts[1]["length"]>,Sum<Parts[2]["length"],Parts[3]["length"]>>;type _StringLength<S extends string,Parts extends [string[],string[],string[],string[]]=[[],[],[],[]]>=S extends""?_safeSum<Parts>:S extends`${infer C1 extends string}${infer Rest1 extends string}`?Rest1 extends`${infer C2 extends string}${infer Rest2 extends string}`?Rest2 extends`${infer C3 extends string}${infer Rest3 extends string}`?Rest3 extends`${infer C4 extends string}${infer Rest4 extends string}`?_StringLength<Rest4,[ [...Parts[0],C1],[...Parts[1],C2],[...Parts[2],C3],[...Parts[3],C4]]>:_StringLength<Rest3,[ [...Parts[0],C1],[...Parts[1],C2],[...Parts[2],C3],Parts[3]]>:_StringLength<Rest2,[[...Parts[0],C1],[...Parts[1],C2],Parts[2],Parts[3]]>:_StringLength<Rest1,[[...Parts[0],C1],Parts[1],Parts[2],Parts[3]]>:_StringLength<S,Parts>;
-/** -------------------------------------------------------
- * * ***Utility Type: `StringLength`.***
- * -------------------------------------------------------
- * **Returns the length of a string at the type level.**
- * - Supports string length in range `[0, 3968]`.
- * @template S - The string to measure.
- * @example
- * ```ts
- * type Case1 = StringLength<''>;
- * // ➔ 0
- * type Case2 = StringLength<'xxx'>;
- * // ➔ 3
- * ```
- */
-type StringLength<S extends string>=_StringLength<S>;
-/** -------------------------------------------------------
- * * ***Utility Type: `CompareStringLength`.***
- * -------------------------------------------------------
- * - **Compares the lengths of two strings and returns one of three possible type values:**
- *    - `IfStr1Shorter` if the first string is shorter.
- *    - `IfStr2Shorter` if the second string is shorter.
- *    - `IfEqual` if both strings have the same length.
- * - Defaults to `never` if not provided.
- * @template Str1 - First string.
- * @template Str2 - Second string.
- * @template IfStr1Shorter - Type to return if Str1 is shorter (default `never`).
- * @template IfStr2Shorter - Type to return if Str2 is shorter (default `never`).
- * @template IfEqual - Type to return if both strings have equal length (default `never`).
- * @example
- * ```ts
- * type Case1 = CompareStringLength<'a', 'ab', 'first shorter'>;
- * // ➔ 'first shorter'
- * type Case2 = CompareStringLength<'abc', 'ab', 'first shorter', 'first longer'>;
- * // ➔ 'first longer'
- * type Case3 = CompareStringLength<'ab', 'ab', 'first shorter', 'first longer', 'equal'>;
- * // ➔ 'equal'
- * ```
- */
-type CompareStringLength<Str1 extends string,Str2 extends string,IfStr1Shorter=never,IfStr2Shorter=never,IfEqual=never>=IsEmptyString<Str1>extends true?IsEmptyString<Str2>extends true?IfEqual:IfStr1Shorter:IsEmptyString<Str2>extends true?IfStr2Shorter:Str1 extends`${string}${infer Str1Rest extends string}`?Str2 extends`${string}${infer Str2Rest extends string}`?CompareStringLength<Str1Rest,Str2Rest,IfStr1Shorter,IfStr2Shorter,IfEqual>:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsShorterString`.***
- * -------------------------------------------------------
- * **Returns `true` if the first string is shorter than the second string; otherwise `false`.**
- * @template Str1 - First string.
- * @template Str2 - Second string.
- * @example
- * ```ts
- * type Case1 = IsShorterString<'a', 'ab'>;
- * // ➔ true
- * type Case2 = IsShorterString<'abc', 'ab'>;
- * // ➔ false
- * ```
- */
-type IsShorterString<Str1 extends string,Str2 extends string>=CompareStringLength<Str1,Str2,true,false,false>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsLongerString`.***
- * -------------------------------------------------------
- * **Returns `true` if the first string is longer than the second string; otherwise `false`.**
- * @template Str1 - First string.
- * @template Str2 - Second string.
- * @example
- * ```ts
- * type Case1 = IsLongerString<'ab', 'a'>; // ➔ true
- * type Case2 = IsLongerString<'a', 'ab'>; // ➔ false
- * ```
- */
-type IsLongerString<Str1 extends string,Str2 extends string>=CompareStringLength<Str1,Str2,false,true,false>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsSameLengthString`.***
- * -------------------------------------------------------
- * **Returns `true` if two strings have the same length; otherwise `false`.**
- * @template Str1 - First string.
- * @template Str2 - Second string.
- * @example
- * ```ts
- * type Case1 = IsSameLengthString<'ab', 'ab'>;  // ➔ true
- * type Case2 = IsSameLengthString<'ab', 'abc'>; // ➔ false
- * ```
- */
-type IsSameLengthString<Str1 extends string,Str2 extends string>=CompareStringLength<Str1,Str2,false,false,true>;
-/** -------------------------------------------------------
- * * ***Type Options for {@link NumberLength | **`NumberLength`**}.***
- */
-type TypeNumberLengthOptions={
-/** * ***Removes the leading minus `-` from negative numbers, default: `true`.***
- *
- * @default true
- */
-stripSign?:boolean;
-/** * ***Removes the decimal point `.` from floats, default: `true`.***
- *
- * @default true
- */
-stripDot?:boolean;
-/** * ***Removes the trailing `n` from BigInt literals, default: `true`.***
- *
- * @default true
- */
-stripBigInt?:boolean;};
-/** -------------------------------------------------------
- * * ***Default options for {@link NumberLength | **`NumberLength`**} (all `true`).***
- */
-type DefaultNumberLengthOptions={stripSign:true;stripDot:true;stripBigInt:true;};
-/** -------------------------------------------------------
- * * ***Merge provided options with defaults for {@link NumberLength | **`NumberLength`**}.***
- */
-type MergeOptions<Opts extends TypeNumberLengthOptions>={[K in keyof DefaultNumberLengthOptions]:K extends keyof Opts?Opts[K]:DefaultNumberLengthOptions[K];};
-/** -------------------------------------------------------
- * * ***Utility Type: `NumberLength`.***
- * -------------------------------------------------------
- * **A type-level utility that returns the **number of digits/characters**
- * of a numeric literal type, with optional cleaning.**
- * - **Supports:**
- *    - Integers (positive & negative).
- *    - Floats (`.` optionally removed).
- *    - Scientific notation (`e`/`E`, TypeScript normalizes to number).
- *    - BigInts (`n` suffix optionally removed).
- * @template T - A numeric literal (`number` or `bigint`).
- * @template Options - Optional configuration (default: all `true`):
- * - `stripSign` ➔ Removes the leading `-` (default `true`).
- * - `stripDot` ➔ Removes the decimal point `.` (default `true`).
- * - `stripBigInt` ➔ Removes trailing `n` (default `true`).
- * @example
- * #### ✅ _Valid Examples:_
- * ```ts
- * // Integers
- * type A = NumberLength<100>;  // ➔ 3
- * type B = NumberLength<-100>; // ➔ 3 (minus stripped by default)
- * type C = NumberLength<-100, { stripSign: false }>; // ➔ 4 (minus kept)
- *
- * // Floats
- * type D = NumberLength<0.25>;  // ➔ 2 (dot removed)
- * type E = NumberLength<-0.25>; // ➔ 2 (minus & dot removed)
- * type F = NumberLength<12.34, { stripDot: false }>; // ➔ 5 (12.34)
- *
- * // Scientific notation
- * type G = NumberLength<5e4>;  // ➔ 5 (50000)
- * type H = NumberLength<-5e4>; // ➔ 5 (-50000, minus stripped)
- * type I = NumberLength<-5e4,{ stripSign:false }>; // ➔ 6 (-50000, minus not stripped)
- *
- * // BigInts
- * type J = NumberLength<12n>;    // ➔ 2
- * type K = NumberLength<-2125n>; // ➔ 4 (- & n removed)
- * type L = NumberLength<-2125n, { stripSign: false }>;
- * // ➔ 5 (minus kept)
- * type M = NumberLength<123n, { stripBigInt: false }>;
- * // ➔ 4 (123n)
- * type N = NumberLength<-123n, { stripBigInt: false, stripSign: false }>;
- * // ➔ 5 (minus & n kept ➔ -123n)
- * ```
- * ---
- * #### ❌ _Invalid Examples:_
- * ```ts
- * type Invalid1 = NumberLength<string>;   // ➔ never
- * type Invalid2 = NumberLength<boolean>;  // ➔ never
- * type Invalid3 = NumberLength<"123">;    // ➔ never (string literal)
- * type Invalid4 = NumberLength<number>;   // ➔ never (not literal)
- * type Invalid5 = NumberLength<bigint>;   // ➔ never (not literal)
- * type Invalid6 = NumberLength<any>;      // ➔ never
- * type Invalid7 = NumberLength<unknown>;  // ➔ never
- * type Invalid8 = NumberLength<never>;    // ➔ never
- * ```
- * ---
- * @remarks
- * - Uses type-level string manipulation to "clean" numeric literal according to options.
- * - Removes `-`, `.`, or `n` if corresponding option is true.
- * - Works reliably for literal numbers, floats, and BigInt.
- * - Scientific notation is normalized by TypeScript, so `5e4` becomes `50000`.
- */
-type NumberLength<T extends number|bigint,Options extends Partial<TypeNumberLengthOptions>=DefaultNumberLengthOptions>=If<OrArr<[IsBaseType<T>,Extends<T,string>,Not<Extends<T,number|bigint>>]>>extends true?never:StringLength<ReplaceAll<Stringify<T>,[ MergeOptions<Options>["stripSign"] extends true?"-":"",MergeOptions<Options>["stripDot"] extends true?".":"",MergeOptions<Options>["stripBigInt"] extends true?"n":""],"">>;
-/** -------------------------------------------------------
- * * ***Utility Type: `CompareNumberLength`.***
- * -------------------------------------------------------
- * **Compares the **number of digits** of two numeric literal types.**
- * - **Returns:**
- *    - `IfNum1Shorter` if the first number has fewer digits than the second (default: `never`).
- *    - `IfNum2Shorter` if the second number has fewer digits than the first (default: `never`).
- *    - `IfEqual` if both numbers have the same number of digits (default: `never`).
- * - **Important:**
- *    - This utility only works with **literal numbers**.
- *    - Using non-literal numbers (`number`) will return `never`.
- * @template Num1 - The first number literal to compare.
- * @template Num2 - The second number literal to compare.
- * @template IfNum1Shorter - Return type if the first number is shorter (default: `never`).
- * @template IfNum2Shorter - Return type if the second number is shorter (default: `never`).
- * @template IfEqual - Return type if both numbers have the same length (default: `never`).
- * @example
- * ```ts
- * // First number shorter than second
- * type Case1 = CompareNumberLength<1, 12, 'first shorter'>;
- * // ➔ 'first shorter'
- *
- * // First number longer than second
- * type Case2 = CompareNumberLength<123, 12, 'first shorter', 'first longer'>;
- * // ➔ 'first longer'
- *
- * // Both numbers have equal length
- * type Case3 = CompareNumberLength<12, 12, 'first shorter', 'first longer', 'equal'>;
- * // ➔ 'equal'
- *
- * // Defaults (no custom return types)
- * type Case4 = CompareNumberLength<1, 12>;
- * // ➔ never
- *
- * // Non-literal numbers
- * type NumA = number;
- * type NumB = 12;
- * type Case4 = CompareNumberLength<NumA, NumB, 'first shorter', 'first longer', 'equal'>;
- * // ➔ never
- * ```
- * ---
- * @remarks
- * - Internally uses {@link Stringify | **`Stringify`**} and {@link CompareStringLength | **`CompareStringLength`**}.
- * - Works for `positive`, `negative`, and `floating-point literal numbers`.
- */
-type CompareNumberLength<Num1 extends number,Num2 extends number,IfNum1Shorter=never,IfNum2Shorter=never,IfEqual=never>=If<Or<Extends<number,Num1>,Extends<number,Num2>>>extends true?never:CompareStringLength<Stringify<Num1>,Stringify<Num2>,IfNum1Shorter,IfNum2Shorter,IfEqual>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsShorterNumber`.***
- * -------------------------------------------------------
- * **Compares the number of digits of two numeric literal types and returns a **boolean**.**
- * - **Returns:**
- *    - `true` if the first number has fewer digits than the second.
- *    - `false` otherwise (including when numbers have equal length).
- * - **Important:**
- *    - This utility only works with **literal numbers**.
- *    - Using non-literal numbers (`number`) will return `never`.
- * @template Num1 - The first number literal to compare.
- * @template Num2 - The second number literal to compare.
- * @example
- * ```ts
- * // Literal numbers
- * type Case1 = IsShorterNumber<1, 10>;
- * // ➔ true
- *
- * type Case2 = IsShorterNumber<100, 10>;
- * // ➔ false
- *
- * type Case3 = IsShorterNumber<12, 12>;
- * // ➔ false
- *
- * // Non-literal numbers
- * type NumA = number;
- * type NumB = 12;
- * type Case4 = IsShorterNumber<NumA, NumB>;
- * // ➔ never
- * ```
- * ---
- * @remarks
- * - Internally uses {@link CompareNumberLength | **`CompareNumberLength`**}.
- * - Works for `positive`, `negative`, and `floating-point literal numbers`.
- */
-type IsShorterNumber<Num1 extends number,Num2 extends number>=CompareNumberLength<Num1,Num2,true,false,false>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsLongerNumber`.***
- * -------------------------------------------------------
- * **Compares the number of digits of two numeric literal types and returns a **boolean**.**
- * - **Returns:**
- *    - `true` if the first number has more digits than the second.
- *    - `false` otherwise (including when numbers have equal length).
- * - **Important:**
- *    - Only works with **literal numbers**.
- *    - Non-literal numbers (`number`) return `never`.
- * @template Num1 - The first number literal to compare.
- * @template Num2 - The second number literal to compare.
- * @example
- * ```ts
- * type Case1 = IsLongerNumber<10, 1>;
- * // ➔ true
- *
- * type Case2 = IsLongerNumber<10, 100>;
- * // ➔ false
- *
- * type Case3 = IsLongerNumber<12, 12>;
- * // ➔ false
- *
- * // Non-literal numbers
- * type NumA = number;
- * type NumB = 12;
- * type Case4 = IsLongerNumber<NumA, NumB>;
- * // ➔ never
- * ```
- * ---
- * @remarks
- * - Internally uses {@link CompareNumberLength | **`CompareNumberLength`**}.
- * - Works for `positive`, `negative`, and `floating-point literal numbers`.
- */
-type IsLongerNumber<Num1 extends number,Num2 extends number>=CompareNumberLength<Num1,Num2,false,true,false>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsSameLengthNumber`.***
- * -------------------------------------------------------
- * **Compares the number of digits of two numeric literal types and returns a **boolean**.**
- * - **Returns:**
- *    - `true` if the numbers have the same number of digits.
- *    - `false` otherwise.
- * - **Important:**
- *    - Only works with **literal numbers**.
- *    - Non-literal numbers (`number`) return `never`.
- * @template Num1 - The first number literal to compare.
- * @template Num2 - The second number literal to compare.
- * @example
- * ```ts
- * type Case1 = IsSameLengthNumber<10, 10>;
- * // ➔ true
- *
- * type Case2 = IsSameLengthNumber<10, 100>;
- * // ➔ false
- *
- * // Non-literal numbers
- * type NumA = number;
- * type NumB = 12;
- * type Case3 = IsSameLengthNumber<NumA, NumB>;
- * // ➔ never
- * ```
- * ---
- * @remarks
- * - Internally uses {@link CompareNumberLength | **`CompareNumberLength`**}.
- * - Works for `positive`, `negative`, and `floating-point literal numbers`.
- */
-type IsSameLengthNumber<Num1 extends number,Num2 extends number>=CompareNumberLength<Num1,Num2,false,false,true>;type LowerThanMap={"0":["1","2","3","4","5","6","7","8","9"];"1":["2","3","4","5","6","7","8","9"];"2":["3","4","5","6","7","8","9"];"3":["4","5","6","7","8","9"];"4":["5","6","7","8","9"];"5":["6","7","8","9"];"6":["7","8","9"];"7":["8","9"];"8":["9"];"9":[];};type _IsLowerThan<Num1 extends string,Num2 extends string>=Num1 extends`${infer Num1Character extends keyof LowerThanMap}${infer Num1Rest extends string}`?Num2 extends`${infer Num2Character extends string}${infer Num2Rest extends string}`?IsEqual<Num1Character,Num2Character>extends true?_IsLowerThan<Num1Rest,Num2Rest>:Num2Character extends LowerThanMap[Num1Character][number]?true:false:true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsLowerThan`.***
- * -------------------------------------------------------
- * **Returns a boolean indicating whether `Num1` is strictly lower than `Num2`.**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer to compare.
- * @template Num2 - The second integer to compare.
- * @example
- * type Case1 = IsLowerThan<1, 10>;  // ➔ true
- * type Case2 = IsLowerThan<1, -10>; // ➔ false
- */
-type IsLowerThan<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>extends true?false:IsNegative<Num1>extends true?IsNegative<Num2>extends false?true:CompareNumberLength<Num1,Num2,false,true,Not<_IsLowerThan<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>>:IsNegative<Num2>extends true?false:CompareNumberLength<Num1,Num2,true,false,_IsLowerThan<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfLowerThan`.***
- * -------------------------------------------------------
- * **Returns `IfTrue` if `Num1` is lower than `Num2`, otherwise returns `IfFalse`.**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer to compare.
- * @template Num2 - The second integer to compare.
- * @template IfTrue - Value to return if `Num1 < Num2`.
- * @template IfFalse - Value to return if `Num1 >= Num2`.
- * @example
- * type Case1 = IfLowerThan<1, 10, 'valid'>;
- * // ➔ 'valid'
- * type Case2 = IfLowerThan<1, -10, 'valid', 'invalid'>;
- * // ➔ 'invalid'
- */
-type IfLowerThan<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=If<IsLowerThan<Num1,Num2>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsLowerOrEqual`.***
- * -------------------------------------------------------
- * **Returns a boolean indicating whether `Num1` is lower than or equal to `Num2`.**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer to compare.
- * @template Num2 - The second integer to compare.
- * @example
- * type Case1 = IsLowerOrEqual<1, 10>;
- * // ➔ true
- * type Case2 = IsLowerOrEqual<1, -10>;
- * // ➔ false
- */
-type IsLowerOrEqual<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>extends true?true:IsLowerThan<Num1,Num2>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfLowerOrEqual`.***
- * -------------------------------------------------------
- * **Returns the third argument if the first argument (integer) is lower than
- * the second argument (integer) or equal (defaults to `true`), otherwise returns
- * the fourth argument (defaults to `false`).**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer to compare.
- * @template Num2 - The second integer to compare.
- * @template IfTrue - Value to return if `Num1 <= Num2`.
- * @template IfFalse - Value to return if `Num1 > Num2`.
- * @example
- * type Case1 = IfLowerOrEqual<1, 10, 'valid'>;
- * // ➔ 'valid'
- * type Case2 = IfLowerOrEqual<23, 1, 'valid', 'invalid'>;
- * // ➔ 'invalid'
- */
-type IfLowerOrEqual<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=If<IsEqual<Num1,Num2>extends true?true:IsLowerThan<Num1,Num2>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsGreaterThan`.***
- * -------------------------------------------------------
- * **Returns a boolean indicating whether the first integer
- * is ***greater than*** the second integer.**
- * - **Behavior:**
- *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer.
- * @template Num2 - The second integer.
- * @example
- * ```ts
- * type A = IsGreaterThan<10, 1>;   // ➔ true
- * type B = IsGreaterThan<-10, 1>;  // ➔ false
- * ```
- */
-type IsGreaterThan<Num1 extends number,Num2 extends number>=IsLowerThan<Num2,Num1>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfGreaterThan`.***
- * -------------------------------------------------------
- * - **Conditional:**
- *    - Returns the third argument if the first integer is ***greater than*** the
- *      second integer, otherwise returns the fourth argument.
- * - **Behavior:**
- *    - Defaults: `IfTrue = true`, `IfFalse = false`.
- *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer.
- * @template Num2 - The second integer.
- * @template IfTrue - The branch type if condition is met. (default: `true`)
- * @template IfFalse - The branch type if condition is not met. (default: `false`)
- * @example
- * ```ts
- * type A = IfGreaterThan<10, 1, "valid">;
- * // ➔ "valid"
- * type B = IfGreaterThan<-10, 1, "valid", "invalid">;
- * // ➔ "invalid"
- * ```
- */
-type IfGreaterThan<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=IfLowerThan<Num2,Num1,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsGreaterOrEqual`.***
- * -------------------------------------------------------
- * **Returns a boolean indicating whether the first integer
- * is ***greater than or equal*** to the second integer.**
- * - **Behavior:**
- *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer.
- * @template Num2 - The second integer.
- * @example
- * ```ts
- * type A = IsGreaterOrEqual<10, 1>;  // ➔ true
- * type B = IsGreaterOrEqual<-10, 1>; // ➔ false
- * type C = IsGreaterOrEqual<10, 10>; // ➔ true
- * ```
- */
-type IsGreaterOrEqual<Num1 extends number,Num2 extends number>=IsEqual<Num1,Num2>extends true?true:IsGreaterThan<Num1,Num2>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfGreaterOrEqual`.***
- * -------------------------------------------------------
- * - **Conditional:**
- *    - Returns the third argument if the first integer is ***greater than or
- *      equal*** to the second integer, otherwise returns the fourth argument.
- * - **Behavior:**
- *    - Defaults: `IfTrue = true`, `IfFalse = false`.
- *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer.
- * @template Num2 - The second integer.
- * @template IfTrue - The branch type if condition is met. (default: `true`)
- * @template IfFalse - The branch type if condition is not met. (default: `false`)
- * @example
- * ```ts
- * type A = IfGreaterOrEqual<10, 1, "valid">;
- * // ➔ "valid"
- * type B = IfGreaterOrEqual<-10, 1, "valid", "invalid">;
- * // ➔ "invalid"
- * type C = IfGreaterOrEqual<10, 10, "yes", "no">;
- * // ➔ "yes"
- * ```
- */
-type IfGreaterOrEqual<Num1 extends number,Num2 extends number,IfTrue=true,IfFalse=false>=If<IsEqual<Num1,Num2>extends true?true:IsGreaterThan<Num1,Num2>,IfTrue,IfFalse>;
-/** ---------------------------------------------------------------------------
- * * ***Type Options for {@link IsBetween | `IsBetween`}.***
- * ---------------------------------------------------------------------------
- * **Options to configure whether the borders of the interval are included
- * when using {@link IsBetween | **`IsBetween`**}.**
- */
-type IsBetweenOptions={
-/** * ***Whether to include the lower border (`Min`) in the comparison.***
- *
- * - `true` ➔ include `Min` (**default**).
- * - `false` ➔ exclude `Min`.
- *
- * @default true
- */
-minIncluded?:boolean;
-/** * ***Whether to include the upper border (`Max`) in the comparison.***
- *
- * - `true` ➔ include `Max` (**default**).
- * - `false` ➔ exclude `Max`.
- *
- * @default true
- */
-maxIncluded?:boolean;};
-/** -------------------------------------------------------
- * * ***Utility Type: `IsBetween`.***
- * -------------------------------------------------------
- * **Returns a boolean whether the first integer argument is between the second and the third integer argument, by default, borders of the interval are included, which can be modified by the second argument.**
- * - **Behavior:**
- *    - `minIncluded`, `maxIncluded` options show whether to include the lower and the higher borders
- *       respectively.
- *    - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @example
- * type Case1 = IsBetween<1, 1, 10>;
- * // ➔ true
- * type Case2 = IsBetween<1, 1, 10, {minIncluded: false}>;
- * // ➔ false
- * type Case3 = IsBetween<10, 1, 10, {maxIncluded: false}>;
- * // ➔ false
- */
-type IsBetween<Num extends number,Min extends number,Max extends number,Options extends IsBetweenOptions={minIncluded:true;maxIncluded:true;}>=IsEqual<Num,Min>extends true?Options["minIncluded"]:IsEqual<Num,Max>extends true?Options["maxIncluded"]:And<IsGreaterThan<Num,Min>,IsLowerThan<Num,Max>>;type _IsValidRGBParameter<T extends number>=IsInteger<T>extends true?IsBetween<T,0,255>:false;
-/** * ***Configuration options for a type-level utility
- * {@link RGB | `RGB`} | {@link IsRGB | `IsRGB` } | {@link IfRGB | `IfRGB` }.*** */
-type RGBOptions={
-/** * ***Separator character(s) used between the RGB components (`r`, `g`, `b`).***
- *
- * - **For example:**
- *    - `","` ➔ `"rgb(23,242,0)"`.
- *    - `", "` ➔ `"rgb(23, 242, 0)"`.
- *
- * @default ", "
- */
-separator:string;};
-/** * ***Default configuration for the {@link RGBOptions | `RGBOptions`}.***
- *
- * @example
- * ```ts
- * type Opt = DefaultRGBOptions;
- * // ➔ { separator: ", " }
- * ```
- */
-type DefaultRGBOptions={
-/** * ***Default separator for RGB components.***
- *
- * **Produces strings like `"rgb(23, 242, 0)"`.**
- */
-separator:", ";};
-/** -------------------------------------------------------
- * * ***Utility Type: `RGB`.***
- * -------------------------------------------------------
- * **A type-level utility that validates an **RGB color string**.**
- * - **Behavior:**
- *    - Accepts `rgb(r, g, b)` format with customizable separators.
- *    - Each parameter `r`, `g`, `b` must be an integer between `0` and `255`.
- *    - Returns `T` if valid, otherwise `never`.
- * @template T - A string to check.
- * @template Options - Options with `separator` (defaults to `", "`).
- * @example
- * ```ts
- * type A = RGB<"rgb(23, 242, 0)">;
- * // ➔ "rgb(23, 242, 0)"
- * type B = RGB<"rgb(324, 123, 3)">;
- * // ➔ never
- * type C = RGB<"rgb(23,242,0)", { separator: "," }>;
- * // ➔ "rgb(23,242,0)"
- * ```
- */
-type RGB<T extends string,Options extends RGBOptions=DefaultRGBOptions>=T extends`rgb(${infer R extends number}${Options["separator"]}${infer G extends number}${Options["separator"]}${infer B extends number})`?AndArr<[ _IsValidRGBParameter<R>,_IsValidRGBParameter<G>,_IsValidRGBParameter<B>]>extends true?T:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsRGB`.***
- * -------------------------------------------------------
- * **A type-level utility that checks if a string is a valid **RGB color**.**
- * - Returns `true` if valid, otherwise `false`.
- * @template T - A string to check.
- * @template Options - Options with `separator` (defaults to `", "`).
- * @example
- * ```ts
- * type A = IsRGB<"rgb(23, 242, 0)">;
- * // ➔ true
- * type B = IsRGB<"rgb(324, 123, 3)">;
- * // ➔ false
- * type C = IsRGB<"rgb(23,242,0)", { separator: "," }>;
- * // ➔ true
- * ```
- */
-type IsRGB<T extends string,Options extends RGBOptions=DefaultRGBOptions>=Not<IsNever<RGB<T,Options>>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfRGB`.***
- * -------------------------------------------------------
- * **A conditional type that returns `IfTrue` if `T` is a valid **RGB color**,
- * otherwise returns `IfFalse`.**
- * @template T - A string to check.
- * @template IfTrue - Return type if valid (defaults to `true`).
- * @template IfFalse - Return type if invalid (defaults to `false`).
- * @template Options - Options with `separator` (defaults to `", "`).
- * @example
- * ```ts
- * type A = IfRGB<"rgb(23, 242, 0)">;
- * // ➔ true
- * type B = IfRGB<"rgb(23, 242, 0)", "valid">;
- * // ➔ "valid"
- * type C = IfRGB<"rgb(324, 123, 3)", "valid", "invalid">;
- * // ➔ "invalid"
- * type D = IfRGB<"rgb(23,242,0)", true, false { separator: "," }>;
- * // ➔ true
- * ```
- */
-type IfRGB<T extends string,IfTrue=true,IfFalse=false,Options extends RGBOptions=DefaultRGBOptions>=If<IsRGB<T,Options>,IfTrue,IfFalse>;type _ValidHEXCharacters=["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"];type _AllowedHEXLength=3|4|6|8;
-/** -------------------------------------------------------
- * * ***Utility Type: `HEX`.***
- * -------------------------------------------------------
- * **A type-level utility that validates a **HEX color string**.**
- * - **Behavior:**
- *    - Accepts `#RGB`, `#RGBA`, `#RRGGBB`, or `#RRGGBBAA` formats.
- *    - Characters must be `[0-9A-F]` (**case-insensitive**).
- *    - Returns `T` if valid, otherwise `never`.
- * @template T - A string to check.
- * @example
- * ```ts
- * type A = HEX<"#000">;      // ➔ "#000"
- * type B = HEX<"#g00">;      // ➔ never
- * type C = HEX<"#0000">;     // ➔ "#0000"
- * type D = HEX<"#00000">;    // ➔ never
- * type E = HEX<"#000000">;   // ➔ "#000000"
- * type F = HEX<"#00000000">; // ➔ "#00000000"
- * ```
- */
-type HEX<T extends string>=(Uppercase<T>extends`#${infer HEXWithoutHashTag extends string}`?StringLength<HEXWithoutHashTag>extends _AllowedHEXLength?ExtendsArr<Split<HEXWithoutHashTag,"">,_ValidHEXCharacters[number]>:false:false)extends true?T:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsHEX`.***
- * -------------------------------------------------------
- * **A type-level utility that checks if a string is a valid **HEX color**.**
- * - Returns `true` if valid, otherwise `false`.
- * @template T - A string to check.
- * @example
- * ```ts
- * type A = IsHEX<"#000">; // ➔ true
- * type B = IsHEX<"#g00">; // ➔ false
- * ```
- */
-type IsHEX<T extends string>=Not<IsNever<HEX<T>>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfHEX`.***
- * -------------------------------------------------------
- * **A conditional type that returns `IfTrue` if `T` is a valid **HEX color**,
- * otherwise returns `IfFalse`.**
- * @template T - A string to check.
- * @template IfTrue - Return type if valid (defaults to `true`).
- * @template IfFalse - Return type if invalid (defaults to `false`).
- * @example
- * ```ts
- * type A = IfHEX<"#000">;
- * // ➔ true
- * type B = IfHEX<"#g00">;
- * // ➔ false
- * type C = IfHEX<"#0000", "valid">;
- * // ➔ "valid"
- * type D = IfHEX<"#00000", "valid","invalid">;
- * // ➔ "invalid"
- * ```
- */
-type IfHEX<T extends string,IfTrue=true,IfFalse=false>=If<IsHEX<T>,IfTrue,IfFalse>;
-/** * ***Configuration options for a type-level utility
- * {@link HSL | `HSL` } | {@link IsHSL | `IsHSL` } | {@link IfHSL | `IfHSL` }.*** */
-type HSLOptions={
-/** * ***Separator character(s) used between the HSL components (`h`, `s`, `l`).***
- *
- * - **For example:**
- *    - `","` ➔ `"hsl(180,100%,50%)"`.
- *    - `", "` ➔ `"hsl(180, 100%, 50%)"`.
- *
- * @default ", "
- */
-separator:string;};
-/** * ***Default configuration for the {@link HSLOptions | `HSLOptions`}.***
- *
- * @example
- * ```ts
- * type Opt = DefaultHSLOptions;
- * // ➔ { separator: ", " }
- * ```
- */
-type DefaultHSLOptions={
-/** * ***Default separator for HSL components.***
- *
- * **Produces strings like `"hsl(180, 100%, 50%)"`.**
- */
-separator:", ";};
-/** -------------------------------------------------------
- * * ***Utility Type: `HSL`.***
- * -------------------------------------------------------
- * **A type-level utility that validates an **HSL color string**.**
- * - **Behavior:**
- *    - Accepts `hsl(h, s%, l%)` format with customizable separators.
- *    - `h` must be an integer, `s` and `l` must be integers between `0` and `100`.
- *    - Returns `T` if valid, otherwise `never`.
- * @template T - A string to check.
- * @template Options - Options with `separator` (defaults to `", "`).
- * @example
- * ```ts
- * type A = HSL<"hsl(100, 34%, 56%)">;
- * // ➔ "hsl(100, 34%, 56%)"
- * type B = HSL<"hsl(100, 200%, 3)">;
- * // ➔ never
- * type C = HSL<"hsl(100,34%,56%)", { separator: "," }>;
- * // ➔ "hsl(100,34%,56%)"
- * ```
- */
-type HSL<T extends string,Options extends HSLOptions=DefaultHSLOptions>=(T extends`hsl(${infer H extends number}${Options["separator"]}${infer S extends number}%${Options["separator"]}${infer L extends number}%)`?AndArr<[IsInteger<H>,IsInteger<S>,IsInteger<L>]>extends true?AndArr<[IsBetween<S,0,100>,IsBetween<L,0,100>]>:false:false)extends true?T:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsHSL`.***
- * -------------------------------------------------------
- * **A type-level utility that checks if a string is a valid **HSL color**.**
- * - Returns `true` if valid, otherwise `false`.
- * @template T - A string to check.
- * @template Options - Options with `separator` (defaults to `", "`).
- * @example
- * ```ts
- * type A = IsHSL<"hsl(100, 34%, 56%)">;
- * // ➔ true
- * type B = IsHSL<"hsl(101, 200%, 3)">;
- * // ➔ false
- * type C = IsHSL<"hsl(100,34%,56%)", { separator: "," }>;
- * // ➔ true
- * ```
- */
-type IsHSL<T extends string,Options extends HSLOptions=DefaultHSLOptions>=Not<IsNever<HSL<T,Options>>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfHSL`.***
- * -------------------------------------------------------
- * **A conditional type that returns `IfTrue` if `T` is a valid **HSL color**,
- * otherwise returns `IfFalse`.**
- * @template T - A string to check.
- * @template IfTrue - Return type if valid (defaults to `true`).
- * @template IfFalse - Return type if invalid (defaults to `false`).
- * @template Options - Options with `separator` (defaults to `", "`).
- * @example
- * ```ts
- * type A = IfHSL<"hsl(100, 34%, 56%)", "ok">;
- * // ➔ "ok"
- * type B = IfHSL<"hsl(101, 200%, 3)", "ok", "fail">;
- * // ➔ "fail"
- * type C = IfHSL<"hsl(100,34%,56%)", true, false, { separator: "," }>;
- * // ➔ true
- * ```
- */
-type IfHSL<T extends string,IfTrue=true,IfFalse=false,Options extends HSLOptions=DefaultHSLOptions>=If<IsHSL<T,Options>,IfTrue,IfFalse>;
-/** * ***High-level configuration for {@link Color | `Color`} parsing utilities.***
- *
- * **Allows customizing **RGB** and **HSL** parsing behavior independently.**
- */
-type ColorOptions={
-/** * ***Options for handling RGB color strings.***
- *
- * - **Behavior:**
- *    - Controls parsing and formatting behavior of RGB values.
- *    - By default uses {@link DefaultRGBOptions | **`DefaultRGBOptions`**}.
- * @default DefaultRGBOptions
- * @example
- * ```ts
- * type Opt = ColorOptions["rgbOptions"];
- * // ➔ { separator: string }
- *
- * // with defaults applied:
- * type Opt = DefaultRGBOptions;
- * // ➔ { separator: ", " }
- * ```
- */
-rgbOptions?:RGBOptions;
-/** * ***Options for handling HSL color strings.***
- *
- * - **Behavior:**
- *    - Controls parsing and formatting behavior of HSL values.
- *    - By default uses {@link DefaultHSLOptions | **`DefaultHSLOptions`**}.
- * @default DefaultHSLOptions
- * @example
- * ```ts
- * type Opt = ColorOptions["hslOptions"];
- * // ➔ { separator: string }
- *
- * // with defaults applied:
- * type Opt = DefaultHSLOptions;
- * // ➔ { separator: ", " }
- * ```
- */
-hslOptions?:HSLOptions;};
-/** * ***Default configuration for the {@link ColorOptions |`ColorOptions`}.***
- *
- * @example
- * ```ts
- * type Opt = DefaultColorOptions;
- * // ➔ { rgbOptions: { separator: ", " }, hslOptions: { separator: ", " } }
- * ```
- */
-type DefaultColorOptions={
-/** * ***Default configuration for `RGBOptions`.***
- *
- * - **Behavior:**
- *    - Provides the default separator for RGB strings.
- *    - By default: `", "`
- * @example
- * ```ts
- * type RGBOpt = DefaultColorOptions["rgbOptions"];
- * // ➔ { separator: ", " }
- * ```
- */
-rgbOptions:DefaultRGBOptions;
-/** * ***Default configuration for `HSLOptions`.***
- *
- * - **Behavior:**
- *    - Provides the default separator for HSL strings.
- *    - By default: `", "`
- * @example
- * ```ts
- * type HSLOpt = DefaultColorOptions["hslOptions"];
- * // ➔ { separator: ", " }
- * ```
- */
-hslOptions:DefaultHSLOptions;};type ResolveRGBOptions<O extends ColorOptions>=O["rgbOptions"] extends RGBOptions?O["rgbOptions"]:DefaultRGBOptions;type ResolveHSLOptions<O extends ColorOptions>=O["hslOptions"] extends HSLOptions?O["hslOptions"]:DefaultHSLOptions;
-/** -------------------------------------------------------
- * * ***Utility Type: `Color`.***
- * -------------------------------------------------------
- * - **A type-level utility that validates a string as a **Color** in:**
- *    - **`RGB`**.
- *    - **`HEX`**.
- *    - **`HSL`**.
- * @returns {T} Returns `T` if valid, otherwise `never`.
- * @template T - A string to check.
- * @template Options - Options to pass down to `RGB`/`HSL` validation.
- * @example
- * ```ts
- * type A = Color<"rgb(23, 242, 0)">;
- * // ➔ "rgb(23, 242, 0)"
- * type B = Color<"rgb(324, 123, 3)">;
- * // ➔ never
- * type C = Color<"#000000">;
- * // ➔ "#000000"
- * type D = Color<"hsl(100,34%,56%)", { hslOptions: { separator: "," }}>;
- * // ➔ "hsl(100,34%,56%)"
- * ```
- */
-type Color<T extends string,Options extends ColorOptions=DefaultColorOptions>=HEX<T>|HSL<T,ResolveHSLOptions<Options>>|RGB<T,ResolveRGBOptions<Options>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsColor`.***
- * -------------------------------------------------------
- * **A type-level utility that checks if a string is a valid **Color**
- * (`RGB` | `HEX` | `HSL`).**
- * @returns {T} - Returns `true` if valid, otherwise `false`.
- * @template T - A string to check.
- * @template Options - Options to pass down to RGB/HSL validation.
- * @example
- * ```ts
- * type A = IsColor<"rgb(23, 242, 0)">;
- * // ➔ true
- * type B = IsColor<"rgb(324, 123, 3)">;
- * // ➔ false
- * type C = IsColor<"#000000">;
- * // ➔ true
- * type D = IsColor<"hsl(100,34%,56%)", { hslOptions: { separator: "," } }>;
- * // ➔ true
- * ```
- */
-type IsColor<T extends string,Options extends ColorOptions=DefaultColorOptions>=Not<IsNever<Color<T,Options>>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfColor`.***
- * -------------------------------------------------------
- * **A conditional type that returns `IfTrue` if `T` is a valid **Color**
- * (`RGB` | `HEX` | `HSL`), otherwise returns `IfFalse`.**
- * @template T - A string to check.
- * @template IfTrue - Return type if valid (defaults to `true`).
- * @template IfFalse - Return type if invalid (defaults to `false`).
- * @template Options - Options to pass down to RGB/HSL validation.
- * @example
- * ```ts
- * type A = IfColor<"rgb(23, 242, 0)", { rgbOptions: { separator: ", " }}, "valid">;
- * // ➔ "valid"
- * type B = IfColor<"rgb(324, 123, 3)", DefaultColorOptions, "valid","invalid">;
- * // ➔ "invalid"
- * type C = IfColor<"#000000">;
- * // ➔ true
- * ```
- */
-type IfColor<T extends string,Options extends ColorOptions=DefaultColorOptions,IfTrue=true,IfFalse=false>=If<IsColor<T,Options>,IfTrue,IfFalse>;
-/** -------------------------------------------------------
- * * ***Utility Type: `Concat`.***
- * -------------------------------------------------------
- * **A type-level utility that concatenates `two arrays` into `one`.**
- * @template T - The first array type.
- * @template U - The second array type, or a single element.
- * @example
- * ```ts
- * type A = Concat<[number, number], [string, string]>;
- * // ➔ [number, number, string, string]
- * type B = Concat<[], [1, 2]>;
- * // ➔ [1, 2]
- * type C = Concat<[1, 2], 3>;
- * // ➔ [1, 2, 3]
- * type D = Concat<[], 5>;
- * // ➔ [5]
- * type E = Concat<[1, 2], []>;
- * // ➔ [1, 2]
- * ```
- */
-type Concat<T extends readonly unknown[],U>=[ ...T,...(U extends readonly unknown[]?U:[U])];
-/** -------------------------------------------------------
- * * ***Utility Type: `DigitsTuple`.***
- * -------------------------------------------------------
- * **A **type-level utility** that converts a numeric literal (number or bigint) into
- * a structured representation of its digits.**
- * - **The resulting type is an **object** with the following properties:**
- *    - `negative`: boolean flag indicating if the number is negative.
- *    - `bigint`: boolean flag indicating if the value is a bigint.
- *    - `float`: boolean flag indicating if the value is a floating-point number.
- *    - `digits`: a tuple of digits (each as a `number`), with decimal points and
- *      bigint suffix `n` removed.
- * - **Works with:**
- *    - Positive integers
- *    - Negative integers
- *    - Zero and negative zero
- *    - Floating-point numbers (decimal points are ignored)
- *    - BigInt values
- * **Note:** TypeScript automatically normalizes scientific notation numeric literals
- * (e.g., `5e3` ➔ `5000`), so the `digits` tuple will reflect the expanded value.
- * @template T - A numeric literal type (`number` or `bigint`) to convert.
- * @example
- * ```ts
- * // Single digit
- * type A = DigitsTuple<1>;
- * // ➔ { negative: false; bigint: false; float: false; digits: [1] }
- *
- * // Positive integer
- * type B = DigitsTuple<123>;
- * // ➔ { negative: false; bigint: false; float: false; digits: [1, 2, 3] }
- *
- * // Negative integer
- * type C = DigitsTuple<-123>;
- * // ➔ { negative: true; bigint: false; float: false; digits: [1, 2, 3] }
- *
- * // Zero and negative zero (treated the same)
- * type D = DigitsTuple<0>;
- * // ➔ { negative: false; bigint: false; float: false; digits: [0] }
- * type E = DigitsTuple<-0>;
- * // ➔ { negative: false; bigint: false; float: false; digits: [0] }
- *
- * // Floating-point numbers
- * type F = DigitsTuple<0.123>;
- * // ➔ { negative: false; bigint: false; float: true; digits: [0, 1, 2, 3] }
- * type G = DigitsTuple<-0.123>;
- * // ➔ { negative: true; bigint: false; float: true; digits: [0, 1, 2, 3] }
- *
- * // BigInt values
- * type H = DigitsTuple<98765n>;
- * // ➔ { negative: false; bigint: true; float: false; digits: [9, 8, 7, 6, 5] }
- * type I = DigitsTuple<-98765n>;
- * // ➔ { negative: true; bigint: true; float: false; digits: [9, 8, 7, 6, 5] }
- *
- * // Scientific notation numeric literals (auto-expanded)
- * type J = DigitsTuple<5e3>; // `5e3` is same like `5000`
- * // ➔ { negative: false; bigint: false; float: false; digits: [5, 0, 0, 0] }
- * type K = DigitsTuple<-2.5e2>; // `-2.5e2` is same like `-250`
- * // ➔ { negative: true; bigint: false; float: true; digits: [2, 5, 0] }
- * ```
- */
-type DigitsTuple<T extends number|bigint>={negative:`${T}`extends`-${string}`?true:false;float:IsFloat<Extract<T,number>>extends true?true:false;bigint:T extends bigint?true:false;digits:Split<ReplaceAll<Stringify<Abs<T>>,[".","n"],"">>extends infer R?{[K in keyof R]:R[K] extends string?ParseNumber<R[K]>:never;}:never;};
-/** -------------------------------------------------------
- * * ***Utility Type: `ReturnItselfIfExtends`.***
- * -------------------------------------------------------
- * **This utility is useful when you want to **narrow types by extension**,
- * replacing them with a fallback if they match a given base constraint,
- * while preserving them otherwise.**
- * - **A conditional type that returns:**
- *    - `Else` if `T` extends `Base`.
- *    - `T` itself if `T` does extend `Base`.
- *    - `IfANever` if `T` is `never`.
- * @template T - The type to check.
- * @template Base - The base type to test against.
- * @template Else - The type to return if `T` extends `Base`.
- * @template IfANever - The type to return if `T` or `Base` is `never` (default: `never`).
- * @example
- * ```ts
- * type Case1 = ReturnItselfIfExtends<1, number, 2>
- * // ➔ 1
- *
- * type Case2 = ReturnItselfIfExtends<'1', number, 2>
- * // ➔ 2
- *
- * // ℹ️ Never Case:
- * type Case3 = ReturnItselfIfExtends<never, string, 0>
- * // ➔ never
- *
- * type Case4 = ReturnItselfIfExtends<string, never, 0, undefined>
- * // ➔ undefined
- * ```
- */
-type ReturnItselfIfExtends<T,Base,Else,IfANever=never>=IfNever<If<Extends<Or<Base,T>,true>,never>,IfANever,T extends Base?T:Else>;
-/** -------------------------------------------------------
- * * ***Utility Type: `ReturnItselfIfNotExtends`.***
- * -------------------------------------------------------
- * **This utility is useful for preserving a type unless it matches
- * a broader constraint, in which case it is replaced with a fallback.**
- * - **A conditional type that returns:**
- *    - `Else` if `T` extends `Base`.
- *    - `T` itself if `T` does **not** extend `Base`.
- *    - `IfANever` if `T` is `never`.
- * @template T - The type to check.
- * @template Base - The base type to test against.
- * @template Else - The type to return if `T` extends `Base`.
- * @template IfANever - The type to return if `T` or `Base` is `never` (default: `never`).
- * @example
- * ```ts
- * type Case1 = ReturnItselfIfNotExtends<'1', number, 2>
- * // ➔ '1'
- * type Case2 = ReturnItselfIfNotExtends<1, number, 2>
- * // ➔ 2
- *
- * // ℹ️ Never Case:
- * type Case3 = ReturnItselfIfNotExtends<never, string, 0>;
- *  // ➔ never
- * type Case4 = ReturnItselfIfNotExtends<string, never, 0, undefined>;
- *  // ➔ undefined
- * ```
- */
-type ReturnItselfIfNotExtends<T,Base,Else,IfANever=never>=IfNever<If<Extends<Or<Base,T>,true>,never>,IfANever,T extends Base?Else:T>;type MultiplicationMap={0:[0,0,0,0,0,0,0,0,0,0];1:[0,1,2,3,4,5,6,7,8,9];2:[0,2,4,6,8,10,12,14,16,18];3:[0,3,6,9,12,15,18,21,24,27];4:[0,4,8,12,16,20,24,28,32,36];5:[0,5,10,15,20,25,30,35,40,45];6:[0,6,12,18,24,30,36,42,48,54];7:[0,7,14,21,28,35,42,49,56,63];8:[0,8,16,24,32,40,48,56,64,72];9:[0,9,18,27,36,45,54,63,72,81];};type _MultiSingle<Num1 extends string,DigitOfNum2 extends keyof MultiplicationMap,Carry extends number=0,Result extends string="">=IsEmptyString<Num1>extends true?ReturnItselfIfNotExtends<RemoveLeading<`${Carry}${Result}`,"0">,"","0">:IsEqual<Num1,0>extends true?"0":IsEqual<DigitOfNum2,0>extends true?"0":LastCharacter<Num1,{includeRest:true;}>extends [ infer Num1LastCharacter extends string,infer Num1Rest extends string]?Stringify<Sum<MultiplicationMap[DigitOfNum2][ParseNumber<Num1LastCharacter>& keyof MultiplicationMap[DigitOfNum2]],Carry>>extends infer Multiplied extends string?LastCharacter<Multiplied,{includeRest:true;}>extends [ infer MultipliedLastDigit extends string,infer MultipliedRest extends string]?_MultiSingle<Num1Rest,DigitOfNum2,If<IsNever<ParseNumber<MultipliedRest>>,0,ParseNumber<MultipliedRest>>,`${MultipliedLastDigit}${Result}`>:never:never:never;type _Multi<Num1 extends string,Num2 extends string,Result extends string="",Iteration extends unknown[]=[]>=IsEmptyString<Num2>extends true?Result:LastCharacter<Num2,{includeRest:true;}>extends [ infer Num2LastCharacter extends string,infer Num2Rest extends string]?ParseNumber<Num2LastCharacter>extends infer Num2Digit extends keyof MultiplicationMap?_Multi<Num1,Num2Rest,Stringify<_Sum<Result,ReturnItselfIfNotExtends<RemoveLeading<`${_MultiSingle<Num1, Num2Digit>}${Repeat<"0", Iteration["length"]>}`,"0">,"","0">>>,Push<Iteration,unknown>>:never:Result;
-/** -------------------------------------------------------
- * * ***Utility Type: `Multi`.***
- * -------------------------------------------------------
- * **Accepts two integers and returns their **multiplication**.**
- * - **Behavior:**
- *    - Handles negative numbers automatically.
- *    - Uses internal type-level recursion to simulate multiplication of
- *      digit strings.
- *    - Works with integers within the range:
- *      - `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - The first integer (can be negative).
- * @template Num2 - The second integer (can be negative).
- * @example
- * ```ts
- * type Case1 = Multi<10, 0>;   // ➔ 0
- * type Case2 = Multi<4, 6>;    // ➔ 24
- * type Case3 = Multi<-4, 6>;   // ➔ -24
- * type Case4 = Multi<-4, -6>;  // ➔ 24
- * type Case5 = Multi<123, 45>; // ➔ 5535
- * ```
- * @note
- * - ***Internal helpers:***
- *     - `_Multi` ➔ Recursively multiplies digit strings and accumulates the result.
- *     - `_MultiSingle` ➔ Multiplies a string-number with a single digit, handling carry.
- */
-type Multi<Num1 extends number,Num2 extends number>=IsEqual<Num1,0>extends true?0:IsEqual<Num2,0>extends true?0:ParseNumber<_Multi<Stringify<Abs<Num1>>,Stringify<Abs<Num2>>>>extends infer Result extends number?IfNegative<Num1,IfNegative<Num2,Result,Negate<Result>>,IfNegative<Num2,Negate<Result>,Result>>:never;type _FindQuotient<Dividend extends number,Divisor extends number,CurrentQuotient extends number>=Multi<Divisor,CurrentQuotient>extends infer Product extends number?IsEqual<Dividend,Product>extends true?CurrentQuotient:IsLowerThan<Dividend,Product>extends true?_FindQuotient<Dividend,Divisor,Decrement<CurrentQuotient>>:CurrentQuotient:never;type _Div<Dividend extends string,Divisor extends number,Result extends string="",CurrentDividend extends string="",IterationsWithoutDivision extends number=0,HadFirstDivision extends boolean=false>=Or<IsEmptyString<CurrentDividend>,IsLowerThan<ParseNumber<CurrentDividend>,Divisor>>extends true?IsEmptyString<Dividend>extends true?ParseNumber<If<And<HadFirstDivision,IsNotEqual<IterationsWithoutDivision,0>>,`${Result}0`,Result>>:Dividend extends`${infer FirstDigit extends string}${infer Rest extends string}`?_Div<Rest,Divisor,If<And<HadFirstDivision,IsNotEqual<IterationsWithoutDivision,0>>,`${Result}0`,Result>,IfEqual<CurrentDividend,"0",FirstDigit,`${CurrentDividend}${FirstDigit}`>,Increment<IterationsWithoutDivision>,HadFirstDivision>:never:_FindQuotient<ParseNumber<CurrentDividend>,Divisor,10>extends infer Quotient extends number?IsNever<Quotient>extends true?ParseNumber<Result>:Sub<ParseNumber<CurrentDividend>,Multi<Quotient,Divisor>>extends infer Remainder extends number?_Div<Dividend,Divisor,`${Result}${Quotient}`,IfGreaterThan<Remainder,0,`${Remainder}`,"">,0,true>:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Div`.***
- * -------------------------------------------------------
- * **A type-level utility that returns the integer division of two numbers.
- * Handles negative numbers correctly and returns `never` if dividing by zero.**
- * - **Behavior:**
- *    - Returns `0` if the absolute value of dividend is smaller than divisor.
- *    - Preserves the sign according to standard integer division rules.
- * @template Dividend - The dividend number.
- * @template Divisor - The divisor number.
- * @example
- * ```ts
- * type A = Div<10, 2>;  // ➔ 5
- * type B = Div<7, 3>;   // ➔ 2
- * type C = Div<-7, 3>;  // ➔ -2
- * type D = Div<7, -3>;  // ➔ -2
- * type E = Div<-7, -3>; // ➔ 2
- * type F = Div<2, 5>;   // ➔ 0
- * type G = Div<0, 5>;   // ➔ 0
- * type H = Div<5, 0>;   // ➔ never
- * ```
- */
-type Div<Dividend extends number,Divisor extends number>=IsEqual<Divisor,0>extends true?never:IsEqual<Dividend,0>extends true?0:IsEqual<Dividend,Divisor>extends true?1:IsLowerThan<Abs<Dividend>,Abs<Divisor>>extends true?0:_Div<Stringify<Abs<Dividend>>,Abs<Divisor>>extends infer Quotient extends number?If<Or<And<IsNegative<Dividend>,IsNegative<Divisor>>,And<IsPositive<Dividend>,IsPositive<Divisor>>>,Quotient,Negate<Quotient>>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Dot`.***
- * -------------------------------------------------------
- * **A type-level utility that concatenates two string literals with a `.`.**
- * - **Behavior:**
- *    - If the `Trims` flag is `true` (default), leading and trailing spaces in
- *      both strings are trimmed before concatenation.
- *    - If the second string literal is empty, it returns the first string literal.
- *    - If the first string literal is empty, it returns the second string literal.
- *    - Otherwise, it returns `${T}.${U}` (trimmed if `Trims` is `true`).
- * @template T - The first string literal.
- * @template U - The second string literal.
- * @template Trims - Whether to trim whitespace from the inputs before concatenation (default: `true`).
- * @example
- * ```ts
- * type A = Dot<"foo", "bar">;
- * // ➔ "foo.bar"
- * type B = Dot<"foo", "">;
- * // ➔ "foo"
- * type C = Dot<"", "baz">;
- * // ➔ "baz"
- * type D = Dot<"  hello  ", " world ", true>;
- * // ➔ "hello.world"
- * type E = Dot<"  hello  ", " world ", false>;
- * // ➔ "  hello  . world "
- * ```
- */
-type Dot<T extends string,U extends string,Trims extends boolean=true>=Extends<Trims,true>extends true?""extends Trim<U>?Trim<T>:""extends Trim<T>?`${Trim<U>}`:`${Trim<T>}.${Trim<U>}`:""extends U?T:`${T}.${U}`;
-/** -------------------------------------------------------
- * * ***Utility Type: `DotArray`.***
- * -------------------------------------------------------
- * **A type-level utility that concatenates an array of string literals with a `.`.**
- * - **Behavior:**
- *    - Skips empty strings in the array.
- *    - If `Trims` is `true` (default), trims whitespace from each element.
- *    - Returns a single string literal.
- * @template Arr - An array of string literals.
- * @template Trims - Whether to trim whitespace from each element (default: `true`).
- * @example
- * ```ts
- * type A = DotArray<["foo", "bar", "baz"]>;
- * // ➔ "foo.bar.baz"
- * type B = DotArray<["foo", "", "baz"]>;
- * // ➔ "foo.baz"
- * type C = DotArray<["  foo  ", " bar "], true>;
- * // ➔ "foo.bar"
- * type D = DotArray<["  foo  ", " bar "], false>;
- * // ➔ "  foo  . bar "
- * type E = DotArray<[]>;
- * // ➔ ""
- * ```
- */
-type DotArray<Arr extends string[],Trims extends boolean=true>=Arr extends [ infer Head extends string,...infer Tail extends string[]]?Head extends""?DotArray<Tail,Trims>:`${Trims extends true ? Trim<Head> : Head}${Tail extends [] ? "" : `.${DotArray<Tail,Trims>}`}`:"";
-/** -------------------------------------------------------
- * * ***Utility Type: `EndsWith`.***
- * -------------------------------------------------------
- * **A type-level utility that returns a boolean indicating
- * whether the first string literal ends with the ***second one***.**
- * @template T - The string to check.
- * @template C - The ***ending string*** to match.
- * @example
- * ```ts
- * type A = EndsWith<"Hello", "lo">;    // ➔ true
- * type B = EndsWith<"Foobar", "bar">;  // ➔ true
- * type C = EndsWith<"Foobar", "foo">;  // ➔ false
- * type D = EndsWith<"Hello", "world">; // ➔ false
- * ```
- */
-type EndsWith<T extends string,C extends string>=T extends`${infer _}${C}`?true:false;
-/** --------------------------------------------------
- * * ***Utility Type: `ExcludeStrict`.***
- * --------------------------------------------------
- * **Performs a stricter version of `Exclude<T, U>` with improved type narrowing.**
- * - ✅ Especially useful in generic libraries or utility types
- *    where standard `Exclude` may collapse or widen types unintentionally.
- * @template T - The full union or set of types.
- * @template U - The type(s) to be excluded from `T`.
- * @example
- * ```ts
- * type A = 'a' | 'b' | 'c';
- * type B = ExcludeStrict<A, 'b'>;
- * // ➔ 'a' | 'c'
- * ```
- */
-type ExcludeStrict<T,U extends T>=T extends unknown?0 extends(U extends T?([T] extends [U]?0:never):never)?never:T:never;type _Factorial<T extends number,CurrentNum extends number=1,CurrentProduct extends number=1>=IsEqual<T,CurrentNum>extends true?Multi<CurrentProduct,CurrentNum>:_Factorial<T,Increment<CurrentNum>,Multi<CurrentProduct,CurrentNum>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `Factorial`.***
- * -------------------------------------------------------
- * **Accepts an integer argument and returns its ***mathematical factorial***.**
- * - **Behavior:**
- *    - Valid range: `[0, 21]`.
- *    - Negative numbers or `number` type result in `never`.
- * @template T - The integer to compute factorial for.
- * @example
- * ```ts
- * type A = Factorial<0>;
- * // ➔ 1
- * type B = Factorial<6>;
- * // ➔ 720
- * type C = Factorial<-5>;
- * // ➔ never
- * type D = Factorial<number>;
- * // ➔ never
- * ```
- */
-type Factorial<T extends number>=number extends T?never:IsNegative<T>extends true?never:IsEqual<T,0>extends true?1:_Factorial<T>;
-/** -------------------------------------------------------
- * * ***Utility Type: `Fibonacci`.***
- * -------------------------------------------------------
- * **A type-level utility that computes the ***Fibonacci number*** at a given
- * index `T`.**
- * - **Behavior:**
- *    - Returns `never` for negative numbers.
- *    - Supports indices in the range `[0, 78]` due to TypeScript recursion limits.
- * @template T - The index of the Fibonacci sequence.
- * @example
- * ```ts
- * type A = Fibonacci<0>;  // ➔ 0
- * type B = Fibonacci<1>;  // ➔ 1
- * type C = Fibonacci<4>;  // ➔ 3
- * type D = Fibonacci<10>; // ➔ 55
- * type E = Fibonacci<40>; // ➔ 102334155
- * type D = Fibonacci<number>; // ➔ never
- * ```
- */
-type Fibonacci<T extends number>=IsNegative<T>extends true?never:IsLowerThan<T,2>extends true?T:Fibonacci<Decrement<T>>extends infer NMinusOne extends number?Fibonacci<Sub<T,2>>extends infer NMinusTwo extends number?Sum<NMinusOne,NMinusTwo>:never:never;
-/** ---------------------------------------------------------------------------
- * * ***Type Options for {@link FirstCharacter | `FirstCharacter`}.***
- * ---------------------------------------------------------------------------
- * **Configuration options for the {@link FirstCharacter | `FirstCharacter`} type-level utility.**
- */
-type FirstCharacterOptions={
-/** * ***Whether to include the rest of the string in the result tuple.***
- *
- * - **Behavior:**
- *    - `true` ➔ returns `[first character, rest of string]`.
- *    - `false` ➔ returns only the first character.
- * @default false
- * @example
- * ```ts
- * type Opt = { includeRest: true };
- * type R = FirstCharacter<"abc", Opt>; // ➔ ["a", "bc"]
- * ```
- */
-includeRest:boolean;};
-/** -------------------------------------------------------
- * * ***Utility Type: `FirstCharacter`.***
- * -------------------------------------------------------
- * **Accepts a string literal and returns its first character.**
- * - **Behavior:**
- *    - If `Options["includeRest"]` is `true`, it returns a
- *      tuple: `[first character, rest of string]`.
- *    - Otherwise, it returns only the first character.
- * @template T - The string literal to process.
- * @template Options - Configuration options (default: `{ includeRest: false }`).
- *   - `includeRest: boolean` — Whether to include the rest of the string in a tuple.
- * @example
- * ```ts
- * type A = FirstCharacter<"abc">;
- * // ➔ "a"
- * type B = FirstCharacter<"abc", { includeRest: true }>;
- * // ➔ ["a", "bc"]
- * type C = FirstCharacter<"">;
- * // ➔ never
- * type D = FirstCharacter<string>;
- * // ➔ never
- * ```
- */
-type FirstCharacter<T extends string,Options extends FirstCharacterOptions={includeRest:false;}>=T extends`${infer First extends string}${infer Rest extends string}`?If<Options["includeRest"],[First,Rest],First>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `FirstDigit`.***
- * -------------------------------------------------------
- * **Extracts the **first digit** of a given number `T`.**
- * - **Behavior:**
- *    - Works with integers and decimals.
- *    - Handles negative numbers (`-123` ➔ `-1`).
- *    - Handles `0` and `-0` correctly (always returns `0`).
- *    - Works with bigint literals too.
- * @template T - A number or bigint to extract the first digit from.
- * @template Options - Optional settings.
- * - `alwaysPositive?: boolean` (default: `false`)
- *   If `true`, the result is always positive regardless of the sign.
- * @example
- * ```ts
- * type A = FirstDigit<0>;      // ➔ 0
- * type B = FirstDigit<-0>;     // ➔ 0
- * type C = FirstDigit<123>;    // ➔ 1
- * type D = FirstDigit<-123>;   // ➔ -1
- * type E = FirstDigit<0.123>;  // ➔ 0
- * type F = FirstDigit<-0.123>; // ➔ 0
- * type G = FirstDigit<98765>;  // ➔ 9
- * type H = FirstDigit<-98765>; // ➔ -9
- * type I = FirstDigit<-98765, {alwaysPositive:true}>; // ➔ 9
- * ```
- */
-type FirstDigit<T extends number|bigint,Options extends{
-/**
- * If `true`, the result is always positive regardless of the sign, defaultValue: `false`.
- * @example
- * type I = FirstDigit<-98765, {alwaysPositive:true}>;
- * // ➔ 9
- *
- * @default false
- */
-alwaysPositive?:boolean;}={alwaysPositive:false;}>=DigitsTuple<T>["digits"] extends readonly [infer First extends number,...unknown[]]?Options["alwaysPositive"] extends true?First:DigitsTuple<T>["negative"] extends true?Negate<First>:First:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Floor`.***
- * -------------------------------------------------------
- * **Type-level equivalent of `Math.floor()`.**
- * - Returns the ***floored value*** of the passed number.
- * @template T - A number type.
- * @example
- * ```ts
- * type A = Floor<1.9>;  // ➔ 1
- * type B = Floor<-1.2>; // ➔ -2
- * type C = Floor<3>;    // ➔ 3
- * type D = Floor<-5>;   // ➔ -5
- * ```
- */
-type Floor<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extends [infer Whole extends number,unknown]?IsNegative<T>extends true?Negate<Increment<Whole>>:Whole:never:T;
-/** --------------------------------------------------
- * * ***Utility Type: `Identity`.***
- * --------------------------------------------------
- * **Identity utility type that preserves the structure and inference of type `T`.**
- * - ✅ Commonly used to force TypeScript to expand a mapped or intersection type
- *    into a more readable and usable shape.
- * @template T - The type to preserve and normalize.
- * @example
- * ```ts
- * type A = { a: string; b: number };
- * type B = Identity<A>;
- * // ➔ { a: string; b: number }
- * ```
- */
-type Identity<T>={[P in keyof T]:T[P];};
-/** ---------------------------------------------------------------------------
- * * ***Type Options for {@link Shift | `Shift`}.***
- * ---------------------------------------------------------------------------
- */
-type ShiftOptions={
-/**
- * If `true`, return both the rest of the array and the removed element
- * as a tuple `[Rest, Removed]`.
- *
- * Default is `false`.
- *
- * @default false
- */
-includeRemoved:boolean;};
-/** -------------------------------------------------------
- * * ***Utility Type: `Shift`.***
- * -------------------------------------------------------
- * **Removes the first element from the array type `T`.**
- * - **Behavior:**
- *    - By default (`includeRemoved: false`), returns the array without the first element.
- *    - If `includeRemoved: true`, returns a tuple `[Rest, Removed]`:
- *      - `Rest`: the remaining array.
- *      - `Removed`: the removed first element.
- * @template T - The array type to operate on.
- * @template Options - Optional flags. Default `{ includeRemoved: false }`.
- * @example
- * ```ts
- * // Default: just remove first element
- * type Case1 = Shift<[1, 2, 3]>;
- * // ➔ [2, 3]
- *
- * // Include removed element
- * type Case2 = Shift<[1, 2, 3], { includeRemoved: true }>;
- * // ➔ [[2, 3], 1]
- *
- * // Empty array
- * type Case3 = Shift<[]>;
- * // ➔ never
- * ```
- */
-type Shift<T extends readonly unknown[],Options extends ShiftOptions={includeRemoved:false;}>=T extends readonly [infer Removed,...infer Rest extends readonly unknown[]]?If<Options["includeRemoved"],[Rest,Removed],Rest>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Includes`.***
- * -------------------------------------------------------
- * **Returns a boolean whether the second argument is in the first array argument.**
- * @template T - The array to check.
- * @template Pivot - The value to look for.
- * @example
- * ```ts
- * type Case1 = Includes<[1, 2, 3], 1>; // ➔ true
- * type Case2 = Includes<[1, 2, 3], 4>; // ➔ false
- * ```
- */
-type Includes<T extends readonly unknown[],Pivot>=IsEmptyArray<T>extends true?false:Shift<T,{includeRemoved:true;}>extends [ infer Rest extends readonly unknown[],infer Removed]?IfEqual<Pivot,Removed,true,Includes<Rest,Pivot>>:false;type _IndexOfArray<T extends readonly unknown[],Pivot,Index extends number=0>=T extends readonly [infer First,...infer Rest extends unknown[]]?IsEqual<First,Pivot>extends true?Index:_IndexOfArray<Rest,Pivot,Increment<Index>>:-1;type _IndexOfString<T extends string,Pivot,Index extends number=0>=T extends`${infer First}${infer Rest extends string}`?IsEqual<First,Pivot>extends true?Index:_IndexOfString<Rest,Pivot,Increment<Index>>:-1;
-/** -------------------------------------------------------
- * * ***Utility Type: `IndexOf`.***
- * --------------------------------------------------------
- * **Type version of `Array.prototype.indexOf()` and `String.prototype.indexOf()`.**
- * - Returns the index of the second argument in the first argument.
- * @example
- * ```ts
- * type Case1 = IndexOf<[1, 2, 3], 2>; // ➔ 1
- * type Case2 = IndexOf<[1, 2, 3], 4>; // ➔ -1
- * type Case3 = IndexOf<'123', '2'>;   // ➔ 1
- * type Case4 = IndexOf<'123', '4'>;   // ➔ -1
- * ```
- */
-type IndexOf<T extends readonly unknown[]|string,Pivot extends T extends string?string:unknown>=T extends string?IsStringLiteral<T>extends true?_IndexOfString<T,Pivot>:never:T extends readonly unknown[]?IsTuple<T>extends true?_IndexOfArray<T,Pivot>:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsArrayIndex`.***
- * -------------------------------------------------------
- * **Returns a boolean whether the passed argument is a valid array index.**
- * @example
- * ```ts
- * type Case1 = IsArrayIndex<1>;   // ➔ true
- * type Case2 = IsArrayIndex<'1'>; // ➔ true
- * type Case3 = IsArrayIndex<-1>;  // ➔ false
- * type Case4 = IsArrayIndex<"a">; // ➔ false
- * ```
- */
-type IsArrayIndex<T>=T extends number?And<IsInteger<T>,IsGreaterOrEqual<T,0>>:T extends string?ParseNumber<T>extends infer NumT extends number?Not<IsNever<NumT>>extends true?And<IsInteger<NumT>,IsGreaterOrEqual<NumT,0>>:false:false:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `Mod`.***
- * -------------------------------------------------------
- * **Returns the **remainder** of the division of two numbers (`Dividend % Divisor`).**
- * - **Behavior:**
- *    - Computes the remainder using type-level arithmetic:
- *      - `Dividend - (Divisor * (Dividend / Divisor))`.
- *    - Works with integers within the range:
- *      - `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Dividend - The dividend (numerator).
- * @template Divisor - The divisor (denominator).
- * @example
- * ```ts
- * type T0 = Mod<1, 2>;  // ➔ 1
- * type T1 = Mod<1, 3>;  // ➔ 1
- * type T2 = Mod<10, 3>; // ➔ 1
- * type T3 = Mod<7, 7>;  // ➔ 0
- * ```
- */
-type Mod<Dividend extends number,Divisor extends number>=Div<Dividend,Divisor>extends infer Quotient extends number?Multi<Quotient,Divisor>extends infer Product extends number?Sub<Dividend,Product>:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsDivisibleByTwo`.***
- * -------------------------------------------------------
- * **Accepts an integer argument and returns a boolean whether it is divisible by two.**
- *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @example
- * // truthy
- * type Case1 = IsDivisibleByTwo<4>;  // ➔ true
- * type Case2 = IsDivisibleByTwo<-6>; // ➔ true
- *
- * // falsy
- * type Case3 = IsDivisibleByTwo<3>;  // ➔ false
- * type Case4 = IsDivisibleByTwo<-5>; // ➔ false
- */
-type IsDivisibleByTwo<T extends number>=IsEven<T>;type DivisibleByThreeMap={3:true;6:true;9:true;};type _IsDivisibleByThree<T extends number>=DigitsTuple<Abs<T>>["digits"] extends infer Digits extends readonly number[]?IsEqual<Digits["length"],1>extends true?Digits[0] extends keyof DivisibleByThreeMap?true:false:SumArr<Digits>extends infer DigitsSum extends number?IfLowerThan<DigitsSum,3>extends true?false:_IsDivisibleByThree<DigitsSum>:never:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsDivisibleByThree`.***
- * -------------------------------------------------------
- * **Accepts an integer argument and returns a boolean whether it is divisible by three.**
- *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @example
- * // truthy
- * type Case1 = IsDivisibleByThree<123>;  // ➔ true
- * type Case2 = IsDivisibleByThree<-126>; // ➔ true
- *
- * // falsy
- * type Case3 = IsDivisibleByThree<124>;  // ➔ false
- * type Case4 = IsDivisibleByThree<-128>; // ➔ false
- */
-type IsDivisibleByThree<T extends number>=_IsDivisibleByThree<T>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsDivisibleByFive`.***
- * -------------------------------------------------------
- * **Accepts an integer argument and returns a boolean whether it is divisible by five.**
- *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @example
- * // truthy
- * type Case1 = IsDivisibleByFive<125>;  // ➔ true
- * type Case2 = IsDivisibleByFive<-115>; // ➔ true
- *
- * // falsy
- * type Case3 = IsDivisibleByFive<13>;  // ➔ false
- * type Case4 = IsDivisibleByFive<-17>; // ➔ false
- */
-type IsDivisibleByFive<T extends number>=EndsWith<Stringify<T>,"0"|"5">;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsDivisibleBySix`.***
- * -------------------------------------------------------
- * **Accepts an integer argument and returns a boolean whether it is divisible by six.**
- *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @example
- * // truthy
- * type Case1 = IsDivisibleBySix<126>;  // ➔ true
- * type Case2 = IsDivisibleBySix<-156>; // ➔ true
- *
- * // falsy
- * type Case3 = IsDivisibleBySix<124>;  // ➔ false
- * type Case4 = IsDivisibleBySix<-139>; // ➔ false
- */
-type IsDivisibleBySix<T extends number>=And<IsDivisibleByTwo<T>,IsDivisibleByThree<T>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsDivisibleByTen`.***
- * -------------------------------------------------------
- * **Accepts an integer argument and returns a boolean whether it is divisible by ten.**
- *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @example
- * // truthy
- * type Case1 = IsDivisibleByTen<100>; // ➔ true
- * type Case2 = IsDivisibleByTen<-80>; // ➔ true
- *
- * // falsy
- * type Case3 = IsDivisibleByTen<101>; // ➔ false
- * type Case4 = IsDivisibleByTen<-72>; // ➔ false
- */
-type IsDivisibleByTen<T extends number>=EndsWith<Stringify<T>,"0">;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsDivisibleByHundred`.***
- * -------------------------------------------------------
- * **Accepts an integer argument and returns a boolean whether it is divisible by hundred.**
- *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @example
- * // truthy
- * type Case1 = IsDivisibleByHundred<100>;  // ➔ true
- * type Case2 = IsDivisibleByHundred<-300>; // ➔ true
- *
- * // falsy
- * type Case3 = IsDivisibleByHundred<101>;  // ➔ false
- * type Case4 = IsDivisibleByHundred<-210>; // ➔ false
- */
-type IsDivisibleByHundred<T extends number>=EndsWith<Stringify<T>,"00">;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsDivisible`.***
- * -------------------------------------------------------
- * **Returns a boolean whether the first integer argument is divisible by the
- * second integer argument.**
- * @example
- * // truthy
- * type Case1 = IsDivisible<1024, 2>; // ➔ true
- * type Case2 = IsDivisible<2034, 3>; // ➔ true
- *
- * // falsy
- * type Case3 = IsDivisible<1023, 2>; // ➔ false
- * type Case4 = IsDivisible<3034, 3>; // ➔ false
- */
-type IsDivisible<Dividend extends number,Divisor extends number>=IsEqual<Mod<Dividend,Divisor>,0>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsLetter`.***
- * -------------------------------------------------------
- * **Returns a boolean whether the passed argument is a letter (Only for letters that have both upper and lower case).**
- * @template T - The string to check.
- * @example
- * type Case1 = IsLetter<'a'>; // ➔ true
- * type Case2 = IsLetter<'1'>; // ➔ false
- */
-type IsLetter<T extends string>=Uppercase<T>extends Lowercase<T>?false:true;type _IsUnion<T,U=T>=IsNever<T>extends true?false:T extends U?Not<IsNever<Exclude<U,T>>>:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsUnion`.***
- * -------------------------------------------------------
- * **Returns a boolean whether the passed argument is a union.**
- * @template T - The type to check.
- * @example
- * type Case1 = IsUnion<'a' | 'b'>;
- * // ➔ true
- * type Case2 = IsUnion<'a'>;
- * // ➔ false
- */
-type IsUnion<T>=_IsUnion<T,T>;
-/** -------------------------------------------------------
- * * ***Utility Type: `Join`.***
- * -------------------------------------------------------
- * **Type version of `Array.prototype.join()`.**
- * - Joins the first array argument by the second argument.
- * @template T - The array to join.
- * @template Glue - The string or number to join with, defaultValue: `""`.
- * @example
- * type Case0 = Join<["p", "e", "a", "r"]>;
- * // ➔ 'pear'
- * type Case1 = Join<["a", "p", "p", "l", "e"], "-">;
- * // ➔ 'a-p-p-l-e'
- * type Case2 = Join<["2", "2", "2"], 1>;
- * // ➔ '21212'
- * type Case3 = Join<["o"], "u">;
- * // ➔ 'o'
- * type Case3 = Join<[], "n">;
- * // ➔ never
- */
-type Join<T extends readonly(string|number)[],Glue extends string|number="">=IsTuple<T>extends true?T extends readonly [ infer First extends string|number,...infer Rest extends readonly(string|number)[]]?IfEmptyArray<Rest,First,`${First}${Glue}${Join<Rest, Glue>}`>:never:never;
-/** --------------------------------------------------
- * * ***Utility Type: `AnyRecord`.***
- * --------------------------------------------------
- * **Represents an object with arbitrary string keys and values of **any** type.**
- * - ⚠️ **Use with caution — `any`** disables type safety.
- *    - Prefer stricter like {@link UnknownRecord | **`UnknownRecord`**} typing when possible.
- * - ✅ Commonly used as a fallback for flexible key-value structures
- *    such as query parameters, configuration maps, or JSON-like data.
- * @example
- * ```ts
- * const config: AnyRecord = {
- *   mode: "dark",
- *   retries: 3,
- *   debug: true,
- * };
- * ```
- */
-type AnyRecord=Record<string,any>;
-/** --------------------------------------------------
- * * ***Utility Type: `UnknownRecord`.***
- * --------------------------------------------------
- * **Represents an object with arbitrary string keys and values of **unknown** type.**
- * - ✅ Safer alternative to `AnyRecord` — forces explicit type narrowing
- *   before values can be used, maintaining type safety.
- * - ✅ Suitable for working with untyped external data sources
- *   (e.g., JSON APIs, parsed configs) where values must be validated first.
- * @example
- * ```ts
- * const data: UnknownRecord = JSON.parse("{}");
- *
- * // Must narrow the type before usage
- * if (typeof data.id === "string") {
- *   console.log(data.id.toUpperCase());
- * }
- *
- * // Or:
- * const unknownObject: UnknownRecord = {
- *   mode: "dark",
- *   retries: 3,
- *   debug: true,
- * };
- * ```
- */
-type UnknownRecord=Record<string,unknown>;
-/** -------------------------------------------------------
- * * ***Utility Type: `AnyStringRecord`.***
- * -------------------------------------------------------
- * **Same as **{@link AnyString | **`AnyString`**}** but uses `Record<never, never>` as the intersection.**
- * - This approach is often more reliable in preserving literal types
- *   in generic inference scenarios.
- * @example
- * ```ts
- * declare function acceptsAnyStringRecord<T extends AnyStringRecord>(value: T): T;
- *
- * const a = acceptsAnyStringRecord("hello");
- * // ➔ "hello"
- *
- * const b = acceptsAnyStringRecord(String("world"));
- * // ➔ string
- * ```
- */
-type AnyStringRecord=Record<never,never>& string;
-/** -------------------------------------------------------
- * * ***Utility Type: `LooseLiteral`.***
- * -------------------------------------------------------
- * **Improves the autocompletion and inference of **loose literal types**.**
- * @description
- * Ensures that specified literal types are preserved while still
- * allowing assignment of a broader base type.
- * - **Useful in scenarios where:**
- *    - You want to accept **specific literal values** but still allow
- *      any value of a base type (like `string` or `number`).
- *    - You want stricter typing in generics while preserving literals.
- * @template Literal - The literal type(s) to preserve.
- * @template BaseType - The base type to extend when not matching literal.
- * @example
- * ```ts
- * type T0 = LooseLiteral<"a" | "b" | "c", string>;
- * // ➔ "a" | "b" | "c" | (string & {})
- *
- * declare function acceptsLoose<T extends LooseLiteral<"x" | "y", string>>(value: T): T;
- * const a = acceptsLoose("x");
- * // ➔ "x"
- * const b = acceptsLoose("any string");
- * // ➔ string
- * ```
- */
-type LooseLiteral<Literal,BaseType>=Literal|(BaseType & AnyStringRecord);
-/** -------------------------------------------------------
- * * ***Utility Type: `Max`.***
- * -------------------------------------------------------
- * **Accepts two integers and returns the **maximum** among them.**
- *  - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - First integer to compare.
- * @template Num2 - Second integer to compare.
- * @example
- * ```ts
- * type Case1 = Max<1, 10>;  // ➔ 10
- * type Case2 = Max<1, -10>; // ➔ 1
- * ```
- */
-type Max<Num1 extends number,Num2 extends number>=IfLowerThan<Num1,Num2,Num2,Num1>;
-/** * ***Recursively computes the maximum number in a tuple of integers.***
- *
- * @private ***Private internal type for {@link MaxArr | **`MaxArr`**}.***
- * @template T - Tuple of numbers to process.
- * @template CurrentMax - Current maximum value, defaults to the first element of T.
- */
-type _MaxArr<T extends readonly number[],CurrentMax extends number=ReturnItselfIfNotExtends<T[0],undefined,never>>=IsEmptyArray<T>extends true?CurrentMax:Shift<T,{includeRemoved:true;}>extends [ infer Rest extends number[],infer First extends number]?_MaxArr<Rest,Max<First,CurrentMax>>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `MaxArr`.***
- * -------------------------------------------------------
- * **Accepts a tuple of integers and returns the **maximum** among its elements.**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template T - Tuple of numbers to evaluate.
- * - Only tuples are supported; arrays of unknown length will return `never`.
- * @example
- * ```ts
- * type Case1 = MaxArr<[1, 2, 4, 10]>; // ➔ 10
- * type Case2 = MaxArr<[-1, 4, -10]>;  // ➔ 4
- * type Case3 = MaxArr<number[]>;      // ➔ never (not a tuple)
- * ```
- */
-type MaxArr<T extends readonly number[]>=IsTuple<T>extends true?_MaxArr<T>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `DeepMergeArrayUnion`.***
- * -------------------------------------------------------
- * **Recursively merges element types of nested arrays inside an array type,
- * **preserving the nested array structure**.**
- * - Converts an array of nested arrays into a union of its element types,
- *   while keeping the nested arrays intact.
- * @template T - The outer array type.
- * @returns The nested array type with merged element types.
- * @example
- * ```ts
- * const test = [
- *   ["a", null],
- *   ["b", [undefined, "c"]],
- * ];
- *
- * type Merged = DeepMergeArrayUnion<typeof test>;
- * // ➔ ((string | null | (string | undefined)[])[])[]
- * ```
- */
-type DeepMergeArrayUnion<T extends any[]>=T extends(infer U)[]?U extends any[]?DeepMergeArrayUnionHelper<U>[]:U[]:never;type DeepMergeArrayUnionHelper<T>=T extends(infer U)[]?DeepMergeArrayUnionHelper<U>|Exclude<T,any[]>:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `Min`.***
- * -------------------------------------------------------
- * **Accepts two integers and returns the **minimum** among them.**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template Num1 - First integer.
- * @template Num2 - Second integer.
- * @example
- * ```ts
- * type Case1 = Min<1, 10>;  // ➔ 1
- * type Case2 = Min<1, -10>; // ➔ -10
- * ```
- */
-type Min<Num1 extends number,Num2 extends number>=IfLowerThan<Num1,Num2,Num1,Num2>;
-/** * ***Helper type for computing the minimum of a tuple of numbers recursively.***
- *
- * @private ***Private internal type for {@link MinArr | **`MinArr`**}.***
- * @template T - Array of numbers
- * @template CurrentMin - Current minimum in recursion
- */
-type _MinArr<T extends readonly number[],CurrentMin extends number=ReturnItselfIfNotExtends<T[0],undefined,never>>=IsEmptyArray<T>extends true?CurrentMin:Shift<T,{includeRemoved:true;}>extends [ infer Rest extends number[],infer First extends number]?_MinArr<Rest,Min<First,CurrentMin>>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `MinArr`.***
- * -------------------------------------------------------
- * **Accepts an array of integers and returns the **minimum** among its elements.**
- * - Range: `[Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]`.
- * @template T - Tuple of numbers.
- * @example
- * ```ts
- * type Case1 = MinArr<[1, 2, 4, 10]>; // ➔ 1
- * type Case2 = MinArr<[-1, 4, -10]>;  // ➔ -10
- * ```
- */
-type MinArr<T extends readonly number[]>=IsTuple<T>extends true?_MinArr<T>:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `NonNullableObject`.***
- * -------------------------------------------------------
- * **Makes all properties of the object type `T` non-nullable.**
- * @template T - Object type to transform.
- * @example
- * ```ts
- * type A = NonNullableObject<{ a: string | null; b: number | undefined }>;
- * // ➔ { a: string; b: number }
- * ```
- */
-type NonNullableObject<T>={[K in keyof T]:NonNullable<T[K]>;};
-/** -------------------------------------------------------
- * * ***Utility Type: `NonNullableObjectOnly`.***
- * -------------------------------------------------------
- * **Makes only the specified properties `K` of the object type `T` non-nullable.**
- * @template T - Object type to transform.
- * @template K - Keys of `T` to make non-nullable.
- * @example
- * ```ts
- * type A = NonNullableObjectOnly<
- *   { a: string | null; b: number | undefined; c: boolean | null },
- *   "a" | "b"
- * >;
- * // ➔ { a: string; b: number; c: boolean | null }
- * ```
- */
-type NonNullableObjectOnly<T,K extends keyof T>=Prettify<Pick<T,Exclude<keyof T,K>>&{[P in K]:NonNullable<T[P]>;}>;
-/** -------------------------------------------------------
- * * ***Utility Type: `NonNullableObjectExcept`.***
- * -------------------------------------------------------
- * **Makes all properties of the object type `T` non-nullable except for the specified properties `K`.**
- * @template T - Object type to transform.
- * @template K - Keys of `T` to leave unchanged.
- * @example
- * ```ts
- * type A = NonNullableObjectExcept<
- *   { a: string | null; b: number | undefined; c: boolean | null },
- *   "c"
- * >;
- * // ➔ { a: string; b: number; c: boolean | null }
- * ```
- */
-type NonNullableObjectExcept<T,K extends keyof T>=Prettify<Pick<T,K>&{[P in Exclude<keyof T,K>]:NonNullable<T[P]>;}>;
-/** --------------------------------------------------
- * * ***Internal Utility Type for: {@link NumberRangeLimit | `NumberRangeLimit`}.***
- * --------------------------------------------------
- * @template From - Starting number of the range (inclusive).
- * @template To - Ending number of the range (inclusive).
- * @template Result - Internal accumulator for recursion (do not set manually).
- */
-type _NumberRangeLimit<From extends number,To extends number,Result extends number[]=[From]>=IsGreaterThan<From,To>extends true?[...Result,To][number] extends infer R extends number?R extends R?IsGreaterThan<R,To>extends true?never:R:never:never:_NumberRangeLimit<Sum<From,7>,To,[ ...Result,From,Sum<From,1>,Sum<From,2>,Sum<From,3>,Sum<From,4>,Sum<From,5>,Sum<From,6>]>;
-/** --------------------------------------------------
- * * ***Utility Type: `NumberRangeLimit`.***
- * --------------------------------------------------
- * **Generate a union type of numbers within a specified range (optimized recursive batching).**
- * @description
- * Produces a **numeric union type** from `From` to `To` (inclusive),
- * using ***batched recursive expansion*** (**adds up to `7` numbers at a time**).
- *
- * This batching allows generating **larger ranges** (`≥ 101`) efficiently without
- * hitting TypeScript’s recursion limits too quickly.
- * - ✅ Optimized for **performance** (fewer recursive steps).
- * - ⚠️ Supports up to `To = 999` safely.
- * - ⚙️ Best used for **larger ranges** (`≥ 101`) or when you need **arbitrary ranges** within `0–999`.
- * - ℹ️ For **smaller ranges** (`≤ 100`) or when readability matters use {@link NumberRangeUnion | **`NumberRangeUnion`**} instead.
- * @template From - Starting number of the range (inclusive).
- * @template To - Ending number of the range (inclusive).
- * @example
- * ```ts
- * type RangeA = NumberRangeLimit<5, 8>;
- * // ➔ 5 | 6 | 7 | 8
- * type RangeB = NumberRangeLimit<10, 15>;
- * // ➔ 10 | 11 | 12 | 13 | 14 | 15
- * type RangeC = NumberRangeLimit<8, 8>;
- * // ➔ 8
- * type RangeD = NumberRangeLimit<20, 10>;
- * // ➔ 10
- * ```
- */
-type NumberRangeLimit<From extends number,To extends number>=_NumberRangeLimit<From,To>;type _IsPalindrome<T extends string>=IsEmptyString<T>extends true?true:Not<IsStringLiteral<T>>extends true?false:T extends`${infer First extends string}${infer Rest extends string}`?IsEmptyString<Rest>extends true?true:Rest extends`${infer NewRest extends string}${First}`?_IsPalindrome<NewRest>:false:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IsPalindrome`.***
- * -------------------------------------------------------
- * **Determines if a string or number is a **palindrome** at type-level.
- * A palindrome reads the same forwards and backwards (e.g., `"racecar"`).**
- * @template T - A string or number to check.
- * @example
- * ```ts
- * type T0 = IsPalindrome<"racecar">; // true
- * type T1 = IsPalindrome<"hello">;   // false
- * type T2 = IsPalindrome<12321>;     // true
- * type T3 = IsPalindrome<12345>;     // false
- * ```
- * @remarks
- * - Converts numbers to strings using {@link Stringify | **`Stringify`**}.
- * - Uses {@link IsEmptyString | **`IsEmptyString`**},
- *   {@link IsStringLiteral | **`IsStringLiteral`**},
- *   and {@link Not | **`Not`**} for type-level logic.
- * - Returns `true` if the input is a palindrome, otherwise `false`.
- */
-type IsPalindrome<T extends string|number>=_IsPalindrome<Stringify<T>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `UnionToIntersection`.***
- * -------------------------------------------------------
- * **Converts a union type into an **intersection**.**
- * @description
- * 📖 Reference: ***[`StackOverflow`](https://stackoverflow.com/questions/50374908/transform-union-type-to-intersection-type/50375286#50375286).***
- * @template U - The union type to be converted.
- * @example
- * ```ts
- * type A = UnionToIntersection<{ a: string } | { b: number }>;
- * // ➔ { a: string } & { b: number }
- * type B = UnionToIntersection<
- *   { a: string } | { b: number } | { c: boolean }
- * >;
- * // ➔ { a: string } & { b: number } & { c: boolean }
- * ```
- */
-type UnionToIntersection<U>=(U extends any?(k:U)=>void:never)extends(k:infer I)=>void?I:never;
-/** -------------------------------------------------------
- * * ***Utility Type: `PrettifyUnionIntersection`.***
- * -------------------------------------------------------
- * **Converts a union type into an **intersection** using ***{@link UnionToIntersection | `UnionToIntersection`}***, and then
- * applies ***{@link Prettify | `Prettify`}*** to simplify the resulting intersection
- * for better readability in IntelliSense and tooltips.**
- * @description
- * Useful when the raw intersection of union types produces
- * deeply nested or hard-to-read structures.
- * @template T - The union type to be converted.
- * @template Options - Optional formatting options for `Prettify`.
- * @example
- * ```ts
- * // Basic union ➔ intersection
- * type A = { a: string } | { b: number };
- * type B = PrettifyUnionIntersection<A>;
- * // ➔ { a: string } & { b: number }
- * // final result become ➔ { a: string b: number }
- *
- * // Larger union
- * type C = { a: string } | { b: number } | { c: boolean };
- * type D = PrettifyUnionIntersection<C>;
- * // ➔ { a: string } & { b: number } & { c: boolean }
- * // final result become ➔ { a: string b: number c: boolean }
- *
- * // With PrettifyOptions (custom formatting)
- * type E = PrettifyUnionIntersection<A, { recursive: true }>;
- * ```
- */
-type PrettifyUnionIntersection<T,Options extends PrettifyOptions=DefaultPrettifyOptions>=Prettify<UnionToIntersection<T>,Options>;
-/** Internal Helper */
-
-/** Get optional keys of an object */
-type OptionalKeys<T>={[P in keyof T]-?:{}extends Pick<T,P>?P:never;}[keyof T];
-/** Get required keys of an object */
-type RequiredKeys<T>=Exclude<keyof T,OptionalKeys<T>>;
-/** Remove duplicate `undefined` from unions */
-type CleanOptional$1<T>=[T] extends [undefined]?undefined:undefined extends T?Exclude<T,undefined>|undefined:T;
-/** Required keys only (no optional ones) */
-type RequiredKeysOf<U>=Exclude<keyof U,OptionalKeys<U>>;
-/** Force re-evaluation / cleaner display */
-
-/** -------------------------------------------------------
- * * ***Utility Type: `PartialOnly`.***
- * -------------------------------------------------------
- * **Make only the specified properties in `T` **optional**, while keeping all
- * other properties required.**
- * @template T - The object type to transform.
- * @template K - Keys of `T` that should become optional.
- * @example
- * ```ts
- * // Only "a" is optional, "b" and "c" remain required
- * type T0 = PartialOnly<{ a: string; b: number; c: boolean }, "a">;
- * // ➔ { a?: string; b: number; c: boolean }
- *
- * // Both "a" and "b" are optional
- * type T1 = PartialOnly<{ a: string; b: number; c: boolean }, "a" | "b">;
- * // ➔ { a?: string; b?: number; c: boolean }
- *
- * // Only "a" is optional (since "x" is not a valid key of T)
- * type T2 = PartialOnly<{ a: string; b: number; c: boolean }, "a" | "x">;
- * // ➔ { a?: string; b: number; c: boolean }
- * ```
- * - ℹ️ ***If key is never or not in object, all properties remain required:***
- *
- * ```ts
- * type Skip1 = PartialOnly<{ a: string; b: number; c: boolean }, "x">;
- * // ➔ { a: string; b: number; c: boolean }
- *
- * type Skip2 = PartialOnly<{ a: string; b: number; c: boolean }, never>;
- * // ➔ { a: string; b: number; c: boolean }
- * ```
- */
-type PartialOnly<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?T:PrettifyUnionIntersection<{[P in Exclude<RequiredKeys<T>,Extract<keyof T,K>>]-?:T[P];}&{[P in Exclude<OptionalKeys<T>,Extract<keyof T,K>>]+?:CleanOptional$1<T[P]>;}&{[P in Extract<keyof T,K>]+?:CleanOptional$1<T[P]>;}>;
-/** -------------------------------------------------------
- * * ***Utility Type: `PartialExcept`.***
- * -------------------------------------------------------
- * **Make all properties in `T` **optional**, except for the ones specified
- * in `K`, which remain as-is.**
- * - **Behavior:**
- *    - If a property in `K` is originally required ➔ it stays required.
- *    - If a property in `K` is originally optional ➔ it stays optional.
- *    - All other properties become optional.
- *    - Duplicate `undefined` types are cleaned up automatically.
- * @template T - The object type to transform.
- * @template K - Keys of `T` that should remain as-is (not forced optional).
- * @example
- * ```ts
- * // "a" remains required, "b" and "c" become optional
- * type T0 = PartialExcept<{ a: string; b: number; c: boolean }, "a">;
- * // ➔ { a: string; b?: number; c?: boolean }
- *
- * // "a" and "b" remain required, "c" becomes optional
- * type T1 = PartialExcept<{ a: string; b: number; c: boolean }, "a" | "b">;
- * // ➔ { a: string; b: number; c?: boolean }
- *
- * // "b" is originally optional, so it stays optional,
- * // "a" stays required, "c" becomes optional
- * type T2 = PartialExcept<{ a: string; b?: number; c: boolean }, "a" | "b">;
- * // ➔ { a: string; b?: number; c?: boolean }
- *
- * // none of the keys match ➔ everything optional
- * type T3 = PartialExcept<{ a: string; b: number; c: boolean }, "x">;
- * // ➔ { a?: string; b?: number; c?: boolean }
- * ```
- * - ℹ️ ***If key is never, all properties become optional:***
- * ```ts
- * type Skip = PartialExcept<{ a: string; b: number; c: boolean }, never>;
- * // ➔ { a?: string; b?: number; c?: boolean }
- * ```
- */
-type PartialExcept<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?Partial<T>:PrettifyUnionIntersection<Identity<{[P in RequiredKeysOf<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>>]-?:CleanOptional$1<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>[P]>;}&{[P in OptionalKeys<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>>]+?:CleanOptional$1<Identity<Pick<T,Extract<keyof T,K>>&{[P in Exclude<keyof T,K>]?:T[P];}>[P]>;}>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `ValueOf`.***
- * -------------------------------------------------------
- * **Gets the types of all property values in an object `T`.**
- * @template T - The object type.
- * @example
- * ```ts
- * type Case1 = ValueOf<{ a: string, b: number }>;
- * // ➔ string | number
- * ```
- */
-type ValueOf<T>=T[keyof T];
-/** -------------------------------------------------------
- * * ***Utility Type: `ValueOfOnly`.***
- * -------------------------------------------------------
- * **Gets the types of properties in object `T` specified by `K`.**
- * @template T - The object type.
- * @template K - Keys of `T` to extract values from.
- * @example
- * ```ts
- * type Case1 = ValueOfOnly<{ a: string, b: number }, "a">;
- * // ➔ string
- * ```
- */
-type ValueOfOnly<T,K extends keyof T>=T[K];
-/** -------------------------------------------------------
- * * ***Utility Type: `ValueOfExcept`.***
- * -------------------------------------------------------
- * **Gets the types of properties in object `T` **except** for keys in `K`.**
- * @template T - The object type.
- * @template K - Keys of `T` to exclude.
- * @example
- * ```ts
- * type Case1 = ValueOfExcept<{ a: string, b: number }, "a">;
- * // ➔ number
- * ```
- */
-type ValueOfExcept<T,K extends keyof T>=T[keyof Omit<T,K>];
-/** -------------------------------------------------------
- * * ***Utility Type: `ValueOfArray`.***
- * -------------------------------------------------------
- * **Gets the types of elements in a tuple or array `T`.**
- * @template T - The tuple or array type.
- * @example
- * ```ts
- * type Case1 = ValueOfArray<[string, number]>;
- * // ➔ string | number
- * ```
- */
-type ValueOfArray<T extends readonly unknown[]>=T[number];
-/** -------------------------------------------------------
- * * ***Utility Type: `OverWritable`.***
- * -------------------------------------------------------
- * **Option type to signal that some properties can be overwritten when
- * applying default options.**
- * @property overwriteDefault - If true, all options in the passed `Options`
- *   object will **overwrite** defaults, even if rules say otherwise.
- */
-type OverWritable={
-/** If true, all options in the passed `Options` object will **overwrite** defaults, even if rules say otherwise, defaultValue: `false`.
- *
- * @default false
- */
-overwriteDefault?:boolean;};
-/** -------------------------------------------------------
- * * ***Utility Type: `ApplyDefaultOptions`.***
- * -------------------------------------------------------
- * **Type-level utility that merges a user-specified `Options` object
- * with a `DefaultOptions` object using a set of `OverwriteRules`.**
- * @template BaseOptions - The base type of all options.
- * @template Options - User-specified options that may override defaults.
- * @template DefaultOptions - Default values for options.
- * @template OverwriteRules - A mapping that indicates which keys
- *   should always allow overwriting defaults.
- * @template OverwriteDefault - If true, all options in `Options`
- *   overwrite defaults regardless of rules.
- * @remarks
- * - Recursively applies defaults for nested objects.
- * - Only objects that are non-nullable and non-unknown are recursively merged.
- * - If a property is **not an object** or recursion is not needed,
- *   it either takes the value from `Options` or merges `Options[K] | DefaultOptions[K]`.
- * - Helps safely build strongly typed configuration objects with defaults.
- * @example
- * ```ts
- * type Base = {
- *   a: { x: number; y: string };
- *   b: boolean;
- * };
- *
- * type Defaults = {
- *   a: { x: 1; y: "default" };
- *   b: true;
- * };
- *
- * type UserOptions = {
- *   a: { y: "custom" };
- * };
- *
- * type Result = ApplyDefaultOptions<Base, UserOptions, Defaults, { a: true; b: false }>;
- * // Result: {
- * //   a: { x: 1; y: "custom"; tra: "test" };
- * //   b: boolean;
- * // }
- * ```
- */
-type ApplyDefaultOptions<BaseOptions,Options extends BaseOptions,DefaultOptions extends BaseOptions,OverwriteRules,OverwriteDefault extends boolean=false>=Prettify<{[K in keyof BaseOptions]-?:K extends keyof Options?AndArr<[ Extends<NonNullable<BaseOptions[K]>,object>,Not<IsNever<DefaultOptions[K]>>,Not<IsUnknown<BaseOptions[K]>>]>extends true?ApplyDefaultOptions<NonNullable<BaseOptions[K]>,Extract<Options[K],NonNullable<BaseOptions[K]>>,Extract<DefaultOptions[K],NonNullable<BaseOptions[K]>>,OverwriteRules[K & keyof OverwriteRules],OverwriteDefault>&{tra:"test";}:Or<IsEqual<OverwriteDefault,true>,And<Extends<K,keyof OverwriteRules>,Extends<OverwriteRules[K & keyof OverwriteRules],true>>>extends true?Options[K]:Options[K]|DefaultOptions[K]:DefaultOptions[K];}>;
-/** --------------------------------------------------------------
- * * ***Options for {@link PathToFields | **`PathToFields`**} type-level utility.***
- * --------------------------------------------------------------
- * @template ignoredTypes - Types to ignore completely.
- * @template stopTypes - Types at which recursion stops and returns `[]`.
- * @template limit - Max recursion depth.
- * @template format - Output format, `"dot"` or `"array"`.
- * @template ignoredKeys - Keys to ignore when generating paths.
- * @template arrayIndexing - Options for handling array paths.
- */
-type PathToFieldsOptions=Prettify<OverWritable &{
-/** Types to ignored completely (default: `undefined`).
- *
- * @default undefined
- */
-ignoredTypes?:unknown;
-/** Types at which recursion stops (default: `undefined`).
- *
- * @default undefined
- */
-stopTypes?:unknown;
-/** Max recursion depth (default: `10`).
- *
- * @default 10
- */
-limit?:number;
-/** Format Output Options:
- * - `"dot"` ➔ dot-notation strings, default output (`"a.b.c"`).
- * - `"array"` ➔ array of path segments (`["a", "b", "c"]`).
- *
- * @default "dot"
- */
-format?:"dot"|"array";
-/** Keys to skip when generating paths (default: `undefined`).
- *
- * @default undefined
- */
-ignoredKeys?:PropertyKey;
-/** Options for array Indexing (default: `{ exactIndexes: false }`).
- *
- * When `arrayIndexing.exactIndexes = true` ➔ outputs exact tuple indexes (`"arr.0"`), otherwise generic `"arr.${number}"`.
- * @default undefined
- */
-arrayIndexing?:{
-/** Options for array Exact Indexing (default: `false`).
- *
- * When `exactIndexes = true` ➔ outputs exact tuple indexes (`"arr.0"`), otherwise generic `"arr.${number}"`.
- * - For increase limit indexing, you can set `limit` options, default
- *   limit is: `10`.
- * @default false
- */
-exactIndexes:boolean;};},{recursive:true;}>;
-/** * ***Default options for {@link PathToFields}.*** */
-type DefaultPathToFieldsOptions={ignoredTypes:never;stopTypes:string|number|boolean|symbol|Date|AnyFunction;format:"dot";limit:10;ignoredKeys:never;arrayIndexing:{exactIndexes:false;};};type OverwriteRules={limit:true;format:true;arrayIndexing:{exactIndexes:true;};};type Booleanize<T>=T extends true?true:false;type _PathToFieldsArray<T extends readonly unknown[],Options extends PathToFieldsOptions,Iteration extends number=0>=And<IsTuple<T>,IsEqual<Booleanize<Options["arrayIndexing"] extends{exactIndexes:infer E;}?E:false>,true>>extends true?ValueOfArray<{[K in keyof T]:IsArrayIndex<K>extends true?[K,..._PathToFields<T[K],Options,Increment<Iteration>>]:never;}>:ArrayElementType<T>extends infer ElementType?[`${number}`,...(ElementType extends ElementType?_PathToFields<ElementType,Options,Increment<Iteration>>:never)]:never;type _PathToFields<T,Options extends PathToFieldsOptions,Iteration extends number=0>=T extends Options["ignoredTypes"]?never:T extends Options["stopTypes"]?[]:IsEqual<Iteration,Options["limit"]>extends true?never:T extends readonly unknown[]?_PathToFieldsArray<T,Options,Iteration>:ValueOf<{[K in Exclude<keyof T,symbol|Options["ignoredKeys"]>]:NonNullable<T[K]>extends infer NonNullableFields?NonNullableFields extends readonly unknown[]?[K,..._PathToFieldsArray<NonNullableFields,Options,Iteration>]:[K,..._PathToFields<NonNullableFields,Options,Increment<Iteration>>]:never;}>;
-/** -------------------------------------------------------
- * * ***Utility Type: `PathToFields`.***
- * -------------------------------------------------------
- * **Generates **all possible property paths** within a type `T`.
- * Supports nested objects, arrays, tuples, and optional configuration.**
- * @template T - Object type to extract paths from.
- * @template Options - Optional configuration.
- * @example
- * ```ts
- * // Nested object
- * type T1 = PathToFields<{ a: { b: { c: number } } }>;
- * // Result: "a.b.c"
- *
- * // Array of objects (dot notation, default)
- * type T2 = PathToFields<{ arr: { id: string; value: number }[] }>;
- * // Result: "arr.${number}.id" | "arr.${number}.value"
- *
- * // Output format as array of path segments
- * type T4 = PathToFields<
- *   { user: { profile: { name: string } } },
- *   { format: "array" }
- * >;
- * // Result: ["user", "profile", "name"]
- *
- * // Ignoring specific keys
- * type T5 = PathToFields<
- *   { id: string; password: string; profile: { bio: string } },
- *   { ignoredKeys: "password" }
- * >;
- * // Result: "id" | "profile.bio"
- *
- * // Stopping recursion at specific types
- * type T6 = PathToFields<
- *   { settings: Date; nested: { inner: number } },
- *   { stopTypes: Date }
- * >;
- * // Result: "settings" | "nested.inner"
- * ```
- * @remarks
- * - `Options.format = "dot"` ➔ dot-notation strings, default output (`"a.b.c"`).
- * - `Options.format = "array"` ➔ array of path segments (`["a", "b", "c"]`).
- * - `Options.limit` ➔ max recursion depth (default 10).
- * - `Options.stopTypes` ➔ types at which recursion stops.
- * - `Options.ignoredTypes` ➔ types ignored completely.
- * - `Options.ignoredKeys` ➔ keys to skip when generating paths.
- * - `Options.arrayIndexing.exactIndexes = true` ➔ outputs exact tuple indexes (`"arr.0"`), otherwise generic `"arr.${number}"`.
- */
-type PathToFields<T,Options extends PathToFieldsOptions=never>=(IsNever<Options>extends true?DefaultPathToFieldsOptions:ApplyDefaultOptions<Omit<PathToFieldsOptions,keyof OverWritable>,Options,DefaultPathToFieldsOptions,OverwriteRules,PathToFieldsOptions["overwriteDefault"] extends boolean?PathToFieldsOptions["overwriteDefault"]:false>)extends infer MergedOptions extends PathToFieldsOptions?_PathToFields<T,MergedOptions>extends infer Paths extends readonly(string|number)[]?IsEqual<MergedOptions["format"],"dot">extends true?Paths extends Paths?Join<Paths,".">:never:Paths:never:never;type _Pow<Num extends number,Factor extends number,CurrentProduct extends number=1,Iteration extends unknown[]=[]>=IsEqual<Iteration["length"],Factor>extends true?CurrentProduct:_Pow<Num,Factor,Multi<CurrentProduct,Num>,Push<Iteration,unknown>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `Pow`.***
- * -------------------------------------------------------
- * **Returns a type-level **exponentiation** result:**
- *   - Raises the first integer parameter (`Num`) to the power of the second
- *     integer parameter (`Factor`).
- * @template Num - The base number (integer).
- * @template Factor - The exponent number (integer, >= 0).
- * @example
- * ```ts
- * type Case1 = Pow<10, 2>
- * // ➔ 100
- * type Case2 = Pow<5, 0>
- * // ➔ 1
- * type Case3 = Pow<2, 3>
- * // ➔ 8
- * ```
- */
-type Pow<Num extends number,Factor extends number>=_Pow<Num,Factor>;
-/** -------------------------------------------------------
- * * ***Utility Type: `ReadonlyOnly`.***
- * -------------------------------------------------------
- * **Makes the specified keys `K` of an object type `T` readonly,
- * while leaving the other properties mutable.**
- * @template T - The object type.
- * @template K - Keys of `T` to make readonly.
- * @example
- * ```ts
- * type T0 = ReadonlyOnly<{ a: string; b: number }, 'a'>;
- * // ➔ { readonly a: string; b: number }
- *
- * type T1 = ReadonlyOnly<{ x: boolean; y: number; z: string }, 'y' | 'z'>;
- * // ➔ { x: boolean; readonly y: number; readonly z: string }
- * ```
- */
-type ReadonlyOnly<T extends object,K extends keyof T>=Prettify<Pick<T,Exclude<keyof T,K>>&{readonly [P in K]:T[P];}>;
-/** -------------------------------------------------------
- * * ***Utility Type: `ReadonlyExcept`.***
- * -------------------------------------------------------
- * **Makes all properties of an object type `T` readonly,
- * except for the specified keys `K` which remain mutable.**
- * @template T - The object type.
- * @template K - Keys of `T` to remain mutable.
- * @example
- * ```ts
- * type T0 = ReadonlyExcept<{ a: string; b: number }, 'a'>;
- * // ➔ { a: string; readonly b: number }
- *
- * type T1 = ReadonlyExcept<{ x: boolean; y: number; z: string }, 'x' | 'z'>;
- * // ➔ { x: boolean; readonly y: number; z: string }
- * ```
- */
-type ReadonlyExcept<T extends object,K extends keyof T>=Prettify<Pick<T,K>&{readonly [P in Exclude<keyof T,K>]:T[P];}>;
-/** -------------------------------------------------------
- * * ***Utility Type: `RemoveIndexSignature`.***
- * -------------------------------------------------------
- * **Removes **index signatures** (e.g., `[key: string]: any`) from an object
- * type `T`, leaving only explicitly declared properties.**
- * @template T - The object type to process.
- * @example
- * ```ts
- * type Case1 = RemoveIndexSignature<{ [key: string]: number | string; a: string }>;
- * // ➔ { a: string }
- *
- * type Case2 = RemoveIndexSignature<{ x: number; y: boolean }>;
- * // ➔ { x: number; y: boolean }
- *
- * type Case3 = RemoveIndexSignature<{ [key: string]: number }>;
- * // ➔ {}  // all keys were index signatures
- * ```
- */
-type RemoveIndexSignature<T>={[Key in keyof T as Key extends`${infer _}`?Key:never]:T[Key];};
-/** -------------------------------------------------------
- * * ***Utility Type: `Replace`.***
- * -------------------------------------------------------
- * **Replaces the **first occurrence** of a substring (`Pivot`)
- * inside a string (`T`) with another substring (`ReplaceBy`).**
- * @template T - The source string.
- * @template Pivot - The substring to replace.
- * @template ReplaceBy - The substring that replaces `Pivot`.
- * @example
- * ```ts
- * type Case1 = Replace<'remove me me', 'me', 'him'>;
- * // ➔ 'remove him me'
- * type Case2 = Replace<'remove me me', 'us', 'him'>;
- * // ➔ 'remove me me'
- * type Case3 = Replace<'aaaa', 'a', 'b'>;
- * // ➔ 'baaa'
- * type Case4 = Replace<'hello', 'x', 'y'>;
- * // ➔ 'hello' (no match found)
- * ```
- */
-type Replace<T extends string,Pivot extends string,ReplaceBy extends string>=T extends`${infer A}${Pivot}${infer B}`?`${A}${ReplaceBy}${B}`:T;
-/** --------------------------------------------------
- * * ***Utility Type: `ReplaceToPartial`.***
- * --------------------------------------------------
- * **Replaces specified keys in a type with a new value type, making them optional.**
- * - ✅ Useful when certain properties in a type should allow partial overrides
- *   while keeping the rest of the structure intact.
- * @template TypeToBeChecked - The original object type.
- * @template KeyToBeReplaced - The keys in the original type to be replaced.
- * @template NewValueToUse - The new type to assign to the replaced keys.
- * @example
- * ```ts
- * type A = { name: string; age: number };
- * type B = ReplaceToPartial<A, 'age', string>;
- * // ➔ { name: string; age?: string }
- * ```
- */
-type ReplaceToPartial<TypeToBeChecked,KeyToBeReplaced extends keyof TypeToBeChecked,NewValueToUse>=Identity<Pick<TypeToBeChecked,Exclude<keyof TypeToBeChecked,KeyToBeReplaced>>&{[P in KeyToBeReplaced]?:NewValueToUse;}>;
-/** --------------------------------------------------
- * * ***Utility Type: `ReplaceToRequired`.***
- * --------------------------------------------------
- * **Replaces specified keys in a type with a new value type, making them required.**
- * - ✅ Useful when redefining a property’s type while ensuring it's required.
- * @template TypeToBeChecked - The original object type.
- * @template KeyToBeReplaced - The keys in the original type to be replaced.
- * @template NewValueToUse - The new type to assign to the replaced keys.
- * @example
- * ```ts
- * type A = { name?: string | string[]; age: number };
- * type B = ReplaceToRequired<A, 'name', string>;
- * // ➔ { name: string; age: number }
- * ```
- */
-type ReplaceToRequired<TypeToBeChecked,KeyToBeReplaced extends keyof TypeToBeChecked,NewValueToUse>=Identity<Pick<TypeToBeChecked,Exclude<keyof TypeToBeChecked,KeyToBeReplaced>>&{[P in KeyToBeReplaced]:NewValueToUse;}>;
-/** Internal Helper */
-
-/** Remove duplicate `undefined` from a type */
-type CleanOptional<T>=[T] extends [undefined]?undefined:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `RequiredOnly`.***
- * -------------------------------------------------------
- * **Make only the specified properties in `T` **required**, while keeping the rest unchanged (remain optional if optional).**
- * @template T - The object type to transform.
- * @template K - Keys of `T` that should become required.
- * @example
- * ```ts
- * // Only "a" is required, "b" and "c" remain optional
- * type T0 = RequiredOnly<{ a?: number; b?: string; c?: boolean }, "a">;
- * // ➔ { a: number; b?: string; c?: boolean }
- *
- * // Both "a" and "b" are required
- * type T1 = RequiredOnly<{ a?: number; b?: string; c?: boolean }, "a" | "b">;
- * // ➔ { a: number; b: string; c?: boolean }
- *
- * // Only "a" is required (since "x" is not a valid key of T)
- * type T2 = RequiredOnly<{ a?: number; b?: string; c?: boolean }, "a" | "x">;
- * // ➔ { a: number; b?: string; c?: boolean }
- * ```
- * - ℹ️ ***If key is never or not in object, all properties remain unchanged:***
- * ```ts
- * type Skip1 = RequiredOnly<{ a?: number; b?: string; c?: boolean }, "x">;
- * // ➔ { a?: number; b?: string; c?: boolean }
- *
- * type Skip2 = RequiredOnly<{ a?: number; b?: string; c?: boolean }, never>;
- * // ➔ { a?: number; b?: string; c?: boolean }
- * ```
- */
-type RequiredOnly<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?T:PrettifyUnionIntersection<{[P in Exclude<keyof T,K>]?:CleanOptional<T[P]>;}&{[P in Extract<keyof T,K>]-?:NonUndefined<CleanOptional<T[P]>>;}>;
-/** -------------------------------------------------------
- * * ***Utility Type: `RequiredExcept`.***
- * -------------------------------------------------------
- * **Make **all properties** in `T` required, except the specified keys which remain optional.**
- * @template T - The object type to transform.
- * @template K - Keys of `T` that should remain optional.
- * @example
- * ```ts
- * // All required except "a"
- * type T0 = RequiredExcept<{ a?: number; b?: string; c?: boolean }, "a">;
- * // ➔ { a?: number; b: string; c: boolean }
- *
- * // All required except "a" and "b"
- * type T1 = RequiredExcept<{ a?: number; b?: string; c?: boolean }, "a" | "b">;
- * // ➔ { a?: number; b?: string; c: boolean }
- *
- * // Only "a" remains optional (since "x" is not a valid key of T)
- * type T2 = RequiredExcept<{ a?: number; b?: string; c?: boolean }, "a" | "x">;
- * // ➔ { a?: number; b: string; c: boolean }
- * ```
- *
- * - ℹ️ ***If key is never or not in object, all properties become required:***
- * ```ts
- * type Skip1 = RequiredExcept<{ a?: number; b?: string; c?: boolean }, "x">;
- * // ➔ { a: number; b: string; c: boolean }
- *
- * type Skip2 = RequiredExcept<{ a?: number; b?: string; c?: boolean }, never>;
- * // ➔ { a: number; b: string; c: boolean }
- * ```
- */
-type RequiredExcept<T extends object,K extends keyof T|AnyString>=IsNever<K>extends true?Required<T>:PrettifyUnionIntersection<{[P in Exclude<keyof T,K>]-?:NonUndefined<CleanOptional<T[P]>>;}&{[P in Extract<keyof T,K>]?:CleanOptional<T[P]>;}>;type _Reverse<T extends readonly unknown[],Result extends readonly unknown[]=[]>=T extends readonly [infer First,...infer Rest]?_Reverse<Rest,[First,...Result]>:Result;type FilterByType$1<T extends readonly unknown[],U>=T extends readonly [ infer Head,...infer Tail]?Head extends U?[Head,...FilterByType$1<Tail,U>]:FilterByType$1<Tail,U>:[];type Grouped<T extends readonly unknown[]>=[ ...FilterByType$1<T,number>,...FilterByType$1<T,string>,...FilterByType$1<T,boolean>,...FilterByType$1<T,Exclude<T[number],number|string|boolean>>];type MaybeReadonly<T extends readonly unknown[],R extends readonly unknown[]>=IsTuple<T>extends true?(IsReadonlyArray<T>extends true?Readonly<R>:R):R;
-/** -------------------------------------------------------
- * * ***Utility Type: `Reverse`.***
- * -------------------------------------------------------
- * **Returns a new tuple or readonly array type with the elements in reverse order.**
- * - **Behavior:**
- *    1. **Tuple**: The reversed result preserves tuple properties,
- *       including `readonly` if applicable.
- *         - Elements are **grouped in this order before reversing**:
- *       `number`, `string`, `boolean`, then any other types.
- *    2. **Normal array (non-tuple)**: The type is returned as-is (no reversal).
- * - ℹ️ **Notes:**
- *    - Supports arbitrary types in the tuple, including objects, Date, symbol, etc.
- *    - Grouping ensures that numbers, strings, and booleans are reversed in logical
- *      groups, while other types remain at the end in their original order before
- *      reverse.
- * @template T - The array or tuple type to reverse.
- * @example
- * ```ts
- * // Mutable tuple of numbers
- * type T0 = Reverse<[1, 2, 3]>;
- * // Grouped: [1,2,3] (numbers first)
- * // Reversed: [3, 2, 1]
- *
- * // Readonly tuple of numbers
- * type T1 = Reverse<readonly [1, 2, 3]>;
- * // Grouped: [1,2,3]
- * // Reversed: readonly [3, 2, 1]
- *
- * // Tuple of strings
- * type T2 = Reverse<["a", "b", "c"]>;
- * // Grouped: ["a","b","c"]
- * // Reversed: ["c","b","a"]
- *
- * // Readonly tuple of strings
- * type T3 = Reverse<readonly ["x", "y", "z"]>;
- * // Grouped: ["x","y","z"]
- * // Reversed: readonly ["z","y","x"]
- *
- * // Tuple of mixed types (numbers, strings, booleans)
- * type T4 = Reverse<[1, "a", true, 2, "b", false]>;
- * // Grouped: [1,2,"a","b",true,false]
- * // Reversed: [false,"b","a",2,1,true]
- *
- * // Readonly tuple of mixed types
- * type T5 = Reverse<readonly [false, "b", 2, "x", true]>;
- * // Grouped: [2,"b","x",false,true]
- * // Reversed: readonly [true,false,"x","b",2]
- *
- * // Tuple with arbitrary types (Date, object, symbol, bigint, etc.)
- * type T6 = Reverse<[1, "a", true, 2, "b", false, Date, {x:1}, symbol, 10n]>;
- * // Grouped: [1,2,"a","b",true,false,Date,{x:1},symbol,10n]
- * // Reversed: [10n,symbol,{x:1},Date,false,true,"b","a",2,1]
- *
- * // Normal arrays (not tuples) remain unchanged
- * type T7 = Reverse<number[]>;
- * // ➔ number[]
- *
- * type T8 = Reverse<string[]>;
- * // ➔ string[]
- *
- * type T9 = Reverse<(number | string)[]>;
- * // ➔ (string | number)[]
- *
- * type T10 = Reverse<(boolean | number | string)[]>;
- * // ➔ (string | number | boolean)[]
- * ```
- */
-type Reverse<T extends readonly unknown[]>=T extends readonly [ unknown,...unknown[]]?_Reverse<Grouped<T>>extends infer R extends readonly unknown[]?MaybeReadonly<T,R>:never:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `Round`.***
- * -------------------------------------------------------
- * **Type-level version of `Math.round()`.
- * Returns the value of a number rounded to the **nearest integer**.**
- * - **Behavior:**
- *    - If `T` is a float, it rounds to the nearest whole number:
- *      - Fraction `≥ 0.5` ➔ rounds up.
- *      - Fraction `< 0.5` ➔ rounds down.
- *    - If `T` is already an integer, it returns `T` as-is.
- * @template T - The number type to round.
- * @example
- * ```ts
- * // Positive float
- * type T0 = Round<3.14>;
- * // ➔ 3
- *
- * // Negative float
- * type T1 = Round<-3.14>;
- * // ➔ -3
- *
- * // Fraction ≥ 0.5
- * type T2 = Round<2.6>;
- * // ➔ 3
- *
- * // Already integer
- * type T3 = Round<5>;
- * // ➔ 5
- * ```
- */
-type Round<T extends number>=IsFloat<T>extends true?GetFloatNumberParts<T>extends [ infer Whole extends number,infer Fraction extends number]?IsGreaterThan<FirstDigit<Fraction>,4>extends true?Increment<Whole>:Whole:never:T;type SliceRemovedItemValue=Record<"__type-rzl_internal__",symbol>;type FilterRemoved<T extends readonly unknown[],Result extends unknown[]=[]>=T extends readonly [infer First,...infer Rest extends unknown[]]?FilterRemoved<Rest,First extends SliceRemovedItemValue?Result:Push<Result,First>>:Result;
-/** -------------------------------------------------------
- * * ***Utility Type: `Slice`.***
- * -------------------------------------------------------
- * **Type-level version of `Array.prototype.slice()`.**
- * @description
- * Returns a shallow copy of a portion of an array, selected from `Start` to `End` (not including `End`).
- * - **Behavior:**
- *    - `Start` defaults to `0`.
- *    - `End` defaults to `T["length"]`.
- *    - Negative indices are interpreted as `T["length"] + index`.
- *    - If `Start >= T["length"]` or `End <= Start`, returns an empty array `[]`.
- *    - If the full range is selected, returns `T` as-is.
- * @template T - The array type to slice.
- * @template Start - The start index (inclusive). Defaults to `0`.
- * @template End - The end index (exclusive). Defaults to `T["length"]`.
- * @example
- * ```ts
- * // Slice from index 1 to end
- * type T0 = Slice<[1, 2, 3, 4], 1>;
- * // ➔ [2, 3, 4]
- *
- * // Slice from index 1 to 3
- * type T1 = Slice<[1, 2, 3, 4], 1, 3>;
- * // ➔ [2, 3]
- *
- * // Slice with negative start
- * type T2 = Slice<[1, 2, 3, 4], -2>;
- * // ➔ [3, 4]
- *
- * // Slice with negative end
- * type T3 = Slice<[1, 2, 3, 4], 1, -1>;
- * // ➔ [2, 3]
- *
- * // Slice exceeding array length
- * type T4 = Slice<[1, 2, 3], 0, 10>;
- * // ➔ [1, 2, 3]
- *
- * // Slice resulting in empty array
- * type T5 = Slice<[1, 2, 3], 3, 2>;
- * // ➔ []
- * ```
- */
-type Slice<T extends readonly unknown[],Start extends number=0,End extends number=T["length"]>=(IsEmptyArray<T>extends true?"self":IsGreaterOrEqual<Start,T["length"]>extends true?"empty":IsNegative<End>extends true?IsGreaterOrEqual<Abs<End>,T["length"]>extends true?"empty":[IfPositive<Start,Start,Sum<T["length"],Start>>,Sum<T["length"],End>]:And<Or<IsEqual<Start,0>,IsGreaterOrEqual<Abs<Start>,T["length"]>>,IsGreaterOrEqual<End,T["length"]>>extends true?"self":[IfPositive<Start,Start,Sum<T["length"],Start>>,End])extends infer Indexes?Indexes extends"self"?T:Indexes extends"empty"?[]:Indexes extends [infer NewStart extends number,infer NewEnd extends number]?IfGreaterOrEqual<NewStart,NewEnd>extends true?[]:FilterRemoved<{[K in keyof T]:IsArrayIndex<K>extends true?If<And<IsGreaterOrEqual<ParseNumber<K>,NewStart>,IsLowerThan<ParseNumber<K>,NewEnd>>,T[K],SliceRemovedItemValue>:T[K];}>:T:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `Swap`.***
- * -------------------------------------------------------
- * **Swaps the positions of two elements in a tuple at the type level.**
- * - **Behavior:**
- *    - Only works on tuple types. Non-tuple arrays are returned as-is.
- *    - Validates that `FromIndex` and `ToIndex` are within bounds of the tuple.
- *    - If `FromIndex` and `ToIndex` are equal, the tuple remains unchanged.
- * @template T - The tuple type.
- * @template FromIndex - The index of the first element to swap.
- * @template ToIndex - The index of the second element to swap.
- * @example
- * ```ts
- * // Swap first and last element
- * type Case1 = Swap<[1, 2, 3], 0, 2>;
- * // ➔ [3, 2, 1]
- *
- * // Swap same index (no change)
- * type Case2 = Swap<[1, 2, 3], 0, 0>;
- * // ➔ [1, 2, 3]
- *
- * // Swap middle elements
- * type Case3 = Swap<["a", "b", "c"], 1, 2>;
- * // ➔ ["a", "c", "b"]
- *
- * // Non-tuple array remains unchanged
- * type Case4 = Swap<number[], 0, 1>;
- * // ➔ number[]
- * ```
- */
-type Swap<T extends readonly unknown[],FromIndex extends number,ToIndex extends number>=IsTuple<T>extends true?And<IsBetween<FromIndex,0,T["length"]>,IsBetween<ToIndex,0,T["length"]>>extends true?T[FromIndex] extends infer From?T[ToIndex] extends infer To?{[K in keyof T]:ParseNumber<K>extends infer NumK?IsEqual<FromIndex,NumK>extends true?To:IsEqual<ToIndex,NumK>extends true?From:T[K]:never;}:never:never:never:T;type _SortSingle<Result extends readonly number[],PivotIndex extends number,CurrentIndex extends number>=IsEqual<PivotIndex,CurrentIndex>extends true?Result:Increment<CurrentIndex>extends infer NextCurrentIndex extends number?_SortSingle<IsGreaterThan<Result[CurrentIndex],Result[NextCurrentIndex]>extends true?Swap<Result,CurrentIndex,NextCurrentIndex>extends infer NewResult extends readonly number[]?NewResult:Result:Result,PivotIndex,NextCurrentIndex>:never;type _Sort<T extends readonly number[],CurrentIndex extends number>=IsLowerOrEqual<CurrentIndex,0>extends true?T:_SortSingle<T,CurrentIndex,0>extends infer NewT extends readonly number[]?_Sort<NewT,Decrement<CurrentIndex>>:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `Sort`.***
- * -------------------------------------------------------
- * **Type-level function that sorts a **tuple of numbers** in **ascending order**.**
- * - **Behavior:**
- *    - Tuples with length `< 2` are returned as-is.
- *    - Works only on **tuple literal types**, not on general arrays (`number[]`).
- * @template T - Tuple of numbers to sort.
- * @example
- * ```ts
- * // Sort positive numbers
- * type T0 = Sort<[3, 2, 1]>;
- * // ➔ [1, 2, 3]
- *
- * // Sort numbers with negative values
- * type T1 = Sort<[1, -1, 0]>;
- * // ➔ [-1, 0, 1]
- *
- * // Already sorted
- * type T2 = Sort<[0, 1, 2]>;
- * // ➔ [0, 1, 2]
- *
- * // Single element tuple
- * type T3 = Sort<[42]>;
- * // ➔ [42]
- *
- * // Empty tuple
- * type T4 = Sort<[]>;
- * // ➔ []
- * ```
- */
-type Sort<T extends readonly number[]>=IsLowerThan<T["length"],2>extends true?T:_Sort<T,Decrement<T["length"]>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `StartsWith`.***
- * -------------------------------------------------------
- * **Type-level utility that determines whether a string `Str`
- * starts with the substring `Pivot`.**
- * - **Behavior:**
- *    - Supports `Pivot` as either `string` or `number`.
- *    - Returns `true` if `Str` starts with `Pivot`, otherwise `false`.
- * @template Str - The string to check.
- * @template Pivot - The substring or number to check as the prefix.
- * @example
- * ```ts
- * // Check string prefix
- * type Case1 = StartsWith<'abc', 'a'>;
- * // ➔ true
- *
- * type Case2 = StartsWith<'abc', 'b'>;
- * // ➔ false
- *
- * // Check numeric prefix
- * type Case3 = StartsWith<'123', 1>;
- * // ➔ true
- *
- * type Case4 = StartsWith<'123', 2>;
- * // ➔ false
- *
- * // Multi-character pivot
- * type Case5 = StartsWith<'typescript', 'type'>;
- * // ➔ true
- *
- * type Case6 = StartsWith<'typescript', 'script'>;
- * // ➔ false
- * ```
- */
-type StartsWith<Str extends string,Pivot extends string|number>=Str extends`${Pivot}${string}`?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `Switch`.***
- * -------------------------------------------------------
- * **Type-level version of a `switch` statement.**
- * - **Behavior:**
- *    - Checks if `Condition` exists as a key in `Cases`.
- *    - Returns the corresponding value if the key exists.
- *    - Returns `Default` if the key does not exist.
- * @template Condition - The value to match against case keys.
- * @template Cases - An object mapping keys to corresponding values.
- * @template Default - The default value returned if `Condition` is not a key in `Cases` (defaults to `never`).
- * @example
- * ```ts
- * const a = 'const';
- *
- * // Matches 'const' key ➔ 'bar'
- * type Result1 = Switch<typeof a, { number: 'foo', const: 'bar' }, 'foobar'>;
- * // ➔ 'bar'
- *
- * // Condition not present ➔ returns default
- * type Result2 = Switch<'other', { number: 'foo', const: 'bar' }, 'default'>;
- * // ➔ 'default'
- *
- * // Condition present but no default specified
- * type Result3 = Switch<'number', { number: 'foo', const: 'bar' }>;
- * // ➔ 'foo'
- * ```
- */
-type Switch<Condition extends PropertyKey,Cases extends Record<PropertyKey,unknown>,Default=never>=Condition extends keyof Cases?Cases[Condition]:Default;
-/** -------------------------------------------------------
- * * ***Utility Type: `ToPrimitive`.***
- * -------------------------------------------------------
- * **Converts a literal type to its corresponding primitive type.**
- * - **Behavior:**
- *    - `string literal` ➔ `string`.
- *    - `number literal` ➔ `number`.
- *    - `boolean literal` ➔ `boolean`.
- *    - `bigint literal` ➔ `bigint`.
- *    - `symbol literal` ➔ `symbol`.
- *    - `null` ➔ `null`.
- *    - `undefined` ➔ `undefined`.
- *    - Objects ➔ recursively converts all properties to their primitive types.
- * @template T - The literal type to convert to a primitive type.
- * @example
- * ```ts
- * // Number literal
- * type Case1 = ToPrimitive<1>;
- * // ➔ number
- *
- * // String literal
- * type Case2 = ToPrimitive<'1'>;
- * // ➔ string
- *
- * // Boolean literal
- * type Case3 = ToPrimitive<true>;
- * // ➔ boolean
- *
- * // BigInt literal
- * type Case4 = ToPrimitive<123n>;
- * // ➔ bigint
- *
- * // Symbol literal
- * type Case5 = ToPrimitive<symbol>;
- * // ➔ symbol
- *
- * // Null and undefined
- * type Case6 = ToPrimitive<null>;
- * // ➔ null
- * type Case7 = ToPrimitive<undefined>;
- * // ➔ undefined
- *
- * // Object with literal properties
- * type Case8 = ToPrimitive<{ a: 1; b: 's'; c: true }>;
- * // ➔ { a: number; b: string; c: boolean }
- * ```
- */
-type ToPrimitive<T>=T extends string?string:T extends number?number:T extends null?null:T extends undefined?undefined:T extends boolean?boolean:T extends bigint?bigint:T extends symbol?symbol:{[K in keyof T]:ToPrimitive<T[K]>;};
-/** -------------------------------------------------------
- * * ***Utility Type: `Trunc`.***
- * -------------------------------------------------------
- * **Type version of `Math.trunc()`.**
- * @description
- * Returns the **integer part** of a number by removing any fractional digits.
- * - **Behavior:**
- *     - If `T` is a floating-point number, returns the integer part.
- *     - Preserves the sign for negative numbers.
- *     - If `T` is already an integer, returns `T`.
- *     - If `T` is `number` (general type), returns `T`.
- * @template T - The number type to truncate.
- * @example
- * ```ts
- * // Positive float
- * type T0 = Trunc<3.14>;
- * // ➔ 3
- *
- * // Negative float
- * type T1 = Trunc<-3.14>;
- * // ➔ -3
- *
- * // Already integer
- * type T2 = Trunc<42>;
- * // ➔ 42
- *
- * // General number type
- * type T3 = Trunc<number>;
- * // ➔ number
- * ```
- */
-type Trunc<T extends number>=number extends T?T:IsFloat<T>extends true?GetFloatNumberParts<T>[0] extends infer IntegerPart extends number?IsNegative<T>extends true?Negate<IntegerPart>:IntegerPart:never:T;type FilterByType<T extends readonly unknown[],U>=T extends readonly [ infer Head,...infer Tail]?Head extends U?[Head,...FilterByType<Tail,U>]:FilterByType<Tail,U>:[];type GroupedKeys<T extends readonly PropertyKey[]>=[ ...FilterByType<T,symbol>,...FilterByType<T,string>,...FilterByType<T,number>];
-/** -------------------------------------------------------
- * * ***Utility Type: `TupleToObject`.***
- * -------------------------------------------------------
- * **Accepts a tuple of `string`, `number`, or `symbol` and returns an object type
- * where each key **and its value** are the elements of the tuple.**
- * - **Behavior:**
- *    - Tuple elements must extend `PropertyKey` (`string | number | symbol`).
- *    - The resulting object has keys and values identical to the tuple elements.
- * @template T - The tuple of property keys.
- * @example
- * ```ts
- * // Tuple of strings
- * type T0 = TupleToObject<['foo', 'bar']>;
- * // ➔ { foo: 'foo'; bar: 'bar' }
- *
- * // Tuple of numbers
- * type T1 = TupleToObject<[1, 2, 3]>;
- * // ➔ { 1: 1; 2: 2; 3: 3 }
- *
- * // Tuple of mixed property keys
- * type T2 = TupleToObject<['a', 0, symbol]>;
- * // ➔ { [x: symbol]: symbol; 0: 0; a: 'a'; }
- * ```
- */
-type TupleToObject<T extends readonly PropertyKey[]>={[K in GroupedKeys<T>[number]]:K;};
-/** -------------------------------------------------------
- * * ***Utility Type: `Unshift`.***
- * -------------------------------------------------------
- * **Adds the specified element `U` to the **beginning** of the tuple/array `T`.**
- * @template T - The original tuple or array.
- * @template U - The element to add at the start.
- * @example
- * ```ts
- * // Adding string to a tuple
- * type Case1 = Unshift<['bar'], 'foo'>;
- * // ➔ ['foo', 'bar']
- *
- * // Adding number to an empty array
- * type Case2 = Unshift<[], 1>;
- * // ➔ [1]
- * ```
- */
-type Unshift<T extends readonly unknown[],U>=[U,...T];export{Abs,And,AndArr,AnyFunction,type AnyRecord,AnyString,type AnyStringRecord,type AreAnagrams,type ArgumentTypes,type ArrayElementType,type Ceil,type Color,type ColorCssNamed,type ColorOptions,type CompareNumberLength,type CompareStringLength,type Concat,type Decrement,type DeepMergeArrayUnion,type DefaultColorOptions,type DefaultHSLOptions,type DefaultNumberLengthOptions,type DefaultPathToFieldsOptions,DefaultPrettifyOptions,type DefaultRGBOptions,type DigitsTuple,type Div,type Dot,type DotArray,type EndsWith,type ExcludeStrict,Extends,ExtendsArr,type Factorial,type Fibonacci,type FirstCharacter,type FirstCharacterOptions,type FirstDigit,type Floor,type GetFloatNumberParts,type HEX,type HSL,type HSLOptions,type Identity,If,type IfColor,IfEmptyArray,IfEmptyString,type IfEqual,IfExtends,type IfGreaterOrEqual,type IfGreaterThan,type IfHEX,type IfHSL,type IfLowerOrEqual,type IfLowerThan,IfNegative,IfNever,type IfNotEqual,IfPositive,type IfRGB,type IfTuple,type Includes,type Increment,type IndexOf,IsAny,type IsArrayIndex,type IsBaseType,type IsBetween,type IsBetweenOptions,type IsColor,type IsDivisible,type IsDivisibleByFive,type IsDivisibleByHundred,type IsDivisibleBySix,type IsDivisibleByTen,type IsDivisibleByThree,type IsDivisibleByTwo,IsEmptyArray,IsEmptyString,type IsEqual,IsEven,type IsExactly,IsFloat,type IsGreaterOrEqual,type IsGreaterThan,type IsHEX,type IsHSL,IsInteger,type IsLetter,type IsLongerNumber,type IsLongerString,type IsLowerOrEqual,type IsLowerThan,IsNegative,IsNegativeInteger,IsNever,type IsNotEqual,type IsPalindrome,IsPositive,type IsRGB,IsReadonlyArray,type IsSameLengthNumber,type IsSameLengthString,type IsShorterNumber,type IsShorterString,IsStringLiteral,type IsTuple,type IsUnion,IsUnknown,type Join,type LastCharacter,type LastCharacterOptions,type LooseLiteral,type Max,type MaxArr,type Min,type MinArr,type Mod,type Multi,Negate,type NonNullableObject,type NonNullableObjectExcept,type NonNullableObjectOnly,NonUndefined,Not,NotExtends,type NumberLength,type NumberRangeLimit,Or,OrArr,ParseNumber,type PartialExcept,type PartialOnly,type PathToFields,type PathToFieldsOptions,Pop,type Pow,Prettify,PrettifyOptions,type PrettifyUnionIntersection,Push,type RGB,type RGBOptions,type ReadonlyExcept,type ReadonlyOnly,type RemoveIndexSignature,type RemoveLeading,Repeat,type Replace,type ReplaceAll,type ReplaceToPartial,type ReplaceToRequired,type RequiredExcept,type RequiredOnly,type ReturnItselfIfExtends,type ReturnItselfIfNotExtends,type Reverse,type Round,type Shift,type ShiftOptions,type Slice,type Sort,Split,type StartsWith,type StringLength,type Stringify,type Sub,type Sum,type SumArr,type Swap,type Switch,type ToPrimitive,Trim,type Trunc,type TupleToObject,type TypeNumberLengthOptions,TypedArray,type UnionToIntersection,type UnknownRecord,type Unshift,type ValueOf,type ValueOfArray,type ValueOfExcept,type ValueOfOnly};