type-plus 8.0.0-beta.6 → 8.0.0-beta.7

package/src/any/is_any.ts

@@ -1,13 +1,13 @@
-import type { $Never } from '../never/never.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $InputOptions } from '../type_plus/branch/$input_options.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js'
-import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
-import type { $Unknown } from '../unknown/unknown.js'
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
 
 /**
- * 🎭 *predicate*
+ * 🎭 **predicate**
  *
  * Validate if `T` is `any`.
  *
@@ -20,40 +20,43 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = IsAny<string | boolean> // false
  * ```
  *
- * 🔢 *customize*
+ * 🌪️ **filter**
  *
  * Filter to ensure `T` is `any`.
  *
  * @example
  * ```ts
  * type R = IsAny<any, { selection: 'filter' }> // any
- *
  * type R = IsAny<never, { selection: 'filter' }> // never
  * type R = IsAny<unknown, { selection: 'filter' }> // never
  * type R = IsAny<string | boolean, { selection: 'filter' }> // never
  * ```
  *
- * 🔢 *customize*
+ * 🔱 **branching**
  *
  * Use unique branch identifiers to allow precise processing of the result.
  *
  * @example
  * ```ts
- * type R = IsAny<any, $SelectionBranch> // $Then
- * type R = IsAny<string, $SelectionBranch> // $Else
+ * type R = IsAny<any, $Selection.Branch> // $Then
+ * type R = IsAny<string, $Selection.Branch> // $Else
+ * type R = IsAny<unknown, IsAny.$Branch> // $Unknown
+ * type R = IsAny<never, IsAny.$Branch> // $Never
+ * type R = IsAny<void, IsAny.$Branch> // $Void
  * ```
  */
-export type IsAny<T, $O extends IsAny.$Options = {}> = $SpecialType<
+export type IsAny<T, $O extends IsAny.$Options = {}> = $Special<
 	T,
 	{
-		$any: $ResolveBranch<T, $O, [$Then]>
-		$unknown: $ResolveBranch<T, $O, [$Unknown, $Else]>
-		$never: $ResolveBranch<T, $O, [$Never, $Else]>
-		$else: $ResolveBranch<T, $O, [$Else]>
+		$any: $ResolveBranch<$O, [$Then], T>
+		$unknown: $ResolveBranch<$O, [$Unknown, $Else]>
+		$never: $ResolveBranch<$O, [$Never, $Else]>
+		$void: $ResolveBranch<$O, [$Void, $Else]>
+		$else: $ResolveBranch<$O, [$Else]>
 	}
 >
 
 export namespace IsAny {
-	export type $Options = $SelectionOptions & $InputOptions<$Unknown | $Never>
-	export type $Branch = $SelectionBranch
+	export type $Options = $Selection.Options & $InputOptions<$Unknown | $Never | $Void>
+	export type $Branch = $Selection.Branch & $Unknown.$Branch & $Never.$Branch & $Void.$Branch
 }

package/src/any/is_not_any.ts

@@ -1,10 +1,10 @@
-import type { $Never } from '../never/never.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $InputOptions } from '../type_plus/branch/$input_options.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js'
-import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
-import type { $Unknown } from '../unknown/unknown.js'
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
 
 /**
  * 🎭 *predicate*
@@ -43,17 +43,18 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = IsNotAny<string, $SelectionBranch> // $Then
  * ```
  */
-export type IsNotAny<T, $O extends IsNotAny.$Options = {}> = $SpecialType<
+export type IsNotAny<T, $O extends IsNotAny.$Options = {}> = $Special<
 	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<$O, [$Else]>
+		$never: $ResolveBranch<$O, [$Never, $Then], T>
+		$unknown: $ResolveBranch<$O, [$Unknown, $Then], T>
+		$void: $ResolveBranch<$O, [$Void, $Then], T>
+		$else: $ResolveBranch<$O, [$Then], T>
 	}
 >
 
 export namespace IsNotAny {
-	export type $Options = $SelectionOptions & $InputOptions<$Unknown | $Never>
-	export type $Branch = $SelectionBranch
+	export type $Options = $Selection.Options & $InputOptions<$Unknown | $Never | $Void>
+	export type $Branch = $Selection.Branch & $Unknown.$Branch & $Never.$Branch & $Void.$Branch
 }

package/src/any/readme.md

@@ -1,16 +1,25 @@
-# Any
+# `any`
 
