type-fest 5.4.3 → 5.5.0

package/index.d.ts

@@ -43,6 +43,7 @@ export type {ReadonlyDeep} from './source/readonly-deep.d.ts';
 export type {LiteralUnion} from './source/literal-union.d.ts';
 export type {Promisable} from './source/promisable.d.ts';
 export type {Arrayable} from './source/arrayable.d.ts';
+export type {Optional} from './source/optional.d.ts';
 export type {Opaque, UnwrapOpaque, Tagged, GetTagMetadata, UnwrapTagged} from './source/tagged.d.ts';
 export type {InvariantOf} from './source/invariant-of.d.ts';
 export type {SetOptional} from './source/set-optional.d.ts';
@@ -144,6 +145,7 @@ export type {ArraySlice} from './source/array-slice.d.ts';
 export type {ArraySplice} from './source/array-splice.d.ts';
 export type {ArrayTail} from './source/array-tail.d.ts';
 export type {ArrayElement} from './source/array-element.d.ts';
+export type {ArrayLength} from './source/array-length.d.ts';
 export type {SetFieldType, SetFieldTypeOptions} from './source/set-field-type.d.ts';
 export type {Paths, PathsOptions} from './source/paths.d.ts';
 export type {AllUnionFields} from './source/all-union-fields.d.ts';
@@ -153,9 +155,12 @@ export type {IsNull} from './source/is-null.d.ts';
 export type {IfNull} from './source/if-null.d.ts';
 export type {IsUndefined} from './source/is-undefined.d.ts';
 export type {And} from './source/and.d.ts';
+export type {AndAll} from './source/and-all.d.ts';
 export type {Or} from './source/or.d.ts';
+export type {OrAll} from './source/or-all.d.ts';
 export type {Xor} from './source/xor.d.ts';
 export type {AllExtend, AllExtendOptions} from './source/all-extend.d.ts';
+export type {SomeExtend, SomeExtendOptions} from './source/some-extend.d.ts';
 export type {NonEmptyTuple} from './source/non-empty-tuple.d.ts';
 export type {FindGlobalInstanceType, FindGlobalType} from './source/find-global-type.d.ts';
 export type {If} from './source/if.d.ts';
@@ -167,6 +172,7 @@ export type {IsNullable} from './source/is-nullable.d.ts';
 export type {TupleOf} from './source/tuple-of.d.ts';
 export type {ExclusifyUnion} from './source/exclusify-union.d.ts';
 export type {ArrayReverse} from './source/array-reverse.d.ts';
+export type {UnionMember} from './source/union-member.d.ts';
 
 // Template literal types
 export type {CamelCase, CamelCaseOptions} from './source/camel-case.d.ts';
@@ -207,5 +213,6 @@ export type {TsConfigJson} from './source/tsconfig-json.d.ts';
 export type {ExtendsStrict} from './source/extends-strict.d.ts';
 export type {ExtractStrict} from './source/extract-strict.d.ts';
 export type {ExcludeStrict} from './source/exclude-strict.d.ts';
+export type {ExcludeExactly} from './source/exclude-exactly.d.ts';
 
 export {};

package/package.json

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

package/readme.md

@@ -180,10 +180,13 @@ Click the type names for complete docs.
 - [`AllUnionFields`](source/all-union-fields.d.ts) - Create a type with all fields from a union of object types.
 - [`DistributedOmit`](source/distributed-omit.d.ts) - Omits keys from a type, distributing the operation over a union.
 - [`DistributedPick`](source/distributed-pick.d.ts) - Picks keys from a type, distributing the operation over a union.
