type-fest 4.41.0 → 5.0.0

package/source/basic.d.ts

@@ -16,7 +16,7 @@ Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/Jav
 export type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;
 
 /**
-Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
+Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/2/classes.html#abstract-classes-and-members).
 
 @category Class
 
@@ -34,35 +34,3 @@ Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/relea
 @category Class
 */
 export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new(...arguments_: Arguments) => T;
-
-/**
-Matches a JSON object.
-
-This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
-
-@category JSON
-*/
-export type JsonObject = {[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined};
-
-/**
-Matches a JSON array.
-
-@category JSON
-*/
-export type JsonArray = JsonValue[] | readonly JsonValue[];
-
-/**
-Matches any valid JSON primitive value.
-
-@category JSON
-*/
-export type JsonPrimitive = string | number | boolean | null;
-
-/**
-Matches any valid JSON value.
-
-@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
-
-@category JSON
-*/
-export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

package/source/camel-case.d.ts

@@ -1,5 +1,5 @@
-import type {ApplyDefaultOptions} from './internal';
-import type {Words} from './words';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {Words} from './words.d.ts';
 
 /**
 CamelCase options.
@@ -10,13 +10,13 @@ export type CamelCaseOptions = {
 	/**
 	Whether to preserved consecutive uppercase letter.
 
-	@default true
+	@default false
 	*/
 	preserveConsecutiveUppercase?: boolean;
 };
 
 export type DefaultCamelCaseOptions = {
-	preserveConsecutiveUppercase: true;
+	preserveConsecutiveUppercase: false;
 };
 
 /**
@@ -83,7 +83,7 @@ export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extend
 	? string extends Type
 		? Type
 		: Uncapitalize<CamelCaseFromArray<
-		Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
-		ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, Options>
+			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
+			ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, Options>
 		>>
 	: Type;

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

@@ -1,6 +1,6 @@
-import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case';
-import type {ApplyDefaultOptions, NonRecursiveType} from './internal';
-import type {UnknownArray} from './unknown-array';
+import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions, NonRecursiveType} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Convert object properties to camel case recursively.
@@ -41,10 +41,10 @@ const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 	],
 };
 
-const preserveConsecutiveUppercase: CamelCasedPropertiesDeep<{fooBAR: { fooBARBiz: [{ fooBARBaz: string }] }}, {preserveConsecutiveUppercase: false}> = {
-	fooBar: {
-		fooBarBiz: [{
-			fooBarBaz: 'string',
+const preserveConsecutiveUppercase: CamelCasedPropertiesDeep<{fooBAR: {fooBARBiz: [{fooBARBaz: string}]}}, {preserveConsecutiveUppercase: true}> = {
+	fooBAR: {
+		fooBARBiz: [{
+			fooBARBaz: 'string',
 		}],
 	},
 };

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

@@ -1,5 +1,5 @@
-import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case';
-import type {ApplyDefaultOptions} from './internal';
+import type {CamelCase, CamelCaseOptions, DefaultCamelCaseOptions} from './camel-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
 
 /**
 Convert object properties to camel case but not recursively.
@@ -23,8 +23,8 @@ const result: CamelCasedProperties<User> = {
 	userName: 'Tom',
 };
 
-const preserveConsecutiveUppercase: CamelCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: false}> = {
-	fooBar: 'string',
+const preserveConsecutiveUppercase: CamelCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
+	fooBAR: 'string',
 };
 ```
 

package/source/characters.d.ts

@@ -0,0 +1,60 @@
+/**
+Matches any uppercase letter in the basic Latin alphabet (A-Z).
+
+@example
+```
+import type {UppercaseLetter} from 'type-fest';
+
+const a: UppercaseLetter = 'A';  // Valid
+const b: UppercaseLetter = 'a';  // Invalid
+const c: UppercaseLetter = 'AB'; // Invalid
+```
+
+@category Type
+*/
+export type UppercaseLetter = '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';
+
+/**
+Matches any lowercase letter in the basic Latin alphabet (a-z).
+
+@example
+```
+import type {LowercaseLetter} from 'type-fest';
+
+const a: LowercaseLetter = 'a'; // Valid
+const b: LowercaseLetter = 'A'; // Invalid
+```
+
+@category Type
+*/
+export type LowercaseLetter = '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';
+
+/**
+Matches any digit as a string ('0'-'9').
+
+@example
+```
+import type {DigitCharacter} from 'type-fest';
+
+const a: DigitCharacter = '0'; // Valid
+const b: DigitCharacter = 0;   // Invalid
+```
+
+@category Type
+*/
+export type DigitCharacter = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+
+/**
+Matches any lowercase letter (a-z), uppercase letter (A-Z), or digit ('0'-'9') in the basic Latin alphabet.
+
+@example
+```
+import type {Alphanumeric} from 'type-fest';
+
+const a: Alphanumeric = 'A'; // Valid
+const b: Alphanumeric = '#'; // Invalid
+```
+
+@category Type
+*/
+export type Alphanumeric = LowercaseLetter | UppercaseLetter | DigitCharacter;

