type-plus 5.6.0 → 6.0.0

package/ts/math/GreaterThan.ts

@@ -1,37 +1,54 @@
-import type { Head, PadLeft, Tail } from '../array/index.js'
+import type { Head, PadLeft, Tail } from '../array_plus/index.js'
 import type { And, Equal, Or, Xor } from '../predicates/index.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { IsPositive } from './IsPositive.js'
 import type { IsWhole } from './IsWhole.js'
 import type { Max } from './Max.js'
 
-export type GreaterThan<A extends number, B extends number, Fail = never> =
-  And<IsWhole<A>, IsWhole<B>> extends false ? Fail :
-  number extends A ? Fail :
-  number extends B ? Fail :
-  Equal<A, B> extends true ? false :
-  Xor<IsPositive<A>, IsPositive<B>> extends true ? IsPositive<A> :
-  Or<IsPositive<A>, IsPositive<B>> extends false ? GreaterThan.ForWholeNumber<B, A> :
-  GreaterThan.ForWholeNumber<A, B>
+export type GreaterThan<A extends number, B extends number, Fail = never> = And<
+	IsWhole<A>,
+	IsWhole<B>
+> extends false
+	? Fail
+	: number extends A
+	? Fail
+	: number extends B
+	? Fail
+	: Equal<A, B> extends true
+	? false
+	: Xor<IsPositive<A>, IsPositive<B>> extends true
+	? IsPositive<A>
+	: Or<IsPositive<A>, IsPositive<B>> extends false
+	? GreaterThan.ForWholeNumber<B, A>
+	: GreaterThan.ForWholeNumber<A, B>
 
 export namespace GreaterThan {
-  export type ForWholeNumber<A extends number, B extends number> = (
-    DigitArray.FromNumberAbs<A> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumberAbs<B> extends infer DB ? DB extends number[] ?
-    Max<DA['length'], DB['length']> extends infer M ? M extends number ?
-    PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
-    PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-    ForDigitArray<PDA, PDB>
-    : never : never
-    : never : never
-    : never : never
-    : never : never
-    : never : never
-  )
+	export type ForWholeNumber<
+		A extends number,
+		B extends number
+	> = DigitArray.FromNumberAbs<A> extends infer DA
+		? DA extends number[]
+			? DigitArray.FromNumberAbs<B> extends infer DB
+				? DB extends number[]
+					? Max<DA['length'], DB['length']> extends infer M
+						? M extends number
+							? PadLeft<DA, M, 0> extends infer PDA
+								? PDA extends number[]
+									? PadLeft<DB, M, 0> extends infer PDB
+										? PDB extends number[]
+											? ForDigitArray<PDA, PDB>
+											: never
+										: never
+									: never
+								: never
+							: never
+						: never
+					: never
+				: never
+			: never
+		: never
 
-  export type ForDigitArray<DA extends number[], DB extends number[]> = (
-    Equal<Head<DA>, Head<DB>> extends true
-    ? ForDigitArray<Tail<DA>, Tail<DB>>
-    : Digit.GreaterThan<Head<DA>, Head<DB>>
-  )
+	export type ForDigitArray<DA extends number[], DB extends number[]> = Equal<Head<DA>, Head<DB>> extends true
+		? ForDigitArray<Tail<DA>, Tail<DB>>
+		: Digit.GreaterThan<Head<DA>, Head<DB>>
 }

package/ts/math/IsPositive.ts

@@ -1,9 +1,10 @@
-/**
- * Check if type of positive number literal
- * `number` type is false as it can be negative.
- * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
- */
-export type IsPositive<N extends number, Then = true, Else = false> =
-  number extends N
-  ? Else
-  : `${N}` extends `-${number}` ? Else : Then
+/**
+ * Check if type of positive number literal
+ * `number` type is false as it can be negative.
+ * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+ */
+export type IsPositive<N extends number, Then = true, Else = false> = number extends N
+	? Else
+	: `${N}` extends `-${number}`
+	? Else
+	: Then

package/ts/math/IsWhole.ts

@@ -1,9 +1,10 @@
-/**
- * Check if type is whole number literal.
- * `number` type is false as it can be fractional.
- * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
- */
-export type IsWhole<N extends number, Then = true, Else = false> =
-  number extends N
-  ? Else
-  : `${N}` extends `${number}.${number}` ? Else : Then
+/**
+ * Check if type is whole number literal.
+ * `number` type is false as it can be fractional.
+ * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+ */
+export type IsWhole<N extends number, Then = true, Else = false> = number extends N
+	? Else
+	: `${N}` extends `${number}.${number}`
+	? Else
+	: Then

