@depup/type-fest 5.4.4-depup.0 → 5.9.0-depup.0

package/source/set-required.d.ts

@@ -6,7 +6,7 @@ import type {Simplify} from './simplify.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
-Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
+Create a type that makes the given keys required, while keeping the remaining keys as is.
 
 Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
 
@@ -21,11 +21,7 @@ type Foo = {
 };
 
 type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
-// type SomeRequired = {
-// 	a?: number;
-// 	b: string; // Was already required and still is.
-// 	c: boolean; // Is now required.
-// }
+//=> {a?: number; b: string; c: boolean}
 
 // Set specific indices in an array to be required.
 type ArrayExample = SetRequired<[number?, number?, number?], 0 | 1>;
@@ -47,9 +43,9 @@ type _SetRequired<BaseType, Keys extends keyof BaseType> =
 			: never
 		: Simplify<
 		// Pick just the keys that are optional from the base type.
-			Except<BaseType, Keys> &
+			Except<BaseType, Keys>
 		// Pick the keys that should be required from the base type and make them required.
-			Required<HomomorphicPick<BaseType, Keys>>
+			& Required<HomomorphicPick<BaseType, Keys>>
 		>;
 
 /**

package/source/shared-union-fields-deep.d.ts

@@ -89,7 +89,7 @@ function displayPetInfoWithSharedUnionFieldsDeep(petInfo: SharedUnionFieldsDeep<
 export type SharedUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOptions = {}> =
 	ApplyDefaultOptions<SharedUnionFieldsDeepOptions, DefaultSharedUnionFieldsDeepOptions, Options> extends infer OptionsWithDefaults extends Required<SharedUnionFieldsDeepOptions>
 	// `Union extends` will convert `Union`
-	// to a [distributive conditionaltype](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	// to a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
 	// But this is not what we want, so we need to wrap `Union` with `[]` to prevent it.
 		? [Union] extends [NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>]
 			? Union
@@ -106,11 +106,12 @@ export type SharedUnionFieldsDeep<Union, Options extends SharedUnionFieldsDeepOp
 Same as `SharedUnionFieldsDeep`, but accepts only `object`s and as inputs. Internal helper for `SharedUnionFieldsDeep`.
 */
 type SharedObjectUnionFieldsDeep<Union, Options extends Required<SharedUnionFieldsDeepOptions>> =
-	// `keyof Union` can extract the same key in union type, if there is no same key, return never.
-	keyof Union extends infer Keys
+	// Extract the shared keys from the union. Throughout this type, use `Keys` instead of `keyof Union`
+	// to prevent the mapped type from distributing over the union.
+	keyof Union extends infer Keys extends keyof Union
 		? IsNever<Keys> extends false
 			? {
-				[Key in keyof Union]:
+				[Key in Keys]:
 				Union[Key] extends NonRecursiveType
 					? Union[Key]
 					// Remove `undefined` from the union to support optional

package/source/shared-union-fields.d.ts

@@ -66,14 +66,14 @@ function displayPetInfoWithSharedUnionFields(petInfo: SharedUnionFields<Cat | Do
 @category Union
 */
 export type SharedUnionFields<Union> =
-Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
-	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
-		?
-		| SkippedMembers
-		| (IsNever<RelevantMembers> extends true
-			? never
-			: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
-		: never
-	: never;
+	Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+		? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+			? // eslint-disable-line @stylistic/operator-linebreak
+			| SkippedMembers
+			| (IsNever<RelevantMembers> extends true
+				? never
+				: Simplify<Pick<RelevantMembers, keyof RelevantMembers>>)
+			: never
+		: never;
 
 export {};

package/source/snake-case.d.ts

@@ -16,6 +16,7 @@ import type {SnakeCase} from 'type-fest';
 const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
 const noSplitOnNumbers: SnakeCase<'p2pNetwork'> = 'p2p_network';
 const splitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: true}> = 'p_2_p_network';
+const splitOnPunctuation: SnakeCase<'div.card::after', {splitOnPunctuation: true}> = 'div_card_after';
 
 // Advanced
 

package/source/snake-cased-properties-deep.d.ts

@@ -51,6 +51,13 @@ const splitOnNumbers: SnakeCasedPropertiesDeep<{line1: {line2: [{line3: string}]
 		],
 	},
 };
+
+const splitOnPunctuation: SnakeCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	'user_info': {
+		'user_id': 1,
+		'user_name': 'Tom',
+	},
+};
 ```
 
 @category Change case

package/source/snake-cased-properties.d.ts

@@ -4,7 +4,7 @@ import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.d.ts';
 
 /**
-Convert object properties to snake case but not recursively.
+Convert top-level object properties to snake case.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -28,6 +28,10 @@ const result: SnakeCasedProperties<User> = {
 const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
 	'line_1': 'string',
 };
+
+const splitOnPunctuation: SnakeCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	'foo_bar': 'string',
+};
 ```
 
 @category Change case

