type-fest 4.11.0 → 4.12.0

package/index.d.ts

@@ -46,6 +46,7 @@ export type {ConditionalPick} from './source/conditional-pick';
 export type {ConditionalPickDeep, ConditionalPickDeepOptions} from './source/conditional-pick-deep';
 export type {UnionToIntersection} from './source/union-to-intersection';
 export type {Stringified} from './source/stringified';
+export type {StringSlice} from './source/string-slice';
 export type {FixedLengthArray} from './source/fixed-length-array';
 export type {MultidimensionalArray} from './source/multidimensional-array';
 export type {MultidimensionalReadonlyArray} from './source/multidimensional-readonly-array';
@@ -72,7 +73,14 @@ export type {
 	NonNegative,
 	NegativeInteger,
 	NonNegativeInteger,
+	IsNegative,
 } from './source/numeric';
+export type {GreaterThan} from './source/greater-than';
+export type {GreaterThanOrEqual} from './source/greater-than-or-equal';
+export type {LessThan} from './source/less-than';
+export type {LessThanOrEqual} from './source/less-than-or-equal';
+export type {Sum} from './source/sum';
+export type {Subtract} from './source/subtract';
 export type {StringKeyOf} from './source/string-key-of';
 export type {Exact} from './source/exact';
 export type {ReadonlyTuple} from './source/readonly-tuple';
@@ -104,6 +112,7 @@ export type {IsUnknown} from './source/is-unknown';
 export type {IfUnknown} from './source/if-unknown';
 export type {ArrayIndices} from './source/array-indices';
 export type {ArrayValues} from './source/array-values';
+export type {ArraySlice} from './source/array-slice';
 export type {ArraySplice} from './source/array-splice';
 export type {SetFieldType} from './source/set-field-type';
 export type {Paths} from './source/paths';

package/package.json

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

package/readme.md

@@ -239,11 +239,13 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`Trim`](source/trim.d.ts) - Remove leading and trailing spaces from a string.
 - [`Split`](source/split.d.ts) - Represents an array of strings split using a given character or character set.
 - [`Replace`](source/replace.d.ts) - Represents a string with some or all matches replaced by a replacement.
+- [`StringSlice`](source/string-slice.d.ts) - Returns a string slice of a given range, just like `String#slice()`.
 
 ### Array
 
 - [`Includes`](source/includes.d.ts) - Returns a boolean for whether the given array includes the given item.
 - [`Join`](source/join.d.ts) - Join an array of strings and/or numbers using the given string as a delimiter.
+- [`ArraySlice`](source/array-slice.d.ts) - Returns an array slice of a given range, just like `Array#slice()`.
 - [`LastArrayElement`](source/last-array-element.d.ts) - Extracts the type of the last element of an array.
 - [`FixedLengthArray`](source/fixed-length-array.d.ts) - Create a type that represents an array of the given type and length.
 - [`MultidimensionalArray`](source/multidimensional-array.d.ts) - Create a type that represents a multidimensional array of the given type and dimensions.
@@ -263,6 +265,13 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - [`NonNegative`](source/numeric.d.ts) - A non-negative `number`/`bigint` (`0 <= x < ∞`).
 - [`NegativeInteger`](source/numeric.d.ts) - A negative (`-∞ < x < 0`) `number` that is an integer.
 - [`NonNegativeInteger`](source/numeric.d.ts) - A non-negative (`0 <= x < ∞`) `number` that is an integer.
+- [`IsNegative`](source/numeric.d.ts) - Returns a boolean for whether the given number is a negative number.
+- [`GreaterThan`](source/greater-than.d.ts) - Returns a boolean for whether a given number is greater than another number.
+- [`GreaterThanOrEqual`](source/greater-than-or-equal.d.ts) - Returns a boolean for whether a given number is greater than or equal to another number.
+- [`LessThan`](source/less-than.d.ts) - Returns a boolean for whether a given number is less than another number.
+- [`LessThanOrEqual`](source/less-than-or-equal.d.ts) - Returns a boolean for whether a given number is less than or equal to another number.
+- [`Sum`](source/sum.d.ts) - Returns the sum of two numbers.
+- [`Subtract`](source/subtract.d.ts) - Returns the difference between two numbers.
 
 ### Change case
 

package/source/array-slice.d.ts

