type-plus 5.5.2 → 6.0.0

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]

package/ts/object/everyKey.ts

@@ -1,9 +1,9 @@
 import type { KeyTypes } from './KeyTypes.js'
 
 export function everyKey<S extends Record<KeyTypes, any>, T = any>(
-  subject: S,
-  predicate: (this: T, key: keyof S, index: number, array: string[]) => unknown,
-  thisArg?: T
+	subject: S,
+	predicate: (this: T, key: keyof S, index: number, array: string[]) => unknown,
+	thisArg?: T
 ): boolean {
-  return Object.keys(subject).every(predicate, thisArg)
+	return Object.keys(subject).every(predicate, thisArg)
 }

package/ts/object/facade.ts

@@ -4,36 +4,211 @@ import type { AnyRecord } from './AnyRecord.js'
  * creates a facade of the subject.
  */
 export function facade<T extends AnyRecord, P1 extends keyof T>(subject: T, prop1: P1): Pick<T, P1>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T, P12 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T>(
+	subject: T,
+	prop1: P1,
+	prop2: P2
+): Pick<T, P1 | P2>
+export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3
+): Pick<T, P1 | P2 | P3>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T
+>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T
+>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T,
+	P6 extends keyof T
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T,
+	P6 extends keyof T,
+	P7 extends keyof T
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T,
+	P6 extends keyof T,
+	P7 extends keyof T,
+	P8 extends keyof T
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T,
+	P6 extends keyof T,
+	P7 extends keyof T,
+	P8 extends keyof T,
+	P9 extends keyof T
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T,
+	P6 extends keyof T,
+	P7 extends keyof T,
+	P8 extends keyof T,
+	P9 extends keyof T,
+	P10 extends keyof T
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9,
+	prop10: P10
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T,
+	P6 extends keyof T,
+	P7 extends keyof T,
+	P8 extends keyof T,
+	P9 extends keyof T,
+	P10 extends keyof T,
+	P11 extends keyof T
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9,
+	prop10: P10,
+	prop11: P11
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
+export function facade<
+	T extends AnyRecord,
+	P1 extends keyof T,
+	P2 extends keyof T,
+	P3 extends keyof T,
+	P4 extends keyof T,
+	P5 extends keyof T,
+	P6 extends keyof T,
+	P7 extends keyof T,
+	P8 extends keyof T,
+	P9 extends keyof T,
+	P10 extends keyof T,
+	P11 extends keyof T,
+	P12 extends keyof T
+>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3,
+	prop4: P4,
+	prop5: P5,
+	prop6: P6,
+	prop7: P7,
+	prop8: P8,
+	prop9: P9,
+	prop10: P10,
+	prop11: P11,
+	prop12: P12
+): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
 export function facade<T extends AnyRecord>(subject: T, ...props: (keyof T)[]) {
-  return props.reduce((p, k) => {
-    const prop = subject[k]
-    if (typeof prop === 'function') {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-      p[k] = prop.bind(subject)
-    }
-    else {
-      Object.defineProperty(p, k, {
-        get() {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return subject[k]
-        },
-        set(value: any) {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
-          return subject[k] = value
-        },
-      })
-    }
-    return p
-  }, {} as T)
+	return props.reduce((p, k) => {
+		const prop = subject[k]
+		if (typeof prop === 'function') {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+			p[k] = prop.bind(subject)
+		} else {
+			Object.defineProperty(p, k, {
+				get() {
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+					return subject[k]
+				},
+				set(value: any) {
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
+					return (subject[k] = value)
+				}
+			})
+		}
+		return p
+	}, {} as T)
 }

package/ts/object/filterKey.ts

@@ -1,10 +1,11 @@
 import type { KeyTypes } from './KeyTypes.js'
 
 export function filterKey<S extends Record<KeyTypes, any>, T = any>(
-  subject: S,
-  predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>, subject: S) => boolean,
-  thisArg?: T): Array<keyof S> {
-  return Object.keys(subject).filter(function (this: T, k, i, a) {
-    return predicate.apply(this, [k, i, a, subject])
-  }, thisArg)
+	subject: S,
+	predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>, subject: S) => boolean,
+	thisArg?: T
+): Array<keyof S> {
+	return Object.keys(subject).filter(function (this: T, k, i, a) {
+		return predicate.apply(this, [k, i, a, subject])
+	}, thisArg)
 }

package/ts/object/findKey.ts

