@pawover/kit 0.0.0-beta.41 → 0.0.0-beta.43

package/dist/index.d.ts

@@ -1,10 +1,9 @@
-import { a as Simplify, c as Not, d as IsNever, f as OptionalKeysOf, i as HomomorphicPick, l as UnknownArray, m as UnionToIntersection, n as ApplyDefaultOptions, o as IfNotAnyOrNever, p as IsAny, r as CollapseLiterals, s as IsExactOptionalPropertyTypesEnabled, t as Except, u as If } from "./except-MacUK44u.js";
-import { t as ValueOf } from "./value-of-DUmTbnuw.js";
-import { a as AnyObject, i as AnyGeneratorFunction, n as AnyAsyncGeneratorFunction, o as PlainObject, r as AnyFunction, s as TreeLike, t as AnyAsyncFunction } from "./index-DBPmnr4a.js";
-import { clone, cloneDeep, cloneDeepWith } from "lodash-es";
+import { a as IsEqual, c as IsExactOptionalPropertyTypesEnabled, d as If, f as IsNever, h as UnionToIntersection, i as HomomorphicPick, l as Not, m as IsAny, n as ApplyDefaultOptions, o as Simplify, p as OptionalKeysOf, r as CollapseLiterals, s as IfNotAnyOrNever, t as Except, u as UnknownArray } from "./except-6l9Qdmn1.js";
+import { t as ValueOf } from "./value-of-Dz22arsm.js";
+import { a as AnyObject, i as AnyGeneratorFunction, n as AnyAsyncGeneratorFunction, o as PlainObject, r as AnyFunction, s as TreeLike, t as AnyAsyncFunction } from "./index-D0_YLsqN.js";
 import { BigNumber, MathExpression, MathJsInstance, Matrix } from "mathjs";
 
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/basic.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/basic.d.ts
 /**
 Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 
@@ -15,8 +14,7 @@ type Class<T, Arguments extends unknown[] = any[]> = {
   new (...arguments_: Arguments): T;
 };
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/internal/array.d.ts
-
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/array.d.ts
 /**
 Transforms a tuple type by replacing it's rest element with a single element that has the same type as the rest element, while keeping all the non-rest elements intact.
 
@@ -50,8 +48,7 @@ type B = CollapseRestElement<[string?, string?, ...number[]]>;
 */
 type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
 type _CollapseRestElement<TArray extends UnknownArray, ForwardAccumulator extends UnknownArray = [], BackwardAccumulator extends UnknownArray = []> = TArray extends UnknownArray // For distributing `TArray`
