@pawover/kit 0.0.0-beta.5 → 0.0.0-beta.6

package/dist/index.d.ts

@@ -122,58 +122,31 @@ declare function arrayReplace<T>(initialList: readonly T[], newItem: T, match: (
  */
 declare function arraySplit<T>(initialList: readonly T[], size?: number): T[][];
 //#endregion
-//#region src/utils/function/to.d.ts
-/**
- * @param promise
- * @param errorExt 可以传递给err对象的其他信息
- */
-declare function to<T, U$1 = Error>(promise: Readonly<Promise<T>>, errorExt?: PlainObject): Promise<[U$1, undefined] | [null, T]>;
-//#endregion
-//#region src/utils/math/toMathBignumber.d.ts
+//#region src/utils/device/isMobile.d.ts
 /**
- * 将任意类型的值转换为 `math.bignumber`
+ * 检测当前设备是否为移动设备
  *
- * @param mathJsInstance mathJs 实例
- * @param value 任意类型的值
- * @param saveValue 安全值
+ * @param maxWidth - 移动设备最大宽度（默认 768px）
+ * @param dpi - 标准 DPI 基准（默认 160）
  */
-declare function toMathBignumber(mathJsInstance: MathJsInstance, value: unknown, saveValue?: BigNumber | undefined): BigNumber;
-//#endregion
-//#region src/utils/math/toMathDecimal.d.ts
+declare function isMobile(maxWidth?: number, dpi?: number): boolean;
 /**
- * 将任意类型的值转换为十进制数字字符串
+ * 检测当前设备是否为IOS移动设备
  *
- * @param mathJsInstance mathJs 实例
- * @param value 任意类型的值
- * @param precision 精度
- * @param isFormat 是否格式化为字符串
+ * @param maxWidth - 移动设备最大宽度（默认 768px）
+ * @param dpi - 标准 DPI 基准（默认 160）
  */
-declare function toMathDecimal(mathJsInstance: MathJsInstance, value: unknown, precision?: number | undefined, isFormat?: true): string;
-declare function toMathDecimal(mathJsInstance: MathJsInstance, value: unknown, precision?: number | undefined, isFormat?: false): BigNumber;
+declare function isISOMobile(maxWidth?: number, dpi?: number): boolean;
 //#endregion
-//#region src/utils/math/toMathEvaluate.d.ts
+//#region src/utils/device/isTablet.d.ts
 /**
- * 数学表达式求值
+ * 检测当前设备是否为平板
  *
- * @param mathJsInstance mathJs 实例
- * @param expr 表达式
- * @param scope 键值映射
- */
-declare function toMathEvaluate(mathJsInstance: MathJsInstance, expr: MathExpression | Matrix, scope?: Record<string, BigNumber>): string;
-//#endregion
-//#region src/utils/object/cloneDeep.d.ts
-interface CloningStrategy {
-  cloneMap: <K$1, V>(parent: Map<K$1, V>, track: (newParent: Map<K$1, V>) => Map<K$1, V>, clone: <T>(value: T) => T) => Map<K$1, V> | null;
-  cloneSet: <T>(parent: Set<T>, track: (newParent: Set<T>) => Set<T>, clone: <T>(value: T) => T) => Set<T> | null;
-  cloneArray: <T>(parent: readonly T[], track: (newParent: T[]) => T[], clone: <T>(value: T) => T) => T[] | null;
-  cloneObject: <T extends AnyObject>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;
-  cloneOther: <T>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;
-}
-/**
- * cloneDeep
- * @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
+ * @param minWidth - 平板最小宽度（默认 768px）
+ * @param maxWidth - 平板最大宽度（默认 1200px）
+ * @param dpi - 标准 DPI 基准（默认 160）
  */
-declare function cloneDeep<T extends AnyObject>(root: T, customStrategy?: Partial<CloningStrategy>): T;
+declare function isTablet(minWidth?: number, maxWidth?: number, dpi?: number): boolean;
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/basic.d.ts
 /**
@@ -334,7 +307,7 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 @category Type Guard
 @category Utilities
 */
-type IsOptionalKeyOf<Type extends object, Key$1 extends keyof Type> = IsAny<Type | Key$1> extends true ? never : Key$1 extends keyof Type ? Type extends Record<Key$1, Type[Key$1]> ? false : true : false;
+type IsOptionalKeyOf<Type$1 extends object, Key$2 extends keyof Type$1> = IsAny<Type$1 | Key$2> extends true ? never : Key$2 extends keyof Type$1 ? Type$1 extends Record<Key$2, Type$1[Key$2]> ? false : true : false;
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
@@ -370,8 +343,8 @@ const update2: UpdateOperation<User> = {
 
 @category Utilities
 */
-type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+type OptionalKeysOf<Type$1 extends object> = Type$1 extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type$1 as IsOptionalKeyOf<Type$1, Key> extends false ? never : Key]: never }) & keyof Type$1 // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
 : never;
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/required-keys-of.d.ts
@@ -405,67 +378,8 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 
 @category Utilities
 */
-type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
-? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
-//#endregion
-//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/has-required-keys.d.ts
-/**
-Creates a type that represents `true` or `false` depending on whether the given type has any required fields.
-
-This is useful when you want to create an API whose behavior depends on the presence or absence of required fields.
-
-@example
-```
-import type {HasRequiredKeys} from 'type-fest';
-
-type GeneratorOptions<Template extends object> = {
-	prop1: number;
-	prop2: string;
-} & (HasRequiredKeys<Template> extends true
-	? {template: Template}
-	: {template?: Template});
-
-type Template1 = {
-	optionalSubParam?: string;
-};
-
-type Template2 = {
-	requiredSubParam: string;
-};
-
-type Options1 = GeneratorOptions<Template1>;
-type Options2 = GeneratorOptions<Template2>;
-
-const optA: Options1 = {
-	prop1: 0,
-	prop2: 'hi',
-};
-const optB: Options1 = {
-	prop1: 0,
-	prop2: 'hi',
-	template: {},
-};
-const optC: Options1 = {
-	prop1: 0,
-	prop2: 'hi',
-	template: {
-		optionalSubParam: 'optional value',
-	},
-};
-
-const optD: Options2 = {
-	prop1: 0,
-	prop2: 'hi',
-	template: {
-		requiredSubParam: 'required value',
-	},
-};
-
-```
-
-@category Utilities
-*/
-type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+type RequiredKeysOf<Type$1 extends object> = Type$1 extends unknown // For distributing `Type`
+? Exclude<keyof Type$1, OptionalKeysOf<Type$1>> : never;
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/is-never.d.ts
 /**
@@ -616,10 +530,50 @@ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
 @category Type Guard
 @category Utilities
 */
-type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+type If<Type$1 extends boolean, IfBranch, ElseBranch> = IsNever<Type$1> extends true ? ElseBranch : Type$1 extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/unknown-array.d.ts
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+type UnknownArray = readonly unknown[];
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/internal/type.d.ts
 /**
+Returns a boolean for whether A is false.
+
+@example
+```
+type A = Not<true>;
+//=> false
+
+type B = Not<false>;
+//=> true
+```
+*/
+type Not<A$1 extends boolean> = A$1 extends true ? false : A$1 extends false ? true : never;
+/**
 An if-else-like type that resolves depending on whether the given type is `any` or `never`.
 
 @example
@@ -664,6 +618,407 @@ type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
 ```
 */
 type IfNotAnyOrNever<T, IfNotAnyOrNever$1, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever$1>>;
