type-fest 5.3.0 → 5.4.0

package/index.d.ts

@@ -22,6 +22,7 @@ export type {TaggedUnion} from './source/tagged-union.d.ts';
 export type {Writable} from './source/writable.d.ts';
 export type {WritableDeep} from './source/writable-deep.d.ts';
 export type {Merge} from './source/merge.d.ts';
+export type {ObjectMerge} from './source/object-merge.d.ts';
 export type {MergeDeep, MergeDeepOptions} from './source/merge-deep.d.ts';
 export type {MergeExclusive} from './source/merge-exclusive.d.ts';
 export type {RequireAtLeastOne} from './source/require-at-least-one.d.ts';
@@ -32,6 +33,7 @@ export type {SingleKeyObject} from './source/single-key-object.d.ts';
 export type {OmitIndexSignature} from './source/omit-index-signature.d.ts';
 export type {PickIndexSignature} from './source/pick-index-signature.d.ts';
 export type {PartialDeep, PartialDeepOptions} from './source/partial-deep.d.ts';
+export type {UnwrapPartial} from './source/unwrap-partial.d.ts';
 export type {RequiredDeep} from './source/required-deep.d.ts';
 export type {PickDeep} from './source/pick-deep.d.ts';
 export type {OmitDeep} from './source/omit-deep.d.ts';
@@ -164,6 +166,7 @@ export type {IsOptional} from './source/is-optional.d.ts';
 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';
 
 // Template literal types
 export type {CamelCase, CamelCaseOptions} from './source/camel-case.d.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-fest",
-	"version": "5.3.0",
+	"version": "5.4.0",
 	"description": "A collection of essential TypeScript types",
 	"license": "(MIT OR CC0-1.0)",
 	"repository": "sindresorhus/type-fest",
@@ -25,9 +25,9 @@
 		"node": ">=20"
 	},
 	"scripts": {
-		"test:tsc": "node --max-old-space-size=5120 ./node_modules/.bin/tsc",
-		"test:tsd": "tsd",
-		"test:xo": "xo",
+		"test:tsc": "node --max-old-space-size=6144 ./node_modules/.bin/tsc",
+		"test:tsd": "node --max-old-space-size=6144 ./node_modules/.bin/tsd",
+		"test:xo": "node --max-old-space-size=6144 ./node_modules/.bin/xo",
 		"test:linter": "node --test",
 		"test": "run-p test:*"
 	},

package/readme.md

@@ -106,6 +106,7 @@ Click the type names for complete docs.
 - [`Writable`](source/writable.d.ts) - Create a type that strips `readonly` from the given type. Inverse of `Readonly<T>`.
 - [`WritableDeep`](source/writable-deep.d.ts) - Create a deeply mutable version of an `object`/`ReadonlyMap`/`ReadonlySet`/`ReadonlyArray` type. The inverse of `ReadonlyDeep<T>`. Use `Writable<T>` if you only need one level deep.
 - [`Merge`](source/merge.d.ts) - Merge two types into a new type. Keys of the second type overrides keys of the first type.
+- [`ObjectMerge`](source/object-merge.d.ts) - Merge two object types into a new object type, where keys from the second override keys from the first.
 - [`MergeDeep`](source/merge-deep.d.ts) - Merge two objects or two arrays/tuples recursively into a new type.
 - [`MergeExclusive`](source/merge-exclusive.d.ts) - Create a type that has mutually exclusive keys.
 - [`OverrideProperties`](source/override-properties.d.ts) - Override only existing properties of the given type. Similar to `Merge`, but enforces that the original type has the properties you want to override.
