type-plus 4.8.2 → 4.10.0

package/ts/object/ANotB.ts

@@ -1,21 +1,21 @@
-import { Equal } from '../predicates'
-import { AnyRecord } from './AnyRecord'
-import { IsDisjoint } from './IsDisjoint'
-import { KeysWithDiffType } from './KeysWithDiffType'
-
-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] }
-  )
+import type { Equal } from '../predicates/index.js'
+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 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] }
+  )

package/ts/object/IsDisjoint.ts

@@ -1,12 +1,12 @@
-import { And, Not } from '../predicates'
-import { AnyRecord } from './AnyRecord'
-import { HasKey } from './hasKey'
-
-/**
- * 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>>>
+import { And, Not } from '../predicates/index.js'
+import type { AnyRecord } from './AnyRecord.js'
+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>>>

package/ts/object/KeysWithDiffType.ts

@@ -1,6 +1,6 @@
-import { ValueOf } from './ValueOf'
-import { IsDisjoint } from './IsDisjoint'
-import { AnyRecord } from './AnyRecord'
+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 :

package/ts/object/KnownKeys.ts

@@ -2,7 +2,7 @@
 // known from Gerrit Birkeland @Gerrit0
 // https://github.com/Microsoft/TypeScript/issues/25987#issuecomment-408339599
 
-import { PrimitiveTypes } from '../PrimitiveTypes'
+import { PrimitiveTypes } from '../PrimitiveTypes.js'
 
 // https://github.com/microsoft/TypeScript/issues/25987#issuecomment-441224690
 export type KnownKeys<T> =

package/ts/object/OptionalKeys.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export type OptionalKeys<O extends Record<KeyTypes, any>> = O extends unknown
 ? OptionalKeys._<O>

package/ts/object/Partial.ts

@@ -1,6 +1,6 @@
-import { UnionKeys } from '../UnionKeys'
-import { Omit } from './omit'
-import { Pick } from './pick'
+import { UnionKeys } from '../UnionKeys.js'
+import { Omit } from './omit.js'
+import { Pick } from './pick.js'
 
 /**
  * Apply `Partial<>` on the selected properties.

package/ts/object/RecursiveIntersect.ts

@@ -1,4 +1,4 @@
-import { AnyRecord } from './AnyRecord'
+import type { AnyRecord } from './AnyRecord.js'
 
 /**
  * Intersect type recursively.

package/ts/object/RecursivePartial.ts

@@ -1,4 +1,4 @@
-import { AnyRecord } from './AnyRecord'
+import type { AnyRecord } from './AnyRecord.js'
 
 // Source: https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript-2-1
 export type RecursivePartial<T> = {

package/ts/object/RecursiveRequired.ts

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

package/ts/object/RequiredKeys.ts

@@ -1,5 +1,5 @@
-import { KeyTypes } from './KeyTypes'
-import { OptionalKeys } from './OptionalKeys'
+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

package/ts/object/SpreadRecord.ts

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

package/ts/object/everyKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import type { KeyTypes } from './KeyTypes.js'
 
 export function everyKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/facade.ts

@@ -1,39 +1,39 @@
-import { AnyRecord } from './AnyRecord'
-
-/**
- * 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>(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)
-}
+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>(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)
+}

package/ts/object/filterKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export function filterKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/findKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export function findKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/forEachKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export function forEachKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/getField.ts

@@ -1,4 +1,4 @@
-import { UnionKeys } from '../UnionKeys'
+import { UnionKeys } from '../UnionKeys.js'
 
 export function getField<
   T,

package/ts/object/hasKey.ts

@@ -1,7 +1,7 @@
-import { AnyRecord } from './AnyRecord'
-
-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>
-}
+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>
+}

package/ts/object/hasProperty.ts

@@ -1,4 +1,4 @@
-import { UnionKeys } from '../UnionKeys'
+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]

package/ts/object/index.ts

@@ -1,36 +1,36 @@
-export type { ANotB, BNotA, LeftJoin } from './ANotB'
-export type { AnyRecord } from './AnyRecord'
-export * from './everyKey'
-export type { ExcludePropType } from './ExcludePropType'
-export * from './facade'
-export * from './filterKey'
-export * from './findKey'
-export * from './forEachKey'
-export * from './getField'
-export * from './hasKey'
-export * from './hasProperty'
-export type { IsDisjoint } from './IsDisjoint'
-export type { IsRecord } from './IsRecord'
-export type { KeysOfOptional } from './KeyofOptional'
-export type { KeysWithDiffType } from './KeysWithDiffType'
-export type { KeyTypes } from './KeyTypes'
-export type { KnownKeys } from './KnownKeys'
-export * from './mapKey'
-export * from './mapProperties'
-export * from './omit'
-export type { OptionalKeys } from './OptionalKeys'
-export type { PartialExcept, PartialOmit, PartialPick } from './Partial'
-export * from './pick'
-export * from './record'
-export type { RecursiveIntersect } from './RecursiveIntersect'
-export type { RecursivePartial } from './RecursivePartial'
-export type { RecursiveRequired } from './RecursiveRequired'
-export * from './reduceKey'
-export * from './replaceProperty'
-export type { RequiredExcept, RequiredPick } from './Required'
-export type { RequiredKeys } from './RequiredKeys'
-export * from './someKey'
-export * from './split'
-export type { SpreadRecord } from './SpreadRecord'
-export * from './typeOverrideIncompatible'
-export type { ValueOf } from './ValueOf'
+export type { ANotB, BNotA, LeftJoin } from './ANotB.js'
+export type { AnyRecord } from './AnyRecord.js'
+export * from './everyKey.js'
+export type { ExcludePropType } from './ExcludePropType.js'
+export * from './facade.js'
+export * from './filterKey.js'
+export * from './findKey.js'
+export * from './forEachKey.js'
+export * from './getField.js'
+export * from './hasKey.js'
+export * from './hasProperty.js'
+export type { IsDisjoint } from './IsDisjoint.js'
+export type { IsRecord } from './IsRecord.js'
+export type { KeysOfOptional } from './KeyofOptional.js'
+export type { KeysWithDiffType } from './KeysWithDiffType.js'
+export type { KeyTypes } from './KeyTypes.js'
+export type { KnownKeys } from './KnownKeys.js'
+export * from './mapKey.js'
+export * from './mapProperties.js'
+export * from './omit.js'
+export type { OptionalKeys } from './OptionalKeys.js'
+export type { PartialExcept, PartialOmit, PartialPick } from './Partial.js'
+export * from './pick.js'
+export * from './record.js'
+export type { RecursiveIntersect } from './RecursiveIntersect.js'
+export type { RecursivePartial } from './RecursivePartial.js'
+export type { RecursiveRequired } from './RecursiveRequired.js'
+export * from './reduceKey.js'
+export * from './replaceProperty.js'
+export type { RequiredExcept, RequiredPick } from './Required.js'
+export type { RequiredKeys } from './RequiredKeys.js'
+export * from './someKey.js'
+export * from './split.js'
+export type { SpreadRecord } from './SpreadRecord.js'
+export * from './typeOverrideIncompatible.js'
+export type { ValueOf } from './ValueOf.js'

package/ts/object/mapKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import { KeyTypes } from './KeyTypes.js'
 
 export function mapKey<R, S extends Record<KeyTypes, any>, T = any>(
   subject: S,

package/ts/object/mapProperties.ts

@@ -1,6 +1,6 @@
-import { AnyRecord } from './AnyRecord'
-import { reduceByKey } from './reduceKey'
-import { ValueOf } from './ValueOf'
+import type { AnyRecord } from './AnyRecord.js'
+import { reduceByKey } from './reduceKey.js'
+import { ValueOf } from './ValueOf.js'
 
 /**
  * An Object-specific version of `map`.

package/ts/object/omit.ts

@@ -1,36 +1,36 @@
-import { AnyRecord, reduceByKey } from '../object'
-import { UnionKeys } from '../UnionKeys'
-import { Pick } from './pick'
-
-// by Titian Cernicova-Dragomir
-// https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347
-// type-zoo
-export type Omit<T, K extends UnionKeys<T>> = T extends T
-  ? keyof T extends K
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  ? {}
-  : Pick<T, Exclude<keyof T, K>> : never
-
-/**
- * @deprecated replaced by `Omit`
- */
-export type Except<T, K extends keyof T> = Omit<T, K>
-
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Omit<T, P1>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Omit<T, P1 | P2>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Omit<T, P1 | P2 | P3>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Omit<T, P1 | P2 | P3 | P4>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Omit<T, P1 | P2 | P3 | P4 | P5>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Omit<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<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): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<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): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function omit<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
-  return reduceByKey(subject, (p, k) => {
-    if (props.indexOf(k) === -1) p[k] = subject[k]
-    return p
-  }, {} as AnyRecord)
-}
+import { AnyRecord, reduceByKey } from '../object/index.js'
+import { UnionKeys } from '../UnionKeys.js'
+import { Pick } from './pick.js'
+
+// by Titian Cernicova-Dragomir
+// https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347
+// type-zoo
+export type Omit<T, K extends UnionKeys<T>> = T extends T
+  ? keyof T extends K
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  ? {}
+  : Pick<T, Exclude<keyof T, K>> : never
+
+/**
+ * @deprecated replaced by `Omit`
+ */
+export type Except<T, K extends keyof T> = Omit<T, K>
+
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Omit<T, P1>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Omit<T, P1 | P2>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Omit<T, P1 | P2 | P3>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Omit<T, P1 | P2 | P3 | P4>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Omit<T, P1 | P2 | P3 | P4 | P5>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Omit<T, P1 | P2 | P3 | P4 | P5 | P6>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<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): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<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): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
+export function omit<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
+  return reduceByKey(subject, (p, k) => {
+    if (props.indexOf(k) === -1) p[k] = subject[k]
+    return p
+  }, {} as AnyRecord)
+}

