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

package/src/equal/identity_equal.ts

@@ -1,11 +1,7 @@
+import type { Equal } from './equal.js'
+
 /**
  * This is a common equal check.
  * It is good for some basic cases, but not for all.
  */
-export type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2) extends <_>() => _ extends
-	| (B & _)
-	| _
-	? 1
-	: 2
-	? Then
-	: Else
+export type IdentityEqual<A, B, Then, Else> = Equal.$Same<A, B, { $then: Then; $else: Else }>

package/src/equal/is_equal.ts

@@ -0,0 +1,150 @@
+import type { IsAny } from '../any/is_any.js'
+import type { And, Or } from '../logical/logical.js'
+import type { IsNever } from '../never/is_never.js'
+import type { IsObject } from '../object/is_object.js'
+import type { Properties } from '../object/properties.js'
+import type { IsSymbol } from '../symbol/is_symbol.js'
+import type { IdentityEqual } from './identity_equal.js'
+
+type BothNever<A, B, Both, One, None> = And<
+	IsNever<A>,
+	IsNever<B>,
+	{
+		$then: Both
+		$else: Or<
+			IsNever<A>,
+			IsNever<B>,
+			{
+				$then: One
+				$else: None
+			}
+		>
+	}
+>
+
+type BothAny<A, B, Both, One, None> = And<
+	IsAny<A>,
+	IsAny<B>,
+	{
+		$then: Both
+		$else: Or<
+			IsAny<A>,
+			IsAny<B>,
+			{
+				$then: One
+				$else: None
+			}
+		>
+	}
+>
+
+/**
+ * Checks `A` and `B` are equal.
+ *
+ * ```ts
+ * type R = IsEqual<1, 1> // true
+ * type R = IsEqual<any, any> // true
+ * type R = IsEqual<boolean, boolean> // true
+ * type R = IsEqual<true, true> // true
+ * type R = IsEqual<[1], [1]> // true
+ *
+ * type R = IsEqual<boolean, true> // false
+ * type R = IsEqual<any, 1> // false
+ * type R = IsEqual<[any], [1]> // false
+ * type R = IsEqual<{ a: 1 }, { a: 1; b: 2 }> // false
+ * ```
+ *
+ * Note that intersection type checks only works at first level.
+ * It cannot be check recursively,
+ * or else will run into infinite recursion if the type includes recursive types.
+ *
+ * @deprecated 💀 **deprecated since 8.0.0**: use `Equal` instead.
+ */
+export type IsEqual<A, B, Then = true, Else = false> = [A, B] extends [B, A]
+	? BothNever<
+			A,
+			B,
+			Then,
+			Else,
+			BothAny<
+				A,
+				B,
+				Then,
+				Else,
+				IdentityEqual<
+					A,
+					B,
+					Then,
+					And<
+						IsObject<A>,
+						IsObject<B>,
+						{
+							$then: IdentityEqual<
+								Properties<A>,
+								Properties<B>,
+								[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
+									? IsEqual<P1, P2, Then, Else>
+									: Then,
+								Else
+							>
+							// `A` and `B` are narrowed, need to check again.
+							// This is fixed in TS 5.0.2, but keeping it to support older versions.
+							$else: [A, B] extends [B, A] ? Then : Else
+						}
+					>
+				>
+			>
+		>
+	: And<
+			IsSymbol<A, { distributive: false }>,
+			IsSymbol<B, { distributive: false }>,
+			{
+				$then: Then
+				$else: Else
+			}
+		>
+
+/**
+ * Checks `A` and `B` are not equal.
+ *
+ * ```ts
+ * type R = IsNotEqual<1, 1> // false
+ * type R = IsNotEqual<any, any> // false
+ * type R = IsNotEqual<boolean, boolean> // false
+ * type R = IsNotEqual<true, true> // false
+ * type R = IsNotEqual<[1], [1]> // false
+ *
+ * type R = IsNotEqual<boolean, true> // true
+ * type R = IsNotEqual<any, 1> // true
+ * type R = IsNotEqual<[any], [1]> // true
+ * type R = IsNotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
+ * ```
+ *
+ * Note that intersection type checks only works at first level.
+ * It cannot be check recursively,
+ * or else will run into infinite recursion if the type includes recursive types.
+ *
+ * @deprecated 💀 **deprecated since 8.0.0**: use `Equal` instead.
+ */
+export type IsNotEqual<A, B, Then = true, Else = false> = IsEqual<A, B, Else, Then>
+
+/**
+ * Checks `A` and `B` are not equal.
+ *
+ * @deprecated this will be changed to `filter` variant in the future.
+ * Please use `IsNotEqual` for the `predicate` behavior.
+ *
+ * ```ts
+ * type R = NotEqual<1, 1> // false
+ * type R = NotEqual<any, any> // false
+ * type R = NotEqual<boolean, boolean> // false
+ * type R = NotEqual<true, true> // false
+ * type R = NotEqual<[1], [1]> // false
+ *
+ * type R = NotEqual<boolean, true> // true
+ * type R = NotEqual<any, 1> // true
+ * type R = NotEqual<[any], [1]> // true
+ * type R = NotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
+ * ```
+ */
+export type NotEqual<A, B, Then = true, Else = false> = IsNotEqual<A, B, Then, Else>

package/src/equal/readme.md

@@ -1,4 +1,23 @@
-# IsEqual
+# Equality
+
+Equality check in TypeScript is hard.
+
+In fact, it is impossible to implement a perfect equality check in TypeScript,
+unless TypeScript itself provides a built-in type for it.
+
+## [`Equal`](./equal.ts)
+
+🏷️ **since 8.0.0**
+
+`Equal<A, B>` checks if `A` and `B` are equal.
+
+Note that intersection type checks only works at first level.
+It cannot be checked recursively,
+or else will run into infinite recursion if the type includes recursive types.
+
+## [`IsEqual`](./is_equal.ts)
+
+💀 **deprecated since 8.0.0**: use [`Equal`] instead.
 
 `IsEqual<A, B>` and friends check if `A` and `B` are equal.
 

package/src/function/is_function.ts

@@ -1,4 +1,15 @@
-import type { $Select } from '../type_plus/branch/$select.js'
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection } 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'
 
 /**
  * 🎭 *predicate*
@@ -53,10 +64,31 @@ import type { $Select } from '../type_plus/branch/$select.js'
  * type R = IsFunction<string, $SelectionBranch> // $Else
  * ```
  */
