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

package/src/numeric/is_not_positive.ts

@@ -1,8 +1,14 @@
+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 { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
 import type { IsBigint } from '../bigint/is_bigint.js'
 import type { IsNumber } from '../number/is_number.js'
-import type { $Equality } from '../type_plus/$equality.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * Is `T` not a positive numeric type.
@@ -33,18 +39,22 @@ export type IsNotPositive<T, $O extends IsNotPositive.$Options = {}> = IsBigint<
 		: IsNumber<Exclude<T, bigint>, { distributive: $O['distributive']; $then: $Then; $else: $Else }> extends infer R
 			? R extends $Then
 				? IsNotPositive._Negative<T, number, $O>
-				: $ResolveBranch<Exclude<T, number | bigint>, $O, [$Then]>
+				: $ResolveBranch<$O, [$Then], Exclude<T, number | bigint>>
 			: never
 	: never
 
 export namespace IsNotPositive {
-	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 _Negative<T, U extends number | bigint, $O extends IsNotPositive.$Options> = T extends U
 		? `${T}` extends `-${string}`
-			? $ResolveBranch<T, $O, [$Then]>
+			? $ResolveBranch<$O, [$Then], T>
 			: U extends T
-				? $ResolveBranch<T, $O, [$Then]> | $ResolveBranch<T, $O, [$Else]>
-				: $ResolveBranch<T, $O, [$Else]>
+				? $ResolveBranch<$O, [$Then], T> | $ResolveBranch<$O, [$Else]>
+				: $ResolveBranch<$O, [$Else]>
 		: never
 }

package/src/numeric/is_numeric.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'
 
 /**
  * Is `T` numeric.
@@ -11,10 +22,31 @@ import type { $Select } from '../type_plus/branch/$select.js'
  * type R = IsNumeric<unknown> // false
  * ```
  */
-export type IsNumeric<T, $O extends IsNumeric.$Options = {}> = $Select<T, number | bigint, $O>
+export type IsNumeric<T, $O extends IsNumeric.$Options = {}> = $Special<
+	T,
+	$MergeOptions<
+		$O,
+		{
+			$then: $ResolveBranch<$O, [$Else]>
+			$else: IsNumeric.$<T, $O>
+		}
+	>
+>
 
 export namespace IsNumeric {
-	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, number | bigint, $O>
 }

package/src/numeric/is_positive.ts

@@ -1,8 +1,14 @@
+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 { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
 import type { IsBigint } from '../bigint/is_bigint.js'
 import type { IsNumber } from '../number/is_number.js'
-import type { $Equality } from '../type_plus/$equality.js'
-import type { $ResolveBranch } from '../type_plus/branch/$resolve_branch.js'
-import type { $Else, $Then } from '../type_plus/branch/$selection.js'
 
 /**
  * Is `T` a positive numeric type.
@@ -23,29 +29,31 @@ export type IsPositive<T, $O extends IsPositive.$Options = {}> = IsBigint<
 	T,
 	{
 		distributive: $O['distributive']
-		$then: $Then
-		$else: $Else
+		$then: IsPositive._Positive<T, bigint, $O>
+		$else: IsNumber<
+			Exclude<T, bigint>,
+			{
+				distributive: $O['distributive']
+				$then: IsPositive._Positive<T, number, $O>
+				$else: $ResolveBranch<$O, [$Else]>
+			}
+		>
 	}
-> extends infer R
-	? R extends $Then
-		? IsPositive._Positive<T, bigint, $O>
-		: IsNumber<Exclude<T, bigint>, { distributive: $O['distributive']; $then: $Then; $else: $Else }> extends infer R
-			? R extends $Then
-				? IsPositive._Positive<T, number, $O>
-				: $ResolveBranch<T, $O, [$Else]>
-			: never
-	: never
-
+>
 export namespace IsPositive {
-	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 _Positive<T, U extends number | bigint, $O extends IsPositive.$Options> = T extends U & infer R
 		? `${T}` extends `-${string}`
-			? $ResolveBranch<T, $O, [$Else]>
+			? $ResolveBranch<$O, [$Else]>
 			: U extends T
-				? $ResolveBranch<T, $O, [$Then]> | $ResolveBranch<T, $O, [$Else]>
+				? $ResolveBranch<$O, [$Then], T> | $ResolveBranch<$O, [$Else]>
 				: [T, R] extends [R, T]
-					? $ResolveBranch<T, $O, [$Then]>
-					: $ResolveBranch<number, $O, [$Then]> | $ResolveBranch<T, $O, [$Else]>
+					? $ResolveBranch<$O, [$Then], T>
+					: $ResolveBranch<$O, [$Then], T> | $ResolveBranch<$O, [$Else]>
 		: never
 }

package/src/object/ANotB.ts

@@ -1,4 +1,4 @@
-import type { IsEqual } from '../equal/equal.js'
+import type { IsEqual } from '../equal/is_equal.js'
 import type { AnyRecord } from './any_record.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { KeysWithDiffType } from './KeysWithDiffType.js'

package/src/object/adjust_exact_optional_props.ts

@@ -10,5 +10,14 @@ import type { RequiredKeys } from './RequiredKeys.js'
  * It adds `undefined` to optional properties.
  */
 export type AdjustExactOptionalProps<T extends AnyRecord> = T extends object
-	? { [K in OptionalKeys<T>]?: T[K] | undefined } & { [K in RequiredKeys<T>]: T[K] }
+	? [{ [K in OptionalKeys<T>]?: T[K] | undefined }, { [K in RequiredKeys<T>]: T[K] }] extends [
+			infer O extends AnyRecord,
+			infer R extends AnyRecord,
+		]
+		? keyof O extends never
+			? R
+			: keyof R extends never
+				? O
+				: O & R
+		: never
 	: never

package/src/object/index.ts

@@ -1,8 +1,8 @@
-export type * from './adjust_exact_optional_props.js'
 export type { ANotB, BNotA } from './ANotB.js'
+export type * from './adjust_exact_optional_props.js'
 export type { AnyRecord } from './any_record.js'
-export * from './everyKey.js'
 export type { ExcludePropType } from './ExcludePropType.js'
+export * from './everyKey.js'
 export * from './facade.js'
 export * from './filterKey.js'
 export * from './findKey.js'
@@ -25,15 +25,15 @@ export type * from './optional_key.js'
 export type { Partial, PartialExcept, PartialOmit, PartialPick } from './Partial.js'
 export * from './pick.js'
 export type { Properties } from './properties.js'
-export * from './record.js'
-export type { RecursivePartial } from './recursive_partial.js'
 export type { RecursiveIntersect } from './RecursiveIntersect.js'
 export type { RecursiveRequired } from './RecursiveRequired.js'
+export type { RequiredKeys } from './RequiredKeys.js'
+export * from './record.js'
+export type { RecursivePartial } from './recursive_partial.js'
 export * from './reduceKey.js'
 export * from './replaceProperty.js'
-export type { RequiredKeys } from './RequiredKeys.js'
+export type { SpreadRecord } from './SpreadRecord.js'
 export * from './someKey.js'
 export * from './split.js'
-export type { SpreadRecord } from './SpreadRecord.js'
 export * from './typeOverrideIncompatible.js'
 export type { ValueOf } from './ValueOf.js'

package/src/object/is_not_object.ts

@@ -1,14 +1,18 @@
+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 { IdentityEqual } from '../equal/identity_equal.js'
 import type { IsNever } from '../never/is_never.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 { $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'
 
 /**
  * Is `T` not an `object`.
@@ -89,19 +93,22 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsNotObject<string, $SelectionBranch> // $Then
  * ```
  */
-export type IsNotObject<T, $O extends IsNotObject.$Options = {}> = $SpecialType<
+export type IsNotObject<T, $O extends IsNotObject.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Then]>
+			$then: $ResolveBranch<$O, [$Then], T>
 			$else: IsNotObject.$<T, $O>
 		}
 	>
 >
 export namespace IsNotObject {
-	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*
@@ -111,29 +118,29 @@ export namespace IsNotObject {
 	 * 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: _D<T, $O>; $else: _N<T, $O> }>
+	export type $<T, $O extends $UtilOptions> = $ResolveOptions<[$O['exact'], $Exact.Default]> extends true
+		? $Distributive.Parse<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
 		: NotAssignable.$<T, object, $O>
-	export type $UtilOptions = NotAssignable.$UtilOptions & $ExactOptions
+	export type $UtilOptions = NotAssignable.$UtilOptions & $Exact.Options
 
 	export type _D<T, $O extends $UtilOptions> = T extends object
 		? IdentityEqual<
 				T,
 				{},
-				$ResolveBranch<T, $O, [$Then]>,
+				$ResolveBranch<$O, [$Then], T>,
 				IsNever<
 					keyof T,
 					{
-						$then: $ResolveBranch<T, $O, [$Else]>
-						$else: $ResolveBranch<T, $O, [$Then]>
+						$then: $ResolveBranch<$O, [$Else]>
+						$else: $ResolveBranch<$O, [$Then], T>
 					}
 				>
 			>
-		: $ResolveBranch<T, $O, [$Then]>
+		: $ResolveBranch<$O, [$Then], T>
 
 	export type _N<T, $O extends $UtilOptions> = [T] extends [object & infer U]
 		? U extends object
-			? $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/object/is_object.ts

@@ -1,14 +1,18 @@
+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 { IdentityEqual } from '../equal/identity_equal.js'
 import type { IsNever } from '../never/is_never.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'
 
 /**
  * 🎭 *predicate*
@@ -76,20 +80,23 @@ import type { $Else, $Then } from '../type_plus/branch/$selection.js'
  * type R = IsObject<string, $SelectionBranch> // $Else
  * ```
  */
-export type IsObject<T, $O extends IsObject.$Options = {}> = $SpecialType<
+export type IsObject<T, $O extends IsObject.$Options = {}> = $Special<
 	T,
 	$MergeOptions<
 		$O,
 		{
-			$then: $ResolveBranch<T, $O, [$Else]>
+			$then: $ResolveBranch<$O, [$Else]>
 			$else: IsObject.$<T, $O>
 		}
 	>
 >
 
 export namespace IsObject {
-	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*
@@ -99,29 +106,29 @@ export namespace IsObject {
 	 * 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: _D<T, $O>; $else: _N<T, $O> }>
+	export type $<T, $O extends $UtilOptions> = $ResolveOptions<[$O['exact'], $Exact.Default]> extends true
+		? $Distributive.Parse<$O, { $then: _D<T, $O>; $else: _N<T, $O> }>
 		: Assignable.$<T, object, $O>
-	export type $UtilOptions = Assignable.$UtilOptions & $ExactOptions
+	export type $UtilOptions = Assignable.$UtilOptions & $Exact.Options
 
 	export type _D<T, $O extends $UtilOptions> = T extends object
 		? IdentityEqual<
 				T,
 				{},
-				$ResolveBranch<T, $O, [$Else]>,
+				$ResolveBranch<$O, [$Else]>,
 				IsNever<
 					keyof T,
 					{
-						$then: $ResolveBranch<T, $O, [$Then]>
-						$else: $ResolveBranch<T, $O, [$Else]>
+						$then: $ResolveBranch<$O, [$Then], T>
+						$else: $ResolveBranch<$O, [$Else]>
 					}
 				>
 			>
-		: $ResolveBranch<T, $O, [$Else]>
+		: $ResolveBranch<$O, [$Else]>
 
 	export type _N<T, $O extends $UtilOptions> = [T] extends [object & infer U]
 		? U extends object
-			? $ResolveBranch<T, $O, [$Else]>
-			: $ResolveBranch<T, $O, [$Then]>
-		: $ResolveBranch<T, $O, [$Else]>
+			? $ResolveBranch<$O, [$Else]>
+			: $ResolveBranch<$O, [$Then], T>
+		: $ResolveBranch<$O, [$Else]>
 }

package/src/object/left_join.ts

@@ -1,4 +1,4 @@
-import type { IsEqual } from '../equal/equal.js'
+import type { IsEqual } from '../equal/is_equal.js'
 import type { AnyRecord } from './any_record.js'
 import type { IsDisjoint } from './IsDisjoint.js'
 import type { Properties } from './properties.js'

package/src/object/merge.ts

@@ -1,10 +1,10 @@
+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'
@@ -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/properties.ts

@@ -1,4 +1,37 @@
+import type { IsAny } from '../any/is_any.js'
+import type { IsUnknown } from '../unknown/is_unknown.js'
+
 /**
- * Gets the properties of an object type.
+ * Extracts the property map of a type: an object type with the same keys and
+ * value types as `T`, preserving optional and readonly modifiers.
+ *
+ * - For object types: returns `{ [k in keyof T]: T[k] }`.
+ * - For `any` and `unknown`: returns the input type unchanged.
+ * - For function types (e.g. `() => void`): returns `{}` because call signatures
+ *   are not indexable; for `Function`, returns the interface of methods.
+ * - For intersections: merges properties from all branches.
+ *
+ * @typeParam T - The type whose properties to extract.
+ *
+ * @example
+ * ```ts
+ * type T = { a: number; b?: string }
+ * type R = Properties<T> // { a: number; b?: string }
+ *
+ * type Merged = Properties<{ a: 1 } & { b: 2 }> // { a: 1; b: 2 }
+ * ```
  */
-export type Properties<T> = { [k in keyof T]: T[k] } // & {}
+export type Properties<T> = IsAny<
+	T,
+	{
+		$then: T
+		$else: IsUnknown<
+			T,
+			{
+				$then: T
+				$else: { [k in keyof T]: T[k] } // & {}
+			}
+		>
+	}
+>
+//  [unknown] extends [T] ? unknown : { [k in keyof T]: T[k] } // & {}