diff --git a/source/internal/type.d.ts b/source/internal/type.d.ts
index c1f53a2b9..7038aa766 100644
--- a/source/internal/type.d.ts
+++ b/source/internal/type.d.ts
@@ -2,6 +2,8 @@ import type {If} from '../if.d.ts';
 import type {IsAny} from '../is-any.d.ts';
 import type {IsNever} from '../is-never.d.ts';
 import type {Primitive} from '../primitive.d.ts';
+import type {IsEqual} from '../is-equal.d.ts';
+import type {UnionToIntersection} from '../union-to-intersection.d.ts';
 import type {UnknownArray} from '../unknown-array.d.ts';
 
 /**
@@ -161,4 +163,50 @@ export type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extend
 	? false
 	: true;
 
+/**
+Returns the last element of a union type; otherwise `never` if `never` passed.
+Note that this is non-deterministic because the order of union type is not guaranteed.
+
+@see https://github.com/microsoft/TypeScript/issues/13298#issuecomment-468375328
+
+This can be used to implement a recursive type function that accepts a union type.
+It can detect a termination case using {@link IsNever `IsNever`}.
+
+@example
+```
+type RecursionType<T, R = []> =
+	LastOfUnion<T> extends infer L
+		? IsNever<L> extends false
+			? RecursionType<Exclude<T, L>, [...R, L]>
+			: R
+		: never;
+
+type RecursionTest = RecursionType<string | number>;
+//=> [string, number]
+```
+
+@example
+```
+export type UnionToTuple<T, L = LastOfUnion<T>> =
+	IsNever<T> extends false
+		? [...UnionToTuple<Exclude<T, L>>, L]
+		: [];
+```
+
+@example
+```
+type Last = LastOfUnion<1 | 2 | 3>;
+//=> 3
+
+type LastNever = LastOfUnion<never>;
+//=> never
+```
+*/
+export type LastOfUnion<T> =
+	IsEqual<T, never> extends true
+		? never
+		: UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
+			? R
+			: never;
+
 export {};
diff --git a/source/pick-deep.d.ts b/source/pick-deep.d.ts
index 4c8e0d60c..789b2c693 100644
--- a/source/pick-deep.d.ts
+++ b/source/pick-deep.d.ts
@@ -1,10 +1,169 @@
 import type {TupleOf} from './tuple-of.d.ts';
-import type {BuildObject, NonRecursiveType, ObjectValue} from './internal/index.d.ts';
-import type {IsNever} from './is-never.d.ts';
+import type {BuildObject, LastOfUnion, StringToNumber} from './internal/index.d.ts';
 import type {Paths} from './paths.d.ts';
 import type {Simplify} from './simplify.d.ts';
-import type {UnionToIntersection} from './union-to-intersection.d.ts';
+import type {GreaterThan} from './greater-than.d.ts';
+import type {IsEqual} from './is-equal.d.ts';
+import type {Or} from './or.d.ts';
+import type {IsNegative} from './numeric.d.ts';
+import type {IsTuple} from './is-tuple.d.ts';
+import type {KeysOfUnion} from './keys-of-union.d.ts';
 import type {UnknownArray} from './unknown-array.d.ts';