package/source/conditional-except.d.ts

@@ -1,5 +1,5 @@
-import type {Except} from './except';
-import type {ConditionalKeys} from './conditional-keys';
+import type {Except} from './except.d.ts';
+import type {ConditionalKeys} from './conditional-keys.d.ts';
 
 /**
 Exclude keys from a shape that matches the given `Condition`.
@@ -40,6 +40,6 @@ type NonStringKeysOnly = ConditionalExcept<Example, string>;
 @category Object
 */
 export type ConditionalExcept<Base, Condition> = Except<
-Base,
-ConditionalKeys<Base, Condition>
+	Base,
+	ConditionalKeys<Base, Condition>
 >;

package/source/conditional-keys.d.ts

@@ -1,4 +1,7 @@
-import type {IfNever} from './if-never';
+import type {ExtendsStrict} from './extends-strict.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {TupleToObject} from './tuple-to-object.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
 
 /**
 Extract the keys from a type where the value type of the key extends the given `Condition`.
@@ -9,39 +12,50 @@ Internally this is used for the `ConditionalPick` and `ConditionalExcept` types.
 ```
 import type {ConditionalKeys} from 'type-fest';
 
-interface Example {
+type Example = {
 	a: string;
 	b: string | number;
 	c?: string;
 	d: {};
-}
+};
 
 type StringKeysOnly = ConditionalKeys<Example, string>;
 //=> 'a'
 ```
 
-To support partial types, make sure your `Condition` is a union of undefined (for example, `string | undefined`) as demonstrated below.
+Note: To extract optional keys, make sure your `Condition` is a union of `undefined` (for example, `string | undefined`) as demonstrated below.
 
 @example
 ```
 import type {ConditionalKeys} from 'type-fest';
 
-type StringKeysAndUndefined = ConditionalKeys<Example, string | undefined>;
-//=> 'a' | 'c'
+type StringKeysAndUndefined = ConditionalKeys<{a?: string}, string | undefined>;
+//=> 'a'
+
+type NoMatchingKeys = ConditionalKeys<{a?: string}, string>;
+//=> never
+```
+
+You can also extract array indices whose value match the specified condition, as shown below:
+```
+import type {ConditionalKeys} from 'type-fest';
+
+type StringValueIndices = ConditionalKeys<[string, number, string], string>;
+//=> '0' | '2'
+
+type NumberValueIndices = ConditionalKeys<[string, number?, string?], number | undefined>;
+//=> '1'
 ```
 
 @category Object
 */
-export type ConditionalKeys<Base, Condition> =
-{
-	// Map through all the keys of the given base type.
-	[Key in keyof Base]-?:
-	// Pick only keys with types extending the given `Condition` type.
-	Base[Key] extends Condition
-	// Retain this key
-	// If the value for the key extends never, only include it if `Condition` also extends never
-		? IfNever<Base[Key], IfNever<Condition, Key, never>, Key>
-	// Discard this key since the condition fails.
-		: never;
-	// Convert the produced object into a union type of the keys which passed the conditional test.
-}[keyof Base];
+export type ConditionalKeys<Base, Condition> = (Base extends UnknownArray ? TupleToObject<Base> : Base) extends infer _Base // Remove non-numeric keys from arrays
+	? IfNotAnyOrNever<_Base, _ConditionalKeys<_Base, Condition>, keyof _Base>
+	: never;
+
+type _ConditionalKeys<Base, Condition> = keyof {
+	[
+	Key in (keyof Base & {}) as // `& {}` prevents homomorphism
+	ExtendsStrict<Base[Key], Condition> extends true ? Key : never
+	]: never
+};

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