@@ -122,6 +123,7 @@ Click the type names for complete docs.
 - [`PartialDeep`](source/partial-deep.d.ts) - Create a deeply optional version of another type. Use [`Partial<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#partialtype) if you only need one level deep.
 - [`PartialOnUndefinedDeep`](source/partial-on-undefined-deep.d.ts) - Create a deep version of another type where all keys accepting `undefined` type are set to optional.
 - [`UndefinedOnPartialDeep`](source/undefined-on-partial-deep.d.ts) - Create a deep version of another type where all optional keys are set to also accept `undefined`.
+- [`UnwrapPartial`](source/unwrap-partial.d.ts) - Revert the `Partial` modifier on an object type.
 - [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
 - [`LiteralUnion`](source/literal-union.d.ts) - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
 - [`Tagged`](source/tagged.d.ts) - Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf). (This replaces the previous [`Opaque`](source/tagged.d.ts) type, which is now deprecated.)
@@ -263,6 +265,7 @@ Click the type names for complete docs.
 - [`SplitOnRestElement`](source/split-on-rest-element.d.ts) - Splits an array into three parts, where the first contains all elements before the rest element, the second is the [`rest`](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) element itself, and the third contains all elements after the rest element.
 - [`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.
 
 ### Numeric
 
@@ -474,6 +477,8 @@ There are many advanced types most users don't know about.
 	// NodeConfig interface.
 	new NodeAppBuilder().config({appName: 'ToDoApp'});
 	```
+
+	`Partial<T>` can be reverted with [`UnwrapPartial`](source/unwrap-partial.d.ts).
 	</details>
 
 - [`Required<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#requiredtype) - Make all properties in `T` required.

package/source/all-extend.d.ts

@@ -78,18 +78,21 @@ type D = AllExtend<[true, boolean, true], true>;
 Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
 
 ```
+// @exactOptionalPropertyTypes: true
 import type {AllExtend} from 'type-fest';
 
-// `exactOptionalPropertyTypes` enabled
 type A = AllExtend<[1?, 2?, 3?], number>;
 //=> true
+```
 
-// `exactOptionalPropertyTypes` disabled
-type B = AllExtend<[1?, 2?, 3?], number>;
-//=> false
+```
+// @exactOptionalPropertyTypes: false
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1?, 2?, 3?], number>;
+//=> boolean
 
-// `exactOptionalPropertyTypes` disabled
-type C = AllExtend<[1?, 2?, 3?], number | undefined>;
+type B = AllExtend<[1?, 2?, 3?], number | undefined>;
 //=> true
 ```
 

package/source/array-reverse.d.ts

@@ -0,0 +1,84 @@
+import type {If} from './if.d.ts';
+import type {IsArrayReadonly} from './internal/array.d.ts';
+import type {IfNotAnyOrNever, IsExactOptionalPropertyTypesEnabled} from './internal/type.d.ts';
+import type {IsOptionalKeyOf} from './is-optional-key-of.d.ts';
+import type {UnknownArray} from './unknown-array.d.ts';
+
+/**
+Reverse the order of elements in a tuple type.
+
+@example
+```ts
+import type {ArrayReverse} from 'type-fest';
+
+type A = ArrayReverse<[string, number, boolean]>;
+//=> [boolean, number, string]
+
+type B = ArrayReverse<readonly [string, number, ...boolean[]]>;
+//=> readonly [...boolean[], number, string]
+
+type C = ArrayReverse<['foo', 'bar'] | readonly [1, 2, 3]>;
+//=> ['bar', 'foo'] | readonly [3, 2, 1]
+
+type D = ArrayReverse<string[]>;
+//=> string[]
+
+type E = ArrayReverse<[]>;
+//=> []
+```
+
+Note: If the tuple contains optional elements, the result will be a union of tuples, refer to the examples below:
+
+@example
+```ts
+import type {ArrayReverse} from 'type-fest';
+
+type A = ArrayReverse<[string, number, boolean?]>;
+//=> [number, string] | [boolean, number, string]
+
+type B = ArrayReverse<[string, number?, boolean?]>;
+//=> [string] | [number, string] | [boolean, number, string]
+
+type C = ArrayReverse<[string?, number?, boolean?]>;
+//=> [] | [string] | [number, string] | [boolean, number, string]
+
+type D = ArrayReverse<[string, number?, ...boolean[]]>;
+//=> [string] | [...boolean[], number, string]
+
+type E = ArrayReverse<[string?, number?, ...boolean[]]>;
+//=> [] | [string] | [...boolean[], number, string]
+```
+
+@category Array
+*/
+export type ArrayReverse<TArray extends UnknownArray> = IfNotAnyOrNever<TArray,
+	TArray extends unknown // For distributing `TArray`
+		? _ArrayReverse<TArray> extends infer Result
+			? If<IsArrayReadonly<TArray>, Readonly<Result>, Result>
+			: never // Should never happen
+		: never>; // Should never happen
+
+type _ArrayReverse<
+	TArray extends UnknownArray,
+	BeforeRestAcc extends UnknownArray = [],
+	AfterRestAcc extends UnknownArray = [],
+	Result extends UnknownArray = never,
+> =
+	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]
+			? _ArrayReverse<Rest, BeforeRestAcc, [...AfterRestAcc, Last], Result> // Accumulate elements that are present after the rest element in reverse order.
+			: Result | [...AfterRestAcc, ...TArray, ...BeforeRestAcc] // Add the rest element between the accumulated elements.
+		: TArray extends readonly [(infer First)?, ...infer Rest]
+			? IsOptionalKeyOf<TArray, '0'> extends true
+				? _ArrayReverse<
+					Rest,
+					[First | (If<IsExactOptionalPropertyTypesEnabled, never, undefined>), ...BeforeRestAcc], // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+					AfterRestAcc,
+					Result | BeforeRestAcc
+				>
+				: _ArrayReverse<Rest, [First, ...BeforeRestAcc], AfterRestAcc, Result>
+			: never; // Should never happen, since `readonly [(infer First)?, ...infer Rest]` is a top-type for arrays.
+
+export {};