+import type {IsNever} from './is-never.d.ts';
+
+/**
+`Pick<{0: 0}, '0'>` does not work as expected in some cases, but `ForcePick` handles both `string` and `number` keys correctly.
+
+type Test_ForcePick_0 = ForcePick<[0,1], 1>; // 1
+type Test_ForcePick_1 = ForcePick<{0: 'aa'}, '0'>; // {0: 'aa'}
+type Test_ForcePick_2 = ForcePick<{'0': 'aa'}, '0'>; // {'0': 'aa'}
+type Test_ForcePick_3 = ForcePick<{0: 'aa'}, 0>; // {0: 'aa'}
+type Test_ForcePick_4 = ForcePick<{'0': 'aa'}, 0>; // {'0': 'aa'}
+*/
+type ForcePick<Collection, Key extends (string | number)> =
+	Collection extends UnknownArray
+		? Collection[Key extends keyof Collection ? Key : never]
+		: {[K in keyof Collection as `${K extends (string | number) ? K : never}` extends `${Key}` ? K : never]: Collection[K]};
+
+/**
+Forcefully access the property value of `T` by Key if it exists, supporting both `string` and `number` representations; otherwise, return `never`.
+
+type TestForceGet_0 = ForceGet<{2: 'x'}, '2'>; // 'x'
+type TestForceGet_1 = ForceGet<{'2': 'x'}, '2'>; // 'x'
+type TestForceGet_2 = ForceGet<{2: 'x'}, 2>; // 'x'
+type TestForceGet_3 = ForceGet<{'2': 'x'}, 2>; // 'x'
+type TestForceGet_4 = ForceGet<['x', 'xx'], 0>; // 'x'
+type TestForceGet_5 = ForceGet<['x', 'xx'], '0'>; // 'x'
+type TestForceGet_6 = ForceGet<['x', 'xx'], '2'>; // never
+type TestForceGet_7 = ForceGet<{a: 'x'}, 'b'>; // never
+type TestForceGet_8 = ForceGet<[0,1,2], `${number}`>; // 0 | 1 | 2
+type TestForceGet_9 = ForceGet<string[], `${number}`> // string
+*/
+type ForceGet<T, Key extends PropertyKey> =
+	Key extends keyof T
+		? T[Key]
+		: Key extends string | number
+			? StringToNumber<`${Key}`> extends infer Number_ extends number
+				? IsNever<Number_> extends false
+					? `${Key}` extends `${keyof T extends (string | number) ? keyof T : never}`
+						? T[(`${Key}` extends infer K extends keyof T ? K : never)] | T[(Number_ extends infer K extends keyof T ? K : never)]
+						/* `${number}` case */
+						: `${Key}` extends `${infer N extends number}`
+							? [IsEqual<N, number>, T] extends [true, ReadonlyArray<infer ArrayType>]
+								? ArrayType
+								: never
+							: never
+					: never
+				: never
+			: never;
+
+/**
+Returns `true` if the key is theoretically accessible on the value `A`; otherwise, returns `false`.
+
+type Test_IsKeyOf_0 = IsKeyOf<[0, 1], 1>; // true
+type Test_IsKeyOf_1 = IsKeyOf<[0, 1], 3>; // false
+type Test_IsKeyOf_2 = IsKeyOf<[0, 1], -1>; // false
+type Test_IsKeyOf_3 = IsKeyOf<[0, 1], 's'>; // false
+type Test_IsKeyOf_4 = IsKeyOf<[0, 1], '1'>; // true
+type Test_IsKeyOf_5 = IsKeyOf<[0, 1], '3'>; // false
+type Test_IsKeyOf_6 = IsKeyOf<[0, 1], '-1'>; // false
+type Test_IsKeyOf_7 = IsKeyOf<[0, 1], `${number}`>; // true
+type Test_IsKeyOf_8 = IsKeyOf<Array<{a: 0}>, `${number}`>; // true
+type Test_IsKeyOf_9 = IsKeyOf<{0: 'a0'}, 0>; // true
+type Test_IsKeyOf_10 = IsKeyOf<{'0': 'a0'}, 0>; // true
+type Test_IsKeyOf_11 = IsKeyOf<{0: 'a0'}, '0'>; // true
+type Test_IsKeyOf_12 = IsKeyOf<{'0': 'a0'}, 0>; // true
+type Test_IsKeyOf_13 = IsKeyOf<{'0': 'a0'}, never>; // false
+*/
+type IsKeyOf<A, K extends PropertyKey> =
+	IsEqual<K, never> extends true
+		? false
+		: A extends UnknownArray
+			? IsEqual<IsTuple<A>, true> extends false
+				? K extends `${number}`
+					? true
+					: K extends (string | number)
+						? IsEqual<false, IsNegative<StringToNumber<`${K}`>>>
+						: never
+				: K extends (string | number)
+					? [A['length'], IsEqual<A['length'], number>, IsEqual<false, IsNegative<StringToNumber<`${K}`>>>, GreaterThan<A['length'], StringToNumber<`${K}`>>] extends [number, false, true, true]
+						? true
+						: false
+					: false
+			: A extends object
+				? K extends (string | number)
+					? `${K}` extends `${keyof A extends (string | number) ? keyof A : never}`
+						? true
+						: false
+					: false
+				: false;
+
+/**
+Returns `A` itself if it is not an `object`.
+If `A` is an `object`, behaves like `Pick<A, K>`.
+If `A` is an `UnknownArray`, returns `A[K]`.
+If `K` is `never`, returns `never`.
+
+This fixes https://github.com/sindresorhus/type-fest/issues/1224.
+
+type Test_PickOrSelf_0 = PickOrSelf<string, 'a'>; // string
+type Test_PickOrSelf_1 = PickOrSelf<{readonly a?: 0}, 'a'>; // {readonly a?: 0}
+type Test_PickOrSelf_2 = PickOrSelf<{2?: 0}, '2'>; // {2?: 0}
+type Test_PickOrSelf_3 = PickOrSelf<{2?: 0}, 2>; // {2?: 0}
+type Test_PickOrSelf_4 = PickOrSelf<{'2': 0}, 2>; // {'2': 0}
+type Test_PickOrSelf_5 = PickOrSelf<{2?: 0}, never>; // never
+*/
+type PickOrSelf<A, K extends (number | string)> =
+	A extends UnknownArray
+		? ForcePick<A, K>
+		: A extends object
+			? IsEqual<true, IsKeyOf<A, K>> extends true
+				? ForcePick<A, K>
+				: never
+			: A;
+
+/**
+Merges only the `object` types from a union; otherwise, returns the value as-is.
+
+type Test_MergeOnlyObjectUnion_0 = MergeOnlyObjectUnion<0 | string | {readonly a: 0} | {b?: 2} | [0] | [1]>; // string | 0 | [0] | [1] | {readonly a: 0; b?: 2}
+*/
+type MergeOnlyObjectUnion<MaybeObjectUnion> = _MergeOnlyObjectUnion<MaybeObjectUnion>;
+type _MergeOnlyObjectUnion<MaybeObjectUnion, ObjectStack = {}, UnionStack = never> =
+	LastOfUnion<MaybeObjectUnion> extends infer L
+		? IsNever<L> extends false
+			? L extends UnknownArray
+				? _MergeOnlyObjectUnion<Exclude<MaybeObjectUnion, L>, ObjectStack, UnionStack | L>
+				: L extends object
+					? _MergeOnlyObjectUnion<Exclude<MaybeObjectUnion, L>, ObjectStack & L, UnionStack>
+					: _MergeOnlyObjectUnion<Exclude<MaybeObjectUnion, L>, ObjectStack, UnionStack | L>
+			: UnionStack | Simplify<IsEqual<{}, ObjectStack> extends false ? ObjectStack : never>
+		: never;
+
+/**
+This doesn't fail with non-object type, to safely support `keyof` with union types including `object`s.
+
+type Test_CoerceKeyof_0 = CoerceKeyof<string | {x: 0}>; // "x"
+type Test_CoerceKeyof_1 = CoerceKeyof<string | {x: 0} | {y: 0}>; // "x" | "y"
+type Test_CoerceKeyof_2 = CoerceKeyof<string>; // never
+*/
+type CoerceKeyof<R> = R extends object ? keyof R extends (string | number) ? keyof R : never : never;
+
+/* `BuildObject` supporting `${number}`. */
+type Build<K extends PropertyKey, L, M extends object | UnknownArray> =
+	`${K extends string ? K : never}` extends `${infer N extends number}`
+		? IsEqual<N, number> extends true
+			/* Preserve readonly for arrays */
+			? M extends unknown[]
+				? L[]
+				: M extends readonly unknown[]
+					? readonly L[]
+					: never
+			: M extends unknown[]
+				? [...TupleOf<N>, L]
+				: M extends readonly unknown[]
+					? readonly [...TupleOf<N>, L]
+					: BuildObject<K, L, M>
+		: BuildObject<K, L, M>;
 
 /**
 Pick properties from a deeply-nested object.
@@ -77,76 +236,114 @@ type Street = PickDeep<Configuration, 'userConfig.address.1.street2'>;
 @category Object
 @category Array
 */
