type-plus 8.0.0-beta.2 → 8.0.0-beta.4

package/src/testing/test_type.ts

@@ -26,13 +26,13 @@ export namespace testType {
 		 *
 		 * @return `expected` as `A` for type inspection.
 		 */
-		equal<A, B, C>(expected: IsEqual<A, B> & IsEqual<A, C>): A,
+		equal<A, B, C>(expected: IsEqual<A, B> & IsEqual<A, C>): A
 		/**
 		 * Check if type `A` is equal to type `B`.
 		 *
 		 * @return `expected` as `A` for type inspection.
 		 */
-		equal<A, B>(expected: IsEqual<A, B>): A,
+		equal<A, B>(expected: IsEqual<A, B>): A
 		/**
 		 * Check if `A` can assign to `B`.
 		 *
@@ -54,7 +54,7 @@ export namespace testType {
 		 *
 		 * @return `expected` as `A` for type inspection.
 		 */
-		canAssign<A, B>(expected: Assignable<A, B>): A,
+		canAssign<A, B>(expected: Assignable<A, B>): A
 		/**
 		 * Check if `A` can fully assign to `B`.
 		 *
@@ -69,91 +69,91 @@ export namespace testType {
 		 *
 		 * @return `expected` as `A` for type inspection.
 		 */
-		strictCanAssign<A, B>(expected: Assignable<A, B, { distributive: false }>): A,
+		strictCanAssign<A, B>(expected: Assignable<A, B, { distributive: false }>): A
 		/**
 		 * Check if type `T` is exactly `any`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		any<T>(expected: IsAny<T>): T,
+		any<T>(expected: IsAny<T>): T
 		/**
 		 * Check if type `T` is exactly `array`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		array<T>(expected: IsArray<T, { exact: true }>): T,
+		array<T>(expected: IsArray<T, { exact: true }>): T
 		/**
 		 * Check if type `T` is exactly `bigint`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		strictBigint<T>(expected: IsBigint<T, { distributive: false, exact: true }>): T,
+		strictBigint<T>(expected: IsBigint<T, { distributive: false; exact: true }>): T
 		/**
 		 * Check if type `T` is `bigint` or bigint literals.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		bigint<T>(expected: IsBigint<T, { distributive: false }>): T,
+		bigint<T>(expected: IsBigint<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `boolean`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		strictBoolean<T>(expected: IsBoolean<T, { distributive: false, exact: true }>): T,
+		strictBoolean<T>(expected: IsBoolean<T, { distributive: false; exact: true }>): T
 		/**
 		 * Check if type `T` is `boolean` and boolean literals.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		boolean<T>(expected: IsBoolean<T, { distributive: false }>): T,
+		boolean<T>(expected: IsBoolean<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `true`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		true<T>(expected: IsTrue<T, { distributive: false }>): T,
+		true<T>(expected: IsTrue<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `false`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		false<T>(expected: IsFalse<T, { distributive: false }>): T,
+		false<T>(expected: IsFalse<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `boolean`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		strictFunction<T>(expected: IsStrictFunction<T, { distributive: false }>): T,
+		strictFunction<T>(expected: IsStrictFunction<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is `boolean` and boolean literals.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		function<T>(expected: IsFunction<T, { distributive: false }>): T,
+		function<T>(expected: IsFunction<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `never`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		never<T>(expected: IsNever<T>): T,
+		never<T>(expected: IsNever<T>): T
 		/**
 		 * Check if type `T` is exactly `null`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		null<T>(expected: IsNull<T, { distributive: false }>): T,
+		null<T>(expected: IsNull<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `number`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		strictNumber<T>(expected: IsNumber<T, { distributive: false, exact: true }>): T,
+		strictNumber<T>(expected: IsNumber<T, { distributive: false; exact: true }>): T
 		/**
 		 * Check if type `T` is `number` or number literals.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		number<T>(expected: IsNumber<T, { distributive: false }>): T,
+		number<T>(expected: IsNumber<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is `object`.
 		 *
@@ -161,50 +161,50 @@ export namespace testType {
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		object<T>(expected: IsObject<T, { distributive: false }>): T,
+		object<T>(expected: IsObject<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `string`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		strictString<T>(expected: IsString<T, { distributive: false, exact: true }>): T,
+		strictString<T>(expected: IsString<T, { distributive: false; exact: true }>): T
 		/**
 		 * Check if type `T` is `string` or string literals.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		string<T>(expected: IsString<T, { distributive: false }>): T,
+		string<T>(expected: IsString<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is a `symbol`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		symbol<T>(expected: IsSymbol<T, { distributive: false }>): T,
+		symbol<T>(expected: IsSymbol<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is a *tuple*.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		tuple<T>(expected: IsTuple<T, { distributive: false }>): T,
+		tuple<T>(expected: IsTuple<T, { distributive: false }>): T
 		/**
 		 * Check if type `T` is exactly `undefined`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		undefined<T>(expected: IsUndefined<T, { distributive: false }>): T,
+		undefined<T>(expected: IsUndefined<T, { distributive: false }>): T
 		// hasUndefined<T>(expected: CanAssign<T, undefined>): T
 		/**
 		 * Check if type `T` is exactly `unknown`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		unknown<T>(expected: IsUnknown<T>): T,
+		unknown<T>(expected: IsUnknown<T>): T
 		/**
 		 * Check if type `T` is exactly `void`.
 		 *
 		 * @return `expected` as `T` for type inspection.
 		 */
-		void<T>(expected: IsVoid<T, { distributive: false }>): T,
+		void<T>(expected: IsVoid<T, { distributive: false }>): T
 		/**
 		 * A quick way to inspect a type.
 		 *
@@ -232,69 +232,69 @@ export namespace testType {
 	}
 
 	export type InspectedType<T> = {
-		type: T,
-		extends<R>(): T extends R ? true : false,
-		extends_any: T extends any ? true : false,
-		extends_unknown: T extends unknown ? true : false,
-		extends_void: T extends void ? true : false,
-		extends_never: T extends never ? true : false,
-		extends_undefined: T extends undefined ? true : false,
-		extends_null: T extends null ? true : false,
-		extends_boolean: T extends boolean ? true : false,
-		extends_true: T extends true ? true : false,
-		extends_false: T extends false ? true : false,
-		extends_number: T extends number ? true : false,
-		extends_1: T extends 1 ? true : false,
-		extends_bigint: T extends bigint ? true : false,
-		extends_1n: T extends 1n ? true : false,
-		extends_string: T extends string ? true : false,
-		extends_a: T extends 'a' ? true : false,
-		extends_symbol: T extends symbol ? true : false,
-		extends_object: T extends object ? true : false,
-		extends_function: T extends Function ? true : false,
-		extends_array_unknown: T extends unknown[] ? true : false,
-		extends_tuple_empty: T extends [] ? true : false,
-		union<R>(): T | R,
-		union_any: T | any,
-		union_unknown: T | unknown,
-		union_void: T | void,
-		union_never: T | never,
-		union_undefined: T | undefined,
-		union_null: T | null,
-		union_boolean: T | boolean,
-		union_true: T | true,
-		union_false: T | false,
-		union_number: T | number,
-		union_1: T | 1,
-		union_bigint: T | bigint,
-		union_1n: T | 1n,
-		union_string: T | string,
-		union_a: T | 'a',
-		union_symbol: T | symbol,
-		union_object: T | object,
-		union_function: T | Function,
-		union_array_unknown: T | unknown[],
-		union_tuple_empty: T | [],
-		intersect<R>(): T & R,
-		intersect_any: T & any,
-		intersect_unknown: T & unknown,
-		intersect_void: T & void,
-		intersect_never: T & never,
-		intersect_undefined: T & undefined,
-		intersect_null: T & null,
-		intersect_boolean: T & boolean,
-		intersect_true: T & true,
-		intersect_false: T & false,
-		intersect_number: T & number,
-		intersect_1: T & 1,
-		intersect_bigint: T & bigint,
-		intersect_1n: T & 1n,
-		intersect_string: T & string,
-		intersect_a: T & 'a',
-		intersect_symbol: T & symbol,
-		intersect_object: T & object,
-		intersect_function: T & Function,
-		intersect_array_unknown: T & unknown[],
+		type: T
+		extends<R>(): T extends R ? true : false
+		extends_any: T extends any ? true : false
+		extends_unknown: T extends unknown ? true : false
+		extends_void: T extends void ? true : false
+		extends_never: T extends never ? true : false
+		extends_undefined: T extends undefined ? true : false
+		extends_null: T extends null ? true : false
+		extends_boolean: T extends boolean ? true : false
+		extends_true: T extends true ? true : false
+		extends_false: T extends false ? true : false
+		extends_number: T extends number ? true : false
+		extends_1: T extends 1 ? true : false
+		extends_bigint: T extends bigint ? true : false
+		extends_1n: T extends 1n ? true : false
+		extends_string: T extends string ? true : false
+		extends_a: T extends 'a' ? true : false
+		extends_symbol: T extends symbol ? true : false
+		extends_object: T extends object ? true : false
+		extends_function: T extends Function ? true : false
+		extends_array_unknown: T extends unknown[] ? true : false
+		extends_tuple_empty: T extends [] ? true : false
+		union<R>(): T | R
+		union_any: T | any
+		union_unknown: T | unknown
+		union_void: T | void
+		union_never: T | never
+		union_undefined: T | undefined
+		union_null: T | null
+		union_boolean: T | boolean
+		union_true: T | true
+		union_false: T | false
+		union_number: T | number
+		union_1: T | 1
+		union_bigint: T | bigint
+		union_1n: T | 1n
+		union_string: T | string
+		union_a: T | 'a'
+		union_symbol: T | symbol
+		union_object: T | object
+		union_function: T | Function
+		union_array_unknown: T | unknown[]
+		union_tuple_empty: T | []
+		intersect<R>(): T & R
+		intersect_any: T & any
+		intersect_unknown: T & unknown
+		intersect_void: T & void
+		intersect_never: T & never
+		intersect_undefined: T & undefined
+		intersect_null: T & null
+		intersect_boolean: T & boolean
+		intersect_true: T & true
+		intersect_false: T & false
+		intersect_number: T & number
+		intersect_1: T & 1
+		intersect_bigint: T & bigint
+		intersect_1n: T & 1n
+		intersect_string: T & string
+		intersect_a: T & 'a'
+		intersect_symbol: T & symbol
+		intersect_object: T & object
+		intersect_function: T & Function
+		intersect_array_unknown: T & unknown[]
 		intersect_tuple_empty: T & []
 	}
 }
@@ -309,5 +309,5 @@ export namespace testType {
 export const testType = new Proxy({} as testType.TestType, {
 	get(_target, _prop, _receiver) {
 		return (expected: unknown) => expected
-	}
+	},
 })

package/src/tuple/common_prop_keys.ts

@@ -21,16 +21,13 @@ import type { CommonPropKeys as TupleCommonPropKeys } from './tuple_plus.common_
  */
 export type CommonPropKeys<
 	T extends Record<KeyTypes, unknown>[],
-	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions
+	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions,
 > = number extends T['length'] ? ArrayCommonPropKeys<T> : TupleCommonPropKeys<T, Options>
 
-
 export namespace CommonPropKeys {
-	export interface Options extends TupleCommonPropKeys.Options {
-	}
+	export interface Options extends TupleCommonPropKeys.Options {}
 
-	export interface DefaultOptions extends TupleCommonPropKeys.DefaultOptions {
-	}
+	export interface DefaultOptions extends TupleCommonPropKeys.DefaultOptions {}
 }
 
 /**

package/src/tuple/create_tuple.ts

@@ -11,32 +11,32 @@ import type { IsPositive } from '../numeric/is_positive.js'
 export type CreateTuple<L extends number, T = unknown, Fail = never> = number extends L
 	? T[]
 	: IsPositive<L> extends true
-	? IsInteger<L> extends true
-		? ToTuple<[], DigitArray.FromString<`${L}`>, T>
+		? IsInteger<L> extends true
+			? ToTuple<[], DigitArray.FromString<`${L}`>, T>
+			: Fail
 		: Fail
-	: Fail
 export type ToTuple<R extends any[], S extends number[], X = any> = S['length'] extends 0
 	? R
 	: S['length'] extends 1
-	? [...R, ...DigitToTuple<X>[S[0]]]
-	: S extends [any, ...infer T]
-	? T extends any[]
-		? ToTuple<Multi10<[...R, ...DigitToTuple<X>[S[0]]]>, T>
-		: never
-	: never
+		? [...R, ...DigitToTuple<X>[S[0]]]
+		: S extends [any, ...infer T]
+			? T extends any[]
+				? ToTuple<Multi10<[...R, ...DigitToTuple<X>[S[0]]]>, T>
+				: never
+			: never
 
 type DigitToTuple<T = 1> = {
 	[k in number]: any[]
 } & {
-	0: [],
-	1: [T],
-	2: [T, T],
-	3: [T, T, T],
-	4: [T, T, T, T],
-	5: [T, T, T, T, T],
-	6: [T, T, T, T, T, T],
-	7: [T, T, T, T, T, T, T],
-	8: [T, T, T, T, T, T, T, T],
+	0: []
+	1: [T]
+	2: [T, T]
+	3: [T, T, T]
+	4: [T, T, T, T]
+	5: [T, T, T, T, T]
+	6: [T, T, T, T, T, T]
+	7: [T, T, T, T, T, T, T]
+	8: [T, T, T, T, T, T, T, T]
 	9: [T, T, T, T, T, T, T, T, T]
 }
 type Multi10<C extends any[]> = [...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C, ...C]

package/src/tuple/drop.ts

@@ -25,24 +25,24 @@ import type { DropMatch as TupleDropMatch } from './tuple_plus.drop_match.js'
  */
 export type DropFirst<
 	T extends unknown[],
-	Options extends DropFirst.Options = DropFirst.DefaultOptions<T>
+	Options extends DropFirst.Options = DropFirst.DefaultOptions<T>,
 > = number extends T['length']
 	? Options['$array']
 	: T['length'] extends 0
-	? Options['caseEmptyTuple']
-	: T['length'] extends 1
-	? []
-	: T extends [any, ...infer Tail]
-	? Tail
-	: never
+		? Options['caseEmptyTuple']
+		: T['length'] extends 1
+			? []
+			: T extends [any, ...infer Tail]
+				? Tail
+				: never
 
 export namespace DropFirst {
 	export interface Options {
-		$array?: unknown,
-		caseEmptyTuple?: unknown,
+		$array?: unknown
+		caseEmptyTuple?: unknown
 	}
 	export interface DefaultOptions<T> {
-		$array: T,
+		$array: T
 		caseEmptyTuple: []
 	}
 }
@@ -71,30 +71,28 @@ export namespace DropFirst {
  */
 export type DropLast<
 	T extends unknown[],
-	Cases extends DropLast.Options = DropLast.DefaultOptions<T>
+	Cases extends DropLast.Options = DropLast.DefaultOptions<T>,
 > = number extends T['length']
 	? Cases['$array']
 	: T['length'] extends 0
-	? Cases['caseEmptyTuple']
-	: T['length'] extends 1
-	? []
-	: T extends [...infer Heads, any]
-	? Heads
-	: never
-
+		? Cases['caseEmptyTuple']
+		: T['length'] extends 1
+			? []
+			: T extends [...infer Heads, any]
+				? Heads
+				: never
 
 export namespace DropLast {
 	export interface Options {
-		$array?: unknown,
-		caseEmptyTuple?: unknown,
+		$array?: unknown
+		caseEmptyTuple?: unknown
 	}
 	export interface DefaultOptions<T> {
-		$array: T,
+		$array: T
 		caseEmptyTuple: []
 	}
 }
 
-
 /**
  * ⚗️ *transform*
  *
@@ -107,7 +105,7 @@ export namespace DropLast {
  * type R = DropMatch<Array<1 | 2>, number> // never[]
  * ```
  */
-export type DropMatch<A extends Readonly<Array<unknown>>, Criteria> =	number extends A['length']
+export type DropMatch<A extends Readonly<Array<unknown>>, Criteria> = number extends A['length']
 	? ArrayDropMatch<A, Criteria>
 	: TupleDropMatch<A, Criteria>
 
@@ -121,5 +119,5 @@ export type DropUndefined<A extends Array<any>> = DropMatch<A, undefined>
  * 💀 *deprecated* the type does not sufficiently cover the use cases.
  */
 export function drop<A extends Readonly<unknown[]>, const C>(array: A, value: C): DropMatch<A, C> {
-	return array.filter(v => v !== value) as DropMatch<A, C>
+	return array.filter((v) => v !== value) as DropMatch<A, C>
 }

package/src/tuple/is_not_tuple.ts

@@ -55,13 +55,12 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsNotTuple<[], IsNotTuple.$Branch> // $Else
  * ```
  */
-export type IsNotTuple<
+export type IsNotTuple<T, $O extends IsNotTuple.$Options = {}> = $SpecialType<
 	T,
-	$O extends IsNotTuple.$Options = {}
-> = $SpecialType<T,
-	$MergeOptions<$O,
+	$MergeOptions<
+		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Then]>,
+			$then: $ResolveBranch<T, $O, [$Then]>
 			$else: IsNotTuple.$<T, $O>
 		}
 	>
@@ -80,22 +79,21 @@ export namespace IsNotTuple {
 	 * This is a type util for building custom types.
 	 * It does not check against special types.
 	 */
-	export type $<T, $O extends $UtilOptions> = $IsDistributive<$O, {
-		$then: T extends readonly any[]
-		? (
-			number extends T['length']
-			? $ResolveBranch<T, $O, [$Then]>
-			: $ResolveBranch<T, $O, [$Else]>
-		)
-		: $ResolveBranch<T, $O, [$Then]>,
-		$else: [T] extends [readonly any[]]
-		? (
-			number extends T['length']
-			? $ResolveBranch<T, $O, [$Then]>
-			: $ResolveBranch<T, $O, [$Else]>
-		)
-		: $ResolveBranch<T, $O, [$Then]>
-	}>
+	export type $<T, $O extends $UtilOptions> = $IsDistributive<
+		$O,
+		{
+			$then: T extends readonly any[]
+				? number extends T['length']
+					? $ResolveBranch<T, $O, [$Then]>
+					: $ResolveBranch<T, $O, [$Else]>
+				: $ResolveBranch<T, $O, [$Then]>
+			$else: [T] extends [readonly any[]]
+				? number extends T['length']
+					? $ResolveBranch<T, $O, [$Then]>
+					: $ResolveBranch<T, $O, [$Else]>
+				: $ResolveBranch<T, $O, [$Then]>
+		}
+	>
 
 	export type $UtilOptions = NotAssignable.$UtilOptions
 }

package/src/tuple/is_tuple.ts

@@ -53,18 +53,16 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsTuple<string, IsTuple.$Branch> // $Else
  * ```
  */
-export type IsTuple<
+export type IsTuple<T, $O extends IsTuple.$Options = {}> = $SpecialType<
 	T,
-	$O extends IsTuple.$Options = {}
-> =
-	$SpecialType<T,
-		$MergeOptions<$O,
-			{
-				$then: $ResolveBranch<T, $O, [$Else]>,
-				$else: IsTuple.$<T, $O>
-			}
-		>
+	$MergeOptions<
+		$O,
+		{
+			$then: $ResolveBranch<T, $O, [$Else]>
+			$else: IsTuple.$<T, $O>
+		}
 	>
+>
 
 export namespace IsTuple {
 	export type $Options = $Equality.$Options
@@ -78,22 +76,21 @@ export namespace IsTuple {
 	 * This is a type util for building custom types.
 	 * It does not check against special types.
 	 */
-	export type $<T, $O extends $UtilOptions> = $IsDistributive<$O, {
-		$then: T extends readonly any[]
-		? (
-			number extends T['length']
-			? $ResolveBranch<T, $O, [$Else]>
-			: $ResolveBranch<T, $O, [$Then]>
-		)
-		: $ResolveBranch<T, $O, [$Else]>,
-		$else: [T] extends [readonly any[]]
-		? (
-			number extends T['length']
-			? $ResolveBranch<T, $O, [$Else]>
-			: $ResolveBranch<T, $O, [$Then]>
-		)
-		: $ResolveBranch<T, $O, [$Else]>
-	}>
+	export type $<T, $O extends $UtilOptions> = $IsDistributive<
+		$O,
+		{
+			$then: T extends readonly any[]
+				? number extends T['length']
+					? $ResolveBranch<T, $O, [$Else]>
+					: $ResolveBranch<T, $O, [$Then]>
+				: $ResolveBranch<T, $O, [$Else]>
+			$else: [T] extends [readonly any[]]
+				? number extends T['length']
+					? $ResolveBranch<T, $O, [$Else]>
+					: $ResolveBranch<T, $O, [$Then]>
+				: $ResolveBranch<T, $O, [$Else]>
+		}
+	>
 
 	export type $UtilOptions = Assignable.$UtilOptions
 }

package/src/tuple/tail.ts

@@ -5,6 +5,8 @@ import type { UnionOfValues } from '../array/union_of_values.js'
  */
 export type Tail<T extends readonly unknown[]> = T['length'] extends 0
 	? never
-	: (T extends readonly [any, ...infer Tail]
-		? Tail extends UnionOfValues<T>[] ? Tail : never
-		: T)
+	: T extends readonly [any, ...infer Tail]
+		? Tail extends UnionOfValues<T>[]
+			? Tail
+			: never
+		: T

package/src/tuple/tuple_plus.common_prop_keys.ts

@@ -22,29 +22,23 @@ import type { Tail } from './tail.js'
  */
 export type CommonPropKeys<
 	T extends Record<KeyTypes, unknown>[],
-	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions
+	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions,
 > = IsNever<
 	T,
 	{
-		$then: Options['$never'],
-		$else: (T['length'] extends 0
+		$then: Options['$never']
+		$else: T['length'] extends 0
 			? never
-			: (
-				T['length'] extends 1
+			: T['length'] extends 1
 				? keyof T[0]
-				: (
-					T['length'] extends 2
+				: T['length'] extends 2
 					? keyof T[0] & keyof T[1]
 					: keyof T[0] & keyof T[1] & CommonPropKeys<Tail<Tail<T>>>
-				)
-			))
 	}
 >
 
 export namespace CommonPropKeys {
-	export interface Options extends $Never.$Options {
-	}
+	export interface Options extends $Never.$Options {}
 
-	export interface DefaultOptions extends $Never.$Default {
-	}
+	export interface DefaultOptions extends $Never.$Default {}
 }