@depup/type-fest 5.5.0-depup.0 → 5.10.0-depup.0

package/source/extends-strict.d.ts

@@ -1,44 +1,151 @@
 import type {IsNever} from './is-never.d.ts';
 import type {IsAny} from './is-any.d.ts';
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {And} from './and.d.ts';
+import type {Or} from './or.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {OrAll} from './or-all.d.ts';
 
-/**
-A stricter, non-distributive version of `extends` for checking whether one type is assignable to another.
+export type ExtendsStrictOptions = {
+	/**
+	Whether to distribute over unions.
+
+	@default false
+
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
+
+	type T1 = ExtendsStrict<string | number, string, {distributiveUnions: true}>;
+	//=> boolean
+
+	type T2 = ExtendsStrict<string | number, string, {distributiveUnions: false}>;
+	//=> false
+	```
+	*/
+	distributiveUnions?: boolean;
+
+	/**
+	Whether `never` extends every other type.
+
+	When enabled, `never` is not treated as a bottom type and only extends itself (or `any` / `unknown`).
+
+	@default true
+
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
+
+	type T1 = ExtendsStrict<never, number, {strictNever: true}>;
+	//=> false
+
+	type T2 = ExtendsStrict<never, number, {strictNever: false}>;
+	//=> true
+
+	type T3 = ExtendsStrict<never, never, {strictNever: true}>;
+	//=> true
+
+	type T4 = ExtendsStrict<never, any, {strictNever: true}>;
+	//=> true
+
+	type T5 = ExtendsStrict<never, unknown, {strictNever: true}>;
+	//=> true
+	```
+
+	Note: This option only has an effect when checking assignability from `never` (`ExtendsStrict<never, ...>`), and not when checking assignability to `never` (`ExtendsStrict<..., never>`).
+	*/
+	strictNever?: boolean;
+
+	/**
+	Whether `any` extends every other type.
+
+	When enabled, `any` does not extend every other type, it only extends itself (or `unknown`).
+
+	@default false
 
-Unlike the built-in `extends` keyword, `ExtendsStrict`:
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
 
-1. Prevents distribution over union types by wrapping both types in tuples. For example, `ExtendsStrict<string | number, number>` returns `false`, whereas `string | number extends number` would result in `boolean`.
+	type T1 = ExtendsStrict<any, number, {strictAny: true}>;
+	//=> false
 
-2. Treats `never` as a special case: `never` doesn't extend every other type, it only extends itself (or `any`). For example, `ExtendsStrict<never, number>` returns `false` whereas `never extends number` would result in `true`.
+	type T2 = ExtendsStrict<any, number, {strictAny: false; distributiveUnions: false}>;
+	//=> true
+
+	type T3 = ExtendsStrict<any, any, {strictAny: true}>;
+	//=> true
+
+	type T4 = ExtendsStrict<any, unknown, {strictAny: true}>;
+	//=> true
+	```
+
+	Note: If `strictAny` is `false` and `distributiveUnions` is `true`, then `any` would distribute and the result would be the `boolean` type, except when checking assignability to `any` or `unknown`.
+
+	@example
+	```
+	import type {ExtendsStrict} from 'type-fest';
+
+	type T1 = ExtendsStrict<any, number, {strictAny: false; distributiveUnions: true}>;
+	//=> boolean
+
+	type T2 = ExtendsStrict<any, any, {strictAny: false; distributiveUnions: true}>;
+	//=> true
+
+	type T3 = ExtendsStrict<any, unknown, {strictAny: false; distributiveUnions: true}>;
+	//=> true
+	```
+
+	Note: This option only has an effect when checking assignability from `any` (`ExtendsStrict<any, ...>`), and not when checking assignability to `any` (`ExtendsStrict<..., any>`).
+	*/
+	strictAny?: boolean;
+};
+
+type DefaultExtendsStrictOptions = {
+	distributiveUnions: false;
+	strictNever: true;
+	strictAny: false;
+};
+
+/**
+A customizable version of `extends` for checking whether one type is assignable to another.
+
+Refer {@link ExtendsStrictOptions} for the different ways you can customize the behavior of this type.
 
 @example
 ```
 import type {ExtendsStrict} from 'type-fest';
 
-type T1 = ExtendsStrict<number | string, string>;
+type T1 = ExtendsStrict<number | string, string, {distributiveUnions: false}>;
 //=> false
 
-type T2 = ExtendsStrict<never, number>;
+type T2 = ExtendsStrict<never, number, {strictNever: true}>;
 //=> false
 
-type T3 = ExtendsStrict<never, never>;
-//=> true
-
-type T4 = ExtendsStrict<string, number | string>;
-//=> true
-
-type T5 = ExtendsStrict<string, string>;
-//=> true
+type T3 = ExtendsStrict<any, number, {strictAny: true}>;
+//=> false
 ```
 
+@see {@link ExtendsStrictOptions}
+
 @category Improved Built-in
 */
