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

package/source/array-splice.d.ts

@@ -8,13 +8,13 @@ import type {TupleOf} from './tuple-of.d.ts';
 The implementation of `SplitArrayByIndex` for fixed length arrays.
 */
 type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
-SplitIndex extends 0
-	? [[], T]
-	: T extends readonly [...TupleOf<SplitIndex>, ...infer V]
-		? T extends readonly [...infer U, ...V]
-			? [U, V]
-			: [never, never]
-		: [never, never];
+	SplitIndex extends 0
+		? [[], T]
+		: T extends readonly [...TupleOf<SplitIndex>, ...infer V]
+			? T extends readonly [...infer U, ...V]
+				? [U, V]
+				: [never, never]
+			: [never, never];
 
 /**
 The implementation of `SplitArrayByIndex` for variable length arrays.
@@ -26,23 +26,23 @@ type SplitVariableArrayByIndex<T extends UnknownArray,
 		? TupleOf<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
 		: [],
 > =
-SplitIndex extends 0
-	? [[], T]
-	: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
-		? [
-			SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
-			[
-				...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
-				...VariablePartOfArray<T>,
-			],
-		]
-		: [
-			[
-				...StaticPartOfArray<T>,
-				...(T2 extends UnknownArray ? T2 : []),
-			],
-			VariablePartOfArray<T>,
-		];
+	SplitIndex extends 0
+		? [[], T]
+		: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
+			? [
+				SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
+				[
+					...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
+					...VariablePartOfArray<T>,
+				],
+			]
+			: [
+				[
+					...StaticPartOfArray<T>,
+					...(T2 extends UnknownArray ? T2 : []),
+				],
+				VariablePartOfArray<T>,
+			];
 
 /**
 Split the given array `T` by the given `SplitIndex`.

package/source/array-tail.d.ts

@@ -51,13 +51,13 @@ const availableTopSciFi = curry(searchBooks)('sci-fi')(4.5)(true);
 
 @category Array
 */
-export type ArrayTail<TArray extends UnknownArray> = IfNotAnyOrNever<TArray,
-	TArray extends UnknownArray // For distributing `TArray`
+export type ArrayTail<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, {
+	ifNot: TArray extends UnknownArray // For distributing `TArray`
 		? _ArrayTail<TArray> extends infer Result
 			? If<IsArrayReadonly<TArray>, Readonly<Result>, Result>
 			: never // Should never happen
-		: never
->;
+		: never;
+}>;
 
 type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?, ...infer Tail]
 	? keyof TArray & `${number}` extends never

package/source/camel-case.d.ts

@@ -1,5 +1,5 @@
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
-import type {Words, WordsOptions} from './words.d.ts';
+import type {_DefaultWordsOptions, Words, WordsOptions} from './words.d.ts';
 
 /**
 CamelCase options.
@@ -13,13 +13,39 @@ export type CamelCaseOptions = WordsOptions & {
 	@default false
 	*/
 	preserveConsecutiveUppercase?: boolean;
+
+	/**
+	Whether to preserve leading underscores.
+
+	This matches the behavior of the [`camelcase`](https://github.com/sindresorhus/camelcase) package v9+.
+
+	@default false
+	*/
+	preserveLeadingUnderscores?: boolean;
 };
 