package/source/some-extend.d.ts

@@ -0,0 +1,115 @@
+import type {CollapseRestElement} from './internal/array.d.ts';
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
+import type {IsAny} from './is-any.d.ts';
+import type {IsNever} from './is-never.d.ts';
+import type {Or} from './or.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+@see {@link SomeExtend}
+*/
+export type SomeExtendOptions = {
+	/**
+	Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+
+	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+	- When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+
+	@default true
+
+	@example
+	```
+	import type {SomeExtend} from 'type-fest';
+
+	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
+	//=> false
+
+	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
+	//=> true
+
+	type C = SomeExtend<[1, never], never, {strictNever: true}>;
+	//=> true
+
+	type D = SomeExtend<[1, never], never, {strictNever: false}>;
+	//=> true
+
+	type E = SomeExtend<[never], any, {strictNever: true}>;
+	//=> true
+
+	type F = SomeExtend<[never], any, {strictNever: false}>;
+	//=> true
+	```
+	*/
+	strictNever?: boolean;
+};
+
+type DefaultSomeExtendOptions = {
+	strictNever: true;
+};
+
+/**
+Returns a boolean for whether some element in an array type extends another type.
+
+@example
+```
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<['1', '2', 3], number>;
+//=> true
+
+type B = SomeExtend<[1, 2, 3], string>;
+//=> false
+
+type C = SomeExtend<[string, number | string], number>;
+//=> boolean
+
+type D = SomeExtend<[true, boolean, true], false>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+// @exactOptionalPropertyTypes: true
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> true
+```
+
+```
+// @exactOptionalPropertyTypes: false
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> boolean
+
+type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
+//=> true
+```
+
+@see {@link SomeExtendOptions}
+
+@category Utilities
+@category Array
+*/
+export type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> =
+	_SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, {
+	ifNot: TArray extends readonly [infer First, ...infer Rest]
+		? IsNever<First> extends true
+			? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true
+				// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+				? true
+				: _SomeExtend<Rest, Type, Options>
+			: First extends Type
+				? true
+				: _SomeExtend<Rest, Type, Options>
+		: false;
+	ifAny: false;
+	ifNever: false;
+}>;
+
+export {};

package/source/split-on-rest-element.d.ts

@@ -65,10 +65,12 @@ export type SplitOnRestElement<
 	Options extends SplitOnRestElementOptions = {},
 > =
 	Array_ extends unknown // For distributing `Array_`
-		? IfNotAnyOrNever<Array_, _SplitOnRestElement<
-			Array_,
-			ApplyDefaultOptions<SplitOnRestElementOptions, DefaultSplitOnRestElementOptions, Options>
-		>> extends infer Result extends UnknownArray
+		? IfNotAnyOrNever<Array_, {
+			ifNot: _SplitOnRestElement<
+				Array_,
+				ApplyDefaultOptions<SplitOnRestElementOptions, DefaultSplitOnRestElementOptions, Options>
+			>;
+		}> extends infer Result extends UnknownArray
 			? If<IsArrayReadonly<Array_>, Readonly<Result>, Result>
 			: never // Should never happen
 		: never; // Should never happen

package/source/split.d.ts

@@ -1,6 +1,6 @@
 import type {And} from './and.d.ts';
 import type {ApplyDefaultOptions, Not} from './internal/index.d.ts';