-export type PickDeep<T, PathUnion extends Paths<T>> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray
-			? UnionToIntersection<{
-				[P in PathUnion]: InternalPickDeep<T, P>;
-			}[PathUnion]
-			>
-			: T extends object
-				? Simplify<UnionToIntersection<{
-					[P in PathUnion]: InternalPickDeep<T, P>;
-				}[PathUnion]>>
-				: never;
+export type PickDeep<T, PathUnion extends Paths<T>> = InternalPickDeep<T, MergeTree<PathToTree<PathUnion>> extends infer M extends PathTreeType ? M : never>;
 
-/**
-Pick an object/array from the given object/array by one path.
-*/
-type InternalPickDeep<T, Path extends string | number> =
-	T extends NonRecursiveType
-		? never
-		: T extends UnknownArray ? PickDeepArray<T, Path>
-			: T extends object ? Simplify<PickDeepObject<T, Path>>
-				: never;
+type InternalPickDeep<Parent, PathTree extends PathTreeType> =
+	Parent extends UnknownArray
+		? _PickDeep<Parent, PathTree, keyof PathTree>
+		: Parent extends object
+			? _PickDeep<Parent, PathTree, keyof PathTree>
+			: Parent;
 
-/**
-Pick an object from the given object by one path.
-*/
-type PickDeepObject<RecordType extends object, P extends string | number> =
-	P extends `${infer RecordKeyInPath}.${infer SubPath}`
-		? ObjectValue<RecordType, RecordKeyInPath> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<RecordKeyInPath, InternalPickDeep<NonNullable<ObjectV>, SubPath>, RecordType>
+type RecursionPickDeep<NextParent, NextPathTree extends PathTreeType> =
+	NextParent extends infer NextParentArray extends UnknownArray
+		/* NextParent: array */
+		? IsEqual<IsTuple<NextParentArray>, false> extends true
+			? NextParentArray extends readonly unknown[]
+				/* If end */
+				? ForceGet<NextPathTree, CoerceKeyof<NextPathTree>> extends LeafMarker
+					? IsEqual<`${number}`, `${CoerceKeyof<NextPathTree>}`> extends true
+						/* `leadingSpreadArray2_Actual` in `test-d/pick-deep.ts` */
+						? NextParent
+						/* `tailingSpreadArray1_Actual` in `test-d/pick-deep.ts` */
+						: [...TupleOf<StringToNumber<`${CoerceKeyof<NextPathTree>}`>>, PickOrSelf<NextParent, CoerceKeyof<NextPathTree>>]
+					/* Not end */
+					: InternalPickDeep<PickOrSelf<NextParent, CoerceKeyof<NextPathTree>>, Extract<ForceGet<NextPathTree, CoerceKeyof<NextPathTree>>, PathTreeType>> extends infer Result
+						? IsEqual<`${number}`, `${CoerceKeyof<NextPathTree>}`> extends true
+							/* `leadingSpreadArray1_Actual` in `test-d/pick-deep.ts` */
+							? NextParentArray extends unknown[]
+								? Result[]
+								: readonly Result[]
+							/* `tailingSpreadArray2_Actual` in `test-d/pick-deep.ts`. */
+							: [...TupleOf<StringToNumber<`${CoerceKeyof<NextPathTree>}`>>, Result]
+						: never
 				: never