-- [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both true.
-- [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types is true.
-- [`Xor`](source/xor.d.ts) - Returns a boolean for whether only one of two given types is true.
+- [`And`](source/and.d.ts) - Returns a boolean for whether two given types are both `true`.
+- [`Or`](source/or.d.ts) - Returns a boolean for whether either of two given types is `true`.
+- [`Xor`](source/xor.d.ts) - Returns a boolean for whether only one of two given types is `true`.
+- [`AndAll`](source/and-all.d.ts) - Returns a boolean for whether all of the given elements are `true`.
+- [`OrAll`](source/or-all.d.ts) - Returns a boolean for whether any of the given elements is `true`.
 - [`AllExtend`](source/all-extend.d.ts) - Returns a boolean for whether every element in an array type extends another type.
+- [`SomeExtend`](source/some-extend.d.ts) - Returns a boolean for whether some element in an array type extends another type.
 - [`NonEmptyTuple`](source/non-empty-tuple.d.ts) - Matches any non-empty tuple.
 - [`NonEmptyString`](source/non-empty-string.d.ts) - Matches any non-empty string.
 - [`FindGlobalType`](source/find-global-type.d.ts) - Tries to find the type of a global with the given name.
@@ -191,6 +194,8 @@ Click the type names for complete docs.
 - [`ConditionalSimplify`](source/conditional-simplify.d.ts) - Simplifies a type while including and/or excluding certain types from being simplified.
 - [`ConditionalSimplifyDeep`](source/conditional-simplify-deep.d.ts) - Recursively simplifies a type while including and/or excluding certain types from being simplified.
 - [`ExclusifyUnion`](source/exclusify-union.d.ts) - Ensure mutual exclusivity in object unions by adding other members’ keys as `?: never`.
+- [`Optional`](source/optional.d.ts) - Create a type that represents either the value or `undefined`, while stripping `null` from the type.
+- [`UnionMember`](source/union-member.d.ts) - Returns an arbitrary member of a union type.
 
 ### Type Guard
 
@@ -266,6 +271,7 @@ Click the type names for complete docs.
 - [`ExtractRestElement`](source/extract-rest-element.d.ts) - Extract the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element type from an array.
 - [`ExcludeRestElement`](source/exclude-rest-element.d.ts) - Create a tuple with the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element removed.
 - [`ArrayReverse`](source/array-reverse.d.ts) - Reverse the order of elements in a tuple type.
+- [`ArrayLength`](source/array-length.d.ts) - Return the length of an array. Equivalent to `T['length']` where `T` extends any array.
 
 ### Numeric
 
@@ -281,7 +287,7 @@ Click the type names for complete docs.
 - [`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.
 - [`IsFloat`](source/is-float.d.ts) - Returns a boolean for whether the given number is a float, like `1.5` or `-1.5`.
-- [`IsInteger`](source/is-integer.d.ts) - Returns a boolean for whether the given number is a integer, like `-5`, `1.0` or `100`.
+- [`IsInteger`](source/is-integer.d.ts) - Returns a boolean for whether the given number is an integer, like `-5`, `1.0` or `100`.
 - [`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.
@@ -319,6 +325,7 @@ Click the type names for complete docs.
 - [`ExtendsStrict`](source/extends-strict.d.ts) - A stricter, non-distributive version of `extends` for checking whether one type is assignable to another.
 - [`ExtractStrict`](source/extract-strict.d.ts) - A stricter version of `Extract<T, U>` that ensures every member of `U` can successfully extract something from `T`.
 - [`ExcludeStrict`](source/exclude-strict.d.ts) - A stricter version of `Exclude<T, U>` that ensures every member of `U` can successfully exclude something from `T`.
+- [`ExcludeExactly`](source/exclude-exactly.d.ts) - A stricter version of `Exclude<T, U>` that excludes types only when they are exactly identical.
 
 ## Declined types
 
@@ -353,8 +360,11 @@ Click the type names for complete docs.
 - `PickByTypes` - See [`ConditionalPick`](source/conditional-pick.d.ts)
 - `HomomorphicOmit` - See [`Except`](source/except.d.ts)
 - `IfAny`, `IfNever`, `If*` - See [`If`](source/if.d.ts)
+- `Maybe`, `Option` - See [`Optional`](source/optional.d.ts)
 - `MaybePromise` - See [`Promisable`](source/promisable.d.ts)
 - `ReadonlyTuple` - See [`TupleOf`](source/tuple-of.d.ts)
+- `LastOfUnion` - See [`UnionMember`](source/union-member.d.ts)
+- `FirstOfUnion` - See [`UnionMember`](source/union-member.d.ts)
 
 ## Tips
 

package/source/all-extend.d.ts

@@ -1,4 +1,3 @@
-import type {If} from './if.d.ts';
 import type {CollapseRestElement} from './internal/array.d.ts';
 import type {ApplyDefaultOptions} from './internal/object.d.ts';
 import type {IfNotAnyOrNever, Not} from './internal/type.d.ts';
@@ -104,17 +103,17 @@ type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 export type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> =
 	_AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
 
-type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, If<IsAny<Type>, true,
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray,
 	TArray extends readonly [infer First, ...infer Rest]
 		? IsNever<First> extends true
-			? Or<IsNever<Type>, Not<Options['strictNever']>> extends true
-				// If target `Type` is also `never` OR `strictNever` is disabled, recurse further.
+			? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true
+				// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
 				? _AllExtend<Rest, Type, Options>
 				: false
 			: First extends Type
 				? _AllExtend<Rest, Type, Options>
 				: false
-		: true
->, false, false>;
+		: true,
+	false, false>;
 
 export {};

package/source/and-all.d.ts

@@ -0,0 +1,76 @@
+import type {AllExtend} from './all-extend.d.ts';
+
+/**
+Returns a boolean for whether all of the given elements are `true`.
+
+Use-cases:
+- Check if all conditions in a list of booleans are met.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type TTT = AndAll<[true, true, true]>;
+//=> true
+
+type TTF = AndAll<[true, true, false]>;
+//=> false
+
+type TFT = AndAll<[true, false, true]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `AndAll<[true, boolean]>` expands to `AndAll<[true, true]> | AndAll<[true, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[true, boolean]>;
+//=> boolean
+
+type B = AndAll<[false, boolean]>;
+//=> false
+```
+
+Note: If any of the elements is `never`, the result becomes `false`.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[true, true, never]>;
+//=> false
+
+type B = AndAll<[false, never, never]>;
+//=> false
+
+type C = AndAll<[never, never, never]>;
+//=> false
+
+type D = AndAll<[boolean, true, never]>;
+//=> false
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {AndAll} from 'type-fest';
+
+type A = AndAll<[false, any]>;
+//=> false
+
+type B = AndAll<[true, any]>;
+//=> boolean
+```
+
+Note: `AndAll<[]>` evaluates to `true` due to the concept of [vacuous truth](https://en.wikipedia.org/wiki/Logical_conjunction#:~:text=In%20keeping%20with%20the%20concept%20of%20vacuous%20truth%2C%20when%20conjunction%20is%20defined%20as%20an%20operator%20or%20function%20of%20arbitrary%20arity%2C%20the%20empty%20conjunction%20(AND%2Ding%20over%20an%20empty%20set%20of%20operands)%20is%20often%20defined%20as%20having%20the%20result%20true.), i.e., there are no `false` elements in an empty tuple.
+
+@see {@link And}
+@see {@link OrAll}
+*/
+export type AndAll<T extends readonly boolean[]> = AllExtend<T, true>;
+
+export {};

package/source/and.d.ts

@@ -1,4 +1,4 @@
-import type {AllExtend} from './all-extend.d.ts';
+import type {AndAll} from './and-all.d.ts';
 
 /**
 Returns a boolean for whether two given types are both true.
@@ -73,9 +73,10 @@ type G = And<never, never>;
 //=> false
 ```
 
+@see {@link AndAll}
 @see {@link Or}
 @see {@link Xor}
 */
-export type And<A extends boolean, B extends boolean> = AllExtend<[A, B], true>;
+export type And<A extends boolean, B extends boolean> = AndAll<[A, B]>;
 
 export {};

package/source/array-length.d.ts

@@ -0,0 +1,36 @@
+/**
+Return the length of an array. Equivalent to `T['length']` where `T` extends any array.
+
+Tuples resolve to numeric literals, while non-tuples resolve to the `number` type.
+
+@example
+```
+import type {ArrayLength} from 'type-fest';
+
+type TupleLength = ArrayLength<[1, 2, 3]>;
+//=> 3
+
+type TupleWithOptionalMembersLength = ArrayLength<[1, 2, number?]>;
+//=> 2 | 3
+
+type NonTupleArrayLength = ArrayLength<string[]>;
+//=> number
+
+type TupleWithRestElementLength = ArrayLength<[1, 2, ...string[]]>;
+//=> number
+
+// Distinguish between arrays with fixed and non-fixed lengths
+type IsFixedLengthArray<T extends readonly unknown[]> = number extends ArrayLength<T> ? false : true;
+
+type A = IsFixedLengthArray<number[]>;
+//=> false
+
+type B = IsFixedLengthArray<[1, 2, 3]>;
+//=> true
+```
+
+@category Array
+*/
+export type ArrayLength<T extends readonly unknown[]> = T['length'];
+
+export {};

package/source/array-splice.d.ts

@@ -50,10 +50,10 @@ Split the given array `T` by the given `SplitIndex`.
 @example
 ```
 type A = SplitArrayByIndex<[1, 2, 3, 4], 2>;
-// type A = [[1, 2], [3, 4]];
+//=> [[1, 2], [3, 4]];
 
 type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
-// type B = [[], [1, 2, 3, 4]];
+//=> [[], [1, 2, 3, 4]];
 ```
 */
 type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =

package/source/conditional-pick-deep.d.ts

@@ -74,7 +74,7 @@ type BooleanPick = ConditionalPickDeep<Example, boolean | undefined>;
 //=> {c: {e: {g?: boolean}; j: boolean}}
 
 type NumberPick = ConditionalPickDeep<Example, number>;
-//=> {}
+//=> never
 
 type StringOrBooleanPick = ConditionalPickDeep<Example, string | boolean>;
 //=> {
@@ -99,11 +99,13 @@ export type ConditionalPickDeep<
 	Type,
 	Condition,
 	Options extends ConditionalPickDeepOptions = {},
-> = _ConditionalPickDeep<
+> = _NeverIfEmpty<_ConditionalPickDeep<
 	Type,
 	Condition,
 	ApplyDefaultOptions<ConditionalPickDeepOptions, DefaultConditionalPickDeepOptions, Options>
->;
+>>;
+
+type _NeverIfEmpty<Type> = Type extends EmptyObject ? never : Type;
 
 type _ConditionalPickDeep<
 	Type,

package/source/conditional-pick.d.ts

@@ -1,4 +1,5 @@
 import type {ConditionalKeys} from './conditional-keys.d.ts';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 Pick keys from the shape that matches the given `Condition`.
@@ -38,9 +39,10 @@ type StringKeysOnly = ConditionalPick<Example, string>;
 
 @category Object
 */
-export type ConditionalPick<Base, Condition> = Pick<
-	Base,
-	ConditionalKeys<Base, Condition>
->;
+export type ConditionalPick<Base, Condition> = ConditionalKeys<Base, Condition> extends infer Keys
+	? IsNever<Keys> extends true
+		? never
+		: Pick<Base, Keys & keyof Base>
+	: never;
 
 export {};

package/source/exclude-exactly.d.ts

@@ -0,0 +1,57 @@
+import type {IsNever} from './is-never.d.ts';
+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 `Exclude<T, U>` that excludes types only when they are exactly identical.
+
+@example
+```
+import type {ExcludeExactly} from 'type-fest';
+
+type TestExclude1 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 1 | 2 | 3
+
+type TestExcludeExactly1 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, string>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude2 = Exclude<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> never
+
+type TestExcludeExactly2 = ExcludeExactly<'a' | 'b' | 'c' | 1 | 2 | 3, any>;
+//=> 'a' | 'b' | 'c' | 1 | 2 | 3
+
+type TestExclude3 = Exclude<{a: string} | {a: string; b: string}, {a: string}>;
+//=> never
+
+type TestExcludeExactly3 = ExcludeExactly<{a: string} | {a: string; b: string}, {a: string}>;
+//=> {a: string; b: string}
+```
+
+@category Improved Built-in
+*/
+export type ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<
+		Union,
+		_ExcludeExactly<Union, Delete>,
+		// If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
+		If<IsAny<Delete>, never, Union>,
+		// If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
+		If<IsNever<Delete>, never, Union>
+	>;
+
+type _ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<Delete,
+		Union extends unknown // For distributing `Union`
+			? [Delete extends unknown // For distributing `Delete`
+				? If<IsEqual<Union, Delete>, true, never>
+				: never] extends [never] ? Union : never
+			: never,
+		// If `Delete` is `any` or `never`, then return `Union`,
+		// because `Union` cannot be `any` or `never` here.
+		Union, Union
+	>;
+
+export {};

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

@@ -16,9 +16,42 @@ type B = GreaterThanOrEqual<1, 1>;
 type C = GreaterThanOrEqual<1, 5>;
 //=> false
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+type A = GreaterThanOrEqual<number, 1>;
+//=> boolean
+
+type B = GreaterThanOrEqual<1, number>;
+//=> boolean
+
+type C = GreaterThanOrEqual<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {GreaterThanOrEqual} from 'type-fest';
+
+// Use `GreaterThanOrEqual` to constrain a function parameter to non-negative numbers.
+declare function setNonNegative<N extends number>(value: GreaterThanOrEqual<N, 0> extends true ? N : never): void;
+
+setNonNegative(0); // ✅ Allowed
+setNonNegative(1); // ✅ Allowed
+
+// @ts-expect-error
+setNonNegative(-1);
+
+// @ts-expect-error
+setNonNegative(-2);
+```
 */
 export type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
+	? boolean
 	: A extends number // For distributing `A`
 		? B extends number // For distributing `B`
 			? A extends B

package/source/greater-than.d.ts

@@ -20,12 +20,45 @@ type B = GreaterThan<1, 1>;
 type C = GreaterThan<1, 5>;
 //=> false
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+type A = GreaterThan<number, 1>;
+//=> boolean
+
+type B = GreaterThan<1, number>;
+//=> boolean
+
+type C = GreaterThan<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {GreaterThan} from 'type-fest';
+
+// Use `GreaterThan` to constrain a function parameter to positive numbers.
+declare function setPositive<N extends number>(value: GreaterThan<N, 0> extends true ? N : never): void;
+
+setPositive(1); // ✅ Allowed
+setPositive(2); // ✅ Allowed
+
+// @ts-expect-error
+setPositive(0);
+
+// @ts-expect-error
+setPositive(-1);
+```
 */
 export type GreaterThan<A extends number, B extends number> =
 	A extends number // For distributing `A`
 		? B extends number // For distributing `B`
 			? number extends A | B
-				? never
+				? boolean
 				: [
 					IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
 					IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,

package/source/internal/array.d.ts

@@ -4,13 +4,6 @@ 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';
 
-/**
-Infer the length of the given array `<T>`.
-
-@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
-*/
-type ArrayLength<T extends readonly unknown[]> = T extends {readonly length: infer L} ? L : never;
-
 /**
 Matches any unknown array or tuple.
 */

package/source/internal/tuple.d.ts

@@ -23,7 +23,7 @@ type Union = TupleLength<[] | [1, 2, 3] | number[]>;
 */
 export type TupleLength<T extends UnknownArray> =
 	// `extends unknown` is used to convert `T` (if `T` is a union type) to
-	// a [distributive conditionaltype](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types))
+	// a [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types))
 	T extends unknown
 		? number extends T['length']
 			? never // Return never if the given type is an non-flexed-length array like `Array<string>`

package/source/internal/type.d.ts

@@ -3,6 +3,7 @@ import type {IsAny} from '../is-any.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
+import type {UnionToIntersection} from '../union-to-intersection.d.ts';
 
 /**
 Matches any primitive, `void`, `Date`, or `RegExp` value.

package/source/is-equal.d.ts

@@ -1,4 +1,3 @@
-import type {IsNever} from './is-never.d.ts';
 /**
 Returns a boolean for whether the two given types are equal.
 

package/source/is-union.d.ts

@@ -1,4 +1,5 @@
 import type {IsNever} from './is-never.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
 
 /**
 Returns a boolean for whether the given type is a union.
@@ -24,7 +25,7 @@ type InternalIsUnion<T, U = T> =
 	IsNever<T> extends true
 		? false
 		: T extends any
-			? [U] extends [T]
+			? IsEqual<U, T> extends true
 				? false
 				: true
 			: never

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

@@ -16,9 +16,45 @@ type B = LessThanOrEqual<1, 1>;
 type C = LessThanOrEqual<1, 5>;
 //=> true
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+type A = LessThanOrEqual<number, 1>;
+//=> boolean
+
+type B = LessThanOrEqual<1, number>;
+//=> boolean
+
+type C = LessThanOrEqual<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {LessThanOrEqual} from 'type-fest';
+
+// Use `LessThanOrEqual` to constrain a function parameter to non-positive numbers.
+declare function setNonPositive<N extends number>(value: LessThanOrEqual<N, 0> extends true ? N : never): void;
+
+setNonPositive(0); // ✅ Allowed
+setNonPositive(-1); // ✅ Allowed
+
+// @ts-expect-error
+setNonPositive(1);
+
+// @ts-expect-error
+setNonPositive(2);
+```
 */
-export type LessThanOrEqual<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThan<A, B> extends true ? false : true;
+export type LessThanOrEqual<A extends number, B extends number> =
+	GreaterThan<A, B> extends infer Result
+		? Result extends true
+			? false
+			: true
+		: never; // Should never happen
 
 export {};

package/source/less-than.d.ts

@@ -16,10 +16,42 @@ type B = LessThan<1, 1>;
 type C = LessThan<1, 5>;
 //=> true
 ```
+
+Note: If either argument is the non-literal `number` type, the result is `boolean`.
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+type A = LessThan<number, 1>;
+//=> boolean
+
+type B = LessThan<1, number>;
+//=> boolean
+
+type C = LessThan<number, number>;
+//=> boolean
+```
+
+@example
+```
+import type {LessThan} from 'type-fest';
+
+// Use `LessThan` to constrain a function parameter to negative numbers.
+declare function setNegative<N extends number>(value: LessThan<N, 0> extends true ? N : never): void;
+
+setNegative(-1); // ✅ Allowed
+setNegative(-2); // ✅ Allowed
+
+// @ts-expect-error
+setNegative(0);
+
+// @ts-expect-error
+setNegative(1);
+```
 */
-export type LessThan<A extends number, B extends number> = number extends A | B
-	? never
-	: GreaterThanOrEqual<A, B> extends infer Result
+export type LessThan<A extends number, B extends number> =
+	GreaterThanOrEqual<A, B> extends infer Result
 		? Result extends true
 			? false
 			: true