-export type ExtendsStrict<Left, Right> =
-	IsAny<Left | Right> extends true
-		? true
+export type ExtendsStrict<Left, Right, Options extends ExtendsStrictOptions = {}> =
+	_ExtendsStrict<Left, Right, ApplyDefaultOptions<ExtendsStrictOptions, DefaultExtendsStrictOptions, Options>>;
+
+type _ExtendsStrict<Left, Right, Options extends Required<ExtendsStrictOptions>> =
+	And<IsAny<Left>, Options['strictAny']> extends true
+		? Or<IsAny<Right>, IsUnknown<Right>>
 		: IsNever<Left> extends true
-			? IsNever<Right>
-			: [Left] extends [Right]
-				? true
-				: false;
+			? Options['strictNever'] extends true
+				? OrAll<[IsNever<Right>, IsAny<Right>, IsUnknown<Right>]>
+				: true
+			: Options['distributiveUnions'] extends true
+				? Left extends Right
+					? true
+					: false
+				: [Left] extends [Right]
+					? true
+					: false;
 
 export {};

package/source/extract-exactly.d.ts

@@ -0,0 +1,56 @@
+import type {IsAny} from './is-any.d.ts';
+import type {If} from './if.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+
+/**
+A stricter version of `Extract<T, U>` that extracts types only when they are exactly identical.
+
+@example
+```
+import type {ExtractExactly} from 'type-fest';
+
+type TestExtract1 = Extract<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 'a' | 'b' | 'c'
+
+type TestExtractExactly1 = ExtractExactly<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> never
+
+type TestExtract2 = Extract<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExtractExactly2 = ExtractExactly<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> never
+
+type TestExtract3 = Extract<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string} | {a: string; b: string}
+
+type TestExtractExactly3 = ExtractExactly<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string}
+```
+
+@category Improved Built-in
+*/
+export type ExtractExactly<Union, Match> =
+	IfNotAnyOrNever<Union, {
+		ifNot: _ExtractExactly<Union, Match>;
+		// If `Union` is `any`, then if `Match` is `any`, return `any`, else return `never`.
+		ifAny: If<IsAny<Match>, Union, never>;
+		// If `Union` is `never`, return `never`, doesn't matter what `Match` is.
+		ifNever: never;
+	}>;
+
+type _ExtractExactly<Union, Match> =
+	IfNotAnyOrNever<Match, {
+		ifNot: Union extends unknown // For distributing `Union`
+			? [Match extends unknown // For distributing `Match`
+				? If<IsEqual<Union, Match>, true, never>
+				: never] extends [never] ? never : Union
+			: never;
+		// If `Match` is `any` or `never`, then return `never`,
+		// because `Union` cannot be `any` or `never` here.
+		ifAny: never;
+		ifNever: never;
+	}>;
+
+export {};

package/source/get.d.ts

