npm - @mavogel/awscdk-rootmail - Versions diffs - 0.1.2 → 0.1.3 - Mend

@mavogel/awscdk-rootmail 0.1.2 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1984) hide show

package/node_modules/deepmerge-ts/dist/index.d.mts CHANGED Viewed

@@ -1,180 +1,50 @@
 // Generated by dts-bundle-generator v9.5.1
-/**
- * Simplify a complex type such as a union or intersection of objects into a
- * single object.
- */
-export type SimplifyObject<T extends {}> = {
+type SimplifyObject<T extends {}> = {
 	[K in keyof T]: T[K];
 } & {};
-/**
- * Flatten a collection of tuples of tuples into a collection of tuples.
- */
-export type FlattenTuples<T> = {
-	[I in keyof T]: FlattenTuple<T[I]>;
-};
-/**
- * Flatten a tuple of tuples into a single tuple.
- */
-export type FlattenTuple<T> = T extends readonly [
-] ? [
-] : T extends readonly [
-	infer T0
-] ? [
-	...FlattenTuple<T0>
-] : T extends readonly [
-	infer T0,
-	...infer Ts
-] ? [
-	...FlattenTuple<T0>,
-	...FlattenTuple<Ts>
-] : [
-	T
-];
-/**
- * Safely test whether or not the first given types extends the second.
- *
- * Needed in particular for testing if a type is "never".
- */
-export type Is<T1, T2> = [
+type Is<T1, T2> = [
 	T1
 ] extends [
 	T2
 ] ? true : false;
-/**
- * Safely test whether or not the given type is "never".
- */
-export type IsNever<T> = Is<T, never>;
-/**
- * And operator for types.
- */
-export type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
-/**
- * Not operator for types.
- */
-export type Not<T extends boolean> = T extends true ? false : true;
-/**
- * Check if a key is optional in the given object.
- */
-export type KeyIsOptional<K extends PropertyKey, O extends {
-	[Key in K]?: unknown;
-}> = O extends {
-	[Key in K]: unknown;
-} ? false : true;
-/**
- * Returns whether or not the given type a record.
- *
- * Note: Does not pass for interfaces.
- */
-export type IsRecord<T> = And<Not<IsNever<T>>, T extends Readonly<Record<PropertyKey, unknown>> ? true : false>;
-/**
- * Returns whether or not all the given types are records.
- */
-export type EveryIsRecord<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
-	infer Head,
-	...infer Rest
-] ? IsRecord<Head> extends true ? Rest extends ReadonlyArray<unknown> ? EveryIsRecord<Rest> : true : false : true;
-/**
- * Returns whether or not the given type is an array.
- */
-export type IsArray<T> = And<Not<IsNever<T>>, T extends ReadonlyArray<unknown> ? true : false>;
-/**
- * Returns whether or not all the given types are arrays.
- */
-export type EveryIsArray<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
-	infer T1
-] ? IsArray<T1> : Ts extends readonly [
-	infer Head,
-	...infer Rest
-] ? IsArray<Head> extends true ? Rest extends readonly [
-	unknown,
-	...ReadonlyArray<unknown>
-] ? EveryIsArray<Rest> : false : false : false;
-/**
- * Returns whether or not the given type is an set.
- *
- * Note: This may also return true for Maps.
- */
-export type IsSet<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlySet<unknown>> ? true : false>;
-/**
- * Returns whether or not all the given types are sets.
- *
- * Note: This may also return true if all are maps.
- */
-export type EveryIsSet<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [
-	infer T1
-]> ? IsSet<T1> : Ts extends readonly [
-	infer Head,
-	...infer Rest
-] ? IsSet<Head> extends true ? Rest extends readonly [
-	unknown,
-	...ReadonlyArray<unknown>
-] ? EveryIsSet<Rest> : false : false : false;
-/**
- * Returns whether or not the given type is an map.
- */
-export type IsMap<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlyMap<unknown, unknown>> ? true : false>;
-/**
- * Returns whether or not all the given types are maps.
- */
-export type EveryIsMap<Ts extends ReadonlyArray<unknown>> = Ts extends Readonly<readonly [
-	infer T1
-]> ? IsMap<T1> : Ts extends readonly [
-	infer Head,
-	...infer Rest
-] ? IsMap<Head> extends true ? Rest extends readonly [
-	unknown,
-	...ReadonlyArray<unknown>
-] ? EveryIsMap<Rest> : false : false : false;
-/**
- * Union of the sets' values' types
- */
-export type UnionSetValues<Ts extends ReadonlyArray<unknown>> = UnionSetValuesHelper<Ts, never>;
-/**
- * Tail-recursive helper type for UnionSetValues.
- */
-export type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+type IsNever<T> = Is<T, never>;
+type IsUnion<T, U = T> = T extends unknown ? ([
+	U
+] extends [
+	T
+] ? false : true) : never;
+type And<T1 extends boolean, T2 extends boolean> = T1 extends false ? false : T2;
+type Not<T extends boolean> = T extends true ? false : true;
+type KeyIsOptional<K extends PropertyKey, O extends Partial<Record<K, unknown>>> = O extends Record<K, unknown> ? false : true;
+type IsRecord<T> = And<Not<IsNever<T>>, T extends Readonly<Record<PropertyKey, unknown>> ? true : false>;
+type IsArray<T> = And<Not<IsNever<T>>, T extends ReadonlyArray<unknown> ? true : false>;
+type IsSet<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlySet<unknown>> ? true : false>;
+type IsMap<T> = And<Not<IsNever<T>>, T extends Readonly<ReadonlyMap<unknown, unknown>> ? true : false>;
+type UnionSetValues<Ts extends ReadonlyArray<unknown>> = UnionSetValuesHelper<Ts, never>;
+type UnionSetValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
 	infer Head,
 	...infer Rest
 ] ? Head extends Readonly<ReadonlySet<infer V1>> ? Rest extends ReadonlyArray<unknown> ? UnionSetValuesHelper<Rest, Acc | V1> : Acc | V1 : never : Acc;
-/**
- * Union of the maps' values' types
- */
-export type UnionMapKeys<Ts extends ReadonlyArray<unknown>> = UnionMapKeysHelper<Ts, never>;
-/**
- * Tail-recursive helper type for UnionMapKeys.
- */
-export type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+type UnionMapKeys<Ts extends ReadonlyArray<unknown>> = UnionMapKeysHelper<Ts, never>;
+type UnionMapKeysHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
 	infer Head,
 	...infer Rest
 ] ? Head extends Readonly<ReadonlyMap<infer K1, unknown>> ? Rest extends readonly [
 ] ? Acc | K1 : UnionMapKeysHelper<Rest, Acc | K1> : never : Acc;
-/**
- * Union of the maps' keys' types
- */
-export type UnionMapValues<Ts extends ReadonlyArray<unknown>> = UnionMapValuesHelper<Ts, never>;
-/**
- * Tail-recursive helper type for UnionMapValues.
- */
-export type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
+type UnionMapValues<Ts extends ReadonlyArray<unknown>> = UnionMapValuesHelper<Ts, never>;
+type UnionMapValuesHelper<Ts extends ReadonlyArray<unknown>, Acc> = Ts extends readonly [
 	infer Head,
 	...infer Rest
 ] ? Head extends Readonly<ReadonlyMap<unknown, infer V1>> ? Rest extends readonly [
 ] ? Acc | V1 : UnionMapValuesHelper<Rest, Acc | V1> : never : Acc;