-			: never
-		: ObjectValue<RecordType, P> extends infer ObjectV
-			? IsNever<ObjectV> extends false
-				? BuildObject<P, ObjectV, RecordType>
+			/* NextParent: tuple */
+			: InternalPickDeep<NextParent, NextPathTree>
+		/* NextParent: object */
+		: InternalPickDeep<Simplify<PickOrSelf<NextParent, CoerceKeyof<Simplify<PickOrSelf<NextParent, CoerceKeyof<NextPathTree>>>>>>, NextPathTree>;
+
+type _PickDeep<Parent, PathTree extends PathTreeType, K extends keyof PathTree, U = never> =
+	LastOfUnion<K> extends infer L extends keyof PathTree
+		? IsNever<L> extends false
+			? L extends number | string
+				? IsEqual<true, IsKeyOf<Parent, L>> extends true
+					/* Detect an end of path. */
+					? IsEqual<LeafMarker, PathTree[L]> extends true
+						? PickOrSelf<Parent, L> extends infer PickResult
+							? PickResult extends UnknownArray
+								? _PickDeep<Parent, PathTree, Exclude<K, L>, U | Simplify<[...TupleOf<StringToNumber<`${L}`>>, PickResult]>>
+								: _PickDeep<Parent, PathTree, Exclude<K, L>, U | Simplify<PickResult>>
+							: never
+						/* Not a leaf - recurse deeper */
+						: ForceGet<PathTree, L> extends infer SubTree
+							? _PickDeep<Parent, PathTree, Exclude<K, L>, U | Simplify<Build<L, RecursionPickDeep<ForceGet<Parent, L>, Extract<SubTree, PathTreeType>>, Extract<Parent, object>>>>
+							: never
+					: never
 				: never
-			: never;
+			: MergeOnlyObjectUnion<U>
+		: never;
 
 /**
-Pick an array from the given array by one path.
+Converts a dot-delimited path string into a nested object tree structure.
+Example: `'a.b.c'` becomes `{a: {b: {c: ''}}}`
+
+type Test_PathToTree = MergeTree<PathToTree<`a.b.${'c'|'d'}.x` | `d.b.${'c'|'d'}`>>;
+// {d: {b: {d: ''; c: ''}};
+//  a: {b: {d: {x: ''}; c: {x: ''}}}}
 */
