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

package/src/object/merge.ts

@@ -1,13 +1,13 @@
+import type { $Never } from '../$type/special/$never.js'
 import type { IsAny } from '../any/is_any.js'
 import type { NonComposableTypes } from '../composable_types.js'
+import type { Or } from '../logical/logical.js'
 import type { IsNever } from '../never/is_never.js'
 import type { IsNotNever } from '../never/is_not_never.js'
-import type { $Never } from '../never/never.js'
 import type { IsLiteral } from '../predicates/literal.js'
-import type { Or } from '../predicates/logical.js'
-import type { AnyRecord } from './any_record.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeyTypes } from './KeyTypes.js'
+import type { AnyRecord } from './any_record.js'
 import type { OptionalKeys } from './optional_key.js'
 
 /**
@@ -29,56 +29,60 @@ export type Merge<
 > = Or<
 	IsAny<A>,
 	IsAny<B>,
-	any,
-	Or<
-		IsNever<A>,
-		IsNever<B>,
-		never,
-		IsDisjoint<A, B> extends true
-			? A & B
-			: [keyof A, keyof B] extends [infer KA extends KeyTypes, infer KB extends KeyTypes]
-				? IsLiteral<KA> extends true
-					? IsLiteral<KB> extends true
-						? [OptionalKeys<A>, OptionalKeys<B>] extends [infer PKA extends KeyTypes, infer PKB extends KeyTypes]
-							? // property is optional when both A[k] and B[k] are optional
-								(IsNotNever<PKA & PKB, { selection: 'filter' }> extends infer R extends KeyTypes
-									? { [k in R]?: A[k] | B[k] }
-									: unknown) &
-									// properties only in A excluding partials is A[k]
-									(IsNotNever<Exclude<KA, PKA | KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+	{
+		$then: any
+		$else: Or<
+			IsNever<A>,
+			IsNever<B>,
+			{
+				$then: never
+				$else: IsDisjoint<A, B> extends true
+					? A & B
+					: [keyof A, keyof B] extends [infer KA extends KeyTypes, infer KB extends KeyTypes]
+						? IsLiteral<KA> extends true
+							? IsLiteral<KB> extends true
+								? [OptionalKeys<A>, OptionalKeys<B>] extends [infer PKA extends KeyTypes, infer PKB extends KeyTypes]
+									? // property is optional when both A[k] and B[k] are optional
+										(IsNotNever<PKA & PKB, { selection: 'filter' }> extends infer R extends KeyTypes
+											? { [k in R]?: A[k] | B[k] }
+											: unknown) &
+											// properties only in A excluding partials is A[k]
+											(IsNotNever<Exclude<KA, PKA | KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+												? { [k in R]: A[k] }
+												: unknown) &
+											// properties only in B excluding partials is B[k]
+											(IsNotNever<Exclude<KB, PKB>, { selection: 'filter' }> extends infer R extends KeyTypes
+												? { [k in R]: B[k] }
+												: unknown) &
+											// properties is required in A but optional in B is unionized without undefined
+											(IsNotNever<Exclude<KA & PKB, PKA>, { selection: 'filter' }> extends infer R extends KeyTypes
+												? { [k in R]: A[k] | Exclude<B[k], undefined> }
+												: unknown)
+									: never
+								: (IsNotNever<Exclude<KA, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
 										? { [k in R]: A[k] }
 										: unknown) &
-									// properties only in B excluding partials is B[k]
-									(IsNotNever<Exclude<KB, PKB>, { selection: 'filter' }> extends infer R extends KeyTypes
-										? { [k in R]: B[k] }
+										(IsNotNever<Exclude<KB, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+											? { [k in R]: B[k] }
+											: unknown) &
+										(IsNotNever<KA & KB, { selection: 'filter' }> extends infer R extends KeyTypes
+											? { [k in R]: A[k] | B[k] }
+											: unknown)
+							: IsLiteral<KB> extends true
+								? { [k in Exclude<KA, KB>]: A[k] } & { [k in keyof B]: B[k] }
+								: (IsNotNever<Exclude<KA, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+										? { [k in R]: A[k] }
 										: unknown) &
-									// properties is required in A but optional in B is unionized without undefined
-									(IsNotNever<Exclude<KA & PKB, PKA>, { selection: 'filter' }> extends infer R extends KeyTypes
-										? { [k in R]: A[k] | Exclude<B[k], undefined> }
-										: unknown)
-							: never
-						: (IsNotNever<Exclude<KA, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
-								? { [k in R]: A[k] }
-								: unknown) &
-								(IsNotNever<Exclude<KB, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
-									? { [k in R]: B[k] }
-									: unknown) &
-								(IsNotNever<KA & KB, { selection: 'filter' }> extends infer R extends KeyTypes
-									? { [k in R]: A[k] | B[k] }
-									: unknown)
-					: IsLiteral<KB> extends true
-						? { [k in Exclude<KA, KB>]: A[k] } & { [k in keyof B]: B[k] }
-						: (IsNotNever<Exclude<KA, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
-								? { [k in R]: A[k] }
-								: unknown) &
-								(IsNotNever<Exclude<KB, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
-									? { [k in R]: B[k] }
-									: unknown) &
-								(IsNotNever<KA & KB, { selection: 'filter' }> extends infer R extends KeyTypes
-									? { [k in R]: A[k] | B[k] }
-									: unknown)
-				: never
-	>
+										(IsNotNever<Exclude<KB, KA & KB>, { selection: 'filter' }> extends infer R extends KeyTypes
+											? { [k in R]: B[k] }
+											: unknown) &
+										(IsNotNever<KA & KB, { selection: 'filter' }> extends infer R extends KeyTypes
+											? { [k in R]: A[k] | B[k] }
+											: unknown)
+						: never
+			}
+		>
+	}
 >
 
 export namespace Merge {

package/src/object/optional_key.ts

@@ -1,5 +1,5 @@
-import type { AnyRecord } from './any_record.js'
 import type { KeyTypes } from './KeyTypes.js'
+import type { AnyRecord } from './any_record.js'
 
 /**
  * Validate if the key `K` in `T` is optional.

package/src/object/record.ts

@@ -1,6 +1,6 @@
 import type { Widen } from '../utils/index.js'
-import type { AnyRecord } from './any_record.js'
 import type { KeyTypes } from './KeyTypes.js'
+import type { AnyRecord } from './any_record.js'
 
 /**
  * Creates a `Record<Key, Value>` or your custom record.

package/src/object/split.ts

@@ -1,7 +1,7 @@
+import type { Partial } from './Partial.js'
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import type { AnyRecord } from './any_record.js'
 import type { Omit } from './omit.js'
-import type { Partial } from './Partial.js'
 import { reduceByKey } from './reduceKey.js'
 
 type Splitter<T extends AnyRecord> = Partial<{ [k in keyof T]: T[k] | undefined }>

package/src/predicates/CanAssign.ts

@@ -1,5 +1,5 @@
-import type { Assignable } from './assignable.js'
 import type { NotExtendable } from './Extends.js'
+import type { Assignable } from './assignable.js'
 
 /**
  * Can `A` assign to `B`

package/src/predicates/assignable.ts

@@ -1,13 +1,11 @@
-import type { $Any } from '../any/any.js'
-import type { $Never } from '../never/never.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $DistributiveDefault, $DistributiveOptions } from '../type_plus/branch/$distributive.js'
-import type { $InputOptions } from '../type_plus/branch/$input_options.js'
-import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $SelectionBranch, $SelectionPredicate, $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 { $Distributive } from '../$type/distributive/$distributive.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'
 
 /**
  * 🎭 *predicate*
@@ -56,18 +54,18 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = Assignable<never, any, { $never: 1 }> // 1
  * ```
  */