package/source/array-slice.d.ts

@@ -45,7 +45,7 @@ function arraySlice<
 const slice = arraySlice([1, '2', {a: 3}, [4, 5]], 0, -1);
 
 type Slice = typeof slice;
-//=> [1, '2', { readonly a: 3; }]
+//=> [1, '2', {readonly a: 3}]
 
 const value = slice[2].a;
 //=> 3

package/source/array-splice.d.ts

@@ -76,15 +76,15 @@ import type {ArraySplice} from 'type-fest';
 
 type SomeMonths0 = ['January', 'April', 'June'];
 type Months0 = ArraySplice<SomeMonths0, 1, 0, ['Feb', 'March']>;
-//=> ['January', 'Feb', 'March', 'April', 'June'];
+//=> ['January', 'Feb', 'March', 'April', 'June']
 
 type SomeMonths1 = ['January', 'April', 'June'];
 type Months1 = ArraySplice<SomeMonths1, 1, 1>;
-//=> ['January', 'June'];
+//=> ['January', 'June']
 
 type SomeMonths2 = ['January', 'Foo', 'April'];
 type Months2 = ArraySplice<SomeMonths2, 1, 1, ['Feb', 'March']>;
-//=> ['January', 'Feb', 'March', 'April'];
+//=> ['January', 'Feb', 'March', 'April']
 ```
 
 @category Array

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

@@ -83,7 +83,7 @@ type StringOrBooleanPick = ConditionalPickDeep<Example, string | boolean>;
 // 	c: {
 // 		d: string;
 // 		e: {
-// 			h: string | boolean
+// 			h: string | boolean;
 // 		};
 // 		j: boolean;
 // 	};

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

@@ -53,11 +53,11 @@ type TypeB = {
 
 type SimplifyDeepTypeAB = ConditionalSimplifyDeep<TypeA & TypeB, SomeComplexType1 | SomeComplexType2, object>;
 //=> {
-//	foo: {
+// 	foo: {
 // 		a: string;
-// 		b: string;
 // 		complexType: SomeComplexType1 & SomeComplexType2;
-//	};
+// 		b: string;
+// 	};
 // }
 ```
 

