From b610ee0150622d04b7a186cdc0aa1f53c206346c Mon Sep 17 00:00:00 2001
From: semantic-release-bot <semantic-release-bot@martynus.net>
Date: Sun, 19 May 2024 11:13:39 +0000
Subject: [PATCH] chore(release): 6.0.0 [skip ci]

# [6.0.0](https://github.com/RebeccaStevens/deepmerge-ts/compare/v5.1.0...v6.0.0) (2024-05-19)

### Bug Fixes

* type when merging optional properties of a record ([fa9ace2](https://github.com/RebeccaStevens/deepmerge-ts/commit/fa9ace2a2b38030d12fa85634966d409b8bb123f))

### Build System

* remove typing support for typescript<4.7 ([f2f5956](https://github.com/RebeccaStevens/deepmerge-ts/commit/f2f5956d653a672073fc3c0174f9d8d6ca9d4371))

### Features

* allow restricting what types can be passed in as parameters ([69e9ba3](https://github.com/RebeccaStevens/deepmerge-ts/commit/69e9ba3519319eb02763887f457549340e9a9c76)), closes [#305](https://github.com/RebeccaStevens/deepmerge-ts/issues/305)
* remove deprecated type DeepMergeLeafHKT ([1982e56](https://github.com/RebeccaStevens/deepmerge-ts/commit/1982e56016cbbbfd07f78e8512b56e8294ff83c0))
* undefined will no longer replace defined values by default ([9c86605](https://github.com/RebeccaStevens/deepmerge-ts/commit/9c866054cbade77118b5cd62b1e8e68033fe2879))

### Performance Improvements

* remove BlacklistedRecordProps ([19d4944](https://github.com/RebeccaStevens/deepmerge-ts/commit/19d4944fa228d66d5af93f419526ffaf8b5a376b))

### BREAKING CHANGES

* remove deprecated type DeepMergeLeafHKT
* undefined will no longer replace defined values by default
* The order of the generics of `deepmergeCustom`
and `deepmergeIntoCustom` have changed. If you are passing generics
to these functions you need to update them.
* remove typing support for typescript<4.7
---
 CHANGELOG.md                              |  34 ++
 dist/deno/README.md                       |  27 +-
 dist/deno/deepmerge-into.ts               |  90 ++--
 dist/deno/deepmerge.ts                    |  75 ++--
 dist/deno/defaults/into.ts                |  24 +-
 dist/deno/defaults/meta-data-updater.ts   |   2 +-
 dist/deno/defaults/vanilla.ts             |  29 +-
 dist/deno/index.ts                        |   1 -
 dist/deno/types/defaults.ts               | 263 +++++++++---
 dist/deno/types/merging.ts                |  79 ++--
 dist/deno/types/options.ts                |  63 ++-
 dist/deno/types/utils.ts                  | 295 +++++++------
 dist/deno/utils.ts                        |  14 +-
 dist/node/index.cjs                       |  81 ++--
 dist/node/{types/current => }/index.d.cts | 500 +++++++++++++++-------
 dist/node/{types/current => }/index.d.mts | 500 +++++++++++++++-------
 dist/node/index.mjs                       |  81 ++--
 dist/node/types/legacy/v4_0.d.ts          |  80 ----
 dist/node/types/legacy/v4_6.d.ts          | 407 ------------------
 19 files changed, 1374 insertions(+), 1271 deletions(-)
 rename dist/node/{types/current => }/index.d.cts (58%)
 rename dist/node/{types/current => }/index.d.mts (58%)
 delete mode 100644 dist/node/types/legacy/v4_0.d.ts
 delete mode 100644 dist/node/types/legacy/v4_6.d.ts

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7bb6009b..aaf7fe26 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,40 @@
 # Changelog
 All notable changes to this project will be documented in this file. Dates are displayed in UTC.
 
+# [6.0.0](https://github.com/RebeccaStevens/deepmerge-ts/compare/v5.1.0...v6.0.0) (2024-05-19)
+
+
+### Bug Fixes
+
+* type when merging optional properties of a record ([fa9ace2](https://github.com/RebeccaStevens/deepmerge-ts/commit/fa9ace2a2b38030d12fa85634966d409b8bb123f))
+
+
+### Build System
+
+* remove typing support for typescript<4.7 ([f2f5956](https://github.com/RebeccaStevens/deepmerge-ts/commit/f2f5956d653a672073fc3c0174f9d8d6ca9d4371))
+
+
+### Features
+
+* allow restricting what types can be passed in as parameters ([69e9ba3](https://github.com/RebeccaStevens/deepmerge-ts/commit/69e9ba3519319eb02763887f457549340e9a9c76)), closes [#305](https://github.com/RebeccaStevens/deepmerge-ts/issues/305)
+* remove deprecated type DeepMergeLeafHKT ([1982e56](https://github.com/RebeccaStevens/deepmerge-ts/commit/1982e56016cbbbfd07f78e8512b56e8294ff83c0))
+* undefined will no longer replace defined values by default ([9c86605](https://github.com/RebeccaStevens/deepmerge-ts/commit/9c866054cbade77118b5cd62b1e8e68033fe2879))
+
+
+### Performance Improvements
+
+* remove BlacklistedRecordProps ([19d4944](https://github.com/RebeccaStevens/deepmerge-ts/commit/19d4944fa228d66d5af93f419526ffaf8b5a376b))
+
+
+### BREAKING CHANGES
+
+* remove deprecated type DeepMergeLeafHKT
+* undefined will no longer replace defined values by default
+* The order of the generics of `deepmergeCustom`
+and `deepmergeIntoCustom` have changed. If you are passing generics
+to these functions you need to update them.
+* remove typing support for typescript<4.7
+
 # [5.1.0](https://github.com/RebeccaStevens/deepmerge-ts/compare/v5.0.0...v5.1.0) (2023-04-04)
 
 
diff --git a/dist/deno/README.md b/dist/deno/README.md
index 1b745a47..c0cd28bf 100644
--- a/dist/deno/README.md
+++ b/dist/deno/README.md
@@ -22,6 +22,14 @@ Deeply merge 2 or more objects respecting type information.
 
 [Any donations would be much appreciated](./DONATIONS.md). 😄
 
+### Enterprise Users
+
+`deepmerge-ts` is available as part of the Tidelift Subscription.
+
+Tidelift is working with the maintainers of `deepmerge-ts` and a growing network of open source maintainers to ensure
+your open source software supply chain meets enterprise standards now and into the future.
+[Learn more.](https://tidelift.com/subscription/pkg/npm-deepmerge-ts?utm_source=npm-deepmerge-ts&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+
 ## Installation
 
 ### Node
@@ -43,8 +51,8 @@ yarn add deepmerge-ts
 // import_map.json
 {
   "imports": {
-    "deepmerge-ts": "https://deno.land/x/deepmergets@__version__/dist/deno/index.ts"
-  }
+    "deepmerge-ts": "https://deno.land/x/deepmergets@__version__/dist/deno/index.ts",
+  },
 }
 ```
 
@@ -112,15 +120,18 @@ console.log(merged);
 // }
 ```
 
-You can try out this example at [codesandbox.io](https://codesandbox.io/s/deepmerge-ts-example-iltxby?file=/src/example.ts).
+You can try out this example at
+[codesandbox.io](https://codesandbox.io/s/deepmerge-ts-example-iltxby?file=/src/example.ts).
 
 ### Merging into a Target
 
-You can use `deepmergeInto` if you want to update a target object with the merge result instead of creating a new object.
+You can use `deepmergeInto` if you want to update a target object with the merge result instead of creating a new
+object.
 
 This function is best used with objects that are all of the same type.
 
-Note: If the target object's type is different to the input objects, we'll assert that the target's type has changed (this is not done automatically with `deepmergeIntoCustom`).
+Note: If the target object's type differs from the input objects, we'll assert that the target's type has changed
+(this is not done automatically with `deepmergeIntoCustom`).
 
 ### Customized the Merging Process
 
@@ -131,7 +142,8 @@ See [deepmerge custom docs](./docs/deepmergeCustom.md) for more details.
 
 ## Performance
 
-We use smart merging instead of the classic merging strategy which some alternative libraries use. This vastly improves performance, both in execution time and memory usage.
+We use smart merging instead of the classic merging strategy which some alternative libraries use. This vastly improves
+performance, both in execution time and memory usage.
 
 ### Classic Merge (not what we do)
 
@@ -145,7 +157,8 @@ This strategy has large performance issues when lots of items need to be merged.
 
 With our smart merging, we look ahead to see what can be merged and only merge those things.
 
-In addition to performance improvements, this strategy merges multiple inputs at once; allowing for benefits such as taking averages of the inputs.
+In addition to performance improvements, this strategy merges multiple inputs at once; allowing for benefits such as
+taking averages of the inputs.
 
 ![smart merge animation](./assets/smart-merge.gif)
 
diff --git a/dist/deno/deepmerge-into.ts b/dist/deno/deepmerge-into.ts
index fcf6a0bb..bfd119cc 100644
--- a/dist/deno/deepmerge-into.ts
+++ b/dist/deno/deepmerge-into.ts
@@ -3,14 +3,14 @@ import * as defaultMergeIntoFunctions from "./defaults/into.ts";
 import { defaultMetaDataUpdater } from "./defaults/meta-data-updater.ts";
 import {
   type DeepMergeBuiltInMetaData,
+  type DeepMergeHKT,
   type DeepMergeIntoOptions,
+  type DeepMergeMergeFunctionsDefaultURIs,
   type DeepMergeMergeIntoFunctionUtils,
   type Reference,
-  type DeepMergeHKT,
-  type DeepMergeMergeFunctionsDefaultURIs,
 } from "./types/index.ts";
-import { type FlatternAlias } from "./types/utils.ts";
-import { getObjectType, ObjectType } from "./utils.ts";
+import { type SimplifyObject } from "./types/utils.ts";
+import { ObjectType, getObjectType } from "./utils.ts";
 
 /**
  * Deeply merge objects into a target.
@@ -31,11 +31,11 @@ export function deepmergeInto<T extends object>(
  */
 export function deepmergeInto<
   Target extends object,
-  Ts extends ReadonlyArray<unknown>
+  Ts extends ReadonlyArray<unknown>,
 >(
   target: Target,
   ...objects: Ts
-): asserts target is FlatternAlias<
+): asserts target is SimplifyObject<
   Target &
     DeepMergeHKT<
       [Target, ...Ts],
@@ -46,11 +46,11 @@ export function deepmergeInto<
 
 export function deepmergeInto<
   Target extends object,
-  Ts extends ReadonlyArray<unknown>
+  Ts extends ReadonlyArray<unknown>,
 >(
   target: Target,
   ...objects: Ts
-): asserts target is FlatternAlias<
+): asserts target is SimplifyObject<
   Target &
     DeepMergeHKT<
       [Target, ...Ts],
@@ -66,12 +66,12 @@ export function deepmergeInto<
  *
  * @param options - The options on how to customize the merge function.
  */
-export function deepmergeIntoCustom(
+export function deepmergeIntoCustom<BaseTs = unknown>(
   options: DeepMergeIntoOptions<
     DeepMergeBuiltInMetaData,
     DeepMergeBuiltInMetaData
-  >
-): <Target extends object, Ts extends ReadonlyArray<unknown>>(
+  >,
+): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(
   target: Target,
   ...objects: Ts
 ) => void;
@@ -83,23 +83,25 @@ export function deepmergeIntoCustom(
  * @param rootMetaData - The meta data passed to the root items' being merged.
  */
 export function deepmergeIntoCustom<
-  MetaData,
-  MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  BaseTs = unknown,
+  MetaData = DeepMergeBuiltInMetaData,
+  MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeIntoOptions<MetaData, MetaMetaData>,
-  rootMetaData?: MetaData
-): <Target extends object, Ts extends ReadonlyArray<unknown>>(
+  rootMetaData?: MetaData,
+): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(
   target: Target,
   ...objects: Ts
 ) => void;
 
 export function deepmergeIntoCustom<
+  BaseTs,
   MetaData,
-  MetaMetaData extends DeepMergeBuiltInMetaData
+  MetaMetaData extends DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeIntoOptions<MetaData, MetaMetaData>,
-  rootMetaData?: MetaData
-): <Target extends object, Ts extends ReadonlyArray<unknown>>(
+  rootMetaData?: MetaData,
+): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(
   target: Target,
   ...objects: Ts
 ) => void {
@@ -108,7 +110,7 @@ export function deepmergeIntoCustom<
    */
   type CustomizedDeepmergeInto = <
     Target extends object,
-    Ts extends ReadonlyArray<unknown>
+    Ts extends ReadonlyArray<unknown>,
   >(
     target: Target,
     ...objects: Ts
@@ -142,13 +144,13 @@ export function deepmergeIntoCustom<
  */
 function getIntoUtils<
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeIntoOptions<M, MM>,
   customizedDeepmergeInto: DeepMergeMergeIntoFunctionUtils<
     M,
     MM
-  >["deepmergeInto"]
+  >["deepmergeInto"],
 ): DeepMergeMergeIntoFunctionUtils<M, MM> {
   return {
     defaultMergeFunctions: defaultMergeIntoFunctions,
@@ -157,13 +159,13 @@ function getIntoUtils<
       ...Object.fromEntries(
         Object.entries(options)
           .filter(([key, option]) =>
-            Object.hasOwn(defaultMergeIntoFunctions, key)
+            Object.hasOwn(defaultMergeIntoFunctions, key),
           )
           .map(([key, option]) =>
             option === false
               ? [key, defaultMergeIntoFunctions.mergeOthers]
-              : [key, option]
-          )
+              : [key, option],
+          ),
       ),
     } as DeepMergeMergeIntoFunctionUtils<M, MM>["mergeFunctions"],
     metaDataUpdater: (options.metaDataUpdater ??
@@ -186,13 +188,13 @@ export function mergeUnknownsInto<
   Ts extends ReadonlyArray<unknown>,
   U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   m_target: Reference<unknown>,
   values: Ts,
   utils: U,
-  meta: M | undefined
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  meta: M | undefined,
+  // eslint-disable-next-line ts/no-invalid-void-type
 ): void | symbol {
   if (values.length === 0) {
     return;
@@ -219,7 +221,7 @@ export function mergeUnknownsInto<
         m_target as Reference<Record<PropertyKey, unknown>>,
         values as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
         utils,
-        meta
+        meta,
       );
     }
 
@@ -228,7 +230,7 @@ export function mergeUnknownsInto<
         m_target as Reference<unknown[]>,
         values as ReadonlyArray<ReadonlyArray<unknown>>,
         utils,
-        meta
+        meta,
       );
     }
 
@@ -237,7 +239,7 @@ export function mergeUnknownsInto<
         m_target as Reference<Set<unknown>>,
         values as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
         utils,
-        meta
+        meta,
       );
     }
 
@@ -246,7 +248,7 @@ export function mergeUnknownsInto<
         m_target as Reference<Map<unknown, unknown>>,
         values as ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
         utils,
-        meta
+        meta,
       );
     }
 
@@ -265,18 +267,18 @@ export function mergeUnknownsInto<
 function mergeRecordsInto<
   U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   m_target: Reference<Record<PropertyKey, unknown>>,
   values: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const action = utils.mergeFunctions.mergeRecords(
     m_target,
     values,
     utils,
-    meta
+    meta,
   );
 
   if (action === actions.defaultMerge) {
@@ -298,18 +300,18 @@ function mergeRecordsInto<
 function mergeArraysInto<
   U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   m_target: Reference<unknown[]>,
   values: ReadonlyArray<ReadonlyArray<unknown>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const action = utils.mergeFunctions.mergeArrays(
     m_target,
     values,
     utils,
-    meta
+    meta,
   );
 
   if (action === actions.defaultMerge) {
@@ -326,12 +328,12 @@ function mergeArraysInto<
 function mergeSetsInto<
   U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   m_target: Reference<Set<unknown>>,
   values: ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const action = utils.mergeFunctions.mergeSets(m_target, values, utils, meta);
 
@@ -349,12 +351,12 @@ function mergeSetsInto<
 function mergeMapsInto<
   U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   m_target: Reference<Map<unknown, unknown>>,
   values: ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const action = utils.mergeFunctions.mergeMaps(m_target, values, utils, meta);
 
@@ -372,18 +374,18 @@ function mergeMapsInto<
 function mergeOthersInto<
   U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   m_target: Reference<unknown>,
   values: ReadonlyArray<unknown>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const action = utils.mergeFunctions.mergeOthers(
     m_target,
     values,
     utils,
-    meta
+    meta,
   );
 
   if (
diff --git a/dist/deno/deepmerge.ts b/dist/deno/deepmerge.ts
index 8ad91449..ceeff141 100644
--- a/dist/deno/deepmerge.ts
+++ b/dist/deno/deepmerge.ts
@@ -4,13 +4,13 @@ import * as defaultMergeFunctions from "./defaults/vanilla.ts";
 import {
   type DeepMergeBuiltInMetaData,
   type DeepMergeHKT,
+  type DeepMergeMergeFunctionUtils,
   type DeepMergeMergeFunctionsDefaultURIs,
   type DeepMergeMergeFunctionsURIs,
   type DeepMergeOptions,
-  type DeepMergeMergeFunctionUtils,
   type GetDeepMergeMergeFunctionsURIs,
 } from "./types/index.ts";
-import { getObjectType, ObjectType } from "./utils.ts";
+import { ObjectType, getObjectType } from "./utils.ts";
 
 /**
  * Deeply merge objects.
@@ -18,7 +18,6 @@ import { getObjectType, ObjectType } from "./utils.ts";
  * @param objects - The objects to merge.
  */
 export function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(
-  // eslint-disable-next-line functional/functional-parameters
   ...objects: readonly [...Ts]
 ): DeepMergeHKT<
   Ts,
@@ -38,10 +37,11 @@ export function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(
  * @param options - The options on how to customize the merge function.
  */
 export function deepmergeCustom<
-  PMF extends Partial<DeepMergeMergeFunctionsURIs>
+  BaseTs = unknown,
+  PMF extends Partial<DeepMergeMergeFunctionsURIs> = {},
 >(
-  options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>
-): <Ts extends ReadonlyArray<unknown>>(
+  options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>,
+): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
 ) => DeepMergeHKT<
   Ts,
@@ -56,24 +56,26 @@ export function deepmergeCustom<
  * @param rootMetaData - The meta data passed to the root items' being merged.
  */
 export function deepmergeCustom<
-  PMF extends Partial<DeepMergeMergeFunctionsURIs>,
-  MetaData,
-  MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  BaseTs = unknown,
+  PMF extends Partial<DeepMergeMergeFunctionsURIs> = {},
+  MetaData = DeepMergeBuiltInMetaData,
+  MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeOptions<MetaData, MetaMetaData>,
-  rootMetaData?: MetaData
-): <Ts extends ReadonlyArray<unknown>>(
+  rootMetaData?: MetaData,
+): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
 ) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
 
 export function deepmergeCustom<
+  BaseTs,
   PMF extends Partial<DeepMergeMergeFunctionsURIs>,
   MetaData,
-  MetaMetaData extends DeepMergeBuiltInMetaData
+  MetaMetaData extends DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeOptions<MetaData, MetaMetaData>,
-  rootMetaData?: MetaData
-): <Ts extends ReadonlyArray<unknown>>(
+  rootMetaData?: MetaData,
+): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
 ) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData> {
   /**
@@ -85,16 +87,13 @@ export function deepmergeCustom<
 
   const utils: DeepMergeMergeFunctionUtils<MetaData, MetaMetaData> = getUtils(
     options,
-    customizedDeepmerge as CustomizedDeepmerge
+    customizedDeepmerge as CustomizedDeepmerge,
   );
 
   /**
    * The customized deepmerge function.
    */
-  function customizedDeepmerge(
-    // eslint-disable-next-line functional/functional-parameters
-    ...objects: ReadonlyArray<unknown>
-  ) {
+  function customizedDeepmerge(...objects: ReadonlyArray<unknown>) {
     return mergeUnknowns<
       ReadonlyArray<unknown>,
       typeof utils,
@@ -114,10 +113,10 @@ export function deepmergeCustom<
  */
 function getUtils<
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeOptions<M, MM>,
-  customizedDeepmerge: DeepMergeMergeFunctionUtils<M, MM>["deepmerge"]
+  customizedDeepmerge: DeepMergeMergeFunctionUtils<M, MM>["deepmerge"],
 ): DeepMergeMergeFunctionUtils<M, MM> {
   return {
     defaultMergeFunctions,
@@ -129,8 +128,8 @@ function getUtils<
           .map(([key, option]) =>
             option === false
               ? [key, defaultMergeFunctions.mergeOthers]
-              : [key, option]
-          )
+              : [key, option],
+          ),
       ),
     } as DeepMergeMergeFunctionUtils<M, MM>["mergeFunctions"],
     metaDataUpdater: (options.metaDataUpdater ??
@@ -154,7 +153,7 @@ export function mergeUnknowns<
   U extends DeepMergeMergeFunctionUtils<M, MM>,
   MF extends DeepMergeMergeFunctionsURIs,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(values: Ts, utils: U, meta: M | undefined): DeepMergeHKT<Ts, MF, M> {
   if (values.length === 0) {
     return undefined as DeepMergeHKT<Ts, MF, M>;
@@ -169,7 +168,6 @@ export function mergeUnknowns<
 
   const type = getObjectType(values[0]);
 
-  /* eslint-disable functional/no-loop-statements, functional/no-conditional-statements -- using imperative code here is more performant. */
   if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
     for (let m_index = 1; m_index < values.length; m_index++) {
       if (getObjectType(values[m_index]) === type) {
@@ -183,14 +181,13 @@ export function mergeUnknowns<
       >;
     }
   }
-  /* eslint-enable functional/no-loop-statements, functional/no-conditional-statements */
 
   switch (type) {
     case ObjectType.RECORD: {
       return mergeRecords<U, MF, M, MM>(
         values as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
         utils,
-        meta
+        meta,
       ) as DeepMergeHKT<Ts, MF, M>;
     }
 
@@ -198,7 +195,7 @@ export function mergeUnknowns<
       return mergeArrays<U, M, MM>(
         values as ReadonlyArray<Readonly<ReadonlyArray<unknown>>>,
         utils,
-        meta
+        meta,
       ) as DeepMergeHKT<Ts, MF, M>;
     }
 
@@ -206,7 +203,7 @@ export function mergeUnknowns<
       return mergeSets<U, M, MM>(
         values as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
         utils,
-        meta
+        meta,
       ) as DeepMergeHKT<Ts, MF, M>;
     }
 
@@ -214,7 +211,7 @@ export function mergeUnknowns<
       return mergeMaps<U, M, MM>(
         values as ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
         utils,
-        meta
+        meta,
       ) as DeepMergeHKT<Ts, MF, M>;
     }
 
@@ -237,11 +234,11 @@ function mergeRecords<
   U extends DeepMergeMergeFunctionUtils<M, MM>,
   MF extends DeepMergeMergeFunctionsURIs,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const result = utils.mergeFunctions.mergeRecords(values, utils, meta);
 
@@ -272,11 +269,11 @@ function mergeRecords<
 function mergeArrays<
   U extends DeepMergeMergeFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: ReadonlyArray<Readonly<ReadonlyArray<unknown>>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const result = utils.mergeFunctions.mergeArrays(values, utils, meta);
 
@@ -300,11 +297,11 @@ function mergeArrays<
 function mergeSets<
   U extends DeepMergeMergeFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const result = utils.mergeFunctions.mergeSets(values, utils, meta);
 
@@ -327,11 +324,11 @@ function mergeSets<
 function mergeMaps<
   U extends DeepMergeMergeFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ) {
   const result = utils.mergeFunctions.mergeMaps(values, utils, meta);
 
@@ -354,7 +351,7 @@ function mergeMaps<
 function mergeOthers<
   U extends DeepMergeMergeFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(values: ReadonlyArray<unknown>, utils: U, meta: M | undefined) {
   const result = utils.mergeFunctions.mergeOthers(values, utils, meta);
 
diff --git a/dist/deno/defaults/into.ts b/dist/deno/defaults/into.ts
index 9ee960bf..144b43a3 100644
--- a/dist/deno/defaults/into.ts
+++ b/dist/deno/defaults/into.ts
@@ -27,12 +27,12 @@ export function mergeRecords<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
   U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   m_target: Reference<Record<PropertyKey, unknown>>,
   values: Ts,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ): void {
   for (const key of getKeys(values)) {
     const propValues = [];
@@ -57,7 +57,7 @@ export function mergeRecords<
       propertyTarget,
       propValues,
       utils,
-      updatedMeta
+      updatedMeta,
     );
 
     if (key === "__proto__") {
@@ -81,7 +81,7 @@ export function mergeRecords<
  */
 export function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(
   m_target: Reference<unknown[]>,
-  values: Ts
+  values: Ts,
 ): void {
   m_target.value.push(...values.slice(1).flat());
 }
@@ -93,7 +93,7 @@ export function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(
  * @param values - The sets (including the target's value if there is one).
  */
 export function mergeSets<
-  Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>
+  Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
 >(m_target: Reference<Set<unknown>>, values: Ts): void {
   for (const value of getIterableOfIterables(values.slice(1))) {
     m_target.value.add(value);
@@ -107,7 +107,7 @@ export function mergeSets<
  * @param values - The maps (including the target's value if there is one).
  */
 export function mergeMaps<
-  Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>
+  Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
 >(m_target: Reference<Map<unknown, unknown>>, values: Ts): void {
   for (const [key, value] of getIterableOfIterables(values.slice(1))) {
     m_target.value.set(key, value);
@@ -115,11 +115,17 @@ export function mergeMaps<
 }
 
 /**
- * Set the target to the last value.
+ * Set the target to the last non-undefined value.
  */
 export function mergeOthers<Ts extends ReadonlyArray<unknown>>(
   m_target: Reference<unknown>,
-  values: Ts
+  values: Ts,
 ) {
-  m_target.value = values.at(-1);
+  for (let i = values.length - 1; i >= 0; i--) {
+    if (values[i] !== undefined) {
+      m_target.value = values[i];
+      return;
+    }
+  }
+  m_target.value = undefined;
 }
diff --git a/dist/deno/defaults/meta-data-updater.ts b/dist/deno/defaults/meta-data-updater.ts
index 2b392149..1b9432c3 100644
--- a/dist/deno/defaults/meta-data-updater.ts
+++ b/dist/deno/defaults/meta-data-updater.ts
@@ -5,7 +5,7 @@ import { type DeepMergeBuiltInMetaData } from "../types/index.ts";
  */
 export function defaultMetaDataUpdater<M>(
   previousMeta: M,
-  metaMeta: DeepMergeBuiltInMetaData
+  metaMeta: DeepMergeBuiltInMetaData,
 ): DeepMergeBuiltInMetaData {
   return metaMeta;
 }
diff --git a/dist/deno/defaults/vanilla.ts b/dist/deno/defaults/vanilla.ts
index d8aeef9c..decd60cd 100644
--- a/dist/deno/defaults/vanilla.ts
+++ b/dist/deno/defaults/vanilla.ts
@@ -4,12 +4,12 @@ import {
   type DeepMergeArraysDefaultHKT,
   type DeepMergeBuiltInMetaData,
   type DeepMergeMapsDefaultHKT,
-  type DeepMergeMergeFunctionsURIs,
   type DeepMergeMergeFunctionUtils,
+  type DeepMergeMergeFunctionsURIs,
   type DeepMergeRecordsDefaultHKT,
   type DeepMergeSetsDefaultHKT,
 } from "../types/index.ts";
-import { getKeys, objectHasProperty, getIterableOfIterables } from "../utils.ts";
+import { getIterableOfIterables, getKeys, objectHasProperty } from "../utils.ts";
 
 /**
  * The default merge functions.
@@ -32,16 +32,14 @@ export function mergeRecords<
   U extends DeepMergeMergeFunctionUtils<M, MM>,
   MF extends DeepMergeMergeFunctionsURIs,
   M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: Ts,
   utils: U,
-  meta: M | undefined
+  meta: M | undefined,
 ): DeepMergeRecordsDefaultHKT<Ts, MF, M> {
   const result: Record<PropertyKey, unknown> = {};
 
-  /* eslint-disable functional/no-loop-statements, functional/no-conditional-statements, functional/no-expression-statements, functional/immutable-data -- using imperative code here is more performant. */
-
   for (const key of getKeys(values)) {
     const propValues = [];
 
@@ -63,7 +61,7 @@ export function mergeRecords<
     const propertyResult = mergeUnknowns<ReadonlyArray<unknown>, U, MF, M, MM>(
       propValues,
       utils,
-      updatedMeta
+      updatedMeta,
     );
 
     if (propertyResult === actions.skip) {
@@ -82,8 +80,6 @@ export function mergeRecords<
     }
   }
 
-  /* eslint-enable functional/no-loop-statements, functional/no-conditional-statements, functional/no-expression-statements, functional/immutable-data */
-
   return result as DeepMergeRecordsDefaultHKT<Ts, MF, M>;
 }
 
@@ -95,7 +91,7 @@ export function mergeRecords<
 export function mergeArrays<
   Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 >(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M> {
   return values.flat() as DeepMergeArraysDefaultHKT<Ts, MF, M>;
 }
@@ -106,7 +102,7 @@ export function mergeArrays<
  * @param values - The sets.
  */
 export function mergeSets<
-  Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>
+  Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
 >(values: Ts): DeepMergeSetsDefaultHKT<Ts> {
   return new Set(getIterableOfIterables(values)) as DeepMergeSetsDefaultHKT<Ts>;
 }
@@ -117,14 +113,19 @@ export function mergeSets<
  * @param values - The maps.
  */
 export function mergeMaps<
-  Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>
+  Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
 >(values: Ts): DeepMergeMapsDefaultHKT<Ts> {
   return new Map(getIterableOfIterables(values)) as DeepMergeMapsDefaultHKT<Ts>;
 }
 
 /**
- * Get the last value in the given array.
+ * Get the last non-undefined value in the given array.
  */
 export function mergeOthers<Ts extends ReadonlyArray<unknown>>(values: Ts) {
-  return values.at(-1);
+  for (let i = values.length - 1; i >= 0; i--) {
+    if (values[i] !== undefined) {
+      return values[i];
+    }
+  }
+  return undefined;
 }
diff --git a/dist/deno/index.ts b/dist/deno/index.ts
index 377dff8e..cd408d1a 100644
--- a/dist/deno/index.ts
+++ b/dist/deno/index.ts
@@ -14,7 +14,6 @@ export type {
   DeepMergeBuiltInMetaData,
   DeepMergeHKT,
   DeepMergeLeaf,
-  DeepMergeLeafHKT,
   DeepMergeLeafURI,
   DeepMergeMapsDefaultHKT,
   DeepMergeMergeFunctionsDefaultURIs,
diff --git a/dist/deno/types/defaults.ts b/dist/deno/types/defaults.ts
index d37d3303..53b565af 100644
--- a/dist/deno/types/defaults.ts
+++ b/dist/deno/types/defaults.ts
@@ -1,18 +1,19 @@
 import {
   type DeepMergeHKT,
   type DeepMergeLeafURI,
-  type DeepMergeMergeFunctionsURIs,
   type DeepMergeMergeFunctionURItoKind,
+  type DeepMergeMergeFunctionsURIs,
 } from "./merging.ts";
 import {
-  type FlatternAlias,
   type FilterOutNever,
-  type OptionalKeysOf,
-  type RequiredKeysOf,
+  type FlattenTuples,
+  type SimplifyObject,
+  type TransposeTuple,
+  type TupleToIntersection,
+  type TuplifyUnion,
   type UnionMapKeys,
   type UnionMapValues,
   type UnionSetValues,
-  type ValueOfKey,
 } from "./utils.ts";
 
 /**
@@ -46,11 +47,37 @@ export type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
   DeepMergeOthersURI: DeepMergeLeafURI;
 }>;
 
-/**
- * A union of all the props that should not be included in type information for
- * merged records.
- */
-type BlacklistedRecordProps = "__proto__";
+type RecordEntries<T extends Record<PropertyKey, unknown>> = TuplifyUnion<
+  {
+    [K in keyof T]: [K, T[K]];
+  }[keyof T]
+>;
+
+type RecordMeta = Record<PropertyKey, RecordPropertyMeta>;
+
+type RecordPropertyMeta<
+  Key extends PropertyKey = PropertyKey,
+  Value = unknown,
+  Optional extends boolean = boolean,
+> = {
+  key: Key;
+  value: Value;
+  optional: Optional;
+};
+
+type RecordsToRecordMeta<
+  Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
+> = {
+  [I in keyof Ts]: RecordToRecordMeta<Ts[I]>;
+};
+
+type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> = {
+  [K in keyof T]-?: {
+    key: K;
+    value: Required<T>[K];
+    optional: {} extends Pick<T, K> ? true : false;
+  };
+};
 
 /**
  * Deep merge records.
@@ -58,77 +85,176 @@ type BlacklistedRecordProps = "__proto__";
 export type DeepMergeRecordsDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
-> = Ts extends Readonly<readonly [unknown, ...Readonly<ReadonlyArray<unknown>>]>
-  ? FlatternAlias<
-      Omit<
-        DeepMergeRecordsDefaultHKTInternalProps<Ts, MF, M>,
-        BlacklistedRecordProps
+  M,
+> =
+  Ts extends ReadonlyArray<Record<PropertyKey, unknown>>
+    ? SimplifyObject<
+        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>
       >
-    >
-  : {};
+    : never;
 
 /**
  * Deep merge record props.
  */
-type DeepMergeRecordsDefaultHKTInternalProps<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
+type DeepMergeRecordMetaDefaultHKTProps<
+  RecordMetas extends ReadonlyArray<RecordMeta>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
-> = {
-  [K in OptionalKeysOf<Ts>]?: DeepMergeHKT<
-    DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>,
-    MF,
-    M
-  >;
-} & {
-  [K in RequiredKeysOf<Ts>]: DeepMergeHKT<
-    DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>,
-    MF,
-    M
+  M,
+> = CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M>;
+
+type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> =
+  GroupValuesByKey<
+    FlattenTuples<
+      TransposeTuple<{
+        [I in keyof RecordMetas]: TransposeTuple<RecordEntries<RecordMetas[I]>>;
+      }>
+    >
   >;
-};
+
+type GroupValuesByKey<Ts> = Ts extends readonly [
+  infer Keys extends ReadonlyArray<PropertyKey>,
+  infer Values,
+]
+  ? {
+      [I in keyof Keys]: DeepMergeRecordPropertyMetaDefaultHKTGetPossible<
+        Keys[I],
+        FilterOutNever<{
+          [J in keyof Values]: Values[J] extends {
+            key: Keys[I];
+          }
+            ? Values[J]
+            : never;
+        }>
+      >;
+    }
+  : never;
+
+type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> =
+  Ts extends ReadonlyArray<unknown>
+    ? TupleToIntersection<{
+        [I in keyof Ts]: Ts[I] extends {
+          key: infer Key extends PropertyKey;
+          values: infer Values extends ReadonlyArray<unknown>;
+          optional: infer O extends boolean;
+        }
+          ? CreateRecordForKeyFromMeta<Key, Values, O, MF, M>
+          : never;
+      }>
+    : never;
+
+type CreateRecordForKeyFromMeta<
+  Key extends PropertyKey,
+  Values extends ReadonlyArray<unknown>,
+  Optional extends boolean,
+  MF extends DeepMergeMergeFunctionsURIs,
+  M,
+> = Optional extends true
+  ? {
+      [k in Key]+?: DeepMergeHKT<Values, MF, M>;
+    }
+  : {
+      [k in Key]-?: DeepMergeHKT<Values, MF, M>;
+    };
 
 /**
- * Get the value of the property.
+ * Get the possible types of a property.
  */
-type DeepMergeRecordsDefaultHKTInternalPropValue<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  K extends PropertyKey,
-  M
-> = FilterOutNever<
-  DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts, K, M, readonly []>
->;
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossible<
+  Key extends PropertyKey,
+  Ts,
+> = Ts extends readonly [
+  RecordPropertyMeta,
+  ...ReadonlyArray<RecordPropertyMeta>,
+]
+  ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+      Ts,
+      { key: Key; values: []; optional: never }
+    >
+  : never;
 
 /**
- * Tail-recursive helper type for DeepMergeRecordsDefaultHKTInternalPropValue.
+ * Tail-recursive helper type for DeepMergeRecordPropertyMetaDefaultHKTGetPossible.
  */
-type DeepMergeRecordsDefaultHKTInternalPropValueHelper<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  K extends PropertyKey,
-  M,
-  Acc extends ReadonlyArray<unknown>
-> = Ts extends readonly [
-  infer Head extends Readonly<Record<PropertyKey, unknown>>,
-  ...infer Rest
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+  Ts extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>,
+  ],
+  Acc extends {
+    key: PropertyKey;
+    values: ReadonlyArray<unknown>;
+    optional: boolean;
+  },
+> = Ts extends [
+  ...infer Rest,
+  {
+    key: infer K extends PropertyKey;
+    value: infer V;
+    optional: infer O extends boolean;
+  },
 ]
-  ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-    ? DeepMergeRecordsDefaultHKTInternalPropValueHelper<
-        Rest,
-        K,
-        M,
-        [...Acc, ValueOfKey<Head, K>]
-      >
-    : [...Acc, ValueOfKey<Head, K>]
+  ? Acc["optional"] extends true
+    ? Acc extends { values: [infer Head, ...infer AccRest] }
+      ? Rest extends readonly [
+          RecordPropertyMeta,
+          ...ReadonlyArray<RecordPropertyMeta>,
+        ]
+        ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+            Rest,
+            {
+              key: K;
+              values: [V | Head, ...AccRest];
+              optional: O;
+            }
+          >
+        : {
+            key: K;
+            values: [V | Head, ...AccRest];
+            optional: O;
+          }
+      : Rest extends readonly [
+            RecordPropertyMeta,
+            ...ReadonlyArray<RecordPropertyMeta>,
+          ]
+        ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+            Rest,
+            {
+              key: K;
+              values: [V, ...Acc["values"]];
+              optional: O;
+            }
+          >
+        : {
+            key: K;
+            values: [V, ...Acc["values"]];
+            optional: O;
+          }
+    : Rest extends readonly [
+          RecordPropertyMeta,
+          ...ReadonlyArray<RecordPropertyMeta>,
+        ]
+      ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
+          Rest,
+          {
+            key: K;
+            values: [V, ...Acc["values"]];
+            optional: O;
+          }
+        >
+      : {
+          key: K;
+          values: [V, ...Acc["values"]];
+          optional: O;
+        }
   : never;
 
 /**
- * Deep merge 2 arrays.
+ * Deep merge arrays.
  */
 export type DeepMergeArraysDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 > = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
 
 /**
@@ -138,28 +264,28 @@ type DeepMergeArraysDefaultHKTHelper<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
   M,
-  Acc extends ReadonlyArray<unknown>
+  Acc extends ReadonlyArray<unknown>,
 > = Ts extends readonly [
   infer Head extends ReadonlyArray<unknown>,
-  ...infer Rest
+  ...infer Rest,
 ]
   ? Rest extends readonly [
       ReadonlyArray<unknown>,
-      ...ReadonlyArray<ReadonlyArray<unknown>>
+      ...ReadonlyArray<ReadonlyArray<unknown>>,
     ]
     ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [...Acc, ...Head]>
     : [...Acc, ...Head]
   : never;
 
 /**
- * Deep merge 2 sets.
+ * Deep merge sets.
  */
 export type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<
   UnionSetValues<Ts>
 >;
 
 /**
- * Deep merge 2 maps.
+ * Deep merge maps.
  */
 export type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<
   UnionMapKeys<Ts>,
@@ -170,39 +296,34 @@ export type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<
  * Get the merge functions with defaults apply from the given subset.
  */
 export type GetDeepMergeMergeFunctionsURIs<
-  PMF extends Partial<DeepMergeMergeFunctionsURIs>
+  PMF extends Partial<DeepMergeMergeFunctionsURIs>,
 > = Readonly<{
   // prettier-ignore
   DeepMergeRecordsURI:
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeRecordsURI"]
       : DeepMergeRecordsDefaultURI;
 
   // prettier-ignore
   DeepMergeArraysURI:
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeArraysURI"]
       : DeepMergeArraysDefaultURI;
 
   // prettier-ignore
   DeepMergeSetsURI:
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeSetsURI"]
       : DeepMergeSetsDefaultURI;
 
   // prettier-ignore
   DeepMergeMapsURI:
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeMapsURI"]
       : DeepMergeMapsDefaultURI;
 
   // prettier-ignore
   DeepMergeOthersURI:
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeOthersURI"]
       : DeepMergeLeafURI;
diff --git a/dist/deno/types/merging.ts b/dist/deno/types/merging.ts
index 27a0e88b..9ccda959 100644
--- a/dist/deno/types/merging.ts
+++ b/dist/deno/types/merging.ts
@@ -1,26 +1,28 @@
 import {
-  type DeepMergeRecordsDefaultHKT,
   type DeepMergeArraysDefaultHKT,
-  type DeepMergeSetsDefaultHKT,
   type DeepMergeMapsDefaultHKT,
+  type DeepMergeRecordsDefaultHKT,
+  type DeepMergeSetsDefaultHKT,
 } from "./defaults.ts";
 import {
   type EveryIsArray,
   type EveryIsMap,
   type EveryIsRecord,
   type EveryIsSet,
+  type Is,
   type IsNever,
   type IsTuple,
+  type Or,
 } from "./utils.ts";
 
 /**
  * Mapping of merge function URIs to the merge function type.
  */
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+// eslint-disable-next-line ts/consistent-type-definitions
 export interface DeepMergeMergeFunctionURItoKind<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  in out M
+  in out M,
 > {
   readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
   readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
@@ -36,7 +38,7 @@ type DeepMergeMergeFunctionKind<
   URI extends DeepMergeMergeFunctionURIs,
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 > = DeepMergeMergeFunctionURItoKind<Ts, MF, M>[URI];
 
 /**
@@ -84,22 +86,23 @@ export type DeepMergeMergeFunctionsURIs = Readonly<{
 export type DeepMergeHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
-> = IsTuple<Ts> extends true
-  ? Ts extends readonly []
-    ? undefined
-    : Ts extends readonly [infer T1]
-    ? T1
-    : EveryIsArray<Ts> extends true
-    ? DeepMergeArraysHKT<Ts, MF, M>
-    : EveryIsMap<Ts> extends true
-    ? DeepMergeMapsHKT<Ts, MF, M>
-    : EveryIsSet<Ts> extends true
-    ? DeepMergeSetsHKT<Ts, MF, M>
-    : EveryIsRecord<Ts> extends true
-    ? DeepMergeRecordsHKT<Ts, MF, M>
-    : DeepMergeOthersHKT<Ts, MF, M>
-  : unknown;
+  M,
+> =
+  IsTuple<Ts> extends true
+    ? Ts extends readonly []
+      ? undefined
+      : Ts extends readonly [infer T1]
+        ? T1
+        : EveryIsArray<Ts> extends true
+          ? DeepMergeArraysHKT<Ts, MF, M>
+          : EveryIsMap<Ts> extends true
+            ? DeepMergeMapsHKT<Ts, MF, M>
+            : EveryIsSet<Ts> extends true
+              ? DeepMergeSetsHKT<Ts, MF, M>
+              : EveryIsRecord<Ts> extends true
+                ? DeepMergeRecordsHKT<Ts, MF, M>
+                : DeepMergeOthersHKT<Ts, MF, M>
+    : unknown;
 
 /**
  * Deep merge records.
@@ -107,7 +110,7 @@ export type DeepMergeHKT<
 type DeepMergeRecordsHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 > = DeepMergeMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
 
 /**
@@ -116,7 +119,7 @@ type DeepMergeRecordsHKT<
 type DeepMergeArraysHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 > = DeepMergeMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
 
 /**
@@ -125,7 +128,7 @@ type DeepMergeArraysHKT<
 type DeepMergeSetsHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 > = DeepMergeMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
 
 /**
@@ -134,7 +137,7 @@ type DeepMergeSetsHKT<
 type DeepMergeMapsHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 > = DeepMergeMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
 
 /**
@@ -143,7 +146,7 @@ type DeepMergeMapsHKT<
 type DeepMergeOthersHKT<
   Ts extends ReadonlyArray<unknown>,
   MF extends DeepMergeMergeFunctionsURIs,
-  M
+  M,
 > = DeepMergeMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
 
 /**
@@ -151,14 +154,6 @@ type DeepMergeOthersHKT<
  */
 export type DeepMergeLeafURI = "DeepMergeLeafURI";
 
-/**
- * Get the leaf type from many types that can't be merged.
- *
- * @deprecated Use `DeepMergeLeaf` instead.
- */
-export type DeepMergeLeafHKT<Ts extends ReadonlyArray<unknown>> =
-  DeepMergeLeaf<Ts>;
-
 /**
  * Get the leaf type from many types that can't be merged.
  */
@@ -166,14 +161,14 @@ export type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> =
   Ts extends readonly []
     ? never
     : Ts extends readonly [infer T]
-    ? T
-    : Ts extends readonly [...infer Rest, infer Tail]
-    ? IsNever<Tail> extends true
-      ? Rest extends ReadonlyArray<unknown>
-        ? DeepMergeLeaf<Rest>
-        : never
-      : Tail
-    : never;
+      ? T
+      : Ts extends readonly [...infer Rest, infer Tail]
+        ? Or<IsNever<Tail>, Is<Tail, undefined>> extends true
+          ? Rest extends ReadonlyArray<unknown>
+            ? DeepMergeLeaf<Rest>
+            : never
+          : Tail
+        : never;
 
 /**
  * The meta data deepmerge is able to provide.
diff --git a/dist/deno/types/options.ts b/dist/deno/types/options.ts
index 930d0a70..15ecf706 100644
--- a/dist/deno/types/options.ts
+++ b/dist/deno/types/options.ts
@@ -8,7 +8,7 @@ import { type DeepMergeBuiltInMetaData } from "./merging.ts";
  */
 export type DeepMergeOptions<
   in out M,
-  MM extends Readonly<Record<PropertyKey, unknown>> = {}
+  MM extends Readonly<Record<PropertyKey, unknown>> = {},
 > = Partial<DeepMergeOptionsFull<M, MM & DeepMergeBuiltInMetaData>>;
 
 /**
@@ -16,12 +16,12 @@ export type DeepMergeOptions<
  */
 export type DeepMergeIntoOptions<
   in out M,
-  MM extends Readonly<Record<PropertyKey, unknown>> = {}
+  MM extends Readonly<Record<PropertyKey, unknown>> = {},
 > = Partial<DeepMergeIntoOptionsFull<M, MM & DeepMergeBuiltInMetaData>>;
 
 type MetaDataUpdater<
   in out M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = (previousMeta: M | undefined, metaMeta: Readonly<Partial<MM>>) => M;
 
 /**
@@ -29,7 +29,7 @@ type MetaDataUpdater<
  */
 type DeepMergeOptionsFull<
   in out M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: DeepMergeMergeFunctions<M, MM>["mergeRecords"] | false;
   mergeArrays: DeepMergeMergeFunctions<M, MM>["mergeArrays"] | false;
@@ -45,7 +45,7 @@ type DeepMergeOptionsFull<
  */
 type DeepMergeIntoOptionsFull<
   in out M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: DeepMergeMergeIntoFunctions<M, MM>["mergeRecords"] | false;
   mergeArrays: DeepMergeMergeIntoFunctions<M, MM>["mergeArrays"] | false;
@@ -67,55 +67,55 @@ export type Reference<T> = {
  */
 type DeepMergeMergeFunctions<
   in M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: <
     Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>
+    U extends DeepMergeMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => unknown;
 
   mergeArrays: <
     Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>
+    U extends DeepMergeMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => unknown;
 
   mergeMaps: <
     Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>
+    U extends DeepMergeMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => unknown;
 
   mergeSets: <
     Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>
+    U extends DeepMergeMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => unknown;
 
   mergeOthers: <
     Ts extends ReadonlyArray<unknown>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>
+    U extends DeepMergeMergeFunctionUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => unknown;
 }>;
 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+// eslint-disable-next-line ts/no-invalid-void-type
 type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
 
 /**
@@ -123,56 +123,56 @@ type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
  */
 type DeepMergeMergeIntoFunctions<
   in M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: <
     Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>
+    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Record<PropertyKey, unknown>>,
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => DeepMergeMergeIntoFunctionsReturnType;
 
   mergeArrays: <
     Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>
+    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<unknown[]>,
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => DeepMergeMergeIntoFunctionsReturnType;
 
   mergeMaps: <
     Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>
+    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Map<unknown, unknown>>,
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => DeepMergeMergeIntoFunctionsReturnType;
 
   mergeSets: <
     Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>
+    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Set<unknown>>,
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => DeepMergeMergeIntoFunctionsReturnType;
 
   mergeOthers: <
     Ts extends ReadonlyArray<unknown>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>
+    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<unknown>,
     values: Ts,
     utils: U,
-    meta: M | undefined
+    meta: M | undefined,
   ) => DeepMergeMergeIntoFunctionsReturnType;
 }>;
 
@@ -181,7 +181,7 @@ type DeepMergeMergeIntoFunctions<
  */
 export type DeepMergeMergeFunctionUtils<
   in out M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeFunctions: DeepMergeMergeFunctions<M, MM>;
   defaultMergeFunctions: MergeFunctions;
@@ -197,10 +197,9 @@ export type DeepMergeMergeFunctionUtils<
 /**
  * The utils provided to the merge functions.
  */
-// eslint-disable-next-line functional/no-mixed-types
 export type DeepMergeMergeIntoFunctionUtils<
   in out M,
-  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData
+  MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeFunctions: DeepMergeMergeIntoFunctions<M, MM>;
   defaultMergeFunctions: MergeIntoFunctions;
@@ -208,7 +207,7 @@ export type DeepMergeMergeIntoFunctionUtils<
   deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(
     target: Target,
     ...values: Ts
-  ) => void; // eslint-disable-line functional/no-return-void
+  ) => void;
   actions: Readonly<{
     defaultMerge: symbol;
   }>;
diff --git a/dist/deno/types/utils.ts b/dist/deno/types/utils.ts
index 61fcf2ca..dd9e8bed 100644
--- a/dist/deno/types/utils.ts
+++ b/dist/deno/types/utils.ts
@@ -1,18 +1,28 @@
 /**
- * Flatten a complex type such as a union or intersection of objects into a
+ * Simplify a complex type such as a union or intersection of objects into a
  * single object.
  */
-export type FlatternAlias<T> = Is<T, unknown> extends true
-  ? T
-  : { [P in keyof T]: T[P] } & {};
+export type SimplifyObject<T extends {}> = {
+  [K in keyof T]: T[K];
+} & {};
 
 /**
- * Get the value of the given key in the given object.
+ * Flatten a collection of tuples of tuples into a collection of tuples.
  */
-export type ValueOfKey<
-  T extends Record<PropertyKey, unknown>,
-  K extends PropertyKey
-> = K extends keyof T ? T[K] : never;
+export type FlattenTuples<T> = {
+  [I in keyof T]: FlattenTuple<T[I]>;
+};
+
+/**
+ * Flatten a tuple of tuples into a single tuple.
+ */
+export type FlattenTuple<T> = T extends readonly []
+  ? []
+  : T extends readonly [infer T0]
+    ? [...FlattenTuple<T0>]
+    : T extends readonly [infer T0, ...infer Ts]
+      ? [...FlattenTuple<T0>, ...FlattenTuple<Ts>]
+      : [T];
 
 /**
  * Safely test whether or not the first given types extends the second.
@@ -26,6 +36,25 @@ export type Is<T1, T2> = [T1] extends [T2] ? true : false;
  */
 export type IsNever<T> = Is<T, never>;
 
+/**
+ * And operator for types.
+ */
+export type And<T1 extends boolean, T2 extends boolean> = T1 extends false
+  ? false
+  : T2;
+
+/**
+ * Or operator for types.
+ */
+export type Or<T1 extends boolean, T2 extends boolean> = T1 extends true
+  ? true
+  : T2;
+
+/**
+ * Not operator for types.
+ */
+export type Not<T extends boolean> = T extends true ? false : true;
+
 /**
  * Returns whether or not all the given types are never.
  */
@@ -73,12 +102,12 @@ export type EveryIsArray<Ts extends ReadonlyArray<unknown>> =
   Ts extends readonly [infer T1]
     ? IsArray<T1>
     : Ts extends readonly [infer Head, ...infer Rest]
-    ? IsArray<Head> extends true
-      ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-        ? EveryIsArray<Rest>
+      ? IsArray<Head> extends true
+        ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
+          ? EveryIsArray<Rest>
+          : false
         : false
-      : false
-    : false;
+      : false;
 
 /**
  * Returns whether or not the given type is an set.
@@ -95,17 +124,16 @@ export type IsSet<T> = And<
  *
  * Note: This may also return true if all are maps.
  */
-export type EveryIsSet<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<
-  readonly [infer T1]
->
-  ? IsSet<T1>
-  : Ts extends readonly [infer Head, ...infer Rest]
-  ? IsSet<Head> extends true
-    ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-      ? EveryIsSet<Rest>
-      : false
-    : false
-  : false;
+export type EveryIsSet<Ts extends ReadonlyArray<unknown>> =
+  Ts extends Readonly<readonly [infer T1]>
+    ? IsSet<T1>
+    : Ts extends readonly [infer Head, ...infer Rest]
+      ? IsSet<Head> extends true
+        ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
+          ? EveryIsSet<Rest>
+          : false
+        : false
+      : false;
 
 /**
  * Returns whether or not the given type is an map.
@@ -118,36 +146,16 @@ export type IsMap<T> = And<
 /**
  * Returns whether or not all the given types are maps.
  */
-export type EveryIsMap<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<
-  readonly [infer T1]
->
-  ? IsMap<T1>
-  : Ts extends readonly [infer Head, ...infer Rest]
-  ? IsMap<Head> extends true
-    ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-      ? EveryIsMap<Rest>
-      : false
-    : false
-  : false;
-
-/**
- * And operator for types.
- */
-export type And<T1 extends boolean, T2 extends boolean> = T1 extends false
-  ? false
-  : T2;
-
-/**
- * Or operator for types.
- */
-export type Or<T1 extends boolean, T2 extends boolean> = T1 extends true
-  ? true
-  : T2;
-
-/**
- * Not operator for types.
- */
-export type Not<T extends boolean> = T extends true ? false : true;
+export type EveryIsMap<Ts extends ReadonlyArray<unknown>> =
+  Ts extends Readonly<readonly [infer T1]>
+    ? IsMap<T1>
+    : Ts extends readonly [infer Head, ...infer Rest]
+      ? IsMap<Head> extends true
+        ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
+          ? EveryIsMap<Rest>
+          : false
+        : false
+      : false;
 
 /**
  * Union of the sets' values' types
@@ -160,7 +168,7 @@ export type UnionSetValues<Ts extends ReadonlyArray<unknown>> =
  */
 type UnionSetValuesHelper<
   Ts extends ReadonlyArray<unknown>,
-  Acc
+  Acc,
 > = Ts extends readonly [infer Head, ...infer Rest]
   ? Head extends Readonly<ReadonlySet<infer V1>>
     ? Rest extends ReadonlyArray<unknown>
@@ -180,7 +188,7 @@ export type UnionMapKeys<Ts extends ReadonlyArray<unknown>> =
  */
 type UnionMapKeysHelper<
   Ts extends ReadonlyArray<unknown>,
-  Acc
+  Acc,
 > = Ts extends readonly [infer Head, ...infer Rest]
   ? Head extends Readonly<ReadonlyMap<infer K1, unknown>>
     ? Rest extends readonly []
@@ -200,7 +208,7 @@ export type UnionMapValues<Ts extends ReadonlyArray<unknown>> =
  */
 type UnionMapValuesHelper<
   Ts extends ReadonlyArray<unknown>,
-  Acc
+  Acc,
 > = Ts extends readonly [infer Head, ...infer Rest]
   ? Head extends Readonly<ReadonlyMap<unknown, infer V1>>
     ? Rest extends readonly []
@@ -209,106 +217,25 @@ type UnionMapValuesHelper<
     : never
   : Acc;
 
-/**
- * Get all the keys of the given records.
- */
-export type KeysOf<Ts extends ReadonlyArray<unknown>> = KeysOfHelper<Ts, never>;
-
-/**
- * Tail-recursive helper type for KeysOf.
- */
-type KeysOfHelper<
-  Ts extends ReadonlyArray<unknown>,
-  Acc
-> = Ts extends readonly [infer Head, ...infer Rest]
-  ? Head extends Record<PropertyKey, unknown>
-    ? Rest extends ReadonlyArray<unknown>
-      ? KeysOfHelper<Rest, Acc | keyof Head>
-      : Acc | keyof Head
-    : never
-  : Acc;
-
-/**
- * Get the keys of the type what match a certain criteria.
- */
-type KeysOfType<T, U> = {
-  [K in keyof T]: T[K] extends U ? K : never;
-}[keyof T];
-
-/**
- * Get the required keys of the type.
- */
-type RequiredKeys<T> = Exclude<
-  KeysOfType<T, Exclude<T[keyof T], undefined>>,
-  undefined
->;
-
-/**
- * Get all the required keys on the types in the tuple.
- */
-export type RequiredKeysOf<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>]
-> = RequiredKeysOfHelper<Ts, never>;
-
-/**
- * Tail-recursive helper type for RequiredKeysOf.
- */
-type RequiredKeysOfHelper<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  Acc
-> = Ts extends readonly [infer Head, ...infer Rest]
-  ? Head extends Record<PropertyKey, unknown>
-    ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-      ? RequiredKeysOfHelper<Rest, Acc | RequiredKeys<Head>>
-      : Acc | RequiredKeys<Head>
-    : never
-  : Acc;
-
-/**
- * Get the optional keys of the type.
- */
-type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-
-/**
- * Get all the optional keys on the types in the tuple.
- */
-export type OptionalKeysOf<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>]
-> = OptionalKeysOfHelper<Ts, never>;
-
-/**
- * Tail-recursive helper type for OptionalKeysOf.
- */
-type OptionalKeysOfHelper<
-  Ts extends readonly [unknown, ...ReadonlyArray<unknown>],
-  Acc
-> = Ts extends readonly [infer Head, ...infer Rest]
-  ? Head extends Record<PropertyKey, unknown>
-    ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>]
-      ? OptionalKeysOfHelper<Rest, Acc | OptionalKeys<Head>>
-      : Acc | OptionalKeys<Head>
-    : never
-  : Acc;
-
 /**
  * Filter out nevers from a tuple.
  */
-export type FilterOutNever<T extends ReadonlyArray<unknown>> =
-  FilterOutNeverHelper<T, []>;
+export type FilterOutNever<T> =
+  T extends ReadonlyArray<unknown> ? FilterOutNeverHelper<T, []> : never;
 
 /**
  * Tail-recursive helper type for FilterOutNever.
  */
 type FilterOutNeverHelper<
   T extends ReadonlyArray<unknown>,
-  Acc extends ReadonlyArray<unknown>
+  Acc extends ReadonlyArray<unknown>,
 > = T extends readonly []
   ? Acc
   : T extends readonly [infer Head, ...infer Rest]
-  ? IsNever<Head> extends true
-    ? FilterOutNeverHelper<Rest, Acc>
-    : FilterOutNeverHelper<Rest, [...Acc, Head]>
-  : T;
+    ? IsNever<Head> extends true
+      ? FilterOutNeverHelper<Rest, Acc>
+      : FilterOutNeverHelper<Rest, [...Acc, Head]>
+    : T;
 
 /**
  * Is the type a tuple?
@@ -316,5 +243,77 @@ type FilterOutNeverHelper<
 export type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly []
   ? true
   : T extends readonly [unknown, ...ReadonlyArray<unknown>]
-  ? true
-  : false;
+    ? true
+    : false;
+
+/**
+ * Perfrom a transpose operation on a 2D tuple.
+ */
+export type TransposeTuple<T> = T extends readonly [
+  ...(readonly [...unknown[]]),
+]
+  ? T extends readonly []
+    ? []
+    : T extends readonly [infer X extends ReadonlyArray<unknown>]
+      ? TransposeTupleSimpleCase<X>
+      : T extends readonly [
+            infer X extends ReadonlyArray<unknown>,
+            ...infer XS extends ReadonlyArray<ReadonlyArray<unknown>>,
+          ]
+        ? PrependCol<X, TransposeTuple<XS>>
+        : T
+  : never;
+
+type PrependCol<
+  T extends ReadonlyArray<unknown>,
+  S extends ReadonlyArray<ReadonlyArray<unknown>>,
+> = T extends readonly []
+  ? S extends readonly []
+    ? []
+    : never
+  : T extends readonly [infer X, ...infer XS]
+    ? S extends readonly [
+        readonly [...infer Y],
+        ...infer YS extends ReadonlyArray<ReadonlyArray<unknown>>,
+      ]
+      ? [[X, ...Y], ...PrependCol<XS, YS>]
+      : never
+    : never;
+
+type TransposeTupleSimpleCase<T extends readonly [...unknown[]]> =
+  T extends readonly []
+    ? []
+    : T extends readonly [infer X, ...infer XS]
+      ? [[X], ...TransposeTupleSimpleCase<XS>]
+      : never;
+
+/**
+ * Convert a tuple to an intersection of each of its types.
+ */
+export type TupleToIntersection<T extends ReadonlyArray<unknown>> =
+  {
+    [K in keyof T]: (x: T[K]) => void;
+  } extends Record<number, (x: infer I) => void>
+    ? I
+    : never;
+
+/**
+ * Convert a union to a tuple.
+ *
+ * Warning: The order of the elements is non-deterministic.
+ * Warning 2: The union maybe me modified by the TypeScript engine before convertion.
+ * Warning 3: This implementation relies on a hack/limitation in TypeScript.
+ */
+export type TuplifyUnion<T, L = LastOf<T>> =
+  IsNever<T> extends true ? [] : [...TuplifyUnion<Exclude<T, L>>, L];
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;
+
+type LastOf<T> =
+  UnionToIntersection<T extends any ? () => T : never> extends () => infer R
+    ? R
+    : never;
diff --git a/dist/deno/utils.ts b/dist/deno/utils.ts
index 399f862a..a8fc2756 100644
--- a/dist/deno/utils.ts
+++ b/dist/deno/utils.ts
@@ -51,7 +51,6 @@ export function getObjectType(object: unknown): ObjectType {
 export function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey> {
   const keys = new Set<PropertyKey>();
 
-  /* eslint-disable functional/no-loop-statements, functional/no-expression-statements -- using a loop here is more efficient. */
   for (const object of objects) {
     for (const key of [
       ...Object.keys(object),
@@ -60,7 +59,6 @@ export function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey> {
       keys.add(key);
     }
   }
-  /* eslint-enable functional/no-loop-statements, functional/no-expression-statements */
 
   return keys;
 }
@@ -74,7 +72,7 @@ export function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey> {
  */
 export function objectHasProperty(
   object: object,
-  property: PropertyKey
+  property: PropertyKey,
 ): boolean {
   return (
     typeof object === "object" &&
@@ -86,14 +84,11 @@ export function objectHasProperty(
  * Get an iterable object that iterates over the given iterables.
  */
 export function getIterableOfIterables<T>(
-  iterables: ReadonlyArray<Readonly<Iterable<T>>>
+  iterables: ReadonlyArray<Readonly<Iterable<T>>>,
 ): Iterable<T> {
   return {
-    // eslint-disable-next-line functional/functional-parameters
     *[Symbol.iterator]() {
-      // eslint-disable-next-line functional/no-loop-statements
       for (const iterable of iterables) {
-        // eslint-disable-next-line functional/no-loop-statements
         for (const value of iterable) {
           yield value;
         }
@@ -119,12 +114,11 @@ function isRecord(value: object): value is Record<PropertyKey, unknown> {
   const { constructor } = value;
 
   // If has modified constructor.
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  // eslint-disable-next-line ts/no-unnecessary-condition
   if (constructor === undefined) {
     return true;
   }
 
-  // eslint-disable-next-line prefer-destructuring
   const prototype: unknown = constructor.prototype;
 
   // If has modified prototype.
@@ -137,7 +131,7 @@ function isRecord(value: object): value is Record<PropertyKey, unknown> {
   }
 
   // If constructor does not have an Object-specific method.
-  // eslint-disable-next-line sonarjs/prefer-single-boolean-return, no-prototype-builtins
+  // eslint-disable-next-line sonar/prefer-single-boolean-return, no-prototype-builtins
   if (!prototype.hasOwnProperty("isPrototypeOf")) {
     return false;
   }
diff --git a/dist/node/index.cjs b/dist/node/index.cjs
index 78acaeb1..b9ea4df5 100644
--- a/dist/node/index.cjs
+++ b/dist/node/index.cjs
@@ -21,6 +21,18 @@ function defaultMetaDataUpdater(previousMeta, metaMeta) {
     return metaMeta;
 }
 
+/**
+ * The different types of objects deepmerge-ts support.
+ */
+var ObjectType;
+(function (ObjectType) {
+    ObjectType[ObjectType["NOT"] = 0] = "NOT";
+    ObjectType[ObjectType["RECORD"] = 1] = "RECORD";
+    ObjectType[ObjectType["ARRAY"] = 2] = "ARRAY";
+    ObjectType[ObjectType["SET"] = 3] = "SET";
+    ObjectType[ObjectType["MAP"] = 4] = "MAP";
+    ObjectType[ObjectType["OTHER"] = 5] = "OTHER";
+})(ObjectType || (ObjectType = {}));
 /**
  * Get the type of the given object.
  *
@@ -55,7 +67,6 @@ function getObjectType(object) {
  */
 function getKeys(objects) {
     const keys = new Set();
-    /* eslint-disable functional/no-loop-statements, functional/no-expression-statements -- using a loop here is more efficient. */
     for (const object of objects) {
         for (const key of [
             ...Object.keys(object),
@@ -64,7 +75,6 @@ function getKeys(objects) {
             keys.add(key);
         }
     }
-    /* eslint-enable functional/no-loop-statements, functional/no-expression-statements */
     return keys;
 }
 /**
@@ -83,11 +93,8 @@ function objectHasProperty(object, property) {
  */
 function getIterableOfIterables(iterables) {
     return {
-        // eslint-disable-next-line functional/functional-parameters
         *[Symbol.iterator]() {
-            // eslint-disable-next-line functional/no-loop-statements
             for (const iterable of iterables) {
-                // eslint-disable-next-line functional/no-loop-statements
                 for (const value of iterable) {
                     yield value;
                 }
@@ -109,11 +116,10 @@ function isRecord(value) {
     }
     const { constructor } = value;
     // If has modified constructor.
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    // eslint-disable-next-line ts/no-unnecessary-condition
     if (constructor === undefined) {
         return true;
     }
-    // eslint-disable-next-line prefer-destructuring
     const prototype = constructor.prototype;
     // If has modified prototype.
     if (prototype === null ||
@@ -122,7 +128,7 @@ function isRecord(value) {
         return false;
     }
     // If constructor does not have an Object-specific method.
-    // eslint-disable-next-line sonarjs/prefer-single-boolean-return, no-prototype-builtins
+    // eslint-disable-next-line sonar/prefer-single-boolean-return, no-prototype-builtins
     if (!prototype.hasOwnProperty("isPrototypeOf")) {
         return false;
     }
@@ -137,7 +143,6 @@ function isRecord(value) {
  */
 function mergeRecords$2(values, utils, meta) {
     const result = {};
-    /* eslint-disable functional/no-loop-statements, functional/no-conditional-statements, functional/no-expression-statements, functional/immutable-data -- using imperative code here is more performant. */
     for (const key of getKeys(values)) {
         const propValues = [];
         for (const value of values) {
@@ -168,7 +173,6 @@ function mergeRecords$2(values, utils, meta) {
             result[key] = propertyResult;
         }
     }
-    /* eslint-enable functional/no-loop-statements, functional/no-conditional-statements, functional/no-expression-statements, functional/immutable-data */
     return result;
 }
 /**
@@ -196,19 +200,24 @@ function mergeMaps$2(values) {
     return new Map(getIterableOfIterables(values));
 }
 /**
- * Get the last value in the given array.
+ * Get the last non-undefined value in the given array.
  */
 function mergeOthers$2(values) {
-    return values.at(-1);
+    for (let i = values.length - 1; i >= 0; i--) {
+        if (values[i] !== undefined) {
+            return values[i];
+        }
+    }
+    return undefined;
 }
 
 var defaultMergeFunctions = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    mergeArrays: mergeArrays$2,
-    mergeMaps: mergeMaps$2,
-    mergeOthers: mergeOthers$2,
-    mergeRecords: mergeRecords$2,
-    mergeSets: mergeSets$2
+  __proto__: null,
+  mergeArrays: mergeArrays$2,
+  mergeMaps: mergeMaps$2,
+  mergeOthers: mergeOthers$2,
+  mergeRecords: mergeRecords$2,
+  mergeSets: mergeSets$2
 });
 
 /**
@@ -216,9 +225,7 @@ var defaultMergeFunctions = /*#__PURE__*/Object.freeze({
  *
  * @param objects - The objects to merge.
  */
-function deepmerge(
-// eslint-disable-next-line functional/functional-parameters
-...objects) {
+function deepmerge(...objects) {
     return deepmergeCustom({})(...objects);
 }
 function deepmergeCustom(options, rootMetaData) {
@@ -226,9 +233,7 @@ function deepmergeCustom(options, rootMetaData) {
     /**
      * The customized deepmerge function.
      */
-    function customizedDeepmerge(
-    // eslint-disable-next-line functional/functional-parameters
-    ...objects) {
+    function customizedDeepmerge(...objects) {
         return mergeUnknowns(objects, utils, rootMetaData);
     }
     return customizedDeepmerge;
@@ -269,7 +274,6 @@ function mergeUnknowns(values, utils, meta) {
         return mergeOthers$1(values, utils, meta);
     }
     const type = getObjectType(values[0]);
-    /* eslint-disable functional/no-loop-statements, functional/no-conditional-statements -- using imperative code here is more performant. */
     if (type !== 0 /* ObjectType.NOT */ && type !== 5 /* ObjectType.OTHER */) {
         for (let m_index = 1; m_index < values.length; m_index++) {
             if (getObjectType(values[m_index]) === type) {
@@ -278,7 +282,6 @@ function mergeUnknowns(values, utils, meta) {
             return mergeOthers$1(values, utils, meta);
         }
     }
-    /* eslint-enable functional/no-loop-statements, functional/no-conditional-statements */
     switch (type) {
         case 1 /* ObjectType.RECORD */: {
             return mergeRecords$1(values, utils, meta);
@@ -444,19 +447,25 @@ function mergeMaps(m_target, values) {
     }
 }
 /**
- * Set the target to the last value.
+ * Set the target to the last non-undefined value.
  */
 function mergeOthers(m_target, values) {
-    m_target.value = values.at(-1);
+    for (let i = values.length - 1; i >= 0; i--) {
+        if (values[i] !== undefined) {
+            m_target.value = values[i];
+            return;
+        }
+    }
+    m_target.value = undefined;
 }
 
 var defaultMergeIntoFunctions = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    mergeArrays: mergeArrays,
-    mergeMaps: mergeMaps,
-    mergeOthers: mergeOthers,
-    mergeRecords: mergeRecords,
-    mergeSets: mergeSets
+  __proto__: null,
+  mergeArrays: mergeArrays,
+  mergeMaps: mergeMaps,
+  mergeOthers: mergeOthers,
+  mergeRecords: mergeRecords,
+  mergeSets: mergeSets
 });
 
 function deepmergeInto(target, ...objects) {
@@ -500,9 +509,7 @@ function getIntoUtils(options, customizedDeepmergeInto) {
  * @param m_target - The target to merge into.
  * @param values - The values.
  */
-function mergeUnknownsInto(m_target, values, utils, meta
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) {
+function mergeUnknownsInto(m_target, values, utils, meta) {
     if (values.length === 0) {
         return;
     }
diff --git a/dist/node/types/current/index.d.cts b/dist/node/index.d.cts
similarity index 58%
rename from dist/node/types/current/index.d.cts
rename to dist/node/index.d.cts
index 70985a14..65b554a8 100644
--- a/dist/node/types/current/index.d.cts
+++ b/dist/node/index.d.cts
@@ -1,24 +1,60 @@
 /**
- * Flatten a complex type such as a union or intersection of objects into a
+ * Simplify a complex type such as a union or intersection of objects into a
  * single object.
  */
-type FlatternAlias<T> = Is<T, unknown> extends true ? T : {
-    [P in keyof T]: T[P];
+type SimplifyObject<T extends {}> = {
+    [K in keyof T]: T[K];
 } & {};
 /**
- * Get the value of the given key in the given object.
+ * Flatten a collection of tuples of tuples into a collection of tuples.
  */
-type ValueOfKey<T extends Record<PropertyKey, unknown>, K extends PropertyKey> = K extends keyof T ? T[K] : never;
+type FlattenTuples<T> = {
+    [I in keyof T]: FlattenTuple<T[I]>;
+};
+/**
+ * Flatten a tuple of tuples into a single tuple.
+ */
+type FlattenTuple<T> = T extends readonly [
+] ? [
+] : T extends readonly [
+    infer T0
+] ? [
+    ...FlattenTuple<T0>
+] : T extends readonly [
+    infer T0,
+    ...infer Ts
+] ? [
+    ...FlattenTuple<T0>,
+    ...FlattenTuple<Ts>
+] : [
+    T
+];
 /**
  * Safely test whether or not the first given types extends the second.
  *
  * Needed in particular for testing if a type is "never".
  */
-type Is<T1, T2> = [T1] extends [T2] ? true : false;
+type Is<T1, T2> = [
+    T1
+] extends [
+    T2
+] ? true : false;
 /**
  * Safely test whether or not the given type is "never".
  */
 type IsNever<T> = Is<T, never>;
+/**
+ * And operator for types.
+ */
+type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
+/**
+ * Or operator for types.
+ */
+type Or<T1 extends boolean, T2 extends boolean> = T1 extends true ? true : T2;
+/**
+ * Not operator for types.
+ */
+type Not<T extends boolean> = T extends true ? false : true;
 /**
  * Returns whether or not the given type a record.
  */
@@ -26,7 +62,10 @@ type IsRecord<T> = And<Not<IsNever<T>>, T extends Readonly<Record<PropertyKey, u
 /**
  * Returns whether or not all the given types are records.
  */
-type EveryIsRecord<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [infer Head, ...infer Rest] ? IsRecord<Head> extends true ? Rest extends ReadonlyArray<unknown> ? EveryIsRecord<Rest> : true : false : true;
+type EveryIsRecord<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsRecord<Head> extends true ? Rest extends ReadonlyArray<unknown> ? EveryIsRecord<Rest> : true : false : true;
 /**
  * Returns whether or not the given type is an array.
  */
@@ -34,7 +73,15 @@ type IsArray<T> = And<Not<IsNever<T>>, T extends ReadonlyArray<unknown> ? true :
 /**
  * Returns whether or not all the given types are arrays.
  */
-type EveryIsArray<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [infer T1] ? IsArray<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsArray<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsArray<Rest> : false : false : false;
+type EveryIsArray<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+    infer T1
+] ? IsArray<T1> : Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsArray<Head> extends true ? Rest extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? EveryIsArray<Rest> : false : false : false;
 /**
  * Returns whether or not the given type is an set.
  *
@@ -46,7 +93,15 @@ type IsSet<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlySet<unknown>> ?
  *
  * Note: This may also return true if all are maps.
  */
-type EveryIsSet<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [infer T1]> ? IsSet<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsSet<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsSet<Rest> : false : false : false;
+type EveryIsSet<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [
+    infer T1
+]> ? IsSet<T1> : Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsSet<Head> extends true ? Rest extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? EveryIsSet<Rest> : false : false : false;
 /**
  * Returns whether or not the given type is an map.
  */
@@ -54,15 +109,15 @@ type IsMap<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlyMap<unknown, unk
 /**
  * Returns whether or not all the given types are maps.
  */
-type EveryIsMap<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [infer T1]> ? IsMap<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsMap<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsMap<Rest> : false : false : false;
-/**
- * And operator for types.
- */
-type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
-/**
- * Not operator for types.
- */
-type Not<T extends boolean> = T extends true ? false : true;
+type EveryIsMap<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [
+    infer T1
+]> ? IsMap<T1> : Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsMap<Head> extends true ? Rest extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? EveryIsMap<Rest> : false : false : false;
 /**
  * Union of the sets' values' types
  */
@@ -70,7 +125,10 @@ type UnionSetValues<Ts extends ReadonlyArray<unknown>> = UnionSetValuesHelper<Ts
 /**
  * Tail-recursive helper type for UnionSetValues.
  */
-type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlySet<infer V1>> ? Rest extends ReadonlyArray<unknown> ? UnionSetValuesHelper<Rest, Acc | V1> : Acc | V1 : never : Acc;
+type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Readonly<ReadonlySet<infer V1>> ? Rest extends ReadonlyArray<unknown> ? UnionSetValuesHelper<Rest, Acc | V1> : Acc | V1 : never : Acc;
 /**
  * Union of the maps' values' types
  */
@@ -78,7 +136,11 @@ type UnionMapKeys<Ts extends ReadonlyArray<unknown>> = UnionMapKeysHelper<Ts, ne
 /**
  * Tail-recursive helper type for UnionMapKeys.
  */
-type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlyMap<infer K1, unknown>> ? Rest extends readonly [] ? Acc | K1 : UnionMapKeysHelper<Rest, Acc | K1> : never : Acc;
+type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Readonly<ReadonlyMap<infer K1, unknown>> ? Rest extends readonly [
+] ? Acc | K1 : UnionMapKeysHelper<Rest, Acc | K1> : never : Acc;
 /**
  * Union of the maps' keys' types
  */
@@ -86,53 +148,105 @@ type UnionMapValues<Ts extends ReadonlyArray<unknown>> = UnionMapValuesHelper<Ts
 /**
  * Tail-recursive helper type for UnionMapValues.
  */
-type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
-/**
- * Get the keys of the type what match a certain criteria.
- */
-type KeysOfType<T, U> = {
-    [K in keyof T]: T[K] extends U ? K : never;
-}[keyof T];
-/**
- * Get the required keys of the type.
- */
-type RequiredKeys<T> = Exclude<KeysOfType<T, Exclude<T[keyof T], undefined>>, undefined>;
-/**
- * Get all the required keys on the types in the tuple.
- */
-type RequiredKeysOf<Ts extends readonly [unknown, ...ReadonlyArray<unknown>]> = RequiredKeysOfHelper<Ts, never>;
-/**
- * Tail-recursive helper type for RequiredKeysOf.
- */
-type RequiredKeysOfHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Record<PropertyKey, unknown> ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? RequiredKeysOfHelper<Rest, Acc | RequiredKeys<Head>> : Acc | RequiredKeys<Head> : never : Acc;
-/**
- * Get the optional keys of the type.
- */
-type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-/**
- * Get all the optional keys on the types in the tuple.
- */
-type OptionalKeysOf<Ts extends readonly [unknown, ...ReadonlyArray<unknown>]> = OptionalKeysOfHelper<Ts, never>;
-/**
- * Tail-recursive helper type for OptionalKeysOf.
- */
-type OptionalKeysOfHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Record<PropertyKey, unknown> ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? OptionalKeysOfHelper<Rest, Acc | OptionalKeys<Head>> : Acc | OptionalKeys<Head> : never : Acc;
+type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [
+] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
 /**
  * Filter out nevers from a tuple.
  */
-type FilterOutNever<T extends ReadonlyArray<unknown>> = FilterOutNeverHelper<T, []>;
+type FilterOutNever<T> = T extends ReadonlyArray<unknown> ? FilterOutNeverHelper<T, [
+]> : never;
 /**
  * Tail-recursive helper type for FilterOutNever.
  */
-type FilterOutNeverHelper<T extends ReadonlyArray<unknown>, Acc extends ReadonlyArray<unknown>> = T extends readonly [] ? Acc : T extends readonly [infer Head, ...infer Rest] ? IsNever<Head> extends true ? FilterOutNeverHelper<Rest, Acc> : FilterOutNeverHelper<Rest, [...Acc, Head]> : T;
+type FilterOutNeverHelper<T extends ReadonlyArray<unknown>, Acc extends ReadonlyArray<unknown>> = T extends readonly [
+] ? Acc : T extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsNever<Head> extends true ? FilterOutNeverHelper<Rest, Acc> : FilterOutNeverHelper<Rest, [
+    ...Acc,
+    Head
+]> : T;
 /**
  * Is the type a tuple?
  */
-type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [] ? true : T extends readonly [unknown, ...ReadonlyArray<unknown>] ? true : false;
-
+type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [
+] ? true : T extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? true : false;
+/**
+ * Perfrom a transpose operation on a 2D tuple.
+ */
+type TransposeTuple<T> = T extends readonly [
+    ...(readonly [
+        ...unknown[]
+    ])
+] ? T extends readonly [
+] ? [
+] : T extends readonly [
+    infer X extends ReadonlyArray<unknown>
+] ? TransposeTupleSimpleCase<X> : T extends readonly [
+    infer X extends ReadonlyArray<unknown>,
+    ...infer XS extends ReadonlyArray<ReadonlyArray<unknown>>
+] ? PrependCol<X, TransposeTuple<XS>> : T : never;
+type PrependCol<T extends ReadonlyArray<unknown>, S extends ReadonlyArray<ReadonlyArray<unknown>>> = T extends readonly [
+] ? S extends readonly [
+] ? [
+] : never : T extends readonly [
+    infer X,
+    ...infer XS
+] ? S extends readonly [
+    readonly [
+        ...infer Y
+    ],
+    ...infer YS extends ReadonlyArray<ReadonlyArray<unknown>>
+] ? [
+    [
+        X,
+        ...Y
+    ],
+    ...PrependCol<XS, YS>
+] : never : never;
+type TransposeTupleSimpleCase<T extends readonly [
+    ...unknown[]
+]> = T extends readonly [
+] ? [
+] : T extends readonly [
+    infer X,
+    ...infer XS
+] ? [
+    [
+        X
+    ],
+    ...TransposeTupleSimpleCase<XS>
+] : never;
+/**
+ * Convert a tuple to an intersection of each of its types.
+ */
+type TupleToIntersection<T extends ReadonlyArray<unknown>> = {
+    [K in keyof T]: (x: T[K]) => void;
+} extends Record<number, (x: infer I) => void> ? I : never;
+/**
+ * Convert a union to a tuple.
+ *
+ * Warning: The order of the elements is non-deterministic.
+ * Warning 2: The union maybe me modified by the TypeScript engine before convertion.
+ * Warning 3: This implementation relies on a hack/limitation in TypeScript.
+ */
+type TuplifyUnion<T, L = LastOf<T>> = IsNever<T> extends true ? [
+] : [
+    ...TuplifyUnion<Exclude<T, L>>,
+    L
+];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
 /**
  * Mapping of merge function URIs to the merge function type.
  */
+// eslint-disable-next-line ts/consistent-type-definitions
 interface DeepMergeMergeFunctionURItoKind<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, in out M> {
     readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
     readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
@@ -176,7 +290,10 @@ type DeepMergeMergeFunctionsURIs = Readonly<{
 /**
  * Deep merge types.
  */
-type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [] ? undefined : Ts extends readonly [infer T1] ? T1 : EveryIsArray<Ts> extends true ? DeepMergeArraysHKT<Ts, MF, M> : EveryIsMap<Ts> extends true ? DeepMergeMapsHKT<Ts, MF, M> : EveryIsSet<Ts> extends true ? DeepMergeSetsHKT<Ts, MF, M> : EveryIsRecord<Ts> extends true ? DeepMergeRecordsHKT<Ts, MF, M> : DeepMergeOthersHKT<Ts, MF, M> : unknown;
+type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [
+] ? undefined : Ts extends readonly [
+    infer T1
+] ? T1 : EveryIsArray<Ts> extends true ? DeepMergeArraysHKT<Ts, MF, M> : EveryIsMap<Ts> extends true ? DeepMergeMapsHKT<Ts, MF, M> : EveryIsSet<Ts> extends true ? DeepMergeSetsHKT<Ts, MF, M> : EveryIsRecord<Ts> extends true ? DeepMergeRecordsHKT<Ts, MF, M> : DeepMergeOthersHKT<Ts, MF, M> : unknown;
 /**
  * Deep merge records.
  */
@@ -201,16 +318,16 @@ type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeM
  * The merge function that returns a leaf.
  */
 type DeepMergeLeafURI = "DeepMergeLeafURI";
-/**
- * Get the leaf type from many types that can't be merged.
- *
- * @deprecated Use `DeepMergeLeaf` instead.
- */
-type DeepMergeLeafHKT<Ts extends ReadonlyArray<unknown>> = DeepMergeLeaf<Ts>;
 /**
  * Get the leaf type from many types that can't be merged.
  */
-type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [] ? never : Ts extends readonly [infer T] ? T : Ts extends readonly [...infer Rest, infer Tail] ? IsNever<Tail> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest> : never : Tail : never;
+type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+] ? never : Ts extends readonly [
+    infer T
+] ? T : Ts extends readonly [
+    ...infer Rest,
+    infer Tail
+] ? Or<IsNever<Tail>, Is<Tail, undefined>> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest> : never : Tail : never;
 /**
  * The meta data deepmerge is able to provide.
  */
@@ -218,7 +335,6 @@ type DeepMergeBuiltInMetaData = Readonly<{
     key: PropertyKey;
     parents: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>;
 }>;
-
 /**
  * The default merge function to merge records with.
  */
@@ -245,41 +361,152 @@ type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
     DeepMergeMapsURI: DeepMergeMapsDefaultURI;
     DeepMergeOthersURI: DeepMergeLeafURI;
 }>;
-/**
- * A union of all the props that should not be included in type information for
- * merged records.
- */
-type BlacklistedRecordProps = "__proto__";
+type RecordEntries<T extends Record<PropertyKey, unknown>> = TuplifyUnion<{
+    [K in keyof T]: [
+        K,
+        T[K]
+    ];
+}[keyof T]>;
+type RecordMeta = Record<PropertyKey, RecordPropertyMeta>;
+type RecordPropertyMeta<Key extends PropertyKey = PropertyKey, Value = unknown, Optional extends boolean = boolean> = {
+    key: Key;
+    value: Value;
+    optional: Optional;
+};
+type RecordsToRecordMeta<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>> = {
+    [I in keyof Ts]: RecordToRecordMeta<Ts[I]>;
+};
+type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> = {
+    [K in keyof T]-?: {
+        key: K;
+        value: Required<T>[K];
+        optional: {} extends Pick<T, K> ? true : false;
+    };
+};
 /**
  * Deep merge records.
  */
-type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends Readonly<readonly [unknown, ...Readonly<ReadonlyArray<unknown>>]> ? FlatternAlias<Omit<DeepMergeRecordsDefaultHKTInternalProps<Ts, MF, M>, BlacklistedRecordProps>> : {};
+type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? SimplifyObject<DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>> : never;
 /**
  * Deep merge record props.
  */
-type DeepMergeRecordsDefaultHKTInternalProps<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], MF extends DeepMergeMergeFunctionsURIs, M> = {
-    [K in OptionalKeysOf<Ts>]?: DeepMergeHKT<DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>, MF, M>;
-} & {
-    [K in RequiredKeysOf<Ts>]: DeepMergeHKT<DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>, MF, M>;
+type DeepMergeRecordMetaDefaultHKTProps<RecordMetas extends ReadonlyArray<RecordMeta>, MF extends DeepMergeMergeFunctionsURIs, M> = CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M>;
+type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> = GroupValuesByKey<FlattenTuples<TransposeTuple<{
+    [I in keyof RecordMetas]: TransposeTuple<RecordEntries<RecordMetas[I]>>;
+}>>>;
+type GroupValuesByKey<Ts> = Ts extends readonly [
+    infer Keys extends ReadonlyArray<PropertyKey>,
+    infer Values
+] ? {
+    [I in keyof Keys]: DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Keys[I], FilterOutNever<{
+        [J in keyof Values]: Values[J] extends {
+            key: Keys[I];
+        } ? Values[J] : never;
+    }>>;
+} : never;
+type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? TupleToIntersection<{
+    [I in keyof Ts]: Ts[I] extends {
+        key: infer Key extends PropertyKey;
+        values: infer Values extends ReadonlyArray<unknown>;
+        optional: infer O extends boolean;
+    } ? CreateRecordForKeyFromMeta<Key, Values, O, MF, M> : never;
+}> : never;
+type CreateRecordForKeyFromMeta<Key extends PropertyKey, Values extends ReadonlyArray<unknown>, Optional extends boolean, MF extends DeepMergeMergeFunctionsURIs, M> = Optional extends true ? {
+    [k in Key]+?: DeepMergeHKT<Values, MF, M>;
+} : {
+    [k in Key]-?: DeepMergeHKT<Values, MF, M>;
 };
 /**
- * Get the value of the property.
+ * Get the possible types of a property.
  */
-type DeepMergeRecordsDefaultHKTInternalPropValue<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], K extends PropertyKey, M> = FilterOutNever<DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts, K, M, readonly []>>;
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Key extends PropertyKey, Ts> = Ts extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts, {
+    key: Key;
+    values: [
+    ];
+    optional: never;
+}> : never;
 /**
- * Tail-recursive helper type for DeepMergeRecordsDefaultHKTInternalPropValue.
+ * Tail-recursive helper type for DeepMergeRecordPropertyMetaDefaultHKTGetPossible.
  */
-type DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], K extends PropertyKey, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [
-    infer Head extends Readonly<Record<PropertyKey, unknown>>,
-    ...infer Rest
-] ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? DeepMergeRecordsDefaultHKTInternalPropValueHelper<Rest, K, M, [
-    ...Acc,
-    ValueOfKey<Head, K>
-]> : [...Acc, ValueOfKey<Head, K>] : never;
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+], Acc extends {
+    key: PropertyKey;
+    values: ReadonlyArray<unknown>;
+    optional: boolean;
+}> = Ts extends [
+    ...infer Rest,
+    {
+        key: infer K extends PropertyKey;
+        value: infer V;
+        optional: infer O extends boolean;
+    }
+] ? Acc["optional"] extends true ? Acc extends {
+    values: [
+        infer Head,
+        ...infer AccRest
+    ];
+} ? Rest extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
+    key: K;
+    values: [
+        V | Head,
+        ...AccRest
+    ];
+    optional: O;
+}> : {
+    key: K;
+    values: [
+        V | Head,
+        ...AccRest
+    ];
+    optional: O;
+} : Rest extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+}> : {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+} : Rest extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+}> : {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+} : never;
 /**
- * Deep merge 2 arrays.
+ * Deep merge arrays.
  */
-type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
+type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, [
+]>;
 /**
  * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
  */
@@ -289,35 +516,45 @@ type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, MF exten
 ] ? Rest extends readonly [
     ReadonlyArray<unknown>,
     ...ReadonlyArray<ReadonlyArray<unknown>>
-] ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [...Acc, ...Head]> : [...Acc, ...Head] : never;
+] ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [
+    ...Acc,
+    ...Head
+]> : [
+    ...Acc,
+    ...Head
+] : never;
 /**
- * Deep merge 2 sets.
+ * Deep merge sets.
  */
 type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<UnionSetValues<Ts>>;
 /**
- * Deep merge 2 maps.
+ * Deep merge maps.
  */
 type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<UnionMapKeys<Ts>, UnionMapValues<Ts>>;
 /**
  * Get the merge functions with defaults apply from the given subset.
  */
 type GetDeepMergeMergeFunctionsURIs<PMF extends Partial<DeepMergeMergeFunctionsURIs>> = Readonly<{
+    // prettier-ignore
     DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
+    // prettier-ignore
     DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
+    // prettier-ignore
     DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
+    // prettier-ignore
     DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
+    // prettier-ignore
     DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
 }>;
-
 /**
  * The default merge functions.
  */
-type MergeFunctions$1 = {
-    mergeRecords: typeof mergeRecords$1;
-    mergeArrays: typeof mergeArrays$1;
-    mergeSets: typeof mergeSets$1;
-    mergeMaps: typeof mergeMaps$1;
-    mergeOthers: typeof mergeOthers$1;
+type MergeFunctions = {
+    mergeRecords: typeof mergeRecords;
+    mergeArrays: typeof mergeArrays;
+    mergeSets: typeof mergeSets;
+    mergeMaps: typeof mergeMaps;
+    mergeOthers: typeof mergeOthers;
 };
 /**
  * The default strategy to merge records into a target record.
@@ -325,72 +562,43 @@ type MergeFunctions$1 = {
  * @param m_target - The result will be mutated into this record
  * @param values - The records (including the target's value if there is one).
  */
-declare function mergeRecords$1<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined): void;
+declare function mergeRecords<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined): void;
 /**
  * The default strategy to merge arrays into a target array.
  *
  * @param m_target - The result will be mutated into this array
  * @param values - The arrays (including the target's value if there is one).
  */
-declare function mergeArrays$1<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(m_target: Reference<unknown[]>, values: Ts): void;
+declare function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(m_target: Reference<unknown[]>, values: Ts): void;
 /**
  * The default strategy to merge sets into a target set.
  *
  * @param m_target - The result will be mutated into this set
  * @param values - The sets (including the target's value if there is one).
  */
-declare function mergeSets$1<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(m_target: Reference<Set<unknown>>, values: Ts): void;
+declare function mergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(m_target: Reference<Set<unknown>>, values: Ts): void;
 /**
  * The default strategy to merge maps into a target map.
  *
  * @param m_target - The result will be mutated into this map
  * @param values - The maps (including the target's value if there is one).
  */
-declare function mergeMaps$1<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(m_target: Reference<Map<unknown, unknown>>, values: Ts): void;
+declare function mergeMaps<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(m_target: Reference<Map<unknown, unknown>>, values: Ts): void;
 /**
- * Set the target to the last value.
+ * Set the target to the last non-undefined value.
  */
-declare function mergeOthers$1<Ts extends ReadonlyArray<unknown>>(m_target: Reference<unknown>, values: Ts): void;
-
+declare function mergeOthers<Ts extends ReadonlyArray<unknown>>(m_target: Reference<unknown>, values: Ts): void;
+type MergeIntoFunctions = MergeFunctions;
 /**
  * The default merge functions.
  */
-type MergeFunctions = {
+type MergeFunctions$0 = {
     mergeRecords: typeof mergeRecords;
     mergeArrays: typeof mergeArrays;
     mergeSets: typeof mergeSets;
     mergeMaps: typeof mergeMaps;
     mergeOthers: typeof mergeOthers;
 };
-/**
- * The default strategy to merge records.
- *
- * @param values - The records.
- */
-declare function mergeRecords<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeMergeFunctionUtils<M, MM>, MF extends DeepMergeMergeFunctionsURIs, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(values: Ts, utils: U, meta: M | undefined): DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-/**
- * The default strategy to merge arrays.
- *
- * @param values - The arrays.
- */
-declare function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>, MF extends DeepMergeMergeFunctionsURIs, M>(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M>;
-/**
- * The default strategy to merge sets.
- *
- * @param values - The sets.
- */
-declare function mergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(values: Ts): DeepMergeSetsDefaultHKT<Ts>;
-/**
- * The default strategy to merge maps.
- *
- * @param values - The maps.
- */
-declare function mergeMaps<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(values: Ts): DeepMergeMapsDefaultHKT<Ts>;
-/**
- * Get the last value in the given array.
- */
-declare function mergeOthers<Ts extends ReadonlyArray<unknown>>(values: Ts): unknown;
-
 /**
  * The options the user can pass to customize deepmerge.
  */
@@ -439,6 +647,7 @@ type DeepMergeMergeFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMer
     mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
     mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
 }>;
+// eslint-disable-next-line ts/no-invalid-void-type
 type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
 /**
  * All the merge functions that deepmerge uses.
@@ -455,7 +664,7 @@ type DeepMergeMergeIntoFunctions<in M, MM extends DeepMergeBuiltInMetaData = Dee
  */
 type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
     mergeFunctions: DeepMergeMergeFunctions<M, MM>;
-    defaultMergeFunctions: MergeFunctions;
+    defaultMergeFunctions: MergeFunctions$0;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
     useImplicitDefaultMerging: boolean;
@@ -469,34 +678,34 @@ type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData =
  */
 type DeepMergeMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
     mergeFunctions: DeepMergeMergeIntoFunctions<M, MM>;
-    defaultMergeFunctions: MergeFunctions$1;
+    defaultMergeFunctions: MergeIntoFunctions;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...values: Ts) => void;
     actions: Readonly<{
         defaultMerge: symbol;
     }>;
 }>;
-
 /**
  * Deeply merge objects.
  *
  * @param objects - The objects to merge.
  */
-declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [...Ts]): DeepMergeHKT<Ts, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
+declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
+    ...Ts
+]): DeepMergeHKT<Ts, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
 /**
  * Deeply merge two or more objects using the given options.
  *
  * @param options - The options on how to customize the merge function.
  */
-declare function deepmergeCustom<PMF extends Partial<DeepMergeMergeFunctionsURIs>>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
 /**
  * Deeply merge two or more objects using the given options and meta data.
  *
  * @param options - The options on how to customize the merge function.
  * @param rootMetaData - The meta data passed to the root items' being merged.
  */
-declare function deepmergeCustom<PMF extends Partial<DeepMergeMergeFunctionsURIs>, MetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
-
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeMergeFunctionsURIs> = {}, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
 /**
  * Deeply merge objects into a target.
  *
@@ -510,7 +719,7 @@ declare function deepmergeInto<T extends object>(target: T, ...objects: Readonly
  * @param target - This object will be mutated with the merge result.
  * @param objects - The objects to merge into the target.
  */
-declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is FlatternAlias<Target & DeepMergeHKT<[
+declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is SimplifyObject<Target & DeepMergeHKT<[
     Target,
     ...Ts
 ], DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
@@ -519,15 +728,14 @@ declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<u
  *
  * @param options - The options on how to customize the merge function.
  */
-declare function deepmergeIntoCustom(options: DeepMergeIntoOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
+declare function deepmergeIntoCustom<BaseTs = unknown>(options: DeepMergeIntoOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
 /**
  * Deeply merge two or more objects using the given options and meta data.
  *
  * @param options - The options on how to customize the merge function.
  * @param rootMetaData - The meta data passed to the root items' being merged.
  */
-declare function deepmergeIntoCustom<MetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeIntoOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
-
+declare function deepmergeIntoCustom<BaseTs = unknown, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeIntoOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
 /**
  * The different types of objects deepmerge-ts support.
  */
@@ -563,5 +771,5 @@ declare function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey>;
  * @returns Whether the object has the property.
  */
 declare function objectHasProperty(object: object, property: PropertyKey): boolean;
-
-export { DeepMergeArraysDefaultHKT, DeepMergeBuiltInMetaData, DeepMergeHKT, DeepMergeIntoOptions, DeepMergeLeaf, DeepMergeLeafHKT, DeepMergeLeafURI, DeepMergeMapsDefaultHKT, DeepMergeMergeFunctionURItoKind, DeepMergeMergeFunctionUtils, DeepMergeMergeFunctionsDefaultURIs, MergeFunctions as DeepMergeMergeFunctionsDefaults, DeepMergeMergeFunctionsURIs, DeepMergeMergeIntoFunctionUtils, MergeFunctions$1 as DeepMergeMergeIntoFunctionsDefaults, DeepMergeOptions, DeepMergeRecordsDefaultHKT, DeepMergeSetsDefaultHKT, Reference as DeepMergeValueReference, GetDeepMergeMergeFunctionsURIs, ObjectType, deepmerge, deepmergeCustom, deepmergeInto, deepmergeIntoCustom, getKeys, getObjectType, objectHasProperty };
+export { deepmerge, deepmergeCustom, deepmergeInto, deepmergeIntoCustom, ObjectType, getKeys, getObjectType, objectHasProperty };
+export type { MergeFunctions as DeepMergeMergeIntoFunctionsDefaults, MergeFunctions$0 as DeepMergeMergeFunctionsDefaults, DeepMergeArraysDefaultHKT, DeepMergeBuiltInMetaData, DeepMergeHKT, DeepMergeLeaf, DeepMergeLeafURI, DeepMergeMapsDefaultHKT, DeepMergeMergeFunctionsDefaultURIs, DeepMergeMergeFunctionsURIs, DeepMergeMergeFunctionURItoKind, DeepMergeMergeFunctionUtils, DeepMergeMergeIntoFunctionUtils, DeepMergeOptions, DeepMergeIntoOptions, DeepMergeRecordsDefaultHKT, DeepMergeSetsDefaultHKT, Reference as DeepMergeValueReference, GetDeepMergeMergeFunctionsURIs };
diff --git a/dist/node/types/current/index.d.mts b/dist/node/index.d.mts
similarity index 58%
rename from dist/node/types/current/index.d.mts
rename to dist/node/index.d.mts
index 70985a14..65b554a8 100644
--- a/dist/node/types/current/index.d.mts
+++ b/dist/node/index.d.mts
@@ -1,24 +1,60 @@
 /**
- * Flatten a complex type such as a union or intersection of objects into a
+ * Simplify a complex type such as a union or intersection of objects into a
  * single object.
  */
-type FlatternAlias<T> = Is<T, unknown> extends true ? T : {
-    [P in keyof T]: T[P];
+type SimplifyObject<T extends {}> = {
+    [K in keyof T]: T[K];
 } & {};
 /**
- * Get the value of the given key in the given object.
+ * Flatten a collection of tuples of tuples into a collection of tuples.
  */
-type ValueOfKey<T extends Record<PropertyKey, unknown>, K extends PropertyKey> = K extends keyof T ? T[K] : never;
+type FlattenTuples<T> = {
+    [I in keyof T]: FlattenTuple<T[I]>;
+};
+/**
+ * Flatten a tuple of tuples into a single tuple.
+ */
+type FlattenTuple<T> = T extends readonly [
+] ? [
+] : T extends readonly [
+    infer T0
+] ? [
+    ...FlattenTuple<T0>
+] : T extends readonly [
+    infer T0,
+    ...infer Ts
+] ? [
+    ...FlattenTuple<T0>,
+    ...FlattenTuple<Ts>
+] : [
+    T
+];
 /**
  * Safely test whether or not the first given types extends the second.
  *
  * Needed in particular for testing if a type is "never".
  */
-type Is<T1, T2> = [T1] extends [T2] ? true : false;
+type Is<T1, T2> = [
+    T1
+] extends [
+    T2
+] ? true : false;
 /**
  * Safely test whether or not the given type is "never".
  */
 type IsNever<T> = Is<T, never>;
+/**
+ * And operator for types.
+ */
+type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
+/**
+ * Or operator for types.
+ */
+type Or<T1 extends boolean, T2 extends boolean> = T1 extends true ? true : T2;
+/**
+ * Not operator for types.
+ */
+type Not<T extends boolean> = T extends true ? false : true;
 /**
  * Returns whether or not the given type a record.
  */
@@ -26,7 +62,10 @@ type IsRecord<T> = And<Not<IsNever<T>>, T extends Readonly<Record<PropertyKey, u
 /**
  * Returns whether or not all the given types are records.
  */
-type EveryIsRecord<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [infer Head, ...infer Rest] ? IsRecord<Head> extends true ? Rest extends ReadonlyArray<unknown> ? EveryIsRecord<Rest> : true : false : true;
+type EveryIsRecord<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsRecord<Head> extends true ? Rest extends ReadonlyArray<unknown> ? EveryIsRecord<Rest> : true : false : true;
 /**
  * Returns whether or not the given type is an array.
  */
@@ -34,7 +73,15 @@ type IsArray<T> = And<Not<IsNever<T>>, T extends ReadonlyArray<unknown> ? true :
 /**
  * Returns whether or not all the given types are arrays.
  */
-type EveryIsArray<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [infer T1] ? IsArray<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsArray<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsArray<Rest> : false : false : false;
+type EveryIsArray<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+    infer T1
+] ? IsArray<T1> : Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsArray<Head> extends true ? Rest extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? EveryIsArray<Rest> : false : false : false;
 /**
  * Returns whether or not the given type is an set.
  *
@@ -46,7 +93,15 @@ type IsSet<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlySet<unknown>> ?
  *
  * Note: This may also return true if all are maps.
  */
-type EveryIsSet<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [infer T1]> ? IsSet<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsSet<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsSet<Rest> : false : false : false;
+type EveryIsSet<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [
+    infer T1
+]> ? IsSet<T1> : Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsSet<Head> extends true ? Rest extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? EveryIsSet<Rest> : false : false : false;
 /**
  * Returns whether or not the given type is an map.
  */
@@ -54,15 +109,15 @@ type IsMap<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlyMap<unknown, unk
 /**
  * Returns whether or not all the given types are maps.
  */
-type EveryIsMap<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [infer T1]> ? IsMap<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsMap<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsMap<Rest> : false : false : false;
-/**
- * And operator for types.
- */
-type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
-/**
- * Not operator for types.
- */
-type Not<T extends boolean> = T extends true ? false : true;
+type EveryIsMap<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [
+    infer T1
+]> ? IsMap<T1> : Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsMap<Head> extends true ? Rest extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? EveryIsMap<Rest> : false : false : false;
 /**
  * Union of the sets' values' types
  */
@@ -70,7 +125,10 @@ type UnionSetValues<Ts extends ReadonlyArray<unknown>> = UnionSetValuesHelper<Ts
 /**
  * Tail-recursive helper type for UnionSetValues.
  */
-type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlySet<infer V1>> ? Rest extends ReadonlyArray<unknown> ? UnionSetValuesHelper<Rest, Acc | V1> : Acc | V1 : never : Acc;
+type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Readonly<ReadonlySet<infer V1>> ? Rest extends ReadonlyArray<unknown> ? UnionSetValuesHelper<Rest, Acc | V1> : Acc | V1 : never : Acc;
 /**
  * Union of the maps' values' types
  */
@@ -78,7 +136,11 @@ type UnionMapKeys<Ts extends ReadonlyArray<unknown>> = UnionMapKeysHelper<Ts, ne
 /**
  * Tail-recursive helper type for UnionMapKeys.
  */
-type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlyMap<infer K1, unknown>> ? Rest extends readonly [] ? Acc | K1 : UnionMapKeysHelper<Rest, Acc | K1> : never : Acc;
+type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Readonly<ReadonlyMap<infer K1, unknown>> ? Rest extends readonly [
+] ? Acc | K1 : UnionMapKeysHelper<Rest, Acc | K1> : never : Acc;
 /**
  * Union of the maps' keys' types
  */
@@ -86,53 +148,105 @@ type UnionMapValues<Ts extends ReadonlyArray<unknown>> = UnionMapValuesHelper<Ts
 /**
  * Tail-recursive helper type for UnionMapValues.
  */
-type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
-/**
- * Get the keys of the type what match a certain criteria.
- */
-type KeysOfType<T, U> = {
-    [K in keyof T]: T[K] extends U ? K : never;
-}[keyof T];
-/**
- * Get the required keys of the type.
- */
-type RequiredKeys<T> = Exclude<KeysOfType<T, Exclude<T[keyof T], undefined>>, undefined>;
-/**
- * Get all the required keys on the types in the tuple.
- */
-type RequiredKeysOf<Ts extends readonly [unknown, ...ReadonlyArray<unknown>]> = RequiredKeysOfHelper<Ts, never>;
-/**
- * Tail-recursive helper type for RequiredKeysOf.
- */
-type RequiredKeysOfHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Record<PropertyKey, unknown> ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? RequiredKeysOfHelper<Rest, Acc | RequiredKeys<Head>> : Acc | RequiredKeys<Head> : never : Acc;
-/**
- * Get the optional keys of the type.
- */
-type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-/**
- * Get all the optional keys on the types in the tuple.
- */
-type OptionalKeysOf<Ts extends readonly [unknown, ...ReadonlyArray<unknown>]> = OptionalKeysOfHelper<Ts, never>;
-/**
- * Tail-recursive helper type for OptionalKeysOf.
- */
-type OptionalKeysOfHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Record<PropertyKey, unknown> ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? OptionalKeysOfHelper<Rest, Acc | OptionalKeys<Head>> : Acc | OptionalKeys<Head> : never : Acc;
+type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [
+] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
 /**
  * Filter out nevers from a tuple.
  */
-type FilterOutNever<T extends ReadonlyArray<unknown>> = FilterOutNeverHelper<T, []>;
+type FilterOutNever<T> = T extends ReadonlyArray<unknown> ? FilterOutNeverHelper<T, [
+]> : never;
 /**
  * Tail-recursive helper type for FilterOutNever.
  */
-type FilterOutNeverHelper<T extends ReadonlyArray<unknown>, Acc extends ReadonlyArray<unknown>> = T extends readonly [] ? Acc : T extends readonly [infer Head, ...infer Rest] ? IsNever<Head> extends true ? FilterOutNeverHelper<Rest, Acc> : FilterOutNeverHelper<Rest, [...Acc, Head]> : T;
+type FilterOutNeverHelper<T extends ReadonlyArray<unknown>, Acc extends ReadonlyArray<unknown>> = T extends readonly [
+] ? Acc : T extends readonly [
+    infer Head,
+    ...infer Rest
+] ? IsNever<Head> extends true ? FilterOutNeverHelper<Rest, Acc> : FilterOutNeverHelper<Rest, [
+    ...Acc,
+    Head
+]> : T;
 /**
  * Is the type a tuple?
  */
-type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [] ? true : T extends readonly [unknown, ...ReadonlyArray<unknown>] ? true : false;
-
+type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [
+] ? true : T extends readonly [
+    unknown,
+    ...ReadonlyArray<unknown>
+] ? true : false;
+/**
+ * Perfrom a transpose operation on a 2D tuple.
+ */
+type TransposeTuple<T> = T extends readonly [
+    ...(readonly [
+        ...unknown[]
+    ])
+] ? T extends readonly [
+] ? [
+] : T extends readonly [
+    infer X extends ReadonlyArray<unknown>
+] ? TransposeTupleSimpleCase<X> : T extends readonly [
+    infer X extends ReadonlyArray<unknown>,
+    ...infer XS extends ReadonlyArray<ReadonlyArray<unknown>>
+] ? PrependCol<X, TransposeTuple<XS>> : T : never;
+type PrependCol<T extends ReadonlyArray<unknown>, S extends ReadonlyArray<ReadonlyArray<unknown>>> = T extends readonly [
+] ? S extends readonly [
+] ? [
+] : never : T extends readonly [
+    infer X,
+    ...infer XS
+] ? S extends readonly [
+    readonly [
+        ...infer Y
+    ],
+    ...infer YS extends ReadonlyArray<ReadonlyArray<unknown>>
+] ? [
+    [
+        X,
+        ...Y
+    ],
+    ...PrependCol<XS, YS>
+] : never : never;
+type TransposeTupleSimpleCase<T extends readonly [
+    ...unknown[]
+]> = T extends readonly [
+] ? [
+] : T extends readonly [
+    infer X,
+    ...infer XS
+] ? [
+    [
+        X
+    ],
+    ...TransposeTupleSimpleCase<XS>
+] : never;
+/**
+ * Convert a tuple to an intersection of each of its types.
+ */
+type TupleToIntersection<T extends ReadonlyArray<unknown>> = {
+    [K in keyof T]: (x: T[K]) => void;
+} extends Record<number, (x: infer I) => void> ? I : never;
+/**
+ * Convert a union to a tuple.
+ *
+ * Warning: The order of the elements is non-deterministic.
+ * Warning 2: The union maybe me modified by the TypeScript engine before convertion.
+ * Warning 3: This implementation relies on a hack/limitation in TypeScript.
+ */
+type TuplifyUnion<T, L = LastOf<T>> = IsNever<T> extends true ? [
+] : [
+    ...TuplifyUnion<Exclude<T, L>>,
+    L
+];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
 /**
  * Mapping of merge function URIs to the merge function type.
  */
+// eslint-disable-next-line ts/consistent-type-definitions
 interface DeepMergeMergeFunctionURItoKind<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, in out M> {
     readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
     readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
@@ -176,7 +290,10 @@ type DeepMergeMergeFunctionsURIs = Readonly<{
 /**
  * Deep merge types.
  */
-type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [] ? undefined : Ts extends readonly [infer T1] ? T1 : EveryIsArray<Ts> extends true ? DeepMergeArraysHKT<Ts, MF, M> : EveryIsMap<Ts> extends true ? DeepMergeMapsHKT<Ts, MF, M> : EveryIsSet<Ts> extends true ? DeepMergeSetsHKT<Ts, MF, M> : EveryIsRecord<Ts> extends true ? DeepMergeRecordsHKT<Ts, MF, M> : DeepMergeOthersHKT<Ts, MF, M> : unknown;
+type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [
+] ? undefined : Ts extends readonly [
+    infer T1
+] ? T1 : EveryIsArray<Ts> extends true ? DeepMergeArraysHKT<Ts, MF, M> : EveryIsMap<Ts> extends true ? DeepMergeMapsHKT<Ts, MF, M> : EveryIsSet<Ts> extends true ? DeepMergeSetsHKT<Ts, MF, M> : EveryIsRecord<Ts> extends true ? DeepMergeRecordsHKT<Ts, MF, M> : DeepMergeOthersHKT<Ts, MF, M> : unknown;
 /**
  * Deep merge records.
  */
@@ -201,16 +318,16 @@ type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeM
  * The merge function that returns a leaf.
  */
 type DeepMergeLeafURI = "DeepMergeLeafURI";
-/**
- * Get the leaf type from many types that can't be merged.
- *
- * @deprecated Use `DeepMergeLeaf` instead.
- */
-type DeepMergeLeafHKT<Ts extends ReadonlyArray<unknown>> = DeepMergeLeaf<Ts>;
 /**
  * Get the leaf type from many types that can't be merged.
  */
-type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [] ? never : Ts extends readonly [infer T] ? T : Ts extends readonly [...infer Rest, infer Tail] ? IsNever<Tail> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest> : never : Tail : never;
+type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+] ? never : Ts extends readonly [
+    infer T
+] ? T : Ts extends readonly [
+    ...infer Rest,
+    infer Tail
+] ? Or<IsNever<Tail>, Is<Tail, undefined>> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest> : never : Tail : never;
 /**
  * The meta data deepmerge is able to provide.
  */
@@ -218,7 +335,6 @@ type DeepMergeBuiltInMetaData = Readonly<{
     key: PropertyKey;
     parents: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>;
 }>;
-
 /**
  * The default merge function to merge records with.
  */
@@ -245,41 +361,152 @@ type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
     DeepMergeMapsURI: DeepMergeMapsDefaultURI;
     DeepMergeOthersURI: DeepMergeLeafURI;
 }>;
-/**
- * A union of all the props that should not be included in type information for
- * merged records.
- */
-type BlacklistedRecordProps = "__proto__";
+type RecordEntries<T extends Record<PropertyKey, unknown>> = TuplifyUnion<{
+    [K in keyof T]: [
+        K,
+        T[K]
+    ];
+}[keyof T]>;
+type RecordMeta = Record<PropertyKey, RecordPropertyMeta>;
+type RecordPropertyMeta<Key extends PropertyKey = PropertyKey, Value = unknown, Optional extends boolean = boolean> = {
+    key: Key;
+    value: Value;
+    optional: Optional;
+};
+type RecordsToRecordMeta<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>> = {
+    [I in keyof Ts]: RecordToRecordMeta<Ts[I]>;
+};
+type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> = {
+    [K in keyof T]-?: {
+        key: K;
+        value: Required<T>[K];
+        optional: {} extends Pick<T, K> ? true : false;
+    };
+};
 /**
  * Deep merge records.
  */
-type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends Readonly<readonly [unknown, ...Readonly<ReadonlyArray<unknown>>]> ? FlatternAlias<Omit<DeepMergeRecordsDefaultHKTInternalProps<Ts, MF, M>, BlacklistedRecordProps>> : {};
+type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? SimplifyObject<DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>> : never;
 /**
  * Deep merge record props.
  */
-type DeepMergeRecordsDefaultHKTInternalProps<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], MF extends DeepMergeMergeFunctionsURIs, M> = {
-    [K in OptionalKeysOf<Ts>]?: DeepMergeHKT<DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>, MF, M>;
-} & {
-    [K in RequiredKeysOf<Ts>]: DeepMergeHKT<DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>, MF, M>;
+type DeepMergeRecordMetaDefaultHKTProps<RecordMetas extends ReadonlyArray<RecordMeta>, MF extends DeepMergeMergeFunctionsURIs, M> = CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M>;
+type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> = GroupValuesByKey<FlattenTuples<TransposeTuple<{
+    [I in keyof RecordMetas]: TransposeTuple<RecordEntries<RecordMetas[I]>>;
+}>>>;
+type GroupValuesByKey<Ts> = Ts extends readonly [
+    infer Keys extends ReadonlyArray<PropertyKey>,
+    infer Values
+] ? {
+    [I in keyof Keys]: DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Keys[I], FilterOutNever<{
+        [J in keyof Values]: Values[J] extends {
+            key: Keys[I];
+        } ? Values[J] : never;
+    }>>;
+} : never;
+type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? TupleToIntersection<{
+    [I in keyof Ts]: Ts[I] extends {
+        key: infer Key extends PropertyKey;
+        values: infer Values extends ReadonlyArray<unknown>;
+        optional: infer O extends boolean;
+    } ? CreateRecordForKeyFromMeta<Key, Values, O, MF, M> : never;
+}> : never;
+type CreateRecordForKeyFromMeta<Key extends PropertyKey, Values extends ReadonlyArray<unknown>, Optional extends boolean, MF extends DeepMergeMergeFunctionsURIs, M> = Optional extends true ? {
+    [k in Key]+?: DeepMergeHKT<Values, MF, M>;
+} : {
+    [k in Key]-?: DeepMergeHKT<Values, MF, M>;
 };
 /**
- * Get the value of the property.
+ * Get the possible types of a property.
  */
-type DeepMergeRecordsDefaultHKTInternalPropValue<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], K extends PropertyKey, M> = FilterOutNever<DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts, K, M, readonly []>>;
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Key extends PropertyKey, Ts> = Ts extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts, {
+    key: Key;
+    values: [
+    ];
+    optional: never;
+}> : never;
 /**
- * Tail-recursive helper type for DeepMergeRecordsDefaultHKTInternalPropValue.
+ * Tail-recursive helper type for DeepMergeRecordPropertyMetaDefaultHKTGetPossible.
  */
-type DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], K extends PropertyKey, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [
-    infer Head extends Readonly<Record<PropertyKey, unknown>>,
-    ...infer Rest
-] ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? DeepMergeRecordsDefaultHKTInternalPropValueHelper<Rest, K, M, [
-    ...Acc,
-    ValueOfKey<Head, K>
-]> : [...Acc, ValueOfKey<Head, K>] : never;
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+], Acc extends {
+    key: PropertyKey;
+    values: ReadonlyArray<unknown>;
+    optional: boolean;
+}> = Ts extends [
+    ...infer Rest,
+    {
+        key: infer K extends PropertyKey;
+        value: infer V;
+        optional: infer O extends boolean;
+    }
+] ? Acc["optional"] extends true ? Acc extends {
+    values: [
+        infer Head,
+        ...infer AccRest
+    ];
+} ? Rest extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
+    key: K;
+    values: [
+        V | Head,
+        ...AccRest
+    ];
+    optional: O;
+}> : {
+    key: K;
+    values: [
+        V | Head,
+        ...AccRest
+    ];
+    optional: O;
+} : Rest extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+}> : {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+} : Rest extends readonly [
+    RecordPropertyMeta,
+    ...ReadonlyArray<RecordPropertyMeta>
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+}> : {
+    key: K;
+    values: [
+        V,
+        ...Acc["values"]
+    ];
+    optional: O;
+} : never;
 /**
- * Deep merge 2 arrays.
+ * Deep merge arrays.
  */
-type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
+type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, [
+]>;
 /**
  * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
  */
@@ -289,35 +516,45 @@ type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, MF exten
 ] ? Rest extends readonly [
     ReadonlyArray<unknown>,
     ...ReadonlyArray<ReadonlyArray<unknown>>
-] ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [...Acc, ...Head]> : [...Acc, ...Head] : never;
+] ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [
+    ...Acc,
+    ...Head
+]> : [
+    ...Acc,
+    ...Head
+] : never;
 /**
- * Deep merge 2 sets.
+ * Deep merge sets.
  */
 type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<UnionSetValues<Ts>>;
 /**
- * Deep merge 2 maps.
+ * Deep merge maps.
  */
 type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<UnionMapKeys<Ts>, UnionMapValues<Ts>>;
 /**
  * Get the merge functions with defaults apply from the given subset.
  */
 type GetDeepMergeMergeFunctionsURIs<PMF extends Partial<DeepMergeMergeFunctionsURIs>> = Readonly<{
+    // prettier-ignore
     DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
+    // prettier-ignore
     DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
+    // prettier-ignore
     DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
+    // prettier-ignore
     DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
+    // prettier-ignore
     DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
 }>;
-
 /**
  * The default merge functions.
  */
-type MergeFunctions$1 = {
-    mergeRecords: typeof mergeRecords$1;
-    mergeArrays: typeof mergeArrays$1;
-    mergeSets: typeof mergeSets$1;
-    mergeMaps: typeof mergeMaps$1;
-    mergeOthers: typeof mergeOthers$1;
+type MergeFunctions = {
+    mergeRecords: typeof mergeRecords;
+    mergeArrays: typeof mergeArrays;
+    mergeSets: typeof mergeSets;
+    mergeMaps: typeof mergeMaps;
+    mergeOthers: typeof mergeOthers;
 };
 /**
  * The default strategy to merge records into a target record.
@@ -325,72 +562,43 @@ type MergeFunctions$1 = {
  * @param m_target - The result will be mutated into this record
  * @param values - The records (including the target's value if there is one).
  */
-declare function mergeRecords$1<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined): void;
+declare function mergeRecords<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined): void;
 /**
  * The default strategy to merge arrays into a target array.
  *
  * @param m_target - The result will be mutated into this array
  * @param values - The arrays (including the target's value if there is one).
  */
-declare function mergeArrays$1<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(m_target: Reference<unknown[]>, values: Ts): void;
+declare function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(m_target: Reference<unknown[]>, values: Ts): void;
 /**
  * The default strategy to merge sets into a target set.
  *
  * @param m_target - The result will be mutated into this set
  * @param values - The sets (including the target's value if there is one).
  */
-declare function mergeSets$1<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(m_target: Reference<Set<unknown>>, values: Ts): void;
+declare function mergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(m_target: Reference<Set<unknown>>, values: Ts): void;
 /**
  * The default strategy to merge maps into a target map.
  *
  * @param m_target - The result will be mutated into this map
  * @param values - The maps (including the target's value if there is one).
  */
-declare function mergeMaps$1<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(m_target: Reference<Map<unknown, unknown>>, values: Ts): void;
+declare function mergeMaps<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(m_target: Reference<Map<unknown, unknown>>, values: Ts): void;
 /**
- * Set the target to the last value.
+ * Set the target to the last non-undefined value.
  */
-declare function mergeOthers$1<Ts extends ReadonlyArray<unknown>>(m_target: Reference<unknown>, values: Ts): void;
-
+declare function mergeOthers<Ts extends ReadonlyArray<unknown>>(m_target: Reference<unknown>, values: Ts): void;
+type MergeIntoFunctions = MergeFunctions;
 /**
  * The default merge functions.
  */
-type MergeFunctions = {
+type MergeFunctions$0 = {
     mergeRecords: typeof mergeRecords;
     mergeArrays: typeof mergeArrays;
     mergeSets: typeof mergeSets;
     mergeMaps: typeof mergeMaps;
     mergeOthers: typeof mergeOthers;
 };
-/**
- * The default strategy to merge records.
- *
- * @param values - The records.
- */
-declare function mergeRecords<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeMergeFunctionUtils<M, MM>, MF extends DeepMergeMergeFunctionsURIs, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(values: Ts, utils: U, meta: M | undefined): DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-/**
- * The default strategy to merge arrays.
- *
- * @param values - The arrays.
- */
-declare function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>, MF extends DeepMergeMergeFunctionsURIs, M>(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M>;
-/**
- * The default strategy to merge sets.
- *
- * @param values - The sets.
- */
-declare function mergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(values: Ts): DeepMergeSetsDefaultHKT<Ts>;
-/**
- * The default strategy to merge maps.
- *
- * @param values - The maps.
- */
-declare function mergeMaps<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(values: Ts): DeepMergeMapsDefaultHKT<Ts>;
-/**
- * Get the last value in the given array.
- */
-declare function mergeOthers<Ts extends ReadonlyArray<unknown>>(values: Ts): unknown;
-
 /**
  * The options the user can pass to customize deepmerge.
  */
@@ -439,6 +647,7 @@ type DeepMergeMergeFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMer
     mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
     mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
 }>;
+// eslint-disable-next-line ts/no-invalid-void-type
 type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
 /**
  * All the merge functions that deepmerge uses.
@@ -455,7 +664,7 @@ type DeepMergeMergeIntoFunctions<in M, MM extends DeepMergeBuiltInMetaData = Dee
  */
 type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
     mergeFunctions: DeepMergeMergeFunctions<M, MM>;
-    defaultMergeFunctions: MergeFunctions;
+    defaultMergeFunctions: MergeFunctions$0;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
     useImplicitDefaultMerging: boolean;
@@ -469,34 +678,34 @@ type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData =
  */
 type DeepMergeMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
     mergeFunctions: DeepMergeMergeIntoFunctions<M, MM>;
-    defaultMergeFunctions: MergeFunctions$1;
+    defaultMergeFunctions: MergeIntoFunctions;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...values: Ts) => void;
     actions: Readonly<{
         defaultMerge: symbol;
     }>;
 }>;
-
 /**
  * Deeply merge objects.
  *
  * @param objects - The objects to merge.
  */
-declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [...Ts]): DeepMergeHKT<Ts, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
+declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
+    ...Ts
+]): DeepMergeHKT<Ts, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
 /**
  * Deeply merge two or more objects using the given options.
  *
  * @param options - The options on how to customize the merge function.
  */
-declare function deepmergeCustom<PMF extends Partial<DeepMergeMergeFunctionsURIs>>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
 /**
  * Deeply merge two or more objects using the given options and meta data.
  *
  * @param options - The options on how to customize the merge function.
  * @param rootMetaData - The meta data passed to the root items' being merged.
  */
-declare function deepmergeCustom<PMF extends Partial<DeepMergeMergeFunctionsURIs>, MetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
-
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeMergeFunctionsURIs> = {}, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
 /**
  * Deeply merge objects into a target.
  *
@@ -510,7 +719,7 @@ declare function deepmergeInto<T extends object>(target: T, ...objects: Readonly
  * @param target - This object will be mutated with the merge result.
  * @param objects - The objects to merge into the target.
  */
-declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is FlatternAlias<Target & DeepMergeHKT<[
+declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is SimplifyObject<Target & DeepMergeHKT<[
     Target,
     ...Ts
 ], DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
@@ -519,15 +728,14 @@ declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<u
  *
  * @param options - The options on how to customize the merge function.
  */
-declare function deepmergeIntoCustom(options: DeepMergeIntoOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
+declare function deepmergeIntoCustom<BaseTs = unknown>(options: DeepMergeIntoOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
 /**
  * Deeply merge two or more objects using the given options and meta data.
  *
  * @param options - The options on how to customize the merge function.
  * @param rootMetaData - The meta data passed to the root items' being merged.
  */
-declare function deepmergeIntoCustom<MetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeIntoOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
-
+declare function deepmergeIntoCustom<BaseTs = unknown, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeIntoOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
 /**
  * The different types of objects deepmerge-ts support.
  */
@@ -563,5 +771,5 @@ declare function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey>;
  * @returns Whether the object has the property.
  */
 declare function objectHasProperty(object: object, property: PropertyKey): boolean;
-
-export { DeepMergeArraysDefaultHKT, DeepMergeBuiltInMetaData, DeepMergeHKT, DeepMergeIntoOptions, DeepMergeLeaf, DeepMergeLeafHKT, DeepMergeLeafURI, DeepMergeMapsDefaultHKT, DeepMergeMergeFunctionURItoKind, DeepMergeMergeFunctionUtils, DeepMergeMergeFunctionsDefaultURIs, MergeFunctions as DeepMergeMergeFunctionsDefaults, DeepMergeMergeFunctionsURIs, DeepMergeMergeIntoFunctionUtils, MergeFunctions$1 as DeepMergeMergeIntoFunctionsDefaults, DeepMergeOptions, DeepMergeRecordsDefaultHKT, DeepMergeSetsDefaultHKT, Reference as DeepMergeValueReference, GetDeepMergeMergeFunctionsURIs, ObjectType, deepmerge, deepmergeCustom, deepmergeInto, deepmergeIntoCustom, getKeys, getObjectType, objectHasProperty };
+export { deepmerge, deepmergeCustom, deepmergeInto, deepmergeIntoCustom, ObjectType, getKeys, getObjectType, objectHasProperty };
+export type { MergeFunctions as DeepMergeMergeIntoFunctionsDefaults, MergeFunctions$0 as DeepMergeMergeFunctionsDefaults, DeepMergeArraysDefaultHKT, DeepMergeBuiltInMetaData, DeepMergeHKT, DeepMergeLeaf, DeepMergeLeafURI, DeepMergeMapsDefaultHKT, DeepMergeMergeFunctionsDefaultURIs, DeepMergeMergeFunctionsURIs, DeepMergeMergeFunctionURItoKind, DeepMergeMergeFunctionUtils, DeepMergeMergeIntoFunctionUtils, DeepMergeOptions, DeepMergeIntoOptions, DeepMergeRecordsDefaultHKT, DeepMergeSetsDefaultHKT, Reference as DeepMergeValueReference, GetDeepMergeMergeFunctionsURIs };
diff --git a/dist/node/index.mjs b/dist/node/index.mjs
index 70e5e1dd..3080703f 100644
--- a/dist/node/index.mjs
+++ b/dist/node/index.mjs
@@ -19,6 +19,18 @@ function defaultMetaDataUpdater(previousMeta, metaMeta) {
     return metaMeta;
 }
 
+/**
+ * The different types of objects deepmerge-ts support.
+ */
+var ObjectType;
+(function (ObjectType) {
+    ObjectType[ObjectType["NOT"] = 0] = "NOT";
+    ObjectType[ObjectType["RECORD"] = 1] = "RECORD";
+    ObjectType[ObjectType["ARRAY"] = 2] = "ARRAY";
+    ObjectType[ObjectType["SET"] = 3] = "SET";
+    ObjectType[ObjectType["MAP"] = 4] = "MAP";
+    ObjectType[ObjectType["OTHER"] = 5] = "OTHER";
+})(ObjectType || (ObjectType = {}));
 /**
  * Get the type of the given object.
  *
@@ -53,7 +65,6 @@ function getObjectType(object) {
  */
 function getKeys(objects) {
     const keys = new Set();
-    /* eslint-disable functional/no-loop-statements, functional/no-expression-statements -- using a loop here is more efficient. */
     for (const object of objects) {
         for (const key of [
             ...Object.keys(object),
@@ -62,7 +73,6 @@ function getKeys(objects) {
             keys.add(key);
         }
     }
-    /* eslint-enable functional/no-loop-statements, functional/no-expression-statements */
     return keys;
 }
 /**
@@ -81,11 +91,8 @@ function objectHasProperty(object, property) {
  */
 function getIterableOfIterables(iterables) {
     return {
-        // eslint-disable-next-line functional/functional-parameters
         *[Symbol.iterator]() {
-            // eslint-disable-next-line functional/no-loop-statements
             for (const iterable of iterables) {
-                // eslint-disable-next-line functional/no-loop-statements
                 for (const value of iterable) {
                     yield value;
                 }
@@ -107,11 +114,10 @@ function isRecord(value) {
     }
     const { constructor } = value;
     // If has modified constructor.
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    // eslint-disable-next-line ts/no-unnecessary-condition
     if (constructor === undefined) {
         return true;
     }
-    // eslint-disable-next-line prefer-destructuring
     const prototype = constructor.prototype;
     // If has modified prototype.
     if (prototype === null ||
@@ -120,7 +126,7 @@ function isRecord(value) {
         return false;
     }
     // If constructor does not have an Object-specific method.
-    // eslint-disable-next-line sonarjs/prefer-single-boolean-return, no-prototype-builtins
+    // eslint-disable-next-line sonar/prefer-single-boolean-return, no-prototype-builtins
     if (!prototype.hasOwnProperty("isPrototypeOf")) {
         return false;
     }
@@ -135,7 +141,6 @@ function isRecord(value) {
  */
 function mergeRecords$2(values, utils, meta) {
     const result = {};
-    /* eslint-disable functional/no-loop-statements, functional/no-conditional-statements, functional/no-expression-statements, functional/immutable-data -- using imperative code here is more performant. */
     for (const key of getKeys(values)) {
         const propValues = [];
         for (const value of values) {
@@ -166,7 +171,6 @@ function mergeRecords$2(values, utils, meta) {
             result[key] = propertyResult;
         }
     }
-    /* eslint-enable functional/no-loop-statements, functional/no-conditional-statements, functional/no-expression-statements, functional/immutable-data */
     return result;
 }
 /**
@@ -194,19 +198,24 @@ function mergeMaps$2(values) {
     return new Map(getIterableOfIterables(values));
 }
 /**
- * Get the last value in the given array.
+ * Get the last non-undefined value in the given array.
  */
 function mergeOthers$2(values) {
-    return values.at(-1);
+    for (let i = values.length - 1; i >= 0; i--) {
+        if (values[i] !== undefined) {
+            return values[i];
+        }
+    }
+    return undefined;
 }
 
 var defaultMergeFunctions = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    mergeArrays: mergeArrays$2,
-    mergeMaps: mergeMaps$2,
-    mergeOthers: mergeOthers$2,
-    mergeRecords: mergeRecords$2,
-    mergeSets: mergeSets$2
+  __proto__: null,
+  mergeArrays: mergeArrays$2,
+  mergeMaps: mergeMaps$2,
+  mergeOthers: mergeOthers$2,
+  mergeRecords: mergeRecords$2,
+  mergeSets: mergeSets$2
 });
 
 /**
@@ -214,9 +223,7 @@ var defaultMergeFunctions = /*#__PURE__*/Object.freeze({
  *
  * @param objects - The objects to merge.
  */
-function deepmerge(
-// eslint-disable-next-line functional/functional-parameters
-...objects) {
+function deepmerge(...objects) {
     return deepmergeCustom({})(...objects);
 }
 function deepmergeCustom(options, rootMetaData) {
@@ -224,9 +231,7 @@ function deepmergeCustom(options, rootMetaData) {
     /**
      * The customized deepmerge function.
      */
-    function customizedDeepmerge(
-    // eslint-disable-next-line functional/functional-parameters
-    ...objects) {
+    function customizedDeepmerge(...objects) {
         return mergeUnknowns(objects, utils, rootMetaData);
     }
     return customizedDeepmerge;
@@ -267,7 +272,6 @@ function mergeUnknowns(values, utils, meta) {
         return mergeOthers$1(values, utils, meta);
     }
     const type = getObjectType(values[0]);
-    /* eslint-disable functional/no-loop-statements, functional/no-conditional-statements -- using imperative code here is more performant. */
     if (type !== 0 /* ObjectType.NOT */ && type !== 5 /* ObjectType.OTHER */) {
         for (let m_index = 1; m_index < values.length; m_index++) {
             if (getObjectType(values[m_index]) === type) {
@@ -276,7 +280,6 @@ function mergeUnknowns(values, utils, meta) {
             return mergeOthers$1(values, utils, meta);
         }
     }
-    /* eslint-enable functional/no-loop-statements, functional/no-conditional-statements */
     switch (type) {
         case 1 /* ObjectType.RECORD */: {
             return mergeRecords$1(values, utils, meta);
@@ -442,19 +445,25 @@ function mergeMaps(m_target, values) {
     }
 }
 /**
- * Set the target to the last value.
+ * Set the target to the last non-undefined value.
  */
 function mergeOthers(m_target, values) {
-    m_target.value = values.at(-1);
+    for (let i = values.length - 1; i >= 0; i--) {
+        if (values[i] !== undefined) {
+            m_target.value = values[i];
+            return;
+        }
+    }
+    m_target.value = undefined;
 }
 
 var defaultMergeIntoFunctions = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    mergeArrays: mergeArrays,
-    mergeMaps: mergeMaps,
-    mergeOthers: mergeOthers,
-    mergeRecords: mergeRecords,
-    mergeSets: mergeSets
+  __proto__: null,
+  mergeArrays: mergeArrays,
+  mergeMaps: mergeMaps,
+  mergeOthers: mergeOthers,
+  mergeRecords: mergeRecords,
+  mergeSets: mergeSets
 });
 
 function deepmergeInto(target, ...objects) {
@@ -498,9 +507,7 @@ function getIntoUtils(options, customizedDeepmergeInto) {
  * @param m_target - The target to merge into.
  * @param values - The values.
  */
-function mergeUnknownsInto(m_target, values, utils, meta
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-) {
+function mergeUnknownsInto(m_target, values, utils, meta) {
     if (values.length === 0) {
         return;
     }
diff --git a/dist/node/types/legacy/v4_0.d.ts b/dist/node/types/legacy/v4_0.d.ts
deleted file mode 100644
index 7a30a0a1..00000000
--- a/dist/node/types/legacy/v4_0.d.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-/**
- * @file
- *
- * These types are a more simplified version of this library's types
- * designed to work with versions of TypeScript < 4.1
- */
-
-declare type MetaDataUpdater = (previousMeta: any, metaMeta: any) => any;
-
-/**
- * All the options the user can pass to customize deepmerge.
- */
-declare type DeepMergeOptionsFull = Readonly<{
-  mergeRecords: DeepMergeMergeFunctions["mergeRecords"] | false;
-  mergeArrays: DeepMergeMergeFunctions["mergeArrays"] | false;
-  mergeMaps: DeepMergeMergeFunctions["mergeMaps"] | false;
-  mergeSets: DeepMergeMergeFunctions["mergeSets"] | false;
-  mergeOthers: DeepMergeMergeFunctions["mergeOthers"];
-  metaDataUpdater: MetaDataUpdater;
-}>;
-
-/**
- * All the merge functions that deepmerge uses.
- */
-declare type DeepMergeMergeFunctions = Readonly<{
-  mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<keyof any, any>>>, U extends DeepMergeMergeFunctionUtils>(records: Ts, utils: U, meta: any) => any;
-  mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<any>>, U extends DeepMergeMergeFunctionUtils>(records: Ts, utils: U, meta: any) => any;
-  mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<any, any>>>, U extends DeepMergeMergeFunctionUtils>(records: Ts, utils: U, meta: any) => any;
-  mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<any>>>, U extends DeepMergeMergeFunctionUtils>(records: Ts, utils: U, meta: any) => any;
-  mergeOthers: <Ts extends ReadonlyArray<any>, U extends DeepMergeMergeFunctionUtils>(records: Ts, utils: U, meta: any) => any;
-}>;
-
-/**
- * The utils provided to the merge functions.
- */
-declare type DeepMergeMergeFunctionUtils = Readonly<{
-  mergeFunctions: DeepMergeMergeFunctions;
-  defaultMergeFunctions: DeepMergeMergeFunctionsDefaults;
-  metaDataUpdater: MetaDataUpdater;
-  deepmerge: <Ts extends ReadonlyArray<any>>(...values: Ts) => any;
-}>;
-
-/**
- * The default merge functions.
- */
-declare type DeepMergeMergeFunctionsDefaults = Readonly<{
-  mergeMaps: (values: Record<keyof any, any>[]) => any;
-  mergeSets: (values: any[][]) => any;
-  mergeArrays: (values: Set<any>[]) => any;
-  mergeRecords: (values: Map<any, any>[], utils: DeepMergeMergeFunctionUtils, meta: any) => any;
-  mergeOthers: (values: any[]) => any;
-}>;
-
-/**
- * Deeply merge objects.
- *
- * @param objects - The objects to merge.
- */
-declare function deepmerge(): undefined;
-declare function deepmerge<T0>(arg0: T0): T0;
-declare function deepmerge<T0, T1>(arg0: T0, arg1: T1): T0 & T1;
-declare function deepmerge<T0, T1, T2>(arg0: T0, arg1: T1, arg2: T2): T0 & T1 & T2;
-declare function deepmerge<T0, T1, T2, T3>(arg0: T0, arg1: T1, arg2: T2, arg3: T3): T0 & T1 & T2 & T3;
-declare function deepmerge<T0, T1, T2, T3, T4>(arg0: T0, arg1: T1, arg2: T2, arg3: T3, arg4: T4): T0 & T1 & T2 & T3 & T4;
-declare function deepmerge<T0, T1, T2, T3, T4, T5>(arg0: T0, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): T0 & T1 & T2 & T3 & T4 & T5;
-declare function deepmerge<T0, T1, T2, T3, T4, T5, T6>(arg0: T0, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6): T0 & T1 & T2 & T3 & T4 & T5 & T6;
-declare function deepmerge<T0, T1, T2, T3, T4, T5, T6, T7>(arg0: T0, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7): T0 & T1 & T2 & T3 & T4 & T5 & T6 & T7;
-declare function deepmerge<T0, T1, T2, T3, T4, T5, T6, T7, T8>(arg0: T0, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8): T0 & T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8;
-declare function deepmerge<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(arg0: T0, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, arg7: T7, arg8: T8, arg9: T9): T0 & T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9;
-declare function deepmerge(...args: any[]): any;
-
-/**
- * Deeply merge two or more objects using the given options and meta data.
- *
- * @param options - The options on how to customize the merge function.
- * @param rootMetaData - The meta data passed to the root items' being merged.
- */
-declare function deepmergeCustom(options: Partial<DeepMergeOptionsFull>, rootMetaData?: any): (...objects: any[]) => any;
-
-export { deepmerge, deepmergeCustom };
diff --git a/dist/node/types/legacy/v4_6.d.ts b/dist/node/types/legacy/v4_6.d.ts
deleted file mode 100644
index 6738d013..00000000
--- a/dist/node/types/legacy/v4_6.d.ts
+++ /dev/null
@@ -1,407 +0,0 @@
-/**
- * Flatten a complex type such as a union or intersection of objects into a
- * single object.
- */
-declare type FlatternAlias<T> = {
-    [P in keyof T]: T[P];
-} & {};
-/**
- * Get the value of the given key in the given object.
- */
-declare type ValueOfKey<T extends Record<PropertyKey, unknown>, K extends PropertyKey> = K extends keyof T ? T[K] : never;
-/**
- * Safely test whether or not the first given types extends the second.
- *
- * Needed in particular for testing if a type is "never".
- */
-declare type Is<T1, T2> = [T1] extends [T2] ? true : false;
-/**
- * Safely test whether or not the given type is "never".
- */
-declare type IsNever<T> = Is<T, never>;
-/**
- * Returns whether or not the given type a record.
- */
-declare type IsRecord<T> = And<Not<IsNever<T>>, T extends Readonly<Record<PropertyKey, unknown>> ? true : false>;
-/**
- * Returns whether or not all the given types are records.
- */
-declare type EveryIsRecord<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [infer Head, ...infer Rest] ? IsRecord<Head> extends true ? Rest extends ReadonlyArray<unknown> ? EveryIsRecord<Rest> : true : false : true;
-/**
- * Returns whether or not the given type is an array.
- */
-declare type IsArray<T> = And<Not<IsNever<T>>, T extends ReadonlyArray<unknown> ? true : false>;
-/**
- * Returns whether or not all the given types are arrays.
- */
-declare type EveryIsArray<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [infer T1] ? IsArray<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsArray<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsArray<Rest> : false : false : false;
-/**
- * Returns whether or not the given type is an set.
- *
- * Note: This may also return true for Maps.
- */
-declare type IsSet<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlySet<unknown>> ? true : false>;
-/**
- * Returns whether or not all the given types are sets.
- *
- * Note: This may also return true if all are maps.
- */
-declare type EveryIsSet<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [infer T1]> ? IsSet<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsSet<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsSet<Rest> : false : false : false;
-/**
- * Returns whether or not the given type is an map.
- */
-declare type IsMap<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlyMap<unknown, unknown>> ? true : false>;
-/**
- * Returns whether or not all the given types are maps.
- */
-declare type EveryIsMap<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [infer T1]> ? IsMap<T1> : Ts extends readonly [infer Head, ...infer Rest] ? IsMap<Head> extends true ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? EveryIsMap<Rest> : false : false : false;
-/**
- * And operator for types.
- */
-declare type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
-/**
- * Not operator for types.
- */
-declare type Not<T extends boolean> = T extends true ? false : true;
-/**
- * Union of the sets' values' types
- */
-declare type UnionSetValues<Ts extends ReadonlyArray<unknown>> = UnionSetValuesHelper<Ts, never>;
-/**
- * Tail-recursive helper type for UnionSetValues.
- */
-declare type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlySet<infer V1>> ? Rest extends ReadonlyArray<unknown> ? UnionSetValuesHelper<Rest, Acc | V1> : Acc | V1 : never : Acc;
-/**
- * Union of the maps' values' types
- */
-declare type UnionMapKeys<Ts extends ReadonlyArray<unknown>> = UnionMapKeysHelper<Ts, never>;
-/**
- * Tail-recursive helper type for UnionMapKeys.
- */
-declare type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlyMap<infer K1, unknown>> ? Rest extends readonly [] ? Acc | K1 : UnionMapKeysHelper<Rest, Acc | K1> : never : Acc;
-/**
- * Union of the maps' keys' types
- */
-declare type UnionMapValues<Ts extends ReadonlyArray<unknown>> = UnionMapValuesHelper<Ts, never>;
-/**
- * Tail-recursive helper type for UnionMapValues.
- */
-declare type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
-/**
- * Get the keys of the type what match a certain criteria.
- */
-declare type KeysOfType<T, U> = {
-    [K in keyof T]: T[K] extends U ? K : never;
-}[keyof T];
-/**
- * Get the required keys of the type.
- */
-declare type RequiredKeys<T> = Exclude<KeysOfType<T, Exclude<T[keyof T], undefined>>, undefined>;
-/**
- * Get all the required keys on the types in the tuple.
- */
-declare type RequiredKeysOf<Ts extends readonly [unknown, ...ReadonlyArray<unknown>]> = RequiredKeysOfHelper<Ts, never>;
-/**
- * Tail-recursive helper type for RequiredKeysOf.
- */
-declare type RequiredKeysOfHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Record<PropertyKey, unknown> ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? RequiredKeysOfHelper<Rest, Acc | RequiredKeys<Head>> : Acc | RequiredKeys<Head> : never : Acc;
-/**
- * Get the optional keys of the type.
- */
-declare type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
-/**
- * Get all the optional keys on the types in the tuple.
- */
-declare type OptionalKeysOf<Ts extends readonly [unknown, ...ReadonlyArray<unknown>]> = OptionalKeysOfHelper<Ts, never>;
-/**
- * Tail-recursive helper type for OptionalKeysOf.
- */
-declare type OptionalKeysOfHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], Acc> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Record<PropertyKey, unknown> ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? OptionalKeysOfHelper<Rest, Acc | OptionalKeys<Head>> : Acc | OptionalKeys<Head> : never : Acc;
-/**
- * Filter out nevers from a tuple.
- */
-declare type FilterOutNever<T extends ReadonlyArray<unknown>> = FilterOutNeverHelper<T, []>;
-/**
- * Tail-recursive helper type for FilterOutNever.
- */
-declare type FilterOutNeverHelper<T extends ReadonlyArray<unknown>, Acc extends ReadonlyArray<unknown>> = T extends readonly [] ? Acc : T extends readonly [infer Head, ...infer Rest] ? IsNever<Head> extends true ? FilterOutNeverHelper<Rest, Acc> : FilterOutNeverHelper<Rest, [...Acc, Head]> : T;
-/**
- * Is the type a tuple?
- */
-declare type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [] ? true : T extends readonly [unknown, ...ReadonlyArray<unknown>] ? true : false;
-
-/**
- * Mapping of merge function URIs to the merge function type.
- */
-interface DeepMergeMergeFunctionURItoKind<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> {
-    readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
-    readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-    readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, MF, M>;
-    readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT<Ts>;
-    readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT<Ts>;
-}
-/**
- * Get the type of the given merge function via its URI.
- */
-declare type DeepMergeMergeFunctionKind<URI extends DeepMergeMergeFunctionURIs, Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionURItoKind<Ts, MF, M>[URI];
-/**
- * A union of all valid merge function URIs.
- */
-declare type DeepMergeMergeFunctionURIs = keyof DeepMergeMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeMergeFunctionsURIs, unknown>;
-/**
- * The merge functions to use when deep merging.
- */
-declare type DeepMergeMergeFunctionsURIs = Readonly<{
-    /**
-     * The merge function to merge records with.
-     */
-    DeepMergeRecordsURI: DeepMergeMergeFunctionURIs;
-    /**
-     * The merge function to merge arrays with.
-     */
-    DeepMergeArraysURI: DeepMergeMergeFunctionURIs;
-    /**
-     * The merge function to merge sets with.
-     */
-    DeepMergeSetsURI: DeepMergeMergeFunctionURIs;
-    /**
-     * The merge function to merge maps with.
-     */
-    DeepMergeMapsURI: DeepMergeMergeFunctionURIs;
-    /**
-     * The merge function to merge other things with.
-     */
-    DeepMergeOthersURI: DeepMergeMergeFunctionURIs;
-}>;
-/**
- * Deep merge types.
- */
-declare type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [] ? undefined : Ts extends readonly [infer T1] ? T1 : EveryIsArray<Ts> extends true ? DeepMergeArraysHKT<Ts, MF, M> : EveryIsMap<Ts> extends true ? DeepMergeMapsHKT<Ts, MF, M> : EveryIsSet<Ts> extends true ? DeepMergeSetsHKT<Ts, MF, M> : EveryIsRecord<Ts> extends true ? DeepMergeRecordsHKT<Ts, MF, M> : DeepMergeOthersHKT<Ts, MF, M> : unknown;
-/**
- * Deep merge records.
- */
-declare type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
-/**
- * Deep merge arrays.
- */
-declare type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
-/**
- * Deep merge sets.
- */
-declare type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
-/**
- * Deep merge maps.
- */
-declare type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
-/**
- * Deep merge other things.
- */
-declare type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
-/**
- * The merge function that returns a leaf.
- */
-declare type DeepMergeLeafURI = "DeepMergeLeafURI";
-/**
- * Get the leaf type from many types that can't be merged.
- *
- * @deprecated Use `DeepMergeLeaf` instead.
- */
-declare type DeepMergeLeafHKT<Ts extends ReadonlyArray<unknown>> = DeepMergeLeaf<Ts>;
-/**
- * Get the leaf type from many types that can't be merged.
- */
-declare type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [] ? never : Ts extends readonly [infer T] ? T : Ts extends readonly [...infer Rest, infer Tail] ? IsNever<Tail> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest> : never : Tail : never;
-/**
- * The meta data deepmerge is able to provide.
- */
-declare type DeepMergeBuiltInMetaData = Readonly<{
-    key: PropertyKey;
-    parents: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>;
-}>;
-
-/**
- * The default merge function to merge records with.
- */
-declare type DeepMergeRecordsDefaultURI = "DeepMergeRecordsDefaultURI";
-/**
- * The default merge function to merge arrays with.
- */
-declare type DeepMergeArraysDefaultURI = "DeepMergeArraysDefaultURI";
-/**
- * The default merge function to merge sets with.
- */
-declare type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI";
-/**
- * The default merge function to merge maps with.
- */
-declare type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI";
-/**
- * The default merge functions to use when deep merging.
- */
-declare type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
-    DeepMergeRecordsURI: DeepMergeRecordsDefaultURI;
-    DeepMergeArraysURI: DeepMergeArraysDefaultURI;
-    DeepMergeSetsURI: DeepMergeSetsDefaultURI;
-    DeepMergeMapsURI: DeepMergeMapsDefaultURI;
-    DeepMergeOthersURI: DeepMergeLeafURI;
-}>;
-/**
- * A union of all the props that should not be included in type information for
- * merged records.
- */
-declare type BlacklistedRecordProps = "__proto__";
-/**
- * Deep merge records.
- */
-declare type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends Readonly<readonly [unknown, ...Readonly<ReadonlyArray<unknown>>]> ? FlatternAlias<Omit<DeepMergeRecordsDefaultHKTInternalProps<Ts, MF, M>, BlacklistedRecordProps>> : {};
-/**
- * Deep merge record props.
- */
-declare type DeepMergeRecordsDefaultHKTInternalProps<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], MF extends DeepMergeMergeFunctionsURIs, M> = {
-    [K in OptionalKeysOf<Ts>]?: DeepMergeHKT<DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>, MF, M>;
-} & {
-    [K in RequiredKeysOf<Ts>]: DeepMergeHKT<DeepMergeRecordsDefaultHKTInternalPropValue<Ts, K, M>, MF, M>;
-};
-/**
- * Get the value of the property.
- */
-declare type DeepMergeRecordsDefaultHKTInternalPropValue<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], K extends PropertyKey, M> = FilterOutNever<DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts, K, M, readonly []>>;
-/**
- * Tail-recursive helper type for DeepMergeRecordsDefaultHKTInternalPropValue.
- */
-declare type DeepMergeRecordsDefaultHKTInternalPropValueHelper<Ts extends readonly [unknown, ...ReadonlyArray<unknown>], K extends PropertyKey, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends Readonly<Record<PropertyKey, unknown>> ? Rest extends readonly [unknown, ...ReadonlyArray<unknown>] ? DeepMergeRecordsDefaultHKTInternalPropValueHelper<Rest, K, M, [
-    ...Acc,
-    ValueOfKey<Head, K>
-]> : [...Acc, ValueOfKey<Head, K>] : never : never;
-/**
- * Deep merge 2 arrays.
- */
-declare type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
-/**
- * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
- */
-declare type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [infer Head, ...infer Rest] ? Head extends ReadonlyArray<unknown> ? Rest extends readonly [
-    ReadonlyArray<unknown>,
-    ...ReadonlyArray<ReadonlyArray<unknown>>
-] ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [...Acc, ...Head]> : [...Acc, ...Head] : never : never;
-/**
- * Deep merge 2 sets.
- */
-declare type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<UnionSetValues<Ts>>;
-/**
- * Deep merge 2 maps.
- */
-declare type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<UnionMapKeys<Ts>, UnionMapValues<Ts>>;
-/**
- * Get the merge functions with defaults apply from the given subset.
- */
-declare type GetDeepMergeMergeFunctionsURIs<PMF extends Partial<DeepMergeMergeFunctionsURIs>> = Readonly<{
-    DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
-    DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
-    DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
-    DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
-    DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
-}>;
-
-/**
- * The options the user can pass to customize deepmerge.
- */
-declare type DeepMergeOptions<M, MM extends Readonly<Record<PropertyKey, unknown>> = DeepMergeBuiltInMetaData> = Partial<DeepMergeOptionsFull<M, MM & DeepMergeBuiltInMetaData>>;
-declare type MetaDataUpdater<M, MM extends DeepMergeBuiltInMetaData> = (previousMeta: M | undefined, metaMeta: Readonly<Partial<MM>>) => M;
-/**
- * All the options the user can pass to customize deepmerge.
- */
-declare type DeepMergeOptionsFull<M, MM extends DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: DeepMergeMergeFunctions<M, MM>["mergeRecords"] | false;
-    mergeArrays: DeepMergeMergeFunctions<M, MM>["mergeArrays"] | false;
-    mergeMaps: DeepMergeMergeFunctions<M, MM>["mergeMaps"] | false;
-    mergeSets: DeepMergeMergeFunctions<M, MM>["mergeSets"] | false;
-    mergeOthers: DeepMergeMergeFunctions<M, MM>["mergeOthers"];
-    metaDataUpdater: MetaDataUpdater<M, MM>;
-    enableImplicitDefaultMerging: boolean;
-}>;
-/**
- * All the merge functions that deepmerge uses.
- */
-declare type DeepMergeMergeFunctions<M, MM extends DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(records: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(records: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(records: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(records: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeMergeFunctionUtils<M, MM>>(records: Ts, utils: U, meta: M | undefined) => unknown;
-}>;
-/**
- * The utils provided to the merge functions.
- */
-declare type DeepMergeMergeFunctionUtils<M, MM extends DeepMergeBuiltInMetaData> = Readonly<{
-    mergeFunctions: DeepMergeMergeFunctions<M, MM>;
-    defaultMergeFunctions: DeepMergeMergeFunctionsDefaults;
-    metaDataUpdater: MetaDataUpdater<M, MM>;
-    deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
-    useImplicitDefaultMerging: boolean;
-    actions: Readonly<{
-        defaultMerge: symbol;
-        skip: symbol;
-    }>;
-}>;
-
-declare const defaultMergeFunctions: {
-    readonly mergeMaps: typeof defaultMergeMaps;
-    readonly mergeSets: typeof defaultMergeSets;
-    readonly mergeArrays: typeof defaultMergeArrays;
-    readonly mergeRecords: typeof defaultMergeRecords;
-    readonly mergeOthers: typeof leaf;
-};
-/**
- * The default merge functions.
- */
-declare type DeepMergeMergeFunctionsDefaults = typeof defaultMergeFunctions;
-/**
- * Deeply merge objects.
- *
- * @param objects - The objects to merge.
- */
-declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [...Ts]): DeepMergeHKT<Ts, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
-/**
- * Deeply merge two or more objects using the given options.
- *
- * @param options - The options on how to customize the merge function.
- */
-declare function deepmergeCustom<PMF extends Partial<DeepMergeMergeFunctionsURIs>>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
-/**
- * Deeply merge two or more objects using the given options and meta data.
- *
- * @param options - The options on how to customize the merge function.
- * @param rootMetaData - The meta data passed to the root items' being merged.
- */
-declare function deepmergeCustom<PMF extends Partial<DeepMergeMergeFunctionsURIs>, MetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
-/**
- * The default strategy to merge records.
- *
- * @param values - The records.
- */
-declare function defaultMergeRecords<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeMergeFunctionUtils<M, MM>, MF extends DeepMergeMergeFunctionsURIs, M, MM extends DeepMergeBuiltInMetaData>(values: Ts, utils: U, meta: M | undefined): DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-/**
- * The default strategy to merge arrays.
- *
- * @param values - The arrays.
- */
-declare function defaultMergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>, MF extends DeepMergeMergeFunctionsURIs, M>(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M>;
-/**
- * The default strategy to merge sets.
- *
- * @param values - The sets.
- */
-declare function defaultMergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(values: Ts): DeepMergeSetsDefaultHKT<Ts>;
-/**
- * The default strategy to merge maps.
- *
- * @param values - The maps.
- */
-declare function defaultMergeMaps<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(values: Ts): DeepMergeMapsDefaultHKT<Ts>;
-/**
- * Get the last value in the given array.
- */
-declare function leaf<Ts extends ReadonlyArray<unknown>>(values: Ts): unknown;
-
-export { DeepMergeArraysDefaultHKT, DeepMergeBuiltInMetaData, DeepMergeHKT, DeepMergeLeaf, DeepMergeLeafHKT, DeepMergeLeafURI, DeepMergeMapsDefaultHKT, DeepMergeMergeFunctionURItoKind, DeepMergeMergeFunctionUtils, DeepMergeMergeFunctionsDefaultURIs, DeepMergeMergeFunctionsDefaults, DeepMergeMergeFunctionsURIs, DeepMergeOptions, DeepMergeRecordsDefaultHKT, DeepMergeSetsDefaultHKT, deepmerge, deepmergeCustom };