@pawover/kit 0.0.0-beta.40 → 0.0.0-beta.42

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-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 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-C_xUtgFe.js";
+import { t as ValueOf } from "./value-of-DPr10cdW.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 { 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,7 +15,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.
@@ -59,7 +59,7 @@ 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;
 
@@ -106,7 +106,7 @@ 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;
@@ -197,7 +197,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>;
 ```
@@ -282,7 +282,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).
 
@@ -345,7 +345,7 @@ type _IsStringLiteral<S> =
 // 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 +413,162 @@ 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$1, Options extends SomeExtendOptions = {}> = _SomeExtend<CollapseRestElement<TArray>, Type$1, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+type _SomeExtend<TArray extends UnknownArray, Type$1, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type$1>, IsAny<Type$1>>, Not<Options['strictNever']>> extends true
+// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+? true : _SomeExtend<Rest, Type$1, Options> : First extends Type$1 ? true : _SomeExtend<Rest, Type$1, 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 +642,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$1 extends boolean, B$1 extends boolean> = OrAll<[A$1, B$1]>;
 //#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}
 */
@@ -579,11 +732,85 @@ type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 @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$1, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type$1>, IsAny<Type$1>>, Not<Options['strictNever']>> extends true
+// If target `Type` is also `never`, or is `any`, 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.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.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.d.ts
 /**
 Returns a boolean for whether two given types are both true.
 
@@ -657,23 +884,111 @@ 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$1 extends boolean, B$1 extends boolean> = AndAll<[A$1, B$1]>;
 //#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 +1024,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,11 +1043,7 @@ 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
@@ -745,7 +1056,7 @@ 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.
 
@@ -804,7 +1115,7 @@ type SplitHelper<S extends string, Delimiter extends string, Options extends Req
 : 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;
 };
@@ -2631,13 +2942,6 @@ declare function objectValues<O extends PlainObject>(plainObject: O): O[keyof O]
 declare function objectValues<O extends AnyObject>(anyObject: O): O[keyof O][];
 //#endregion
 //#region src/utils/string/stringInitialCase.d.ts
-/**
- * 字符串首字母大小写
- * - 包含非西欧字母字符时，不处理
- * - 纯字母且全大写时，不处理
- * - 纯字母且非全大写时，首字母小写，其余保留
- * - 纯字母且非全大写时，首字母大写，其余保留
- *
 /**
  * 字符串首字母大小写
  * - 包含非西欧字母字符时，不处理
@@ -2657,10 +2961,6 @@ declare function objectValues<O extends AnyObject>(anyObject: O): O[keyof O][];
 declare function stringInitialCase(input: string, caseType?: "lower" | "upper" | undefined): string;
 //#endregion
 //#region src/utils/string/stringReplace.d.ts
-/**
- * 字符串替换
- * - 替换第一个匹配项
- *
 /**
  * 字符串替换
  * - 替换第一个匹配项
@@ -2693,9 +2993,6 @@ declare function stringReplace<I$1 extends string, S extends string, R$1 extends
 declare function stringTemplate(input: string, template: PlainObject, regex?: RegExp): string;
 //#endregion
 //#region src/utils/string/stringToJson.d.ts
-/**
- * 处理 JSON 字符串
- *
 /**
  * 处理 JSON 字符串
  *
@@ -2710,6 +3007,24 @@ declare function stringTemplate(input: string, template: PlainObject, regex?: Re
  */
 declare function stringToJson<D extends AnyObject = AnyObject>(input: string | null | undefined, safeValue: D): D;
 //#endregion
+//#region src/utils/string/stringToLowerCase.d.ts
+/**
+ * 将字符串转换为小写
+ * - 将字符串字面量类型转换为其小写形式
+ * - 当输入无效时，返回空字符串
+ *
+ * @param input 待处理字符串
+ * @returns 转换后的小写字符串类型，如果输入无效则返回空字符串类型 ""
+ * @example
+ * ```ts
+ * stringToLowerCase("HELLO"); // 类型为 "hello"
+ * stringToLowerCase(someUnknownString); // 类型为 string
+ * stringToLowerCase(null); // 类型为 ""
+ * ```
+ */
+declare function stringToLowerCase<const T extends string>(input: T): Lowercase<T>;
+declare function stringToLowerCase(input: unknown): "";
+//#endregion
 //#region src/utils/string/stringToNumber.d.ts
 /**
  * 从字符串中提取数字字符串
@@ -2754,6 +3069,24 @@ declare function stringToNumber(input: string): string;
  */
 declare function stringToPosix(input: string | null | undefined, removeLeadingSlash?: boolean): string;
 //#endregion
+//#region src/utils/string/stringToUpperCase.d.ts
+/**
+ * 将字符串转换为大写
+ * - 将字符串字面量类型转换为其大写形式
+ * - 当输入无效时，返回空字符串
+ *
+ * @param input 待处理字符串
+ * @returns 转换后的大写字符串，如果输入无效则返回空字符串
+ * @example
+ * ```ts
+ * stringToUpperCase("hello"); // 类型为 "HELLO"
+ * stringToUpperCase(someUnknownString); // 类型为 string
+ * stringToUpperCase(null); // 类型为 ""
+ * ```
+ */
+declare function stringToUpperCase<const T extends string>(input: T): Uppercase<T>;
+declare function stringToUpperCase(input: unknown): "";
+//#endregion
 //#region src/utils/string/stringToValues.d.ts
 /**
  * 字符串分割为数组
@@ -3298,7 +3631,7 @@ declare function isWeakSet(value: unknown): value is WeakSet<AnyObject>;
  * 检查 value 是否为 string 类型
  *
  * @param value 待检查值
- * @param checkEmpty 是否排除空字符串
+ * @param checkEmpty 是否检查空字符串
  * @returns 是否为字符串
  * @example
  * ```ts
@@ -3349,5 +3682,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, stringToNumber, stringToPosix, 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, 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 };
 //# sourceMappingURL=index.d.ts.map