es-toolkit 1.29.0 → 1.30.0

package/dist/compat/index.js

@@ -2,16 +2,16 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zipWith = require('../_chunk/zipWith-Bb2eZI.js');
+const zipWith = require('../_chunk/zipWith-nbzldx.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
 const unary = require('../_chunk/unary-CcTNuC.js');
 const noop = require('../_chunk/noop-2IwLUk.js');
-const rangeRight = require('../_chunk/rangeRight-w3WrXN.js');
+const range$1 = require('../_chunk/range-HnEIT7.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 const toMerged = require('../_chunk/toMerged-DGFrN7.js');
 const isPlainObject$1 = require('../_chunk/isPlainObject-octpoD.js');
 const isWeakSet$1 = require('../_chunk/isWeakSet-CvIdTA.js');
-const upperFirst = require('../_chunk/upperFirst-CorAVn.js');
+const upperFirst$1 = require('../_chunk/upperFirst-CorAVn.js');
 const util_index = require('../util/index.js');
 
 function castArray(value) {
@@ -390,10 +390,10 @@ function cloneDeep(obj) {
 }
 
 const IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
-function isIndex(value) {
+function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
     switch (typeof value) {
         case 'number': {
-            return Number.isInteger(value) && value >= 0 && value < Number.MAX_SAFE_INTEGER;
+            return Number.isInteger(value) && value >= 0 && value < length;
         }
         case 'symbol': {
             return false;
@@ -496,6 +496,18 @@ function differenceBy(arr, ..._values) {
     return zipWith.differenceBy(Array.from(arr), values, iteratee(iteratee$1));
 }
 
+function differenceWith(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    const comparator = last(values);
+    const flattenedValues = flattenArrayLike(values);
+    if (typeof comparator === 'function') {
+        return zipWith.differenceWith(Array.from(array), flattenedValues, comparator);
+    }
+    return zipWith.difference(Array.from(array), flattenedValues);
+}
+
 function isSymbol(value) {
     return typeof value === 'symbol' || value instanceof Symbol;
 }
@@ -863,7 +875,7 @@ function forEach(collection, callback = unary.identity) {
     if (!collection) {
         return collection;
     }
-    const keys = isArrayLike(collection) || Array.isArray(collection) ? rangeRight.range(0, collection.length) : Object.keys(collection);
+    const keys = isArrayLike(collection) || Array.isArray(collection) ? range$1.range(0, collection.length) : Object.keys(collection);
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
         const value = collection[key];
@@ -1008,6 +1020,32 @@ function lastIndexOf(array, searchElement, fromIndex) {
     return Array.from(array).lastIndexOf(searchElement, index);
 }
 
+function map(collection, _iteratee) {
+    if (!collection) {
+        return [];
+    }
+    const keys = isArrayLike(collection) || Array.isArray(collection) ? range$1.range(0, collection.length) : Object.keys(collection);
+    const iteratee$1 = iteratee(_iteratee ?? unary.identity);
+    const result = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = collection[key];
+        result[i] = iteratee$1(value, key, collection);
+    }
+    return result;
+}
+
+function nth(array, n = 0) {
+    if (!isArrayLikeObject(array) || array.length === 0) {
+        return undefined;
+    }
+    n = toInteger(n);
+    if (n < 0) {
+        n += array.length;
+    }
+    return array[n];
+}
+
 function getPriority(a) {
     if (typeof a === 'symbol') {
         return 1;
@@ -1129,6 +1167,10 @@ function orderBy(collection, criteria, orders, guard) {
         .map(item => item.original);
 }
 
+function pull(arr, ...valuesToRemove) {
+    return zipWith.pull(arr, flatten(valuesToRemove));
+}
+
 function sample(collection) {
     if (collection == null) {
         return undefined;
@@ -1261,6 +1303,15 @@ function takeRight(arr, count = 1, guard) {
     return zipWith.takeRight(toArray$1(arr), count);
 }
 
+function takeRightWhile(_array, predicate) {
+    if (!isArrayLikeObject(_array)) {
+        return [];
+    }
+    const array = toArray$1(_array);
+    const index = array.findLastIndex(unary.negate(iteratee(predicate)));
+    return array.slice(index + 1);
+}
+
 function union(...arrays) {
     const validArrays = arrays.filter(isArrayLikeObject);
     const flattened = flatten(validArrays, 1);
@@ -1339,6 +1390,18 @@ function zipObjectDeep(keys, values) {
     return result;
 }
 
+function after(n, func) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    n = toInteger(n);
+    return function (...args) {
+        if (--n < 1) {
+            return func.apply(this, args);
+        }
+    };
+}
+
 function ary(func, n = func.length, guard) {
     if (guard) {
         n = func.length;
@@ -1598,6 +1661,13 @@ function defer(func, ...args) {
     return setTimeout(func, 1, ...args);
 }
 
+function delay(func, wait, ...args) {
+    if (typeof func !== 'function') {
+        throw new TypeError('Expected a function');
+    }
+    return setTimeout(func, toNumber(wait) || 0, ...args);
+}
+
 function flip(func) {
     return function (...args) {
         return func.apply(this, args.reverse());
@@ -1620,6 +1690,12 @@ function flowRight(...funcs) {
     return unary.flowRight(...flattenFuncs);
 }
 
+function nthArg(n = 0) {
+    return function (...args) {
+        return args.at(toInteger(n));
+    };
+}
+
 function rearg(func, ...indices) {
     const flattenIndices = flatten(indices);
     return function (...args) {
@@ -1700,7 +1776,7 @@ function clamp(value, bound1, bound2) {
     if (Number.isNaN(bound2)) {
         bound2 = 0;
     }
-    return rangeRight.clamp(value, bound1, bound2);
+    return range$1.clamp(value, bound1, bound2);
 }
 
 function floor(number, precision = 0) {
@@ -1729,7 +1805,7 @@ function inRange(value, minimum, maximum) {
     if (minimum === maximum) {
         return false;
     }
-    return rangeRight.inRange(value, minimum, maximum);
+    return range$1.inRange(value, minimum, maximum);
 }
 
 function max(items = []) {
@@ -1830,6 +1906,50 @@ function random(...args) {
     }
 }
 
+function range(start, end, step) {
+    if (step && typeof step !== 'number' && isIterateeCall(start, end, step)) {
+        end = step = undefined;
+    }
+    start = toFinite(start);
+    if (end === undefined) {
+        end = start;
+        start = 0;
+    }
+    else {
+        end = toFinite(end);
+    }
+    step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
+    const length = Math.max(Math.ceil((end - start) / (step || 1)), 0);
+    const result = new Array(length);
+    for (let index = 0; index < length; index++) {
+        result[index] = start;
+        start += step;
+    }
+    return result;
+}
+
+function rangeRight(start, end, step) {
+    if (step && typeof step !== 'number' && isIterateeCall(start, end, step)) {
+        end = step = undefined;
+    }
+    start = toFinite(start);
+    if (end === undefined) {
+        end = start;
+        start = 0;
+    }
+    else {
+        end = toFinite(end);
+    }
+    step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
+    const length = Math.max(Math.ceil((end - start) / (step || 1)), 0);
+    const result = new Array(length);
+    for (let index = length - 1; index >= 0; index--) {
+        result[index] = start;
+        start += step;
+    }
+    return result;
+}
+
 function round(number, precision = 0) {
     return decimalAdjust('round', number, precision);
 }
@@ -1856,7 +1976,7 @@ function sum(array) {
 }
 
 function isPrototype(value) {
-    const constructor = value.constructor;
+    const constructor = value?.constructor;
     const prototype = typeof constructor === 'function' ? constructor.prototype : Object.prototype;
     return value === prototype;
 }
@@ -1957,6 +2077,29 @@ function defaults(object, ...sources) {
     return object;
 }
 
+function findKey(obj, predicate) {
+    if (!isObject(obj)) {
+        return undefined;
+    }
+    return findKeyImpl(obj, predicate);
+}
+function findKeyImpl(obj, predicate) {
+    if (typeof predicate === 'function') {
+        return toMerged.findKey(obj, predicate);
+    }
+    if (typeof predicate === 'object') {
+        if (Array.isArray(predicate)) {
+            const key = predicate[0];
+            const value = predicate[1];
+            return toMerged.findKey(obj, matchesProperty(key, value));
+        }
+        return toMerged.findKey(obj, matches(predicate));
+    }
+    if (typeof predicate === 'string') {
+        return toMerged.findKey(obj, property(predicate));
+    }
+}
+
 function fromPairs(pairs) {
     if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
         return {};
@@ -1991,6 +2134,31 @@ function invertBy(object, iteratee) {
     return result;
 }
 
+function keys(object) {
+    if (isArrayLike(object)) {
+        return arrayLikeKeys(object);
+    }
+    const result = Object.keys(Object(object));
+    if (!isPrototype(object)) {
+        return result;
+    }
+    return result.filter(key => key !== 'constructor');
+}
+function arrayLikeKeys(object) {
+    const indices = times(object.length, index => `${index}`);
+    const filteredKeys = new Set(indices);
+    if (isWeakSet$1.isBuffer(object)) {
+        filteredKeys.add('offset');
+        filteredKeys.add('parent');
+    }
+    if (isTypedArray(object)) {
+        filteredKeys.add('buffer');
+        filteredKeys.add('byteLength');
+        filteredKeys.add('byteOffset');
+    }
+    return [...indices, ...Object.keys(object).filter(key => !filteredKeys.has(key))];
+}
+
 function mapKeys(object, getNewKey) {
     getNewKey = getNewKey ?? unary.identity;
     switch (typeof getNewKey) {
@@ -2260,6 +2428,12 @@ function pick(obj, ...keysArr) {
     return result;
 }
 
+function propertyOf(object) {
+    return function (path) {
+        return get(object, path);
+    };
+}
+
 function toDefaulted(object, ...sources) {
     const cloned = cloneDeep(object);
     return defaults(cloned, ...sources);
@@ -2418,7 +2592,11 @@ function normalizeForCase(str) {
 }
 
 function camelCase(str) {
-    return upperFirst.camelCase(normalizeForCase(str));
+    return upperFirst$1.camelCase(normalizeForCase(str));
+}
+
+function deburr(str) {
+    return upperFirst$1.deburr(toString(str));
 }
 
 function endsWith(str, target, position = str.length) {
@@ -2426,19 +2604,27 @@ function endsWith(str, target, position = str.length) {
 }
 
 function escape(string) {
-    return upperFirst.escape(toString(string));
+    return upperFirst$1.escape(toString(string));
+}
+
+function escapeRegExp(str) {
+    return upperFirst$1.escapeRegExp(toString(str));
 }
 
 function kebabCase(str) {
-    return upperFirst.kebabCase(normalizeForCase(str));
+    return upperFirst$1.kebabCase(normalizeForCase(str));
 }
 
 function lowerCase(str) {
-    return upperFirst.lowerCase(normalizeForCase(str));
+    return upperFirst$1.lowerCase(normalizeForCase(str));
+}
+
+function lowerFirst(str) {
+    return upperFirst$1.lowerFirst(toString(str));
 }
 
 function pad(str, length, chars = ' ') {
-    return upperFirst.pad(toString(str), length, chars);
+    return upperFirst$1.pad(toString(str), length, chars);
 }
 
 function padEnd(str, length = 0, chars = ' ') {
@@ -2461,11 +2647,11 @@ function replace(target = '', pattern, replacement) {
 }
 
 function snakeCase(str) {
-    return upperFirst.snakeCase(normalizeForCase(str));
+    return upperFirst$1.snakeCase(normalizeForCase(str));
 }
 
 function startCase(str) {
-    const words = upperFirst.words(normalizeForCase(str).trim());
+    const words = upperFirst$1.words(normalizeForCase(str).trim());
     let result = '';
     for (let i = 0; i < words.length; i++) {
         const word = words[i];
@@ -2566,6 +2752,10 @@ function template(string, options, guard) {
     return result;
 }
 
+function toLower(value) {
+    return toString(value).toLowerCase();
+}
+
 function toUpper(value) {
     return toString(value).toUpperCase();
 }
@@ -2579,14 +2769,14 @@ function trim(str, chars, guard) {
     }
     switch (typeof chars) {
         case 'string': {
-            return upperFirst.trim(str, chars.toString().split(''));
+            return upperFirst$1.trim(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return upperFirst.trim(str, chars.flatMap(x => x.toString().split('')));
+                return upperFirst$1.trim(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
-                return upperFirst.trim(str, chars.toString().split(''));
+                return upperFirst$1.trim(str, chars.toString().split(''));
             }
         }
     }
@@ -2601,14 +2791,14 @@ function trimEnd(str, chars, guard) {
     }
     switch (typeof chars) {
         case 'string': {
-            return upperFirst.trimEnd(str, chars.toString().split(''));
+            return upperFirst$1.trimEnd(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return upperFirst.trimEnd(str, chars.flatMap(x => x.toString().split('')));
+                return upperFirst$1.trimEnd(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
-                return upperFirst.trimEnd(str, chars.toString().split(''));
+                return upperFirst$1.trimEnd(str, chars.toString().split(''));
             }
         }
     }
@@ -2623,24 +2813,32 @@ function trimStart(str, chars, guard) {
     }
     switch (typeof chars) {
         case 'string': {
-            return upperFirst.trimStart(str, chars.toString().split(''));
+            return upperFirst$1.trimStart(str, chars.toString().split(''));
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return upperFirst.trimStart(str, chars.flatMap(x => x.toString().split('')));
+                return upperFirst$1.trimStart(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
-                return upperFirst.trimStart(str, chars.toString().split(''));
+                return upperFirst$1.trimStart(str, chars.toString().split(''));
             }
         }
     }
 }
 
+function unescape(str) {
+    return upperFirst$1.unescape(toString(str));
+}
+
 function upperCase(str) {
-    return upperFirst.upperCase(normalizeForCase(str));
+    return upperFirst$1.upperCase(normalizeForCase(str));
+}
+
+function upperFirst(str) {
+    return upperFirst$1.upperFirst(toString(str));
 }
 
-function words(str, pattern = upperFirst.CASE_SPLIT_PATTERN) {
+function words(str, pattern = upperFirst$1.CASE_SPLIT_PATTERN) {
     const input = toString(str);
     const words = Array.from(input.match(pattern) ?? []);
     return words.filter(x => x !== '');
@@ -2671,6 +2869,92 @@ function gte(value, other) {
     return toNumber(value) >= toNumber(other);
 }
 
+function invoke(object, path, args = []) {
+    if (object == null) {
+        return;
+    }
+    switch (typeof path) {
+        case 'string': {
+            if (typeof object === 'object' && Object.hasOwn(object, path)) {
+                return invokeImpl(object, [path], args);
+            }
+            return invokeImpl(object, toPath(path), args);
+        }
+        case 'number':
+        case 'symbol': {
+            return invokeImpl(object, [path], args);
+        }
+        default: {
+            if (Array.isArray(path)) {
+                return invokeImpl(object, path, args);
+            }
+            else {
+                return invokeImpl(object, [path], args);
+            }
+        }
+    }
+}
+function invokeImpl(object, path, args) {
+    const parent = get(object, path.slice(0, -1), object);
+    if (parent == null) {
+        return undefined;
+    }
+    let lastKey = last(path);
+    let lastValue = lastKey?.valueOf();
+    if (typeof lastValue === 'number') {
+        lastKey = toKey(lastValue);
+    }
+    else {
+        lastKey = String(lastKey);
+    }
+    const func = get(parent, lastKey);
+    return func?.apply(parent, args);
+}
+
+function lt(value, other) {
+    if (typeof value === 'string' && typeof other === 'string') {
+        return value < other;
+    }
+    return toNumber(value) < toNumber(other);
+}
+
+function lte(value, other) {
+    if (typeof value === 'string' && typeof other === 'string') {
+        return value <= other;
+    }
+    return toNumber(value) <= toNumber(other);
+}
+
+function method(path, ...args) {
+    return function (object) {
+        return invoke(object, path, args);
+    };
+}
+
+function now() {
+    return Date.now();
+}
+
+function stubArray() {
+    return [];
+}
+
+function stubFalse() {
+    return false;
+}
+
+function stubObject() {
+    return {};
+}
+
+function stubString() {
+    return '';
+}
+
+function stubTrue() {
+    return true;
+}
+
 function toArray(value) {
     if (value == null) {
         return [];
@@ -2678,9 +2962,6 @@ function toArray(value) {
     if (isArrayLike(value) || isMap(value)) {
         return Array.from(value);
     }
-    if (typeof value === 'string') {
-        return value.split('');
-    }
     if (typeof value === 'object') {
         return Object.values(value);
     }
@@ -2697,6 +2978,27 @@ function toLength(value) {
     return clamp(length, 0, MAX_ARRAY_LENGTH);
 }
 
+function toPlainObject(value) {
+    const plainObject = {};
+    const valueKeys = keysIn(value);
+    for (let i = 0; i < valueKeys.length; i++) {
+        const key = valueKeys[i];
+        const objValue = value[key];
+        if (key === '__proto__') {
+            Object.defineProperty(plainObject, key, {
+                configurable: true,
+                enumerable: true,
+                value: objValue,
+                writable: true,
+            });
+        }
+        else {
+            plainObject[key] = objValue;
+        }
+    }
+    return plainObject;
+}
+
 const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 
 function toSafeInteger(value) {
@@ -2706,15 +3008,8 @@ function toSafeInteger(value) {
     return clamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
 }
 
-let idCounter = 0;
-function uniqueId(prefix = '') {
-    const id = ++idCounter;
-    return `${prefix}${id}`;
-}
-
 exports.at = zipWith.at;
 exports.countBy = zipWith.countBy;
-exports.differenceWith = zipWith.differenceWith;
 exports.flatMap = zipWith.flatMap;
 exports.flatMapDeep = zipWith.flatMapDeep;
 exports.forEachRight = zipWith.forEachRight;
@@ -2730,7 +3025,6 @@ exports.partition = zipWith.partition;
 exports.pullAt = zipWith.pullAt;
 exports.sampleSize = zipWith.sampleSize;
 exports.shuffle = zipWith.shuffle;
-exports.takeRightWhile = zipWith.takeRightWhile;
 exports.takeWhile = zipWith.takeWhile;
 exports.toFilled = zipWith.toFilled;
 exports.unionBy = zipWith.unionBy;
@@ -2744,10 +3038,8 @@ exports.zipObject = zipWith.zipObject;
 exports.zipWith = zipWith.zipWith;
 exports.AbortError = promise_index.AbortError;
 exports.TimeoutError = promise_index.TimeoutError;
-exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = unary.after;
 exports.identity = unary.identity;
 exports.memoize = unary.memoize;
 exports.negate = unary.negate;
@@ -2756,15 +3048,12 @@ exports.partial = unary.partial;
 exports.partialRight = unary.partialRight;
 exports.unary = unary.unary;
 exports.noop = noop.noop;
-exports.mean = rangeRight.mean;
-exports.meanBy = rangeRight.meanBy;
-exports.median = rangeRight.median;
-exports.medianBy = rangeRight.medianBy;
-exports.range = rangeRight.range;
-exports.rangeRight = rangeRight.rangeRight;
+exports.mean = range$1.mean;
+exports.meanBy = range$1.meanBy;
+exports.median = range$1.median;
+exports.medianBy = range$1.medianBy;
 exports.randomInt = randomInt.randomInt;
 exports.clone = toMerged.clone;
-exports.findKey = toMerged.findKey;
 exports.flattenObject = toMerged.flattenObject;
 exports.invert = toMerged.invert;
 exports.isObjectLike = toMerged.isObjectLike;
@@ -2785,16 +3074,12 @@ exports.isLength = isWeakSet$1.isLength;
 exports.isNotNil = isWeakSet$1.isNotNil;
 exports.isNull = isWeakSet$1.isNull;
 exports.isUndefined = isWeakSet$1.isUndefined;
-exports.capitalize = upperFirst.capitalize;
-exports.constantCase = upperFirst.constantCase;
-exports.deburr = upperFirst.deburr;
-exports.escapeRegExp = upperFirst.escapeRegExp;
-exports.lowerFirst = upperFirst.lowerFirst;
-exports.pascalCase = upperFirst.pascalCase;
-exports.unescape = upperFirst.unescape;
-exports.upperFirst = upperFirst.upperFirst;
+exports.capitalize = upperFirst$1.capitalize;
+exports.constantCase = upperFirst$1.constantCase;
+exports.pascalCase = upperFirst$1.pascalCase;
 exports.invariant = util_index.invariant;
 exports.add = add;
+exports.after = after;
 exports.ary = ary;
 exports.assignIn = assignIn;
 exports.attempt = attempt;
@@ -2816,11 +3101,14 @@ exports.constant = constant;
 exports.curry = curry;
 exports.curryRight = curryRight;
 exports.debounce = debounce;
+exports.deburr = deburr;
 exports.defaultTo = defaultTo;
 exports.defaults = defaults;
 exports.defer = defer;
+exports.delay = delay;
 exports.difference = difference;
 exports.differenceBy = differenceBy;
+exports.differenceWith = differenceWith;
 exports.drop = drop;
 exports.dropRight = dropRight;
 exports.dropRightWhile = dropRightWhile;
@@ -2828,12 +3116,14 @@ exports.dropWhile = dropWhile;
 exports.each = forEach;
 exports.endsWith = endsWith;
 exports.escape = escape;
+exports.escapeRegExp = escapeRegExp;
 exports.every = every;
 exports.extend = assignIn;
 exports.fill = fill;
 exports.filter = filter;
 exports.find = find;
 exports.findIndex = findIndex;
+exports.findKey = findKey;
 exports.findLastIndex = findLastIndex;
 exports.first = head;
 exports.flatten = flatten;
@@ -2856,6 +3146,7 @@ exports.indexOf = indexOf;
 exports.intersection = intersection;
 exports.intersectionBy = intersectionBy;
 exports.invertBy = invertBy;
+exports.invoke = invoke;
 exports.isArguments = isArguments;
 exports.isArray = isArray;
 exports.isArrayBuffer = isArrayBuffer;
@@ -2887,10 +3178,15 @@ exports.isWeakSet = isWeakSet;
 exports.iteratee = iteratee;
 exports.join = join;
 exports.kebabCase = kebabCase;
+exports.keys = keys;
 exports.keysIn = keysIn;
 exports.last = last;
 exports.lastIndexOf = lastIndexOf;
 exports.lowerCase = lowerCase;
+exports.lowerFirst = lowerFirst;
+exports.lt = lt;
+exports.lte = lte;
+exports.map = map;
 exports.mapKeys = mapKeys;
 exports.mapValues = mapValues;
 exports.matches = matches;
@@ -2898,7 +3194,11 @@ exports.matchesProperty = matchesProperty;
 exports.max = max;
 exports.merge = merge;
 exports.mergeWith = mergeWith;
+exports.method = method;
 exports.min = min;
+exports.now = now;
+exports.nth = nth;
+exports.nthArg = nthArg;
 exports.omit = omit;
 exports.orderBy = orderBy;
 exports.pad = pad;
@@ -2907,7 +3207,11 @@ exports.padStart = padStart;
 exports.parseInt = parseInt;
 exports.pick = pick;
 exports.property = property;
+exports.propertyOf = propertyOf;
+exports.pull = pull;
 exports.random = random;
+exports.range = range;
+exports.rangeRight = rangeRight;
 exports.rearg = rearg;
 exports.repeat = repeat;
 exports.replace = replace;
@@ -2923,11 +3227,17 @@ exports.sortBy = sortBy;
 exports.spread = spread;
 exports.startCase = startCase;
 exports.startsWith = startsWith;
+exports.stubArray = stubArray;
+exports.stubFalse = stubFalse;
+exports.stubObject = stubObject;
+exports.stubString = stubString;
+exports.stubTrue = stubTrue;
 exports.sum = sum;
 exports.sumBy = sumBy;
 exports.tail = tail;
 exports.take = take;
 exports.takeRight = takeRight;
+exports.takeRightWhile = takeRightWhile;
 exports.template = template;
 exports.templateSettings = templateSettings;
 exports.throttle = throttle;
@@ -2937,21 +3247,24 @@ exports.toDefaulted = toDefaulted;
 exports.toFinite = toFinite;
 exports.toInteger = toInteger;
 exports.toLength = toLength;
+exports.toLower = toLower;
 exports.toNumber = toNumber;
 exports.toPath = toPath;
+exports.toPlainObject = toPlainObject;
 exports.toSafeInteger = toSafeInteger;
 exports.toString = toString;
 exports.toUpper = toUpper;
 exports.trim = trim;
 exports.trimEnd = trimEnd;
 exports.trimStart = trimStart;
+exports.unescape = unescape;
 exports.union = union;
 exports.uniq = uniq;
 exports.uniqBy = uniqBy;
-exports.uniqueId = uniqueId;
 exports.unset = unset;
 exports.unzip = unzip;
 exports.upperCase = upperCase;
+exports.upperFirst = upperFirst;
 exports.without = without;
 exports.words = words;
 exports.zip = zip;