-/**
- * Use the more precise type if the types are compatible.
- * Otherwise, union them.
- */
-export type PreciseOrUnion<A, B> = A extends B ? A : B extends A ? B : A | B;
+type PreciseOrUnion<A, B> = A extends B ? A : B extends A ? B : A | B;
 /**
  * Filter out U from a tuple.
  */
 export type FilterOut<T extends ReadonlyArray<unknown>, U> = FilterOutHelper<T, U, [
 ]>;
-/**
- * Tail-recursive helper type for FilterOut.
- */
-export type FilterOutHelper<T extends ReadonlyArray<unknown>, U, 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
@@ -182,102 +52,27 @@ export type FilterOutHelper<T extends ReadonlyArray<unknown>, U, Acc extends Rea
 	...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?
- */
-export type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [
+type IsTuple<T extends ReadonlyArray<unknown>> = T extends readonly [
 ] ? true : T extends readonly [
 	unknown,
 	...ReadonlyArray<unknown>
 ] ? true : false;
-/**
- * Perfrom a transpose operation on a 2D tuple.
- */
-export type TransposeTuple<T> = T extends readonly [
-	...(readonly [
-		...unknown[]
-	])
-] ? T extends readonly [
-] ? [
-] : T extends readonly [
-	infer X extends ReadonlyArray<unknown>
-] ? TransposeTupleSimpleCase<X> : T extends readonly [
-	infer X extends ReadonlyArray<unknown>,
-	...infer XS extends ReadonlyArray<ReadonlyArray<unknown>>
-] ? PrependCol<X, TransposeTuple<XS>> : T : never;
-export type PrependCol<T extends ReadonlyArray<unknown>, S extends ReadonlyArray<ReadonlyArray<unknown>>> = T extends readonly [
-] ? S extends readonly [
-] ? [
-] : never : T extends readonly [
-	infer X,
-	...infer XS
-] ? S extends readonly [
-	readonly [
-		...infer Y
-	],
-	...infer YS extends ReadonlyArray<ReadonlyArray<unknown>>
-] ? [
-	[
-		X,
-		...Y
-	],
-	...PrependCol<XS, YS>
-] : never : never;
-export type TransposeTupleSimpleCase<T extends readonly [
-	...unknown[]
-]> = T extends readonly [
-] ? [
-] : T extends readonly [
-	infer X,
-	...infer XS
-] ? [
-	[
-		X
-	],
-	...TransposeTupleSimpleCase<XS>
-] : never;
-/**
- * Convert a tuple to an intersection of each of its types.
- */
-export type TupleToIntersection<T extends ReadonlyArray<unknown>> = {
-	[K in keyof T]: (x: T[K]) => void;
-} extends Record<number, (x: infer I) => void> ? I : never;
-/**
- * Convert a union to a tuple.
- *
- * Warning: The order of the elements is non-deterministic.
- * Warning 2: The union maybe me modified by the TypeScript engine before convertion.
- * Warning 3: This implementation relies on a hack/limitation in TypeScript.
- */
-export type UnionToTuple<T, L = LastOf<T>> = IsNever<T> extends true ? [
-] : [
-	...UnionToTuple<Exclude<T, L>>,
-	L
-];
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
-/**
- * Convert a tuple of tuples to a tuple of unions.
- */
-export type TupleTupleToTupleUnion<T extends ReadonlyArray<ReadonlyArray<unknown>>> = {
+type UnionToTuple<T, Acc extends ReadonlyArray<unknown> = [
+], L = LastOf<T>> = IsNever<T> extends true ? Acc : UnionToTuple<Exclude<T, L>, [
+	L,
+	...Acc
+]>;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type LastOf<T> = UnionToIntersection<T extends unknown ? () => T : never> extends () => infer R ? R : never;
+type TupleTupleToTupleUnion<T extends ReadonlyArray<ReadonlyArray<unknown>>> = {
 	[I in keyof T]: TupleToUnion<T[I]>;
 };
-/**
- * Convert a tuple to a union.
- */
-export type TupleToUnion<T extends ReadonlyArray<unknown>> = T extends readonly [
+type TupleToUnion<T extends ReadonlyArray<unknown>> = T extends readonly [
 ] ? never : T extends readonly [
 	infer Head,
 	...infer Rest
 ] ? Head | TupleToUnion<Rest> : never;
-/**
- * Assert that a type is of a given type.
- */
-export type AssertType<Expected, T> = T extends Expected ? T : never;
+type AssertType<Expected, T> = T extends Expected ? T : never;
 /**
  * Mapping of merge function URIs to the merge function type.
  */
@@ -287,17 +82,12 @@ export interface DeepMergeFunctionURItoKind<Ts extends ReadonlyArray<unknown>, F
 	readonly DeepMergeArraysDefaultURI: DeepMergeArraysDefaultHKT<Ts, Fs, M>;
 	readonly DeepMergeSetsDefaultURI: DeepMergeSetsDefaultHKT<Ts>;
 	readonly DeepMergeMapsDefaultURI: DeepMergeMapsDefaultHKT<Ts>;
+	readonly DeepMergeCircularReferencesURI: DeepMergeCircularReferencesDefaultHKT<Ts, Fs, M>;
 	readonly DeepMergeFilterValuesDefaultURI: DeepMergeFilterValuesDefaultHKT<Ts>;
 	readonly DeepMergeNoFilteringURI: Ts;
 }
-/**
- * Get the type of the given merge function via its URI.
- */
-export 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.
- */
-export type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown>;
+type DeepMergeFunctionKind<URI extends DeepMergeFunctionURIs, Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionURItoKind<Ts, Fs, M>[URI];
+type DeepMergeFunctionURIs = keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown>;
 /**
  * The merge functions to use when deep merging.
  */
@@ -331,35 +121,57 @@ export type DeepMergeFunctionsURIs = Readonly<{
  * Deep merge types.
  */
 export 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;
-export type DeepMergeHKTHelper<Ts, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<unknown> ? IsTuple<Ts> extends true ? Ts extends readonly [
+] ? undefined : DeepMergeSameTypeShortcut<Ts, Fs> extends true ? DeepMergeSameTypeElement<Ts> : 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.
- */
-export type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeRecordsURI"], Ts, Fs, M>;
-/**
- * Deep merge arrays.
- */
-export type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeArraysURI"], Ts, Fs, M>;
-/**
- * Deep merge sets.
- */
-export type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeSetsURI"], Ts, Fs, M>;
-/**
- * Deep merge maps.
- */
-export type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeMapsURI"], Ts, Fs, M>;
-/**
- * Deep merge other things.
- */
-export type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeOthersURI"], Ts, Fs, M>;
-/**
- * Filter values.
- */
-export type FilterValuesHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeFilterValuesURI"], Ts, Fs, M>;
+] ? T1 : DeepMergeDispatch<Ts, Fs, M, DeepMergeTupleKind<Ts>> : unknown : never;
+type DeepMergeSameTypeShortcut<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs> = Is<Fs, DeepMergeFunctionsDefaultURIs> extends true ? AllSameTypes<Ts> extends true ? Ts extends readonly [
+	infer T1,
+	...ReadonlyArray<unknown>
+] ? DeepMergeSameTypeShortcutElement<T1> extends true ? true : false : false : false : false;
+type DeepMergeSameTypeShortcutElement<T1> = DeepMergeSameTypeValueSound<T1, [
+]> extends true ? true : false;
+type DeepMergeSameTypeValueSound<V, Seen extends ReadonlyArray<unknown>> = [
+	V
+] extends [
+	Seen[number]
+] ? false : IsUnion<V> extends true ? false : undefined extends V ? false : V extends ReadonlyArray<unknown> ? V extends unknown[] ? Not<IsTuple<V>> : false : V extends ReadonlySet<unknown> ? V extends Set<unknown> ? true : false : V extends ReadonlyMap<unknown, unknown> ? V extends Map<unknown, unknown> ? true : false : V extends Readonly<Record<PropertyKey, unknown>> ? DeepMergeSameTypeRecordSound<V, [
+	V,
+	...Seen
+]> : true;
+type DeepMergeSameTypeRecordSound<T, Seen extends ReadonlyArray<unknown>> = {
+	[K in keyof T]-?: IsReadonlyProperty<T, K> extends true ? K : DeepMergeSameTypeValueSound<Required<T>[K], Seen> extends true ? never : K;
+}[keyof T] extends never ? true : false;
+type IsReadonlyProperty<T, K extends keyof T> = (<P>() => P extends {
+	[PK in K]: T[K];
+} ? 1 : 2) extends <P>() => P extends {
+	readonly [PK in K]: T[K];
+} ? 1 : 2 ? true : false;
+type DeepMergeSameTypeElement<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+	infer T1,
+	...ReadonlyArray<unknown>
+] ? T1 : never;
+type AllSameTypes<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? Rest extends ReadonlyArray<unknown> ? RestIsSameAs<Rest, Head> : true : true;
+type RestIsSameAs<Ts extends ReadonlyArray<unknown>, T> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? And<Is<Head, T>, Is<T, Head>> extends true ? Rest extends ReadonlyArray<unknown> ? RestIsSameAs<Rest, T> : true : false : true;
+type DeepMergeDispatch<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M, Kind> = Kind extends "array" ? DeepMergeArraysHKT<Ts, Fs, M> : Kind extends "map" ? DeepMergeMapsHKT<Ts, Fs, M> : Kind extends "set" ? DeepMergeSetsHKT<Ts, Fs, M> : Kind extends "record" ? DeepMergeRecordsHKT<Ts, Fs, M> : DeepMergeOthersHKT<Ts, Fs, M>;
+type DeepMergeElementKind<T> = IsArray<T> extends true ? "array" : IsMap<T> extends true ? "map" : IsSet<T> extends true ? "set" : IsRecord<T> extends true ? "record" : "other";
+type DeepMergeTupleKind<Ts extends ReadonlyArray<unknown>> = DeepMergeKinds<Ts> extends "array" ? "array" : DeepMergeKinds<Ts> extends "map" ? "map" : DeepMergeKinds<Ts> extends "set" ? "set" : DeepMergeKinds<Ts> extends "record" ? "record" : "other";
+type DeepMergeKinds<Ts extends ReadonlyArray<unknown>> = {
+	[I in keyof Ts]: DeepMergeElementKind<Ts[I]>;
+}[number];
+type DeepMergeRecordsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeRecordsURI"], Ts, Fs, M>;
+type DeepMergeArraysHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeArraysURI"], Ts, Fs, M>;
+type DeepMergeSetsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeSetsURI"], Ts, Fs, M>;
+type DeepMergeMapsHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeMapsURI"], Ts, Fs, M>;
+type DeepMergeOthersHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeOthersURI"], Ts, Fs, M>;
+type FilterValuesHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeFunctionKind<Fs["DeepMergeFilterValuesURI"], Ts, Fs, M>;
 /**
  * The merge function that returns a leaf.
  */
@@ -378,42 +190,57 @@ export type DeepMergeLeaf<Ts extends ReadonlyArray<unknown>, Fs extends DeepMerg
 	...infer Rest,
 	infer Tail
 ] ? IsNever<Tail> extends true ? Rest extends ReadonlyArray<unknown> ? DeepMergeLeaf<Rest, Fs, M> : never : DeepMergeLeafApplyFilter<Ts, AssertType<ReadonlyArray<unknown>, TupleTupleToTupleUnion<AssertType<ReadonlyArray<ReadonlyArray<unknown>>, {
-	[I in keyof Ts]: FilterValuesHKT<UnionToTuple<Ts[I]>, Fs, M>;
+	[I in keyof Ts]: DeepMergeLeafElement<Ts[I], Fs, M>;
 }>>>> : never;