-? keyof TArray & `${number}` extends never
-// Enters this branch, if `TArray` is empty (e.g., []),
+? keyof TArray & `${number}` extends never // Enters this branch, if `TArray` is empty (e.g., []),
 // or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
 ? TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
 : TArray extends readonly [] ? [...ForwardAccumulator, ...BackwardAccumulator] : [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
@@ -59,10 +56,9 @@ type _CollapseRestElement<TArray extends UnknownArray, ForwardAccumulator extend
 : First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
 : never; // Should never happen
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/numeric.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/numeric.d.ts
 type _Numeric = number | bigint;
 type Zero = 0 | 0n;
-
 /**
 Matches the hidden `Infinity` type.
 
@@ -74,7 +70,6 @@ Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277)
 */
 // See https://github.com/microsoft/TypeScript/issues/31752
 // eslint-disable-next-line no-loss-of-precision
-
 /**
 A negative `number`/`bigint` (`-∞ < x < 0`)
 
@@ -106,13 +101,12 @@ type IsNegative<T extends _Numeric> = T extends Negative<T> ? true : false;
 //#region node_modules/.pnpm/tagged-tag@1.0.0/node_modules/tagged-tag/index.d.ts
 declare const tag: unique symbol;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/tagged.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/tagged.d.ts
 // eslint-disable-next-line type-fest/require-exported-types
 type TagContainer<Token> = {
   readonly [tag]: Token;
 };
 type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata }>;
-
 /**
 Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
 
@@ -174,7 +168,7 @@ type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
 
 @category Type
 */
-type Tagged<Type$1, TagName extends PropertyKey, TagMetadata = never> = Type$1 & Tag<TagName, TagMetadata>;
+type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
 /**
 Revert a tagged type back to its original type by removing all tags.
 
@@ -197,7 +191,7 @@ const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
 // Without UnwrapTagged, the following expression would throw a type error.
 const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
 
-// Attempting to pass an non-Tagged type to UnwrapTagged will raise a type error.
+// Attempting to pass a non-Tagged type to UnwrapTagged will raise a type error.
 // @ts-expect-error
 type WontWork = UnwrapTagged<string>;
 ```
@@ -206,7 +200,6 @@ type WontWork = UnwrapTagged<string>;
 */
 type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> = RemoveAllTags<TaggedType>;
 type RemoveAllTags<T> = T extends Tag<PropertyKey, any> ? { [ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]> ? RemoveAllTags<Type> : never }[keyof T[typeof tag]] : T;
-
 /**
 Note: The `Opaque` type is deprecated in favor of `Tagged`.
 
@@ -282,7 +275,7 @@ type Person = {
 @deprecated Use {@link Tagged} instead
 */
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/is-literal.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-literal.d.ts
 /**
 Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
 
@@ -340,12 +333,11 @@ type L2 = Length<`${number}`>;
 @category Utilities
 */
 type IsStringLiteral<S> = IfNotAnyOrNever<S, _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>, false, false>;
-type _IsStringLiteral<S> =
-// If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+type _IsStringLiteral<S> = // If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
 // and since `{}` extends index signatures, the result becomes `false`.
 S extends string ? {} extends Record<S, never> ? false : true : false;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/tuple-of.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/tuple-of.d.ts
 /**
 Create a tuple type of the specified length with elements of the specified type.
 
@@ -413,7 +405,160 @@ Note: If you need a readonly tuple, simply wrap this type with `Readonly`, for e
 type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, _TupleOf<If<IsNegative<Length>, 0, Length>, Fill, []>, Fill[], []>;
 type _TupleOf<L extends number, Fill, Accumulator extends UnknownArray> = number extends L ? Fill[] : L extends Accumulator['length'] ? Accumulator : _TupleOf<L, Fill, [...Accumulator, Fill]>;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/or.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/some-extend.d.ts
+/**
+@see {@link SomeExtend}
+*/
+type SomeExtendOptions = {
+  /**
+  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+  	@default true
+  	@example
+  ```
+  import type {SomeExtend} from 'type-fest';
+  	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
+  //=> false
+  	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
+  //=> true
+  	type C = SomeExtend<[1, never], never, {strictNever: true}>;
+  //=> true
+  	type D = SomeExtend<[1, never], never, {strictNever: false}>;
+  //=> true
+  	type E = SomeExtend<[never], any, {strictNever: true}>;
+  //=> true
+  	type F = SomeExtend<[never], any, {strictNever: false}>;
+  //=> true
+  ```
+  */
+  strictNever?: boolean;
+};
+type DefaultSomeExtendOptions = {
+  strictNever: true;
+};
+/**
+Returns a boolean for whether some element in an array type extends another type.
+
+@example
+```
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<['1', '2', 3], number>;
+//=> true
+
+type B = SomeExtend<[1, 2, 3], string>;
+//=> false
+
+type C = SomeExtend<[string, number | string], number>;
+//=> boolean
+
+type D = SomeExtend<[true, boolean, true], false>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+// @exactOptionalPropertyTypes: true
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> true
+```
+
+```
+// @exactOptionalPropertyTypes: false
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> boolean
+
+type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
+//=> true
+```
+
+@see {@link SomeExtendOptions}
+
+@category Utilities
+@category Array
+*/
+type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> = _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+? true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false, false, false>;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or-all.d.ts
+/**
+Returns a boolean for whether any of the given elements is `true`.
+
+Use-cases:
+- Check if at least one condition in a list of booleans is met.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type FFT = OrAll<[false, false, true]>;
+//=> true
+
+type FFF = OrAll<[false, false, false]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `OrAll<[false, boolean]>` expands to `OrAll<[false, true]> | OrAll<[false, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, boolean]>;
+//=> boolean
+
+type B = OrAll<[true, boolean]>;
+//=> true
+```
+
+Note: If `never` is passed as an element, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[never, never, true]>;
+//=> true
+
+type B = OrAll<[never, never, false]>;
+//=> false
+
+type C = OrAll<[never, never, never]>;
+//=> false
+
+type D = OrAll<[never, never, boolean]>;
+//=> boolean
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, any]>;
+//=> boolean
+
+type B = OrAll<[true, any]>;
+//=> true
+```
+
+Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in an empty tuple. See [Wikipedia: Clause (logic) > Empty clauses](https://en.wikipedia.org/wiki/Clause_(logic)#Empty_clauses:~:text=The%20truth%20evaluation%20of%20an%20empty%20disjunctive%20clause%20is%20always%20false.).
+
+@see {@link Or}
+@see {@link AndAll}
+*/
+type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or.d.ts
 /**
 Returns a boolean for whether either of two given types is true.
 
@@ -487,15 +632,13 @@ type G = Or<never, never>;
 //=> false
 ```
 
+@see {@link OrAll}
 @see {@link And}
 @see {@link Xor}
 */
-type Or<A$1 extends boolean, B$1 extends boolean> = _Or<If<IsNever<A$1>, false, A$1>, If<IsNever<B$1>, false, B$1>>;
-// `never` is treated as `false`
-
-type _Or<A$1 extends boolean, B$1 extends boolean> = A$1 extends true ? true : B$1 extends true ? true : false;
+type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/all-extend.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/all-extend.d.ts
 /**
 @see {@link AllExtend}
 */
@@ -531,7 +674,6 @@ type AllExtendOptions = {
 type DefaultAllExtendOptions = {
   strictNever: true;
 };
-
 /**
 Returns a boolean for whether every element in an array type extends another type.
 
@@ -578,12 +720,85 @@ type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 @category Utilities
 @category Array
 */
-type AllExtend<TArray extends UnknownArray, Type$1, Options extends AllExtendOptions = {}> = _AllExtend<CollapseRestElement<TArray>, Type$1, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
-type _AllExtend<TArray extends UnknownArray, Type$1, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, If<IsAny<Type$1>, true, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<IsNever<Type$1>, Not<Options['strictNever']>> extends true
-// If target `Type` is also `never` OR `strictNever` is disabled, recurse further.
-? _AllExtend<Rest, Type$1, Options> : false : First extends Type$1 ? _AllExtend<Rest, Type$1, Options> : false : true>, false, false>;
+type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> = _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
+? _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true, false, false>;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/and.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/and-all.d.ts
+/**
+Returns a boolean for whether all of the given elements are `true`.
+
+Use-cases:
+- Check if all conditions in a list of booleans are met.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type TTT = AndAll<[true, true, true]>;
+//=> true
+
+type TTF = AndAll<[true, true, false]>;
+//=> false
+
+type TFT = AndAll<[true, false, true]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `AndAll<[true, boolean]>` expands to `AndAll<[true, true]> | AndAll<[true, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[true, boolean]>;
+//=> boolean
+
+type B = AndAll<[false, boolean]>;
+//=> false
+```
+
+Note: If any of the elements is `never`, the result becomes `false`.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[true, true, never]>;
+//=> false
+
+type B = AndAll<[false, never, never]>;
+//=> false
+
+type C = AndAll<[never, never, never]>;
+//=> false
+
+type D = AndAll<[boolean, true, never]>;
+//=> false
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[false, any]>;
+//=> false
+
+type B = AndAll<[true, any]>;
+//=> boolean
+```
+
+Note: `AndAll<[]>` evaluates to `true` due to the concept of [vacuous truth](https://en.wikipedia.org/wiki/Logical_conjunction#:~:text=In%20keeping%20with%20the%20concept%20of%20vacuous%20truth%2C%20when%20conjunction%20is%20defined%20as%20an%20operator%20or%20function%20of%20arbitrary%20arity%2C%20the%20empty%20conjunction%20(AND%2Ding%20over%20an%20empty%20set%20of%20operands)%20is%20often%20defined%20as%20having%20the%20result%20true.), i.e., there are no `false` elements in an empty tuple.
+
+@see {@link And}
+@see {@link OrAll}
+*/
+type AndAll<T extends readonly boolean[]> = AllExtend<T, true>;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/and.d.ts
 /**
 Returns a boolean for whether two given types are both true.
 
@@ -657,23 +872,108 @@ type G = And<never, never>;
 //=> false
 ```
 
+@see {@link AndAll}
 @see {@link Or}
 @see {@link Xor}
 */
-type And<A$1 extends boolean, B$1 extends boolean> = AllExtend<[A$1, B$1], true>;
+type And<A extends boolean, B extends boolean> = AndAll<[A, B]>;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/union-to-tuple.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/exclude-exactly.d.ts
 /**
-Returns the last element of a union type.
+A stricter version of `Exclude<T, U>` that excludes types only when they are exactly identical.
 
 @example
 ```
-type Last = LastOfUnion<1 | 2 | 3>;
-//=> 3
+import type {ExcludeExactly} from 'type-fest';
+
+type TestExclude1 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 1 | 2 | 3
+
+type TestExcludeExactly1 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude2 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> never
+
+type TestExcludeExactly2 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude3 = Exclude<{a: string} | {a: string; b: string}, {a: string}>;
+//=> never
+
+type TestExcludeExactly3 = ExcludeExactly<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string; b: string}
 ```
+
+@category Improved Built-in
 */
-type LastOfUnion<T> = UnionToIntersection<T extends any ? () => T : never> extends (() => (infer R)) ? R : never;
+type ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Union, _ExcludeExactly<Union, Delete>, // If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
+If<IsAny<Delete>, never, Union>, // If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
+If<IsNever<Delete>, never, Union>>;
+type _ExcludeExactly<Union, Delete> = IfNotAnyOrNever<Delete, Union extends unknown // For distributing `Union`
+? [Delete extends unknown // For distributing `Delete`
+? If<IsEqual<Union, Delete>, true, never> : never] extends [never] ? Union : never : never, // If `Delete` is `any` or `never`, then return `Union`,
+// because `Union` cannot be `any` or `never` here.
+Union, Union>;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/union-member.d.ts
+/**
+Returns an arbitrary member of a union type.
+
+Use-cases:
+- Implementing recursive type functions that accept a union type.
+
+@example
+```
+import type {UnionMember, IsNever} from 'type-fest';
+
+type UnionLength<T, Acc extends any[] = []> =
+	UnionMember<T> extends infer Member
+		? IsNever<Member> extends false
+			? UnionLength<Exclude<T, Member>, [...Acc, Member]>
+			: Acc['length']
+		: never;
+
+type T1 = UnionLength<'foo' | 'bar' | 'baz'>;
+//=> 3
+
+type T2 = UnionLength<{a: string}>;
+//=> 1
+```
+
+- Picking an arbitrary member from a union
+
+@example
+```
+import type {UnionMember, Primitive, LiteralToPrimitive} from 'type-fest';
+
+type IsHomogenous<T extends Primitive> = [T] extends [LiteralToPrimitive<UnionMember<T>>] ? true : false;
 
+type T1 = IsHomogenous<1 | 2 | 3 | 4>;
+//=> true
+
+type T2 = IsHomogenous<'foo' | 'bar'>;
+//=> true
+
+type T3 = IsHomogenous<'foo' | 'bar' | 1>;
+//=> false
+```
+
+Returns `never` when the input is `never`.
+
+@example
+```
+import type {UnionMember} from 'type-fest';
+
+type LastNever = UnionMember<never>;
+//=> never
+```
+
+@category Type
+*/
+type UnionMember<T> = IsNever<T> extends true ? never : UnionToIntersection<T extends any ? () => T : never> extends (() => (infer R)) ? R : never;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/union-to-tuple.d.ts
 /**
 Convert a union type into an unordered tuple type of its elements.
 
@@ -709,9 +1009,9 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 
 @category Array
 */
-type UnionToTuple<T, L = LastOfUnion<T>> = IsNever<T> extends false ? [...UnionToTuple<Exclude<T, L>>, L] : [];
+type UnionToTuple<T, L = UnionMember<T>> = IsNever<T> extends false ? [...UnionToTuple<ExcludeExactly<T, L>>, L] : [];
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/set-optional.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/set-optional.d.ts
 /**
 Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
 
@@ -728,24 +1028,18 @@ type Foo = {
 };
 
 type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
-// type SomeOptional = {
-// 	a: number;
-// 	b?: string; // Was already optional and still is.
-// 	c?: boolean; // Is now optional.
-// }
+//=> {a: number; b?: string; c?: boolean}
 ```
 
 @category Object
 */
 type SetOptional<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetOptional<BaseType, Keys>;
 type _SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown // To distribute `BaseType` when it's a union type.
-? Simplify<
-// Pick just the keys that are readonly from the base type.
-Except<BaseType, Keys> &
-// Pick the keys that should be mutable from the base type and make them mutable.
+? Simplify< // Pick just the keys that are readonly from the base type.
+Except<BaseType, Keys> & // Pick the keys that should be mutable from the base type and make them mutable.
 Partial<HomomorphicPick<BaseType, Keys>>> : never;
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/split.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/split.d.ts
 /**
 Split options.
 
@@ -773,7 +1067,6 @@ type SplitOptions = {
 type DefaultSplitOptions = {
   strictLiteralChecks: true;
 };
-
 /**
 Represents an array of strings split using a given character or character set.
 
@@ -799,19 +1092,17 @@ type Split<S extends string, Delimiter extends string, Options extends SplitOpti
 type SplitHelper<S extends string, Delimiter extends string, Options extends Required<SplitOptions>, Accumulator extends string[] = []> = S extends string // For distributing `S`
 ? Delimiter extends string // For distributing `Delimiter`
 // If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
-? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true ? S extends `${infer Head}${Delimiter}${infer Tail}` ? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]> : Delimiter extends '' ? S extends '' ? Accumulator : [...Accumulator, S] : [...Accumulator, S]
-// Otherwise, return `string[]`
+? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true ? S extends `${infer Head}${Delimiter}${infer Tail}` ? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]> : Delimiter extends '' ? S extends '' ? Accumulator : [...Accumulator, S] : [...Accumulator, S] // Otherwise, return `string[]`
 : string[] : never // Should never happen
 : never; // Should never happen
 //#endregion
-//#region node_modules/.pnpm/type-fest@5.4.4/node_modules/type-fest/source/replace.d.ts
+//#region node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/replace.d.ts
 type ReplaceOptions = {
   all?: boolean;
 };
 type DefaultReplaceOptions = {
   all: false;
 };
-
 /**
 Represents a string with some or all matches replaced by a replacement.
 
@@ -916,7 +1207,7 @@ declare function arrayCompete<T>(initialList: readonly T[], match: (a: T, b: T,
  * type list1 = number[]
  * ```
  */
-declare type List<A$1 = any> = ReadonlyArray<A$1>;
+declare type List<A = any> = ReadonlyArray<A>;
 //#endregion
 //#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Any/Cast.d.ts
 /**
@@ -1184,7 +1475,7 @@ declare type IterationMap = {
  * type test1 = I.Pos<I.Prev<i>> // 19
  * ```
  */
-declare type Prev<I$1 extends Iteration> = IterationMap[I$1[2]];
+declare type Prev<I extends Iteration> = IterationMap[I[2]];
 //#endregion
 //#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Iteration/IterationOf.d.ts
 /**
@@ -1222,7 +1513,7 @@ declare type IterationOf<N extends number> = `${N}` extends keyof IterationMap ?
  * type test1 = I.Pos<I.Next<i>> // 21
  * ```
  */
-declare type Pos<I$1 extends Iteration> = I$1[0];
+declare type Pos<I extends Iteration> = I[0];
 //#endregion
 //#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/Tail.d.ts
 /**
@@ -1264,7 +1555,7 @@ declare type Naked<L extends List> = Overwrite<Required<L>, L>;
  * ```ts
  * ```
  */
-declare type Prepend<L extends List, A$1 extends any> = [A$1, ...L];
+declare type Prepend<L extends List, A extends any> = [A, ...L];
 //#endregion
 //#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Iteration/_Internal.d.ts
 /**
@@ -1288,7 +1579,7 @@ declare type Way = '->' | '<-';
  * type test3 = L.Append<[1, 2], [3, 4]> // [1, 2, [3, 4]]
  * ```
  */
-declare type Append<L extends List, A$1 extends any> = [...L, A$1];
+declare type Append<L extends List, A extends any> = [...L, A];
 //#endregion
 //#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/Drop.d.ts
 /**
@@ -1301,10 +1592,10 @@ declare type DropForth<L extends List, N extends Iteration> = {
 /**
  * @hidden
  */
-declare type DropBack<L extends List, N extends Iteration, I$1 extends Iteration = Prev<N>, LN extends List = []> = {
-  0: DropBack<L, N, Prev<I$1>, Prepend<LN, L[Pos<I$1>]>>;
+declare type DropBack<L extends List, N extends Iteration, I extends Iteration = Prev<N>, LN extends List = []> = {
+  0: DropBack<L, N, Prev<I>, Prepend<LN, L[Pos<I>]>>;
   1: LN;
-}[Extends<-1, Pos<I$1>>];
+}[Extends<-1, Pos<I>>];
 /**
  * @hidden
  */
@@ -1333,10 +1624,10 @@ declare type Drop<L extends List, N extends number, way extends Way = '->'> = L
  * starts in reverse from `N` till `N` = 0
  * @hidden
  */
-declare type TakeForth<L extends List, N extends Iteration, I$1 extends Iteration = Prev<N>, LN extends List = []> = {
-  0: TakeForth<L, N, Prev<I$1>, Prepend<LN, L[Pos<I$1>]>>;
+declare type TakeForth<L extends List, N extends Iteration, I extends Iteration = Prev<N>, LN extends List = []> = {
+  0: TakeForth<L, N, Prev<I>, Prepend<LN, L[Pos<I>]>>;
   1: LN;
-}[Extends<-1, Pos<I$1>>];
+}[Extends<-1, Pos<I>>];
 /**
  * starts in reverse from the end till `N` = 0
  * @hidden
@@ -1369,15 +1660,15 @@ declare type _Take<L extends List, N extends number, way extends Way = '->'> = _
 declare type Take<L extends List, N extends number, way extends Way = '->'> = L extends unknown ? N extends unknown ? _Take<L, N, way> : never : never;
 //#endregion
 //#region src/types/index.type.d.ts
-type AnyArray<A$1 = any> = readonly A$1[];
+type AnyArray<A = any> = readonly A[];
 type Range<Start extends number, End extends number> = Exclude<keyof TupleOf<End>, keyof TupleOf<Start>>;
-type TupleToEntries<A$1 extends readonly unknown[]> = If<IsAny<A$1>, unknown, { [Key in keyof A$1]: [Key, A$1[Key]] }>;
+type TupleToEntries<A extends readonly unknown[]> = If<IsAny<A>, unknown, { [Key in keyof A]: [Key, A[Key]] }>;
 type Groups<L extends AnyArray, LN extends AnyArray = [], D extends number[] = []> = D["length"] extends 40 ? LN : {
   0: Groups<Drop<L, 1>, Append<LN, [`${LN["length"]}`, Take<L, 1>]>, [...D, 0]>;
   1: LN;
 }[Extends<L, AnyArray<never>>];
 type TupleToGroups<L extends AnyArray> = Groups<L> extends infer X ? Cast<X, AnyArray> : never;
-type MatchFunction<T, R$1 = unknown> = (row: T, index: number) => R$1;
+type MatchFunction<T, R = unknown> = (row: T, index: number) => R;
 //#endregion
 //#region src/utils/array/arrayCounting.d.ts
 /**
@@ -1396,7 +1687,7 @@ type MatchFunction<T, R$1 = unknown> = (row: T, index: number) => R$1;
  * arrayCounting(users, (u) => u.group); // { A: 2, B: 1 }
  * ```
  */
-declare function arrayCounting<T, K$1 extends PropertyKey>(initialList: readonly T[], match: MatchFunction<T, K$1>): Record<string, number>;
+declare function arrayCounting<T, K extends PropertyKey>(initialList: readonly T[], match: MatchFunction<T, K>): Record<string, number>;
 //#endregion
 //#region src/utils/array/arrayDifference.d.ts
 /**
@@ -1523,7 +1814,7 @@ declare function arrayMerge<T, D = T>(initialList: readonly T[], mergeList: read
  * ```
  */
 declare function arrayPick<const T>(initialList: readonly T[], filter: (row: T, index: number) => boolean): T[];
-declare function arrayPick<const T, K$1 = T>(initialList: readonly T[], filter: (row: T, index: number) => boolean, mapper: ((row: T, index: number) => K$1)): K$1[];
+declare function arrayPick<const T, K = T>(initialList: readonly T[], filter: (row: T, index: number) => boolean, mapper: ((row: T, index: number) => K)): K[];
 //#endregion
 //#region src/utils/array/arrayReplace.d.ts
 /**
@@ -1541,8 +1832,8 @@ declare function arrayPick<const T, K$1 = T>(initialList: readonly T[], filter:
  * ```
  */
 declare function arrayReplace<const T>(initialList: readonly T[], newItem: T, match: MatchFunction<T, boolean>): T[];
-declare function arrayReplace<const T, K$1 extends T>(initialList: readonly T[], newItem: K$1, match: MatchFunction<T, boolean>): T[];
-declare function arrayReplace<const T, K$1>(initialList: readonly T[], newItem: K$1, match: MatchFunction<T, boolean>): (T | K$1)[];
+declare function arrayReplace<const T, K extends T>(initialList: readonly T[], newItem: K, match: MatchFunction<T, boolean>): T[];
+declare function arrayReplace<const T, K>(initialList: readonly T[], newItem: K, match: MatchFunction<T, boolean>): (T | K)[];
 //#endregion
 //#region src/utils/array/arrayReplaceMove.d.ts
 type PositionType = "start" | "end" | number;
@@ -1627,9 +1918,9 @@ declare function arrayZip(): [];
  * arrayZipToObject(["a", "b"], 1); // { a: 1, b: 1 }
  * ```
  */
-declare function arrayZipToObject<const K$1 extends PropertyKey, const V$1>(keys: readonly K$1[], array: readonly V$1[]): Record<K$1, V$1>;
-declare function arrayZipToObject<const K$1 extends PropertyKey, const V$1>(keys: readonly K$1[], match: MatchFunction<K$1, V$1>): Record<K$1, V$1>;
-declare function arrayZipToObject<const K$1 extends PropertyKey, const V$1>(keys: readonly K$1[], value: V$1): Record<K$1, V$1>;
+declare function arrayZipToObject<const K extends PropertyKey, const V>(keys: readonly K[], array: readonly V[]): Record<K, V>;
+declare function arrayZipToObject<const K extends PropertyKey, const V>(keys: readonly K[], match: MatchFunction<K, V>): Record<K, V>;
+declare function arrayZipToObject<const K extends PropertyKey, const V>(keys: readonly K[], value: V): Record<K, V>;
 //#endregion
 //#region src/utils/device/isBrowser.d.ts
 declare function isBrowser(): boolean;
@@ -1693,7 +1984,7 @@ declare function isTablet(minWidth?: number, maxWidth?: number, dpi?: number): b
  * console.log(data);
  * ```
  */
-declare function to<T, U$1 = Error>(promise: Readonly<Promise<T>>, errorExt?: PlainObject): Promise<[U$1, undefined] | [null, T]>;
+declare function to<T, U = Error>(promise: Readonly<Promise<T>>, errorExt?: PlainObject): Promise<[U, undefined] | [null, T]>;
 //#endregion
 //#region src/utils/math/mathToBignumber.d.ts
 /**
@@ -1974,7 +2265,7 @@ interface BigInt64Array$1 {
    * the accumulation. The first call to the callbackfn function provides this value as an argument
    * instead of an array value.
    */
-  reduce<U$1>(callbackfn: (previousValue: U$1, currentValue: bigint, currentIndex: number, array: BigInt64Array$1) => U$1, initialValue: U$1): U$1;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array$1) => U, initialValue: U): U;
   /**
    * Calls the specified callback function for all the elements in an array, in descending order.
    * The return value of the callback function is the accumulated result, and is provided as an
@@ -1996,7 +2287,7 @@ interface BigInt64Array$1 {
    * the accumulation. The first call to the callbackfn function provides this value as an argument
    * instead of an array value.
    */
