inferred-types 0.55.19 → 0.55.21

package/modules/runtime/dist/index.d.ts

@@ -3011,17 +3011,17 @@ declare const TW_HUE: {
     readonly stone: 273;
 };
 declare const TW_LUMINOSITY: {
-    readonly 50: 97.78;
-    readonly 100: 93.56;
-    readonly 200: 88.11;
-    readonly 300: 82.67;
-    readonly 400: 74.22;
-    readonly 500: 64.78;
-    readonly 600: 57.33;
-    readonly 700: 46.89;
-    readonly 800: 39.44;
-    readonly 900: 32;
-    readonly 950: 23.78;
+    readonly "50": 97.78;
+    readonly "100": 93.56;
+    readonly "200": 88.11;
+    readonly "300": 82.67;
+    readonly "400": 74.22;
+    readonly "500": 64.78;
+    readonly "600": 57.33;
+    readonly "700": 46.89;
+    readonly "800": 39.44;
+    readonly "900": 32;
+    readonly "950": 23.78;
 };
 /**
  * **TW_CHROMA**
@@ -3032,17 +3032,17 @@ declare const TW_LUMINOSITY: {
  * **Related:** `TW_CHROMA_50`, `TW_CHROMA_100`, ...
  */
 declare const TW_CHROMA: {
-    readonly 50: 0.0108;
-    readonly 100: 0.0321;
-    readonly 200: 0.0609;
-    readonly 300: 0.0908;
-    readonly 400: 0.1398;
-    readonly 500: 0.1472;
-    readonly 600: 0.1299;
-    readonly 700: 0.1067;
-    readonly 800: 0.0898;
-    readonly 900: 0.0726;
-    readonly 950: 0.054;
+    readonly "50": 0.0108;
+    readonly "100": 0.0321;
+    readonly "200": 0.0609;
+    readonly "300": 0.0908;
+    readonly "400": 0.1398;
+    readonly "500": 0.1472;
+    readonly "600": 0.1299;
+    readonly "700": 0.1067;
+    readonly "800": 0.0898;
+    readonly "900": 0.0726;
+    readonly "950": 0.054;
 };
 /**
  * The list of "targets" where Tailwind color string references
@@ -3773,23 +3773,23 @@ type ValidChars<T extends readonly string[]> = [] extends T ? true : First<T> ex
  */
 type IsVariable<T extends string> = T extends Variable ? ValidChars<Chars<T>> extends true ? true : false : false;
 
-type Process$1z<TVal, TDefault> = TVal extends Something ? TVal : TDefault;
+type Process$1A<TVal, TDefault> = TVal extends Something ? TVal : TDefault;
 /**
  * **Default**`<TVal,TDefault,[TProtect]>`
  *
  * Branching operator which allows giving a value `TVal` a _default value_ when
  * it's value is either `null` or `undefined`.
  */
-type Default<TVal, TDefault> = Process$1z<TVal, TDefault>;
+type Default<TVal, TDefault> = Process$1A<TVal, TDefault>;
 
-type Process$1y<TConditions extends readonly boolean[], TBooleanSeen extends boolean> = [] extends TConditions ? IfEqual<TBooleanSeen, true, boolean, true> : [First<TConditions>] extends [false] ? false : Process$1y<AfterFirst<TConditions>, TBooleanSeen>;
+type Process$1z<TConditions extends readonly boolean[], TBooleanSeen extends boolean> = [] extends TConditions ? IfEqual<TBooleanSeen, true, boolean, true> : [First<TConditions>] extends [false] ? false : Process$1z<AfterFirst<TConditions>, TBooleanSeen>;
 /**
  * **And**`<TConditions, [TEmpty]>`
  *
  * Allows an array of conditions which are either ARE a boolean value or a
  * function which evaluates to a boolean value to be logically AND'd together.
  */
-type And<TConditions, TEmpty extends boolean = false> = TConditions extends readonly (boolean | LogicFunction)[] ? IsEqual<TConditions, []> extends true ? TEmpty : LogicalReturns<TConditions> extends readonly boolean[] ? Process$1y<LogicalReturns<TConditions>, NarrowlyContains<LogicalReturns<TConditions>, boolean>> : never : never;
+type And<TConditions, TEmpty extends boolean = false> = TConditions extends readonly (boolean | LogicFunction)[] ? IsEqual<TConditions, []> extends true ? TEmpty : LogicalReturns<TConditions> extends readonly boolean[] ? Process$1z<LogicalReturns<TConditions>, NarrowlyContains<LogicalReturns<TConditions>, boolean>> : never : never;
 
 /**
  * comparison operators which require the base type to be a string
@@ -3806,14 +3806,14 @@ type NumericComparatorOperation = "greaterThan" | "greaterThanOrEqual" | "lessTh
  */
 type ComparatorOperation = "extends" | "equals" | StringComparatorOperation | "contains" | "containsAll" | NumericComparatorOperation | "returnEquals" | "returnExtends";
 type Unionize<T> = T extends readonly unknown[] ? TupleToUnion<T> : T;
-type Process$1x<TVal, TOp extends ComparatorOperation, TComparator> = TOp extends "extends" ? DoesExtend<TVal, Unionize<TComparator>> : TOp extends "equals" ? IsEqual<TVal, Unionize<TComparator>> : TOp extends "contains" ? [TVal] extends [string | number | Tuple] ? Contains<TVal, TComparator> : never : TOp extends "containsAll" ? [TVal] extends [Tuple] ? [TComparator] extends [string | number | readonly string[]] ? Contains<TVal, TComparator> : never : never : TOp extends "startsWith" ? [TVal] extends [string | number] ? [TComparator] extends [string | number | readonly string[]] ? StartsWith<TVal, TComparator> : never : never : TOp extends "greaterThan" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsGreaterThan<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "greaterThanOrEqual" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsGreaterThanOrEqual<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "lessThan" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsLessThan<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "lessThanOrEqual" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsLessThanOrEqual<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "endsWith" ? [TVal] extends [string | number] ? [TComparator] extends [string | number | readonly string[]] ? EndsWith<TVal, TComparator> : never : never : TOp extends "returnEquals" ? TVal extends ((...args: any[]) => any) ? IsEqual<ReturnType<TVal>, TComparator> : false : TOp extends "returnExtends" ? TVal extends ((...args: any[]) => any) ? IsEqual<ReturnType<TVal>, TComparator> : false : never;
+type Process$1y<TVal, TOp extends ComparatorOperation, TComparator> = TOp extends "extends" ? DoesExtend<TVal, Unionize<TComparator>> : TOp extends "equals" ? IsEqual<TVal, Unionize<TComparator>> : TOp extends "contains" ? [TVal] extends [string | number | Tuple] ? Contains<TVal, TComparator> : never : TOp extends "containsAll" ? [TVal] extends [Tuple] ? [TComparator] extends [string | number | readonly string[]] ? Contains<TVal, TComparator> : never : never : TOp extends "startsWith" ? [TVal] extends [string | number] ? [TComparator] extends [string | number | readonly string[]] ? StartsWith<TVal, TComparator> : never : never : TOp extends "greaterThan" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsGreaterThan<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "greaterThanOrEqual" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsGreaterThanOrEqual<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "lessThan" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsLessThan<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "lessThanOrEqual" ? And<[Extends<TComparator, NumberLike>, Extends<TVal, NumberLike>]> extends true ? IsLessThanOrEqual<As<TVal, NumberLike>, As<TComparator, NumberLike>> : never : TOp extends "endsWith" ? [TVal] extends [string | number] ? [TComparator] extends [string | number | readonly string[]] ? EndsWith<TVal, TComparator> : never : never : TOp extends "returnEquals" ? TVal extends ((...args: any[]) => any) ? IsEqual<ReturnType<TVal>, TComparator> : false : TOp extends "returnExtends" ? TVal extends ((...args: any[]) => any) ? IsEqual<ReturnType<TVal>, TComparator> : false : never;
 /**
  * **Compare**`<TVal,TOp,TComparator>`
  *
  * Compares the value `TVal` with `TComparator` using
  * the `TOp` _operator_.
  */