-export type Assignable<A, B, $O extends Assignable.$Options = {}> = $SpecialType<
+export type Assignable<A, B, $O extends Assignable.$Options = {}> = $Special<
 	B,
 	{
-		$any: $ResolveBranch<A, $O, [0 extends 1 & A ? $Any : unknown, $Then]>
-		$unknown: $ResolveBranch<A, $O, [[A, unknown] extends [unknown, A] ? $Unknown : unknown, $Then]>
-		$never: $ResolveBranch<A, $O, [A, never] extends [never, A] ? [$Never, $Then] : [$Else]>
-		$else: $SpecialType<
+		$any: $ResolveBranch<$O, [0 extends 1 & A ? $Any : unknown, $Then], A>
+		$unknown: $ResolveBranch<$O, [[A, unknown] extends [unknown, A] ? $Unknown : unknown, $Then], A>
+		$never: $ResolveBranch<$O, [A, never] extends [never, A] ? [$Never, $Then] : [$Else], A>
+		$else: $Special<
 			A,
 			{
-				$any: $ResolveBranch<A, $O, [$Any, $Then]>
-				$unknown: $ResolveBranch<A, $O, [$Unknown, $Then]>
-				$never: $ResolveBranch<A, $O, [$Never, $Then]>
+				$any: $ResolveBranch<$O, [$Any, $Then], A>
+				$unknown: $ResolveBranch<$O, [$Unknown, $Then], A>
+				$never: $ResolveBranch<$O, [$Never, $Then], A>
 				$else: Assignable.$<A, B, $O>
 			}
 		>
@@ -75,9 +73,9 @@ export type Assignable<A, B, $O extends Assignable.$Options = {}> = $SpecialType
 >
 
 export namespace Assignable {
-	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
-	export type $Default = $SelectionPredicate & $DistributiveDefault
-	export type $Branch<$O extends $DistributiveOptions = {}> = $SelectionBranch & $O
+	export type $Options = $Selection.Options & $Distributive.Options & $InputOptions<$Any | $Unknown | $Never>
+	export type $Default = $Selection.Predicate & $Distributive.Default
+	export type $Branch<$O extends $Distributive.Options = {}> = $Selection.Branch & $O
 
 	/**
 	 * 🧰 *type util*
@@ -89,13 +87,13 @@ export namespace Assignable {
 	 *
 	 * It is suitable for building custom types.
 	 */
-	export type $<A, B, $O extends $UtilOptions> = $IsDistributive<
+	export type $<A, B, $O extends $UtilOptions> = $Distributive.Parse<
 		$O,
 		{
-			$then: A extends B ? $ResolveBranch<A, $O, [$Then]> : $ResolveBranch<A, $O, [$Else]>
-			$else: [A] extends [B] ? $ResolveBranch<A, $O, [$Then]> : $ResolveBranch<A, $O, [$Else]>
+			$then: A extends B ? $ResolveBranch<$O, [$Then], A> : $ResolveBranch<$O, [$Else], A>
+			$else: [A] extends [B] ? $ResolveBranch<$O, [$Then], A> : $ResolveBranch<$O, [$Else], A>
 		}
 	>
 
-	export type $UtilOptions = $SelectionOptions & $DistributiveOptions
+	export type $UtilOptions = $Selection.Options & $Distributive.Options
 }

package/src/predicates/index.ts

@@ -3,4 +3,4 @@ export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends
 export type { If } from './If.js'
 export type { IsEmptyObject } from './IsEmptyObject.js'
 export type { IsLiteral } from './literal.js'
-export type { And, Not, Or, Xor } from './logical.js'
+export type { And, Not, Or, Xor } from '../logical/logical.js'

package/src/predicates/not_assignable.ts

@@ -1,18 +1,16 @@
-import type { $Any } from '../any/any.js'
-import type { $Never } from '../never/never.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $DistributiveDefault, $DistributiveOptions } from '../type_plus/branch/$distributive.js'
-import type { $InputOptions } from '../type_plus/branch/$input_options.js'
-import type { $IsDistributive } from '../type_plus/branch/$is_distributive.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $SelectionBranch, $SelectionPredicate, $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 { $Distributive } from '../$type/distributive/$distributive.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'
 
 /**
  * 🎭 *predicate*
  *
- * Validate if `A` is not assignable to `B`.
+ * Validate if `A` is not assignable to `B`.]
  *
  * @example
  * ```ts
@@ -56,18 +54,18 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = NotAssignable<never, any, { $never: 1 }> // 1
  * ```
  */
-export type NotAssignable<A, B, $O extends NotAssignable.$Options = {}> = $SpecialType<
+export type NotAssignable<A, B, $O extends NotAssignable.$Options = {}> = $Special<
 	B,
 	{
-		$any: $ResolveBranch<A, $O, [0 extends 1 & A ? $Any : unknown, $Else]>
-		$unknown: $ResolveBranch<A, $O, [[A, unknown] extends [unknown, A] ? $Unknown : unknown, $Else]>
-		$never: $ResolveBranch<A, $O, [A, never] extends [never, A] ? [$Never, $Else] : [$Then]>
-		$else: $SpecialType<
+		$any: $ResolveBranch<$O, [0 extends 1 & A ? $Any : unknown, $Else], A>
+		$unknown: $ResolveBranch<$O, [[A, unknown] extends [unknown, A] ? $Unknown : unknown, $Else], A>
+		$never: $ResolveBranch<$O, [A, never] extends [never, A] ? [$Never, $Else] : [$Then], A>
+		$else: $Special<
 			A,
 			{
-				$any: $ResolveBranch<A, $O, [$Any, $Else]>
-				$unknown: $ResolveBranch<A, $O, [$Unknown, $Else]>
-				$never: $ResolveBranch<A, $O, [$Never, $Else]>
+				$any: $ResolveBranch<$O, [$Any, $Else], A>
+				$unknown: $ResolveBranch<$O, [$Unknown, $Else], A>
+				$never: $ResolveBranch<$O, [$Never, $Else], A>
 				$else: NotAssignable.$<A, B, $O>
 			}
 		>
@@ -75,9 +73,9 @@ export type NotAssignable<A, B, $O extends NotAssignable.$Options = {}> = $Speci
 >
 
 export namespace NotAssignable {
-	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
-	export type $Default = $SelectionPredicate & $DistributiveDefault
-	export type $Branch<$O extends $DistributiveOptions = {}> = $SelectionBranch & $O
+	export type $Options = $Selection.Options & $Distributive.Options & $InputOptions<$Any | $Unknown | $Never>
+	export type $Default = $Selection.Predicate & $Distributive.Default
+	export type $Branch<$O extends $Distributive.Options = {}> = $Selection.Branch & $O
 
 	/**
 	 * 🧰 *type util*
@@ -89,13 +87,13 @@ export namespace NotAssignable {
 	 *
 	 * It is suitable for building custom types.
 	 */
-	export type $<A, B, $O extends $UtilOptions> = $IsDistributive<
+	export type $<A, B, $O extends $UtilOptions> = $Distributive.Parse<
 		$O,
 		{
-			$then: A extends B ? $ResolveBranch<A, $O, [$Else]> : $ResolveBranch<A, $O, [$Then]>
-			$else: [A] extends [B] ? $ResolveBranch<A, $O, [$Else]> : $ResolveBranch<A, $O, [$Then]>
+			$then: A extends B ? $ResolveBranch<$O, [$Else], A> : $ResolveBranch<$O, [$Then], A>
+			$else: [A] extends [B] ? $ResolveBranch<$O, [$Else], A> : $ResolveBranch<$O, [$Then], A>
 		}
 	>
 
-	export type $UtilOptions = $SelectionOptions & $DistributiveOptions
+	export type $UtilOptions = $Selection.Options & $Distributive.Options
 }

package/src/string/is_not_string.ts

@@ -1,13 +1,16 @@
+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 { $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 { $ResolveOptions } from '../type_plus/$resolve_options.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $ExactOptions } 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'
-import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
 
 /**
  * 🎭 *predicate*
@@ -57,20 +60,23 @@ import type { $SelectionOptions } from '../type_plus/branch/$selection_options.j
  * type R = IsNotString<bigint, $IsNotString.$Branch> // $Then
  * ```
  */
-export type IsNotString<T, $O extends IsNotString.$Options = {}> = $SpecialType<
+export type IsNotString<T, $O extends IsNotString.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Then]>
+			$then: $ResolveBranch<$O, [$Then], T>
 			$else: IsNotString.$<T, $O>
 		}
 	>
 >
 
 export namespace IsNotString {
-	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*
@@ -81,18 +87,18 @@ export namespace IsNotString {
 	 * It does not check against special types.
 	 */
 	export type $<T, $O extends $UtilOptions> = $ResolveOptions<[$O['exact'], false]> extends true
-		? $IsDistributive<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
+		? $Distributive.Parse<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
 		: NotAssignable.$<T, string, $O>
-	export type $UtilOptions = NotAssignable.$UtilOptions & $ExactOptions
+	export type $UtilOptions = NotAssignable.$UtilOptions & $Exact.Options
 
-	export type _D<T, $O extends $SelectionOptions> = T extends string & infer U
+	export type _D<T, $O extends $Selection.Options> = T extends string & infer U
 		? U extends string
-			? $ResolveBranch<T, $O, [$Then]>
-			: $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Then]>
-	export type _N<T, $O extends $SelectionOptions> = [T] extends [string & infer U]
+			? $ResolveBranch<$O, [$Then], T>
+			: $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Then], T>
+	export type _N<T, $O extends $Selection.Options> = [T] extends [string & infer U]
 		? U extends string
-			? $ResolveBranch<T, $O, [$Then]>
-			: $ResolveBranch<T, $O, [$Else]>
-		: $ResolveBranch<T, $O, [$Then]>
+			? $ResolveBranch<$O, [$Then], T>
+			: $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Then], T>
 }