-  reduceRight<U$1>(callbackfn: (previousValue: U$1, currentValue: bigint, currentIndex: number, array: BigInt64Array$1) => U$1, initialValue: U$1): U$1;
+  reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigInt64Array$1) => U, initialValue: U): U;
   /** Reverses the elements in the array. */
   reverse(): this;
   /**
@@ -2183,7 +2474,7 @@ interface BigUint64Array$1 {
    * the accumulation. The first call to the callbackfn function provides this value as an argument
    * instead of an array value.
    */
-  reduce<U$1>(callbackfn: (previousValue: U$1, currentValue: bigint, currentIndex: number, array: BigUint64Array$1) => U$1, initialValue: U$1): U$1;
+  reduce<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array$1) => U, initialValue: U): U;
   /**
    * Calls the specified callback function for all the elements in an array, in descending order.
    * The return value of the callback function is the accumulated result, and is provided as an
@@ -2205,7 +2496,7 @@ interface BigUint64Array$1 {
    * the accumulation. The first call to the callbackfn function provides this value as an argument
    * instead of an array value.
    */
-  reduceRight<U$1>(callbackfn: (previousValue: U$1, currentValue: bigint, currentIndex: number, array: BigUint64Array$1) => U$1, initialValue: U$1): U$1;
+  reduceRight<U>(callbackfn: (previousValue: U, currentValue: bigint, currentIndex: number, array: BigUint64Array$1) => U, initialValue: U): U;
   /** Reverses the elements in the array. */
   reverse(): this;
   /**
@@ -2340,7 +2631,6 @@ declare class Any {
 /**
  * Represents a class constructor.
  */
