type-plus 7.5.0 → 8.0.0-beta.0

package/ts/array/strict_array_type.ts

@@ -0,0 +1,75 @@
+import type { IsNever } from '../never/never_type.js'
+import type { StrictNumberType } from '../number/strict_number_type.js'
+
+/**
+ * 🌪️ *filter*
+ *
+ * Filter `T` to ensure it is an array, excluding tuple.
+ *
+ * @example
+ * ```ts
+ * type R = StrictArrayType<number[]> // number[]
+ *
+ * type R = StrictArrayType<[1]> // never
+ * type R = StrictArrayType<number[] | 1> // never
+ * type R = StrictArrayType<number[] & { a: 1 }> // never
+ * ```
+ */
+export type StrictArrayType<T, Then = T, Else = never> = IsNever<
+	T,
+	Else,
+	[any[]] extends [T]
+	? ([T] extends [readonly any[]]
+		? StrictNumberType<T['length'], Then, Else>
+		: Else)
+	: Else
+>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is an array, excluding tuple.
+ *
+ * @example
+ * ```ts
+ * type R = IsStrictArray<number[]> // true
+ *
+ * type R = IsStrictArray<number> // false
+ * type R = IsStrictArray<[1]> // false
+ * ```
+ */
+export type IsStrictArray<T, Then = true, Else = false> = StrictArrayType<T, Then, Else>
+
+/**
+ * 🌪️ *filter*
+ *
+ * Filter `T` to ensure it is not an array, excluding tuple.
+ *
+ * i.e. *tuple* will pass through this filter.
+ *
+ * @example
+ * ```ts
+ * type R = NotStrictArrayType<number[]> // never
+ *
+ * type R = NotStrictArrayType<number> // number
+ * type R = NotStrictArrayType<[1]> // [1]
+ * ```
+ */
+export type NotStrictArrayType<T, Then = T, Else = never> = StrictArrayType<T, Else, Then>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is not an array, excluding tuple.
+ *
+ * i.e. *tuple* will pass through this filter.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotStrictArray<number[]> // false
+ *
+ * type R = IsNotStrictArray<number> // true
+ * type R = IsNotStrictArray<[1]> // true
+ * ```
+ */
+export type IsNotStrictArray<T, Then = true, Else = false> = StrictArrayType<T, Else, Then>

package/ts/array/union_of_props.ts

@@ -4,7 +4,7 @@ import type { Tail } from '../tuple/tail.js'
 /**
  * Gets the union of properties of the elements in `A`
  */
-export type UnionOfProps<A extends Record<any, any>[], P extends KeyTypes> = A['length'] extends 0
+export type UnionOfProps<A extends readonly Record<any, any>[], P extends KeyTypes> = A['length'] extends 0
 	? never
 	: A['length'] extends 1
 	? A[0][P]
@@ -14,4 +14,4 @@ export type UnionOfProps<A extends Record<any, any>[], P extends KeyTypes> = A['
  * Gets the union of properties in the element of `A`
  * This will be deprecated in 4.0. Please use UnionOfProps instead.
  */
-export type PropUnion<A extends Record<any, any>[], P extends KeyTypes> = UnionOfProps<A, P>
+export type PropUnion<A extends readonly Record<any, any>[], P extends KeyTypes> = UnionOfProps<A, P>

package/ts/array/union_of_values.ts

@@ -1,7 +1,7 @@
 /**
  * Gets the union of value types in `A`
  */
-export type UnionOfValues<A extends Array<any>> = A extends Array<infer E> ? E : never
+export type UnionOfValues<A extends readonly unknown[]> = A extends Readonly<Array<infer E>> ? E : never
 
 // alternative implementation
 // export type UnionOfValues<A extends readonly any[]> = (A)[number]
@@ -11,4 +11,4 @@ export type UnionOfValues<A extends Array<any>> = A extends Array<infer E> ? E :
  * Gets the union of value types in `A`
  * @deprecated Please use `UnionOfValues` instead.
  */
-export type ArrayValue<A extends any[]> = UnionOfValues<A>
+export type ArrayValue<A extends readonly unknown[]> = UnionOfValues<A>

package/ts/equal/equal.ts

@@ -4,6 +4,7 @@ import type { IsObject } from '../object/object_type.js'
 import type { Properties } from '../object/properties.js'
 import type { And, Or } from '../predicates/logical.js'
 import type { IsSymbol } from '../symbol/symbol_type.js'
+import type { IdentityEqual } from './identity_equal.js'
 
 type BothNever<A, B, Both, One, None> = And<
 	IsNever<A>,
@@ -14,14 +15,6 @@ type BothNever<A, B, Both, One, None> = And<
 
 type BothAny<A, B, Both, One, None> = And<IsAny<A>, IsAny<B>, Both, Or<IsAny<A>, IsAny<B>, One, None>>
 
-type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2) extends <_>() => _ extends
-	| (B & _)
-	| _
-	? 1
-	: 2
-	? Then
-	: Else
-
 /**
  * Checks `A` and `B` are equal.
  *
@@ -44,37 +37,37 @@ type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2)
  */
 export type IsEqual<A, B, Then = true, Else = false> = [A, B] extends [B, A]
 	? BothNever<
+		A,
+		B,
+		Then,
+		Else,
+		BothAny<
 			A,
 			B,
 			Then,
 			Else,
-			BothAny<
+			IdentityEqual<
 				A,
 				B,
 				Then,
-				Else,
-				IdentityEqual<
-					A,
-					B,
-					Then,
-					And<
-						IsObject<A>,
-						IsObject<B>,
-						IdentityEqual<
-							Properties<A>,
-							Properties<B>,
-							[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
-								? IsEqual<P1, P2, Then, Else>
-								: Then,
-							Else
-						>,
-						// `A` and `B` are narrowed, need to check again.
-						// This is fixed in TS 5.0.2, but keeping it to support older versions.
-						[A, B] extends [B, A] ? Then : Else
-					>
+				And<
+					IsObject<A>,
+					IsObject<B>,
+					IdentityEqual<
+						Properties<A>,
+						Properties<B>,
+						[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
+						? IsEqual<P1, P2, Then, Else>
+						: Then,
+						Else
+					>,
+					// `A` and `B` are narrowed, need to check again.
+					// This is fixed in TS 5.0.2, but keeping it to support older versions.
+					[A, B] extends [B, A] ? Then : Else
 				>
 			>
-	  >
+		>
+	>
 	: And<IsSymbol<A>, IsSymbol<B>, Then, Else>
 
 /**

package/ts/equal/identity_equal.ts

@@ -0,0 +1,9 @@
+
+/**
+ * This is a common equal check.
+ * It is good for some basic cases, but not for all.
+ */
+export type IdentityEqual<A, B, Then, Else> =
+	(<_>() => _ extends (A & _) | _ ? 1 : 2) extends (<_>() => _ extends | (B & _) | _ ? 1 : 2)
+	? Then
+	: Else

package/ts/index.ts

@@ -11,9 +11,11 @@ export type { Head } from './array/head.js'
 export type { IntersectOfProps, MapToProp } from './array/intersect_of_props.js'
 export type { Last } from './array/last.js'
 export { literalArray } from './array/literal_array.js'
+export type { IsLooseArray, IsNotLooseArray, LooseArrayType, NotLooseArrayType } from './array/loose_array_type.js'
 export type { PadStart } from './array/pad_start.js'
 export { reduceWhile } from './array/reduce_while.js'
 export type { Reverse } from './array/reverse.js'
+export type { IsNotStrictArray, IsStrictArray, NotStrictArrayType, StrictArrayType } from './array/strict_array_type.js'
 export type { PropUnion, UnionOfProps } from './array/union_of_props.js'
 export type { UnionOfValues } from './array/union_of_values.js'
 export { assertType } from './assertion/assert_type.js'
@@ -50,7 +52,9 @@ export * from './functional/index.js'
 export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
 export type { Abs, Add, Decrement, GreaterThan, Increment, Max, Multiply, Subtract } from './math/index.js'
 export * as MathPlus from './math/math_plus.js'
+export * from './mix_types/merge.js'
 export type { AnyOrNeverType, IsAnyOrNever } from './mix_types/any_or_never_type.js'
+export type * from './mix_types/box.js'
 export type { IsNever, IsNotNever, Is_Never, NeverType, NotNeverType, Not_Never } from './never/never_type.js'
 export * from './nodejs/index.js'
 export * from './nominal/index.js'
@@ -79,6 +83,8 @@ export type {
 export type { IsNotPositive, IsPositive, NonPositive, Positive } from './numeric/positive.js'
 export type { Required, RequiredExcept, RequiredPick } from './object/Required.js'
 export * from './object/index.js'
+export type * from './object/is_strict_object.js'
+export * as ObjectPlus from './object/object_plus.js'
 export type { IsNotObject, IsObject, NotObjectType, ObjectType } from './object/object_type.js'
 export * from './predicates/index.js'
 export type { PrimitiveTypes } from './primitive.js'
@@ -116,6 +122,6 @@ export type { UnionKeys } from './union_keys.js'
 export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
 export * from './unpartial.js'
 export * from './utils/index.js'
-export type { MergeOptions as MergeCases } from './utils/options.js'
+export type { TypePlusOptions } from './utils/options.js'
 export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'
 

package/ts/math/numeric_struct.ts

@@ -83,12 +83,12 @@ export namespace NumericStruct {
 	 */
 	export type FromNumeric<N extends number | bigint, Fail = never> = N extends number
 		? number extends N
-			? Fail
-			: ['number', DigitsStruct.FromNumber<N>]
+		? Fail
+		: ['number', DigitsStruct.FromNumber<N>]
 		: N extends bigint
 		? bigint extends N
-			? Fail
-			: ['bigint', DigitsStruct.FromBigint<N>]
+		? Fail
+		: ['bigint', DigitsStruct.FromBigint<N>]
 		: never
 
 	/**
@@ -100,8 +100,8 @@ export namespace NumericStruct {
 		M[DIGITS_STRUCT]
 	> extends infer S extends string
 		? M[TYPE] extends 'bigint'
-			? StringToBigint<S, StringToNumber<S, `The value '${S}' cannot be represented as bigint or number`>>
-			: StringToNumber<S, StringToBigint<S, `The value '${S}' cannot be represented as bigint or number`>>
+		? StringToBigint<S, StringToNumber<S, `The value '${S}' cannot be represented as bigint or number`>>
+		: StringToNumber<S, StringToBigint<S, `The value '${S}' cannot be represented as bigint or number`>>
 		: never
 
 	export type Add<A extends NumericStruct, B extends NumericStruct> = [
@@ -126,8 +126,8 @@ type StringToBigint<S extends string, Fail> = S extends `${infer N extends bigin
 // TODO: move into `NumericHelpers`
 export type StringToNumber<S extends string, Fail> = S extends `${infer N extends number}`
 	? number extends N
-		? Fail
-		: N
+	? Fail
+	: N
 	: Fail
 
 export type DigitsStruct = [Sign: '+' | '-', Digits: number[], Exponent: number]
@@ -144,20 +144,20 @@ export namespace DigitsStruct {
 	 */
 	export type FromNumber<N extends number> = `${N}` extends `-${infer R}`
 		? R extends `${infer W}.${infer F}`
-			? [DigitArray.FromString<W>, DigitArray.FromString<F>] extends [
-					infer WA extends number[],
-					infer FA extends number[]
-			  ]
-				? ['-', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']]
-				: never
-			: ['-', DigitArray.FromString<R>, 0]
+		? [DigitArray.FromString<W>, DigitArray.FromString<F>] extends [
+			infer WA extends number[],
+			infer FA extends number[]
+		]
+		? ['-', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']]
+		: never
+		: ['-', DigitArray.FromString<R>, 0]
 		: `${N}` extends `${infer W}.${infer F}`
 		? [DigitArray.FromString<W>, DigitArray.FromString<F>] extends [
-				infer WA extends number[],
-				infer FA extends number[]
-		  ]
-			? ['+', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']]
-			: never
+			infer WA extends number[],
+			infer FA extends number[]
+		]
+		? ['+', DigitArray.TrimLeadingZeros<[...WA, ...FA]>, FA['length']]
+		: never
 		: ['+', DigitArray.FromString<`${N}`>, 0]
 
 	/**
@@ -176,22 +176,22 @@ export namespace DigitsStruct {
 	 */
 	export type ToString<D extends DigitsStruct> = (
 		PadStart<D[DIGITS], D[EXPONENT], 0> extends infer Padded extends number[]
-			? Padded['length'] extends D[EXPONENT]
-				? DigitArray.ToString<[0, '.', ...DigitArray.TrimTrailingZeros<Padded>]>
-				: SplitFloat<Padded, D[EXPONENT]> extends [infer W extends number[], infer F extends number[]]
-				? F extends []
-					? DigitArray.ToString<W>
-					: DigitArray.ToString<[...W, '.', ...DigitArray.TrimTrailingZeros<F>]>
-				: never
-			: never
+		? Padded['length'] extends D[EXPONENT]
+		? DigitArray.ToString<[0, '.', ...DigitArray.TrimTrailingZeros<Padded>]>
+		: SplitFloat<Padded, D[EXPONENT]> extends [infer W extends number[], infer F extends number[]]
+		? F extends []
+		? DigitArray.ToString<W>
+		: DigitArray.ToString<[...W, '.', ...DigitArray.TrimTrailingZeros<F>]>
+		: never
+		: never
 	) extends infer R
 		? R extends '0'
-			? R
-			: R extends string
-			? D[SIGN] extends '-'
-				? `-${R}`
-				: R
-			: never
+		? R
+		: R extends string
+		? D[SIGN] extends '-'
+		? `-${R}`
+		: R
+		: never
 		: never
 
 	/**
@@ -228,8 +228,8 @@ export namespace DigitsStruct {
 		R extends number[] = []
 	> = I extends []
 		? D[SIGN] extends '-'
-			? ['+', R, D[EXPONENT]]
-			: ['-', R, D[EXPONENT]]
+		? ['+', R, D[EXPONENT]]
+		: ['-', R, D[EXPONENT]]
 		: I extends [infer H extends number, ...infer T extends number[]]
 		? FlipSign<D, T, [...R, Digit.FlipSign<H>]>
 		: never
@@ -245,14 +245,14 @@ export namespace DigitsStruct {
 		infer BB extends DigitsStruct
 	]
 		? [BA[SIGN], BB[SIGN]] extends ['+', '+']
-			? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-			: [BA[SIGN], BB[SIGN]] extends ['+', '-']
-			? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-			: [BA[SIGN], BB[SIGN]] extends ['-', '+']
-			? Normalize<['+', DigitArray.Subtract<BB[DIGITS], BA[DIGITS]>, BB[EXPONENT]]>
-			: [BA[SIGN], BB[SIGN]] extends ['-', '-']
-			? Normalize<['-', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-			: never
+		? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
+		: [BA[SIGN], BB[SIGN]] extends ['+', '-']
+		? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
+		: [BA[SIGN], BB[SIGN]] extends ['-', '+']
+		? Normalize<['+', DigitArray.Subtract<BB[DIGITS], BA[DIGITS]>, BB[EXPONENT]]>
+		: [BA[SIGN], BB[SIGN]] extends ['-', '-']
+		? Normalize<['-', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
+		: never
 		: never
 
 	export type Subtract<A extends DigitsStruct, B extends DigitsStruct> = Balance<A, B> extends [
@@ -260,14 +260,14 @@ export namespace DigitsStruct {
 		infer BB extends DigitsStruct
 	]
 		? [BA[SIGN], BB[SIGN]] extends ['+', '+']
-			? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-			: [BA[SIGN], BB[SIGN]] extends ['+', '-']
-			? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-			: [BA[SIGN], BB[SIGN]] extends ['-', '+']
-			? Normalize<['-', DigitArray.Add<BB[DIGITS], BA[DIGITS]>, BA[EXPONENT]]>
-			: [BA[SIGN], BB[SIGN]] extends ['-', '-']
-			? Normalize<['-', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
-			: never
+		? Normalize<['+', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
+		: [BA[SIGN], BB[SIGN]] extends ['+', '-']
+		? Normalize<['+', DigitArray.Add<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
+		: [BA[SIGN], BB[SIGN]] extends ['-', '+']
+		? Normalize<['-', DigitArray.Add<BB[DIGITS], BA[DIGITS]>, BA[EXPONENT]]>
+		: [BA[SIGN], BB[SIGN]] extends ['-', '-']
+		? Normalize<['-', DigitArray.Subtract<BA[DIGITS], BB[DIGITS]>, BA[EXPONENT]]>
+		: never
 		: never
 
 	export type Multiply<A extends DigitsStruct, B extends DigitsStruct> = NumericAdd<
@@ -275,14 +275,14 @@ export namespace DigitsStruct {
 		B[EXPONENT]
 	> extends infer Exp extends number
 		? [A[SIGN], B[SIGN]] extends ['+', '+']
-			? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
-			: [A[SIGN], B[SIGN]] extends ['+', '-']
-			? Normalize<['-', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
-			: [A[SIGN], B[SIGN]] extends ['-', '+']
-			? Normalize<['-', DigitArray.Multiply<B[DIGITS], A[DIGITS]>, Exp]>
-			: [A[SIGN], B[SIGN]] extends ['-', '-']
-			? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
-			: never
+		? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
+		: [A[SIGN], B[SIGN]] extends ['+', '-']
+		? Normalize<['-', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
+		: [A[SIGN], B[SIGN]] extends ['-', '+']
+		? Normalize<['-', DigitArray.Multiply<B[DIGITS], A[DIGITS]>, Exp]>
+		: [A[SIGN], B[SIGN]] extends ['-', '-']
+		? Normalize<['+', DigitArray.Multiply<A[DIGITS], B[DIGITS]>, Exp]>
+		: never
 		: never
 
 	/**
@@ -293,8 +293,8 @@ export namespace DigitsStruct {
 		B[EXPONENT]
 	> extends [infer Pads extends number[], infer Longer]
 		? Longer extends 'A'
-			? [A, [B[SIGN], DigitArray.TrimLeadingZeros<[...B[DIGITS], ...Pads]>, A[EXPONENT]]]
-			: [[A[SIGN], DigitArray.TrimLeadingZeros<[...A[DIGITS], ...Pads]>, B[EXPONENT]], B]
+		? [A, [B[SIGN], DigitArray.TrimLeadingZeros<[...B[DIGITS], ...Pads]>, A[EXPONENT]]]
+		: [[A[SIGN], DigitArray.TrimLeadingZeros<[...A[DIGITS], ...Pads]>, B[EXPONENT]], B]
 		: never
 
 	type GetBalancePadding<
@@ -306,11 +306,11 @@ export namespace DigitsStruct {
 		? [[], 'A']
 		: R extends []
 		? // have not reach min yet
-		  C['length'] extends A
-			? GetBalancePadding<A, B, [0, ...C], [0]>
-			: C['length'] extends B
-			? GetBalancePadding<A, B, [0, ...C], [0, ...R]>
-			: GetBalancePadding<A, B, [0, ...C], []>
+		C['length'] extends A
+		? GetBalancePadding<A, B, [0, ...C], [0]>
+		: C['length'] extends B
+		? GetBalancePadding<A, B, [0, ...C], [0, ...R]>
+		: GetBalancePadding<A, B, [0, ...C], []>
 		: C['length'] extends A
 		? [R, 'A']
 		: C['length'] extends B
@@ -395,35 +395,35 @@ export namespace DigitArray {
 
 	export type Add<A extends number[], B extends number[], R extends number[] = []> = A extends []
 		? B extends []
-			? R
-			: B extends [...infer BH extends number[], infer BL extends number]
-			? Add<[], BH, [BL, ...R]>
-			: never
+		? R
+		: B extends [...infer BH extends number[], infer BL extends number]
+		? Add<[], BH, [BL, ...R]>
+		: never
 		: B extends []
 		? A extends [...infer AH extends number[], infer AL extends number]
-			? Add<AH, [], [AL, ...R]>
-			: never
+		? Add<AH, [], [AL, ...R]>
+		: never
 		: [A, B] extends [
-				[...infer AH extends number[], infer AL extends number],
-				[...infer BH extends number[], infer BL extends number]
-		  ]
+			[...infer AH extends number[], infer AL extends number],
+			[...infer BH extends number[], infer BL extends number]
+		]
 		? Add<AH, BH, [Digit.Add<AL, BL>, ...R]>
 		: never
 
 	export type Subtract<A extends number[], B extends number[], R extends number[] = []> = A extends []
 		? B extends []
-			? TrimLeadingZeros<R>
-			: B extends [...infer BH extends number[], infer BL extends number]
-			? Subtract<[], BH, [ToNegative<BL>, ...R]>
-			: never
+		? TrimLeadingZeros<R>
+		: B extends [...infer BH extends number[], infer BL extends number]
+		? Subtract<[], BH, [ToNegative<BL>, ...R]>
+		: never
 		: B extends []
 		? A extends [...infer AH extends number[], infer AL extends number]
-			? Subtract<AH, [], [AL, ...R]>
-			: never
+		? Subtract<AH, [], [AL, ...R]>
+		: never
 		: [A, B] extends [
-				[...infer AH extends number[], infer AL extends number],
-				[...infer BH extends number[], infer BL extends number]
-		  ]
+			[...infer AH extends number[], infer AL extends number],
+			[...infer BH extends number[], infer BL extends number]
+		]
 		? Subtract<AH, BH, [Digit.Subtract<AL, BL>, ...R]>
 		: never
 
@@ -465,32 +465,32 @@ export namespace DigitArray {
 		? TrimLeadingZeros<R>
 		: N extends [infer Tail extends number]
 		? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}`
-			? CarryDigits<[], [T1, T2, ...R]>
-			: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
-			? `-${T1}` extends `${infer NT extends number}`
-				? CarryDigits<[], [NT, T2, ...R]>
-				: never
-			: CarryDigits<[], [Tail, ...R]>
+		? CarryDigits<[], [T1, T2, ...R]>
+		: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
+		? `-${T1}` extends `${infer NT extends number}`
+		? CarryDigits<[], [NT, T2, ...R]>
+		: never
+		: CarryDigits<[], [Tail, ...R]>
 		: N extends [infer Head extends number, infer Tail extends number]
 		? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}`
-			? CarryDigits<[Digit.Add<Head, T1>], [T2, ...R]>
-			: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
-			? `-${T1}` extends `${infer NT extends number}`
-				? CarryDigits<[Digit.Add<Head, NT>], [T2, ...R]>
-				: never
-			: `${Tail}` extends `-${number}`
-			? CarryDigits<[Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]>
-			: CarryDigits<[Head], [Tail, ...R]>
+		? CarryDigits<[Digit.Add<Head, T1>], [T2, ...R]>
+		: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
+		? `-${T1}` extends `${infer NT extends number}`
+		? CarryDigits<[Digit.Add<Head, NT>], [T2, ...R]>
+		: never
+		: `${Tail}` extends `-${number}`
+		? CarryDigits<[Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]>
+		: CarryDigits<[Head], [Tail, ...R]>
 		: N extends [...infer Heads extends number[], infer Head extends number, infer Tail extends number]
 		? `${Tail}` extends `${infer T1 extends number}${infer T2 extends number}`
-			? CarryDigits<[...Heads, Digit.Add<Head, T1>], [T2, ...R]>
-			: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
-			? `-${T1}` extends `${infer NT extends number}`
-				? CarryDigits<[...Heads, Digit.Add<Head, NT>], [T2, ...R]>
-				: never
-			: `${Tail}` extends `-${number}`
-			? CarryDigits<[...Heads, Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]>
-			: CarryDigits<[...Heads, Head], [Tail, ...R]>
+		? CarryDigits<[...Heads, Digit.Add<Head, T1>], [T2, ...R]>
+		: `${Tail}` extends `-${infer T1 extends number}${infer T2 extends number}`
+		? `-${T1}` extends `${infer NT extends number}`
+		? CarryDigits<[...Heads, Digit.Add<Head, NT>], [T2, ...R]>
+		: never
+		: `${Tail}` extends `-${number}`
+		? CarryDigits<[...Heads, Digit.Add<Head, -1>], [Digit.Plus10[Tail], ...R]>
+		: CarryDigits<[...Heads, Head], [Tail, ...R]>
 		: never
 }
 
@@ -503,8 +503,8 @@ export namespace Digit {
 	 */
 	export type Add<A extends number, B extends number> = `${A}` extends `-${infer AD extends number}`
 		? `${B}` extends `-${infer BD extends number}`
-			? ToNegative<PositiveEntryAdd<AD, BD>>
-			: Subtract<B, AD>
+		? ToNegative<PositiveEntryAdd<AD, BD>>
+		: Subtract<B, AD>
 		: `${B}` extends `-${infer BD extends number}`
 		? Subtract<A, BD>
 		: PositiveEntryAdd<A, B>

package/ts/mix_types/box.ts

@@ -0,0 +1,62 @@
+import type { IsBigint } from '../bigint/bigint_type.js'
+import type { IsBoolean } from '../boolean/boolean_type.js'
+import type { IsFunction } from '../function/function_type.js'
+import type { IsNumber } from '../number/number_type.js'
+import type { IsStrictObject } from '../object/is_strict_object.js'
+import type { IsString } from '../string/string_type.js'
+import type { IsSymbol } from '../symbol/symbol_type.js'
+
+/**
+ * ⚗️ *transform*
+ * 🔢 *customizable*
+ *
+ * Converts primitive types to their boxed types.
+ *
+ * @typeParam Options['$notBoxable'] return type when `T` is not boxable. Defaults to `never`.
+ *
+ * @example
+ * ```ts
+ * Box<number> // Number
+ * Box<object> // Object
+ * Box<string>  // String
+ * Box<'abc'>  // String
+ *
+ * Box<undefined> // never
+ * ```
+ */
+export type Box<T, Options extends Box.Options = Box.DefaultOptions> =
+	IsFunction<
+		T,
+		Function,
+		IsStrictObject<
+			T,
+			Object,
+			T extends Record<any, any> ? T :
+			IsBoolean<
+				T,
+				Boolean,
+				IsNumber<
+					T,
+					Number,
+					IsString<
+						T,
+						String,
+						IsSymbol<
+							T,
+							Symbol,
+							IsBigint<T, BigInt, Options['$notBoxable']>
+						>
+					>
+				>
+			>
+		>
+	>
+
+export namespace Box {
+	export type Options = {
+		$notBoxable?: unknown
+	}
+	export interface DefaultOptions {
+		$notBoxable: never
+	}
+}