package/ts/math/Max.ts

@@ -1,8 +1,10 @@
 import type { Equal } from '../predicates/index.js'
 import { GreaterThan } from './GreaterThan.js'
 
-export type Max<A extends number, B extends number, Fail = never> =
-  GreaterThan<A, B> extends infer Result ?
-  Equal<Result, never> extends true ? Fail :
-  Result extends true ? A : B
-  : never
+export type Max<A extends number, B extends number, Fail = never> = GreaterThan<A, B> extends infer Result
+	? Equal<Result, never> extends true
+		? Fail
+		: Result extends true
+		? A
+		: B
+	: never

package/ts/math/Subtract.ts

@@ -1,4 +1,4 @@
-import type { PadLeft, Some, Tail } from '../array/index.js'
+import type { PadLeft, Some, Tail } from '../array_plus/index.js'
 import type { And } from '../predicates/index.js'
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 import type { Digit, DigitArray } from './Digit.js'
@@ -6,35 +6,50 @@ import type { IsPositive } from './IsPositive.js'
 import type { IsWhole } from './IsWhole.js'
 import type { Max } from './Max.js'
 
-export type Subtract<A extends number, B extends number, Fail = never> =
-  And<
-    And<IsPositive<A>, IsWhole<A>>,
-    And<IsPositive<B>, IsWhole<B>>
-  > extends true
-  ? (DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
-    Max<DA['length'], DB['length']> extends infer M ? M extends number ?
-    PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
-    PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-    Subtract.DigitArray<[], PDA, PDB> extends infer Result ? Result extends number[] ?
-    Some<Result, never, 'strict'> extends true ? Fail :
-    DigitArray.ToNumber<Result>
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail)
-  : Fail
+export type Subtract<A extends number, B extends number, Fail = never> = And<
+	And<IsPositive<A>, IsWhole<A>>,
+	And<IsPositive<B>, IsWhole<B>>
+> extends true
+	? DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA
+		? DA extends number[]
+			? DigitArray.FromNumber<B> extends infer DB
+				? DB extends number[]
+					? Max<DA['length'], DB['length']> extends infer M
+						? M extends number
+							? PadLeft<DA, M, 0> extends infer PDA
+								? PDA extends number[]
+									? PadLeft<DB, M, 0> extends infer PDB
+										? PDB extends number[]
+											? Subtract.DigitArray<[], PDA, PDB> extends infer Result
+												? Result extends number[]
+													? Some<Result, never, 'strict'> extends true
+														? Fail
+														: DigitArray.ToNumber<Result>
+													: Fail
+												: Fail
+											: Fail
+										: Fail
+									: Fail
+								: Fail
+							: Fail
+						: Fail
+					: Fail
+				: Fail
+			: Fail
+		: Fail
+	: Fail
 
 export namespace Subtract {
-  export type DigitArray<R extends number[], A extends number[], B extends number[]> =
-    A['length'] extends 0 ? R :
-    DigitArray<[...R, Digit<A[0], B[0]>], Tail<A>, Tail<B>>
+	export type DigitArray<R extends number[], A extends number[], B extends number[]> = A['length'] extends 0
+		? R
+		: DigitArray<[...R, Digit<A[0], B[0]>], Tail<A>, Tail<B>>
 
-
-  export type Digit<A extends number, B extends number> =
-    Digit.ToTuple[A] extends [...(infer U), ...Digit.ToTuple[B]] ? U['length'] : never
+	export type Digit<A extends number, B extends number> = Digit.ToTuple[A] extends [
+		...infer U,
+		...Digit.ToTuple[B]
+	]
+		? U['length']
+		: never
 }
 
 /**

package/ts/nodejs/isNodeError.ts

@@ -1,18 +1,18 @@
 export type SystemErrors = {
-  'EACCES': Error & { code: 'EACCES' },
-  'EADDRINUSE': Error & { code: 'EADDRINUSE' },
-  'ECONNREFUSED': Error,
-  'ECONNRESET': Error,
-  'EEXIST': Error,
-  'EISDIR': Error,
-  'EMFILE': Error,
-  'ENOENT': Error & { code: 'ENOENT', path: string },
-  'ENOTDIR': Error,
-  'ENOTEMPTY': Error,
-  'ENOTFOUND': Error,
-  'EPERM': Error,
-  'EPIPE': Error,
-  'ETIMEDOUT': Error,
+	EACCES: Error & { code: 'EACCES' }
+	EADDRINUSE: Error & { code: 'EADDRINUSE' }
+	ECONNREFUSED: Error
+	ECONNRESET: Error
+	EEXIST: Error
+	EISDIR: Error
+	EMFILE: Error
+	ENOENT: Error & { code: 'ENOENT'; path: string }
+	ENOTDIR: Error
+	ENOTEMPTY: Error
+	ENOTFOUND: Error
+	EPERM: Error
+	EPIPE: Error
+	ETIMEDOUT: Error
 }
 
 export type SystemErrorCodes = keyof SystemErrors
@@ -23,5 +23,5 @@ export type SystemErrorCodes = keyof SystemErrors
  * Feel free to contribute.
  */
 export function isSystemError<C extends SystemErrorCodes>(code: C, err: unknown): err is SystemErrors[C] {
-  return !!err && (err as any).code === code
+	return !!err && (err as any).code === code
 }