-export type IsFunction<T, $O extends IsFunction.$Options = {}> = $Select<T, Function, $O>
+export type IsFunction<T, $O extends IsFunction.$Options = {}> = $Special<
+	T,
+	$MergeOptions<
+		$O,
+		{
+			$then: $ResolveBranch<$O, [$Else]>
+			$else: IsFunction.$<T, $O>
+		}
+	>
+>
 
 export namespace IsFunction {
-	export type $Options = $Select.$Options
-	export type $Default = $Select.$Default
-	export type $Branch = $Select.$Branch
+	export type $Options = $Selection.Options &
+		$Distributive.Options &
+		$Exact.Options &
+		$InputOptions<$Any | $Unknown | $Never | $Void>
+	export type $Default = $Selection.Predicate & $Distributive.Default & $Exact.Default
+	export type $Branch<$O extends $Options = {}> = $Selection.Branch<$O>
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is `Function`.
+	 *
+	 * This is a type util for building custom types.
+	 * It does not check against special types.
+	 */
+	export type $<T, $O extends Assignable.$UtilOptions> = Assignable.$<T, Function, $O>
 }

package/src/function/is_not_function.ts

@@ -1,4 +1,4 @@
-import type { $SelectInvert } from '../type_plus/branch/$select_invert.js'
+import type { $SelectInvert } from '../equal/equal.js'
 
 /**
  * Is `T` not a `Function`.

package/src/function/is_not_strict_function.ts

@@ -1,11 +1,12 @@
-import type { $Any } from '../any/any.js'
-import type { $Never } from '../never/never.js'
-import type { $ResolveOptions } from '../type_plus/$resolve_options.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $SelectInvertStrict } from '../type_plus/branch/$select_invert_strict.js'
-import type { $Else, $Then } from '../type_plus/branch/$selection.js'
-import type { $Unknown } from '../unknown/unknown.js'
+import type { $ResolveOptions } from '../$type/$resolve_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Then } from '../$type/branch/$selection.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 { $SelectInvertStrict } from '../equal/equal.js'
 
 /**
  * Is `T` not exactly `Function`.
@@ -18,12 +19,13 @@ import type { $Unknown } from '../unknown/unknown.js'
  * ```
  */
 
