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

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

@@ -1,6 +1,6 @@
+export type { And, Not, Or, Xor } from '../logical/logical.js'
 export * from './CanAssign.js'
 export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends.js'
 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'

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/promise/index.ts

@@ -1,5 +1,5 @@
 export * from './isPromise.js'
-export * from './mapSeries.js'
 export * from './MaybePromise.js'
+export * from './mapSeries.js'
 export type { AwaitedProp, PromiseValue } from './PromiseValue.js'
 export type { PromiseValueMerge } from './PromiseValueMerge.js'

package/src/promise/isPromise.ts

@@ -1,4 +1,4 @@
 export function isPromise<R = any>(subject: unknown): subject is Promise<R> {
-	// @ts-ignore
+	// @ts-expect-error
 	return !!subject && typeof subject['then'] === 'function'
 }

package/src/string/$extract_manipulated_string.ts

@@ -19,32 +19,36 @@ export type $ExtractManipulatedString<T extends string> = [T, unknown] extends [
 		>
 
 export namespace $ExtractManipulatedString {
-	export type _UpperOrElse<N, Else> = N extends Uppercase<infer Y>
-		? string extends Y
-			? Uppercase<any> extends N
-				? Y
-				: N
-			: $ExtractManipulatedString<Y>
-		: Else
-	export type _LowerOrElse<N, Else> = N extends Lowercase<infer Y>
-		? string extends Y
-			? Lowercase<any> extends N
-				? Y
-				: N
-			: $ExtractManipulatedString<Y>
-		: Else
-	export type _CapOrElse<N, Else> = N extends Capitalize<infer Y>
-		? string extends Y
-			? Capitalize<any> extends N
-				? Y
-				: N
-			: $ExtractManipulatedString<Y>
-		: Else
-	export type _UncapOrElse<N, Else> = N extends Uncapitalize<infer Y>
-		? string extends Y
-			? Uncapitalize<any> extends N
-				? Y
-				: N
-			: $ExtractManipulatedString<Y>
-		: Else
+	export type _UpperOrElse<N, Else> =
+		N extends Uppercase<infer Y>
+			? string extends Y
+				? Uppercase<any> extends N
+					? Y
+					: N
+				: $ExtractManipulatedString<Y>
+			: Else
+	export type _LowerOrElse<N, Else> =
+		N extends Lowercase<infer Y>
+			? string extends Y
+				? Lowercase<any> extends N
+					? Y
+					: N
+				: $ExtractManipulatedString<Y>
+			: Else
+	export type _CapOrElse<N, Else> =
+		N extends Capitalize<infer Y>
+			? string extends Y
+				? Capitalize<any> extends N
+					? Y
+					: N
+				: $ExtractManipulatedString<Y>
+			: Else
+	export type _UncapOrElse<N, Else> =
+		N extends Uncapitalize<infer Y>
+			? string extends Y
+				? Uncapitalize<any> extends N
+					? Y
+					: N
+				: $ExtractManipulatedString<Y>
+			: Else
 }

package/src/string/_string_type.ts

@@ -1,11 +1,12 @@
 import type { $ExtractManipulatedString } from './$extract_manipulated_string.js'
 
-export type _StringType<T extends string> = $ExtractManipulatedString<T> extends infer K
-	? K extends string & infer U
-		? [K, U] extends [U, K]
-			? {} extends { [P in `${K}`]: unknown }
-				? 'templateLiteral'
-				: 'stringLiteral'
-			: 'string'
+export type _StringType<T extends string> =
+	$ExtractManipulatedString<T> extends infer K
+		? K extends string & infer U
+			? [K, U] extends [U, K]
+				? {} extends { [P in `${K}`]: unknown }
+					? 'templateLiteral'
+					: 'stringLiteral'
+				: 'string'
+			: never
 		: never
-	: never

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
 }

package/src/string/is_string.ts

@@ -1,12 +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 { $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'
 
 /**
  * 🎭 *predicate*
@@ -56,20 +60,23 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsString<bigint, $IsString.$Branch> // $Else
  * ```
  */
-export type IsString<T, $O extends IsString.$Options = {}> = $SpecialType<
+export type IsString<T, $O extends IsString.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Else]>
+			$then: $ResolveBranch<$O, [$Else]>
 			$else: IsString.$<T, $O>
 		}
 	>
 >
 
 export namespace IsString {
-	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*
@@ -80,19 +87,19 @@ export namespace IsString {
 	 * 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> }>
 		: Assignable.$<T, string, $O>
 
-	export type $UtilOptions = Assignable.$UtilOptions & $ExactOptions
+	export type $UtilOptions = Assignable.$UtilOptions & $Exact.Options
 
 	export type _D<T, $O extends $UtilOptions> = T extends string & infer U
 		? U extends string
-			? $ResolveBranch<T, $O, [$Else]>
-			: $ResolveBranch<T, $O, [$Then]>
-		: $ResolveBranch<T, $O, [$Else]>
+			? $ResolveBranch<$O, [$Else]>
+			: $ResolveBranch<$O, [$Then], T>
+		: $ResolveBranch<$O, [$Else]>
 	export type _N<T, $O extends $UtilOptions> = [T] extends [string & infer U]
 		? U extends string
-			? $ResolveBranch<T, $O, [$Else]>
-			: $ResolveBranch<T, $O, [$Then]>
-		: $ResolveBranch<T, $O, [$Else]>
+			? $ResolveBranch<$O, [$Else]>
+			: $ResolveBranch<$O, [$Then], T>
+		: $ResolveBranch<$O, [$Else]>
 }