-export type DeepMergeLeafApplyFilter<Original extends ReadonlyArray<unknown>, Filtered extends ReadonlyArray<unknown>> = Original extends readonly [
+type DeepMergeLeafElement<E, Fs extends DeepMergeFunctionsURIs, M> = Fs["DeepMergeFilterValuesURI"] extends DeepMergeFilterValuesDefaultURI ? [
+	E extends undefined ? never : E
+] : FilterValuesHKT<UnionToTuple<E>, Fs, M>;
+type DeepMergeLeafApplyFilter<Original extends ReadonlyArray<unknown>, Filtered extends ReadonlyArray<unknown>> = Original extends readonly [
 	...infer OriginalRest,
 	infer OriginalTail
 ] ? Filtered extends readonly [
 	...infer FilteredRest,
 	infer FilteredTail
 ] ? OriginalTail extends FilteredTail ? FilteredTail : FilteredTail | DeepMergeLeafApplyFilter<OriginalRest, FilteredRest> : never : never;
-/**
- * The meta data deepmerge is able to provide.
- */
-export type DeepMergeBuiltInMetaData = Readonly<{
-	key: PropertyKey;
-	parents: ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>;
+type HierarchyValue = Readonly<{
+	key: unknown;
+	parents: ReadonlyArray<unknown>;
+	values: ReadonlyArray<unknown>;
+	result: unknown;
 }>;
+type DeepMergeRootMetaData = undefined;
 /**
- * The default merge function to merge records with.
- */
-export type DeepMergeRecordsDefaultURI = "DeepMergeRecordsDefaultURI";
-/**
- * The default merge function to merge arrays with.
- */
-export type DeepMergeArraysDefaultURI = "DeepMergeArraysDefaultURI";
-/**
- * The default merge function to merge sets with.
+ * The built-in metadata type used by deepmerge.
  */
-export type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI";
+export type DeepMergeBuiltInMetaData = DeepMergeRootMetaData | (Partial<DeepMergeMergeInfo> & Readonly<{
+	hierarchy?: ReadonlyArray<HierarchyValue>;
+}>);
 /**
- * The default merge function to merge maps with.
+ * The metadata type used by deepmerge.
  */
-export type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI";
+export type DeepMergeMetaData = unknown;
 /**
- * The default filter values function.
- */
-export type DeepMergeFilterValuesDefaultURI = "DeepMergeFilterValuesDefaultURI";
+ * Information about a single merge step, passed to {@link MetaDataUpdater}.
+ *
+ * - `key` — the property key being merged (e.g. a `Record` property name,
+ * an array index for arrays, or `undefined` for the top-level merge).
+ * - `parents` — the input values (in their original positions) that are
+ * being merged at this step. For `deepmergeInto` these include the
+ * target's value at index 0.
+ * - `values` — the candidate values for `key` extracted from `parents`.
+ * - `result` — the partial merge result computed so far for this step.
+ */
+export type DeepMergeMergeInfo = Readonly<{
+	key: unknown;
+	parents: ReadonlyArray<unknown>;
+	values: ReadonlyArray<unknown>;
+	result: unknown;
+}>;
+type DeepMergeRecordsDefaultURI = "DeepMergeRecordsDefaultURI";
+type DeepMergeArraysDefaultURI = "DeepMergeArraysDefaultURI";
+type DeepMergeSetsDefaultURI = "DeepMergeSetsDefaultURI";
+type DeepMergeMapsDefaultURI = "DeepMergeMapsDefaultURI";
+type DeepMergeFilterValuesDefaultURI = "DeepMergeFilterValuesDefaultURI";
 /**
  * The default merge functions to use when deep merging.
  */
@@ -425,157 +252,165 @@ export type DeepMergeFunctionsDefaultURIs = Readonly<{
 	DeepMergeOthersURI: DeepMergeLeafURI;
 	DeepMergeFilterValuesURI: DeepMergeFilterValuesDefaultURI;
 }>;
-export type RecordEntries<T extends Record<PropertyKey, unknown>> = FilterOut<UnionToTuple<{
-	[K in keyof T]: [
-		K,
-		T[K]
-	];
-}[keyof T]>, undefined>;
-export type RecordMeta = Record<PropertyKey, RecordPropertyMeta>;
-export type RecordPropertyMeta<Key extends PropertyKey = PropertyKey, Value = unknown, Optional extends boolean = boolean> = {
+type KnownKeys<T> = keyof {
+	[K in keyof T as string extends K ? never : number extends K ? never : symbol extends K ? never : K]: unknown;
+};
+type RecordPropertyMeta<Key extends PropertyKey = PropertyKey, Value = unknown, Optional extends boolean = boolean> = {
 	key: Key;
 	value: Value;
 	optional: Optional;
 };
-export type RecordsToRecordMeta<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>> = FilterOutNever<{
-	[I in keyof Ts]: RecordToRecordMeta<Ts[I]>;
-}>;
-export type RecordToRecordMeta<T extends Record<PropertyKey, unknown>> = {
-	[K in keyof T]-?: {
-		key: K;
-		value: Required<T>[K];
-		optional: KeyIsOptional<K, T>;
-	};
-};
 /**
  * Deep merge records.
  */
-export 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.
- */
-export type DeepMergeRecordMetaDefaultHKTProps<RecordMetas, Fs extends DeepMergeFunctionsURIs, M> = RecordMetas extends ReadonlyArray<RecordMeta> ? CreateRecordFromMeta<MergeRecordMeta<RecordMetas>, Fs, M> : never;
-export type MergeRecordMeta<RecordMetas extends ReadonlyArray<RecordMeta>> = GroupValuesByKey<FlattenTuples<TransposeTuple<FilterOut<{
-	[I in keyof RecordMetas]: TransposeTuple<RecordEntries<RecordMetas[I]>>;
-}, readonly [
-]>>>>;
-export type GroupValuesByKey<Ts> = Ts extends readonly [
-	infer Keys extends ReadonlyArray<PropertyKey>,
-	infer Values
-] ? {
-	[I in keyof Keys]: DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Keys[I], FilterOutNever<{
-		[J in keyof Values]: Values[J] extends {
-			key: Keys[I];
-		} ? Values[J] : never;
-	}>>;
-} : never;
-export 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, Fs, M> : never;
-}> : never;
-export 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, Fs, M>;
+export type DeepMergeRecordsDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = Ts extends ReadonlyArray<Record<PropertyKey, unknown>> ? IsNever<RecordKeysOf<Ts>> extends true ? never : SimplifyObject<DeepMergeRecordProps<Ts, Fs, M>> : never;
+type DeepMergeRecordProps<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = {
+	[K in RequiredKeysOf<Ts>]: DeepMergeHKT<ValuesForKey<K, Ts>, Fs, M>;
+} & {
+	[K in OptionalKeysOf<Ts>]?: DeepMergeHKT<ValuesForKey<K, Ts>, Fs, M>;
 };
-/**
- * Get the possible types of a property.
- */
-export type DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Key extends PropertyKey, Ts> = Ts extends readonly [
+type RequiredKeysOf<Ts extends ReadonlyArray<unknown>> = {
+	[K in RecordKeysOf<Ts>]: OptionalForKey<K, Ts> extends true ? never : K;
+}[RecordKeysOf<Ts>];
+type OptionalKeysOf<Ts extends ReadonlyArray<unknown>> = {
+	[K in RecordKeysOf<Ts>]: OptionalForKey<K, Ts> extends true ? K : never;
+}[RecordKeysOf<Ts>];
+type RecordKeysOf<Ts extends ReadonlyArray<unknown>> = {
+	[I in keyof Ts]: RecordKeys<Ts[I]>;
+}[number];
+type RecordKeys<T> = IsNever<KnownKeys<T>> extends true ? keyof T : KnownKeys<T>;
+type ValuesForKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K, Ts> extends true ? DeepMergeRecordPropertyMetaDefaultHKTGetPossible<K, PresentMetasOfKey<K, Ts>>["values"] : DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K, Ts>;
+type OptionalForKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey<K, Ts>;
+type DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? K extends keyof Head ? Rest extends ReadonlyArray<unknown> ? [
+	Required<Head>[K],
+	...DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K, Rest>
+] : [
+	Required<Head>[K]
+] : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptionalOfKey<K, Rest> : [
+] : [
+];
+type DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? K extends keyof Head ? KeyIsOptional<K, Head> extends true ? true : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K, Rest> : false : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTHasOptionalOfKey<K, Rest> : false : false;
+type DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? K extends keyof Head ? KeyIsOptional<K, Head> : Rest extends ReadonlyArray<unknown> ? DeepMergeRecordPropertyMetaDefaultHKTGetOptionalOfKey<K, Rest> : never : never;
+type MetaOfKey<R, K extends PropertyKey> = K extends keyof R ? {
+	key: K;
+	value: Required<R>[K];
+	optional: KeyIsOptional<K, R>;
+} : never;
+type PresentMetasOfKey<K extends PropertyKey, Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? K extends keyof Head ? Rest extends ReadonlyArray<unknown> ? [
+	MetaOfKey<Head, K>,
+	...PresentMetasOfKey<K, Rest>
+] : [
+	MetaOfKey<Head, K>
+] : Rest extends ReadonlyArray<unknown> ? PresentMetasOfKey<K, Rest> : [
+] : [
+];
+type DeepMergeRecordPropertyMetaDefaultHKTGetPossible<Key extends PropertyKey, Ts> = Ts extends readonly [
 	RecordPropertyMeta,
 	...ReadonlyArray<RecordPropertyMeta>
-] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts, {
+] ? {
 	key: Key;
-	values: [
-	];
-	optional: never;
-}> : never;
-/**
- * Tail-recursive helper type for DeepMergeRecordPropertyMetaDefaultHKTGetPossible.
- */
-export type DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Ts extends readonly [
+	values: DeepMergeRecordPropertyMetaDefaultHKTGetValues<Ts>;
+	optional: DeepMergeRecordPropertyMetaDefaultHKTGetOptional<Ts>;
+} : never;
+type DeepMergeRecordPropertyMetaDefaultHKTGetValues<Ts extends readonly [
 	RecordPropertyMeta,
 	...ReadonlyArray<RecordPropertyMeta>
-], Acc extends {
-	key: PropertyKey;
-	values: ReadonlyArray<unknown>;
-	optional: boolean;
-}> = Ts extends [
+]> = DeepMergeRecordPropertyMetaDefaultHKTHasOptional<Ts> extends true ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Ts, [
+], false> : DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional<Ts>;
+type DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional<Ts extends readonly [
+	RecordPropertyMeta,
+	...ReadonlyArray<RecordPropertyMeta>
+]> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? Rest extends readonly [
+	RecordPropertyMeta,
+	...ReadonlyArray<RecordPropertyMeta>
+] ? [
+	Head extends {
+		value: infer V;
+	} ? V : never,
+	...DeepMergeRecordPropertyMetaDefaultHKTGetValuesNoOptional<Rest>
+] : [
+	Head extends {
+		value: infer V;
+	} ? V : never
+] : never;
+type DeepMergeRecordPropertyMetaDefaultHKTHasOptional<Ts extends readonly [
+	RecordPropertyMeta,
+	...ReadonlyArray<RecordPropertyMeta>
+]> = {
+	[I in keyof Ts]: Ts[I] extends {
+		optional: true;
+	} ? true : false;
+}[number] extends false ? false : true;
+type DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Ts extends readonly [
+	RecordPropertyMeta,
+	...ReadonlyArray<RecordPropertyMeta>
+], Acc extends ReadonlyArray<unknown>, AccOptional extends boolean> = Ts extends [
 	...infer Rest,
 	{
-		key: infer K extends PropertyKey;
 		value: infer V;
 		optional: infer O extends boolean;
 	}
-] ? Acc["optional"] extends true ? Acc extends {
-	values: [
-		infer Head,
-		...infer AccRest
-	];
-} ? Rest extends readonly [
+] ? AccOptional extends true ? Acc extends readonly [
+	infer Head,
+	...infer AccRest
+] ? Rest extends readonly [
 	RecordPropertyMeta,
 	...ReadonlyArray<RecordPropertyMeta>
-] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
-	key: K;
-	values: [
-		PreciseOrUnion<V, Head>,
-		...AccRest
-	];
-	optional: O;
-}> : {
-	key: K;
-	values: [
-		PreciseOrUnion<V, Head>,
-		...AccRest
-	];
-	optional: O;
-} : Rest extends readonly [
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Rest, [
+	PreciseOrUnion<V, Head>,
+	...AccRest
+], O> : [
+	PreciseOrUnion<V, Head>,
+	...AccRest
+] : Rest extends readonly [
 	RecordPropertyMeta,
 	...ReadonlyArray<RecordPropertyMeta>
-] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
-	key: K;
-	values: [
-		V,
-		...Acc["values"]
-	];
-	optional: O;
-}> : {
-	key: K;
-	values: [
-		V,
-		...Acc["values"]
-	];
-	optional: O;
-} : Rest extends readonly [
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Rest, [
+	V,
+	...Acc
+], O> : [
+	V,
+	...Acc
+] : Rest extends readonly [
 	RecordPropertyMeta,
 	...ReadonlyArray<RecordPropertyMeta>
-] ? DeepMergeRecordPropertyMetaDefaultHKTGetPossibleHelper<Rest, {
-	key: K;
-	values: [
-		V,
-		...Acc["values"]
-	];
-	optional: O;
-}> : {
-	key: K;
-	values: [
-		V,
-		...Acc["values"]
-	];
-	optional: O;
-} : never;
+] ? DeepMergeRecordPropertyMetaDefaultHKTGetValuesHelper<Rest, [
+	V,
+	...Acc
+], O> : [
+	V,
+	...Acc
+] : never;
+type DeepMergeRecordPropertyMetaDefaultHKTGetOptional<Ts extends readonly [
+	RecordPropertyMeta,
+	...ReadonlyArray<RecordPropertyMeta>
+]> = Ts extends readonly [
+	infer First,
+	...ReadonlyArray<RecordPropertyMeta>
+] ? First extends {
+	optional: infer O extends boolean;
+} ? O : never : never;
 /**
  * Deep merge arrays.
  */
 export type DeepMergeArraysDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeArraysDefaultHKTHelper<Ts, Fs, M, [
 ]>;
-/**
- * Tail-recursive helper type for DeepMergeArraysDefaultHKT.
- */
-export type DeepMergeArraysDefaultHKTHelper<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, 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 [
@@ -599,125 +434,143 @@ export type DeepMergeMapsDefaultHKT<Ts extends ReadonlyArray<unknown>> = Map<Uni
 /**
  * Filter out undefined values.
  */
-export type DeepMergeFilterValuesDefaultHKT<Ts extends ReadonlyArray<unknown>> = FilterOut<Ts, undefined>;
+export type DeepMergeFilterValuesDefaultHKT<Ts extends ReadonlyArray<unknown>> = DeepMergeFilterValuesShortcut<Ts> extends true ? Ts : FilterOut<Ts, undefined>;
+type DeepMergeFilterValuesShortcut<Ts extends ReadonlyArray<unknown>> = Ts extends readonly [
+	infer Head,
+	...infer Rest
+] ? Is<Head, undefined> extends true ? false : Rest extends ReadonlyArray<unknown> ? DeepMergeFilterValuesShortcut<Rest> : true : true;
 /**
  * Get the merge functions with defaults apply from the given subset.
  */
 export type GetDeepMergeFunctionsURIs<PMF extends Partial<DeepMergeFunctionsURIs>> = Readonly<{
-	DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
-	DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
-	DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
-	DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
-	DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
-	DeepMergeFilterValuesURI: PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind<any, any, any> ? PMF["DeepMergeFilterValuesURI"] : DeepMergeFilterValuesDefaultURI;
+	DeepMergeRecordsURI: PMF["DeepMergeRecordsURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeRecordsURI"] : DeepMergeRecordsDefaultURI;
+	DeepMergeArraysURI: PMF["DeepMergeArraysURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeArraysURI"] : DeepMergeArraysDefaultURI;
+	DeepMergeSetsURI: PMF["DeepMergeSetsURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeSetsURI"] : DeepMergeSetsDefaultURI;
+	DeepMergeMapsURI: PMF["DeepMergeMapsURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeMapsURI"] : DeepMergeMapsDefaultURI;
+	DeepMergeOthersURI: PMF["DeepMergeOthersURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeOthersURI"] : DeepMergeLeafURI;
+	DeepMergeFilterValuesURI: PMF["DeepMergeFilterValuesURI"] extends keyof DeepMergeFunctionURItoKind<ReadonlyArray<unknown>, DeepMergeFunctionsURIs, unknown> ? PMF["DeepMergeFilterValuesURI"] : DeepMergeFilterValuesDefaultURI;
 }>;
+/**
+ * Deep merge circular references.
+ */
+export type DeepMergeCircularReferencesDefaultHKT<Ts extends ReadonlyArray<unknown>, Fs extends DeepMergeFunctionsURIs, M> = DeepMergeLeaf<Ts, Fs, M>;
+declare function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): DeepMergeArraysDefaultHKT<Ts, Fs, M>;
+declare function mergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): DeepMergeSetsDefaultHKT<Ts>;
+declare function mergeOthers<Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils?: U, meta?: M): unknown;
+declare function mergeArraysInto<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(mut_target: DeepMergeValueReference<unknown[]>, values: Ts): void;
+declare function mergeSetsInto<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(mut_target: DeepMergeValueReference<Set<unknown>>, values: Ts): void;
+declare function mergeOthersInto<Ts extends ReadonlyArray<unknown>>(mut_target: DeepMergeValueReference<unknown>, values: Ts): void;
 /**
  * The default merge functions.
  */