@@ -161,7 +161,7 @@ type PropertyOf<BaseType, Key extends string, Options extends Required<GetOption
 
 // This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
 /**
-Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
+Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs#get) function.
 
 Use-case: Retrieve a property from deep inside an API response or some other complex object.
 

package/source/greater-than.d.ts

@@ -1,8 +1,9 @@
-import type {NumberAbsolute, PositiveNumericStringGt} from './internal/index.d.ts';
+import type {PositiveNumericStringGt} from './internal/index.d.ts';
 import type {IsEqual} from './is-equal.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {And} from './and.d.ts';
 import type {Or} from './or.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns a boolean for whether a given number is greater than another number.
@@ -82,7 +83,7 @@ export type GreaterThan<A extends number, B extends number> =
 											? true
 											: [false, false] extends R
 												? PositiveNumericStringGt<`${A}`, `${B}`>
-												: PositiveNumericStringGt<`${NumberAbsolute<B>}`, `${NumberAbsolute<A>}`>
+												: PositiveNumericStringGt<`${Absolute<B>}`, `${Absolute<A>}`>
 									: never
 					: never
 			: never // Should never happen

package/source/has-optional-keys.d.ts

@@ -1,7 +1,7 @@
 import type {OptionalKeysOf} from './optional-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any optional fields.
+Returns a boolean for whether the given type has any optional fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of optional fields.
 

package/source/has-readonly-keys.d.ts

@@ -1,7 +1,7 @@
 import type {ReadonlyKeysOf} from './readonly-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any readonly fields.
+Returns a boolean for whether the given type has any readonly fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of readonly fields.
 

package/source/has-required-keys.d.ts

@@ -1,7 +1,7 @@
 import type {RequiredKeysOf} from './required-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any required fields.
+Returns a boolean for whether the given type has any required fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of required fields.
 

package/source/has-writable-keys.d.ts

@@ -1,7 +1,7 @@
 import type {WritableKeysOf} from './writable-keys-of.d.ts';
 
 /**
-Creates a type that represents `true` or `false` depending on whether the given type has any writable fields.
+Returns a boolean for whether the given type has any writable fields.
 
 This is useful when you want to create an API whose behavior depends on the presence or absence of writable fields.
 

package/source/int-closed-range.d.ts

@@ -2,13 +2,11 @@ import type {IntRange} from './int-range.d.ts';
 import type {Sum} from './sum.d.ts';
 
 /**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (inclusive) parameter.
+Generate a union of numbers between a specified start and end (both inclusive), with an optional step.
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntClosedRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8 | 10`.
 
-Note: `Start` or `End` must be non-negative and smaller than `999`.
+Note: `Start` and `End` must each be between `-998` and `998`. The maximum is one less than for `IntRange` because the end is incremented internally to make it inclusive. If `Start` is greater than `End`, the result is `never`.
 
 Use-cases:
 1. This can be used to define a set of valid input/output values. for example:
@@ -25,6 +23,9 @@ type FontSize = IntClosedRange<10, 20>;
 
 type EvenNumber = IntClosedRange<0, 10, 2>;
 //=> 0 | 2 | 4 | 6 | 8 | 10
+
+type Offset = IntClosedRange<-3, 3>;
+//=> -3 | -2 | -1 | 0 | 1 | 2 | 3
 ```
 
 2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntClosedRange<0, 100>;`

package/source/int-range.d.ts

@@ -1,14 +1,16 @@
 import type {TupleOf} from './tuple-of.d.ts';
 import type {Subtract} from './subtract.d.ts';
+import type {Absolute} from './absolute.d.ts';
+import type {IsNegative} from './numeric.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {ReverseSign} from './internal/index.d.ts';
 
 /**
-Generate a union of numbers.
-
-The numbers are created from the given `Start` (inclusive) parameter to the given `End` (exclusive) parameter.
+Generate a union of numbers between a specified start (inclusive) and end (exclusive), with an optional step.
 
 You skip over numbers using the `Step` parameter (defaults to `1`). For example, `IntRange<0, 10, 2>` will create a union of `0 | 2 | 4 | 6 | 8`.
 
-Note: `Start` or `End` must be non-negative and smaller than `1000`.
+Note: `Start` and `End` must each be between `-998` and `999`. Negative ranges reach TypeScript's instantiation-depth limit one value earlier, so their supported minimum is one smaller in magnitude than the maximum. If `Start` is greater than `End`, the result is `never`.
 
 Use-cases:
 1. This can be used to define a set of valid input/output values. for example:
@@ -25,6 +27,9 @@ type FontSize = IntRange<10, 20>;
 
 type EvenNumber = IntRange<0, 11, 2>;
 //=> 0 | 2 | 4 | 6 | 8 | 10
+
+type Offset = IntRange<-3, 3>;
+//=> -3 | -2 | -1 | 0 | 1 | 2
 ```
 
 2. This can be used to define random numbers in a range. For example, `type RandomNumber = IntRange<0, 100>;`
@@ -42,7 +47,41 @@ type Hundreds = IntRange<100, 901, 100>;
 
 @see {@link IntClosedRange}
 */
