es-toolkit 1.23.0 → 1.24.0-dev.764

package/dist/compat/object/pick.d.ts

@@ -25,7 +25,7 @@ declare function pick<T extends Record<string, any>, K extends keyof T>(obj: T,
  * @template T - The type of object.
  * @param {T | null | undefined} obj - The object to pick keys from.
  * @param {...any} keys
- * @param {PropertyKey | PropertyKey[] | ProperyKey[][]}} keys - An array of keys to be picked from the object. received keysgoes through a flattening process before being used.
+ * @param {PropertyKey | PropertyKey[] | PropertyKey[][]}} keys - An array of keys to be picked from the object. received keys goes through a flattening process before being used.
  * @returns {Partial<T, K>} A new object with the specified keys picked.
  *
  * @example

package/dist/compat/object/toDefaulted.d.mts

@@ -0,0 +1,122 @@
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @param {T} object - The target object.
+ * @returns {T} The cloned object.
+ */
+declare function toDefaulted<T extends object>(object: T): T;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S} source - The object that specifies the default values to apply.
+ * @returns {NonNullable<T & S>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S extends object>(object: T, source: S): NonNullable<T & S>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S1 extends object, S2 extends object>(object: T, source1: S1, source2: S2): NonNullable<T & S1 & S2>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S1 extends object, S2 extends object, S3 extends object>(object: T, source1: S1, source2: S2, source3: S3): NonNullable<T & S1 & S2 & S3>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @template S4 - The type of the fourth object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @param {S4} source4 - The fourth object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3 & S4>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S1 extends object, S2 extends object, S3 extends object, S4 extends object>(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable<T & S1 & S2 & S3 & S4>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the objects that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S[]} sources - The objects that specifies the default values to apply.
+ * @returns {object} A new object that combines the target and default values, ensuring no properties are left undefined.
+ *
+ * @example
+ * toDefaulted({ a: 1 }, { a: 2, b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * toDefaulted({ a: 1, b: 2 }, { b: 3 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * toDefaulted({ a: null }, { a: 1 }); // { a: null }
+ * toDefaulted({ a: undefined }, { a: 1 }); // { a: 1 }
+ */
+declare function toDefaulted<T extends object, S extends object>(object: T, ...sources: S[]): object;
+
+export { toDefaulted };

package/dist/compat/object/toDefaulted.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @param {T} object - The target object.
+ * @returns {T} The cloned object.
+ */
+declare function toDefaulted<T extends object>(object: T): T;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S} source - The object that specifies the default values to apply.
+ * @returns {NonNullable<T & S>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S extends object>(object: T, source: S): NonNullable<T & S>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S1 extends object, S2 extends object>(object: T, source1: S1, source2: S2): NonNullable<T & S1 & S2>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S1 extends object, S2 extends object, S3 extends object>(object: T, source1: S1, source2: S2, source3: S3): NonNullable<T & S1 & S2 & S3>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S1 - The type of the first object that provides default values.
+ * @template S2 - The type of the second object that provides default values.
+ * @template S3 - The type of the third object that provides default values.
+ * @template S4 - The type of the fourth object that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S1} source1 - The first object that specifies the default values to apply.
+ * @param {S2} source2 - The second object that specifies the default values to apply.
+ * @param {S3} source3 - The third object that specifies the default values to apply.
+ * @param {S4} source4 - The fourth object that specifies the default values to apply.
+ * @returns {NonNullable<T & S1 & S2 & S3 & S4>} A new object that combines the target and default values, ensuring no properties are left undefined.
+ */
+declare function toDefaulted<T extends object, S1 extends object, S2 extends object, S3 extends object, S4 extends object>(object: T, source1: S1, source2: S2, source3: S3, source4: S4): NonNullable<T & S1 & S2 & S3 & S4>;
+/**
+ * Creates a new object based on the provided `object`, applying default values from the `sources` to ensure that no properties are left `undefined`.
+ * It assigns default values to properties that are either `undefined` or come from `Object.prototype`.
+ *
+ * You can provide multiple source objects to set these default values,
+ * and they will be applied in the order they are given, from left to right.
+ * Once a property has been set, any later values for that property will be ignored.
+ *
+ * Note: This function creates a new object. If you want to modify the `object`, use the `defaults` function instead.
+ *
+ * @template T - The type of the object being processed.
+ * @template S - The type of the objects that provides default values.
+ * @param {T} object - The target object that will receive default values.
+ * @param {S[]} sources - The objects that specifies the default values to apply.
+ * @returns {object} A new object that combines the target and default values, ensuring no properties are left undefined.
+ *
+ * @example
+ * toDefaulted({ a: 1 }, { a: 2, b: 2 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * toDefaulted({ a: 1, b: 2 }, { b: 3 }, { c: 3 }); // { a: 1, b: 2, c: 3 }
+ * toDefaulted({ a: null }, { a: 1 }); // { a: null }
+ * toDefaulted({ a: undefined }, { a: 1 }); // { a: 1 }
+ */
+declare function toDefaulted<T extends object, S extends object>(object: T, ...sources: S[]): object;
+
+export { toDefaulted };

package/dist/compat/object/toDefaulted.mjs

@@ -0,0 +1,9 @@
+import { cloneDeep } from './cloneDeep.mjs';
+import { defaults } from './defaults.mjs';
+
+function toDefaulted(object, ...sources) {
+    const cloned = cloneDeep(object);
+    return defaults(cloned, ...sources);
+}
+
+export { toDefaulted };

package/dist/compat/predicate/isArrayBuffer.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `ArrayBuffer`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `ArrayBuffer`.
+ *
+ * @param {unknown} value The value to check if it is a `ArrayBuffer`.
+ * @returns {value is ArrayBuffer} Returns `true` if `value` is a `ArrayBuffer`, else `false`.
+ *
+ * @example
+ * const value1 = new ArrayBuffer();
+ * const value2 = new Array();
+ * const value3 = new Map();
+ *
+ * console.log(isArrayBuffer(value1)); // true
+ * console.log(isArrayBuffer(value2)); // false
+ * console.log(isArrayBuffer(value3)); // false
+ */
+declare function isArrayBuffer(value?: unknown): value is ArrayBuffer;
+
+export { isArrayBuffer };

package/dist/compat/predicate/isArrayBuffer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `ArrayBuffer`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `ArrayBuffer`.
+ *
+ * @param {unknown} value The value to check if it is a `ArrayBuffer`.
+ * @returns {value is ArrayBuffer} Returns `true` if `value` is a `ArrayBuffer`, else `false`.
+ *
+ * @example
+ * const value1 = new ArrayBuffer();
+ * const value2 = new Array();
+ * const value3 = new Map();
+ *
+ * console.log(isArrayBuffer(value1)); // true
+ * console.log(isArrayBuffer(value2)); // false
+ * console.log(isArrayBuffer(value3)); // false
+ */
+declare function isArrayBuffer(value?: unknown): value is ArrayBuffer;
+
+export { isArrayBuffer };

package/dist/compat/predicate/isArrayBuffer.mjs

@@ -0,0 +1,7 @@
+import { isArrayBuffer as isArrayBuffer$1 } from '../../predicate/isArrayBuffer.mjs';
+
+function isArrayBuffer(value) {
+    return isArrayBuffer$1(value);
+}
+
+export { isArrayBuffer };

package/dist/compat/predicate/isDate.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Checks if `value` is a Date object.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is Date} Returns `true` if `value` is a Date object, `false` otherwise.
+ *
+ * @example
+ * const value1 = new Date();
+ * const value2 = '2024-01-01';
+ *
+ * console.log(isDate(value1)); // true
+ * console.log(isDate(value2)); // false
+ */
+declare function isDate(value?: unknown): value is Date;
+
+export { isDate };

package/dist/compat/predicate/isDate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if `value` is a Date object.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is Date} Returns `true` if `value` is a Date object, `false` otherwise.
+ *
+ * @example
+ * const value1 = new Date();
+ * const value2 = '2024-01-01';
+ *
+ * console.log(isDate(value1)); // true
+ * console.log(isDate(value2)); // false
+ */
+declare function isDate(value?: unknown): value is Date;
+
+export { isDate };

package/dist/compat/predicate/isDate.mjs

@@ -0,0 +1,7 @@
+import { isDate as isDate$1 } from '../../predicate/isDate.mjs';
+
+function isDate(value) {
+    return isDate$1(value);
+}
+
+export { isDate };

package/dist/compat/predicate/isEqualWith.d.mts

@@ -0,0 +1,38 @@
+/**
+ * Compares two values for equality using a custom comparison function.
+ *
+ * The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.
+ *
+ * This function also uses the custom equality function to compare values inside objects,
+ * arrays, maps, sets, and other complex structures, ensuring a deep comparison.
+ *
+ * This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.
+ *
+ * The custom comparison function can take up to six parameters:
+ * - `x`: The value from the first object `a`.
+ * - `y`: The value from the second object `b`.
+ * - `property`: The property key used to get `x` and `y`.
+ * - `xParent`: The parent of the first value `x`.
+ * - `yParent`: The parent of the second value `y`.
+ * - `stack`: An internal stack (Map) to handle circular references.
+ *
+ * @param {unknown} a - The first value to compare.
+ * @param {unknown} b - The second value to compare.
+ * @param {(x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map<any, any>) => boolean | void} [areValuesEqual=noop] - A function to customize the comparison.
+ *   If it returns a boolean, that result will be used. If it returns undefined,
+ *   the default equality comparison will be used.
+ * @returns {boolean} `true` if the values are equal according to the customizer, otherwise `false`.
+ *
+ * @example
+ * const customizer = (a, b) => {
+ *   if (typeof a === 'string' && typeof b === 'string') {
+ *     return a.toLowerCase() === b.toLowerCase();
+ *   }
+ * };
+ * isEqualWith('Hello', 'hello', customizer); // true
+ * isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true
+ * isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true
+ */
+declare function isEqualWith(a: any, b: any, areValuesEqual?: (a: any, b: any, property?: PropertyKey, aParent?: any, bParent?: any, stack?: Map<any, any>) => boolean | void): boolean;
+
+export { isEqualWith };

package/dist/compat/predicate/isEqualWith.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Compares two values for equality using a custom comparison function.
+ *
+ * The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.
+ *
+ * This function also uses the custom equality function to compare values inside objects,
+ * arrays, maps, sets, and other complex structures, ensuring a deep comparison.
+ *
+ * This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.
+ *
+ * The custom comparison function can take up to six parameters:
+ * - `x`: The value from the first object `a`.
+ * - `y`: The value from the second object `b`.
+ * - `property`: The property key used to get `x` and `y`.
+ * - `xParent`: The parent of the first value `x`.
+ * - `yParent`: The parent of the second value `y`.
+ * - `stack`: An internal stack (Map) to handle circular references.
+ *
+ * @param {unknown} a - The first value to compare.
+ * @param {unknown} b - The second value to compare.
+ * @param {(x: any, y: any, property?: PropertyKey, xParent?: any, yParent?: any, stack?: Map<any, any>) => boolean | void} [areValuesEqual=noop] - A function to customize the comparison.
+ *   If it returns a boolean, that result will be used. If it returns undefined,
+ *   the default equality comparison will be used.
+ * @returns {boolean} `true` if the values are equal according to the customizer, otherwise `false`.
+ *
+ * @example
+ * const customizer = (a, b) => {
+ *   if (typeof a === 'string' && typeof b === 'string') {
+ *     return a.toLowerCase() === b.toLowerCase();
+ *   }
+ * };
+ * isEqualWith('Hello', 'hello', customizer); // true
+ * isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true
+ * isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true
+ */
+declare function isEqualWith(a: any, b: any, areValuesEqual?: (a: any, b: any, property?: PropertyKey, aParent?: any, bParent?: any, stack?: Map<any, any>) => boolean | void): boolean;
+
+export { isEqualWith };

package/dist/compat/predicate/isEqualWith.mjs

@@ -0,0 +1,23 @@
+import { after } from '../../function/after.mjs';
+import { noop } from '../../function/noop.mjs';
+import { isEqualWith as isEqualWith$1 } from '../../predicate/isEqualWith.mjs';
+
+function isEqualWith(a, b, areValuesEqual = noop) {
+    if (typeof areValuesEqual !== 'function') {
+        areValuesEqual = noop;
+    }
+    return isEqualWith$1(a, b, (...args) => {
+        const result = areValuesEqual(...args);
+        if (result !== undefined) {
+            return Boolean(result);
+        }
+        if (a instanceof Map && b instanceof Map) {
+            return isEqualWith(Array.from(a), Array.from(b), after(2, areValuesEqual));
+        }
+        if (a instanceof Set && b instanceof Set) {
+            return isEqualWith(Array.from(a), Array.from(b), after(2, areValuesEqual));
+        }
+    });
+}
+
+export { isEqualWith };

package/dist/compat/predicate/isMap.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `Map`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Map`.
+ *
+ * @param {unknown} value The value to check if it is a `Map`.
+ * @returns {value is Map<any, any>} Returns `true` if `value` is a `Map`, else `false`.
+ *
+ * @example
+ * const value1 = new Map();
+ * const value2 = new Set();
+ * const value3 = new WeakMap();
+ *
+ * console.log(isMap(value1)); // true
+ * console.log(isMap(value2)); // false
+ * console.log(isMap(value3)); // false
+ */
+declare function isMap(value?: unknown): value is Map<any, any>;
+
+export { isMap };

package/dist/compat/predicate/isMap.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `Map`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Map`.
+ *
+ * @param {unknown} value The value to check if it is a `Map`.
+ * @returns {value is Map<any, any>} Returns `true` if `value` is a `Map`, else `false`.
+ *
+ * @example
+ * const value1 = new Map();
+ * const value2 = new Set();
+ * const value3 = new WeakMap();
+ *
+ * console.log(isMap(value1)); // true
+ * console.log(isMap(value2)); // false
+ * console.log(isMap(value3)); // false
+ */
+declare function isMap(value?: unknown): value is Map<any, any>;
+
+export { isMap };

package/dist/compat/predicate/isMap.mjs

@@ -0,0 +1,7 @@
+import { isMap as isMap$1 } from '../../predicate/isMap.mjs';
+
+function isMap(value) {
+    return isMap$1(value);
+}
+
+export { isMap };

package/dist/compat/predicate/isMatch.mjs

@@ -1,5 +1,6 @@
 import { isObject } from './isObject.mjs';
 import { isPrimitive } from '../../predicate/isPrimitive.mjs';
+import { eq } from '../util/eq.mjs';
 
 function isMatch(target, source) {
     if (source === target) {
@@ -48,7 +49,7 @@ function isMatch(target, source) {
         }
         default: {
             if (!isObject(target)) {
-                return target === source || (Number.isNaN(target) && Number.isNaN(source));
+                return eq(target, source);
             }
             return !source;
         }

package/dist/compat/predicate/isSet.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `Set`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Set`.
+ *
+ * @param {unknown} value The value to check if it is a `Set`.
+ * @returns {value is Set<any>} Returns `true` if `value` is a `Set`, else `false`.
+ *
+ * @example
+ * const value1 = new Set();
+ * const value2 = new Map();
+ * const value3 = new WeakSet();
+ *
+ * console.log(isSet(value1)); // true
+ * console.log(isSet(value2)); // false
+ * console.log(isSet(value3)); // false
+ */
+declare function isSet(value?: unknown): value is Set<any>;
+
+export { isSet };

package/dist/compat/predicate/isSet.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is `Set`.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `Set`.
+ *
+ * @param {unknown} value The value to check if it is a `Set`.
+ * @returns {value is Set<any>} Returns `true` if `value` is a `Set`, else `false`.
+ *
+ * @example
+ * const value1 = new Set();
+ * const value2 = new Map();
+ * const value3 = new WeakSet();
+ *
+ * console.log(isSet(value1)); // true
+ * console.log(isSet(value2)); // false
+ * console.log(isSet(value3)); // false
+ */
+declare function isSet(value?: unknown): value is Set<any>;
+
+export { isSet };

package/dist/compat/predicate/isSet.mjs

@@ -0,0 +1,7 @@
+import { isSet as isSet$1 } from '../../predicate/isSet.mjs';
+
+function isSet(value) {
+    return isSet$1(value);
+}
+
+export { isSet };

package/dist/compat/string/upperCase.mjs

@@ -1,5 +1,4 @@
 import { upperCase as upperCase$1 } from '../../string/upperCase.mjs';
-import '../../string/deburr.mjs';
 import { normalizeForCase } from '../_internal/normalizeForCase.mjs';
 
 function upperCase(str) {

package/dist/compat/util/constant.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Creates a new function that always returns `undefined`.
+ *
+ * @returns {() => undefined} Returns the new constant function.
+ */
+declare function constant(): () => undefined;
+/**
+ * Creates a new function that always returns `value`.
+ *
+ * @template T - The type of the value to return.
+ * @param {T} value - The value to return from the new function.
+ * @returns {() => T} Returns the new constant function.
+ */
+declare function constant<T>(value: T): () => T;
+
+export { constant };

package/dist/compat/util/constant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a new function that always returns `undefined`.
+ *
+ * @returns {() => undefined} Returns the new constant function.
+ */
+declare function constant(): () => undefined;
+/**
+ * Creates a new function that always returns `value`.
+ *
+ * @template T - The type of the value to return.
+ * @param {T} value - The value to return from the new function.
+ * @returns {() => T} Returns the new constant function.
+ */
+declare function constant<T>(value: T): () => T;
+
+export { constant };

package/dist/compat/util/constant.mjs

@@ -0,0 +1,5 @@
+function constant(value) {
+    return () => value;
+}
+
+export { constant };

package/dist/compat/util/defaultTo.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Returns the default value for `null`, `undefined`, and `NaN`.
+ *
+ * @param {T | null | undefined} value - The value to check.
+ * @param {T} [defaultValue] - The default value to return if the first value is null, undefined, or NaN.
+ * @returns {T} Returns either the first value or the default value.
+ *
+ * @example
+ * defaultTo(null, 'default') // returns 'default'
+ * defaultTo(undefined, 42) // returns 42
+ * defaultTo(NaN, 0) // returns 0
+ * defaultTo('actual', 'default') // returns 'actual'
+ * defaultTo(123, 0) // returns 123
+ */
+declare function defaultTo<T>(value: T | null | undefined, defaultValue?: T): T;
+
+export { defaultTo };