type-fest 4.35.0 → 4.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "4.35.0",
+	"version": "4.37.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/source/array-slice.d.ts

@@ -91,7 +91,7 @@ type ArraySliceHelper<
 		? Sum<ArrayLength, Start> extends infer AddResult extends number
 			? number extends AddResult // (ArrayLength + Start) < 0
 				? 0
-				: AddResult
+				: GreaterThan<AddResult, 0> extends true ? AddResult : 0
 			: never
 		: Start,
 	PositiveE extends number = IsNegative<End> extends true ? Sum<ArrayLength, End> : End,

package/source/array-splice.d.ts

@@ -21,7 +21,9 @@ The implementation of `SplitArrayByIndex` for variable length arrays.
 type SplitVariableArrayByIndex<T extends UnknownArray,
 	SplitIndex extends number,
 	T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>,
-	T2 = T1 extends number ? BuildTuple<T1, VariablePartOfArray<T>[number]> : [],
+	T2 = T1 extends number
+		? BuildTuple<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
+		: [],
 > =
 SplitIndex extends 0
 	? [[], T]

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

@@ -75,14 +75,9 @@ type CamelCasedPropertiesArrayDeep<Value extends UnknownArray> =
 				: // Leading spread array
 				Value extends readonly [...infer U, infer V]
 					? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>]
-					: Value extends readonly [...infer U, infer V]
-						? readonly [
-							...CamelCasedPropertiesDeep<U>,
-							CamelCasedPropertiesDeep<V>,
-						]
-						: // Array
-						Value extends Array<infer U>
-							? Array<CamelCasedPropertiesDeep<U>>
-							: Value extends ReadonlyArray<infer U>
-								? ReadonlyArray<CamelCasedPropertiesDeep<U>>
-								: never;
+					: // Array
+					Value extends Array<infer U>
+						? Array<CamelCasedPropertiesDeep<U>>
+						: Value extends ReadonlyArray<infer U>
+							? ReadonlyArray<CamelCasedPropertiesDeep<U>>
+							: never;

package/source/delimiter-case.d.ts

@@ -1,54 +1,23 @@
-import type {UpperCaseCharacters, WordSeparators} from './internal';
-
-// Transforms a string that is fully uppercase into a fully lowercase version. Needed to add support for SCREAMING_SNAKE_CASE, see https://github.com/sindresorhus/type-fest/issues/385
-type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
-
-// This implementation does not support SCREAMING_SNAKE_CASE, it is used internally by `SplitIncludingDelimiters`.
-type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> =
-	Source extends '' ? [] :
-		Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ?
-			(
-				Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}`
-					? UsedDelimiter extends Delimiter
-						? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}`
-							? [...SplitIncludingDelimiters<FirstPart, Delimiter>, UsedDelimiter, ...SplitIncludingDelimiters<SecondPart, Delimiter>]
-							: never
-						: never
-					: never
-			) :
-			[Source];
-
-/**
-Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
-
-@category Template literal
-*/
-export type SplitIncludingDelimiters<Source extends string, Delimiter extends string> = SplitIncludingDelimiters_<UpperCaseToLowerCase<Source>, Delimiter>;
+import type {IsStringLiteral} from './is-literal';
+import type {Words, WordsOptions} from './words';
 
 /**
-Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
-
-@see StringArrayToDelimiterCase
+Convert an array of words to delimiter case starting with a delimiter with input capitalization.
 */
