ut2 1.5.6 → 1.7.0

package/es/countBy.js

@@ -1,20 +1,18 @@
+import forEach from './forEach.js';
 import createIteratee from './internals/createIteratee.js';
-import isArray from './isArray.js';
 
 function countBy(collection, iteratee) {
     var result = {};
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(iteratee);
-        collection.forEach(function (item) {
-            var key = internalIteratee_1(item);
-            if (key in result) {
-                ++result[key];
-            }
-            else {
-                result[key] = 1;
-            }
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    forEach(collection, function (item) {
+        var key = internalIteratee(item);
+        if (key in result) {
+            ++result[key];
+        }
+        else {
+            result[key] = 1;
+        }
+    });
     return result;
 }
 

package/es/difference.js

@@ -1,8 +1,10 @@
 import eq from './eq.js';
+import identity from './identity.js';
 import createIteratee from './internals/createIteratee.js';
 import isArray from './isArray.js';
 
 function difference(array, values, iteratee, strictCheck) {
+    if (iteratee === void 0) { iteratee = identity; }
     if (strictCheck === void 0) { strictCheck = false; }
     if (!isArray(array)) {
         return [];

package/es/every.js

@@ -0,0 +1,16 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
+
+function every(collection, predicate) {
+    if (predicate === void 0) { predicate = identity; }
+    var result = true;
+    forEach(collection, function (item, index, arr) {
+        if (!predicate(item, index, arr)) {
+            result = false;
+            return false;
+        }
+    });
+    return result;
+}
+
+export { every as default };

package/es/filter.js

@@ -0,0 +1,15 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
+
+function filter(array, predicate) {
+    if (predicate === void 0) { predicate = identity; }
+    var results = [];
+    forEach(array, function (item, index) {
+        if (predicate(item, index, array)) {
+            results.push(item);
+        }
+    });
+    return results;
+}
+
+export { filter as default };

package/es/find.js

@@ -0,0 +1,16 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
+
+function find(collection, predicate) {
+    if (predicate === void 0) { predicate = identity; }
+    var result;
+    forEach(collection, function (item, index, arr) {
+        if (predicate(item, index, arr)) {
+            result = item;
+            return false;
+        }
+    });
+    return result;
+}
+
+export { find as default };

package/es/forEach.js

@@ -0,0 +1,6 @@
+import createForEach from './internals/createForEach.js';
+
+var forEach = createForEach(1);
+var forEach$1 = forEach;
+
+export { forEach$1 as default };

package/es/forEachRight.js

@@ -0,0 +1,6 @@
+import createForEach from './internals/createForEach.js';
+
+var forEachRight = createForEach(-1);
+var forEachRight$1 = forEachRight;
+
+export { forEachRight$1 as default };

package/es/groupBy.js

@@ -1,20 +1,20 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
 import createIteratee from './internals/createIteratee.js';
-import isArray from './isArray.js';
 
 function groupBy(collection, iteratee) {
+    if (iteratee === void 0) { iteratee = identity; }
     var result = {};
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(iteratee);
-        collection.forEach(function (item) {
-            var key = internalIteratee_1(item);
-            if (key in result) {
-                result[key].push(item);
-            }
-            else {
-                result[key] = [item];
-            }
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    forEach(collection, function (item) {
+        var key = internalIteratee(item);
+        if (key in result) {
+            result[key].push(item);
+        }
+        else {
+            result[key] = [item];
+        }
+    });
     return result;
 }
 

package/es/index.js

@@ -11,10 +11,19 @@ export { default as unzip } from './unzip.js';
 export { default as xor } from './xor.js';
 export { default as zip } from './zip.js';
 export { default as countBy } from './countBy.js';
+export { default as every } from './every.js';
+export { default as find } from './find.js';
+export { default as filter } from './filter.js';
+export { default as forEach } from './forEach.js';
+export { default as forEachRight } from './forEachRight.js';
 export { default as groupBy } from './groupBy.js';
 export { default as keyBy } from './keyBy.js';
 export { default as orderBy } from './orderBy.js';
+export { default as map } from './map.js';
 export { default as partition } from './partition.js';
+export { default as reduce } from './reduce.js';
+export { default as reduceRight } from './reduceRight.js';
+export { default as some } from './some.js';
 export { default as after } from './after.js';
 export { default as before } from './before.js';
 export { default as debounce } from './debounce.js';
@@ -71,6 +80,7 @@ export { default as random } from './random.js';
 export { default as randomInt } from './randomInt.js';
 export { default as allKeys } from './allKeys.js';
 export { default as allKeysIn } from './allKeysIn.js';
+export { default as keys } from './keys.js';
 export { default as keysIn } from './keysIn.js';
 export { default as merge } from './merge.js';
 export { default as omit } from './omit.js';
@@ -102,6 +112,7 @@ export { default as lt } from './lt.js';
 export { default as lte } from './lte.js';
 export { default as noop } from './noop.js';
 export { default as nthArg } from './nthArg.js';
+export { default as range } from './range.js';
 export { default as sleep } from './sleep.js';
 export { default as times } from './times.js';
 export { default as toFinite } from './toFinite.js';

package/es/internals/createExtremum.js

@@ -1,6 +1,5 @@
 import isArray from '../isArray.js';
 import isSymbol from '../isSymbol.js';
-import isUndefined from '../isUndefined.js';
 import createIteratee from './createIteratee.js';
 
 function createExtremum(array, comparator, iteratee) {
@@ -8,23 +7,14 @@ function createExtremum(array, comparator, iteratee) {
         return;
     }
     var result, computed;
-    if (isUndefined(iteratee)) {
-        array.forEach(function (value) {
-            if (value != null && (result === undefined ? value === value && !isSymbol(value) : comparator(value, result))) {
-                result = value;
-            }
-        });
-    }
-    else {
-        var internalIteratee_1 = createIteratee(iteratee);
-        array.forEach(function (value) {
-            var current = internalIteratee_1(value);
-            if (current != null && (computed === undefined ? current === current && !isSymbol(current) : comparator(current, computed))) {
-                computed = current;
-                result = value;
-            }
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    array.forEach(function (value) {
+        var current = internalIteratee(value);
+        if (current != null && (computed === undefined ? current === current && !isSymbol(current) : comparator(current, computed))) {
+            computed = current;
+            result = value;
+        }
+    });
     return result;
 }
 

package/es/internals/createForEach.js

@@ -0,0 +1,23 @@
+import identity from '../identity.js';
+import isArrayLike from '../isArrayLike.js';
+import keys from '../keys.js';
+
+function createForEach(dir) {
+    function forEach(collection, iteratee) {
+        if (iteratee === void 0) { iteratee = identity; }
+        var _keys = !isArrayLike(collection) && keys(collection);
+        var len = (_keys || collection).length;
+        var i = dir > 0 ? 0 : len - 1;
+        while (i >= 0 && i < len) {
+            var currentKey = _keys ? _keys[i] : i;
+            if (iteratee(collection[currentKey], currentKey, collection) === false) {
+                break;
+            }
+            i += dir;
+        }
+        return collection;
+    }
+    return forEach;
+}
+
+export { createForEach as default };

package/es/internals/createReduce.js

@@ -0,0 +1,29 @@
+import identity from '../identity.js';
+import isArrayLike from '../isArrayLike.js';
+import keys from '../keys.js';
+
+function createReduce(dir) {
+    function reducer(collection, iteratee, memo, initial) {
+        var _keys = !isArrayLike(collection) && keys(collection);
+        var len = (_keys || collection).length;
+        var i = dir > 0 ? 0 : len - 1;
+        if (!initial && len > 0) {
+            memo = collection[_keys ? _keys[i] : i];
+            i += dir;
+        }
+        while (i >= 0 && i < len) {
+            var currentKey = _keys ? _keys[i] : i;
+            memo = iteratee(memo, collection[currentKey], currentKey, collection);
+            i += dir;
+        }
+        return memo;
+    }
+    function reduce(collection, iteratee, initialValue) {
+        if (iteratee === void 0) { iteratee = identity; }
+        var initial = arguments.length >= 3;
+        return reducer(collection, iteratee, initialValue, initial);
+    }
+    return reduce;
+}
+
+export { createReduce as default };

package/es/internals/helpers.js

@@ -1,7 +1,7 @@
 import getTag from './getTag.js';
 import { argumentsTag, functionProtoToString } from './native.js';
 
-var VERSION = "1.5.6";
+var VERSION = "1.7.0";
 var supportedArgumentsType = getTag((function () { return arguments; })()) === argumentsTag;
 var FUNC_ERROR_TEXT = 'Expected a function';
 function toSource(func) {

package/es/intersection.js

@@ -1,8 +1,10 @@
 import eq from './eq.js';
+import identity from './identity.js';
 import createIteratee from './internals/createIteratee.js';
 import isArray from './isArray.js';
 
 function intersection(array, other, iteratee, strictCheck) {
+    if (iteratee === void 0) { iteratee = identity; }
     if (strictCheck === void 0) { strictCheck = false; }
     if (!isArray(array) || !isArray(other)) {
         return [];

package/es/isEmpty.js

@@ -1,5 +1,5 @@
 import getTag from './internals/getTag.js';
-import keys from './internals/keys.js';
+import keys from './internals/specialKeys.js';
 import { mapTag, setTag } from './internals/native.js';
 import isArrayLike from './isArrayLike.js';
 import isNil from './isNil.js';

package/es/keyBy.js

@@ -1,15 +1,15 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
 import createIteratee from './internals/createIteratee.js';
-import isArray from './isArray.js';
 
 function keyBy(collection, iteratee) {
+    if (iteratee === void 0) { iteratee = identity; }
     var result = {};
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(iteratee);
-        collection.forEach(function (item) {
-            var key = internalIteratee_1(item);
-            result[key] = item;
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    forEach(collection, function (item) {
+        var key = internalIteratee(item);
+        result[key] = item;
+    });
     return result;
 }
 

package/es/keys.js

@@ -0,0 +1,11 @@
+import { objectKeys } from './internals/native.js';
+import isObject from './isObject.js';
+
+function keys(object) {
+    if (!isObject(object)) {
+        return [];
+    }
+    return objectKeys(object);
+}
+
+export { keys as default };

package/es/map.js

@@ -0,0 +1,13 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
+
+function map(collection, iteratee) {
+    if (iteratee === void 0) { iteratee = identity; }
+    var result = [];
+    forEach(collection, function (item, index, arr) {
+        result.push(iteratee(item, index, arr));
+    });
+    return result;
+}
+
+export { map as default };

package/es/merge.js

@@ -1,44 +1,54 @@
-import allKeysIn from './allKeysIn.js';
+import keysIn from './keysIn.js';
 import isArray from './isArray.js';
 import isObject from './isObject.js';
 import isObjectLike from './isObjectLike.js';
 import isPlainObject from './isPlainObject.js';
 
-function baseMerge(object, source, customizer, storage) {
-    if (storage === void 0) { storage = new WeakMap(); }
+function baseMerge(object, source, getKeys, customizer, stack) {
+    if (stack === void 0) { stack = new WeakMap(); }
     var obj = Object(object);
     if (!isObject(source) || obj === source) {
         return obj;
     }
-    var keys = allKeysIn(source);
+    var keys = getKeys(source);
+    var hasCustomizer = typeof customizer === 'function';
     keys.forEach(function (key) {
         var srcValue = source[key];
-        var newValue = typeof customizer === 'function' ? customizer(obj[key], srcValue, key, obj, source) : undefined;
-        if (newValue === undefined) {
-            newValue = srcValue;
-        }
-        if (isObjectLike(newValue) && !storage.has(newValue)) {
-            storage.set(newValue, true);
-            var objValue = obj[key];
-            var newObjValue = void 0;
-            if (isArray(newValue)) {
-                newObjValue = isArray(objValue) ? objValue : [];
-            }
-            else if (isPlainObject(newValue)) {
-                newObjValue = isPlainObject(objValue) ? objValue : {};
-            }
-            obj[key] = newObjValue ? baseMerge(newObjValue, newValue, customizer, storage) : newValue;
+        var srcIsObj = isObject(srcValue);
+        if (srcIsObj && stack.has(srcValue)) {
+            obj[key] = srcValue;
         }
         else {
-            if (newValue !== undefined || (newValue === undefined && !(key in obj))) {
+            var newValue = hasCustomizer ? customizer(obj[key], srcValue, key, obj, source) : undefined;
+            if (newValue !== undefined) {
                 obj[key] = newValue;
             }
+            else {
+                var objValue = obj[key];
+                var newObjValue = void 0;
+                if (srcIsObj) {
+                    stack.set(srcValue, true);
+                    if (isArray(srcValue)) {
+                        newObjValue = isArray(objValue) ? objValue : [];
+                    }
+                    else if (isPlainObject(srcValue)) {
+                        newObjValue = isObjectLike(objValue) ? objValue : {};
+                    }
+                }
+                if (newObjValue) {
+                    obj[key] = baseMerge(newObjValue, srcValue, getKeys, customizer, stack);
+                }
+                else if (srcValue !== undefined || !(key in obj)) {
+                    obj[key] = srcValue;
+                }
+            }
         }
     });
     return obj;
 }
-function merge(object, source, customizer) {
-    return baseMerge(object, source, customizer);
+function merge(object, source, customizer, getKeys) {
+    if (getKeys === void 0) { getKeys = keysIn; }
+    return baseMerge(object, source, getKeys, customizer);
 }
 
 export { merge as default };

package/es/orderBy.js

@@ -2,21 +2,21 @@ import identity from './identity.js';
 import createIteratee from './internals/createIteratee.js';
 import { compareMultiple } from './internals/compare.js';
 import isArray from './isArray.js';
+import forEach from './forEach.js';
 
 function orderBy(collection, iteratees, orders) {
     var result = [];
     iteratees = (isArray(iteratees) ? iteratees : iteratees !== undefined ? [iteratees] : [identity]);
     orders = (isArray(orders) ? orders : orders !== undefined ? [orders] : []);
-    if (isArray(collection)) {
-        collection.forEach(function (item, index) {
-            var criteria = iteratees.map(function (iteratee) { return createIteratee(iteratee)(item); });
-            result.push({
-                criteria: criteria,
-                index: index,
-                value: item
-            });
+    var index = -1;
+    forEach(collection, function (item) {
+        var criteria = iteratees.map(function (iteratee) { return createIteratee(iteratee)(item); });
+        result.push({
+            criteria: criteria,
+            index: ++index,
+            value: item
         });
-    }
+    });
     return result.sort(function (a, b) { return compareMultiple(a, b, orders); }).map(function (item) { return item.value; });
 }
 

package/es/partition.js

@@ -1,14 +1,14 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
 import createIteratee from './internals/createIteratee.js';
-import isArray from './isArray.js';
 
 function partition(collection, predicate) {
+    if (predicate === void 0) { predicate = identity; }
     var result = [[], []];
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(predicate);
-        collection.forEach(function (item) {
-            result[internalIteratee_1(item) ? 0 : 1].push(item);
-        });
-    }
+    var internalIteratee = createIteratee(predicate);
+    forEach(collection, function (item) {
+        result[internalIteratee(item) ? 0 : 1].push(item);
+    });
     return result;
 }
 

package/es/range.js

@@ -0,0 +1,28 @@
+import { mathMax, mathCeil } from './internals/native.js';
+import isNil from './isNil.js';
+import toFinite from './toFinite.js';
+
+function range(start, end, step) {
+    start = toFinite(start);
+    if (isNil(end)) {
+        end = start;
+        start = 0;
+    }
+    else {
+        end = toFinite(end);
+    }
+    step = toFinite(step);
+    if (!step) {
+        step = start < end ? 1 : -1;
+    }
+    var index = -1;
+    var length = mathMax(mathCeil((end - start) / step), 0);
+    var result = Array(length);
+    while (length--) {
+        result[++index] = start;
+        start += step;
+    }
+    return result;
+}
+
+export { range as default };

package/es/reduce.js

@@ -0,0 +1,6 @@
+import createReduce from './internals/createReduce.js';
+
+var reduce = createReduce(1);
+var reduce$1 = reduce;
+
+export { reduce$1 as default };

package/es/reduceRight.js

@@ -0,0 +1,6 @@
+import createReduce from './internals/createReduce.js';
+
+var reduceRight = createReduce(-1);
+var reduceRight$1 = reduceRight;
+
+export { reduceRight$1 as default };

package/es/some.js

@@ -0,0 +1,16 @@
+import forEach from './forEach.js';
+import identity from './identity.js';
+
+function some(collection, predicate) {
+    if (predicate === void 0) { predicate = identity; }
+    var result = false;
+    forEach(collection, function (item, index, arr) {
+        if (predicate(item, index, arr)) {
+            result = true;
+            return false;
+        }
+    });
+    return result;
+}
+
+export { some as default };

package/es/toString.js

@@ -9,7 +9,7 @@ function baseToString(value) {
         return value;
     }
     if (isArray(value)) {
-        return "".concat(value.map(baseToString));
+        return '' + value.map(baseToString);
     }
     if (isSymbol(value)) {
         return symbolToString ? symbolToString.call(value) : '';

package/es/uniq.js

@@ -1,25 +1,17 @@
 import eq from './eq.js';
 import createIteratee from './internals/createIteratee.js';
 import isArray from './isArray.js';
-import isUndefined from './isUndefined.js';
 
 function uniq(array, iteratee, strickCheck) {
     if (strickCheck === void 0) { strickCheck = false; }
     if (!isArray(array)) {
         return [];
     }
-    if (isUndefined(iteratee)) {
-        return array.filter(function (value, index, arr) {
-            return arr.findIndex(function (item) { return eq(item, value, strickCheck); }) === index;
-        });
-    }
-    else {
-        var internalIteratee_1 = createIteratee(iteratee);
-        return array.filter(function (value, index, arr) {
-            var current = internalIteratee_1(value);
-            return arr.findIndex(function (item) { return eq(internalIteratee_1(item), current, strickCheck); }) === index;
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    return array.filter(function (value, index, arr) {
+        var current = internalIteratee(value);
+        return arr.findIndex(function (item) { return eq(internalIteratee(item), current, strickCheck); }) === index;
+    });
 }
 
 export { uniq as default };

package/es/xor.js

@@ -1,4 +1,5 @@
 import difference from './difference.js';
+import identity from './identity.js';
 import createIteratee from './internals/createIteratee.js';
 import intersection from './intersection.js';
 import isArray from './isArray.js';
@@ -7,6 +8,7 @@ import uniq from './uniq.js';
 
 function xor(array, other, iteratee, strickCheck) {
     if (other === void 0) { other = []; }
+    if (iteratee === void 0) { iteratee = identity; }
     if (strickCheck === void 0) { strickCheck = false; }
     if (!isArray(array) && !isArray(other)) {
         return [];

package/lib/countBy.js

@@ -1,22 +1,20 @@
 'use strict';
 
+var forEach = require('./forEach.js');
 var createIteratee = require('./internals/createIteratee.js');
-var isArray = require('./isArray.js');
 
 function countBy(collection, iteratee) {
     var result = {};
-    if (isArray(collection)) {
-        var internalIteratee_1 = createIteratee(iteratee);
-        collection.forEach(function (item) {
-            var key = internalIteratee_1(item);
-            if (key in result) {
-                ++result[key];
-            }
-            else {
-                result[key] = 1;
-            }
-        });
-    }
+    var internalIteratee = createIteratee(iteratee);
+    forEach(collection, function (item) {
+        var key = internalIteratee(item);
+        if (key in result) {
+            ++result[key];
+        }
+        else {
+            result[key] = 1;
+        }
+    });
     return result;
 }