-type MergeFunctions = {
-	mergeRecords: typeof mergeRecordsInto;
+type MergeFunctions<M extends DeepMergeMetaData = DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = {
+	mergeRecords: <Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => void;
 	mergeArrays: typeof mergeArraysInto;
 	mergeSets: typeof mergeSetsInto;
-	mergeMaps: typeof mergeMapsInto;
+	mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => void;
+	mergeCircularReferences: <Ts extends ReadonlyArray<object>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown>, values: Ts, utils: U, meta: M | undefined) => void;
 	mergeOthers: typeof mergeOthersInto;
 };
-declare function mergeRecordsInto<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeIntoFunctionUtils<M, MM>, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(mut_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined): void;
-declare function mergeArraysInto<Ts extends ReadonlyArray<ReadonlyArray<unknown>>>(mut_target: Reference<unknown[]>, values: Ts): void;
-declare function mergeSetsInto<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(mut_target: Reference<Set<unknown>>, values: Ts): void;
-declare function mergeMapsInto<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(mut_target: Reference<Map<unknown, unknown>>, values: Ts): void;
-declare function mergeOthersInto<Ts extends ReadonlyArray<unknown>>(mut_target: Reference<unknown>, values: Ts): void;
 /**
  * The default merge functions.
  */
-type MergeFunctions$1 = {
-	mergeRecords: typeof mergeRecords;
+type MergeFunctions$1<M extends DeepMergeMetaData = DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = {
+	mergeRecords: <Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs>(values: Ts, utils: U, meta: M) => DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
 	mergeArrays: typeof mergeArrays;
 	mergeSets: typeof mergeSets;
-	mergeMaps: typeof mergeMaps;
+	mergeMaps: <Ts extends ReadonlyArray<ReadonlyMap<unknown, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs>(values: Ts, utils: U, meta: M) => DeepMergeMapsDefaultHKT<Ts>;
+	mergeCircularReferences: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs>(values: Ts, cyclicDepths: ReadonlyArray<number>, utils: U, meta: M) => DeepMergeCircularReferencesDefaultHKT<Ts, Fs, M>;
 	mergeOthers: typeof mergeOthers;
 };
-declare function mergeRecords<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeUtils<M, MM>, Fs extends DeepMergeFunctionsURIs, M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(values: Ts, utils: U, meta: M | undefined): DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
-declare function mergeArrays<Ts extends ReadonlyArray<ReadonlyArray<unknown>>, Fs extends DeepMergeFunctionsURIs, M>(values: Ts): DeepMergeArraysDefaultHKT<Ts, Fs, M>;
-declare function mergeSets<Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>>(values: Ts): DeepMergeSetsDefaultHKT<Ts>;
-declare function mergeMaps<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>>(values: Ts): DeepMergeMapsDefaultHKT<Ts>;
-declare function mergeOthers<Ts extends ReadonlyArray<unknown>>(values: Ts): unknown;
 /**
  * The options the user can pass to customize deepmerge.
  */
-export type DeepMergeOptions<in out M, MM extends Readonly<Record<PropertyKey, unknown>> = {}> = Partial<DeepMergeOptionsFull<M, MM & DeepMergeBuiltInMetaData>>;
+export type DeepMergeOptions<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends Readonly<Record<PropertyKey, unknown>> = {}> = Partial<DeepMergeOptionsFull<M, MI & DeepMergeMergeInfo>>;
+/**
+ * The options the user can pass to customize deepmergeFastUnsafe.
+ */
+export type DeepMergeFastUnsafeOptions = Partial<Omit<DeepMergeOptionsFull<undefined>, "metaDataUpdater" | "maxDepth" | "mergeCircularReferences">>;
 /**
  * The options the user can pass to customize deepmergeInto.
  */
-export type DeepMergeIntoOptions<in out M, MM extends Readonly<Record<PropertyKey, unknown>> = {}> = Partial<DeepMergeIntoOptionsFull<M, MM & DeepMergeBuiltInMetaData>>;
-export type MetaDataUpdater<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = (previousMeta: M | undefined, metaMeta: Readonly<Partial<MM>>) => M;
+export type DeepMergeIntoOptions<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends Readonly<Record<PropertyKey, unknown>> = {}> = Partial<DeepMergeIntoOptionsFull<M, MI & DeepMergeMergeInfo>>;
 /**
- * All the options the user can pass to customize deepmerge.
+ * The options the user can pass to customize deepmergeIntoFastUnsafe.
  */
-export type DeepMergeOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-	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>;
+export type DeepMergeIntoFastUnsafeOptions = Partial<Omit<DeepMergeIntoOptionsFull<undefined>, "metaDataUpdater" | "maxDepth" | "mergeCircularReferences">>;
+type MetaDataUpdater<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = (previousMeta: M | undefined, mergeInfo: Readonly<Partial<MI>>) => M;
+type DeepMergeOptionsFull<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
+	mergeRecords: DeepMergeFunctions<M, MI>["mergeRecords"] | false;
+	mergeArrays: DeepMergeFunctions<M, MI>["mergeArrays"] | false;
+	mergeMaps: DeepMergeFunctions<M, MI>["mergeMaps"] | false;
+	mergeSets: DeepMergeFunctions<M, MI>["mergeSets"] | false;
+	mergeCircularReferences: DeepMergeFunctions<M, MI>["mergeCircularReferences"] | false;
+	mergeOthers: DeepMergeFunctions<M, MI>["mergeOthers"];
+	metaDataUpdater: MetaDataUpdater<M, MI>;
 	enableImplicitDefaultMerging: boolean;
 	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
+	/**
+	 * The maximum depth to merge to. When reached, further nested objects will not be deeply merged.
+	 * Useful for preventing stack exhaustion when merging untrusted input.
+	 *
+	 * @default 1000
+	 */
+	maxDepth: number;
 }>;