@@ -1,9 +1,9 @@
-import type {IsEqual} from './is-equal';
-import type {ConditionalExcept} from './conditional-except';
-import type {ConditionalSimplifyDeep} from './conditional-simplify';
-import type {UnknownRecord} from './unknown-record';
-import type {EmptyObject} from './empty-object';
-import type {ApplyDefaultOptions, IsPlainObject} from './internal';
+import type {IsEqual} from './is-equal.d.ts';
+import type {ConditionalExcept} from './conditional-except.d.ts';
+import type {ConditionalSimplifyDeep} from './conditional-simplify-deep.d.ts';
+import type {UnknownRecord} from './unknown-record.d.ts';
+import type {EmptyObject} from './empty-object.d.ts';
+import type {ApplyDefaultOptions, IsPlainObject} from './internal/index.d.ts';
 
 /**
 Used to mark properties that should be excluded.
@@ -100,9 +100,9 @@ export type ConditionalPickDeep<
 	Condition,
 	Options extends ConditionalPickDeepOptions = {},
 > = _ConditionalPickDeep<
-Type,
-Condition,
-ApplyDefaultOptions<ConditionalPickDeepOptions, DefaultConditionalPickDeepOptions, Options>
+	Type,
+	Condition,
+	ApplyDefaultOptions<ConditionalPickDeepOptions, DefaultConditionalPickDeepOptions, Options>
 >;
 
 type _ConditionalPickDeep<

package/source/conditional-pick.d.ts

@@ -1,4 +1,4 @@
-import type {ConditionalKeys} from './conditional-keys';
+import type {ConditionalKeys} from './conditional-keys.d.ts';
 
 /**
 Pick keys from the shape that matches the given `Condition`.
@@ -39,6 +39,6 @@ type StringKeysOnly = ConditionalPick<Example, string>;
 @category Object
 */
 export type ConditionalPick<Base, Condition> = Pick<
-Base,
-ConditionalKeys<Base, Condition>
+	Base,
+	ConditionalKeys<Base, Condition>
 >;

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