-type PickDeepArray<ArrayType extends UnknownArray, P extends string | number> =
-	// Handle paths that are `${number}.${string}`
-	P extends `${infer ArrayIndex extends number}.${infer SubPath}`
-		// When `ArrayIndex` is equal to `number`
-		? number extends ArrayIndex
-			? ArrayType extends unknown[]
-				? Array<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-				: ArrayType extends readonly unknown[]
-					? ReadonlyArray<InternalPickDeep<NonNullable<ArrayType[number]>, SubPath>>
-					: never
-			// When `ArrayIndex` is a number literal
-			: ArrayType extends unknown[]
-				? [...TupleOf<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-				: ArrayType extends readonly unknown[]
-					? readonly [...TupleOf<ArrayIndex>, InternalPickDeep<NonNullable<ArrayType[ArrayIndex]>, SubPath>]
-					: never
-		// When the path is equal to `number`
-		: P extends `${infer ArrayIndex extends number}`
-			// When `ArrayIndex` is `number`
-			? number extends ArrayIndex
-				? ArrayType
-				// When `ArrayIndex` is a number literal
-				: ArrayType extends unknown[]
-					? [...TupleOf<ArrayIndex>, ArrayType[ArrayIndex]]
-					: ArrayType extends readonly unknown[]
-						? readonly [...TupleOf<ArrayIndex>, ArrayType[ArrayIndex]]
-						: never
-			: never;
+type PathToTree<S> =
+	S extends `${infer F}.${infer Next}`
+		? Next extends `${infer _}.${infer __}`
+			? {[K in F]: PathToTree<Next>}
+			: {[K in F]: {[L in Next]: LeafMarker}}
+		: {[K in S extends string ? S : never]: LeafMarker};
+
+type LeafMarker = '';
+type PathTreeType = {[K in string]: PathTreeType | LeafMarker};
+
+/**
+Merges nested `object` trees from a union into a single tree structure.
+
+type Test_MergeTree_0 = MergeTree<{a: {b: ''}} | {a: {c: ''}}>; // {a: {b: ''; c: '';}}
+*/
+type MergeTree<T extends object, M extends object = never> =
+	LastOfUnion<T> extends infer L extends object
+		? IsNever<L> extends false
+			? MergeTree<Exclude<T, L>, MergeTreeObject<M, L>>
+			: IsEqual<M, {}> extends true
+				? never
+				: M
+		: never;
+
+type _MergeTreeObject<A extends object, B extends object, KU extends (keyof A | keyof B), R extends object = {}> =
+	LastOfUnion<KU> extends infer K
+		? IsNever<K> extends false
+			? K extends (keyof A) & (keyof B)
+				? _MergeTreeObject<A, B, Exclude<KU, K>, Simplify<R & BuildObject<K, MergeTreeObject<Extract<A[K], object>, Extract<B[K], object>>, A | B>>>
+				: K extends keyof A
+					? _MergeTreeObject<A, B, Exclude<KU, K>, Simplify<R & BuildObject<K, A[K], A>>>
+					: K extends keyof B
+						? _MergeTreeObject<A, B, Exclude<KU, K>, Simplify<R & BuildObject<K, B[K], B>>>
+						: R
+			: R
+		: never;
+
+type MergeTreeObject<A extends object, B extends object> =
+	Or<IsNever<A>, IsEqual<A, {}>> extends true
+		? B
+		: Or<IsNever<B>, IsEqual<B, {}>> extends true
+			? A
+			: _MergeTreeObject<A, B, Extract<(KeysOfUnion<A> | KeysOfUnion<B>), (keyof A | keyof B)>>;
 
 export {};
diff --git a/source/union-to-tuple.d.ts b/source/union-to-tuple.d.ts
index 5a6d13ae2..ada4b9d18 100644
--- a/source/union-to-tuple.d.ts
+++ b/source/union-to-tuple.d.ts
@@ -1,19 +1,5 @@
 import type {IsNever} from './is-never.d.ts';
-import type {UnionToIntersection} from './union-to-intersection.d.ts';
-
-/**
-Returns the last element of a union type.
-
-@example
-```
-type Last = LastOfUnion<1 | 2 | 3>;
-//=> 3
-```
-*/
-type LastOfUnion<T> =
-UnionToIntersection<T extends any ? () => T : never> extends () => (infer R)
-	? R
-	: never;
+import type {LastOfUnion} from './internal/index.d.ts';
 
 /**
 Convert a union type into an unordered tuple type of its elements.
@@ -50,9 +36,11 @@ const petList = Object.keys(pets) as UnionToTuple<Pet>;
 
 @category Array
 */
-export type UnionToTuple<T, L = LastOfUnion<T>> =
-IsNever<T> extends false
-	? [...UnionToTuple<Exclude<T, L>>, L]
-	: [];
+export type UnionToTuple<T> = _UnionToTuple<T>;
+
+type _UnionToTuple<T, L = LastOfUnion<T>> =
+	IsNever<T> extends false
+		? [..._UnionToTuple<Exclude<T, L>>, L]
+		: [];
 
 export {};
diff --git a/test-d/pick-deep.ts b/test-d/pick-deep.ts
index 556fefc81..6ab2c7152 100644
--- a/test-d/pick-deep.ts
+++ b/test-d/pick-deep.ts
@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {PickDeep} from '../index.d.ts';
+import type {IsEqual, PickDeep} from '../index.d.ts';
 
 declare class ClassA {
 	a: string;
@@ -32,8 +32,9 @@ type Testing = BaseType & {
 	2?: BaseType;
 };
 
-declare const normal: PickDeep<Testing, 'string'>;
-expectType<{string: string}>(normal);
+type normal_Actual = PickDeep<Testing, 'string'>;
+type normal_Expected = {string: string};
+expectType<true>({} as IsEqual<normal_Actual, normal_Expected>);
 
 type DeepType = {
 	nested: {
@@ -48,8 +49,8 @@ type DeepType = {
 };
 type DepthType = {nested: {deep: {deeper: {value: string}}}};
 
-declare const deep: PickDeep<DeepType, 'nested.deep.deeper.value'>;
-expectType<DepthType>(deep);
+type deep_Actual = PickDeep<DeepType, 'nested.deep.deeper.value'>;
+expectType<true>({} as IsEqual<deep_Actual, DepthType>);
 
 // Test interface
 // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
@@ -59,70 +60,172 @@ interface DeepInterface extends DeepType {
 		string: string;
 	};
 }
-declare const deepInterface: PickDeep<DeepInterface, 'nested.deep.deeper.value'>;
-expectType<DepthType>(deepInterface);
-declare const deepInterface2: PickDeep<DeepInterface, 'bar.number'>;
-expectType<{bar: {number: number}}>(deepInterface2);
+
+type deepInterface_Actual = PickDeep<DeepInterface, 'nested.deep.deeper.value'>;
+expectType<true>({} as IsEqual<deepInterface_Actual, DepthType>);
+
+type deepInterface2_Actual = PickDeep<DeepInterface, 'bar.number'>;
+type deepInterface2_Expected = {bar: {number: number}};
+expectType<true>({} as IsEqual<deepInterface2_Actual, deepInterface2_Expected>);
 
 type GenericType<T> = {
 	genericKey: T;
 };
-declare const genericTest: PickDeep<GenericType<number>, 'genericKey'>;
-expectType<{genericKey: number}>(genericTest);
-
-declare const union: PickDeep<Testing, 'object.number' | 'object.string'>;
-expectType<{object: {number: number} & {string: string}}>(union);
-
-declare const optional: PickDeep<Testing, 'optionalObject.optionalString'>;
-expectType<{optionalObject?: {optionalString?: string}}>(optional);
-
-declare const optionalUnion: PickDeep<Testing, 'optionalObject.string' | 'object.number'>;
-expectType<{optionalObject?: {string?: string}; object: {number: number}}>(optionalUnion);
-
-declare const readonlyTest: PickDeep<Testing, 'readonlyObject.a'>;
-expectType<{readonly readonlyObject: {a: 1}}>(readonlyTest);
-
-declare const array: PickDeep<Testing, 'object.array'>;
-expectType<{object: {array: number[]}}>(array);
-
-declare const readonlyArray: PickDeep<Testing, 'object.readonlyArray'>;
-expectType<{object: {readonlyArray: readonly number[]}}>(readonlyArray);
-
-declare const tuple: PickDeep<Testing, 'object.tuples'>;
-expectType<{object: {tuples: ['foo', 'bar']}}>(tuple);
-
-declare const objectArray1: PickDeep<Testing, `object.objectArray.${number}`>;
-expectType<{object: {objectArray: Array<{a: 1; b: 2}>}}>(objectArray1);
-
-declare const objectArray2: PickDeep<Testing, `object.objectArray.${number}.a`>;
-expectType<{object: {objectArray: Array<{a: 1}>}}>(objectArray2);
-
-declare const leadingSpreadArray1: PickDeep<Testing, `object.leadingSpreadArray.${number}.a`>;
-expectType<{object: {leadingSpreadArray: [...Array<{a: 1}>]}}>(leadingSpreadArray1);
-
-declare const leadingSpreadArray2: PickDeep<Testing, `object.leadingSpreadArray.${number}`>;
-expectType<{object: {leadingSpreadArray: [...Array<{a: 1}>, {b: 2}]}}>(leadingSpreadArray2);
-
-declare const tailingSpreadArray1: PickDeep<Testing, 'object.tailingSpreadArray.1'>;
-expectType<{object: {tailingSpreadArray: [unknown, {b: {c: 2; other: 2}}]}}>(tailingSpreadArray1);
-
-declare const tailingSpreadArray2: PickDeep<Testing, 'object.tailingSpreadArray.1.b.c'>;
-expectType<{object: {tailingSpreadArray: [unknown, {b: {c: 2}}]}}>(tailingSpreadArray2);
-
-declare const date: PickDeep<Testing, 'object.date'>;
-expectType<{object: {date: Date}}>(date);
-
-declare const instance: PickDeep<Testing, 'object.instance'>;
-expectType<{object: {instance: ClassA}}>(instance);
-
-declare const classTest: PickDeep<Testing, 'object.Class'>;
-expectType<{object: {Class: typeof ClassA}}>(classTest);
-
-declare const numberTest: PickDeep<Testing, '1'>;
-expectType<{1: BaseType}>(numberTest);
-
-declare const numberTest2: PickDeep<Testing, '1.0'>;
-expectType<{1: {0: number}}>(numberTest2);
+type genericTest_Actual = PickDeep<GenericType<number>, 'genericKey'>;
+type genericTest_Expected = {genericKey: number};
+expectType<true>({} as IsEqual<genericTest_Actual, genericTest_Expected>);
+
+type union_Actual = PickDeep<Testing, 'object.number' | 'object.string'>;
+type union_Expected = {object: {number: number; string: string}};
+expectType<true>({} as IsEqual<union_Actual, union_Expected>);
+
+type optional_Actual = PickDeep<Testing, 'optionalObject.optionalString'>;
+type optional_Expected = {optionalObject?: {optionalString?: string}};
+expectType<true>({} as IsEqual<optional_Actual, optional_Expected>);
+
+type optionalUnion_Actual = PickDeep<Testing, 'optionalObject.string' | 'object.number'>;
+type optionalUnion_Expected = {
+	optionalObject?: {string?: string};
+	object: {number: number};
+};
+expectType<true>({} as IsEqual<optionalUnion_Actual, optionalUnion_Expected>);
+
+type readonlyTest_Actual = PickDeep<Testing, 'readonlyObject.a'>;
+type readonlyTest_Expected = {readonly readonlyObject: {a: 1}};
+expectType<true>({} as IsEqual<readonlyTest_Actual, readonlyTest_Expected>);
+
+type array_Actual = PickDeep<Testing, 'object.array'>;
+type array_Expected = {object: {array: number[]}};
+expectType<true>({} as IsEqual<array_Actual, array_Expected>);
+
+type readonlyArray_Actual = PickDeep<Testing, 'object.readonlyArray'>;
+type readonlyArray_Expected = {object: {readonlyArray: readonly number[]}};
+expectType<true>({} as IsEqual<readonlyArray_Actual, readonlyArray_Expected>);
+
+type tuple_Actual = PickDeep<Testing, 'object.tuples'>;
+type tuple_Expected = {object: {tuples: ['foo', 'bar']}};
+expectType<true>({} as IsEqual<tuple_Actual, tuple_Expected>);
+
+type objectArray1_Actual = PickDeep<Testing, `object.objectArray.${number}`>;
+type objectArray1_Expected = {object: {objectArray: Array<{a: 1; b: 2}>}};
+expectType<true>({} as IsEqual<objectArray1_Actual, objectArray1_Expected>);
+
+type objectArray2_Actual = PickDeep<Testing, `object.objectArray.${number}.a`>;
+type objectArray2_Expected = {object: {objectArray: Array<{a: 1}>}};
+expectType<true>({} as IsEqual<objectArray2_Actual, objectArray2_Expected>);
+
+type leadingSpreadArray1_Actual = PickDeep<Testing, `object.leadingSpreadArray.${number}.a`>;
+type leadingSpreadArray1_Expected = {object: {leadingSpreadArray: [...Array<{a: 1}>]}};
+expectType<true>({} as IsEqual<leadingSpreadArray1_Actual, leadingSpreadArray1_Expected>);
+
+type leadingSpreadArray2_Actual = PickDeep<Testing, `object.leadingSpreadArray.${number}`>;
+type leadingSpreadArray2_Expected = {object: {leadingSpreadArray: [...Array<{a: 1}>, {b: 2}]}};
+expectType<true>({} as IsEqual<leadingSpreadArray2_Actual, leadingSpreadArray2_Expected>);
+
+type tailingSpreadArray1_Actual = PickDeep<Testing, 'object.tailingSpreadArray.1'>;
+type tailingSpreadArray1_Expected = {object: {tailingSpreadArray: [unknown, {b: {c: 2; other: 2}}]}};
+expectType<true>({} as IsEqual<tailingSpreadArray1_Actual, tailingSpreadArray1_Expected>);
+
+type tailingSpreadArray2_Actual = PickDeep<Testing, 'object.tailingSpreadArray.1.b.c'>;
+type tailingSpreadArray2_Expected = {object: {tailingSpreadArray: [unknown, {b: {c: 2}}]}};
+expectType<true>({} as IsEqual<tailingSpreadArray2_Actual, tailingSpreadArray2_Expected>);
+
+type date_Actual = PickDeep<Testing, 'object.date'>;
+type date_Expected = {object: {date: Date}};
+expectType<true>({} as IsEqual<date_Actual, date_Expected>);
+
+// The `PickDeep` test for a property containing a class instance (ClassA).
+type instance_Actual = PickDeep<Testing, 'object.instance'>;
+type instance_Expected = {object: {instance: ClassA}};
+expectType<true>({} as IsEqual<instance_Actual, instance_Expected>);
+
+type classTest_Actual = PickDeep<Testing, 'object.Class'>;
+type classTest_Expected = {object: {Class: typeof ClassA}};
+expectType<true>({} as IsEqual<classTest_Actual, classTest_Expected>);
+
+type numberTest_Actual = PickDeep<Testing, '1'>;
+type numberTest_Expected = {1: BaseType};
+expectType<true>({} as IsEqual<numberTest_Actual, numberTest_Expected>);
+
+type numberTest2_Actual = PickDeep<Testing, '1.0'>;
+type numberTest2_Expected = {1: {0: number}};
+expectType<true>({} as IsEqual<numberTest2_Actual, numberTest2_Expected>);
+
+type notEqual_NumberTest2_Actual0 = PickDeep<Testing, '1'>;
+type notEqual_NumberTest2_Expected0 = PickDeep<Testing, '1.0'>;
+expectType<false>({} as IsEqual<notEqual_NumberTest2_Actual0, notEqual_NumberTest2_Expected0>);
+
+type numberTest3_Actual = PickDeep<Testing, '2.0'>;
+type numberTest3_Expected = {2?: {0: number}};
+expectType<true>({} as IsEqual<numberTest3_Actual, numberTest3_Expected>);
+
+// Test for https://github.com/sindresorhus/type-fest/issues/1224
+// Ensures `null` and `undefined` are preserved: https://github.com/sindresorhus/type-fest/issues/880#issuecomment-2115864014
+type unionElement0_Actual = PickDeep<{obj: string | {a: string; b: number; c: boolean} | null | undefined}, 'obj'>;
+type unionElement0_Expected = {obj: string | {a: string; b: number; c: boolean} | null | undefined};
+expectType<true>({} as IsEqual<unionElement0_Actual, unionElement0_Expected>);
+
+// Test for https://github.com/sindresorhus/type-fest/issues/1224
+type unionElement1_Actual = PickDeep<{obj: string | {a: string; b: number; c: {d: 'result'}} | null | undefined}, 'obj.b'>;
+type unionElement1_Expected = {obj: string | null | undefined | {b: number}};
+expectType<true>({} as IsEqual<unionElement1_Actual, unionElement1_Expected>);
+
+// Test for https://github.com/sindresorhus/type-fest/issues/1224
+type unionElement2_Actual = PickDeep<{obj: string | {a: string; b: number; c: {readonly d?: 'result'}} | null | undefined}, 'obj.c.d'>;
+type unionElement2_Expected = {obj: string | null | undefined | {c: {readonly d?: 'result'}}};
+expectType<true>({} as IsEqual<unionElement2_Actual, unionElement2_Expected>);
+
+// Test for https://github.com/sindresorhus/type-fest/issues/1224
+type unionElement3_Actual = PickDeep<
+	{obj: string | {a: string; b: number; c?: {readonly d?: 'result' | 'is'}} | null | undefined}, 'obj.c.d'>;
+type unionElement3_Expected = {obj: string | null | undefined | {c?: {readonly d?: 'result' | 'is'}}};
+expectType<true>({} as IsEqual<unionElement3_Actual, unionElement3_Expected>);
+
+// Test for https://github.com/sindresorhus/type-fest/issues/1224
+type unionElement4_Actual = PickDeep<
+	{obj: string | {a: string; b: number; c?: {readonly d?: 'result' | 'is'}} | null | undefined}, 'obj.c.d' | 'obj.b'>;
+type unionElement4_Expected = {obj: string | null | undefined | {c?: {readonly d?: 'result' | 'is'}; b: number}};
+expectType<true>({} as IsEqual<unionElement4_Actual, unionElement4_Expected>);
+
+// Test for https://github.com/sindresorhus/type-fest/issues/1140#issuecomment-2881382244
+type unionObject0_Actual = PickDeep<{foo: string} | {foo: number}, 'foo'>;
+type unionObject0_Expected = {foo: string} | {foo: number};
+expectType<true>({} as IsEqual<unionObject0_Actual, unionObject0_Expected>);
+
+// Test for https://github.com/sindresorhus/type-fest/issues/1223
+type unionKeyObjectArray_Actual = PickDeep<{arr: Array<{a: string; b: number; c: boolean}>}, `arr.${number}.${'b' | 'c'}`>;
+type unionKeyObjectArray_Expected = {arr: Array<{b: number; c: boolean}>};
+expectType<true>({} as IsEqual<unionKeyObjectArray_Actual, unionKeyObjectArray_Expected>);
+
+type unionKeyObjectArrayArray_Actual = PickDeep<{arr: Array<Array<{a: string; b: number; c: boolean}>>}, `arr.${number}.${number}.${'b' | 'c'}`>;
+type unionKeyObjectArrayArray_Expected = {arr: Array<Array<{b: number; c: boolean}>>};
+expectType<true>({} as IsEqual<unionKeyObjectArrayArray_Actual, unionKeyObjectArrayArray_Expected>);
+
+type unionSameKeysObject_Actual = PickDeep<{a: string | {b: 1 | true; c: 2; d: {g: {f: 9; h: 10}}} | {b: '1'; c: '2'}; x: 10 | 11; y: [[0, 1], 2, 3]}, `a.${'b' | 'c'}` | 'x'>;
+type unionSameKeysObject_Expected = {x: 10 | 11; a: string | {b: 1 | true; c: 2} | {b: '1'; c: '2'}};
+expectType<true>({} as IsEqual<unionSameKeysObject_Actual, unionSameKeysObject_Expected>);
+
+type unionTupleTuple_Actual = PickDeep<[0, string | [1, [2]]], '1.1'>;
+type unionTupleTuple_Expected = [unknown, string | [unknown, [2]]];
+expectType<true>({} as IsEqual<unionTupleTuple_Actual, unionTupleTuple_Expected>);
+
+// Test: readonly array should preserve readonly modifier when picking into elements
+type ReadonlyArrayContainer = {
+	items: ReadonlyArray<{a: 1; b: 2}>;
+};
+type readonlyArrayPick_Actual = PickDeep<ReadonlyArrayContainer, `items.${number}.a`>;
+type readonlyArrayPick_Expected = {items: ReadonlyArray<{a: 1}>};
+expectType<true>({} as IsEqual<readonlyArrayPick_Actual, readonlyArrayPick_Expected>);
 
-declare const numberTest3: PickDeep<Testing, '2.0'>;
-expectType<{2?: {0: number}}>(numberTest3);
+// Test: mutable array should stay mutable
+type MutableArrayContainer = {
+	items: Array<{a: 1; b: 2}>;
+};
+type mutableArrayPick_Actual = PickDeep<MutableArrayContainer, `items.${number}.a`>;
+type mutableArrayPick_Expected = {items: Array<{a: 1}>};
+expectType<true>({} as IsEqual<mutableArrayPick_Actual, mutableArrayPick_Expected>);
+
+// Test: https://github.com/sindresorhus/type-fest/issues/880#issuecomment-2115864014
+type Nested = {name: string; age: number};
+type RootNestedNullable = {name: string; age: number; nested: Nested | null};
+expectType<true>({} as IsEqual<{name: string; nested: {name: string} | null}, PickDeep<RootNestedNullable, 'name' | 'nested.name'>>);
diff --git a/test-d/union-to-tuple.ts b/test-d/union-to-tuple.ts
index 12de3cf2b..6c5392272 100644
--- a/test-d/union-to-tuple.ts
+++ b/test-d/union-to-tuple.ts
@@ -11,3 +11,5 @@ expectType<Options1[number]>({} as (1 | 2 | 3));
 
 type Options2 = UnionToTuple<boolean | 1>;
 expectType<Options2[number]>({} as (1 | false | true));
+
+expectType<[]>({} as UnionToTuple<never>);