-export type IsNotStrictFunction<T, $O extends IsNotStrictFunction.$Options = {}> = $SpecialType<
+export type IsNotStrictFunction<T, $O extends IsNotStrictFunction.$Options = {}> = $Special<
 	T,
 	{
-		$any: $ResolveBranch<T, $O, [$Any, $Then]>
-		$unknown: $ResolveBranch<T, $O, [$Unknown, $Then]>
-		$never: $ResolveBranch<T, $O, [$Never, $Then]>
+		$any: $ResolveBranch<$O, [$Any, $Then], T>
+		$unknown: $ResolveBranch<$O, [$Unknown, $Then], T>
+		$never: $ResolveBranch<$O, [$Never, $Then], T>
+		$void: $ResolveBranch<$O, [$Void, $Then], T>
 		$else: $ResolveOptions<[$O['distributive'], $SelectInvertStrict.$Default['distributive']]> extends true
 			? IsNotStrictFunction._D<T, $O>
 			: $SelectInvertStrict._N<T, Function, $O>
@@ -35,6 +37,6 @@ export namespace IsNotStrictFunction {
 	export type $Default = $SelectInvertStrict.$Default
 	export type $Branch = $SelectInvertStrict.$Branch
 	export type _D<T, $O extends IsNotStrictFunction.$Options> = T extends Function
-		? $ResolveBranch<T, $O, [T extends (...args: any[]) => any ? $Then : $Else]>
-		: $ResolveBranch<T, $O, [$Then]>
+		? $ResolveBranch<$O, [T extends (...args: any[]) => any ? $Then : $Else], T>
+		: $ResolveBranch<$O, [$Then], T>
 }

package/src/function/is_strict_function.ts

@@ -1,11 +1,15 @@
-import type { $Any } from '../any/any.js'
-import type { $Never } from '../never/never.js'
-import type { $ResolveOptions } from '../type_plus/$resolve_options.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $SelectStrict } from '../type_plus/branch/$select_strict.js'
-import type { $Else, $Then } from '../type_plus/branch/$selection.js'
-import type { $Unknown } from '../unknown/unknown.js'
+import type { $ResolveOptions } from '../$type/$resolve_options.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 { $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 { Equal } from '../equal/equal.js'
 
 /**
  * Is `T` exactly `Function`.
@@ -17,25 +21,29 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = IsStrictFunction<(() => void) & { a: 1 }> // false
  * ```
  */
-export type IsStrictFunction<T, $O extends IsStrictFunction.$Options = {}> = $SpecialType<
+export type IsStrictFunction<T, $O extends IsStrictFunction.$Options = {}> = $Special<
 	T,
 	{
-		$any: $ResolveBranch<T, $O, [$Any, $Else]>
-		$unknown: $ResolveBranch<T, $O, [$Unknown, $Else]>
-		$never: $ResolveBranch<T, $O, [$Never, $Else]>
-		$else: $ResolveOptions<[$O['distributive'], $SelectStrict.$Default['distributive']]> extends true
+		$any: $ResolveBranch<$O, [$Any, $Else]>
+		$never: $ResolveBranch<$O, [$Never, $Else]>
+		$unknown: $ResolveBranch<$O, [$Unknown, $Else]>
+		$void: $ResolveBranch<$O, [$Void, $Else]>
+		$else: $ResolveOptions<[$O['distributive'], $Distributive.Default['distributive']]> extends true
 			? IsStrictFunction._D<T, $O>
-			: $SelectStrict._N<T, Function, $O>
+			: Equal._ExactEqualNonDistributive<T, Function, $O>
 	}
 >
 
 export namespace IsStrictFunction {
-	export type $Options = $SelectStrict.$Options
-	export type $Default = $SelectStrict.$Default
-	export type $Branch = $SelectStrict.$Branch
-	export type _D<T, $O extends $SelectStrict.$Options> = T extends Function
+	export type $Options = $Selection.Options &
+		$Distributive.Options &
+		$Exact.Options &
+		$InputOptions<$Any | $Unknown | $Never | $Void>
+	export type $Default = $Selection.Predicate & $Distributive.Default & $Exact.Default
+	export type $Branch<$O extends $Options = {}> = $Selection.Branch<$O>
+	export type _D<T, $O extends Equal.$Options> = T extends Function
 		? T extends (...args: any[]) => any
-			? $ResolveBranch<T, $O, [$Else]>
-			: $ResolveBranch<T, $O, [$Then]>
-		: $ResolveBranch<T, $O, [$Else]>
+			? $ResolveBranch<$O, [$Else]>
+			: $ResolveBranch<$O, [$Then], T>
+		: $ResolveBranch<$O, [$Else]>
 }

package/src/functional/Maybe.ts

@@ -1,4 +1,4 @@
-import type { IsEqual } from '../equal/equal.js'
+import type { IsEqual } from '../equal/is_equal.js'
 import type { Brand } from '../nominal/index.js'
 import type { Widen } from '../utils/index.js'
 

package/src/functional/compose.ts

@@ -10,7 +10,5 @@ import type { AnyFunction } from '../function/any_function.js'
  * and return the result of the last function.
  */
 export function compose<FS extends AnyFunction[]>(...fns: FS): (...args: Parameters<Head<FS>>) => ReturnType<Last<FS>> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
-	// biome-ignore lint/performance/noAccumulatingSpread: https://github.com/biomejs/biome/issues/2183
-	return (...args: any[]) => fns.reduce((args, fn) => [fn(...args)], args)[0]
+	return (...args: any[]) => fns.reduce((args, fn) => [fn.apply(null, args)], args)[0]
 }