-type Compare$1<TVal, TOp extends ComparatorOperation, TComparator> = WhenNever<Process$1x<TVal, TOp, TComparator>>;
+type Compare$1<TVal, TOp extends ComparatorOperation, TComparator> = WhenNever<Process$1y<TVal, TOp, TComparator>>;
 
 type Negate<TVal> = IsNever<TVal> extends true ? never : [TVal] extends [boolean] ? IsTrue<TVal> extends true ? false : IsFalse<TVal> extends true ? true : boolean : [TVal] extends [LogicFunction] ? Negate<ReturnType<LogicFunction>> : never;
 type NegateTuple<TTuple extends readonly (boolean | LogicFunction)[], TResults extends readonly (boolean | LogicFunction)[] = []> = [] extends TTuple ? IsEqual<TResults, [], false, TResults> : NegateTuple<AfterFirst<TTuple>, [
@@ -3835,7 +3835,7 @@ type NegateTuple<TTuple extends readonly (boolean | LogicFunction)[], TResults e
  */
 type Not<TVal, TNotBoolean extends boolean = false> = [TVal] extends [boolean] ? Exclude<As<Negate<TVal>, boolean>, any[]> : [TVal] extends [LogicFunction] ? As<Negate<ReturnType<TVal>>, boolean> : [TVal] extends [readonly (LogicFunction | boolean)[]] ? As<NegateTuple<TVal>, readonly boolean[]> : TNotBoolean;
 
-type Process$1w<TConditions extends readonly boolean[], TBooleanSean extends boolean> = NarrowlyContains<TConditions, true> extends true ? true : [IsEqual<TBooleanSean, true>] extends [true] ? boolean : false;
+type Process$1x<TConditions extends readonly boolean[], TBooleanSean extends boolean> = NarrowlyContains<TConditions, true> extends true ? true : [IsEqual<TBooleanSean, true>] extends [true] ? boolean : false;
 type ConditionError<TErr> = TErr extends ErrorCondition ? ProxyError<TErr, "Or", "TConditions"> : never;
 /**
  * **Or**`<TConditions, [TEmpty]>`
@@ -3848,16 +3848,16 @@ type ConditionError<TErr> = TErr extends ErrorCondition ? ProxyError<TErr, "Or",
  *
  * **Related:** `And`
  */
-type Or<TConditions, TEmpty extends boolean = false> = IsNever<TConditions> extends true ? Throw<"invalid-never", `Or<TConditions> received "never" for it's conditions!`, "Or"> : IsEqual<TConditions, []> extends true ? TEmpty : TConditions extends readonly (boolean | LogicFunction)[] ? LogicalReturns<TConditions> extends readonly boolean[] ? Process$1w<LogicalReturns<TConditions>, NarrowlyContains<LogicalReturns<TConditions>, boolean>> : never : IsErrorCondition<TConditions> extends true ? ConditionError<TConditions> : Throw<"invalid-conditions", `The conditions passed to Or<TConditions> were invalid!`, "Or", {
+type Or<TConditions, TEmpty extends boolean = false> = IsNever<TConditions> extends true ? Throw<"invalid-never", `Or<TConditions> received "never" for it's conditions!`, "Or"> : IsEqual<TConditions, []> extends true ? TEmpty : TConditions extends readonly (boolean | LogicFunction)[] ? LogicalReturns<TConditions> extends readonly boolean[] ? Process$1x<LogicalReturns<TConditions>, NarrowlyContains<LogicalReturns<TConditions>, boolean>> : never : IsErrorCondition<TConditions> extends true ? ConditionError<TConditions> : Throw<"invalid-conditions", `The conditions passed to Or<TConditions> were invalid!`, "Or", {
     library: "inferred-types/constants";
     value: TConditions;
 }>;
 
-type Process$1v<TElements extends readonly unknown[], TOp extends ComparatorOperation, TComparator> = [] extends TElements ? false : [WhenNever<Compare$1<First<TElements>, TOp, TComparator>>] extends [true] ? true : Process$1v<AfterFirst<TElements>, TOp, TComparator>;
+type Process$1w<TElements extends readonly unknown[], TOp extends ComparatorOperation, TComparator> = [] extends TElements ? false : [WhenNever<Compare$1<First<TElements>, TOp, TComparator>>] extends [true] ? true : Process$1w<AfterFirst<TElements>, TOp, TComparator>;
 type Some<TContainer extends Container, TOp extends "extends" | "equals" | "startsWith" | "endsWith" | "lessThan" | "greaterThan", TComparator extends Or<[
     IsEqual<TOp, "startsWith">,
     IsEqual<TOp, "endsWith">
-]> extends true ? string : Or<[IsEqual<TOp, "lessThan">, IsEqual<TOp, "greaterThan">]> extends true ? NumberLike : unknown> = TContainer extends readonly unknown[] ? Process$1v<TContainer, TOp, TComparator> : TContainer extends Dictionary ? Process$1v<Values<TContainer>, TOp, TComparator> : never;
+]> extends true ? string : Or<[IsEqual<TOp, "lessThan">, IsEqual<TOp, "greaterThan">]> extends true ? NumberLike : unknown> = TContainer extends readonly unknown[] ? Process$1w<TContainer, TOp, TComparator> : TContainer extends Dictionary ? Process$1w<Values<TContainer>, TOp, TComparator> : never;
 
 type AllAcc<TList extends readonly unknown[], TExtend> = [] extends TList ? true : If<Extends<First<TList>, TExtend>, AllAcc<AfterFirst<TList>, TExtend>, false>;
 /**
@@ -3948,11 +3948,11 @@ type Contains<TContent extends string | number | readonly unknown[], TComparator
 type DoesExtend<TValue, TExtends> = IsNever<TValue> extends true ? false : [TValue] extends [TExtends] ? true : false;
 
 type Test$1<TValue extends string, TComparator extends string> = TValue extends `${string}${TComparator}` ? true : false;
-type Process$1u<TValue extends string, TComparator extends string> = IsStringLiteral<TComparator> extends true ? IsStringLiteral<TValue> extends true ? Test$1<TValue, TComparator> : boolean : boolean;
+type Process$1v<TValue extends string, TComparator extends string> = IsStringLiteral<TComparator> extends true ? IsStringLiteral<TValue> extends true ? Test$1<TValue, TComparator> : boolean : boolean;
 type ProcessEach$1<TValue extends string, TComparator extends readonly string[]> = Or<{
-    [K in keyof TComparator]: Process$1u<TValue, TComparator[K]>;
+    [K in keyof TComparator]: Process$1v<TValue, TComparator[K]>;
 }>;
-type PreProcess$4<TValue extends string, TComparator extends string | readonly string[]> = TComparator extends readonly string[] ? ProcessEach$1<TValue, TComparator> : TComparator extends string ? Process$1u<TValue, TComparator> : never;
+type PreProcess$4<TValue extends string, TComparator extends string | readonly string[]> = TComparator extends readonly string[] ? ProcessEach$1<TValue, TComparator> : TComparator extends string ? Process$1v<TValue, TComparator> : never;
 /**
  * **EndsWith**<TValue, TComparator>
  *
@@ -3989,13 +3989,13 @@ type _HasArray<TList extends readonly unknown[]> = [] extends TList ? false : Is
  */
 type HasArray<TList extends readonly unknown[]> = _HasArray<TList>;
 
-type Process$1t<TStr extends string, TChars extends string, _TOp extends "any" | "all"> = TStr extends `${string}${TChars}${string}` ? true : false;
+type Process$1u<TStr extends string, TChars extends string, _TOp extends "any" | "all"> = TStr extends `${string}${TChars}${string}` ? true : false;
 type ProcessTuple$4<TStr extends string, TChars extends readonly string[], TOp extends "any" | "all"> = TOp extends "any" ? Or<{
     [K in keyof TChars]: TStr extends `${string}${TChars[K]}${string}` ? true : false;
 }> : And<{
     [K in keyof TChars]: TStr extends `${string}${TChars[K]}${string}` ? true : false;
 }>;
-type PreProcess$3<TStr extends string, TChars extends string, TOp extends "any" | "all"> = IsUnion<TChars> extends true ? UnionToTuple$1<TChars> extends readonly string[] ? ProcessTuple$4<TStr, UnionToTuple$1<TChars>, TOp> : never : Process$1t<TStr, TChars, TOp>;
+type PreProcess$3<TStr extends string, TChars extends string, TOp extends "any" | "all"> = IsUnion<TChars> extends true ? UnionToTuple$1<TChars> extends readonly string[] ? ProcessTuple$4<TStr, UnionToTuple$1<TChars>, TOp> : never : Process$1u<TStr, TChars, TOp>;
 /**
  * **HasCharacters**`<TStr,TChars>`
  *
@@ -4009,7 +4009,7 @@ type PreProcess$3<TStr extends string, TChars extends string, TOp extends "any"
  */
 type HasCharacters<TStr extends string, TChars extends string | readonly string[], TOp extends "any" | "all" = "any"> = IsStringLiteral<TStr> extends true ? TChars extends string ? IsStringLiteral<TChars> extends true ? PreProcess$3<TStr, TChars, TOp> : boolean : TChars extends readonly string[] ? AllStringLiterals<AsArray<TChars>> extends true ? ProcessTuple$4<TStr, TChars, TOp> : boolean : boolean : boolean;
 
-type Process$1s<TStr extends string, TChars extends string> = ReplaceAll<TStr, TChars, ""> extends "" ? false : true;
+type Process$1t<TStr extends string, TChars extends string> = ReplaceAll<TStr, TChars, ""> extends "" ? false : true;
 /**
  * **HasOtherCharacters**`<TStr,TChars>`
  *
@@ -4021,7 +4021,7 @@ type Process$1s<TStr extends string, TChars extends string> = ReplaceAll<TStr, T
  *
  * **Related:** `HasCharacters`
  */
-type HasOtherCharacters<TStr extends string, TChars extends string | readonly string[]> = [IsWideType<TStr>] extends [true] ? boolean : [TChars] extends [string] ? IsWideType<TChars> extends true ? boolean : Process$1s<TStr, TChars> : TChars extends readonly string[] ? Process$1s<TStr, TupleToUnion<TChars>> : never;
+type HasOtherCharacters<TStr extends string, TChars extends string | readonly string[]> = [IsWideType<TStr>] extends [true] ? boolean : [TChars] extends [string] ? IsWideType<TChars> extends true ? boolean : Process$1t<TStr, TChars> : TChars extends readonly string[] ? Process$1t<TStr, TupleToUnion<TChars>> : never;
 
 /**
  * **HasParameters**`<T>`
@@ -4261,7 +4261,7 @@ type Validations<T> = IsStringLiteral<T> extends true ? true : IsNumericLiteral<
  */
 type IsLiteral<T> = [IsUnion<T>] extends [true] ? false : Validations<T>;
 
-type Process$1p<T> = UnionToTuple$1<T> extends readonly unknown[] ? RetainLiterals<UnionToTuple$1<T>>["length"] extends UnionToTuple$1<T>["length"] ? true : false : never;
+type Process$1q<T> = UnionToTuple$1<T> extends readonly unknown[] ? RetainLiterals<UnionToTuple$1<T>>["length"] extends UnionToTuple$1<T>["length"] ? true : false : never;
 /**
  * **IsLiteralUnion**`<T>`
  *
@@ -4270,7 +4270,7 @@ type Process$1p<T> = UnionToTuple$1<T> extends readonly unknown[] ? RetainLitera
  *
  * **Related:** `IsLiteralUnion`, `IsWideUnion`
  */
-type IsLiteralUnion<T> = [IsUnion<T>] extends [true] ? Process$1p<T> : false;
+type IsLiteralUnion<T> = [IsUnion<T>] extends [true] ? Process$1q<T> : false;
 
 /**
  * **IsNarrowingFn**`<TFn>`
@@ -4389,7 +4389,7 @@ type IsSingleChar<T> = T extends string ? Length<T> extends 1 ? true : If<IsStri
  */
 type IsString<T> = [IsUnion<T>] extends [true] ? WidenUnion<T> extends string ? true : string extends WidenUnion<T> ? boolean : false : [T] extends [string] ? true : false;
 
-type Process$1m<T, TNever> = [IsNever<T>] extends [true] ? TNever : [IsEqual<T, true>] extends [true] ? true : false;
+type Process$1n<T, TNever> = [IsNever<T>] extends [true] ? TNever : [IsEqual<T, true>] extends [true] ? true : false;
 /**
  * **IsTrue**`<T,[TNever]>`
  *
@@ -4403,9 +4403,9 @@ type Process$1m<T, TNever> = [IsNever<T>] extends [true] ? TNever : [IsEqual<T,
  * type F2 = IsTrue<"foobar">;
  * ```
  */
-type IsTrue<T, TNever = never> = Process$1m<T, TNever>;
+type IsTrue<T, TNever = never> = Process$1n<T, TNever>;
 
-type Process$1l<T> = [IsNever<T>] extends [true] ? false : T extends readonly unknown[] ? number extends T["length"] ? false : true : false;
+type Process$1m<T> = [IsNever<T>] extends [true] ? false : T extends readonly unknown[] ? number extends T["length"] ? false : true : false;
 /**
  * **IsTuple**`<T>`
  *
@@ -4418,7 +4418,7 @@ type Process$1l<T> = [IsNever<T>] extends [true] ? false : T extends readonly un
  * - types such as `string[]`, etc. are _not_ tuples as they
  * do not discretely specify a length of elements
  */
-type IsTuple<T> = Process$1l<T> extends boolean ? Process$1l<T> : never;
+type IsTuple<T> = Process$1m<T> extends boolean ? Process$1m<T> : never;
 
 /**
  * **IsUndefined**
@@ -4570,7 +4570,7 @@ type InvalidNever = Throw<"invalid-never", `The value of T when calling IsWideTy
  */
 type IsWideType<T, TNever = InvalidNever> = [IsNever<T>] extends [true] ? TNever : [T] extends [ErrorCondition] ? ProxyError<T, "IsWideType"> : IsWideScalar<T> extends true ? true : IsWideContainer<T> extends true ? true : IsWideUnion<T> extends true ? true : false;
 
-type Process$1k<T extends readonly unknown[]> = {
+type Process$1l<T extends readonly unknown[]> = {
     [K in keyof T]: IsWideType<T[K]> extends true ? true : Or<[IsUndefined<T[K]>, IsNull<T[K]>]> extends true ? true : false;
 };
 /**
@@ -4581,7 +4581,7 @@ type Process$1k<T extends readonly unknown[]> = {
  *
  * **Related:** `IsNonLiteralUnion`
  */
-type IsWideUnion<T> = [IsUnion<T>] extends [true] ? [Process$1k<UnionToTuple$1<T>>] extends [readonly true[]] ? true : false : false;
+type IsWideUnion<T> = [IsUnion<T>] extends [true] ? [Process$1l<UnionToTuple$1<T>>] extends [readonly true[]] ? true : false : false;
 
 type Overlap<TKeys extends readonly ObjectKey[], TComparator extends AnyObject> = [] extends TKeys ? false : First<TKeys> extends keyof TComparator ? true : Overlap<AfterFirst<TKeys>, TComparator>;
 /**
@@ -4670,7 +4670,7 @@ type HasQueryParameter<T extends string, P extends string> = And<[
 ]> extends true ? GetUrlQueryParams<T> extends `${string}${P}=${string}` ? true : false : boolean;
 
 type Check<TValue extends string, TComparator extends string | number> = TValue extends `${TComparator}${string}` ? true : false;
-type Process$1j<TValue extends string, TComparator extends string | number | readonly string[]> = TComparator extends readonly string[] ? Check<[
+type Process$1k<TValue extends string, TComparator extends string | number | readonly string[]> = TComparator extends readonly string[] ? Check<[
     TValue
 ] extends [number] ? `${TValue}` : TValue, TupleToUnion<TComparator>> : Check<[
     TValue
@@ -4689,9 +4689,9 @@ type Process$1j<TValue extends string, TComparator extends string | number | rea
  *    - this can be much more type efficient for unions with lots of characters
  *    - if you need larger pattern matches then use a Tuple for `TComparator`
  */
-type StartsWith<TValue extends string | number, TComparator extends string | number | readonly string[]> = [IsWideType<TValue>] extends [true] ? boolean : [IsWideType<TComparator>] extends [true] ? boolean : IsEqual<Process$1j<AsString<TValue>, TComparator>, boolean> extends true ? true : Process$1j<AsString<TValue>, TComparator>;
+type StartsWith<TValue extends string | number, TComparator extends string | number | readonly string[]> = [IsWideType<TValue>] extends [true] ? boolean : [IsWideType<TComparator>] extends [true] ? boolean : IsEqual<Process$1k<AsString<TValue>, TComparator>, boolean> extends true ? true : Process$1k<AsString<TValue>, TComparator>;
 
-type Process$1i<T extends readonly unknown[]> = HasArray<T> extends true ? true : false;
+type Process$1j<T extends readonly unknown[]> = HasArray<T> extends true ? true : false;
 /**
  * **UnionHasArray**`<T>`
  *
@@ -4701,7 +4701,7 @@ type Process$1i<T extends readonly unknown[]> = HasArray<T> extends true ? true
  * - and that one of the elements of the union is an array
  * of some sort.
  */
-type UnionHasArray<T> = IsUnion<T> extends true ? Process$1i<UnionToTuple$1<T>> : false;
+type UnionHasArray<T> = IsUnion<T> extends true ? Process$1j<UnionToTuple$1<T>> : false;
 
 type ShouldFail<TTest> = [IsNever<TTest>] extends [true] ? true : [IsFalse<TTest>] extends [true] ? true : false;
 type Iterate$8<TTest extends readonly unknown[]> = Or<{
@@ -4811,8 +4811,8 @@ type Merge$1<TUser extends Partial<OnPassRemap>, TKeys extends readonly (ObjectK
     false: false;
     error: Constant$1<"not-set">;
 }> = [] extends TKeys ? TConfig : Merge$1<TUser, AfterFirst<TKeys>, As<ExpandDictionary<Record<First<TKeys>, TUser[First<TKeys>]> & Omit<TConfig, First<TKeys>>>, OnPassRemap>>;
-type Process$1g<TTest, TPass, TRemap extends OnPassRemap<unknown, unknown, unknown>> = [IsNever<TTest>] extends [true] ? TRemap["never"] : [IsErrorCondition<TTest>] extends [true] ? TRemap["error"] extends Constant$1<"not-set"> ? TTest : TRemap["error"] : [IsFalse<TTest>] extends [true] ? TRemap["false"] : TPass;
-type Iterate$7<TTest extends readonly unknown[], TPass, TRemap extends OnPassRemap<unknown, unknown, unknown>> = [] extends TTest ? TPass : Process$1g<First<TTest>, TPass, TRemap> extends TPass ? Iterate$7<AfterFirst<TTest>, TPass, TRemap> : Process$1g<First<TTest>, TPass, TRemap>;
+type Process$1h<TTest, TPass, TRemap extends OnPassRemap<unknown, unknown, unknown>> = [IsNever<TTest>] extends [true] ? TRemap["never"] : [IsErrorCondition<TTest>] extends [true] ? TRemap["error"] extends Constant$1<"not-set"> ? TTest : TRemap["error"] : [IsFalse<TTest>] extends [true] ? TRemap["false"] : TPass;
+type Iterate$7<TTest extends readonly unknown[], TPass, TRemap extends OnPassRemap<unknown, unknown, unknown>> = [] extends TTest ? TPass : Process$1h<First<TTest>, TPass, TRemap> extends TPass ? Iterate$7<AfterFirst<TTest>, TPass, TRemap> : Process$1h<First<TTest>, TPass, TRemap>;
 /**
  * **OnPass**`<TTest, TPass,[TRemap],[TFalse]>`
  *
@@ -4826,7 +4826,7 @@ type Iterate$7<TTest extends readonly unknown[], TPass, TRemap extends OnPassRem
  * - the `TRemap` allows you to remap error conditions
  * as well if needed
  */
-type OnPass<TTest, TPass, TRemap extends Partial<OnPassRemap<unknown, unknown, unknown>> = OnPassRemap<never, false, Constant$1<"not-set">>> = TTest extends readonly unknown[] ? Iterate$7<TTest, TPass, TRemap extends OnPassRemap<never, false, Constant$1<"not-set">> ? TRemap : Merge$1<TRemap, Keys<TRemap>>> : Process$1g<TTest, TPass, TRemap extends OnPassRemap<never, false, Constant$1<"not-set">> ? TRemap : Merge$1<TRemap, Keys<TRemap>>>;
+type OnPass<TTest, TPass, TRemap extends Partial<OnPassRemap<unknown, unknown, unknown>> = OnPassRemap<never, false, Constant$1<"not-set">>> = TTest extends readonly unknown[] ? Iterate$7<TTest, TPass, TRemap extends OnPassRemap<never, false, Constant$1<"not-set">> ? TRemap : Merge$1<TRemap, Keys<TRemap>>> : Process$1h<TTest, TPass, TRemap extends OnPassRemap<never, false, Constant$1<"not-set">> ? TRemap : Merge$1<TRemap, Keys<TRemap>>>;
 
 /**
  * **WhenNever**`<T, [TMapTo]>`
@@ -4905,13 +4905,13 @@ type RemoveEmpty<T> = T extends Tuple ? As<RemoveMarked<ProcessTup<T>>, readonly
 
 type Marked$2 = typeof MARKED;
 type _Keys$4<T extends object> = UnionToTuple$1<keyof RemoveIndexKeys<T>> extends readonly ObjectKey[] ? UnionToTuple$1<keyof RemoveIndexKeys<T>> : never;
-type Process$1e<T extends Container, TKeys extends readonly PropertyKey[], TResults extends Container = T extends readonly unknown[] ? [] : EmptyObject> = [] extends TKeys ? TResults : First<TKeys> extends keyof T ? DoesExtend<T[First<TKeys>], Marked$2> extends true ? Process$1e<T, AfterFirst<TKeys>, TResults> : Process$1e<T, AfterFirst<TKeys>, First<TKeys> extends keyof T ? TResults extends readonly unknown[] ? [...TResults, T[First<TKeys>]] : TResults extends Dictionary ? TResults & Record<First<TKeys>, T[First<TKeys>]> : never : never> : never;
+type Process$1f<T extends Container, TKeys extends readonly PropertyKey[], TResults extends Container = T extends readonly unknown[] ? [] : EmptyObject> = [] extends TKeys ? TResults : First<TKeys> extends keyof T ? DoesExtend<T[First<TKeys>], Marked$2> extends true ? Process$1f<T, AfterFirst<TKeys>, TResults> : Process$1f<T, AfterFirst<TKeys>, First<TKeys> extends keyof T ? TResults extends readonly unknown[] ? [...TResults, T[First<TKeys>]] : TResults extends Dictionary ? TResults & Record<First<TKeys>, T[First<TKeys>]> : never : never> : never;
 /**
  * **RemoveMarked**`<T>`
  *
  * Removes all values in `T` which extends `Constant<"Marked">`
  */
-type RemoveMarked<T extends Container> = Process$1e<T, T extends Tuple ? NumericKeys<T> : _Keys$4<T>>;
+type RemoveMarked<T extends Container> = Process$1f<T, T extends Tuple ? NumericKeys<T> : _Keys$4<T>>;
 
 /**
  * **RemoveIndexKeys**`<T>`
@@ -4949,7 +4949,7 @@ type _AsArray<T> = T extends Tuple ? Mutable<T> : If<IsUndefined<T>, [
  */
 type AsArray<T> = _AsArray<T> extends any[] ? _AsArray<T> : never;
 
-type Process$1d<T extends `${number}`> = If<IsStringLiteral<T>, StripLeading<T, "-">, string>;
+type Process$1e<T extends `${number}`> = If<IsStringLiteral<T>, StripLeading<T, "-">, string>;
 /**
  * **Abs**`<T>`
  *
@@ -4958,7 +4958,7 @@ type Process$1d<T extends `${number}`> = If<IsStringLiteral<T>, StripLeading<T,
  * - you can pass in a numeric string literal and it perform ABS func while
  * preserving string literal type
  */
-type Abs<T extends NumberLike> = T extends number ? AsNumber<Process$1d<`${T}`>> : T extends `${number}` ? Process$1d<T> : never;
+type Abs<T extends NumberLike> = T extends number ? AsNumber<Process$1e<`${T}`>> : T extends `${number}` ? Process$1e<T> : never;
 
 /**
  * **NumericChar**
@@ -4982,13 +4982,13 @@ type GrowExp<A extends any[], N extends number, P extends any[][], L extends num
 type MapItemType<T, I> = {
     [K in keyof T]: I;
 };
-type Process$1c<T, N extends number> = N extends 0 ? [] : MapItemType<GrowExp<[0], N, []>, T>;
+type Process$1d<T, N extends number> = N extends 0 ? [] : MapItemType<GrowExp<[0], N, []>, T>;
 /**
  * **FixedLengthArray**`<T,N>`
  *
  * Creates a fixed length `<N>` array of a given type `<T>`
  */
-type FixedLengthArray<T, N extends number> = Process$1c<T, N> extends readonly unknown[] ? Process$1c<T, N> : never;
+type FixedLengthArray<T, N extends number> = Process$1d<T, N> extends readonly unknown[] ? Process$1d<T, N> : never;
 
 /**
  * **ParseInt**`<T>`
@@ -5011,7 +5011,7 @@ type ParseInt<T> = T extends `${infer N extends number}` ? N : never;
  */
 type AsNumber<T> = T extends number ? T : T extends `${number}` ? ParseInt<T> : never;
 
-type Process$1b<TTuple extends readonly string[], TSeparator extends string, TResult extends string = ""> = [] extends TTuple ? TResult : Process$1b<AfterFirst<TTuple>, TSeparator, TResult extends "" ? First<TTuple> extends "" ? TResult : `${First<TTuple>}` : First<TTuple> extends "" ? TResult : `${TResult}${TSeparator}${First<TTuple>}`>;
+type Process$1c<TTuple extends readonly string[], TSeparator extends string, TResult extends string = ""> = [] extends TTuple ? TResult : Process$1c<AfterFirst<TTuple>, TSeparator, TResult extends "" ? First<TTuple> extends "" ? TResult : `${First<TTuple>}` : First<TTuple> extends "" ? TResult : `${TResult}${TSeparator}${First<TTuple>}`>;
 type Slicer<TTuple extends readonly unknown[], TMax extends number | null, TEllipsis extends string | false> = TMax extends number ? TakeFirst<TTuple, TMax> extends readonly unknown[] ? TEllipsis extends string ? ToStringArray<[...TakeFirst<TTuple, TMax>, TEllipsis]> : ToStringArray<TakeFirst<TTuple, TMax>> : never : ToStringArray<TTuple>;
 /**
  * **Join**`<TArr,[TSeparator],[TMax]>`
@@ -5026,7 +5026,7 @@ type Slicer<TTuple extends readonly unknown[], TMax extends number | null, TElli
  *
  * **Related:** `Concat<TArr>`
  */
-type Join<TTuple extends readonly unknown[], TSeparator extends string = "", TMax extends number | null = null, TEllipsis extends string | false = "..."> = ToStringArray<TTuple> extends readonly string[] ? TMax extends number ? IsGreaterThan<TTuple["length"], TMax> extends true ? Process$1b<Slicer<TTuple, TMax, TEllipsis>, TSeparator> : Process$1b<ToStringArray<TTuple>, TSeparator> : Process$1b<ToStringArray<TTuple>, TSeparator> : never;
+type Join<TTuple extends readonly unknown[], TSeparator extends string = "", TMax extends number | null = null, TEllipsis extends string | false = "..."> = ToStringArray<TTuple> extends readonly string[] ? TMax extends number ? IsGreaterThan<TTuple["length"], TMax> extends true ? Process$1c<Slicer<TTuple, TMax, TEllipsis>, TSeparator> : Process$1c<ToStringArray<TTuple>, TSeparator> : Process$1c<ToStringArray<TTuple>, TSeparator> : never;
 
 /**
  * **AsString**<T>
@@ -5112,9 +5112,9 @@ type RightMostDigit<s extends string> = s extends `${infer rest}${NumericChar}`
 type SumStrings<left extends string, right extends string, accumulatedResultDigits extends string = "", carry extends boolean = false> = "" extends left ? "" extends right ? carry extends true ? `1${accumulatedResultDigits}` : accumulatedResultDigits : RightMostDigit<right> extends RightMostDigitResult<infer remainingRight, infer rightDigit> ? SumSingleDigits<"0", rightDigit, carry> extends SingleDigitSumResult<infer resultDigit, infer resultCarry> ? SumStrings<"", remainingRight, `${resultDigit}${accumulatedResultDigits}`, resultCarry> : never : never : "" extends right ? RightMostDigit<left> extends RightMostDigitResult<infer remainingLeft, infer leftDigit> ? SumSingleDigits<"0", leftDigit, carry> extends SingleDigitSumResult<infer resultDigit, infer resultCarry> ? SumStrings<remainingLeft, "", `${resultDigit}${accumulatedResultDigits}`, resultCarry> : never : never : RightMostDigit<left> extends RightMostDigitResult<infer remainingLeft, infer leftDigit> ? RightMostDigit<right> extends RightMostDigitResult<infer remainingRight, infer rightDigit> ? SumSingleDigits<leftDigit, rightDigit, carry> extends SingleDigitSumResult<infer resultDigit, infer resultCarry> ? SumStrings<remainingLeft, remainingRight, `${resultDigit}${accumulatedResultDigits}`, resultCarry> : never : never : never;
 type _Subtract<TValue extends `${number}`, TCountArr extends readonly unknown[]> = [] extends TCountArr ? TValue : _Subtract<Decrement<TValue>, AfterFirst<TCountArr>>;
 type AddNegatives<A extends `${number}`, B extends `${number}`> = SumStrings<A, B>;
-type Process$1a<A extends `${number}`, B extends `${number}`> = And<[IsNegativeNumber<A>, IsNegativeNumber<B>]> extends true ? `-${AddNegatives<Abs<A>, Abs<B>>}` : IsNegativeNumber<B> extends true ? FixedLengthArray<unknown, AsNumber<Abs<B>>> extends readonly unknown[] ? _Subtract<A, FixedLengthArray<unknown, AsNumber<Abs<B>>>> : never : IsNegativeNumber<A> extends true ? FixedLengthArray<unknown, AsNumber<Abs<A>>> extends readonly unknown[] ? _Subtract<B, FixedLengthArray<unknown, AsNumber<Abs<A>>>> : never : SumStrings<A, B>;
+type Process$1b<A extends `${number}`, B extends `${number}`> = And<[IsNegativeNumber<A>, IsNegativeNumber<B>]> extends true ? `-${AddNegatives<Abs<A>, Abs<B>>}` : IsNegativeNumber<B> extends true ? FixedLengthArray<unknown, AsNumber<Abs<B>>> extends readonly unknown[] ? _Subtract<A, FixedLengthArray<unknown, AsNumber<Abs<B>>>> : never : IsNegativeNumber<A> extends true ? FixedLengthArray<unknown, AsNumber<Abs<A>>> extends readonly unknown[] ? _Subtract<B, FixedLengthArray<unknown, AsNumber<Abs<A>>>> : never : SumStrings<A, B>;
 type CheckWide<A extends NumberLike, B extends NumberLike> = IsWideType<A> extends true ? true : IsWideType<B> extends true ? true : false;
-type PreProcess$2<A extends NumberLike, B extends NumberLike> = CheckWide<A, B> extends true ? Or<[IsString<A>, IsString<A>]> extends true ? string : number : Or<[IsWideType<A>, IsWideType<B>]> extends true ? If<IsString<A>, string, number> : A extends `${number}` ? B extends `${number}` ? As<Process$1a<A, B>, `${number}`> : As<Process$1a<A, AsString<B>>, `${number}`> : A extends number ? B extends number ? AsNumber<Process$1a<`${A}`, `${B}`>> : AsNumber<Process$1a<`${A}`, As<B, `${number}`>>> : never;
+type PreProcess$2<A extends NumberLike, B extends NumberLike> = CheckWide<A, B> extends true ? Or<[IsString<A>, IsString<A>]> extends true ? string : number : Or<[IsWideType<A>, IsWideType<B>]> extends true ? If<IsString<A>, string, number> : A extends `${number}` ? B extends `${number}` ? As<Process$1b<A, B>, `${number}`> : As<Process$1b<A, AsString<B>>, `${number}`> : A extends number ? B extends number ? AsNumber<Process$1b<`${A}`, `${B}`>> : AsNumber<Process$1b<`${A}`, As<B, `${number}`>>> : never;
 /**
  * **Add**`<A,B>`
  *
@@ -5309,7 +5309,7 @@ type ProxyError<TError extends ErrorCondition, TUtility extends string, TGeneric
  * Iterates over each element of the Tuple
  */
 type SingleFilter$3<TList extends readonly unknown[], TFilter, TOp extends ComparatorOperation, Result extends unknown[] = []> = TList extends [infer Head, ...infer Rest] ? [Compare$1<Head, TOp, TFilter>] extends [true] ? SingleFilter$3<Rest, TFilter, TOp, Result> : SingleFilter$3<Rest, TFilter, TOp, [...Result, Head]> : Result;
-type Process$17<TList extends unknown[] | readonly unknown[], TFilter, TOp extends ComparatorOperation> = TList extends unknown[] ? SingleFilter$3<TList, TFilter, TOp> : TList extends readonly unknown[] ? Readonly<SingleFilter$3<[...TList], TFilter, TOp>> : never;
+type Process$18<TList extends unknown[] | readonly unknown[], TFilter, TOp extends ComparatorOperation> = TList extends unknown[] ? SingleFilter$3<TList, TFilter, TOp> : TList extends readonly unknown[] ? Readonly<SingleFilter$3<[...TList], TFilter, TOp>> : never;
 /**
  * **Filter**`<TList, TComparator, [TOp]>`
  *
@@ -5333,7 +5333,7 @@ type Process$17<TList extends unknown[] | readonly unknown[], TFilter, TOp exten
  *
  * **Related:** `RetainFromList`, `RemoveFromList`
  */
-type Filter<TList extends readonly unknown[], TComparator, TOp extends ComparatorOperation = "extends"> = TList extends readonly unknown[] ? IfNever<TComparator, RemoveNever<TList>, If<IsArray<TComparator>, Process$17<TList, TupleToUnion<TComparator>, TOp>, Process$17<TList, TComparator, TOp>>> : never;
+type Filter<TList extends readonly unknown[], TComparator, TOp extends ComparatorOperation = "extends"> = TList extends readonly unknown[] ? IfNever<TComparator, RemoveNever<TList>, If<IsArray<TComparator>, Process$18<TList, TupleToUnion<TComparator>, TOp>, Process$18<TList, TComparator, TOp>>> : never;
 
 /**
  * Converts a Tuple type into a _union_ of the tuple elements
@@ -5443,7 +5443,7 @@ type _DU<T extends string> = T extends Lowercase<T> ? T : `-${Lowercase<T>}`;
  */
 type DashUppercase<T extends string> = HasUppercase<T> extends false ? T : T extends `${infer C0}${infer C1}${infer R}` ? `${_DU<C0>}${_DU<C1>}${DashUppercase<R>}` : T extends `${infer C0}${infer R}` ? `${_DU<C0>}${DashUppercase<R>}` : "";
 
-type Process$15<TString extends string, TPreserve extends boolean = false> = TPreserve extends true ? Concat<[
+type Process$16<TString extends string, TPreserve extends boolean = false> = TPreserve extends true ? Concat<[
     LeftWhitespace<TString>,
     KebabCase<TString, false>,
     RightWhitespace<TString>
@@ -5463,7 +5463,7 @@ type Process$15<TString extends string, TPreserve extends boolean = false> = TPr
  * type Dash = Dasherize<"\n  foo bar \t">;
  * ```
  */
-type KebabCase<TString extends string, TPreserve extends boolean = false> = Process$15<TString, TPreserve> extends string ? Process$15<TString, TPreserve> : never;
+type KebabCase<TString extends string, TPreserve extends boolean = false> = Process$16<TString, TPreserve> extends string ? Process$16<TString, TPreserve> : never;
 
 /**
  * **LowerAllCaps**`<T>
@@ -7140,7 +7140,7 @@ type PhoneCountryLookup = Mutable<[...typeof PHONE_COUNTRY_CODES]>;
  */
 type PhoneCountryCode = FirstOfEach<PhoneCountryLookup>;
 
-type Process$14<T extends string, _TDelimiter extends PhoneNumberDelimiter = PhoneNumberDelimiter> = OnPass<[
+type Process$15<T extends string, _TDelimiter extends PhoneNumberDelimiter = PhoneNumberDelimiter> = OnPass<[
 ], T>;
 /**
  * **PhoneNumber**`<[T]>`
@@ -7161,7 +7161,7 @@ type Process$14<T extends string, _TDelimiter extends PhoneNumberDelimiter = Pho
  *
  * - Related: `PhoneNumberWithCountryCode`, `UsPhoneNumber`
  */
-type PhoneNumber<T extends number | string | null = null, TDelimiter extends PhoneNumberDelimiter = PhoneNumberDelimiter> = T extends null ? LocalPhoneNumber<TDelimiter> | CountryPhoneNumber<TDelimiter> | InternationalPhoneNumber<TDelimiter> : IsStringLiteral<T> extends true ? Process$14<As<T, string>, TDelimiter> : IsNumericLiteral<T> extends true ? Process$14<`${As<T, number>}`, TDelimiter> : T extends string ? string | ErrorCondition<"invalid-phone-number"> : T extends number ? number | ErrorCondition<"invalid-phone-number"> : never;
+type PhoneNumber<T extends number | string | null = null, TDelimiter extends PhoneNumberDelimiter = PhoneNumberDelimiter> = T extends null ? LocalPhoneNumber<TDelimiter> | CountryPhoneNumber<TDelimiter> | InternationalPhoneNumber<TDelimiter> : IsStringLiteral<T> extends true ? Process$15<As<T, string>, TDelimiter> : IsNumericLiteral<T> extends true ? Process$15<`${As<T, number>}`, TDelimiter> : T extends string ? string | ErrorCondition<"invalid-phone-number"> : T extends number ? number | ErrorCondition<"invalid-phone-number"> : never;
 type PhoneNumberWithCountryCode = `+${PhoneCountryCode} ${string}`;
 type Sep = "." | " " | "-";
 type AreaCode = `(${number}) ` | `${number}${Sep}`;
@@ -7857,7 +7857,7 @@ type YouTubeVideosInPlaylist = `https://www.youtube.com/playlist?${string}list=$
  */
 type GetYouTubePageType<T> = T extends YouTubeUrl ? T extends YouTubeHome ? "home" : T extends YouTubeVideoUrl ? HasQueryParameter<T, "list"> extends true ? T extends YouTubeShareUrl ? HasQueryParameter<T, "t"> extends true ? "play::video::in-list::share-link::with-timestamp" : "play::video::in-list::share-link" : "play::video::in-list" : T extends YouTubeShareUrl ? HasQueryParameter<T, "t"> extends true ? "play::video::solo::share-link::with-timestamp" : "play::video::solo::share-link" : "play::video::solo" : T extends YouTubeCreatorUrl ? GetUrlPath<T> extends `${string}/videos` ? "creator::videos" : GetUrlPath<T> extends `${string}/playlists` ? "creator::playlists" : Last<Split<GetUrlPath<T>, "/">> extends `@${string}` ? "creator::featured" : GetUrlPath<T> extends `${string}/featured` ? "creator::featured" : "creator::other" : T extends YouTubeFeedUrl ? T extends YouTubeFeedUrl<"history"> ? "feed::history" : T extends YouTubeFeedUrl<"playlists"> ? "feed::playlists" : T extends YouTubeFeedUrl<"liked"> ? "feed::liked" : T extends YouTubeFeedUrl<"subscriptions"> ? "feed::subscriptions" : T extends YouTubeFeedUrl<"trending"> ? "feed::trending" : "feed::other" : T extends YouTubeVideosInPlaylist ? "playlist::show" : "other" : never;
 
-type Process$12<TStr extends string, TResult extends readonly string[] = []> = IsStringLiteral<TStr> extends true ? IsEqual<TStr["length"], 0> extends true ? [] : TStr extends `${infer Char}${infer Rest}` ? Process$12<Rest, [
+type Process$13<TStr extends string, TResult extends readonly string[] = []> = IsStringLiteral<TStr> extends true ? IsEqual<TStr["length"], 0> extends true ? [] : TStr extends `${infer Char}${infer Rest}` ? Process$13<Rest, [
     ...TResult,
     Char
 ]> : TResult : string;
@@ -7866,10 +7866,10 @@ type Process$12<TStr extends string, TResult extends readonly string[] = []> = I
  *
  * Takes a literal string and converts it to an array of characters.
  */
-type Chars<TStr extends string> = IsStringLiteral<TStr> extends true ? Process$12<TStr> extends readonly string[] ? Process$12<TStr> : never : readonly string[];
+type Chars<TStr extends string> = IsStringLiteral<TStr> extends true ? Process$13<TStr> extends readonly string[] ? Process$13<TStr> : never : readonly string[];
 
 type ElementLiteral<T> = [T] extends [string] ? IsStringLiteral<T> extends true ? T : string : [T] extends [number] ? IsNumericLiteral<T> extends true ? T : `${number}` : [T] extends [boolean] ? IsBooleanLiteral<T> extends true ? T : `${boolean}` : never;
-type Process$11<T extends Tuple, Result extends string = ""> = [] extends T ? Result : Process$11<AfterFirst<T>, `${Result}${ElementLiteral<First<T>>}`>;
+type Process$12<T extends Tuple, Result extends string = ""> = [] extends T ? Result : Process$12<AfterFirst<T>, `${Result}${ElementLiteral<First<T>>}`>;
 /**
  * **Concat**`<T>`
  *
@@ -7885,7 +7885,7 @@ type Process$11<T extends Tuple, Result extends string = ""> = [] extends T ? Re
  *
  * **Related:** `Join<TArr,TWith>`
  */
-type Concat<T extends readonly unknown[]> = Process$11<T>;
+type Concat<T extends readonly unknown[]> = Process$12<T>;
 
 /**
  * The ISO8601 standard means of representing a _timezone_. `Z` by itself represents UTC.
@@ -7946,9 +7946,9 @@ type Iso8601Time<TExplicit extends IsoExplicitness = "both", TZ extends Timezone
  */
 type Iso8601DateTime<TZ extends Timezone | "" = Timezone | ""> = `${number}-${number}-${number}T${number}:${number}:${number}${TZ}`;
 
-type Process$10<TContent extends string, TLeading extends string> = TContent extends `${TLeading}${string}` ? TContent : `${TLeading}${TContent}`;
+type Process$11<TContent extends string, TLeading extends string> = TContent extends `${TLeading}${string}` ? TContent : `${TLeading}${TContent}`;
 type IterateOver$1<TContent extends readonly (string | number)[], TLeading extends string | number> = {
-    [K in keyof TContent]: TContent[K] extends string ? Process$10<TContent[K], AsStringUnion<TLeading>> : TContent[K] extends number ? AsNumber<Process$10<`${TContent[K]}`, AsStringUnion<TLeading>>> : never;
+    [K in keyof TContent]: TContent[K] extends string ? Process$11<TContent[K], AsStringUnion<TLeading>> : TContent[K] extends number ? AsNumber<Process$11<`${TContent[K]}`, AsStringUnion<TLeading>>> : never;
 };
 type WideContent<TContent extends string | number, TLeading extends string | number> = IsString<TContent> extends true ? `${TLeading}${string}` : number;
 type WideLeading<TContent extends string | number, TLeading extends string | number> = TContent extends string ? `${TLeading}${TContent}` : number;
@@ -7973,7 +7973,7 @@ type WideLeading<TContent extends string | number, TLeading extends string | num
  *
  * **Related:** `EnsureLeadingEvery`, `EnsureTrailing`, `EnsureSurround`, `Surround`
  */
-type EnsureLeading<TContent extends string | number | readonly (string | number)[], TLeading extends string | number> = TContent extends readonly (string | number)[] ? IterateOver$1<TContent, TLeading> : IsWideType<TContent> extends true ? WideContent<As<TContent, string | number>, TLeading> : IsWideType<TLeading> extends true ? WideLeading<As<TContent, string | number>, TLeading> : TContent extends string ? Process$10<TContent, AsStringUnion<TLeading>> : TContent extends number ? AsNumber<Process$10<`${TContent}`, AsStringUnion<TLeading>>> : never;
+type EnsureLeading<TContent extends string | number | readonly (string | number)[], TLeading extends string | number> = TContent extends readonly (string | number)[] ? IterateOver$1<TContent, TLeading> : IsWideType<TContent> extends true ? WideContent<As<TContent, string | number>, TLeading> : IsWideType<TLeading> extends true ? WideLeading<As<TContent, string | number>, TLeading> : TContent extends string ? Process$11<TContent, AsStringUnion<TLeading>> : TContent extends number ? AsNumber<Process$11<`${TContent}`, AsStringUnion<TLeading>>> : never;
 
 /**
  * **EnsureSurround**
@@ -8535,7 +8535,7 @@ type TypeStrength = "strong" | "simple";
 type StripSlash<T extends readonly string[]> = {
     [K in keyof T]: T[K] extends `/${infer Middle}/` ? Middle : T[K] extends `/${infer Trailing}` ? Trailing : T[K] extends `${infer Leading}/` ? Leading : T[K];
 };
-type Process$Z<TPath extends string, TFirst extends string, TLast extends string> = TFirst extends `/${string}` ? TLast extends `${string}/` ? `/${TPath}/` : `/${TPath}` : TLast extends `${string}/` ? `${TPath}/` : TPath;
+type Process$_<TPath extends string, TFirst extends string, TLast extends string> = TFirst extends `/${string}` ? TLast extends `${string}/` ? `/${TPath}/` : `/${TPath}` : TLast extends `${string}/` ? `${TPath}/` : TPath;
 /**
  * **PathJoin**`<T,U>`
  *
@@ -8549,7 +8549,7 @@ type Process$Z<TPath extends string, TFirst extends string, TLast extends string
  * `EnsureStarting<T>`, and `StripStarting<T>` to further shape
  * the type.
  */
-type PathJoin<TSegments extends readonly string[]> = StripSlash<TSegments> extends readonly string[] ? Process$Z<Join<StripSlash<TSegments>, "/">, First<TSegments>, Last<TSegments>> : never;
+type PathJoin<TSegments extends readonly string[]> = StripSlash<TSegments> extends readonly string[] ? Process$_<Join<StripSlash<TSegments>, "/">, First<TSegments>, Last<TSegments>> : never;
 
 type ExceptionLookup = typeof PLURAL_EXCEPTIONS;
 type SingularNoun = "s" | "sh" | "ch" | "x" | "z" | "o";
@@ -8621,7 +8621,7 @@ type _RetainAfter<TStr extends string, TBreak extends string, TInclude extends b
  */
 type RetainAfter<TStr extends string, TBreak extends string, TInclude extends boolean = false> = IsNever<_RetainAfter<TStr, TBreak, TInclude>> extends true ? "" : IsUnion<_RetainAfter<TStr, TBreak, TInclude>> extends true ? MaxLength<UnionToTuple$1<_RetainAfter<TStr, TBreak, TInclude>>> : _RetainAfter<TStr, TBreak, TInclude>;
 
-type Process$Y<TChars extends readonly string[], TOp extends "is" | "not", TComparator extends string, TInclude extends boolean = false, TResult extends string = ""> = [] extends TChars ? TResult : First<TChars> extends TComparator ? TOp extends "is" ? Process$Y<AfterFirst<TChars>, TOp, TComparator, TInclude, `${TResult}${First<TChars>}`> : If<TInclude, `${TResult}${First<TChars>}`, TResult> : TOp extends "is" ? If<TInclude, `${TResult}${First<TChars>}`, TResult> : Process$Y<AfterFirst<TChars>, TOp, TComparator, TInclude, `${TResult}${First<TChars>}`>;
+type Process$Z<TChars extends readonly string[], TOp extends "is" | "not", TComparator extends string, TInclude extends boolean = false, TResult extends string = ""> = [] extends TChars ? TResult : First<TChars> extends TComparator ? TOp extends "is" ? Process$Z<AfterFirst<TChars>, TOp, TComparator, TInclude, `${TResult}${First<TChars>}`> : If<TInclude, `${TResult}${First<TChars>}`, TResult> : TOp extends "is" ? If<TInclude, `${TResult}${First<TChars>}`, TResult> : Process$Z<AfterFirst<TChars>, TOp, TComparator, TInclude, `${TResult}${First<TChars>}`>;
 /**
  * **RetainUntil**`<TContent,TComparator>`
  *
@@ -8635,7 +8635,7 @@ type Process$Y<TChars extends readonly string[], TOp extends "is" | "not", TComp
  *
  * **Related:** `RetainWhile`
  */
-type RetainUntil<TContent extends string, TComparator extends string, TInclude extends boolean = false> = Process$Y<Chars<TContent>, "not", TComparator, TInclude>;
+type RetainUntil<TContent extends string, TComparator extends string, TInclude extends boolean = false> = Process$Z<Chars<TContent>, "not", TComparator, TInclude>;
 /**
  * **RetainWhile**`<TContent,TComparator>`
  *
@@ -8649,7 +8649,7 @@ type RetainUntil<TContent extends string, TComparator extends string, TInclude e
  *
  * **Related:** `RetainUntil`
  */
-type RetainWhile<TContent extends string, TComparator extends string> = Process$Y<Chars<TContent>, "is", TComparator>;
+type RetainWhile<TContent extends string, TComparator extends string> = Process$Z<Chars<TContent>, "is", TComparator>;
 
 type Policy = "omit" | "before" | "after";
 type Postfix<T extends string> = ["postfix", T];
@@ -8666,7 +8666,7 @@ type EachBlock<TContent extends readonly (string | Postfix<string>)[], TSep exte
     First<TContent>
 ]>;
 type Iterate$3<TContent extends readonly (string | Postfix<string>)[], TSep extends readonly string[], TPolicy extends Policy> = [] extends TSep ? FixPostfix<Filter<TContent, "", "equals">> : Iterate$3<EachBlock<TContent, First<TSep>, TPolicy>, AfterFirst<TSep>, TPolicy>;
-type Process$X<TContent extends string, TSep extends string | readonly string[], TPolicy extends Policy = "omit"> = IsLiteral<TSep> extends true ? TSep extends "" ? ErrMsg<"invalid-separator", `Split<T>: an empty string was used as a separator. Use Chars<T> if you want to split a string into characters!`> : TSep extends readonly string[] ? Iterate$3<[TContent], TSep, TPolicy> : TSep extends string ? Convert$3<TContent, TSep, TPolicy> extends readonly (string | Postfix<string>)[] ? FixPostfix<Convert$3<TContent, TSep, TPolicy>> : never : never : never;
+type Process$Y<TContent extends string, TSep extends string | readonly string[], TPolicy extends Policy = "omit"> = IsLiteral<TSep> extends true ? TSep extends "" ? ErrMsg<"invalid-separator", `Split<T>: an empty string was used as a separator. Use Chars<T> if you want to split a string into characters!`> : TSep extends readonly string[] ? Iterate$3<[TContent], TSep, TPolicy> : TSep extends string ? Convert$3<TContent, TSep, TPolicy> extends readonly (string | Postfix<string>)[] ? FixPostfix<Convert$3<TContent, TSep, TPolicy>> : never : never : never;
 /**
  * **Split**`<TContent,TSep,[TPolicy]>`
  *
@@ -8681,7 +8681,7 @@ type Process$X<TContent extends string, TSep extends string | readonly string[],
  * than `SplitAlt` but there are instances where `SplitAlt` is more performant
  * in inference.
  */
-type Split<TContent extends string, TSep extends string | readonly string[], TPolicy extends Policy = "omit"> = IsStringLiteral<TContent> extends true ? IsUnion<TSep> extends true ? UnionToTuple$1<TSep> extends readonly string[] ? Split<TContent, UnionToTuple$1<TSep>, TPolicy> : ErrMsg<"invalid-union"> : Process$X<TContent, TSep, TPolicy> : string[];
+type Split<TContent extends string, TSep extends string | readonly string[], TPolicy extends Policy = "omit"> = IsStringLiteral<TContent> extends true ? IsUnion<TSep> extends true ? UnionToTuple$1<TSep> extends readonly string[] ? Split<TContent, UnionToTuple$1<TSep>, TPolicy> : ErrMsg<"invalid-union"> : Process$Y<TContent, TSep, TPolicy> : string[];
 
 type UnionPolicy = "omit" | "include";
 type UnionSplit<TContent extends readonly string[], TSep extends string, TUnionPolicy extends UnionPolicy, TResult extends readonly string[] = []> = [] extends TContent ? TResult : UnionSplit<AfterFirst<TContent>, // advance to next character
@@ -8696,8 +8696,8 @@ type LiteralSplit<TContent extends string, TSep extends string, TUnionPolicy ext
     ...TResults,
     TUnionPolicy extends "omit" ? Block : `${Block}${TSep}`
 ]> : Filter<[...TResults, TContent], "">;
-type Process$W<TContent extends string, TSep extends string | readonly string[], TUnionPolicy extends UnionPolicy = "omit"> = IsWideType<TContent> extends true ? string : TSep extends readonly string[] ? TupleToUnion<TSep> extends string ? Chars<TContent> extends readonly string[] ? UnionSplit<Chars<TContent>, TupleToUnion<TSep>, TUnionPolicy> : never : never : TSep extends string ? LiteralSplit<TContent, TSep, TUnionPolicy> : never;
-type PreProcess$1<TContent extends string, TSep extends string | readonly string[], TUnionPolicy extends UnionPolicy = "omit"> = IsUnion<TSep> extends true ? UnionToTuple$1<TSep> extends readonly string[] ? Process$W<TContent, UnionToTuple$1<TSep>, TUnionPolicy> : never : Process$W<TContent, TSep, TUnionPolicy>;
+type Process$X<TContent extends string, TSep extends string | readonly string[], TUnionPolicy extends UnionPolicy = "omit"> = IsWideType<TContent> extends true ? string : TSep extends readonly string[] ? TupleToUnion<TSep> extends string ? Chars<TContent> extends readonly string[] ? UnionSplit<Chars<TContent>, TupleToUnion<TSep>, TUnionPolicy> : never : never : TSep extends string ? LiteralSplit<TContent, TSep, TUnionPolicy> : never;
+type PreProcess$1<TContent extends string, TSep extends string | readonly string[], TUnionPolicy extends UnionPolicy = "omit"> = IsUnion<TSep> extends true ? UnionToTuple$1<TSep> extends readonly string[] ? Process$X<TContent, UnionToTuple$1<TSep>, TUnionPolicy> : never : Process$X<TContent, TSep, TUnionPolicy>;
 /**
  * **SplitAlt**`<TContent,TSep,[TPolicy]>`
  *
@@ -8737,7 +8737,7 @@ type StripAfter<TStr extends string, TBreak extends string> = IsStringLiteral<TS
  */
 type StripBefore<TStr extends string, TBreak extends string> = IsStringLiteral<TStr> extends true ? IsStringLiteral<TBreak> extends true ? TStr extends `${string}${TBreak}${infer REST}` ? `${REST}` : TStr : string : string;
 
-type Process$V<TContent extends string, TStrip extends string> = And<[IsStringLiteral<TContent>, IsStringLiteral<TStrip>]> extends true ? TContent extends `${TStrip & string}${infer After}` ? After : TContent : string;
+type Process$W<TContent extends string, TStrip extends string> = And<[IsStringLiteral<TContent>, IsStringLiteral<TStrip>]> extends true ? TContent extends `${TStrip & string}${infer After}` ? After : TContent : string;
 /**
  * **StripLeading**`<T, U>`
  *
@@ -8754,9 +8754,9 @@ type Process$V<TContent extends string, TStrip extends string> = And<[IsStringLi
  *   - if `T` is a non-string type then no transformation will be done
  *   - same applies to `U`
  */
-type StripLeading<TContent extends string | number, TStrip extends string | number> = TContent extends number ? AsNumber<Process$V<`${TContent}`, AsStringUnion<TStrip>>> : TContent extends string ? Process$V<TContent, AsStringUnion<TStrip>> : never;
+type StripLeading<TContent extends string | number, TStrip extends string | number> = TContent extends number ? AsNumber<Process$W<`${TContent}`, AsStringUnion<TStrip>>> : TContent extends string ? Process$W<TContent, AsStringUnion<TStrip>> : never;
 
-type Process$U<TContent extends string, TSurround extends string> = TContent extends `${TSurround}${infer REMAIN}` ? REMAIN extends `${infer LEADING}${TSurround}` ? LEADING : REMAIN : TContent extends `${infer LEADING}${TSurround}` ? LEADING : TContent;
+type Process$V<TContent extends string, TSurround extends string> = TContent extends `${TSurround}${infer REMAIN}` ? REMAIN extends `${infer LEADING}${TSurround}` ? LEADING : REMAIN : TContent extends `${infer LEADING}${TSurround}` ? LEADING : TContent;
 /**
  * **StripSurround**`<TContent, TSurround>`
  *
@@ -8768,9 +8768,9 @@ type Process$U<TContent extends string, TSurround extends string> = TContent ext
  * type Hello = StripSurround<"(Hi there)", "(" | ")">;
  * ```
  */
-type StripSurround<TContent extends string | number, TSurround extends string | number> = IsWideType<TContent> extends true ? TContent : TContent extends string ? Process$U<TContent, AsStringUnion<TSurround>> : AsNumber<Process$U<`${TContent}`, AsStringUnion<TSurround>>>;
+type StripSurround<TContent extends string | number, TSurround extends string | number> = IsWideType<TContent> extends true ? TContent : TContent extends string ? Process$V<TContent, AsStringUnion<TSurround>> : AsNumber<Process$V<`${TContent}`, AsStringUnion<TSurround>>>;
 
-type Process$T<TContent extends string, TStrip extends string> = And<[IsStringLiteral<TContent>, IsStringLiteral<TStrip>]> extends true ? TContent extends `${infer Before}${TStrip}` ? Before : TContent : string;
+type Process$U<TContent extends string, TStrip extends string> = And<[IsStringLiteral<TContent>, IsStringLiteral<TStrip>]> extends true ? TContent extends `${infer Before}${TStrip}` ? Before : TContent : string;
 /**
  * **StripEnding**`<TContent, TStrip>`
  *
@@ -8784,23 +8784,23 @@ type Process$T<TContent extends string, TStrip extends string> = And<[IsStringLi
  * type R = StripEnding<T,U>;
  * ```
  */
-type StripTrailing<TContent extends string | number, TStrip extends string | number> = TContent extends number ? AsNumber<Process$T<`${TContent}`, `${TStrip}`> extends `${number}` ? Process$T<`${TContent}`, `${TStrip}`> : never> : TContent extends string ? Process$T<`${TContent}`, `${TStrip}`> extends string ? Process$T<`${TContent}`, `${TStrip}`> : never : never;
+type StripTrailing<TContent extends string | number, TStrip extends string | number> = TContent extends number ? AsNumber<Process$U<`${TContent}`, `${TStrip}`> extends `${number}` ? Process$U<`${TContent}`, `${TStrip}`> : never> : TContent extends string ? Process$U<`${TContent}`, `${TStrip}`> extends string ? Process$U<`${TContent}`, `${TStrip}`> : never : never;
 
-type Process$S<TChars extends readonly string[], TOp extends "is" | "not", TComparator extends string, TResult extends string> = [] extends TChars ? TResult : First<TChars> extends TComparator ? TOp extends "is" ? Process$S<AfterFirst<TChars>, TOp, TComparator, Shift<TResult> extends string ? Shift<TResult> : ""> : TResult : TOp extends "is" ? TResult : Process$S<AfterFirst<TChars>, TOp, TComparator, Shift<TResult> extends string ? Shift<TResult> : "">;
+type Process$T<TChars extends readonly string[], TOp extends "is" | "not", TComparator extends string, TResult extends string> = [] extends TChars ? TResult : First<TChars> extends TComparator ? TOp extends "is" ? Process$T<AfterFirst<TChars>, TOp, TComparator, Shift<TResult> extends string ? Shift<TResult> : ""> : TResult : TOp extends "is" ? TResult : Process$T<AfterFirst<TChars>, TOp, TComparator, Shift<TResult> extends string ? Shift<TResult> : "">;
 /**
  * **StripUntil**`<TContent,TComparator>`
  *
  * Strip characters from the start of `TContent` _until_ a
  * character extends `TComparator`.
  */
-type StripUntil<TContent extends string, TComparator extends string> = Process$S<Chars<TContent>, "not", TComparator, TContent>;
+type StripUntil<TContent extends string, TComparator extends string> = Process$T<Chars<TContent>, "not", TComparator, TContent>;
 /**
  * **StripWhile**`<TContent,TComparator>`
  *
  * Strip characters from the start of `TContent` _while_ those
  * characters extend `TComparator`.
  */
-type StripWhile<TContent extends string, TComparator extends string> = Process$S<Chars<TContent>, "is", TComparator, TContent>;
+type StripWhile<TContent extends string, TComparator extends string> = Process$T<Chars<TContent>, "is", TComparator, TContent>;
 
 type Compute<TStr extends string, TLen extends Tuple = []> = TStr extends `${infer _Char}${infer Rest}` ? Compute<Rest, [...TLen, unknown]> : TLen["length"];
 /**
@@ -8811,9 +8811,9 @@ type Compute<TStr extends string, TLen extends Tuple = []> = TStr extends `${inf
  */
 type StrLen<T extends string> = Compute<T>;
 
-type Process$R<TContent extends string, TPrefix extends string, TPostfix extends string> = `${TPrefix}${TContent}${TPostfix}`;
+type Process$S<TContent extends string, TPrefix extends string, TPostfix extends string> = `${TPrefix}${TContent}${TPostfix}`;
 type ProcessEach<TContent extends readonly string[], TPrefix extends string, TPostfix extends string> = {
-    [K in keyof TContent]: Process$R<TContent[K], TPrefix, TPostfix>;
+    [K in keyof TContent]: Process$S<TContent[K], TPrefix, TPostfix>;
 };
 /**
  * **Surround**`<TContent,TPrefix,TPostfix>`
@@ -8828,7 +8828,7 @@ type ProcessEach<TContent extends readonly string[], TPrefix extends string, TPo
  * type T2 = Surround<["one","two"], "<",">">;
  * ```
  */
-type Surround<TContent extends string | number | readonly (string | number)[], TPrefix extends string, TPostfix extends string> = TContent extends number ? Surround<`${TContent}`, TPrefix, TPostfix> : TContent extends readonly unknown[] ? TContent extends readonly string[] ? ProcessEach<TContent, TPrefix, TPostfix> : ProcessEach<ToStringArray<TContent> extends readonly string[] ? ToStringArray<TContent> : never, TPrefix, TPostfix> : TContent extends string ? Process$R<TContent, TPrefix, TPostfix> : never;
+type Surround<TContent extends string | number | readonly (string | number)[], TPrefix extends string, TPostfix extends string> = TContent extends number ? Surround<`${TContent}`, TPrefix, TPostfix> : TContent extends readonly unknown[] ? TContent extends readonly string[] ? ProcessEach<TContent, TPrefix, TPostfix> : ProcessEach<ToStringArray<TContent> extends readonly string[] ? ToStringArray<TContent> : never, TPrefix, TPostfix> : TContent extends string ? Process$S<TContent, TPrefix, TPostfix> : never;
 
 type CivilianTwoDigitHour = "10" | "11" | "12";
 type TimeResolution = "HH:MM" | "HH:MM:SS" | "HH:MM:SS.ms";
@@ -9010,7 +9010,7 @@ type TypeSubtype = `${string}/${string}` & {
     brand: "type-subtype";
 };
 
-type Process$Q<T> = T extends NumberLike ? AsNumber<T> : T extends BooleanLike ? AsBoolean<T> : T;
+type Process$R<T> = T extends NumberLike ? AsNumber<T> : T extends BooleanLike ? AsBoolean<T> : T;
 /**
  * **UnderlyingType**`<T>`
  *
@@ -9023,8 +9023,8 @@ type Process$Q<T> = T extends NumberLike ? AsNumber<T> : T extends BooleanLike ?
  * In all other cases it simply proxies the type of `T` through.
  */
 type UnderlyingType<T> = T extends readonly unknown[] ? {
-    [K in keyof T]: Process$Q<T[K]>;
-} : Process$Q<T>;
+    [K in keyof T]: Process$R<T[K]>;
+} : Process$R<T>;
 
 /**
  * **JsonValue**`<T>`
@@ -9101,7 +9101,7 @@ type MutableArray<T extends readonly unknown[]> = [
  */
 type Mutable<T> = [T] extends [readonly unknown[]] ? MutableArray<T> : [T] extends [boolean] ? T : [IsObjectLiteral<T>] extends [true] ? MutableObject<T> : T;
 
-type Process$O<TSource extends AnyObject, TKeys extends readonly (ObjectKey & keyof TSource)[], TTuple extends readonly KeyValue[] = []> = [] extends TKeys ? TTuple : Process$O<TSource, AfterFirst<TKeys>, [
+type Process$P<TSource extends AnyObject, TKeys extends readonly (ObjectKey & keyof TSource)[], TTuple extends readonly KeyValue[] = []> = [] extends TKeys ? TTuple : Process$P<TSource, AfterFirst<TKeys>, [
     ...TTuple,
     {
         key: First<TKeys>;
@@ -9125,10 +9125,10 @@ type Compact<TSource extends AnyObject, TKeys extends readonly (ObjectKey & keyo
  * type C = ObjectToTuple< foo: 1 }, true>;
  * ```
  */
-type ObjectToTuple<TObj extends AnyObject, TCompact extends boolean = false> = TObj extends ExplicitlyEmptyObject ? [] : IsWideContainer<TObj> extends true ? TCompact extends false ? KeyValue[] : Record<ObjectKey, any>[] : TCompact extends false ? Process$O<TObj, As<Keys<TObj>, readonly (ObjectKey & keyof TObj)[]>> : Compact<TObj, As<Keys<TObj>, readonly (ObjectKey & keyof TObj)[]>>;
+type ObjectToTuple<TObj extends AnyObject, TCompact extends boolean = false> = TObj extends ExplicitlyEmptyObject ? [] : IsWideContainer<TObj> extends true ? TCompact extends false ? KeyValue[] : Record<ObjectKey, any>[] : TCompact extends false ? Process$P<TObj, As<Keys<TObj>, readonly (ObjectKey & keyof TObj)[]>> : Compact<TObj, As<Keys<TObj>, readonly (ObjectKey & keyof TObj)[]>>;
 
 type Prefix$2<T extends boolean> = T extends true ? "\n  " : "";
-type Process$N<T extends readonly Record<ObjectKey, any>[], E extends boolean> = Join<{
+type Process$O<T extends readonly Record<ObjectKey, any>[], E extends boolean> = Join<{
     [K in keyof T]: T[K] extends Record<infer Key extends string, infer Value> ? `${Prefix$2<E>}${Key}: ${AsString<Value>}` : never;
 }, "; ">;
 /**
@@ -9138,10 +9138,10 @@ type Process$N<T extends readonly Record<ObjectKey, any>[], E extends boolean> =
  *
  * **Related:** `ObjectToJsString`, `ObjectToJsonString`, `ObjectToTuple`
  */
-type ObjectToCssString<TObj extends AnyObject, TExpand extends boolean = false> = TObj extends ExplicitlyEmptyObject ? "{}" : IsWideContainer<TObj> extends true ? string : Surround<Process$N<ObjectToTuple<TObj, true>, false>, TExpand extends false ? "{ " : "{", TExpand extends false ? " }" : "\n}">;
+type ObjectToCssString<TObj extends AnyObject, TExpand extends boolean = false> = TObj extends ExplicitlyEmptyObject ? "{}" : IsWideContainer<TObj> extends true ? string : Surround<Process$O<ObjectToTuple<TObj, true>, false>, TExpand extends false ? "{ " : "{", TExpand extends false ? " }" : "\n}">;
 
 type Prefix<T extends boolean> = T extends true ? "\n  " : "";
-type Process$K<T extends readonly Record<ObjectKey, any>[], E extends boolean> = Join<{
+type Process$L<T extends readonly Record<ObjectKey, any>[], E extends boolean> = Join<{
     [K in keyof T]: T[K] extends Record<infer Key extends string, infer Value> ? Value extends AnyObject ? `${Prefix<E>}${Key} ${AsString<Value>}` : never : never;
 }, "\n  ">;
 /**
@@ -9151,7 +9151,7 @@ type Process$K<T extends readonly Record<ObjectKey, any>[], E extends boolean> =
  *
  * **Related:** `ObjectToJsString`, `ObjectToJsonString`, `ObjectToTuple`, `ObjectToCssString`
  */
-type ObjectToKeyframeString<TObj extends AnyObject, TExpand extends boolean = false> = TObj extends ExplicitlyEmptyObject ? "{}" : IsWideContainer<TObj> extends true ? string : Surround<Process$K<ObjectToTuple<TObj, true>, false>, TExpand extends false ? "{ " : "{\n  ", TExpand extends false ? " }" : "\n}">;
+type ObjectToKeyframeString<TObj extends AnyObject, TExpand extends boolean = false> = TObj extends ExplicitlyEmptyObject ? "{}" : IsWideContainer<TObj> extends true ? string : Surround<Process$L<ObjectToTuple<TObj, true>, false>, TExpand extends false ? "{ " : "{\n  ", TExpand extends false ? " }" : "\n}">;
 
 /**
  * **RemoveIndex**`<T>`
@@ -9186,9 +9186,9 @@ type RemoveIndex<T extends Record<any, any>> = {
  */
 type Replace<TText extends string, TFind extends string, TReplace extends string> = TText extends "" ? If<IsEqual<TFind, "">, TReplace, ""> : TFind extends "" ? TText : TText extends `${infer F}${TFind}${infer E}` ? `${F}${TReplace}${E}` : TText;
 
-type Process$J<TText extends string, TFind extends string, TReplace extends string> = Replace<TText, TFind, TReplace> extends `${string}${TFind}${string}` ? Process$J<Replace<TText, TFind, TReplace>, TFind, TReplace> : Replace<TText, TFind, TReplace>;
-type Iterate$2<TText extends string, TFind extends readonly string[], TReplace extends string> = [] extends TFind ? TText : Iterate$2<Process$J<TText, First<TFind>, TReplace>, AfterFirst<TFind>, TReplace>;
-type Singular<TText extends string, TFind extends string, TReplace extends string> = IsStringLiteral<TText> extends true ? IsStringLiteral<TFind> extends true ? IsUnion<TFind> extends true ? UnionToTuple$1<TFind> extends readonly string[] ? Iterate$2<TText, UnionToTuple$1<TFind>, TReplace> : never : Process$J<TText, TFind, TReplace> : string : string;
+type Process$K<TText extends string, TFind extends string, TReplace extends string> = Replace<TText, TFind, TReplace> extends `${string}${TFind}${string}` ? Process$K<Replace<TText, TFind, TReplace>, TFind, TReplace> : Replace<TText, TFind, TReplace>;
+type Iterate$2<TText extends string, TFind extends readonly string[], TReplace extends string> = [] extends TFind ? TText : Iterate$2<Process$K<TText, First<TFind>, TReplace>, AfterFirst<TFind>, TReplace>;
+type Singular<TText extends string, TFind extends string, TReplace extends string> = IsStringLiteral<TText> extends true ? IsStringLiteral<TFind> extends true ? IsUnion<TFind> extends true ? UnionToTuple$1<TFind> extends readonly string[] ? Iterate$2<TText, UnionToTuple$1<TFind>, TReplace> : never : Process$K<TText, TFind, TReplace> : string : string;
 type Multiple<TText extends readonly string[], TFind extends string, TReplace extends string, TResult extends readonly string[] = []> = [] extends TText ? TResult : Multiple<AfterFirst<TText>, TFind, TReplace, [
     ...TResult,
     ReplaceAll<First<TText>, TFind, TReplace>
@@ -9212,7 +9212,7 @@ type Multiple<TText extends readonly string[], TFind extends string, TReplace ex
  */
 type ReplaceAll<TText extends string | readonly string[], TFind extends string, TReplace extends string> = TText extends readonly string[] ? IsLiteral<TText> extends true ? Multiple<TText, TFind, TReplace> : string[] : TText extends string ? Singular<TText, TFind, TReplace> : never;
 
-type Process$I<TChars extends readonly string[], TRetain extends string> = RemoveMarked<{
+type Process$J<TChars extends readonly string[], TRetain extends string> = RemoveMarked<{
     [K in keyof TChars]: TChars[K] extends TRetain ? TChars[K] : Constant$1<"Marked">;
 }>;
 /**
@@ -9222,7 +9222,7 @@ type Process$I<TChars extends readonly string[], TRetain extends string> = Remov
  * of the characters in `TRetain` _retained_ while all
  * other characters are removed.
  */
-type RetainChars<TContent extends string, TRetain extends string> = Or<[IsWideType<TContent>, IsWideType<TRetain>]> extends true ? string : Process$I<Chars<TContent>, TRetain> extends readonly string[] ? Join<Process$I<Chars<TContent>, TRetain>> : never;
+type RetainChars<TContent extends string, TRetain extends string> = Or<[IsWideType<TContent>, IsWideType<TRetain>]> extends true ? string : Process$J<Chars<TContent>, TRetain> extends readonly string[] ? Join<Process$J<Chars<TContent>, TRetain>> : never;
 
 /**
  * Provides the _left_ whitespace of a string
@@ -9236,7 +9236,7 @@ type RightWhitespace<S extends string> = string extends S ? string : Replace<S,
 type Strip<TChars extends readonly string[], TStrip extends string> = {
     [K in keyof TChars]: TChars[K] extends TStrip ? Marked$3 : TChars[K];
 };
-type Process$H<TChars extends readonly string[], TStrip extends string> = As<RemoveMarked<Strip<TChars, TStrip>>, readonly string[]>;
+type Process$I<TChars extends readonly string[], TStrip extends string> = As<RemoveMarked<Strip<TChars, TStrip>>, readonly string[]>;
 /**
  * **StripChars**`<TContent,TStrip>`
  *
@@ -9247,7 +9247,7 @@ type Process$H<TChars extends readonly string[], TStrip extends string> = As<Rem
  * of single characters or this will throw
  * `ErrorCondition<"invalid-strip-char">`
  */
-type StripChars<TContent extends string, TStrip extends string> = Or<[IsWideType<TContent>, IsWideType<TStrip>]> extends true ? string : Chars<TContent> extends readonly string[] ? Concat<Process$H<Chars<TContent>, TStrip>> extends string ? Concat<Process$H<Chars<TContent>, TStrip>> : never : never;
+type StripChars<TContent extends string, TStrip extends string> = Or<[IsWideType<TContent>, IsWideType<TStrip>]> extends true ? string : Chars<TContent> extends readonly string[] ? Concat<Process$I<Chars<TContent>, TStrip>> extends string ? Concat<Process$I<Chars<TContent>, TStrip>> : never : never;
 
 /**
  * **ToNumber**`<T>`
@@ -9290,7 +9290,7 @@ type ToStringArray<T extends Tuple> = {
     [K in keyof T]: AsString<T[K]>;
 } : never;
 
-type Process$G<S extends string> = string extends S ? string : S extends `${Whitespace}${infer Right}` ? Process$G<Right> : S extends `${infer Left}${Whitespace}` ? Process$G<Left> : S;
+type Process$H<S extends string> = string extends S ? string : S extends `${Whitespace}${infer Right}` ? Process$H<Right> : S extends `${infer Left}${Whitespace}` ? Process$H<Left> : S;
 /**
  * Trims off blank spaces, `\n` and `\t` characters from both sides of a _string literal_.
  * ```ts
@@ -9300,7 +9300,7 @@ type Process$G<S extends string> = string extends S ? string : S extends `${Whit
  * type T = Trim<string>;
  * ```
  */
-type Trim<S extends string> = Process$G<S> extends string ? Process$G<S> : never;
+type Trim<S extends string> = Process$H<S> extends string ? Process$H<S> : never;
 
 /**
  * Trims off whitespace on left of string
@@ -9375,10 +9375,10 @@ type GetKeys$1<T extends AnyFunction> = FnProps<T> extends Dictionary ? Keys<FnP
  * Widens any _scalar_ type `T`.
  */
 type WidenScalar<T extends Scalar> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends symbol ? symbol : T extends null ? null : never;
-type Process$D<T> = T extends Scalar ? WidenScalar<T> : T extends unknown[] ? T extends (infer Type)[] ? IsUnion<Type> extends true ? WidenUnion<Type>[] : Type extends unknown[] ? WidenTuple<Type> : T : never : T extends AnyFunction ? GetKeys$1<T>["length"] extends 0 ? RemoveFnProps<T> : RemoveFnProps<T> & ExpandRecursively<WidenObj<FnProps<T>, GetKeys$1<T>>> : T;
-type WidenObj<T extends Dictionary, TKeys extends readonly (keyof T)[], TResults extends Dictionary = EmptyObject> = [] extends TKeys ? TResults : WidenObj<T, AfterFirst<TKeys>, TResults & Record<First<TKeys>, T[First<TKeys>] extends TypedFunction ? WidenFn<IsNarrowingFn<T[First<TKeys>]>, Parameters<T[First<TKeys>]>, ReturnType<T[First<TKeys>]>, ExpandDictionary<FnProps<T[First<TKeys>]>>> : IsLiteral<T[First<TKeys>]> extends true ? WidenLiteral<T[First<TKeys>]> : Process$D<T[First<TKeys>]>>>;
+type Process$E<T> = T extends Scalar ? WidenScalar<T> : T extends unknown[] ? T extends (infer Type)[] ? IsUnion<Type> extends true ? WidenUnion<Type>[] : Type extends unknown[] ? WidenTuple<Type> : T : never : T extends AnyFunction ? GetKeys$1<T>["length"] extends 0 ? RemoveFnProps<T> : RemoveFnProps<T> & ExpandRecursively<WidenObj<FnProps<T>, GetKeys$1<T>>> : T;
+type WidenObj<T extends Dictionary, TKeys extends readonly (keyof T)[], TResults extends Dictionary = EmptyObject> = [] extends TKeys ? TResults : WidenObj<T, AfterFirst<TKeys>, TResults & Record<First<TKeys>, T[First<TKeys>] extends TypedFunction ? WidenFn<IsNarrowingFn<T[First<TKeys>]>, Parameters<T[First<TKeys>]>, ReturnType<T[First<TKeys>]>, ExpandDictionary<FnProps<T[First<TKeys>]>>> : IsLiteral<T[First<TKeys>]> extends true ? WidenLiteral<T[First<TKeys>]> : Process$E<T[First<TKeys>]>>>;
 type WidenTuple<T extends readonly unknown[]> = {
-    [K in keyof T]: IsLiteral<T[K]> extends true ? WidenLiteral<T[K]> : Process$D<T[K]>;
+    [K in keyof T]: IsLiteral<T[K]> extends true ? WidenLiteral<T[K]> : Process$E<T[K]>;
 };
 type WidenFnParams<T extends readonly unknown[]> = {
     [K in keyof T]: IsLiteral<T[K]> extends true ? WidenLiteral<T[K]> : IsLiteralUnion<T[K]> extends true ? WidenUnion<T[K]> : T[K];
@@ -9411,10 +9411,10 @@ type WidenContainer<T extends Container, TForce extends boolean = false> = [
  * **Note:** should you want the container values to be fully widened you
  * can set `TForce` to true.
  */
-type Widen<T, TForce extends boolean = false> = [IsUnion<T>] extends [true] ? WidenUnion<T> : T extends Container ? WidenContainer<T, TForce> : T extends Scalar ? WidenScalar<T> : Process$D<T>;
+type Widen<T, TForce extends boolean = false> = [IsUnion<T>] extends [true] ? WidenUnion<T> : T extends Container ? WidenContainer<T, TForce> : T extends Scalar ? WidenScalar<T> : Process$E<T>;
 
 type Tighten<T extends string> = T extends ` ${infer Rest extends string}` ? T extends `  ${infer Double extends string}` ? Double : Rest : T;
-type Process$C<T extends string, Result extends readonly unknown[] = []> = T extends `${infer Element},${infer Rest}` ? Process$C<Rest, [
+type Process$D<T extends string, Result extends readonly unknown[] = []> = T extends `${infer Element},${infer Rest}` ? Process$D<Rest, [
     ...Result,
     Tighten<Element> extends NumberLike ? AsNumber<Tighten<Element>> : Tighten<Element>
 ]> : [
@@ -9445,7 +9445,7 @@ type ProcessUnionStr<T extends string, Result extends string | number = never> =
  *
  * **Related:** `CsvToTupleStr`, `CsvToUnion`
  */
-type CsvToTuple<T extends string> = Process$C<T>;
+type CsvToTuple<T extends string> = Process$D<T>;
 /**
  * **CsvToTupleStr**`<T>`
  *
@@ -9610,12 +9610,12 @@ type WideFlatten<T> = T extends (infer Type)[] ? Type extends unknown[] ? Type :
  * Just returns `TList` "as is" if it's not a a Tuple or
  * Union type.
  */
-type Process$w<TList, TLevel extends 1 | 2 | 3 = 1> = TList extends readonly unknown[] ? IsTuple<TList> extends true ? FlattenTuple<TList, TLevel> : WideFlatten<TList> : IsUnion<TList> extends true ? FlattenUnion<TList> : TList;
+type Process$x<TList, TLevel extends 1 | 2 | 3 = 1> = TList extends readonly unknown[] ? IsTuple<TList> extends true ? FlattenTuple<TList, TLevel> : WideFlatten<TList> : IsUnion<TList> extends true ? FlattenUnion<TList> : TList;
 /**
  * converts a wide array to a scalar and tuple
  * to a union type
  */
-type ToScalar<TList, TLevel extends 1 | 2 | 3> = [IsTuple<Process$w<TList>>] extends [true] ? TupleToUnion<Process$w<TList, TLevel>> : Process$w<TList, TLevel> extends (infer Type)[] ? Type : never;
+type ToScalar<TList, TLevel extends 1 | 2 | 3> = [IsTuple<Process$x<TList>>] extends [true] ? TupleToUnion<Process$x<TList, TLevel>> : Process$x<TList, TLevel> extends (infer Type)[] ? Type : never;
 type IterateScalar<T extends readonly unknown[], TLevel extends 1 | 2 | 3> = TupleToUnion<{
     [K in keyof T]: T[K] extends unknown[] ? ToScalar<T[K], TLevel> : T[K];
 }>;
@@ -9631,15 +9631,15 @@ type IterateScalar<T extends readonly unknown[], TLevel extends 1 | 2 | 3> = Tup
  * if you set `ToScalar` to `true` then it will flatten right out of being an array
  * into a union type
  */
-type Flatten<TList, TLevel extends 1 | 2 | 3 = 1, ToScalar extends boolean = false> = [ToScalar] extends [false] ? Process$w<TList, TLevel> : [
-    IsUnion<Process$w<TList, TLevel>>
-] extends [true] ? IterateScalar<UnionToTuple$1<Process$w<TList, TLevel>>, TLevel> : [IsTuple<Process$w<TList, TLevel>>] extends [true] ? TupleToUnion<Process$w<TList, TLevel>> : Process$w<TList, TLevel> extends (infer Type)[] ? Type : never;
+type Flatten<TList, TLevel extends 1 | 2 | 3 = 1, ToScalar extends boolean = false> = [ToScalar] extends [false] ? Process$x<TList, TLevel> : [
+    IsUnion<Process$x<TList, TLevel>>
+] extends [true] ? IterateScalar<UnionToTuple$1<Process$x<TList, TLevel>>, TLevel> : [IsTuple<Process$x<TList, TLevel>>] extends [true] ? TupleToUnion<Process$x<TList, TLevel>> : Process$x<TList, TLevel> extends (infer Type)[] ? Type : never;
 
 /**
  * extract props from functions
  */
 type F<T> = T extends TypedFunction ? FnProps<T> : T;
-type Process$v<TList extends readonly unknown[], TKey extends string> = RemoveNever<{
+type Process$w<TList extends readonly unknown[], TKey extends string> = RemoveNever<{
     [K in keyof TList]: [TKey] extends [keyof F<TList[K]>] ? [IndexOf<F<TList[K]>, TKey>] extends [undefined] ? never : IndexOf<F<TList[K]>, TKey> : [IsValidDotPath<F<TList[K]>, TKey>] extends [true] ? Mutable<Get$1<F<TList[K]>, TKey, never>> : never;
 }>;
 /**
@@ -9661,7 +9661,7 @@ type Process$v<TList extends readonly unknown[], TKey extends string> = RemoveNe
  * ], "name">
  * ```
  */
-type GetEach<TList extends readonly unknown[], TKey extends string | null> = TKey extends null ? TList : TKey extends "" ? TList : IsReadonlyArray<TList> extends true ? Readonly<Process$v<[...TList], Exclude<TKey, null>>> : Process$v<TList, Exclude<TKey, null>>;
+type GetEach<TList extends readonly unknown[], TKey extends string | null> = TKey extends null ? TList : TKey extends "" ? TList : IsReadonlyArray<TList> extends true ? Readonly<Process$w<[...TList], Exclude<TKey, null>>> : Process$w<TList, Exclude<TKey, null>>;
 
 type Override<TValue, TOverride> = TOverride extends Constant$1<"no-override"> ? TValue : TValue extends ErrorCondition<"invalid-index"> ? TOverride : TValue;
 type NegativeIndex<TValue extends readonly unknown[], TIdx extends number> = Decrement<Abs<TIdx>> extends number ? If<IsValidIndex<TValue, Decrement<Abs<TIdx>>>, TValue[Decrement<Abs<TIdx>>], Throw<"invalid-index", `Use of a negative index [${AsString<TIdx>}] was unsuccessful in matching a valid index`, "IndexOf", {
@@ -9686,7 +9686,7 @@ type HandleObj<TValue extends Dictionary, TIdx extends PropertyKey> = TIdx exten
     key: TIdx;
     library: "inferred-types/constants";
 }>;
-type Process$u<TValue, TIdx extends PropertyKey | null> = If<IsNull<TIdx>, TValue, TValue extends readonly unknown[] ? If<IsValidIndex<TValue, AsPropertyKey<TIdx>>, HandleArr<TValue, AsPropertyKey<TIdx>>, Throw<"invalid-index", `Call to IndexOf<DescribeType<TValue>,${AsString<TIdx>}> is not allowed as an tuple based container must receive either null or numeric index value.`, "IndexOf", {
+type Process$v<TValue, TIdx extends PropertyKey | null> = If<IsNull<TIdx>, TValue, TValue extends readonly unknown[] ? If<IsValidIndex<TValue, AsPropertyKey<TIdx>>, HandleArr<TValue, AsPropertyKey<TIdx>>, Throw<"invalid-index", `Call to IndexOf<DescribeType<TValue>,${AsString<TIdx>}> is not allowed as an tuple based container must receive either null or numeric index value.`, "IndexOf", {
     library: "inferred-types/constants";
     container: TValue;
     key: TIdx;
@@ -9715,7 +9715,7 @@ type Process$u<TValue, TIdx extends PropertyKey | null> = If<IsNull<TIdx>, TValu
  * **Errors:** produces an `ErrorCondition<"invalid-index">` when an a bad index value
  * is passed in for the given container
  */
-type IndexOf<TValue, TIdx extends PropertyKey | null, TOverride = Constant$1<"no-override">> = TIdx extends null ? TValue : Override<Process$u<TValue, TIdx>, TOverride>;
+type IndexOf<TValue, TIdx extends PropertyKey | null, TOverride = Constant$1<"no-override">> = TIdx extends null ? TValue : Override<Process$v<TValue, TIdx>, TOverride>;
 
 /**
  * **Last**`<TList, [TEmpty]>`
@@ -9777,14 +9777,14 @@ interface FnMeta<TFn extends AnyFunction = AnyFunction, TArgs extends readonly a
     isNarrowingFn: IsNarrowingFn<TFn>;
 }
 
-type Process$s<T extends AnyFunction> = IsEqual<T, Function> extends true ? EmptyObject : keyof T extends ObjectKey ? Pick<T, keyof T> : never;
+type Process$t<T extends AnyFunction> = IsEqual<T, Function> extends true ? EmptyObject : keyof T extends ObjectKey ? Pick<T, keyof T> : never;
 /**
  * **FnProps**`<T>`
  *
  * Return a dictionary of key/value pairs from a function. If no key/value
  * pairs are assigned to the function base then an empty object is returned.
  */
-type FnProps<T extends AnyFunction> = Process$s<T>;
+type FnProps<T extends AnyFunction> = Process$t<T>;
 
 type FnDefn = [fn: AnyFunction] | [fn: AnyFunction, desc: string] | [fn: AnyFunction, props: Record<ObjectKey, unknown>];
 /**
@@ -10703,7 +10703,7 @@ interface VueRef<T = any> {
     value: T;
 }
 
-type Process$r<TValues extends readonly (boolean | LogicFunction)[], _TParams extends readonly unknown[] = []> = {
+type Process$s<TValues extends readonly (boolean | LogicFunction)[], _TParams extends readonly unknown[] = []> = {
     [K in keyof TValues]: TValues[K] extends ((...args: any[]) => boolean) ? ReturnType<TValues[K]> : TValues[K];
 };
 /**
@@ -10716,7 +10716,7 @@ type Process$r<TValues extends readonly (boolean | LogicFunction)[], _TParams ex
  *
  * **Related**: `ReturnTypes` and `TruthyReturns`
  */
-type LogicalReturns<TValues extends readonly (boolean | LogicFunction)[], _TParams extends readonly unknown[] = []> = Process$r<TValues, _TParams> extends readonly boolean[] ? Process$r<TValues, _TParams> : never;
+type LogicalReturns<TValues extends readonly (boolean | LogicFunction)[], _TParams extends readonly unknown[] = []> = Process$s<TValues, _TParams> extends readonly boolean[] ? Process$s<TValues, _TParams> : never;
 
 type Reduce<T extends readonly ([string, number])[], TMax extends number = 0, TVal extends string = ""> = [] extends T ? TVal : Reduce<AfterFirst<T>, First<T> extends [string, infer Len extends number] ? If<IsGreaterThan<Len, TMax>, Len, TMax> : TMax, First<T> extends [infer Val extends string, infer Len extends number] ? If<IsGreaterThan<Len, TMax>, Val, TVal> : TVal>;
 /**
@@ -10736,7 +10736,7 @@ type Recurse<TList extends Tuple, TResults extends Tuple = []> = [] extends TLis
 type Convert$1<TList extends Tuple> = Length<TList> extends 0 ? number[] : Recurse<{
     [K in keyof TList]: K;
 }>;
-type Process$q<TList extends Tuple> = If<IsReadonlyArray<TList>, TList["length"] extends 0 ? number[] : Readonly<Convert$1<TList>>, Convert$1<TList>>;
+type Process$r<TList extends Tuple> = If<IsReadonlyArray<TList>, TList["length"] extends 0 ? number[] : Readonly<Convert$1<TList>>, Convert$1<TList>>;
 /**
  * **NumericKeys**<`TList`>
  *
@@ -10751,7 +10751,7 @@ type Process$q<TList extends Tuple> = If<IsReadonlyArray<TList>, TList["length"]
  *
  * **Related:** `Keys`
  */
-type NumericKeys<TList extends Tuple> = Process$q<TList> extends readonly number[] ? Process$q<TList> : never;
+type NumericKeys<TList extends Tuple> = Process$r<TList> extends readonly number[] ? Process$r<TList> : never;
 
 type _Get<T, K, Acc = never> = K extends `${infer A}.${infer B}` ? A extends keyof T ? _Get<T[A], B, _Get<T[A], B>> : Acc : K extends keyof T ? _Get<T[K], K, T[K]> : Acc;
 /**
@@ -10785,7 +10785,7 @@ type _Pop<TVal extends Tuple> = TVal extends [...(infer Rest), unknown] ? Rest :
  */
 type Pop<TList extends Tuple | string> = TList extends string ? IsWideType<TList> extends true ? string : IsStringLiteral<TList> extends true ? TList extends string ? TList extends "" ? "" : Chars<TList> extends readonly string[] ? Concat<_Pop<Chars<TList>>> : never : never : string : _Pop<Exclude<TList, string>>;
 
-type Process$o<TList extends readonly unknown[], TValue> = [
+type Process$p<TList extends readonly unknown[], TValue> = [
     ...TList,
     TValue
 ];
@@ -10796,13 +10796,13 @@ type Process$o<TList extends readonly unknown[], TValue> = [
  *
  * - If you want to make the push conditional you can add `TCondition`
  */
-type Push<TList extends readonly unknown[], TVal, TCondition = true> = [TCondition] extends [true] ? As<Process$o<TList, TVal>, readonly unknown[]> : TList;
+type Push<TList extends readonly unknown[], TVal, TCondition = true> = [TCondition] extends [true] ? As<Process$p<TList, TVal>, readonly unknown[]> : TList;
 
 /**
  * Iterates over each element of the Tuple
  */
 type SingleFilter<TList extends readonly unknown[], TFilter, TOp extends ComparatorOperation, Result extends unknown[] = []> = TList extends [infer Head, ...infer Rest] ? [Compare$1<Head, TOp, TFilter>] extends [true] ? SingleFilter<Rest, TFilter, TOp, [...Result, Head]> : SingleFilter<Rest, TFilter, TOp, Result> : Result;
-type Process$n<TList extends readonly unknown[], TComparator, TOp extends ComparatorOperation> = TList extends unknown[] ? SingleFilter<TList, TComparator, TOp> : TList extends readonly unknown[] ? Readonly<SingleFilter<[...TList], TComparator, TOp>> : never;
+type Process$o<TList extends readonly unknown[], TComparator, TOp extends ComparatorOperation> = TList extends unknown[] ? SingleFilter<TList, TComparator, TOp> : TList extends readonly unknown[] ? Readonly<SingleFilter<[...TList], TComparator, TOp>> : never;
 type PrepList<T extends readonly unknown[], O extends ComparatorOperation> = Or<[
     IsEqual<O, "contains">,
     IsEqual<O, "startsWith">,
@@ -10821,9 +10821,9 @@ type PrepList<T extends readonly unknown[], O extends ComparatorOperation> = Or<
  *
  * **Related:** `Filter`
  */
-type Retain<TList extends readonly unknown[], TComparator, TOp extends ComparatorOperation = "extends"> = PrepList<TList, TOp> extends readonly unknown[] ? [TComparator] extends [unknown[]] ? Process$n<PrepList<TList, TOp>, TupleToUnion<TComparator>, TOp> : Process$n<PrepList<TList, TOp>, TComparator, TOp> : never;
+type Retain<TList extends readonly unknown[], TComparator, TOp extends ComparatorOperation = "extends"> = PrepList<TList, TOp> extends readonly unknown[] ? [TComparator] extends [unknown[]] ? Process$o<PrepList<TList, TOp>, TupleToUnion<TComparator>, TOp> : Process$o<PrepList<TList, TOp>, TComparator, TOp> : never;
 
-type Process$m<T extends readonly unknown[]> = RemoveMarked<{
+type Process$n<T extends readonly unknown[]> = RemoveMarked<{
     [K in keyof T]: If<IsLiteral<T[K]>, T[K], Constant$1<"Marked">>;
 }>;
 /**
@@ -10836,7 +10836,7 @@ type Process$m<T extends readonly unknown[]> = RemoveMarked<{
  *
  * **Related:** `Retain`, `FilterLiterals`, `RetainWideTypes`
  */
-type RetainLiterals<T extends readonly unknown[]> = Process$m<T> extends readonly unknown[] ? Process$m<T> : never;
+type RetainLiterals<T extends readonly unknown[]> = Process$n<T> extends readonly unknown[] ? Process$n<T> : never;
 
 /**
  * **Second**`<T, [ELSE]>`
@@ -10877,8 +10877,8 @@ type RemoveStart<TList extends readonly unknown[], TStart extends number> = TSta
     ...(infer REST)
 ] ? REST : Throw<"invalid-start-index">;
 type TruncateAtLen<TList extends readonly unknown[], TLen extends number> = IsNegativeNumber<TLen> extends true ? If<IsGreaterThan<Abs<TLen>, TList["length"]>, never, TakeFirst<TList, Add<TList["length"], TLen>>> : If<IsGreaterThanOrEqual<TLen, TList["length"]>, TList, TakeFirst<TList, TLen>>;
-type Process$k<TList extends readonly unknown[], TStart extends number, TLen extends number | undefined> = TList extends readonly unknown[] ? RemoveStart<TList, TStart> extends readonly unknown[] ? If<IsNumericLiteral<TLen>, TruncateAtLen<RemoveStart<TList, TStart>, As<TLen, number>>, RemoveStart<TList, TStart>> : RemoveStart<TList, TStart> : never;
-type PreProcess<TList extends readonly unknown[], TStart extends number, TLen extends number | undefined = undefined> = TList extends string ? Chars<TList> extends readonly string[] ? Concat<As<Process$k<Chars<TList>, TStart, TLen>, readonly string[]>> : never : TList extends readonly unknown[] ? Process$k<TList, TStart, TLen> : never;
+type Process$l<TList extends readonly unknown[], TStart extends number, TLen extends number | undefined> = TList extends readonly unknown[] ? RemoveStart<TList, TStart> extends readonly unknown[] ? If<IsNumericLiteral<TLen>, TruncateAtLen<RemoveStart<TList, TStart>, As<TLen, number>>, RemoveStart<TList, TStart>> : RemoveStart<TList, TStart> : never;
+type PreProcess<TList extends readonly unknown[], TStart extends number, TLen extends number | undefined = undefined> = TList extends string ? Chars<TList> extends readonly string[] ? Concat<As<Process$l<Chars<TList>, TStart, TLen>, readonly string[]>> : never : TList extends readonly unknown[] ? Process$l<TList, TStart, TLen> : never;
 /**
  * **Slice**`<TList, TStart, TLen>`
  *
@@ -10892,7 +10892,7 @@ type PreProcess<TList extends readonly unknown[], TStart extends number, TLen ex
  */
 type Slice<TList extends readonly unknown[] | string, TStart extends number, TLen extends number | undefined = undefined> = TList extends string ? Concat<As<PreProcess<Chars<TList>, TStart, TLen>, readonly string[]>> : TList extends readonly unknown[] ? PreProcess<TList, TStart, TLen> extends readonly unknown[] ? PreProcess<TList, TStart, TLen> : never : never;
 
-type Process$j<TContent extends readonly unknown[], TLen extends number, TIdx extends number = 0, TResult extends readonly unknown[] = []> = [] extends TContent ? TResult : If<IsGreaterThanOrEqual<TIdx, TLen>, TResult, Process$j<AfterFirst<TContent>, TLen, Increment<TIdx>, [
+type Process$k<TContent extends readonly unknown[], TLen extends number, TIdx extends number = 0, TResult extends readonly unknown[] = []> = [] extends TContent ? TResult : If<IsGreaterThanOrEqual<TIdx, TLen>, TResult, Process$k<AfterFirst<TContent>, TLen, Increment<TIdx>, [
     ...TResult,
     First<TContent>
 ]>>;
@@ -10909,7 +10909,7 @@ type Process$j<TContent extends readonly unknown[], TLen extends number, TIdx ex
  * - if you want a precise length, then set `THandle` to "throw" and
  * an error will be thrown.
  */
-type TakeFirst<TContent extends readonly unknown[], TLen extends number, THandle extends "ignore" | "throw" = "ignore"> = If<IsGreaterThan<TLen, TContent["length"]>, If<THandle extends "ignore" ? true : false, TContent, Throw<"invalid-length", `TakeFirst<TContent,TLen> was called where the length of TLen(${TLen}) was greater than the length of the content (${TContent["length"]})!`>>, If<IsEqual<TLen, TContent["length"]>, TContent, Process$j<TContent, TLen>>>;
+type TakeFirst<TContent extends readonly unknown[], TLen extends number, THandle extends "ignore" | "throw" = "ignore"> = If<IsGreaterThan<TLen, TContent["length"]>, If<THandle extends "ignore" ? true : false, TContent, Throw<"invalid-length", `TakeFirst<TContent,TLen> was called where the length of TLen(${TLen}) was greater than the length of the content (${TContent["length"]})!`>>, If<IsEqual<TLen, TContent["length"]>, TContent, Process$k<TContent, TLen>>>;
 
 type _Keys$2<T extends object> = UnionToTuple$1<keyof RemoveIndexKeys<T>> extends readonly ObjectKey[] ? UnionToTuple$1<keyof RemoveIndexKeys<T>> : never;
 type ProcessObj$1<T extends Container, TKeys extends readonly PropertyKey[], TResults extends Dictionary = EmptyObject> = [] extends TKeys ? TResults : First<TKeys> extends keyof T ? IfNever<T[First<TKeys>], ProcessObj$1<T, AfterFirst<TKeys>, TResults>, ProcessObj$1<T, AfterFirst<TKeys>, First<TKeys> extends keyof T ? TResults extends readonly unknown[] ? [...TResults, T[First<TKeys>]] : TResults extends Dictionary ? TResults & Record<First<TKeys>, T[First<TKeys>]> : never : never>> : never;
@@ -10925,7 +10925,7 @@ type _Keys<T extends object> = UnionToTuple$1<keyof RemoveIndexKeys<T>>;
 type GetKeys<T extends object> = IsVueRef<T> extends true ? ["value"] : _Keys<T> extends [symbol] ? ObjectKey[] : _Keys<T> extends [] ? UnionToTuple$1<keyof T> extends [ObjectKey] ? (keyof T)[] : ObjectKey[] : _Keys<T>;
 type ProcessObj<TContainer extends object> = GetKeys<TContainer>;
 type ProcessTuple<TContainer extends readonly unknown[]> = NumericKeys<TContainer> extends readonly number[] ? NumericKeys<TContainer> : never;
-type Process$g<TContainer extends AnyObject> = [IsObjectLiteral<RemoveIndexKeys<TContainer>>] extends [true] ? ProcessObj<RemoveIndexKeys<TContainer>> extends readonly (keyof TContainer & ObjectKey)[] ? As<ProcessObj<RemoveIndexKeys<TContainer>>, readonly ObjectKey[]> : never : ObjectKey[];
+type Process$h<TContainer extends AnyObject> = [IsObjectLiteral<RemoveIndexKeys<TContainer>>] extends [true] ? ProcessObj<RemoveIndexKeys<TContainer>> extends readonly (keyof TContainer & ObjectKey)[] ? As<ProcessObj<RemoveIndexKeys<TContainer>>, readonly ObjectKey[]> : never : ObjectKey[];
 /**
  * **Keys**`<TContainer>`
  *
@@ -10942,7 +10942,7 @@ type Process$g<TContainer extends AnyObject> = [IsObjectLiteral<RemoveIndexKeys<
  *
  * **Related:** `ValidKey`, `PublicKeys`
  */
-type Keys<TContainer extends Tuple | AnyObject> = TContainer extends Tuple ? ProcessTuple<TContainer> : TContainer extends AnyObject ? Process$g<TContainer> extends readonly ObjectKey[] ? Process$g<TContainer> : never : never;
+type Keys<TContainer extends Tuple | AnyObject> = TContainer extends Tuple ? ProcessTuple<TContainer> : TContainer extends AnyObject ? Process$h<TContainer> extends readonly ObjectKey[] ? Process$h<TContainer> : never : never;
 
 type ProcessTupleKeys<TObj extends AnyObject, TKeys extends readonly ObjectKey[]> = ExpandDictionary<WithoutKeys<TObj, TKeys> & {
     [K in keyof WithKeys<TObj, TKeys>]?: K extends keyof TObj ? TObj[K] : never;
@@ -11020,7 +11020,7 @@ interface ConstrainedObjectIdentity<TConstraint extends AnyObject> {
     asCallback: ConstrainedObjectCallback<TConstraint>;
 }
 
-type Process$e<TKeys extends readonly string[], TValue, TObj extends Dictionary = EmptyObject> = [] extends TKeys ? TObj : Process$e<AfterFirst<TKeys>, TValue, TObj & Record<First<TKeys>, TValue>>;
+type Process$f<TKeys extends readonly string[], TValue, TObj extends Dictionary = EmptyObject> = [] extends TKeys ? TObj : Process$f<AfterFirst<TKeys>, TValue, TObj & Record<First<TKeys>, TValue>>;
 /**
  * **CreateKV**`<TKeys,[TValue]>`
  *
@@ -11028,7 +11028,7 @@ type Process$e<TKeys extends readonly string[], TValue, TObj extends Dictionary
  * as `TKeys` and with all properties set to the value
  * of `TValue` (which defaults to `unknown`)
  */
-type CreateKV<TKeys extends readonly string[], TValue = unknown> = ExpandRecursively<Process$e<TKeys, TValue>>;
+type CreateKV<TKeys extends readonly string[], TValue = unknown> = ExpandRecursively<Process$f<TKeys, TValue>>;
 
 /**
  * the _optional_ variants of the `SimpleScalarToken` type
@@ -11628,7 +11628,7 @@ type SKeys<T extends AnyObject> = IsVueRef<T> extends true ? ["value"] : _SKeys<
  */
 type TakeProp<TTest, TProp extends PropertyKey, TElse = undefined> = TProp extends keyof TTest ? TTest[TProp] : TElse;
 
-type Process$4<TKeys extends readonly ObjectKey[], TObj extends Record<ObjectKey, unknown>, TResult extends readonly unknown[] = []> = [] extends TKeys ? TResult : Process$4<AfterFirst<TKeys>, TObj, [
+type Process$5<TKeys extends readonly ObjectKey[], TObj extends Record<ObjectKey, unknown>, TResult extends readonly unknown[] = []> = [] extends TKeys ? TResult : Process$5<AfterFirst<TKeys>, TObj, [
     ...TResult,
     First<TKeys> extends keyof TObj ? TObj[First<TKeys>] : never
 ]>;
@@ -11640,7 +11640,7 @@ type Process$4<TKeys extends readonly ObjectKey[], TObj extends Record<ObjectKey
  * - for **tuples** this is just a _proxy_ of the type
  * - for _wide_ types like `string[]`
  */
-type Values<T extends Container> = T extends Tuple ? T : T extends Dictionary ? Process$4<Keys<T> extends readonly ObjectKey[] ? Keys<T> : never, T> : T extends TypedFunction ? [T] : [];
+type Values<T extends Container> = T extends Tuple ? T : T extends Dictionary ? Process$5<Keys<T> extends readonly ObjectKey[] ? Keys<T> : never, T> : T extends TypedFunction ? [T] : [];
 
 type MakeIntoUnion<K extends PropertyKey | readonly PropertyKey[]> = K extends readonly PropertyKey[] ? TupleToUnion<K> : K;
 type MakeNumericIndex<T> = T;
@@ -11663,7 +11663,7 @@ type MakeNumericIndex<T> = T;
  */
 type WithKeys<T extends AnyObject | Tuple, K extends PropertyKey | readonly PropertyKey[]> = ExpandRecursively<UnionToIntersection<MakeIntoUnion<K> extends keyof T ? T extends Tuple ? MakeNumericIndex<Pick<T, MakeIntoUnion<K>>> : Pick<T, MakeIntoUnion<K>> : never>>;
 
-type Process$3<TObj extends Dictionary, TKeys extends ObjectKey> = [] extends TKeys ? TObj : Omit<TObj, TKeys>;
+type Process$4<TObj extends Dictionary, TKeys extends ObjectKey> = [] extends TKeys ? TObj : Omit<TObj, TKeys>;
 /**
  * **WithoutKeys**`<TObj, TKeys>`
  *
@@ -11671,7 +11671,7 @@ type Process$3<TObj extends Dictionary, TKeys extends ObjectKey> = [] extends TK
  * functionally equivalent to the `Omit<T,U>` built-in but rather than
  * taking a union type it takes an array of keys.
  */
-type WithoutKeys<TObj extends Dictionary, TKeys extends ObjectKey | readonly ObjectKey[]> = TKeys extends readonly ObjectKey[] ? Process$3<TObj, TupleToUnion<TKeys>> : ExpandDictionary<Process$3<TObj, TKeys extends readonly ObjectKey[] ? TupleToUnion<TKeys> : TKeys>>;
+type WithoutKeys<TObj extends Dictionary, TKeys extends ObjectKey | readonly ObjectKey[]> = TKeys extends readonly ObjectKey[] ? Process$4<TObj, TupleToUnion<TKeys>> : ExpandDictionary<Process$4<TObj, TKeys extends readonly ObjectKey[] ? TupleToUnion<TKeys> : TKeys>>;
 
 /**
  * **WithoutValue**
@@ -11690,7 +11690,7 @@ type WithoutKeys<TObj extends Dictionary, TKeys extends ObjectKey | readonly Obj
 type WithoutValue<TObj extends AnyObject, TValue extends Narrowable> = ExpandRecursively<Pick<TObj, KeysWithoutValue<TObj, TValue>>>;
 
 type Marked$1 = typeof MARKED;
-type Process$2<TObj extends Dictionary, TValue, TOp extends "equals" | "extends"> = RemoveMarked<{
+type Process$3<TObj extends Dictionary, TValue, TOp extends "equals" | "extends"> = RemoveMarked<{
     [K in keyof TObj]: If<Compare$1<TObj[K], TOp, TValue>, TObj[K], Marked$1>;
 }>;
 /**
@@ -11706,7 +11706,7 @@ type Process$2<TObj extends Dictionary, TValue, TOp extends "equals" | "extends"
  *
  * **Related:** `WithoutValue`, `WithKeys`, `WithoutKeys`
  */
-type WithValue<TObj extends Dictionary, TValue, TOp extends "equals" | "extends" = "extends"> = ExpandRecursively<Process$2<TObj, TValue, TOp>>;
+type WithValue<TObj extends Dictionary, TValue, TOp extends "equals" | "extends" = "extends"> = ExpandRecursively<Process$3<TObj, TValue, TOp>>;
 
 /** Converts a single KeyValue into a one-key object */
 type KeyValueToObj<KV extends {
@@ -11740,7 +11740,7 @@ interface KeyValue<K = ObjectKey, V = any> {
     value: V;
 }
 
-type Process$1<TObj extends AnyObject, TKeys extends readonly (ObjectKey & keyof TObj)[], TKv extends readonly KeyValue[] = []> = [] extends TKeys ? TKv : Process$1<TObj, AfterFirst<TKeys>, [
+type Process$2<TObj extends AnyObject, TKeys extends readonly (ObjectKey & keyof TObj)[], TKv extends readonly KeyValue[] = []> = [] extends TKeys ? TKv : Process$2<TObj, AfterFirst<TKeys>, [
     ...TKv,
     {
         key: First<TKeys>;
@@ -11769,7 +11769,7 @@ type Process$1<TObj extends AnyObject, TKeys extends readonly (ObjectKey & keyof
  *
  * **Related:** `KeyValue`, `FromKv`
  */
-type ToKv<TObj extends AnyObject, TKeys extends (readonly (ObjectKey & keyof TObj)[]) | false = As<Keys<TObj>, (readonly (ObjectKey & keyof TObj)[])>> = IsObjectLiteral<TObj> extends true ? TKeys extends readonly (ObjectKey & keyof TObj)[] ? Process$1<TObj, TKeys> : Array<{
+type ToKv<TObj extends AnyObject, TKeys extends (readonly (ObjectKey & keyof TObj)[]) | false = As<Keys<TObj>, (readonly (ObjectKey & keyof TObj)[])>> = IsObjectLiteral<TObj> extends true ? TKeys extends readonly (ObjectKey & keyof TObj)[] ? Process$2<TObj, TKeys> : Array<{
     [K in keyof TObj]: {
         key: K;
         value: TObj[K];
@@ -11896,7 +11896,7 @@ type Intersection<A extends readonly unknown[], B extends readonly unknown[], TD
 
 type Get<TValue, TDeref extends PropertyKey | never> = IfNever<TDeref, TValue, // just proxy value back
 TDeref extends keyof TValue ? TValue[TDeref] : TValue extends Container ? never : TValue>;
-type Process<TValues extends readonly unknown[], TDeref extends string | number | never, TResults extends readonly unknown[] = []> = [] extends TValues ? TResults : Process<AfterFirst<TValues>, TDeref, Push<TResults, First<TResults>, IsScalar<First<TValues>> extends true ? Not<Contains<TResults, First<TValues>>> : Not<Contains<As<IsNever<TDeref> extends true ? TResults : GetEach<TResults, AsString<TDeref>>, string | number | readonly unknown[]>, Get<First<TValues>, TDeref>>>>>;
+type Process$1<TValues extends readonly unknown[], TDeref extends string | number | never, TResults extends readonly unknown[] = []> = [] extends TValues ? TResults : Process$1<AfterFirst<TValues>, TDeref, Push<TResults, First<TResults>, IsScalar<First<TValues>> extends true ? Not<Contains<TResults, First<TValues>>> : Not<Contains<As<IsNever<TDeref> extends true ? TResults : GetEach<TResults, AsString<TDeref>>, string | number | readonly unknown[]>, Get<First<TValues>, TDeref>>>>>;
 /**
  * **Unique**`<TList, [TDeref]>`
  *
@@ -11913,7 +11913,7 @@ type Process<TValues extends readonly unknown[], TDeref extends string | number
  * type FooBar = Unique<["foo","foo","bar"]>;
  * ```
  */
-type Unique<TList extends readonly unknown[], TDeref extends string | number | never = never> = IfNever<TDeref, UnionToTuple$1<TupleToUnion<TList>>, Process<TList, TDeref>>;
+type Unique<TList extends readonly unknown[], TDeref extends string | number | never = never> = IfNever<TDeref, UnionToTuple$1<TupleToUnion<TList>>, Process$1<TList, TDeref>>;
 
 /**
  * **UniqueKeys**`<L,R>`
@@ -12962,11 +12962,15 @@ declare function capitalize<T extends string>(str: T): Capitalize<T>;
  */
 declare function cssColor<TColorSpace extends CssColorSpace, TV1 extends ColorFnValue, TV2 extends ColorFnValue, TV3 extends ColorFnValue, TOp extends undefined | ColorFnOptOpacity>(color: TColorSpace, v1: TV1, v2: TV2, v3: TV3, opacity?: TOp): CssColorFn<TColorSpace, TV1, TV2, TV3, TOp extends ` / ${number}` ? TOp : "">;
 
-type Rtn$1<TColor extends TwColor, TLum extends TwLuminosity> = TLum extends keyof TwLuminosityLookup ? TLum extends keyof TwChromaLookup ? TColor extends keyof TwHue ? `oklch(${TwLuminosityLookup[TLum]} ${TwChromaLookup[TLum]} ${TwHue[TColor]}) ` : never : never : never;
+type Rtn$1<TColor extends TwColor, TLum extends TwLuminosity> = TLum extends keyof TwLuminosityLookup ? TLum extends keyof TwChromaLookup ? TColor extends keyof TwHue ? `oklch(${TwLuminosityLookup[TLum]} ${TwChromaLookup[TLum]} ${TwHue[TColor]})` : never : never : never;
 /**
+ * **twColor**`(color, luminosity)` => `oklch(...)`
+ *
  * Provides a Tailwind Color using the `oklch` color
  * specification. The output is intended to put into
  * a CSS property.
+ *
+ * **Related:** `twColorRgb()`
  */
 declare function twColor<TColor extends TwColor, TLum extends TwLuminosity>(color: TColor, luminosity: TLum): Rtn$1<TColor, TLum>;