+/**
+Indicates the value of `exactOptionalPropertyTypes` compiler option.
+*/
+type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?] ? false : true;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.3.1/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.
+
+@example
+```
+type A = CollapseRestElement<[string, string, ...number[]]>;
+//=> [string, string, number]
+
+type B = CollapseRestElement<[...string[], number, number]>;
+//=> [string, number, number]
+
+type C = CollapseRestElement<[string, string, ...Array<number | bigint>]>;
+//=> [string, string, number | bigint]
+
+type D = CollapseRestElement<[string, number]>;
+//=> [string, number]
+```
+
+Note: Optional modifiers (`?`) are removed from elements unless the `exactOptionalPropertyTypes` compiler option is disabled. When disabled, there's an additional `| undefined` for optional elements.
+
+@example
+```
+// `exactOptionalPropertyTypes` enabled
+type A = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string, string, number]
+
+// `exactOptionalPropertyTypes` disabled
+type B = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string | undefined, string | undefined, 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., []),
+// 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.
+: TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator, '0' extends OptionalKeysOf<TArray> ? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+: 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.3.1/node_modules/type-fest/source/numeric.d.ts
+type _Numeric = number | bigint;
+type Zero = 0 | 0n;
+
+/**
+Matches the hidden `Infinity` type.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
+
+@see {@link NegativeInfinity}
+
+@category Numeric
+*/
+// See https://github.com/microsoft/TypeScript/issues/31752
+// eslint-disable-next-line no-loss-of-precision
+
+/**
+A negative `number`/`bigint` (`-∞ < x < 0`)
+
+Use-case: Validating and documenting parameters.
+
+@see {@link NegativeInteger}
+@see {@link NonNegative}
+
+@category Numeric
+*/
+type Negative<T extends _Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
+/**
+Returns a boolean for whether the given number is a negative number.
+
+@see {@link Negative}
+
+@example
+```
+import type {IsNegative} from 'type-fest';
+
+type ShouldBeFalse = IsNegative<1>;
+type ShouldBeTrue = IsNegative<-1>;
+```
+
+@category Numeric
+*/
+type IsNegative<T extends _Numeric> = T extends Negative<T> ? true : false;
+//#endregion
+//#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.3.1/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.)
+
+A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
+
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+
+A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
+
+A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
+  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
+	- `A` contains at least all the tags `B` has;
+	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
+	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+type AccountNumber = Tagged<number, 'AccountNumber'>;
+type AccountBalance = Tagged<number, 'AccountBalance'>;
+
+function createAccountNumber(): AccountNumber {
+	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
+	return 2 as AccountNumber;
+}
+
+declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
+// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
+// @ts-expect-error
+getMoneyForAccount(2);
+
+// You can also use tagged values like their underlying, untagged type.
+// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
+// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
+const accountNumber = createAccountNumber() + 2;
+```
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+// You can apply multiple tags to a type by using `Tagged` repeatedly.
+type Url = Tagged<string, 'URL'>;
+type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
+
+// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
+type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
+```
+
+@category Type
+*/
+type Tagged<Type$1, TagName extends PropertyKey, TagMetadata = never> = Type$1 & Tag<TagName, TagMetadata>;
+/**
+Revert a tagged type back to its original type by removing all tags.
+
+Why is this necessary?
+
+1. Use a `Tagged` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Tagged, UnwrapTagged} from 'type-fest';
+
+type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1,
+};
+
+// 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.
+// @ts-expect-error
+type WontWork = UnwrapTagged<string>;
+```
+
+@category Type
+*/
+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`.
+
+Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for runtime values that would otherwise have the same type. (See examples.)
+
+The generic type parameters can be anything.
+
+Note that `Opaque` is somewhat of a misnomer here, in that, unlike [some alternative implementations](https://github.com/microsoft/TypeScript/issues/4895#issuecomment-425132582), the original, untagged type is not actually hidden. (E.g., functions that accept the untagged type can still be called with the "opaque" version -- but not vice-versa.)
+
+Also note that this implementation is limited to a single tag. If you want to allow multiple tags, use `Tagged` instead.
+
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
+	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
+
+@example
+```
+import type {Opaque} from 'type-fest';
+
+type AccountNumber = Opaque<number, 'AccountNumber'>;
+type AccountBalance = Opaque<number, 'AccountBalance'>;
+
+// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+type ThingOne = Opaque<string>;
+type ThingTwo = Opaque<string>;
+
+// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
+// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
+type NewThingOne = Opaque<string, 'ThingOne'>;
+type NewThingTwo = Opaque<string, 'ThingTwo'>;
+
+// Now they're completely separate types, so the following will fail to compile.
+function createNewThingOne(): NewThingOne {
+	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
+	return 'new thing one' as NewThingOne;
+}
+
+// This will fail to compile, as they are fundamentally different types.
+// @ts-expect-error
+const thingTwo = createNewThingOne() as NewThingTwo;
+
+// Here's another example of opaque typing.
+function createAccountNumber(): AccountNumber {
+	return 2 as AccountNumber;
+}
+
+declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
+// @ts-expect-error
+getMoneyForAccount(2);
+
+// You can use opaque values like they aren't opaque too.
+const accountNumber = createAccountNumber();
+
+// This will compile successfully.
+const newAccountNumber = accountNumber + 2;
+
+// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
+type Person = {
+	id: Opaque<number, Person>;
+	name: string;
+};
+```
+
+@category Type
+@deprecated Use {@link Tagged} instead
+*/
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.3.1/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).
+
+Useful for:
+	- providing strongly-typed string manipulation functions
+	- constraining strings to be a string literal
+	- type utilities, such as when constructing parsers and ASTs
+
+The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
+
+// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
+function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
+	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
+}
+
+const output = capitalize('hello, world!');
+//=> 'Hello, world!'
+```
+
+@example
+```
+// String types with infinite set of possible values return `false`.
+
+import type {IsStringLiteral} from 'type-fest';
+
+type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
+//=> false
+
+type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
+//=> false
+
+// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
+
+type Length<S extends string, Counter extends never[] = []> =
+	IsStringLiteral<S> extends false
+		? number // return `number` for infinite string types
+		: S extends `${string}${infer Tail}`
+			? Length<Tail, [...Counter, never]>
+			: Counter['length'];
+
+type L1 = Length<Lowercase<string>>;
+//=> number
+
+type L2 = Length<`${number}`>;
+//=> number
+```
+
+@category Type Guard
+@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,
+// 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.3.1/node_modules/type-fest/source/tuple-of.d.ts
+/**
+Create a tuple type of the specified length with elements of the specified type.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type RGB = TupleOf<3, number>;
+//=> [number, number, number]
+
+type Line = TupleOf<2, {x: number; y: number}>;
+//=> [{x: number; y: number}, {x: number; y: number}]
+
+type TicTacToeBoard = TupleOf<3, TupleOf<3, 'X' | 'O' | null>>;
+//=> [['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null], ['X' | 'O' | null, 'X' | 'O' | null, 'X' | 'O' | null]]
+```
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type Range<Start extends number, End extends number> = Exclude<keyof TupleOf<End>, keyof TupleOf<Start>>;
+
+type ZeroToFour = Range<0, 5>;
+//=> '0' | '1' | '2' | '3' | '4'
+
+type ThreeToEight = Range<3, 9>;
+//=> '3' | '4' | '5' | '6' | '7' | '8'
+```
+
+Note: If the specified length is the non-literal `number` type, the result will not be a tuple but a regular array.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type StringArray = TupleOf<number, string>;
+//=> string[]
+```
+
+Note: If the type for elements is not specified, it will default to `unknown`.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type UnknownTriplet = TupleOf<3>;
+//=> [unknown, unknown, unknown]
+```
+
+Note: If the specified length is negative, the result will be an empty tuple.
+
+@example
+```
+import type {TupleOf} from 'type-fest';
+
+type EmptyTuple = TupleOf<-3, string>;
+//=> []
+```
+
+Note: If you need a readonly tuple, simply wrap this type with `Readonly`, for example, to create `readonly [number, number, number]` use `Readonly<TupleOf<3, number>>`.
+
+@category Array
+*/
+type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, _TupleOf<If<IsNegative<Length>, 0, Length>, Fill, []>, Fill[], []>;
+type _TupleOf<L$1 extends number, Fill, Accumulator extends UnknownArray> = number extends L$1 ? Fill[] : L$1 extends Accumulator['length'] ? Accumulator : _TupleOf<L$1, Fill, [...Accumulator, Fill]>;
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/simplify.d.ts
 /**
@@ -1027,6 +1382,282 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 ```
 */
 type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