-`any` is one of the two top types in TypeScript.
-It is a supertype of all types.
+The `any` type is one of the two top types in TypeScript.
+It is a super-type of all types.
 It is a way to opt-out of type checking and let the values pass through compile-time checks.
 
-## [IsAny](./is_any.ts)
+## [`IsAny`](./is_any.ts)
 
-`IsAny<T, $O = { selection: 'predicate' | 'filter', $then: true, $else: false }>`
+```ts
+IsAny<T, $O = {
+	selection: 'predicate' | 'filter' = 'predicate',
+	$then: unknown = true,
+	$else: unknown = false,
+	$unknown: unknown,
+	$never: unknown,
+	$void: unknown
+}>
+```
 
-🎭 *predicate*
+🎭 **predicate**
 
-Validate if `T` is exactly `any`.
+Validate if `T` is `any`.
 
 ```ts
 type R = IsAny<any> // true
@@ -20,32 +29,34 @@ type R = IsAny<unknown> // false
 type R = IsAny<string | boolean> // false
 ```
 
-🔢 *customize*
+🌪️ **filter**
 
-Filter to ensure `T` is exactly `any`.
+Filter to ensure `T` is `any`.
 
 ```ts
 type R = IsAny<any, { selection: 'filter' }> // any
-
 type R = IsAny<never, { selection: 'filter' }> // never
 type R = IsAny<unknown, { selection: 'filter' }> // never
 type R = IsAny<string | boolean, { selection: 'filter' }> // never
 ```
 
-🔢 *customize*
+🔱 **branching**
 
 Use unique branch identifiers to allow precise processing of the result.
 
 ```ts
-type R = IsAny<any, $SelectionBranch> // $Then
-type R = IsAny<string, $SelectionBranch> // $Else
+type R = IsAny<any, $Selection.Branch> // $Then
+type R = IsAny<string, $Selection.Branch> // $Else
+type R = IsAny<unknown, IsAny.$Branch> // $Unknown
+type R = IsAny<never, IsAny.$Branch> // $Never
+type R = IsAny<void, IsAny.$Branch> // $Void
 ```
 
-### [IsNotAny](./is_not_any.ts)
+### [`IsNotAny`](./is_not_any.ts)
 
 `IsNotAny<T, $O = { selection: 'predicate' | 'filter', $then: true, $else: false }>`
 
-🎭 *predicate*
+🎭 **predicate**
 
 Validate if `T` is not exactly `any`.
 
@@ -57,7 +68,7 @@ type R = IsNotAny<unknown> // true
 type R = IsNotAny<string | boolean> // true
 ```
 
-🔢 *customize*
+🌪️ **filter**
 
 Filter to ensure `T` is not exactly `any`.
 
@@ -69,7 +80,7 @@ type R = IsNotAny<unknown, { selection: 'filter' }> // unknown
 type R = IsNotAny<string | boolean, { selection: 'filter' }> // string | boolean
 ```
 
-🔢 *customize*
+🔱 **branching**
 
 Use unique branch identifiers to allow precise processing of the result.
 
@@ -85,8 +96,8 @@ type R = IsNotAny<string, $SelectionBranch> // $Then
 Well, yeah:
 
 ```ts
-type A = any extends unknown ? 1 : 2 // 1
-type B = unknown extends any ? 1 : 2 // 1
+type A = any extends unknown ? true : false // true
+type B = unknown extends any ? true : false // true
 ```
 
 > Aren't using `any` is bad?

package/src/array/array.some.ts

@@ -1,4 +1,4 @@
-import type { IsEqual } from '../equal/equal.js'
+import type { IsEqual } from '../equal/is_equal.js'
 import type { CanAssign } from '../index.js'
 import type { Tail } from '../tuple/tail.js'
 import type { UnionOfValues } from './union_of_values.js'

package/src/array/array_plus.common_prop_keys.ts

@@ -1,5 +1,5 @@
+import type { $Never } from '../$type/special/$never.js'
 import type { IsNever } from '../never/is_never.js'
-import type { $Never } from '../never/never.js'
 import type { KeyTypes } from '../object/KeyTypes.js'
 
 /**

package/src/array/array_plus.filter.ts

@@ -5,9 +5,9 @@
 //  */
 // export type Filter<A extends readonly unknown[], Criteria = true> = Filter._<A, Criteria, []>
 
-import type { IsEqual } from '../equal/equal.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { IsEqual } from '../equal/is_equal.js'
 import type { IsNever } from '../never/is_never.js'