-import type {IsStringLiteral} from './is-literal.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
 import type {Or} from './or.d.ts';
 
 /**

package/source/spread.d.ts

@@ -41,11 +41,7 @@ const bar = {c: false};
 const fooBar = {...foo, ...bar};
 
 type FooBar = Spread<Foo, Bar>;
-// type FooBar = {
-// 	a: number;
-// 	b?: string | number | undefined;
-// 	c: boolean;
-// }
+//=> {a: number; b?: string | number; c: boolean}
 
 declare function baz(argument: FooBar): void;
 

package/source/string-length.d.ts

@@ -0,0 +1,38 @@
+import type {StringToArray} from './string-to-array.d.ts';
+
+/**
+Returns the length of the given string.
+
+@example
+```
+import type {StringLength} from 'type-fest';
+
+type A = StringLength<'abcde'>;
+//=> 5
+
+type B = StringLength<'abcde' | 'fgh'>;
+//=> 3 | 5
+```
+
+For non-literal strings, the result is `number` because the length of a non-literal string can be any number.
+
+@example
+```
+import type {StringLength} from 'type-fest';
+
+type A = StringLength<string>;
+//=> number
+
+type B = StringLength<Uppercase<string>>;
+//=> number
+
+type C = StringLength<`${string}abc`>;
+//=> number
+```
+
+@category String
+@category Template literal
+*/
+export type StringLength<S extends string> = StringToArray<S>['length'];
+
+export {};

package/source/string-repeat.d.ts

@@ -1,5 +1,6 @@
-import type {IsNumericLiteral} from './is-literal.d.ts';
+import type {IsNumericLiteral} from './is-numeric-literal.d.ts';
 import type {IsNegative} from './numeric.d.ts';
+import type {DigitCharacter} from './characters.d.ts';
 
 /**
 Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
@@ -9,9 +10,9 @@ Returns a new string which contains the specified number of copies of a given st
 import type {StringRepeat} from 'type-fest';
 
 declare function stringRepeat<
-	Input extends string,
+	S extends string,
 	Count extends number,
->(input: Input, count: Count): StringRepeat<Input, Count>;
+>(input: S, count: Count): StringRepeat<S, Count>;
 
 // The return type is the exact string literal, not just `string`.
 
@@ -22,28 +23,54 @@ stringRepeat('=', 3);
 //=> '==='
 ```
 
+Note: If the specified count has a decimal part, the decimal part will be ignored.
+
+@example
+```
+import type {StringRepeat} from 'type-fest';
+
+type DecimalCount = StringRepeat<'foo', 2.5>;
+//=> 'foofoo'
+```
+
 @category String
 @category Template literal
 */
-export type StringRepeat<
-	Input extends string,
-	Count extends number,
-> = StringRepeatHelper<Input, Count>;
-
-type StringRepeatHelper<
-	Input extends string,
-	Count extends number,
-	Counter extends never[] = [],
-	Accumulator extends string = '',
-> =
-	IsNegative<Count> extends true
-		? never
-		: Input extends ''
-			? ''
-			: Count extends Counter['length']
-				? Accumulator
+export type StringRepeat<S extends string, Count extends number> =
+	Count extends unknown // To distribute `Count`
+		? IsNegative<Count> extends true
+			? never
+			: S extends ''
+				? ''
 				: IsNumericLiteral<Count> extends false
 					? string
-					: StringRepeatHelper<Input, Count, [...Counter, never], `${Accumulator}${Input}`>;
+					: `${Count}` extends `${string}e${string}`
+						? string
+						: BuildStringDigitByDigit<S, `${Count}`>
+		: never;
+
+type BuildStringDigitByDigit<S extends string, Count extends string, Accumulator extends string = ''> =
+	Count extends `${infer First extends DigitCharacter}${infer Rest}`
+		? BuildStringDigitByDigit<
+			S,
+			Rest,
+			`${RepeatStringTenTimes<Accumulator>}${DigitStringRepeat<S, First>}`
+		>
+		: Accumulator;
+
+type RepeatStringTenTimes<S extends string> = `${S}${S}${S}${S}${S}${S}${S}${S}${S}${S}`;
+
+type DigitStringRepeat<S extends string, Digit extends DigitCharacter> = [
+	'',
+	`${S}`,
+	`${S}${S}`,
+	`${S}${S}${S}`,
+	`${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}${S}${S}`,
+][Digit];
 
 export {};