@@ -0,0 +1,93 @@
+import type {Sum} from './sum';
+import type {LessThan} from './less-than';
+import type {LessThanOrEqual} from './less-than-or-equal';
+import type {IsNegative} from './numeric';
+import type {And} from './internal';
+import type {IsEqual} from './is-equal';
+
+/**
+Returns an array slice of a given range, just like `Array#slice()`.
+
+@example
+```
+import type {ArraySlice} from 'type-fest';
+
+type T0 = ArraySlice<[0, 1, 2, 3, 4]>;
+//=> [0, 1, 2, 3, 4]
+
+type T1 = ArraySlice<[0, 1, 2, 3, 4], 0, -1>;
+//=> [0, 1, 2, 3]
+
+type T2 = ArraySlice<[0, 1, 2, 3, 4], 1, -2>;
+//=> [1, 2]
+
+type T3 = ArraySlice<[0, 1, 2, 3, 4], -2, 4>;
+//=> [3]
+
+type T4 = ArraySlice<[0, 1, 2, 3, 4], -2, -1>;
+//=> [3]
+
+type T5 = ArraySlice<[0, 1, 2, 3, 4], 0, -999>;
+//=> []
+
+function arraySlice<
+	const Array_ extends readonly unknown[],
+	Start extends number = 0,
+	End extends number = Array_['length'],
+>(array: Array_, start?: Start, end?: End) {
+	return array.slice(start, end) as ArraySlice<Array_, Start, End>;
+}
+
+const slice = arraySlice([1, '2', {a: 3}, [4, 5]], 0, -1);
+
+typeof slice;
+//=> [1, '2', { readonly a: 3; }]
+
+slice[2].a;
+//=> 3
+
+// @ts-expect-error -- TS2493: Tuple type '[1, "2", {readonly a: 3}]' of length '3' has no element at index '3'.
+slice[3];
+```
+
+@category Array
+*/
+export type ArraySlice<
+	Array_ extends readonly unknown[],
+	Start extends number = 0,
+	End extends number = Array_['length'],
+> = ArraySliceHelper<Array_, Start, End>;
+
+type ArraySliceHelper<
+	Array_ extends readonly unknown[],
+	Start extends number = 0,
+	End extends number = Array_['length'],
+	TraversedElement extends Array<Array_[number]> = [],
+	Result extends Array<Array_[number]> = [],
+	ArrayLength extends number = Array_['length'],
+	PositiveS extends number = IsNegative<Start> extends true
+		? Sum<ArrayLength, Start> extends infer AddResult extends number
+			? number extends AddResult // (ArrayLength + Start) < 0
+				? 0
+				: AddResult
+			: never
+		: Start,
+	PositiveE extends number = IsNegative<End> extends true ? Sum<ArrayLength, End> : End,
+> = true extends [IsNegative<PositiveS>, LessThanOrEqual<PositiveE, PositiveS>][number]
+	? []
+	: ArraySliceByPositiveIndex<Array_, PositiveS, PositiveE>;
+
+type ArraySliceByPositiveIndex<
+	Array_ extends readonly unknown[],
+	Start extends number,
+	End extends number,
+	TraversedElement extends Array<Array_[number]> = [],
+	Result extends Array<Array_[number]> = [],
+> = Array_ extends readonly [infer H, ...infer Rest]
+	? And<
+	IsEqual<LessThanOrEqual<Start, TraversedElement['length']>, true>,
+	IsEqual<LessThan<TraversedElement['length'], End>, true>
+	> extends true
+		? ArraySliceByPositiveIndex<Rest, Start, End, [...TraversedElement, H], [...Result, H]>
+		: ArraySliceByPositiveIndex<Rest, Start, End, [...TraversedElement, H], Result>
+	: Result;

package/source/array-splice.d.ts

