es-toolkit 1.23.0-dev.733 → 1.23.0-dev.735

package/dist/_chunk/deburr-BPmkoM.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const deburrMap = new Map(Object.entries({
+    Æ: 'Ae',
+    Ð: 'D',
+    Ø: 'O',
+    Þ: 'Th',
+    ß: 'ss',
+    æ: 'ae',
+    ð: 'd',
+    ø: 'o',
+    þ: 'th',
+    Đ: 'D',
+    đ: 'd',
+    Ħ: 'H',
+    ħ: 'h',
+    ı: 'i',
+    IJ: 'IJ',
+    ij: 'ij',
+    ĸ: 'k',
+    Ŀ: 'L',
+    ŀ: 'l',
+    Ł: 'L',
+    ł: 'l',
+    ʼn: "'n",
+    Ŋ: 'N',
+    ŋ: 'n',
+    Œ: 'Oe',
+    œ: 'oe',
+    Ŧ: 'T',
+    ŧ: 't',
+    ſ: 's',
+}));
+function deburr(str) {
+    str = str.normalize('NFD');
+    let result = '';
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if ((char >= '\u0300' && char <= '\u036f') || (char >= '\ufe20' && char <= '\ufe23')) {
+            continue;
+        }
+        result += deburrMap.get(char) ?? char;
+    }
+    return result;
+}
+
+exports.deburr = deburr;

package/dist/_chunk/{flowRight-B6_Omw.js → flowRight-bRd7s5.js}

@@ -116,52 +116,6 @@ function unary(func) {
     return ary(func, 1);
 }
 
