es-toolkit 1.50.0 → 1.51.0-dev.2065

package/dist/object/mergeWith.js

@@ -1,4 +1,5 @@
 const require_isPlainObject = require("../predicate/isPlainObject.js");
+const require_isMergeableValue = require("../_internal/isMergeableValue.js");
 const require_isUnsafeProperty = require("../_internal/isUnsafeProperty.js");
 //#region src/object/mergeWith.ts
 /**
@@ -58,10 +59,9 @@ function mergeWith(target, source, merge) {
 		const targetValue = target[key];
 		const merged = merge(targetValue, sourceValue, key, target, source);
 		if (merged !== void 0) target[key] = merged;
-		else if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith([], sourceValue, merge);
-		else if (require_isPlainObject.isPlainObject(sourceValue)) if (require_isPlainObject.isPlainObject(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith({}, sourceValue, merge);
+		else if (require_isMergeableValue.isMergeableValue(sourceValue) && require_isMergeableValue.isMergeableValue(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
+		else if (Array.isArray(sourceValue)) target[key] = mergeWith([], sourceValue, merge);
+		else if (require_isPlainObject.isPlainObject(sourceValue)) target[key] = mergeWith({}, sourceValue, merge);
 		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
 	}
 	return target;

package/dist/object/mergeWith.mjs

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../predicate/isPlainObject.mjs";
+import { isMergeableValue } from "../_internal/isMergeableValue.mjs";
 import { isUnsafeProperty } from "../_internal/isUnsafeProperty.mjs";
 //#region src/object/mergeWith.ts
 /**
@@ -58,10 +59,9 @@ function mergeWith(target, source, merge) {
 		const targetValue = target[key];
 		const merged = merge(targetValue, sourceValue, key, target, source);
 		if (merged !== void 0) target[key] = merged;
-		else if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith([], sourceValue, merge);
-		else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
-		else target[key] = mergeWith({}, sourceValue, merge);
+		else if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) target[key] = mergeWith(targetValue, sourceValue, merge);
+		else if (Array.isArray(sourceValue)) target[key] = mergeWith([], sourceValue, merge);
+		else if (isPlainObject(sourceValue)) target[key] = mergeWith({}, sourceValue, merge);
 		else if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;
 	}
 	return target;

package/dist/object/toCamelCaseKeys.d.mts

@@ -1,10 +1,6 @@
+import { ToCamelCaseKeys } from "../types/ToCamelCaseKeys.mjs";
+
 //#region src/object/toCamelCaseKeys.d.ts
-type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
-type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
-/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
-type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to camelCase.
  *

package/dist/object/toCamelCaseKeys.d.ts

@@ -1,10 +1,6 @@
+import { ToCamelCaseKeys } from "../types/ToCamelCaseKeys.js";
+
 //#region src/object/toCamelCaseKeys.d.ts
-type SnakeToCamel<S extends string> = S extends `${infer H}_${infer T}` ? `${Lowercase<H>}${Capitalize<SnakeToCamel<T>>}` : Lowercase<S>;
-type PascalToCamel<S extends string> = S extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : S;
-/** If it's snake_case, apply the snake_case rule; for uppercase keys, lowercase the entire string; otherwise, just lowercase the first letter (including PascalCase → camelCase). */
-type AnyToCamel<S extends string> = S extends `${string}_${string}` ? SnakeToCamel<S> : S extends Uppercase<S> ? Lowercase<S> : PascalToCamel<S>;
-type NonPlainObject = Date | RegExp | Map<any, any> | Set<any> | WeakMap<any, any> | WeakSet<any> | Promise<any> | Error | ArrayBuffer | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array | ((...args: any[]) => any) | typeof globalThis;
-type ToCamelCaseKeys<T> = T extends NonPlainObject ? T : T extends any[] ? Array<ToCamelCaseKeys<T[number]>> : T extends Record<string, any> ? { [K in keyof T as AnyToCamel<Extract<K, string>>]: ToCamelCaseKeys<T[K]> } : T;
 /**
  * Creates a new object composed of the properties with keys converted to camelCase.
  *

package/dist/object/toConstantCaseKeys.d.mts

@@ -0,0 +1,52 @@
+import { ToConstantCaseKeys } from "../types/ToConstantCaseKeys.mjs";
+
+//#region src/object/toConstantCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to CONSTANT_CASE format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to CONSTANT_CASE.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toConstantCaseKeys(obj);
+ * // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toConstantCaseKeys(arr);
+ * // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toConstantCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   USER_DATA: {
+ * //     USER_ID: 1,
+ * //     USER_ADDRESS: {
+ * //       STREET_NAME: 'Main St',
+ * //       ZIP_CODE: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toConstantCaseKeys<T>(obj: T): ToConstantCaseKeys<T>;
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toConstantCaseKeys.d.ts

@@ -0,0 +1,52 @@
+import { ToConstantCaseKeys } from "../types/ToConstantCaseKeys.js";
+
+//#region src/object/toConstantCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to CONSTANT_CASE format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to CONSTANT_CASE.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toConstantCaseKeys(obj);
+ * // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toConstantCaseKeys(arr);
+ * // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toConstantCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   USER_DATA: {
+ * //     USER_ID: 1,
+ * //     USER_ADDRESS: {
+ * //       STREET_NAME: 'Main St',
+ * //       ZIP_CODE: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toConstantCaseKeys<T>(obj: T): ToConstantCaseKeys<T>;
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toConstantCaseKeys.js

@@ -0,0 +1,66 @@
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_constantCase = require("../string/constantCase.js");
+//#region src/object/toConstantCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to CONSTANT_CASE format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to CONSTANT_CASE.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toConstantCaseKeys(obj);
+* // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toConstantCaseKeys(arr);
+* // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toConstantCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   USER_DATA: {
+* //     USER_ID: 1,
+* //     USER_ADDRESS: {
+* //       STREET_NAME: 'Main St',
+* //       ZIP_CODE: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toConstantCaseKeys(obj) {
+	if (require_isArray.isArray(obj)) return obj.map((item) => toConstantCaseKeys(item));
+	if (require_isPlainObject.isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const constantKey = require_constantCase.constantCase(key);
+			result[constantKey] = toConstantCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+exports.toConstantCaseKeys = toConstantCaseKeys;

package/dist/object/toConstantCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { constantCase } from "../string/constantCase.mjs";
+//#region src/object/toConstantCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to CONSTANT_CASE.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to CONSTANT_CASE format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to CONSTANT_CASE.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toConstantCaseKeys(obj);
+* // result will be { USER_ID: 1, FIRST_NAME: 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toConstantCaseKeys(arr);
+* // arrResult will be [{ USER_ID: 1, FIRST_NAME: 'John' }, { USER_ID: 2, FIRST_NAME: 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toConstantCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   USER_DATA: {
+* //     USER_ID: 1,
+* //     USER_ADDRESS: {
+* //       STREET_NAME: 'Main St',
+* //       ZIP_CODE: '12345'
+* //     }
+* //   }
+* // }
+*/
+function toConstantCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toConstantCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const constantKey = constantCase(key);
+			result[constantKey] = toConstantCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toConstantCaseKeys };