+// `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+
+/**
+Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
+
+Note: This doesn't collapse literals within tagged types. For example, `CollapseLiterals<Tagged<'foo' | (string & {}), 'Tag'>>` returns `("foo" & Tag<"Tag", never>) | (string & Tag<"Tag", never>)` and not `string & Tag<"Tag", never>`.
+
+Use-case: For collapsing unions created using {@link LiteralUnion}.
+
+@example
+```
+import type {LiteralUnion} from 'type-fest';
+
+type A = CollapseLiterals<'foo' | 'bar' | (string & {})>;
+//=> string
+
+type B = CollapseLiterals<LiteralUnion<1 | 2 | 3, number>>;
+//=> number
+
+type C = CollapseLiterals<LiteralUnion<'onClick' | 'onChange', `on${string}`>>;
+//=> `on${string}`
+
+type D = CollapseLiterals<'click' | 'change' | (`on${string}` & {})>;
+//=> 'click' | 'change' | `on${string}`
+
+type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;
+//=> string | null | undefined
+```
+*/
+type CollapseLiterals<T> = {} extends T ? T : T extends infer U & {} ? U : T;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/or.d.ts
+/**
+Returns a boolean for whether either of two given types is true.
+
+Use-case: Constructing complex conditional types where at least one condition must be satisfied.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type TT = Or<true, true>;
+//=> true
+
+type TF = Or<true, false>;
+//=> true
+
+type FT = Or<false, true>;
+//=> true
+
+type FF = Or<false, false>;
+//=> false
+```
+
+Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `Or<false, boolean>` expands to `Or<false, true> | Or<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type A = Or<false, boolean>;
+//=> boolean
+
+type B = Or<boolean, false>;
+//=> boolean
+
+type C = Or<true, boolean>;
+//=> true
+
+type D = Or<boolean, true>;
+//=> true
+
+type E = Or<boolean, boolean>;
+//=> boolean
+```
+
+Note: If `never` is passed as an argument, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type A = Or<true, never>;
+//=> true
+
+type B = Or<never, true>;
+//=> true
+
+type C = Or<false, never>;
+//=> false
+
+type D = Or<never, false>;
+//=> false
+
+type E = Or<boolean, never>;
+//=> boolean
+
+type F = Or<never, boolean>;
+//=> boolean
+
+type G = Or<never, never>;
+//=> false
+```
+
+@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;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/all-extend.d.ts
+/**
+@see {@link AllExtend}
+*/
+type AllExtendOptions = {
+  /**
+  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 {AllExtend} from 'type-fest';
+  	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
+  //=> false
+  	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
+  //=> true
+  	type C = AllExtend<[never, never], never, {strictNever: true}>;
+  //=> true
+  	type D = AllExtend<[never, never], never, {strictNever: false}>;
+  //=> true
+  	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
+  //=> true
+  	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
+  //=> true
+  	type G = AllExtend<[never, 1], never, {strictNever: true}>;
+  //=> false
+  	type H = AllExtend<[never, 1], never, {strictNever: false}>;
+  //=> false
+  ```
+  */
+  strictNever?: boolean;
+};
+type DefaultAllExtendOptions = {
+  strictNever: true;
+};
+
+/**
+Returns a boolean for whether every element in an array type extends another type.
+
+@example
+```
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1, 2, 3], number>;
+//=> true
+
+type B = AllExtend<[1, 2, '3'], number>;
+//=> false
+
+type C = AllExtend<[number, number | string], number>;
+//=> boolean
+
+type D = AllExtend<[true, boolean, true], true>;
+//=> 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.
+
+```
+import type {AllExtend} from 'type-fest';
+
+// `exactOptionalPropertyTypes` enabled
+type A = AllExtend<[1?, 2?, 3?], number>;
+//=> true
+
+// `exactOptionalPropertyTypes` disabled
+type B = AllExtend<[1?, 2?, 3?], number>;
+//=> false
+
+// `exactOptionalPropertyTypes` disabled
+type C = AllExtend<[1?, 2?, 3?], number | undefined>;
+//=> true
+```
+
+@see {@link AllExtendOptions}
+
+@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>;
+//#endregion
+//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/and.d.ts
+/**
+Returns a boolean for whether two given types are both true.
+
+Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+
+@example
+```
+import type {And} from 'type-fest';
+
+type TT = And<true, true>;
+//=> true
+
+type TF = And<true, false>;
+//=> false
+
+type FT = And<false, true>;
+//=> false
+
+type FF = And<false, false>;
+//=> false
+```
+
+Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `And<true, boolean>` expands to `And<true, true> | And<true, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {And} from 'type-fest';
+
+type A = And<true, boolean>;
+//=> boolean
+
+type B = And<boolean, true>;
+//=> boolean
+
+type C = And<false, boolean>;
+//=> false
+
+type D = And<boolean, false>;
+//=> false
+
+type E = And<boolean, boolean>;
+//=> boolean
+```
+
+Note: If either of the types is `never`, the result becomes `false`.
+
+@example
+```
+import type {And} from 'type-fest';
+
+type A = And<true, never>;
+//=> false
+
+type B = And<never, true>;
+//=> false
+
+type C = And<false, never>;
+//=> false
+
+type D = And<never, false>;
+//=> false
+
+type E = And<boolean, never>;
+//=> false
+
+type F = And<never, boolean>;
+//=> false
+
+type G = And<never, never>;
+//=> false
+```
+
+@see {@link Or}
+@see {@link Xor}
+*/
+type And<A$1 extends boolean, B$1 extends boolean> = AllExtend<[A$1, B$1], true>;
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/except.d.ts
 /**
@@ -1106,93 +1737,26 @@ const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
 // Consider the following example:
 
 type UserData = {
-	[metadata: string]: string;
-	email: string;
-	name: string;
-	role: 'admin' | 'user';
-};
-
-// `Omit` clearly doesn't behave as expected in this case:
-type PostPayload = Omit<UserData, 'email'>;
-//=> { [x: string]: string; [x: number]: string; }
-
-// In situations like this, `Except` works better.
-// It simply removes the `email` key while preserving all the other keys.
-type PostPayloadFixed = Except<UserData, 'email'>;
-//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }
-```
-
-@category Object
-*/
-type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
-type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
-//#endregion
-//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/require-at-least-one.d.ts
-/**
-Create a type that requires at least one of the given keys. The remaining keys are kept as is.
-
-@example
-```
-import type {RequireAtLeastOne} from 'type-fest';
-
-type Responder = {
-	text?: () => string;
-	json?: () => string;
-	secure?: boolean;
-};
-
-const responder: RequireAtLeastOne<Responder, 'text' | 'json'> = {
-	json: () => '{"message": "ok"}',
-	secure: true,
-};
-```
-
-@category Object
-*/
-type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, _RequireAtLeastOne<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
-type _RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType> = {
-  // For each `Key` in `KeysType` make a mapped type:
-[Key in KeysType]-?: Required<Pick<ObjectType, Key>> &
-// 1. Make `Key`'s type required
-// 2. Make all other keys in `KeysType` optional
-Partial<Pick<ObjectType, Exclude<KeysType, Key>>> }[KeysType] &
-// 3. Add the remaining keys not in `KeysType`
-Except<ObjectType, KeysType>;
-//#endregion
-//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/non-empty-object.d.ts
-/**
-Represents an object with at least 1 non-optional key.
-
-This is useful when you need an object where all keys are optional, but there must be at least 1 key.
-
-@example
-```
-import type {NonEmptyObject} from 'type-fest';
-
-type User = {
+	[metadata: string]: string;
+	email: string;
 	name: string;
-	surname: string;
-	id: number;
+	role: 'admin' | 'user';
 };
 
-type UpdateRequest<Entity extends object> = NonEmptyObject<Partial<Entity>>;
-
-const update1: UpdateRequest<User> = {
-	name: 'Alice',
-	surname: 'Acme',
-};
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> { [x: string]: string; [x: number]: string; }
 
-// At least 1 key is required, therefore this will report a 2322 error:
-// Type '{}' is not assignable to type 'UpdateRequest<User>'
-// @ts-expect-error
-const update2: UpdateRequest<User> = {};
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayloadFixed = Except<UserData, 'email'>;
+//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }
 ```
 
-@see Use `IsEmptyObject` to check whether an object is empty.
-
 @category Object
 */
-type NonEmptyObject<T extends object> = HasRequiredKeys<T> extends true ? T : RequireAtLeastOne<T, keyof T>;
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/union-to-tuple.d.ts
 /**
@@ -1241,7 +1805,7 @@ 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$1 = LastOfUnion<T>> = IsNever<T> extends false ? [...UnionToTuple<Exclude<T, L$1>>, L$1] : [];
 //#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/set-optional.d.ts
 /**
@@ -1301,6 +1865,65 @@ type C = ValueOf<{id: number; name: string; active: boolean}, 'id' | 'name'>;
 */
 type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];
 //#endregion