-/**
- * All the options the user can pass to customize deepmergeInto.
- */
-export type DeepMergeIntoOptionsFull<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-	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>;
+type DeepMergeIntoOptionsFull<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
+	mergeRecords: DeepMergeIntoFunctions<M, MI>["mergeRecords"] | false;
+	mergeArrays: DeepMergeIntoFunctions<M, MI>["mergeArrays"] | false;
+	mergeMaps: DeepMergeIntoFunctions<M, MI>["mergeMaps"] | false;
+	mergeSets: DeepMergeIntoFunctions<M, MI>["mergeSets"] | false;
+	mergeCircularReferences: DeepMergeIntoFunctions<M, MI>["mergeCircularReferences"] | false;
+	mergeOthers: DeepMergeIntoFunctions<M, MI>["mergeOthers"];
+	metaDataUpdater: MetaDataUpdater<M, MI>;
 	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | false;
+	/**
+	 * The maximum depth to merge to. When reached, further nested objects will not be deeply merged.
+	 * Useful for preventing stack exhaustion when merging untrusted input.
+	 *
+	 * @default 1000
+	 */
+	maxDepth: number;
 }>;
 /**
- * An object that has a reference to a value.
+ * An object that has a reference to a value being merged into.
  */
-type Reference<T> = {
+export type DeepMergeValueReference<T> = {
 	value: T;
 };
-/**
- * All the utility functions that can be overridden.
- */
-export type DeepMergeUtilityFunctions<in M> = Readonly<{
-	filterValues: <Ts extends ReadonlyArray<unknown>>(values: Ts, meta: M | undefined) => unknown[];
+type DeepMergeUtilityFunctions<in M extends DeepMergeMetaData = DeepMergeBuiltInMetaData> = Readonly<{
+	filterValues: <Ts extends ReadonlyArray<unknown>>(values: Ts, meta: M | undefined) => ReadonlyArray<unknown>;
 }>;
-/**
- * All the merge functions that deepmerge uses.
- */
-export 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;
+type DeepMergeFunctions<in M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
+	mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+	mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+	mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+	mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
+	mergeCircularReferences: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>>(values: Ts, cyclicDepths: ReadonlyArray<number>, utils: U, meta: M | undefined) => unknown;
+	mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeUtils<M, MI>>(values: Ts, utils: U, meta: M | undefined) => unknown;
 }>;
-export type DeepMergeIntoFunctionsReturnType = void | symbol;
-/**
- * All the merge functions that deepmerge uses.
- */
-export type DeepMergeIntoFunctions<in M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-	mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(mut_target: Reference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
-	mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(mut_target: Reference<unknown[]>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
-	mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoFunctionUtils<M, MM>>(mut_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>>(mut_target: Reference<Set<unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
-	mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeIntoFunctionUtils<M, MM>>(mut_target: Reference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+type DeepMergeIntoFunctionsReturnType = void | symbol;
+type DeepMergeIntoFunctions<in M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
+	mergeRecords: <Ts extends ReadonlyArray<Readonly<Record<PropertyKey, unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+	mergeArrays: <Ts extends ReadonlyArray<ReadonlyArray<unknown>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown[]>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+	mergeMaps: <Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Map<unknown, unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+	mergeSets: <Ts extends ReadonlyArray<Readonly<ReadonlySet<unknown>>>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<Set<unknown>>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+	mergeCircularReferences: <Ts extends ReadonlyArray<object>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
+	mergeOthers: <Ts extends ReadonlyArray<unknown>, U extends DeepMergeIntoUtils<M, MI>>(mut_target: DeepMergeValueReference<unknown>, values: Ts, utils: U, meta: M | undefined) => DeepMergeIntoFunctionsReturnType;
 }>;
 /**
  * The utils provided to the merge functions.
  */
-export type DeepMergeUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-	mergeFunctions: DeepMergeFunctions<M, MM>;
-	defaultMergeFunctions: MergeFunctions$1;
-	metaDataUpdater: MetaDataUpdater<M, MM>;
+export type DeepMergeUtils<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
+	mergeFunctions: DeepMergeFunctions<M, MI>;
+	defaultMergeFunctions: MergeFunctions$1<M, MI>;
+	metaDataUpdater: MetaDataUpdater<M, MI>;
 	deepmerge: <Ts extends ReadonlyArray<unknown>>(...values: Ts) => unknown;
 	useImplicitDefaultMerging: boolean;
 	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
+	maxDepth: number | undefined;
 	actions: Readonly<{
 		defaultMerge: symbol;
 		skip: symbol;
@@ -726,37 +579,111 @@ export type DeepMergeUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepM
 /**
  * The utils provided to the merge functions.
  */
-export type DeepMergeIntoFunctionUtils<in out M, MM extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData> = Readonly<{
-	mergeFunctions: DeepMergeIntoFunctions<M, MM>;
-	defaultMergeFunctions: MergeFunctions;
-	metaDataUpdater: MetaDataUpdater<M, MM>;
+export type DeepMergeIntoUtils<in out M extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo> = Readonly<{
+	mergeFunctions: DeepMergeIntoFunctions<M, MI>;
+	defaultMergeFunctions: MergeFunctions<M, MI>;
+	metaDataUpdater: MetaDataUpdater<M, MI>;
 	deepmergeInto: <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...values: Ts) => void;
 	filterValues: DeepMergeUtilityFunctions<M>["filterValues"] | undefined;
+	maxDepth: number | undefined;
 	actions: Readonly<{
 		defaultMerge: symbol;
 	}>;
 }>;
+/**
+ * The utils provided to the merge functions in fast mode.
+ */
+export type DeepMergeFastUnsafeUtils = DeepMergeUtils<undefined>;
+/**
+ * The utils provided to the into merge functions in fast mode.
+ */
+export type DeepMergeIntoFastUnsafeUtils = DeepMergeIntoUtils<undefined>;
 /**
  * Deeply merge objects.
  *
  * @param objects - The objects to merge.
+ * @returns The merged result.
  */
 export declare function deepmerge<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
 	...Ts
 ]): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>;
+/**
+ * Used by the default `deepmerge` function.
+ *
+ * @internal
+ * @returns A customized deepmerge function.
+ */
+export declare function deepmergeCustom(): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => 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.
+ * @returns A customized deepmerge function.
  */
-export declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, DeepMergeBuiltInMetaData>;
+export declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}>(options: DeepMergeOptions<DeepMergeBuiltInMetaData, DeepMergeMergeInfo>): <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.
+ * @param rootMetaData - The meta data passed to the root items being merged.
+ * @returns A customized deepmerge function.
+ * @example
+ * ```ts
+ * import { deepmergeCustom } from "deepmerge-ts";
+ *
+ * // Merge arrays by concatenation instead of last-wins.
+ * const merge = deepmergeCustom({
+ *   mergeArrays: (values) => values.flat(),
+ * });
+ *
+ * const result = merge({ tags: ["a"] }, { tags: ["b"] });
+ * // => { tags: ["a", "b"] }
+ * ```
  */
-export 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>;
+export declare function deepmergeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}, MetaData extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeMergeInfo = DeepMergeMergeInfo>(options: DeepMergeOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, MetaData>;
+/**
+ * Deeply merge objects using a high-performance strategy.
+ *
+ * Differences from `deepmerge` (standard version):
+ * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
+ * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
+ * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
+ * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
+ *
+ * @warning Only use this function with **trusted, non-circular data**.
+ * Using this function with untrusted user data can result in serious security vulnerabilities:
+ * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
+ * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
+ * @param objects - The objects to merge.
+ * @returns The merged result.
+ */
+export declare function deepmergeFastUnsafe<Ts extends Readonly<ReadonlyArray<unknown>>>(...objects: readonly [
+	...Ts
+]): DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, undefined>;
+/**
+ * Used by the default `deepmergeFastUnsafe` function.
+ *
+ * @internal
+ * @returns A customized deepmergeFastUnsafe function.
+ */
+export declare function deepmergeFastUnsafeCustom(): <Ts extends ReadonlyArray<unknown>>(...objects: Ts) => DeepMergeHKT<Ts, DeepMergeFunctionsDefaultURIs, undefined>;
+/**
+ * Deeply merge two or more objects using the given options and a high-performance strategy.
+ *
+ * Differences from `deepmergeCustom` (standard version):
+ * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
+ * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
+ * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
+ * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
+ *
+ * @warning Only use this function with **trusted, non-circular data**.
+ * Using this function with untrusted user data can result in serious security vulnerabilities:
+ * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
+ * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
+ * @param options - The options on how to customize the merge function.
+ * @returns A customized deepmergeFastUnsafe function.
+ */
+export declare function deepmergeFastUnsafeCustom<BaseTs = unknown, PMF extends Partial<DeepMergeFunctionsURIs> = {}>(options: DeepMergeFastUnsafeOptions): <Ts extends ReadonlyArray<BaseTs>>(...objects: Ts) => DeepMergeHKT<Ts, GetDeepMergeFunctionsURIs<PMF>, undefined>;
 /**
  * Deeply merge objects into a target.
  *
@@ -774,19 +701,110 @@ export declare function deepmergeInto<Target extends object, Ts extends Readonly
 	Target,
 	...Ts
 ], DeepMergeFunctionsDefaultURIs, DeepMergeBuiltInMetaData>>;
+/**
+ * Used by the default `deepmergeInto` function.
+ *
+ * @internal
+ * @returns A customized deepmergeInto function.
+ */
+export declare function deepmergeIntoCustom(): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
 /**
  * Deeply merge two or more objects using the given options.
  *
  * @param options - The options on how to customize the merge function.
+ * @returns A customized deepmergeInto function.
  */
-export declare function deepmergeIntoCustom<BaseTs = unknown>(options: DeepMergeIntoOptions<DeepMergeBuiltInMetaData, DeepMergeBuiltInMetaData>): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
+export declare function deepmergeIntoCustom<BaseTs = unknown>(options: DeepMergeIntoOptions<DeepMergeBuiltInMetaData, DeepMergeMergeInfo>): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
 /**
- * Deeply merge two or more objects using the given options and meta data.
+ * Deeply merge two or more objects into a target 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.
+ * @param rootMetaData - The meta data passed to the root items being merged.
+ * @returns A customized deepmergeInto function.
+ * @example
+ * ```ts
+ * import { deepmergeIntoCustom } from "deepmerge-ts";
+ *
+ * // Merge arrays by union instead of by concatenation.
+ * const mergeInto = deepmergeIntoCustom({
+ *   mergeArrays: (target, values) => {
+ *     const set = new Set(target.value);
+ *     for (const arr of values.slice(1)) {
+ *       for (const item of arr) {
+ *         set.add(item);
+ *       }
+ *     }
+ *     target.value = [...set];
+ *   },
+ * });
+ *
+ * const target = { tags: ["a"] };
+ * mergeInto(target, { tags: ["a", "b"] });
+ * // => { tags: ["a", "b"] }
+ * ```
  */
-export declare function deepmergeIntoCustom<BaseTs = unknown, MetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeBuiltInMetaData = DeepMergeBuiltInMetaData>(options: DeepMergeIntoOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
+export declare function deepmergeIntoCustom<BaseTs = unknown, MetaData extends DeepMergeMetaData = DeepMergeBuiltInMetaData, MetaMetaData extends DeepMergeMergeInfo = DeepMergeMergeInfo>(options: DeepMergeIntoOptions<MetaData, MetaMetaData>, rootMetaData?: MetaData): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
+/**
+ * Deeply merge objects into a target using a high-performance strategy.
+ *
+ * Differences from `deepmergeInto` (standard version):
+ * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
+ * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
+ * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
+ * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
+ *
+ * @warning Only use this function with **trusted, non-circular data**.
+ * Using this function with untrusted user data can result in serious security vulnerabilities:
+ * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
+ * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
+ * @param target - This object will be mutated with the merge result.
+ * @param objects - The objects to merge into the target.
+ */
+export declare function deepmergeIntoFastUnsafe<T extends object>(target: T, ...objects: ReadonlyArray<T>): void;
+/**
+ * Deeply merge objects into a target using a high-performance strategy.
+ *
+ * Differences from `deepmergeInto` (standard version):
+ * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
+ * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
+ * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
+ * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
+ *
+ * @warning Only use this function with **trusted, non-circular data**.
+ * Using this function with untrusted user data can result in serious security vulnerabilities:
+ * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
+ * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
+ * @param target - This object will be mutated with the merge result.
+ * @param objects - The objects to merge into the target.
+ */
+export declare function deepmergeIntoFastUnsafe<Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts): asserts target is SimplifyObject<Target & DeepMergeHKT<[
+	Target,
+	...Ts
+], DeepMergeFunctionsDefaultURIs, undefined>>;
+/**
+ * Used by the default `deepmergeIntoFastUnsafe` function.
+ *
+ * @internal
+ * @returns A customized deepmergeIntoFastUnsafe function.
+ */
+export declare function deepmergeIntoFastUnsafeCustom(): <Target extends object, Ts extends ReadonlyArray<unknown>>(target: Target, ...objects: Ts) => void;
+/**
+ * Deeply merge two or more objects into a target using the given options and a high-performance strategy.
+ *
+ * Differences from `deepmergeIntoCustom` (standard version):
+ * - **No circular reference detection:** Does not track object hierarchies or detect cyclic references. Circular structures will result in a stack overflow.
+ * - **No recursion depth limits:** Does not enforce a `maxDepth` limit (standard version defaults to 1000).
+ * - **No metadata tracking:** Metadata updates and custom metadata tracking are bypassed, avoiding metadata object allocations.
+ * - **No prototype pollution interception:** Assumes trusted data and directly assigns properties.
+ *
+ * @warning Only use this function with **trusted, non-circular data**.
+ * Using this function with untrusted user data can result in serious security vulnerabilities:
+ * - **Prototype pollution:** Prototype pollution safeguards are omitted for speed; malicious keys like `__proto__` can pollute object prototypes.
+ * - **Denial of Service (DoS):** Circular reference detection and recursion depth limits are disabled; cyclic or deeply nested input will cause infinite recursion and crash via stack overflow.
+ * @param options - The options on how to customize the merge function.
+ * @returns A customized deepmergeIntoFastUnsafe function.
+ */
+export declare function deepmergeIntoFastUnsafeCustom<BaseTs = unknown>(options: DeepMergeIntoFastUnsafeOptions): <Target extends object, Ts extends ReadonlyArray<BaseTs>>(target: Target, ...objects: Ts) => void;
 /**
  * The different types of objects deepmerge-ts support.
  */
@@ -805,6 +823,17 @@ export declare const enum ObjectType {
  * @returns The type of the given object.
  */
 export declare function getObjectType(object: unknown): ObjectType;
+/**
+ * Get the keys of the given object(s) including symbol keys.
+ * If an array is given, the keys of all the objects within the array are returned.
+ *
+ * Note: Only keys to enumerable properties are returned.
+ *
+ * @deprecated Use `getKeysOfObjects` instead.
+ * @param objects - An array of objects to get the keys of.
+ * @returns A set containing all the keys of all the given objects.
+ */
+export declare const getKeys: typeof getKeysOfObjects;
 /**
  * Get the keys of the given objects including symbol keys.
  *
@@ -813,7 +842,7 @@ export declare function getObjectType(object: unknown): ObjectType;
  * @param objects - An array of objects to get the keys of.
  * @returns A set containing all the keys of all the given objects.
  */
-export declare function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey>;
+export declare function getKeysOfObjects(objects: ReadonlyArray<object>): Set<PropertyKey>;
 /**
  * Does the given object have the given property.
  *
@@ -822,11 +851,36 @@ export declare function getKeys(objects: ReadonlyArray<object>): Set<PropertyKey
  * @returns Whether the object has the property.
  */
 export declare function objectHasProperty(object: object, property: PropertyKey): boolean;
+/**
+ * The fast default merge functions.
+ */
+type MergeFunctionsFast = {
+	mergeRecords: typeof mergeRecordsIntoFast;
+	mergeArrays: typeof mergeArraysInto;
+	mergeSets: typeof mergeSetsInto;
+	mergeMaps: typeof mergeMapsIntoFast;
+	mergeOthers: typeof mergeOthersInto;
+};
+declare function mergeRecordsIntoFast<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeIntoUtils<M, MI>, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(mut_target: DeepMergeValueReference<Record<PropertyKey, unknown>>, values: Ts, utils: U): void;
+declare function mergeMapsIntoFast<Ts extends ReadonlyArray<Readonly<ReadonlyMap<unknown, unknown>>>, U extends DeepMergeIntoUtils<M, MI>, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(mut_target: DeepMergeValueReference<Map<unknown, unknown>>, values: Ts, utils: U): void;
+/**
+ * The fast default merge functions.
+ */
+type MergeFunctionsFast$1 = {
+	mergeRecords: typeof mergeRecordsFast;
+	mergeArrays: typeof mergeArrays;
+	mergeSets: typeof mergeSets;
+	mergeMaps: typeof mergeMapsFast;
+	mergeOthers: typeof mergeOthers;
+};
+declare function mergeRecordsFast<Ts extends ReadonlyArray<Record<PropertyKey, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils: U): DeepMergeRecordsDefaultHKT<Ts, Fs, M>;
+declare function mergeMapsFast<Ts extends ReadonlyArray<ReadonlyMap<unknown, unknown>>, U extends DeepMergeUtils<M, MI>, Fs extends DeepMergeFunctionsURIs, M extends DeepMergeMetaData, MI extends DeepMergeMergeInfo = DeepMergeMergeInfo>(values: Ts, utils: U): DeepMergeMapsDefaultHKT<Ts>;
 export {
 	MergeFunctions as DeepMergeIntoFunctionsDefaults,
 	MergeFunctions$1 as DeepMergeFunctionsDefaults,
-	Reference as DeepMergeValueReference,
+	MergeFunctionsFast as DeepMergeIntoFunctionsDefaultsFastUnsafe,
+	MergeFunctionsFast$1 as DeepMergeFunctionsDefaultsFastUnsafe,
 };
 export {};