@@ -0,0 +1,71 @@
+/**
+Recursively simplifies a type while including and/or excluding certain types from being simplified.
+
+@example
+```
+import type {ConditionalSimplifyDeep} from 'type-fest';
+
+type TypeA = {
+	foo: {
+		a: string;
+	};
+};
+
+type TypeB = {
+	foo: {
+		b: string;
+	};
+};
+
+type SimplifyDeepTypeAB = ConditionalSimplifyDeep<TypeA & TypeB, never, object>;
+//=> {foo: {a: string; b: string}}
+```
+
+@example
+```
+import type {ConditionalSimplifyDeep} from 'type-fest';
+
+type SomeComplexType1 = {
+	a1: string;
+	b1: number;
+	c1: boolean;
+};
+
+type SomeComplexType2 = {
+	a2: string;
+	b2: number;
+	c2: boolean;
+};
+
+type TypeA = {
+	foo: {
+		a: string;
+		complexType: SomeComplexType1;
+	};
+};
+
+type TypeB = {
+	foo: {
+		b: string;
+		complexType: SomeComplexType2;
+	};
+};
+
+type SimplifyDeepTypeAB = ConditionalSimplifyDeep<TypeA & TypeB, SomeComplexType1 | SomeComplexType2, object>;
+//=> {
+//	foo: {
+// 		a: string;
+// 		b: string;
+// 		complexType: SomeComplexType1 & SomeComplexType2;
+//	};
+// }
+```
+
+@see SimplifyDeep
+@category Object
+*/
+export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
+	? Type
+	: Type extends IncludeType
+		? {[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>}
+		: Type;

package/source/conditional-simplify.d.ts

@@ -1,32 +1,48 @@
 /**
-Simplifies a type while including and/or excluding certain types from being simplified. Useful to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+Simplifies a type while including and/or excluding certain types from being simplified.
 
-This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
+Useful to improve type hints shown in editors. And also to transform an `interface` into a `type` to aid with assignability.
 
-@internal
-@experimental
-@see Simplify
-@category Object
-*/
-export type ConditionalSimplify<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
-	? Type
-	: Type extends IncludeType
-		? {[TypeKey in keyof Type]: Type[TypeKey]}
-		: Type;
+@example
+```
+import type {ConditionalSimplify} from 'type-fest';
 
-/**
-Recursively simplifies a type while including and/or excluding certain types from being simplified.
+type TypeA = {
+	a: string;
+};
 
-This type is **experimental** and was introduced as a result of this {@link https://github.com/sindresorhus/type-fest/issues/436 issue}. It should be used with caution.
+type TypeB = {
+	b: string;
+};
 
-See {@link ConditionalSimplify} for usages and examples.
+type TypeAB = TypeA & TypeB;
+//=> TypeA & TypeB
 
-@internal
-@experimental
+type SimplifyTypeAB = ConditionalSimplify<TypeAB, never, object>;
+//=> {a: string; b: string}
+```
+
+@example
+```
+import type {ConditionalSimplify} from 'type-fest';
+
+type Simplify<T> = ConditionalSimplify<T, Set<unknown> | Map<unknown, unknown> | unknown[], object>;
+
+type A = Simplify<Set<number> & Set<string>>;
+//=> Set<number> & Set<string>
+
+type B = Simplify<Map<number, number> & Map<string, string>>;
+//=> Map<number, number> & Map<string, string>
+
+type C = Simplify<{a: number} & {b: string}>;
+//=> {a: number; b: string}
+```
+
+@see ConditionalSimplifyDeep
 @category Object
 */
-export type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
+export type ConditionalSimplify<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType
 	? Type
 	: Type extends IncludeType
-		? {[TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType>}
+		? {[TypeKey in keyof Type]: Type[TypeKey]}
 		: Type;

package/source/delimiter-case.d.ts

@@ -1,7 +1,8 @@
-import type {ApplyDefaultOptions, AsciiPunctuation, StartsWith} from './internal';
-import type {IsStringLiteral} from './is-literal';
-import type {Merge} from './merge';
-import type {DefaultWordsOptions, Words, WordsOptions} from './words';
+import type {ApplyDefaultOptions, AsciiPunctuation, StartsWith} from './internal/index.d.ts';
+import type {IsStringLiteral} from './is-literal.d.ts';
+import type {Merge} from './merge.d.ts';
+import type {RemovePrefix} from './remove-prefix.d.ts';
+import type {DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
 
 export type DefaultDelimiterCaseOptions = Merge<DefaultWordsOptions, {splitOnNumbers: false}>;
 
@@ -21,10 +22,6 @@ type DelimiterCaseFromArray<
 	}${FirstWord}`>
 	: OutputString;
 
-type RemoveFirstLetter<S extends string> = S extends `${infer _}${infer Rest}`
-	? Rest
-	: '';
-
 /**
 Convert a string literal to a custom string delimiter casing.
 
@@ -71,8 +68,8 @@ export type DelimiterCase<
 > = Value extends string
 	? IsStringLiteral<Value> extends false
 		? Value
-		: Lowercase<RemoveFirstLetter<DelimiterCaseFromArray<
-		Words<Value, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>,
-		Delimiter
-		>>>
+		: Lowercase<RemovePrefix<DelimiterCaseFromArray<
+			Words<Value, ApplyDefaultOptions<WordsOptions, DefaultDelimiterCaseOptions, Options>>,
+			Delimiter
+		>, string, {strict: false}>>
 	: Value;

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

@@ -1,7 +1,7 @@
-import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
-import type {ApplyDefaultOptions, NonRecursiveType} from './internal';
-import type {UnknownArray} from './unknown-array';
-import type {WordsOptions} from './words';
+import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
+import type {ApplyDefaultOptions, NonRecursiveType} from './internal/index.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+import type {WordsOptions} from './words.d.ts';
 
 /**
 Convert object properties to delimiter case recursively.

package/source/delimiter-cased-properties.d.ts

@@ -1,6 +1,6 @@
-import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case';
-import type {ApplyDefaultOptions} from './internal';
-import type {WordsOptions} from './words';
+import type {DefaultDelimiterCaseOptions, DelimiterCase} from './delimiter-case.d.ts';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {WordsOptions} from './words.d.ts';
 
 /**
 Convert object properties to delimiter case but not recursively.

package/source/distributed-omit.d.ts

@@ -1,4 +1,4 @@
-import type {KeysOfUnion} from './keys-of-union';
+import type {KeysOfUnion} from './keys-of-union.d.ts';
 
 /**
 Omits keys from a type, distributing the operation over a union.

package/source/distributed-pick.d.ts

@@ -1,4 +1,4 @@
-import type {KeysOfUnion} from './keys-of-union';
+import type {KeysOfUnion} from './keys-of-union.d.ts';
 
 /**
 Pick keys from a type, distributing the operation over a union.

package/source/enforce-optional.d.ts

@@ -1,4 +1,4 @@
-import type {Simplify} from './simplify';
+import type {Simplify} from './simplify.d.ts';
 
 // Returns `never` if the key is optional otherwise return the key type.
 type RequiredFilter<Type, Key extends keyof Type> = undefined extends Type[Key]

package/source/entries.d.ts

@@ -1,4 +1,4 @@
-import type {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry';
+import type {ArrayEntry, MapEntry, ObjectEntry, SetEntry} from './entry.d.ts';
 
 type ArrayEntries<BaseType extends readonly unknown[]> = Array<ArrayEntry<BaseType>>;
 type MapEntries<BaseType> = Array<MapEntry<BaseType>>;

package/source/exact.d.ts

@@ -1,8 +1,8 @@
-import type {ArrayElement, ObjectValue} from './internal';
-import type {IsEqual} from './is-equal';
-import type {KeysOfUnion} from './keys-of-union';
-import type {IsUnknown} from './is-unknown';
-import type {Primitive} from './primitive';
+import type {ArrayElement, ObjectValue} from './internal/index.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {KeysOfUnion} from './keys-of-union.d.ts';
+import type {IsUnknown} from './is-unknown.d.ts';
+import type {Primitive} from './primitive.d.ts';
 
 /**
 Create a type from `ParameterType` and `InputType` and change keys exclusive to `InputType` to `never`.
@@ -10,7 +10,7 @@ Create a type from `ParameterType` and `InputType` and change keys exclusive to
 - Mark these excess keys as `never`.
 */
 type ExactObject<ParameterType, InputType> = {[Key in keyof ParameterType]: Exact<ParameterType[Key], ObjectValue<InputType, Key>>}
-& Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+	& Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
 
 /**
 Create a type that does not allow extra properties, meaning it only allows properties that are explicitly declared.

package/source/except.d.ts

@@ -1,5 +1,5 @@
-import type {ApplyDefaultOptions} from './internal';
-import type {IsEqual} from './is-equal';
+import type {ApplyDefaultOptions} from './internal/index.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
 
 /**
 Filter out keys from an object.

package/source/exclude-strict.d.ts

@@ -0,0 +1,45 @@
+/**
+A stricter version of {@link Exclude<T, U>} that ensures every member of `U` can successfully exclude something from `T`.
+
+For example, `ExcludeStrict<string | number | boolean, number | bigint>` will error because `bigint` cannot exclude anything from `string | number | boolean`.
+
+@example
+```
+// Valid Examples
+
+type Example1 = ExcludeStrict<{status: 'success'; data: string[]} | {status: 'error'; error: string}, {status: 'success'}>;
+//=> {status: 'error'; error: string}
+
+type Example2 = ExcludeStrict<'xs' | 's' | 'm' | 'l' | 'xl', 'xs' | 's'>;
+//=> 'm' | 'l' | 'xl'
+
+type Example3 = ExcludeStrict<{x: number; y: number} | [number, number], unknown[]>;
+//=> {x: number; y: number}
+```
+
+@example
+```
+// Invalid Examples
+
+// `'xxl'` cannot exclude anything from `'xs' | 's' | 'm' | 'l' | 'xl'`
+type Example1 = ExcludeStrict<'xs' | 's' | 'm' | 'l' | 'xl', 'xl' | 'xxl'>;
+//                                                           ~~~~~~~~~~~~
+// Error: Type "'xl' | 'xxl'" does not satisfy the constraint 'never'.
+
+// `unknown[]` cannot exclude anything from `{x: number; y: number} | {x: string; y: string}`
+type Example2 = ExcludeStrict<{x: number; y: number} | {x: string; y: string}, unknown[]>;
+//                                                                             ~~~~~~~~~
+// Error: Type 'unknown[]' does not satisfy the constraint 'never'.
+```
+
+@category Improved Built-in
+*/
+export type ExcludeStrict<
+	T,
+	U extends [U] extends [
+		// Ensure every member of `U` excludes something from `T`
+		U extends unknown ? ([T] extends [Exclude<T, U>] ? never : U) : never,
+	]
+		? unknown
+		: never,
+> = Exclude<T, U>;