+//#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/split.d.ts
+/**
+Split options.
+
+@see {@link Split}
+*/
+type SplitOptions = {
+  /**
+  When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
+  	@default true
+  	@example
+  ```ts
+  import type {Split} from 'type-fest';
+  	type Example1 = Split<`foo.${string}.bar`, '.', {strictLiteralChecks: false}>;
+  //=> ['foo', string, 'bar']
+  	type Example2 = Split<`foo.${string}`, '.', {strictLiteralChecks: true}>;
+  //=> string[]
+  	type Example3 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: false}>;
+  //=> ['foo', 'r', 'z']
+  	type Example4 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: true}>;
+  //=> string[]
+  ```
+  */
+  strictLiteralChecks?: boolean;
+};
+type DefaultSplitOptions = {
+  strictLiteralChecks: true;
+};
+
+/**
+Represents an array of strings split using a given character or character set.
+
+Use-case: Defining the return type of a method like `String.prototype.split`.
+
+@example
+```
+import type {Split} from 'type-fest';
+
+declare function split<S extends string, D extends string>(string: S, separator: D): Split<S, D>;
+
+type Item = 'foo' | 'bar' | 'baz' | 'waldo';
+const items = 'foo,bar,baz,waldo';
+const array: Item[] = split(items, ',');
+```
+
+@see {@link SplitOptions}
+
+@category String
+@category Template literal
+*/
+type Split<S extends string, Delimiter extends string, Options extends SplitOptions = {}> = SplitHelper<S, Delimiter, ApplyDefaultOptions<SplitOptions, DefaultSplitOptions, Options>>;
+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[]`
+: string[] : never // Should never happen
+: never; // Should never happen
+//#endregion
 //#region node_modules/.pnpm/type-fest@5.3.1/node_modules/type-fest/source/replace.d.ts
 type ReplaceOptions = {
   all?: boolean;
@@ -1367,13 +1990,84 @@ type _Replace<Input extends string, Search extends string, Replacement extends s
 ? Replacement extends string // For distributing `Replacement`
 ? Input extends `${infer Head}${Search}${infer Tail}` ? Options['all'] extends true ? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`> : `${Head}${Replacement}${Tail}` : `${Accumulator}${Input}` : never : never;
 //#endregion
+//#region node_modules/.pnpm/@pawover+types@0.0.0-alpha._110402f22903360a3e22e90ae898db58/node_modules/@pawover/types/dist/index.d.ts
+//#endregion
+//#region src/index.d.ts
+/** 任意对象类型 */
+type AnyObject<K$1 extends PropertyKey = PropertyKey, T = any> = Record<K$1, T>;
+/** 普通对象类型 */
+type PlainObject<K$1 extends PropertyKey = PropertyKey, T = unknown> = Record<K$1, T>;
+/** 描述树类型 */
+type TreeLike<T extends AnyObject, CK extends string = "children"> = T & Record<CK, TreeLike<T, CK>[]>;
+/** 描述函数类型 */
+type AnyFunction<P$1 extends any[] = any[], R$1 = any> = (...arg: P$1) => R$1;
+/** 描述异步函数类型 */
+type AnyAsyncFunction<P$1 extends any[] = any[], R$1 = any> = (...args: P$1) => Promise<R$1>;
+type AnyGeneratorFunction<P$1 extends any[] = any[], T = any, R$1 = any, N = any> = (...args: P$1) => Generator<T, R$1, N>;
+type AnyAsyncGeneratorFunction<P$1 extends any[] = any[], T = any, R$1 = any, N = any> = (...args: P$1) => AsyncGenerator<T, R$1, N>;
+//#endregion
+//#endregion
+//#region src/utils/function/to.d.ts
+/**
+ * @param promise
+ * @param errorExt 可以传递给err对象的其他信息
+ */
+declare function to<T, U$1 = Error>(promise: Readonly<Promise<T>>, errorExt?: PlainObject): Promise<[U$1, undefined] | [null, T]>;
+//#endregion
+//#region src/utils/math/toMathBignumber.d.ts
+/**
+ * 将任意类型的值转换为 `math.bignumber`
+ *
+ * @param mathJsInstance mathJs 实例
+ * @param value 任意类型的值
+ * @param saveValue 安全值
+ */
+declare function toMathBignumber(mathJsInstance: MathJsInstance, value: unknown, saveValue?: BigNumber | undefined): BigNumber;
+//#endregion
+//#region src/utils/math/toMathDecimal.d.ts
+/**
+ * 将任意类型的值转换为十进制数字字符串
+ *
+ * @param mathJsInstance mathJs 实例
+ * @param value 任意类型的值
+ * @param precision 精度
+ * @param isFormat 是否格式化为字符串
+ */
+declare function toMathDecimal(mathJsInstance: MathJsInstance, value: unknown, precision?: number | undefined, isFormat?: true): string;
+declare function toMathDecimal(mathJsInstance: MathJsInstance, value: unknown, precision?: number | undefined, isFormat?: false): BigNumber;
+//#endregion
+//#region src/utils/math/toMathEvaluate.d.ts
+/**
+ * 数学表达式求值
+ *
+ * @param mathJsInstance mathJs 实例
+ * @param expr 表达式
+ * @param scope 键值映射
+ */
+declare function toMathEvaluate(mathJsInstance: MathJsInstance, expr: MathExpression | Matrix, scope?: Record<string, BigNumber>): string;
+//#endregion
+//#region src/utils/object/cloneDeep.d.ts
+interface CloningStrategy {
+  cloneMap: <K$1, V$1>(parent: Map<K$1, V$1>, track: (newParent: Map<K$1, V$1>) => Map<K$1, V$1>, clone: <T>(value: T) => T) => Map<K$1, V$1> | null;
+  cloneSet: <T>(parent: Set<T>, track: (newParent: Set<T>) => Set<T>, clone: <T>(value: T) => T) => Set<T> | null;
+  cloneArray: <T>(parent: readonly T[], track: (newParent: T[]) => T[], clone: <T>(value: T) => T) => T[] | null;
+  cloneObject: <T extends AnyObject>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;
+  cloneOther: <T>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;
+}
+/**
+ * cloneDeep
+ * @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
+ */
+declare function cloneDeep<T extends AnyObject>(root: T, customStrategy?: Partial<CloningStrategy>): T;
+//#endregion
 //#region src/utils/object/enumEntries.d.ts
 /**
  * 返回枚举的属性的键/值数组
  *
  * @param enumeration 枚举
  */
-declare function enumEntries<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, E[keyof E]][];
+declare function enumEntries<E extends PlainObject>(enumeration: E): [keyof E, E[keyof E]][];
+declare function enumEntries<E extends AnyObject>(enumeration: E): [keyof E, E[keyof E]][];
 //#endregion
 //#region src/utils/object/enumKeys.d.ts
 /**
@@ -1381,10 +2075,8 @@ declare function enumEntries<E extends AnyObject>(enumeration: NonEmptyObject<E>
  *
  * @param enumeration 枚举
  */
-declare function enumKeys<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, ...(keyof E)[]];
-//#endregion
-//#region src/utils/object/enumTypeCheck.d.ts
-declare function enumTypeCheck<E extends AnyObject>(enumeration: E): E & Record<PropertyKey, unknown>;
+declare function enumKeys<E extends PlainObject>(enumeration: E): (keyof E)[];
+declare function enumKeys<E extends AnyObject>(enumeration: E): (keyof E)[];
 //#endregion
 //#region src/utils/object/enumValues.d.ts
 /**
@@ -1392,13 +2084,13 @@ declare function enumTypeCheck<E extends AnyObject>(enumeration: E): E & Record<
  *
  * @param enumeration 枚举
  */
-declare function enumValues<E extends AnyObject>(enumeration: NonEmptyObject<E>): UnionToTuple<ValueOf<E>>;
+declare function enumValues<E extends PlainObject>(enumeration: E): UnionToTuple<ValueOf<E>>;
+declare function enumValues<E extends AnyObject>(enumeration: E): UnionToTuple<ValueOf<E>>;
 //#endregion
 //#region src/utils/object/mapEntries.d.ts