@@ -1,4 +1,6 @@
-import type {BuildTuple, Subtract, StaticPartOfArray, VariablePartOfArray, GTE} from './internal';
+import type {BuildTuple, StaticPartOfArray, VariablePartOfArray} from './internal';
+import type {GreaterThanOrEqual} from './greater-than-or-equal';
+import type {Subtract} from './subtract';
 import type {UnknownArray} from './unknown-array';
 
 /**
@@ -23,7 +25,7 @@ type SplitVariableArrayByIndex<T extends UnknownArray,
 > =
 SplitIndex extends 0
 	? [[], T]
-	: GTE<StaticPartOfArray<T>['length'], SplitIndex> extends true
+	: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
 		? [
 			SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
 			[

package/source/greater-than-or-equal.d.ts

@@ -0,0 +1,22 @@
+import type {GreaterThan} from './greater-than';
+
+/**
+Returns a boolean for whether a given number is greater than or equal to another number.
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+GreaterThanOrEqual<1, -5>;
+//=> true
+
+GreaterThanOrEqual<1, 1>;
+//=> true
+
+GreaterThanOrEqual<1, 5>;
+//=> false
+```
+*/
+export type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B
+	? never
+	: A extends B ? true : GreaterThan<A, B>;

package/source/greater-than.d.ts

