es-toolkit 1.22.0 → 1.23.0-dev.715

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # es-toolkit Changelog
 
+## Version v1.23.0
+
+Released on October 1st, 2024.
+
+- Added support for [isEqualWith](https://es-toolkit.slash.page/reference/predicate/isEqualWith.html), [isArrayBuffer](https://es-toolkit.slash.page/reference/predicate/isArrayBuffer.html), [curryRight](https://es-toolkit.slash.page/reference/function/curryRight.html), [isJSONValue](https://es-toolkit.slash.page/reference/predicate/isJSONValue.html), [isJSONObject](https://es-toolkit.slash.page/reference/predicate/isJSONObject.html), [isJSONArray](https://es-toolkit.slash.page/reference/predicate/isJSONArray.html).
+- Fixed a bug in [merge](https://es-toolkit.slash.page/reference/object/merge.html) that copied the reference from the `source` object to the `target` object.
+- Fixed a bug in [includes](https://es-toolkit.slash.page/reference/compat/array/includes.html) that returned `true` for inherited properties.
+- Fixed a bug in [startCase](https://es-toolkit.slash.page/reference/string/startCase.html) and other string methods that did not correctly split the words when using accented letters.
+- Fixed a bug in [filter](https://es-toolkit.slash.page/reference/compat/array/filter.html) that did not provide correct arguments to the predicate function.
+- Fixed a bug in [isMatch](https://es-toolkit.slash.page/reference/compat/predicate/isMatch.html) that did not strictly compare primitive falsy values.
+
+This version includes contributions from @D-Sketon, @wojtekmaj, @mass2527, @chhw130, and @knott11. Thank you for your valuable contributions!
+
 ## Version v1.22.0
 
 Released on September 28th, 2024.

package/dist/_chunk/{flowRight-BzdOZX.js → flowRight-Dv8J0U.js}

@@ -88,8 +88,6 @@ function debounce(func, debounceMs, { signal, edges } = {}) {
     return debounced;
 }
 
-function noop() { }
-
 function once(func) {
     let called = false;
     let cache;
@@ -190,6 +188,26 @@ function rest(func, startIndex = func.length - 1) {
     };
 }
 
+function curryRight(func) {
+    if (func.length === 0 || func.length === 1) {
+        return func;
+    }
+    return function (arg) {
+        return makeCurryRight(func, func.length, [arg]);
+    };
+}
+function makeCurryRight(origin, argsLength, args) {
+    if (args.length === argsLength) {
+        return origin(...args);
+    }
+    else {
+        const next = function (arg) {
+            return makeCurryRight(origin, argsLength, [arg, ...args]);
+        };
+        return next;
+    }
+}
+
 function flow(...funcs) {
     return function (...args) {
         let result = funcs.length ? funcs[0].apply(this, args) : args[0];
@@ -207,12 +225,12 @@ function flowRight(...funcs) {
 exports.after = after;
 exports.ary = ary;
 exports.before = before;
+exports.curryRight = curryRight;
 exports.debounce = debounce;
 exports.flow = flow;
 exports.flowRight = flowRight;
 exports.memoize = memoize;
 exports.negate = negate;
-exports.noop = noop;
 exports.once = once;
 exports.partial = partial;
 exports.partialRight = partialRight;

package/dist/_chunk/{toMerged-2WPeoI.js → isObjectLike-aywuSF.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const isPlainObject = require('./isPlainObject-BIekvL.js');
+const isPlainObject = require('./isPlainObject-DgrsU7.js');
 
 function omitBy(obj, shouldOmit) {
     const result = {};
@@ -141,10 +141,10 @@ function cloneDeepImpl(obj, stack = new Map()) {
         for (let i = 0; i < obj.length; i++) {
             result[i] = cloneDeepImpl(obj[i], stack);
         }
-        if (Object.prototype.hasOwnProperty.call(obj, 'index')) {
+        if (Object.hasOwn(obj, 'index')) {
             result.index = obj.index;
         }
-        if (Object.prototype.hasOwnProperty.call(obj, 'input')) {
+        if (Object.hasOwn(obj, 'input')) {
             result.input = obj.input;
         }
         return result;
@@ -234,10 +234,6 @@ function copyProperties(target, source, stack) {
     }
 }
 
-function isObjectLike(value) {
-    return typeof value === 'object' && value !== null;
-}
-
 function merge(target, source) {
     const sourceKeys = Object.keys(source);
     for (let i = 0; i < sourceKeys.length; i++) {
@@ -245,10 +241,20 @@ function merge(target, source) {
         const sourceValue = source[key];
         const targetValue = target[key];
         if (Array.isArray(sourceValue)) {
-            target[key] = merge(targetValue ?? [], sourceValue);
+            if (Array.isArray(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge([], sourceValue);
+            }
         }
-        else if (isObjectLike(targetValue) && isObjectLike(sourceValue)) {
-            target[key] = merge(targetValue ?? {}, sourceValue);
+        else if (isPlainObject.isPlainObject(sourceValue)) {
+            if (isPlainObject.isPlainObject(targetValue)) {
+                target[key] = merge(targetValue, sourceValue);
+            }
+            else {
+                target[key] = merge({}, sourceValue);
+            }
         }
         else if (targetValue === undefined || sourceValue !== undefined) {
             target[key] = sourceValue;
@@ -261,6 +267,10 @@ function toMerged(target, source) {
     return merge(cloneDeep(target), source);
 }
 
+function isObjectLike(value) {
+    return typeof value === 'object' && value !== null;
+}
+
 exports.clone = clone;
 exports.cloneDeep = cloneDeep;
 exports.copyProperties = copyProperties;

package/dist/_chunk/{isPlainObject-BIekvL.js → isPlainObject-DgrsU7.js}

@@ -1,31 +1,31 @@
 'use strict';
 
-function isTypedArray(x) {
-    return ArrayBuffer.isView(x) && !(x instanceof DataView);
-}
-
 function isPrimitive(value) {
     return value == null || (typeof value !== 'object' && typeof value !== 'function');
 }
 
-function isPlainObject(object) {
-    if (typeof object !== 'object') {
+function isTypedArray(x) {
+    return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+function isPlainObject(value) {
+    if (typeof value !== 'object') {
         return false;
     }
-    if (object == null) {
+    if (value == null) {
         return false;
     }
-    if (Object.getPrototypeOf(object) === null) {
+    if (Object.getPrototypeOf(value) === null) {
         return true;
     }
-    if (object.toString() !== '[object Object]') {
+    if (value.toString() !== '[object Object]') {
         return false;
     }
-    let proto = object;
+    let proto = value;
     while (Object.getPrototypeOf(proto) !== null) {
         proto = Object.getPrototypeOf(proto);
     }
-    return Object.getPrototypeOf(object) === proto;
+    return Object.getPrototypeOf(value) === proto;
 }
 
 exports.isPlainObject = isPlainObject;

package/dist/_chunk/{isWeakSet-clQklw.js → isWeakSet-BAMm2l.js}

@@ -1,11 +1,27 @@
 'use strict';
 
-const isPlainObject = require('./isPlainObject-BIekvL.js');
+const isPlainObject = require('./isPlainObject-DgrsU7.js');
+const noop = require('./noop-2IwLUk.js');
+
+function isArrayBuffer(value) {
+    return value instanceof ArrayBuffer;
+}
 
 function isDate(value) {
     return value instanceof Date;
 }
 
+function getSymbols(object) {
+    return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+
+function getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return Object.prototype.toString.call(value);
+}
+
 const regexpTag = '[object RegExp]';
 const stringTag = '[object String]';
 const numberTag = '[object Number]';
@@ -33,18 +49,14 @@ const bigInt64ArrayTag = '[object BigInt64Array]';
 const float32ArrayTag = '[object Float32Array]';
 const float64ArrayTag = '[object Float64Array]';
 
-function getSymbols(object) {
-    return Object.getOwnPropertySymbols(object).filter(symbol => Object.prototype.propertyIsEnumerable.call(object, symbol));
+function isEqualWith(a, b, areValuesEqual) {
+    return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
 }
-
-function getTag(value) {
-    if (value == null) {
-        return value === undefined ? '[object Undefined]' : '[object Null]';
+function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
+    const result = areValuesEqual(a, b, property, aParent, bParent, stack);
+    if (result !== undefined) {
+        return result;
     }
-    return Object.prototype.toString.call(value);
-}
-
-function isEqual(a, b) {
     if (typeof a === typeof b) {
         switch (typeof a) {
             case 'bigint':
@@ -61,13 +73,13 @@ function isEqual(a, b) {
                 return a === b;
             }
             case 'object': {
-                return areObjectsEqual(a, b);
+                return areObjectsEqual(a, b, stack, areValuesEqual);
             }
         }
     }
-    return areObjectsEqual(a, b);
+    return areObjectsEqual(a, b, stack, areValuesEqual);
 }
-function areObjectsEqual(a, b, stack) {
+function areObjectsEqual(a, b, stack, areValuesEqual) {
     if (Object.is(a, b)) {
         return true;
     }
@@ -116,7 +128,7 @@ function areObjectsEqual(a, b, stack) {
                     return false;
                 }
                 for (const [key, value] of a.entries()) {
-                    if (!b.has(key) || !areObjectsEqual(value, b.get(key), stack)) {
+                    if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) {
                         return false;
                     }
                 }
@@ -131,7 +143,7 @@ function areObjectsEqual(a, b, stack) {
                 for (let i = 0; i < aValues.length; i++) {
                     const aValue = aValues[i];
                     const index = bValues.findIndex(bValue => {
-                        return areObjectsEqual(aValue, bValue, stack);
+                        return isEqualWithImpl(aValue, bValue, undefined, a, b, stack, areValuesEqual);
                     });
                     if (index === -1) {
                         return false;
@@ -159,7 +171,7 @@ function areObjectsEqual(a, b, stack) {
                     return false;
                 }
                 for (let i = 0; i < a.length; i++) {
-                    if (!areObjectsEqual(a[i], b[i], stack)) {
+                    if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) {
                         return false;
                     }
                 }
@@ -169,19 +181,20 @@ function areObjectsEqual(a, b, stack) {
                 if (a.byteLength !== b.byteLength) {
                     return false;
                 }
-                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack);
+                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
             case dataViewTag: {
                 if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
                     return false;
                 }
-                return areObjectsEqual(a.buffer, b.buffer, stack);
+                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
             case errorTag: {
                 return a.name === b.name && a.message === b.message;
             }
             case objectTag: {
-                const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack) || (isPlainObject.isPlainObject(a) && isPlainObject.isPlainObject(b));
+                const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) ||
+                    (isPlainObject.isPlainObject(a) && isPlainObject.isPlainObject(b));
                 if (!areEqualInstances) {
                     return false;
                 }
@@ -193,11 +206,11 @@ function areObjectsEqual(a, b, stack) {
                 for (let i = 0; i < aKeys.length; i++) {
                     const propKey = aKeys[i];
                     const aProp = a[propKey];
-                    if (!Object.prototype.hasOwnProperty.call(b, propKey)) {
+                    if (!Object.hasOwn(b, propKey)) {
                         return false;
                     }
                     const bProp = b[propKey];
-                    if (!areObjectsEqual(aProp, bProp, stack)) {
+                    if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) {
                         return false;
                     }
                 }
@@ -214,6 +227,10 @@ function areObjectsEqual(a, b, stack) {
     }
 }
 
+function isEqual(a, b) {
+    return isEqualWith(a, b, noop.noop);
+}
+
 function isMap(value) {
     return value instanceof Map;
 }
@@ -246,6 +263,47 @@ function isRegExp(value) {
     return value instanceof RegExp;
 }
 
+function isJSONArray(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every(item => isJSONValue(item));
+}
+
+function isJSONValue(value) {
+    switch (typeof value) {
+        case 'object': {
+            return value === null || isJSONArray(value) || isJSONObject(value);
+        }
+        case 'string':
+        case 'number':
+        case 'boolean': {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+}
+
+function isJSONObject(obj) {
+    if (!isPlainObject.isPlainObject(obj)) {
+        return false;
+    }
+    const keys = Reflect.ownKeys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        if (typeof key !== 'string') {
+            return false;
+        }
+        if (!isJSONValue(value)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 function isSet(value) {
     return value instanceof Set;
 }
@@ -262,9 +320,14 @@ exports.argumentsTag = argumentsTag;
 exports.booleanTag = booleanTag;
 exports.getSymbols = getSymbols;
 exports.getTag = getTag;
+exports.isArrayBuffer = isArrayBuffer;
 exports.isDate = isDate;
 exports.isEqual = isEqual;
+exports.isEqualWith = isEqualWith;
 exports.isFunction = isFunction;
+exports.isJSONArray = isJSONArray;
+exports.isJSONObject = isJSONObject;
+exports.isJSONValue = isJSONValue;
 exports.isLength = isLength;
 exports.isMap = isMap;
 exports.isNil = isNil;

package/dist/_chunk/noop-2IwLUk.js

@@ -0,0 +1,5 @@
+'use strict';
+
+function noop() { }
+
+exports.noop = noop;

package/dist/_chunk/{pad-Cw2pvt.js → pad-BWiShN.js}

@@ -1,14 +1,14 @@
 'use strict';
 
-function capitalize(str) {
-    return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase());
-}
-
-const CASE_SPLIT_PATTERN = /[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu;
+const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu;
 function getWords(str) {
     return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
 }
 
+function capitalize(str) {
+    return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase());
+}
+
 function camelCase(str) {
     const words = getWords(str);
     if (words.length === 0) {
@@ -55,46 +55,46 @@ function constantCase(str) {
     return words.map(word => word.toUpperCase()).join('_');
 }
 
-function trimStart(str, chars) {
+function trimEnd(str, chars) {
     if (chars === undefined) {
-        return str.trimStart();
+        return str.trimEnd();
     }
-    let startIndex = 0;
+    let endIndex = str.length;
     switch (typeof chars) {
         case 'string': {
-            while (startIndex < str.length && str[startIndex] === chars) {
-                startIndex++;
+            while (endIndex > 0 && str[endIndex - 1] === chars) {
+                endIndex--;
             }
             break;
         }
         case 'object': {
-            while (startIndex < str.length && chars.includes(str[startIndex])) {
-                startIndex++;
+            while (endIndex > 0 && chars.includes(str[endIndex - 1])) {
+                endIndex--;
             }
         }
     }
-    return str.substring(startIndex);
+    return str.substring(0, endIndex);
 }
 
-function trimEnd(str, chars) {
+function trimStart(str, chars) {
     if (chars === undefined) {
-        return str.trimEnd();
+        return str.trimStart();
     }
-    let endIndex = str.length;
+    let startIndex = 0;
     switch (typeof chars) {
         case 'string': {
-            while (endIndex > 0 && str[endIndex - 1] === chars) {
-                endIndex--;
+            while (startIndex < str.length && str[startIndex] === chars) {
+                startIndex++;
             }
             break;
         }
         case 'object': {
-            while (endIndex > 0 && chars.includes(str[endIndex - 1])) {
-                endIndex--;
+            while (startIndex < str.length && chars.includes(str[startIndex])) {
+                startIndex++;
             }
         }
     }
-    return str.substring(0, endIndex);
+    return str.substring(startIndex);
 }
 
 function trim(str, chars) {