diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ffe64be..e5c18240 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,26 @@
 # Changelog
 All notable changes to this project will be documented in this file. Dates are displayed in UTC.
 
+# [7.0.0](https://github.com/RebeccaStevens/deepmerge-ts/compare/v6.0.3...v7.0.0) (2024-05-20)
+
+
+### Code Refactoring
+
+* rename DeepMergeFunctionUtils to DeepMergeUtils ([e821255](https://github.com/RebeccaStevens/deepmerge-ts/commit/e821255380dd9307041e6749c43d363e4e2ae633))
+* rename DeepMergeMerge* to DeepMerge* ([fd4d2d4](https://github.com/RebeccaStevens/deepmerge-ts/commit/fd4d2d462eec14841adc45d741148cc7a9449a1f))
+
+
+### Features
+
+* allow filtering out values before merging them ([0784f63](https://github.com/RebeccaStevens/deepmerge-ts/commit/0784f63befc4ab4d66b6f3ae4b2076fba203fb48)), closes [#460](https://github.com/RebeccaStevens/deepmerge-ts/issues/460)
+
+
+### BREAKING CHANGES
+
+* rename DeepMergeFunctionUtils to DeepMergeUtils
+* rename DeepMergeMerge* to DeepMerge*
+* allow filtering out values before merging them
+
 ## [6.0.3](https://github.com/RebeccaStevens/deepmerge-ts/compare/v6.0.2...v6.0.3) (2024-05-20)
 
 
diff --git a/dist/deno/deepmerge-into.ts b/dist/deno/deepmerge-into.ts
index bfd119cc..b822bf90 100644
--- a/dist/deno/deepmerge-into.ts
+++ b/dist/deno/deepmerge-into.ts
@@ -1,12 +1,15 @@
 import { actionsInto as actions } from "./actions.ts";
+import {
+  defaultFilterValues,
+  defaultMetaDataUpdater,
+} from "./defaults/general.ts";
 import * as defaultMergeIntoFunctions from "./defaults/into.ts";
-import { defaultMetaDataUpdater } from "./defaults/meta-data-updater.ts";
 import {
   type DeepMergeBuiltInMetaData,
+  type DeepMergeFunctionsDefaultURIs,
   type DeepMergeHKT,
+  type DeepMergeIntoFunctionUtils,
   type DeepMergeIntoOptions,
-  type DeepMergeMergeFunctionsDefaultURIs,
-  type DeepMergeMergeIntoFunctionUtils,
   type Reference,
 } from "./types/index.ts";
 import { type SimplifyObject } from "./types/utils.ts";
@@ -39,7 +42,7 @@ export function deepmergeInto<
   Target &
     DeepMergeHKT<
       [Target, ...Ts],
-      DeepMergeMergeFunctionsDefaultURIs,
+      DeepMergeFunctionsDefaultURIs,
       DeepMergeBuiltInMetaData
     >
 >;
@@ -54,7 +57,7 @@ export function deepmergeInto<
   Target &
     DeepMergeHKT<
       [Target, ...Ts],
-      DeepMergeMergeFunctionsDefaultURIs,
+      DeepMergeFunctionsDefaultURIs,
       DeepMergeBuiltInMetaData
     >
 > {
@@ -116,7 +119,7 @@ export function deepmergeIntoCustom<
     ...objects: Ts
   ) => void;
 
-  const utils: DeepMergeMergeIntoFunctionUtils<MetaData, MetaMetaData> =
+  const utils: DeepMergeIntoFunctionUtils<MetaData, MetaMetaData> =
     getIntoUtils(options, customizedDeepmergeInto as CustomizedDeepmergeInto);
 
   /**
@@ -147,11 +150,8 @@ function getIntoUtils<
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeIntoOptions<M, MM>,
-  customizedDeepmergeInto: DeepMergeMergeIntoFunctionUtils<
-    M,
-    MM
-  >["deepmergeInto"],
-): DeepMergeMergeIntoFunctionUtils<M, MM> {
+  customizedDeepmergeInto: DeepMergeIntoFunctionUtils<M, MM>["deepmergeInto"],
+): DeepMergeIntoFunctionUtils<M, MM> {
   return {
     defaultMergeFunctions: defaultMergeIntoFunctions,
     mergeFunctions: {
@@ -167,13 +167,17 @@ function getIntoUtils<
               : [key, option],
           ),
       ),
-    } as DeepMergeMergeIntoFunctionUtils<M, MM>["mergeFunctions"],
+    } as DeepMergeIntoFunctionUtils<M, MM>["mergeFunctions"],
     metaDataUpdater: (options.metaDataUpdater ??
-      defaultMetaDataUpdater) as unknown as DeepMergeMergeIntoFunctionUtils<
+      defaultMetaDataUpdater) as unknown as DeepMergeIntoFunctionUtils<
       M,
       MM
     >["metaDataUpdater"],
     deepmergeInto: customizedDeepmergeInto,
+    filterValues:
+      options.filterValues === false
+        ? undefined
+        : options.filterValues ?? defaultFilterValues,
     actions,
   };
 }
@@ -186,7 +190,7 @@ function getIntoUtils<
  */
 export function mergeUnknownsInto<
   Ts extends ReadonlyArray<unknown>,
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -196,22 +200,34 @@ export function mergeUnknownsInto<
   meta: M | undefined,
   // eslint-disable-next-line ts/no-invalid-void-type
 ): void | symbol {
-  if (values.length === 0) {
+  const filteredValues = utils.filterValues?.(values, meta) ?? values;
+
+  if (filteredValues.length === 0) {
     return;
   }
-  if (values.length === 1) {
-    return void mergeOthersInto<U, M, MM>(m_target, values, utils, meta);
+  if (filteredValues.length === 1) {
+    return void mergeOthersInto<U, M, MM>(
+      m_target,
+      filteredValues,
+      utils,
+      meta,
+    );
   }
 
   const type = getObjectType(m_target.value);
 
   if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
-    for (let m_index = 1; m_index < values.length; m_index++) {
-      if (getObjectType(values[m_index]) === type) {
+    for (let m_index = 1; m_index < filteredValues.length; m_index++) {
+      if (getObjectType(filteredValues[m_index]) === type) {
         continue;
       }
 
-      return void mergeOthersInto<U, M, MM>(m_target, values, utils, meta);
+      return void mergeOthersInto<U, M, MM>(
+        m_target,
+        filteredValues,
+        utils,
+        meta,
+      );
     }
   }
 
@@ -219,7 +235,7 @@ export function mergeUnknownsInto<
     case ObjectType.RECORD: {
       return void mergeRecordsInto<U, M, MM>(
         m_target as Reference<Record<PropertyKey, unknown>>,
-        values as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
+        filteredValues as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
         utils,
         meta,
       );
@@ -228,7 +244,7 @@ export function mergeUnknownsInto<
     case ObjectType.ARRAY: {
       return void mergeArraysInto<U, M, MM>(
         m_target as Reference<unknown[]>,
-        values as ReadonlyArray<ReadonlyArray<unknown>>,
+        filteredValues as ReadonlyArray<ReadonlyArray<unknown>>,
         utils,
         meta,
       );
@@ -237,7 +253,7 @@ export function mergeUnknownsInto<
     case ObjectType.SET: {
       return void mergeSetsInto<U, M, MM>(
         m_target as Reference<Set<unknown>>,
-        values as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
+        filteredValues as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
         utils,
         meta,
       );
@@ -246,14 +262,21 @@ export function mergeUnknownsInto<
     case ObjectType.MAP: {
       return void mergeMapsInto<U, M, MM>(
         m_target as Reference<Map<unknown, unknown>>,
-        values as ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
+        filteredValues as ReadonlyArray<
+          Readonly<ReadonlyMap<unknown, unknown>>
+        >,
         utils,
         meta,
       );
     }
 
     default: {
-      return void mergeOthersInto<U, M, MM>(m_target, values, utils, meta);
+      return void mergeOthersInto<U, M, MM>(
+        m_target,
+        filteredValues,
+        utils,
+        meta,
+      );
     }
   }
 }
@@ -265,7 +288,7 @@ export function mergeUnknownsInto<
  * @param values - The records.
  */
 function mergeRecordsInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -298,7 +321,7 @@ function mergeRecordsInto<
  * @param values - The arrays.
  */
 function mergeArraysInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -326,7 +349,7 @@ function mergeArraysInto<
  * @param values - The sets.
  */
 function mergeSetsInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -349,7 +372,7 @@ function mergeSetsInto<
  * @param values - The maps.
  */
 function mergeMapsInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -372,7 +395,7 @@ function mergeMapsInto<
  * @param values - The other things.
  */
 function mergeOthersInto<
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
diff --git a/dist/deno/deepmerge.ts b/dist/deno/deepmerge.ts
index ceeff141..f4d39983 100644
--- a/dist/deno/deepmerge.ts
+++ b/dist/deno/deepmerge.ts
@@ -1,14 +1,17 @@
 import { actions } from "./actions.ts";
-import { defaultMetaDataUpdater } from "./defaults/meta-data-updater.ts";
+import {
+  defaultFilterValues,
+  defaultMetaDataUpdater,
+} from "./defaults/general.ts";
 import * as defaultMergeFunctions from "./defaults/vanilla.ts";
 import {
   type DeepMergeBuiltInMetaData,
+  type DeepMergeFunctionsDefaultURIs,
+  type DeepMergeFunctionsURIs,
   type DeepMergeHKT,
-  type DeepMergeMergeFunctionUtils,
-  type DeepMergeMergeFunctionsDefaultURIs,
-  type DeepMergeMergeFunctionsURIs,
   type DeepMergeOptions,
-  type GetDeepMergeMergeFunctionsURIs,
+  type DeepMergeUtils,
+  type GetDeepMergeFunctionsURIs,
 } from "./types/index.ts";
 import { ObjectType, getObjectType } from "./utils.ts";
 
@@ -19,14 +22,10 @@ import { ObjectType, getObjectType } from "./utils.ts";
  */
 export function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(
   ...objects: readonly [...Ts]
-): DeepMergeHKT<
-  Ts,
-  DeepMergeMergeFunctionsDefaultURIs,
-  DeepMergeBuiltInMetaData
-> {
+): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData> {
   return deepmergeCustom({})(...objects) as DeepMergeHKT<
     Ts,
-    DeepMergeMergeFunctionsDefaultURIs,
+    DeepMergeFunctionsDefaultURIs,
     DeepMergeBuiltInMetaData
   >;
 }
@@ -38,16 +37,12 @@ export function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(
  */
 export function deepmergeCustom<
   BaseTs = unknown,
-  PMF extends Partial<DeepMergeMergeFunctionsURIs> = {},
+  PMF extends Partial<DeepMergeFunctionsURIs> = {},
 >(
   options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>,
 ): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
-) => DeepMergeHKT<
-  Ts,
-  GetDeepMergeMergeFunctionsURIs<PMF>,
-  DeepMergeBuiltInMetaData
->;
+) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
 
 /**
  * Deeply merge two or more objects using the given options and meta data.
@@ -57,7 +52,7 @@ export function deepmergeCustom<
  */
 export function deepmergeCustom<
   BaseTs = unknown,
-  PMF extends Partial<DeepMergeMergeFunctionsURIs> = {},
+  PMF extends Partial<DeepMergeFunctionsURIs> = {},
   MetaData = DeepMergeBuiltInMetaData,
   MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -65,11 +60,11 @@ export function deepmergeCustom<
   rootMetaData?: MetaData,
 ): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
-) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
+) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
 
 export function deepmergeCustom<
   BaseTs,
-  PMF extends Partial<DeepMergeMergeFunctionsURIs>,
+  PMF extends Partial<DeepMergeFunctionsURIs>,
   MetaData,
   MetaMetaData extends DeepMergeBuiltInMetaData,
 >(
@@ -77,15 +72,15 @@ export function deepmergeCustom<
   rootMetaData?: MetaData,
 ): <Ts extends ReadonlyArray<BaseTs>>(
   ...objects: Ts
-) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData> {
+) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData> {
   /**
    * The type of the customized deepmerge function.
    */
   type CustomizedDeepmerge = <Ts extends ReadonlyArray<unknown>>(
     ...objects: Ts
-  ) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, MetaData>;
+  ) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
 
-  const utils: DeepMergeMergeFunctionUtils<MetaData, MetaMetaData> = getUtils(
+  const utils: DeepMergeUtils<MetaData, MetaMetaData> = getUtils(
     options,
     customizedDeepmerge as CustomizedDeepmerge,
   );
@@ -97,7 +92,7 @@ export function deepmergeCustom<
     return mergeUnknowns<
       ReadonlyArray<unknown>,
       typeof utils,
-      GetDeepMergeMergeFunctionsURIs<PMF>,
+      GetDeepMergeFunctionsURIs<PMF>,
       MetaData,
       MetaMetaData
     >(objects, utils, rootMetaData);
@@ -116,8 +111,8 @@ function getUtils<
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   options: DeepMergeOptions<M, MM>,
-  customizedDeepmerge: DeepMergeMergeFunctionUtils<M, MM>["deepmerge"],
-): DeepMergeMergeFunctionUtils<M, MM> {
+  customizedDeepmerge: DeepMergeUtils<M, MM>["deepmerge"],
+): DeepMergeUtils<M, MM> {
   return {
     defaultMergeFunctions,
     mergeFunctions: {
@@ -131,14 +126,18 @@ function getUtils<
               : [key, option],
           ),
       ),
-    } as DeepMergeMergeFunctionUtils<M, MM>["mergeFunctions"],
+    } as DeepMergeUtils<M, MM>["mergeFunctions"],
     metaDataUpdater: (options.metaDataUpdater ??
-      defaultMetaDataUpdater) as unknown as DeepMergeMergeFunctionUtils<
+      defaultMetaDataUpdater) as unknown as DeepMergeUtils<
       M,
       MM
     >["metaDataUpdater"],
     deepmerge: customizedDeepmerge,
     useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,
+    filterValues:
+      options.filterValues === false
+        ? undefined
+        : options.filterValues ?? defaultFilterValues,
     actions,
   };
 }
@@ -150,33 +149,35 @@ function getUtils<
  */
 export function mergeUnknowns<
   Ts extends ReadonlyArray<unknown>,
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  U extends DeepMergeUtils<M, MM>,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   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>;
+>(values: Ts, utils: U, meta: M | undefined): DeepMergeHKT<Ts, Fs, M> {
+  const filteredValues = utils.filterValues?.(values, meta) ?? values;
+
+  if (filteredValues.length === 0) {
+    return undefined as DeepMergeHKT<Ts, Fs, M>;
   }
-  if (values.length === 1) {
-    return mergeOthers<U, M, MM>(values, utils, meta) as DeepMergeHKT<
+  if (filteredValues.length === 1) {
+    return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
       Ts,
-      MF,
+      Fs,
       M
     >;
   }
 
-  const type = getObjectType(values[0]);
+  const type = getObjectType(filteredValues[0]);
 
   if (type !== ObjectType.NOT && type !== ObjectType.OTHER) {
-    for (let m_index = 1; m_index < values.length; m_index++) {
-      if (getObjectType(values[m_index]) === type) {
+    for (let m_index = 1; m_index < filteredValues.length; m_index++) {
+      if (getObjectType(filteredValues[m_index]) === type) {
         continue;
       }
 
-      return mergeOthers<U, M, MM>(values, utils, meta) as DeepMergeHKT<
+      return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
         Ts,
-        MF,
+        Fs,
         M
       >;
     }
@@ -184,41 +185,43 @@ export function mergeUnknowns<
 
   switch (type) {
     case ObjectType.RECORD: {
-      return mergeRecords<U, MF, M, MM>(
-        values as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
+      return mergeRecords<U, Fs, M, MM>(
+        filteredValues as ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.ARRAY: {
       return mergeArrays<U, M, MM>(
-        values as ReadonlyArray<Readonly<ReadonlyArray<unknown>>>,
+        filteredValues as ReadonlyArray<Readonly<ReadonlyArray<unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.SET: {
       return mergeSets<U, M, MM>(
-        values as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
+        filteredValues as ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     case ObjectType.MAP: {
       return mergeMaps<U, M, MM>(
-        values as ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
+        filteredValues as ReadonlyArray<
+          Readonly<ReadonlyMap<unknown, unknown>>
+        >,
         utils,
         meta,
-      ) as DeepMergeHKT<Ts, MF, M>;
+      ) as DeepMergeHKT<Ts, Fs, M>;
     }
 
     default: {
-      return mergeOthers<U, M, MM>(values, utils, meta) as DeepMergeHKT<
+      return mergeOthers<U, M, MM>(filteredValues, utils, meta) as DeepMergeHKT<
         Ts,
-        MF,
+        Fs,
         M
       >;
     }
@@ -231,8 +234,8 @@ export function mergeUnknowns<
  * @param values - The records.
  */
 function mergeRecords<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  U extends DeepMergeUtils<M, MM>,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -252,7 +255,7 @@ function mergeRecords<
     return utils.defaultMergeFunctions.mergeRecords<
       ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
       U,
-      MF,
+      Fs,
       M,
       MM
     >(values, utils, meta);
@@ -267,7 +270,7 @@ function mergeRecords<
  * @param values - The arrays.
  */
 function mergeArrays<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -295,7 +298,7 @@ function mergeArrays<
  * @param values - The sets.
  */
 function mergeSets<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -322,7 +325,7 @@ function mergeSets<
  * @param values - The maps.
  */
 function mergeMaps<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -349,7 +352,7 @@ function mergeMaps<
  * @param values - The other things.
  */
 function mergeOthers<
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
+  U extends DeepMergeUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(values: ReadonlyArray<unknown>, utils: U, meta: M | undefined) {
diff --git a/dist/deno/defaults/general.ts b/dist/deno/defaults/general.ts
new file mode 100644
index 00000000..a9f44722
--- /dev/null
+++ b/dist/deno/defaults/general.ts
@@ -0,0 +1,25 @@
+import { type DeepMergeBuiltInMetaData } from "../types/index.ts";
+
+/**
+ * The default function to update meta data.
+ *
+ * It doesn't update the meta data.
+ */
+export function defaultMetaDataUpdater<M>(
+  previousMeta: M,
+  metaMeta: DeepMergeBuiltInMetaData,
+): DeepMergeBuiltInMetaData {
+  return metaMeta;
+}
+
+/**
+ * The default function to filter values.
+ *
+ * It filters out undefined values.
+ */
+export function defaultFilterValues<Ts extends ReadonlyArray<unknown>, M>(
+  values: Ts,
+  meta: M | undefined,
+): unknown[] {
+  return values.filter((value) => value !== undefined);
+}
diff --git a/dist/deno/defaults/into.ts b/dist/deno/defaults/into.ts
index b32fd976..65ae1a9a 100644
--- a/dist/deno/defaults/into.ts
+++ b/dist/deno/defaults/into.ts
@@ -1,7 +1,7 @@
 import { mergeUnknownsInto } from "../deepmerge-into.ts";
 import {
   type DeepMergeBuiltInMetaData,
-  type DeepMergeMergeIntoFunctionUtils,
+  type DeepMergeIntoFunctionUtils,
   type Reference,
 } from "../types/index.ts";
 import { getIterableOfIterables, getKeys, objectHasProperty } from "../utils.ts";
@@ -25,7 +25,7 @@ export type MergeFunctions = {
  */
 export function mergeRecords<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
-  U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+  U extends DeepMergeIntoFunctionUtils<M, MM>,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
@@ -121,11 +121,5 @@ export function mergeOthers<Ts extends ReadonlyArray<unknown>>(
   m_target: Reference<unknown>,
   values: Ts,
 ) {
-  for (let i = values.length - 1; i >= 0; i--) {
-    if (values[i] !== undefined) {
-      m_target.value = values[i];
-      return;
-    }
-  }
-  m_target.value = undefined;
+  m_target.value = values.at(-1);
 }
diff --git a/dist/deno/defaults/meta-data-updater.ts b/dist/deno/defaults/meta-data-updater.ts
deleted file mode 100644
index 1b9432c3..00000000
--- a/dist/deno/defaults/meta-data-updater.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { type DeepMergeBuiltInMetaData } from "../types/index.ts";
-
-/**
- * The default function to update meta data.
- */
-export function defaultMetaDataUpdater<M>(
-  previousMeta: M,
-  metaMeta: DeepMergeBuiltInMetaData,
-): DeepMergeBuiltInMetaData {
-  return metaMeta;
-}
diff --git a/dist/deno/defaults/vanilla.ts b/dist/deno/defaults/vanilla.ts
index decd60cd..a3bd2d60 100644
--- a/dist/deno/defaults/vanilla.ts
+++ b/dist/deno/defaults/vanilla.ts
@@ -3,11 +3,11 @@ import { mergeUnknowns } from "../deepmerge.ts";
 import {
   type DeepMergeArraysDefaultHKT,
   type DeepMergeBuiltInMetaData,
+  type DeepMergeFunctionsURIs,
   type DeepMergeMapsDefaultHKT,
-  type DeepMergeMergeFunctionUtils,
-  type DeepMergeMergeFunctionsURIs,
   type DeepMergeRecordsDefaultHKT,
   type DeepMergeSetsDefaultHKT,
+  type DeepMergeUtils,
 } from "../types/index.ts";
 import { getIterableOfIterables, getKeys, objectHasProperty } from "../utils.ts";
 
@@ -29,15 +29,15 @@ export type MergeFunctions = {
  */
 export function mergeRecords<
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>,
-  U extends DeepMergeMergeFunctionUtils<M, MM>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  U extends DeepMergeUtils<M, MM>,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 >(
   values: Ts,
   utils: U,
   meta: M | undefined,
-): DeepMergeRecordsDefaultHKT<Ts, MF, M> {
+): DeepMergeRecordsDefaultHKT<Ts, Fs, M> {
   const result: Record<PropertyKey, unknown> = {};
 
   for (const key of getKeys(values)) {
@@ -58,7 +58,7 @@ export function mergeRecords<
       parents: values,
     } as unknown as MM);
 
-    const propertyResult = mergeUnknowns<ReadonlyArray<unknown>, U, MF, M, MM>(
+    const propertyResult = mergeUnknowns<ReadonlyArray<unknown>, U, Fs, M, MM>(
       propValues,
       utils,
       updatedMeta,
@@ -80,7 +80,7 @@ export function mergeRecords<
     }
   }
 
-  return result as DeepMergeRecordsDefaultHKT<Ts, MF, M>;
+  return result as DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
 }
 
 /**
@@ -90,10 +90,10 @@ export function mergeRecords<
  */
 export function mergeArrays<
   Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
->(values: Ts): DeepMergeArraysDefaultHKT<Ts, MF, M> {
-  return values.flat() as DeepMergeArraysDefaultHKT<Ts, MF, M>;
+>(values: Ts): DeepMergeArraysDefaultHKT<Ts, Fs, M> {
+  return values.flat() as DeepMergeArraysDefaultHKT<Ts, Fs, M>;
 }
 
 /**
@@ -122,10 +122,5 @@ export function mergeMaps<
  * Get the last non-undefined value in the given array.
  */
 export function mergeOthers<Ts extends ReadonlyArray<unknown>>(values: Ts) {
-  for (let i = values.length - 1; i >= 0; i--) {
-    if (values[i] !== undefined) {
-      return values[i];
-    }
-  }
-  return undefined;
+  return values.at(-1);
 }
diff --git a/dist/deno/index.ts b/dist/deno/index.ts
index cd408d1a..60bf4c05 100644
--- a/dist/deno/index.ts
+++ b/dist/deno/index.ts
@@ -7,24 +7,26 @@ export {
   objectHasProperty,
 } from "./utils.ts";
 
-export type { MergeFunctions as DeepMergeMergeIntoFunctionsDefaults } from "./defaults/into.ts";
-export type { MergeFunctions as DeepMergeMergeFunctionsDefaults } from "./defaults/vanilla.ts";
+export type { MergeFunctions as DeepMergeIntoFunctionsDefaults } from "./defaults/into.ts";
+export type { MergeFunctions as DeepMergeFunctionsDefaults } from "./defaults/vanilla.ts";
 export type {
   DeepMergeArraysDefaultHKT,
   DeepMergeBuiltInMetaData,
   DeepMergeHKT,
   DeepMergeLeaf,
   DeepMergeLeafURI,
+  DeepMergeNoFilteringURI,
   DeepMergeMapsDefaultHKT,
-  DeepMergeMergeFunctionsDefaultURIs,
-  DeepMergeMergeFunctionsURIs,
-  DeepMergeMergeFunctionURItoKind,
-  DeepMergeMergeFunctionUtils,
-  DeepMergeMergeIntoFunctionUtils,
+  DeepMergeFunctionsDefaultURIs,
+  DeepMergeFunctionsURIs,
+  DeepMergeFunctionURItoKind,
+  DeepMergeUtils,
+  DeepMergeIntoFunctionUtils,
   DeepMergeOptions,
   DeepMergeIntoOptions,
   DeepMergeRecordsDefaultHKT,
   DeepMergeSetsDefaultHKT,
   Reference as DeepMergeValueReference,
-  GetDeepMergeMergeFunctionsURIs,
+  GetDeepMergeFunctionsURIs,
 } from "./types/index.ts";
+export type { FilterOut } from "./types/utils.ts";
diff --git a/dist/deno/types/defaults.ts b/dist/deno/types/defaults.ts
index aaa389e8..a8096baa 100644
--- a/dist/deno/types/defaults.ts
+++ b/dist/deno/types/defaults.ts
@@ -1,10 +1,11 @@
 import {
+  type DeepMergeFunctionURItoKind,
+  type DeepMergeFunctionsURIs,
   type DeepMergeHKT,
   type DeepMergeLeafURI,
-  type DeepMergeMergeFunctionURItoKind,
-  type DeepMergeMergeFunctionsURIs,
 } from "./merging.ts";
 import {
+  type FilterOut,
   type FilterOutNever,
   type FlattenTuples,
   type KeyIsOptional,
@@ -37,15 +38,21 @@ type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI";
  */
 type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI";
 
+/**
+ * The default filter values function.
+ */
+type DeepMergeFilterValuesDefaultURI = "DeepMergeFilterValuesDefaultURI";
+
 /**
  * The default merge functions to use when deep merging.
  */
-export type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
+export type DeepMergeFunctionsDefaultURIs = Readonly<{
   DeepMergeRecordsURI: DeepMergeRecordsDefaultURI;
   DeepMergeArraysURI: DeepMergeArraysDefaultURI;
   DeepMergeSetsURI: DeepMergeSetsDefaultURI;
   DeepMergeMapsURI: DeepMergeMapsDefaultURI;
   DeepMergeOthersURI: DeepMergeLeafURI;
+  DeepMergeFilterValuesURI: DeepMergeFilterValuesDefaultURI;
 }>;
 
 type RecordEntries<T extends Record<PropertyKey, unknown>> = TuplifyUnion<
@@ -88,12 +95,12 @@ type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> =
  */
 export type DeepMergeRecordsDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > =
   Ts extends ReadonlyArray<Record<PropertyKey, unknown>>
     ? SimplifyObject<
-        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>
+        DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, Fs, M>
       >
     : never;
 
@@ -102,11 +109,11 @@ export type DeepMergeRecordsDefaultHKT<
  */
 type DeepMergeRecordMetaDefaultHKTProps<
   RecordMetas,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > =
   RecordMetas extends ReadonlyArray<RecordMeta>
-    ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M>
+    ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, Fs, M>
     : never;
 
 type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> =
@@ -136,7 +143,7 @@ type GroupValuesByKey<Ts> = Ts extends readonly [
     }
   : never;
 
-type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> =
+type CreateRecordFromMeta<Ts, Fs extends DeepMergeFunctionsURIs, M> =
   Ts extends ReadonlyArray<unknown>
     ? TupleToIntersection<{
         [I in keyof Ts]: Ts[I] extends {
@@ -144,7 +151,7 @@ type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> =
           values: infer Values extends ReadonlyArray<unknown>;
           optional: infer O extends boolean;
         }
-          ? CreateRecordForKeyFromMeta<Key, Values, O, MF, M>
+          ? CreateRecordForKeyFromMeta<Key, Values, O, Fs, M>
           : never;
       }>
     : never;
@@ -153,14 +160,14 @@ type CreateRecordForKeyFromMeta<
   Key extends PropertyKey,
   Values extends ReadonlyArray<unknown>,
   Optional extends boolean,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
 > = Optional extends true
   ? {
-      [k in Key]+?: DeepMergeHKT<Values, MF, M>;
+      [k in Key]+?: DeepMergeHKT<Values, Fs, M>;
     }
   : {
-      [k in Key]-?: DeepMergeHKT<Values, MF, M>;
+      [k in Key]-?: DeepMergeHKT<Values, Fs, M>;
     };
 
 /**
@@ -260,16 +267,16 @@ type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<
  */
 export type DeepMergeArraysDefaultHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, []>;
+> = DeepMergeArraysDefaultHKTHelper<Ts, Fs, M, []>;
 
 /**
  * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
  */
 type DeepMergeArraysDefaultHKTHelper<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
   Acc extends ReadonlyArray<unknown>,
 > = Ts extends readonly [
@@ -280,7 +287,7 @@ type DeepMergeArraysDefaultHKTHelper<
       ReadonlyArray<unknown>,
       ...ReadonlyArray<ReadonlyArray<unknown>>,
     ]
-    ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [...Acc, ...Head]>
+    ? DeepMergeArraysDefaultHKTHelper<Rest, Fs, M, [...Acc, ...Head]>
     : [...Acc, ...Head]
   : never;
 
@@ -299,39 +306,51 @@ export type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<
   UnionMapValues<Ts>
 >;
 
+/**
+ * Filter out undefined values.
+ */
+export type DeepMergeFilterValuesDefaultHKT<Ts extends ReadonlyArray<unknown>> =
+  FilterOut<Ts, undefined>;
+
 /**
  * Get the merge functions with defaults apply from the given subset.
  */
-export type GetDeepMergeMergeFunctionsURIs<
-  PMF extends Partial<DeepMergeMergeFunctionsURIs>,
+export type GetDeepMergeFunctionsURIs<
+  PMF extends Partial<DeepMergeFunctionsURIs>,
 > = Readonly<{
   // prettier-ignore
   DeepMergeRecordsURI:
-    PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeRecordsURI"]
       : DeepMergeRecordsDefaultURI;
 
   // prettier-ignore
   DeepMergeArraysURI:
-    PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeArraysURI"]
       : DeepMergeArraysDefaultURI;
 
   // prettier-ignore
   DeepMergeSetsURI:
-    PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeSetsURI"]
       : DeepMergeSetsDefaultURI;
 
   // prettier-ignore
   DeepMergeMapsURI:
-    PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeMapsURI"]
       : DeepMergeMapsDefaultURI;
 
   // prettier-ignore
   DeepMergeOthersURI:
-    PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any>
+    PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
       ? PMF["DeepMergeOthersURI"]
       : DeepMergeLeafURI;
+
+  // prettier-ignore
+  DeepMergeFilterValuesURI:
+    PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any>
+      ? PMF["DeepMergeFilterValuesURI"]
+      : DeepMergeFilterValuesDefaultURI;
 }>;
diff --git a/dist/deno/types/merging.ts b/dist/deno/types/merging.ts
index 9ccda959..a47a574a 100644
--- a/dist/deno/types/merging.ts
+++ b/dist/deno/types/merging.ts
@@ -1,5 +1,6 @@
 import {
   type DeepMergeArraysDefaultHKT,
+  type DeepMergeFilterValuesDefaultHKT,
   type DeepMergeMapsDefaultHKT,
   type DeepMergeRecordsDefaultHKT,
   type DeepMergeSetsDefaultHKT,
@@ -9,75 +10,80 @@ import {
   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 ts/consistent-type-definitions
-export interface DeepMergeMergeFunctionURItoKind<
+export interface DeepMergeFunctionURItoKind<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   in out M,
 > {
   readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
-  readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-  readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, MF, M>;
+  readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
+  readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, Fs, M>;
   readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT<Ts>;
   readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT<Ts>;
+  readonly DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT<Ts>;
+  readonly DeepMergeNoFilteringURI: Ts;
 }
 
 /**
  * Get the type of the given merge function via its URI.
  */
-type DeepMergeMergeFunctionKind<
-  URI extends DeepMergeMergeFunctionURIs,
+type DeepMergeFunctionKind<
+  URI extends DeepMergeFunctionURIs,
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionURItoKind<Ts, MF, M>[URI];
+> = DeepMergeFunctionURItoKind<Ts, Fs, M>[URI];
 
 /**
  * A union of all valid merge function URIs.
  */
-type DeepMergeMergeFunctionURIs = keyof DeepMergeMergeFunctionURItoKind<
+type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind<
   ReadonlyArray<unknown>,
-  DeepMergeMergeFunctionsURIs,
+  DeepMergeFunctionsURIs,
   unknown
 >;
 
 /**
  * The merge functions to use when deep merging.
  */
-export type DeepMergeMergeFunctionsURIs = Readonly<{
+export type DeepMergeFunctionsURIs = Readonly<{
   /**
    * The merge function to merge records with.
    */
-  DeepMergeRecordsURI: DeepMergeMergeFunctionURIs;
+  DeepMergeRecordsURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge arrays with.
    */
-  DeepMergeArraysURI: DeepMergeMergeFunctionURIs;
+  DeepMergeArraysURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge sets with.
    */
-  DeepMergeSetsURI: DeepMergeMergeFunctionURIs;
+  DeepMergeSetsURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge maps with.
    */
-  DeepMergeMapsURI: DeepMergeMergeFunctionURIs;
+  DeepMergeMapsURI: DeepMergeFunctionURIs;
 
   /**
    * The merge function to merge other things with.
    */
-  DeepMergeOthersURI: DeepMergeMergeFunctionURIs;
+  DeepMergeOthersURI: DeepMergeFunctionURIs;
+
+  /**
+   * The function to filter values.
+   */
+  DeepMergeFilterValuesURI: DeepMergeFunctionURIs;
 }>;
 
 /**
@@ -85,75 +91,98 @@ export type DeepMergeMergeFunctionsURIs = Readonly<{
  */
 export type DeepMergeHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   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>
+      : DeepMergeHKTHelper<FilterValuesHKT<Ts, Fs, M>, Fs, M>
     : unknown;
 
+type DeepMergeHKTHelper<Ts, Fs extends DeepMergeFunctionsURIs, M> =
+  Ts extends ReadonlyArray<unknown>
+    ? IsTuple<Ts> extends true
+      ? Ts extends readonly []
+        ? unknown
+        : Ts extends readonly [infer T1]
+          ? T1
+          : EveryIsArray<Ts> extends true
+            ? DeepMergeArraysHKT<Ts, Fs, M>
+            : EveryIsMap<Ts> extends true
+              ? DeepMergeMapsHKT<Ts, Fs, M>
+              : EveryIsSet<Ts> extends true
+                ? DeepMergeSetsHKT<Ts, Fs, M>
+                : EveryIsRecord<Ts> extends true
+                  ? DeepMergeRecordsHKT<Ts, Fs, M>
+                  : DeepMergeOthersHKT<Ts, Fs, M>
+      : unknown
+    : never;
+
 /**
  * Deep merge records.
  */
 type DeepMergeRecordsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeRecordsURI"], Ts, Fs, M>;
 
 /**
  * Deep merge arrays.
  */
 type DeepMergeArraysHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeArraysURI"], Ts, Fs, M>;
 
 /**
  * Deep merge sets.
  */
 type DeepMergeSetsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeSetsURI"], Ts, Fs, M>;
 
 /**
  * Deep merge maps.
  */
 type DeepMergeMapsHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeMapsURI"], Ts, Fs, M>;
 
 /**
  * Deep merge other things.
  */
 type DeepMergeOthersHKT<
   Ts extends ReadonlyArray<unknown>,
-  MF extends DeepMergeMergeFunctionsURIs,
+  Fs extends DeepMergeFunctionsURIs,
+  M,
+> = DeepMergeFunctionKind<Fs["DeepMergeOthersURI"], Ts, Fs, M>;
+
+/**
+ * Filter values.
+ */
+type FilterValuesHKT<
+  Ts extends ReadonlyArray<unknown>,
+  Fs extends DeepMergeFunctionsURIs,
   M,
-> = DeepMergeMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
+> = DeepMergeFunctionKind<Fs["DeepMergeFilterValuesURI"], Ts, Fs, M>;
 
 /**
  * The merge function that returns a leaf.
  */
 export type DeepMergeLeafURI = "DeepMergeLeafURI";
 
+/**
+ * Don't filter values.
+ */
+export type DeepMergeNoFilteringURI = "DeepMergeNoFilteringURI";
+
 /**
  * Get the leaf type from many types that can't be merged.
  */
@@ -163,7 +192,7 @@ export type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> =
     : Ts extends readonly [infer T]
       ? T
       : Ts extends readonly [...infer Rest, infer Tail]
-        ? Or<IsNever<Tail>, Is<Tail, undefined>> extends true
+        ? IsNever<Tail> extends true
           ? Rest extends ReadonlyArray<unknown>
             ? DeepMergeLeaf<Rest>
             : never
diff --git a/dist/deno/types/options.ts b/dist/deno/types/options.ts
index 15ecf706..c8b1b0c2 100644
--- a/dist/deno/types/options.ts
+++ b/dist/deno/types/options.ts
@@ -31,13 +31,14 @@ type DeepMergeOptionsFull<
   in out M,
   MM extends DeepMergeBuiltInMetaData = 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"];
+  mergeRecords: DeepMergeFunctions<M, MM>["mergeRecords"] | false;
+  mergeArrays: DeepMergeFunctions<M, MM>["mergeArrays"] | false;
+  mergeMaps: DeepMergeFunctions<M, MM>["mergeMaps"] | false;
+  mergeSets: DeepMergeFunctions<M, MM>["mergeSets"] | false;
+  mergeOthers: DeepMergeFunctions<M, MM>["mergeOthers"];
   metaDataUpdater: MetaDataUpdater<M, MM>;
   enableImplicitDefaultMerging: boolean;
+  filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
 }>;
 
 /**
@@ -47,12 +48,13 @@ type DeepMergeIntoOptionsFull<
   in out M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
-  mergeRecords: DeepMergeMergeIntoFunctions<M, MM>["mergeRecords"] | false;
-  mergeArrays: DeepMergeMergeIntoFunctions<M, MM>["mergeArrays"] | false;
-  mergeMaps: DeepMergeMergeIntoFunctions<M, MM>["mergeMaps"] | false;
-  mergeSets: DeepMergeMergeIntoFunctions<M, MM>["mergeSets"] | false;
-  mergeOthers: DeepMergeMergeIntoFunctions<M, MM>["mergeOthers"];
+  mergeRecords: DeepMergeIntoFunctions<M, MM>["mergeRecords"] | false;
+  mergeArrays: DeepMergeIntoFunctions<M, MM>["mergeArrays"] | false;
+  mergeMaps: DeepMergeIntoFunctions<M, MM>["mergeMaps"] | false;
+  mergeSets: DeepMergeIntoFunctions<M, MM>["mergeSets"] | false;
+  mergeOthers: DeepMergeIntoFunctions<M, MM>["mergeOthers"];
   metaDataUpdater: MetaDataUpdater<M, MM>;
+  filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
 }>;
 
 /**
@@ -62,16 +64,26 @@ export type Reference<T> = {
   value: T;
 };
 
+/**
+ * All the utility functions that can be overridden.
+ */
+type DeepMergeUtilityFunctions<in M> = Readonly<{
+  filterValues: <Ts extends ReadonlyArray<unknown>>(
+    values: Ts,
+    meta: M | undefined,
+  ) => unknown[];
+}>;
+
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeFunctions<
+type DeepMergeFunctions<
   in M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: <
     Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -80,7 +92,7 @@ type DeepMergeMergeFunctions<
 
   mergeArrays: <
     Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -89,7 +101,7 @@ type DeepMergeMergeFunctions<
 
   mergeMaps: <
     Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -98,7 +110,7 @@ type DeepMergeMergeFunctions<
 
   mergeSets: <
     Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -107,7 +119,7 @@ type DeepMergeMergeFunctions<
 
   mergeOthers: <
     Ts extends ReadonlyArray<unknown>,
-    U extends DeepMergeMergeFunctionUtils<M, MM>,
+    U extends DeepMergeUtils<M, MM>,
   >(
     values: Ts,
     utils: U,
@@ -116,78 +128,79 @@ type DeepMergeMergeFunctions<
 }>;
 
 // eslint-disable-next-line ts/no-invalid-void-type
-type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
+type DeepMergeIntoFunctionsReturnType = void | symbol;
 
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeIntoFunctions<
+type DeepMergeIntoFunctions<
   in M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
   mergeRecords: <
     Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Record<PropertyKey, unknown>>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeArrays: <
     Ts extends ReadonlyArray<ReadonlyArray<unknown>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<unknown[]>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeMaps: <
     Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Map<unknown, unknown>>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeSets: <
     Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<Set<unknown>>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 
   mergeOthers: <
     Ts extends ReadonlyArray<unknown>,
-    U extends DeepMergeMergeIntoFunctionUtils<M, MM>,
+    U extends DeepMergeIntoFunctionUtils<M, MM>,
   >(
     m_target: Reference<unknown>,
     values: Ts,
     utils: U,
     meta: M | undefined,
-  ) => DeepMergeMergeIntoFunctionsReturnType;
+  ) => DeepMergeIntoFunctionsReturnType;
 }>;
 
 /**
  * The utils provided to the merge functions.
  */
-export type DeepMergeMergeFunctionUtils<
+export type DeepMergeUtils<
   in out M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
-  mergeFunctions: DeepMergeMergeFunctions<M, MM>;
+  mergeFunctions: DeepMergeFunctions<M, MM>;
   defaultMergeFunctions: MergeFunctions;
   metaDataUpdater: MetaDataUpdater<M, MM>;
   deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
   useImplicitDefaultMerging: boolean;
+  filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
   actions: Readonly<{
     defaultMerge: symbol;
     skip: symbol;
@@ -197,17 +210,18 @@ export type DeepMergeMergeFunctionUtils<
 /**
  * The utils provided to the merge functions.
  */
-export type DeepMergeMergeIntoFunctionUtils<
+export type DeepMergeIntoFunctionUtils<
   in out M,
   MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData,
 > = Readonly<{
-  mergeFunctions: DeepMergeMergeIntoFunctions<M, MM>;
+  mergeFunctions: DeepMergeIntoFunctions<M, MM>;
   defaultMergeFunctions: MergeIntoFunctions;
   metaDataUpdater: MetaDataUpdater<M, MM>;
   deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(
     target: Target,
     ...values: Ts
   ) => void;
+  filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
   actions: Readonly<{
     defaultMerge: symbol;
   }>;
diff --git a/dist/deno/types/utils.ts b/dist/deno/types/utils.ts
index 83a049da..8ec7a1d0 100644
--- a/dist/deno/types/utils.ts
+++ b/dist/deno/types/utils.ts
@@ -226,25 +226,35 @@ type UnionMapValuesHelper<
   : Acc;
 
 /**
- * Filter out nevers from a tuple.
+ * Filter out U from a tuple.
  */
-export type FilterOutNever<T> =
-  T extends ReadonlyArray<unknown> ? FilterOutNeverHelper<T, []> : never;
+export type FilterOut<T extends ReadonlyArray<unknown>, U> = FilterOutHelper<
+  T,
+  U,
+  []
+>;
 
 /**
- * Tail-recursive helper type for FilterOutNever.
+ * Tail-recursive helper type for FilterOut.
  */
-type FilterOutNeverHelper<
+type FilterOutHelper<
   T extends ReadonlyArray<unknown>,
+  U,
   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]>
+    ? Is<Head, U> extends true
+      ? FilterOutHelper<Rest, U, Acc>
+      : FilterOutHelper<Rest, U, [...Acc, Head]>
     : T;
 
+/**
+ * Filter out nevers from a tuple.
+ */
+export type FilterOutNever<T> =
+  T extends ReadonlyArray<unknown> ? FilterOut<T, never> : never;
+
 /**
  * Is the type a tuple?
  */
diff --git a/dist/node/index.cjs b/dist/node/index.cjs
index 76a9b1c8..50955e04 100644
--- a/dist/node/index.cjs
+++ b/dist/node/index.cjs
@@ -16,10 +16,20 @@ const actionsInto = {
 
 /**
  * The default function to update meta data.
+ *
+ * It doesn't update the meta data.
  */
 function defaultMetaDataUpdater(previousMeta, metaMeta) {
     return metaMeta;
 }
+/**
+ * The default function to filter values.
+ *
+ * It filters out undefined values.
+ */
+function defaultFilterValues(values, meta) {
+    return values.filter((value) => value !== undefined);
+}
 
 /**
  * The different types of objects deepmerge-ts support.
@@ -203,12 +213,7 @@ function mergeMaps$2(values) {
  * Get the last non-undefined value in the given array.
  */
 function mergeOthers$2(values) {
-    for (let i = values.length - 1; i >= 0; i--) {
-        if (values[i] !== undefined) {
-            return values[i];
-        }
-    }
-    return undefined;
+    return values.at(-1);
 }
 
 var defaultMergeFunctions = /*#__PURE__*/Object.freeze({
@@ -258,6 +263,9 @@ function getUtils(options, customizedDeepmerge) {
             defaultMetaDataUpdater),
         deepmerge: customizedDeepmerge,
         useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,
+        filterValues: options.filterValues === false
+            ? undefined
+            : options.filterValues ?? defaultFilterValues,
         actions,
     };
 }
@@ -267,36 +275,37 @@ function getUtils(options, customizedDeepmerge) {
  * @param values - The values.
  */
 function mergeUnknowns(values, utils, meta) {
-    if (values.length === 0) {
+    const filteredValues = utils.filterValues?.(values, meta) ?? values;
+    if (filteredValues.length === 0) {
         return undefined;
     }
-    if (values.length === 1) {
-        return mergeOthers$1(values, utils, meta);
+    if (filteredValues.length === 1) {
+        return mergeOthers$1(filteredValues, utils, meta);
     }
-    const type = getObjectType(values[0]);
+    const type = getObjectType(filteredValues[0]);
     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) {
+        for (let m_index = 1; m_index < filteredValues.length; m_index++) {
+            if (getObjectType(filteredValues[m_index]) === type) {
                 continue;
             }
-            return mergeOthers$1(values, utils, meta);
+            return mergeOthers$1(filteredValues, utils, meta);
         }
     }
     switch (type) {
         case 1 /* ObjectType.RECORD */: {
-            return mergeRecords$1(values, utils, meta);
+            return mergeRecords$1(filteredValues, utils, meta);
         }
         case 2 /* ObjectType.ARRAY */: {
-            return mergeArrays$1(values, utils, meta);
+            return mergeArrays$1(filteredValues, utils, meta);
         }
         case 3 /* ObjectType.SET */: {
-            return mergeSets$1(values, utils, meta);
+            return mergeSets$1(filteredValues, utils, meta);
         }
         case 4 /* ObjectType.MAP */: {
-            return mergeMaps$1(values, utils, meta);
+            return mergeMaps$1(filteredValues, utils, meta);
         }
         default: {
-            return mergeOthers$1(values, utils, meta);
+            return mergeOthers$1(filteredValues, utils, meta);
         }
     }
 }
@@ -450,13 +459,7 @@ function mergeMaps(m_target, values) {
  * Set the target to the last non-undefined value.
  */
 function mergeOthers(m_target, values) {
-    for (let i = values.length - 1; i >= 0; i--) {
-        if (values[i] !== undefined) {
-            m_target.value = values[i];
-            return;
-        }
-    }
-    m_target.value = undefined;
+    m_target.value = values.at(-1);
 }
 
 var defaultMergeIntoFunctions = /*#__PURE__*/Object.freeze({
@@ -500,6 +503,9 @@ function getIntoUtils(options, customizedDeepmergeInto) {
         metaDataUpdater: (options.metaDataUpdater ??
             defaultMetaDataUpdater),
         deepmergeInto: customizedDeepmergeInto,
+        filterValues: options.filterValues === false
+            ? undefined
+            : options.filterValues ?? defaultFilterValues,
         actions: actionsInto,
     };
 }
@@ -510,36 +516,37 @@ function getIntoUtils(options, customizedDeepmergeInto) {
  * @param values - The values.
  */
 function mergeUnknownsInto(m_target, values, utils, meta) {
-    if (values.length === 0) {
+    const filteredValues = utils.filterValues?.(values, meta) ?? values;
+    if (filteredValues.length === 0) {
         return;
     }
-    if (values.length === 1) {
-        return void mergeOthersInto(m_target, values, utils, meta);
+    if (filteredValues.length === 1) {
+        return void mergeOthersInto(m_target, filteredValues, utils, meta);
     }
     const type = getObjectType(m_target.value);
     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) {
+        for (let m_index = 1; m_index < filteredValues.length; m_index++) {
+            if (getObjectType(filteredValues[m_index]) === type) {
                 continue;
             }
-            return void mergeOthersInto(m_target, values, utils, meta);
+            return void mergeOthersInto(m_target, filteredValues, utils, meta);
         }
     }
     switch (type) {
         case 1 /* ObjectType.RECORD */: {
-            return void mergeRecordsInto(m_target, values, utils, meta);
+            return void mergeRecordsInto(m_target, filteredValues, utils, meta);
         }
         case 2 /* ObjectType.ARRAY */: {
-            return void mergeArraysInto(m_target, values, utils, meta);
+            return void mergeArraysInto(m_target, filteredValues, utils, meta);
         }
         case 3 /* ObjectType.SET */: {
-            return void mergeSetsInto(m_target, values, utils, meta);
+            return void mergeSetsInto(m_target, filteredValues, utils, meta);
         }
         case 4 /* ObjectType.MAP */: {
-            return void mergeMapsInto(m_target, values, utils, meta);
+            return void mergeMapsInto(m_target, filteredValues, utils, meta);
         }
         default: {
-            return void mergeOthersInto(m_target, values, utils, meta);
+            return void mergeOthersInto(m_target, filteredValues, utils, meta);
         }
     }
 }
diff --git a/dist/node/index.d.cts b/dist/node/index.d.cts
index 9685a256..ce5894d3 100644
--- a/dist/node/index.d.cts
+++ b/dist/node/index.d.cts
@@ -47,10 +47,6 @@ 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.
  */
@@ -162,21 +158,25 @@ type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends r
 ] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [
 ] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
 /**
- * Filter out nevers from a tuple.
+ * Filter out U from a tuple.
  */
-type FilterOutNever<T> = T extends ReadonlyArray<unknown> ? FilterOutNeverHelper<T, [
-]> : never;
+type FilterOut<T extends ReadonlyArray<unknown>, U> = FilterOutHelper<T, U, [
+]>;
 /**
- * Tail-recursive helper type for FilterOutNever.
+ * Tail-recursive helper type for FilterOut.
  */
-type FilterOutNeverHelper<T extends ReadonlyArray<unknown>, Acc extends ReadonlyArray<unknown>> = T extends readonly [
+type FilterOutHelper<T extends ReadonlyArray<unknown>, U, Acc extends ReadonlyArray<unknown>> = T extends readonly [
 ] ? Acc : T extends readonly [
     infer Head,
     ...infer Rest
-] ? IsNever<Head> extends true ? FilterOutNeverHelper<Rest, Acc> : FilterOutNeverHelper<Rest, [
+] ? Is<Head, U> extends true ? FilterOutHelper<Rest, U, Acc> : FilterOutHelper<Rest, U, [
     ...Acc,
     Head
 ]> : T;
+/**
+ * Filter out nevers from a tuple.
+ */
+type FilterOutNever<T> = T extends ReadonlyArray<unknown> ? FilterOut<T, never> : never;
 /**
  * Is the type a tuple?
  */
@@ -255,77 +255,93 @@ type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends ()
  * 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> {
+interface DeepMergeFunctionURItoKind<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, in out M> {
     readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
-    readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-    readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, MF, M>;
+    readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
+    readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, Fs, M>;
     readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT<Ts>;
     readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT<Ts>;
+    readonly DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT<Ts>;
+    readonly DeepMergeNoFilteringURI: Ts;
 }
 /**
  * Get the type of the given merge function via its URI.
  */
-type DeepMergeMergeFunctionKind<URI extends DeepMergeMergeFunctionURIs, Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionURItoKind<Ts, MF, M>[URI];
+type DeepMergeFunctionKind<URI extends DeepMergeFunctionURIs, Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionURItoKind<Ts, Fs, M>[URI];
 /**
  * A union of all valid merge function URIs.
  */
-type DeepMergeMergeFunctionURIs = keyof DeepMergeMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeMergeFunctionsURIs, unknown>;
+type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown>;
 /**
  * The merge functions to use when deep merging.
  */
-type DeepMergeMergeFunctionsURIs = Readonly<{
+type DeepMergeFunctionsURIs = Readonly<{
     /**
      * The merge function to merge records with.
      */
-    DeepMergeRecordsURI: DeepMergeMergeFunctionURIs;
+    DeepMergeRecordsURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge arrays with.
      */
-    DeepMergeArraysURI: DeepMergeMergeFunctionURIs;
+    DeepMergeArraysURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge sets with.
      */
-    DeepMergeSetsURI: DeepMergeMergeFunctionURIs;
+    DeepMergeSetsURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge maps with.
      */
-    DeepMergeMapsURI: DeepMergeMergeFunctionURIs;
+    DeepMergeMapsURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge other things with.
      */
-    DeepMergeOthersURI: DeepMergeMergeFunctionURIs;
+    DeepMergeOthersURI: DeepMergeFunctionURIs;
+    /**
+     * The function to filter values.
+     */
+    DeepMergeFilterValuesURI: DeepMergeFunctionURIs;
 }>;
 /**
  * Deep merge types.
  */
-type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [
-] ? undefined : Ts extends readonly [
+type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [
+] ? undefined : DeepMergeHKTHelper<FilterValuesHKT<Ts, Fs, M>, Fs, M> : unknown;
+type DeepMergeHKTHelper<Ts, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? IsTuple<Ts> extends true ? Ts extends readonly [
+] ? unknown : 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;
+] ? T1 : EveryIsArray<Ts> extends true ? DeepMergeArraysHKT<Ts, Fs, M> : EveryIsMap<Ts> extends true ? DeepMergeMapsHKT<Ts, Fs, M> : EveryIsSet<Ts> extends true ? DeepMergeSetsHKT<Ts, Fs, M> : EveryIsRecord<Ts> extends true ? DeepMergeRecordsHKT<Ts, Fs, M> : DeepMergeOthersHKT<Ts, Fs, M> : unknown : never;
 /**
  * Deep merge records.
  */
-type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
+type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeRecordsURI"], Ts, Fs, M>;
 /**
  * Deep merge arrays.
  */
-type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
+type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeArraysURI"], Ts, Fs, M>;
 /**
  * Deep merge sets.
  */
-type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
+type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeSetsURI"], Ts, Fs, M>;
 /**
  * Deep merge maps.
  */
-type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
+type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeMapsURI"], Ts, Fs, M>;
 /**
  * Deep merge other things.
  */
-type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
+type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeOthersURI"], Ts, Fs, M>;
+/**
+ * Filter values.
+ */
+type FilterValuesHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeFilterValuesURI"], Ts, Fs, M>;
 /**
  * The merge function that returns a leaf.
  */
 type DeepMergeLeafURI = "DeepMergeLeafURI";
+/**
+ * Don't filter values.
+ */
+type DeepMergeNoFilteringURI = "DeepMergeNoFilteringURI";
 /**
  * Get the leaf type from many types that can't be merged.
  */
@@ -335,7 +351,7 @@ type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
 ] ? 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;
+] ? IsNever<Tail> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest> : never : Tail : never;
 /**
  * The meta data deepmerge is able to provide.
  */
@@ -359,15 +375,20 @@ type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI";
  * The default merge function to merge maps with.
  */
 type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI";
+/**
+ * The default filter values function.
+ */
+type DeepMergeFilterValuesDefaultURI = "DeepMergeFilterValuesDefaultURI";
 /**
  * The default merge functions to use when deep merging.
  */
-type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
+type DeepMergeFunctionsDefaultURIs = Readonly<{
     DeepMergeRecordsURI: DeepMergeRecordsDefaultURI;
     DeepMergeArraysURI: DeepMergeArraysDefaultURI;
     DeepMergeSetsURI: DeepMergeSetsDefaultURI;
     DeepMergeMapsURI: DeepMergeMapsDefaultURI;
     DeepMergeOthersURI: DeepMergeLeafURI;
+    DeepMergeFilterValuesURI: DeepMergeFilterValuesDefaultURI;
 }>;
 type RecordEntries<T extends Record<PropertyKey, unknown>> = TuplifyUnion<{
     [K in keyof T]: [
@@ -394,11 +415,11 @@ type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> = object extends
 /**
  * Deep merge records.
  */
-type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? SimplifyObject<DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>> : never;
+type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? SimplifyObject<DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, Fs, M>> : never;
 /**
  * Deep merge record props.
  */
-type DeepMergeRecordMetaDefaultHKTProps<RecordMetas, MF extends DeepMergeMergeFunctionsURIs, M> = RecordMetas extends ReadonlyArray<RecordMeta> ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M> : never;
+type DeepMergeRecordMetaDefaultHKTProps<RecordMetas, Fs extends DeepMergeFunctionsURIs, M> = RecordMetas extends ReadonlyArray<RecordMeta> ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, Fs, M> : never;
 type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> = GroupValuesByKey<FlattenTuples<TransposeTuple<{
     [I in keyof RecordMetas]: TransposeTuple<RecordEntries<RecordMetas[I]>>;
 }>>>;
@@ -412,17 +433,17 @@ type GroupValuesByKey<Ts> = Ts extends readonly [
         } ? Values[J] : never;
     }>>;
 } : never;
-type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? TupleToIntersection<{
+type CreateRecordFromMeta<Ts, Fs extends DeepMergeFunctionsURIs, 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;
+    } ? CreateRecordForKeyFromMeta<Key, Values, O, Fs, 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>;
+type CreateRecordForKeyFromMeta<Key extends PropertyKey, Values extends ReadonlyArray<unknown>, Optional extends boolean, Fs extends DeepMergeFunctionsURIs, M> = Optional extends true ? {
+    [k in Key]+?: DeepMergeHKT<Values, Fs, M>;
 } : {
-    [k in Key]-?: DeepMergeHKT<Values, MF, M>;
+    [k in Key]-?: DeepMergeHKT<Values, Fs, M>;
 };
 /**
  * Get the possible types of a property.
@@ -513,18 +534,18 @@ type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts extends readonly
 /**
  * Deep merge arrays.
  */
-type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, [
+type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, Fs, M, [
 ]>;
 /**
  * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
  */
-type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [
+type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [
     infer Head extends ReadonlyArray<unknown>,
     ...infer Rest
 ] ? Rest extends readonly [
     ReadonlyArray<unknown>,
     ...ReadonlyArray<ReadonlyArray<unknown>>
-] ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [
+] ? DeepMergeArraysDefaultHKTHelper<Rest, Fs, M, [
     ...Acc,
     ...Head
 ]> : [
@@ -539,20 +560,26 @@ type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<UnionSetVa
  * Deep merge maps.
  */
 type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<UnionMapKeys<Ts>, UnionMapValues<Ts>>;
+/**
+ * Filter out undefined values.
+ */
+type DeepMergeFilterValuesDefaultHKT<Ts extends ReadonlyArray<unknown>> = FilterOut<Ts, undefined>;
 /**
  * Get the merge functions with defaults apply from the given subset.
  */
-type GetDeepMergeMergeFunctionsURIs<PMF extends Partial<DeepMergeMergeFunctionsURIs>> = Readonly<{
+type GetDeepMergeFunctionsURIs<PMF extends Partial<DeepMergeFunctionsURIs>> = Readonly<{
+    // prettier-ignore
+    DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
     // prettier-ignore
-    DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
+    DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
     // prettier-ignore
-    DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
+    DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
     // prettier-ignore
-    DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
+    DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
     // prettier-ignore
-    DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
+    DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
     // prettier-ignore
-    DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
+    DeepMergeFilterValuesURI: PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeFilterValuesURI"] : DeepMergeFilterValuesDefaultURI;
 }>;
 /**
  * The default merge functions.
@@ -570,7 +597,7 @@ type MergeFunctions = {
  * @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<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 DeepMergeIntoFunctionUtils<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.
  *
@@ -620,24 +647,26 @@ type MetaDataUpdater<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBu
  * All the options the user can pass to customize deepmerge.
  */
 type DeepMergeOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = 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"];
+    mergeRecords: DeepMergeFunctions<M, MM>["mergeRecords"] | false;
+    mergeArrays: DeepMergeFunctions<M, MM>["mergeArrays"] | false;
+    mergeMaps: DeepMergeFunctions<M, MM>["mergeMaps"] | false;
+    mergeSets: DeepMergeFunctions<M, MM>["mergeSets"] | false;
+    mergeOthers: DeepMergeFunctions<M, MM>["mergeOthers"];
     metaDataUpdater: MetaDataUpdater<M, MM>;
     enableImplicitDefaultMerging: boolean;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
 }>;
 /**
  * All the options the user can pass to customize deepmergeInto.
  */
 type DeepMergeIntoOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: DeepMergeMergeIntoFunctions<M, MM>["mergeRecords"] | false;
-    mergeArrays: DeepMergeMergeIntoFunctions<M, MM>["mergeArrays"] | false;
-    mergeMaps: DeepMergeMergeIntoFunctions<M, MM>["mergeMaps"] | false;
-    mergeSets: DeepMergeMergeIntoFunctions<M, MM>["mergeSets"] | false;
-    mergeOthers: DeepMergeMergeIntoFunctions<M, MM>["mergeOthers"];
+    mergeRecords: DeepMergeIntoFunctions<M, MM>["mergeRecords"] | false;
+    mergeArrays: DeepMergeIntoFunctions<M, MM>["mergeArrays"] | false;
+    mergeMaps: DeepMergeIntoFunctions<M, MM>["mergeMaps"] | false;
+    mergeSets: DeepMergeIntoFunctions<M, MM>["mergeSets"] | false;
+    mergeOthers: DeepMergeIntoFunctions<M, MM>["mergeOthers"];
     metaDataUpdater: MetaDataUpdater<M, MM>;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
 }>;
 /**
  * An object that has a reference to a value.
@@ -645,37 +674,44 @@ type DeepMergeIntoOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = De
 type Reference<T> = {
     value: T;
 };
+/**
+ * All the utility functions that can be overridden.
+ */
+type DeepMergeUtilityFunctions<in M> = Readonly<{
+    filterValues: <Ts extends ReadonlyArray<unknown>>(values: Ts, meta: M | undefined) => unknown[];
+}>;
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
-    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;
+type DeepMergeFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
 }>;
 // eslint-disable-next-line ts/no-invalid-void-type
-type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
+type DeepMergeIntoFunctionsReturnType = void | symbol;
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeIntoFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown[]>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Set<unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
+type DeepMergeIntoFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown[]>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Set<unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
 }>;
 /**
  * The utils provided to the merge functions.
  */
-type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeFunctions: DeepMergeMergeFunctions<M, MM>;
+type DeepMergeUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeFunctions: DeepMergeFunctions<M, MM>;
     defaultMergeFunctions: MergeFunctions$0;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
     useImplicitDefaultMerging: boolean;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
     actions: Readonly<{
         defaultMerge: symbol;
         skip: symbol;
@@ -684,11 +720,12 @@ type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData =
 /**
  * The utils provided to the merge functions.
  */
-type DeepMergeMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeFunctions: DeepMergeMergeIntoFunctions<M, MM>;
+type DeepMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeFunctions: DeepMergeIntoFunctions<M, MM>;
     defaultMergeFunctions: MergeIntoFunctions;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...values: Ts) => void;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
     actions: Readonly<{
         defaultMerge: symbol;
     }>;
@@ -700,20 +737,20 @@ type DeepMergeMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaDa
  */
 declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
     ...Ts
-]): DeepMergeHKT<Ts, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
+]): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, 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<BaseTs = unknown, PMF extends Partial<DeepMergeMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<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<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>;
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
 /**
  * Deeply merge objects into a target.
  *
@@ -730,7 +767,7 @@ declare function deepmergeInto<T extends object>(target: T, ...objects: Readonly
 declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is SimplifyObject<Target & DeepMergeHKT<[
     Target,
     ...Ts
-], DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
+], DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
 /**
  * Deeply merge two or more objects using the given options.
  *
@@ -780,4 +817,4 @@ declare function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey>;
  */
 declare function objectHasProperty(object: object, property: PropertyKey): boolean;
 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 };
+export type { MergeFunctions as DeepMergeIntoFunctionsDefaults, MergeFunctions$0 as DeepMergeFunctionsDefaults, DeepMergeArraysDefaultHKT, DeepMergeBuiltInMetaData, DeepMergeHKT, DeepMergeLeaf, DeepMergeLeafURI, DeepMergeNoFilteringURI, DeepMergeMapsDefaultHKT, DeepMergeFunctionsDefaultURIs, DeepMergeFunctionsURIs, DeepMergeFunctionURItoKind, DeepMergeUtils, DeepMergeIntoFunctionUtils, DeepMergeOptions, DeepMergeIntoOptions, DeepMergeRecordsDefaultHKT, DeepMergeSetsDefaultHKT, Reference as DeepMergeValueReference, GetDeepMergeFunctionsURIs, FilterOut };
diff --git a/dist/node/index.d.mts b/dist/node/index.d.mts
index 9685a256..ce5894d3 100644
--- a/dist/node/index.d.mts
+++ b/dist/node/index.d.mts
@@ -47,10 +47,6 @@ 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.
  */
@@ -162,21 +158,25 @@ type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends r
 ] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [
 ] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
 /**
- * Filter out nevers from a tuple.
+ * Filter out U from a tuple.
  */
-type FilterOutNever<T> = T extends ReadonlyArray<unknown> ? FilterOutNeverHelper<T, [
-]> : never;
+type FilterOut<T extends ReadonlyArray<unknown>, U> = FilterOutHelper<T, U, [
+]>;
 /**
- * Tail-recursive helper type for FilterOutNever.
+ * Tail-recursive helper type for FilterOut.
  */
-type FilterOutNeverHelper<T extends ReadonlyArray<unknown>, Acc extends ReadonlyArray<unknown>> = T extends readonly [
+type FilterOutHelper<T extends ReadonlyArray<unknown>, U, Acc extends ReadonlyArray<unknown>> = T extends readonly [
 ] ? Acc : T extends readonly [
     infer Head,
     ...infer Rest
-] ? IsNever<Head> extends true ? FilterOutNeverHelper<Rest, Acc> : FilterOutNeverHelper<Rest, [
+] ? Is<Head, U> extends true ? FilterOutHelper<Rest, U, Acc> : FilterOutHelper<Rest, U, [
     ...Acc,
     Head
 ]> : T;
+/**
+ * Filter out nevers from a tuple.
+ */
+type FilterOutNever<T> = T extends ReadonlyArray<unknown> ? FilterOut<T, never> : never;
 /**
  * Is the type a tuple?
  */
@@ -255,77 +255,93 @@ type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends ()
  * 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> {
+interface DeepMergeFunctionURItoKind<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, in out M> {
     readonly DeepMergeLeafURI: DeepMergeLeaf<Ts>;
-    readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, MF, M>;
-    readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, MF, M>;
+    readonly DeepMergeRecordsDefaultURI: DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
+    readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, Fs, M>;
     readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT<Ts>;
     readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT<Ts>;
+    readonly DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT<Ts>;
+    readonly DeepMergeNoFilteringURI: Ts;
 }
 /**
  * Get the type of the given merge function via its URI.
  */
-type DeepMergeMergeFunctionKind<URI extends DeepMergeMergeFunctionURIs, Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionURItoKind<Ts, MF, M>[URI];
+type DeepMergeFunctionKind<URI extends DeepMergeFunctionURIs, Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionURItoKind<Ts, Fs, M>[URI];
 /**
  * A union of all valid merge function URIs.
  */
-type DeepMergeMergeFunctionURIs = keyof DeepMergeMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeMergeFunctionsURIs, unknown>;
+type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown>;
 /**
  * The merge functions to use when deep merging.
  */
-type DeepMergeMergeFunctionsURIs = Readonly<{
+type DeepMergeFunctionsURIs = Readonly<{
     /**
      * The merge function to merge records with.
      */
-    DeepMergeRecordsURI: DeepMergeMergeFunctionURIs;
+    DeepMergeRecordsURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge arrays with.
      */
-    DeepMergeArraysURI: DeepMergeMergeFunctionURIs;
+    DeepMergeArraysURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge sets with.
      */
-    DeepMergeSetsURI: DeepMergeMergeFunctionURIs;
+    DeepMergeSetsURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge maps with.
      */
-    DeepMergeMapsURI: DeepMergeMergeFunctionURIs;
+    DeepMergeMapsURI: DeepMergeFunctionURIs;
     /**
      * The merge function to merge other things with.
      */
-    DeepMergeOthersURI: DeepMergeMergeFunctionURIs;
+    DeepMergeOthersURI: DeepMergeFunctionURIs;
+    /**
+     * The function to filter values.
+     */
+    DeepMergeFilterValuesURI: DeepMergeFunctionURIs;
 }>;
 /**
  * Deep merge types.
  */
-type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [
-] ? undefined : Ts extends readonly [
+type DeepMergeHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = IsTuple<Ts> extends true ? Ts extends readonly [
+] ? undefined : DeepMergeHKTHelper<FilterValuesHKT<Ts, Fs, M>, Fs, M> : unknown;
+type DeepMergeHKTHelper<Ts, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? IsTuple<Ts> extends true ? Ts extends readonly [
+] ? unknown : 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;
+] ? T1 : EveryIsArray<Ts> extends true ? DeepMergeArraysHKT<Ts, Fs, M> : EveryIsMap<Ts> extends true ? DeepMergeMapsHKT<Ts, Fs, M> : EveryIsSet<Ts> extends true ? DeepMergeSetsHKT<Ts, Fs, M> : EveryIsRecord<Ts> extends true ? DeepMergeRecordsHKT<Ts, Fs, M> : DeepMergeOthersHKT<Ts, Fs, M> : unknown : never;
 /**
  * Deep merge records.
  */
-type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeRecordsURI"], Ts, MF, M>;
+type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeRecordsURI"], Ts, Fs, M>;
 /**
  * Deep merge arrays.
  */
-type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeArraysURI"], Ts, MF, M>;
+type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeArraysURI"], Ts, Fs, M>;
 /**
  * Deep merge sets.
  */
-type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeSetsURI"], Ts, MF, M>;
+type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeSetsURI"], Ts, Fs, M>;
 /**
  * Deep merge maps.
  */
-type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeMapsURI"], Ts, MF, M>;
+type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeMapsURI"], Ts, Fs, M>;
 /**
  * Deep merge other things.
  */
-type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeMergeFunctionKind<MF["DeepMergeOthersURI"], Ts, MF, M>;
+type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeOthersURI"], Ts, Fs, M>;
+/**
+ * Filter values.
+ */
+type FilterValuesHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeFilterValuesURI"], Ts, Fs, M>;
 /**
  * The merge function that returns a leaf.
  */
 type DeepMergeLeafURI = "DeepMergeLeafURI";
+/**
+ * Don't filter values.
+ */
+type DeepMergeNoFilteringURI = "DeepMergeNoFilteringURI";
 /**
  * Get the leaf type from many types that can't be merged.
  */
@@ -335,7 +351,7 @@ type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
 ] ? 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;
+] ? IsNever<Tail> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest> : never : Tail : never;
 /**
  * The meta data deepmerge is able to provide.
  */
@@ -359,15 +375,20 @@ type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI";
  * The default merge function to merge maps with.
  */
 type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI";
+/**
+ * The default filter values function.
+ */
+type DeepMergeFilterValuesDefaultURI = "DeepMergeFilterValuesDefaultURI";
 /**
  * The default merge functions to use when deep merging.
  */
-type DeepMergeMergeFunctionsDefaultURIs = Readonly<{
+type DeepMergeFunctionsDefaultURIs = Readonly<{
     DeepMergeRecordsURI: DeepMergeRecordsDefaultURI;
     DeepMergeArraysURI: DeepMergeArraysDefaultURI;
     DeepMergeSetsURI: DeepMergeSetsDefaultURI;
     DeepMergeMapsURI: DeepMergeMapsDefaultURI;
     DeepMergeOthersURI: DeepMergeLeafURI;
+    DeepMergeFilterValuesURI: DeepMergeFilterValuesDefaultURI;
 }>;
 type RecordEntries<T extends Record<PropertyKey, unknown>> = TuplifyUnion<{
     [K in keyof T]: [
@@ -394,11 +415,11 @@ type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> = object extends
 /**
  * Deep merge records.
  */
-type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? SimplifyObject<DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, MF, M>> : never;
+type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? SimplifyObject<DeepMergeRecordMetaDefaultHKTProps<RecordsToRecordMeta<Ts>, Fs, M>> : never;
 /**
  * Deep merge record props.
  */
-type DeepMergeRecordMetaDefaultHKTProps<RecordMetas, MF extends DeepMergeMergeFunctionsURIs, M> = RecordMetas extends ReadonlyArray<RecordMeta> ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, MF, M> : never;
+type DeepMergeRecordMetaDefaultHKTProps<RecordMetas, Fs extends DeepMergeFunctionsURIs, M> = RecordMetas extends ReadonlyArray<RecordMeta> ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, Fs, M> : never;
 type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> = GroupValuesByKey<FlattenTuples<TransposeTuple<{
     [I in keyof RecordMetas]: TransposeTuple<RecordEntries<RecordMetas[I]>>;
 }>>>;
@@ -412,17 +433,17 @@ type GroupValuesByKey<Ts> = Ts extends readonly [
         } ? Values[J] : never;
     }>>;
 } : never;
-type CreateRecordFromMeta<Ts, MF extends DeepMergeMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? TupleToIntersection<{
+type CreateRecordFromMeta<Ts, Fs extends DeepMergeFunctionsURIs, 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;
+    } ? CreateRecordForKeyFromMeta<Key, Values, O, Fs, 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>;
+type CreateRecordForKeyFromMeta<Key extends PropertyKey, Values extends ReadonlyArray<unknown>, Optional extends boolean, Fs extends DeepMergeFunctionsURIs, M> = Optional extends true ? {
+    [k in Key]+?: DeepMergeHKT<Values, Fs, M>;
 } : {
-    [k in Key]-?: DeepMergeHKT<Values, MF, M>;
+    [k in Key]-?: DeepMergeHKT<Values, Fs, M>;
 };
 /**
  * Get the possible types of a property.
@@ -513,18 +534,18 @@ type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts extends readonly
 /**
  * Deep merge arrays.
  */
-type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, MF, M, [
+type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, Fs, M, [
 ]>;
 /**
  * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
  */
-type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, MF extends DeepMergeMergeFunctionsURIs, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [
+type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M, Acc extends ReadonlyArray<unknown>> = Ts extends readonly [
     infer Head extends ReadonlyArray<unknown>,
     ...infer Rest
 ] ? Rest extends readonly [
     ReadonlyArray<unknown>,
     ...ReadonlyArray<ReadonlyArray<unknown>>
-] ? DeepMergeArraysDefaultHKTHelper<Rest, MF, M, [
+] ? DeepMergeArraysDefaultHKTHelper<Rest, Fs, M, [
     ...Acc,
     ...Head
 ]> : [
@@ -539,20 +560,26 @@ type DeepMergeSetsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Set<UnionSetVa
  * Deep merge maps.
  */
 type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<UnionMapKeys<Ts>, UnionMapValues<Ts>>;
+/**
+ * Filter out undefined values.
+ */
+type DeepMergeFilterValuesDefaultHKT<Ts extends ReadonlyArray<unknown>> = FilterOut<Ts, undefined>;
 /**
  * Get the merge functions with defaults apply from the given subset.
  */
-type GetDeepMergeMergeFunctionsURIs<PMF extends Partial<DeepMergeMergeFunctionsURIs>> = Readonly<{
+type GetDeepMergeFunctionsURIs<PMF extends Partial<DeepMergeFunctionsURIs>> = Readonly<{
+    // prettier-ignore
+    DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
     // prettier-ignore
-    DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
+    DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
     // prettier-ignore
-    DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
+    DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
     // prettier-ignore
-    DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
+    DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
     // prettier-ignore
-    DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
+    DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
     // prettier-ignore
-    DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
+    DeepMergeFilterValuesURI: PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeFilterValuesURI"] : DeepMergeFilterValuesDefaultURI;
 }>;
 /**
  * The default merge functions.
@@ -570,7 +597,7 @@ type MergeFunctions = {
  * @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<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 DeepMergeIntoFunctionUtils<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.
  *
@@ -620,24 +647,26 @@ type MetaDataUpdater<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBu
  * All the options the user can pass to customize deepmerge.
  */
 type DeepMergeOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = 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"];
+    mergeRecords: DeepMergeFunctions<M, MM>["mergeRecords"] | false;
+    mergeArrays: DeepMergeFunctions<M, MM>["mergeArrays"] | false;
+    mergeMaps: DeepMergeFunctions<M, MM>["mergeMaps"] | false;
+    mergeSets: DeepMergeFunctions<M, MM>["mergeSets"] | false;
+    mergeOthers: DeepMergeFunctions<M, MM>["mergeOthers"];
     metaDataUpdater: MetaDataUpdater<M, MM>;
     enableImplicitDefaultMerging: boolean;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
 }>;
 /**
  * All the options the user can pass to customize deepmergeInto.
  */
 type DeepMergeIntoOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: DeepMergeMergeIntoFunctions<M, MM>["mergeRecords"] | false;
-    mergeArrays: DeepMergeMergeIntoFunctions<M, MM>["mergeArrays"] | false;
-    mergeMaps: DeepMergeMergeIntoFunctions<M, MM>["mergeMaps"] | false;
-    mergeSets: DeepMergeMergeIntoFunctions<M, MM>["mergeSets"] | false;
-    mergeOthers: DeepMergeMergeIntoFunctions<M, MM>["mergeOthers"];
+    mergeRecords: DeepMergeIntoFunctions<M, MM>["mergeRecords"] | false;
+    mergeArrays: DeepMergeIntoFunctions<M, MM>["mergeArrays"] | false;
+    mergeMaps: DeepMergeIntoFunctions<M, MM>["mergeMaps"] | false;
+    mergeSets: DeepMergeIntoFunctions<M, MM>["mergeSets"] | false;
+    mergeOthers: DeepMergeIntoFunctions<M, MM>["mergeOthers"];
     metaDataUpdater: MetaDataUpdater<M, MM>;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
 }>;
 /**
  * An object that has a reference to a value.
@@ -645,37 +674,44 @@ type DeepMergeIntoOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = De
 type Reference<T> = {
     value: T;
 };
+/**
+ * All the utility functions that can be overridden.
+ */
+type DeepMergeUtilityFunctions<in M> = Readonly<{
+    filterValues: <Ts extends ReadonlyArray<unknown>>(values: Ts, meta: M | undefined) => unknown[];
+}>;
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
-    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeMergeFunctionUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
-    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;
+type DeepMergeFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+    mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MM>>(values: Ts, utils: U, meta: M | undefined) => unknown;
 }>;
 // eslint-disable-next-line ts/no-invalid-void-type
-type DeepMergeMergeIntoFunctionsReturnType = void | symbol;
+type DeepMergeIntoFunctionsReturnType = void | symbol;
 /**
  * All the merge functions that deepmerge uses.
  */
-type DeepMergeMergeIntoFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown[]>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Set<unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
-    mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeMergeIntoFunctionsReturnType;
+type DeepMergeIntoFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown[]>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<Set<unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+    mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeIntoFunctionUtils<M, MM>>(m_target: Reference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
 }>;
 /**
  * The utils provided to the merge functions.
  */
-type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeFunctions: DeepMergeMergeFunctions<M, MM>;
+type DeepMergeUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeFunctions: DeepMergeFunctions<M, MM>;
     defaultMergeFunctions: MergeFunctions$0;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
     useImplicitDefaultMerging: boolean;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
     actions: Readonly<{
         defaultMerge: symbol;
         skip: symbol;
@@ -684,11 +720,12 @@ type DeepMergeMergeFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData =
 /**
  * The utils provided to the merge functions.
  */
-type DeepMergeMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-    mergeFunctions: DeepMergeMergeIntoFunctions<M, MM>;
+type DeepMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+    mergeFunctions: DeepMergeIntoFunctions<M, MM>;
     defaultMergeFunctions: MergeIntoFunctions;
     metaDataUpdater: MetaDataUpdater<M, MM>;
     deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...values: Ts) => void;
+    filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
     actions: Readonly<{
         defaultMerge: symbol;
     }>;
@@ -700,20 +737,20 @@ type DeepMergeMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaDa
  */
 declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
     ...Ts
-]): DeepMergeHKT<Ts, DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
+]): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, 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<BaseTs = unknown, PMF extends Partial<DeepMergeMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<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<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>;
+declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
 /**
  * Deeply merge objects into a target.
  *
@@ -730,7 +767,7 @@ declare function deepmergeInto<T extends object>(target: T, ...objects: Readonly
 declare function deepmergeInto<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is SimplifyObject<Target & DeepMergeHKT<[
     Target,
     ...Ts
-], DeepMergeMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
+], DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
 /**
  * Deeply merge two or more objects using the given options.
  *
@@ -780,4 +817,4 @@ declare function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey>;
  */
 declare function objectHasProperty(object: object, property: PropertyKey): boolean;
 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 };
+export type { MergeFunctions as DeepMergeIntoFunctionsDefaults, MergeFunctions$0 as DeepMergeFunctionsDefaults, DeepMergeArraysDefaultHKT, DeepMergeBuiltInMetaData, DeepMergeHKT, DeepMergeLeaf, DeepMergeLeafURI, DeepMergeNoFilteringURI, DeepMergeMapsDefaultHKT, DeepMergeFunctionsDefaultURIs, DeepMergeFunctionsURIs, DeepMergeFunctionURItoKind, DeepMergeUtils, DeepMergeIntoFunctionUtils, DeepMergeOptions, DeepMergeIntoOptions, DeepMergeRecordsDefaultHKT, DeepMergeSetsDefaultHKT, Reference as DeepMergeValueReference, GetDeepMergeFunctionsURIs, FilterOut };
diff --git a/dist/node/index.mjs b/dist/node/index.mjs
index f8386ad0..d71554bb 100644
--- a/dist/node/index.mjs
+++ b/dist/node/index.mjs
@@ -14,10 +14,20 @@ const actionsInto = {
 
 /**
  * The default function to update meta data.
+ *
+ * It doesn't update the meta data.
  */
 function defaultMetaDataUpdater(previousMeta, metaMeta) {
     return metaMeta;
 }
+/**
+ * The default function to filter values.
+ *
+ * It filters out undefined values.
+ */
+function defaultFilterValues(values, meta) {
+    return values.filter((value) => value !== undefined);
+}
 
 /**
  * The different types of objects deepmerge-ts support.
@@ -201,12 +211,7 @@ function mergeMaps$2(values) {
  * Get the last non-undefined value in the given array.
  */
 function mergeOthers$2(values) {
-    for (let i = values.length - 1; i >= 0; i--) {
-        if (values[i] !== undefined) {
-            return values[i];
-        }
-    }
-    return undefined;
+    return values.at(-1);
 }
 
 var defaultMergeFunctions = /*#__PURE__*/Object.freeze({
@@ -256,6 +261,9 @@ function getUtils(options, customizedDeepmerge) {
             defaultMetaDataUpdater),
         deepmerge: customizedDeepmerge,
         useImplicitDefaultMerging: options.enableImplicitDefaultMerging ?? false,
+        filterValues: options.filterValues === false
+            ? undefined
+            : options.filterValues ?? defaultFilterValues,
         actions,
     };
 }
@@ -265,36 +273,37 @@ function getUtils(options, customizedDeepmerge) {
  * @param values - The values.
  */
 function mergeUnknowns(values, utils, meta) {
-    if (values.length === 0) {
+    const filteredValues = utils.filterValues?.(values, meta) ?? values;
+    if (filteredValues.length === 0) {
         return undefined;
     }
-    if (values.length === 1) {
-        return mergeOthers$1(values, utils, meta);
+    if (filteredValues.length === 1) {
+        return mergeOthers$1(filteredValues, utils, meta);
     }
-    const type = getObjectType(values[0]);
+    const type = getObjectType(filteredValues[0]);
     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) {
+        for (let m_index = 1; m_index < filteredValues.length; m_index++) {
+            if (getObjectType(filteredValues[m_index]) === type) {
                 continue;
             }
-            return mergeOthers$1(values, utils, meta);
+            return mergeOthers$1(filteredValues, utils, meta);
         }
     }
     switch (type) {
         case 1 /* ObjectType.RECORD */: {
-            return mergeRecords$1(values, utils, meta);
+            return mergeRecords$1(filteredValues, utils, meta);
         }
         case 2 /* ObjectType.ARRAY */: {
-            return mergeArrays$1(values, utils, meta);
+            return mergeArrays$1(filteredValues, utils, meta);
         }
         case 3 /* ObjectType.SET */: {
-            return mergeSets$1(values, utils, meta);
+            return mergeSets$1(filteredValues, utils, meta);
         }
         case 4 /* ObjectType.MAP */: {
-            return mergeMaps$1(values, utils, meta);
+            return mergeMaps$1(filteredValues, utils, meta);
         }
         default: {
-            return mergeOthers$1(values, utils, meta);
+            return mergeOthers$1(filteredValues, utils, meta);
         }
     }
 }
@@ -448,13 +457,7 @@ function mergeMaps(m_target, values) {
  * Set the target to the last non-undefined value.
  */
 function mergeOthers(m_target, values) {
-    for (let i = values.length - 1; i >= 0; i--) {
-        if (values[i] !== undefined) {
-            m_target.value = values[i];
-            return;
-        }
-    }
-    m_target.value = undefined;
+    m_target.value = values.at(-1);
 }
 
 var defaultMergeIntoFunctions = /*#__PURE__*/Object.freeze({
@@ -498,6 +501,9 @@ function getIntoUtils(options, customizedDeepmergeInto) {
         metaDataUpdater: (options.metaDataUpdater ??
             defaultMetaDataUpdater),
         deepmergeInto: customizedDeepmergeInto,
+        filterValues: options.filterValues === false
+            ? undefined
+            : options.filterValues ?? defaultFilterValues,
         actions: actionsInto,
     };
 }
@@ -508,36 +514,37 @@ function getIntoUtils(options, customizedDeepmergeInto) {
  * @param values - The values.
  */
 function mergeUnknownsInto(m_target, values, utils, meta) {
-    if (values.length === 0) {
+    const filteredValues = utils.filterValues?.(values, meta) ?? values;
+    if (filteredValues.length === 0) {
         return;
     }
-    if (values.length === 1) {
-        return void mergeOthersInto(m_target, values, utils, meta);
+    if (filteredValues.length === 1) {
+        return void mergeOthersInto(m_target, filteredValues, utils, meta);
     }
     const type = getObjectType(m_target.value);
     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) {
+        for (let m_index = 1; m_index < filteredValues.length; m_index++) {
+            if (getObjectType(filteredValues[m_index]) === type) {
                 continue;
             }
-            return void mergeOthersInto(m_target, values, utils, meta);
+            return void mergeOthersInto(m_target, filteredValues, utils, meta);
         }
     }
     switch (type) {
         case 1 /* ObjectType.RECORD */: {
-            return void mergeRecordsInto(m_target, values, utils, meta);
+            return void mergeRecordsInto(m_target, filteredValues, utils, meta);
         }
         case 2 /* ObjectType.ARRAY */: {
-            return void mergeArraysInto(m_target, values, utils, meta);
+            return void mergeArraysInto(m_target, filteredValues, utils, meta);
         }
         case 3 /* ObjectType.SET */: {
-            return void mergeSetsInto(m_target, values, utils, meta);
+            return void mergeSetsInto(m_target, filteredValues, utils, meta);
         }
         case 4 /* ObjectType.MAP */: {
-            return void mergeMapsInto(m_target, values, utils, meta);
+            return void mergeMapsInto(m_target, filteredValues, utils, meta);
         }
         default: {
-            return void mergeOthersInto(m_target, values, utils, meta);
+            return void mergeOthersInto(m_target, filteredValues, utils, meta);
         }
     }
 }