@@ -1,10 +1,11 @@
 import { KeyTypes } from './KeyTypes.js'
 
 export function findKey<S extends Record<KeyTypes, any>, T = any>(
-  subject: S,
-  predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>, subject: S) => boolean,
-  thisArg?: T): keyof S | undefined {
-  return Object.keys(subject).find(function (this: T, k, i, a) {
-    return predicate.apply(this, [k, i, a, subject])
-  }, thisArg)
+	subject: S,
+	predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>, subject: S) => boolean,
+	thisArg?: T
+): keyof S | undefined {
+	return Object.keys(subject).find(function (this: T, k, i, a) {
+		return predicate.apply(this, [k, i, a, subject])
+	}, thisArg)
 }

package/ts/object/forEachKey.ts

@@ -1,8 +1,9 @@
 import { KeyTypes } from './KeyTypes.js'
 
 export function forEachKey<S extends Record<KeyTypes, any>, T = any>(
-  subject: S,
-  predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>) => void,
-  thisArg?: T): void {
-  return Object.keys(subject).forEach(predicate, thisArg)
+	subject: S,
+	predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>) => void,
+	thisArg?: T
+): void {
+	return Object.keys(subject).forEach(predicate, thisArg)
 }

package/ts/object/getField.ts

@@ -1,21 +1,20 @@
 import { UnionKeys } from '../UnionKeys.js'
 
+export function getField<T, TX extends Exclude<T, undefined | null>, K extends UnionKeys<TX>>(
+	subject: T,
+	key: K
+): TX[K]
 export function getField<
-  T,
-  TX extends Exclude<T, undefined | null>,
-  K extends UnionKeys<TX>,
-  >(subject: T, key: K): TX[K]
-export function getField<
-  T,
-  TX extends Exclude<T, undefined | null>,
-  K extends UnionKeys<TX>,
-  DV extends Exclude<TX[K], undefined>
+	T,
+	TX extends Exclude<T, undefined | null>,
+	K extends UnionKeys<TX>,
+	DV extends Exclude<TX[K], undefined>
 >(subject: T, key: K, defaultValue: DV): DV
 export function getField<
-  T,
-  TX extends Exclude<T, undefined | null>,
-  K extends UnionKeys<TX>,
-  DV extends Exclude<TX[K], undefined>
+	T,
+	TX extends Exclude<T, undefined | null>,
+	K extends UnionKeys<TX>,
+	DV extends Exclude<TX[K], undefined>
 >(subject: T, key: K, defaultValue?: DV) {
-  return subject && (subject as unknown as { [k in K]: TX[K] | DV })[key] || defaultValue
+	return (subject && (subject as unknown as { [k in K]: TX[K] | DV })[key]) || defaultValue
 }

package/ts/object/hasKey.ts

@@ -3,5 +3,5 @@ import type { AnyRecord } from './AnyRecord.js'
 export type HasKey<T, K, Then = true, Else = false> = K extends keyof T ? Then : Else
 
 export function hasKey<T extends AnyRecord, K extends string>(subject: T, ...keys: K[]): HasKey<T, K> {
-  return !keys.some(key => !subject[key]) as unknown as HasKey<T, K>
+	return !keys.some(key => !subject[key]) as unknown as HasKey<T, K>
 }

package/ts/object/hasProperty.ts

@@ -1,5 +1,5 @@
 import { UnionKeys } from '../UnionKeys.js'
 
 export function hasProperty<T, P extends UnionKeys<T>>(value: T, prop: P): value is T & Record<P, T[P]> {
-  return !!value[prop]
+	return !!value[prop]
 }

package/ts/object/mapKey.ts

@@ -1,10 +1,11 @@
 import { KeyTypes } from './KeyTypes.js'
 
 export function mapKey<R, S extends Record<KeyTypes, any>, T = any>(
-  subject: S,
-  predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>, subject: S) => R,
-  thisArg?: T): R[] {
-  return Object.keys(subject).map(function (this: T, k, i, a) {
-    return predicate.apply(this, [k, i, a, subject])
-  }, thisArg)
+	subject: S,
+	predicate: (this: T, key: keyof S, index: number, obj: Array<keyof S>, subject: S) => R,
+	thisArg?: T
+): R[] {
+	return Object.keys(subject).map(function (this: T, k, i, a) {
+		return predicate.apply(this, [k, i, a, subject])
+	}, thisArg)
 }