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

package/src/any/is_not_any.ts

@@ -43,15 +43,15 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = IsNotAny<string, $SelectionBranch> // $Then
  * ```
  */
-export type IsNotAny<
+export type IsNotAny<T, $O extends IsNotAny.$Options = {}> = $SpecialType<
 	T,
-	$O extends IsNotAny.$Options = {}
-> = $SpecialType<T, {
-	$any: $ResolveBranch<T, $O, [$Else]>,
-	$unknown: $ResolveBranch<T, $O, [$Unknown, $Then]>,
-	$never: $ResolveBranch<T, $O, [$Never, $Then]>,
-	$else: $ResolveBranch<T, $O, [$Then]>
-}>
+	{
+		$any: $ResolveBranch<T, $O, [$Else]>
+		$unknown: $ResolveBranch<T, $O, [$Unknown, $Then]>
+		$never: $ResolveBranch<T, $O, [$Never, $Then]>
+		$else: $ResolveBranch<T, $O, [$Then]>
+	}
+>
 
 export namespace IsNotAny {
 	export type $Options = $SelectionOptions & $InputOptions<$Unknown | $Never>

package/src/array/array.at.ts

@@ -17,24 +17,27 @@ import type { IndexAt } from './array_plus.index_at.js'
  * type R = At<[1, 2, 3], -1> // 3
  * ```
  */
-export type At<A extends readonly unknown[], N extends number, Fail = never> =
-	IndexAt<
-		A,
-		N,
-		Fail,
-		Fail,
-		Fail
-	> extends infer I
+export type At<A extends readonly unknown[], N extends number, Fail = never> = IndexAt<
+	A,
+	N,
+	Fail,
+	Fail,
+	Fail
+> extends infer I
 	? I extends number
-	? IsTuple.$<
-		A,
-		{
-			$then: IsNumber.$<I, {
-				exact: true,
-				$then: A[I] | undefined,
-				$else: A[I]
-			}>,
-			$else: A[I] | undefined
-		}>
-	: Fail
+		? IsTuple.$<
+				A,
+				{
+					$then: IsNumber.$<
+						I,
+						{
+							exact: true
+							$then: A[I] | undefined
+							$else: A[I]
+						}
+					>
+					$else: A[I] | undefined
+				}
+			>
+		: Fail
 	: never

package/src/array/array.entries.ts

@@ -14,7 +14,7 @@ import type { IsTuple } from '../tuple/is_tuple.js'
 export type Entries<A extends readonly unknown[]> = IsTuple<
 	A,
 	{
-		$then: Entries.Device<A, []>,
+		$then: Entries.Device<A, []>
 		$else: A extends Array<infer T> ? Array<[number, T]> : never
 	}
 >
@@ -22,7 +22,7 @@ export type Entries<A extends readonly unknown[]> = IsTuple<
 export namespace Entries {
 	export type Device<A extends readonly unknown[], R extends unknown[]> = A['length'] extends 0
 		? R
-		: (A extends readonly [...infer F, infer N]
+		: A extends readonly [...infer F, infer N]
 			? Device<F, [[F['length'], N], ...R]>
-			: never)
+			: never
 }

package/src/array/array.find_last.ts

@@ -20,12 +20,12 @@ export type FindLast<A extends readonly unknown[], Criteria> = IsTuple<
 	A,
 	{
 		$then: A['length'] extends 0
-		? never
-		: (A extends readonly [...infer Heads, infer Last]
-			? (Last extends Criteria
-				? Last
-				: FindLast<Heads, Criteria>)
-			: never),
+			? never
+			: A extends readonly [...infer Heads, infer Last]
+				? Last extends Criteria
+					? Last
+					: FindLast<Heads, Criteria>
+				: never
 		$else: A extends Readonly<Array<infer T>> ? (T extends Criteria ? T | undefined : never) : never
 	}
 >

package/src/array/array.reverse.ts

@@ -14,12 +14,13 @@ import type { IsReadonly } from './array_plus.is_readonly.js'
  * @returns The reversed array type.
  */
 export type Reverse<A extends readonly unknown[]> = Reverse._<A> extends infer R