package/source/string-slice.d.ts

@@ -1,6 +1,6 @@
 import type {Join} from './join.d.ts';
 import type {ArraySlice} from './array-slice.d.ts';
-import type {StringToArray} from './internal/index.d.ts';
+import type {StringToArray} from './string-to-array.d.ts';
 
 /**
 Returns a string slice of a given range, just like `String#slice()`.

package/source/string-to-array.d.ts

@@ -0,0 +1,97 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {Or} from './or.d.ts';
+
+/**
+@see {@link StringToArray}
+*/
+export type StringToArrayOptions = {
+	/**
+	When enabled, non-literal parts of the string (e.g., `string`, `Uppercase<string>`) are mapped as single elements instead of being mapped as a rest element.
+
+	Note: Enabling this option can produce misleading results that might not reflect the actual runtime behavior.
+	For example, `StringToArray<string, {mapNonLiteralsDirectly: true}>` returns `[string]`, but at runtime, the string could be `'abc'` (which satisfies `string`), and converting it to an array would result in `['a', 'b', 'c']`, which doesn't satisfy `[string]`.
+
+	So, it is recommended to not enable this option unless you are aware of the implications.
+
+	@default false
+
+	@example
+	```
+	import type {StringToArray} from 'type-fest';
+
+	type A = StringToArray<string, {mapNonLiteralsDirectly: false}>;
+	//=> string[]
+
+	type B = StringToArray<string, {mapNonLiteralsDirectly: true}>;
+	//=> [string]
+
+	type C = StringToArray<`on${string}`, {mapNonLiteralsDirectly: false}>;
+	//=> ['o', 'n', ...string[]]
+
+	type D = StringToArray<`on${string}`, {mapNonLiteralsDirectly: true}>;
+	//=> ['o', 'n', string]
+
+	type E = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: false}>;
+	//=> [...string[], 'x', 'y', 'z']
+
+	type F = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: true}>;
+	//=> [string, 'x', 'y', 'z']
+	```
+	*/
+	mapNonLiteralsDirectly?: boolean;
+};
+
+type DefaultStringToArrayOptions = {
+	mapNonLiteralsDirectly: false;
+};
+
+/**
+Returns an array of the characters of the specified string.
+
+@example
+```
+import type {StringToArray} from 'type-fest';
+
+type A = StringToArray<'abcde'>;
+//=> ['a', 'b', 'c', 'd', 'e']
+
+type B = StringToArray<''>;
+//=> []
+
+type C = StringToArray<string>;
+//=> string[]
+
+type D = StringToArray<`foo${string}bar`>;
+//=> ['f', 'o', 'o', ...string[], 'b', 'a', 'r']
+
+type E = StringToArray<`foo${string}bar`, {mapNonLiteralsDirectly: true}>;
+//=> ['f', 'o', 'o', string, 'b', 'a', 'r']
+```
+
+@see {@link StringToArrayOptions}
+
+@category String
+*/
+export type StringToArray<S extends string, Options extends StringToArrayOptions = {}> =
+	IfNotAnyOrNever<
+		S,
+		{
+			ifNot: _StringToArray<S, ApplyDefaultOptions<StringToArrayOptions, DefaultStringToArrayOptions, Options>>;
+			ifAny: unknown[];
+		}
+	>;
+
+type _StringToArray<S extends string, Options extends Required<StringToArrayOptions>, Accumulator extends string[] = []> =
+	S extends `${infer First}${infer Rest}`
+		? Or<IsStringLiteral<First>, Options['mapNonLiteralsDirectly']> extends true
+			? _StringToArray<Rest, Options, [...Accumulator, First]>
+			: _StringToArray<Rest, Options, [...Accumulator, ...First[]]>
+		: S extends ''
+			? Accumulator
+			: Options['mapNonLiteralsDirectly'] extends true
+				? [...Accumulator, S]
+				: [...Accumulator, ...S[]];
+
+export {};