-type StringPartToDelimiterCase<StringPart extends string, Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
-	StringPart extends UsedWordSeparators ? Delimiter :
-		Start extends true ? Lowercase<StringPart> :
-			StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` :
-				StringPart;
-
-/**
-Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
-
-It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
-
-@see SplitIncludingDelimiters
-*/
-type StringArrayToDelimiterCase<Parts extends readonly any[], Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
-	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
-		? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
-		: Parts extends [string]
-			? string
-			: '';
+type DelimiterCaseFromArray<
+	Words extends string[],
+	Delimiter extends string,
+	OutputString extends string = '',
+> = Words extends [
+	infer FirstWord extends string,
+	...infer RemainingWords extends string[],
+]
+	? DelimiterCaseFromArray<RemainingWords, Delimiter, `${OutputString}${Delimiter}${FirstWord}`>
+	: OutputString;
+
+type RemoveFirstLetter<S extends string> = S extends `${infer _}${infer Rest}`
+	? Rest
+	: '';
 
 /**
 Convert a string literal to a custom string delimiter casing.
@@ -65,6 +34,7 @@ import type {DelimiterCase} from 'type-fest';
 // Simple
 
 const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
 
 // Advanced
 
@@ -87,13 +57,17 @@ const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
 
 @category Change case
 @category Template literal
-*/
-export type DelimiterCase<Value, Delimiter extends string> = string extends Value ? Value : Value extends string
-	? StringArrayToDelimiterCase<
-	SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>,
-	true,
-	WordSeparators,
-	UpperCaseCharacters,
-	Delimiter
-	>
+ */
+export type DelimiterCase<
+	Value,
+	Delimiter extends string,
+	Options extends WordsOptions = {splitOnNumbers: false},
+> = Value extends string
+	? IsStringLiteral<Value> extends false
+		? Value
+		: Lowercase<
+		RemoveFirstLetter<
+		DelimiterCaseFromArray<Words<Value, Options>, Delimiter>
+		>
+		>
 	: Value;

package/source/internal/numeric.d.ts

@@ -1,4 +1,5 @@
 import type {IsNever} from '../is-never';
+import type {NegativeInfinity, PositiveInfinity} from '../numeric';
 import type {UnknownArray} from '../unknown-array';
 import type {StringToNumber} from './string';
 
@@ -89,3 +90,29 @@ type InternalUnionMax<N extends number, T extends UnknownArray = []> =
 		:	T['length'] extends N
 			? InternalUnionMax<Exclude<N, T['length']>, T>
 			: InternalUnionMax<N, [...T, unknown]>;
+
+/**
+Returns the number with reversed sign.
+
+@example
+```
+ReverseSign<-1>;
+//=> 1
+
+ReverseSign<1>;
+//=> -1
+
+ReverseSign<NegativeInfinity>
+//=> PositiveInfinity
+
+ReverseSign<PositiveInfinity>
+//=> NegativeInfinity
+```
+*/
+export type ReverseSign<N extends number> =
+	// Handle edge cases
+	N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity :
+	// Handle negative numbers
+	`${N}` extends `-${infer P extends number}` ? P
+		// Handle positive numbers
+		: `-${N}` extends `${infer R extends number}` ? R : never;

package/source/kebab-case.d.ts

@@ -1,4 +1,5 @@
 import type {DelimiterCase} from './delimiter-case';
+import type {WordsOptions} from './words';
 
 /**
 Convert a string literal to kebab-case.
@@ -12,6 +13,7 @@ import type {KebabCase} from 'type-fest';
 // Simple
 
 const someVariable: KebabCase<'fooBar'> = 'foo-bar';
+const someVariableNoSplitOnNumbers: KebabCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p-network';
 
 // Advanced
 
@@ -35,4 +37,7 @@ const rawCliOptions: KebabCasedProperties<CliOptions> = {
 @category Change case
 @category Template literal
 */
-export type KebabCase<Value> = DelimiterCase<Value, '-'>;
+export type KebabCase<
+	Value,
+	Options extends WordsOptions = {splitOnNumbers: false},
+> = DelimiterCase<Value, '-', Options>;

package/source/paths.d.ts

@@ -246,13 +246,7 @@ type InternalPaths<T, Options extends Required<PathsOptions>> =
 										bracketNotation: Options['bracketNotation'];
 										maxRecursionDepth: Subtract<MaxDepth, 1>;
 										leavesOnly: Options['leavesOnly'];
-										depth: Options['depth'] extends infer Depth extends number // For distributing `Options['depth']`
-											? Depth extends 0 // Don't subtract further if `Depth` has reached `0`
-												? never
-												: ToString<Depth> extends `-${number}` // Don't subtract if `Depth` is -ve
-													? never
-													: Subtract<Options['depth'], 1> // If `Subtract` supported -ve numbers, then `depth` could have simply been `Subtract<Options['depth'], 1>`
-											: never; // Should never happen
+										depth: Subtract<Options['depth'], 1>;
 									}> extends infer SubPath
 										? SubPath extends string | number
 											? (

package/source/replace.d.ts

@@ -60,8 +60,20 @@ export type Replace<
 	Search extends string,
 	Replacement extends string,
 	Options extends ReplaceOptions = {},
-> = Input extends `${infer Head}${Search}${infer Tail}`
-	? Options['all'] extends true
-		? `${Head}${Replacement}${Replace<Tail, Search, Replacement, Options>}`
-		: `${Head}${Replacement}${Tail}`
-	: Input;
+> = _Replace<Input, Search, Replacement, Options>;
+
+type _Replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+	Options extends ReplaceOptions,
+	Accumulator extends string = '',
+> = Search extends string // For distributing `Search`
+	? Replacement extends string // For distributing `Replacement`
+		? Input extends `${infer Head}${Search}${infer Tail}`
+			? Options['all'] extends true
+				? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`>
+				: `${Head}${Replacement}${Tail}`
+			: `${Accumulator}${Input}`
+		: never
+	: never;

