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

package/dist/{index-Bn_PNnsM.d.ts → index-CN5K25yO.d.ts}

@@ -1,4 +1,4 @@
-import { t as ValueOf } from "./value-of-DUmTbnuw.js";
+import { t as ValueOf } from "./value-of-DPr10cdW.js";
 
 //#region src/enums/date.d.ts
 declare const DATE_FORMAT: {
@@ -209,4 +209,4 @@ declare const THEME_MODE_ENUM: {
 };
 //#endregion
 export { MIME as a, DATE_FORMAT as c, THEME_TYPE as i, THEME_MODE_ENUM as n, BREAK_POINT_TOKEN_ENUM as o, THEME_MODE_TYPE as r, BREAK_POINT_TOKEN_TYPE as s, THEME_ENUM as t };
-//# sourceMappingURL=index-Bn_PNnsM.d.ts.map
+//# sourceMappingURL=index-CN5K25yO.d.ts.map

package/dist/{index-Bn_PNnsM.d.ts.map → index-CN5K25yO.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-Bn_PNnsM.d.ts","names":[],"sources":["../src/enums/date.ts","../src/enums/grid.ts","../src/enums/mime.ts","../src/enums/theme.ts"],"sourcesContent":[],"mappings":";;;cAAa;;;EAAA,SAAA,aAmDH,EAAA,qBAAA;;;;ECnDE,SAAA,OAAA,EAAA,YAAsB;EAErB,SAAA,YAAA,EAAA,qBA2BH;;;;ECzBG,SA+HH,OAAA,EAAA,aAAA;;;;ECjIE,SAAA,UAAU,EAAA,UAAkB;EAC3B,SAAA,gBAGH,EAAA,UAAA;EAEE,SAAA,SAAe,EAAA,OAAA;EACd,SAAA,YAIH,EAAA,QAAA;;;;;;;;;;;;;;;;KFbE,sBAAA,GAAyB,oBAAoB;;cAE5C;EDFA,SAAA,EAAA,EAAA,GAmDH;;;;ECnDE,SAAA,KAAA,EAAA,GAAA;EAEC,SAAA,KAAA,EAAA,GAAA;;;;ECEA,SA+HH,EAAA,EAAA,GAAA;;;;ECjIE,SAAA,KAAU,EAAA,IAAA;EACT,SAAA,KAGH,EAAA,IAAA;EAEE,SAAA,GAAA,EAAA,IAAe;EACd,SAAA,MAAA,EAAA,IAIH;;;;;;;;;;AHbV;cEIa;;;EDJD;EAEC,SAAA,IAAA,EAAA,WA2BH;;;;ECzBG,SA+HH,GAAA,EAAA,UAAA;;;;ECjIE,SAAA,GAAA,EAAU,UAAkB;EAC3B;EAKD,SAAA,KAAA,EAAA,uBAAiC;EAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAPD,UAAA,GAAa,eAAe;cAC3B;EHHA,SAAA,KAmDH,EAAA,OAAA;;;KG3CE,eAAA,GAAkB,eAAe;AFRjC,cESC,eFTqB,EAAA;EAErB,SAAA,KAAA,EAAA,OAAA"}
+{"version":3,"file":"index-CN5K25yO.d.ts","names":[],"sources":["../src/enums/date.ts","../src/enums/grid.ts","../src/enums/mime.ts","../src/enums/theme.ts"],"sourcesContent":[],"mappings":";;;cAAa;;;EAAA,SAAA,aAmDH,EAAA,qBAAA;;;;ECnDE,SAAA,OAAA,EAAA,YAAsB;EAErB,SAAA,YAAA,EAAA,qBA2BH;;;;ECzBG,SA+HH,OAAA,EAAA,aAAA;;;;ECjIE,SAAA,UAAU,EAAA,UAAkB;EAC3B,SAAA,gBAGH,EAAA,UAAA;EAEE,SAAA,SAAe,EAAA,OAAA;EACd,SAAA,YAIH,EAAA,QAAA;;;;;;;;;;;;;;;;KFbE,sBAAA,GAAyB,oBAAoB;;cAE5C;EDFA,SAAA,EAAA,EAAA,GAmDH;;;;ECnDE,SAAA,KAAA,EAAA,GAAA;EAEC,SAAA,KAAA,EAAA,GAAA;;;;ECEA,SA+HH,EAAA,EAAA,GAAA;;;;ECjIE,SAAA,KAAU,EAAA,IAAA;EACT,SAAA,KAGH,EAAA,IAAA;EAEE,SAAA,GAAA,EAAA,IAAe;EACd,SAAA,MAAA,EAAA,IAIH;;;;;;;;;;AHbV;cEIa;;;EDJD;EAEC,SAAA,IAAA,EAAA,WA2BH;;;;ECzBG,SA+HH,GAAA,EAAA,UAAA;;;;ECjIE,SAAA,GAAA,EAAU,UAAA;EACT;EAKD,SAAA,KAAA,EAAA,uBAAiC;EAChC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAPD,UAAA,GAAa,eAAe;cAC3B;EHHA,SAAA,KAmDH,EAAA,OAAA;;;KG3CE,eAAA,GAAkB,eAAe;AFRjC,cESC,eFTqB,EAAA;EAErB,SAAA,KAAA,EAAA,OAAA"}

package/dist/index-DBPmnr4a.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index-DBPmnr4a.d.ts","names":["Split","TupleToUnion","ALPHABET","Alphabet","ValidChar","ApiNameCheck","N","P","R","L","AdvancedRecordMode","AdvancedRecord","K","A","mode","PropertyKey","AnyObject","T","Record","PlainObject","TreeLike","CK","AnyFunction","R$1","AnyAsyncFunction","Promise","AnyGeneratorFunction","Generator","AnyAsyncGeneratorFunction","AsyncGenerator"],"sources":["../node_modules/.pnpm/@pawover+types@0.0.0-alpha._d6a4faea50420a71bc77e0a59520b8b6/node_modules/@pawover/types/dist/index.d.ts"],"sourcesContent":["import { Split, TupleToUnion } from \"type-fest\";\n\n//#region src/api.d.ts\n/** 字母表 */\ntype ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n/** 单个字母 */\ntype Alphabet = TupleToUnion<Split<ALPHABET, \"\">>;\n/** 有效字符 */\ntype ValidChar = Alphabet | \"_\";\n/** 定义 API 命名 - 键名检查 */\ntype ApiNameCheck<N extends string, P extends string = \"\"> = N extends `${infer L extends ValidChar}${infer R}` ? ApiNameCheck<R, `${P}${L}`> : P extends `${infer S}_` ? S : P;\n//#endregion\n//#region src/advancedRecord.d.ts\ntype AdvancedRecordMode = [\"?\" | \"!\", \"W\" | \"R\"];\ntype AdvancedRecord<K extends PropertyKey, A = unknown, mode extends AdvancedRecordMode = [\"!\", \"W\"]> = {\n  \"!\": {\n    R: { readonly [P in K]: A };\n    W: { [P in K]: A };\n  };\n  \"?\": {\n    R: { readonly [P in K]?: A };\n    W: { [P in K]?: A };\n  };\n}[mode[0]][mode[1]];\n//#endregion\n//#region src/index.d.ts\n/** 任意对象类型 */\ntype AnyObject<K extends PropertyKey = PropertyKey, T = any> = Record<K, T>;\n/** 普通对象类型 */\ntype PlainObject<K extends PropertyKey = PropertyKey, T = unknown> = Record<K, T>;\n/** 描述树类型 */\ntype TreeLike<T extends AnyObject, CK extends string = \"children\"> = T & Record<CK, TreeLike<T, CK>[]>;\n/** 描述函数类型 */\ntype AnyFunction<P extends any[] = any[], R$1 = any> = (...arg: P) => R$1;\n/** 描述异步函数类型 */\ntype AnyAsyncFunction<P extends any[] = any[], R$1 = any> = (...args: P) => Promise<R$1>;\ntype AnyGeneratorFunction<P extends any[] = any[], T = any, R$1 = any, N = any> = (...args: P) => Generator<T, R$1, N>;\ntype AnyAsyncGeneratorFunction<P extends any[] = any[], T = any, R$1 = any, N = any> = (...args: P) => AsyncGenerator<T, R$1, N>;\n//#endregion\nexport { AdvancedRecord, AdvancedRecordMode, AnyAsyncFunction, AnyAsyncGeneratorFunction, AnyFunction, AnyGeneratorFunction, AnyObject, type ApiNameCheck, PlainObject, TreeLike };\n//# sourceMappingURL=index.d.ts.map"],"x_google_ignoreList":[0],"mappings":";;AA+B+E;AAEN;;KANpEgB,SAQ+EO,CAAAA,UAR3DR,WAQ2DQ,GAR7CR,WAQ6CQ,EAAAA,IAAAA,GAAAA,CAAAA,GARrBL,MAQqBK,CARdX,CAQcW,EARXN,CAQWM,CAAAA;;KAN/EJ,WAM8E,CAAA,UANxDJ,WAMwD,GAN1CA,WAM0C,EAAA,IAAA,OAAA,CAAA,GANdG,MAMc,CANPN,CAMO,EANJK,CAMI,CAAA;AAAA;KAJ9EG,QAKuFb,CAAAA,UALpES,SAKoET,EAAAA,WAAAA,MAAAA,GAAAA,UAAAA,CAAAA,GALvBU,CAKuBV,GALnBW,MAKmBX,CALZc,EAKYd,EALRa,QAKQb,CALCU,CAKDV,EALIc,EAKJd,CAAAA,EAAAA,CAAAA;;KAHvFe,WAG0GC,CAAAA,UAAAA,GAAAA,EAAAA,GAAAA,GAAAA,EAAAA,EAAAA,MAAAA,GAAAA,CAAAA,GAAAA,CAAAA,GAAAA,GAAAA,EAH/ChB,CAG+CgB,EAAAA,GAHzCA,GAGyCA;;KAD1GC,gBAC6FG,CAAAA,UAAAA,GAAAA,EAAAA,GAAAA,GAAAA,EAAAA,EAAAA,MAAAA,GAAAA,CAAAA,GAAAA,CAAAA,GAAAA,IAAAA,EAD5BpB,CAC4BoB,EAAAA,GADtBF,OACsBE,CADdJ,GACcI,CAAAA;KAA7FD,oBAAsG,CAAA,UAAA,GAAA,EAAA,GAAA,GAAA,EAAA,EAAA,IAAA,GAAA,EAAA,MAAA,GAAA,EAAA,IAAA,GAAA,CAAA,GAAA,CAAA,GAAA,IAAA,EAAfnB,CAAe,EAAA,GAAToB,SAAS,CAACV,CAAD,EAAIM,GAAJ,EAASjB,CAAT,CAAA;AAAA,KACtGsB,yBAAAA,CAAAA,UAAyBrB,GAAAU,EAAAM,GAAAA,GAAAjB,EAAAA,EAAA,IAAA,GAAA,EAAA,MAAA,GAAA,EAAA,IAAA,GAAA,CAAA,GAAA,CAAA,GAAA,IAAA,EAAmEC,CAAnE,EAAA,GAAyEsB,cAAzE,CAAwFZ,CAAxF,EAA2FM,GAA3F,EAAgGjB,CAAhG,CAAA"}
+{"version":3,"file":"index-DBPmnr4a.d.ts","names":["Split","TupleToUnion","ALPHABET","Alphabet","ValidChar","ApiNameCheck","N","P","R","L","AdvancedRecordMode","AdvancedRecord","K","A","mode","PropertyKey","AnyObject","T","Record","PlainObject","TreeLike","CK","AnyFunction","R$1","AnyAsyncFunction","Promise","AnyGeneratorFunction","Generator","AnyAsyncGeneratorFunction","AsyncGenerator"],"sources":["../node_modules/.pnpm/@pawover+types@0.0.0-alpha._d6a4faea50420a71bc77e0a59520b8b6/node_modules/@pawover/types/dist/index.d.ts"],"sourcesContent":["import { Split, TupleToUnion } from \"type-fest\";\n\n//#region src/api.d.ts\n/** 字母表 */\ntype ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\";\n/** 单个字母 */\ntype Alphabet = TupleToUnion<Split<ALPHABET, \"\">>;\n/** 有效字符 */\ntype ValidChar = Alphabet | \"_\";\n/** 定义 API 命名 - 键名检查 */\ntype ApiNameCheck<N extends string, P extends string = \"\"> = N extends `${infer L extends ValidChar}${infer R}` ? ApiNameCheck<R, `${P}${L}`> : P extends `${infer S}_` ? S : P;\n//#endregion\n//#region src/advancedRecord.d.ts\ntype AdvancedRecordMode = [\"?\" | \"!\", \"W\" | \"R\"];\ntype AdvancedRecord<K extends PropertyKey, A = unknown, mode extends AdvancedRecordMode = [\"!\", \"W\"]> = {\n  \"!\": {\n    R: { readonly [P in K]: A };\n    W: { [P in K]: A };\n  };\n  \"?\": {\n    R: { readonly [P in K]?: A };\n    W: { [P in K]?: A };\n  };\n}[mode[0]][mode[1]];\n//#endregion\n//#region src/index.d.ts\n/** 任意对象类型 */\ntype AnyObject<K extends PropertyKey = PropertyKey, T = any> = Record<K, T>;\n/** 普通对象类型 */\ntype PlainObject<K extends PropertyKey = PropertyKey, T = unknown> = Record<K, T>;\n/** 描述树类型 */\ntype TreeLike<T extends AnyObject, CK extends string = \"children\"> = T & Record<CK, TreeLike<T, CK>[]>;\n/** 描述函数类型 */\ntype AnyFunction<P extends any[] = any[], R$1 = any> = (...arg: P) => R$1;\n/** 描述异步函数类型 */\ntype AnyAsyncFunction<P extends any[] = any[], R$1 = any> = (...args: P) => Promise<R$1>;\ntype AnyGeneratorFunction<P extends any[] = any[], T = any, R$1 = any, N = any> = (...args: P) => Generator<T, R$1, N>;\ntype AnyAsyncGeneratorFunction<P extends any[] = any[], T = any, R$1 = any, N = any> = (...args: P) => AsyncGenerator<T, R$1, N>;\n//#endregion\nexport { AdvancedRecord, AdvancedRecordMode, AnyAsyncFunction, AnyAsyncGeneratorFunction, AnyFunction, AnyGeneratorFunction, AnyObject, type ApiNameCheck, PlainObject, TreeLike };\n//# sourceMappingURL=index.d.ts.map"],"x_google_ignoreList":[0],"mappings":";;AA+B+E;AAEN;;KANpEgB,SAQ+EO,CAAAA,UAR3DR,WAQ2DQ,GAR7CR,WAQ6CQ,EAAAA,IAAAA,GAAAA,CAAAA,GARrBL,MAQqBK,CARdX,CAQcW,EARXN,CAQWM,CAAAA;;KAN/EJ,WAM8E,CAAA,UANxDJ,WAMwD,GAN1CA,WAM0C,EAAA,IAAA,OAAA,CAAA,GANdG,MAMc,CANPN,CAMO,EANJK,CAMI,CAAA;AAAA;KAJ9EG,QAKuFb,CAAAA,UALpES,SAKoET,EAAAA,WAAAA,MAAAA,GAAAA,UAAAA,CAAAA,GALvBU,CAKuBV,GALnBW,MAKmBX,CALZc,EAKYd,EALRa,QAKQb,CALCU,CAKDV,EALIc,EAKJd,CAAAA,EAAAA,CAAAA;;KAHvFe,WAG0GC,CAAAA,UAAAA,GAAAA,EAAAA,GAAAA,GAAAA,EAAAA,EAAAA,MAAAA,GAAAA,CAAAA,GAAAA,CAAAA,GAAAA,GAAAA,EAH/ChB,CAG+CgB,EAAAA,GAHzCA,GAGyCA;;KAD1GC,gBAC6FG,CAAAA,UAAAA,GAAAA,EAAAA,GAAAA,GAAAA,EAAAA,EAAAA,MAAAA,GAAAA,CAAAA,GAAAA,CAAAA,GAAAA,IAAAA,EAD5BpB,CAC4BoB,EAAAA,GADtBF,OACsBE,CADdJ,GACcI,CAAAA;KAA7FD,oBAAsG,CAAA,UAAA,GAAA,EAAA,GAAA,GAAA,EAAA,EAAA,IAAA,GAAA,EAAA,MAAA,GAAA,EAAA,IAAA,GAAA,CAAA,GAAA,CAAA,GAAA,IAAA,EAAfnB,CAAe,EAAA,GAAToB,SAAS,CAACV,CAAD,EAAIM,GAAJ,EAASjB,CAAT,CAAA;AAAA,KACtGsB,yBAAAA,CAAAA,UAAyBX,GAAAM,EAAAA,GAAAjB,GAAAA,EAAAA,EAAA,IAAA,GAAA,EAAA,MAAA,GAAA,EAAA,IAAA,GAAA,CAAA,GAAA,CAAA,GAAA,IAAA,EAAmEC,CAAnE,EAAA,GAAyEsB,cAAzE,CAAwFZ,CAAxF,EAA2FM,GAA3F,EAAgGjB,CAAhG,CAAA"}

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;
 };