package/source/string-to-number.d.ts

@@ -0,0 +1,67 @@
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from './numeric.d.ts';
+
+/**
+Converts a numeric string to a number.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type PositiveInteger = StringToNumber<'1234'>;
+//=> 1234
+
+type NegativeInteger = StringToNumber<'-1234'>;
+//=> -1234
+
+type PositiveFloat = StringToNumber<'1234.56'>;
+//=> 1234.56
+
+type NegativeFloat = StringToNumber<'-1234.56'>;
+//=> -1234.56
+
+type PositiveInfinity = StringToNumber<'Infinity'>;
+//=> Infinity
+
+type NegativeInfinity = StringToNumber<'-Infinity'>;
+//=> -Infinity
+```
+
+Note: Some strings, such as `'1.50'`, `'0b10'`, or `'12_345'`, may look like they can be converted to numbers, but they don't actually have corresponding numeric literals. So, in such cases, this type produces `never`. See [type-fest#1446](https://github.com/sindresorhus/type-fest/pull/1446) for more details.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type FractionalsEndingInZero = StringToNumber<'1.50'>;
+//=> never
+
+type NonDecimalBases = StringToNumber<'0b10' | '0o10' | '0x10'>;
+//=> never
+
+type NumericSeparators = StringToNumber<'12_345'>;
+//=> never
+```
+
+@category String
+@category Numeric
+@category Template literal
+*/
+export type StringToNumber<S extends string> = IfNotAnyOrNever<S, {ifNot: _StringToNumber<S>; ifAny: number}>;
+
+type _StringToNumber<S extends string> =
+	S extends `${infer N extends number}`
+		? number extends N
+			? `${number}` extends S
+				? N
+				: never
+			: N
+		: string extends S
+			? number
+			: S extends 'Infinity'
+				? PositiveInfinity
+				: S extends '-Infinity'
+					? NegativeInfinity
+					: never;
+
+export {};

package/source/subtract.d.ts

@@ -1,7 +1,8 @@
-import type {NumberAbsolute, ReverseSign} from './internal/index.d.ts';
+import type {ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {LessThan} from './less-than.d.ts';
 import type {TupleOf} from './tuple-of.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns the difference between two numbers.
@@ -59,9 +60,9 @@ type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNeg
 		? SubtractPositives<A, B>
 		: AreNegative extends [true, true]
 			// When both numbers are negative we subtract the absolute values and then reverse the sign
-			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			? ReverseSign<SubtractPositives<Absolute<A>, Absolute<B>>>
 			// When the signs are different we can add the absolute values and then reverse the sign if A < B
-			: [...TupleOf<NumberAbsolute<A>>, ...TupleOf<NumberAbsolute<B>>] extends infer R extends unknown[]
+			: [...TupleOf<Absolute<A>>, ...TupleOf<Absolute<B>>] extends infer R extends unknown[]
 				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
 				: never;
 

package/source/sum.d.ts

@@ -1,7 +1,8 @@
 import type {TupleOf} from './tuple-of.d.ts';
-import type {NumberAbsolute, TupleMax, ReverseSign} from './internal/index.d.ts';
+import type {TupleMax, ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {Subtract} from './subtract.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns the sum of two numbers.
@@ -57,11 +58,11 @@ type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative
 		? SumPositives<A, B>
 		: AreNegative extends [true, true]
 			// When both numbers are negative we add the absolute values and then reverse the sign
-			? ReverseSign<SumPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			? ReverseSign<SumPositives<Absolute<A>, Absolute<B>>>
 			// When the signs are different we can subtract the absolute values, remove the sign
 			// and then reverse the sign if the larger absolute value is negative
-			: NumberAbsolute<Subtract<NumberAbsolute<A>, NumberAbsolute<B>>> extends infer Result extends number
-				? TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_ extends number
+			: Absolute<Subtract<Absolute<A>, Absolute<B>>> extends infer Result extends number
+				? TupleMax<[Absolute<A>, Absolute<B>]> extends infer Max_ extends number
 					? Max_ extends A | B
 						// The larger absolute value is positive, so the result is positive
 						? Result