es-toolkit 1.26.1-dev.836 → 1.26.1-dev.837

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/{isWeakSet-D8h8bS.js → isUndefined-C_iNqA.js}

@@ -1,7 +1,8 @@
 'use strict';
 
+const partialRight = require('./partialRight-CRhV1h.js');
 const isPlainObject = require('./isPlainObject-octpoD.js');
-const noop = require('./noop-2IwLUk.js');
+require('./deburr-BPmkoM.js');
 
 function isArrayBuffer(value) {
     return value instanceof ArrayBuffer;
@@ -18,11 +19,16 @@ function isDate(value) {
     return value instanceof Date;
 }
 
-function getTag(value) {
-    if (value == null) {
-        return value === undefined ? '[object Undefined]' : '[object Null]';
-    }
-    return Object.prototype.toString.call(value);
+function isLength(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+
+function isArrayLike(value) {
+    return value != null && typeof value !== 'function' && isLength(value.length);
+}
+
+function eq(value, other) {
+    return value === other || (Number.isNaN(value) && Number.isNaN(other));
 }
 
 const regexpTag = '[object RegExp]';
@@ -52,9 +58,187 @@ 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 getTag(value) {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return Object.prototype.toString.call(value);
+}
+
+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$1(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$1(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 curryRight(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 === curryRight.placeholder);
+        const length = partialArgs.length - holders.length;
+        if (length < arity) {
+            return makeCurryRight(func, arity - length, partialArgs);
+        }
+        if (this instanceof wrapper) {
+            return new func(...partialArgs);
+        }
+        return func.apply(this, partialArgs);
+    };
+    wrapper.placeholder = curryRightPlaceholder;
+    return wrapper;
+}
+function makeCurryRight(func, arity, partialArgs) {
+    function wrapper(...providedArgs) {
+        const holders = providedArgs.filter(item => item === curryRight.placeholder);
+        const length = providedArgs.length - holders.length;
+        providedArgs = composeArgs(providedArgs, partialArgs);
+        if (length < arity) {
+            return makeCurryRight(func, arity - length, providedArgs);
+        }
+        if (this instanceof wrapper) {
+            return new func(...providedArgs);
+        }
+        return func.apply(this, providedArgs);
+    }
+    wrapper.placeholder = curryRightPlaceholder;
+    return wrapper;
+}
+function composeArgs(providedArgs, partialArgs) {
+    const placeholderLength = partialArgs.filter(arg => arg === curryRight.placeholder).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 === curryRight.placeholder) {
+            if (providedIndex < providedArgs.length) {
+                args.push(providedArgs[providedIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    return args;
 }
+const curryRightPlaceholder = Symbol('curryRight.placeholder');
+curryRight.placeholder = curryRightPlaceholder;
 
 function isEqualWith(a, b, areValuesEqual) {
     return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
@@ -234,8 +418,48 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
     }
 }
 
+function isMap(value) {
+    return value instanceof Map;
+}
+
+function isRegExp(value) {
+    return value instanceof RegExp;
+}
+
+function isSet(value) {
+    return value instanceof Set;
+}
+
+function isWeakMap(value) {
+    return value instanceof WeakMap;
+}
+
+function isWeakSet(value) {
+    return value instanceof WeakSet;
+}
+
+function isEmpty(value) {
+    if (value == null) {
+        return true;
+    }
+    if (isArrayLike(value)) {
+        return value.length === 0;
+    }
+    if (value instanceof Map || value instanceof Set) {
+        return value.size === 0;
+    }
+    switch (typeof value) {
+        case 'object': {
+            return Object.keys(value).length === 0 && isPlainObject.getSymbols(value).length === 0;
+        }
+        default: {
+            return true;
+        }
+    }
+}
+
 function isEqual(a, b) {
-    return isEqualWith(a, b, noop.noop);
+    return isEqualWith(a, b, partialRight.noop);
 }
 
 function isFile(x) {
@@ -288,18 +512,6 @@ function isJSONObject(obj) {
     return true;
 }
 
-function isLength(value) {
-    return Number.isSafeInteger(value) && value >= 0;
-}
-
-function isMap(value) {
-    return value instanceof Map;
-}
-
-function isNil(x) {
-    return x == null;
-}
-
 function isNotNil(x) {
     return x != null;
 }
@@ -308,33 +520,23 @@ function isNull(x) {
     return x === null;
 }
 
-function isRegExp(value) {
-    return value instanceof RegExp;
-}
-
-function isSet(value) {
-    return value instanceof Set;
-}
-
 function isUndefined(x) {
     return x === undefined;
 }
 
-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.curryRight = curryRight;
 exports.eq = eq;
 exports.getTag = getTag;
 exports.isArrayBuffer = isArrayBuffer;
+exports.isArrayLike = isArrayLike;
 exports.isBlob = isBlob;
 exports.isDate = isDate;
+exports.isEmpty = isEmpty;
 exports.isEqual = isEqual;
 exports.isEqualWith = isEqualWith;
 exports.isFile = isFile;

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/{unary-CcTNuC.js → unary-DqRmr1.js}

@@ -130,52 +130,6 @@ function once(func) {
     };
 }
 
-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);
@@ -200,7 +154,5 @@ exports.identity = identity;
 exports.memoize = memoize;
 exports.negate = negate;
 exports.once = once;
-exports.partial = partial;
-exports.partialRight = partialRight;
 exports.rest = rest;
 exports.unary = unary;

package/dist/_chunk/{upperFirst-BUECmK.js → upperFirst-Dk8IW1.js}

@@ -18,55 +18,6 @@ function camelCase(str) {
     return `${first.toLowerCase()}${rest.map(word => capitalize(word)).join('')}`;
 }
 
-function constantCase(str) {
-    const words = getWords(str);
-    return words.map(word => word.toUpperCase()).join('_');
-}
-
-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;',
@@ -78,10 +29,6 @@ function escape(str) {
     return str.replace(/[&<>"']/g, match => htmlEscapes[match]);
 }
 
-function escapeRegExp(str) {
-    return str.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
-}
-
 function kebabCase(str) {
     const words = getWords(str);
     return words.map(word => word.toLowerCase()).join('-');
@@ -92,19 +39,10 @@ function lowerCase(str) {
     return words.map(word => word.toLowerCase()).join(' ');
 }
 
-function lowerFirst(str) {
-    return str.substring(0, 1).toLowerCase() + str.substring(1);
-}
-
 function pad(str, length, chars = ' ') {
     return str.padStart(Math.floor((length - str.length) / 2) + str.length, chars).padEnd(length, chars);
 }
 
-function pascalCase(str) {
-    const words = getWords(str);
-    return words.map(word => capitalize(word)).join('');
-}
-
 function snakeCase(str) {
     const words = getWords(str);
     return words.map(word => word.toLowerCase()).join('_');
@@ -159,17 +97,6 @@ function trim(str, chars) {
     return trimStart(trimEnd(str, chars), chars);
 }
 
-const htmlUnescapes = {
-    '&amp;': '&',
-    '&lt;': '<',
-    '&gt;': '>',
-    '&quot;': '"',
-    '&#39;': "'",
-};
-function unescape(str) {
-    return str.replace(/&(?:amp|lt|gt|quot|#(0+)?39);/g, match => htmlUnescapes[match] || "'");
-}
-
 function upperCase(str) {
     const words = getWords(str);
     let result = '';
@@ -182,6 +109,35 @@ function upperCase(str) {
     return result;
 }
 
+function constantCase(str) {
+    const words = getWords(str);
+    return words.map(word => word.toUpperCase()).join('_');
+}
+
+function escapeRegExp(str) {
+    return str.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
+}
+
+function lowerFirst(str) {
+    return str.substring(0, 1).toLowerCase() + str.substring(1);
+}
+
+function pascalCase(str) {
+    const words = getWords(str);
+    return words.map(word => capitalize(word)).join('');
+}
+
+const htmlUnescapes = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'",
+};
+function unescape(str) {
+    return str.replace(/&(?:amp|lt|gt|quot|#(0+)?39);/g, match => htmlUnescapes[match] || "'");
+}
+
 function upperFirst(str) {
     return str.substring(0, 1).toUpperCase() + str.substring(1);
 }
@@ -189,7 +145,6 @@ function upperFirst(str) {
 exports.camelCase = camelCase;
 exports.capitalize = capitalize;
 exports.constantCase = constantCase;
-exports.deburr = deburr;
 exports.escape = escape;
 exports.escapeRegExp = escapeRegExp;
 exports.getWords = getWords;