type-fest 4.11.1 → 4.13.0

package/index.d.ts

@@ -6,6 +6,7 @@ export * from './source/observable-like';
 
 // Utilities
 export type {KeysOfUnion} from './source/keys-of-union';
+export type {DistributedOmit} from './source/distributed-omit';
 export type {EmptyObject, IsEmptyObject} from './source/empty-object';
 export type {NonEmptyObject} from './source/non-empty-object';
 export type {UnknownRecord} from './source/unknown-record';
@@ -46,6 +47,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 +74,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 +113,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.1",
+	"version": "4.13.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",

package/readme.md

@@ -182,6 +182,7 @@ Click the type names for complete docs.
 - [`SetFieldType`](source/set-field-type.d.ts) - Create a type that changes the type of the given keys.
 - [`Paths`](source/paths.d.ts) - Generate a union of all possible paths to properties in the given object.
 - [`SharedUnionFieldsDeep`](source/shared-union-fields-deep.d.ts) - Create a type with shared fields from a union of object types, deeply traversing nested structures.
+- [`DistributedOmit`](source/distributed-omit.d.ts) - Omits keys from a type, distributing the operation over a union.
 
 ### Type Guard
 
@@ -239,11 +240,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 +266,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
 
@@ -314,6 +324,7 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - `RequireOnlyOne` - See [`RequireExactlyOne`](source/require-exactly-one.d.ts)
 - `AtMostOne` - See [`RequireOneOrNone`](source/require-one-or-none.d.ts)
 - `AllKeys` - See [`KeysOfUnion`](source/keys-of-union.d.ts)
+- `Branded` - See [`Opaque`](source/opaque.d.ts)
 
 ## Tips
 

package/source/array-slice.d.ts

@@ -0,0 +1,106 @@
+import type {Sum} from './sum';
+import type {LessThanOrEqual} from './less-than-or-equal';
+import type {GreaterThanOrEqual} from './greater-than-or-equal';
+import type {GreaterThan} from './greater-than';
+import type {IsNegative} from './numeric';
+import type {And, Not, ArrayMin} from './internal';
+import type {IsEqual} from './is-equal';
+import type {ArraySplice} from './array-splice';
+
+/**
+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 = never,
+	End extends number = never,
+> = And<IsEqual<Start, never>, IsEqual<End, never>> extends true
+	? Array_
+	: number extends Array_['length']
+		? VariableLengthArraySliceHelper<Array_, Start, End>
+		: ArraySliceHelper<Array_, IsEqual<Start, never> extends true ? 0 : Start, IsEqual<End, never> extends true ? Array_['length'] : End>;
+
+type VariableLengthArraySliceHelper<
+	Array_ extends readonly unknown[],
+	Start extends number,
+	End extends number,
+> = And<Not<IsNegative<Start>>, IsEqual<End, never>> extends true
+	? ArraySplice<Array_, 0, Start>
+	: And<
+	And<Not<IsNegative<Start>>, Not<IsNegative<End>>>,
+	IsEqual<GreaterThan<End, Start>, true>
+	> extends true
+		? ArraySliceByPositiveIndex<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>, GreaterThanOrEqual<PositiveS, ArrayLength>][number]
+	? []
+	: ArraySliceByPositiveIndex<Array_, ArrayMin<[PositiveS, ArrayLength]>, ArrayMin<[PositiveE, ArrayLength]>>;
+
+type ArraySliceByPositiveIndex<
+	Array_ extends readonly unknown[],
+	Start extends number,
+	End extends number,
+	Result extends Array<Array_[number]> = [],
+> = Start extends End
+	? Result
+	: ArraySliceByPositiveIndex<Array_, Sum<Start, 1>, End, [...Result, Array_[Start]]>;

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/distributed-omit.d.ts

@@ -0,0 +1,89 @@
+import type {KeysOfUnion} from './keys-of-union';
+
+/**
+Omits keys from a type, distributing the operation over a union.
+
+TypeScript's `Omit` doesn't distribute over unions, leading to the erasure of unique properties from union members when omitting keys. This creates a type that only retains properties common to all union members, making it impossible to access member-specific properties after the Omit. Essentially, using `Omit` on a union type merges the types into a less specific one, hindering type narrowing and property access based on discriminants. This type solves that.
+
+Example:
+
+```
+type A = {
+	discriminant: 'A';
+	foo: string;
+	a: number;
+};
+
+type B = {
+	discriminant: 'B';
+	foo: string;
+	b: string;
+};
+
+type Union = A | B;
+
+type OmittedUnion = Omit<Union, 'foo'>;
+//=> {discriminant: 'A' | 'B'}
+
+const omittedUnion: OmittedUnion = createOmittedUnion();
+
+if (omittedUnion.discriminant === 'A') {
+	// We would like to narrow `omittedUnion`'s type
+	// to `A` here, but we can't because `Omit`
+	// doesn't distribute over unions.
+
+	omittedUnion.a;
+ 	//=> Error: `a` is not a property of `{discriminant: 'A' | 'B'}`
+}
+```
+
+While `Except` solves this problem, it restricts the keys you can omit to the ones that are present in **ALL** union members, where `DistributedOmit` allows you to omit keys that are present in **ANY** union member.
+
+@example
+```
+type A = {
+	discriminant: 'A';
+	foo: string;
+	a: number;
+};
+
+type B = {
+	discriminant: 'B';
+	foo: string;
+	bar: string;
+	b: string;
+};
+
+type C = {
+	discriminant: 'C';
+	bar: string;
+	c: boolean;
+};
+
+// Notice that `foo` exists in `A` and `B`, but not in `C`, and
+// `bar` exists in `B` and `C`, but not in `A`.
+
+type Union = A | B | C;
+
+type OmittedUnion = DistributedOmit<Union, 'foo' | 'bar'>;
+
+const omittedUnion: OmittedUnion = createOmittedUnion();
+
+if (omittedUnion.discriminant === 'A') {
+	omittedUnion.a;
+ 	//=> OK
+
+	omittedUnion.foo;
+ 	//=> Error: `foo` is not a property of `{discriminant: 'A'; a: string}`
+
+	omittedUnion.bar;
+ 	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`
+}
+```
+
+@category Object
+*/
+export type DistributedOmit<ObjectType, KeyType extends KeysOfUnion<ObjectType>> =
+	ObjectType extends unknown
+		? Omit<ObjectType, KeyType>
+		: never;

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/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/omit-deep.d.ts