package/source/distributed-omit.d.ts

@@ -34,7 +34,7 @@ if (omittedUnion.discriminant === 'A') {
 
 	// @ts-expect-error
 	const aValue = omittedUnion.a;
-	//=> Error: `a` is not a property of `{discriminant: 'A' | 'B'}`
+	// Error: `a` is not a property of `{discriminant: 'A' | 'B'}`
 }
 ```
 
@@ -74,15 +74,15 @@ declare const omittedUnion: OmittedUnion;
 
 if (omittedUnion.discriminant === 'A') {
 	const aValue = omittedUnion.a;
-	//=> OK
+	// OK
 
 	// @ts-expect-error
 	const fooValue = omittedUnion.foo;
-	//=> Error: `foo` is not a property of `{discriminant: 'A'; a: string}`
+	// Error: `foo` is not a property of `{discriminant: 'A'; a: string}`
 
 	// @ts-expect-error
 	const barValue = omittedUnion.bar;
-	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`
+	// Error: `bar` is not a property of `{discriminant: 'A'; a: string}`
 }
 ```
 

package/source/distributed-pick.d.ts

@@ -25,7 +25,7 @@ type B = {
 type Union = A | B;
 
 type PickedUnion = Pick<Union, 'discriminant' | 'foo'>;
-//=> {discriminant: 'A' | 'B', foo: {bar: string} | {baz: string}}
+//=> {discriminant: 'A' | 'B'; foo: {bar: string} | {baz: string}}
 
 declare const pickedUnion: PickedUnion;
 
@@ -36,7 +36,7 @@ if (pickedUnion.discriminant === 'A') {
 
 	// @ts-expect-error
 	const barValue = pickedUnion.foo.bar;
-	//=> Error: Property 'bar' does not exist on type '{bar: string} | {baz: string}'.
+	// Error: Property 'bar' does not exist on type '{bar: string} | {baz: string}'.
 }
 ```
 
@@ -70,15 +70,15 @@ declare const pickedUnion: PickedUnion;
 
 if (pickedUnion.discriminant === 'A') {
 	const barValue = pickedUnion.foo.bar;
-	//=> OK
+	// OK
 
 	// @ts-expect-error
 	const extraneousValue = pickedUnion.extraneous;
-	//=> Error: Property `extraneous` does not exist on type `Pick<A, 'discriminant' | 'foo'>`.
+	// Error: Property `extraneous` does not exist on type `Pick<A, 'discriminant' | 'foo'>`.
 
 	// @ts-expect-error
 	const bazValue = pickedUnion.foo.baz;
-	//=> Error: `bar` is not a property of `{discriminant: 'A'; a: string}`.
+	// Error: `bar` is not a property of `{discriminant: 'A'; a: string}`.
 }
 ```
 

package/source/exact.d.ts

@@ -29,7 +29,7 @@ declare function onlyAcceptName(arguments_: OnlyAcceptName): void;
 // TypeScript complains about excess properties when an object literal is provided.
 // @ts-expect-error
 onlyAcceptName({name: 'name', id: 1});
-//=> `id` is excess
+// `id` is excess
 
 // TypeScript does not complain about excess properties when the provided value is a variable (not an object literal).
 const invalidInput = {name: 'name', id: 1};

package/source/except.d.ts

@@ -68,14 +68,14 @@ type FooWithoutA = Except<Foo, 'a'>;
 
 // @ts-expect-error
 const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
-//=> errors: 'a' does not exist in type '{ b: string; }'
+// errors: 'a' does not exist in type '{ b: string; }'
 
 type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
-//=> {a: number} & Partial<Record<"b", never>>
+//=> {a: number} & Partial<Record<'b', never>>
 
 // @ts-expect-error
 const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
-//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+// errors at 'b': Type 'string' is not assignable to type 'undefined'.
 
 // The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
 
@@ -90,12 +90,12 @@ type UserData = {
 
 // `Omit` clearly doesn't behave as expected in this case:
 type PostPayload = Omit<UserData, 'email'>;
-//=> { [x: string]: string; [x: number]: string; }
+//=> {[x: string]: string; [x: number]: string}
 
 // In situations like this, `Except` works better.
 // It simply removes the `email` key while preserving all the other keys.
 type PostPayloadFixed = Except<UserData, 'email'>;
-//=> { [x: string]: string; name: string; role: 'admin' | 'user'; }
+//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
 ```
 
 @category Object

