es-toolkit 1.35.0-dev.1202 → 1.35.0-dev.1209

package/dist/_chunk/{isPromise-ByAybB.js → isPromise-BqEEYJ.js}

@@ -1,8 +1,67 @@
 'use strict';
 
-const isPlainObject = require('./isPlainObject-Xaozpc.js');
 const noop = require('./noop-2IwLUk.js');
 
+function isPrimitive(value) {
+    return value == null || (typeof value !== 'object' && typeof value !== 'function');
+}
+
+function isTypedArray(x) {
+    return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+
+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]';
+const booleanTag = '[object Boolean]';
+const argumentsTag = '[object Arguments]';
+const symbolTag = '[object Symbol]';
+const dateTag = '[object Date]';
+const mapTag = '[object Map]';
+const setTag = '[object Set]';
+const arrayTag = '[object Array]';
+const functionTag = '[object Function]';
+const arrayBufferTag = '[object ArrayBuffer]';
+const objectTag = '[object Object]';
+const errorTag = '[object Error]';
+const dataViewTag = '[object DataView]';
+const uint8ArrayTag = '[object Uint8Array]';
+const uint8ClampedArrayTag = '[object Uint8ClampedArray]';
+const uint16ArrayTag = '[object Uint16Array]';
+const uint32ArrayTag = '[object Uint32Array]';
+const bigUint64ArrayTag = '[object BigUint64Array]';
+const int8ArrayTag = '[object Int8Array]';
+const int16ArrayTag = '[object Int16Array]';
+const int32ArrayTag = '[object Int32Array]';
+const bigInt64ArrayTag = '[object BigInt64Array]';
+const float32ArrayTag = '[object Float32Array]';
+const float64ArrayTag = '[object Float64Array]';
+
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    const hasObjectPrototype = proto === null ||
+        proto === Object.prototype ||
+        Object.getPrototypeOf(proto) === null;
+    if (!hasObjectPrototype) {
+        return false;
+    }
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+
 function isLength(value) {
     return Number.isSafeInteger(value) && value >= 0;
 }
@@ -27,14 +86,14 @@ function isSymbol(value) {
     return typeof value === 'symbol';
 }
 
-function isFunction(value) {
-    return typeof value === 'function';
-}
-
 function isBuffer(x) {
     return typeof Buffer !== 'undefined' && Buffer.isBuffer(x);
 }
 
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
 function isArrayBuffer(value) {
     return value instanceof ArrayBuffer;
 }
@@ -77,33 +136,33 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
     if (Object.is(a, b)) {
         return true;
     }