-import type { $Never } from '../never/never.js'
 import type { TypePlusOptions } from '../utils/options.js'
 
 /**

package/src/array/array_plus.find.ts

@@ -1,6 +1,6 @@
-import type { $Never } from '../never/never.js'
+import type { $ResolveOptions } from '../$type/$resolve_options.js'
+import type { $Never } from '../$type/special/$never.js'
 import type { IsTuple } from '../tuple/is_tuple.js'
-import type { $ResolveOptions } from '../type_plus/$resolve_options.js'
 import type { ElementMatch } from './array_plus.element_match.js'
 
 /**

package/src/array/array_plus.index_at.ts

@@ -1,5 +1,5 @@
 import type { IsAny } from '../any/is_any.js'
-import type { IsEqual } from '../equal/equal.js'
+import type { IsEqual } from '../equal/is_equal.js'
 import type { Abs } from '../math/abs.js'
 import type { GreaterThan } from '../math/greater_than.js'
 import type { Subtract } from '../math/subtract.js'
@@ -7,7 +7,6 @@ import type { IsNever } from '../never/is_never.js'
 import type { IsNumber } from '../number/is_number.js'
 import type { IsInteger } from '../numeric/is_integer.js'
 import type { IsNegative } from '../numeric/is_negative.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * 🦴 *utilities*
@@ -29,13 +28,13 @@ export type IndexAt<
 	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
+> = IsNever<
+	A,
+	{
+		$then: Fail
+		$else: IndexAt._<A, N, Fail, Upper, Lower>
+	}
+>
 
 export namespace IndexAt {
 	export type _<A extends readonly unknown[], N extends number, Fail = never, Upper = A['length'], Lower = 0> = IsEqual<
@@ -45,31 +44,26 @@ export namespace IndexAt {
 		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'],
+					{
+						exact: true
+						$then: N
+						$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
+							}
+						>
+					}
+				>
 				// 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
+						$else: IsNumber<N, { exact: true; $then: N; $else: never }>
 					}
 				>
 			}

package/src/array/array_plus.is_readonly.ts

@@ -1,6 +1,6 @@
+import type { $Selection } from '../$type/branch/$selection.js'
+import type { $Never } from '../$type/special/$never.js'
 import type { IsNever } from '../never/is_never.js'
-import type { $Never } from '../never/never.js'
-import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
 import type { TypePlusOptions } from '../utils/options.js'
 import type { LooseArrayType } from './loose_array_type.js'
 
@@ -35,7 +35,7 @@ export type IsReadonly<A, $Options extends IsReadonly.Options = IsReadonly.Defau
 	: never
 
 export namespace IsReadonly {
-	export interface Options extends $Never.$Options, $SelectionOptions, TypePlusOptions.NotArray {}
+	export interface Options extends $Never.$Options, $Selection.Options, TypePlusOptions.NotArray {}
 
 	export interface DefaultOptions {
 		$then: true

package/src/array/head.ts

@@ -1,6 +1,6 @@
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Never } from '../$type/special/$never.js'
 import type { IsNever } from '../never/is_never.js'
-import type { $Never } from '../never/never.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * 🦴 *utilities*
@@ -24,7 +24,7 @@ import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$select
  */
 export type Head<T extends readonly unknown[], Options extends Head.Options = Head.DefaultOptions> = IsNever<
 	T,
-	$SelectionBranch
+	$Selection.Branch
 > extends infer R
 	? R extends $Then
 		? Options['$never']

package/src/array/is_array.ts

@@ -1,11 +1,15 @@
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Distributive } from '../$type/distributive/$distributive.js'
+import type { $Exact } from '../$type/exact/$exact.js'
+import type { $Any } from '../$type/special/$any.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
+import type { $MergeOptions } from '../$type/utils/$merge_options.js'
 import type { Assignable } from '../predicates/assignable.js'