package/source/exclusify-union.d.ts

@@ -30,13 +30,19 @@ loadConfig1({filePath: './config.json', content: '{ "name": "app" }'}); // No er
 
 // Use `ExclusifyUnion` to prevent that mistake.
 type Config = ExclusifyUnion<FileConfig | InlineConfig>;
-//=> {filePath: string; content?: never} | {content: string; filePath?: never}
+//=> {
+// 	filePath: string;
+// 	content?: never;
+// } | {
+// 	content: string;
+// 	filePath?: never;
+// }
 
 declare function loadConfig2(options: Config): void;
 
 // @ts-expect-error
 loadConfig2({filePath: './config.json', content: '{ "name": "app" }'});
-//=> Error: Argument of type '{ filePath: string; content: string; }' is not assignable to parameter of type '{ filePath: string; content?: never; } | { content: string; filePath?: never; }'.
+// Error: Argument of type '{ filePath: string; content: string; }' is not assignable to parameter of type '{ filePath: string; content?: never; } | { content: string; filePath?: never; }'.
 
 loadConfig2({filePath: './config.json'}); // Ok
 
@@ -63,7 +69,15 @@ function processPayment1(payment: CardPayment | PaypalPayment) {
 }
 
 type Payment = ExclusifyUnion<CardPayment | PaypalPayment>;
