type-plus 7.6.0 → 8.0.0-beta.0

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

package/ts/mix_types/merge.ts

@@ -0,0 +1,61 @@
+import type { Box } from './box.js'
+import type { IsNever } from '../never/never_type.js'
+import type { IsNull } from '../null/null_type.js'
+import type { Merge as ObjectMerge } from '../object/merge.js'
+import type { Or } from '../predicates/logical.js'
+import type { IsUndefined } from '../undefined/undefined_type.js'
+import type { IsUnknown } from '../unknown/unknown_type.js'
+import type { IsVoid } from '../void/void_type.js'
+
+/**
+ * ⚗️ *transform*
+ * 🔢 *customizable*
+ *
+ * Merges type `A` and type `B`.
+ *
+ * This type performs the same operations as `{ ...a, ...b }` but at the type level.
+ *
+ * This is a more general type then `ObjectPlus.Merge<A, B>`,
+ * which constraints `A` and `B` to be `Record`.
+ *
+ * This type does not have such restrictions, and tries to handle the other types accordingly.
+ */
+export type Merge<A, B> =
+	Or<
+		IsNever<A>,
+		IsNever<B>,
+		never,
+		Or<
+			IsVoid<A>,
+			IsVoid<B>,
+			A & B,
+			Or<
+				IsUnknown<A>,
+				Or<IsUndefined<A>, IsNull<A>>,
+				B,
+				Or<
+					IsUnknown<B>,
+					Or<IsUndefined<B>, IsNull<B>>,
+					A,
+					ObjectMerge<
+						Box<A, { $notBoxable: {} }>,
+						Box<B, { $notBoxable: {} }>
+					>
+				>
+			>
+		>
+	>
+
+/**
+* Left join `a` with `b`.
+*
+* This returns the proper type of `{ ...a, ...b }`
+*
+* @example
+* ```ts
+* merge({ a: 1 }, {} as { a?: string | undefined }) // { a: number | string }
+* ```
+*/
+export function merge<A, B>(a: A, b: B): Merge<A, B> {
+	return { ...a, ...b } as any
+}

package/ts/mix_types/readme.md

@@ -38,3 +38,37 @@ type R = IsAnyOrNever<never> // true
 
 type R = IsAnyOrNever<unknown> // false
 ```
+
+## [Box](./box.ts)
+
+`Box<T, Options = { $notBoxable }>`
+
+⚗️ *transform*
+🔢 *customizable*
+
+Converts primitive types to their boxed types.
+
+`$notBoxable`: return type when `T` is not boxable. Defaults to `never`.
+
+```ts
+Box<number> // Number
+Box<object> // Object
+Box<string>  // String
+Box<'abc'>  // String
+
+Box<undefined> // never
+```
+
+## [Merge](./merge.ts)
+
+⚗️ *transform*
+🔢 *customizable*
+
+Merges type `A` and type `B`.
+
+This type performs the same operations as `{ ...a, ...b }` but at the type level.
+
+This is a more general type then `ObjectPlus.Merge<A, B>`,
+which constraints `A` and `B` to be `Record`.
+
+This type does not have such restrictions, and tries to handle the other types accordingly.

package/ts/never/never_type.ts

@@ -61,10 +61,10 @@ export namespace NeverType {
 	 * Type options when input type is `never`.
 	 */
 	export interface Options {
-		caseNever?: unknown
+		$never?: unknown
 	}
 
 	export interface DefaultOptions {
-		caseNever: never
+		$never: never
 	}
 }

package/ts/object/ANotB.ts

@@ -1,5 +1,5 @@
 import type { IsEqual } from '../equal/equal.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeysWithDiffType } from './KeysWithDiffType.js'
 

package/ts/object/IsDisjoint.ts

@@ -1,5 +1,5 @@
 import type { And, Not } from '../predicates/index.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { HasKey } from './hasKey.js'
 
 /**

package/ts/object/KeysWithDiffType.ts

@@ -1,9 +1,9 @@
 import type { ValueOf } from './ValueOf.js'
 import type { IsDisjoint } from './IsDisjoint.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 export type KeysWithDiffType<A extends AnyRecord, B extends AnyRecord> = IsDisjoint<A, B> extends true
 	? never
 	: ValueOf<{
-			[k in keyof A & keyof B]: A[k] extends B[k] ? never : k
-	  }>
+		[k in keyof A & keyof B]: A[k] extends B[k] ? never : k
+	}>

package/ts/object/KnownKeys.ts

@@ -8,10 +8,10 @@ import type { PrimitiveTypes } from '../primitive.js'
 export type KnownKeys<T> = T extends PrimitiveTypes
 	? never
 	: {
-			[K in keyof T]: string extends K ? never : number extends K ? never : K
-	  } extends { [_ in keyof T]: infer U }
+		[K in keyof T]: string extends K ? never : number extends K ? never : K
+	} extends { [_ in keyof T]: infer U }
 	? // eslint-disable-next-line @typescript-eslint/ban-types
-	  {} extends U
-		? never
-		: U
+	{} extends U
+	? never
+	: U
 	: never

package/ts/object/RecursiveIntersect.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 /**
  * Intersect type recursively.
@@ -16,10 +16,10 @@ export type RecursiveIntersect<T, U> = T &
 		? Array<Y & U> & U
 		: T extends AnyRecord
 		? {
-				[P in keyof T]: T[P] extends Array<infer R>
-					? Array<RecursiveIntersect<R, U>> & U
-					: T[P] extends AnyRecord
-					? RecursiveIntersect<T[P], U>
-					: T[P] & U
-		  } & U
+			[P in keyof T]: T[P] extends Array<infer R>
+			? Array<RecursiveIntersect<R, U>> & U
+			: (T[P] extends AnyRecord
+				? RecursiveIntersect<T[P], U>
+				: T[P] & U)
+		} & U
 		: U)

package/ts/object/RecursiveRequired.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 export type RecursiveRequired<T> = {
 	[P in keyof T]-?: T[P] extends (infer U)[]

package/ts/object/facade.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 /**
  * creates a facade of the subject.

package/ts/object/hasKey.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 
 export type HasKey<T, K, Then = true, Else = false> = K extends keyof T ? Then : Else
 

package/ts/object/index.ts

@@ -1,5 +1,5 @@
 export type { ANotB, BNotA } from './ANotB.js'
-export type { AnyRecord } from './AnyRecord.js'
+export type { AnyRecord } from './any_record.js'
 export type { ExcludePropType } from './ExcludePropType.js'
 export type { IsDisjoint } from './IsDisjoint.js'
 export type { IsRecord } from './IsRecord.js'

package/ts/object/is_strict_object.ts

@@ -0,0 +1,14 @@
+import type { IdentityEqual } from '../equal/identity_equal.js'
+import type { IsNever } from '../never/never_type.js'
+import type { IsObject } from './object_type.js'
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is strictly the `object` type.
+ */
+export type IsStrictObject<T, Then = true, Else = false> = IsObject<
+	T,
+	IdentityEqual<T, {}, Else, IsNever<keyof T, Then, Else>>,
+	Else
+>

package/ts/object/left_join.ts

@@ -1,5 +1,5 @@
 import type { IsEqual } from '../equal/equal.js'
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeysWithDiffType } from './KeysWithDiffType.js'
 import type { Properties } from './properties.js'

package/ts/object/mapProperties.ts

@@ -1,4 +1,4 @@
-import type { AnyRecord } from './AnyRecord.js'
+import type { AnyRecord } from './any_record.js'
 import { reduceByKey } from './reduceKey.js'
 import type { ValueOf } from './ValueOf.js'