type-plus 8.0.0-beta.2 → 8.0.0-beta.3

package/src/object/merge.ts

@@ -25,83 +25,64 @@ export type Merge<
 	A extends AnyRecord,
 	B extends AnyRecord,
 	// biome-ignore lint/correctness/noUnusedVariables: FIXME
-	Options = Merge.DefaultOptions> = Or<
-		IsAny<A>,
-		IsAny<B>,
-		any,
-		Or<
-			IsNever<A>,
-			IsNever<B>,
-			never,
-			IsDisjoint<A, B> extends true
+	Options = Merge.DefaultOptions
+> = 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 ? { [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) &
-						(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
+			: [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) &
+								(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<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
 	>
+>
 
 export namespace Merge {
-	export type JoinProps<A, B> = A extends NonComposableTypes
-		? B
-		: (B extends NonComposableTypes
-			? A
-			: A & B)
+	export type JoinProps<A, B> = A extends NonComposableTypes ? B : B extends NonComposableTypes ? A : A & B
 
 	export type Options = {
 		$never?: undefined

package/src/object/omit.ts

@@ -4,12 +4,14 @@ import type { Pick } from './pick.js'
 import { record } from './record.js'
 import { reduceByKey } from './reduceKey.js'
 
-// by Titian Cernicova-Dragomir
-// https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347
-// type-zoo
-export type Omit<T, K extends UnionKeys<T>> = T extends unknown
-? Pick<T, Exclude<keyof T, K>>
-: never
+/**
+ * Omit properties from a type.
+ *
+ * @origin [typescript#28339](https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347)
+ * @originAuthor Titian Cernicova-Dragomir
+ * @alternative [type-zoo](https://github.com/pelotom/type-zoo)
+ */
+export type Omit<T, K extends UnionKeys<T>> = T extends unknown ? Pick<T, Exclude<keyof T, K>> : never
 
 /**
  * @deprecated replaced by `Omit`
@@ -22,12 +24,12 @@ export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends Un
 	prop1: P1,
 	prop2: P2
 ): Omit<T, P1 | P2>
-export function omit<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>
->(subject: T, prop1: P1, prop2: P2, prop3: P3): Omit<T, P1 | P2 | P3>
+export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3
+): Omit<T, P1 | P2 | P3>
 export function omit<
 	T extends AnyRecord,
 	P1 extends UnionKeys<T>,
@@ -51,15 +53,7 @@ export function omit<
 	P4 extends UnionKeys<T>,
 	P5 extends UnionKeys<T>,
 	P6 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6
-): Omit<T, P1 | P2 | P3 | P4 | P5 | P6>
+>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Omit<T, P1 | P2 | P3 | P4 | P5 | P6>
 export function omit<
 	T extends AnyRecord,
 	P1 extends UnionKeys<T>,
@@ -204,10 +198,7 @@ export function omit<
 	prop11: P11,
 	prop12: P12
 ): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function omit<T extends AnyRecord, Props extends UnionKeys<T>>(
-	subject: T,
-	...props: Props[]
-): Omit<T, Props>
+export function omit<T extends AnyRecord, Props extends UnionKeys<T>>(subject: T, ...props: Props[]): Omit<T, Props>
 export function omit<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
 	return reduceByKey(
 		subject,

package/src/object/optional_key.ts

@@ -1,4 +1,3 @@
-
 import type { AnyRecord } from './any_record.js'
 import type { KeyTypes } from './KeyTypes.js'
 
@@ -33,6 +32,4 @@ export type OptionalKeys<T> = T extends unknown
 /**
  * Parse `T` to keep only the optional properties.
  */
-export type OptionalProps<T extends AnyRecord> = T extends unknown
-	? { [k in OptionalKeys<T>]?: T[k] }
-	: never
+export type OptionalProps<T extends AnyRecord> = T extends unknown ? { [k in OptionalKeys<T>]?: T[k] } : never

package/src/object/pick.ts

@@ -9,12 +9,12 @@ export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends Un
 	prop1: P1,
 	prop2: P2
 ): Pick<T, P1 | P2>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>
->(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(
+	subject: T,
+	prop1: P1,
+	prop2: P2,
+	prop3: P3
+): Pick<T, P1 | P2 | P3>
 export function pick<
 	T extends AnyRecord,
 	P1 extends UnionKeys<T>,
@@ -38,15 +38,7 @@ export function pick<
 	P4 extends UnionKeys<T>,
 	P5 extends UnionKeys<T>,
 	P6 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
+>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
 export function pick<
 	T extends AnyRecord,
 	P1 extends UnionKeys<T>,
@@ -191,10 +183,7 @@ export function pick<
 	prop11: P11,
 	prop12: P12
 ): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function pick<T extends AnyRecord, Props extends UnionKeys<T>>(
-	subject: T,
-	...props: Props[]
-): Pick<T, Props>
+export function pick<T extends AnyRecord, Props extends UnionKeys<T>>(subject: T, ...props: Props[]): Pick<T, Props>
 export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
 	return reduceByKey(
 		subject,

package/src/object/recursive_partial.ts

@@ -30,10 +30,10 @@ export type RecursivePartial<T> = {
 	[P in keyof T]?: T[P] extends (infer U)[]
 		? RecursivePartial<U>[] | undefined
 		: T[P] extends infer F extends AnyFunction
-		? [keyof T[P]] extends [undefined]
-			? T[P] | undefined
-			: ExtractFunction<F> & RecursivePartial<Properties<T[P]>>
-		: T[P] extends AnyRecord
-		? RecursivePartial<T[P]> | undefined
-		: T[P] | undefined
+			? [keyof T[P]] extends [undefined]
+				? T[P] | undefined
+				: ExtractFunction<F> & RecursivePartial<Properties<T[P]>>
+			: T[P] extends AnyRecord
+				? RecursivePartial<T[P]> | undefined
+				: T[P] | undefined
 }

package/src/object/split.ts

@@ -22,12 +22,7 @@ export function split<T extends AnyRecord, S1 extends Splitter<T>, S2 extends Sp
 	split1: S1,
 	split2: S2
 ): [Split<T, S1>, Split<T, S2>, Omit<T, keyof S1 | keyof S2>]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>
->(
+export function split<T extends AnyRecord, S1 extends Splitter<T>, S2 extends Splitter<T>, S3 extends Splitter<T>>(
 	target: T,
 	splitter1: S1,
 	splitter2: S2,
@@ -45,13 +40,7 @@ export function split<
 	splitter2: S2,
 	splitter3: S3,
 	splitter4: S4
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4>
-]
+): [Split<T, S1>, Split<T, S2>, Split<T, S3>, Split<T, S4>, Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4>]
 export function split<
 	T extends AnyRecord,
 	S1 extends Splitter<T>,
@@ -194,7 +183,7 @@ export function split<
 ]
 export function split(target: AnyRecord, ...splitters: AnyRecord[]): AnyRecord[] {
 	const keyMap: AnyRecord = {}
-	const s = splitters.map(s =>
+	const s = splitters.map((s) =>
 		reduceByKey(s, (p, k) => ((keyMap[k] = true), (p[k] = target[k] ?? s[k]), p), {} as AnyRecord)
 	)
 	const r = reduceByKey(target, (p, k) => (keyMap[k] ? p : ((p[k] = target[k]), p)), {} as AnyRecord)

package/src/object/typeOverrideIncompatible.ts

@@ -2,7 +2,7 @@ import type { ANotB, AnyRecord } from './index.js'
 
 export function typeOverrideIncompatible<A extends AnyRecord>() {
 	return <B extends AnyRecord>(source: B, override: ANotB<A, B>): A => ({
-			...source,
-			...override
-		})
+		...source,
+		...override
+	})
 }

package/src/predicates/CanAssign.ts

@@ -28,11 +28,11 @@ import type { NotExtendable } from './Extends.js'
  */
 export type CanAssign<A, B, Then = true, Else = false> = boolean extends A
 	? boolean extends B
-	? Then
-	: Else
+		? Then
+		: Else
 	: A extends B
-	? Then
-	: Else
+		? Then
+		: Else
 
 /**
  * Can `A` strictly assign to `B`.
@@ -47,7 +47,11 @@ export type CanAssign<A, B, Then = true, Else = false> = boolean extends A
  * StrictCanAssign<number | string, number | string> // true
  * ```
  */
-export type StrictCanAssign<A, B, Then = true, Else = false> = Assignable<A, B, { distributive: false, $then: Then, $else: Else }>
+export type StrictCanAssign<A, B, Then = true, Else = false> = Assignable<
+	A,
+	B,
+	{ distributive: false; $then: Then; $else: Else }
+>
 
 /**
  * @deprecated use `Assignable<A, B>` instead

package/src/predicates/assignable.ts

@@ -56,22 +56,23 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = Assignable<never, any, { $never: 1 }> // 1
  * ```
  */
-export type Assignable<
-	A,
+export type Assignable<A, B, $O extends Assignable.$Options = {}> = $SpecialType<
 	B,
-	$O extends Assignable.$Options = {}
-> = $SpecialType<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<A, {
-		$any: $ResolveBranch<A, $O, [$Any, $Then]>,
-		$unknown: $ResolveBranch<A, $O, [$Unknown, $Then]>,
-		$never: $ResolveBranch<A, $O, [$Never, $Then]>,
-		$else: Assignable.$<A, B, $O>
-	}>
-}>
-
+	{
+		$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<
+			A,
+			{
+				$any: $ResolveBranch<A, $O, [$Any, $Then]>
+				$unknown: $ResolveBranch<A, $O, [$Unknown, $Then]>
+				$never: $ResolveBranch<A, $O, [$Never, $Then]>
+				$else: Assignable.$<A, B, $O>
+			}
+		>
+	}
+>
 
 export namespace Assignable {
 	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
@@ -88,15 +89,13 @@ export namespace Assignable {
 	 *
 	 * It is suitable for building custom types.
 	 */
-	export type $<
-		A,
-		B,
-		$O extends $UtilOptions
-	> =
-		$IsDistributive<$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]>,
-		}>
+	export type $<A, B, $O extends $UtilOptions> = $IsDistributive<
+		$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]>
+		}
+	>
 
 	export type $UtilOptions = $SelectionOptions & $DistributiveOptions
 }