-export type IntRange<Start extends number, End extends number, Step extends number = 1> = PrivateIntRange<Start, End, Step>;
+export type IntRange<Start extends number, End extends number, Step extends number = 1> =
+	IsNegative<Start> extends true
+		? PrivateNegativeIntRange<Start, End, Step>
+		: PrivateIntRange<Start, End, Step>;
+
+/**
+Removes `StepTuple['length']` elements from the front of `Tuple`, or empties it when it is too short.
+*/
+type DropStep<Tuple extends UnknownArray, StepTuple extends UnknownArray> =
+	Tuple extends [...StepTuple, ...infer Rest extends UnknownArray] ? Rest : [];
+
+/**
+The implementation of `IntRange` for a negative `Start`.
+
+A tuple length can never be negative, so instead of counting up to the value, `Magnitude` counts down from `-Start` and the value is `-Magnitude['length']`. Once `Magnitude` is too short to step again, the range has crossed zero and the rest is delegated to `PrivateIntRange`.
+*/
+type PrivateNegativeIntRange<
+	Start extends number,
+	End extends number,
+	Step extends number,
+	// A `Step` below `1` cannot advance the range, so fall back to `1` like `PrivateIntRange` does
+	StepTuple extends UnknownArray = TupleOf<Step> extends [] ? [unknown] : TupleOf<Step>,
+	// How much of the range is left to generate, shortened by `Step` each time, so the range stops at `End`
+	Remaining extends UnknownArray = TupleOf<Subtract<End, Start>>,
+	// The magnitude of the current value, so the value itself is `-Magnitude['length']`
+	Magnitude extends UnknownArray = TupleOf<Absolute<Start>>,
+	Result = never,
+> = Remaining extends []
+	? Result
+	: Magnitude extends [...StepTuple, ...infer NextMagnitude extends UnknownArray]
+		? PrivateNegativeIntRange<Start, End, Step, StepTuple, DropStep<Remaining, StepTuple>, NextMagnitude, Result | ReverseSign<Magnitude['length']>>
+		// Less than a step is left below zero, so `Crossover` is the amount the next step overshoots it by, and counting up can take over from there
+		: StepTuple extends [...Magnitude, ...infer Crossover extends UnknownArray]
+			? Result | ReverseSign<Magnitude['length']> | PrivateIntRange<Crossover['length'], End, Step>
+			: never;
 
 /**
 The actual implementation of `IntRange`. It's private because it has some arguments that don't need to be exposed.
@@ -56,14 +95,20 @@ type PrivateIntRange<
 	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
 	List extends unknown[] = TupleOf<Start, never>,
 	EndLengthTuple extends unknown[] = TupleOf<End>,
-> = Gap extends 0 ?
+	// Avoid `GreaterThan<Start, End>` here because the extra type instantiations would make `IntRange<0, 999>` exceed TypeScript's instantiation-depth limit
+	// `TupleOf` represents a negative length as an empty tuple, so a negative `End` must be detected before comparing the tuple lengths
+	// Recursive calls pass `false` because reversal only depends on the initial bounds; the termination checks below still handle reaching or overshooting `End` without repeating this tuple comparison
+	IsReversed extends boolean = IsNegative<End> extends true ? true : List extends [...EndLengthTuple, unknown, ...unknown[]] ? true : false,
+> = IsReversed extends true
+	? never
+	: Gap extends 0
 	// Handle the case that without `Step`
-	List['length'] extends End // The result of "List[length] === End"
-		? Exclude<List[number], never> // All unused elements are `never`, so exclude them
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ]>
+		? List['length'] extends End // The result of "List[length] === End"
+			? Exclude<List[number], never> // All unused elements are `never`, so exclude them
+			: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'] ], EndLengthTuple, false>
 	// Handle the case that with `Step`
-	: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
-		? Exclude<List[number], never>
-		: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>]>;
+		: List extends [...(infer U), ...EndLengthTuple] // The result of "List[length] >= End", because the `...TupleOf<Gap, never>` maybe make `List` too long.
+			? Exclude<List[number], never>
+			: PrivateIntRange<Start, End, Step, Gap, [...List, List['length'], ...TupleOf<Gap, never>], EndLengthTuple, false>;
 
 export {};

package/source/internal/array.d.ts

@@ -1,6 +1,5 @@
 import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
-import type {OptionalKeysOf} from '../optional-keys-of.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
 import type {IsExactOptionalPropertyTypesEnabled, IfNotAnyOrNever} from './type.d.ts';
 
@@ -29,8 +28,8 @@ type B = StaticPartOfArray<A>;
 */
 export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> =
 	T extends unknown