package/ts/nominal-types/Brand.ts

@@ -8,10 +8,9 @@ import { typeSym, valueSym } from './types.js'
  * Create a "branded" version of a type.
  * TypeScript won't allow implicit conversion to this type
  */
-export type Brand<B extends string, T> =
-  T extends object
-  ? T & { [typeSym]: B }
-  : { [typeSym]: B, [valueSym]: T }
+export type Brand<B extends string, T> = T extends object
+	? T & { [typeSym]: B }
+	: { [typeSym]: B; [valueSym]: T }
 
 /**
  * Creates a brand creator with the specified type.
@@ -22,11 +21,14 @@ export function brand<B extends string>(type: B): <T>(subject: T) => Brand<B, Wi
  */
 export function brand<B extends string, T>(type: B, subject: T): Brand<B, Widen<T>>
 export function brand(type: string, subject?: unknown) {
-  if (subject === undefined) return function <T>(subject: T) { return brand(type, subject) }
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return brand(type, subject)
+		}
 
-  if (typeof subject === 'object' && subject !== null) {
-    // if subject is not an object, the branding will exist only in type-level.
-    (subject as { [typeSym]: string })[typeSym] = type
-  }
-  return subject
+	if (typeof subject === 'object' && subject !== null) {
+		// if subject is not an object, the branding will exist only in type-level.
+		;(subject as { [typeSym]: string })[typeSym] = type
+	}
+	return subject
 }

package/ts/nominal-types/Flavor.ts

@@ -11,7 +11,7 @@ import { typeSym } from './types.js'
  * This is a less restrictive form of branding.
  */
 export type Flavor<F extends string, T> = T & {
-  [typeSym]?: F
+	[typeSym]?: F
 }
 
 /**
@@ -23,10 +23,13 @@ export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F,
  */
 export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
 export function flavor(type: string, subject?: unknown) {
-  if (subject === undefined) return function <T>(subject: T) { return flavor(type, subject) }
-  if (typeof subject === 'object' && subject !== null) {
-    // if subject is not an object, the branding will exist only in type-level.
-    (subject as { [typeSym]: string })[typeSym] = type
-  }
-  return subject
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return flavor(type, subject)
+		}
+	if (typeof subject === 'object' && subject !== null) {
+		// if subject is not an object, the branding will exist only in type-level.
+		;(subject as { [typeSym]: string })[typeSym] = type
+	}
+	return subject
 }

package/ts/nominal-types/nominalMatch.ts

@@ -2,12 +2,21 @@ import type { Brand } from './Brand.js'
 import type { Flavor } from './Flavor.js'
 import { typeSym } from './types.js'
 
-export function nominalMatch<A extends string, B extends A>(a: Brand<A, unknown>, b: Brand<B, unknown>): boolean
-export function nominalMatch<A extends string, B extends A>(a: Flavor<A, unknown>, b: Flavor<B, unknown>): boolean
-export function nominalMatch<A extends string, B extends A>(a: Brand<A, unknown> | Flavor<A, unknown>, b: Brand<B, unknown> | Flavor<B, unknown>) {
-  if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null)
-    return a[typeSym] === b[typeSym]
-  else {
-    return true
-  }
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown>,
+	b: Brand<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Flavor<A, unknown>,
+	b: Flavor<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown> | Flavor<A, unknown>,
+	b: Brand<B, unknown> | Flavor<B, unknown>
+) {
+	if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null)
+		return a[typeSym] === b[typeSym]
+	else {
+		return true
+	}
 }

package/ts/number_plus/_plus.ts

@@ -0,0 +1 @@
+export type * from './number.js'

package/ts/number_plus/index.ts

@@ -0,0 +1 @@
+export type * from './number.js'