@@ -0,0 +1,49 @@
+import type {NumberAbsolute, And, Or, PositiveNumericStringGt} from './internal';
+import type {IsEqual} from './is-equal';
+import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
+
+/**
+Returns a boolean for whether a given number is greater than another number.
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+GreaterThan<1, -5>;
+//=> true
+
+GreaterThan<1, 1>;
+//=> false
+
+GreaterThan<1, 5>;
+//=> false
+```
+*/
+export type GreaterThan<A extends number, B extends number> = number extends A | B
+	? never
+	: [
+		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
+			? true
+			: Or<
+			And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
+			And<IsEqual<R[2], true>, IsEqual<R[0], false>>
+			> extends true
+				? false
+				: true extends R[number]
+					? false
+					: [IsNegative<A>, IsNegative<B>] extends infer R extends [boolean, boolean]
+						? [true, false] extends R
+							? false
+							: [false, true] extends R
+								? true
+								: [false, false] extends R
+									? PositiveNumericStringGt<`${A}`, `${B}`>
+									: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
+						: never
+		: never;

package/source/int-range.d.ts

@@ -1,4 +1,5 @@
-import type {BuildTuple, Subtract} from './internal';
+import type {BuildTuple} from './internal';
+import type {Subtract} from './subtract';
 
 /**
 Generate a union of numbers.

package/source/internal.d.ts

@@ -2,6 +2,9 @@ import type {Primitive} from './primitive';
 import type {Simplify} from './simplify';
 import type {Trim} from './trim';
 import type {IsAny} from './is-any';
+import type {NegativeInfinity, PositiveInfinity} from './numeric';
+import type {GreaterThan} from './greater-than';
+import type {LessThan} from './less-than';
 import type {IsLiteral} from './is-literal';
 import type {UnknownRecord} from './unknown-record';
 import type {IsNever} from './is-never';
@@ -52,7 +55,7 @@ If `<Fill>` is not provided, it will default to `unknown`.
 
 @link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
 */
-export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = T extends {readonly length: L}
+export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = T['length'] extends L
 	? T
 	: BuildTuple<L, Fill, [...T, Fill]>;
 
@@ -87,16 +90,6 @@ Note: This type is not the return type of the `.toString()` function.
 */
 export type ToString<T> = T extends string | number ? `${T}` : never;
 
-/**
-Create a tuple of length `A` and a tuple composed of two other tuples,
-the inferred tuple `U` and a tuple of length `B`, then extracts the length of tuple `U`.
-
-@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
-*/
-export type Subtract<A extends number, B extends number> = BuildTuple<A> extends [...(infer U), ...BuildTuple<B>]
-	? ArrayLength<U>
-	: never;
-
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
@@ -117,6 +110,108 @@ export type IsPlainObject<T> =
 			? true
 			: false;
 
+/**
+Converts a numeric string to a number.
+
+@example
+```
+type PositiveInt = StringToNumber<'1234'>;
+//=> 1234
+
+type NegativeInt = 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
+```
+
+@category String
+@category Numeric
+@category Template literal
+*/
+export type StringToNumber<S extends string> = S extends `${infer N extends number}`
+	? N
+	: S extends 'Infinity'
+		? PositiveInfinity
+		: S extends '-Infinity'
+			? NegativeInfinity
+			: never;
+
+/**
+Returns a boolean for whether the given string `S` starts with the given string `SearchString`.
+
+@example
+```
+StartsWith<'abcde', 'abc'>;
+//=> true
+
+StartsWith<'abcde', 'bc'>;
+//=> false
+
+StartsWith<string, 'bc'>;
+//=> never
+
+StartsWith<'abcde', string>;
+//=> never
+```
+
+@category String
+@category Template literal
+*/
+export type StartsWith<S extends string, SearchString extends string> = string extends S | SearchString
+	? never
+	: S extends `${SearchString}${infer T}`
+		? true
+		: false;
+
+/**
+Returns the length of the given string.
+
+@example
+```
+StringLength<'abcde'>;
+//=> 5
+
+StringLength<string>;
+//=> never
+```
+
+@category String
+@category Template literal
+*/
+export type StringLength<S extends string> = string extends S
+	? never
+	: StringToArray<S>['length'];
+
+/**
+Returns an array of the characters of the string.
+
+@example
+```
+StringToArray<'abcde'>;
+//=> ['a', 'b', 'c', 'd', 'e']
+
+StringToArray<string>;
+//=> never
+```
+
+@category String
+*/
+export type StringToArray<S extends string, Result extends string[] = []> = string extends S
+	? never
+	: S extends `${infer F}${infer R}`
+		? StringToArray<R, [...Result, F]>
+		: Result;
+
 export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
 
 export type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
@@ -359,6 +454,190 @@ IsPrimitive<Object>
 */
 export type IsPrimitive<T> = [T] extends [Primitive] ? true : false;
 
+/**
+Returns a boolean for whether A and B are both true.
+
+@example
+```
+And<true, true>;
+//=> true
+
+And<true, false>;
+//=> false
+```
+*/
+export type And<A extends boolean, B extends boolean> = [A, B][number] extends true
+	? true
+	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
+		? false
+		: never;
+
+/**
+Returns a boolean for either A or B is true.
+
+@example
+```
+Or<true, false>;
+//=> true
+
+Or<false, false>;
+//=> false
+```
+*/
+export type Or<A extends boolean, B extends boolean> = [A, B][number] extends false
+	? false
+	: true extends [IsEqual<A, true>, IsEqual<B, true>][number]
+		? true
+		: never;
+
+/**
+Returns a boolean for whether A is false.
+
+@example
+```
+Not<true>;
+//=> false
+
+Not<false>;
+//=> true
+```
+*/
+export type Not<A extends boolean> = A extends true
+	? false
+	: A extends false
+		? true
+		: never;
+
+/**
+Returns the maximum value from a tuple of integers.
+
+Note:
+- Float numbers are not supported.
+
+@example
+```
+ArrayMax<[1, 2, 5, 3]>;
+//=> 5
+
+ArrayMax<[1, 2, 5, 3, 99, -1]>;
+//=> 99
+```
+*/
+export type ArrayMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number]
+	? never :
+	A extends [infer F extends number, ...infer R extends number[]]
+		? GreaterThan<F, Result> extends true
+			? ArrayMax<R, F>
+			: ArrayMax<R, Result>
+		: Result;
+
+/**
+Returns the minimum value from a tuple of integers.
+
+Note:
+- Float numbers are not supported.
+
+@example
+```
+ArrayMin<[1, 2, 5, 3]>;
+//=> 1
+
+ArrayMin<[1, 2, 5, 3, -5]>;
+//=> -5
+```
+*/
+export type ArrayMin<A extends number[], Result extends number = PositiveInfinity> = number extends A[number]
+	? never
+	: A extends [infer F extends number, ...infer R extends number[]]
+		? LessThan<F, Result> extends true
+			? ArrayMin<R, F>
+			: ArrayMin<R, Result>
+		: Result;
+
+/**
+Returns the absolute value of a given value.
+
+@example
+```
+NumberAbsolute<-1>;
+//=> 1
+
+NumberAbsolute<1>;
+//=> 1
+
+NumberAbsolute<NegativeInfinity>
+//=> PositiveInfinity
+```
+*/
+export type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
+
+/**
+Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both numeric strings and have the same length.
+
+@example
+```
+SameLengthPositiveNumericStringGt<'50', '10'>;
+//=> true
+
+SameLengthPositiveNumericStringGt<'10', '10'>;
+//=> false
+```
+*/
+type SameLengthPositiveNumericStringGt<A extends string, B extends string> = A extends `${infer FirstA}${infer RestA}`
+	? B extends `${infer FirstB}${infer RestB}`
+		? FirstA extends FirstB
+			? SameLengthPositiveNumericStringGt<RestA, RestB>
+			: PositiveNumericCharacterGt<FirstA, FirstB>
+		: never
+	: false;
+
+type NumericString = '0123456789';
+
+/**
+Returns a boolean for whether `A` is greater than `B`, where `A` and `B` are both positive numeric strings.
+
+@example
+```
+PositiveNumericStringGt<'500', '1'>;
+//=> true
+
+PositiveNumericStringGt<'1', '1'>;
+//=> false
+
+PositiveNumericStringGt<'1', '500'>;
+//=> false
+```
+*/
+export type PositiveNumericStringGt<A extends string, B extends string> = A extends B
+	? false
+	: [BuildTuple<StringLength<A>, 0>, BuildTuple<StringLength<B>, 0>] extends infer R extends [readonly unknown[], readonly unknown[]]
+		? R[0] extends [...R[1], ...infer Remain extends readonly unknown[]]
+			? 0 extends Remain['length']
+				? SameLengthPositiveNumericStringGt<A, B>
+				: true
+			: false
+		: never;
+
+/**
+Returns a boolean for whether `A` represents a number greater than `B`, where `A` and `B` are both positive numeric characters.
+
+@example
+```
+PositiveNumericCharacterGt<'5', '1'>;
+//=> true
+
+PositiveNumericCharacterGt<'1', '1'>;
+//=> false
+```
+*/
+type PositiveNumericCharacterGt<A extends string, B extends string> = NumericString extends `${infer HeadA}${A}${infer TailA}`
+	? NumericString extends `${infer HeadB}${B}${infer TailB}`
+		? HeadA extends `${HeadB}${infer _}${infer __}`
+			? true
+			: false
+		: never
+	: never;
+
 /**
 Utility type to retrieve only literal keys from type.
 */