package/source/screaming-snake-case.d.ts

@@ -1,15 +1,5 @@
-import type {SplitIncludingDelimiters} from './delimiter-case';
 import type {SnakeCase} from './snake-case';
-import type {Includes} from './includes';
-
-/**
-Returns a boolean for whether the string is screaming snake case.
-*/
-type IsScreamingSnakeCase<Value extends string> = Value extends Uppercase<Value>
-	? Includes<SplitIncludingDelimiters<Lowercase<Value>, '_'>, '_'> extends true
-		? true
-		: false
-	: false;
+import type {WordsOptions} from './words';
 
 /**
 Convert a string literal to screaming-snake-case.
@@ -21,13 +11,14 @@ This can be useful when, for example, converting a camel-cased object property t
 import type {ScreamingSnakeCase} from 'type-fest';
 
 const someVariable: ScreamingSnakeCase<'fooBar'> = 'FOO_BAR';
+const someVariableNoSplitOnNumbers: ScreamingSnakeCase<'p2pNetwork', {splitOnNumbers: false}> = 'P2P_NETWORK';
+
 ```
 
 @category Change case
 @category Template literal
-*/
-export type ScreamingSnakeCase<Value> = Value extends string
-	? IsScreamingSnakeCase<Value> extends true
-		? Value
-		: Uppercase<SnakeCase<Value>>
-	: Value;
+ */
+export type ScreamingSnakeCase<
+	Value,
+	Options extends WordsOptions = {splitOnNumbers: false},
+> = Value extends string ? Uppercase<SnakeCase<Value, Options>> : Value;

package/source/snake-case.d.ts

@@ -1,4 +1,5 @@
 import type {DelimiterCase} from './delimiter-case';
+import type {WordsOptions} from './words';
 
 /**
 Convert a string literal to snake-case.
@@ -12,6 +13,7 @@ import type {SnakeCase} from 'type-fest';
 // Simple
 
 const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
+const someVariableNoSplitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p_network';
 
 // Advanced
 
@@ -35,4 +37,7 @@ const dbResult: SnakeCasedProperties<ModelProps> = {
 @category Change case
 @category Template literal
 */
-export type SnakeCase<Value> = DelimiterCase<Value, '_'>;
+export type SnakeCase<
+	Value,
+	Options extends WordsOptions = {splitOnNumbers: false},
+> = DelimiterCase<Value, '_', Options>;