-function partial(func, ...partialArgs) {
-    return function (...providedArgs) {
-        const args = [];
-        let startIndex = 0;
-        for (let i = 0; i < partialArgs.length; i++) {
-            const arg = partialArgs[i];
-            if (arg === partial.placeholder) {
-                args.push(providedArgs[startIndex++]);
-            }
-            else {
-                args.push(arg);
-            }
-        }
-        for (let i = startIndex; i < providedArgs.length; i++) {
-            args.push(providedArgs[i]);
-        }
-        return func.apply(this, args);
-    };
-}
-const partialPlaceholder = Symbol('partial.placeholder');
-partial.placeholder = partialPlaceholder;
-
-function partialRight(func, ...partialArgs) {
-    return function (...providedArgs) {
-        const placeholderLength = partialArgs.filter(arg => arg === partialRightPlaceholder).length;
-        const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
-        const args = [];
-        let providedIndex = 0;
-        for (let i = 0; i < rangeLength; i++) {
-            args.push(providedArgs[providedIndex++]);
-        }
-        for (let i = 0; i < partialArgs.length; i++) {
-            const arg = partialArgs[i];
-            if (arg === partialRight.placeholder) {
-                args.push(providedArgs[providedIndex++]);
-            }
-            else {
-                args.push(arg);
-            }
-        }
-        return func.apply(this, args);
-    };
-}
-const partialRightPlaceholder = Symbol('partialRight.placeholder');
-partialRight.placeholder = partialRightPlaceholder;
-
 function rest(func, startIndex = func.length - 1) {
     return function (...args) {
         const rest = args.slice(startIndex);
@@ -216,7 +170,5 @@ exports.flowRight = flowRight;
 exports.memoize = memoize;
 exports.negate = negate;
 exports.once = once;
-exports.partial = partial;
-exports.partialRight = partialRight;
 exports.rest = rest;
 exports.unary = unary;

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

@@ -1,7 +1,8 @@
 'use strict';
 
 const isPlainObject = require('./isPlainObject-DgrsU7.js');
-const noop = require('./noop-2IwLUk.js');
+const partialRight = require('./partialRight-CRhV1h.js');
+require('./deburr-BPmkoM.js');
 
 function isArrayBuffer(value) {
     return value instanceof ArrayBuffer;
@@ -49,6 +50,142 @@ const bigInt64ArrayTag = '[object BigInt64Array]';
 const float32ArrayTag = '[object Float32Array]';
 const float64ArrayTag = '[object Float64Array]';
 
+function eq(value, other) {
+    return value === other || (Number.isNaN(value) && Number.isNaN(other));
+}
+
+function isNil(x) {
+    return x == null;
+}
+
+function bind(func, thisObj, ...partialArgs) {
+    const bound = function (...providedArgs) {
+        const args = [];
+        let startIndex = 0;
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === bind.placeholder) {
+                args.push(providedArgs[startIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        for (let i = startIndex; i < providedArgs.length; i++) {
+            args.push(providedArgs[i]);
+        }
+        if (this instanceof bound) {
+            return new func(...args);
+        }
+        return func.apply(thisObj, args);
+    };
+    return bound;
+}
+const bindPlaceholder = Symbol('bind.placeholder');
+bind.placeholder = bindPlaceholder;
+
+function bindKey(object, key, ...partialArgs) {
+    const bound = function (...providedArgs) {
+        const args = [];
+        let startIndex = 0;
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === bindKey.placeholder) {
+                args.push(providedArgs[startIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        for (let i = startIndex; i < providedArgs.length; i++) {
+            args.push(providedArgs[i]);
+        }
+        if (this instanceof bound) {
+            return new object[key](...args);
+        }
+        return object[key].apply(object, args);
+    };
+    return bound;
+}
+const bindKeyPlaceholder = Symbol('bindKey.placeholder');
+bindKey.placeholder = bindKeyPlaceholder;
+
+function curry(func, arity = func.length, guard) {
+    arity = guard ? func.length : arity;
+    arity = Number.parseInt(arity, 10);
+    if (Number.isNaN(arity) || arity < 1) {
+        arity = 0;
+    }
+    const wrapper = function (...partialArgs) {
+        const holders = partialArgs.filter(item => item === curry.placeholder);
+        const length = partialArgs.length - holders.length;
+        if (length < arity) {
+            return makeCurry(func, arity - length, partialArgs);
+        }
+        if (this instanceof wrapper) {
+            return new func(...partialArgs);
+        }
+        return func.apply(this, partialArgs);
+    };
+    wrapper.placeholder = curryPlaceholder;
+    return wrapper;
+}
+function makeCurry(func, arity, partialArgs) {
+    function wrapper(...providedArgs) {
+        const holders = providedArgs.filter(item => item === curry.placeholder);
+        const length = providedArgs.length - holders.length;
+        providedArgs = composeArgs(providedArgs, partialArgs);
+        if (length < arity) {
+            return makeCurry(func, arity - length, providedArgs);
+        }
+        if (this instanceof wrapper) {
+            return new func(...providedArgs);
+        }
+        return func.apply(this, providedArgs);
+    }
+    wrapper.placeholder = curryPlaceholder;
+    return wrapper;
+}
+function composeArgs(providedArgs, partialArgs) {
+    const args = [];
+    let startIndex = 0;
+    for (let i = 0; i < partialArgs.length; i++) {
+        const arg = partialArgs[i];
+        if (arg === curry.placeholder && startIndex < providedArgs.length) {
+            args.push(providedArgs[startIndex++]);
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    for (let i = startIndex; i < providedArgs.length; i++) {
+        args.push(providedArgs[i]);
+    }
+    return args;
+}
+const curryPlaceholder = Symbol('curry.placeholder');
+curry.placeholder = curryPlaceholder;
+
+function isLength(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+
+function isSet(value) {
+    return value instanceof Set;
+}
+
+function isRegExp(value) {
+    return value instanceof RegExp;
+}
+
+function isWeakMap(value) {
+    return value instanceof WeakMap;
+}
+
+function isWeakSet(value) {
+    return value instanceof WeakSet;
+}
+
 function isEqualWith(a, b, areValuesEqual) {
     return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
 }
@@ -100,7 +237,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
         case numberTag: {
             const x = a.valueOf();
             const y = b.valueOf();
-            return x === y || (Number.isNaN(x) && Number.isNaN(y));
+            return eq(x, y);
         }
         case booleanTag:
         case dateTag:
@@ -228,17 +365,13 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
 }
 
 function isEqual(a, b) {
-    return isEqualWith(a, b, noop.noop);
+    return isEqualWith(a, b, partialRight.noop);
 }
 
 function isMap(value) {
     return value instanceof Map;
 }
 
-function isNil(x) {
-    return x == null;
-}
-
 function isNotNil(x) {
     return x != null;
 }
@@ -251,18 +384,10 @@ function isUndefined(x) {
     return x === undefined;
 }
 
-function isLength(value) {
-    return Number.isSafeInteger(value) && value >= 0;
-}
-
 function isFunction(value) {
     return typeof value === 'function';
 }
 
-function isRegExp(value) {
-    return value instanceof RegExp;
-}
-
 function isJSONArray(value) {
     if (!Array.isArray(value)) {
         return false;
@@ -304,20 +429,12 @@ function isJSONObject(obj) {
     return true;
 }
 
-function isSet(value) {
-    return value instanceof Set;
-}
-
-function isWeakMap(value) {
-    return value instanceof WeakMap;
-}
-
-function isWeakSet(value) {
-    return value instanceof WeakSet;
-}
-
 exports.argumentsTag = argumentsTag;
+exports.bind = bind;
+exports.bindKey = bindKey;
 exports.booleanTag = booleanTag;
+exports.curry = curry;
+exports.eq = eq;
 exports.getSymbols = getSymbols;
 exports.getTag = getTag;
 exports.isArrayBuffer = isArrayBuffer;

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

@@ -18,14 +18,19 @@ function camelCase(str) {
     return `${first.toLowerCase()}${rest.map(word => capitalize(word)).join('')}`;
 }
 
+function kebabCase(str) {
+    const words = getWords(str);
+    return words.map(word => word.toLowerCase()).join('-');
+}
+
 function snakeCase(str) {
     const words = getWords(str);
     return words.map(word => word.toLowerCase()).join('_');
 }
 
-function kebabCase(str) {
+function lowerCase(str) {
     const words = getWords(str);
-    return words.map(word => word.toLowerCase()).join('-');
+    return words.map(word => word.toLowerCase()).join(' ');
 }
 
 function upperCase(str) {
@@ -40,11 +45,6 @@ function upperCase(str) {
     return result;
 }
 
-function lowerCase(str) {
-    const words = getWords(str);
-    return words.map(word => word.toLowerCase()).join(' ');
-}
-
 function pascalCase(str) {
     const words = getWords(str);
     return words.map(word => capitalize(word)).join('');
@@ -112,50 +112,6 @@ function lowerFirst(str) {
     return str.substring(0, 1).toLowerCase() + str.substring(1);
 }
 
-const deburrMap = new Map(Object.entries({
-    Æ: 'Ae',
-    Ð: 'D',
-    Ø: 'O',
-    Þ: 'Th',
-    ß: 'ss',
-    æ: 'ae',
-    ð: 'd',
-    ø: 'o',
-    þ: 'th',
-    Đ: 'D',
-    đ: 'd',
-    Ħ: 'H',
-    ħ: 'h',
-    ı: 'i',
-    IJ: 'IJ',
-    ij: 'ij',
-    ĸ: 'k',
-    Ŀ: 'L',
-    ŀ: 'l',
-    Ł: 'L',
-    ł: 'l',
-    ʼn: "'n",
-    Ŋ: 'N',
-    ŋ: 'n',
-    Œ: 'Oe',
-    œ: 'oe',
-    Ŧ: 'T',
-    ŧ: 't',
-    ſ: 's',
-}));
-function deburr(str) {
-    str = str.normalize('NFD');
-    let result = '';
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        if ((char >= '\u0300' && char <= '\u036f') || (char >= '\ufe20' && char <= '\ufe23')) {
-            continue;
-        }
-        result += deburrMap.get(char) ?? char;
-    }
-    return result;
-}
-
 const htmlEscapes = {
     '&': '&amp;',
     '<': '&lt;',
@@ -189,7 +145,6 @@ function pad(str, length, chars = ' ') {
 exports.camelCase = camelCase;
 exports.capitalize = capitalize;
 exports.constantCase = constantCase;
-exports.deburr = deburr;
 exports.escape = escape;
 exports.escapeRegExp = escapeRegExp;
 exports.getWords = getWords;

package/dist/_chunk/partialRight-CRhV1h.js

@@ -0,0 +1,53 @@
+'use strict';
+
+function noop() { }
+
+function partial(func, ...partialArgs) {
+    return function (...providedArgs) {
+        const args = [];
+        let startIndex = 0;
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === partial.placeholder) {
+                args.push(providedArgs[startIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        for (let i = startIndex; i < providedArgs.length; i++) {
+            args.push(providedArgs[i]);
+        }
+        return func.apply(this, args);
+    };
+}
+const partialPlaceholder = Symbol('partial.placeholder');
+partial.placeholder = partialPlaceholder;
+
+function partialRight(func, ...partialArgs) {
+    return function (...providedArgs) {
+        const placeholderLength = partialArgs.filter(arg => arg === partialRightPlaceholder).length;
+        const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+        const args = [];
+        let providedIndex = 0;
+        for (let i = 0; i < rangeLength; i++) {
+            args.push(providedArgs[providedIndex++]);
+        }
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === partialRight.placeholder) {
+                args.push(providedArgs[providedIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        return func.apply(this, args);
+    };
+}
+const partialRightPlaceholder = Symbol('partialRight.placeholder');
+partialRight.placeholder = partialRightPlaceholder;
+
+exports.noop = noop;
+exports.partial = partial;
+exports.partialRight = partialRight;

package/dist/_chunk/{range-BXlMmn.js → rangeRight-CtcxMd.js}

@@ -59,10 +59,30 @@ function range(start, end, step) {
     return result;
 }
 
+function rangeRight(start, end, step) {
+    if (end == null) {
+        end = start;
+        start = 0;
+    }
+    if (step == null) {
+        step = 1;
+    }
+    if (!Number.isInteger(step) || step === 0) {
+        throw new Error(`The step value must be a non-zero integer.`);
+    }
+    const length = Math.max(Math.ceil((end - start) / step), 0);
+    const result = new Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = start + (length - i - 1) * step;
+    }
+    return result;
+}
+
 exports.clamp = clamp;
 exports.inRange = inRange;
 exports.mean = mean;
 exports.meanBy = meanBy;
 exports.range = range;
+exports.rangeRight = rangeRight;
 exports.sum = sum;
 exports.sumBy = sumBy;