package/src/index.ts

@@ -1,4 +1,19 @@
-export type * from './any/any.js'
+export type * from './$type/$resolve_options.js'
+export type * from './$type/$type.js'
+export type * from './$type/branch/$branch.js'
+export type * from './$type/branch/$input_options.js'
+export type * from './$type/branch/$resolve_branch.js'
+export type * from './$type/branch/$selection.js'
+export type * from './$type/distributive/$distributive.js'
+export type * from './$type/errors/$error.js'
+export type * from './$type/errors/$infer_error.js'
+export type * from './$type/errors/failed.js'
+export type * from './$type/exact/$exact.js'
+export type * from './$type/special/$any.js'
+export type * from './$type/special/$never.js'
+export type * from './$type/special/$special.js'
+export type * from './$type/special/$unknown.js'
+export type * from './$type/utils/$merge_options.js'
 export type { IsAny } from './any/is_any.js'
 export type { IsNotAny } from './any/is_not_any.js'
 export type { At } from './array/array.at.js'
@@ -26,6 +41,7 @@ export type * from './bigint/is_bigint.js'
 export type * from './bigint/is_bigint_literal.js'
 export type * from './bigint/is_not_bigint.js'
 export type * from './bigint/is_not_bigint_literal.js'
+export type * from './binary/_binary.js'
 export type * from './boolean/is_boolean.js'
 export type * from './boolean/is_false.js'
 export type * from './boolean/is_not_boolean.js'