-import type { $Equality } from '../type_plus/$equality.js'
-import type { $MergeOptions } from '../type_plus/$merge_options.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $ExactOptions, $IsExact } from '../type_plus/branch/$exact.js'
-import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * 🎭 *predicate*
@@ -60,20 +64,23 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsArray<number, IsArray.$Branch> // $Else
  * ```
  */
-export type IsArray<T, $O extends IsArray.$Options = {}> = $SpecialType<
+export type IsArray<T, $O extends IsArray.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Else]>
+			$then: $ResolveBranch<$O, [$Else]>
 			$else: IsArray.$<T, $O>
 		}
 	>
 >
 
 export namespace IsArray {
-	export type $Options = $Equality.$Options & $ExactOptions
-	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+	export type $Options = $Selection.Options &
+		$Distributive.Options &
+		$Exact.Options &
+		$InputOptions<$Any | $Unknown | $Never | $Void>
+	export type $Branch<$O extends $Options = {}> = $Selection.Branch<$O>
 
 	/**
 	 * 🧰 *type util*
@@ -83,33 +90,33 @@ export namespace IsArray {
 	 * This is a type util for building custom types.
 	 * It does not check against special types.
 	 */
-	export type $<T, $O extends $UtilOptions> = $IsExact<
+	export type $<T, $O extends $UtilOptions> = $Exact.Parse<
 		$O,
 		{
-			$then: $IsDistributive<
+			$then: $Distributive.Parse<
 				$O,
 				{
 					$then: T extends readonly any[]
 						? number extends T['length']
-							? $ResolveBranch<T, $O, [$Then]>
-							: $ResolveBranch<T, $O, [$Else]>
-						: $ResolveBranch<T, $O, [$Else]>
+							? $ResolveBranch<$O, [$Then], T>
+							: $ResolveBranch<$O, [$Else]>
+						: $ResolveBranch<$O, [$Else]>
 					$else: [T] extends [readonly any[]]
 						? number extends T['length']
-							? $ResolveBranch<T, $O, [$Then]>
-							: $ResolveBranch<T, $O, [$Else]>
-						: $ResolveBranch<T, $O, [$Else]>
+							? $ResolveBranch<$O, [$Then], T>
+							: $ResolveBranch<$O, [$Else]>
+						: $ResolveBranch<$O, [$Else]>
 				}
 			>
-			$else: $IsDistributive<
+			$else: $Distributive.Parse<
 				$O,
 				{
-					$then: T extends readonly any[] ? $ResolveBranch<T, $O, [$Then]> : $ResolveBranch<T, $O, [$Else]>
-					$else: [T] extends readonly [any[]] ? $ResolveBranch<T, $O, [$Then]> : $ResolveBranch<T, $O, [$Else]>
+					$then: T extends readonly any[] ? $ResolveBranch<$O, [$Then], T> : $ResolveBranch<$O, [$Else]>
+					$else: [T] extends readonly [any[]] ? $ResolveBranch<$O, [$Then], T> : $ResolveBranch<$O, [$Else]>
 				}
 			>
 		}
 	>
 
-	export type $UtilOptions = Assignable.$UtilOptions & $ExactOptions
+	export type $UtilOptions = Assignable.$UtilOptions & $Exact.Options
 }

package/src/array/is_not_array.ts

@@ -1,11 +1,15 @@
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Distributive } from '../$type/distributive/$distributive.js'
+import type { $Exact } from '../$type/exact/$exact.js'
+import type { $Any } from '../$type/special/$any.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
+import type { $MergeOptions } from '../$type/utils/$merge_options.js'
 import type { NotAssignable } from '../predicates/not_assignable.js'
-import type { $Equality } from '../type_plus/$equality.js'
-import type { $MergeOptions } from '../type_plus/$merge_options.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $ExactOptions, $IsExact } from '../type_plus/branch/$exact.js'
-import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * 🎭 *predicate*
@@ -60,19 +64,22 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsNotArray<number, IsNotArray.$Branch> // $Then
  * ```
  */
