type-plus 8.0.0-beta.0 → 8.0.0-beta.3

package/ts/object/omit.ts

@@ -1,222 +0,0 @@
-import type { UnionKeys } from '../union_keys.js'
-import type { AnyRecord } from './any_record.js'
-import type { Pick } from './pick.js'
-import { record } from './record.js'
-import { reduceByKey } from './reduceKey.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
-		? {}
-		: 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, Props extends UnionKeys<T>>(
-	subject: T,
-	...props: Props[]
-): Omit<T, Props>
-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
-		},
-		Object.getPrototypeOf(subject) === null ? record() : {}
-	)
-}

package/ts/object/optional_key.ts

@@ -1,38 +0,0 @@
-
-import type { AnyRecord } from './any_record.js'
-import type { KeyTypes } from './KeyTypes.js'
-
-/**
- * Validate if the key `K` in `T` is optional.
- *
- * 🎭 *validate*
- *
- * @example
- * ```ts
- * IsOptionalKey({ a: 1 }, 'a') // false
- * IsOptionalKey({ a?: 1 }, 'a') // true
- * ```
- */
-export type IsOptionalKey<T, K, Then = true, Else = false> = K extends OptionalKeys<T> ? Then : Else
-
-/**
- * Gets the optional keys of `T`.
- *
- * 🦴 *utilities*
- *
- * @example
- * ```ts
- * OptionalKeys<{ a: 1 }> // never
- * OptionalKeys<{ a?: 1, b: number }> // 'a'
- * ```
- */
-export type OptionalKeys<T> = T extends unknown
-	? { [k in keyof T]-?: Record<KeyTypes, any> extends Pick<T, k> ? k : never }[keyof T]
-	: never
-
-/**
- * Parse `T` to keep only the optional properties.
- */
-export type OptionalProps<T extends AnyRecord> = T extends unknown
-	? { [k in OptionalKeys<T>]?: T[k] }
-	: never

package/ts/object/pick.ts

@@ -1,220 +0,0 @@
-import type { UnionKeys } from '../union_keys.js'
-import type { AnyRecord } from './any_record.js'
-import { record } from './record.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, Props extends UnionKeys<T>>(
-	subject: T,
-	...props: Props[]
-): Pick<T, Props>
-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
-		},
-		Object.getPrototypeOf(subject) === null ? record() : {}
-	)
-}
-
-/**
- * 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/recursive_partial.ts

@@ -1,39 +0,0 @@
-// Source: https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript-2-1
-
-import type { AnyFunction } from '../function/any_function.js'
-import type { ExtractFunction } from '../index.js'
-import type { AnyRecord } from './any_record.js'
-import type { Properties } from './properties.js'
-
-/**
- * Creates a recursive partial type of type T.
- *
- * @example
- * ```ts
- * interface Foo {
- *   bar: number;
- *   baz: {
- *     qux: string
- *   }
- * }
- *
- * type PartialFoo = RecursivePartial<Foo>
- * // {
- * //   bar?: number | undefined;
- * //   baz?: {
- * //     qux?: string | undefined
- * //   } | undefined
- * // }
- * ```
- */
-export type RecursivePartial<T> = {
-	[P in keyof T]?: T[P] extends (infer U)[]
-		? RecursivePartial<U>[] | undefined
-		: T[P] extends infer F extends AnyFunction
-		? [keyof T[P]] extends [undefined]
-			? T[P] | undefined
-			: ExtractFunction<F> & RecursivePartial<Properties<T[P]>>
-		: T[P] extends AnyRecord
-		? RecursivePartial<T[P]> | undefined
-		: T[P] | undefined
-}

package/ts/object/split.ts

@@ -1,203 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import type { AnyRecord } from './any_record.js'
-import type { Omit } from './omit.js'
-import { reduceByKey } from './reduceKey.js'
-import type { Partial } from './Partial.js'
-import type { NonUndefined } from '../utils/NonUndefined.js'
-
-type Splitter<T extends AnyRecord> = Partial<{ [k in keyof T]: T[k] | undefined }>
-export type Split<T extends AnyRecord, S extends AnyRecord> = {
-	[k in keyof S]-?: S[k] extends undefined ? T[k] : NonNullable<T[k]> | NonUndefined<S[k]>
-}
-
-/**
- * Split an object into multiple objects.
- * @returns [...entries, remaining]
- */
-export function split<T extends AnyRecord, S1 extends Splitter<T>>(
-	target: T,
-	split1: S1
-): [Split<T, S1>, Omit<T, keyof S1>]
-export function split<T extends AnyRecord, S1 extends Splitter<T>, S2 extends Splitter<T>>(
-	target: T,
-	split1: S1,
-	split2: S2
-): [Split<T, S1>, Split<T, S2>, Omit<T, keyof S1 | keyof S2>]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3
-): [Split<T, S1>, Split<T, S2>, Split<T, S3>, Omit<T, keyof S1 | keyof S2 | keyof S3>]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>,
-	S8 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7,
-	splitter8: S8
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Split<T, S8>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>,
-	S8 extends Splitter<T>,
-	S9 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7,
-	splitter8: S8,
-	splitter9: S9
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Split<T, S8>,
-	Split<T, S9>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8 | keyof S9>
-]
-export function split(target: AnyRecord, ...splitters: AnyRecord[]): AnyRecord[] {
-	const keyMap: AnyRecord = {}
-	const s = splitters.map(s =>
-		reduceByKey(s, (p, k) => ((keyMap[k] = true), (p[k] = target[k] ?? s[k]), p), {} as AnyRecord)
-	)
-	const r = reduceByKey(target, (p, k) => (keyMap[k] ? p : ((p[k] = target[k]), p)), {} as AnyRecord)
-	return [...s, r]
-}