package/ts/object/pick.ts

@@ -1,35 +1,35 @@
-import { UnionKeys } from '../UnionKeys'
-import { AnyRecord } from './AnyRecord'
-import { reduceByKey } from './reduceKey'
-
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<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 pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
-  return reduceByKey(subject, (p, k) => {
-    if (props.indexOf(k) >= 0) p[k] = subject[k]
-    return p
-  }, {} as T)
-}
-
-/**
- * Pick properties `K` from `T`.
- * Works with union.
- *
- * Original type by Titian Cernicova-Dragomir
- * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
- */
-export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
-
-export namespace Pick {
-  export type _<T, K extends keyof T> = { [P in K]: T[P] }
-}
+import { UnionKeys } from '../UnionKeys.js'
+import type { AnyRecord } from './AnyRecord.js'
+import { reduceByKey } from './reduceKey.js'
+
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<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 pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<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 pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
+  return reduceByKey(subject, (p, k) => {
+    if (props.indexOf(k) >= 0) p[k] = subject[k]
+    return p
+  }, {} as T)
+}
+
+/**
+ * Pick properties `K` from `T`.
+ * Works with union.
+ *
+ * Original type by Titian Cernicova-Dragomir
+ * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
+ */
+export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
+
+export namespace Pick {
+  export type _<T, K extends keyof T> = { [P in K]: T[P] }
+}