package/dist/object/toKebabCaseKeys.d.mts

@@ -0,0 +1,52 @@
+import { ToKebabCaseKeys } from "../types/ToKebabCaseKeys.mjs";
+
+//#region src/object/toKebabCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to kebab-case.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to kebab-case format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to kebab-case.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toKebabCaseKeys(obj);
+ * // result will be { 'user-id': 1, 'first-name': 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toKebabCaseKeys(arr);
+ * // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toKebabCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   'user-data': {
+ * //     'user-id': 1,
+ * //     'user-address': {
+ * //       'street-name': 'Main St',
+ * //       'zip-code': '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toKebabCaseKeys<T>(obj: T): ToKebabCaseKeys<T>;
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toKebabCaseKeys.d.ts

@@ -0,0 +1,52 @@
+import { ToKebabCaseKeys } from "../types/ToKebabCaseKeys.js";
+
+//#region src/object/toKebabCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to kebab-case.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to kebab-case format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to kebab-case.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toKebabCaseKeys(obj);
+ * // result will be { 'user-id': 1, 'first-name': 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toKebabCaseKeys(arr);
+ * // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toKebabCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   'user-data': {
+ * //     'user-id': 1,
+ * //     'user-address': {
+ * //       'street-name': 'Main St',
+ * //       'zip-code': '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toKebabCaseKeys<T>(obj: T): ToKebabCaseKeys<T>;
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toKebabCaseKeys.js

