es-toolkit 1.35.0-dev.1213 → 1.35.0-dev.1214

package/dist/_chunk/{toSnakeCaseKeys-DTk_p5.js → toSnakeCaseKeys-DZO2eB.js}

@@ -1,13 +1,13 @@
 'use strict';
 
-const zipWith = require('./zipWith-Bt0YQl.js');
+const zip$1 = require('./zip-BJSrRi.js');
 const AbortError = require('./AbortError-Cg4ZQ1.js');
 const error_index = require('../error/index.js');
 const unary = require('./unary-EIEhcF.js');
 const noop = require('./noop-2IwLUk.js');
 const range$1 = require('./range-HnEIT7.js');
 const randomInt = require('./randomInt-CF7bZK.js');
-const isPromise = require('./isPromise-BqEEYJ.js');
+const isPromise = require('./isPromise-CxqI1v.js');
 const promise_index = require('../promise/index.js');
 const reverseString = require('./reverseString-BixeGz.js');
 const invariant = require('./invariant-BfGFfr.js');
@@ -331,18 +331,18 @@ function chunk(arr, size = 1) {
     if (size === 0 || !isArrayLike(arr)) {
         return [];
     }
-    return zipWith.chunk(toArray$1(arr), size);
+    return zip$1.chunk(toArray$1(arr), size);
 }
 
 function compact(arr) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return zipWith.compact(Array.from(arr));
+    return zip$1.compact(Array.from(arr));
 }
 
 function concat(...values) {
-    return zipWith.flatten(values);
+    return zip$1.flatten(values);
 }
 
 function isArrayLikeObject(value) {
@@ -361,14 +361,14 @@ function difference(arr, ...values) {
             arr2.push(...Array.from(value));
         }
     }