-declare function mapEntries<K$1 extends PropertyKey, V, NK extends PropertyKey, NV>(obj: PlainObject<K$1, V>, toEntry: (key: K$1, value: V) => [NK, NV]): PlainObject<NK, NV>;
+declare function mapEntries<K$1 extends PropertyKey, V$1, NK extends PropertyKey, NV>(obj: PlainObject<K$1, V$1>, toEntry: (key: K$1, value: V$1) => [NK, NV]): PlainObject<NK, NV>;
 //#endregion
 //#region node_modules/.pnpm/radashi@12.7.1/node_modules/radashi/dist/radashi.d.cts
-
 interface BigInt {
   /**
    * Returns a string representation of an object.
@@ -2081,47 +2773,616 @@ TOverride | (IsOptional extends true ? TInitial : never) : Extract<TOverride, ob
  * @param override 待合并对象
  */
 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>;
 //#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>>;
-declare function objectCrush<T extends PlainObject>(value: T): Crush<T>;
+declare function objectCrush<T extends PlainObject>(plainObject: T): Crush<T>;
+declare function objectCrush<T extends AnyObject>(anyObject: T): Crush<T>;
 //#endregion
-//#region src/utils/object/objectEntries.d.ts
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Any/Key.d.ts
 /**
- * 返回对象的可枚举属性的键/值数组
+ * Describes index keys for any type
+ */
+declare type Key$1 = string | number | symbol;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/List.d.ts
+/**
+ * A [[List]]
+ * @param A its type
+ * @returns [[List]]
+ * @example
+ * ```ts
+ * type list0 = [1, 2, 3]
+ * type list1 = number[]
+ * ```
+ */
+declare type List<A$1 = any> = ReadonlyArray<A$1>;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Any/Cast.d.ts
+/**
+ * Ask TS to re-check that `A1` extends `A2`.
+ * And if it fails, `A2` will be enforced anyway.
+ * Can also be used to add constraints on parameters.
+ * @param A1 to check against
+ * @param A2 to cast to
+ * @returns `A1 | A2`
+ * @example
+ * ```ts
+ * import {A} from 'ts-toolbelt'
  *
- * @param obj 对象
+ * type test0 = A.Cast<'42', string> // '42'
+ * type test1 = A.Cast<'42', number> // number
+ * ```
  */
-declare function objectEntries<O extends AnyObject>(obj: O): [string & keyof O, O[keyof O]][];
+declare type Cast<A1 extends any, A2 extends any> = A1 extends A2 ? A1 : A2;
 //#endregion
-//#region src/utils/object/objectKeys.d.ts
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Object/_Internal.d.ts
 /**
- * 返回对象的可枚举属性和方法的名称
- * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+ * Describes the permissions/modifiers fields can have
+ * `R`: readonly
+ * `W`: writable
+ * `!`: required
+ * `?`: optional
+ */
+declare type Modx = ['?' | '!', 'W' | 'R'];
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Any/Compute.d.ts
+/**
+ * @hidden
+ */
+declare type ComputeRaw<A$1 extends any> = A$1 extends Function ? A$1 : { [K in keyof A$1]: A$1[K] } & unknown;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Any/Extends.d.ts
+/**
+ * Check whether `A1` is part of `A2` or not. The difference with
+ * `extends` is that it forces a [[Boolean]] return.
+ * @param A1
+ * @param A2
+ * @returns [[Boolean]]
+ * @example
+ * ```ts
+ * import {A} from 'ts-toolbelt'
  *
- * @param obj 对象
+ * type test0 = A.Extends<'a' | 'b', 'b'> // Boolean
+ * type test1 = A.Extends<'a', 'a' | 'b'> // True
+ *
+ * type test2 = A.Extends<{a: string}, {a: any}>      // True
+ * type test3 = A.Extends<{a: any}, {a: any, b: any}> // False
+ *
+ * type test4 = A.Extends<never, never> // False
+ * /// Nothing cannot extend nothing, use `A.Equals`
+ * ```
  */
-declare function objectKeys<O extends AnyObject>(obj: O): (keyof O)[];
+declare type Extends<A1 extends any, A2 extends any> = [A1] extends [never] ? 0 : A1 extends A2 ? 1 : 0;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Iteration/Iteration.d.ts
+/**
+ * An entry of `IterationMap`
+ */
+declare type Iteration = [value: number, sign: '-' | '0' | '+', prev: keyof IterationMap, next: keyof IterationMap, oppo: keyof IterationMap];
+declare type IterationMap = {
+  '__': [number, '-' | '0' | '+', '__', '__', '__'];
+  '-100': [-100, '-', '__', '-99', '100'];
+  '-99': [-99, '-', '-100', '-98', '99'];
+  '-98': [-98, '-', '-99', '-97', '98'];
+  '-97': [-97, '-', '-98', '-96', '97'];
+  '-96': [-96, '-', '-97', '-95', '96'];
+  '-95': [-95, '-', '-96', '-94', '95'];
+  '-94': [-94, '-', '-95', '-93', '94'];
+  '-93': [-93, '-', '-94', '-92', '93'];
+  '-92': [-92, '-', '-93', '-91', '92'];
+  '-91': [-91, '-', '-92', '-90', '91'];
+  '-90': [-90, '-', '-91', '-89', '90'];
+  '-89': [-89, '-', '-90', '-88', '89'];
+  '-88': [-88, '-', '-89', '-87', '88'];
+  '-87': [-87, '-', '-88', '-86', '87'];
+  '-86': [-86, '-', '-87', '-85', '86'];
+  '-85': [-85, '-', '-86', '-84', '85'];
+  '-84': [-84, '-', '-85', '-83', '84'];
+  '-83': [-83, '-', '-84', '-82', '83'];
+  '-82': [-82, '-', '-83', '-81', '82'];
+  '-81': [-81, '-', '-82', '-80', '81'];
+  '-80': [-80, '-', '-81', '-79', '80'];
+  '-79': [-79, '-', '-80', '-78', '79'];
+  '-78': [-78, '-', '-79', '-77', '78'];
+  '-77': [-77, '-', '-78', '-76', '77'];
+  '-76': [-76, '-', '-77', '-75', '76'];
+  '-75': [-75, '-', '-76', '-74', '75'];
+  '-74': [-74, '-', '-75', '-73', '74'];
+  '-73': [-73, '-', '-74', '-72', '73'];
+  '-72': [-72, '-', '-73', '-71', '72'];
+  '-71': [-71, '-', '-72', '-70', '71'];
+  '-70': [-70, '-', '-71', '-69', '70'];
+  '-69': [-69, '-', '-70', '-68', '69'];
+  '-68': [-68, '-', '-69', '-67', '68'];
+  '-67': [-67, '-', '-68', '-66', '67'];
+  '-66': [-66, '-', '-67', '-65', '66'];
+  '-65': [-65, '-', '-66', '-64', '65'];
+  '-64': [-64, '-', '-65', '-63', '64'];
+  '-63': [-63, '-', '-64', '-62', '63'];
+  '-62': [-62, '-', '-63', '-61', '62'];
+  '-61': [-61, '-', '-62', '-60', '61'];
+  '-60': [-60, '-', '-61', '-59', '60'];
+  '-59': [-59, '-', '-60', '-58', '59'];
+  '-58': [-58, '-', '-59', '-57', '58'];
+  '-57': [-57, '-', '-58', '-56', '57'];
+  '-56': [-56, '-', '-57', '-55', '56'];
+  '-55': [-55, '-', '-56', '-54', '55'];
+  '-54': [-54, '-', '-55', '-53', '54'];
+  '-53': [-53, '-', '-54', '-52', '53'];
+  '-52': [-52, '-', '-53', '-51', '52'];
+  '-51': [-51, '-', '-52', '-50', '51'];
+  '-50': [-50, '-', '-51', '-49', '50'];
+  '-49': [-49, '-', '-50', '-48', '49'];
+  '-48': [-48, '-', '-49', '-47', '48'];
+  '-47': [-47, '-', '-48', '-46', '47'];
+  '-46': [-46, '-', '-47', '-45', '46'];
+  '-45': [-45, '-', '-46', '-44', '45'];
+  '-44': [-44, '-', '-45', '-43', '44'];
+  '-43': [-43, '-', '-44', '-42', '43'];
+  '-42': [-42, '-', '-43', '-41', '42'];
+  '-41': [-41, '-', '-42', '-40', '41'];
+  '-40': [-40, '-', '-41', '-39', '40'];
+  '-39': [-39, '-', '-40', '-38', '39'];
+  '-38': [-38, '-', '-39', '-37', '38'];
+  '-37': [-37, '-', '-38', '-36', '37'];
+  '-36': [-36, '-', '-37', '-35', '36'];
+  '-35': [-35, '-', '-36', '-34', '35'];
+  '-34': [-34, '-', '-35', '-33', '34'];
+  '-33': [-33, '-', '-34', '-32', '33'];
+  '-32': [-32, '-', '-33', '-31', '32'];
+  '-31': [-31, '-', '-32', '-30', '31'];
+  '-30': [-30, '-', '-31', '-29', '30'];
+  '-29': [-29, '-', '-30', '-28', '29'];
+  '-28': [-28, '-', '-29', '-27', '28'];
+  '-27': [-27, '-', '-28', '-26', '27'];
+  '-26': [-26, '-', '-27', '-25', '26'];
+  '-25': [-25, '-', '-26', '-24', '25'];
+  '-24': [-24, '-', '-25', '-23', '24'];
+  '-23': [-23, '-', '-24', '-22', '23'];
+  '-22': [-22, '-', '-23', '-21', '22'];
+  '-21': [-21, '-', '-22', '-20', '21'];
+  '-20': [-20, '-', '-21', '-19', '20'];
+  '-19': [-19, '-', '-20', '-18', '19'];
+  '-18': [-18, '-', '-19', '-17', '18'];
+  '-17': [-17, '-', '-18', '-16', '17'];
+  '-16': [-16, '-', '-17', '-15', '16'];
+  '-15': [-15, '-', '-16', '-14', '15'];
+  '-14': [-14, '-', '-15', '-13', '14'];
+  '-13': [-13, '-', '-14', '-12', '13'];
+  '-12': [-12, '-', '-13', '-11', '12'];
+  '-11': [-11, '-', '-12', '-10', '11'];
+  '-10': [-10, '-', '-11', '-9', '10'];
+  '-9': [-9, '-', '-10', '-8', '9'];
+  '-8': [-8, '-', '-9', '-7', '8'];
+  '-7': [-7, '-', '-8', '-6', '7'];
+  '-6': [-6, '-', '-7', '-5', '6'];
+  '-5': [-5, '-', '-6', '-4', '5'];
+  '-4': [-4, '-', '-5', '-3', '4'];
+  '-3': [-3, '-', '-4', '-2', '3'];
+  '-2': [-2, '-', '-3', '-1', '2'];
+  '-1': [-1, '-', '-2', '0', '1'];
+  '0': [0, '0', '-1', '1', '0'];
+  '1': [1, '+', '0', '2', '-1'];
+  '2': [2, '+', '1', '3', '-2'];
+  '3': [3, '+', '2', '4', '-3'];
+  '4': [4, '+', '3', '5', '-4'];
+  '5': [5, '+', '4', '6', '-5'];
+  '6': [6, '+', '5', '7', '-6'];
+  '7': [7, '+', '6', '8', '-7'];
+  '8': [8, '+', '7', '9', '-8'];
+  '9': [9, '+', '8', '10', '-9'];
+  '10': [10, '+', '9', '11', '-10'];
+  '11': [11, '+', '10', '12', '-11'];
+  '12': [12, '+', '11', '13', '-12'];
+  '13': [13, '+', '12', '14', '-13'];
+  '14': [14, '+', '13', '15', '-14'];
+  '15': [15, '+', '14', '16', '-15'];
+  '16': [16, '+', '15', '17', '-16'];
+  '17': [17, '+', '16', '18', '-17'];
+  '18': [18, '+', '17', '19', '-18'];
+  '19': [19, '+', '18', '20', '-19'];
+  '20': [20, '+', '19', '21', '-20'];
+  '21': [21, '+', '20', '22', '-21'];
+  '22': [22, '+', '21', '23', '-22'];
+  '23': [23, '+', '22', '24', '-23'];
+  '24': [24, '+', '23', '25', '-24'];
+  '25': [25, '+', '24', '26', '-25'];
+  '26': [26, '+', '25', '27', '-26'];
+  '27': [27, '+', '26', '28', '-27'];
+  '28': [28, '+', '27', '29', '-28'];
+  '29': [29, '+', '28', '30', '-29'];
+  '30': [30, '+', '29', '31', '-30'];
+  '31': [31, '+', '30', '32', '-31'];
+  '32': [32, '+', '31', '33', '-32'];
+  '33': [33, '+', '32', '34', '-33'];
+  '34': [34, '+', '33', '35', '-34'];
+  '35': [35, '+', '34', '36', '-35'];
+  '36': [36, '+', '35', '37', '-36'];
+  '37': [37, '+', '36', '38', '-37'];
+  '38': [38, '+', '37', '39', '-38'];
+  '39': [39, '+', '38', '40', '-39'];
+  '40': [40, '+', '39', '41', '-40'];
+  '41': [41, '+', '40', '42', '-41'];
+  '42': [42, '+', '41', '43', '-42'];
+  '43': [43, '+', '42', '44', '-43'];
+  '44': [44, '+', '43', '45', '-44'];
+  '45': [45, '+', '44', '46', '-45'];
+  '46': [46, '+', '45', '47', '-46'];
+  '47': [47, '+', '46', '48', '-47'];
+  '48': [48, '+', '47', '49', '-48'];
+  '49': [49, '+', '48', '50', '-49'];
+  '50': [50, '+', '49', '51', '-50'];
+  '51': [51, '+', '50', '52', '-51'];
+  '52': [52, '+', '51', '53', '-52'];
+  '53': [53, '+', '52', '54', '-53'];
+  '54': [54, '+', '53', '55', '-54'];
+  '55': [55, '+', '54', '56', '-55'];
+  '56': [56, '+', '55', '57', '-56'];
+  '57': [57, '+', '56', '58', '-57'];
+  '58': [58, '+', '57', '59', '-58'];
+  '59': [59, '+', '58', '60', '-59'];
+  '60': [60, '+', '59', '61', '-60'];
+  '61': [61, '+', '60', '62', '-61'];
+  '62': [62, '+', '61', '63', '-62'];
+  '63': [63, '+', '62', '64', '-63'];
+  '64': [64, '+', '63', '65', '-64'];
+  '65': [65, '+', '64', '66', '-65'];
+  '66': [66, '+', '65', '67', '-66'];
+  '67': [67, '+', '66', '68', '-67'];
+  '68': [68, '+', '67', '69', '-68'];
+  '69': [69, '+', '68', '70', '-69'];
+  '70': [70, '+', '69', '71', '-70'];
+  '71': [71, '+', '70', '72', '-71'];
+  '72': [72, '+', '71', '73', '-72'];
+  '73': [73, '+', '72', '74', '-73'];
+  '74': [74, '+', '73', '75', '-74'];
+  '75': [75, '+', '74', '76', '-75'];
+  '76': [76, '+', '75', '77', '-76'];
+  '77': [77, '+', '76', '78', '-77'];
+  '78': [78, '+', '77', '79', '-78'];
+  '79': [79, '+', '78', '80', '-79'];
+  '80': [80, '+', '79', '81', '-80'];
+  '81': [81, '+', '80', '82', '-81'];
+  '82': [82, '+', '81', '83', '-82'];
+  '83': [83, '+', '82', '84', '-83'];
+  '84': [84, '+', '83', '85', '-84'];
+  '85': [85, '+', '84', '86', '-85'];
+  '86': [86, '+', '85', '87', '-86'];
+  '87': [87, '+', '86', '88', '-87'];
+  '88': [88, '+', '87', '89', '-88'];
+  '89': [89, '+', '88', '90', '-89'];
+  '90': [90, '+', '89', '91', '-90'];
+  '91': [91, '+', '90', '92', '-91'];
+  '92': [92, '+', '91', '93', '-92'];
+  '93': [93, '+', '92', '94', '-93'];
+  '94': [94, '+', '93', '95', '-94'];
+  '95': [95, '+', '94', '96', '-95'];
+  '96': [96, '+', '95', '97', '-96'];
+  '97': [97, '+', '96', '98', '-97'];
+  '98': [98, '+', '97', '99', '-98'];
+  '99': [99, '+', '98', '100', '-99'];
+  '100': [100, '+', '99', '__', '-100'];
+};
 //#endregion
-//#region src/utils/object/objectPick.d.ts
-declare function objectPick<O extends AnyObject, K$1 extends keyof O>(obj: O, keys: readonly K$1[]): Pick<O, K$1>;
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Iteration/Prev.d.ts
+/**
+ * Move `I`'s position backwards
+ * @param I to move
+ * @returns [[Iteration]]
+ * @example
+ * ```ts
+ * import {I} from 'ts-toolbelt'
+ *
+ * type i = I.IterationOf<'20'>
+ *
+ * type test0 = I.Pos<i>         // 20
+ * type test1 = I.Pos<I.Prev<i>> // 19
+ * ```
+ */
+declare type Prev<I$1 extends Iteration> = IterationMap[I$1[2]];
 //#endregion
-//#region src/utils/object/objectSwitch.d.ts
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Iteration/IterationOf.d.ts
 /**
- * 对象反转
- * - 返回交换了对象的可枚举属性的值/键对象
+ * Transform a number into an [[Iteration]]
+ * (to use [[Prev]], [[Next]], & [[Pos]])
+ * @param N to transform
+ * @returns [[Iteration]]
+ * @example
+ * ```ts
+ * import {I} from 'ts-toolbelt'
  *
- * @param obj 对象
+ * type i = I.IterationOf<0> // ["-1", "1", "0", 0, "0"]
+ *
+ * type next = I.Next<i>       // ["0", "2", "1", 1, "+"]
+ * type prev = I.Prev<i>       // ["-2", "0", "-1", -1, "-"]
+ *
+ * type nnext = I.Pos<next>    // +1
+ * type nprev = I.Pos<prev>    // -1
+ * ```
  */
-declare function objectSwitch<O extends AnyObject>(obj: NonEmptyObject<O>): Record<O[keyof O], keyof O>;
+declare type IterationOf<N extends number> = `${N}` extends keyof IterationMap ? IterationMap[`${N}`] : IterationMap['__'];
 //#endregion
-//#region src/utils/object/objectValues.d.ts
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Iteration/Pos.d.ts
+/**
+ * Get the position of `I` (**number**)
+ * @param I to query
+ * @returns `number`
+ * @example
+ * ```ts
+ * import {I} from 'ts-toolbelt'
+ *
+ * type i = I.IterationOf<'20'>
+ *
+ * type test0 = I.Pos<i>         // 20
+ * type test1 = I.Pos<I.Next<i>> // 21
+ * ```
+ */
+declare type Pos<I$1 extends Iteration> = I$1[0];
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/Tail.d.ts
+/**
+ * Remove the first item out of a [[List]]
+ * @param L
+ * @returns [[List]]
+ * @example
+ * ```ts
+ * ```
+ */
+declare type Tail$1<L$1 extends List> = L$1 extends readonly [] ? L$1 : L$1 extends readonly [any?, ...infer LTail] ? LTail : L$1;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Union/IntersectOf.d.ts
+/**
+ * Transform a [[Union]] to an * *intersection**
+ * @param U to transform
+ * @returns `&`
+ * @example
+ * ```ts
+ * ```
+ */
+declare type IntersectOf<U$1 extends any> = (U$1 extends unknown ? (k: U$1) => void : never) extends ((k: infer I) => void) ? I : never;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Object/Overwrite.d.ts
+/**
+ * Update the fields of `O` with the ones of `O1`
+ * (only the existing fields will be updated)
+ * @param O to update
+ * @param O1 to update with
+ * @returns [[Object]]
+ * @example
+ * ```ts
+ * ```
+ */
+declare type Overwrite<O extends object, O1 extends object> = { [K in keyof O]: K extends keyof O1 ? O1[K] : O[K] } & {};
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/_Internal.d.ts
+/**
+ * Remove `?` & `readonly` from a [[List]]
+ */
+declare type Naked<L$1 extends List> = Overwrite<Required<L$1>, L$1>;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/Prepend.d.ts
+/**
+ * Add an element `A` at the beginning of `L`
+ * @param L to append to
+ * @param A to be added to
+ * @returns [[List]]
+ * @example
+ * ```ts
+ * ```
+ */
+declare type Prepend<L$1 extends List, A$1 extends any> = [A$1, ...L$1];
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Iteration/_Internal.d.ts
+/**
+ * Describes how to perform iterations
+ */
+declare type Way = '->' | '<-';
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/Append.d.ts
+/**
+ * Add an element `A` at the end of `L`.
+ * @param L to append to
+ * @param A to be added to
+ * @returns [[List]]
+ * @example
+ * ```ts
+ * import {L} from 'ts-toolbelt'
+ *
+ * type test0 = L.Append<[1, 2, 3], 4> // [1, 2, 3, 4]
+ * type test1 = L.Append<[], 'a'> // ['a']
+ * type test2 = L.Append<readonly ['a', 'b'], 'c'> // ['a', 'b', 'c']
+ * type test3 = L.Append<[1, 2], [3, 4]> // [1, 2, [3, 4]]
+ * ```
+ */
+declare type Append<L$1 extends List, A$1 extends any> = [...L$1, A$1];
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Object/Record.d.ts
+/**
+ * Create an object filled with `A` for the fields `K`
+ * @param K to choose fields
+ * @param A (?=`unknown`) to fill fields with
+ * @param modx (?=`['!', 'W']`) to set modifiers
+ * @returns [[Object]]
+ * @example
+ * ```ts
+ * ```
+ */
+declare type Record$1<K$1 extends Key$1, A$1 extends any = unknown, modx extends Modx = ['!', 'W']> = {
+  '!': {
+    'R': { readonly [P in K$1]: A$1 };
+    'W': { [P in K$1]: A$1 };
+  };
+  '?': {
+    'R': { readonly [P in K$1]?: A$1 };
+    'W': { [P in K$1]?: A$1 };
+  };
+}[modx[0]][modx[1]];
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/Object/Invert.d.ts
+/**
+ * @hidden
+ */
+declare type _Invert<O extends Record$1<Key$1, Key$1>> = ComputeRaw<IntersectOf<{ [K in keyof O]: Record$1<O[K], K> }[keyof O]>>;
+/**
+ * Swaps the keys and values of an [[Object]] (if applicable)
+ * @param O
+ * @returns [[Object]]
+ * @example
+ * ```ts
+ * import {O} from 'ts-toolbelt'
+ *
+ * enum E {
+ *  A = 'Av',
+ *  B = 'Bv',
+ *  C = 'Cv',
+ *  D = 'Dv',
+ *  X = 1
+ * }
+ *
+ * type O = {
+ *  A: 'Av'
+ *  B: 'Bv'
+ *  C: 'Cv'
+ *  D: 'Dv'
+ *  X: 1
+ * }
+ *
+ * type test0 = O.Invert<typeof E>
+ * type test1 = O.Invert<O>
+ * ```
+ */
+declare type Invert<O extends Record$1<keyof O, Key$1>> = O extends unknown ? _Invert<O> : never;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/Drop.d.ts
+/**
+ * @hidden
+ */
+declare type DropForth<L$1 extends List, N extends Iteration> = {
+  0: DropForth<Tail$1<L$1>, Prev<N>>;
+  1: L$1;
+}[Extends<0, Pos<N>>];
+/**
+ * @hidden
+ */
+declare type DropBack<L$1 extends List, N extends Iteration, I$1 extends Iteration = Prev<N>, LN extends List = []> = {
+  0: DropBack<L$1, N, Prev<I$1>, Prepend<LN, L$1[Pos<I$1>]>>;
+  1: LN;
+}[Extends<-1, Pos<I$1>>];
+/**
+ * @hidden
+ */
+declare type __Drop<L$1 extends List, N extends Iteration, way extends Way> = {
+  '->': DropForth<L$1, N>;
+  '<-': DropBack<L$1, N>;
+}[way];
+/**
+ * @hidden
+ */
+declare type _Drop<L$1 extends List, N extends number, way extends Way = '->'> = __Drop<Naked<L$1>, IterationOf<N>, way> extends infer X ? Cast<X, List> : never;
+/**
+ * Remove `N` entries out of `L`
+ * @param L to remove from
+ * @param N to remove out
+ * @param way (?=`'->'`) from front: '->', from end: '<-'
+ * @returns [[List]]
+ * @example
+ * ```ts
+ * ```
+ */
+declare type Drop<L$1 extends List, N extends number, way extends Way = '->'> = L$1 extends unknown ? N extends unknown ? _Drop<L$1, N, way> : never : never;
+//#endregion
+//#region node_modules/.pnpm/ts-toolbelt@9.6.0/node_modules/ts-toolbelt/out/List/Take.d.ts
+/**
+ * starts in reverse from `N` till `N` = 0
+ * @hidden
+ */
+declare type TakeForth<L$1 extends List, N extends Iteration, I$1 extends Iteration = Prev<N>, LN extends List = []> = {
+  0: TakeForth<L$1, N, Prev<I$1>, Prepend<LN, L$1[Pos<I$1>]>>;
+  1: LN;
+}[Extends<-1, Pos<I$1>>];
+/**
+ * starts in reverse from the end till `N` = 0
+ * @hidden
+ */
+declare type TakeBack<L$1 extends List, N extends Iteration> = {
+  0: TakeBack<Tail$1<L$1>, Prev<N>>;
+  1: L$1;
+}[Extends<0, Pos<N>>];
+/**
+ * @hidden
+ */
+declare type __Take<L$1 extends List, N extends Iteration, way extends Way> = {
+  '->': TakeForth<L$1, N>;
+  '<-': TakeBack<L$1, N>;
+}[way];
 /**
- * 返回对象的可枚举属性的值数组
+ * @hidden
+ */
+declare type _Take<L$1 extends List, N extends number, way extends Way = '->'> = __Take<L$1, IterationOf<N>, way> extends infer X ? Cast<X, List> : never;
+/**
+ * Extract `N` entries out of `L`
+ * @param L to extract from
+ * @param N to extract out
+ * @param way (?=`'->'`) to extract from end
+ * @returns [[List]]
+ * @example
+ * ```ts
+ * ```
+ */
+declare type Take<L$1 extends List, N extends number, way extends Way = '->'> = L$1 extends unknown ? N extends unknown ? _Take<L$1, N, way> : never : never;
+//#endregion
+//#region src/types/index.type.d.ts
+type AnyArray<A$1 = any> = readonly A$1[];
+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 Groups<L$1 extends AnyArray, LN extends AnyArray = [], D extends number[] = []> = D["length"] extends 40 ? LN : {
+  0: Groups<Drop<L$1, 1>, Append<LN, [`${LN["length"]}`, Take<L$1, 1>]>, [...D, 0]>;
+  1: LN;
+}[Extends<L$1, AnyArray<never>>];
+type TupleToGroups<L$1 extends AnyArray> = Groups<L$1> extends infer X ? Cast<X, AnyArray> : never;
+//#endregion
+//#region src/utils/object/objectEntries.d.ts
+/**
+ * 返回对象的可枚举属性的键/值数组
+ */
+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 O extends PlainObject>(plainObject: O): [string & keyof O, O[keyof O]][];
+declare function objectEntries<const O extends AnyObject>(anyObject: O): [string & keyof O, O[keyof O]][];
+//#endregion
+//#region src/utils/object/objectInvert.d.ts
+/**
+ * 尽可能地交换对象的键和值
  *
  * @param obj 对象
  */
-declare function objectValues<O extends AnyObject>(obj: O): UnionToTuple<ValueOf<O>>;
+declare function objectInvert<const O extends Record<keyof O, PropertyKey>>(plainObject: O): Invert<O>;
+declare function objectInvert<const O extends AnyObject>(anyObject: O): Invert<O>;
+//#endregion
+//#region src/utils/object/objectKeys.d.ts
+/**
+ * 返回对象可枚举属性和方法的名称
+ * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+ */
+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<O extends PlainObject>(plainObject: O): `${Extract<keyof O, string | number>}`[];
+declare function objectKeys<O extends AnyObject>(anyObject: O): `${Extract<keyof O, string | number>}`[];
+//#endregion
+//#region src/utils/object/objectPick.d.ts
+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>;
+//#endregion
+//#region src/utils/object/objectValues.d.ts
+/**
+ * 返回对象可枚举属性的值的数组
+ */
+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<O extends PlainObject>(plainObject: O): UnionToTuple<ValueOf<O>>;
+declare function objectValues<O extends AnyObject>(anyObject: O): UnionToTuple<ValueOf<O>>;
 //#endregion
 //#region src/utils/string/stringInitialCase.d.ts
 /**
@@ -2291,6 +3552,7 @@ declare function isBigInt(value: unknown): value is bigint;
 //#endregion
 //#region src/utils/typeof/isBlob.d.ts
 declare function isBlob(value: unknown): value is Blob;
+declare function isFile(value: unknown): value is File;
 //#endregion
 //#region src/utils/typeof/isBoolean.d.ts
 declare function isBoolean(value: unknown): value is boolean;
@@ -2301,6 +3563,17 @@ declare function isClass(value: unknown): value is Class<AnyObject>;
 //#region src/utils/typeof/isDate.d.ts
 declare function isDate(value: unknown): value is Date;
 //#endregion
+//#region src/utils/typeof/isEnumeration.d.ts
+/**
+ * 判断一个值是否为有效的枚举对象
+ * - 枚举不能为空
+ * - 枚举所有的值必须是 string 或 number
+ *
+ * @param obj
+ * @returns
+ */
+declare function isEnumeration(obj: unknown): [boolean, boolean];
+//#endregion
 //#region src/utils/typeof/isEqual.d.ts
 /**
  * 检查给定的值是否相等
@@ -2318,9 +3591,6 @@ declare function isError(value: unknown): value is Error;
 declare function isFalsy(value: unknown): boolean;
 declare function isFalsyLike(value: unknown): boolean;
 //#endregion
-//#region src/utils/typeof/isFile.d.ts
-declare function isFile(value: unknown): value is File;
-//#endregion
 //#region src/utils/typeof/isFunction.d.ts
 declare function isFunction(value: unknown): value is AnyFunction;
 declare function isAsyncFunction(value: unknown): value is AnyAsyncFunction;
@@ -2448,5 +3718,5 @@ declare function isWebSocket(value: unknown): value is WebSocket;
 //#region src/utils/typeof/isWindow.d.ts
 declare function isWindow(value: unknown): value is Window;
 //#endregion
-export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arraySplit, cloneDeep, enumEntries, enumKeys, enumTypeCheck, enumValues, getTimeZone, isAbortSignal, isArray, isAsyncFunction, isAsyncGeneratorFunction, isBigInt, isBlob, isBoolean, isClass, isDate, isEqual, isError, isFalsy, isFalsyLike, isFile, isFunction, isGeneratorFunction, isInfinity, isInfinityLike, isInteger, isIterable, isMap, isNaN, isNegativeInteger, isNull, isNumber, isObject, isPositiveInteger, isPromise, isPromiseLike, isReadableStream, isRegExp, isSet, isString, isSymbol, isTypedArray, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWindow, mapEntries, objectAssign, objectCrush, objectEntries, objectKeys, objectPick, objectSwitch, objectValues, rowsToTree, stringInitialCase, stringReplace, stringTemplate, stringToJson, stringToNumber, stringToPosix, stringToValues, stringTrim, stringTruncate, to, toMathBignumber, toMathDecimal, toMathEvaluate, treeFilter, treeFind, treeForEach, treeMap, treeToRows };
+export { arrayCast, arrayCompete, arrayCounting, arrayDifference, arrayFirst, arrayFork, arrayIntersection, arrayLast, arrayMerge, arrayPick, arrayReplace, arraySplit, cloneDeep, enumEntries, enumKeys, enumValues, getTimeZone, isAbortSignal, isArray, isAsyncFunction, isAsyncGeneratorFunction, isBigInt, isBlob, isBoolean, isClass, isDate, isEnumeration, isEqual, isError, isFalsy, isFalsyLike, isFile, isFunction, isGeneratorFunction, isISOMobile, 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, isWindow, mapEntries, objectAssign, objectCrush, objectEntries, objectInvert, objectKeys, objectPick, objectValues, rowsToTree, stringInitialCase, stringReplace, stringTemplate, stringToJson, stringToNumber, stringToPosix, stringToValues, stringTrim, stringTruncate, to, toMathBignumber, toMathDecimal, toMathEvaluate, treeFilter, treeFind, treeForEach, treeMap, treeToRows };
 //# sourceMappingURL=index.d.ts.map