package/source/split.d.ts

@@ -1,3 +1,43 @@
+import type {And} from './and';
+import type {Not} from './internal';
+import type {IsStringLiteral} from './is-literal';
+import type {Or} from './or';
+
+/**
+Split options.
+
+@see {@link Split}
+*/
+type SplitOptions = {
+	/**
+	When enabled, instantiations with non-literal string types (e.g., `string`, `Uppercase<string>`, `on${string}`) simply return back `string[]` without performing any splitting, as the exact structure cannot be statically determined.
+
+	Note: In the future, this option might be enabled by default, so if you currently rely on this being disabled, you should consider explicitly enabling it.
+
+	@default false
+
+	@example
+	```ts
+	type Example1 = Split<`foo.${string}.bar`, '.', {strictLiteralChecks: false}>;
+	//=> ['foo', string, 'bar']
+
+	type Example2 = Split<`foo.${string}`, '.', {strictLiteralChecks: true}>;
+	//=> string[]
+
+	type Example3 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: false}>;
+	//=> ['foo', 'r', 'z']
+
+	type Example4 = Split<'foobarbaz', `b${string}`, {strictLiteralChecks: true}>;
+	//=> string[]
+	```
+	*/
+	strictLiteralChecks?: boolean;
+};
+
+type DefaultSplitOptions = {
+	strictLiteralChecks: false;
+};
+
 /**
 Represents an array of strings split using a given character or character set.
 
@@ -16,20 +56,34 @@ let array: Item[];
 array = split(items, ',');
 ```
 
+@see {@link SplitOptions}
+
 @category String
 @category Template literal
 */
 export type Split<
 	S extends string,
 	Delimiter extends string,
-> = SplitHelper<S, Delimiter>;
+	Options extends SplitOptions = {},
+> = SplitHelper<S, Delimiter, {
+	strictLiteralChecks: Options['strictLiteralChecks'] extends boolean ? Options['strictLiteralChecks'] : DefaultSplitOptions['strictLiteralChecks'];
+}>;
 
 type SplitHelper<
 	S extends string,
 	Delimiter extends string,
+	Options extends Required<SplitOptions>,
 	Accumulator extends string[] = [],
-> = S extends `${infer Head}${Delimiter}${infer Tail}`
-	? SplitHelper<Tail, Delimiter, [...Accumulator, Head]>
-	: Delimiter extends ''
-		? Accumulator
-		: [...Accumulator, S];
+> = S extends string // For distributing `S`
+	? Delimiter extends string // For distributing `Delimeter`
+		// If `strictLiteralChecks` is `false` OR `S` and `Delimiter` both are string literals, then perform the split
+		? Or<Not<Options['strictLiteralChecks']>, And<IsStringLiteral<S>, IsStringLiteral<Delimiter>>> extends true
+			? S extends `${infer Head}${Delimiter}${infer Tail}`
+				? SplitHelper<Tail, Delimiter, Options, [...Accumulator, Head]>
+				: Delimiter extends ''
+					? Accumulator
+					: [...Accumulator, S]
+			// Otherwise, return `string[]`
+			: string[]
+		: never // Should never happen
+	: never; // Should never happen

package/source/subtract.d.ts

@@ -1,17 +1,12 @@
-import type {NumberAbsolute, BuildTuple} from './internal';
-import type {IsEqual} from './is-equal';
+import type {NumberAbsolute, BuildTuple, ReverseSign} from './internal';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
 import type {LessThan} from './less-than';
-import type {Sum} from './sum';
-import type {And} from './and';
-import type {Or} from './or';
 
 /**
 Returns the difference between two numbers.
 
 Note:
 - A or B can only support `-999` ~ `999`.
-- If the result is negative, you can only get `number`.
 
 @example
 ```
@@ -24,7 +19,10 @@ Subtract<111, -222>;
 //=> 333
 
 Subtract<-111, 222>;
-//=> number
+//=> -333
+
+Subtract<18, 96>;
+//=> -78
 
 Subtract<PositiveInfinity, 9999>;
 //=> PositiveInfinity
@@ -35,36 +33,51 @@ Subtract<PositiveInfinity, PositiveInfinity>;
 
 @category Numeric
 */
