type-fest 4.41.0 → 5.0.1

package/source/extends-strict.d.ts

@@ -0,0 +1,42 @@
+import type {IsNever} from './is-never.d.ts';
+import type {IsAny} from './is-any.d.ts';
+
+/**
+A stricter, non-distributive version of `extends` for checking whether one type is assignable to another.
+
+Unlike the built-in `extends` keyword, `ExtendsStrict`:
+
+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`.
+
+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`.
+
+@example
+```
+import type {ExtendsStrict} from 'type-fest';
+
+type T1 = ExtendsStrict<number | string, string>;
+//=> false
+
+type T2 = ExtendsStrict<never, number>;
+//=> false
+
+type T3 = ExtendsStrict<never, never>;
+//=> true
+
+type T4 = ExtendsStrict<string, number | string>;
+//=> true
+
+type T5 = ExtendsStrict<string, string>;
+//=> true
+```
+
+@category Improved Built-in
+*/
+export type ExtendsStrict<Left, Right> =
+	IsAny<Left | Right> extends true
+		? true
+		: IsNever<Left> extends true
+			? IsNever<Right>
+			: [Left] extends [Right]
+				? true
+				: false;

package/source/extract-strict.d.ts

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

package/source/find-global-type.d.ts

@@ -60,5 +60,5 @@ type FindBar = FindGlobalInstanceType<'Bar'>; // Works
 */
 export type FindGlobalInstanceType<Name extends string> =
 	Name extends string
-		? typeof globalThis extends Record<Name, abstract new (...arguments: any[]) => infer T> ? T : never
+		? typeof globalThis extends Record<Name, abstract new (...arguments_: any[]) => infer T> ? T : never
 		: never;

package/source/fixed-length-array.d.ts

@@ -34,8 +34,8 @@ guestFencingTeam.push('Sam');
 @see ReadonlyTuple
 */
 export type FixedLengthArray<Element, Length extends number, ArrayPrototype = [Element, ...Element[]]> = Pick<