@@ -506,42 +785,6 @@ Returns whether the given array `T` is readonly.
 */
 export type IsArrayReadonly<T extends UnknownArray> = T extends unknown[] ? false : true;
 
-/**
-Returns the result of `A >= B`.
-
-@example
-```
-type A = GTE<15, 10>;
-//=> true
-
-type B = GTE<10, 15>;
-//=> false
-
-type C = GTE<10, 10>;
-//=> true
-```
-*/
-export type GTE<A extends number, B extends number> =
-	BuildTuple<A> extends [...infer _, ...BuildTuple<B>]
-		? true
-		: false;
-
-/**
-Returns the result of `A > B`
-
-@example
-```
-type A = GT<15, 10>;
-//=> true
-
-type B = GT<10, 15>;
-//=> false
-*/
-export type GT<A extends number, B extends number> =
-	IsEqual<A, B> extends true
-		? false
-		: GTE<A, B>;
-
 /**
 Get the exact version of the given `Key` in the given object `T`.
 

package/source/less-than-or-equal.d.ts

@@ -0,0 +1,22 @@
+import type {GreaterThan} from './greater-than';
+
+/**
+ Returns a boolean for whether a given number is less than or equal to another number.
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+LessThanOrEqual<1, -5>;
+//=> false
+
+LessThanOrEqual<1, 1>;
+//=> true
+
+LessThanOrEqual<1, 5>;
+//=> true
+```
+*/
+export type LessThanOrEqual<A extends number, B extends number> = number extends A | B
+	? never
+	: GreaterThan<A, B> extends true ? false : true;

package/source/less-than.d.ts

@@ -0,0 +1,22 @@
+import type {GreaterThanOrEqual} from './greater-than-or-equal';
+
+/**
+Returns a boolean for whether a given number is less than another number.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+LessThan<1, -5>;
+//=> false
+
+LessThan<1, 1>;
+//=> false
+
+LessThan<1, 5>;
+//=> true
+```
+*/
+export type LessThan<A extends number, B extends number> = number extends A | B
+	? never
+	: GreaterThanOrEqual<A, B> extends true ? false : true;

package/source/merge-deep.d.ts

@@ -15,7 +15,7 @@ import type {EnforceOptional} from './enforce-optional';
 /**
 Deeply simplifies an object excluding iterables and functions. Used internally to improve the UX and accept both interfaces and type aliases as inputs.
 */