package/ts/number_plus/number.ts

@@ -0,0 +1,58 @@
+/**
+ * Either number or bigint.
+ */
+export type Numeric = number | bigint
+
+/**
+ * The value 0 in number or bigint.
+ */
+export type Zero = 0 | 0n
+
+/**
+ * Check if the value is an integer.
+ *
+ * ```
+ * import type { Integer } from 'type-plus'
+ *
+ * type R = Integer<0> // 0
+ * type R = Integer<1.1> // never
+ *
+ * type R = Integer<0, true, false> // true
+ * type R = Integer<1.1, true, false> // false
+ * ```
+ */
+export type Integer<N extends Numeric, Then = N, Else = never> = `${N}` extends `${bigint}` ? Then : Else
+
+/**
+ * Check if the value is a negative number.
+ *
+ * ```
+ * import type { Negative } from 'type-plus'
+ *
+ * type R = Negative<-1> // -1
+ * type R = Negative<0> // never
+ *
+ * type R = Negative<-1, true, false> // true
+ * type R = Negative<1, true, false> // false
+ * ```
+ */
+export type Negative<N extends Numeric, Then = N, Else = never> = N extends Zero
+	? Else
+	: `${N}` extends `-${string}`
+	? Then
+	: Else
+
+/**
+ * Check if the value it not a negative number.
+ *
+ * ```
+ * import type { NonNegative } from 'type-plus'
+ *
+ * type R = NonNegative<-1> // never
+ * type R = NonNegative<0> // 0
+ *
+ * type R = NonNegative<-1, true, false> // false
+ * type R = NonNegative<1, true, false> // true
+ * ```
+ */
+export type NonNegative<N extends Numeric, Then = N, Else = never> = Negative<N, Else, Then>

package/ts/object/ANotB.ts

@@ -3,19 +3,16 @@ import type { AnyRecord } from './AnyRecord.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeysWithDiffType } from './KeysWithDiffType.js'
 
-export type ANotB<A extends AnyRecord, B extends AnyRecord> =
-  Equal<A, B> extends true
-  ? never
-  : (IsDisjoint<A, B> extends true
-    ? A
-    : { [k in Exclude<keyof A, keyof B> | KeysWithDiffType<A, B>]: A[k] })
+export type ANotB<A extends AnyRecord, B extends AnyRecord> = Equal<A, B> extends true
+	? never
+	: IsDisjoint<A, B> extends true
+	? A
+	: { [k in Exclude<keyof A, keyof B> | KeysWithDiffType<A, B>]: A[k] }
 
 export type BNotA<A extends AnyRecord, B extends AnyRecord> = ANotB<B, A>
 
-export type LeftJoin<A extends AnyRecord, B extends AnyRecord> =
-  Equal<A, B> extends true
-  ? A
-  : (IsDisjoint<A, B> extends true
-    ? A & B
-    : { [k in Exclude<keyof A, keyof B>]: A[k] } & { [k in keyof B]: B[k] }
-  )
+export type LeftJoin<A extends AnyRecord, B extends AnyRecord> = Equal<A, B> extends true
+	? A
+	: IsDisjoint<A, B> extends true
+	? A & B
+	: { [k in Exclude<keyof A, keyof B>]: A[k] } & { [k in keyof B]: B[k] }

package/ts/object/ExcludePropType.ts

@@ -2,5 +2,5 @@
  * Exclude type U from properties in T.
  */
 export type ExcludePropType<T extends Record<keyof any, any>, U> = {
-  [k in keyof T]: Exclude<T[k], U>
+	[k in keyof T]: Exclude<T[k], U>
 }

package/ts/object/IsDisjoint.ts

@@ -6,7 +6,7 @@ import { HasKey } from './hasKey.js'
  * Are the two records disjoint from each other.
  * Disjoint means no common property.
  */
-export type IsDisjoint<
-  A extends AnyRecord,
-  B extends AnyRecord
-  > = And<Not<HasKey<A, keyof B>>, Not<HasKey<B, keyof A>>>
+export type IsDisjoint<A extends AnyRecord, B extends AnyRecord> = And<
+	Not<HasKey<A, keyof B>>,
+	Not<HasKey<B, keyof A>>
+>

package/ts/object/IsRecord.ts

@@ -1,4 +1 @@
-export type IsRecord<T> = T extends any[]
-? false
-: T extends Record<any, any>
-? true : false
+export type IsRecord<T> = T extends any[] ? false : T extends Record<any, any> ? true : false

package/ts/object/KeysWithDiffType.ts