-    return zipWith.difference(arr1, arr2);
+    return zip$1.difference(arr1, arr2);
 }
 
 function last(array) {
     if (!isArrayLike(array)) {
         return undefined;
     }
-    return zipWith.last(toArray$1(array));
+    return zip$1.last(toArray$1(array));
 }
 
 function flattenArrayLike(values) {
@@ -788,9 +788,9 @@ function differenceBy(arr, ..._values) {
     const iteratee$1 = last(_values);
     const values = flattenArrayLike(_values);
     if (isArrayLikeObject(iteratee$1)) {
-        return zipWith.difference(Array.from(arr), values);
+        return zip$1.difference(Array.from(arr), values);
     }
-    return zipWith.differenceBy(Array.from(arr), values, iteratee(iteratee$1));
+    return zip$1.differenceBy(Array.from(arr), values, iteratee(iteratee$1));
 }
 
 function differenceWith(array, ...values) {
@@ -800,25 +800,25 @@ function differenceWith(array, ...values) {
     const comparator = last(values);
     const flattenedValues = flattenArrayLike(values);
     if (typeof comparator === 'function') {
-        return zipWith.differenceWith(Array.from(array), flattenedValues, comparator);
+        return zip$1.differenceWith(Array.from(array), flattenedValues, comparator);
     }
-    return zipWith.difference(Array.from(array), flattenedValues);
+    return zip$1.difference(Array.from(array), flattenedValues);
 }
 
 function drop(collection, itemsCount = 1, guard) {
     if (!isArrayLike(collection)) {
         return [];
     }
-    itemsCount = guard ? 1 : zipWith.toInteger(itemsCount);
-    return zipWith.drop(toArray$1(collection), itemsCount);
+    itemsCount = guard ? 1 : zip$1.toInteger(itemsCount);
+    return zip$1.drop(toArray$1(collection), itemsCount);
 }
 
 function dropRight(collection, itemsCount = 1, guard) {
     if (!isArrayLike(collection)) {
         return [];
     }
-    itemsCount = guard ? 1 : zipWith.toInteger(itemsCount);
-    return zipWith.dropRight(toArray$1(collection), itemsCount);
+    itemsCount = guard ? 1 : zip$1.toInteger(itemsCount);
+    return zip$1.dropRight(toArray$1(collection), itemsCount);
 }
 
 function dropRightWhile(arr, predicate) {
@@ -830,22 +830,22 @@ function dropRightWhile(arr, predicate) {
 function dropRightWhileImpl(arr, predicate) {
     switch (typeof predicate) {
         case 'function': {
-            return zipWith.dropRightWhile(arr, (item, index, arr) => Boolean(predicate(item, index, arr)));
+            return zip$1.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));
+                return zip$1.dropRightWhile(arr, matchesProperty(key, value));
             }
             else {
-                return zipWith.dropRightWhile(arr, matches(predicate));
+                return zip$1.dropRightWhile(arr, matches(predicate));
             }
         }
         case 'symbol':
         case 'number':
         case 'string': {
-            return zipWith.dropRightWhile(arr, property(predicate));
+            return zip$1.dropRightWhile(arr, property(predicate));
         }
     }
 }
@@ -859,22 +859,22 @@ function dropWhile(arr, predicate) {
 function dropWhileImpl(arr, predicate) {
     switch (typeof predicate) {
         case 'function': {
-            return zipWith.dropWhile(arr, (item, index, arr) => Boolean(predicate(item, index, arr)));
+            return zip$1.dropWhile(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.dropWhile(arr, matchesProperty(key, value));
+                return zip$1.dropWhile(arr, matchesProperty(key, value));
             }
             else {
-                return zipWith.dropWhile(arr, matches(predicate));
+                return zip$1.dropWhile(arr, matches(predicate));
             }
         }
         case 'number':
         case 'symbol':
         case 'string': {
-            return zipWith.dropWhile(arr, property(predicate));
+            return zip$1.dropWhile(arr, property(predicate));
         }
     }
 }
@@ -953,7 +953,7 @@ function fill(array, value, start = 0, end = array ? array.length : 0) {
     if (!end) {
         end = 0;
     }
-    return zipWith.fill(array, value, start, end);
+    return zip$1.fill(array, value, start, end);
 }
 
 function isArray(value) {
@@ -1044,7 +1044,7 @@ function findLast(source, _doesMatch, fromIndex) {
         return undefined;
     }
     const length = Array.isArray(source) ? source.length : Object.keys(source).length;
-    fromIndex = zipWith.toInteger(fromIndex ?? length - 1);
+    fromIndex = zip$1.toInteger(fromIndex ?? length - 1);
     if (fromIndex < 0) {
         fromIndex = Math.max(length + fromIndex, 0);
     }
@@ -1129,6 +1129,29 @@ function flatten(value, depth = 1) {
     return result;
 }
 
+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 flatMap(collection, iteratee) {
+    if (isPromise.isNil(collection)) {
+        return [];
+    }
+    const mapped = isPromise.isNil(iteratee) ? map(collection) : map(collection, iteratee);
+    return flatten(mapped, 1);
+}
+
 function flattenDeep(value) {
     return flatten(value, Infinity);
 }
@@ -1175,14 +1198,14 @@ function groupBy(source, _getKeyFromItem) {
     }
     const items = isArrayLike(source) ? Array.from(source) : Object.values(source);
     const getKeyFromItem = iteratee(_getKeyFromItem ?? unary.identity);
-    return zipWith.groupBy(items, getKeyFromItem);
+    return zip$1.groupBy(items, getKeyFromItem);
 }
 
 function head(arr) {
     if (!isArrayLike(arr)) {
         return undefined;
     }
-    return zipWith.head(toArray$1(arr));
+    return zip$1.head(toArray$1(arr));
 }
 
 function includes(source, target, fromIndex, guard) {
@@ -1193,7 +1216,7 @@ function includes(source, target, fromIndex, guard) {
         fromIndex = 0;
     }
     else {
-        fromIndex = zipWith.toInteger(fromIndex);
+        fromIndex = zip$1.toInteger(fromIndex);
     }
     if (isString(source)) {
         if (fromIndex > source.length || target instanceof RegExp) {
@@ -1246,13 +1269,13 @@ function intersection(...arrays) {
     if (!isArrayLikeObject(arrays[0])) {
         return [];
     }
-    let result = zipWith.uniq(Array.from(arrays[0]));
+    let result = zip$1.uniq(Array.from(arrays[0]));
     for (let i = 1; i < arrays.length; i++) {
         const array = arrays[i];
         if (!isArrayLikeObject(array)) {
             return [];
         }
-        result = zipWith.intersection(result, Array.from(array));
+        result = zip$1.intersection(result, Array.from(array));
     }
     return result;
 }
@@ -1261,11 +1284,11 @@ function intersectionBy(array, ...values) {
     if (!isArrayLikeObject(array)) {
         return [];
     }
-    const lastValue = zipWith.last(values);
+    const lastValue = zip$1.last(values);
     if (lastValue === undefined) {
         return Array.from(array);
     }
-    let result = zipWith.uniq(Array.from(array));
+    let result = zip$1.uniq(Array.from(array));
     const count = isArrayLikeObject(lastValue) ? values.length : values.length - 1;
     for (let i = 0; i < count; ++i) {
         const value = values[i];
@@ -1273,13 +1296,13 @@ function intersectionBy(array, ...values) {
             return [];
         }
         if (isArrayLikeObject(lastValue)) {
-            result = zipWith.intersectionBy(result, Array.from(value), unary.identity);
+            result = zip$1.intersectionBy(result, Array.from(value), unary.identity);
         }
         else if (typeof lastValue === 'function') {
-            result = zipWith.intersectionBy(result, Array.from(value), value => lastValue(value));
+            result = zip$1.intersectionBy(result, Array.from(value), value => lastValue(value));
         }
         else if (typeof lastValue === 'string') {
-            result = zipWith.intersectionBy(result, Array.from(value), property(lastValue));
+            result = zip$1.intersectionBy(result, Array.from(value), property(lastValue));
         }
     }
     return result;
@@ -1289,7 +1312,7 @@ function uniq(arr) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return zipWith.uniq(Array.from(arr));
+    return zip$1.uniq(Array.from(arr));
 }
 
 function intersectionWith(firstArr, ...otherArrs) {
@@ -1310,7 +1333,7 @@ function intersectionWith(firstArr, ...otherArrs) {
         if (otherArr == null) {
             return [];
         }
-        result = zipWith.intersectionWith(result, Array.from(otherArr), comparator);
+        result = zip$1.intersectionWith(result, Array.from(otherArr), comparator);
     }
     return result;
 }
@@ -1354,26 +1377,11 @@ 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 = zipWith.toInteger(n);
+    n = zip$1.toInteger(n);
     if (n < 0) {
         n += array.length;
     }
@@ -1421,7 +1429,7 @@ function isKey(value, object) {
     if (Array.isArray(value)) {
         return false;
     }
-    if (typeof value === 'number' || typeof value === 'boolean' || value == null || zipWith.isSymbol(value)) {
+    if (typeof value === 'number' || typeof value === 'boolean' || value == null || zip$1.isSymbol(value)) {
         return true;
     }
     return ((typeof value === 'string' && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value))) ||
@@ -1501,12 +1509,32 @@ function orderBy(collection, criteria, orders, guard) {
         .map(item => item.original);
 }
 
+function partition(source, predicate) {
+    if (!source) {
+        return [[], []];
+    }
+    const collection = isArrayLike(source) ? source : Object.values(source);
+    predicate = iteratee(predicate);
+    const matched = [];
+    const unmatched = [];
+    for (let i = 0; i < collection.length; i++) {
+        const value = collection[i];
+        if (predicate(value)) {
+            matched.push(value);
+        }
+        else {
+            unmatched.push(value);
+        }
+    }
+    return [matched, unmatched];
+}
+
 function pull(arr, ...valuesToRemove) {
-    return zipWith.pull(arr, valuesToRemove);
+    return zip$1.pull(arr, valuesToRemove);
 }
 
 function pullAll(arr, valuesToRemove = []) {
-    return zipWith.pull(arr, Array.from(valuesToRemove));
+    return zip$1.pull(arr, Array.from(valuesToRemove));
 }
 
 function pullAllBy(arr, valuesToRemove, _getValue) {
@@ -1528,6 +1556,154 @@ function pullAllBy(arr, valuesToRemove, _getValue) {
     return arr;
 }
 
+function copyArray(source, array) {
+    const length = source.length;
+    if (array == null) {
+        array = Array(length);
+    }
+    for (let i = 0; i < length; i++) {
+        array[i] = source[i];
+    }
+    return array;
+}
+
+function pullAllWith(array, values, comparator) {
+    if (array?.length == null || values?.length == null) {
+        return array;
+    }
+    if (array === values) {
+        values = copyArray(values);
+    }
+    let resultLength = 0;
+    if (comparator == null) {
+        comparator = (a, b) => isPromise.eq(a, b);
+    }
+    const valuesArray = Array.isArray(values) ? values : Array.from(values);
+    const hasUndefined = valuesArray.includes(undefined);
+    for (let i = 0; i < array.length; i++) {
+        if (i in array) {
+            const shouldRemove = valuesArray.some(value => comparator(array[i], value));
+            if (!shouldRemove) {
+                array[resultLength++] = array[i];
+            }
+            continue;
+        }
+        if (!hasUndefined) {
+            delete array[resultLength++];
+        }
+    }
+    array.length = resultLength;
+    return array;
+}
+
+function at(object, ...paths) {
+    if (paths.length === 0) {
+        return [];
+    }
+    const allPaths = [];
+    for (let i = 0; i < paths.length; i++) {
+        const path = paths[i];
+        if (!isArrayLike(path) || isString(path)) {
+            allPaths.push(path);
+            continue;
+        }
+        for (let j = 0; j < path.length; j++) {
+            allPaths.push(path[j]);
+        }
+    }
+    const result = [];
+    for (let i = 0; i < allPaths.length; i++) {
+        result.push(get(object, allPaths[i]));
+    }
+    return result;
+}
+
+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 pullAt(array, ..._indices) {
+    const indices = flatten(_indices, 1);
+    if (!array) {
+        return Array(indices.length);
+    }
+    const result = at(array, indices);
+    const indicesToPull = indices
+        .map(index => (isIndex(index, array.length) ? Number(index) : index))
+        .sort((a, b) => b - a);
+    for (const index of new Set(indicesToPull)) {
+        if (isIndex(index, array.length)) {
+            Array.prototype.splice.call(array, index, 1);
+            continue;
+        }
+        if (isKey(index, array)) {
+            delete array[toKey(index)];
+            continue;
+        }
+        const path = isArray(index) ? index : toPath(index);
+        unset(array, path);
+    }
+    return result;
+}
+
 function reduce(collection, iteratee = unary.identity, accumulator) {
     if (!collection) {
         return accumulator;
@@ -1604,7 +1780,7 @@ function reject(source, predicate) {
 }
 
 function remove(arr, shouldRemoveElement) {
-    return zipWith.remove(arr, iteratee(shouldRemoveElement));
+    return zip$1.remove(arr, iteratee(shouldRemoveElement));
 }
 
 function reverse(array) {
@@ -1619,9 +1795,9 @@ function sample(collection) {
         return undefined;
     }
     if (isArrayLike(collection)) {
-        return zipWith.sample(toArray$1(collection));
+        return zip$1.sample(toArray$1(collection));
     }
-    return zipWith.sample(Object.values(collection));
+    return zip$1.sample(Object.values(collection));
 }
 
 function size(target) {
@@ -1646,8 +1822,8 @@ function slice(array, start, end) {
         start = 0;
         end = length;
     }
-    start = zipWith.toInteger(start);
-    end = zipWith.toInteger(end);
+    start = zip$1.toInteger(start);
+    end = zip$1.toInteger(end);
     if (start < 0) {
         start = Math.max(length + start, 0);
     }
@@ -1720,7 +1896,7 @@ function sortBy(collection, ...criteria) {
     else if (length > 2 && isIterateeCall(criteria[0], criteria[1], criteria[2])) {
         criteria = [criteria[0]];
     }
-    return orderBy(collection, zipWith.flatten(criteria), ['asc']);
+    return orderBy(collection, zip$1.flatten(criteria), ['asc']);
 }
 
 function isNaN(value) {
@@ -1743,7 +1919,7 @@ function sortedIndexBy(array, value, iteratee$1, retHighest) {
     const transformedValue = iterateeFunction(value);
     const valIsNaN = isNaN(transformedValue);
     const valIsNull = isPromise.isNull(transformedValue);
-    const valIsSymbol = zipWith.isSymbol(transformedValue);
+    const valIsSymbol = zip$1.isSymbol(transformedValue);
     const valIsUndefined = isPromise.isUndefined(transformedValue);
     while (low < high) {
         let setLow;
@@ -1752,7 +1928,7 @@ function sortedIndexBy(array, value, iteratee$1, retHighest) {
         const othIsDefined = !isPromise.isUndefined(computed);
         const othIsNull = isPromise.isNull(computed);
         const othIsReflexive = !isNaN(computed);
-        const othIsSymbol = zipWith.isSymbol(computed);
+        const othIsSymbol = zip$1.isSymbol(computed);
         if (valIsNaN) {
             setLow = retHighest || othIsReflexive;
         }
@@ -1851,23 +2027,23 @@ function tail(arr) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return zipWith.tail(toArray$1(arr));
+    return zip$1.tail(toArray$1(arr));
 }
 
 function take(arr, count = 1, guard) {
-    count = guard ? 1 : zipWith.toInteger(count);
+    count = guard ? 1 : zip$1.toInteger(count);
     if (count < 1 || !isArrayLike(arr)) {
         return [];
     }
-    return zipWith.take(toArray$1(arr), count);
+    return zip$1.take(toArray$1(arr), count);
 }
 
 function takeRight(arr, count = 1, guard) {
-    count = guard ? 1 : zipWith.toInteger(count);
+    count = guard ? 1 : zip$1.toInteger(count);
     if (count <= 0 || !isArrayLike(arr)) {
         return [];
     }
-    return zipWith.takeRight(toArray$1(arr), count);
+    return zip$1.takeRight(toArray$1(arr), count);
 }
 
 function takeRightWhile(_array, predicate) {
@@ -1891,39 +2067,39 @@ function takeWhile(array, predicate) {
 function union(...arrays) {
     const validArrays = arrays.filter(isArrayLikeObject);
     const flattened = flatten(validArrays, 1);
-    return zipWith.uniq(flattened);
+    return zip$1.uniq(flattened);
 }
 
 function unionBy(...values) {
-    const lastValue = zipWith.last(values);
+    const lastValue = zip$1.last(values);
     const flattened = flattenArrayLike(values);
     if (isArrayLikeObject(lastValue) || lastValue == null) {
-        return zipWith.uniq(flattened);
+        return zip$1.uniq(flattened);
     }
-    return zipWith.uniqBy(flattened, iteratee(lastValue));
+    return zip$1.uniqBy(flattened, iteratee(lastValue));
 }
 
 function unionWith(...values) {
-    const lastValue = zipWith.last(values);
+    const lastValue = zip$1.last(values);
     const flattened = flattenArrayLike(values);
     if (isArrayLikeObject(lastValue) || lastValue == null) {
-        return zipWith.uniq(flattened);
+        return zip$1.uniq(flattened);
     }
-    return zipWith.uniqWith(flattened, lastValue);
+    return zip$1.uniqWith(flattened, lastValue);
 }
 
 function uniqBy(array, iteratee$1) {
     if (!isArrayLikeObject(array)) {
         return [];
     }
-    return zipWith.uniqBy(Array.from(array), iteratee(iteratee$1));
+    return zip$1.uniqBy(Array.from(array), iteratee(iteratee$1));
 }
 
 function uniqWith(arr, comparator) {
     if (!isArrayLike(arr)) {
         return [];
     }
-    return typeof comparator === 'function' ? zipWith.uniqWith(Array.from(arr), comparator) : uniq(Array.from(arr));
+    return typeof comparator === 'function' ? zip$1.uniqWith(Array.from(arr), comparator) : uniq(Array.from(arr));
 }
 
 function unzip(array) {
@@ -1932,21 +2108,21 @@ function unzip(array) {
     }
     array = isArray(array) ? array : Array.from(array);
     array = array.filter(item => isArrayLikeObject(item));
-    return zipWith.unzip(array);
+    return zip$1.unzip(array);
 }
 
 function without(array, ...values) {
     if (!isArrayLikeObject(array)) {
         return [];
     }
-    return zipWith.without(Array.from(array), ...values);
+    return zip$1.without(Array.from(array), ...values);
 }
 
 function zip(...arrays) {
     if (!arrays.length) {
         return [];
     }
-    return zipWith.zip(...arrays.filter(group => isArrayLikeObject(group)));
+    return zip$1.zip(...arrays.filter(group => isArrayLikeObject(group)));
 }
 
 const assignValue = (object, key, value) => {
@@ -1956,6 +2132,14 @@ const assignValue = (object, key, value) => {
     }
 };
 
+function zipObject(keys = [], values = []) {
+    const result = {};
+    for (let i = 0; i < keys.length; i++) {
+        assignValue(result, keys[i], values[i]);
+    }
+    return result;
+}
+
 function updateWith(obj, path, updater, customizer) {
     if (obj == null && !isObject(obj)) {
         return obj;
@@ -2004,7 +2188,7 @@ function zipObjectDeep(keys, values) {
     if (!isArrayLike(values)) {
         values = [];
     }
-    const zipped = zipWith.zip(Array.from(keys), Array.from(values));
+    const zipped = zip$1.zip(Array.from(keys), Array.from(values));
     for (let i = 0; i < zipped.length; i++) {
         const [key, value] = zipped[i];
         if (key != null) {
@@ -2014,11 +2198,27 @@ function zipObjectDeep(keys, values) {
     return result;
 }
 
+function zipWith(...combine) {
+    let iteratee = combine.pop();
+    if (!isPromise.isFunction(iteratee)) {
+        combine.push(iteratee);
+        iteratee = undefined;
+    }
+    if (!combine?.length) {
+        return [];
+    }
+    const result = unzip(combine);
+    if (iteratee == null) {
+        return result;
+    }
+    return result.map(group => iteratee(...group));
+}
+
 function after(n, func) {
     if (typeof func !== 'function') {
         throw new TypeError('Expected a function');
     }
-    n = zipWith.toInteger(n);
+    n = zip$1.toInteger(n);
     return function (...args) {
         if (--n < 1) {
             return func.apply(this, args);
@@ -2050,7 +2250,7 @@ function before(n, func) {
         throw new TypeError('Expected a function');
     }
     let result;
-    n = zipWith.toInteger(n);
+    n = zip$1.toInteger(n);
     return function (...args) {
         if (--n > 0) {
             result = func.apply(this, args);
@@ -2289,7 +2489,7 @@ function delay(func, wait, ...args) {
     if (typeof func !== 'function') {
         throw new TypeError('Expected a function');
     }
-    return setTimeout(func, zipWith.toNumber(wait) || 0, ...args);
+    return setTimeout(func, zip$1.toNumber(wait) || 0, ...args);
 }
 
 function flip(func) {
@@ -2299,7 +2499,7 @@ function flip(func) {
 }
 
 function flow(...funcs) {
-    const flattenFuncs = zipWith.flatten(funcs, 1);
+    const flattenFuncs = zip$1.flatten(funcs, 1);
     if (flattenFuncs.some(func => typeof func !== 'function')) {
         throw new TypeError('Expected a function');
     }
@@ -2307,7 +2507,7 @@ function flow(...funcs) {
 }
 
 function flowRight(...funcs) {
-    const flattenFuncs = zipWith.flatten(funcs, 1);
+    const flattenFuncs = zip$1.flatten(funcs, 1);
     if (flattenFuncs.some(func => typeof func !== 'function')) {
         throw new TypeError('Expected a function');
     }
@@ -2316,7 +2516,7 @@ function flowRight(...funcs) {
 
 function nthArg(n = 0) {
     return function (...args) {
-        return args.at(zipWith.toInteger(n));
+        return args.at(zip$1.toInteger(n));
     };
 }
 
@@ -2403,8 +2603,8 @@ function add(value, other) {
         other = toString(other);
     }
     else {
-        value = zipWith.toNumber(value);
-        other = zipWith.toNumber(other);
+        value = zip$1.toNumber(value);
+        other = zip$1.toNumber(other);
     }
     return value + other;
 }
@@ -2453,8 +2653,8 @@ function divide(value, other) {
         other = toString(other);
     }
     else {
-        value = zipWith.toNumber(value);
-        other = zipWith.toNumber(other);
+        value = zip$1.toNumber(value);
+        other = zip$1.toNumber(other);
     }
     return value / other;
 }
@@ -2505,7 +2705,7 @@ function maxBy(items, iteratee$1) {
     if (items == null) {
         return undefined;
     }
-    return zipWith.maxBy(Array.from(items), iteratee(iteratee$1));
+    return zip$1.maxBy(Array.from(items), iteratee(iteratee$1));
 }
 
 function sumBy(array, iteratee$1) {
@@ -2563,7 +2763,7 @@ function minBy(items, iteratee$1) {
     if (items == null) {
         return undefined;
     }
-    return zipWith.minBy(Array.from(items), iteratee(iteratee$1));
+    return zip$1.minBy(Array.from(items), iteratee(iteratee$1));
 }
 
 function multiply(value, other) {
@@ -2578,8 +2778,8 @@ function multiply(value, other) {
         other = toString(other);
     }
     else {
-        value = zipWith.toNumber(value);
-        other = zipWith.toNumber(other);
+        value = zip$1.toNumber(value);
+        other = zip$1.toNumber(other);
     }
     return value * other;
 }
@@ -2660,15 +2860,15 @@ function range(start, end, step) {
     if (step && typeof step !== 'number' && isIterateeCall(start, end, step)) {
         end = step = undefined;
     }
-    start = zipWith.toFinite(start);
+    start = zip$1.toFinite(start);
     if (end === undefined) {
         end = start;
         start = 0;
     }
     else {
-        end = zipWith.toFinite(end);
+        end = zip$1.toFinite(end);
     }
-    step = step === undefined ? (start < end ? 1 : -1) : zipWith.toFinite(step);
+    step = step === undefined ? (start < end ? 1 : -1) : zip$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++) {
@@ -2682,15 +2882,15 @@ function rangeRight(start, end, step) {
     if (step && typeof step !== 'number' && isIterateeCall(start, end, step)) {
         end = step = undefined;
     }
-    start = zipWith.toFinite(start);
+    start = zip$1.toFinite(start);
     if (end === undefined) {
         end = start;
         start = 0;
     }
     else {
-        end = zipWith.toFinite(end);
+        end = zip$1.toFinite(end);
     }
-    step = step === undefined ? (start < end ? 1 : -1) : zipWith.toFinite(step);
+    step = step === undefined ? (start < end ? 1 : -1) : zip$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--) {
@@ -2716,8 +2916,8 @@ function subtract(value, other) {
         other = toString(other);
     }
     else {
-        value = zipWith.toNumber(value);
-        other = zipWith.toNumber(other);
+        value = zip$1.toNumber(value);
+        other = zip$1.toNumber(other);
     }
     return value - other;
 }
@@ -2733,7 +2933,7 @@ function isTypedArray(x) {
 }
 
 function times(n, getValue) {
-    n = zipWith.toInteger(n);
+    n = zip$1.toInteger(n);
     if (n < 1 || !Number.isSafeInteger(n)) {
         return [];
     }
@@ -2958,6 +3158,67 @@ function findKeyImpl(obj, predicate) {
     }
 }
 
+function forIn(object, iteratee = unary.identity) {
+    if (object == null) {
+        return object;
+    }
+    for (const key in object) {
+        const result = iteratee(object[key], key, object);
+        if (result === false) {
+            break;
+        }
+    }
+    return object;
+}
+
+function forInRight(object, iteratee = unary.identity) {
+    if (object == null) {
+        return object;
+    }
+    const keys = [];
+    for (const key in object) {
+        keys.push(key);
+    }
+    for (let i = keys.length - 1; i >= 0; i--) {
+        const key = keys[i];
+        const result = iteratee(object[key], key, object);
+        if (result === false) {
+            break;
+        }
+    }
+    return object;
+}
+
+function forOwn(object, iteratee = unary.identity) {
+    if (object == null) {
+        return object;
+    }
+    const iterable = Object(object);
+    const keys$1 = keys(object);
+    for (let i = 0; i < keys$1.length; ++i) {
+        const key = keys$1[i];
+        if (iteratee(iterable[key], key, iterable) === false) {
+            break;
+        }
+    }
+    return object;
+}
+
+function forOwnRight(object, iteratee = unary.identity) {
+    if (object == null) {
+        return object;
+    }
+    const iterable = Object(object);
+    const keys$1 = keys(object);
+    for (let i = keys$1.length - 1; i >= 0; --i) {
+        const key = keys$1[i];
+        if (iteratee(iterable[key], key, iterable) === false) {
+            break;
+        }
+    }
+    return object;
+}
+
 function fromPairs(pairs) {
     if (!isArrayLike(pairs) && !(pairs instanceof Map)) {
         return {};
@@ -2989,6 +3250,34 @@ function functionsIn(object) {
     return result;
 }
 
+function hasIn(object, path) {
+    let resolvedPath;
+    if (Array.isArray(path)) {
+        resolvedPath = path;
+    }
+    else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {
+        resolvedPath = toPath(path);
+    }
+    else {
+        resolvedPath = [path];
+    }
+    if (resolvedPath.length === 0) {
+        return false;
+    }
+    let current = object;
+    for (let i = 0; i < resolvedPath.length; i++) {
+        const key = resolvedPath[i];
+        if (current == null || !(key in Object(current))) {
+            const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
+            if (!isSparseIndex) {
+                return false;
+            }
+        }
+        current = current[key];
+    }
+    return true;
+}
+
 function invertBy(object, iteratee) {
     const result = {};
     if (isPromise.isNil(object)) {
@@ -3152,68 +3441,6 @@ function merge(object, ...sources) {
     return mergeWith(object, ...sources, noop.noop);
 }
 
-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 omit(obj, ...keysArr) {
     if (obj == null) {
         return {};
@@ -3304,7 +3531,7 @@ function pickBy(obj, shouldPick) {
     }
     const keys = isArrayLike(obj) ? range$1.range(0, obj.length) : [...keysIn(obj), ...getSymbolsIn(obj)];
     for (let i = 0; i < keys.length; i++) {
-        const key = (zipWith.isSymbol(keys[i]) ? keys[i] : keys[i].toString());
+        const key = (zip$1.isSymbol(keys[i]) ? keys[i] : keys[i].toString());
         const value = obj[key];
         if (shouldPick(value, key, obj)) {
             result[key] = value;
@@ -3579,7 +3806,7 @@ function repeat(str, n, guard) {
         n = 1;
     }
     else {
-        n = zipWith.toInteger(n);
+        n = zip$1.toInteger(n);
     }
     return toString(str).repeat(n);
 }
@@ -3595,6 +3822,10 @@ function snakeCase(str) {
     return reverseString.snakeCase(normalizeForCase(str));
 }
 
+function split(string = '', separator, limit) {
+    return toString(string).split(separator, limit);
+}
+
 function startCase(str) {
     const words = reverseString.words(normalizeForCase(str).trim());
     let result = '';
@@ -3827,14 +4058,14 @@ function gt(value, other) {
     if (typeof value === 'string' && typeof other === 'string') {
         return value > other;
     }
-    return zipWith.toNumber(value) > zipWith.toNumber(other);
+    return zip$1.toNumber(value) > zip$1.toNumber(other);
 }
 
 function gte(value, other) {
     if (typeof value === 'string' && typeof other === 'string') {
         return value >= other;
     }
-    return zipWith.toNumber(value) >= zipWith.toNumber(other);
+    return zip$1.toNumber(value) >= zip$1.toNumber(other);
 }
 
 function invoke(object, path, args = []) {
@@ -3883,14 +4114,14 @@ function lt(value, other) {
     if (typeof value === 'string' && typeof other === 'string') {
         return value < other;
     }
-    return zipWith.toNumber(value) < zipWith.toNumber(other);
+    return zip$1.toNumber(value) < zip$1.toNumber(other);
 }
 
 function lte(value, other) {
     if (typeof value === 'string' && typeof other === 'string') {
         return value <= other;
     }
-    return zipWith.toNumber(value) <= zipWith.toNumber(other);
+    return zip$1.toNumber(value) <= zip$1.toNumber(other);
 }
 
 function method(path, ...args) {
@@ -3919,6 +4150,46 @@ function over(...iteratees) {
     };
 }
 
+function overEvery(...predicates) {
+    return function (...values) {
+        for (let i = 0; i < predicates.length; ++i) {
+            const predicate = predicates[i];
+            if (!Array.isArray(predicate)) {
+                if (!iteratee(predicate).apply(this, values)) {
+                    return false;
+                }
+                continue;
+            }
+            for (let j = 0; j < predicate.length; ++j) {
+                if (!iteratee(predicate[j]).apply(this, values)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+}
+
+function overSome(...predicates) {
+    return function (...values) {
+        for (let i = 0; i < predicates.length; ++i) {
+            const predicate = predicates[i];
+            if (!Array.isArray(predicate)) {
+                if (iteratee(predicate).apply(this, values)) {
+                    return true;
+                }
+                continue;
+            }
+            for (let j = 0; j < predicate.length; ++j) {
+                if (iteratee(predicate[j]).apply(this, values)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+}
+
 function stubArray() {
     return [];
 }
@@ -3989,7 +4260,7 @@ function toSafeInteger(value) {
     if (value == null) {
         return 0;
     }
-    return clamp(zipWith.toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+    return clamp(zip$1.toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
 }
 
 let idCounter = 0;
@@ -4012,7 +4283,7 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     assignInWith,
     assignWith,
     asyncNoop: unary.asyncNoop,
-    at: zipWith.at,
+    at,
     attempt,
     attemptAsync: invariant.attemptAsync,
     before,
@@ -4034,7 +4305,7 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     conformsTo,
     constant,
     constantCase: reverseString.constantCase,
-    countBy: zipWith.countBy,
+    countBy: zip$1.countBy,
     create,
     curry,
     curryRight,
@@ -4069,8 +4340,8 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     findLast,
     findLastIndex,
     first: head,
-    flatMap: zipWith.flatMap,
-    flatMapDeep: zipWith.flatMapDeep,
+    flatMap,
+    flatMapDeep: zip$1.flatMapDeep,
     flatten,
     flattenDeep,
     flattenDepth,
@@ -4081,6 +4352,10 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     flowRight,
     forEach,
     forEachRight,
+    forIn,
+    forInRight,
+    forOwn,
+    forOwnRight,
     fromPairs,
     functions,
     functionsIn,
@@ -4089,12 +4364,13 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     gt,
     gte,
     has,
+    hasIn,
     head,
     identity: unary.identity,
     inRange,
     includes,
     indexOf,
-    initial: zipWith.initial,
+    initial: zip$1.initial,
     intersection,
     intersectionBy,
     intersectionWith,
@@ -4143,9 +4419,9 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     isSafeInteger,
     isSet,
     isString,
-    isSubset: zipWith.isSubset,
-    isSubsetWith: zipWith.isSubsetWith,
-    isSymbol: zipWith.isSymbol,
+    isSubset: zip$1.isSubset,
+    isSubsetWith: zip$1.isSubsetWith,
+    isSymbol: zip$1.isSymbol,
     isTypedArray,
     isUndefined: isPromise.isUndefined,
     isWeakMap,
@@ -4153,7 +4429,7 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     iteratee,
     join,
     kebabCase,
-    keyBy: zipWith.keyBy,
+    keyBy: zip$1.keyBy,
     keys,
     keysIn,
     last,
@@ -4191,13 +4467,15 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     once: unary.once,
     orderBy,
     over,
+    overEvery,
+    overSome,
     pad,
     padEnd,
     padStart,
     parseInt,
     partial,
     partialRight,
-    partition: zipWith.partition,
+    partition,
     pascalCase: reverseString.pascalCase,
     pick,
     pickBy,
@@ -4206,7 +4484,8 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     pull,
     pullAll,
     pullAllBy,
-    pullAt: zipWith.pullAt,
+    pullAllWith,
+    pullAt,
     random,
     randomInt: randomInt.randomInt,
     range,
@@ -4224,9 +4503,9 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     reverseString: reverseString.reverseString,
     round,
     sample,
-    sampleSize: zipWith.sampleSize,
+    sampleSize: zip$1.sampleSize,
     set,
-    shuffle: zipWith.shuffle,
+    shuffle: zip$1.shuffle,
     size,
     slice,
     snakeCase,
@@ -4237,6 +4516,7 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     sortedIndexOf,
     sortedLastIndex,
     sortedLastIndexBy,
+    split,
     spread,
     startCase,
     startsWith,
@@ -4261,13 +4541,13 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     toArray,
     toCamelCaseKeys,
     toDefaulted,
-    toFilled: zipWith.toFilled,
-    toFinite: zipWith.toFinite,
-    toInteger: zipWith.toInteger,
+    toFilled: zip$1.toFilled,
+    toFinite: zip$1.toFinite,
+    toInteger: zip$1.toInteger,
     toLength,
     toLower,
     toMerged,
-    toNumber: zipWith.toNumber,
+    toNumber: zip$1.toNumber,
     toPairs,
     toPairsIn,
     toPath,
@@ -4290,24 +4570,24 @@ const compat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     uniqueId,
     unset,
     unzip,
-    unzipWith: zipWith.unzipWith,
+    unzipWith: zip$1.unzipWith,
     update,
     updateWith,
     upperCase,
     upperFirst,
     values,
     valuesIn,
-    windowed: zipWith.windowed,
+    windowed: zip$1.windowed,
     withTimeout: promise_index.withTimeout,
     without,
     words,
-    xor: zipWith.xor,
-    xorBy: zipWith.xorBy,
-    xorWith: zipWith.xorWith,
+    xor: zip$1.xor,
+    xorBy: zip$1.xorBy,
+    xorWith: zip$1.xorWith,
     zip,
-    zipObject: zipWith.zipObject,
+    zipObject,
     zipObjectDeep,
-    zipWith: zipWith.zipWith
+    zipWith
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const toolkit = ((value) => {
@@ -4364,6 +4644,7 @@ exports.assign = assign;
 exports.assignIn = assignIn;
 exports.assignInWith = assignInWith;
 exports.assignWith = assignWith;
+exports.at = at;
 exports.attempt = attempt;
 exports.before = before;
 exports.bind = bind;
@@ -4413,6 +4694,7 @@ exports.findKey = findKey$1;
 exports.findKey$1 = findKey;
 exports.findLast = findLast;
 exports.findLastIndex = findLastIndex;
+exports.flatMap = flatMap;
 exports.flatten = flatten;
 exports.flattenDeep = flattenDeep;
 exports.flattenDepth = flattenDepth;
@@ -4423,6 +4705,10 @@ exports.flow = flow;
 exports.flowRight = flowRight;
 exports.forEach = forEach;
 exports.forEachRight = forEachRight;
+exports.forIn = forIn;
+exports.forInRight = forInRight;
+exports.forOwn = forOwn;
+exports.forOwnRight = forOwnRight;
 exports.fromPairs = fromPairs;
 exports.functions = functions;
 exports.functionsIn = functionsIn;
@@ -4431,6 +4717,7 @@ exports.groupBy = groupBy;
 exports.gt = gt;
 exports.gte = gte;
 exports.has = has;
+exports.hasIn = hasIn;
 exports.head = head;
 exports.inRange = inRange;
 exports.includes = includes;
@@ -4508,12 +4795,15 @@ exports.omit = omit;
 exports.omitBy = omitBy;
 exports.orderBy = orderBy;
 exports.over = over;
+exports.overEvery = overEvery;
+exports.overSome = overSome;
 exports.pad = pad;
 exports.padEnd = padEnd;
 exports.padStart = padStart;
 exports.parseInt = parseInt;
 exports.partial = partial;
 exports.partialRight = partialRight;
+exports.partition = partition;
 exports.pick = pick;
 exports.pickBy = pickBy;
 exports.property = property;
@@ -4521,6 +4811,8 @@ exports.propertyOf = propertyOf;
 exports.pull = pull;
 exports.pullAll = pullAll;
 exports.pullAllBy = pullAllBy;
+exports.pullAllWith = pullAllWith;
+exports.pullAt = pullAt;
 exports.random = random;
 exports.range = range;
 exports.rangeRight = rangeRight;
@@ -4546,6 +4838,7 @@ exports.sortedIndexBy = sortedIndexBy;
 exports.sortedIndexOf = sortedIndexOf;
 exports.sortedLastIndex = sortedLastIndex;
 exports.sortedLastIndexBy = sortedLastIndexBy;
+exports.split = split;
 exports.spread = spread;
 exports.startCase = startCase;
 exports.startsWith = startsWith;
@@ -4603,4 +4896,6 @@ exports.valuesIn = valuesIn;
 exports.without = without;
 exports.words = words;
 exports.zip = zip;
+exports.zipObject = zipObject;
 exports.zipObjectDeep = zipObjectDeep;
+exports.zipWith = zipWith;