-
 /**
  * Get all properties **not using** the `?:` type operator.
  */
@@ -2354,7 +2644,7 @@ type OptionalKeys<T> = T extends any ? keyof T extends infer K ? K extends keyof
  *
  * Otherwise false.
  */
-type IsExactType<Left, Right> = [Left] extends [Any] ? [Right] extends [Any] ? true : false : (<U$1>() => U$1 extends Left ? 1 : 0) extends (<U$1>() => U$1 extends Right ? 1 : 0) ? true : false;
+type IsExactType<Left, Right> = [Left] extends [Any] ? [Right] extends [Any] ? true : false : (<U>() => U extends Left ? 1 : 0) extends (<U>() => U extends Right ? 1 : 0) ? true : false;
 type Primitive = number | string | boolean | symbol | bigint | null | undefined | void;
 /**
  * Coerce a primitive type to its boxed equivalent.
@@ -2407,7 +2697,6 @@ declare namespace WebDocumentAPI {
   type BuiltInType = GlobalObjectType<'Node'> | GlobalObjectType<'NodeList'> | GlobalObjectType<'NodeIterator'> | GlobalObjectType<'HTMLCollection'> | GlobalObjectType<'CSSStyleDeclaration'> | GlobalObjectType<'DOMStringList'> | GlobalObjectType<'DOMTokenList'>;
 }
 type GlobalObjectType<Identifier extends string> = [Identifier] extends [Any] ? never : keyof Identifier extends never ? never : typeof globalThis extends { [P in Identifier]: any } ? InstanceType<(typeof globalThis)[Identifier]> : never;
-
 /**
  * Converts a `PromiseLike` to a `Promise<Result>`.
  *
@@ -2430,7 +2719,6 @@ type GlobalObjectType<Identifier extends string> = [Identifier] extends [Any] ?
  * ```
  * @version 12.4.0
  */