@@ -0,0 +1,66 @@
+const require_isArray = require("../compat/predicate/isArray.js");
+const require_isPlainObject = require("../compat/predicate/isPlainObject.js");
+const require_kebabCase = require("../string/kebabCase.js");
+//#region src/object/toKebabCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to kebab-case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to kebab-case format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to kebab-case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toKebabCaseKeys(obj);
+* // result will be { 'user-id': 1, 'first-name': 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toKebabCaseKeys(arr);
+* // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toKebabCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   'user-data': {
+* //     'user-id': 1,
+* //     'user-address': {
+* //       'street-name': 'Main St',
+* //       'zip-code': '12345'
+* //     }
+* //   }
+* // }
+*/
+function toKebabCaseKeys(obj) {
+	if (require_isArray.isArray(obj)) return obj.map((item) => toKebabCaseKeys(item));
+	if (require_isPlainObject.isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const kebabKey = require_kebabCase.kebabCase(key);
+			result[kebabKey] = toKebabCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+exports.toKebabCaseKeys = toKebabCaseKeys;

package/dist/object/toKebabCaseKeys.mjs

@@ -0,0 +1,66 @@
+import { isArray } from "../compat/predicate/isArray.mjs";
+import { isPlainObject } from "../compat/predicate/isPlainObject.mjs";
+import { kebabCase } from "../string/kebabCase.mjs";
+//#region src/object/toKebabCaseKeys.ts
+/**
+* Creates a new object composed of the properties with keys converted to kebab-case.
+*
+* This function takes an object and returns a new object that includes the same properties,
+* but with all keys converted to kebab-case format.
+*
+* @template T - The type of object.
+* @param obj - The object to convert keys from.
+* @returns A new object with all keys converted to kebab-case.
+*
+* @example
+* // Example with objects
+* const obj = { userId: 1, firstName: 'John' };
+* const result = toKebabCaseKeys(obj);
+* // result will be { 'user-id': 1, 'first-name': 'John' }
+*
+* // Example with arrays of objects
+* const arr = [
+*   { userId: 1, firstName: 'John' },
+*   { userId: 2, firstName: 'Jane' }
+* ];
+* const arrResult = toKebabCaseKeys(arr);
+* // arrResult will be [{ 'user-id': 1, 'first-name': 'John' }, { 'user-id': 2, 'first-name': 'Jane' }]
+*
+* // Example with nested objects
+* const nested = {
+*   userData: {
+*     userId: 1,
+*     userAddress: {
+*       streetName: 'Main St',
+*       zipCode: '12345'
+*     }
+*   }
+* };
+* const nestedResult = toKebabCaseKeys(nested);
+* // nestedResult will be:
+* // {
+* //   'user-data': {
+* //     'user-id': 1,
+* //     'user-address': {
+* //       'street-name': 'Main St',
+* //       'zip-code': '12345'
+* //     }
+* //   }
+* // }
+*/
+function toKebabCaseKeys(obj) {
+	if (isArray(obj)) return obj.map((item) => toKebabCaseKeys(item));
+	if (isPlainObject(obj)) {
+		const result = {};
+		const keys = Object.keys(obj);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const kebabKey = kebabCase(key);
+			result[kebabKey] = toKebabCaseKeys(obj[key]);
+		}
+		return result;
+	}
+	return obj;
+}
+//#endregion
+export { toKebabCaseKeys };

package/dist/object/toMerged.js

@@ -1,6 +1,7 @@
 const require_clone = require("./clone.js");
 const require_cloneDeep = require("./cloneDeep.js");
 const require_isPlainObject = require("../predicate/isPlainObject.js");
+const require_isMergeableValue = require("../_internal/isMergeableValue.js");
 const require_mergeWith = require("./mergeWith.js");
 //#region src/object/toMerged.ts
 /**
@@ -47,10 +48,9 @@ const require_mergeWith = require("./mergeWith.js");
 */
 function toMerged(target, source) {
 	return require_mergeWith.mergeWith(require_cloneDeep.cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
-		if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) return require_mergeWith.mergeWith(require_clone.clone(targetValue), sourceValue, mergeRecursively);
-		else return require_mergeWith.mergeWith([], sourceValue, mergeRecursively);
-		else if (require_isPlainObject.isPlainObject(sourceValue)) if (require_isPlainObject.isPlainObject(targetValue)) return require_mergeWith.mergeWith(require_clone.clone(targetValue), sourceValue, mergeRecursively);
-		else return require_mergeWith.mergeWith({}, sourceValue, mergeRecursively);
+		if (require_isMergeableValue.isMergeableValue(sourceValue) && require_isMergeableValue.isMergeableValue(targetValue)) return require_mergeWith.mergeWith(require_clone.clone(targetValue), sourceValue, mergeRecursively);
+		else if (Array.isArray(sourceValue)) return require_mergeWith.mergeWith([], sourceValue, mergeRecursively);
+		else if (require_isPlainObject.isPlainObject(sourceValue)) return require_mergeWith.mergeWith({}, sourceValue, mergeRecursively);
 	});
 }
 //#endregion