@@ -1,6 +1,8 @@
 import type {ArraySplice} from './array-splice';
 import type {ExactKey, IsArrayReadonly, NonRecursiveType, SetArrayAccess, ToString} from './internal';
 import type {IsEqual} from './is-equal';
+import type {IsNever} from './is-never';
+import type {LiteralUnion} from './literal-union';
 import type {SimplifyDeep} from './merge-deep';
 import type {Paths} from './paths';
 import type {SharedUnionFieldsDeep} from './shared-union-fields-deep';
@@ -69,7 +71,7 @@ type AddressInfo = OmitDeep<Info1, 'address.1.foo'>;
 @category Object
 @category Array
 */
-export type OmitDeep<T, PathUnion extends Paths<T>> =
+export type OmitDeep<T, PathUnion extends LiteralUnion<Paths<T>, string>> =
 	SimplifyDeep<
 	SharedUnionFieldsDeep<
 	{[P in PathUnion]: OmitDeepWithOnePath<T, P>}[PathUnion]
@@ -102,9 +104,11 @@ P extends `${infer RecordKeyInPath}.${infer SubPath}`
 			: ObjectT[Key]
 	}
 	: ExactKey<ObjectT, P> extends infer Key
-		? Key extends PropertyKey
-			? Omit<ObjectT, Key>
-			: ObjectT
+		? IsNever<Key> extends true
+			? ObjectT
+			: Key extends PropertyKey
+				? Omit<ObjectT, Key>
+				: ObjectT
 		: ObjectT;
 
 /**
@@ -133,4 +137,4 @@ type OmitDeepArrayWithOnePath<ArrayType extends UnknownArray, P extends string |
 				? []
 				// If `ArrayIndex` is a number literal
 				: ArraySplice<ArrayType, ArrayIndex, 1, [unknown]>
-			: never;
+			: ArrayType;

package/source/set-parameter-type.d.ts

@@ -1,17 +1,53 @@
 import type {IsUnknown} from './is-unknown';
+import type {StaticPartOfArray} from './internal';
+import type {UnknownArray} from './unknown-array';
 
 /**
-Create a tuple that replaces the given `Tuple`'s elements with the given `Record_`'s values at the given indices.
+Create an array that replaces the given `TArray`'s elements with the given `TObject`'s values at the given indices.
+
+`TArray` and `TObject` supports tailing spread array like `[string, ...boolean[]]`, but does not support `[string, ...boolean[], number]`.
+
+@example:
+```ts
+// object
+type A = MergeObjectToArray<[string, number], {0: boolean}>;
+//=> [boolean, number]
+
+// array
+type B = MergeObjectToArray<[string, number], [boolean]>;
+//=> [boolean, number]
+
+// tailing spread array
+type C = MergeObjectToArray<[string, ...boolean[]], {1: number}>;
+//=> [string, ...number[]]
+
+type D = MergeObjectToArray<[string, ...boolean[]], [number, ...string[]]>;
+//=> [number, ...string[]]
+```
 */