-// TODO: Support big integer and negative number.
-export type Subtract<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-		And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-		> extends true
-			? PositiveInfinity
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-			And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-			> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: [IsNegative<A>, IsNegative<B>] extends infer R
-						? [false, false] extends R
-							? BuildTuple<A> extends infer R
-								? R extends [...BuildTuple<B>, ...infer R]
-									? R['length']
-									: number
-								: never
-							: LessThan<A, B> extends true
-								? number
-								: [false, true] extends R
-									? Sum<A, NumberAbsolute<B>>
-									: Subtract<NumberAbsolute<B>, NumberAbsolute<A>>
-						: never
+// TODO: Support big integer.
+export type Subtract<A extends number, B extends number> =
+	// Handle cases when A or B is the actual "number" type
+	number extends A | B ? number
+		// Handle cases when A and B are both +/- infinity
+		: A extends B & (PositiveInfinity | NegativeInfinity) ? number
+			// Handle cases when A is - infinity or B is + infinity
+			: A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity
+				// Handle cases when A is + infinity or B is - infinity
+				: A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity
+					// Handle case when numbers are equal to each other
+					: A extends B ? 0
+						// Handle cases when A or B is 0
+						: A extends 0 ? ReverseSign<B> : B extends 0 ? A
+							// Handle remaining regular cases
+							: SubtractPostChecks<A, B>;
+
+/**
+Subtracts two numbers A and B, such that they are not equal and neither of them are 0, +/- infinity or the `number` type
+*/
+type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
+	AreNegative extends [false, false]
+		? 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>>>
+			// When the signs are different we can add the absolute values and then reverse the sign if A < B
+			: [...BuildTuple<NumberAbsolute<A>>, ...BuildTuple<NumberAbsolute<B>>] extends infer R extends unknown[]
+				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
+				: never;
+
+/**
+Subtracts two positive numbers.
+*/
+type SubtractPositives<A extends number, B extends number> =
+	LessThan<A, B> extends true
+		// When A < B we can reverse the result of B - A
+		? ReverseSign<SubtractIfAGreaterThanB<B, A>>
+		: SubtractIfAGreaterThanB<A, B>;
+
+/**
+Subtracts two positive numbers A and B such that A > B.
+*/
+type SubtractIfAGreaterThanB<A extends number, B extends number> =
+	// This is where we always want to end up and do the actual subtraction
+	BuildTuple<A> extends [...BuildTuple<B>, ...infer R]
+		? R['length']
 		: never;

package/source/sum.d.ts

@@ -1,17 +1,12 @@
-import type {NumberAbsolute, BuildTuple, TupleMax, TupleMin} from './internal';
-import type {IsEqual} from './is-equal';
+import type {NumberAbsolute, BuildTuple, TupleMax, ReverseSign} from './internal';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
 import type {Subtract} from './subtract';
-import type {And} from './and';
-import type {Or} from './or';
 
 /**
 Returns the sum of two numbers.
 
 Note:
 - A or B can only support `-999` ~ `999`.
-- A and B can only be small integers, less than 1000.
-- If the result is negative, you can only get `number`.
 
 @example
 ```
@@ -24,7 +19,7 @@ Sum<-111, 222>;
 //=> 111
 
 Sum<111, -222>;
-//=> number
+//=> -111
 
 Sum<PositiveInfinity, -9999>;
 //=> PositiveInfinity
@@ -35,36 +30,49 @@ Sum<PositiveInfinity, NegativeInfinity>;
 
 @category Numeric
 */