-		? number extends T['length'] ?
-			T extends readonly [infer U, ...infer V]
+		? number extends T['length']
+			? T extends readonly [infer U, ...infer V]
 				? StaticPartOfArray<V, [...Result, U]>
 				: Result
 			: T
@@ -69,11 +68,11 @@ type NormalResult = SetArrayAccess<ReadonlyStringArray, false>;
 ```
 */
 export type SetArrayAccess<T extends UnknownArray, IsReadonly extends boolean> =
-T extends readonly [...infer U] ?
-	IsReadonly extends true
-		? readonly [...U]
-		: [...U]
-	: T;
+	T extends readonly [...infer U]
+		? IsReadonly extends true
+			? readonly [...U]
+			: [...U]
+		: T;
 
 /**
 Returns whether the given array `T` is readonly.
@@ -111,7 +110,7 @@ type B = CollapseRestElement<[string?, string?, ...number[]]>;
 //=> [string | undefined, string | undefined, number]
 ```
 */
-export type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+export type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {ifNot: _CollapseRestElement<TArray>}>;
 
 type _CollapseRestElement<
 	TArray extends UnknownArray,
@@ -119,26 +118,28 @@ type _CollapseRestElement<
 	BackwardAccumulator extends UnknownArray = [],
 > =
 	TArray extends UnknownArray // For distributing `TArray`