-	? IsReadonly<A> extends true ? Readonly<R> : R
+	? IsReadonly<A> extends true
+		? Readonly<R>
+		: R
 	: never
 
 export namespace Reverse {
 	export type _<A extends readonly unknown[]> = A extends readonly [infer First, ...infer Rest]
 		? [..._<Rest>, First]
 		: A
-
 }

package/src/array/array.some.ts

@@ -27,7 +27,7 @@ export type Some<
 	Criteria,
 	Mode extends 'strict' | 'loose' = 'loose',
 	Then = true,
-	Else = false
+	Else = false,
 > = Mode extends 'strict' ? Some.Strict<A, Criteria, Then, Else> : Some.Loose<A, Criteria, Then, Else>
 
 export namespace Some {
@@ -44,9 +44,9 @@ export namespace Some {
 
 	export type StrictTuple<A extends readonly unknown[], Criteria, Then, Else> = A['length'] extends 0
 		? Else
-		: (IsEqual<A[0], Criteria> extends true
+		: IsEqual<A[0], Criteria> extends true
 			? Then
-			: StrictTuple<Tail<A>, Criteria, Then, Else>)
+			: StrictTuple<Tail<A>, Criteria, Then, Else>
 
 	export type Loose<A extends readonly unknown[], Criteria, Then, Else> = number extends A['length']
 		? LooseArray<A, Criteria, Then, Else>
@@ -61,7 +61,7 @@ export namespace Some {
 
 	export type LooseTuple<A extends readonly unknown[], Criteria, Then, Else> = A['length'] extends 0
 		? Else
-		: (A[0] extends Criteria
+		: A[0] extends Criteria
 			? Then
-			: LooseTuple<Tail<A>, Criteria, Then, Else>)
+			: LooseTuple<Tail<A>, Criteria, Then, Else>
 }

package/src/array/array_plus.common_prop_keys.ts

@@ -21,18 +21,17 @@ import type { KeyTypes } from '../object/KeyTypes.js'
  */
 export type CommonPropKeys<
 	A extends readonly Record<KeyTypes, unknown>[],
-	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions
-> = IsNever<A,
+	Options extends CommonPropKeys.Options = CommonPropKeys.DefaultOptions,
+> = IsNever<
+	A,
 	{
-		$then: Options['$never'],
+		$then: Options['$never']
 		$else: A extends Readonly<Array<infer R extends Record<KeyTypes, unknown>>> ? keyof R : never
 	}
 >
 
 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 {}
 }

package/src/array/array_plus.drop_match.ts

@@ -3,14 +3,14 @@
  */
 export type DropMatch<A extends Readonly<Array<unknown>>, Criteria> = A[0] extends Criteria
 	? never[]
-	: (undefined extends Criteria
-		? (null extends Criteria
+	: undefined extends Criteria
+		? null extends Criteria
 			? Array<NonNullable<A[0]>>
-			: Array<Exclude<A[0], undefined>>)
-		: (null extends Criteria
+			: Array<Exclude<A[0], undefined>>
+		: null extends Criteria
 			? Array<Exclude<A[0], null>>
-			: (Criteria extends A[0]
+			: Criteria extends A[0]
 				? Array<Exclude<A[0], Criteria>>
-				: (A[0] extends Criteria
+				: A[0] extends Criteria
 					? A
-					: Array<Exclude<A[0], Criteria>>))))
+					: Array<Exclude<A[0], Criteria>>

package/src/array/array_plus.element_match.ts

@@ -27,35 +27,38 @@ import type { TypePlusOptions } from '../utils/options.js'
  * Since it is a union, the result will be joined to the matched branch as union.
  * e.g. `ElementMatch<1 | 2, 1>` -> `1 | undefined`
  */
-export type ElementMatch<
+export type ElementMatch<T, Criteria, Options extends ElementMatch.Options = ElementMatch.DefaultOptions<Criteria>> = [
 	T,
-	Criteria,
-	Options extends ElementMatch.Options = ElementMatch.DefaultOptions<Criteria>
-> = [T] extends [Criteria]
+] extends [Criteria]
 	? T
-	: (TypePlusOptions.Merge<Options, ElementMatch.DefaultOptions<Criteria>> extends infer C extends Record<keyof ElementMatch.Options, unknown>
-		? ((T extends Criteria
-			? T
-			: (C['widen'] extends true
-				? (Criteria extends T
-					? C['$widen']
-					: C['$notMatch'])
-				: C['$notMatch'])) extends infer R
-			? IsUnion<T, IsNever<R, { $then: R, $else: R | C['$unionNotMatch'] }>, R>
-			: C['$notMatch'])
-		: never)
+	: TypePlusOptions.Merge<Options, ElementMatch.DefaultOptions<Criteria>> extends infer C extends Record<
+				keyof ElementMatch.Options,
+				unknown
+			>
+		? (
+				T extends Criteria
+					? T
+					: C['widen'] extends true
+						? Criteria extends T
+							? C['$widen']
+							: C['$notMatch']
+						: C['$notMatch']
+			) extends infer R
+			? IsUnion<T, IsNever<R, { $then: R; $else: R | C['$unionNotMatch'] }>, R>
+			: C['$notMatch']
+		: never
 
 export namespace ElementMatch {
 	export interface Options {
-		widen?: boolean | undefined,
-		$notMatch?: unknown,
-		$widen?: unknown,
+		widen?: boolean | undefined
+		$notMatch?: unknown
+		$widen?: unknown
 		$unionNotMatch?: unknown
 	}
 	export interface DefaultOptions<Criteria> {
-		widen: true,
-		$notMatch: never,
-		$widen: Criteria | undefined,
+		widen: true
+		$notMatch: never
+		$widen: Criteria | undefined
 		$unionNotMatch: never
 	}
 }

package/src/array/array_plus.filter.ts

@@ -24,29 +24,28 @@ import type { TypePlusOptions } from '../utils/options.js'
 export type Filter<
 	A extends readonly unknown[],
 	Criteria = true,
-	Options extends Filter.Options = Filter.DefaultOptions
+	Options extends Filter.Options = Filter.DefaultOptions,
 > = TypePlusOptions.Merge<Options, Filter.DefaultOptions> extends infer O extends Filter.Options
-	? (IsNever<
-		A,
-		{
-			$then: O['$never'],
-			$else: (A[0] extends Criteria
-				? A
-				: Criteria extends A[0] ? Array<Criteria> : O['$notArray'])
-		}>)
+	? IsNever<
+			A,
+			{
+				$then: O['$never']
+				$else: A[0] extends Criteria ? A : Criteria extends A[0] ? Array<Criteria> : O['$notArray']
+			}
+		>
 	: never
 
 export namespace Filter {
-	export interface Options extends TypePlusOptions.NotArray, $Never.$Options { }
+	export interface Options extends TypePlusOptions.NotArray, $Never.$Options {}
 
 	export interface DefaultOptions {
-		$never: never,
+		$never: never
 		$notArray: never[]
 	}
 
 	export type _<A extends readonly unknown[], Criteria, Result extends unknown[]> = A['length'] extends 0
 		? Result
-		: (A extends [infer H, ...infer Rest]
+		: A extends [infer H, ...infer Rest]
 			? IsEqual<H, Criteria, _<Rest, Criteria, [...Result, H]>, _<Rest, Criteria, Result>>
-			: never)
+			: never
 }

package/src/array/array_plus.find.ts

@@ -49,23 +49,21 @@ import type { ElementMatch } from './array_plus.element_match.js'
 export type Find<
 	A extends readonly unknown[],
 	Criteria,
-	Options extends Find.Options = Find.DefaultOptions<Criteria>
-> =
-	IsTuple<A, {
-		$then: $ResolveOptions<[Options['$tuple'], Find.DefaultOptions<Criteria>['$tuple']]>,
-		$else: (
-			A extends Readonly<Array<infer T>>
-			? ElementMatch<T, Criteria, Options>
-			: never
-		)
-	}>
+	Options extends Find.Options = Find.DefaultOptions<Criteria>,
+> = IsTuple<
+	A,
+	{
+		$then: $ResolveOptions<[Options['$tuple'], Find.DefaultOptions<Criteria>['$tuple']]>
+		$else: A extends Readonly<Array<infer T>> ? ElementMatch<T, Criteria, Options> : never
+	}
+>
 
 export namespace Find {
 	export interface Options extends ElementMatch.Options, $Never.$Options {
-		$tuple?: unknown,
+		$tuple?: unknown
 	}
 
 	export interface DefaultOptions<Criteria> extends ElementMatch.DefaultOptions<Criteria>, $Never.$Default {
-		$tuple: 'does not support tuple. Please use `FindFirst` or `TuplePlus.Find` instead.',
+		$tuple: 'does not support tuple. Please use `FindFirst` or `TuplePlus.Find` instead.'
 	}
 }

package/src/array/array_plus.index_at.ts

@@ -28,53 +28,48 @@ export type IndexAt<
 	N extends number,
 	Fail = never,
 	Upper = A['length'],
-	Lower = 0
-> = IsNever<
-	A,
-	$SelectionBranch> extends infer R
-	? R extends $Then ? Fail
-	: R extends $Else ? IndexAt._<A, N, Fail, Upper, Lower>
-	: never : never
+	Lower = 0,
+> = IsNever<A, $SelectionBranch> extends infer R
+	? R extends $Then
+		? Fail
+		: R extends $Else
+			? IndexAt._<A, N, Fail, Upper, Lower>
+			: never
+	: never
 
 export namespace IndexAt {
-	export type _<
-		A extends readonly unknown[],
-		N extends number,
-		Fail = never,
-		Upper = A['length'],
-		Lower = 0
-	> = IsEqual<
+	export type _<A extends readonly unknown[], N extends number, Fail = never, Upper = A['length'], Lower = 0> = IsEqual<
 		A['length'],
 		0,
 		Fail,
 		IsInteger<
 			N,
 			{
-				$then: IsNumber<
-					A['length'],
-					IsNumber.$Branch<{ exact: true }>
-				> extends infer R
-				// A: array
-				? R extends $Then ? N
-				// A: tuple
-				: R extends $Else ? IsNegative<
-					N,
-					{
-						$then: GreaterThan<Abs<N>, A['length']> extends true ? Lower : Subtract<A['length'], Abs<N>>,
-						$else: GreaterThan<A['length'], N> extends true ? N : Upper
-					}
-				>
-				: never : never,
+				$then: IsNumber<A['length'], IsNumber.$Branch<{ exact: true }>> extends infer R
+					? // A: array
+						R extends $Then
+						? N
+						: // A: tuple
+							R extends $Else
+							? IsNegative<
+									N,
+									{
+										$then: GreaterThan<Abs<N>, A['length']> extends true ? Lower : Subtract<A['length'], Abs<N>>
+										$else: GreaterThan<A['length'], N> extends true ? N : Upper
+									}
+								>
+							: never
+					: never
 				// N: number or float
 				$else: IsAny<
 					N,
 					{
-						$then: number,
-						$else: IsNumber<
-							N,
-							IsNumber.$Branch<{ exact: true }>
-						> extends infer R
-						? R extends $Then ? N : never : never
+						$then: number
+						$else: IsNumber<N, IsNumber.$Branch<{ exact: true }>> extends infer R
+							? R extends $Then
+								? N
+								: never
+							: never
 					}
 				>
 			}
@@ -82,7 +77,6 @@ export namespace IndexAt {
 	>
 }
 
-
 // import type { IsAny } from '../any/is_any.js'
 // import type { IsEqual } from '../equal/equal.js'
 // import type { Abs } from '../math/abs.js'

package/src/array/array_plus.is_index_out_of_bound.ts

@@ -18,7 +18,7 @@ import type { IndexAt } from './array_plus.index_at.js'
 export type IsIndexOutOfBound<A extends readonly unknown[], N extends number, Then = true, Else = false> = IsNever<
 	IndexAt<A, N, never, never, never>,
 	{
-		$then: Then,
+		$then: Then
 		$else: Else
 	}
 >

package/src/array/array_plus.is_readonly.ts

@@ -19,32 +19,28 @@ import type { LooseArrayType } from './loose_array_type.js'
  * type R = IsReadonly<readonly string[] | number> // boolean
  * ```
  */
-export type IsReadonly<
-	A,
-	$Options extends IsReadonly.Options = IsReadonly.DefaultOptions
-> =
-	TypePlusOptions.Merge<$Options, IsReadonly.DefaultOptions> extends infer O extends IsReadonly.Options ?
-	IsNever<
-		A,
-		{
-			$then: O['$never'],
-			$else: A extends any ?
-			LooseArrayType<A,
-				Readonly<A> extends A ? O['$then'] : O['$else'],
-				O['$notArray']
-			> : never
-		}
-	>
+export type IsReadonly<A, $Options extends IsReadonly.Options = IsReadonly.DefaultOptions> = TypePlusOptions.Merge<
+	$Options,
+	IsReadonly.DefaultOptions
+> extends infer O extends IsReadonly.Options
+	? IsNever<
+			A,
+			{
+				$then: O['$never']
+				$else: A extends any
+					? LooseArrayType<A, Readonly<A> extends A ? O['$then'] : O['$else'], O['$notArray']>
+					: never
+			}
+		>
 	: never
 
 export namespace IsReadonly {
-	export interface Options
-		extends $Never.$Options, $SelectionOptions, TypePlusOptions.NotArray { }
+	export interface Options extends $Never.$Options, $SelectionOptions, TypePlusOptions.NotArray {}
 
 	export interface DefaultOptions {
-		$then: true,
-		$else: false,
-		$never: false,
+		$then: true
+		$else: false
+		$never: false
 		$notArray: false
 	}
 }

package/src/array/array_plus.pad_start.ts

@@ -2,12 +2,8 @@ import type { CanAssign } from '../index.js'
 import type { CreateTuple } from '../tuple/create_tuple.js'
 import type { UnionOfValues } from './union_of_values.js'
 
-export type PadStart<
-	A extends readonly unknown[],
-	MaxLength extends number,
-	PadWith = unknown
-> = MaxLength extends 0
+export type PadStart<A extends readonly unknown[], MaxLength extends number, PadWith = unknown> = MaxLength extends 0
 	? A
 	: CanAssign<PadWith, UnionOfValues<A>> extends true
-	? A
-	: PadStart<[...CreateTuple<MaxLength, PadWith>, ...A], MaxLength, PadWith>
+		? A
+		: PadStart<[...CreateTuple<MaxLength, PadWith>, ...A], MaxLength, PadWith>

package/src/array/array_plus.split_at.ts

@@ -31,12 +31,12 @@ export type SplitAt<
 	A extends readonly unknown[],
 	Index extends number,
 	DeleteCount extends number | never = never,
-	Insert extends readonly unknown[] | never = never
+	Insert extends readonly unknown[] | never = never,
 > = IsArray<
 	A,
 	{
-		exact: true,
-		$then: [A, A],
+		exact: true
+		$then: [A, A]
 		$else: SplitAt._<A, [], [], IndexAt._<A, Index>, DeleteCount, Insert>
 	}
 >
@@ -50,17 +50,18 @@ export namespace SplitAt {
 		DeleteCount,
 		Insert extends readonly unknown[],
 	> = 0 extends A['length']
-		? IsTuple<Insert, { $then: [[...Insert, ...B], C], $else: [B, C] }>
-		: (Index extends B['length']
+		? IsTuple<Insert, { $then: [[...Insert, ...B], C]; $else: [B, C] }>
+		: Index extends B['length']
 			? IsNever<
-				DeleteCount,
-				{
-					$then: [B, A],
-					$else: _D<A, B, C, DeleteCount, Insert>
-				}>
-			: (A extends readonly [infer Head, ...infer Tail]
+					DeleteCount,
+					{
+						$then: [B, A]
+						$else: _D<A, B, C, DeleteCount, Insert>
+					}
+				>
+			: A extends readonly [infer Head, ...infer Tail]
 				? _<Tail, [...B, Head], [], Index, DeleteCount, Insert>
-				: 'unexpected: A does not extends [Head, ...Tail]'))
+				: 'unexpected: A does not extends [Head, ...Tail]'
 
 	export type _D<
 		A extends readonly unknown[],
@@ -69,11 +70,8 @@ export namespace SplitAt {
 		DeleteCount,
 		Insert extends readonly unknown[],
 	> = DeleteCount extends C['length']
-		? IsTuple<Insert, { $then: [[...B, ...Insert, ...A], C], $else: [[...B, ...A], C] }>
-		: (A extends readonly [infer Head, ...infer Tail]
+		? IsTuple<Insert, { $then: [[...B, ...Insert, ...A], C]; $else: [[...B, ...A], C] }>
+		: A extends readonly [infer Head, ...infer Tail]
 			? _D<Tail, B, [...C, Head], DeleteCount, Insert>
-			: IsTuple<Insert, { $then: [[...Insert, ...B], C], $else: [B, C] }>
-		)
-
+			: IsTuple<Insert, { $then: [[...Insert, ...B], C]; $else: [B, C] }>
 }
-

package/src/array/find_first.ts

@@ -51,22 +51,23 @@ import type { Find as ArrayFind } from './array_plus.find.js'
  */
 export type FindFirst<
 	A extends readonly unknown[],
-	Criteria, Options extends FindFirst.Options = FindFirst.DefaultOptions<Criteria>
+	Criteria,
+	Options extends FindFirst.Options = FindFirst.DefaultOptions<Criteria>,
 > = IsTuple<
 	A,
 	{
-		$then: TupleFind<A, Criteria, Options>,
+		$then: TupleFind<A, Criteria, Options>
 		$else: ArrayFind<A, Criteria, Options>
 	}
 >
 
 export namespace FindFirst {
-	export interface Options extends ArrayFind.Options, TupleFind.Options { }
+	export interface Options extends ArrayFind.Options, TupleFind.Options {}
 	export interface DefaultOptions<Criteria>
-		extends ArrayFind.DefaultOptions<Criteria>, TupleFind.DefaultOptions<Criteria> { }
+		extends ArrayFind.DefaultOptions<Criteria>,
+			TupleFind.DefaultOptions<Criteria> {}
 }
 
-
 /**
  * @deprecated use FindFirst
  */

package/src/array/head.ts

@@ -22,17 +22,18 @@ import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$select
  * @typeParam Options['caseEmptyTuple'] Return type when `T` is `[]`.
  * Default to `never`.
  */
-export type Head<
-	T extends readonly unknown[],
-	Options extends Head.Options = Head.DefaultOptions
-> = IsNever<
+export type Head<T extends readonly unknown[], Options extends Head.Options = Head.DefaultOptions> = IsNever<
 	T,
 	$SelectionBranch
 > extends infer R
-	? R extends $Then ? Options['$never']
-	: R extends $Else ? T['length'] extends 0 ? Options['caseEmptyTuple'] : T[0]
-	: never : never
-
+	? R extends $Then
+		? Options['$never']
+		: R extends $Else
+			? T['length'] extends 0
+				? Options['caseEmptyTuple']
+				: T[0]
+			: never
+	: never
 
 export namespace Head {
 	export interface Options extends $Never.$Options {

package/src/array/intersect_of_props.ts

@@ -6,13 +6,13 @@ import type { Tail } from '../tuple/tail.js'
  *
  * Gets the intersect of properties of the elements in `A`.
  */
-export type IntersectOfProps<A extends readonly  Record<any, unknown>[], P extends KeyTypes> = number extends A['length']
+export type IntersectOfProps<A extends readonly Record<any, unknown>[], P extends KeyTypes> = number extends A['length']
 	? A[0][P]
 	: A['length'] extends 0
-	? never
-	: A['length'] extends 1
-	? A[0][P]
-	: A[0][P] & IntersectOfProps<Tail<A>, P>
+		? never
+		: A['length'] extends 1
+			? A[0][P]
+			: A[0][P] & IntersectOfProps<Tail<A>, P>
 
 /**
  * Gets the intersect of properties of the elements in `A`