package/dist/object/toMerged.mjs

@@ -1,6 +1,7 @@
 import { clone } from "./clone.mjs";
 import { cloneDeep } from "./cloneDeep.mjs";
 import { isPlainObject } from "../predicate/isPlainObject.mjs";
+import { isMergeableValue } from "../_internal/isMergeableValue.mjs";
 import { mergeWith } from "./mergeWith.mjs";
 //#region src/object/toMerged.ts
 /**
@@ -47,10 +48,9 @@ import { mergeWith } from "./mergeWith.mjs";
 */
 function toMerged(target, source) {
 	return mergeWith(cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
-		if (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
-		else return mergeWith([], sourceValue, mergeRecursively);
-		else if (isPlainObject(sourceValue)) if (isPlainObject(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
-		else return mergeWith({}, sourceValue, mergeRecursively);
+		if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
+		else if (Array.isArray(sourceValue)) return mergeWith([], sourceValue, mergeRecursively);
+		else if (isPlainObject(sourceValue)) return mergeWith({}, sourceValue, mergeRecursively);
 	});
 }
 //#endregion

package/dist/object/toPascalCaseKeys.d.mts

@@ -0,0 +1,52 @@
+import { ToPascalCaseKeys } from "../types/ToPascalCaseKeys.mjs";
+
+//#region src/object/toPascalCaseKeys.d.ts
+/**
+ * Creates a new object composed of the properties with keys converted to PascalCase.
+ *
+ * This function takes an object and returns a new object that includes the same properties,
+ * but with all keys converted to PascalCase format.
+ *
+ * @template T - The type of object.
+ * @param obj - The object to convert keys from.
+ * @returns A new object with all keys converted to PascalCase.
+ *
+ * @example
+ * // Example with objects
+ * const obj = { userId: 1, firstName: 'John' };
+ * const result = toPascalCaseKeys(obj);
+ * // result will be { UserId: 1, FirstName: 'John' }
+ *
+ * // Example with arrays of objects
+ * const arr = [
+ *   { userId: 1, firstName: 'John' },
+ *   { userId: 2, firstName: 'Jane' }
+ * ];
+ * const arrResult = toPascalCaseKeys(arr);
+ * // arrResult will be [{ UserId: 1, FirstName: 'John' }, { UserId: 2, FirstName: 'Jane' }]
+ *
+ * // Example with nested objects
+ * const nested = {
+ *   userData: {
+ *     userId: 1,
+ *     userAddress: {
+ *       streetName: 'Main St',
+ *       zipCode: '12345'
+ *     }
+ *   }
+ * };
+ * const nestedResult = toPascalCaseKeys(nested);
+ * // nestedResult will be:
+ * // {
+ * //   UserData: {
+ * //     UserId: 1,
+ * //     UserAddress: {
+ * //       StreetName: 'Main St',
+ * //       ZipCode: '12345'
+ * //     }
+ * //   }
+ * // }
+ */
+declare function toPascalCaseKeys<T>(obj: T): ToPascalCaseKeys<T>;
+//#endregion
+export { toPascalCaseKeys };