package/src/string/is_not_string_literal.ts

@@ -1,13 +1,16 @@
+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 { $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 { $ResolveOptions } from '../type_plus/$resolve_options.js'
-import type { $SpecialType } from '../type_plus/$special_type.js'
-import type { $ExactDefault, $ExactOptions } 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'
-import type { $SelectionOptions } from '../type_plus/branch/$selection_options.js'
 import type { _StringType } from './_string_type.js'
 
 /**
@@ -68,20 +71,23 @@ import type { _StringType } from './_string_type.js'
  * type R = IsNotStringLiteral<string, $IsNotStringLiteral.$Branch> // $Then
  * ```
  */
-export type IsNotStringLiteral<T, $O extends IsNotStringLiteral.$Options = {}> = $SpecialType<
+export type IsNotStringLiteral<T, $O extends IsNotStringLiteral.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Then]>
+			$then: $ResolveBranch<$O, [$Then], T>
 			$else: IsNotStringLiteral.$<T, $O>
 		}
 	>
 >
 
 export namespace IsNotStringLiteral {
-	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*
@@ -91,37 +97,37 @@ export namespace IsNotStringLiteral {
 	 * This is a type util for building custom types.
 	 * It does not check against special types.
 	 */
-	export type $<T, $O extends $UtilOptions> = $ResolveOptions<[$O['exact'], $ExactDefault]> extends true
-		? $IsDistributive<$O, { $then: _ED<T, $O>; $else: _EN<T, $O> }>
-		: $IsDistributive<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
+	export type $<T, $O extends $UtilOptions> = $ResolveOptions<[$O['exact'], $Exact.Default]> extends true
+		? $Distributive.Parse<$O, { $then: _ED<T, $O>; $else: _EN<T, $O> }>
+		: $Distributive.Parse<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
 
-	export type $UtilOptions = Assignable.$UtilOptions & $ExactOptions
+	export type $UtilOptions = Assignable.$UtilOptions & $Exact.Options
 
-	export type _ED<T, $O extends $SelectionOptions> = T extends string ? _E<T, $O> : $ResolveBranch<T, $O, [$Then]>
+	export type _ED<T, $O extends $Selection.Options> = T extends string ? _E<T, $O> : $ResolveBranch<$O, [$Then], T>
 
-	export type _EN<T, $O extends $SelectionOptions> = [T] extends [string] ? _E<T, $O> : $ResolveBranch<T, $O, [$Then]>
+	export type _EN<T, $O extends $Selection.Options> = [T] extends [string] ? _E<T, $O> : $ResolveBranch<$O, [$Then], T>
 
-	export type _E<T extends string, $O extends $SelectionOptions> = T extends string
+	export type _E<T extends string, $O extends $Selection.Options> = T extends string
 		? _StringType<T> extends infer R
 			? R extends 'stringLiteral'
-				? $ResolveBranch<T, $O, [$Else]>
-				: $ResolveBranch<T, $O, [$Then]>
+				? $ResolveBranch<$O, [$Else]>
+				: $ResolveBranch<$O, [$Then], T>
 			: never
-		: $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<$O, [$Then], T>
 
-	export type _D<T, $O extends $SelectionOptions> = T extends string & infer U
+	export type _D<T, $O extends $Selection.Options> = T extends string & infer U
 		? _U<T, U, $O>
-		: $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<$O, [$Then], T>
 
-	export type _N<T, $O extends $SelectionOptions> = [T] extends [string & infer U]
+	export type _N<T, $O extends $Selection.Options> = [T] extends [string & infer U]
 		? _U<T, U, $O>
-		: $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<$O, [$Then], T>
 
-	export type _U<T, U, $O extends $SelectionOptions> = U extends `${any}`
-		? $ResolveBranch<T, $O, [$Else]>
+	export type _U<T, U, $O extends $Selection.Options> = U extends `${any}`
+		? $ResolveBranch<$O, [$Else]>
 		: U extends Uppercase<infer N>
 			? _D<N, $O>
 			: U extends Lowercase<infer N>
 				? _D<N, $O>
-				: $ResolveBranch<T, $O, [$Then]>
+				: $ResolveBranch<$O, [$Then], T>
 }

package/src/string/is_not_template_literal.ts

@@ -1,10 +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 { $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'
 import type { _StringType } from './_string_type.js'
 
 /**
@@ -52,36 +57,39 @@ import type { _StringType } from './_string_type.js'
  * type R = IsNotTemplateLiteral<bigint, $IsString.$Branch> // $Then
  * ```
  */
-export type IsNotTemplateLiteral<T, $O extends IsNotTemplateLiteral.$Options = {}> = $SpecialType<
+export type IsNotTemplateLiteral<T, $O extends IsNotTemplateLiteral.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Then]>
+			$then: $ResolveBranch<$O, [$Then], T>
 			$else: IsNotTemplateLiteral.$<T, $O>
 		}
 	>
 >
 
 export namespace IsNotTemplateLiteral {
-	export type $Options = $Equality.$Options
-	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>
 
 	export type $UtilOptions = Assignable.$UtilOptions
 
-	export type $<T, $O extends $UtilOptions> = $IsDistributive<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
+	export type $<T, $O extends $UtilOptions> = $Distributive.Parse<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
 
 	type _D<T, $O extends $UtilOptions> = T extends string
 		? _StringType<T> extends infer R
 			? R extends 'templateLiteral'
-				? $ResolveBranch<T, $O, [$Else]>
-				: $ResolveBranch<T, $O, [$Then]>
+				? $ResolveBranch<$O, [$Else]>
+				: $ResolveBranch<$O, [$Then], T>
 			: never
-		: $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<$O, [$Then], T>
 
 	type _N<T, $O extends $UtilOptions> = _D<T, { $then: $Then; $else: $Else }> extends infer R
 		? $Then | $Else extends R
-			? $ResolveBranch<T, $O, [$Then]>
-			: $ResolveBranch<T, $O, [R]>
+			? $ResolveBranch<$O, [$Then], T>
+			: $ResolveBranch<$O, [R], T>
 		: never
 }