package/ts/object/record.ts

@@ -1,10 +1,11 @@
-import { KeyTypes } from 'type-plus'
-import { Widen } from '../utils'
+import { Widen } from '../utils/index.js'
+import type { AnyRecord } from './AnyRecord.js'
+import { KeyTypes } from './KeyTypes.js'
 
 /**
  * Creates a `Record<Key, Value>`
  */
 export function record<K extends KeyTypes, V>(value?: Record<K, V>): Record<Widen<K>, V> {
-  const r = Object.create(null)
-  return value ? Object.assign(r, value) : r
+  const r = Object.create(null) as AnyRecord
+  return (value ? Object.assign(r, value) : r) as Record<Widen<K>, V>
 }

package/ts/object/reduceKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import type { KeyTypes } from './KeyTypes.js'
 
 export function reduceByKey<S extends Record<KeyTypes, any>, T>(
   subject: S,

package/ts/object/replaceProperty.ts

@@ -1,4 +1,4 @@
-import { AnyRecord } from './AnyRecord'
+import type { AnyRecord } from './AnyRecord.js'
 
 export type ReplaceProperty<
   T extends AnyRecord,

package/ts/object/someKey.ts

@@ -1,4 +1,4 @@
-import { KeyTypes } from './KeyTypes'
+import type { KeyTypes } from './KeyTypes.js'
 
 export function someKey<S extends Record<KeyTypes, any>, T = any>(
   subject: S,