es-toolkit 1.17.0 → 1.18.0-dev.571

package/dist/compat/index.js

@@ -2,32 +2,39 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const initial = require('../_chunk/initial-Ci2bn_.js');
-const promise_index = require('../_chunk/index-CoqN5B.js');
-const function_index = require('../function/index.js');
+const zipWith = require('../_chunk/zipWith-CYaH1Y.js');
+const promise_index = require('../_chunk/index-BGZDR9.js');
+const rest$1 = require('../_chunk/rest-CXt9w3.js');
 const math_index = require('../math/index.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
-const toMerged = require('../_chunk/toMerged-BGwYW5.js');
-const isFunction = require('../_chunk/isFunction-aCEz9d.js');
-const isTypedArray$1 = require('../_chunk/isTypedArray-BBEkFl.js');
+const toMerged = require('../_chunk/toMerged-DN1PPP.js');
+const isWeakSet$1 = require('../_chunk/isWeakSet-CogETi.js');
+const isTypedArray$1 = require('../_chunk/isTypedArray-Dsrnb1.js');
 const string_index = require('../string/index.js');
 
+function castArray(value) {
+    if (arguments.length === 0) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+
 function chunk(arr, size = 1) {
     size = Math.max(Math.floor(size), 0);
     if (size === 0) {
         return [];
     }
-    return initial.chunk(arr, size);
+    return zipWith.chunk(arr, size);
 }
 
 function concat(...values) {
-    return initial.flatten(values);
+    return zipWith.flatten(values);
 }
 
 function difference(arr, ...values) {
     const arr1 = arr;
-    const arr2 = initial.flatten(values);
-    return initial.difference(arr1, arr2);
+    const arr2 = zipWith.flatten(values);
+    return zipWith.difference(arr1, arr2);
 }
 
 function fill(array, value, start = 0, end = array.length) {
@@ -39,7 +46,7 @@ function fill(array, value, start = 0, end = array.length) {
     if (!end) {
         end = 0;
     }
-    return initial.fill(array, value, start, end);
+    return zipWith.fill(array, value, start, end);
 }
 
 const IS_PLAIN = /^\w*$/;
@@ -250,14 +257,14 @@ function cloneDeep(obj) {
         return toMerged.cloneDeep(obj);
     }
     switch (Object.prototype.toString.call(obj)) {
-        case isFunction.numberTag:
-        case isFunction.stringTag:
-        case isFunction.booleanTag: {
+        case isWeakSet$1.numberTag:
+        case isWeakSet$1.stringTag:
+        case isWeakSet$1.booleanTag: {
             const result = new obj.constructor(obj?.valueOf());
             toMerged.copyProperties(result, obj);
             return result;
         }
-        case isFunction.argumentsTag: {
+        case isWeakSet$1.argumentsTag: {
             const result = {};
             toMerged.copyProperties(result, obj);
             result.length = obj.length;
@@ -286,7 +293,7 @@ function isIndex(value) {
 }
 
 function isArguments(value) {
-    return value !== null && typeof value === 'object' && isFunction.getTag(value) === '[object Arguments]';
+    return value !== null && typeof value === 'object' && isWeakSet$1.getTag(value) === '[object Arguments]';
 }
 
 function has(object, path) {
@@ -390,6 +397,34 @@ function findIndex(source, doesMatch) {
     }
 }
 
+function findLastIndex(source, doesMatch, fromIndex = source.length - 1) {
+    if (fromIndex < 0) {
+        fromIndex = Math.max(source.length + fromIndex, 0);
+    }
+    else {
+        fromIndex = Math.min(fromIndex, source.length - 1);
+    }
+    source = source.slice(0, fromIndex + 1);
+    switch (typeof doesMatch) {
+        case 'function': {
+            return source.findLastIndex(doesMatch);
+        }
+        case 'object': {
+            if (Array.isArray(doesMatch) && doesMatch.length === 2) {
+                const key = doesMatch[0];
+                const value = doesMatch[1];
+                return source.findLastIndex(matchesProperty(key, value));
+            }
+            else {
+                return source.findLastIndex(matches(doesMatch));
+            }
+        }
+        case 'string': {
+            return source.findLastIndex(property(doesMatch));
+        }
+    }
+}
+
 function flatten(value, depth = 1) {
     const result = [];
     const flooredDepth = Math.floor(depth);
@@ -426,12 +461,60 @@ function flattenDepth(value, depth = 1) {
     return flatten(value, depth);
 }
 
-const compareValues = (a, b, order) => {
-    if ((a != null && b == null) || a < b) {
-        return order === 'desc' ? 1 : -1;
+function indexOf(array, searchElement, fromIndex) {
+    if (array == null) {
+        return -1;
+    }
+    if (Number.isNaN(searchElement)) {
+        fromIndex = fromIndex ?? 0;
+        if (fromIndex < 0) {
+            fromIndex = Math.max(0, array.length + fromIndex);
+        }
+        for (let i = fromIndex; i < array.length; i++) {
+            if (Number.isNaN(array[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    return array.indexOf(searchElement, fromIndex);
+}
+
+function join(array, separator = ',') {
+    return array.join(separator);
+}
+
+function getPriority(a) {
+    if (typeof a === 'symbol') {
+        return 1;
+    }
+    if (a === null) {
+        return 2;
+    }
+    if (a === undefined) {
+        return 3;
     }
-    if ((a == null && b != null) || a > b) {
-        return order === 'desc' ? -1 : 1;
+    if (a !== a) {
+        return 4;
+    }
+    return 0;
+}
+const compareValues = (a, b, order) => {
+    if (a !== b) {
+        if (typeof a === 'string' && typeof b === 'string') {
+            return order === 'desc' ? b.localeCompare(a) : a.localeCompare(b);
+        }
+        const aPriority = getPriority(a);
+        const bPriority = getPriority(b);
+        if (aPriority === bPriority && aPriority === 0) {
+            if (a < b) {
+                return order === 'desc' ? 1 : -1;
+            }
+            if (a > b) {
+                return order === 'desc' ? -1 : 1;
+            }
+        }
+        return order === 'desc' ? bPriority - aPriority : aPriority - bPriority;
     }
     return 0;
 };
@@ -450,68 +533,80 @@ function isKey(value, object) {
 }
 
 function orderBy(collection, criteria, orders) {
-    if (collection == null) {
+    if (collection == null || typeof collection === 'number') {
         return [];
     }
-    if (!Array.isArray(collection) && typeof collection === 'object') {
+    if (typeof collection === 'object' && !Array.isArray(collection)) {
         collection = Object.values(collection);
     }
     if (!Array.isArray(criteria)) {
-        criteria = criteria == null ? [] : [criteria];
+        criteria = criteria == null ? [null] : [criteria];
     }
     if (!Array.isArray(orders)) {
         orders = orders == null ? [] : [orders];
     }
+    orders = orders.map(order => String(order));
     const getValueByNestedPath = (object, path) => {
         let target = object;
-        for (let i = 0; i < path.length && target != null; i++) {
+        for (let i = 0; i < path.length && target != null; ++i) {
             target = target[path[i]];
         }
         return target;
     };
     const getValueByCriterion = (criterion, object) => {
-        if (object == null) {
+        if (object == null || criterion == null) {
             return object;
         }
+        if (typeof criterion === 'object' && 'key' in criterion) {
+            if (Object.hasOwn(object, criterion.key)) {
+                return object[criterion.key];
+            }
+            return getValueByNestedPath(object, criterion.path);
+        }
         if (typeof criterion === 'function') {
             return criterion(object);
         }
         if (Array.isArray(criterion)) {
             return getValueByNestedPath(object, criterion);
         }
-        if (typeof criterion !== 'object') {
+        if (typeof object === 'object') {
             return object[criterion];
         }
-        if (Object.hasOwn(object, criterion.key)) {
-            return object[criterion.key];
-        }
-        return getValueByNestedPath(object, criterion.path);
+        return object;
     };
     const preparedCriteria = criteria.map(criterion => {
         if (Array.isArray(criterion) && criterion.length === 1) {
             criterion = criterion[0];
         }
-        if (typeof criterion === 'function' || Array.isArray(criterion) || isKey(criterion)) {
+        if (criterion == null || typeof criterion === 'function' || Array.isArray(criterion) || isKey(criterion)) {
             return criterion;
         }
         return { key: criterion, path: toPath(criterion) };
     });
-    return collection.slice().sort((a, b) => {
-        for (let i = 0; i < criteria.length; i++) {
-            const order = String(orders[i]);
-            const valueA = getValueByCriterion(preparedCriteria[i], a);
-            const valueB = getValueByCriterion(preparedCriteria[i], b);
-            const comparedResult = compareValues(valueA, valueB, order);
+    const preparedCollection = collection.map(item => ({
+        original: item,
+        criteria: preparedCriteria.map(criterion => getValueByCriterion(criterion, item)),
+    }));
+    return preparedCollection
+        .slice()
+        .sort((a, b) => {
+        for (let i = 0; i < preparedCriteria.length; i++) {
+            const comparedResult = compareValues(a.criteria[i], b.criteria[i], orders[i]);
             if (comparedResult !== 0) {
                 return comparedResult;
             }
         }
         return 0;
-    });
+    })
+        .map(item => item.original);
+}
+
+function sortBy(collection, criteria) {
+    return orderBy(collection, criteria, ['asc']);
 }
 
 function size(target) {
-    if (isFunction.isNil(target)) {
+    if (isWeakSet$1.isNil(target)) {
         return 0;
     }
     if (target instanceof Map || target instanceof Set) {
@@ -520,6 +615,40 @@ function size(target) {
     return Object.keys(target).length;
 }
 
+function identity(x) {
+    return x;
+}
+
+function some(arr, predicate, guard) {
+    if (guard != null) {
+        predicate = undefined;
+    }
+    if (!predicate) {
+        predicate = identity;
+    }
+    if (!Array.isArray(arr)) {
+        return false;
+    }
+    switch (typeof predicate) {
+        case 'function': {
+            return arr.some(predicate);
+        }
+        case 'object': {
+            if (Array.isArray(predicate) && predicate.length === 2) {
+                const key = predicate[0];
+                const value = predicate[1];
+                return arr.some(matchesProperty(key, value));
+            }
+            else {
+                return arr.some(matches(predicate));
+            }
+        }
+        case 'string': {
+            return arr.some(property(predicate));
+        }
+    }
+}
+
 function set(obj, path, value) {
     const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
     let current = obj;
@@ -538,7 +667,7 @@ function set(obj, path, value) {
 
 function zipObjectDeep(keys, values) {
     const result = {};
-    const zipped = initial.zip(keys, values);
+    const zipped = zipWith.zip(keys, values);
     for (let i = 0; i < zipped.length; i++) {
         const [key, value] = zipped[i];
         if (key != null) {
@@ -548,25 +677,6 @@ function zipObjectDeep(keys, values) {
     return result;
 }
 
-function indexOf(array, searchElement, fromIndex) {
-    if (array == null) {
-        return -1;
-    }
-    if (Number.isNaN(searchElement)) {
-        fromIndex = fromIndex ?? 0;
-        if (fromIndex < 0) {
-            fromIndex = Math.max(0, array.length + fromIndex);
-        }
-        for (let i = fromIndex; i < array.length; i++) {
-            if (Number.isNaN(array[i])) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    return array.indexOf(searchElement, fromIndex);
-}
-
 function ary(func, n = func.length, guard) {
     if (guard) {
         n = func.length;
@@ -574,7 +684,7 @@ function ary(func, n = func.length, guard) {
     if (Number.isNaN(n) || n < 0) {
         n = 0;
     }
-    return function_index.ary(func, n);
+    return rest$1.ary(func, n);
 }
 
 function bind(func, thisObj, ...partialArgs) {
@@ -603,16 +713,73 @@ function bind(func, thisObj, ...partialArgs) {
 const bindPlaceholder = Symbol('bind.placeholder');
 bind.placeholder = bindPlaceholder;
 
+function bindKey(object, key, ...partialArgs) {
+    const bound = function (...providedArgs) {
+        const args = [];
+        let startIndex = 0;
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === bindKey.placeholder) {
+                args.push(providedArgs[startIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        for (let i = startIndex; i < providedArgs.length; i++) {
+            args.push(providedArgs[i]);
+        }
+        if (this instanceof bound) {
+            return new object[key](...args);
+        }
+        return object[key].apply(object, args);
+    };
+    return bound;
+}
+const bindKeyPlaceholder = Symbol('bindKey.placeholder');
+bindKey.placeholder = bindKeyPlaceholder;
+
 function rest(func, start = func.length - 1) {
     start = Number.parseInt(start, 10);
     if (Number.isNaN(start) || start < 0) {
         start = func.length - 1;
     }
-    return function_index.rest(func, start);
+    return rest$1.rest(func, start);
 }
 
-function identity(x) {
-    return x;
+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 mapKeys(object, getNewKey) {
@@ -742,48 +909,107 @@ function mergeWithDeep(target, source, merge, stack) {
 }
 
 function merge(object, ...sources) {
-    return mergeWith(object, ...sources, function_index.noop);
+    return mergeWith(object, ...sources, rest$1.noop);
+}
+
+function isArrayLike(value) {
+    return value != null && typeof value !== 'function' && isWeakSet$1.isLength(value.length);
+}
+
+function fromPairs(pairs) {
+    if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of pairs) {
+        result[key] = value;
+    }
+    return result;
 }
 
 function isArray(value) {
     return Array.isArray(value);
 }
 
-function isArrayLike(value) {
-    return value != null && typeof value !== 'function' && isFunction.isLength(value.length);
+function isObject(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
 }
 
 function isBoolean(x) {
     if (x === true || x === false) {
         return true;
     }
-    if (typeof x === 'object' && x != null && isFunction.getTag(x) === '[object Boolean]') {
+    if (typeof x === 'object' && x != null && isWeakSet$1.getTag(x) === '[object Boolean]') {
         return true;
     }
     return false;
 }
 
 function isRegExp(value) {
-    return isFunction.getTag(value) === '[object RegExp]';
+    return isWeakSet$1.getTag(value) === '[object RegExp]';
 }
 
 function isString(value) {
     if (typeof value === 'string') {
         return true;
     }
-    if (typeof value === 'object' && value != null && isFunction.getTag(value) === '[object String]') {
+    if (typeof value === 'object' && value != null && isWeakSet$1.getTag(value) === '[object String]') {
         return true;
     }
     return false;
 }
 
-const startsWith = (str, target, position = 0) => {
+function isWeakMap(value) {
+    return isWeakSet$1.isWeakMap(value);
+}
+
+function isWeakSet(value) {
+    return isWeakSet$1.isWeakSet(value);
+}
+
+function conformsTo(target, source) {
+    if (source == null) {
+        return true;
+    }
+    if (target == null) {
+        return Object.keys(source).length === 0;
+    }
+    for (const key of Object.keys(source)) {
+        const predicate = source[key];
+        const value = target[key];
+        if ((value === undefined && !(key in target)) || !predicate(value)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function conforms(source) {
+    source = toMerged.cloneDeep(source);
+    return function (object) {
+        return conformsTo(object, source);
+    };
+}
+
+function normalizeForCase(str) {
+    if (typeof str === 'object') {
+        str = str.toString();
+    }
+    str = str.replace(/['\u2019]/g, '');
+    return str;
+}
+
+function camelCase(str) {
+    return string_index.camelCase(normalizeForCase(str));
+}
+
+function startsWith(str, target, position = 0) {
     return str.startsWith(target, position);
-};
+}
 
-const endsWith = (str, target, position = str.length) => {
+function endsWith(str, target, position = str.length) {
     return str.endsWith(target, position);
-};
+}
 
 function padStart(str, length = 0, chars = ' ') {
     return str.padStart(length, chars);
@@ -793,6 +1019,10 @@ function padEnd(str, length = 0, chars = ' ') {
     return str.padEnd(length, chars);
 }
 
+function repeat(str, n) {
+    return str.repeat(n);
+}
+
 function max(items = []) {
     let maxElement = items[0];
     let max = undefined;
@@ -817,72 +1047,79 @@ function min(items = []) {
     return minElement;
 }
 
-exports.at = initial.at;
-exports.compact = initial.compact;
-exports.countBy = initial.countBy;
-exports.differenceBy = initial.differenceBy;
-exports.differenceWith = initial.differenceWith;
-exports.drop = initial.drop;
-exports.dropRight = initial.dropRight;
-exports.dropRightWhile = initial.dropRightWhile;
-exports.dropWhile = initial.dropWhile;
-exports.first = initial.head;
-exports.flatMap = initial.flatMap;
-exports.forEachRight = initial.forEachRight;
-exports.groupBy = initial.groupBy;
-exports.head = initial.head;
-exports.initial = initial.initial;
-exports.intersection = initial.intersection;
-exports.intersectionBy = initial.intersectionBy;
-exports.intersectionWith = initial.intersectionWith;
-exports.isSubset = initial.isSubset;
-exports.keyBy = initial.keyBy;
-exports.last = initial.last;
-exports.maxBy = initial.maxBy;
-exports.minBy = initial.minBy;
-exports.partition = initial.partition;
-exports.pullAt = initial.pullAt;
-exports.sample = initial.sample;
-exports.sampleSize = initial.sampleSize;
-exports.shuffle = initial.shuffle;
-exports.sortBy = initial.sortBy;
-exports.tail = initial.tail;
-exports.take = initial.take;
-exports.takeRight = initial.takeRight;
-exports.takeRightWhile = initial.takeRightWhile;
-exports.takeWhile = initial.takeWhile;
-exports.toFilled = initial.toFilled;
-exports.union = initial.union;
-exports.unionBy = initial.unionBy;
-exports.unionWith = initial.unionWith;
-exports.uniq = initial.uniq;
-exports.uniqBy = initial.uniqBy;
-exports.uniqWith = initial.uniqWith;
-exports.unzip = initial.unzip;
-exports.unzipWith = initial.unzipWith;
-exports.without = initial.without;
-exports.xor = initial.xor;
-exports.xorBy = initial.xorBy;
-exports.xorWith = initial.xorWith;
-exports.zip = initial.zip;
-exports.zipObject = initial.zipObject;
-exports.zipWith = initial.zipWith;
+function parseInt(string, radix = 0, guard) {
+    if (guard) {
+        radix = 0;
+    }
+    return Number.parseInt(string, radix);
+}
+
+exports.at = zipWith.at;
+exports.compact = zipWith.compact;
+exports.countBy = zipWith.countBy;
+exports.differenceBy = zipWith.differenceBy;
+exports.differenceWith = zipWith.differenceWith;
+exports.drop = zipWith.drop;
+exports.dropRight = zipWith.dropRight;
+exports.dropRightWhile = zipWith.dropRightWhile;
+exports.dropWhile = zipWith.dropWhile;
+exports.first = zipWith.head;
+exports.flatMap = zipWith.flatMap;
+exports.flatMapDeep = zipWith.flatMapDeep;
+exports.forEachRight = zipWith.forEachRight;
+exports.groupBy = zipWith.groupBy;
+exports.head = zipWith.head;
+exports.initial = zipWith.initial;
+exports.intersection = zipWith.intersection;
+exports.intersectionBy = zipWith.intersectionBy;
+exports.intersectionWith = zipWith.intersectionWith;
+exports.isSubset = zipWith.isSubset;
+exports.keyBy = zipWith.keyBy;
+exports.last = zipWith.last;
+exports.maxBy = zipWith.maxBy;
+exports.minBy = zipWith.minBy;
+exports.partition = zipWith.partition;
+exports.pullAt = zipWith.pullAt;
+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;
+exports.toFilled = zipWith.toFilled;
+exports.union = zipWith.union;
+exports.unionBy = zipWith.unionBy;
+exports.unionWith = zipWith.unionWith;
+exports.uniq = zipWith.uniq;
+exports.uniqBy = zipWith.uniqBy;
+exports.uniqWith = zipWith.uniqWith;
+exports.unzip = zipWith.unzip;
+exports.unzipWith = zipWith.unzipWith;
+exports.without = zipWith.without;
+exports.xor = zipWith.xor;
+exports.xorBy = zipWith.xorBy;
+exports.xorWith = zipWith.xorWith;
+exports.zip = zipWith.zip;
+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 = function_index.after;
-exports.before = function_index.before;
-exports.debounce = function_index.debounce;
-exports.memoize = function_index.memoize;
-exports.negate = function_index.negate;
-exports.noop = function_index.noop;
-exports.once = function_index.once;
-exports.partial = function_index.partial;
-exports.partialRight = function_index.partialRight;
-exports.throttle = function_index.throttle;
-exports.unary = function_index.unary;
+exports.after = rest$1.after;
+exports.before = rest$1.before;
+exports.debounce = rest$1.debounce;
+exports.memoize = rest$1.memoize;
+exports.negate = rest$1.negate;
+exports.noop = rest$1.noop;
+exports.once = rest$1.once;
+exports.partial = rest$1.partial;
+exports.partialRight = rest$1.partialRight;
+exports.throttle = rest$1.throttle;
+exports.unary = rest$1.unary;
 exports.clamp = math_index.clamp;
 exports.inRange = math_index.inRange;
 exports.mean = math_index.mean;
@@ -903,36 +1140,47 @@ exports.omitBy = toMerged.omitBy;
 exports.pick = toMerged.pick;
 exports.pickBy = toMerged.pickBy;
 exports.toMerged = toMerged.toMerged;
-exports.isEqual = isFunction.isEqual;
-exports.isFunction = isFunction.isFunction;
-exports.isLength = isFunction.isLength;
-exports.isNil = isFunction.isNil;
-exports.isNotNil = isFunction.isNotNil;
-exports.isNull = isFunction.isNull;
-exports.isUndefined = isFunction.isUndefined;
+exports.isEqual = isWeakSet$1.isEqual;
+exports.isFunction = isWeakSet$1.isFunction;
+exports.isLength = isWeakSet$1.isLength;
+exports.isNil = isWeakSet$1.isNil;
+exports.isNotNil = isWeakSet$1.isNotNil;
+exports.isNull = isWeakSet$1.isNull;
+exports.isUndefined = isWeakSet$1.isUndefined;
 exports.isPrimitive = isTypedArray$1.isPrimitive;
-exports.camelCase = string_index.camelCase;
 exports.capitalize = string_index.capitalize;
 exports.deburr = string_index.deburr;
+exports.escape = string_index.escape;
+exports.escapeRegExp = string_index.escapeRegExp;
 exports.kebabCase = string_index.kebabCase;
 exports.lowerCase = string_index.lowerCase;
 exports.lowerFirst = string_index.lowerFirst;
+exports.pad = string_index.pad;
 exports.pascalCase = string_index.pascalCase;
 exports.snakeCase = string_index.snakeCase;
 exports.startCase = string_index.startCase;
+exports.unescape = string_index.unescape;
 exports.upperFirst = string_index.upperFirst;
 exports.ary = ary;
+exports.attempt = attempt;
 exports.bind = bind;
+exports.bindKey = bindKey;
+exports.camelCase = camelCase;
+exports.castArray = castArray;
 exports.chunk = chunk;
 exports.concat = concat;
+exports.conforms = conforms;
+exports.conformsTo = conformsTo;
 exports.difference = difference;
 exports.endsWith = endsWith;
 exports.fill = fill;
 exports.find = find;
 exports.findIndex = findIndex;
+exports.findLastIndex = findLastIndex;
 exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
 exports.flattenDepth = flattenDepth;
+exports.fromPairs = fromPairs;
 exports.get = get;
 exports.has = has;
 exports.indexOf = indexOf;
@@ -941,11 +1189,15 @@ exports.isArray = isArray;
 exports.isArrayLike = isArrayLike;
 exports.isBoolean = isBoolean;
 exports.isMatch = isMatch;
+exports.isObject = isObject;
 exports.isPlainObject = isPlainObject;
 exports.isRegExp = isRegExp;
 exports.isString = isString;
 exports.isSymbol = isSymbol;
 exports.isTypedArray = isTypedArray;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;
+exports.join = join;
 exports.mapKeys = mapKeys;
 exports.mapValues = mapValues;
 exports.matches = matches;
@@ -957,9 +1209,15 @@ exports.min = min;
 exports.orderBy = orderBy;
 exports.padEnd = padEnd;
 exports.padStart = padStart;
+exports.parseInt = parseInt;
 exports.property = property;
+exports.rearg = rearg;
+exports.repeat = repeat;
 exports.rest = rest;
 exports.set = set;
 exports.size = size;
+exports.some = some;
+exports.sortBy = sortBy;
+exports.spread = spread;
 exports.startsWith = startsWith;
 exports.zipObjectDeep = zipObjectDeep;