-// TODO: Support big integer and negative number.
-export type Sum<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[3], false>>,
-		And<IsEqual<R[2], true>, IsEqual<R[1], false>>
-		> extends true
-			? PositiveInfinity
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[2], false>>,
-			And<IsEqual<R[3], true>, IsEqual<R[0], false>>
-			> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: ([IsNegative<A>, IsNegative<B>] extends infer R
-						? [false, false] extends R
-							? [...BuildTuple<A>, ...BuildTuple<B>]['length']
-							: [true, true] extends R
-								? number
-								: TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_
-									? TupleMin<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Min_ extends number
-										? Max_ extends A | B
-											? Subtract<Max_, Min_>
-											: number
-										: never
-									: never
-						: never) & number
+// TODO: Support big integer.
+export type Sum<A extends number, B extends number> =
+	// Handle cases when A or B is the actual "number" type
+	number extends A | B ? number
+		// Handle cases when A and B are both +/- infinity
+		: A extends B & (PositiveInfinity | NegativeInfinity) ? A // A or B could be used here as they are equal
+			// Handle cases when A and B are opposite infinities
+			: A | B extends PositiveInfinity | NegativeInfinity ? number
+				// Handle cases when A is +/- infinity
+				: A extends PositiveInfinity | NegativeInfinity ? A
+					// Handle cases when B is +/- infinity
+					: B extends PositiveInfinity | NegativeInfinity ? B
+						// Handle cases when A or B is 0 or it's the same number with different signs
+						: A extends 0 ? B : B extends 0 ? A : A extends ReverseSign<B> ? 0
+							// Handle remaining regular cases
+							: SumPostChecks<A, B>;
+
+/**
+Adds two numbers A and B, such that they are not equal with different signs and neither of them are 0, +/- infinity or the `number` type
+*/
+type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
+	AreNegative extends [false, false]
+		// When both numbers are positive we can add them together
+		? 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>>>
+			// 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
+					? Max_ extends A | B
+						// The larger absolute value is positive, so the result is positive
+						? Result
+						// The larger absolute value is negative, so the result is negative
+						: ReverseSign<Result>
+					: never
+				: never;
+
+/**
+Adds two positive numbers.
+*/
+type SumPositives<A extends number, B extends number> =
+	[...BuildTuple<A>, ...BuildTuple<B>]['length'] extends infer Result extends number
+		? Result
 		: never;

package/source/tsconfig-json.d.ts