-export type _DefaultCamelCaseOptions = {
-	splitOnNumbers: true;
+export type _DefaultCamelCaseOptions = _DefaultWordsOptions & {
 	preserveConsecutiveUppercase: false;
+	preserveLeadingUnderscores: false;
 };
 
+/**
+Extract leading underscores from a string.
+
+@example
+```
+type A = LeadingUnderscores<'__foo_bar'>;
+//=> '__'
+
+type B = LeadingUnderscores<'foo_bar'>;
+//=> ''
+```
+*/
+type LeadingUnderscores<Type extends string, Underscores extends string = ''> =
+	Type extends `_${infer Rest}`
+		? LeadingUnderscores<Rest, `_${Underscores}`>
+		: Underscores;
+
 /**
 Convert an array of words to camel-case.
 */
@@ -43,6 +69,8 @@ This can be useful when, for example, converting some kebab-cased command-line f
 
 By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
 
+Use the `preserveLeadingUnderscores` option to retain leading underscores, matching the runtime behavior of [`camelcase`](https://github.com/sindresorhus/camelcase) v9+.
+
 @example
 ```
 import type {CamelCase} from 'type-fest';
@@ -51,6 +79,8 @@ import type {CamelCase} from 'type-fest';
 
 const someVariable: CamelCase<'foo-bar'> = 'fooBar';
 const preserveConsecutiveUppercase: CamelCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'fooBARBaz';
+const splitOnPunctuation: CamelCase<'foo-bar:BAZ', {splitOnPunctuation: true}> = 'fooBarBaz';
+const preserveLeadingUnderscores: CamelCase<'_foo_bar', {preserveLeadingUnderscores: true}> = '_fooBar';
 
 // Advanced
 
@@ -83,10 +113,13 @@ const dbResult: CamelCasedProperties<RawOptions> = {
 export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extends string
 	? string extends Type
 		? Type
-		: Uncapitalize<CamelCaseFromArray<
+		: `${Options['preserveLeadingUnderscores'] extends true
+			? LeadingUnderscores<Type>
+			: ''
+		}${Uncapitalize<CamelCaseFromArray<
 			Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type, Options>,
 			ApplyDefaultOptions<CamelCaseOptions, _DefaultCamelCaseOptions, Options>
-		>>
+		>>}`
 	: Type;
 
 export {};

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

@@ -48,6 +48,13 @@ const preserveConsecutiveUppercase: CamelCasedPropertiesDeep<{fooBAR: {fooBARBiz
 		}],
 	},
 };
+
+const splitOnPunctuation: CamelCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	userInfo: {
+		userId: 1,
+		userName: 'Tom',
+	},
+};
 ```
 
 @category Change case
@@ -86,11 +93,11 @@ type CamelCasedPropertiesArrayDeep<
 		? [_CamelCasedPropertiesDeep<U, Options>, ..._CamelCasedPropertiesDeep<V, Options>]
 		: Value extends readonly [infer U, ...infer V]
 			? readonly [_CamelCasedPropertiesDeep<U, Options>, ..._CamelCasedPropertiesDeep<V, Options>]
-			: // Leading spread array
-			Value extends readonly [...infer U, infer V]
+			// Leading spread array
+			: Value extends readonly [...infer U, infer V]
 				? [..._CamelCasedPropertiesDeep<U, Options>, _CamelCasedPropertiesDeep<V, Options>]
-				: // Array
-				Value extends Array<infer U>
+				// Array
+				: Value extends Array<infer U>
 					? Array<_CamelCasedPropertiesDeep<U, Options>>
 					: Value extends ReadonlyArray<infer U>
 						? ReadonlyArray<_CamelCasedPropertiesDeep<U, Options>>

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

@@ -2,7 +2,7 @@ import type {CamelCase, CamelCaseOptions, _DefaultCamelCaseOptions} from './came
 import type {ApplyDefaultOptions} from './internal/index.d.ts';
 
 /**
-Convert object properties to camel case but not recursively.
+Convert top-level object properties to camel case.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -26,6 +26,10 @@ const result: CamelCasedProperties<User> = {
 const preserveConsecutiveUppercase: CamelCasedProperties<{fooBAR: string}, {preserveConsecutiveUppercase: true}> = {
 	fooBAR: 'string',
 };
+
+const splitOnPunctuation: CamelCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	fooBar: 'string',
+};
 ```
 
 @category Change case

package/source/conditional-keys.d.ts

@@ -50,7 +50,7 @@ type NumberValueIndices = ConditionalKeys<[string, number?, string?], number | u
 @category Object
 */
 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>
+	? IfNotAnyOrNever<_Base, {ifNot: _ConditionalKeys<_Base, Condition>; ifAny: keyof _Base}>
 	: never;
 
 type _ConditionalKeys<Base, Condition> = keyof {

package/source/delimiter-case.d.ts

@@ -1,7 +1,6 @@
 import type {ApplyDefaultOptions, AsciiPunctuation, StartsWith} from './internal/index.d.ts';
-import type {IsStringLiteral} from './is-literal.d.ts';
+import type {IsStringLiteral} from './is-string-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}>;
@@ -17,7 +16,7 @@ type DelimiterCaseFromArray<
 	infer FirstWord extends string,
 	...infer RemainingWords extends string[],
 ]
-	? DelimiterCaseFromArray<RemainingWords, Delimiter, `${OutputString}${
+	? DelimiterCaseFromArray<RemainingWords, Delimiter, OutputString extends '' ? FirstWord : `${OutputString}${
 		StartsWith<FirstWord, AsciiPunctuation> extends true ? '' : Delimiter
 	}${FirstWord}`>
 	: OutputString;
@@ -38,6 +37,7 @@ import type {DelimiterCase} from 'type-fest';
 
 const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
 const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
+const someVariableWithPunctuation: DelimiterCase<'div.card::after', '#', {splitOnPunctuation: true}> = 'div#card#after';
 
 // Advanced
 
@@ -66,12 +66,14 @@ export type DelimiterCase<
 	Delimiter extends string,
 	Options extends WordsOptions = {},
 > = Value extends string
-	? IsStringLiteral<Value> extends false
-		? Value
-		: Lowercase<RemovePrefix<DelimiterCaseFromArray<
-			Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>,
-			Delimiter
-		>, string, {strict: false}>>
+	? Delimiter extends string // For distributing `Delimiter`
+		? IsStringLiteral<Value> extends false
+			? Value
+			: Lowercase<DelimiterCaseFromArray<
+				Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>,
+				Delimiter
+			>>
+		: never
 	: Value;
 
 export {};

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

@@ -4,7 +4,7 @@ import type {UnknownArray} from './unknown-array.d.ts';
 import type {WordsOptions} from './words.d.ts';
 
 /**
-Convert object properties to delimiter case recursively.
+Convert object properties to a custom string delimiter casing recursively.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -51,6 +51,13 @@ const splitOnNumbers: DelimiterCasedPropertiesDeep<{line1: {line2: [{line3: stri
 		],
 	},
 };
+
+const splitOnPunctuation: DelimiterCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, '-', {splitOnPunctuation: true}> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom',
+	},
+};
 ```
 
 @category Change case

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

@@ -3,7 +3,7 @@ import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.d.ts';
 
 /**
-Convert object properties to delimiter case but not recursively.
+Convert object properties to a custom string delimiter casing.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -27,6 +27,10 @@ const result: DelimiterCasedProperties<User, '-'> = {
 const splitOnNumbers: DelimiterCasedProperties<{line1: string}, '-', {splitOnNumbers: true}> = {
 	'line-1': 'string',
 };
+
+const splitOnPunctuation: DelimiterCasedProperties<{'foo::bar': string}, '-', {splitOnPunctuation: true}> = {
+	'foo-bar': 'string',
+};
 ```
 
 @category Change case

package/source/empty-object.d.ts

@@ -32,7 +32,7 @@ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<n
 export type EmptyObject = {[emptyObjectSymbol]?: never};
 
 /**
-Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
+Returns a boolean for whether the type is strictly equal to an empty plain object, the `{}` value.
 
 @example
 ```

package/source/entries.d.ts

@@ -6,7 +6,7 @@ type ObjectEntries<BaseType> = Array<_ObjectEntry<BaseType>>;
 type SetEntries<BaseType extends Set<unknown>> = Array<_SetEntry<BaseType>>;
 
 /**
-Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entries` type will return the type of that collection's entries.
+Create a type that describes the key-value pairs produced when calling a collection’s `entries` method.
 
 For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
 

package/source/entry.d.ts

@@ -7,7 +7,7 @@ export type _ObjectEntry<BaseType> = [keyof BaseType, BaseType[keyof BaseType]];
 export type _SetEntry<BaseType> = BaseType extends Set<infer ItemType> ? [ItemType, ItemType] : never;
 
 /**
-Many collections have an `entries` method which returns an array of a given object's own enumerable string-keyed property [key, value] pairs. The `Entry` type will return the type of that collection's entry.
+Create a type that describes a single key-value pair produced when calling a collection’s `entries` method.
 
 For example the {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries|`Object`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries|`Map`}, {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/entries|`Array`}, and {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set/entries|`Set`} collections all have this method. Note that `WeakMap` and `WeakSet` do not have this method since their entries are not enumerable.
 

package/source/exclude-exactly.d.ts

@@ -33,25 +33,25 @@ type TestExcludeExactly3 = ExcludeExactly<{a: string} | {a: string; b: string},
 @category Improved Built-in
 */
 export type ExcludeExactly<Union, Delete> =
-	IfNotAnyOrNever<
-		Union,
-		_ExcludeExactly<Union, Delete>,
+	IfNotAnyOrNever<Union, {
+		ifNot: _ExcludeExactly<Union, Delete>;
 		// If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
-		If<IsAny<Delete>, never, Union>,
+		ifAny: If<IsAny<Delete>, never, Union>;
 		// If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
-		If<IsNever<Delete>, never, Union>
-	>;
+		ifNever: If<IsNever<Delete>, never, Union>;
+	}>;
 
 type _ExcludeExactly<Union, Delete> =
-	IfNotAnyOrNever<Delete,
-		Union extends unknown // For distributing `Union`
+	IfNotAnyOrNever<Delete, {
+		ifNot: Union extends unknown // For distributing `Union`
 			? [Delete extends unknown // For distributing `Delete`
 				? If<IsEqual<Union, Delete>, true, never>
 				: never] extends [never] ? Union : never
-			: never,
+			: never;
 		// If `Delete` is `any` or `never`, then return `Union`,
 		// because `Union` cannot be `any` or `never` here.
-		Union, Union
-	>;
+		ifAny: Union;
+		ifNever: Union;
+	}>;
 
 export {};

package/source/exclude-rest-element.d.ts

@@ -27,14 +27,14 @@ type T4 = ExcludeRestElement<[number, string]>;
 @see {@link SplitOnRestElement}
 @category Array
 */
-export type ExcludeRestElement<Array_ extends UnknownArray> = IfNotAnyOrNever<Array_,
-	SplitOnRestElement<Array_> extends infer Result
+export type ExcludeRestElement<Array_ extends UnknownArray> = IfNotAnyOrNever<Array_, {
+	ifNot: SplitOnRestElement<Array_> extends infer Result
 		? Result extends readonly UnknownArray[]
 			? IsArrayReadonly<Array_> extends true
 				? Readonly<[...Result[0], ...Result[2]]>
 				: [...Result[0], ...Result[2]]
 			: never
-		: never
->;
+		: never;
+}>;
 
 export {};

package/source/exclusify-union.d.ts

@@ -125,13 +125,13 @@ type D = ExclusifyUnion<{a?: 1; readonly b: 2} | {d: 4}>;
 @category Object
 @category Union
 */
-export type ExclusifyUnion<Union> = IfNotAnyOrNever<Union,
-	If<IsUnknown<Union>, Union,
+export type ExclusifyUnion<Union> = IfNotAnyOrNever<Union, {
+	ifNot: If<IsUnknown<Union>, Union,
 		Extract<Union, NonRecursiveType | MapsSetsOrArrays> extends infer SkippedMembers
 			? SkippedMembers | _ExclusifyUnion<Exclude<Union, SkippedMembers>>
 			: never
-	>
->;
+	>;
+}>;
 
 type _ExclusifyUnion<Union, UnionCopy = Union> = Union extends unknown // For distributing `Union`
 	? Simplify<

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.