@@ -34,7 +50,8 @@ export type * from './boolean/is_not_true.js'
 export type * from './boolean/is_true.js'
 export * from './class/index.js'
 export type { ComposableTypes, NonComposableTypes } from './composable_types.js'
-export type { Equal, IsEqual, IsNotEqual, NotEqual } from './equal/equal.js'
+export type * from './equal/equal.js'
+export type { IsEqual, IsNotEqual, NotEqual } from './equal/is_equal.js'
 export type { AnyFunction } from './function/any_function.js'
 export * from './function/extract_function.js'
 export type * from './function/is_function.js'
@@ -51,7 +68,6 @@ export type * from './mix_types/is_any_or_never.js'
 export * from './mix_types/merge.js'
 export type * from './never/is_never.js'
 export type * from './never/is_not_never.js'
-export type * from './never/never.js'
 export * from './nodejs/index.js'
 export * from './nominal/index.js'
 export type * from './null/is_not_null.js'
@@ -105,23 +121,6 @@ export type * from './tuple/is_tuple.js'
 export type { Tail } from './tuple/tail.js'
 export * as TuplePlus from './tuple/tuple_plus.js'
 export * from './type-guard/is_type.js'
-export type { Failed, FailedT } from './type/failed.js'
-export type { NoInfer } from './type/no_infer.js'
-export type * from './type_plus/$equality.js'
-export type * from './type_plus/$error.js'
-export type * from './type_plus/$infer_error.js'
-export type * from './type_plus/$merge_options.js'
-export type * from './type_plus/$resolve_options.js'
-export type * from './type_plus/$special_type.js'
-export type * from './type_plus/$type.js'
-export type * from './type_plus/branch/$branch.js'
-export type * from './type_plus/branch/$distributive.js'
-export type * from './type_plus/branch/$input_options.js'
-export type * from './type_plus/branch/$is_distributive.js'
-export type * from './type_plus/branch/$resolve_branch.js'
-export type * from './type_plus/branch/$select.js'
-export type * from './type_plus/branch/$selection.js'
-export type * from './type_plus/branch/$selection_options.js'
 export type * from './undefined/has_undefined.js'
 export type * from './undefined/is_not_undefined.js'
 export type * from './undefined/is_undefined.js'
@@ -131,9 +130,9 @@ export type { UnionKeys } from './union_keys.js'
 export type * from './unknown/is_not_unknown.js'
 export type * from './unknown/is_unknown.js'
 export type * from './unknown/not_unknown_or.js'
-export type * from './unknown/unknown.js'
 export * from './unpartial.js'
 export * from './utils/index.js'
+export type * from './utils/no_infer.js'
 export type { TypePlusOptions } from './utils/options.js'
 export type * from './void/is_not_void.js'
 export type * from './void/is_void.js'

package/src/logical/logical.ts

@@ -0,0 +1,52 @@
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+
+/**
+ * 🎭 **predicate**
+ *
+ * Logical AND operation.
+ *
+ * @since 🏷️ 8.0.0
+ */
+export type And<A extends boolean, B extends boolean, $O extends $Selection.$BaseOptions = {}> = A extends true
+	? B extends true
+		? $ResolveBranch<$O, [$Then], A>
+		: $ResolveBranch<$O, [$Else], A>
+	: $ResolveBranch<$O, [$Else], A>
+
+/**
+ * 🎭 **predicate**
+ *
+ * Logical OR operation.
+ *
+ * @since 🏷️ 8.0.0
+ */
+export type Or<A extends boolean, B extends boolean, $O extends $Selection.$BaseOptions = {}> = A extends true
+	? $ResolveBranch<$O, [$Then], A>
+	: B extends true
+		? $ResolveBranch<$O, [$Then], A>
+		: $ResolveBranch<$O, [$Else], A>
+
+/**
+ * 🎭 **predicate**
+ *
+ * Logical NOT operation.
+ *
+ * @since 🏷️ 8.0.0
+ */
+export type Not<X extends boolean, $O extends $Selection.$BaseOptions = {}> = X extends true
+	? $ResolveBranch<$O, [$Else], X>
+	: $ResolveBranch<$O, [$Then], X>
+
+/**
+ * 🎭 **predicate**
+ *
+ * Logical XOR operation.
+ *
+ * @since 🏷️ 8.0.0
+ */
+export type Xor<A extends boolean, B extends boolean, $O extends $Selection.$BaseOptions = {}> = A extends true
+	? Not<B>
+	: B extends true
+		? $ResolveBranch<$O, [$Then], A>
+		: $ResolveBranch<$O, [$Else], A>

