es-toolkit 1.36.0 → 1.37.0-dev.1243

package/dist/_chunk/{isPromise-CxqI1v.js → isWeakSet-403Sh5.js}

@@ -1,107 +1,24 @@
 '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;
-}
-
-function eq(value, other) {
-    return value === other || (Number.isNaN(value) && Number.isNaN(other));
-}
-
-function isNil(x) {
-    return x == null;
-}
-
-function isNull(x) {
-    return x === null;
-}
-
-function isUndefined(x) {
-    return x === undefined;
-}
-
-function isSymbol(value) {
-    return typeof value === 'symbol';
-}
-
-function isFunction(value) {
-    return typeof value === 'function';
+function isArrayBuffer(value) {
+    return value instanceof ArrayBuffer;
 }
 
 function isBuffer(x) {
     return typeof Buffer !== 'undefined' && Buffer.isBuffer(x);
 }
 
-function isArrayBuffer(value) {
-    return value instanceof ArrayBuffer;
-}
-
 function isDate(value) {
     return value instanceof Date;
 }
 
+function eq(value, other) {
+    return value === other || (Number.isNaN(value) && Number.isNaN(other));
+}
+
 function isEqualWith(a, b, areValuesEqual) {
     return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
 }
@@ -136,33 +53,33 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
     if (Object.is(a, b)) {
         return true;
     }
-    let aTag = getTag(a);
-    let bTag = getTag(b);
-    if (aTag === argumentsTag) {
-        aTag = objectTag;
+    let aTag = isPlainObject.getTag(a);
+    let bTag = isPlainObject.getTag(b);
+    if (aTag === isPlainObject.argumentsTag) {
+        aTag = isPlainObject.objectTag;
     }
-    if (bTag === argumentsTag) {
-        bTag = objectTag;
+    if (bTag === isPlainObject.argumentsTag) {
+        bTag = isPlainObject.objectTag;
     }
     if (aTag !== bTag) {
         return false;
     }
     switch (aTag) {
-        case stringTag:
+        case isPlainObject.stringTag:
             return a.toString() === b.toString();
-        case numberTag: {
+        case isPlainObject.numberTag: {
             const x = a.valueOf();
             const y = b.valueOf();
             return eq(x, y);
         }
-        case booleanTag:
-        case dateTag:
-        case symbolTag:
+        case isPlainObject.booleanTag:
+        case isPlainObject.dateTag:
+        case isPlainObject.symbolTag:
             return Object.is(a.valueOf(), b.valueOf());
-        case regexpTag: {
+        case isPlainObject.regexpTag: {
             return a.source === b.source && a.flags === b.flags;
         }
-        case functionTag: {
+        case isPlainObject.functionTag: {
             return a === b;
         }
     }
@@ -176,7 +93,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
     stack.set(b, a);
     try {
         switch (aTag) {
-            case mapTag: {
+            case isPlainObject.mapTag: {
                 if (a.size !== b.size) {
                     return false;
                 }
@@ -187,7 +104,7 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case setTag: {
+            case isPlainObject.setTag: {
                 if (a.size !== b.size) {
                     return false;
                 }
@@ -205,18 +122,18 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case arrayTag:
-            case uint8ArrayTag:
-            case uint8ClampedArrayTag:
-            case uint16ArrayTag:
-            case uint32ArrayTag:
-            case bigUint64ArrayTag:
-            case int8ArrayTag:
-            case int16ArrayTag:
-            case int32ArrayTag:
-            case bigInt64ArrayTag:
-            case float32ArrayTag:
-            case float64ArrayTag: {
+            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: {
                 if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
                     return false;
                 }
@@ -230,29 +147,29 @@ function areObjectsEqual(a, b, stack, areValuesEqual) {
                 }
                 return true;
             }
-            case arrayBufferTag: {
+            case isPlainObject.arrayBufferTag: {
                 if (a.byteLength !== b.byteLength) {
                     return false;
                 }
                 return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
-            case dataViewTag: {
+            case isPlainObject.dataViewTag: {
                 if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
                     return false;
                 }
                 return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
             }
-            case errorTag: {
+            case isPlainObject.errorTag: {
                 return a.name === b.name && a.message === b.message;
             }
-            case objectTag: {
+            case isPlainObject.objectTag: {
                 const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) ||
-                    (isPlainObject(a) && isPlainObject(b));
+                    (isPlainObject.isPlainObject(a) && isPlainObject.isPlainObject(b));
                 if (!areEqualInstances) {
                     return false;
                 }
-                const aKeys = [...Object.keys(a), ...getSymbols(a)];
-                const bKeys = [...Object.keys(b), ...getSymbols(b)];
+                const aKeys = [...Object.keys(a), ...isPlainObject.getSymbols(a)];
+                const bKeys = [...Object.keys(b), ...isPlainObject.getSymbols(b)];
                 if (aKeys.length !== bKeys.length) {
                     return false;
                 }
@@ -280,163 +197,68 @@ 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 isEqual(a, b) {
+    return isEqualWith(a, b, noop.noop);
 }
 
-function isWeakMap(value) {
-    return value instanceof WeakMap;
+function isFunction(value) {
+    return typeof value === 'function';
 }
 
-function isWeakSet(value) {
-    return value instanceof WeakSet;
+function isLength(value) {
+    return Number.isSafeInteger(value) && value >= 0;
 }
 
-function isBlob(x) {
-    if (typeof Blob === 'undefined') {
-        return false;
-    }
-    return x instanceof Blob;
+function isMap(value) {
+    return value instanceof Map;
 }
 
-function isBrowser() {
-    return typeof window !== 'undefined' && window?.document != null;
+function isNil(x) {
+    return x == null;
 }
 
-function isEqual(a, b) {
-    return isEqualWith(a, b, noop.noop);
+function isNull(x) {
+    return x === null;
 }
 
-function isFile(x) {
-    if (typeof File === 'undefined') {
-        return false;
-    }
-    return isBlob(x) && x instanceof File;
+function isRegExp(value) {
+    return value instanceof RegExp;
 }
 
-function isJSON(value) {
-    if (typeof value !== 'string') {
-        return false;
-    }
-    try {
-        JSON.parse(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
+function isSet(value) {
+    return value instanceof Set;
 }
 
-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 isJSONArray(value) {
-    if (!Array.isArray(value)) {
-        return false;
-    }
-    return value.every(item => isJSONValue(item));
-}
-function isJSONObject(obj) {
-    if (!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 isSymbol(value) {
+    return typeof value === 'symbol';
 }
 
-function isNode() {
-    return typeof process !== 'undefined' && process?.versions?.node != null;
+function isUndefined(x) {
+    return x === undefined;
 }
 
-function isNotNil(x) {
-    return x != null;
+function isWeakMap(value) {
+    return value instanceof WeakMap;
 }
 
-function isPromise(value) {
-    return value instanceof Promise;
+function isWeakSet(value) {
+    return value instanceof WeakSet;
 }
 
-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;
 exports.isBuffer = isBuffer;
 exports.isDate = isDate;
 exports.isEqual = isEqual;
 exports.isEqualWith = isEqualWith;
-exports.isFile = isFile;
 exports.isFunction = isFunction;
-exports.isJSON = isJSON;
-exports.isJSONArray = isJSONArray;
-exports.isJSONObject = isJSONObject;
-exports.isJSONValue = isJSONValue;
 exports.isLength = isLength;
 exports.isMap = isMap;
 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/{range-HnEIT7.js → range-DSpBDL.js}

@@ -35,25 +35,6 @@ function meanBy(items, getValue) {
     return mean(nums);
 }
 
-function median(nums) {
-    if (nums.length === 0) {
-        return NaN;
-    }
-    const sorted = nums.slice().sort((a, b) => a - b);
-    const middleIndex = Math.floor(sorted.length / 2);
-    if (sorted.length % 2 === 0) {
-        return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2;
-    }
-    else {
-        return sorted[middleIndex];
-    }
-}
-
-function medianBy(items, getValue) {
-    const nums = items.map(x => getValue(x));
-    return median(nums);
-}
-
 function range(start, end, step = 1) {
     if (end == null) {
         end = start;
@@ -74,7 +55,5 @@ exports.clamp = clamp;
 exports.inRange = inRange;
 exports.mean = mean;
 exports.meanBy = meanBy;
-exports.median = median;
-exports.medianBy = medianBy;
 exports.range = range;
 exports.sum = sum;

package/dist/_chunk/snakeCase-BwvoPi.js

@@ -0,0 +1,30 @@
+'use strict';
+
+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('')}`;
+}
+
+function snakeCase(str) {
+    const words$1 = words(str);
+    return words$1.map(word => word.toLowerCase()).join('_');
+}
+
+exports.CASE_SPLIT_PATTERN = CASE_SPLIT_PATTERN;
+exports.camelCase = camelCase;
+exports.capitalize = capitalize;
+exports.snakeCase = snakeCase;
+exports.words = words;

package/dist/_chunk/{unary-EIEhcF.js → unary-DzPndU.js}

@@ -1,7 +1,5 @@
 'use strict';
 
-const delay = require('./delay-_VMfFa.js');
-
 function after(n, func) {
     if (!Number.isInteger(n) || n < 0) {
         throw new Error(`n must be a non-negative integer.`);
@@ -21,8 +19,6 @@ function ary(func, n) {
     };
 }
 
-async function asyncNoop() { }
-
 function debounce(func, debounceMs, { signal, edges } = {}) {
     let pendingThis = undefined;
     let pendingArgs = null;
@@ -187,46 +183,12 @@ function rest(func, startIndex = func.length - 1) {
     };
 }
 
-const DEFAULT_DELAY = 0;
-const DEFAULT_RETRIES = Number.POSITIVE_INFINITY;
-async function retry(func, _options) {
-    let delay$1;
-    let retries;
-    let signal;
-    if (typeof _options === 'number') {
-        delay$1 = DEFAULT_DELAY;
-        retries = _options;
-        signal = undefined;
-    }
-    else {
-        delay$1 = _options?.delay ?? DEFAULT_DELAY;
-        retries = _options?.retries ?? DEFAULT_RETRIES;
-        signal = _options?.signal;
-    }
-    let error;
-    for (let attempts = 0; attempts < retries; attempts++) {
-        if (signal?.aborted) {
-            throw error ?? new Error(`The retry operation was aborted due to an abort signal.`);
-        }
-        try {
-            return await func();
-        }
-        catch (err) {
-            error = err;
-            const currentDelay = typeof delay$1 === 'function' ? delay$1(attempts) : delay$1;
-            await delay.delay(currentDelay);
-        }
-    }
-    throw error;
-}
-
 function unary(func) {
     return ary(func, 1);
 }
 
 exports.after = after;
 exports.ary = ary;
-exports.asyncNoop = asyncNoop;
 exports.debounce = debounce;
 exports.flow = flow;
 exports.flowRight = flowRight;
@@ -239,5 +201,4 @@ exports.partialImpl = partialImpl;
 exports.partialRight = partialRight;
 exports.partialRightImpl = partialRightImpl;
 exports.rest = rest;
-exports.retry = retry;
 exports.unary = unary;

package/dist/_chunk/{reverseString-BixeGz.js → upperFirst-C7IztG.js}

@@ -1,22 +1,6 @@
 'use strict';
 
-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 snakeCase = require('./snakeCase-BwvoPi.js');
 
 const deburrMap = new Map(Object.entries({
     Æ: 'Ae',
@@ -78,13 +62,13 @@ function escapeRegExp(str) {
 }
 
 function kebabCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toLowerCase()).join('-');
+    const words = snakeCase.words(str);
+    return words.map(word => word.toLowerCase()).join('-');
 }
 
 function lowerCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toLowerCase()).join(' ');
+    const words = snakeCase.words(str);
+    return words.map(word => word.toLowerCase()).join(' ');
 }
 
 function lowerFirst(str) {
@@ -95,11 +79,6 @@ 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();
@@ -164,11 +143,11 @@ function unescape(str) {
 }
 
 function upperCase(str) {
-    const words$1 = words(str);
+    const words = snakeCase.words(str);
     let result = '';
-    for (let i = 0; i < words$1.length; i++) {
-        result += words$1[i].toUpperCase();
-        if (i < words$1.length - 1) {
+    for (let i = 0; i < words.length; i++) {
+        result += words[i].toUpperCase();
+        if (i < words.length - 1) {
             result += ' ';
         }
     }
@@ -179,24 +158,6 @@ function upperFirst(str) {
     return str.substring(0, 1).toUpperCase() + str.substring(1);
 }
 
-function constantCase(str) {
-    const words$1 = words(str);
-    return words$1.map(word => word.toUpperCase()).join('_');
-}
-
-function pascalCase(str) {
-    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;
@@ -204,13 +165,9 @@ exports.kebabCase = kebabCase;
 exports.lowerCase = lowerCase;
 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;