-
 /**
  * The return type for `assign`.
  *
@@ -2460,11 +2748,13 @@ type AssignDeep<TInitial, TOverride, IsOptional = false> = never
 /**
  * When a native type is found in TInitial, it will only exist in
  * the result type if the override is optional.
- */ | (TInitial extends AtomicValue ? IsOptional extends true ? TInitial : never : never)
+ */
+| (TInitial extends AtomicValue ? IsOptional extends true ? TInitial : never : never)
 /**
  * When a native type is found in TOverride, it will always exists
  * in the result type.
- */ | (TOverride extends AtomicValue ? TOverride : never)
+ */
+| (TOverride extends AtomicValue ? TOverride : never)
 /**
  * Deep assignment is handled in this branch.
  *
@@ -2475,10 +2765,9 @@ type AssignDeep<TInitial, TOverride, IsOptional = false> = never
  *    every non-native object in TInitial
  * 4. For each non-object type in TOverride, simply replace TInitial
  *    (or use "A | B" if the override is optional)
- */ | (Exclude<TOverride, AtomicValue> extends infer TOverride ? Exclude<TInitial, Exclude<AtomicValue, void>> extends infer TInitial ? [Extract<TInitial, object>] extends [never] ? TOverride | (IsOptional extends true ? TInitial : never) : TInitial extends object ? TOverride extends object ? IsExactType<TOverride, TInitial> extends true ? TOverride : Assign<TInitial, TOverride> :
-// 4.
+ */
+| (Exclude<TOverride, AtomicValue> extends infer TOverride ? Exclude<TInitial, Exclude<AtomicValue, void>> extends infer TInitial ? [Extract<TInitial, object>] extends [never] ? TOverride | (IsOptional extends true ? TInitial : never) : TInitial extends object ? TOverride extends object ? IsExactType<TOverride, TInitial> extends true ? TOverride : Assign<TInitial, TOverride> : // 4.
 TOverride | (IsOptional extends true ? TInitial : never) : Extract<TOverride, object> | (IsOptional extends true ? TInitial : never) : never : never);
-
 /**
  * Creates a shallow copy of the given object/value.
  *
@@ -2512,8 +2801,8 @@ TOverride | (IsOptional extends true ? TInitial : never) : Extract<TOverride, ob
  * objectAssign(initial, override); // { a: 1, b: { c: 2, d: 3 } }
  * ```
  */
-declare function objectAssign<I$1 extends PlainObject, O extends PlainObject>(initial: I$1, override: O): Assign<I$1, O>;
-declare function objectAssign<I$1 extends AnyObject, O extends AnyObject>(initial: I$1, override: O): Assign<I$1, O>;
+declare function objectAssign<I extends PlainObject, O extends PlainObject>(initial: I, override: O): Assign<I, O>;
+declare function objectAssign<I extends AnyObject, O extends AnyObject>(initial: I, override: O): Assign<I, O>;
 //#endregion
 //#region src/utils/object/objectCrush.d.ts
 type Crush<T> = T extends readonly (infer U)[] ? Record<string, U extends object ? unknown : U> : Simplify<UnionToIntersection<keyof T extends infer Prop ? Prop extends keyof T ? T[Prop] extends infer Value ? ([Extract<Value, object>] extends [never] ? never : Record<string, unknown>) | ([Exclude<Value, object>] extends [never] ? never : [Extract<Value, object>] extends [never] ? { [P in Prop]: Value } : Record<string, unknown>) : never : never : never>>;
@@ -2544,13 +2833,13 @@ declare function objectCrush<T extends AnyObject>(anyObject: T): Crush<T>;
  * ```
  */
 declare function objectEntries<const S extends string>(string: S): TupleToEntries<Split<S, "">>;
-declare function objectEntries<const A$1 extends readonly unknown[]>(array: A$1): TupleToGroups<A$1>;
+declare function objectEntries<const A extends readonly unknown[]>(array: A): TupleToGroups<A>;
 declare function objectEntries<const O extends PlainObject>(plainObject: O): [`${keyof Except<O, symbol>}`, O[keyof Except<O, symbol>]][];
 declare function objectEntries<const O extends AnyObject>(anyObject: O): [`${keyof Except<O, symbol>}`, O[keyof Except<O, symbol>]][];
 //#endregion
 //#region src/utils/object/objectInvert.d.ts
-type IntersectOf<U$1> = (U$1 extends unknown ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
-type ComputeRaw<A$1> = A$1 extends AnyFunction ? A$1 : { [K in keyof A$1]: A$1[K] } & unknown;
+type IntersectOf<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type ComputeRaw<A> = A extends AnyFunction ? A : { [K in keyof A]: A[K] } & unknown;
 type _Invert<O extends Record<PropertyKey, PropertyKey>> = ComputeRaw<IntersectOf<{ [K in keyof O]: Record<O[K], K> }[keyof O]>>;
 type Invert<O extends Record<keyof O, PropertyKey>> = O extends unknown ? _Invert<O> : never;
 /**
@@ -2580,7 +2869,7 @@ declare function objectInvert<const O extends AnyObject>(anyObject: O): Invert<O
  * ```
  */
 declare function objectKeys<const S extends string>(string: S): UnionToTuple<Range<0, Split<S, "">["length"]>>;
-declare function objectKeys<const A$1 extends ArrayLike<unknown>>(array: A$1): UnionToTuple<Range<0, A$1["length"]>>;
+declare function objectKeys<const A extends ArrayLike<unknown>>(array: A): UnionToTuple<Range<0, A["length"]>>;
 declare function objectKeys<O extends PlainObject>(plainObject: O): `${Extract<keyof O, string | number>}`[];
 declare function objectKeys<O extends AnyObject>(anyObject: O): `${Extract<keyof O, string | number>}`[];
 //#endregion
@@ -2596,8 +2885,8 @@ declare function objectKeys<O extends AnyObject>(anyObject: O): `${Extract<keyof
  * objectOmit({ a: 1, b: 2 }, ["a"]); // { b: 2 }
  * ```
  */
-declare function objectOmit<O extends PlainObject, K$1 extends keyof O>(plainObject: O, keys: readonly K$1[]): Omit<O, K$1>;
-declare function objectOmit<O extends AnyObject, K$1 extends keyof O>(anyObject: O, keys: readonly K$1[]): Omit<O, K$1>;
+declare function objectOmit<O extends PlainObject, K extends keyof O>(plainObject: O, keys: readonly K[]): Omit<O, K>;
+declare function objectOmit<O extends AnyObject, K extends keyof O>(anyObject: O, keys: readonly K[]): Omit<O, K>;
 //#endregion
 //#region src/utils/object/objectPick.d.ts
 /**
@@ -2611,8 +2900,8 @@ declare function objectOmit<O extends AnyObject, K$1 extends keyof O>(anyObject:
  * objectPick({ a: 1, b: 2 }, ["a"]); // { a: 1 }
  * ```
  */
-declare function objectPick<O extends PlainObject, K$1 extends keyof O>(plainObject: O, keys: readonly K$1[]): Pick<O, K$1>;
-declare function objectPick<O extends AnyObject, K$1 extends keyof O>(anyObject: O, keys: readonly K$1[]): Pick<O, K$1>;
+declare function objectPick<O extends PlainObject, K extends keyof O>(plainObject: O, keys: readonly K[]): Pick<O, K>;
+declare function objectPick<O extends AnyObject, K extends keyof O>(anyObject: O, keys: readonly K[]): Pick<O, K>;
 //#endregion
 //#region src/utils/object/objectValues.d.ts
 /**
@@ -2626,7 +2915,7 @@ declare function objectPick<O extends AnyObject, K$1 extends keyof O>(anyObject:
  * ```
  */
 declare function objectValues<S extends string>(string: S): Split<S, "">;
-declare function objectValues<A$1 extends ArrayLike<unknown>>(array: A$1): A$1;
+declare function objectValues<A extends ArrayLike<unknown>>(array: A): A;
 declare function objectValues<O extends PlainObject>(plainObject: O): O[keyof O][];
 declare function objectValues<O extends AnyObject>(anyObject: O): O[keyof O][];
 //#endregion
@@ -2663,7 +2952,7 @@ declare function stringInitialCase(input: string, caseType?: "lower" | "upper" |
  * stringReplace("hello world", "world", "context"); // "hello context"
  * ```
  */
-declare function stringReplace<I$1 extends string, S extends string, R$1 extends string>(input: I$1, search: S, replacement: R$1): Replace<I$1, S, R$1>;
+declare function stringReplace<I extends string, S extends string, R extends string>(input: I, search: S, replacement: R): Replace<I, S, R>;
 //#endregion
 //#region src/utils/string/stringTemplate.d.ts
 /**
@@ -2917,7 +3206,7 @@ declare function treeForEach<T extends AnyObject, CK extends string = ChildrenKe
 //#endregion
 //#region src/utils/tree/treeMap.d.ts
 type TreeMapOptions<T extends AnyObject, CK extends string> = BaseOptions<T, CK>;
-type TreeMapCallback<R$1 extends AnyObject, T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => R$1;
+type TreeMapCallback<R extends AnyObject, T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => R;
 /**
  * 映射树节点
  * - 返回新的树结构，保持层级关系
@@ -2933,8 +3222,8 @@ type TreeMapCallback<R$1 extends AnyObject, T extends AnyObject> = (row: T, meta
  * // [{ id: 1, val: 20, children: [{ id: 2, val: 40 }] }]
  * ```
  */
-declare function treeMap<R$1 extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeMapCallback<R$1, T>, options?: TreeMapOptions<T, CK>): TreeLike<R$1, CK>[];
-declare function treeMap<R$1 extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeMapCallback<R$1, T>, options?: TreeMapOptions<T, CK>): TreeLike<R$1, CK>;
+declare function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>[];
+declare function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>;
 //#endregion
 //#region src/utils/tree/rowsToTree.d.ts
 interface RowsToTreeOptions<RK extends string = RowKey, PK extends string = ParentIdKey, CK extends string = ChildrenKey> {
@@ -2959,7 +3248,7 @@ interface RowsToTreeOptions<RK extends string = RowKey, PK extends string = Pare
  * // [{ id: 1, parentId: null, children: [{ id: 2, parentId: 1 }] }]
  * ```
  */
-declare function rowsToTree<T extends AnyObject = AnyObject, CK extends string = ChildrenKey, R$1 = TreeLike<T, CK>, RK extends string = RowKey, PK extends string = ParentIdKey>(rows: T[], options?: RowsToTreeOptions<RK, PK, CK> | undefined): R$1[];
+declare function rowsToTree<T extends AnyObject = AnyObject, CK extends string = ChildrenKey, R = TreeLike<T, CK>, RK extends string = RowKey, PK extends string = ParentIdKey>(rows: T[], options?: RowsToTreeOptions<RK, PK, CK> | undefined): R[];
 //#endregion
 //#region src/utils/tree/treeToRows.d.ts
 type TreeToRowsOptions<T extends AnyObject, CK extends string = ChildrenKey> = TreeForeachOptions<T, CK>;
@@ -2977,7 +3266,7 @@ type TreeToRowsOptions<T extends AnyObject, CK extends string = ChildrenKey> = T
  * // [{ id: 1, children: undefined }, { id: 2, children: undefined }]
  * ```
  */
-declare function treeToRows<T extends AnyObject, CK extends string = ChildrenKey, R$1 extends AnyObject = SetOptional<T, CK>>(tree: T | T[], options?: TreeToRowsOptions<T, CK>): R$1[];
+declare function treeToRows<T extends AnyObject, CK extends string = ChildrenKey, R extends AnyObject = SetOptional<T, CK>>(tree: T | T[], options?: TreeToRowsOptions<T, CK>): R[];
 //#endregion
 //#region src/utils/typeof/isAbortSignal.d.ts
 /**
@@ -3258,8 +3547,8 @@ declare function isInfinityLike(value: unknown): boolean;
  * ```ts
  * isObject({}); // true
  * isObject([]); // false
- * isObject(new Date()); // false (because prototype is not Object.prototype)
- * isObject(new Date(), false); // true (is object type)
+ * isObject(new Date()); // false
+ * isObject(new Date(), false); // true
  * isObject(Object.create(null)) // false
  * isObject(Object.create(null), false) // true
  * ```
@@ -3371,5 +3660,5 @@ declare function isWebSocket(value: unknown): value is WebSocket;
  */
 declare function isWindow(value: unknown): value is Window;
 //#endregion
-export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arrayReplaceMove, arraySplit, arrayUnzip, arrayZip, arrayZipToObject, clone, cloneDeep, cloneDeepWith, enumEntries, enumKeys, enumValues, getTimeZone, isAbortSignal, isArray, isAsyncFunction, isAsyncGeneratorFunction, isBigInt, isBlob, isBoolean, isBrowser, isClass, isDate, isEnumeration, isEqual, isError, isFalsy, isFalsyLike, isFile, isFunction, isGeneratorFunction, isIOSMobile, isIframe, isInIframe, isInfinity, isInfinityLike, isInteger, isIterable, isMap, isMobile, isNaN, isNegativeInteger, isNull, isNumber, isObject, isPositiveInteger, isPromise, isPromiseLike, isReadableStream, isRegExp, isSet, isString, isSymbol, isTablet, isTypedArray, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWebWorker, isWindow, mathToBignumber, mathToDecimal, mathToEvaluate, numberWithin, objectAssign, objectCrush, objectEntries, objectInvert, objectKeys, objectMapEntries, objectOmit, objectPick, objectValues, rowsToTree, stringInitialCase, stringReplace, stringTemplate, stringToJson, stringToLowerCase, stringToNumber, stringToPosix, stringToUpperCase, stringToValues, stringTrim, stringTruncate, to, treeFilter, treeFind, treeForEach, treeMap, treeToRows };
+export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arrayReplaceMove, arraySplit, arrayUnzip, arrayZip, arrayZipToObject, enumEntries, enumKeys, enumValues, getTimeZone, isAbortSignal, isArray, isAsyncFunction, isAsyncGeneratorFunction, isBigInt, isBlob, isBoolean, isBrowser, isClass, isDate, isEnumeration, isEqual, isError, isFalsy, isFalsyLike, isFile, isFunction, isGeneratorFunction, isIOSMobile, isIframe, isInIframe, isInfinity, isInfinityLike, isInteger, isIterable, isMap, isMobile, isNaN, isNegativeInteger, isNull, isNumber, isObject, isPositiveInteger, isPromise, isPromiseLike, isReadableStream, isRegExp, isSet, isString, isSymbol, isTablet, isTypedArray, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWebWorker, isWindow, mathToBignumber, mathToDecimal, mathToEvaluate, numberWithin, objectAssign, objectCrush, objectEntries, objectInvert, objectKeys, objectMapEntries, objectOmit, objectPick, objectValues, rowsToTree, stringInitialCase, stringReplace, stringTemplate, stringToJson, stringToLowerCase, stringToNumber, stringToPosix, stringToUpperCase, stringToValues, stringTrim, stringTruncate, to, treeFilter, treeFind, treeForEach, treeMap, treeToRows };
 //# sourceMappingURL=index.d.ts.map