-type SimplifyDeep<Type> = ConditionalSimplifyDeep<Type, Function | Iterable<unknown>, object>;
+export type SimplifyDeep<Type> = ConditionalSimplifyDeep<Type, Function | Iterable<unknown>, object>;
 
 /**
 Try to merge two record properties or return the source property value, preserving `undefined` properties values in both cases.

package/source/multidimensional-array.d.ts

@@ -1,4 +1,4 @@
-import type {Subtract} from './internal';
+import type {Subtract} from './subtract';
 import type {IsEqual} from './is-equal';
 
 type Recursive<T> = Array<Recursive<T>>;

package/source/multidimensional-readonly-array.d.ts

@@ -1,4 +1,4 @@
-import type {Subtract} from './internal';
+import type {Subtract} from './subtract';
 import type {IsEqual} from './is-equal';
 
 type Recursive<T> = ReadonlyArray<Recursive<T>>;

package/source/numeric.d.ts

@@ -168,3 +168,20 @@ declare function setLength<T extends number>(length: NonNegativeInteger<T>): voi
 @category Numeric
 */
 export type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;
+
+/**
+Returns a boolean for whether the given number is a negative number.
+
+@see Negative
+
+@example
+```
+import type {IsNegative} from 'type-fest';
+
+type ShouldBeFalse = IsNegative<1>;
+type ShouldBeTrue = IsNegative<-1>;
+```
+
+@category Numeric
+*/
+export type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;

package/source/string-slice.d.ts

@@ -0,0 +1,37 @@
+import type {Join} from './join';
+import type {ArraySlice} from './array-slice';
+import type {StringToArray} from './internal';
+
+/**
+Returns a string slice of a given range, just like `String#slice()`.
+
+@see {ArraySlice}
+
+@example
+```
+import type {StringSlice} from 'type-fest';
+
+StringSlice<'abcde', 0, 2>;
+//=> 'ab'
+
+StringSlice<'abcde', 1>;
+//=> 'bcde'
+
+StringSlice<'abcde', 0, -1>;
+//=> 'abcd'
+
+StringSlice<'abcde', -2, -1>;
+//=> 'd'
+```
+
+@category String
+*/
+export type StringSlice<
+	S extends string,
+	Start extends number = 0,
+	End extends number = StringToArray<S>['length'],
+> = string extends S
+	? string[]
+	: ArraySlice<StringToArray<S>, Start, End> extends infer R extends readonly string[]
+		? Join<R, ''>
+		: never;

package/source/subtract.d.ts

@@ -0,0 +1,66 @@
+import type {NumberAbsolute, BuildTuple, And, Or} from './internal';
+import type {IsEqual} from './is-equal';
+import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
+import type {LessThan} from './less-than';
+import type {Sum} from './sum';
+
+/**
+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
+```
+import type {Subtract} from 'type-fest';
+
+Subtract<333, 222>;
+//=> 111
+
+Subtract<111, -222>;
+//=> 333
+
+Subtract<-111, 222>;
+//=> number
+
+Subtract<PositiveInfinity, 9999>;
+//=> PositiveInfinity
+
+Subtract<PositiveInfinity, PositiveInfinity>;
+//=> number
+```
+
+@category Numeric
+*/
+// TODO: Support big integer and negative number.
+export type Subtract<A extends number, B extends 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
+	: never;

package/source/sum.d.ts

@@ -0,0 +1,66 @@
+import type {NumberAbsolute, BuildTuple, And, Or, ArrayMax, ArrayMin} from './internal';
+import type {IsEqual} from './is-equal';
+import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
+import type {Subtract} from './subtract';
+
+/**
+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
+```
+import type {Sum} from 'type-fest';
+
+Sum<111, 222>;
+//=> 333
+
+Sum<-111, 222>;
+//=> 111
+
+Sum<111, -222>;
+//=> number
+
+Sum<PositiveInfinity, -9999>;
+//=> PositiveInfinity
+
+Sum<PositiveInfinity, NegativeInfinity>;
+//=> number
+```
+
+@category Numeric
+*/
+// TODO: Support big integer and negative number.
+export type Sum<A extends number, B extends 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
+							: ArrayMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_
+								? ArrayMin<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Min_ extends number
+									? Max_ extends A | B
+										? Subtract<Max_, Min_>
+										: number
+									: never
+								: never
+					: never) & number
+	: never;