package/src/predicates/literal.ts

@@ -25,11 +25,11 @@ export type IsLiteral<
 > = number extends T
 	? Else
 	: string extends T
-	? Else
-	: boolean extends T
-	? Else
-	: symbol extends T
-	? Else
-	: bigint extends T
-	? Else
-	: Then
+		? Else
+		: boolean extends T
+			? Else
+			: symbol extends T
+				? Else
+				: bigint extends T
+					? Else
+					: Then

package/src/predicates/logical.ts

@@ -7,13 +7,13 @@ export type And<A extends boolean, B extends boolean, Then = true, Else = false>
 export type Or<A extends boolean, B extends boolean, Then = true, Else = false> = A extends true
 	? Then
 	: B extends true
-	? Then
-	: Else
+		? Then
+		: Else
 
 export type Not<X extends boolean, Then = true, Else = false> = X extends true ? Else : Then
 
 export type Xor<A extends boolean, B extends boolean, Then = true, Else = false> = A extends Then
 	? Not<B>
 	: B extends true
-	? Then
-	: Else
+		? Then
+		: Else

package/src/predicates/not_assignable.ts

@@ -56,21 +56,23 @@ import type { $Unknown } from '../unknown/unknown.js'
  * type R = NotAssignable<never, any, { $never: 1 }> // 1
  * ```
  */
-export type NotAssignable<
-	A,
+export type NotAssignable<A, B, $O extends NotAssignable.$Options = {}> = $SpecialType<
 	B,
-	$O extends NotAssignable.$Options = {}
-> = $SpecialType<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<A, {
-		$any: $ResolveBranch<A, $O, [$Any, $Else]>,
-		$unknown: $ResolveBranch<A, $O, [$Unknown, $Else]>,
-		$never: $ResolveBranch<A, $O, [$Never, $Else]>,
-		$else: NotAssignable.$<A, B, $O>
-	}>
-}>
+	{
+		$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<
+			A,
+			{
+				$any: $ResolveBranch<A, $O, [$Any, $Else]>
+				$unknown: $ResolveBranch<A, $O, [$Unknown, $Else]>
+				$never: $ResolveBranch<A, $O, [$Never, $Else]>
+				$else: NotAssignable.$<A, B, $O>
+			}
+		>
+	}
+>
 
 export namespace NotAssignable {
 	export type $Options = $SelectionOptions & $DistributiveOptions & $InputOptions<$Any | $Unknown | $Never>
@@ -87,14 +89,13 @@ export namespace NotAssignable {
 	 *
 	 * It is suitable for building custom types.
 	 */
-	export type $<
-		A,
-		B,
-		$O extends $UtilOptions
-	> = $IsDistributive<$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]>,
-	}>
+	export type $<A, B, $O extends $UtilOptions> = $IsDistributive<
+		$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]>
+		}
+	>
 
 	export type $UtilOptions = $SelectionOptions & $DistributiveOptions
 }

package/src/primitive.ts

@@ -1,13 +1,4 @@
 /**
  * 📘 Definition of all primitive types.
  */
-export type PrimitiveTypes =
-	| boolean
-	| number
-	| string
-	| object
-	| symbol
-	| bigint
-	| Function
-	| undefined
-	| null
+export type PrimitiveTypes = boolean | number | string | object | symbol | bigint | Function | undefined | null

package/src/promise/index.ts

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

package/src/promise/mapSeries.ts

@@ -1,3 +1,3 @@
 export function mapSeries<R, T = any>(values: T[], fn: (value: T) => Promise<R>): Promise<R[]> {
-	return values.reduce((p, v) => p.then(r => fn(v).then(v => (r.push(v), r))), Promise.resolve<R[]>([]))
+	return values.reduce((p, v) => p.then((r) => fn(v).then((v) => (r.push(v), r))), Promise.resolve<R[]>([]))
 }

package/src/string/$extract_manipulated_string.ts

@@ -8,38 +8,43 @@
  * - `Capitalize`
  * - `Uncapitalize`
  */
-export type $ExtractManipulatedString<T extends string> =
-	([T, unknown] extends [unknown, T]
-		? T
-		: $ExtractManipulatedString._UpperOrElse<T,
-			$ExtractManipulatedString._LowerOrElse<T,
-				$ExtractManipulatedString._CapOrElse<T,
-					$ExtractManipulatedString._UncapOrElse<T, T>>>>
-	)
+export type $ExtractManipulatedString<T extends string> = [T, unknown] extends [unknown, T]
+	? T
+	: $ExtractManipulatedString._UpperOrElse<
+			T,
+			$ExtractManipulatedString._LowerOrElse<
+				T,
+				$ExtractManipulatedString._CapOrElse<T, $ExtractManipulatedString._UncapOrElse<T, T>>
+			>
+		>
 
 export namespace $ExtractManipulatedString {
 	export type _UpperOrElse<N, Else> = N extends Uppercase<infer Y>
-		? (string extends Y
-			? Uppercase<any> extends N ? Y : N
+		? 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
+		? 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
+		? 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
+		? string extends Y
+			? Uncapitalize<any> extends N
+				? Y
+				: N
 			: $ExtractManipulatedString<Y>
-		)
 		: Else
 }

package/src/string/_string_type.ts

@@ -2,10 +2,10 @@ 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'
-	: never
+		? [K, U] extends [U, K]
+			? {} extends { [P in `${K}`]: unknown }
+				? 'templateLiteral'
+				: 'stringLiteral'
+			: 'string'
+		: never
 	: never