@@ -2,8 +2,8 @@ import { ValueOf } from './ValueOf.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { AnyRecord } from './AnyRecord.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
-  }>
+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
+	  }>

package/ts/object/KnownKeys.ts

@@ -1,16 +1,17 @@
-// Original by Klaus Meinhardt @ajafff
-// known from Gerrit Birkeland @Gerrit0
-// https://github.com/Microsoft/TypeScript/issues/25987#issuecomment-408339599
-
-import { PrimitiveTypes } from '../PrimitiveTypes.js'
-
-// https://github.com/microsoft/TypeScript/issues/25987#issuecomment-441224690
-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 }
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  ? ({} extends U ? never : U)
-  : never
+// Original by Klaus Meinhardt @ajafff
+// known from Gerrit Birkeland @Gerrit0
+// https://github.com/Microsoft/TypeScript/issues/25987#issuecomment-408339599
+
+import { PrimitiveTypes } from '../PrimitiveTypes.js'
+
+// https://github.com/microsoft/TypeScript/issues/25987#issuecomment-441224690
+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 }
+	? // eslint-disable-next-line @typescript-eslint/ban-types
+	  {} extends U
+		? never
+		: U
+	: never

package/ts/object/OptionalKeys.ts

@@ -1,13 +1,9 @@
 import { KeyTypes } from './KeyTypes.js'
 
-export type OptionalKeys<O extends Record<KeyTypes, any>> = O extends unknown
-? OptionalKeys._<O>
-: never
+export type OptionalKeys<O extends Record<KeyTypes, any>> = O extends unknown ? OptionalKeys._<O> : never
 
 export namespace OptionalKeys {
-export type _<O extends Record<KeyTypes, any>> = {
-  [K in keyof O]-?: Record<KeyTypes, any> extends Pick<O, K>
-  ? K
-  : never
-}[keyof O]
+	export type _<O extends Record<KeyTypes, any>> = {
+		[K in keyof O]-?: Record<KeyTypes, any> extends Pick<O, K> ? K : never
+	}[keyof O]
 }

package/ts/object/RecursiveIntersect.ts

@@ -11,12 +11,15 @@ import type { AnyRecord } from './AnyRecord.js'
  * `undefined` is not an accepted value.
  * The resulting type would be `never`
  */
-export type RecursiveIntersect<T, U> = (T & (
-  T extends Array<infer Y> ? 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 : U)
-)
+export type RecursiveIntersect<T, U> = T &
+	(T extends Array<infer Y>
+		? 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
+		: U)

package/ts/object/RecursivePartial.ts

@@ -2,8 +2,9 @@ import type { AnyRecord } from './AnyRecord.js'
 
 // Source: https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript-2-1
 export type RecursivePartial<T> = {
-  [P in keyof T]?:
-  T[P] extends (infer U)[] ? RecursivePartial<U>[] :
-  T[P] extends AnyRecord ? RecursivePartial<T[P]> :
-  T[P];
+	[P in keyof T]?: T[P] extends (infer U)[]
+		? RecursivePartial<U>[]
+		: T[P] extends AnyRecord
+		? RecursivePartial<T[P]>
+		: T[P]
 }

package/ts/object/RecursiveRequired.ts

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

package/ts/object/RequiredKeys.ts

@@ -1,9 +1,8 @@
 import type { KeyTypes } from './KeyTypes.js'
 import type { OptionalKeys } from './OptionalKeys.js'
 
-export type RequiredKeys<T extends Record<KeyTypes, any>> = T extends unknown
-? RequiredKeys._<T> : never
+export type RequiredKeys<T extends Record<KeyTypes, any>> = T extends unknown ? RequiredKeys._<T> : never
 
 export namespace RequiredKeys {
-export type _<T extends Record<KeyTypes, any>> = Exclude<keyof T, OptionalKeys._<T>>
+	export type _<T extends Record<KeyTypes, any>> = Exclude<keyof T, OptionalKeys._<T>>
 }

package/ts/object/SpreadRecord.ts

@@ -1,6 +1,7 @@
 import type { Omit } from '../object/index.js'
 
-export type SpreadRecord<
-A extends Record<any, any>,
-B extends Record<any, any>
-> = Omit<A, Extract<keyof A, keyof B>> & B
+export type SpreadRecord<A extends Record<any, any>, B extends Record<any, any>> = Omit<
+	A,
+	Extract<keyof A, keyof B>
+> &
+	B

package/ts/object/ValueOf.ts

@@ -1,2 +1 @@
-
 export type ValueOf<T> = T[keyof T]