@@ -18,6 +18,7 @@ declare namespace TsConfigJson {
 			| 'ES2022'
 			| 'ESNext'
 			| 'Node16'
+			| 'Node18'
 			| 'NodeNext'
 			| 'Preserve'
 			| 'None'
@@ -32,6 +33,7 @@ declare namespace TsConfigJson {
 			| 'es2022'
 			| 'esnext'
 			| 'node16'
+			| 'node18'
 			| 'nodenext'
 			| 'preserve'
 			| 'none';
@@ -1109,6 +1111,20 @@ declare namespace TsConfigJson {
 		Suppress deprecation warnings
 		*/
 		ignoreDeprecations?: CompilerOptions.IgnoreDeprecations;
+
+		/**
+		Do not allow runtime constructs that are not part of ECMAScript.
+
+		@default false
+		*/
+		erasableSyntaxOnly?: boolean;
+
+		/**
+		Enable lib replacement.
+
+		@default true
+		*/
+		libReplacement?: boolean;
 	};
 
 	namespace WatchOptions {
@@ -1160,12 +1176,12 @@ declare namespace TsConfigJson {
 		synchronousWatchDirectory?: boolean;
 
 		/**
-		Specifies a list of directories to exclude from watch
+		Specifies a list of directories to exclude from watch.
 		*/
 		excludeDirectories?: string[];
 
 		/**
-		Specifies a list of files to exclude from watch
+		Specifies a list of files to exclude from watch.
 		*/
 		excludeFiles?: string[];
 	};

package/source/words.d.ts

@@ -1,11 +1,46 @@
-import type {IsLowerCase, IsNumeric, IsUpperCase, WordSeparators} from './internal';
+import type {
+	IsLowerCase,
+	IsNumeric,
+	IsUpperCase,
+	WordSeparators,
+} from './internal';
 
 type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
 
-type RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}`
+type RemoveLastCharacter<
+	Sentence extends string,
+	Character extends string,
+> = Sentence extends `${infer LeftSide}${Character}`
 	? SkipEmptyWord<LeftSide>
 	: never;
 
+/**
+Words options.
+
+@see {@link Words}
+*/
+export type WordsOptions = {
+	/**
+	Split on numeric sequence.
+
+	@default true
+
+	@example
+	```
+	type Example1 = Words<'p2pNetwork', {splitOnNumbers: true}>;
+	//=> ["p", "2", "p", "Network"]
+
+	type Example2 = Words<'p2pNetwork', {splitOnNumbers: false}>;
+	//=> ["p2p", "Network"]
+	```
+	*/
+	splitOnNumbers?: boolean;
+};
+
+type DefaultOptions = {
+	splitOnNumbers: true;
+};
+
 /**
 Split a string (almost) like Lodash's `_.words()` function.
 
@@ -31,37 +66,53 @@ type Words3 = Words<'--hello the_world'>;
 
 type Words4 = Words<'lifeIs42'>;
 //=> ['life', 'Is', '42']
+
+type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
+//=> ['p2p', 'Network']
 ```
 
 @category Change case
 @category Template literal
 */
-export type Words<
+export type Words<Sentence extends string, Options extends WordsOptions = {}> = WordsImplementation<Sentence, {
+	splitOnNumbers: Options['splitOnNumbers'] extends boolean ? Options['splitOnNumbers'] : DefaultOptions['splitOnNumbers'];
+}>;
+
+type WordsImplementation<
 	Sentence extends string,
+	Options extends Required<WordsOptions>,
 	LastCharacter extends string = '',
 	CurrentWord extends string = '',
 > = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}`
 	? FirstCharacter extends WordSeparators
 		// Skip word separator
-		? [...SkipEmptyWord<CurrentWord>, ...Words<RemainingCharacters>]
+		? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>]
 		: LastCharacter extends ''
 			// Fist char of word
-			? Words<RemainingCharacters, FirstCharacter, FirstCharacter>
-			// Case change: non-numeric to numeric, push word
+			? WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>
+			// Case change: non-numeric to numeric
 			: [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-				? [...SkipEmptyWord<CurrentWord>, ...Words<RemainingCharacters, FirstCharacter, FirstCharacter>]
-				// Case change: numeric to non-numeric, push word
+				? Options['splitOnNumbers'] extends true
+					// Split on number: push word
+					? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
+					// No split on number: concat word
+					: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+				// Case change: numeric to non-numeric
 				: [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-					? [...SkipEmptyWord<CurrentWord>, ...Words<RemainingCharacters, FirstCharacter, FirstCharacter>]
+					? Options['splitOnNumbers'] extends true
+						// Split on number: push word
+						? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
+						// No split on number: concat word
+						: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
 					// No case change: concat word
 					: [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>]
-						? Words<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+						? WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
 					// Case change: lower to upper, push word
 						: [true, true] extends [IsLowerCase<LastCharacter>, IsUpperCase<FirstCharacter>]
-							? [...SkipEmptyWord<CurrentWord>, ...Words<RemainingCharacters, FirstCharacter, FirstCharacter>]
+							? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>]
 						// Case change: upper to lower, brings back the last character, push word
 							: [true, true] extends [IsUpperCase<LastCharacter>, IsLowerCase<FirstCharacter>]
-								? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...Words<RemainingCharacters, FirstCharacter, `${LastCharacter}${FirstCharacter}`>]
+								? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${LastCharacter}${FirstCharacter}`>]
 							// No case change: concat word
-								: Words<RemainingCharacters, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
+								: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`>
 	: [...SkipEmptyWord<CurrentWord>];