package/src/logical/readme.md

@@ -0,0 +1,53 @@
+# Logical Types
+
+Logical types are type-level logic operators.
+
+## [`And`](./and.ts)
+
+🎭 **predicate**
+🏷️ **since 8.0.0**
+
+Logical `And` operator.
+
+```ts
+type R = And<true, true> // true
+type R = And<true, false> // false
+```
+
+## [`Or`](./or.ts)
+
+🎭 **predicate**
+🏷️ **since 8.0.0**
+
+Logical `Or` operator.
+
+```ts
+type R = Or<true, true> // true
+type R = Or<true, false> // true
+type R = Or<false, false> // false
+```
+
+## [`Not`](./not.ts)
+
+🎭 **predicate**
+🏷️ **since 8.0.0**
+
+Logical `Not` operator.
+
+```ts
+type R = Not<true> // false
+type R = Not<false> // true
+```
+
+## [`Xor`](./xor.ts)
+
+🎭 **predicate**
+🏷️ **since 8.0.0**
+
+Logical `Xor` operator.
+
+```ts
+type R = Xor<true, true> // false
+type R = Xor<true, false> // true
+type R = Xor<false, false> // false
+```

package/src/math/abs.ts

@@ -1,6 +1,6 @@
+import type { $Else, $Then } from '../$type/branch/$selection.js'
 import type { IsBigint } from '../bigint/is_bigint.js'
 import type { IsNumber } from '../number/is_number.js'
-import type { $Else, $Then } from '../type_plus/branch/$selection.js'
 
 /*
  * Returns the absolute value of a number or bigint `N`.

package/src/mix_types/box.ts

@@ -1,3 +1,4 @@
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
 import type { IsBigint } from '../bigint/is_bigint.js'
 import type { IsBoolean } from '../boolean/is_boolean.js'
 import type { IsFunction } from '../function/is_function.js'
@@ -5,7 +6,6 @@ import type { IsNumber } from '../number/is_number.js'
 import type { IsObject } from '../object/is_object.js'
 import type { IsString } from '../string/is_string.js'
 import type { IsSymbol } from '../symbol/is_symbol.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * ⚗️ *transform*
@@ -33,7 +33,7 @@ export type Box<T, Options extends Box.Options = Box.DefaultOptions> = IsFunctio
 				? Object
 				: T extends Record<any, any>
 					? T
-					: IsBoolean<T, $SelectionBranch> extends infer R
+					: IsBoolean<T, $Selection.Branch> extends infer R
 						? R extends $Then
 							? Boolean
 							: R extends $Else

package/src/mix_types/is_any_or_never.ts

@@ -1,7 +1,6 @@
+import type { $Selection } from '../$type/branch/$selection.js'
 import type { IsAny } from '../any/is_any.js'
 import type { IsNever } from '../never/is_never.js'
-import type { $SelectionPredicate } from '../type_plus/branch/$selection.js'
-import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
 
 /**
  * 🎭 *predicate*
@@ -22,7 +21,7 @@ import type { $SelectionOptions } from '../type_plus/branch/$selection_options.j
  * type R = IsAnyOrNever<'a', $SelectionPredicate> // false
  * ```
  */
-export type IsAnyOrNever<T, $O extends $SelectionOptions = $SelectionPredicate> = IsNever<
+export type IsAnyOrNever<T, $O extends $Selection.Options = $Selection.Predicate> = IsNever<
 	T,
 	{
 		$then: $O['$then']