-export type IsNotArray<T, $O extends IsNotArray.$Options = {}> = $SpecialType<
+export type IsNotArray<T, $O extends IsNotArray.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Then]>
+			$then: $ResolveBranch<$O, [$Then], T>
 			$else: IsNotArray.$<T, $O>
 		}
 	>
 >
 export namespace IsNotArray {
-	export type $Options = $Equality.$Options & $ExactOptions
-	export type $Branch<$O extends $Options = {}> = $Equality.$Branch<$O>
+	export type $Options = $Selection.Options &
+		$Distributive.Options &
+		$Exact.Options &
+		$InputOptions<$Any | $Unknown | $Never | $Void>
+	export type $Branch<$O extends $Options = {}> = $Selection.Branch<$O>
 
 	/**
 	 * 🧰 *type util*
@@ -82,33 +89,33 @@ export namespace IsNotArray {
 	 * This is a type util for building custom types.
 	 * It does not check against special types.
 	 */
-	export type $<T, $O extends $UtilOptions> = $IsExact<
+	export type $<T, $O extends $UtilOptions> = $Exact.Parse<
 		$O,
 		{
-			$then: $IsDistributive<
+			$then: $Distributive.Parse<
 				$O,
 				{
 					$then: T extends readonly any[]
 						? number extends T['length']
-							? $ResolveBranch<T, $O, [$Else]>
-							: $ResolveBranch<T, $O, [$Then]>
-						: $ResolveBranch<T, $O, [$Then]>
+							? $ResolveBranch<$O, [$Else]>
+							: $ResolveBranch<$O, [$Then], T>
+						: $ResolveBranch<$O, [$Then], T>
 					$else: [T] extends [readonly any[]]
 						? number extends T['length']
-							? $ResolveBranch<T, $O, [$Else]>
-							: $ResolveBranch<T, $O, [$Then]>
-						: $ResolveBranch<T, $O, [$Then]>
+							? $ResolveBranch<$O, [$Else]>
+							: $ResolveBranch<$O, [$Then], T>
+						: $ResolveBranch<$O, [$Then], T>
 				}
 			>
-			$else: $IsDistributive<
+			$else: $Distributive.Parse<
 				$O,
 				{
-					$then: T extends readonly any[] ? $ResolveBranch<T, $O, [$Else]> : $ResolveBranch<T, $O, [$Then]>
-					$else: [T] extends readonly [any[]] ? $ResolveBranch<T, $O, [$Else]> : $ResolveBranch<T, $O, [$Then]>
+					$then: T extends readonly any[] ? $ResolveBranch<$O, [$Else]> : $ResolveBranch<$O, [$Then], T>
+					$else: [T] extends readonly [any[]] ? $ResolveBranch<$O, [$Else]> : $ResolveBranch<$O, [$Then], T>
 				}
 			>
 		}
 	>
 
-	export type $UtilOptions = NotAssignable.$UtilOptions & $ExactOptions
+	export type $UtilOptions = NotAssignable.$UtilOptions & $Exact.Options
 }

package/src/array/last.ts

@@ -1,6 +1,5 @@
+import type { $Never } from '../$type/special/$never.js'
 import type { IsNever } from '../never/is_never.js'
-import type { $Never } from '../never/never.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * 🦴 *utilities*
@@ -23,18 +22,11 @@ import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$select
  */
 export type Last<T extends readonly unknown[], Options extends Last.Options = Last.DefaultOptions> = IsNever<
 	T,
-	$SelectionBranch
-> extends infer R
-	? R extends $Then
-		? Options['$never']
-		: R extends $Else
-			? T['length'] extends 0
-				? Options['caseEmptyTuple']
-				: T extends readonly [...unknown[], infer R]
-					? R
-					: T[0]
-			: never
-	: never
+	{
+		$then: Options['$never']
+		$else: T['length'] extends 0 ? Options['caseEmptyTuple'] : T extends readonly [...unknown[], infer R] ? R : T[0]
+	}
+>
 
 export namespace Last {
 	export interface Options extends $Never.$Options {

package/src/array/readme.md

@@ -1,10 +1,10 @@
 # Array
 
-In TypeScript, the type of an JavaScript array can be an [array](#array) or a [tuple](../tuple/readme.md).
+In TypeScript, the type of JavaScript array can be an [array](#array) or a [tuple](../tuple/readme.md).
 
 `Array<T>` or `T[]` is a type that represents an array of `T`
 
-There is no length limitation to an `Array`,
+There is no length limitation to a `Array`,
 and each element has the same type `T`.
 
 ## Type Checking
@@ -14,7 +14,7 @@ The `ArrayType<T>` and friends are used to check if a type is exactly `Array<T>`
 They are strict type checks, meaning they match only the type `Array<T>`,
 and not [tuple], [union], or intersection types.
 
-### [ArrayType](./array_type.ts#l18)
+### [`ArrayType`](./array_type.ts#l18)
 
 `ArrayType<T, Then = T, Else = never>`
 

package/src/assertion/assert_type.ts

@@ -1,5 +1,5 @@
 import { tersify } from 'tersify'
-import { isConstructor, type AnyConstructor } from '../class/index.js'
+import { type AnyConstructor, isConstructor } from '../class/index.js'
 import type { AnyFunction } from '../function/any_function.js'
 
 /**