-    let aTag = isPlainObject.getTag(a);
-    let bTag = isPlainObject.getTag(b);
-    if (aTag === isPlainObject.argumentsTag) {
-        aTag = isPlainObject.objectTag;
+    let aTag = getTag(a);
+    let bTag = getTag(b);
+    if (aTag === argumentsTag) {
+        aTag = objectTag;
     }
-    if (bTag === isPlainObject.argumentsTag) {
-        bTag = isPlainObject.objectTag;
+    if (bTag === argumentsTag) {
+        bTag = objectTag;
     }
     if (aTag !== bTag) {
         return false;
     }
     switch (aTag) {
-        case isPlainObject.stringTag:
+        case stringTag:
             return a.toString() === b.toString();
-        case isPlainObject.numberTag: {
+        case numberTag: {
             const x = a.valueOf();
             const y = b.valueOf();
             return eq(x, y);
         }
-        case isPlainObject.booleanTag:
-        case isPlainObject.dateTag:
-        case isPlainObject.symbolTag:
+        case booleanTag:
+        case dateTag:
+        case symbolTag:
             return Object.is(a.valueOf(), b.valueOf());
-        case isPlainObject.regexpTag: {
+        case regexpTag: {
             return a.source === b.source && a.flags === b.flags;
         }
-        case isPlainObject.functionTag: {
+        case functionTag: {
             return a === b;
         }
     }
@@ -117,7 +176,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
     stack.set(b, a);
     try {
         switch (aTag) {
-            case isPlainObject.mapTag: {
+            case mapTag: {
                 if (a.size !== b.size) {
                     return false;
                 }
@@ -128,7 +187,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case isPlainObject.setTag: {
+            case setTag: {
                 if (a.size !== b.size) {
                     return false;
                 }
@@ -146,18 +205,18 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case isPlainObject.arrayTag:
-            case isPlainObject.uint8ArrayTag:
-            case isPlainObject.uint8ClampedArrayTag:
-            case isPlainObject.uint16ArrayTag:
-            case isPlainObject.uint32ArrayTag:
-            case isPlainObject.bigUint64ArrayTag:
-            case isPlainObject.int8ArrayTag:
-            case isPlainObject.int16ArrayTag:
-            case isPlainObject.int32ArrayTag:
-            case isPlainObject.bigInt64ArrayTag:
-            case isPlainObject.float32ArrayTag:
-            case isPlainObject.float64ArrayTag: {
+            case arrayTag:
+            case uint8ArrayTag:
+            case uint8ClampedArrayTag:
+            case uint16ArrayTag:
+            case uint32ArrayTag:
+            case bigUint64ArrayTag:
+            case int8ArrayTag:
+            case int16ArrayTag:
+            case int32ArrayTag:
+            case bigInt64ArrayTag:
+            case float32ArrayTag:
+            case float64ArrayTag: {
                 if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
                     return false;
                 }
@@ -171,29 +230,29 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case isPlainObject.arrayBufferTag: {
+            case arrayBufferTag: {
                 if (a.byteLength !== b.byteLength) {
                     return false;
                 }
                 return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
-            case isPlainObject.dataViewTag: {
+            case dataViewTag: {
                 if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
                     return false;
                 }
                 return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
-            case isPlainObject.errorTag: {
+            case errorTag: {
                 return a.name === b.name && a.message === b.message;
             }
-            case isPlainObject.objectTag: {
+            case objectTag: {
                 const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) ||
-                    (isPlainObject.isPlainObject(a) && isPlainObject.isPlainObject(b));
+                    (isPlainObject(a) && isPlainObject(b));
                 if (!areEqualInstances) {
                     return false;
                 }
-                const aKeys = [...Object.keys(a), ...isPlainObject.getSymbols(a)];
-                const bKeys = [...Object.keys(b), ...isPlainObject.getSymbols(b)];
+                const aKeys = [...Object.keys(a), ...getSymbols(a)];
+                const bKeys = [...Object.keys(b), ...getSymbols(b)];
                 if (aKeys.length !== bKeys.length) {
                     return false;
                 }
@@ -298,7 +357,7 @@ function isJSONArray(value) {
     return value.every(item => isJSONValue(item));
 }
 function isJSONObject(obj) {
-    if (!isPlainObject.isPlainObject(obj)) {
+    if (!isPlainObject(obj)) {
         return false;
     }
     const keys = Reflect.ownKeys(obj);
@@ -327,7 +386,20 @@ function isPromise(value) {
     return value instanceof Promise;
 }
 
+exports.argumentsTag = argumentsTag;
+exports.arrayBufferTag = arrayBufferTag;
+exports.arrayTag = arrayTag;
+exports.booleanTag = booleanTag;
+exports.dataViewTag = dataViewTag;
+exports.dateTag = dateTag;
 exports.eq = eq;
+exports.float32ArrayTag = float32ArrayTag;
+exports.float64ArrayTag = float64ArrayTag;
+exports.getSymbols = getSymbols;
+exports.getTag = getTag;
+exports.int16ArrayTag = int16ArrayTag;
+exports.int32ArrayTag = int32ArrayTag;
+exports.int8ArrayTag = int8ArrayTag;
 exports.isArrayBuffer = isArrayBuffer;
 exports.isBlob = isBlob;
 exports.isBrowser = isBrowser;
@@ -347,10 +419,24 @@ exports.isNil = isNil;
 exports.isNode = isNode;
 exports.isNotNil = isNotNil;
 exports.isNull = isNull;
+exports.isPlainObject = isPlainObject;
+exports.isPrimitive = isPrimitive;
 exports.isPromise = isPromise;
 exports.isRegExp = isRegExp;
 exports.isSet = isSet;
 exports.isSymbol = isSymbol;
+exports.isTypedArray = isTypedArray;
 exports.isUndefined = isUndefined;
 exports.isWeakMap = isWeakMap;
 exports.isWeakSet = isWeakSet;
+exports.mapTag = mapTag;
+exports.numberTag = numberTag;
+exports.objectTag = objectTag;
+exports.regexpTag = regexpTag;
+exports.setTag = setTag;
+exports.stringTag = stringTag;
+exports.symbolTag = symbolTag;
+exports.uint16ArrayTag = uint16ArrayTag;
+exports.uint32ArrayTag = uint32ArrayTag;
+exports.uint8ArrayTag = uint8ArrayTag;
+exports.uint8ClampedArrayTag = uint8ClampedArrayTag;

package/dist/_chunk/{reverseString-D-wK2p.js → reverseString-BixeGz.js}

@@ -1,6 +1,66 @@
 'use strict';
 
-const snakeCase = require('./snakeCase-BtVEeB.js');
+function capitalize(str) {
+    return (str.charAt(0).toUpperCase() + str.slice(1).toLowerCase());
+}
+
+const CASE_SPLIT_PATTERN = /\p{Lu}?\p{Ll}+|[0-9]+|\p{Lu}+(?!\p{Ll})|\p{Emoji_Presentation}|\p{Extended_Pictographic}|\p{L}+/gu;
+function words(str) {
+    return Array.from(str.match(CASE_SPLIT_PATTERN) ?? []);
+}
+
+function camelCase(str) {
+    const words$1 = words(str);
+    if (words$1.length === 0) {
+        return '';
+    }
+    const [first, ...rest] = words$1;
+    return `${first.toLowerCase()}${rest.map(word => capitalize(word)).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;',
@@ -18,13 +78,13 @@ function escapeRegExp(str) {
 }
 
 function kebabCase(str) {
-    const words = snakeCase.words(str);
-    return words.map(word => word.toLowerCase()).join('-');
+    const words$1 = words(str);
+    return words$1.map(word => word.toLowerCase()).join('-');
 }
 
 function lowerCase(str) {
-    const words = snakeCase.words(str);
-    return words.map(word => word.toLowerCase()).join(' ');
+    const words$1 = words(str);
+    return words$1.map(word => word.toLowerCase()).join(' ');
 }
 
 function lowerFirst(str) {
@@ -35,6 +95,11 @@ function pad(str, length, chars = ' ') {
     return str.padStart(Math.floor((length - str.length) / 2) + str.length, chars).padEnd(length, chars);
 }
 
+function snakeCase(str) {
+    const words$1 = words(str);
+    return words$1.map(word => word.toLowerCase()).join('_');
+}
+
 function trimEnd(str, chars) {
     if (chars === undefined) {
         return str.trimEnd();
@@ -99,11 +164,11 @@ function unescape(str) {
 }
 
 function upperCase(str) {
-    const words = snakeCase.words(str);
+    const words$1 = words(str);
     let result = '';
-    for (let i = 0; i < words.length; i++) {
-        result += words[i].toUpperCase();
-        if (i < words.length - 1) {
+    for (let i = 0; i < words$1.length; i++) {
+        result += words$1[i].toUpperCase();
+        if (i < words$1.length - 1) {
             result += ' ';
         }
     }
@@ -115,20 +180,24 @@ function upperFirst(str) {
 }
 
 function constantCase(str) {
-    const words = snakeCase.words(str);
-    return words.map(word => word.toUpperCase()).join('_');
+    const words$1 = words(str);
+    return words$1.map(word => word.toUpperCase()).join('_');
 }
 
 function pascalCase(str) {
-    const words = snakeCase.words(str);
-    return words.map(word => snakeCase.capitalize(word)).join('');
+    const words$1 = words(str);
+    return words$1.map(word => capitalize(word)).join('');
 }
 
 function reverseString(value) {
     return [...value].reverse().join('');
 }
 
+exports.CASE_SPLIT_PATTERN = CASE_SPLIT_PATTERN;
+exports.camelCase = camelCase;
+exports.capitalize = capitalize;
 exports.constantCase = constantCase;
+exports.deburr = deburr;
 exports.escape = escape;
 exports.escapeRegExp = escapeRegExp;
 exports.kebabCase = kebabCase;
@@ -137,9 +206,11 @@ exports.lowerFirst = lowerFirst;
 exports.pad = pad;
 exports.pascalCase = pascalCase;
 exports.reverseString = reverseString;
+exports.snakeCase = snakeCase;
 exports.trim = trim;
 exports.trimEnd = trimEnd;
 exports.trimStart = trimStart;
 exports.unescape = unescape;
 exports.upperCase = upperCase;
 exports.upperFirst = upperFirst;
+exports.words = words;