-ArrayPrototype,
-Exclude<keyof ArrayPrototype, ArrayLengthMutationKeys>
+	ArrayPrototype,
+	Exclude<keyof ArrayPrototype, ArrayLengthMutationKeys>
 > & {
 	[index: number]: Element;
 	[Symbol.iterator]: () => IterableIterator<Element>;

package/source/get.d.ts

@@ -1,8 +1,9 @@
-import type {ApplyDefaultOptions, StringDigit, ToString} from './internal';
-import type {LiteralStringUnion} from './literal-union';
-import type {Paths} from './paths';
-import type {Split} from './split';
-import type {StringKeyOf} from './string-key-of';
+import type {ApplyDefaultOptions, ToString} from './internal/index.d.ts';
+import type {LiteralStringUnion} from './literal-union.d.ts';
+import type {Paths} from './paths.d.ts';
+import type {Split} from './split.d.ts';
+import type {KeyAsString} from './key-as-string.d.ts';
+import type {DigitCharacter} from './characters.d.ts';
 
 type GetOptions = {
 	/**
@@ -27,9 +28,9 @@ type GetWithPath<BaseType, Keys, Options extends Required<GetOptions>> =
 		? BaseType
 		: Keys extends readonly [infer Head, ...infer Tail]
 			? GetWithPath<
-			PropertyOf<BaseType, Extract<Head, string>, Options>,
-			Extract<Tail, string[]>,
-			Options
+				PropertyOf<BaseType, Extract<Head, string>, Options>,
+				Extract<Tail, string[]>,
+				Options
 			>
 			: never;
 
@@ -64,7 +65,7 @@ ToPath<'foo[0].bar.baz'>
 //=> ['foo', '0', 'bar', 'baz']
 ```
 */
-type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
+type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.', {strictLiteralChecks: false}>;
 
 /**
 Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`.
@@ -111,7 +112,7 @@ type WithStringsKeys = keyof WithStrings;
 ```
 */
 type WithStringKeys<BaseType> = {
-	[Key in StringKeyOf<BaseType>]: UncheckedIndex<BaseType, Key>
+	[Key in KeyAsString<BaseType>]: UncheckedIndex<BaseType, Key>
 };
 
 /**
@@ -150,7 +151,7 @@ type PropertyOf<BaseType, Key extends string, Options extends Required<GetOption
 					length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
 				}
 					? (
-						ConsistsOnlyOf<Key, StringDigit> extends true
+						ConsistsOnlyOf<Key, DigitCharacter> extends true
 							? Strictify<Item, Options>
 							: unknown
 					)
@@ -213,7 +214,7 @@ export type Get<
 	Options extends GetOptions = {},
 > =
 	GetWithPath<
-	BaseType,
-	Path extends string ? ToPath<Path> : Path,
-	ApplyDefaultOptions<GetOptions, DefaultGetOptions, Options>
+		BaseType,
+		Path extends string ? ToPath<Path> : Path,
+		ApplyDefaultOptions<GetOptions, DefaultGetOptions, Options>
 	>;

package/source/globals/index.d.ts

@@ -0,0 +1 @@
+export type * from './observable-like.d.ts';

package/source/{observable-like.d.ts → globals/observable-like.d.ts}

@@ -9,6 +9,7 @@ declare global {
 @remarks
 The TC39 observable proposal defines a `closed` property, but some implementations (such as xstream) do not as of 10/08/2021.
 As well, some guidance on making an `Observable` to not include `closed` property.
+
 @see https://github.com/tc39/proposal-observable/blob/master/src/Observable.js#L129-L130
 @see https://github.com/staltz/xstream/blob/6c22580c1d84d69773ee4b0905df44ad464955b3/src/index.ts#L79-L85
 @see https://github.com/benlesh/symbol-observable#making-an-object-observable
@@ -23,10 +24,12 @@ export type Unsubscribable = {
 @category Observable
 */
 type OnNext<ValueType> = (value: ValueType) => void;
+
 /**
 @category Observable
 */
 type OnError = (error: unknown) => void;
+
 /**
 @category Observable
 */
@@ -44,6 +47,13 @@ export type Observer<ValueType> = {
 /**
 Matches a value that is like an [Observable](https://github.com/tc39/proposal-observable).
 
+You must import it as a sub-import:
+
+@example
+```
+import type {ObservableLike} from 'type-fest/globals';
+```
+
 @remarks
 The TC39 Observable proposal defines 2 forms of `subscribe()`:
 1. Three callback arguments: `subscribe(observer: OnNext<ValueType>, onError?: OnError, onComplete?: OnComplete): Unsubscribable;`

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

@@ -1,4 +1,4 @@
-import type {GreaterThan} from './greater-than';
+import type {GreaterThan} from './greater-than.d.ts';
 
 /**
 Returns a boolean for whether a given number is greater than or equal to another number.

package/source/greater-than.d.ts

@@ -1,8 +1,8 @@
-import type {NumberAbsolute, PositiveNumericStringGt} from './internal';
-import type {IsEqual} from './is-equal';
-import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric';
-import type {And} from './and';
-import type {Or} from './or';
+import type {NumberAbsolute, 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';
 
 /**
 Returns a boolean for whether a given number is greater than another number.
@@ -31,13 +31,13 @@ export type GreaterThan<A extends number, B extends number> =
 					IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
 				] extends infer R extends [boolean, boolean, boolean, boolean]
 					? Or<
-					And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-					And<IsEqual<R[3], true>, IsEqual<R[1], false>>
+						And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
+						And<IsEqual<R[3], true>, IsEqual<R[1], false>>
 					> extends true
 						? true
 						: Or<
-						And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-						And<IsEqual<R[2], true>, IsEqual<R[0], false>>
+							And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
+							And<IsEqual<R[2], true>, IsEqual<R[0], false>>
 						> extends true
 							? false
 							: true extends R[number]

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

@@ -1,4 +1,4 @@
-import type {OptionalKeysOf} from './optional-keys-of';
+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.

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

@@ -1,4 +1,4 @@
-import type {ReadonlyKeysOf} from './readonly-keys-of';
+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.

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

@@ -1,4 +1,4 @@
-import type {RequiredKeysOf} from './required-keys-of';
+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.

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

@@ -1,4 +1,4 @@
-import type {WritableKeysOf} from './writable-keys-of';
+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.

package/source/if-any.d.ts

@@ -1,8 +1,10 @@
-import type {IsAny} from './is-any';
+import type {IsAny} from './is-any.d.ts';
 
 /**
 An if-else-like type that resolves depending on whether the given type is `any`.
 
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
 @see {@link IsAny}
 
 @example

package/source/if-empty-object.d.ts

@@ -1,8 +1,10 @@
-import type {IsEmptyObject} from './empty-object';
+import type {IsEmptyObject} from './empty-object.d.ts';
 
 /**
 An if-else-like type that resolves depending on whether the given type is `{}`.
 
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
 @see {@link IsEmptyObject}
 
 @example

package/source/if-never.d.ts

@@ -1,8 +1,10 @@
-import type {IsNever} from './is-never';
+import type {IsNever} from './is-never.d.ts';
 
 /**
 An if-else-like type that resolves depending on whether the given type is `never`.
 
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
 @see {@link IsNever}
 
 @example

package/source/if-null.d.ts

@@ -1,8 +1,10 @@
-import type {IsNull} from './is-null';
+import type {IsNull} from './is-null.d.ts';
 
 /**
 An if-else-like type that resolves depending on whether the given type is `null`.
 
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
 @see {@link IsNull}
 
 @example

package/source/if-unknown.d.ts

@@ -1,8 +1,10 @@
-import type {IsUnknown} from './is-unknown';
+import type {IsUnknown} from './is-unknown.d.ts';
 
 /**
 An if-else-like type that resolves depending on whether the given type is `unknown`.
 
+@deprecated This type will be removed in the next major version. Use the {@link If} type instead.
+
 @see {@link IsUnknown}
 
 @example

package/source/if.d.ts

@@ -0,0 +1,65 @@
+import type {IsNever} from './is-never.d.ts';
+
+/**
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
+
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
+
+@example
+```
+import {If} from 'type-fest';
+
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
+
+@category Type Guard
+@category Utilities
+*/
+export type If<Type extends boolean, IfBranch, ElseBranch> =
+	IsNever<Type> extends true
+		? ElseBranch
+		: Type extends true
+			? IfBranch
+			: ElseBranch;

package/source/includes.d.ts

@@ -1,4 +1,4 @@
-import type {IsEqual} from './is-equal';
+import type {IsEqual} from './is-equal.d.ts';
 
 /**
 Returns a boolean for whether the given array includes the given item.

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

@@ -1,5 +1,5 @@
-import type {IntRange} from './int-range';
-import type {Sum} from './sum';
+import type {IntRange} from './int-range.d.ts';
+import type {Sum} from './sum.d.ts';
 
 /**
 Generate a union of numbers.

package/source/int-range.d.ts

@@ -1,5 +1,5 @@
-import type {BuildTuple} from './internal';
-import type {Subtract} from './subtract';
+import type {BuildTuple} from './internal/index.d.ts';
+import type {Subtract} from './subtract.d.ts';
 
 /**
 Generate a union of numbers.
@@ -41,8 +41,10 @@ type PrivateIntRange<
 	Start extends number,
 	End extends number,
 	Step extends number,
-	Gap extends number = Subtract<Step, 1>, // The gap between each number, gap = step - 1
-	List extends unknown[] = BuildTuple<Start, never>, // The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
+	// The gap between each number, gap = step - 1
+	Gap extends number = Subtract<Step, 1>,
+	// The final `List` is `[...StartLengthTuple, ...[number, ...GapLengthTuple], ...[number, ...GapLengthTuple], ... ...]`, so can initialize the `List` with `[...StartLengthTuple]`
+	List extends unknown[] = BuildTuple<Start, never>,
 	EndLengthTuple extends unknown[] = BuildTuple<End>,
 > = Gap extends 0 ?
 	// Handle the case that without `Step`

package/source/internal/array.d.ts

@@ -1,5 +1,8 @@
-import type {IfNever} from '../if-never';
-import type {UnknownArray} from '../unknown-array';
+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';
 
 /**
 Infer the length of the given array `<T>`.
@@ -91,36 +94,65 @@ T extends readonly [...infer U] ?
 /**
 Returns whether the given array `T` is readonly.
 */
-export type IsArrayReadonly<T extends UnknownArray> = IfNever<T, false, T extends unknown[] ? false : true>;
+export type IsArrayReadonly<T extends UnknownArray> = If<IsNever<T>, false, T extends unknown[] ? false : true>;
 
 /**
-An if-else-like type that resolves depending on whether the given array is readonly.
-
-@see {@link IsArrayReadonly}
+Transforms a tuple type by replacing it's rest element with a single element that has the same type as the rest element, while keeping all the non-rest elements intact.
 
 @example
 ```
-import type {ArrayTail} from 'type-fest';
+type A = CollapseRestElement<[string, string, ...number[]]>;
+//=> [string, string, number]
+
+type B = CollapseRestElement<[...string[], number, number]>;
+//=> [string, number, number]
 
-type ReadonlyPreservingArrayTail<TArray extends readonly unknown[]> =
-	ArrayTail<TArray> extends infer Tail
-		? IfArrayReadonly<TArray, Readonly<Tail>, Tail>
-		: never;
+type C = CollapseRestElement<[string, string, ...Array<number | bigint>]>;
+//=> [string, string, number | bigint]
 
-type ReadonlyTail = ReadonlyPreservingArrayTail<readonly [string, number, boolean]>;
-//=> readonly [number, boolean]
+type D = CollapseRestElement<[string, number]>;
+//=> [string, number]
+```
 
-type NonReadonlyTail = ReadonlyPreservingArrayTail<[string, number, boolean]>;
-//=> [number, boolean]
+Note: Optional modifiers (`?`) are removed from elements unless the `exactOptionalPropertyTypes` compiler option is disabled. When disabled, there's an additional `| undefined` for optional elements.
 
-type ShouldBeTrue = IfArrayReadonly<readonly unknown[]>;
-//=> true
+@example
+```
+// `exactOptionalPropertyTypes` enabled
+type A = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string, string, number]
 
-type ShouldBeBar = IfArrayReadonly<unknown[], 'foo', 'bar'>;
-//=> 'bar'
+// `exactOptionalPropertyTypes` disabled
+type B = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string | undefined, string | undefined, number]
 ```
 */
-export type IfArrayReadonly<T extends UnknownArray, TypeIfArrayReadonly = true, TypeIfNotArrayReadonly = false> =
-	IsArrayReadonly<T> extends infer Result
-		? Result extends true ? TypeIfArrayReadonly : TypeIfNotArrayReadonly
+export type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+
+type _CollapseRestElement<
+	TArray extends UnknownArray,
+	ForwardAccumulator extends UnknownArray = [],
+	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]
+				? _CollapseRestElement<
+					Rest,
+					[
+						...ForwardAccumulator,
+						'0' extends OptionalKeysOf<TArray>
+							? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+							: First,
+					],
+					BackwardAccumulator
+				>
+				: never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
 		: never; // Should never happen

package/source/internal/characters.d.ts

@@ -1,7 +1,3 @@
-export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
-
-export type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
-
 export type Whitespace =
 	| '\u{9}' // '\t'
 	| '\u{A}' // '\n'

package/source/internal/index.d.ts

@@ -1,8 +1,8 @@
-export type * from './array';
-export type * from './characters';
-export type * from './keys';
-export type * from './numeric';
-export type * from './object';
-export type * from './string';
-export type * from './tuple';
-export type * from './type';
+export type * from './array.d.ts';
+export type * from './characters.d.ts';
+export type * from './keys.d.ts';
+export type * from './numeric.d.ts';
+export type * from './object.d.ts';
+export type * from './string.d.ts';
+export type * from './tuple.d.ts';
+export type * from './type.d.ts';

package/source/internal/keys.d.ts

@@ -1,6 +1,7 @@
-import type {IsAny} from '../is-any';
-import type {IsLiteral} from '../is-literal';
-import type {ToString} from './string';
+import type {IsAny} from '../is-any.d.ts';
+import type {IsLiteral} from '../is-literal.d.ts';
+import type {IsUnknown} from '../is-unknown.d.ts';
+import type {ToString} from './string.d.ts';
 
 // Returns `never` if the key or property is not jsonable without testing whether the property is required or optional otherwise return the key.
 type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol
@@ -22,32 +23,32 @@ type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol
 Returns the required keys.
 */
 export type FilterDefinedKeys<T extends object> = Exclude<
-{
-	[Key in keyof T]: IsAny<T[Key]> extends true
-		? Key
-		: undefined extends T[Key]
-			? never
-			: T[Key] extends undefined
+	{
+		[Key in keyof T]: IsAny<T[Key]> extends true
+			? Key
+			: IsUnknown<T[Key]> extends true ? Key : undefined extends T[Key]
 				? never
-				: BaseKeyFilter<T, Key>;
-}[keyof T],
-undefined
+				: T[Key] extends undefined
+					? never
+					: BaseKeyFilter<T, Key>;
+	}[keyof T],
+	undefined
 >;
 
 /**
 Returns the optional keys.
 */
 export type FilterOptionalKeys<T extends object> = Exclude<
-{
-	[Key in keyof T]: IsAny<T[Key]> extends true
-		? never
-		: undefined extends T[Key]
-			? T[Key] extends undefined
-				? never
-				: BaseKeyFilter<T, Key>
-			: never;
-}[keyof T],
-undefined
+	{
+		[Key in keyof T]: IsAny<T[Key]> extends true
+			? never
+			: undefined extends T[Key]
+				? T[Key] extends undefined
+					? never
+					: BaseKeyFilter<T, Key>
+				: never;
+	}[keyof T],
+	undefined
 >;
 
 /**
@@ -63,7 +64,7 @@ export type LiteralKeyOf<T> = keyof {[K in keyof T as IsLiteral<K> extends true
 /**
 Get the exact version of the given `Key` in the given object `T`.
 
-Use-case: You known that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
+Use-case: You know that a number key (e.g. 10) is in an object, but you don't know how it is defined in the object, as a string or as a number (e.g. 10 or '10'). You can use this type to get the exact version of the key. See the example.
 
 @example
 ```