es-toolkit 1.23.0-dev.744 → 1.23.0-dev.745

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.23.0-dev.744+9edacf77",
+  "version": "1.23.0-dev.745+df19ff14",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {
@@ -237,6 +237,7 @@
     "globals": "^15.9.0",
     "jscodeshift": "^17.0.0",
     "prettier": "^3.2.5",
+    "prettier-plugin-sort-re-exports": "^0.0.1",
     "rollup": "^4.19.0",
     "rollup-plugin-dts": "^6.1.1",
     "tar": "^6",
@@ -249,6 +250,9 @@
   "dependenciesMeta": {
     "@trivago/prettier-plugin-sort-imports@4.3.0": {
       "unplugged": true
+    },
+    "prettier-plugin-sort-re-exports@0.0.1": {
+      "unplugged": true
     }
   },
   "sideEffects": false,

package/dist/_chunk/{isWeakSet-CjpFwn.js → isWeakSet-Bd6nry.js}

@@ -242,43 +242,26 @@ function isEqual(a, b) {
     return isEqualWith(a, b, noop.noop);
 }
 
-function isMap(value) {
-    return value instanceof Map;
-}
-
-function isNil(x) {
-    return x == null;
-}
-
-function isNotNil(x) {
-    return x != null;
-}
-
-function isNull(x) {
-    return x === null;
-}
-
-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)) {
+function isJSONObject(obj) {
+    if (!isPlainObject.isPlainObject(obj)) {
         return false;
     }
-    return value.every(item => isJSONValue(item));
+    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 isJSONValue(value) {
@@ -297,28 +280,45 @@ function isJSONValue(value) {
     }
 }
 
-function isJSONObject(obj) {
-    if (!isPlainObject.isPlainObject(obj)) {
+function isJSONArray(value) {
+    if (!Array.isArray(value)) {
         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;
+    return value.every(item => isJSONValue(item));
+}
+
+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;
+}
+
+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;
 }

package/dist/_chunk/{rangeRight-CtcxMd.js → sumBy-BkErWJ.js}

@@ -35,11 +35,6 @@ function meanBy(items, getValue) {
     return mean(nums);
 }
 
-function sumBy(items, getValue) {
-    const nums = items.map(x => getValue(x));
-    return sum(nums);
-}
-
 function range(start, end, step) {
     if (end == null) {
         end = start;
@@ -78,6 +73,11 @@ function rangeRight(start, end, step) {
     return result;
 }
 
+function sumBy(items, getValue) {
+    const nums = items.map(x => getValue(x));
+    return sum(nums);
+}
+
 exports.clamp = clamp;
 exports.inRange = inRange;
 exports.mean = mean;

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

@@ -2,41 +2,6 @@
 
 const isPlainObject = require('./isPlainObject-DgrsU7.js');
 
-function omitBy(obj, shouldOmit) {
-    const result = {};
-    const objEntries = Object.entries(obj);
-    for (let i = 0; i < objEntries.length; i++) {
-        const [key, value] = objEntries[i];
-        if (!shouldOmit(value, key)) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-function pickBy(obj, shouldPick) {
-    const result = {};
-    const objEntries = Object.entries(obj);
-    for (let i = 0; i < objEntries.length; i++) {
-        const [key, value] = objEntries[i];
-        if (shouldPick(value, key)) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-
-function invert(obj) {
-    const result = {};
-    const keys = Object.keys(obj);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = obj[key];
-        result[value] = key;
-    }
-    return result;
-}
-
 function clone(obj) {
     if (isPlainObject.isPrimitive(obj)) {
         return obj;
@@ -78,53 +43,6 @@ function clone(obj) {
     return obj;
 }
 
-function flattenObject(object) {
-    return flattenObjectImpl(object);
-}
-function flattenObjectImpl(object, prefix = '') {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        const prefixedKey = prefix ? `${prefix}.${key}` : key;
-        if (isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) {
-            Object.assign(result, flattenObjectImpl(value, prefixedKey));
-            continue;
-        }
-        if (Array.isArray(value)) {
-            for (let index = 0; index < value.length; index++) {
-                result[`${prefixedKey}.${index}`] = value[index];
-            }
-            continue;
-        }
-        result[prefixedKey] = value;
-    }
-    return result;
-}
-
-function mapKeys(object, getNewKey) {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        result[getNewKey(value, key, object)] = value;
-    }
-    return result;
-}
-
-function mapValues(object, getNewValue) {
-    const result = {};
-    const keys = Object.keys(object);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        const value = object[key];
-        result[key] = getNewValue(value, key, object);
-    }
-    return result;
-}
-
 function cloneDeep(obj) {
     return cloneDeepImpl(obj);
 }
@@ -234,6 +152,64 @@ function copyProperties(target, source, stack) {
     }
 }
 
+function flattenObject(object) {
+    return flattenObjectImpl(object);
+}
+function flattenObjectImpl(object, prefix = '') {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        const prefixedKey = prefix ? `${prefix}.${key}` : key;
+        if (isPlainObject.isPlainObject(value) && Object.keys(value).length > 0) {
+            Object.assign(result, flattenObjectImpl(value, prefixedKey));
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index++) {
+                result[`${prefixedKey}.${index}`] = value[index];
+            }
+            continue;
+        }
+        result[prefixedKey] = value;
+    }
+    return result;
+}
+
+function invert(obj) {
+    const result = {};
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = obj[key];
+        result[value] = key;
+    }
+    return result;
+}
+
+function mapKeys(object, getNewKey) {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        result[getNewKey(value, key, object)] = value;
+    }
+    return result;
+}
+
+function mapValues(object, getNewValue) {
+    const result = {};
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        result[key] = getNewValue(value, key, object);
+    }
+    return result;
+}
+
 function merge(target, source) {
     const sourceKeys = Object.keys(source);
     for (let i = 0; i < sourceKeys.length; i++) {
@@ -263,14 +239,38 @@ function merge(target, source) {
     return target;
 }
 
-function toMerged(target, source) {
-    return merge(cloneDeep(target), source);
-}
-
 function isObjectLike(value) {
     return typeof value === 'object' && value !== null;
 }
 
+function omitBy(obj, shouldOmit) {
+    const result = {};
+    const objEntries = Object.entries(obj);
+    for (let i = 0; i < objEntries.length; i++) {
+        const [key, value] = objEntries[i];
+        if (!shouldOmit(value, key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+function pickBy(obj, shouldPick) {
+    const result = {};
+    const objEntries = Object.entries(obj);
+    for (let i = 0; i < objEntries.length; i++) {
+        const [key, value] = objEntries[i];
+        if (shouldPick(value, key)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+function toMerged(target, source) {
+    return merge(cloneDeep(target), source);
+}
+
 exports.clone = clone;
 exports.cloneDeep = cloneDeep;
 exports.copyProperties = copyProperties;

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

@@ -18,41 +18,96 @@ function camelCase(str) {
     return `${first.toLowerCase()}${rest.map(word => capitalize(word)).join('')}`;
 }
 
-function snakeCase(str) {
-    const words = getWords(str);
-    return words.map(word => word.toLowerCase()).join('_');
-}
-
-function kebabCase(str) {
+function constantCase(str) {
     const words = getWords(str);
-    return words.map(word => word.toLowerCase()).join('-');
+    return words.map(word => word.toUpperCase()).join('_');
 }
 
-function upperCase(str) {
-    const words = getWords(str);
+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 < words.length; i++) {
-        result += words[i].toUpperCase();
-        if (i < words.length - 1) {
-            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;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+};
+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('-');
+}
+
 function lowerCase(str) {
     const words = getWords(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 constantCase(str) {
+function snakeCase(str) {
     const words = getWords(str);
-    return words.map(word => word.toUpperCase()).join('_');
+    return words.map(word => word.toLowerCase()).join('_');
 }
 
 function trimEnd(str, chars) {
@@ -104,73 +159,6 @@ function trim(str, chars) {
     return trimStart(trimEnd(str, chars), chars);
 }
 
-function upperFirst(str) {
-    return str.substring(0, 1).toUpperCase() + str.substring(1);
-}
-
-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;',
-    '>': '&gt;',
-    '"': '&quot;',
-    "'": '&#39;',
-};
-function escape(str) {
-    return str.replace(/[&<>"']/g, match => htmlEscapes[match]);
-}
-
-function escapeRegExp(str) {
-    return str.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
-}
-
 const htmlUnescapes = {
     '&amp;': '&',
     '&lt;': '<',
@@ -182,8 +170,20 @@ function unescape(str) {
     return str.replace(/&(?:amp|lt|gt|quot|#(0+)?39);/g, match => htmlUnescapes[match] || "'");
 }
 
-function pad(str, length, chars = ' ') {
-    return str.padStart(Math.floor((length - str.length) / 2) + str.length, chars).padEnd(length, chars);
+function upperCase(str) {
+    const words = getWords(str);
+    let result = '';
+    for (let i = 0; i < words.length; i++) {
+        result += words[i].toUpperCase();
+        if (i < words.length - 1) {
+            result += ' ';
+        }
+    }
+    return result;
+}
+
+function upperFirst(str) {
+    return str.substring(0, 1).toUpperCase() + str.substring(1);
 }
 
 exports.camelCase = camelCase;