-type MergeObjectToTuple<Tuple extends unknown[], Record_ extends Record<number, unknown>> = {
-	[K in keyof Tuple]: Record_ extends Record<string, unknown>
-		// Handle object case like `{0: string, 1: number}`
-		? K extends `${infer NumberK extends number}`
-			? NumberK extends keyof Record_ ? Record_[K] : Tuple[K]
-			: never // Should not happen
-		// Handle tuple case like `[string, number]`
-		: K extends keyof Record_ ? Record_[K] : Tuple[K]
-};
+type MergeObjectToArray<TArray extends UnknownArray, TObject, TArrayCopy extends UnknownArray = TArray> =
+	// If `TObject` is an array like `[0, 1, 2]`
+	TObject extends UnknownArray
+		// If `TObject` is a variable length array, we should use `TObject`'s type as the result type.
+		? number extends TObject['length']
+			? TObject
+			: {
+				[K in keyof TArray]: K extends keyof TObject ? TObject[K] : TArray[K]
+			}
+		: TObject extends object
+			// If `TObject` is a object witch key is number like `{0: string, 1: number}`
+			? {
+				[K in keyof TArray]:
+				K extends `${infer NumberK extends number}`
+					? NumberK extends keyof TObject ? TObject[NumberK] : TArray[K]
+					: number extends K
+					// If array key `K` is `number`, means it's a rest parameter, we should set the rest parameter type to corresponding type in `TObject`.
+					// example: `MergeObjectToParamterArray<[string, ...boolean[]], {1: number}>` => `[string, ...number[]]`
+						? StaticPartOfArray<TArrayCopy>['length'] extends keyof TObject
+							? TObject[StaticPartOfArray<TArrayCopy>['length']]
+							: TArray[K]
+						: never
+			} : never;
 
 /**
 Create a function that replaces some parameters with the given parameters.
@@ -39,7 +75,7 @@ Use-case:
 ```
 import type {SetParameterType} from 'type-fest';
 
-type HandleMessage = (data: Data, message: string) => void;
+type HandleMessage = (data: Data, message: string, ...arguments: any[]) => void;
 
 type HandleOk = SetParameterType<HandleMessage, {0: SuccessData, 1: 'ok'}>;
 //=> type HandleOk = (data: SuccessData, message: 'ok') => void;
@@ -48,9 +84,19 @@ type HandleOk = SetParameterType<HandleMessage, {0: SuccessData, 1: 'ok'}>;
 type HandleError = SetParameterType<HandleMessage, [data: ErrorData, message: 'error']>;
 //=> type HandleError = (data: ErrorData, message: 'error') => void;
 
-// Could change single parameter type.
+// Change single parameter type.
 type HandleWarn = SetParameterType<HandleMessage, {1: 'warn'}>;
 //=> type HandleWarn = (data: Data, message: 'warn') => void;
+
+// Change rest parameter type.
+
+// Way 1: Input full parameter type.
+type HandleLog = SetParameterType<HandleMessage, [data: Data, message: 'log', ...arguments: string[]]>;
+//=> type HandleLog = (data: Data, message: 'log', ...arguments: string[]) => void;
+
+// Way 2: Input rest parameter type by Object index.
+type HandleLog2 = SetParameterType<HandleMessage, {2: string}>;
+//=> type HandleLog2 = (data: Data, message: string, ...arguments: string[]) => void;
 ```
 
 @category Function
@@ -62,7 +108,7 @@ export type SetParameterType<Fn extends (...arguments_: any[]) => unknown, P ext
 			// If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
 			// We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
 			IsUnknown<ThisArg> extends true
-				? (...arguments_: MergeObjectToTuple<Arguments, P>) => ReturnType<Fn>
-				: (this: ThisArg, ...arguments_: MergeObjectToTuple<Arguments, P>) => ReturnType<Fn>
+				? (...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Fn>
+				: (this: ThisArg, ...arguments_: MergeObjectToArray<Arguments, P>) => ReturnType<Fn>
 		)
 		: Fn;	// This part should be unreachable

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,68 @@
+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> = 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
+		: never;

package/source/sum.d.ts

@@ -0,0 +1,68 @@
+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> = 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
+								: 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;