-		? keyof TArray & `${number}` extends never
-			// Enters this branch, if `TArray` is empty (e.g., []),
-			// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
-			? TArray extends readonly [...infer Rest, infer Last]
-				? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
-				: TArray extends readonly []
-					? [...ForwardAccumulator, ...BackwardAccumulator]
-					: [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
-			: TArray extends readonly [(infer First)?, ...infer Rest]
+		? '0' extends keyof TArray
+			// Enters this branch, if `TArray` starts with a non-rest element (e.g., `[string, number]` or `[string, ...number[]]`).
+			? TArray extends readonly [(infer First)?, ...infer Rest]
 				? _CollapseRestElement<
 					Rest,
 					[
 						...ForwardAccumulator,
-						'0' extends OptionalKeysOf<TArray>
-							? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
-							: First,
+						// A tuple allows fewer than one element only when its first element is optional. Written in exactly this shape because equivalent ones, such as `[] extends TArray`, are several times slower.
+						TArray extends readonly [unknown, ...unknown[]]
+							? First
+							: If<IsExactOptionalPropertyTypesEnabled, First, First | undefined>, // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
 					],
 					BackwardAccumulator
 				>
 				: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+			// Enters this branch, if `TArray` is empty (e.g., []),
+			// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+			: TArray extends readonly [...infer Rest, infer Last]
+				? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+				: TArray extends readonly []
+					? [...ForwardAccumulator, ...BackwardAccumulator]
+					: [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
 		: never; // Should never happen
 
 export {};

package/source/internal/keys.d.ts

@@ -87,14 +87,14 @@ type Key4 = ExactKey<Object, 1>;
 @category Object
 */
 export type ExactKey<T extends object, Key extends PropertyKey> =
-Key extends keyof T
-	? Key
-	: ToString<Key> extends keyof T
-		? ToString<Key>
-		: Key extends `${infer NumberKey extends number}`
-			? NumberKey extends keyof T
-				? NumberKey
-				: never
-			: never;
+	Key extends keyof T
+		? Key
+		: ToString<Key> extends keyof T
+			? ToString<Key>
+			: Key extends `${infer NumberKey extends number}`
+				? NumberKey extends keyof T
+					? NumberKey
+					: never
+				: never;
 
 export {};

package/source/internal/numeric.d.ts

@@ -1,26 +1,7 @@
-import type {IsNever} from '../is-never.d.ts';
 import type {Finite, NegativeInfinity, PositiveInfinity} from '../numeric.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
-import type {StringToNumber} from './string.d.ts';
 import type {IfNotAnyOrNever, IsAnyOrNever} from './type.d.ts';
 
-/**
-Returns the absolute value of a given value.
-
-@example
-```
-type A = NumberAbsolute<-1>;
-//=> 1
-
-type B = NumberAbsolute<1>;
-//=> 1
-
-type C = NumberAbsolute<NegativeInfinity>;
-//=> PositiveInfinity
-```
-*/
-export type NumberAbsolute<N extends number> = `${N}` extends `-${infer StringPositiveN}` ? StringToNumber<StringPositiveN> : N;
-
 /**
 Check whether the given type is a number or a number string.
 
@@ -44,11 +25,13 @@ type E = IsNumberLike<'a'>;
 //=> false
 */
 export type IsNumberLike<N> =
-	IfNotAnyOrNever<N,
-		N extends number | `${number}`
+	IfNotAnyOrNever<N, {
+		ifNot: N extends number | `${number}`
 			? true
-			: false,
-		boolean, false>;
+			: false;
+		ifAny: boolean;
+		ifNever: false;
+	}>;
 
 /**
 Returns the minimum number in the given union of numbers.
@@ -85,43 +68,6 @@ type InternalUnionMin<N extends number, T extends UnknownArray = []> =
 		? T['length']
 		: InternalUnionMin<N, [...T, unknown]>;
 
-/**
-Returns the maximum number in the given union of numbers.
-
-Note: Just supports numbers from 0 to 999.
-
-@example
-```
-type A = UnionMax<1 | 3 | 2>;
-//=> 3
-
-type B = UnionMax<number>;
-//=> number
-
-type C = UnionMax<any>;
-//=> any
-
-type D = UnionMax<never>;
-//=> never
-```
-*/
-export type UnionMax<N extends number> =
-	IsAnyOrNever<N> extends true ? N
-		: number extends N ? number
-			: PositiveInfinity extends N ? PositiveInfinity
-				: [N] extends [NegativeInfinity] ? NegativeInfinity
-					: InternalUnionMax<Finite<N>>;
-
-/**
-The actual implementation of `UnionMax`. It's private because it has some arguments that don't need to be exposed.
-*/
-type InternalUnionMax<N extends number, T extends UnknownArray = []> =
-	IsNever<N> extends true
-		? T['length']
-		: T['length'] extends N
-			? InternalUnionMax<Exclude<N, T['length']>, T>
-			: InternalUnionMax<N, [...T, unknown]>;
-
 /**
 Returns the number with reversed sign.
 
@@ -142,10 +88,18 @@ type D = ReverseSign<PositiveInfinity>;
 */
 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;
+	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;
 
 export {};