https://www.bruschet.fr/modules/ads_algolia_front/views/js/lib/lodash/4.17.11-npm/core.js

1/**
2 * @license
3 * Lodash (Custom Build) <https://lodash.com/>
4 * Build: `lodash core -o ./dist/lodash.core.js`
5 * Copyright JS Foundation and other contributors <https://js.foundation/>
6 * Released under MIT license <https://lodash.com/license>
7 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
8 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
9 */
10;(function() {
11
12    /** Used as a safe reference for `undefined` in pre-ES5 environments. */
13    var undefined;
14
15    /** Used as the semantic version number. */
16    var VERSION = '4.17.11';
17
18    /** Error message constants. */
19    var FUNC_ERROR_TEXT = 'Expected a function';
20
21    /** Used to compose bitmasks for value comparisons. */
22    var COMPARE_PARTIAL_FLAG = 1,
23        COMPARE_UNORDERED_FLAG = 2;
24
25    /** Used to compose bitmasks for function metadata. */
26    var WRAP_BIND_FLAG = 1,
27        WRAP_PARTIAL_FLAG = 32;
28
29    /** Used as references for various `Number` constants. */
30    var INFINITY = 1 / 0,
31        MAX_SAFE_INTEGER = 9007199254740991;
32
33    /** `Object#toString` result references. */
34    var argsTag = '[object Arguments]',
35        arrayTag = '[object Array]',
36        asyncTag = '[object AsyncFunction]',
37        boolTag = '[object Boolean]',
38        dateTag = '[object Date]',
39        errorTag = '[object Error]',
40        funcTag = '[object Function]',
41        genTag = '[object GeneratorFunction]',
42        numberTag = '[object Number]',
43        objectTag = '[object Object]',
44        proxyTag = '[object Proxy]',
45        regexpTag = '[object RegExp]',
46        stringTag = '[object String]';
47
48    /** Used to match HTML entities and HTML characters. */
49    var reUnescapedHtml = /[&<>"']/g,
50        reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
51
52    /** Used to detect unsigned integer values. */
53    var reIsUint = /^(?:0|[1-9]\d*)$/;
54
55    /** Used to map characters to HTML entities. */
56    var htmlEscapes = {
57        '&': '&amp;',
58        '<': '&lt;',
59        '>': '&gt;',
60        '"': '&quot;',
61        "'": '&#39;'
62    };
63
64    /** Detect free variable `global` from Node.js. */
65    var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
66
67    /** Detect free variable `self`. */
68    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
69
70    /** Used as a reference to the global object. */
71    var root = freeGlobal || freeSelf || Function('return this')();
72
73    /** Detect free variable `exports`. */
74    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
75
76    /** Detect free variable `module`. */
77    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
78
79    /*--------------------------------------------------------------------------*/
80
81    /**
82     * Appends the elements of `values` to `array`.
83     *
84     * @private
85     * @param {Array} array The array to modify.
86     * @param {Array} values The values to append.
87     * @returns {Array} Returns `array`.
88     */
89    function arrayPush(array, values) {
90        array.push.apply(array, values);
91        return array;
92    }
93
94    /**
95     * The base implementation of `_.findIndex` and `_.findLastIndex` without
96     * support for iteratee shorthands.
97     *
98     * @private
99     * @param {Array} array The array to inspect.
100     * @param {Function} predicate The function invoked per iteration.
101     * @param {number} fromIndex The index to search from.
102     * @param {boolean} [fromRight] Specify iterating from right to left.
103     * @returns {number} Returns the index of the matched value, else `-1`.
104     */
105    function baseFindIndex(array, predicate, fromIndex, fromRight) {
106        var length = array.length,
107            index = fromIndex + (fromRight ? 1 : -1);
108
109        while ((fromRight ? index-- : ++index < length)) {
110            if (predicate(array[index], index, array)) {
111                return index;
112            }
113        }
114        return -1;
115    }
116
117    /**
118     * The base implementation of `_.property` without support for deep paths.
119     *
120     * @private
121     * @param {string} key The key of the property to get.
122     * @returns {Function} Returns the new accessor function.
123     */
124    function baseProperty(key) {
125        return function(object) {
126            return object == null ? undefined : object[key];
127        };
128    }
129
130    /**
131     * The base implementation of `_.propertyOf` without support for deep paths.
132     *
133     * @private
134     * @param {Object} object The object to query.
135     * @returns {Function} Returns the new accessor function.
136     */
137    function basePropertyOf(object) {
138        return function(key) {
139            return object == null ? undefined : object[key];
140        };
141    }
142
143    /**
144     * The base implementation of `_.reduce` and `_.reduceRight`, without support
145     * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
146     *
147     * @private
148     * @param {Array|Object} collection The collection to iterate over.
149     * @param {Function} iteratee The function invoked per iteration.
150     * @param {*} accumulator The initial value.
151     * @param {boolean} initAccum Specify using the first or last element of
152     *  `collection` as the initial value.
153     * @param {Function} eachFunc The function to iterate over `collection`.
154     * @returns {*} Returns the accumulated value.
155     */
156    function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
157        eachFunc(collection, function(value, index, collection) {
158            accumulator = initAccum
159                ? (initAccum = false, value)
160                : iteratee(accumulator, value, index, collection);
161        });
162        return accumulator;
163    }
164
165    /**

443    function baseDelay(func, wait, args) {
444        if (typeof func != 'function') {
445            throw new TypeError(FUNC_ERROR_TEXT);
446        }
447        return setTimeout(function() { func.apply(undefined, args); }, wait);
448    }
449
450    /**
451     * The base implementation of `_.forEach` without support for iteratee shorthands.
452     *
453     * @private
454     * @param {Array|Object} collection The collection to iterate over.
455     * @param {Function} iteratee The function invoked per iteration.
456     * @returns {Array|Object} Returns `collection`.
457     */
458    var baseEach = createBaseEach(baseForOwn);
459
460    /**
461     * The base implementation of `_.every` without support for iteratee shorthands.
462     *
463     * @private
464     * @param {Array|Object} collection The collection to iterate over.
465     * @param {Function} predicate The function invoked per iteration.
466     * @returns {boolean} Returns `true` if all elements pass the predicate check,
467     *  else `false`
468     */
469    function baseEvery(collection, predicate) {
470        var result = true;
471        baseEach(collection, function(value, index, collection) {
472            result = !!predicate(value, index, collection);
473            return result;
474        });
475        return result;
476    }
477
478    /**
479     * The base implementation of methods like `_.max` and `_.min` which accepts a
480     * `comparator` to determine the extremum value.
481     *
482     * @private
483     * @param {Array} array The array to iterate over.
484     * @param {Function} iteratee The iteratee invoked per iteration.
485     * @param {Function} comparator The comparator used to compare values.
486     * @returns {*} Returns the extremum value.
487     */
488    function baseExtremum(array, iteratee, comparator) {
489        var index = -1,
490            length = array.length;
491
492        while (++index < length) {
493            var value = array[index],
494                current = iteratee(value);
495
496            if (current != null && (computed === undefined
497                    ? (current === current && !false)
498                    : comparator(current, computed)
499            )) {
500                var computed = current,
501                    result = value;
502            }
503        }
504        return result;
505    }
506
507    /**
508     * The base implementation of `_.filter` without support for iteratee shorthands.
509     *
510     * @private
511     * @param {Array|Object} collection The collection to iterate over.
512     * @param {Function} predicate The function invoked per iteration.
513     * @returns {Array} Returns the new filtered array.
514     */
515    function baseFilter(collection, predicate) {
516        var result = [];
517        baseEach(collection, function(value, index, collection) {
518            if (predicate(value, index, collection)) {
519                result.push(value);
520            }
521        });
522        return result;
523    }
524
525    /**
526     * The base implementation of `_.flatten` with support for restricting flattening.
527     *
528     * @private
529     * @param {Array} array The array to flatten.
530     * @param {number} depth The maximum recursion depth.
531     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
532     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
533     * @param {Array} [result=[]] The initial result value.
534     * @returns {Array} Returns the new flattened array.
535     */
536    function baseFlatten(array, depth, predicate, isStrict, result) {
537        var index = -1,
538            length = array.length;
539
540        predicate || (predicate = isFlattenable);
541        result || (result = []);
542
543        while (++index < length) {
544            var value = array[index];
545            if (depth > 0 && predicate(value)) {
546                if (depth > 1) {
547                    // Recursively flatten arrays (susceptible to call stack limits).
548                    baseFlatten(value, depth - 1, predicate, isStrict, result);
549                } else {
550                    arrayPush(result, value);
551                }
552            } else if (!isStrict) {
553                result[result.length] = value;
554            }
555        }
556        return result;
557    }
558
559    /**
560     * The base implementation of `baseForOwn` which iterates over `object`
561     * properties returned by `keysFunc` and invokes `iteratee` for each property.
562     * Iteratee functions may exit iteration early by explicitly returning `false`.
563     *
564     * @private
565     * @param {Object} object The object to iterate over.
566     * @param {Function} iteratee The function invoked per iteration.
567     * @param {Function} keysFunc The function to get the keys of `object`.
568     * @returns {Object} Returns `object`.
569     */
570    var baseFor = createBaseFor();
571
572    /**
573     * The base implementation of `_.forOwn` without support for iteratee shorthands.
574     *
575     * @private
576     * @param {Object} object The object to iterate over.
577     * @param {Function} iteratee The function invoked per iteration.
578     * @returns {Object} Returns `object`.
579     */
580    function baseForOwn(object, iteratee) {
581        return object && baseFor(object, iteratee, keys);
582    }
583
584    /**
585     * The base implementation of `_.functions` which creates an array of
586     * `object` function property names filtered from `props`.
587     *
588     * @private
589     * @param {Object} object The object to inspect.
590     * @param {Array} props The property names to filter.
591     * @returns {Array} Returns the function names.
592     */
593    function baseFunctions(object, props) {
594        return baseFilter(props, function(key) {
595            return isFunction(object[key]);
596        });
597    }
598
599    /**
600     * The base implementation of `getTag` without fallbacks for buggy environments.
601     *
602     * @private
603     * @param {*} value The value to query.
604     * @returns {string} Returns the `toStringTag`.
605     */
606    function baseGetTag(value) {
607        return objectToString(value);
608    }
609
610    /**
611     * The base implementation of `_.gt` which doesn't coerce arguments.
612     *
613     * @private
614     * @param {*} value The value to compare.
615     * @param {*} other The other value to compare.
616     * @returns {boolean} Returns `true` if `value` is greater than `other`,
617     *  else `false`.
618     */
619    function baseGt(value, other) {
620        return value > other;
621    }
622
623    /**
624     * The base implementation of `_.isArguments`.
625     *
626     * @private
627     * @param {*} value The value to check.
628     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
629     */
630    var baseIsArguments = noop;
631
632    /**
633     * The base implementation of `_.isDate` without Node.js optimizations.
634     *
635     * @private
636     * @param {*} value The value to check.
637     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
638     */
639    function baseIsDate(value) {
640        return isObjectLike(value) && baseGetTag(value) == dateTag;
641    }
642
643    /**
644     * The base implementation of `_.isEqual` which supports partial comparisons
645     * and tracks traversed objects.
646     *
647     * @private
648     * @param {*} value The value to compare.
649     * @param {*} other The other value to compare.
650     * @param {boolean} bitmask The bitmask flags.
651     *  1 - Unordered comparison
652     *  2 - Partial comparison
653     * @param {Function} [customizer] The function to customize comparisons.
654     * @param {Object} [stack] Tracks traversed `value` and `other` objects.
655     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
656     */
657    function baseIsEqual(value, other, bitmask, customizer, stack) {
658        if (value === other) {
659            return true;
660        }
661        if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
662            return value !== value && other !== other;
663        }
664        return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
665    }
666
667    /**
668     * A specialized version of `baseIsEqual` for arrays and objects which performs
669     * deep comparisons and tracks traversed objects enabling objects with circular
670     * references to be compared.
671     *
672     * @private
673     * @param {Object} object The object to compare.
674     * @param {Object} other The other object to compare.
675     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
676     * @param {Function} customizer The function to customize comparisons.
677     * @param {Function} equalFunc The function to determine equivalents of values.
678     * @param {Object} [stack] Tracks traversed `object` and `other` objects.
679     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
680     */
681    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
682        var objIsArr = isArray(object),
683            othIsArr = isArray(other),
684            objTag = objIsArr ? arrayTag : baseGetTag(object),
685            othTag = othIsArr ? arrayTag : baseGetTag(other);
686
687        objTag = objTag == argsTag ? objectTag : objTag;
688        othTag = othTag == argsTag ? objectTag : othTag;
689
690        var objIsObj = objTag == objectTag,
691            othIsObj = othTag == objectTag,
692            isSameTag = objTag == othTag;
693
694        stack || (stack = []);
695        var objStack = find(stack, function(entry) {
696            return entry[0] == object;
697        });
698        var othStack = find(stack, function(entry) {
699            return entry[0] == other;
700        });
701        if (objStack && othStack) {
702            return objStack[1] == other;
703        }
704        stack.push([object, other]);
705        stack.push([other, object]);
706        if (isSameTag && !objIsObj) {
707            var result = (objIsArr)
708                ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
709                : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
710            stack.pop();
711            return result;
712        }
713        if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
714            var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
715                othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
716
717            if (objIsWrapped || othIsWrapped) {
718                var objUnwrapped = objIsWrapped ? object.value() : object,
719                    othUnwrapped = othIsWrapped ? other.value() : other;
720
721                var result = equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
722                stack.pop();
723                return result;
724            }
725        }
726        if (!isSameTag) {
727            return false;
728        }
729        var result = equalObjects(object, other, bitmask, customizer, equalFunc, stack);
730        stack.pop();
731        return result;
732    }
733
734    /**
735     * The base implementation of `_.isRegExp` without Node.js optimizations.
736     *
737     * @private
738     * @param {*} value The value to check.
739     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
740     */
741    function baseIsRegExp(value) {
742        return isObjectLike(value) && baseGetTag(value) == regexpTag;
743    }
744
745    /**
746     * The base implementation of `_.iteratee`.
747     *
748     * @private
749     * @param {*} [value=_.identity] The value to convert to an iteratee.
750     * @returns {Function} Returns the iteratee.
751     */
752    function baseIteratee(func) {
753        if (typeof func == 'function') {
754            return func;
755        }
756        if (func == null) {
757            return identity;
758        }
759        return (typeof func == 'object' ? baseMatches : baseProperty)(func);
760    }
761
762    /**
763     * The base implementation of `_.lt` which doesn't coerce arguments.
764     *
765     * @private
766     * @param {*} value The value to compare.
767     * @param {*} other The other value to compare.
768     * @returns {boolean} Returns `true` if `value` is less than `other`,
769     *  else `false`.
770     */
771    function baseLt(value, other) {
772        return value < other;
773    }
774
775    /**
776     * The base implementation of `_.map` without support for iteratee shorthands.
777     *
778     * @private
779     * @param {Array|Object} collection The collection to iterate over.
780     * @param {Function} iteratee The function invoked per iteration.
781     * @returns {Array} Returns the new mapped array.
782     */
783    function baseMap(collection, iteratee) {
784        var index = -1,
785            result = isArrayLike(collection) ? Array(collection.length) : [];
786
787        baseEach(collection, function(value, key, collection) {
788            result[++index] = iteratee(value, key, collection);
789        });
790        return result;
791    }
792
793    /**
794     * The base implementation of `_.matches` which doesn't clone `source`.
795     *
796     * @private
797     * @param {Object} source The object of property values to match.
798     * @returns {Function} Returns the new spec function.
799     */
800    function baseMatches(source) {
801        var props = nativeKeys(source);
802        return function(object) {
803            var length = props.length;
804            if (object == null) {
805                return !length;
806            }
807            object = Object(object);
808            while (length--) {
809                var key = props[length];
810                if (!(key in object &&
811                    baseIsEqual(source[key], object[key], COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG)
812                )) {
813                    return false;
814                }
815            }
816            return true;
817        };
818    }
819
820    /**
821     * The base implementation of `_.pick` without support for individual
822     * property identifiers.
823     *
824     * @private
825     * @param {Object} object The source object.
826     * @param {string[]} paths The property paths to pick.
827     * @returns {Object} Returns the new object.
828     */
829    function basePick(object, props) {
830        object = Object(object);
831        return reduce(props, function(result, key) {
832            if (key in object) {
833                result[key] = object[key];
834            }
835            return result;
836        }, {});
837    }
838
839    /**
840     * The base implementation of `_.rest` which doesn't validate or coerce arguments.
841     *
842     * @private
843     * @param {Function} func The function to apply a rest parameter to.
844     * @param {number} [start=func.length-1] The start position of the rest parameter.
845     * @returns {Function} Returns the new function.
846     */
847    function baseRest(func, start) {
848        return setToString(overRest(func, start, identity), func + '');
849    }
850
851    /**
852     * The base implementation of `_.slice` without an iteratee call guard.
853     *
854     * @private
855     * @param {Array} array The array to slice.
856     * @param {number} [start=0] The start position.
857     * @param {number} [end=array.length] The end position.
858     * @returns {Array} Returns the slice of `array`.
859     */
860    function baseSlice(array, start, end) {
861        var index = -1,
862            length = array.length;
863
864        if (start < 0) {
865            start = -start > length ? 0 : (length + start);
866        }
867        end = end > length ? length : end;
868        if (end < 0) {
869            end += length;
870        }
871        length = start > end ? 0 : ((end - start) >>> 0);
872        start >>>= 0;
873
874        var result = Array(length);
875        while (++index < length) {
876            result[index] = array[index + start];
877        }
878        return result;
879    }
880
881    /**
882     * Copies the values of `source` to `array`.
883     *
884     * @private
885     * @param {Array} source The array to copy values from.
886     * @param {Array} [array=[]] The array to copy values to.
887     * @returns {Array} Returns `array`.
888     */
889    function copyArray(source) {
890        return baseSlice(source, 0, source.length);
891    }
892
893    /**
894     * The base implementation of `_.some` without support for iteratee shorthands.
895     *
896     * @private
897     * @param {Array|Object} collection The collection to iterate over.
898     * @param {Function} predicate The function invoked per iteration.
899     * @returns {boolean} Returns `true` if any element passes the predicate check,
900     *  else `false`.
901     */
902    function baseSome(collection, predicate) {
903        var result;
904
905        baseEach(collection, function(value, index, collection) {
906            result = predicate(value, index, collection);
907            return !result;
908        });
909        return !!result;
910    }
911
912    /**
913     * The base implementation of `wrapperValue` which returns the result of
914     * performing a sequence of actions on the unwrapped `value`, where each
915     * successive action is supplied the return value of the previous.
916     *
917     * @private
918     * @param {*} value The unwrapped value.
919     * @param {Array} actions Actions to perform to resolve the unwrapped value.
920     * @returns {*} Returns the resolved value.
921     */
922    function baseWrapperValue(value, actions) {
923        var result = value;
924        return reduce(actions, function(result, action) {
925            return action.func.apply(action.thisArg, arrayPush([result], action.args));
926        }, result);
927    }
928
929    /**
930     * Compares values to sort them in ascending order.
931     *
932     * @private
933     * @param {*} value The value to compare.
934     * @param {*} other The other value to compare.
935     * @returns {number} Returns the sort order indicator for `value`.
936     */
937    function compareAscending(value, other) {
938        if (value !== other) {
939            var valIsDefined = value !== undefined,
940                valIsNull = value === null,
941                valIsReflexive = value === value,
942                valIsSymbol = false;
943
944            var othIsDefined = other !== undefined,
945                othIsNull = other === null,
946                othIsReflexive = other === other,
947                othIsSymbol = false;
948
949            if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
950                (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
951                (valIsNull && othIsDefined && othIsReflexive) ||
952                (!valIsDefined && othIsReflexive) ||
953                !valIsReflexive) {
954                return 1;
955            }
956            if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
957                (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
958                (othIsNull && valIsDefined && valIsReflexive) ||
959                (!othIsDefined && valIsReflexive) ||
960                !othIsReflexive) {
961                return -1;
962            }
963        }
964        return 0;
965    }
966
967    /**
968     * Copies properties of `source` to `object`.
969     *
970     * @private
971     * @param {Object} source The object to copy properties from.
972     * @param {Array} props The property identifiers to copy.
973     * @param {Object} [object={}] The object to copy properties to.
974     * @param {Function} [customizer] The function to customize copied values.
975     * @returns {Object} Returns `object`.
976     */
977    function copyObject(source, props, object, customizer) {
978        var isNew = !object;
979        object || (object = {});
980
981        var index = -1,
982            length = props.length;
983
984        while (++index < length) {
985            var key = props[index];
986
987            var newValue = customizer
988                ? customizer(object[key], source[key], key, object, source)
989                : undefined;
990
991            if (newValue === undefined) {
992                newValue = source[key];
993            }
994            if (isNew) {
995                baseAssignValue(object, key, newValue);
996            } else {
997                assignValue(object, key, newValue);
998            }
999        }
1000        return object;
1001    }
1002
1003    /**
1004     * Creates a function like `_.assign`.
1005     *
1006     * @private
1007     * @param {Function} assigner The function to assign values.
1008     * @returns {Function} Returns the new assigner function.
1009     */
1010    function createAssigner(assigner) {
1011        return baseRest(function(object, sources) {
1012            var index = -1,
1013                length = sources.length,
1014                customizer = length > 1 ? sources[length - 1] : undefined;
1015
1016            customizer = (assigner.length > 3 && typeof customizer == 'function')
1017                ? (length--, customizer)
1018                : undefined;
1019
1020            object = Object(object);
1021            while (++index < length) {
1022                var source = sources[index];
1023                if (source) {
1024                    assigner(object, source, index, customizer);
1025                }
1026            }
1027            return object;
1028        });
1029    }
1030
1031    /**
1032     * Creates a `baseEach` or `baseEachRight` function.
1033     *
1034     * @private
1035     * @param {Function} eachFunc The function to iterate over a collection.
1036     * @param {boolean} [fromRight] Specify iterating from right to left.
1037     * @returns {Function} Returns the new base function.
1038     */
1039    function createBaseEach(eachFunc, fromRight) {
1040        return function(collection, iteratee) {
1041            if (collection == null) {
1042                return collection;
1043            }
1044            if (!isArrayLike(collection)) {
1045                return eachFunc(collection, iteratee);
1046            }
1047            var length = collection.length,
1048                index = fromRight ? length : -1,
1049                iterable = Object(collection);
1050
1051            while ((fromRight ? index-- : ++index < length)) {
1052                if (iteratee(iterable[index], index, iterable) === false) {
1053                    break;
1054                }
1055            }
1056            return collection;
1057        };
1058    }
1059
1060    /**
1061     * Creates a base function for methods like `_.forIn` and `_.forOwn`.
1062     *
1063     * @private
1064     * @param {boolean} [fromRight] Specify iterating from right to left.
1065     * @returns {Function} Returns the new base function.
1066     */
1067    function createBaseFor(fromRight) {
1068        return function(object, iteratee, keysFunc) {
1069            var index = -1,
1070                iterable = Object(object),
1071                props = keysFunc(object),
1072                length = props.length;
1073
1074            while (length--) {
1075                var key = props[fromRight ? length : ++index];
1076                if (iteratee(iterable[key], key, iterable) === false) {
1077                    break;
1078                }
1079            }
1080            return object;
1081        };
1082    }
1083
1084    /**
1085     * Creates a function that produces an instance of `Ctor` regardless of
1086     * whether it was invoked as part of a `new` expression or by `call` or `apply`.
1087     *
1088     * @private
1089     * @param {Function} Ctor The constructor to wrap.
1090     * @returns {Function} Returns the new wrapped function.
1091     */
1092    function createCtor(Ctor) {
1093        return function() {
1094            // Use a `switch` statement to work with class constructors. See
1095            // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
1096            // for more details.
1097            var args = arguments;
1098            var thisBinding = baseCreate(Ctor.prototype),
1099                result = Ctor.apply(thisBinding, args);
1100
1101            // Mimic the constructor's `return` behavior.
1102            // See https://es5.github.io/#x13.2.2 for more details.
1103            return isObject(result) ? result : thisBinding;
1104        };
1105    }
1106
1107    /**
1108     * Creates a `_.find` or `_.findLast` function.
1109     *
1110     * @private
1111     * @param {Function} findIndexFunc The function to find the collection index.
1112     * @returns {Function} Returns the new find function.
1113     */
1114    function createFind(findIndexFunc) {
1115        return function(collection, predicate, fromIndex) {
1116            var iterable = Object(collection);
1117            if (!isArrayLike(collection)) {
1118                var iteratee = baseIteratee(predicate, 3);
1119                collection = keys(collection);
1120                predicate = function(key) { return iteratee(iterable[key], key, iterable); };
1121            }
1122            var index = findIndexFunc(collection, predicate, fromIndex);
1123            return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
1124        };
1125    }
1126
1127    /**
1128     * Creates a function that wraps `func` to invoke it with the `this` binding
1129     * of `thisArg` and `partials` prepended to the arguments it receives.
1130     *
1131     * @private
1132     * @param {Function} func The function to wrap.
1133     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
1134     * @param {*} thisArg The `this` binding of `func`.
1135     * @param {Array} partials The arguments to prepend to those provided to
1136     *  the new function.
1137     * @returns {Function} Returns the new wrapped function.
1138     */
1139    function createPartial(func, bitmask, thisArg, partials) {
1140        if (typeof func != 'function') {
1141            throw new TypeError(FUNC_ERROR_TEXT);
1142        }
1143        var isBind = bitmask & WRAP_BIND_FLAG,
1144            Ctor = createCtor(func);
1145
1146        function wrapper() {
1147            var argsIndex = -1,
1148                argsLength = arguments.length,
1149                leftIndex = -1,
1150                leftLength = partials.length,
1151                args = Array(leftLength + argsLength),
1152                fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
1153
1154            while (++leftIndex < leftLength) {
1155                args[leftIndex] = partials[leftIndex];
1156            }
1157            while (argsLength--) {
1158                args[leftIndex++] = arguments[++argsIndex];
1159            }
1160            return fn.apply(isBind ? thisArg : this, args);
1161        }
1162        return wrapper;
1163    }
1164
1165    /**
1166     * A specialized version of `baseIsEqualDeep` for arrays with support for
1167     * partial deep comparisons.
1168     *
1169     * @private
1170     * @param {Array} array The array to compare.
1171     * @param {Array} other The other array to compare.
1172     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
1173     * @param {Function} customizer The function to customize comparisons.
1174     * @param {Function} equalFunc The function to determine equivalents of values.
1175     * @param {Object} stack Tracks traversed `array` and `other` objects.
1176     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
1177     */
1178    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
1179        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
1180            arrLength = array.length,
1181            othLength = other.length;
1182
1183        if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
1184            return false;
1185        }
1186        var index = -1,
1187            result = true,
1188            seen = (bitmask & COMPARE_UNORDERED_FLAG) ? [] : undefined;
1189
1190        // Ignore non-index properties.
1191        while (++index < arrLength) {
1192            var arrValue = array[index],
1193                othValue = other[index];
1194
1195            var compared;
1196            if (compared !== undefined) {
1197                if (compared) {
1198                    continue;
1199                }
1200                result = false;
1201                break;
1202            }
1203            // Recursively compare arrays (susceptible to call stack limits).
1204            if (seen) {
1205                if (!baseSome(other, function(othValue, othIndex) {
1206                    if (!indexOf(seen, othIndex) &&
1207                        (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
1208                        return seen.push(othIndex);
1209                    }
1210                })) {
1211                    result = false;
1212                    break;
1213                }
1214            } else if (!(
1215                arrValue === othValue ||
1216                equalFunc(arrValue, othValue, bitmask, customizer, stack)
1217            )) {
1218                result = false;
1219                break;
1220            }
1221        }
1222        return result;
1223    }
1224
1225    /**
1226     * A specialized version of `baseIsEqualDeep` for comparing objects of
1227     * the same `toStringTag`.
1228     *
1229     * **Note:** This function only supports comparing values with tags of
1230     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
1231     *
1232     * @private
1233     * @param {Object} object The object to compare.
1234     * @param {Object} other The other object to compare.
1235     * @param {string} tag The `toStringTag` of the objects to compare.
1236     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
1237     * @param {Function} customizer The function to customize comparisons.
1238     * @param {Function} equalFunc The function to determine equivalents of values.
1239     * @param {Object} stack Tracks traversed `object` and `other` objects.
1240     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
1241     */
1242    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
1243        switch (tag) {
1244
1245            case boolTag:
1246            case dateTag:
1247            case numberTag:
1248                // Coerce booleans to `1` or `0` and dates to milliseconds.
1249                // Invalid dates are coerced to `NaN`.
1250                return eq(+object, +other);
1251
1252            case errorTag:
1253                return object.name == other.name && object.message == other.message;
1254
1255            case regexpTag:
1256            case stringTag:
1257                // Coerce regexes to strings and treat strings, primitives and objects,
1258                // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
1259                // for more details.
1260                return object == (other + '');
1261
1262        }
1263        return false;
1264    }
1265
1266    /**
1267     * A specialized version of `baseIsEqualDeep` for objects with support for
1268     * partial deep comparisons.
1269     *
1270     * @private
1271     * @param {Object} object The object to compare.
1272     * @param {Object} other The other object to compare.
1273     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
1274     * @param {Function} customizer The function to customize comparisons.
1275     * @param {Function} equalFunc The function to determine equivalents of values.
1276     * @param {Object} stack Tracks traversed `object` and `other` objects.
1277     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
1278     */
1279    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
1280        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
1281            objProps = keys(object),
1282            objLength = objProps.length,
1283            othProps = keys(other),
1284            othLength = othProps.length;
1285
1286        if (objLength != othLength && !isPartial) {
1287            return false;
1288        }
1289        var index = objLength;
1290        while (index--) {
1291            var key = objProps[index];
1292            if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
1293                return false;
1294            }
1295        }
1296        var result = true;
1297
1298        var skipCtor = isPartial;
1299        while (++index < objLength) {
1300            key = objProps[index];
1301            var objValue = object[key],
1302                othValue = other[key];
1303
1304            var compared;
1305            // Recursively compare objects (susceptible to call stack limits).
1306            if (!(compared === undefined
1307                    ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
1308                    : compared
1309            )) {
1310                result = false;
1311                break;
1312            }
1313            skipCtor || (skipCtor = key == 'constructor');
1314        }
1315        if (result && !skipCtor) {
1316            var objCtor = object.constructor,
1317                othCtor = other.constructor;
1318
1319            // Non `Object` object instances with different constructors are not equal.
1320            if (objCtor != othCtor &&
1321                ('constructor' in object && 'constructor' in other) &&
1322                !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
1323                    typeof othCtor == 'function' && othCtor instanceof othCtor)) {
1324                result = false;
1325            }
1326        }
1327        return result;
1328    }
1329
1330    /**
1331     * A specialized version of `baseRest` which flattens the rest array.
1332     *
1333     * @private
1334     * @param {Function} func The function to apply a rest parameter to.
1335     * @returns {Function} Returns the new function.
1336     */
1337    function flatRest(func) {
1338        return setToString(overRest(func, undefined, flatten), func + '');
1339    }
1340
1341    /**
1342     * Checks if `value` is a flattenable `arguments` object or array.
1343     *
1344     * @private
1345     * @param {*} value The value to check.
1346     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
1347     */
1348    function isFlattenable(value) {
1349        return isArray(value) || isArguments(value);
1350    }
1351
1352    /**
1353     * Checks if `value` is a valid array-like index.
1354     *
1355     * @private
1356     * @param {*} value The value to check.
1357     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
1358     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
1359     */
1360    function isIndex(value, length) {
1361        var type = typeof value;
1362        length = length == null ? MAX_SAFE_INTEGER : length;
1363
1364        return !!length &&
1365            (type == 'number' ||
1366                (type != 'symbol' && reIsUint.test(value))) &&
1367            (value > -1 && value % 1 == 0 && value < length);
1368    }
1369
1370    /**
1371     * Checks if the given arguments are from an iteratee call.
1372     *
1373     * @private
1374     * @param {*} value The potential iteratee value argument.
1375     * @param {*} index The potential iteratee index or key argument.
1376     * @param {*} object The potential iteratee object argument.
1377     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
1378     *  else `false`.
1379     */
1380    function isIterateeCall(value, index, object) {
1381        if (!isObject(object)) {
1382            return false;
1383        }
1384        var type = typeof index;
1385        if (type == 'number'
1386            ? (isArrayLike(object) && isIndex(index, object.length))
1387            : (type == 'string' && index in object)
1388        ) {
1389            return eq(object[index], value);
1390        }
1391        return false;
1392    }
1393
1394    /**
1395     * This function is like
1396     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
1397     * except that it includes inherited enumerable properties.
1398     *
1399     * @private
1400     * @param {Object} object The object to query.
1401     * @returns {Array} Returns the array of property names.
1402     */
1403    function nativeKeysIn(object) {
1404        var result = [];
1405        if (object != null) {
1406            for (var key in Object(object)) {
1407                result.push(key);
1408            }
1409        }
1410        return result;
1411    }
1412
1413    /**
1414     * Converts `value` to a string using `Object.prototype.toString`.
1415     *
1416     * @private
1417     * @param {*} value The value to convert.
1418     * @returns {string} Returns the converted string.
1419     */
1420    function objectToString(value) {
1421        return nativeObjectToString.call(value);
1422    }
1423
1424    /**
1425     * A specialized version of `baseRest` which transforms the rest array.
1426     *
1427     * @private
1428     * @param {Function} func The function to apply a rest parameter to.
1429     * @param {number} [start=func.length-1] The start position of the rest parameter.
1430     * @param {Function} transform The rest array transform.
1431     * @returns {Function} Returns the new function.
1432     */
1433    function overRest(func, start, transform) {
1434        start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
1435        return function() {
1436            var args = arguments,
1437                index = -1,
1438                length = nativeMax(args.length - start, 0),
1439                array = Array(length);
1440
1441            while (++index < length) {
1442                array[index] = args[start + index];
1443            }
1444            index = -1;
1445            var otherArgs = Array(start + 1);
1446            while (++index < start) {
1447                otherArgs[index] = args[index];
1448            }
1449            otherArgs[start] = transform(array);
1450            return func.apply(this, otherArgs);
1451        };
1452    }
1453
1454    /**
1455     * Sets the `toString` method of `func` to return `string`.
1456     *
1457     * @private
1458     * @param {Function} func The function to modify.
1459     * @param {Function} string The `toString` result.
1460     * @returns {Function} Returns `func`.
1461     */
1462    var setToString = identity;
1463
1464    /*------------------------------------------------------------------------*/
1465
1466    /**
1467     * Creates an array with all falsey values removed. The values `false`, `null`,
1468     * `0`, `""`, `undefined`, and `NaN` are falsey.
1469     *
1470     * @static
1471     * @memberOf _
1472     * @since 0.1.0
1473     * @category Array
1474     * @param {Array} array The array to compact.
1475     * @returns {Array} Returns the new array of filtered values.
1476     * @example
1477     *
1478     * _.compact([0, 1, false, 2, '', 3]);
1479     * // => [1, 2, 3]
1480     */
1481    function compact(array) {
1482        return baseFilter(array, Boolean);
1483    }
1484
1485    /**
1486     * Creates a new array concatenating `array` with any additional arrays
1487     * and/or values.
1488     *
1489     * @static
1490     * @memberOf _
1491     * @since 4.0.0
1492     * @category Array
1493     * @param {Array} array The array to concatenate.
1494     * @param {...*} [values] The values to concatenate.
1495     * @returns {Array} Returns the new concatenated array.
1496     * @example
1497     *
1498     * var array = [1];
1499     * var other = _.concat(array, 2, [3], [[4]]);
1500     *
1501     * console.log(other);
1502     * // => [1, 2, 3, [4]]
1503     *
1504     * console.log(array);
1505     * // => [1]
1506     */
1507    function concat() {
1508        var length = arguments.length;
1509        if (!length) {
1510            return [];
1511        }
1512        var args = Array(length - 1),
1513            array = arguments[0],
1514            index = length;
1515
1516        while (index--) {
1517            args[index - 1] = arguments[index];
1518        }
1519        return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
1520    }
1521
1522    /**
1523     * This method is like `_.find` except that it returns the index of the first
1524     * element `predicate` returns truthy for instead of the element itself.
1525     *
1526     * @static
1527     * @memberOf _
1528     * @since 1.1.0
1529     * @category Array
1530     * @param {Array} array The array to inspect.
1531     * @param {Function} [predicate=_.identity] The function invoked per iteration.
1532     * @param {number} [fromIndex=0] The index to search from.
1533     * @returns {number} Returns the index of the found element, else `-1`.
1534     * @example
1535     *
1536     * var users = [
1537     *   { 'user': 'barney',  'active': false },
1538     *   { 'user': 'fred',    'active': false },
1539     *   { 'user': 'pebbles', 'active': true }
1540     * ];
1541     *
1542     * _.findIndex(users, function(o) { return o.user == 'barney'; });
1543     * // => 0
1544     *
1545     * // The `_.matches` iteratee shorthand.
1546     * _.findIndex(users, { 'user': 'fred', 'active': false });
1547     * // => 1
1548     *
1549     * // The `_.matchesProperty` iteratee shorthand.
1550     * _.findIndex(users, ['active', false]);
1551     * // => 0
1552     *
1553     * // The `_.property` iteratee shorthand.
1554     * _.findIndex(users, 'active');
1555     * // => 2
1556     */
1557    function findIndex(array, predicate, fromIndex) {
1558        var length = array == null ? 0 : array.length;
1559        if (!length) {
1560            return -1;
1561        }
1562        var index = fromIndex == null ? 0 : toInteger(fromIndex);
1563        if (index < 0) {
1564            index = nativeMax(length + index, 0);
1565        }
1566        return baseFindIndex(array, baseIteratee(predicate, 3), index);
1567    }
1568
1569    /**
1570     * Flattens `array` a single level deep.
1571     *
1572     * @static
1573     * @memberOf _
1574     * @since 0.1.0
1575     * @category Array
1576     * @param {Array} array The array to flatten.
1577     * @returns {Array} Returns the new flattened array.
1578     * @example
1579     *
1580     * _.flatten([1, [2, [3, [4]], 5]]);
1581     * // => [1, 2, [3, [4]], 5]
1582     */
1583    function flatten(array) {
1584        var length = array == null ? 0 : array.length;
1585        return length ? baseFlatten(array, 1) : [];
1586    }
1587
1588    /**
1589     * Recursively flattens `array`.
1590     *
1591     * @static
1592     * @memberOf _
1593     * @since 3.0.0
1594     * @category Array
1595     * @param {Array} array The array to flatten.
1596     * @returns {Array} Returns the new flattened array.
1597     * @example
1598     *
1599     * _.flattenDeep([1, [2, [3, [4]], 5]]);
1600     * // => [1, 2, 3, 4, 5]
1601     */
1602    function flattenDeep(array) {
1603        var length = array == null ? 0 : array.length;
1604        return length ? baseFlatten(array, INFINITY) : [];
1605    }
1606
1607    /**
1608     * Gets the first element of `array`.
1609     *
1610     * @static
1611     * @memberOf _
1612     * @since 0.1.0
1613     * @alias first
1614     * @category Array
1615     * @param {Array} array The array to query.
1616     * @returns {*} Returns the first element of `array`.
1617     * @example
1618     *
1619     * _.head([1, 2, 3]);
1620     * // => 1
1621     *
1622     * _.head([]);
1623     * // => undefined
1624     */
1625    function head(array) {
1626        return (array && array.length) ? array[0] : undefined;
1627    }
1628
1629    /**
1630     * Gets the index at which the first occurrence of `value` is found in `array`
1631     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
1632     * for equality comparisons. If `fromIndex` is negative, it's used as the
1633     * offset from the end of `array`.
1634     *
1635     * @static
1636     * @memberOf _
1637     * @since 0.1.0
1638     * @category Array
1639     * @param {Array} array The array to inspect.
1640     * @param {*} value The value to search for.
1641     * @param {number} [fromIndex=0] The index to search from.
1642     * @returns {number} Returns the index of the matched value, else `-1`.
1643     * @example
1644     *
1645     * _.indexOf([1, 2, 1, 2], 2);
1646     * // => 1
1647     *
1648     * // Search from the `fromIndex`.
1649     * _.indexOf([1, 2, 1, 2], 2, 2);
1650     * // => 3
1651     */
1652    function indexOf(array, value, fromIndex) {
1653        var length = array == null ? 0 : array.length;
1654        if (typeof fromIndex == 'number') {
1655            fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : fromIndex;
1656        } else {
1657            fromIndex = 0;
1658        }
1659        var index = (fromIndex || 0) - 1,
1660            isReflexive = value === value;
1661
1662        while (++index < length) {
1663            var other = array[index];
1664            if ((isReflexive ? other === value : other !== other)) {
1665                return index;
1666            }
1667        }
1668        return -1;
1669    }
1670
1671    /**
1672     * Gets the last element of `array`.
1673     *
1674     * @static
1675     * @memberOf _
1676     * @since 0.1.0
1677     * @category Array
1678     * @param {Array} array The array to query.
1679     * @returns {*} Returns the last element of `array`.
1680     * @example
1681     *
1682     * _.last([1, 2, 3]);
1683     * // => 3
1684     */
1685    function last(array) {
1686        var length = array == null ? 0 : array.length;
1687        return length ? array[length - 1] : undefined;
1688    }
1689
1690    /**
1691     * Creates a slice of `array` from `start` up to, but not including, `end`.
1692     *
1693     * **Note:** This method is used instead of
1694     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
1695     * returned.
1696     *
1697     * @static
1698     * @memberOf _
1699     * @since 3.0.0
1700     * @category Array
1701     * @param {Array} array The array to slice.
1702     * @param {number} [start=0] The start position.
1703     * @param {number} [end=array.length] The end position.
1704     * @returns {Array} Returns the slice of `array`.
1705     */
1706    function slice(array, start, end) {
1707        var length = array == null ? 0 : array.length;
1708        start = start == null ? 0 : +start;
1709        end = end === undefined ? length : +end;
1710        return length ? baseSlice(array, start, end) : [];
1711    }
1712
1713    /*------------------------------------------------------------------------*/
1714
1715    /**
1716     * Creates a `lodash` wrapper instance that wraps `value` with explicit method
1717     * chain sequences enabled. The result of such sequences must be unwrapped
1718     * with `_#value`.
1719     *
1720     * @static
1721     * @memberOf _
1722     * @since 1.3.0
1723     * @category Seq
1724     * @param {*} value The value to wrap.
1725     * @returns {Object} Returns the new `lodash` wrapper instance.
1726     * @example
1727     *
1728     * var users = [
1729     *   { 'user': 'barney',  'age': 36 },
1730     *   { 'user': 'fred',    'age': 40 },
1731     *   { 'user': 'pebbles', 'age': 1 }
1732     * ];
1733     *
1734     * var youngest = _
1735     *   .chain(users)
1736     *   .sortBy('age')
1737     *   .map(function(o) {
1738     *     return o.user + ' is ' + o.age;
1739     *   })
1740     *   .head()
1741     *   .value();
1742     * // => 'pebbles is 1'
1743     */
1744    function chain(value) {
1745        var result = lodash(value);
1746        result.__chain__ = true;
1747        return result;
1748    }
1749
1750    /**
1751     * This method invokes `interceptor` and returns `value`. The interceptor
1752     * is invoked with one argument; (value). The purpose of this method is to
1753     * "tap into" a method chain sequence in order to modify intermediate results.
1754     *
1755     * @static
1756     * @memberOf _
1757     * @since 0.1.0
1758     * @category Seq
1759     * @param {*} value The value to provide to `interceptor`.
1760     * @param {Function} interceptor The function to invoke.
1761     * @returns {*} Returns `value`.
1762     * @example
1763     *
1764     * _([1, 2, 3])
1765     *  .tap(function(array) {
1766     *    // Mutate input array.
1767     *    array.pop();
1768     *  })
1769     *  .reverse()
1770     *  .value();
1771     * // => [2, 1]
1772     */
1773    function tap(value, interceptor) {
1774        interceptor(value);
1775        return value;
1776    }
1777
1778    /**
1779     * This method is like `_.tap` except that it returns the result of `interceptor`.
1780     * The purpose of this method is to "pass thru" values replacing intermediate
1781     * results in a method chain sequence.
1782     *
1783     * @static
1784     * @memberOf _
1785     * @since 3.0.0
1786     * @category Seq
1787     * @param {*} value The value to provide to `interceptor`.
1788     * @param {Function} interceptor The function to invoke.
1789     * @returns {*} Returns the result of `interceptor`.
1790     * @example
1791     *
1792     * _('  abc  ')
1793     *  .chain()
1794     *  .trim()
1795     *  .thru(function(value) {
1796     *    return [value];
1797     *  })
1798     *  .value();
1799     * // => ['abc']
1800     */
1801    function thru(value, interceptor) {
1802        return interceptor(value);
1803    }
1804
1805    /**
1806     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
1807     *
1808     * @name chain
1809     * @memberOf _
1810     * @since 0.1.0
1811     * @category Seq
1812     * @returns {Object} Returns the new `lodash` wrapper instance.
1813     * @example
1814     *
1815     * var users = [
1816     *   { 'user': 'barney', 'age': 36 },
1817     *   { 'user': 'fred',   'age': 40 }
1818     * ];
1819     *
1820     * // A sequence without explicit chaining.
1821     * _(users).head();
1822     * // => { 'user': 'barney', 'age': 36 }
1823     *
1824     * // A sequence with explicit chaining.
1825     * _(users)
1826     *   .chain()
1827     *   .head()
1828     *   .pick('user')
1829     *   .value();
1830     * // => { 'user': 'barney' }
1831     */
1832    function wrapperChain() {
1833        return chain(this);
1834    }
1835
1836    /**
1837     * Executes the chain sequence to resolve the unwrapped value.
1838     *
1839     * @name value
1840     * @memberOf _
1841     * @since 0.1.0
1842     * @alias toJSON, valueOf
1843     * @category Seq
1844     * @returns {*} Returns the resolved unwrapped value.
1845     * @example
1846     *

2328    var delay = baseRest(function(func, wait, args) {
2329        return baseDelay(func, toNumber(wait) || 0, args);
2330    });
2331
2332    /**
2333     * Creates a function that negates the result of the predicate `func`. The
2334     * `func` predicate is invoked with the `this` binding and arguments of the
2335     * created function.
2336     *
2337     * @static
2338     * @memberOf _
2339     * @since 3.0.0
2340     * @category Function
2341     * @param {Function} predicate The predicate to negate.
2342     * @returns {Function} Returns the new negated function.
2343     * @example
2344     *
2345     * function isEven(n) {
2346     *   return n % 2 == 0;
2347     * }
2348     *
2349     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
2350     * // => [1, 3, 5]
2351     */
2352    function negate(predicate) {
2353        if (typeof predicate != 'function') {
2354            throw new TypeError(FUNC_ERROR_TEXT);
2355        }
2356        return function() {
2357            var args = arguments;
2358            return !predicate.apply(this, args);
2359        };
2360    }
2361
2362    /**
2363     * Creates a function that is restricted to invoking `func` once. Repeat calls
2364     * to the function return the value of the first invocation. The `func` is
2365     * invoked with the `this` binding and arguments of the created function.
2366     *
2367     * @static
2368     * @memberOf _
2369     * @since 0.1.0
2370     * @category Function
2371     * @param {Function} func The function to restrict.
2372     * @returns {Function} Returns the new restricted function.
2373     * @example
2374     *
2375     * var initialize = _.once(createApplication);
2376     * initialize();
2377     * initialize();
2378     * // => `createApplication` is invoked once
2379     */
2380    function once(func) {
2381        return before(2, func);
2382    }
2383
2384    /*------------------------------------------------------------------------*/
2385
2386    /**
2387     * Creates a shallow clone of `value`.
2388     *
2389     * **Note:** This method is loosely based on the
2390     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
2391     * and supports cloning arrays, array buffers, booleans, date objects, maps,
2392     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
2393     * arrays. The own enumerable properties of `arguments` objects are cloned
2394     * as plain objects. An empty object is returned for uncloneable values such
2395     * as error objects, functions, DOM nodes, and WeakMaps.
2396     *
2397     * @static
2398     * @memberOf _
2399     * @since 0.1.0
2400     * @category Lang
2401     * @param {*} value The value to clone.
2402     * @returns {*} Returns the cloned value.
2403     * @see _.cloneDeep
2404     * @example
2405     *
2406     * var objects = [{ 'a': 1 }, { 'b': 2 }];
2407     *
2408     * var shallow = _.clone(objects);
2409     * console.log(shallow[0] === objects[0]);
2410     * // => true
2411     */
2412    function clone(value) {
2413        if (!isObject(value)) {
2414            return value;
2415        }
2416        return isArray(value) ? copyArray(value) : copyObject(value, nativeKeys(value));
2417    }
2418
2419    /**
2420     * Performs a
2421     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2422     * comparison between two values to determine if they are equivalent.
2423     *
2424     * @static
2425     * @memberOf _
2426     * @since 4.0.0
2427     * @category Lang
2428     * @param {*} value The value to compare.
2429     * @param {*} other The other value to compare.
2430     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
2431     * @example
2432     *
2433     * var object = { 'a': 1 };
2434     * var other = { 'a': 1 };
2435     *
2436     * _.eq(object, object);
2437     * // => true
2438     *
2439     * _.eq(object, other);
2440     * // => false
2441     *
2442     * _.eq('a', 'a');
2443     * // => true
2444     *
2445     * _.eq('a', Object('a'));
2446     * // => false
2447     *
2448     * _.eq(NaN, NaN);
2449     * // => true
2450     */
2451    function eq(value, other) {
2452        return value === other || (value !== value && other !== other);
2453    }
2454
2455    /**
2456     * Checks if `value` is likely an `arguments` object.
2457     *
2458     * @static
2459     * @memberOf _
2460     * @since 0.1.0
2461     * @category Lang
2462     * @param {*} value The value to check.
2463     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
2464     *  else `false`.
2465     * @example
2466     *
2467     * _.isArguments(function() { return arguments; }());
2468     * // => true
2469     *
2470     * _.isArguments([1, 2, 3]);
2471     * // => false
2472     */
2473    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
2474        return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
2475            !propertyIsEnumerable.call(value, 'callee');
2476    };
2477
2478    /**
2479     * Checks if `value` is classified as an `Array` object.
2480     *
2481     * @static
2482     * @memberOf _
2483     * @since 0.1.0
2484     * @category Lang
2485     * @param {*} value The value to check.
2486     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
2487     * @example
2488     *
2489     * _.isArray([1, 2, 3]);
2490     * // => true
2491     *
2492     * _.isArray(document.body.children);
2493     * // => false
2494     *
2495     * _.isArray('abc');
2496     * // => false
2497     *
2498     * _.isArray(_.noop);
2499     * // => false
2500     */
2501    var isArray = Array.isArray;
2502
2503    /**
2504     * Checks if `value` is array-like. A value is considered array-like if it's
2505     * not a function and has a `value.length` that's an integer greater than or
2506     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
2507     *
2508     * @static
2509     * @memberOf _
2510     * @since 4.0.0
2511     * @category Lang
2512     * @param {*} value The value to check.
2513     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
2514     * @example
2515     *
2516     * _.isArrayLike([1, 2, 3]);
2517     * // => true
2518     *
2519     * _.isArrayLike(document.body.children);
2520     * // => true
2521     *
2522     * _.isArrayLike('abc');
2523     * // => true
2524     *
2525     * _.isArrayLike(_.noop);
2526     * // => false
2527     */
2528    function isArrayLike(value) {
2529        return value != null && isLength(value.length) && !isFunction(value);
2530    }
2531
2532    /**
2533     * Checks if `value` is classified as a boolean primitive or object.
2534     *
2535     * @static
2536     * @memberOf _
2537     * @since 0.1.0
2538     * @category Lang
2539     * @param {*} value The value to check.
2540     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
2541     * @example
2542     *
2543     * _.isBoolean(false);
2544     * // => true
2545     *
2546     * _.isBoolean(null);
2547     * // => false
2548     */
2549    function isBoolean(value) {
2550        return value === true || value === false ||
2551            (isObjectLike(value) && baseGetTag(value) == boolTag);
2552    }
2553
2554    /**
2555     * Checks if `value` is classified as a `Date` object.
2556     *
2557     * @static
2558     * @memberOf _
2559     * @since 0.1.0
2560     * @category Lang
2561     * @param {*} value The value to check.
2562     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
2563     * @example
2564     *
2565     * _.isDate(new Date);
2566     * // => true
2567     *
2568     * _.isDate('Mon April 23 2012');
2569     * // => false
2570     */
2571    var isDate = baseIsDate;
2572
2573    /**
2574     * Checks if `value` is an empty object, collection, map, or set.
2575     *
2576     * Objects are considered empty if they have no own enumerable str