-//=> {amount: number; cardNumber: string; paypalId?: never} | {amount: number; paypalId: string; cardNumber?: never}
+//=> {
+// 	amount: number;
+// 	cardNumber: string;
+// 	paypalId?: never;
+// } | {
+// 	amount: number;
+// 	paypalId: string;
+// 	cardNumber?: never;
+// }
 
 function processPayment2(payment: Payment) {
 	const details = payment.cardNumber ?? payment.paypalId; // Ok
@@ -76,16 +90,36 @@ function processPayment2(payment: Payment) {
 import type {ExclusifyUnion} from 'type-fest';
 
 type A = ExclusifyUnion<{a: string} | {b: number}>;
-//=> {a: string; b?: never} | {a?: never; b: number}
+//=> {a: string; b?: never} | {b: number; a?: never}
 
 type B = ExclusifyUnion<{a: string} | {b: number} | {c: boolean}>;
-//=> {a: string; b?: never; c?: never} | {a?: never; b: number; c?: never} | {a?: never; b?: never; c: boolean}
+//=> {
+// 	a: string;
+// 	b?: never;
+// 	c?: never;
+// } | {
+// 	b: number;
+// 	a?: never;
+// 	c?: never;
+// } | {
+// 	c: boolean;
+// 	a?: never;
+// 	b?: never;
+// }
 
 type C = ExclusifyUnion<{a: string; b: number} | {b: string; c: number}>;
-//=> {a: string; b: number; c?: never} | {a?: never; b: string; c: number}
+//=> {
+// 	a: string;
+// 	b: number;
+// 	c?: never;
+// } | {
+// 	b: string;
+// 	c: number;
+// 	a?: never;
+// }
 
 type D = ExclusifyUnion<{a?: 1; readonly b: 2} | {d: 4}>;
-//=> {a?: 1; readonly b: 2; d?: never} | {a?: never; b?: never; d: 4}
+//=> {a?: 1; readonly b: 2; d?: never} | {d: 4; a?: never; b?: never}
 ```
 
 @category Object

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

@@ -34,7 +34,7 @@ const color: FixedLengthArray<number, 3> = [255, 128, 64];
 
 // @ts-expect-error
 color.pop();
-//=> Error: Property 'pop' does not exist on type 'FixedLengthArray<number, 3>'.
+// Error: Property 'pop' does not exist on type 'FixedLengthArray<number, 3>'.
 ```
 
 Use-cases:
@@ -56,7 +56,7 @@ const blue = color[2];
 
 // @ts-expect-error
 const alpha = color[3];
-//=> Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
+// Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
 
 // You can write to valid indices.
 color[0] = 128;
@@ -66,19 +66,19 @@ color[2] = 32;
 // But you cannot write to out-of-bounds indices.
 // @ts-expect-error
 color[3] = 0.5;
-//=> Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
+// Error: Property '3' does not exist on type 'FixedLengthArray<number, 3>'.
 
 // @ts-expect-error
 color.push(0.5);
-//=> Error: Property 'push' does not exist on type 'FixedLengthArray<number, 3>'.
+// Error: Property 'push' does not exist on type 'FixedLengthArray<number, 3>'.
 
 // @ts-expect-error
 color = [0, 128, 255, 0.5];
-//=> Error: Type '[number, number, number, number]' is not assignable to type 'FixedLengthArray<number, 3>'. Types of property 'length' are incompatible.
+// Error: Type '[number, number, number, number]' is not assignable to type 'FixedLengthArray<number, 3>'. Types of property 'length' are incompatible.
 
 // @ts-expect-error
 color.length = 4;
-//=> Error: Cannot assign to 'length' because it is a read-only property.
+// Error: Cannot assign to 'length' because it is a read-only property.
 
 function toHex([r, g, b]: readonly [number, number, number]) {
 	return `#${r.toString(16)}${g.toString(16)}${b.toString(16)}`;

package/source/get.d.ts

@@ -187,18 +187,24 @@ type ApiResponse = {
 };
 
 const getName = (apiResponse: ApiResponse) => get(apiResponse, 'hits.hits[0]._source.name');
-//=> (apiResponse: ApiResponse) => {given: string[]; family: string}[] | undefined
+//=> (apiResponse: ApiResponse) => {
+// 	given: string[];
+// 	family: string;
+// }[] | undefined
 
 // Path also supports a readonly array of strings
 const getNameWithPathArray = (apiResponse: ApiResponse) => get(apiResponse, ['hits', 'hits', '0', '_source', 'name']);
-//=> (apiResponse: ApiResponse) => {given: string[]; family: string}[] | undefined
+//=> (apiResponse: ApiResponse) => {
+// 	given: string[];
+// 	family: string;
+// }[] | undefined
 
 // Non-strict mode:
 type A = Get<string[], '3', {strict: false}>;
 //=> string
 
 type B = Get<Record<string, string>, 'foo', {strict: true}>;
-// => string | undefined
+//=> string | undefined
 ```
 
 @category Object

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

@@ -17,8 +17,8 @@ Use-cases:
 ```
 import type {IntClosedRange} from 'type-fest';
 
-type Age = IntClosedRange<0, 120>;
-//=> 0 | 1 | 2 | ... | 119 | 120
+type Age = IntClosedRange<0, 20>;
+//=> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20
 
 type FontSize = IntClosedRange<10, 20>;
 //=> 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20

package/source/int-range.d.ts

@@ -17,8 +17,8 @@ Use-cases:
 ```
 import type {IntRange} from 'type-fest';
 
-type Age = IntRange<0, 120>;
-//=> 0 | 1 | 2 | ... | 119
+type Age = IntRange<0, 20>;
+//=> 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19
 
 type FontSize = IntRange<10, 20>;
 //=> 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19

package/source/internal/object.d.ts

@@ -9,7 +9,7 @@ import type {If} from '../if.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {FilterDefinedKeys, FilterOptionalKeys} from './keys.d.ts';
 import type {MapsSetsOrArrays, NonRecursiveType} from './type.d.ts';
-import type {ToString} from './string.d.ts';
+import type {StringToNumber, ToString} from './string.d.ts';
 
 /**
 Create an object type with the given key `<Key>` and value `<Value>`.
@@ -265,4 +265,28 @@ export type CollapseLiterals<T> = {} extends T
 		? U
 		: T;
 
+/**
+Normalize keys by including string and number representations wherever applicable.
+
+@example
+```ts
+type A = NormalizedKeys<0 | '1'>;
+//=> 0 | '0' | 1 | '1'
+
+type B = NormalizedKeys<string>;
+//=> string | number
+
+type C = NormalizedKeys<number>;
+//=> number | `${number}`
+
+type D = NormalizedKeys<symbol | 'foo'>;
+//=> symbol | 'foo'
+```
+*/
+export type NormalizedKeys<Keys extends PropertyKey> =
+	| Keys
+	| (string extends Keys ? number : never)
+	| StringToNumber<Keys & string>
+	| ToString<Keys & number>;
+
 export {};

package/source/is-literal.d.ts

@@ -207,7 +207,7 @@ const stringId = getId({asString: true});
 
 declare const runtimeBoolean: boolean;
 const eitherId = getId({asString: runtimeBoolean});
-//=> number | string
+//=> string | number
 ```
 
 @category Type Guard
@@ -236,7 +236,8 @@ function get<Object_ extends Record<symbol, number>, Key extends keyof Object_>(
 }
 
 const symbolLiteral = Symbol('literal');
-const symbolValue = Symbol('value');
+let symbolValue = Symbol('value1');
+symbolValue = Symbol('value2');
 
 get({[symbolLiteral]: 1} as const, symbolLiteral);
 //=> 1

package/source/is-never.d.ts

@@ -38,14 +38,14 @@ type IsTrue<T> = T extends true ? true : false;
 
 // When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
 type A = IsTrue<never>;
-//   ^? type A = never
+//=> never
 
 // If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
 type IsTrueFixed<T> =
 	IsNever<T> extends true ? false : T extends true ? true : false;
 
 type B = IsTrueFixed<never>;
-//   ^? type B = false
+//=> false
 ```
 
 @category Type Guard

package/source/is-unknown.d.ts

@@ -12,7 +12,7 @@ Useful in type utilities, such as when dealing with unknown data from API calls.
 import type {IsUnknown} from 'type-fest';
 
 type A = IsUnknown<unknown>;
-//=> unknown
+//=> true
 
 type B = IsUnknown<any>;
 //=> false

package/source/jsonifiable.d.ts

@@ -19,17 +19,15 @@ const error: Jsonifiable = {
 	map: new Map([['a', 1]]),
 };
 
-JSON.stringify(error);
-//=> {"map": {}}
+console.log(JSON.stringify(error)); // {"map": {}}
 
 const good: Jsonifiable = {
 	number: 3,
-	date: new Date(),
+	date: new Date('2025-12-25'),
 	missing: undefined,
 };
 
-JSON.stringify(good);
-//=> {"number": 3, "date": "2022-10-17T22:22:35.920Z"}
+console.log(JSON.stringify(good)); // {"number": 3, "date": "2025-12-25T00:00:00.000Z"}
 ```
 
 @category JSON

package/source/key-as-string.d.ts

@@ -17,7 +17,7 @@ type Foo = {
 };
 
 type StringKeysOfFoo = KeyAsString<Foo>;
-//=> '1' | 'stringKey'
+//=> 'stringKey' | '1'
 ```
 
 @category Object