es-toolkit 1.23.0 → 1.24.0-dev.766

package/dist/compat/index.js

@@ -2,16 +2,16 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zipWith = require('../_chunk/zipWith-EOU_KZ.js');
+const zipWith = require('../_chunk/zipWith-wpjySR.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
-const flowRight$1 = require('../_chunk/flowRight-Dv8J0U.js');
+const unary = require('../_chunk/unary-BZ5Ixo.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
-const range = require('../_chunk/range-BXlMmn.js');
+const sumBy = require('../_chunk/sumBy-BkErWJ.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const isObjectLike = require('../_chunk/isObjectLike-aywuSF.js');
+const toMerged = require('../_chunk/toMerged-DDLv0D.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-DgrsU7.js');
-const isWeakSet$1 = require('../_chunk/isWeakSet-BAMm2l.js');
-const pad$1 = require('../_chunk/pad-BWiShN.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-Bd6nry.js');
+const upperFirst = require('../_chunk/upperFirst-BUECmK.js');
 
 function castArray(value) {
     if (arguments.length === 0) {
@@ -32,9 +32,26 @@ function concat(...values) {
     return zipWith.flatten(values);
 }
 
+function isArrayLike(value) {
+    return value != null && typeof value !== 'function' && isWeakSet$1.isLength(value.length);
+}
+
+function isArrayLikeObject(value) {
+    return toMerged.isObjectLike(value) && isArrayLike(value);
+}
+
 function difference(arr, ...values) {
-    const arr1 = arr;
-    const arr2 = zipWith.flatten(values);
+    if (!isArrayLikeObject(arr)) {
+        return [];
+    }
+    const arr1 = Array.from(arr);
+    const arr2 = [];
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        if (isArrayLikeObject(value)) {
+            arr2.push(...Array.from(value));
+        }
+    }
     return zipWith.difference(arr1, arr2);
 }
 
@@ -221,7 +238,7 @@ function isMatch(target, source) {
         }
         default: {
             if (!isObject(target)) {
-                return target === source || (Number.isNaN(target) && Number.isNaN(source));
+                return isWeakSet$1.eq(target, source);
             }
             return !source;
         }
@@ -272,7 +289,7 @@ function isSetMatch(target, source) {
 }
 
 function matches(source) {
-    source = isObjectLike.cloneDeep(source);
+    source = toMerged.cloneDeep(source);
     return (target) => {
         return isMatch(target, source);
     };
@@ -280,25 +297,25 @@ function matches(source) {
 
 function cloneDeep(obj) {
     if (typeof obj !== 'object') {
-        return isObjectLike.cloneDeep(obj);
+        return toMerged.cloneDeep(obj);
     }
     switch (Object.prototype.toString.call(obj)) {
         case isWeakSet$1.numberTag:
         case isWeakSet$1.stringTag:
         case isWeakSet$1.booleanTag: {
             const result = new obj.constructor(obj?.valueOf());
-            isObjectLike.copyProperties(result, obj);
+            toMerged.copyProperties(result, obj);
             return result;
         }
         case isWeakSet$1.argumentsTag: {
             const result = {};
-            isObjectLike.copyProperties(result, obj);
+            toMerged.copyProperties(result, obj);
             result.length = obj.length;
             result[Symbol.iterator] = obj[Symbol.iterator];
             return result;
         }
         default: {
-            return isObjectLike.cloneDeep(obj);
+            return toMerged.cloneDeep(obj);
         }
     }
 }
@@ -376,6 +393,27 @@ function matchesProperty(property, source) {
     };
 }
 
+function dropRightWhile(arr, predicate) {
+    switch (typeof predicate) {
+        case 'function': {
+            return zipWith.dropRightWhile(arr, (item, index, arr) => Boolean(predicate(item, index, arr)));
+        }
+        case 'object': {
+            if (Array.isArray(predicate) && predicate.length === 2) {
+                const key = predicate[0];
+                const value = predicate[1];
+                return zipWith.dropRightWhile(arr, matchesProperty(key, value));
+            }
+            else {
+                return zipWith.dropRightWhile(arr, matches(predicate));
+            }
+        }
+        case 'string': {
+            return zipWith.dropRightWhile(arr, property(predicate));
+        }
+    }
+}
+
 function dropWhile(arr, predicate) {
     switch (typeof predicate) {
         case 'function': {
@@ -415,11 +453,10 @@ function every(source, doesMatch) {
     switch (typeof doesMatch) {
         case 'function': {
             if (!Array.isArray(source)) {
-                const entries = Object.entries(source);
-                for (let i = 0; i < entries.length; i++) {
-                    const entry = entries[i];
-                    const key = entry[0];
-                    const value = entry[1];
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
                     if (!doesMatch(value, key, source)) {
                         return false;
                     }
@@ -456,6 +493,42 @@ function fill(array, value, start = 0, end = array.length) {
     return zipWith.fill(array, value, start, end);
 }
 
+function isArray(value) {
+    return Array.isArray(value);
+}
+
+function filter(source, predicate) {
+    if (!predicate) {
+        predicate = identity;
+    }
+    const collection = isArray(source) ? source : Object.values(source);
+    switch (typeof predicate) {
+        case 'function': {
+            if (!Array.isArray(source)) {
+                const result = [];
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
+                    if (predicate(value, key, source)) {
+                        result.push(value);
+                    }
+                }
+                return result;
+            }
+            return collection.filter(predicate);
+        }
+        case 'object': {
+            return isArray(predicate)
+                ? collection.filter(matchesProperty(predicate[0], predicate[1]))
+                : collection.filter(matches(predicate));
+        }
+        case 'string': {
+            return collection.filter(property(predicate));
+        }
+    }
+}
+
 function find(source, doesMatch) {
     let values = source;
     if (!Array.isArray(source)) {
@@ -464,11 +537,10 @@ function find(source, doesMatch) {
     switch (typeof doesMatch) {
         case 'function': {
             if (!Array.isArray(source)) {
-                const entries = Object.entries(source);
-                for (let i = 0; i < entries.length; i++) {
-                    const entry = entries[i];
-                    const key = entry[0];
-                    const value = entry[1];
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
                     if (doesMatch(value, key, source)) {
                         return value;
                     }
@@ -640,7 +712,7 @@ function includes(source, target, fromIndex, guard) {
     }
     for (let i = fromIndex; i < keys.length; i++) {
         const value = Reflect.get(source, keys[i]);
-        if (value === target || (Number.isNaN(value) && Number.isNaN(target))) {
+        if (isWeakSet$1.eq(value, target)) {
             return true;
         }
     }
@@ -787,10 +859,6 @@ function orderBy(collection, criteria, orders) {
         .map(item => item.original);
 }
 
-function sortBy(collection, criteria) {
-    return orderBy(collection, criteria, ['asc']);
-}
-
 function size(target) {
     if (isWeakSet$1.isNil(target)) {
         return 0;
@@ -801,6 +869,51 @@ function size(target) {
     return Object.keys(target).length;
 }
 
+function isIterateeCall(value, index, object) {
+    if (!isObject(object)) {
+        return false;
+    }
+    if ((typeof index === 'number' && isArrayLike(object) && isIndex(index) && index < object.length) ||
+        (typeof index === 'string' && index in object)) {
+        return isWeakSet$1.eq(object[index], value);
+    }
+    return false;
+}
+
+function slice(array, start, end) {
+    if (array == null) {
+        return [];
+    }
+    const length = array.length;
+    if (end === undefined) {
+        end = length;
+    }
+    else if (typeof end !== 'number' && isIterateeCall(array, start, end)) {
+        start = 0;
+        end = length;
+    }
+    start = toInteger(start);
+    end = toInteger(end);
+    if (start < 0) {
+        start = Math.max(length + start, 0);
+    }
+    else {
+        start = Math.min(start, length);
+    }
+    if (end < 0) {
+        end = Math.max(length + end, 0);
+    }
+    else {
+        end = Math.min(end, length);
+    }
+    const resultLength = Math.max(end - start, 0);
+    const result = new Array(resultLength);
+    for (let i = 0; i < resultLength; ++i) {
+        result[i] = array[start + i];
+    }
+    return result;
+}
+
 function some(arr, predicate, guard) {
     if (guard != null) {
         predicate = undefined;
@@ -831,6 +944,17 @@ function some(arr, predicate, guard) {
     }
 }
 
+function sortBy(collection, criteria) {
+    return orderBy(collection, criteria, ['asc']);
+}
+
+function take(arr, count) {
+    if (count < 1) {
+        return [];
+    }
+    return zipWith.take(arr, count);
+}
+
 function set(obj, path, value) {
     const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
     let current = obj;
@@ -859,43 +983,6 @@ function zipObjectDeep(keys, values) {
     return result;
 }
 
-function isArray(value) {
-    return Array.isArray(value);
-}
-
-function filter(source, predicate) {
-    if (!predicate) {
-        predicate = identity;
-    }
-    const collection = isArray(source) ? source : Object.values(source);
-    switch (typeof predicate) {
-        case 'function': {
-            if (!Array.isArray(source)) {
-                const result = [];
-                const entries = Object.entries(source);
-                for (let i = 0; i < entries.length; i++) {
-                    const entry = entries[i];
-                    const key = entry[0];
-                    const value = entry[1];
-                    if (predicate(value, key, source)) {
-                        result.push(value);
-                    }
-                }
-                return result;
-            }
-            return collection.filter(predicate);
-        }
-        case 'object': {
-            return isArray(predicate)
-                ? collection.filter(matchesProperty(predicate[0], predicate[1]))
-                : collection.filter(matches(predicate));
-        }
-        case 'string': {
-            return collection.filter(property(predicate));
-        }
-    }
-}
-
 function ary(func, n = func.length, guard) {
     if (guard) {
         n = func.length;
@@ -903,7 +990,33 @@ function ary(func, n = func.length, guard) {
     if (Number.isNaN(n) || n < 0) {
         n = 0;
     }
-    return flowRight$1.ary(func, n);
+    return unary.ary(func, n);
+}
+
+function attempt(func, ...args) {
+    try {
+        return func(...args);
+    }
+    catch (e) {
+        return e instanceof Error ? e : new Error(e);
+    }
+}
+
+function before(n, func) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    let result;
+    n = toInteger(n);
+    return function (...args) {
+        if (--n > 0) {
+            result = func.apply(this, args);
+        }
+        if (n <= 1 && func) {
+            func = undefined;
+        }
+        return result;
+    };
 }
 
 function bind(func, thisObj, ...partialArgs) {
@@ -958,56 +1071,6 @@ function bindKey(object, key, ...partialArgs) {
 const bindKeyPlaceholder = Symbol('bindKey.placeholder');
 bindKey.placeholder = bindKeyPlaceholder;
 
-function defer(func, ...args) {
-    if (typeof func !== 'function') {
-        throw new TypeError('Expected a function');
-    }
-    return setTimeout(func, 1, ...args);
-}
-
-function rest(func, start = func.length - 1) {
-    start = Number.parseInt(start, 10);
-    if (Number.isNaN(start) || start < 0) {
-        start = func.length - 1;
-    }
-    return flowRight$1.rest(func, start);
-}
-
-function spread(func, argsIndex = 0) {
-    argsIndex = Number.parseInt(argsIndex, 10);
-    if (Number.isNaN(argsIndex) || argsIndex < 0) {
-        argsIndex = 0;
-    }
-    return function (...args) {
-        const array = args[argsIndex];
-        const params = args.slice(0, argsIndex);
-        if (array) {
-            params.push(...array);
-        }
-        return func.apply(this, params);
-    };
-}
-
-function attempt(func, ...args) {
-    try {
-        return func(...args);
-    }
-    catch (e) {
-        return e instanceof Error ? e : new Error(e);
-    }
-}
-
-function rearg(func, ...indices) {
-    const flattenIndices = flatten(indices);
-    return function (...args) {
-        const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length);
-        for (let i = reorderedArgs.length; i < args.length; i++) {
-            reorderedArgs.push(args[i]);
-        }
-        return func.apply(this, reorderedArgs);
-    };
-}
-
 function curry(func, arity = func.length, guard) {
     arity = guard ? func.length : arity;
     arity = Number.parseInt(arity, 10);
@@ -1032,7 +1095,7 @@ 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);
+        providedArgs = composeArgs$1(providedArgs, partialArgs);
         if (length < arity) {
             return makeCurry(func, arity - length, providedArgs);
         }
@@ -1044,7 +1107,7 @@ function makeCurry(func, arity, partialArgs) {
     wrapper.placeholder = curryPlaceholder;
     return wrapper;
 }
-function composeArgs(providedArgs, partialArgs) {
+function composeArgs$1(providedArgs, partialArgs) {
     const args = [];
     let startIndex = 0;
     for (let i = 0; i < partialArgs.length; i++) {
@@ -1064,6 +1127,69 @@ function composeArgs(providedArgs, partialArgs) {
 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 debounce(func, debounceMs = 0, options = {}) {
     if (typeof options !== 'object') {
         options = {};
@@ -1078,7 +1204,7 @@ function debounce(func, debounceMs = 0, options = {}) {
     }
     let result = undefined;
     let pendingAt = null;
-    const _debounced = flowRight$1.debounce(function (...args) {
+    const _debounced = unary.debounce(function (...args) {
         result = func.apply(this, args);
         pendingAt = null;
     }, debounceMs, { signal, edges });
@@ -1109,12 +1235,11 @@ function debounce(func, debounceMs = 0, options = {}) {
     return debounced;
 }
 
-function throttle(func, throttleMs = 0, options = {}) {
-    if (typeof options !== 'object') {
-        options = {};
+function defer(func, ...args) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
     }
-    const { leading = true, trailing = true, signal } = options;
-    return debounce(func, throttleMs, { leading, trailing, signal, maxWait: throttleMs });
+    return setTimeout(func, 1, ...args);
 }
 
 function flip(func) {
@@ -1128,7 +1253,7 @@ function flow(...funcs) {
     if (flattenFuncs.some(func => typeof func !== 'function')) {
         throw new TypeError('Expected a function');
     }
-    return flowRight$1.flow(...flattenFuncs);
+    return unary.flow(...flattenFuncs);
 }
 
 function flowRight(...funcs) {
@@ -1136,133 +1261,261 @@ function flowRight(...funcs) {
     if (flattenFuncs.some(func => typeof func !== 'function')) {
         throw new TypeError('Expected a function');
     }
-    return flowRight$1.flowRight(...flattenFuncs);
-}
-
-function isNil(x) {
-    return x == null;
+    return unary.flowRight(...flattenFuncs);
 }
 
-function pick(obj, ...keysArr) {
-    if (isNil(obj)) {
-        return {};
+function rearg(func, ...indices) {
+    const flattenIndices = flatten(indices);
+    return function (...args) {
+        const reorderedArgs = flattenIndices.map(i => args[i]).slice(0, args.length);
+        for (let i = reorderedArgs.length; i < args.length; i++) {
+            reorderedArgs.push(args[i]);
+        }
+        return func.apply(this, reorderedArgs);
+    };
+}
+
+function rest(func, start = func.length - 1) {
+    start = Number.parseInt(start, 10);
+    if (Number.isNaN(start) || start < 0) {
+        start = func.length - 1;
     }
-    const result = {};
-    for (let i = 0; i < keysArr.length; i++) {
-        let keys = keysArr[i];
-        switch (typeof keys) {
-            case 'object': {
-                if (!Array.isArray(keys)) {
-                    keys = Array.from(keys);
-                }
-                break;
-            }
-            case 'string':
-            case 'symbol':
-            case 'number': {
-                keys = [keys];
-                break;
-            }
+    return unary.rest(func, start);
+}
+
+function spread(func, argsIndex = 0) {
+    argsIndex = Number.parseInt(argsIndex, 10);
+    if (Number.isNaN(argsIndex) || argsIndex < 0) {
+        argsIndex = 0;
+    }
+    return function (...args) {
+        const array = args[argsIndex];
+        const params = args.slice(0, argsIndex);
+        if (array) {
+            params.push(...array);
         }
-        for (const key of keys) {
-            const value = get(obj, key);
-            if (typeof key === 'string' && Object.hasOwn(obj, key)) {
-                result[key] = value;
-            }
-            else {
-                set(result, key, value);
-            }
+        return func.apply(this, params);
+    };
+}
+
+function throttle(func, throttleMs = 0, options = {}) {
+    if (typeof options !== 'object') {
+        options = {};
+    }
+    const { leading = true, trailing = true, signal } = options;
+    return debounce(func, throttleMs, { leading, trailing, signal, maxWait: throttleMs });
+}
+
+function decimalAdjust(type, number, precision = 0) {
+    number = Number(number);
+    if (Object.is(number, -0)) {
+        number = '-0';
+    }
+    precision = Math.min(Number.parseInt(precision, 10), 292);
+    if (precision) {
+        const [magnitude, exponent = 0] = number.toString().split('e');
+        let adjustedValue = Math[type](Number(`${magnitude}e${Number(exponent) + precision}`));
+        if (Object.is(adjustedValue, -0)) {
+            adjustedValue = '-0';
         }
+        const [newMagnitude, newExponent = 0] = adjustedValue.toString().split('e');
+        return Number(`${newMagnitude}e${Number(newExponent) - precision}`);
     }
-    return result;
+    return Math[type](Number(number));
 }
 
-function unset(obj, path) {
-    if (obj == null) {
-        return true;
+function ceil(number, precision = 0) {
+    return decimalAdjust('ceil', number, precision);
+}
+
+function clamp(value, bound1, bound2) {
+    if (Number.isNaN(bound1)) {
+        bound1 = 0;
     }
-    switch (typeof path) {
-        case 'symbol':
-        case 'number':
-        case 'object': {
-            if (Array.isArray(path)) {
-                return unsetWithPath(obj, path);
-            }
-            if (typeof path === 'number') {
-                path = toKey(path);
-            }
-            else if (typeof path === 'object') {
-                if (Object.is(path?.valueOf(), -0)) {
-                    path = '-0';
-                }
-                else {
-                    path = String(path);
-                }
+    if (Number.isNaN(bound2)) {
+        bound2 = 0;
+    }
+    return sumBy.clamp(value, bound1, bound2);
+}
+
+function floor(number, precision = 0) {
+    return decimalAdjust('floor', number, precision);
+}
+
+function inRange(value, minimum, maximum) {
+    if (!minimum) {
+        minimum = 0;
+    }
+    if (maximum != null && !maximum) {
+        maximum = 0;
+    }
+    if (minimum != null && typeof minimum !== 'number') {
+        minimum = Number(minimum);
+    }
+    if (maximum == null && minimum === 0) {
+        return false;
+    }
+    if (maximum != null && typeof maximum !== 'number') {
+        maximum = Number(maximum);
+    }
+    if (maximum != null && minimum > maximum) {
+        [minimum, maximum] = [maximum, minimum];
+    }
+    if (minimum === maximum) {
+        return false;
+    }
+    return sumBy.inRange(value, minimum, maximum);
+}
+
+function max(items = []) {
+    let maxElement = items[0];
+    let max = undefined;
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
+        if (max == null || element > max) {
+            max = element;
+            maxElement = element;
+        }
+    }
+    return maxElement;
+}
+
+function min(items = []) {
+    let minElement = items[0];
+    let min = undefined;
+    for (let i = 0; i < items.length; i++) {
+        const element = items[i];
+        if (min == null || element < min) {
+            min = element;
+            minElement = element;
+        }
+    }
+    return minElement;
+}
+
+function parseInt(string, radix = 0, guard) {
+    if (guard) {
+        radix = 0;
+    }
+    return Number.parseInt(string, radix);
+}
+
+function random(...args) {
+    let minimum = 0;
+    let maximum = 1;
+    let floating = false;
+    switch (args.length) {
+        case 1: {
+            if (typeof args[0] === 'boolean') {
+                floating = args[0];
             }
-            if (obj?.[path] === undefined) {
-                return true;
+            else {
+                maximum = args[0];
             }
-            try {
-                delete obj[path];
-                return true;
+            break;
+        }
+        case 2: {
+            if (typeof args[1] === 'boolean') {
+                maximum = args[0];
+                floating = args[1];
             }
-            catch {
-                return false;
+            else {
+                minimum = args[0];
+                maximum = args[1];
             }
         }
-        case 'string': {
-            if (obj?.[path] === undefined && isDeepKey(path)) {
-                return unsetWithPath(obj, toPath(path));
-            }
-            try {
-                delete obj[path];
-                return true;
+        case 3: {
+            if (typeof args[2] === 'object' && args[2] != null && args[2][args[1]] === args[0]) {
+                minimum = 0;
+                maximum = args[0];
+                floating = false;
             }
-            catch {
-                return false;
+            else {
+                minimum = args[0];
+                maximum = args[1];
+                floating = args[2];
             }
         }
     }
-}
-function unsetWithPath(obj, path) {
-    const parent = get(obj, path.slice(0, -1), obj);
-    const lastKey = path[path.length - 1];
-    if (parent?.[lastKey] === undefined) {
-        return true;
+    if (typeof minimum !== 'number') {
+        minimum = Number(minimum);
     }
-    try {
-        delete parent[lastKey];
-        return true;
+    if (typeof maximum !== 'number') {
+        minimum = Number(maximum);
     }
-    catch {
-        return false;
+    if (!minimum) {
+        minimum = 0;
+    }
+    if (!maximum) {
+        maximum = 0;
+    }
+    if (minimum > maximum) {
+        [minimum, maximum] = [maximum, minimum];
+    }
+    minimum = clamp(minimum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    maximum = clamp(maximum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+    if (minimum === maximum) {
+        return minimum;
+    }
+    if (floating) {
+        return randomInt.random(minimum, maximum + 1);
+    }
+    else {
+        return randomInt.randomInt(minimum, maximum + 1);
     }
 }
 
-function omit(obj, ...keysArr) {
-    if (obj == null) {
+function round(number, precision = 0) {
+    return decimalAdjust('round', number, precision);
+}
+
+function defaults(object, ...sources) {
+    object = Object(object);
+    const objectProto = Object.prototype;
+    for (let i = 0; i < sources.length; i++) {
+        const source = sources[i];
+        const keys = Object.keys(source);
+        for (let j = 0; j < keys.length; j++) {
+            const key = keys[j];
+            const value = object[key];
+            if (value === undefined ||
+                (!Object.hasOwn(object, key) && isWeakSet$1.eq(value, objectProto[key]))) {
+                object[key] = source[key];
+            }
+        }
+    }
+    return object;
+}
+
+function fromPairs(pairs) {
+    if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
         return {};
     }
-    const result = isObjectLike.cloneDeep(obj);
-    for (let i = 0; i < keysArr.length; i++) {
-        let keys = keysArr[i];
-        switch (typeof keys) {
-            case 'object': {
-                if (!Array.isArray(keys)) {
-                    keys = Array.from(keys);
-                }
-                for (let j = 0; j < keys.length; j++) {
-                    const key = keys[j];
-                    unset(result, key);
-                }
-                break;
-            }
-            case 'string':
-            case 'symbol':
-            case 'number': {
-                unset(result, keys);
-                break;
-            }
+    const result = {};
+    for (const [key, value] of pairs) {
+        result[key] = value;
+    }
+    return result;
+}
+
+function invertBy(object, iteratee) {
+    const result = {};
+    if (isWeakSet$1.isNil(object)) {
+        return result;
+    }
+    if (iteratee == null) {
+        iteratee = identity;
+    }
+    const keys = Object.keys(object);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = object[key];
+        const valueStr = iteratee(value);
+        if (Array.isArray(result[valueStr])) {
+            result[valueStr].push(key);
+        }
+        else {
+            result[valueStr] = [key];
         }
     }
     return result;
@@ -1275,10 +1528,10 @@ function mapKeys(object, getNewKey) {
         case 'symbol':
         case 'number':
         case 'object': {
-            return isObjectLike.mapKeys(object, property(getNewKey));
+            return toMerged.mapKeys(object, property(getNewKey));
         }
         case 'function': {
-            return isObjectLike.mapKeys(object, getNewKey);
+            return toMerged.mapKeys(object, getNewKey);
         }
     }
 }
@@ -1290,10 +1543,10 @@ function mapValues(object, getNewValue) {
         case 'symbol':
         case 'number':
         case 'object': {
-            return isObjectLike.mapValues(object, property(getNewValue));
+            return toMerged.mapValues(object, property(getNewValue));
         }
         case 'function': {
-            return isObjectLike.mapValues(object, getNewValue);
+            return toMerged.mapValues(object, getNewValue);
         }
     }
 }
@@ -1345,7 +1598,7 @@ function mergeWithDeep(target, source, merge, stack) {
         return target;
     }
     if (stack.has(source)) {
-        return isObjectLike.clone(stack.get(source));
+        return toMerged.clone(stack.get(source));
     }
     stack.set(source, target);
     if (Array.isArray(source)) {
@@ -1389,7 +1642,7 @@ function mergeWithDeep(target, source, merge, stack) {
         else if (Array.isArray(sourceValue)) {
             target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
         }
-        else if (isObjectLike.isObjectLike(targetValue) && isObjectLike.isObjectLike(sourceValue)) {
+        else if (toMerged.isObjectLike(targetValue) && toMerged.isObjectLike(sourceValue)) {
             target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
         }
         else if (targetValue == null && isPlainObject(sourceValue)) {
@@ -1409,43 +1662,138 @@ function merge(object, ...sources) {
     return mergeWith(object, ...sources, noop.noop);
 }
 
-function isArrayLike(value) {
-    return value != null && typeof value !== 'function' && isWeakSet$1.isLength(value.length);
+function unset(obj, path) {
+    if (obj == null) {
+        return true;
+    }
+    switch (typeof path) {
+        case 'symbol':
+        case 'number':
+        case 'object': {
+            if (Array.isArray(path)) {
+                return unsetWithPath(obj, path);
+            }
+            if (typeof path === 'number') {
+                path = toKey(path);
+            }
+            else if (typeof path === 'object') {
+                if (Object.is(path?.valueOf(), -0)) {
+                    path = '-0';
+                }
+                else {
+                    path = String(path);
+                }
+            }
+            if (obj?.[path] === undefined) {
+                return true;
+            }
+            try {
+                delete obj[path];
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        case 'string': {
+            if (obj?.[path] === undefined && isDeepKey(path)) {
+                return unsetWithPath(obj, toPath(path));
+            }
+            try {
+                delete obj[path];
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+}
+function unsetWithPath(obj, path) {
+    const parent = get(obj, path.slice(0, -1), obj);
+    const lastKey = path[path.length - 1];
+    if (parent?.[lastKey] === undefined) {
+        return true;
+    }
+    try {
+        delete parent[lastKey];
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 
-function fromPairs(pairs) {
-    if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
+function omit(obj, ...keysArr) {
+    if (obj == null) {
         return {};
     }
-    const result = {};
-    for (const [key, value] of pairs) {
-        result[key] = value;
+    const result = toMerged.cloneDeep(obj);
+    for (let i = 0; i < keysArr.length; i++) {
+        let keys = keysArr[i];
+        switch (typeof keys) {
+            case 'object': {
+                if (!Array.isArray(keys)) {
+                    keys = Array.from(keys);
+                }
+                for (let j = 0; j < keys.length; j++) {
+                    const key = keys[j];
+                    unset(result, key);
+                }
+                break;
+            }
+            case 'string':
+            case 'symbol':
+            case 'number': {
+                unset(result, keys);
+                break;
+            }
+        }
     }
     return result;
 }
 
-function isBoolean(value) {
-    return typeof value === 'boolean' || value instanceof Boolean;
-}
-
-function isError(value) {
-    return isWeakSet$1.getTag(value) === '[object Error]';
-}
-
-function isFinite(value) {
-    return Number.isFinite(value);
-}
-
-function isRegExp(value) {
-    return isWeakSet$1.isRegExp(value);
+function isNil(x) {
+    return x == null;
 }
 
-function isWeakMap(value) {
-    return isWeakSet$1.isWeakMap(value);
+function pick(obj, ...keysArr) {
+    if (isNil(obj)) {
+        return {};
+    }
+    const result = {};
+    for (let i = 0; i < keysArr.length; i++) {
+        let keys = keysArr[i];
+        switch (typeof keys) {
+            case 'object': {
+                if (!Array.isArray(keys)) {
+                    keys = Array.from(keys);
+                }
+                break;
+            }
+            case 'string':
+            case 'symbol':
+            case 'number': {
+                keys = [keys];
+                break;
+            }
+        }
+        for (const key of keys) {
+            const value = get(obj, key);
+            if (typeof key === 'string' && Object.hasOwn(obj, key)) {
+                result[key] = value;
+            }
+            else {
+                set(result, key, value);
+            }
+        }
+    }
+    return result;
 }
 
-function isWeakSet(value) {
-    return isWeakSet$1.isWeakSet(value);
+function toDefaulted(object, ...sources) {
+    const cloned = cloneDeep(object);
+    return defaults(cloned, ...sources);
 }
 
 function conformsTo(target, source) {
@@ -1468,30 +1816,84 @@ function conformsTo(target, source) {
 }
 
 function conforms(source) {
-    source = isObjectLike.cloneDeep(source);
+    source = toMerged.cloneDeep(source);
     return function (object) {
         return conformsTo(object, source);
     };
 }
 
+function isArrayBuffer(value) {
+    return isWeakSet$1.isArrayBuffer(value);
+}
+
+function isBoolean(value) {
+    return typeof value === 'boolean' || value instanceof Boolean;
+}
+
+function isDate(value) {
+    return isWeakSet$1.isDate(value);
+}
+
+function isEqualWith(a, b, areValuesEqual = noop.noop) {
+    if (typeof areValuesEqual !== 'function') {
+        areValuesEqual = noop.noop;
+    }
+    return isWeakSet$1.isEqualWith(a, b, (...args) => {
+        const result = areValuesEqual(...args);
+        if (result !== undefined) {
+            return Boolean(result);
+        }
+        if (a instanceof Map && b instanceof Map) {
+            return isEqualWith(Array.from(a), Array.from(b), unary.after(2, areValuesEqual));
+        }
+        if (a instanceof Set && b instanceof Set) {
+            return isEqualWith(Array.from(a), Array.from(b), unary.after(2, areValuesEqual));
+        }
+    });
+}
+
+function isError(value) {
+    return isWeakSet$1.getTag(value) === '[object Error]';
+}
+
+function isFinite(value) {
+    return Number.isFinite(value);
+}
+
 function isInteger(value) {
     return Number.isInteger(value);
 }
 
-function isSafeInteger(value) {
-    return Number.isSafeInteger(value);
+function isMap(value) {
+    return isWeakSet$1.isMap(value);
+}
+
+function isNaN(value) {
+    return Number.isNaN(value);
 }
 
 function isNumber(value) {
     return typeof value === 'number' || value instanceof Number;
 }
 
-function isNaN(value) {
-    return Number.isNaN(value);
+function isRegExp(value) {
+    return isWeakSet$1.isRegExp(value);
 }
 
-function isArrayLikeObject(value) {
-    return isObjectLike.isObjectLike(value) && isArrayLike(value);
+function isSafeInteger(value) {
+    return Number.isSafeInteger(value);
+}
+
+function isSet(value) {
+    return isWeakSet$1.isSet(value);
+}
+
+function isWeakMap(value) {
+    return isWeakSet$1.isWeakMap(value);
+}
+
+function isWeakSet(value) {
+    return isWeakSet$1.isWeakSet(value);
 }
 
 function toString(value) {
@@ -1516,19 +1918,43 @@ function normalizeForCase(str) {
 }
 
 function camelCase(str) {
-    return pad$1.camelCase(normalizeForCase(str));
+    return upperFirst.camelCase(normalizeForCase(str));
+}
+
+function endsWith(str, target, position = str.length) {
+    return str.endsWith(target, position);
 }
 
 function kebabCase(str) {
-    return pad$1.kebabCase(normalizeForCase(str));
+    return upperFirst.kebabCase(normalizeForCase(str));
+}
+
+function lowerCase(str) {
+    return upperFirst.lowerCase(normalizeForCase(str));
+}
+
+function pad(str, length, chars = ' ') {
+    return upperFirst.pad(toString(str), length, chars);
+}
+
+function padEnd(str, length = 0, chars = ' ') {
+    return toString(str).padEnd(length, chars);
+}
+
+function padStart(str, length = 0, chars = ' ') {
+    return toString(str).padStart(length, chars);
+}
+
+function repeat(str, n) {
+    return str.repeat(n);
 }
 
 function snakeCase(str) {
-    return pad$1.snakeCase(normalizeForCase(str));
+    return upperFirst.snakeCase(normalizeForCase(str));
 }
 
 function startCase(str) {
-    const words = pad$1.getWords(normalizeForCase(str).trim());
+    const words = upperFirst.getWords(normalizeForCase(str).trim());
     let result = '';
     for (let i = 0; i < words.length; i++) {
         const word = words[i];
@@ -1545,36 +1971,12 @@ function startCase(str) {
     return result;
 }
 
-function lowerCase(str) {
-    return pad$1.lowerCase(normalizeForCase(str));
-}
-
-function upperCase(str) {
-    return pad$1.upperCase(normalizeForCase(str));
-}
-
 function startsWith(str, target, position = 0) {
     return str.startsWith(target, position);
 }
 
-function endsWith(str, target, position = str.length) {
-    return str.endsWith(target, position);
-}
-
-function pad(str, length, chars = ' ') {
-    return pad$1.pad(toString(str), length, chars);
-}
-
-function padStart(str, length = 0, chars = ' ') {
-    return toString(str).padStart(length, chars);
-}
-
-function padEnd(str, length = 0, chars = ' ') {
-    return toString(str).padEnd(length, chars);
-}
-
-function repeat(str, n) {
-    return str.repeat(n);
+function upperCase(str) {
+    return upperFirst.upperCase(normalizeForCase(str));
 }
 
 function trim(str, chars, guard) {
@@ -1586,224 +1988,94 @@ function trim(str, chars, guard) {
     }
     switch (typeof chars) {
         case 'string': {
-            return pad$1.trim(str, chars.toString().split(''));
+            return upperFirst.trim(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return pad$1.trim(str, chars.map(x => x.toString()));
+                return upperFirst.trim(str, chars.map(x => x.toString()));
             }
             else {
-                return pad$1.trim(str, chars.toString().split(''));
+                return upperFirst.trim(str, chars.toString().split(''));
             }
         }
     }
 }
 
-function trimStart(str, chars, guard) {
+function trimEnd(str, chars, guard) {
     if (str == null) {
         return '';
     }
     if (guard != null || chars == null) {
-        return str.toString().trimStart();
+        return str.toString().trimEnd();
     }
     switch (typeof chars) {
         case 'string': {
-            return pad$1.trimStart(str, chars.toString().split(''));
+            return upperFirst.trimEnd(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return pad$1.trimStart(str, chars.map(x => x.toString()));
+                return upperFirst.trimEnd(str, chars.map(x => x.toString()));
             }
             else {
-                return pad$1.trimStart(str, chars.toString().split(''));
+                return upperFirst.trimEnd(str, chars.toString().split(''));
             }
         }
     }
 }
 
-function trimEnd(str, chars, guard) {
+function trimStart(str, chars, guard) {
     if (str == null) {
         return '';
     }
     if (guard != null || chars == null) {
-        return str.toString().trimEnd();
+        return str.toString().trimStart();
     }
     switch (typeof chars) {
         case 'string': {
-            return pad$1.trimEnd(str, chars.toString().split(''));
+            return upperFirst.trimStart(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return pad$1.trimEnd(str, chars.map(x => x.toString()));
+                return upperFirst.trimStart(str, chars.map(x => x.toString()));
             }
             else {
-                return pad$1.trimEnd(str, chars.toString().split(''));
+                return upperFirst.trimStart(str, chars.toString().split(''));
             }
         }
     }
 }
 
-function clamp(value, bound1, bound2) {
-    if (Number.isNaN(bound1)) {
-        bound1 = 0;
-    }
-    if (Number.isNaN(bound2)) {
-        bound2 = 0;
-    }
-    return range.clamp(value, bound1, bound2);
-}
-
-function max(items = []) {
-    let maxElement = items[0];
-    let max = undefined;
-    for (let i = 0; i < items.length; i++) {
-        const element = items[i];
-        if (max == null || element > max) {
-            max = element;
-            maxElement = element;
-        }
-    }
-    return maxElement;
+function constant(value) {
+    return () => value;
 }
 
-function min(items = []) {
-    let minElement = items[0];
-    let min = undefined;
-    for (let i = 0; i < items.length; i++) {
-        const element = items[i];
-        if (min == null || element < min) {
-            min = element;
-            minElement = element;
-        }
+function defaultTo(value, defaultValue) {
+    if (value == null || Number.isNaN(value)) {
+        return defaultValue;
     }
-    return minElement;
+    return value;
 }
 
-function decimalAdjust(type, number, precision = 0) {
-    number = Number(number);
-    if (Object.is(number, -0)) {
-        number = '-0';
-    }
-    precision = Math.min(Number.parseInt(precision, 10), 292);
-    if (precision) {
-        const [magnitude, exponent = 0] = number.toString().split('e');
-        let adjustedValue = Math[type](Number(`${magnitude}e${Number(exponent) + precision}`));
-        if (Object.is(adjustedValue, -0)) {
-            adjustedValue = '-0';
-        }
-        const [newMagnitude, newExponent = 0] = adjustedValue.toString().split('e');
-        return Number(`${newMagnitude}e${Number(newExponent) - precision}`);
+function times(n, getValue) {
+    n = toInteger(n);
+    if (n < 1 || !Number.isSafeInteger(n)) {
+        return [];
     }
-    return Math[type](Number(number));
-}
-
-function ceil(number, precision = 0) {
-    return decimalAdjust('ceil', number, precision);
-}
-
-function floor(number, precision = 0) {
-    return decimalAdjust('floor', number, precision);
-}
-
-function round(number, precision = 0) {
-    return decimalAdjust('round', number, precision);
-}
-
-function parseInt(string, radix = 0, guard) {
-    if (guard) {
-        radix = 0;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+        result[i] = typeof getValue === 'function' ? getValue(i) : i;
     }
-    return Number.parseInt(string, radix);
+    return result;
 }
 
-function inRange(value, minimum, maximum) {
-    if (!minimum) {
-        minimum = 0;
-    }
-    if (maximum != null && !maximum) {
-        maximum = 0;
-    }
-    if (minimum != null && typeof minimum !== 'number') {
-        minimum = Number(minimum);
-    }
-    if (maximum == null && minimum === 0) {
-        return false;
-    }
-    if (maximum != null && typeof maximum !== 'number') {
-        maximum = Number(maximum);
-    }
-    if (maximum != null && minimum > maximum) {
-        [minimum, maximum] = [maximum, minimum];
-    }
-    if (minimum === maximum) {
-        return false;
-    }
-    return range.inRange(value, minimum, maximum);
-}
+const MAX_ARRAY_LENGTH = 4_294_967_295;
 
-function random(...args) {
-    let minimum = 0;
-    let maximum = 1;
-    let floating = false;
-    switch (args.length) {
-        case 1: {
-            if (typeof args[0] === 'boolean') {
-                floating = args[0];
-            }
-            else {
-                maximum = args[0];
-            }
-            break;
-        }
-        case 2: {
-            if (typeof args[1] === 'boolean') {
-                maximum = args[0];
-                floating = args[1];
-            }
-            else {
-                minimum = args[0];
-                maximum = args[1];
-            }
-        }
-        case 3: {
-            if (typeof args[2] === 'object' && args[2] != null && args[2][args[1]] === args[0]) {
-                minimum = 0;
-                maximum = args[0];
-                floating = false;
-            }
-            else {
-                minimum = args[0];
-                maximum = args[1];
-                floating = args[2];
-            }
-        }
-    }
-    if (typeof minimum !== 'number') {
-        minimum = Number(minimum);
-    }
-    if (typeof maximum !== 'number') {
-        minimum = Number(maximum);
-    }
-    if (!minimum) {
-        minimum = 0;
-    }
-    if (!maximum) {
-        maximum = 0;
-    }
-    if (minimum > maximum) {
-        [minimum, maximum] = [maximum, minimum];
-    }
-    minimum = clamp(minimum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-    maximum = clamp(maximum, -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
-    if (minimum === maximum) {
-        return minimum;
-    }
-    if (floating) {
-        return randomInt.random(minimum, maximum + 1);
-    }
-    else {
-        return randomInt.randomInt(minimum, maximum + 1);
+function toLength(value) {
+    if (value == null) {
+        return 0;
     }
+    const length = Math.floor(Number(value));
+    return clamp(length, 0, MAX_ARRAY_LENGTH);
 }
 
 exports.at = zipWith.at;
@@ -1812,7 +2084,6 @@ exports.countBy = zipWith.countBy;
 exports.differenceBy = zipWith.differenceBy;
 exports.differenceWith = zipWith.differenceWith;
 exports.dropRight = zipWith.dropRight;
-exports.dropRightWhile = zipWith.dropRightWhile;
 exports.first = zipWith.head;
 exports.flatMap = zipWith.flatMap;
 exports.flatMapDeep = zipWith.flatMapDeep;
@@ -1834,7 +2105,6 @@ exports.sample = zipWith.sample;
 exports.sampleSize = zipWith.sampleSize;
 exports.shuffle = zipWith.shuffle;
 exports.tail = zipWith.tail;
-exports.take = zipWith.take;
 exports.takeRight = zipWith.takeRight;
 exports.takeRightWhile = zipWith.takeRightWhile;
 exports.takeWhile = zipWith.takeWhile;
@@ -1859,55 +2129,52 @@ exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = flowRight$1.after;
-exports.before = flowRight$1.before;
-exports.curryRight = flowRight$1.curryRight;
-exports.memoize = flowRight$1.memoize;
-exports.negate = flowRight$1.negate;
-exports.once = flowRight$1.once;
-exports.partial = flowRight$1.partial;
-exports.partialRight = flowRight$1.partialRight;
-exports.unary = flowRight$1.unary;
+exports.after = unary.after;
+exports.memoize = unary.memoize;
+exports.negate = unary.negate;
+exports.once = unary.once;
+exports.partial = unary.partial;
+exports.partialRight = unary.partialRight;
+exports.unary = unary.unary;
 exports.noop = noop.noop;
-exports.mean = range.mean;
-exports.meanBy = range.meanBy;
-exports.range = range.range;
-exports.sum = range.sum;
-exports.sumBy = range.sumBy;
+exports.mean = sumBy.mean;
+exports.meanBy = sumBy.meanBy;
+exports.range = sumBy.range;
+exports.rangeRight = sumBy.rangeRight;
+exports.sum = sumBy.sum;
+exports.sumBy = sumBy.sumBy;
 exports.randomInt = randomInt.randomInt;
-exports.clone = isObjectLike.clone;
-exports.flattenObject = isObjectLike.flattenObject;
-exports.invert = isObjectLike.invert;
-exports.isObjectLike = isObjectLike.isObjectLike;
-exports.omitBy = isObjectLike.omitBy;
-exports.pickBy = isObjectLike.pickBy;
-exports.toMerged = isObjectLike.toMerged;
+exports.clone = toMerged.clone;
+exports.flattenObject = toMerged.flattenObject;
+exports.invert = toMerged.invert;
+exports.isObjectLike = toMerged.isObjectLike;
+exports.omitBy = toMerged.omitBy;
+exports.pickBy = toMerged.pickBy;
+exports.toMerged = toMerged.toMerged;
 exports.isPrimitive = isPlainObject$1.isPrimitive;
-exports.isArrayBuffer = isWeakSet$1.isArrayBuffer;
-exports.isDate = isWeakSet$1.isDate;
+exports.eq = isWeakSet$1.eq;
+exports.isBlob = isWeakSet$1.isBlob;
 exports.isEqual = isWeakSet$1.isEqual;
-exports.isEqualWith = isWeakSet$1.isEqualWith;
 exports.isFunction = isWeakSet$1.isFunction;
 exports.isJSONArray = isWeakSet$1.isJSONArray;
 exports.isJSONObject = isWeakSet$1.isJSONObject;
 exports.isJSONValue = isWeakSet$1.isJSONValue;
 exports.isLength = isWeakSet$1.isLength;
-exports.isMap = isWeakSet$1.isMap;
 exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
-exports.isSet = isWeakSet$1.isSet;
 exports.isUndefined = isWeakSet$1.isUndefined;
-exports.capitalize = pad$1.capitalize;
-exports.constantCase = pad$1.constantCase;
-exports.deburr = pad$1.deburr;
-exports.escape = pad$1.escape;
-exports.escapeRegExp = pad$1.escapeRegExp;
-exports.lowerFirst = pad$1.lowerFirst;
-exports.pascalCase = pad$1.pascalCase;
-exports.unescape = pad$1.unescape;
-exports.upperFirst = pad$1.upperFirst;
+exports.capitalize = upperFirst.capitalize;
+exports.constantCase = upperFirst.constantCase;
+exports.deburr = upperFirst.deburr;
+exports.escape = upperFirst.escape;
+exports.escapeRegExp = upperFirst.escapeRegExp;
+exports.lowerFirst = upperFirst.lowerFirst;
+exports.pascalCase = upperFirst.pascalCase;
+exports.unescape = upperFirst.unescape;
+exports.upperFirst = upperFirst.upperFirst;
 exports.ary = ary;
 exports.attempt = attempt;
+exports.before = before;
 exports.bind = bind;
 exports.bindKey = bindKey;
 exports.camelCase = camelCase;
@@ -1919,11 +2186,16 @@ exports.cloneDeep = cloneDeep;
 exports.concat = concat;
 exports.conforms = conforms;
 exports.conformsTo = conformsTo;
+exports.constant = constant;
 exports.curry = curry;
+exports.curryRight = curryRight;
 exports.debounce = debounce;
+exports.defaultTo = defaultTo;
+exports.defaults = defaults;
 exports.defer = defer;
 exports.difference = difference;
 exports.drop = drop;
+exports.dropRightWhile = dropRightWhile;
 exports.dropWhile = dropWhile;
 exports.endsWith = endsWith;
 exports.every = every;
@@ -1945,14 +2217,19 @@ exports.has = has;
 exports.inRange = inRange;
 exports.includes = includes;
 exports.indexOf = indexOf;
+exports.invertBy = invertBy;
 exports.isArguments = isArguments;
 exports.isArray = isArray;
+exports.isArrayBuffer = isArrayBuffer;
 exports.isArrayLike = isArrayLike;
 exports.isArrayLikeObject = isArrayLikeObject;
 exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEqualWith = isEqualWith;
 exports.isError = isError;
 exports.isFinite = isFinite;
 exports.isInteger = isInteger;
+exports.isMap = isMap;
 exports.isMatch = isMatch;
 exports.isNaN = isNaN;
 exports.isNil = isNil;
@@ -1961,6 +2238,7 @@ exports.isObject = isObject;
 exports.isPlainObject = isPlainObject;
 exports.isRegExp = isRegExp;
 exports.isSafeInteger = isSafeInteger;
+exports.isSet = isSet;
 exports.isString = isString;
 exports.isSymbol = isSymbol;
 exports.isTypedArray = isTypedArray;
@@ -1992,15 +2270,20 @@ exports.rest = rest;
 exports.round = round;
 exports.set = set;
 exports.size = size;
+exports.slice = slice;
 exports.snakeCase = snakeCase;
 exports.some = some;
 exports.sortBy = sortBy;
 exports.spread = spread;
 exports.startCase = startCase;
 exports.startsWith = startsWith;
+exports.take = take;
 exports.throttle = throttle;
+exports.times = times;
+exports.toDefaulted = toDefaulted;
 exports.toFinite = toFinite;
 exports.toInteger = toInteger;
+exports.toLength = toLength;
 exports.toNumber = toNumber;
 exports.toPath = toPath;
 exports.toString = toString;