[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/vendor/ -> lodash.js (source)

   1  /**
   2   * @license
   3   * Lodash <https://lodash.com/>
   4   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
   5   * Released under MIT license <https://lodash.com/license>
   6   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   7   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   8   */
   9  ;(function() {
  10  
  11    /** Used as a safe reference for `undefined` in pre-ES5 environments. */
  12    var undefined;
  13  
  14    /** Used as the semantic version number. */
  15    var VERSION = '4.17.15';
  16  
  17    /** Used as the size to enable large array optimizations. */
  18    var LARGE_ARRAY_SIZE = 200;
  19  
  20    /** Error message constants. */
  21    var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
  22        FUNC_ERROR_TEXT = 'Expected a function';
  23  
  24    /** Used to stand-in for `undefined` hash values. */
  25    var HASH_UNDEFINED = '__lodash_hash_undefined__';
  26  
  27    /** Used as the maximum memoize cache size. */
  28    var MAX_MEMOIZE_SIZE = 500;
  29  
  30    /** Used as the internal argument placeholder. */
  31    var PLACEHOLDER = '__lodash_placeholder__';
  32  
  33    /** Used to compose bitmasks for cloning. */
  34    var CLONE_DEEP_FLAG = 1,
  35        CLONE_FLAT_FLAG = 2,
  36        CLONE_SYMBOLS_FLAG = 4;
  37  
  38    /** Used to compose bitmasks for value comparisons. */
  39    var COMPARE_PARTIAL_FLAG = 1,
  40        COMPARE_UNORDERED_FLAG = 2;
  41  
  42    /** Used to compose bitmasks for function metadata. */
  43    var WRAP_BIND_FLAG = 1,
  44        WRAP_BIND_KEY_FLAG = 2,
  45        WRAP_CURRY_BOUND_FLAG = 4,
  46        WRAP_CURRY_FLAG = 8,
  47        WRAP_CURRY_RIGHT_FLAG = 16,
  48        WRAP_PARTIAL_FLAG = 32,
  49        WRAP_PARTIAL_RIGHT_FLAG = 64,
  50        WRAP_ARY_FLAG = 128,
  51        WRAP_REARG_FLAG = 256,
  52        WRAP_FLIP_FLAG = 512;
  53  
  54    /** Used as default options for `_.truncate`. */
  55    var DEFAULT_TRUNC_LENGTH = 30,
  56        DEFAULT_TRUNC_OMISSION = '...';
  57  
  58    /** Used to detect hot functions by number of calls within a span of milliseconds. */
  59    var HOT_COUNT = 800,
  60        HOT_SPAN = 16;
  61  
  62    /** Used to indicate the type of lazy iteratees. */
  63    var LAZY_FILTER_FLAG = 1,
  64        LAZY_MAP_FLAG = 2,
  65        LAZY_WHILE_FLAG = 3;
  66  
  67    /** Used as references for various `Number` constants. */
  68    var INFINITY = 1 / 0,
  69        MAX_SAFE_INTEGER = 9007199254740991,
  70        MAX_INTEGER = 1.7976931348623157e+308,
  71        NAN = 0 / 0;
  72  
  73    /** Used as references for the maximum length and index of an array. */
  74    var MAX_ARRAY_LENGTH = 4294967295,
  75        MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
  76        HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
  77  
  78    /** Used to associate wrap methods with their bit flags. */
  79    var wrapFlags = [
  80      ['ary', WRAP_ARY_FLAG],
  81      ['bind', WRAP_BIND_FLAG],
  82      ['bindKey', WRAP_BIND_KEY_FLAG],
  83      ['curry', WRAP_CURRY_FLAG],
  84      ['curryRight', WRAP_CURRY_RIGHT_FLAG],
  85      ['flip', WRAP_FLIP_FLAG],
  86      ['partial', WRAP_PARTIAL_FLAG],
  87      ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
  88      ['rearg', WRAP_REARG_FLAG]
  89    ];
  90  
  91    /** `Object#toString` result references. */
  92    var argsTag = '[object Arguments]',
  93        arrayTag = '[object Array]',
  94        asyncTag = '[object AsyncFunction]',
  95        boolTag = '[object Boolean]',
  96        dateTag = '[object Date]',
  97        domExcTag = '[object DOMException]',
  98        errorTag = '[object Error]',
  99        funcTag = '[object Function]',
 100        genTag = '[object GeneratorFunction]',
 101        mapTag = '[object Map]',
 102        numberTag = '[object Number]',
 103        nullTag = '[object Null]',
 104        objectTag = '[object Object]',
 105        promiseTag = '[object Promise]',
 106        proxyTag = '[object Proxy]',
 107        regexpTag = '[object RegExp]',
 108        setTag = '[object Set]',
 109        stringTag = '[object String]',
 110        symbolTag = '[object Symbol]',
 111        undefinedTag = '[object Undefined]',
 112        weakMapTag = '[object WeakMap]',
 113        weakSetTag = '[object WeakSet]';
 114  
 115    var arrayBufferTag = '[object ArrayBuffer]',
 116        dataViewTag = '[object DataView]',
 117        float32Tag = '[object Float32Array]',
 118        float64Tag = '[object Float64Array]',
 119        int8Tag = '[object Int8Array]',
 120        int16Tag = '[object Int16Array]',
 121        int32Tag = '[object Int32Array]',
 122        uint8Tag = '[object Uint8Array]',
 123        uint8ClampedTag = '[object Uint8ClampedArray]',
 124        uint16Tag = '[object Uint16Array]',
 125        uint32Tag = '[object Uint32Array]';
 126  
 127    /** Used to match empty string literals in compiled template source. */
 128    var reEmptyStringLeading = /\b__p \+= '';/g,
 129        reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
 130        reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
 131  
 132    /** Used to match HTML entities and HTML characters. */
 133    var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
 134        reUnescapedHtml = /[&<>"']/g,
 135        reHasEscapedHtml = RegExp(reEscapedHtml.source),
 136        reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
 137  
 138    /** Used to match template delimiters. */
 139    var reEscape = /<%-([\s\S]+?)%>/g,
 140        reEvaluate = /<%([\s\S]+?)%>/g,
 141        reInterpolate = /<%=([\s\S]+?)%>/g;
 142  
 143    /** Used to match property names within property paths. */
 144    var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
 145        reIsPlainProp = /^\w*$/,
 146        rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
 147  
 148    /**
 149     * Used to match `RegExp`
 150     * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 151     */
 152    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
 153        reHasRegExpChar = RegExp(reRegExpChar.source);
 154  
 155    /** Used to match leading and trailing whitespace. */
 156    var reTrim = /^\s+|\s+$/g,
 157        reTrimStart = /^\s+/,
 158        reTrimEnd = /\s+$/;
 159  
 160    /** Used to match wrap detail comments. */
 161    var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
 162        reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
 163        reSplitDetails = /,? & /;
 164  
 165    /** Used to match words composed of alphanumeric characters. */
 166    var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 167  
 168    /** Used to match backslashes in property paths. */
 169    var reEscapeChar = /\\(\\)?/g;
 170  
 171    /**
 172     * Used to match
 173     * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
 174     */
 175    var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
 176  
 177    /** Used to match `RegExp` flags from their coerced string values. */
 178    var reFlags = /\w*$/;
 179  
 180    /** Used to detect bad signed hexadecimal string values. */
 181    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
 182  
 183    /** Used to detect binary string values. */
 184    var reIsBinary = /^0b[01]+$/i;
 185  
 186    /** Used to detect host constructors (Safari). */
 187    var reIsHostCtor = /^\[object .+?Constructor\]$/;
 188  
 189    /** Used to detect octal string values. */
 190    var reIsOctal = /^0o[0-7]+$/i;
 191  
 192    /** Used to detect unsigned integer values. */
 193    var reIsUint = /^(?:0|[1-9]\d*)$/;
 194  
 195    /** Used to match Latin Unicode letters (excluding mathematical operators). */
 196    var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
 197  
 198    /** Used to ensure capturing order of template delimiters. */
 199    var reNoMatch = /($^)/;
 200  
 201    /** Used to match unescaped characters in compiled string literals. */
 202    var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
 203  
 204    /** Used to compose unicode character classes. */
 205    var rsAstralRange = '\\ud800-\\udfff',
 206        rsComboMarksRange = '\\u0300-\\u036f',
 207        reComboHalfMarksRange = '\\ufe20-\\ufe2f',
 208        rsComboSymbolsRange = '\\u20d0-\\u20ff',
 209        rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
 210        rsDingbatRange = '\\u2700-\\u27bf',
 211        rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
 212        rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
 213        rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
 214        rsPunctuationRange = '\\u2000-\\u206f',
 215        rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
 216        rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
 217        rsVarRange = '\\ufe0e\\ufe0f',
 218        rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
 219  
 220    /** Used to compose unicode capture groups. */
 221    var rsApos = "['\u2019]",
 222        rsAstral = '[' + rsAstralRange + ']',
 223        rsBreak = '[' + rsBreakRange + ']',
 224        rsCombo = '[' + rsComboRange + ']',
 225        rsDigits = '\\d+',
 226        rsDingbat = '[' + rsDingbatRange + ']',
 227        rsLower = '[' + rsLowerRange + ']',
 228        rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
 229        rsFitz = '\\ud83c[\\udffb-\\udfff]',
 230        rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
 231        rsNonAstral = '[^' + rsAstralRange + ']',
 232        rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
 233        rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
 234        rsUpper = '[' + rsUpperRange + ']',
 235        rsZWJ = '\\u200d';
 236  
 237    /** Used to compose unicode regexes. */
 238    var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
 239        rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
 240        rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
 241        rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
 242        reOptMod = rsModifier + '?',
 243        rsOptVar = '[' + rsVarRange + ']?',
 244        rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
 245        rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
 246        rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
 247        rsSeq = rsOptVar + reOptMod + rsOptJoin,
 248        rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
 249        rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
 250  
 251    /** Used to match apostrophes. */
 252    var reApos = RegExp(rsApos, 'g');
 253  
 254    /**
 255     * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
 256     * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
 257     */
 258    var reComboMark = RegExp(rsCombo, 'g');
 259  
 260    /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
 261    var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
 262  
 263    /** Used to match complex or compound words. */
 264    var reUnicodeWord = RegExp([
 265      rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
 266      rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
 267      rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
 268      rsUpper + '+' + rsOptContrUpper,
 269      rsOrdUpper,
 270      rsOrdLower,
 271      rsDigits,
 272      rsEmoji
 273    ].join('|'), 'g');
 274  
 275    /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
 276    var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');
 277  
 278    /** Used to detect strings that need a more robust regexp to match words. */
 279    var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
 280  
 281    /** Used to assign default `context` object properties. */
 282    var contextProps = [
 283      'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
 284      'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
 285      'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
 286      'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
 287      '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
 288    ];
 289  
 290    /** Used to make template sourceURLs easier to identify. */
 291    var templateCounter = -1;
 292  
 293    /** Used to identify `toStringTag` values of typed arrays. */
 294    var typedArrayTags = {};
 295    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
 296    typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
 297    typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
 298    typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
 299    typedArrayTags[uint32Tag] = true;
 300    typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
 301    typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
 302    typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
 303    typedArrayTags[errorTag] = typedArrayTags[funcTag] =
 304    typedArrayTags[mapTag] = typedArrayTags[numberTag] =
 305    typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
 306    typedArrayTags[setTag] = typedArrayTags[stringTag] =
 307    typedArrayTags[weakMapTag] = false;
 308  
 309    /** Used to identify `toStringTag` values supported by `_.clone`. */
 310    var cloneableTags = {};
 311    cloneableTags[argsTag] = cloneableTags[arrayTag] =
 312    cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
 313    cloneableTags[boolTag] = cloneableTags[dateTag] =
 314    cloneableTags[float32Tag] = cloneableTags[float64Tag] =
 315    cloneableTags[int8Tag] = cloneableTags[int16Tag] =
 316    cloneableTags[int32Tag] = cloneableTags[mapTag] =
 317    cloneableTags[numberTag] = cloneableTags[objectTag] =
 318    cloneableTags[regexpTag] = cloneableTags[setTag] =
 319    cloneableTags[stringTag] = cloneableTags[symbolTag] =
 320    cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
 321    cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
 322    cloneableTags[errorTag] = cloneableTags[funcTag] =
 323    cloneableTags[weakMapTag] = false;
 324  
 325    /** Used to map Latin Unicode letters to basic Latin letters. */
 326    var deburredLetters = {
 327      // Latin-1 Supplement block.
 328      '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
 329      '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
 330      '\xc7': 'C',  '\xe7': 'c',
 331      '\xd0': 'D',  '\xf0': 'd',
 332      '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
 333      '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
 334      '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
 335      '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
 336      '\xd1': 'N',  '\xf1': 'n',
 337      '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
 338      '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
 339      '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
 340      '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
 341      '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
 342      '\xc6': 'Ae', '\xe6': 'ae',
 343      '\xde': 'Th', '\xfe': 'th',
 344      '\xdf': 'ss',
 345      // Latin Extended-A block.
 346      '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
 347      '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
 348      '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
 349      '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
 350      '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
 351      '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
 352      '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
 353      '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
 354      '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
 355      '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
 356      '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
 357      '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
 358      '\u0134': 'J',  '\u0135': 'j',
 359      '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
 360      '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
 361      '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
 362      '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
 363      '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
 364      '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
 365      '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
 366      '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
 367      '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
 368      '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
 369      '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
 370      '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
 371      '\u0163': 't',  '\u0165': 't', '\u0167': 't',
 372      '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
 373      '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
 374      '\u0174': 'W',  '\u0175': 'w',
 375      '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
 376      '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
 377      '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
 378      '\u0132': 'IJ', '\u0133': 'ij',
 379      '\u0152': 'Oe', '\u0153': 'oe',
 380      '\u0149': "'n", '\u017f': 's'
 381    };
 382  
 383    /** Used to map characters to HTML entities. */
 384    var htmlEscapes = {
 385      '&': '&amp;',
 386      '<': '&lt;',
 387      '>': '&gt;',
 388      '"': '&quot;',
 389      "'": '&#39;'
 390    };
 391  
 392    /** Used to map HTML entities to characters. */
 393    var htmlUnescapes = {
 394      '&amp;': '&',
 395      '&lt;': '<',
 396      '&gt;': '>',
 397      '&quot;': '"',
 398      '&#39;': "'"
 399    };
 400  
 401    /** Used to escape characters for inclusion in compiled string literals. */
 402    var stringEscapes = {
 403      '\\': '\\',
 404      "'": "'",
 405      '\n': 'n',
 406      '\r': 'r',
 407      '\u2028': 'u2028',
 408      '\u2029': 'u2029'
 409    };
 410  
 411    /** Built-in method references without a dependency on `root`. */
 412    var freeParseFloat = parseFloat,
 413        freeParseInt = parseInt;
 414  
 415    /** Detect free variable `global` from Node.js. */
 416    var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
 417  
 418    /** Detect free variable `self`. */
 419    var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
 420  
 421    /** Used as a reference to the global object. */
 422    var root = freeGlobal || freeSelf || Function('return this')();
 423  
 424    /** Detect free variable `exports`. */
 425    var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
 426  
 427    /** Detect free variable `module`. */
 428    var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
 429  
 430    /** Detect the popular CommonJS extension `module.exports`. */
 431    var moduleExports = freeModule && freeModule.exports === freeExports;
 432  
 433    /** Detect free variable `process` from Node.js. */
 434    var freeProcess = moduleExports && freeGlobal.process;
 435  
 436    /** Used to access faster Node.js helpers. */
 437    var nodeUtil = (function() {
 438      try {
 439        // Use `util.types` for Node.js 10+.
 440        var types = freeModule && freeModule.require && freeModule.require('util').types;
 441  
 442        if (types) {
 443          return types;
 444        }
 445  
 446        // Legacy `process.binding('util')` for Node.js < 10.
 447        return freeProcess && freeProcess.binding && freeProcess.binding('util');
 448      } catch (e) {}
 449    }());
 450  
 451    /* Node.js helper references. */
 452    var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
 453        nodeIsDate = nodeUtil && nodeUtil.isDate,
 454        nodeIsMap = nodeUtil && nodeUtil.isMap,
 455        nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
 456        nodeIsSet = nodeUtil && nodeUtil.isSet,
 457        nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
 458  
 459    /*--------------------------------------------------------------------------*/
 460  
 461    /**
 462     * A faster alternative to `Function#apply`, this function invokes `func`
 463     * with the `this` binding of `thisArg` and the arguments of `args`.
 464     *
 465     * @private
 466     * @param {Function} func The function to invoke.
 467     * @param {*} thisArg The `this` binding of `func`.
 468     * @param {Array} args The arguments to invoke `func` with.
 469     * @returns {*} Returns the result of `func`.
 470     */
 471    function apply(func, thisArg, args) {
 472      switch (args.length) {
 473        case 0: return func.call(thisArg);
 474        case 1: return func.call(thisArg, args[0]);
 475        case 2: return func.call(thisArg, args[0], args[1]);
 476        case 3: return func.call(thisArg, args[0], args[1], args[2]);
 477      }
 478      return func.apply(thisArg, args);
 479    }
 480  
 481    /**
 482     * A specialized version of `baseAggregator` for arrays.
 483     *
 484     * @private
 485     * @param {Array} [array] The array to iterate over.
 486     * @param {Function} setter The function to set `accumulator` values.
 487     * @param {Function} iteratee The iteratee to transform keys.
 488     * @param {Object} accumulator The initial aggregated object.
 489     * @returns {Function} Returns `accumulator`.
 490     */
 491    function arrayAggregator(array, setter, iteratee, accumulator) {
 492      var index = -1,
 493          length = array == null ? 0 : array.length;
 494  
 495      while (++index < length) {
 496        var value = array[index];
 497        setter(accumulator, value, iteratee(value), array);
 498      }
 499      return accumulator;
 500    }
 501  
 502    /**
 503     * A specialized version of `_.forEach` for arrays without support for
 504     * iteratee shorthands.
 505     *
 506     * @private
 507     * @param {Array} [array] The array to iterate over.
 508     * @param {Function} iteratee The function invoked per iteration.
 509     * @returns {Array} Returns `array`.
 510     */
 511    function arrayEach(array, iteratee) {
 512      var index = -1,
 513          length = array == null ? 0 : array.length;
 514  
 515      while (++index < length) {
 516        if (iteratee(array[index], index, array) === false) {
 517          break;
 518        }
 519      }
 520      return array;
 521    }
 522  
 523    /**
 524     * A specialized version of `_.forEachRight` for arrays without support for
 525     * iteratee shorthands.
 526     *
 527     * @private
 528     * @param {Array} [array] The array to iterate over.
 529     * @param {Function} iteratee The function invoked per iteration.
 530     * @returns {Array} Returns `array`.
 531     */
 532    function arrayEachRight(array, iteratee) {
 533      var length = array == null ? 0 : array.length;
 534  
 535      while (length--) {
 536        if (iteratee(array[length], length, array) === false) {
 537          break;
 538        }
 539      }
 540      return array;
 541    }
 542  
 543    /**
 544     * A specialized version of `_.every` for arrays without support for
 545     * iteratee shorthands.
 546     *
 547     * @private
 548     * @param {Array} [array] The array to iterate over.
 549     * @param {Function} predicate The function invoked per iteration.
 550     * @returns {boolean} Returns `true` if all elements pass the predicate check,
 551     *  else `false`.
 552     */
 553    function arrayEvery(array, predicate) {
 554      var index = -1,
 555          length = array == null ? 0 : array.length;
 556  
 557      while (++index < length) {
 558        if (!predicate(array[index], index, array)) {
 559          return false;
 560        }
 561      }
 562      return true;
 563    }
 564  
 565    /**
 566     * A specialized version of `_.filter` for arrays without support for
 567     * iteratee shorthands.
 568     *
 569     * @private
 570     * @param {Array} [array] The array to iterate over.
 571     * @param {Function} predicate The function invoked per iteration.
 572     * @returns {Array} Returns the new filtered array.
 573     */
 574    function arrayFilter(array, predicate) {
 575      var index = -1,
 576          length = array == null ? 0 : array.length,
 577          resIndex = 0,
 578          result = [];
 579  
 580      while (++index < length) {
 581        var value = array[index];
 582        if (predicate(value, index, array)) {
 583          result[resIndex++] = value;
 584        }
 585      }
 586      return result;
 587    }
 588  
 589    /**
 590     * A specialized version of `_.includes` for arrays without support for
 591     * specifying an index to search from.
 592     *
 593     * @private
 594     * @param {Array} [array] The array to inspect.
 595     * @param {*} target The value to search for.
 596     * @returns {boolean} Returns `true` if `target` is found, else `false`.
 597     */
 598    function arrayIncludes(array, value) {
 599      var length = array == null ? 0 : array.length;
 600      return !!length && baseIndexOf(array, value, 0) > -1;
 601    }
 602  
 603    /**
 604     * This function is like `arrayIncludes` except that it accepts a comparator.
 605     *
 606     * @private
 607     * @param {Array} [array] The array to inspect.
 608     * @param {*} target The value to search for.
 609     * @param {Function} comparator The comparator invoked per element.
 610     * @returns {boolean} Returns `true` if `target` is found, else `false`.
 611     */
 612    function arrayIncludesWith(array, value, comparator) {
 613      var index = -1,
 614          length = array == null ? 0 : array.length;
 615  
 616      while (++index < length) {
 617        if (comparator(value, array[index])) {
 618          return true;
 619        }
 620      }
 621      return false;
 622    }
 623  
 624    /**
 625     * A specialized version of `_.map` for arrays without support for iteratee
 626     * shorthands.
 627     *
 628     * @private
 629     * @param {Array} [array] The array to iterate over.
 630     * @param {Function} iteratee The function invoked per iteration.
 631     * @returns {Array} Returns the new mapped array.
 632     */
 633    function arrayMap(array, iteratee) {
 634      var index = -1,
 635          length = array == null ? 0 : array.length,
 636          result = Array(length);
 637  
 638      while (++index < length) {
 639        result[index] = iteratee(array[index], index, array);
 640      }
 641      return result;
 642    }
 643  
 644    /**
 645     * Appends the elements of `values` to `array`.
 646     *
 647     * @private
 648     * @param {Array} array The array to modify.
 649     * @param {Array} values The values to append.
 650     * @returns {Array} Returns `array`.
 651     */
 652    function arrayPush(array, values) {
 653      var index = -1,
 654          length = values.length,
 655          offset = array.length;
 656  
 657      while (++index < length) {
 658        array[offset + index] = values[index];
 659      }
 660      return array;
 661    }
 662  
 663    /**
 664     * A specialized version of `_.reduce` for arrays without support for
 665     * iteratee shorthands.
 666     *
 667     * @private
 668     * @param {Array} [array] The array to iterate over.
 669     * @param {Function} iteratee The function invoked per iteration.
 670     * @param {*} [accumulator] The initial value.
 671     * @param {boolean} [initAccum] Specify using the first element of `array` as
 672     *  the initial value.
 673     * @returns {*} Returns the accumulated value.
 674     */
 675    function arrayReduce(array, iteratee, accumulator, initAccum) {
 676      var index = -1,
 677          length = array == null ? 0 : array.length;
 678  
 679      if (initAccum && length) {
 680        accumulator = array[++index];
 681      }
 682      while (++index < length) {
 683        accumulator = iteratee(accumulator, array[index], index, array);
 684      }
 685      return accumulator;
 686    }
 687  
 688    /**
 689     * A specialized version of `_.reduceRight` for arrays without support for
 690     * iteratee shorthands.
 691     *
 692     * @private
 693     * @param {Array} [array] The array to iterate over.
 694     * @param {Function} iteratee The function invoked per iteration.
 695     * @param {*} [accumulator] The initial value.
 696     * @param {boolean} [initAccum] Specify using the last element of `array` as
 697     *  the initial value.
 698     * @returns {*} Returns the accumulated value.
 699     */
 700    function arrayReduceRight(array, iteratee, accumulator, initAccum) {
 701      var length = array == null ? 0 : array.length;
 702      if (initAccum && length) {
 703        accumulator = array[--length];
 704      }
 705      while (length--) {
 706        accumulator = iteratee(accumulator, array[length], length, array);
 707      }
 708      return accumulator;
 709    }
 710  
 711    /**
 712     * A specialized version of `_.some` for arrays without support for iteratee
 713     * shorthands.
 714     *
 715     * @private
 716     * @param {Array} [array] The array to iterate over.
 717     * @param {Function} predicate The function invoked per iteration.
 718     * @returns {boolean} Returns `true` if any element passes the predicate check,
 719     *  else `false`.
 720     */
 721    function arraySome(array, predicate) {
 722      var index = -1,
 723          length = array == null ? 0 : array.length;
 724  
 725      while (++index < length) {
 726        if (predicate(array[index], index, array)) {
 727          return true;
 728        }
 729      }
 730      return false;
 731    }
 732  
 733    /**
 734     * Gets the size of an ASCII `string`.
 735     *
 736     * @private
 737     * @param {string} string The string inspect.
 738     * @returns {number} Returns the string size.
 739     */
 740    var asciiSize = baseProperty('length');
 741  
 742    /**
 743     * Converts an ASCII `string` to an array.
 744     *
 745     * @private
 746     * @param {string} string The string to convert.
 747     * @returns {Array} Returns the converted array.
 748     */
 749    function asciiToArray(string) {
 750      return string.split('');
 751    }
 752  
 753    /**
 754     * Splits an ASCII `string` into an array of its words.
 755     *
 756     * @private
 757     * @param {string} The string to inspect.
 758     * @returns {Array} Returns the words of `string`.
 759     */
 760    function asciiWords(string) {
 761      return string.match(reAsciiWord) || [];
 762    }
 763  
 764    /**
 765     * The base implementation of methods like `_.findKey` and `_.findLastKey`,
 766     * without support for iteratee shorthands, which iterates over `collection`
 767     * using `eachFunc`.
 768     *
 769     * @private
 770     * @param {Array|Object} collection The collection to inspect.
 771     * @param {Function} predicate The function invoked per iteration.
 772     * @param {Function} eachFunc The function to iterate over `collection`.
 773     * @returns {*} Returns the found element or its key, else `undefined`.
 774     */
 775    function baseFindKey(collection, predicate, eachFunc) {
 776      var result;
 777      eachFunc(collection, function(value, key, collection) {
 778        if (predicate(value, key, collection)) {
 779          result = key;
 780          return false;
 781        }
 782      });
 783      return result;
 784    }
 785  
 786    /**
 787     * The base implementation of `_.findIndex` and `_.findLastIndex` without
 788     * support for iteratee shorthands.
 789     *
 790     * @private
 791     * @param {Array} array The array to inspect.
 792     * @param {Function} predicate The function invoked per iteration.
 793     * @param {number} fromIndex The index to search from.
 794     * @param {boolean} [fromRight] Specify iterating from right to left.
 795     * @returns {number} Returns the index of the matched value, else `-1`.
 796     */
 797    function baseFindIndex(array, predicate, fromIndex, fromRight) {
 798      var length = array.length,
 799          index = fromIndex + (fromRight ? 1 : -1);
 800  
 801      while ((fromRight ? index-- : ++index < length)) {
 802        if (predicate(array[index], index, array)) {
 803          return index;
 804        }
 805      }
 806      return -1;
 807    }
 808  
 809    /**
 810     * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
 811     *
 812     * @private
 813     * @param {Array} array The array to inspect.
 814     * @param {*} value The value to search for.
 815     * @param {number} fromIndex The index to search from.
 816     * @returns {number} Returns the index of the matched value, else `-1`.
 817     */
 818    function baseIndexOf(array, value, fromIndex) {
 819      return value === value
 820        ? strictIndexOf(array, value, fromIndex)
 821        : baseFindIndex(array, baseIsNaN, fromIndex);
 822    }
 823  
 824    /**
 825     * This function is like `baseIndexOf` except that it accepts a comparator.
 826     *
 827     * @private
 828     * @param {Array} array The array to inspect.
 829     * @param {*} value The value to search for.
 830     * @param {number} fromIndex The index to search from.
 831     * @param {Function} comparator The comparator invoked per element.
 832     * @returns {number} Returns the index of the matched value, else `-1`.
 833     */
 834    function baseIndexOfWith(array, value, fromIndex, comparator) {
 835      var index = fromIndex - 1,
 836          length = array.length;
 837  
 838      while (++index < length) {
 839        if (comparator(array[index], value)) {
 840          return index;
 841        }
 842      }
 843      return -1;
 844    }
 845  
 846    /**
 847     * The base implementation of `_.isNaN` without support for number objects.
 848     *
 849     * @private
 850     * @param {*} value The value to check.
 851     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
 852     */
 853    function baseIsNaN(value) {
 854      return value !== value;
 855    }
 856  
 857    /**
 858     * The base implementation of `_.mean` and `_.meanBy` without support for
 859     * iteratee shorthands.
 860     *
 861     * @private
 862     * @param {Array} array The array to iterate over.
 863     * @param {Function} iteratee The function invoked per iteration.
 864     * @returns {number} Returns the mean.
 865     */
 866    function baseMean(array, iteratee) {
 867      var length = array == null ? 0 : array.length;
 868      return length ? (baseSum(array, iteratee) / length) : NAN;
 869    }
 870  
 871    /**
 872     * The base implementation of `_.property` without support for deep paths.
 873     *
 874     * @private
 875     * @param {string} key The key of the property to get.
 876     * @returns {Function} Returns the new accessor function.
 877     */
 878    function baseProperty(key) {
 879      return function(object) {
 880        return object == null ? undefined : object[key];
 881      };
 882    }
 883  
 884    /**
 885     * The base implementation of `_.propertyOf` without support for deep paths.
 886     *
 887     * @private
 888     * @param {Object} object The object to query.
 889     * @returns {Function} Returns the new accessor function.
 890     */
 891    function basePropertyOf(object) {
 892      return function(key) {
 893        return object == null ? undefined : object[key];
 894      };
 895    }
 896  
 897    /**
 898     * The base implementation of `_.reduce` and `_.reduceRight`, without support
 899     * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
 900     *
 901     * @private
 902     * @param {Array|Object} collection The collection to iterate over.
 903     * @param {Function} iteratee The function invoked per iteration.
 904     * @param {*} accumulator The initial value.
 905     * @param {boolean} initAccum Specify using the first or last element of
 906     *  `collection` as the initial value.
 907     * @param {Function} eachFunc The function to iterate over `collection`.
 908     * @returns {*} Returns the accumulated value.
 909     */
 910    function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
 911      eachFunc(collection, function(value, index, collection) {
 912        accumulator = initAccum
 913          ? (initAccum = false, value)
 914          : iteratee(accumulator, value, index, collection);
 915      });
 916      return accumulator;
 917    }
 918  
 919    /**
 920     * The base implementation of `_.sortBy` which uses `comparer` to define the
 921     * sort order of `array` and replaces criteria objects with their corresponding
 922     * values.
 923     *
 924     * @private
 925     * @param {Array} array The array to sort.
 926     * @param {Function} comparer The function to define sort order.
 927     * @returns {Array} Returns `array`.
 928     */
 929    function baseSortBy(array, comparer) {
 930      var length = array.length;
 931  
 932      array.sort(comparer);
 933      while (length--) {
 934        array[length] = array[length].value;
 935      }
 936      return array;
 937    }
 938  
 939    /**
 940     * The base implementation of `_.sum` and `_.sumBy` without support for
 941     * iteratee shorthands.
 942     *
 943     * @private
 944     * @param {Array} array The array to iterate over.
 945     * @param {Function} iteratee The function invoked per iteration.
 946     * @returns {number} Returns the sum.
 947     */
 948    function baseSum(array, iteratee) {
 949      var result,
 950          index = -1,
 951          length = array.length;
 952  
 953      while (++index < length) {
 954        var current = iteratee(array[index]);
 955        if (current !== undefined) {
 956          result = result === undefined ? current : (result + current);
 957        }
 958      }
 959      return result;
 960    }
 961  
 962    /**
 963     * The base implementation of `_.times` without support for iteratee shorthands
 964     * or max array length checks.
 965     *
 966     * @private
 967     * @param {number} n The number of times to invoke `iteratee`.
 968     * @param {Function} iteratee The function invoked per iteration.
 969     * @returns {Array} Returns the array of results.
 970     */
 971    function baseTimes(n, iteratee) {
 972      var index = -1,
 973          result = Array(n);
 974  
 975      while (++index < n) {
 976        result[index] = iteratee(index);
 977      }
 978      return result;
 979    }
 980  
 981    /**
 982     * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
 983     * of key-value pairs for `object` corresponding to the property names of `props`.
 984     *
 985     * @private
 986     * @param {Object} object The object to query.
 987     * @param {Array} props The property names to get values for.
 988     * @returns {Object} Returns the key-value pairs.
 989     */
 990    function baseToPairs(object, props) {
 991      return arrayMap(props, function(key) {
 992        return [key, object[key]];
 993      });
 994    }
 995  
 996    /**
 997     * The base implementation of `_.unary` without support for storing metadata.
 998     *
 999     * @private
1000     * @param {Function} func The function to cap arguments for.
1001     * @returns {Function} Returns the new capped function.
1002     */
1003    function baseUnary(func) {
1004      return function(value) {
1005        return func(value);
1006      };
1007    }
1008  
1009    /**
1010     * The base implementation of `_.values` and `_.valuesIn` which creates an
1011     * array of `object` property values corresponding to the property names
1012     * of `props`.
1013     *
1014     * @private
1015     * @param {Object} object The object to query.
1016     * @param {Array} props The property names to get values for.
1017     * @returns {Object} Returns the array of property values.
1018     */
1019    function baseValues(object, props) {
1020      return arrayMap(props, function(key) {
1021        return object[key];
1022      });
1023    }
1024  
1025    /**
1026     * Checks if a `cache` value for `key` exists.
1027     *
1028     * @private
1029     * @param {Object} cache The cache to query.
1030     * @param {string} key The key of the entry to check.
1031     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
1032     */
1033    function cacheHas(cache, key) {
1034      return cache.has(key);
1035    }
1036  
1037    /**
1038     * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
1039     * that is not found in the character symbols.
1040     *
1041     * @private
1042     * @param {Array} strSymbols The string symbols to inspect.
1043     * @param {Array} chrSymbols The character symbols to find.
1044     * @returns {number} Returns the index of the first unmatched string symbol.
1045     */
1046    function charsStartIndex(strSymbols, chrSymbols) {
1047      var index = -1,
1048          length = strSymbols.length;
1049  
1050      while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1051      return index;
1052    }
1053  
1054    /**
1055     * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
1056     * that is not found in the character symbols.
1057     *
1058     * @private
1059     * @param {Array} strSymbols The string symbols to inspect.
1060     * @param {Array} chrSymbols The character symbols to find.
1061     * @returns {number} Returns the index of the last unmatched string symbol.
1062     */
1063    function charsEndIndex(strSymbols, chrSymbols) {
1064      var index = strSymbols.length;
1065  
1066      while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1067      return index;
1068    }
1069  
1070    /**
1071     * Gets the number of `placeholder` occurrences in `array`.
1072     *
1073     * @private
1074     * @param {Array} array The array to inspect.
1075     * @param {*} placeholder The placeholder to search for.
1076     * @returns {number} Returns the placeholder count.
1077     */
1078    function countHolders(array, placeholder) {
1079      var length = array.length,
1080          result = 0;
1081  
1082      while (length--) {
1083        if (array[length] === placeholder) {
1084          ++result;
1085        }
1086      }
1087      return result;
1088    }
1089  
1090    /**
1091     * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
1092     * letters to basic Latin letters.
1093     *
1094     * @private
1095     * @param {string} letter The matched letter to deburr.
1096     * @returns {string} Returns the deburred letter.
1097     */
1098    var deburrLetter = basePropertyOf(deburredLetters);
1099  
1100    /**
1101     * Used by `_.escape` to convert characters to HTML entities.
1102     *
1103     * @private
1104     * @param {string} chr The matched character to escape.
1105     * @returns {string} Returns the escaped character.
1106     */
1107    var escapeHtmlChar = basePropertyOf(htmlEscapes);
1108  
1109    /**
1110     * Used by `_.template` to escape characters for inclusion in compiled string literals.
1111     *
1112     * @private
1113     * @param {string} chr The matched character to escape.
1114     * @returns {string} Returns the escaped character.
1115     */
1116    function escapeStringChar(chr) {
1117      return '\\' + stringEscapes[chr];
1118    }
1119  
1120    /**
1121     * Gets the value at `key` of `object`.
1122     *
1123     * @private
1124     * @param {Object} [object] The object to query.
1125     * @param {string} key The key of the property to get.
1126     * @returns {*} Returns the property value.
1127     */
1128    function getValue(object, key) {
1129      return object == null ? undefined : object[key];
1130    }
1131  
1132    /**
1133     * Checks if `string` contains Unicode symbols.
1134     *
1135     * @private
1136     * @param {string} string The string to inspect.
1137     * @returns {boolean} Returns `true` if a symbol is found, else `false`.
1138     */
1139    function hasUnicode(string) {
1140      return reHasUnicode.test(string);
1141    }
1142  
1143    /**
1144     * Checks if `string` contains a word composed of Unicode symbols.
1145     *
1146     * @private
1147     * @param {string} string The string to inspect.
1148     * @returns {boolean} Returns `true` if a word is found, else `false`.
1149     */
1150    function hasUnicodeWord(string) {
1151      return reHasUnicodeWord.test(string);
1152    }
1153  
1154    /**
1155     * Converts `iterator` to an array.
1156     *
1157     * @private
1158     * @param {Object} iterator The iterator to convert.
1159     * @returns {Array} Returns the converted array.
1160     */
1161    function iteratorToArray(iterator) {
1162      var data,
1163          result = [];
1164  
1165      while (!(data = iterator.next()).done) {
1166        result.push(data.value);
1167      }
1168      return result;
1169    }
1170  
1171    /**
1172     * Converts `map` to its key-value pairs.
1173     *
1174     * @private
1175     * @param {Object} map The map to convert.
1176     * @returns {Array} Returns the key-value pairs.
1177     */
1178    function mapToArray(map) {
1179      var index = -1,
1180          result = Array(map.size);
1181  
1182      map.forEach(function(value, key) {
1183        result[++index] = [key, value];
1184      });
1185      return result;
1186    }
1187  
1188    /**
1189     * Creates a unary function that invokes `func` with its argument transformed.
1190     *
1191     * @private
1192     * @param {Function} func The function to wrap.
1193     * @param {Function} transform The argument transform.
1194     * @returns {Function} Returns the new function.
1195     */
1196    function overArg(func, transform) {
1197      return function(arg) {
1198        return func(transform(arg));
1199      };
1200    }
1201  
1202    /**
1203     * Replaces all `placeholder` elements in `array` with an internal placeholder
1204     * and returns an array of their indexes.
1205     *
1206     * @private
1207     * @param {Array} array The array to modify.
1208     * @param {*} placeholder The placeholder to replace.
1209     * @returns {Array} Returns the new array of placeholder indexes.
1210     */
1211    function replaceHolders(array, placeholder) {
1212      var index = -1,
1213          length = array.length,
1214          resIndex = 0,
1215          result = [];
1216  
1217      while (++index < length) {
1218        var value = array[index];
1219        if (value === placeholder || value === PLACEHOLDER) {
1220          array[index] = PLACEHOLDER;
1221          result[resIndex++] = index;
1222        }
1223      }
1224      return result;
1225    }
1226  
1227    /**
1228     * Converts `set` to an array of its values.
1229     *
1230     * @private
1231     * @param {Object} set The set to convert.
1232     * @returns {Array} Returns the values.
1233     */
1234    function setToArray(set) {
1235      var index = -1,
1236          result = Array(set.size);
1237  
1238      set.forEach(function(value) {
1239        result[++index] = value;
1240      });
1241      return result;
1242    }
1243  
1244    /**
1245     * Converts `set` to its value-value pairs.
1246     *
1247     * @private
1248     * @param {Object} set The set to convert.
1249     * @returns {Array} Returns the value-value pairs.
1250     */
1251    function setToPairs(set) {
1252      var index = -1,
1253          result = Array(set.size);
1254  
1255      set.forEach(function(value) {
1256        result[++index] = [value, value];
1257      });
1258      return result;
1259    }
1260  
1261    /**
1262     * A specialized version of `_.indexOf` which performs strict equality
1263     * comparisons of values, i.e. `===`.
1264     *
1265     * @private
1266     * @param {Array} array The array to inspect.
1267     * @param {*} value The value to search for.
1268     * @param {number} fromIndex The index to search from.
1269     * @returns {number} Returns the index of the matched value, else `-1`.
1270     */
1271    function strictIndexOf(array, value, fromIndex) {
1272      var index = fromIndex - 1,
1273          length = array.length;
1274  
1275      while (++index < length) {
1276        if (array[index] === value) {
1277          return index;
1278        }
1279      }
1280      return -1;
1281    }
1282  
1283    /**
1284     * A specialized version of `_.lastIndexOf` which performs strict equality
1285     * comparisons of values, i.e. `===`.
1286     *
1287     * @private
1288     * @param {Array} array The array to inspect.
1289     * @param {*} value The value to search for.
1290     * @param {number} fromIndex The index to search from.
1291     * @returns {number} Returns the index of the matched value, else `-1`.
1292     */
1293    function strictLastIndexOf(array, value, fromIndex) {
1294      var index = fromIndex + 1;
1295      while (index--) {
1296        if (array[index] === value) {
1297          return index;
1298        }
1299      }
1300      return index;
1301    }
1302  
1303    /**
1304     * Gets the number of symbols in `string`.
1305     *
1306     * @private
1307     * @param {string} string The string to inspect.
1308     * @returns {number} Returns the string size.
1309     */
1310    function stringSize(string) {
1311      return hasUnicode(string)
1312        ? unicodeSize(string)
1313        : asciiSize(string);
1314    }
1315  
1316    /**
1317     * Converts `string` to an array.
1318     *
1319     * @private
1320     * @param {string} string The string to convert.
1321     * @returns {Array} Returns the converted array.
1322     */
1323    function stringToArray(string) {
1324      return hasUnicode(string)
1325        ? unicodeToArray(string)
1326        : asciiToArray(string);
1327    }
1328  
1329    /**
1330     * Used by `_.unescape` to convert HTML entities to characters.
1331     *
1332     * @private
1333     * @param {string} chr The matched character to unescape.
1334     * @returns {string} Returns the unescaped character.
1335     */
1336    var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
1337  
1338    /**
1339     * Gets the size of a Unicode `string`.
1340     *
1341     * @private
1342     * @param {string} string The string inspect.
1343     * @returns {number} Returns the string size.
1344     */
1345    function unicodeSize(string) {
1346      var result = reUnicode.lastIndex = 0;
1347      while (reUnicode.test(string)) {
1348        ++result;
1349      }
1350      return result;
1351    }
1352  
1353    /**
1354     * Converts a Unicode `string` to an array.
1355     *
1356     * @private
1357     * @param {string} string The string to convert.
1358     * @returns {Array} Returns the converted array.
1359     */
1360    function unicodeToArray(string) {
1361      return string.match(reUnicode) || [];
1362    }
1363  
1364    /**
1365     * Splits a Unicode `string` into an array of its words.
1366     *
1367     * @private
1368     * @param {string} The string to inspect.
1369     * @returns {Array} Returns the words of `string`.
1370     */
1371    function unicodeWords(string) {
1372      return string.match(reUnicodeWord) || [];
1373    }
1374  
1375    /*--------------------------------------------------------------------------*/
1376  
1377    /**
1378     * Create a new pristine `lodash` function using the `context` object.
1379     *
1380     * @static
1381     * @memberOf _
1382     * @since 1.1.0
1383     * @category Util
1384     * @param {Object} [context=root] The context object.
1385     * @returns {Function} Returns a new `lodash` function.
1386     * @example
1387     *
1388     * _.mixin({ 'foo': _.constant('foo') });
1389     *
1390     * var lodash = _.runInContext();
1391     * lodash.mixin({ 'bar': lodash.constant('bar') });
1392     *
1393     * _.isFunction(_.foo);
1394     * // => true
1395     * _.isFunction(_.bar);
1396     * // => false
1397     *
1398     * lodash.isFunction(lodash.foo);
1399     * // => false
1400     * lodash.isFunction(lodash.bar);
1401     * // => true
1402     *
1403     * // Create a suped-up `defer` in Node.js.
1404     * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
1405     */
1406    var runInContext = (function runInContext(context) {
1407      context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
1408  
1409      /** Built-in constructor references. */
1410      var Array = context.Array,
1411          Date = context.Date,
1412          Error = context.Error,
1413          Function = context.Function,
1414          Math = context.Math,
1415          Object = context.Object,
1416          RegExp = context.RegExp,
1417          String = context.String,
1418          TypeError = context.TypeError;
1419  
1420      /** Used for built-in method references. */
1421      var arrayProto = Array.prototype,
1422          funcProto = Function.prototype,
1423          objectProto = Object.prototype;
1424  
1425      /** Used to detect overreaching core-js shims. */
1426      var coreJsData = context['__core-js_shared__'];
1427  
1428      /** Used to resolve the decompiled source of functions. */
1429      var funcToString = funcProto.toString;
1430  
1431      /** Used to check objects for own properties. */
1432      var hasOwnProperty = objectProto.hasOwnProperty;
1433  
1434      /** Used to generate unique IDs. */
1435      var idCounter = 0;
1436  
1437      /** Used to detect methods masquerading as native. */
1438      var maskSrcKey = (function() {
1439        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
1440        return uid ? ('Symbol(src)_1.' + uid) : '';
1441      }());
1442  
1443      /**
1444       * Used to resolve the
1445       * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
1446       * of values.
1447       */
1448      var nativeObjectToString = objectProto.toString;
1449  
1450      /** Used to infer the `Object` constructor. */
1451      var objectCtorString = funcToString.call(Object);
1452  
1453      /** Used to restore the original `_` reference in `_.noConflict`. */
1454      var oldDash = root._;
1455  
1456      /** Used to detect if a method is native. */
1457      var reIsNative = RegExp('^' +
1458        funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
1459        .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
1460      );
1461  
1462      /** Built-in value references. */
1463      var Buffer = moduleExports ? context.Buffer : undefined,
1464          Symbol = context.Symbol,
1465          Uint8Array = context.Uint8Array,
1466          allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
1467          getPrototype = overArg(Object.getPrototypeOf, Object),
1468          objectCreate = Object.create,
1469          propertyIsEnumerable = objectProto.propertyIsEnumerable,
1470          splice = arrayProto.splice,
1471          spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,
1472          symIterator = Symbol ? Symbol.iterator : undefined,
1473          symToStringTag = Symbol ? Symbol.toStringTag : undefined;
1474  
1475      var defineProperty = (function() {
1476        try {
1477          var func = getNative(Object, 'defineProperty');
1478          func({}, '', {});
1479          return func;
1480        } catch (e) {}
1481      }());
1482  
1483      /** Mocked built-ins. */
1484      var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
1485          ctxNow = Date && Date.now !== root.Date.now && Date.now,
1486          ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
1487  
1488      /* Built-in method references for those with the same name as other `lodash` methods. */
1489      var nativeCeil = Math.ceil,
1490          nativeFloor = Math.floor,
1491          nativeGetSymbols = Object.getOwnPropertySymbols,
1492          nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
1493          nativeIsFinite = context.isFinite,
1494          nativeJoin = arrayProto.join,
1495          nativeKeys = overArg(Object.keys, Object),
1496          nativeMax = Math.max,
1497          nativeMin = Math.min,
1498          nativeNow = Date.now,
1499          nativeParseInt = context.parseInt,
1500          nativeRandom = Math.random,
1501          nativeReverse = arrayProto.reverse;
1502  
1503      /* Built-in method references that are verified to be native. */
1504      var DataView = getNative(context, 'DataView'),
1505          Map = getNative(context, 'Map'),
1506          Promise = getNative(context, 'Promise'),
1507          Set = getNative(context, 'Set'),
1508          WeakMap = getNative(context, 'WeakMap'),
1509          nativeCreate = getNative(Object, 'create');
1510  
1511      /** Used to store function metadata. */
1512      var metaMap = WeakMap && new WeakMap;
1513  
1514      /** Used to lookup unminified function names. */
1515      var realNames = {};
1516  
1517      /** Used to detect maps, sets, and weakmaps. */
1518      var dataViewCtorString = toSource(DataView),
1519          mapCtorString = toSource(Map),
1520          promiseCtorString = toSource(Promise),
1521          setCtorString = toSource(Set),
1522          weakMapCtorString = toSource(WeakMap);
1523  
1524      /** Used to convert symbols to primitives and strings. */
1525      var symbolProto = Symbol ? Symbol.prototype : undefined,
1526          symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
1527          symbolToString = symbolProto ? symbolProto.toString : undefined;
1528  
1529      /*------------------------------------------------------------------------*/
1530  
1531      /**
1532       * Creates a `lodash` object which wraps `value` to enable implicit method
1533       * chain sequences. Methods that operate on and return arrays, collections,
1534       * and functions can be chained together. Methods that retrieve a single value
1535       * or may return a primitive value will automatically end the chain sequence
1536       * and return the unwrapped value. Otherwise, the value must be unwrapped
1537       * with `_#value`.
1538       *
1539       * Explicit chain sequences, which must be unwrapped with `_#value`, may be
1540       * enabled using `_.chain`.
1541       *
1542       * The execution of chained methods is lazy, that is, it's deferred until
1543       * `_#value` is implicitly or explicitly called.
1544       *
1545       * Lazy evaluation allows several methods to support shortcut fusion.
1546       * Shortcut fusion is an optimization to merge iteratee calls; this avoids
1547       * the creation of intermediate arrays and can greatly reduce the number of
1548       * iteratee executions. Sections of a chain sequence qualify for shortcut
1549       * fusion if the section is applied to an array and iteratees accept only
1550       * one argument. The heuristic for whether a section qualifies for shortcut
1551       * fusion is subject to change.
1552       *
1553       * Chaining is supported in custom builds as long as the `_#value` method is
1554       * directly or indirectly included in the build.
1555       *
1556       * In addition to lodash methods, wrappers have `Array` and `String` methods.
1557       *
1558       * The wrapper `Array` methods are:
1559       * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
1560       *
1561       * The wrapper `String` methods are:
1562       * `replace` and `split`
1563       *
1564       * The wrapper methods that support shortcut fusion are:
1565       * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
1566       * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
1567       * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
1568       *
1569       * The chainable wrapper methods are:
1570       * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
1571       * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
1572       * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
1573       * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
1574       * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
1575       * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
1576       * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
1577       * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
1578       * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
1579       * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
1580       * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
1581       * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
1582       * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
1583       * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
1584       * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
1585       * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
1586       * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
1587       * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
1588       * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
1589       * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
1590       * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
1591       * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
1592       * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
1593       * `zipObject`, `zipObjectDeep`, and `zipWith`
1594       *
1595       * The wrapper methods that are **not** chainable by default are:
1596       * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
1597       * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
1598       * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
1599       * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
1600       * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
1601       * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
1602       * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
1603       * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
1604       * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
1605       * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
1606       * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
1607       * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
1608       * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
1609       * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
1610       * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
1611       * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
1612       * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
1613       * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
1614       * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
1615       * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
1616       * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
1617       * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
1618       * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
1619       * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
1620       * `upperFirst`, `value`, and `words`
1621       *
1622       * @name _
1623       * @constructor
1624       * @category Seq
1625       * @param {*} value The value to wrap in a `lodash` instance.
1626       * @returns {Object} Returns the new `lodash` wrapper instance.
1627       * @example
1628       *
1629       * function square(n) {
1630       *   return n * n;
1631       * }
1632       *
1633       * var wrapped = _([1, 2, 3]);
1634       *
1635       * // Returns an unwrapped value.
1636       * wrapped.reduce(_.add);
1637       * // => 6
1638       *
1639       * // Returns a wrapped value.
1640       * var squares = wrapped.map(square);
1641       *
1642       * _.isArray(squares);
1643       * // => false
1644       *
1645       * _.isArray(squares.value());
1646       * // => true
1647       */
1648      function lodash(value) {
1649        if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
1650          if (value instanceof LodashWrapper) {
1651            return value;
1652          }
1653          if (hasOwnProperty.call(value, '__wrapped__')) {
1654            return wrapperClone(value);
1655          }
1656        }
1657        return new LodashWrapper(value);
1658      }
1659  
1660      /**
1661       * The base implementation of `_.create` without support for assigning
1662       * properties to the created object.
1663       *
1664       * @private
1665       * @param {Object} proto The object to inherit from.
1666       * @returns {Object} Returns the new object.
1667       */
1668      var baseCreate = (function() {
1669        function object() {}
1670        return function(proto) {
1671          if (!isObject(proto)) {
1672            return {};
1673          }
1674          if (objectCreate) {
1675            return objectCreate(proto);
1676          }
1677          object.prototype = proto;
1678          var result = new object;
1679          object.prototype = undefined;
1680          return result;
1681        };
1682      }());
1683  
1684      /**
1685       * The function whose prototype chain sequence wrappers inherit from.
1686       *
1687       * @private
1688       */
1689      function baseLodash() {
1690        // No operation performed.
1691      }
1692  
1693      /**
1694       * The base constructor for creating `lodash` wrapper objects.
1695       *
1696       * @private
1697       * @param {*} value The value to wrap.
1698       * @param {boolean} [chainAll] Enable explicit method chain sequences.
1699       */
1700      function LodashWrapper(value, chainAll) {
1701        this.__wrapped__ = value;
1702        this.__actions__ = [];
1703        this.__chain__ = !!chainAll;
1704        this.__index__ = 0;
1705        this.__values__ = undefined;
1706      }
1707  
1708      /**
1709       * By default, the template delimiters used by lodash are like those in
1710       * embedded Ruby (ERB) as well as ES2015 template strings. Change the
1711       * following template settings to use alternative delimiters.
1712       *
1713       * @static
1714       * @memberOf _
1715       * @type {Object}
1716       */
1717      lodash.templateSettings = {
1718  
1719        /**
1720         * Used to detect `data` property values to be HTML-escaped.
1721         *
1722         * @memberOf _.templateSettings
1723         * @type {RegExp}
1724         */
1725        'escape': reEscape,
1726  
1727        /**
1728         * Used to detect code to be evaluated.
1729         *
1730         * @memberOf _.templateSettings
1731         * @type {RegExp}
1732         */
1733        'evaluate': reEvaluate,
1734  
1735        /**
1736         * Used to detect `data` property values to inject.
1737         *
1738         * @memberOf _.templateSettings
1739         * @type {RegExp}
1740         */
1741        'interpolate': reInterpolate,
1742  
1743        /**
1744         * Used to reference the data object in the template text.
1745         *
1746         * @memberOf _.templateSettings
1747         * @type {string}
1748         */
1749        'variable': '',
1750  
1751        /**
1752         * Used to import variables into the compiled template.
1753         *
1754         * @memberOf _.templateSettings
1755         * @type {Object}
1756         */
1757        'imports': {
1758  
1759          /**
1760           * A reference to the `lodash` function.
1761           *
1762           * @memberOf _.templateSettings.imports
1763           * @type {Function}
1764           */
1765          '_': lodash
1766        }
1767      };
1768  
1769      // Ensure wrappers are instances of `baseLodash`.
1770      lodash.prototype = baseLodash.prototype;
1771      lodash.prototype.constructor = lodash;
1772  
1773      LodashWrapper.prototype = baseCreate(baseLodash.prototype);
1774      LodashWrapper.prototype.constructor = LodashWrapper;
1775  
1776      /*------------------------------------------------------------------------*/
1777  
1778      /**
1779       * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
1780       *
1781       * @private
1782       * @constructor
1783       * @param {*} value The value to wrap.
1784       */
1785      function LazyWrapper(value) {
1786        this.__wrapped__ = value;
1787        this.__actions__ = [];
1788        this.__dir__ = 1;
1789        this.__filtered__ = false;
1790        this.__iteratees__ = [];
1791        this.__takeCount__ = MAX_ARRAY_LENGTH;
1792        this.__views__ = [];
1793      }
1794  
1795      /**
1796       * Creates a clone of the lazy wrapper object.
1797       *
1798       * @private
1799       * @name clone
1800       * @memberOf LazyWrapper
1801       * @returns {Object} Returns the cloned `LazyWrapper` object.
1802       */
1803      function lazyClone() {
1804        var result = new LazyWrapper(this.__wrapped__);
1805        result.__actions__ = copyArray(this.__actions__);
1806        result.__dir__ = this.__dir__;
1807        result.__filtered__ = this.__filtered__;
1808        result.__iteratees__ = copyArray(this.__iteratees__);
1809        result.__takeCount__ = this.__takeCount__;
1810        result.__views__ = copyArray(this.__views__);
1811        return result;
1812      }
1813  
1814      /**
1815       * Reverses the direction of lazy iteration.
1816       *
1817       * @private
1818       * @name reverse
1819       * @memberOf LazyWrapper
1820       * @returns {Object} Returns the new reversed `LazyWrapper` object.
1821       */
1822      function lazyReverse() {
1823        if (this.__filtered__) {
1824          var result = new LazyWrapper(this);
1825          result.__dir__ = -1;
1826          result.__filtered__ = true;
1827        } else {
1828          result = this.clone();
1829          result.__dir__ *= -1;
1830        }
1831        return result;
1832      }
1833  
1834      /**
1835       * Extracts the unwrapped value from its lazy wrapper.
1836       *
1837       * @private
1838       * @name value
1839       * @memberOf LazyWrapper
1840       * @returns {*} Returns the unwrapped value.
1841       */
1842      function lazyValue() {
1843        var array = this.__wrapped__.value(),
1844            dir = this.__dir__,
1845            isArr = isArray(array),
1846            isRight = dir < 0,
1847            arrLength = isArr ? array.length : 0,
1848            view = getView(0, arrLength, this.__views__),
1849            start = view.start,
1850            end = view.end,
1851            length = end - start,
1852            index = isRight ? end : (start - 1),
1853            iteratees = this.__iteratees__,
1854            iterLength = iteratees.length,
1855            resIndex = 0,
1856            takeCount = nativeMin(length, this.__takeCount__);
1857  
1858        if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
1859          return baseWrapperValue(array, this.__actions__);
1860        }
1861        var result = [];
1862  
1863        outer:
1864        while (length-- && resIndex < takeCount) {
1865          index += dir;
1866  
1867          var iterIndex = -1,
1868              value = array[index];
1869  
1870          while (++iterIndex < iterLength) {
1871            var data = iteratees[iterIndex],
1872                iteratee = data.iteratee,
1873                type = data.type,
1874                computed = iteratee(value);
1875  
1876            if (type == LAZY_MAP_FLAG) {
1877              value = computed;
1878            } else if (!computed) {
1879              if (type == LAZY_FILTER_FLAG) {
1880                continue outer;
1881              } else {
1882                break outer;
1883              }
1884            }
1885          }
1886          result[resIndex++] = value;
1887        }
1888        return result;
1889      }
1890  
1891      // Ensure `LazyWrapper` is an instance of `baseLodash`.
1892      LazyWrapper.prototype = baseCreate(baseLodash.prototype);
1893      LazyWrapper.prototype.constructor = LazyWrapper;
1894  
1895      /*------------------------------------------------------------------------*/
1896  
1897      /**
1898       * Creates a hash object.
1899       *
1900       * @private
1901       * @constructor
1902       * @param {Array} [entries] The key-value pairs to cache.
1903       */
1904      function Hash(entries) {
1905        var index = -1,
1906            length = entries == null ? 0 : entries.length;
1907  
1908        this.clear();
1909        while (++index < length) {
1910          var entry = entries[index];
1911          this.set(entry[0], entry[1]);
1912        }
1913      }
1914  
1915      /**
1916       * Removes all key-value entries from the hash.
1917       *
1918       * @private
1919       * @name clear
1920       * @memberOf Hash
1921       */
1922      function hashClear() {
1923        this.__data__ = nativeCreate ? nativeCreate(null) : {};
1924        this.size = 0;
1925      }
1926  
1927      /**
1928       * Removes `key` and its value from the hash.
1929       *
1930       * @private
1931       * @name delete
1932       * @memberOf Hash
1933       * @param {Object} hash The hash to modify.
1934       * @param {string} key The key of the value to remove.
1935       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
1936       */
1937      function hashDelete(key) {
1938        var result = this.has(key) && delete this.__data__[key];
1939        this.size -= result ? 1 : 0;
1940        return result;
1941      }
1942  
1943      /**
1944       * Gets the hash value for `key`.
1945       *
1946       * @private
1947       * @name get
1948       * @memberOf Hash
1949       * @param {string} key The key of the value to get.
1950       * @returns {*} Returns the entry value.
1951       */
1952      function hashGet(key) {
1953        var data = this.__data__;
1954        if (nativeCreate) {
1955          var result = data[key];
1956          return result === HASH_UNDEFINED ? undefined : result;
1957        }
1958        return hasOwnProperty.call(data, key) ? data[key] : undefined;
1959      }
1960  
1961      /**
1962       * Checks if a hash value for `key` exists.
1963       *
1964       * @private
1965       * @name has
1966       * @memberOf Hash
1967       * @param {string} key The key of the entry to check.
1968       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
1969       */
1970      function hashHas(key) {
1971        var data = this.__data__;
1972        return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
1973      }
1974  
1975      /**
1976       * Sets the hash `key` to `value`.
1977       *
1978       * @private
1979       * @name set
1980       * @memberOf Hash
1981       * @param {string} key The key of the value to set.
1982       * @param {*} value The value to set.
1983       * @returns {Object} Returns the hash instance.
1984       */
1985      function hashSet(key, value) {
1986        var data = this.__data__;
1987        this.size += this.has(key) ? 0 : 1;
1988        data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
1989        return this;
1990      }
1991  
1992      // Add methods to `Hash`.
1993      Hash.prototype.clear = hashClear;
1994      Hash.prototype['delete'] = hashDelete;
1995      Hash.prototype.get = hashGet;
1996      Hash.prototype.has = hashHas;
1997      Hash.prototype.set = hashSet;
1998  
1999      /*------------------------------------------------------------------------*/
2000  
2001      /**
2002       * Creates an list cache object.
2003       *
2004       * @private
2005       * @constructor
2006       * @param {Array} [entries] The key-value pairs to cache.
2007       */
2008      function ListCache(entries) {
2009        var index = -1,
2010            length = entries == null ? 0 : entries.length;
2011  
2012        this.clear();
2013        while (++index < length) {
2014          var entry = entries[index];
2015          this.set(entry[0], entry[1]);
2016        }
2017      }
2018  
2019      /**
2020       * Removes all key-value entries from the list cache.
2021       *
2022       * @private
2023       * @name clear
2024       * @memberOf ListCache
2025       */
2026      function listCacheClear() {
2027        this.__data__ = [];
2028        this.size = 0;
2029      }
2030  
2031      /**
2032       * Removes `key` and its value from the list cache.
2033       *
2034       * @private
2035       * @name delete
2036       * @memberOf ListCache
2037       * @param {string} key The key of the value to remove.
2038       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2039       */
2040      function listCacheDelete(key) {
2041        var data = this.__data__,
2042            index = assocIndexOf(data, key);
2043  
2044        if (index < 0) {
2045          return false;
2046        }
2047        var lastIndex = data.length - 1;
2048        if (index == lastIndex) {
2049          data.pop();
2050        } else {
2051          splice.call(data, index, 1);
2052        }
2053        --this.size;
2054        return true;
2055      }
2056  
2057      /**
2058       * Gets the list cache value for `key`.
2059       *
2060       * @private
2061       * @name get
2062       * @memberOf ListCache
2063       * @param {string} key The key of the value to get.
2064       * @returns {*} Returns the entry value.
2065       */
2066      function listCacheGet(key) {
2067        var data = this.__data__,
2068            index = assocIndexOf(data, key);
2069  
2070        return index < 0 ? undefined : data[index][1];
2071      }
2072  
2073      /**
2074       * Checks if a list cache value for `key` exists.
2075       *
2076       * @private
2077       * @name has
2078       * @memberOf ListCache
2079       * @param {string} key The key of the entry to check.
2080       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2081       */
2082      function listCacheHas(key) {
2083        return assocIndexOf(this.__data__, key) > -1;
2084      }
2085  
2086      /**
2087       * Sets the list cache `key` to `value`.
2088       *
2089       * @private
2090       * @name set
2091       * @memberOf ListCache
2092       * @param {string} key The key of the value to set.
2093       * @param {*} value The value to set.
2094       * @returns {Object} Returns the list cache instance.
2095       */
2096      function listCacheSet(key, value) {
2097        var data = this.__data__,
2098            index = assocIndexOf(data, key);
2099  
2100        if (index < 0) {
2101          ++this.size;
2102          data.push([key, value]);
2103        } else {
2104          data[index][1] = value;
2105        }
2106        return this;
2107      }
2108  
2109      // Add methods to `ListCache`.
2110      ListCache.prototype.clear = listCacheClear;
2111      ListCache.prototype['delete'] = listCacheDelete;
2112      ListCache.prototype.get = listCacheGet;
2113      ListCache.prototype.has = listCacheHas;
2114      ListCache.prototype.set = listCacheSet;
2115  
2116      /*------------------------------------------------------------------------*/
2117  
2118      /**
2119       * Creates a map cache object to store key-value pairs.
2120       *
2121       * @private
2122       * @constructor
2123       * @param {Array} [entries] The key-value pairs to cache.
2124       */
2125      function MapCache(entries) {
2126        var index = -1,
2127            length = entries == null ? 0 : entries.length;
2128  
2129        this.clear();
2130        while (++index < length) {
2131          var entry = entries[index];
2132          this.set(entry[0], entry[1]);
2133        }
2134      }
2135  
2136      /**
2137       * Removes all key-value entries from the map.
2138       *
2139       * @private
2140       * @name clear
2141       * @memberOf MapCache
2142       */
2143      function mapCacheClear() {
2144        this.size = 0;
2145        this.__data__ = {
2146          'hash': new Hash,
2147          'map': new (Map || ListCache),
2148          'string': new Hash
2149        };
2150      }
2151  
2152      /**
2153       * Removes `key` and its value from the map.
2154       *
2155       * @private
2156       * @name delete
2157       * @memberOf MapCache
2158       * @param {string} key The key of the value to remove.
2159       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2160       */
2161      function mapCacheDelete(key) {
2162        var result = getMapData(this, key)['delete'](key);
2163        this.size -= result ? 1 : 0;
2164        return result;
2165      }
2166  
2167      /**
2168       * Gets the map value for `key`.
2169       *
2170       * @private
2171       * @name get
2172       * @memberOf MapCache
2173       * @param {string} key The key of the value to get.
2174       * @returns {*} Returns the entry value.
2175       */
2176      function mapCacheGet(key) {
2177        return getMapData(this, key).get(key);
2178      }
2179  
2180      /**
2181       * Checks if a map value for `key` exists.
2182       *
2183       * @private
2184       * @name has
2185       * @memberOf MapCache
2186       * @param {string} key The key of the entry to check.
2187       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2188       */
2189      function mapCacheHas(key) {
2190        return getMapData(this, key).has(key);
2191      }
2192  
2193      /**
2194       * Sets the map `key` to `value`.
2195       *
2196       * @private
2197       * @name set
2198       * @memberOf MapCache
2199       * @param {string} key The key of the value to set.
2200       * @param {*} value The value to set.
2201       * @returns {Object} Returns the map cache instance.
2202       */
2203      function mapCacheSet(key, value) {
2204        var data = getMapData(this, key),
2205            size = data.size;
2206  
2207        data.set(key, value);
2208        this.size += data.size == size ? 0 : 1;
2209        return this;
2210      }
2211  
2212      // Add methods to `MapCache`.
2213      MapCache.prototype.clear = mapCacheClear;
2214      MapCache.prototype['delete'] = mapCacheDelete;
2215      MapCache.prototype.get = mapCacheGet;
2216      MapCache.prototype.has = mapCacheHas;
2217      MapCache.prototype.set = mapCacheSet;
2218  
2219      /*------------------------------------------------------------------------*/
2220  
2221      /**
2222       *
2223       * Creates an array cache object to store unique values.
2224       *
2225       * @private
2226       * @constructor
2227       * @param {Array} [values] The values to cache.
2228       */
2229      function SetCache(values) {
2230        var index = -1,
2231            length = values == null ? 0 : values.length;
2232  
2233        this.__data__ = new MapCache;
2234        while (++index < length) {
2235          this.add(values[index]);
2236        }
2237      }
2238  
2239      /**
2240       * Adds `value` to the array cache.
2241       *
2242       * @private
2243       * @name add
2244       * @memberOf SetCache
2245       * @alias push
2246       * @param {*} value The value to cache.
2247       * @returns {Object} Returns the cache instance.
2248       */
2249      function setCacheAdd(value) {
2250        this.__data__.set(value, HASH_UNDEFINED);
2251        return this;
2252      }
2253  
2254      /**
2255       * Checks if `value` is in the array cache.
2256       *
2257       * @private
2258       * @name has
2259       * @memberOf SetCache
2260       * @param {*} value The value to search for.
2261       * @returns {number} Returns `true` if `value` is found, else `false`.
2262       */
2263      function setCacheHas(value) {
2264        return this.__data__.has(value);
2265      }
2266  
2267      // Add methods to `SetCache`.
2268      SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
2269      SetCache.prototype.has = setCacheHas;
2270  
2271      /*------------------------------------------------------------------------*/
2272  
2273      /**
2274       * Creates a stack cache object to store key-value pairs.
2275       *
2276       * @private
2277       * @constructor
2278       * @param {Array} [entries] The key-value pairs to cache.
2279       */
2280      function Stack(entries) {
2281        var data = this.__data__ = new ListCache(entries);
2282        this.size = data.size;
2283      }
2284  
2285      /**
2286       * Removes all key-value entries from the stack.
2287       *
2288       * @private
2289       * @name clear
2290       * @memberOf Stack
2291       */
2292      function stackClear() {
2293        this.__data__ = new ListCache;
2294        this.size = 0;
2295      }
2296  
2297      /**
2298       * Removes `key` and its value from the stack.
2299       *
2300       * @private
2301       * @name delete
2302       * @memberOf Stack
2303       * @param {string} key The key of the value to remove.
2304       * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2305       */
2306      function stackDelete(key) {
2307        var data = this.__data__,
2308            result = data['delete'](key);
2309  
2310        this.size = data.size;
2311        return result;
2312      }
2313  
2314      /**
2315       * Gets the stack value for `key`.
2316       *
2317       * @private
2318       * @name get
2319       * @memberOf Stack
2320       * @param {string} key The key of the value to get.
2321       * @returns {*} Returns the entry value.
2322       */
2323      function stackGet(key) {
2324        return this.__data__.get(key);
2325      }
2326  
2327      /**
2328       * Checks if a stack value for `key` exists.
2329       *
2330       * @private
2331       * @name has
2332       * @memberOf Stack
2333       * @param {string} key The key of the entry to check.
2334       * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2335       */
2336      function stackHas(key) {
2337        return this.__data__.has(key);
2338      }
2339  
2340      /**
2341       * Sets the stack `key` to `value`.
2342       *
2343       * @private
2344       * @name set
2345       * @memberOf Stack
2346       * @param {string} key The key of the value to set.
2347       * @param {*} value The value to set.
2348       * @returns {Object} Returns the stack cache instance.
2349       */
2350      function stackSet(key, value) {
2351        var data = this.__data__;
2352        if (data instanceof ListCache) {
2353          var pairs = data.__data__;
2354          if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
2355            pairs.push([key, value]);
2356            this.size = ++data.size;
2357            return this;
2358          }
2359          data = this.__data__ = new MapCache(pairs);
2360        }
2361        data.set(key, value);
2362        this.size = data.size;
2363        return this;
2364      }
2365  
2366      // Add methods to `Stack`.
2367      Stack.prototype.clear = stackClear;
2368      Stack.prototype['delete'] = stackDelete;
2369      Stack.prototype.get = stackGet;
2370      Stack.prototype.has = stackHas;
2371      Stack.prototype.set = stackSet;
2372  
2373      /*------------------------------------------------------------------------*/
2374  
2375      /**
2376       * Creates an array of the enumerable property names of the array-like `value`.
2377       *
2378       * @private
2379       * @param {*} value The value to query.
2380       * @param {boolean} inherited Specify returning inherited property names.
2381       * @returns {Array} Returns the array of property names.
2382       */
2383      function arrayLikeKeys(value, inherited) {
2384        var isArr = isArray(value),
2385            isArg = !isArr && isArguments(value),
2386            isBuff = !isArr && !isArg && isBuffer(value),
2387            isType = !isArr && !isArg && !isBuff && isTypedArray(value),
2388            skipIndexes = isArr || isArg || isBuff || isType,
2389            result = skipIndexes ? baseTimes(value.length, String) : [],
2390            length = result.length;
2391  
2392        for (var key in value) {
2393          if ((inherited || hasOwnProperty.call(value, key)) &&
2394              !(skipIndexes && (
2395                 // Safari 9 has enumerable `arguments.length` in strict mode.
2396                 key == 'length' ||
2397                 // Node.js 0.10 has enumerable non-index properties on buffers.
2398                 (isBuff && (key == 'offset' || key == 'parent')) ||
2399                 // PhantomJS 2 has enumerable non-index properties on typed arrays.
2400                 (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
2401                 // Skip index properties.
2402                 isIndex(key, length)
2403              ))) {
2404            result.push(key);
2405          }
2406        }
2407        return result;
2408      }
2409  
2410      /**
2411       * A specialized version of `_.sample` for arrays.
2412       *
2413       * @private
2414       * @param {Array} array The array to sample.
2415       * @returns {*} Returns the random element.
2416       */
2417      function arraySample(array) {
2418        var length = array.length;
2419        return length ? array[baseRandom(0, length - 1)] : undefined;
2420      }
2421  
2422      /**
2423       * A specialized version of `_.sampleSize` for arrays.
2424       *
2425       * @private
2426       * @param {Array} array The array to sample.
2427       * @param {number} n The number of elements to sample.
2428       * @returns {Array} Returns the random elements.
2429       */
2430      function arraySampleSize(array, n) {
2431        return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
2432      }
2433  
2434      /**
2435       * A specialized version of `_.shuffle` for arrays.
2436       *
2437       * @private
2438       * @param {Array} array The array to shuffle.
2439       * @returns {Array} Returns the new shuffled array.
2440       */
2441      function arrayShuffle(array) {
2442        return shuffleSelf(copyArray(array));
2443      }
2444  
2445      /**
2446       * This function is like `assignValue` except that it doesn't assign
2447       * `undefined` values.
2448       *
2449       * @private
2450       * @param {Object} object The object to modify.
2451       * @param {string} key The key of the property to assign.
2452       * @param {*} value The value to assign.
2453       */
2454      function assignMergeValue(object, key, value) {
2455        if ((value !== undefined && !eq(object[key], value)) ||
2456            (value === undefined && !(key in object))) {
2457          baseAssignValue(object, key, value);
2458        }
2459      }
2460  
2461      /**
2462       * Assigns `value` to `key` of `object` if the existing value is not equivalent
2463       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2464       * for equality comparisons.
2465       *
2466       * @private
2467       * @param {Object} object The object to modify.
2468       * @param {string} key The key of the property to assign.
2469       * @param {*} value The value to assign.
2470       */
2471      function assignValue(object, key, value) {
2472        var objValue = object[key];
2473        if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
2474            (value === undefined && !(key in object))) {
2475          baseAssignValue(object, key, value);
2476        }
2477      }
2478  
2479      /**
2480       * Gets the index at which the `key` is found in `array` of key-value pairs.
2481       *
2482       * @private
2483       * @param {Array} array The array to inspect.
2484       * @param {*} key The key to search for.
2485       * @returns {number} Returns the index of the matched value, else `-1`.
2486       */
2487      function assocIndexOf(array, key) {
2488        var length = array.length;
2489        while (length--) {
2490          if (eq(array[length][0], key)) {
2491            return length;
2492          }
2493        }
2494        return -1;
2495      }
2496  
2497      /**
2498       * Aggregates elements of `collection` on `accumulator` with keys transformed
2499       * by `iteratee` and values set by `setter`.
2500       *
2501       * @private
2502       * @param {Array|Object} collection The collection to iterate over.
2503       * @param {Function} setter The function to set `accumulator` values.
2504       * @param {Function} iteratee The iteratee to transform keys.
2505       * @param {Object} accumulator The initial aggregated object.
2506       * @returns {Function} Returns `accumulator`.
2507       */
2508      function baseAggregator(collection, setter, iteratee, accumulator) {
2509        baseEach(collection, function(value, key, collection) {
2510          setter(accumulator, value, iteratee(value), collection);
2511        });
2512        return accumulator;
2513      }
2514  
2515      /**
2516       * The base implementation of `_.assign` without support for multiple sources
2517       * or `customizer` functions.
2518       *
2519       * @private
2520       * @param {Object} object The destination object.
2521       * @param {Object} source The source object.
2522       * @returns {Object} Returns `object`.
2523       */
2524      function baseAssign(object, source) {
2525        return object && copyObject(source, keys(source), object);
2526      }
2527  
2528      /**
2529       * The base implementation of `_.assignIn` without support for multiple sources
2530       * or `customizer` functions.
2531       *
2532       * @private
2533       * @param {Object} object The destination object.
2534       * @param {Object} source The source object.
2535       * @returns {Object} Returns `object`.
2536       */
2537      function baseAssignIn(object, source) {
2538        return object && copyObject(source, keysIn(source), object);
2539      }
2540  
2541      /**
2542       * The base implementation of `assignValue` and `assignMergeValue` without
2543       * value checks.
2544       *
2545       * @private
2546       * @param {Object} object The object to modify.
2547       * @param {string} key The key of the property to assign.
2548       * @param {*} value The value to assign.
2549       */
2550      function baseAssignValue(object, key, value) {
2551        if (key == '__proto__' && defineProperty) {
2552          defineProperty(object, key, {
2553            'configurable': true,
2554            'enumerable': true,
2555            'value': value,
2556            'writable': true
2557          });
2558        } else {
2559          object[key] = value;
2560        }
2561      }
2562  
2563      /**
2564       * The base implementation of `_.at` without support for individual paths.
2565       *
2566       * @private
2567       * @param {Object} object The object to iterate over.
2568       * @param {string[]} paths The property paths to pick.
2569       * @returns {Array} Returns the picked elements.
2570       */
2571      function baseAt(object, paths) {
2572        var index = -1,
2573            length = paths.length,
2574            result = Array(length),
2575            skip = object == null;
2576  
2577        while (++index < length) {
2578          result[index] = skip ? undefined : get(object, paths[index]);
2579        }
2580        return result;
2581      }
2582  
2583      /**
2584       * The base implementation of `_.clamp` which doesn't coerce arguments.
2585       *
2586       * @private
2587       * @param {number} number The number to clamp.
2588       * @param {number} [lower] The lower bound.
2589       * @param {number} upper The upper bound.
2590       * @returns {number} Returns the clamped number.
2591       */
2592      function baseClamp(number, lower, upper) {
2593        if (number === number) {
2594          if (upper !== undefined) {
2595            number = number <= upper ? number : upper;
2596          }
2597          if (lower !== undefined) {
2598            number = number >= lower ? number : lower;
2599          }
2600        }
2601        return number;
2602      }
2603  
2604      /**
2605       * The base implementation of `_.clone` and `_.cloneDeep` which tracks
2606       * traversed objects.
2607       *
2608       * @private
2609       * @param {*} value The value to clone.
2610       * @param {boolean} bitmask The bitmask flags.
2611       *  1 - Deep clone
2612       *  2 - Flatten inherited properties
2613       *  4 - Clone symbols
2614       * @param {Function} [customizer] The function to customize cloning.
2615       * @param {string} [key] The key of `value`.
2616       * @param {Object} [object] The parent object of `value`.
2617       * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
2618       * @returns {*} Returns the cloned value.
2619       */
2620      function baseClone(value, bitmask, customizer, key, object, stack) {
2621        var result,
2622            isDeep = bitmask & CLONE_DEEP_FLAG,
2623            isFlat = bitmask & CLONE_FLAT_FLAG,
2624            isFull = bitmask & CLONE_SYMBOLS_FLAG;
2625  
2626        if (customizer) {
2627          result = object ? customizer(value, key, object, stack) : customizer(value);
2628        }
2629        if (result !== undefined) {
2630          return result;
2631        }
2632        if (!isObject(value)) {
2633          return value;
2634        }
2635        var isArr = isArray(value);
2636        if (isArr) {
2637          result = initCloneArray(value);
2638          if (!isDeep) {
2639            return copyArray(value, result);
2640          }
2641        } else {
2642          var tag = getTag(value),
2643              isFunc = tag == funcTag || tag == genTag;
2644  
2645          if (isBuffer(value)) {
2646            return cloneBuffer(value, isDeep);
2647          }
2648          if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
2649            result = (isFlat || isFunc) ? {} : initCloneObject(value);
2650            if (!isDeep) {
2651              return isFlat
2652                ? copySymbolsIn(value, baseAssignIn(result, value))
2653                : copySymbols(value, baseAssign(result, value));
2654            }
2655          } else {
2656            if (!cloneableTags[tag]) {
2657              return object ? value : {};
2658            }
2659            result = initCloneByTag(value, tag, isDeep);
2660          }
2661        }
2662        // Check for circular references and return its corresponding clone.
2663        stack || (stack = new Stack);
2664        var stacked = stack.get(value);
2665        if (stacked) {
2666          return stacked;
2667        }
2668        stack.set(value, result);
2669  
2670        if (isSet(value)) {
2671          value.forEach(function(subValue) {
2672            result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
2673          });
2674        } else if (isMap(value)) {
2675          value.forEach(function(subValue, key) {
2676            result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
2677          });
2678        }
2679  
2680        var keysFunc = isFull
2681          ? (isFlat ? getAllKeysIn : getAllKeys)
2682          : (isFlat ? keysIn : keys);
2683  
2684        var props = isArr ? undefined : keysFunc(value);
2685        arrayEach(props || value, function(subValue, key) {
2686          if (props) {
2687            key = subValue;
2688            subValue = value[key];
2689          }
2690          // Recursively populate clone (susceptible to call stack limits).
2691          assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
2692        });
2693        return result;
2694      }
2695  
2696      /**
2697       * The base implementation of `_.conforms` which doesn't clone `source`.
2698       *
2699       * @private
2700       * @param {Object} source The object of property predicates to conform to.
2701       * @returns {Function} Returns the new spec function.
2702       */
2703      function baseConforms(source) {
2704        var props = keys(source);
2705        return function(object) {
2706          return baseConformsTo(object, source, props);
2707        };
2708      }
2709  
2710      /**
2711       * The base implementation of `_.conformsTo` which accepts `props` to check.
2712       *
2713       * @private
2714       * @param {Object} object The object to inspect.
2715       * @param {Object} source The object of property predicates to conform to.
2716       * @returns {boolean} Returns `true` if `object` conforms, else `false`.
2717       */
2718      function baseConformsTo(object, source, props) {
2719        var length = props.length;
2720        if (object == null) {
2721          return !length;
2722        }
2723        object = Object(object);
2724        while (length--) {
2725          var key = props[length],
2726              predicate = source[key],
2727              value = object[key];
2728  
2729          if ((value === undefined && !(key in object)) || !predicate(value)) {
2730            return false;
2731          }
2732        }
2733        return true;
2734      }
2735  
2736      /**
2737       * The base implementation of `_.delay` and `_.defer` which accepts `args`
2738       * to provide to `func`.
2739       *
2740       * @private
2741       * @param {Function} func The function to delay.
2742       * @param {number} wait The number of milliseconds to delay invocation.
2743       * @param {Array} args The arguments to provide to `func`.
2744       * @returns {number|Object} Returns the timer id or timeout object.
2745       */
2746      function baseDelay(func, wait, args) {
2747        if (typeof func != 'function') {
2748          throw new TypeError(FUNC_ERROR_TEXT);
2749        }
2750        return setTimeout(function() { func.apply(undefined, args); }, wait);
2751      }
2752  
2753      /**
2754       * The base implementation of methods like `_.difference` without support
2755       * for excluding multiple arrays or iteratee shorthands.
2756       *
2757       * @private
2758       * @param {Array} array The array to inspect.
2759       * @param {Array} values The values to exclude.
2760       * @param {Function} [iteratee] The iteratee invoked per element.
2761       * @param {Function} [comparator] The comparator invoked per element.
2762       * @returns {Array} Returns the new array of filtered values.
2763       */
2764      function baseDifference(array, values, iteratee, comparator) {
2765        var index = -1,
2766            includes = arrayIncludes,
2767            isCommon = true,
2768            length = array.length,
2769            result = [],
2770            valuesLength = values.length;
2771  
2772        if (!length) {
2773          return result;
2774        }
2775        if (iteratee) {
2776          values = arrayMap(values, baseUnary(iteratee));
2777        }
2778        if (comparator) {
2779          includes = arrayIncludesWith;
2780          isCommon = false;
2781        }
2782        else if (values.length >= LARGE_ARRAY_SIZE) {
2783          includes = cacheHas;
2784          isCommon = false;
2785          values = new SetCache(values);
2786        }
2787        outer:
2788        while (++index < length) {
2789          var value = array[index],
2790              computed = iteratee == null ? value : iteratee(value);
2791  
2792          value = (comparator || value !== 0) ? value : 0;
2793          if (isCommon && computed === computed) {
2794            var valuesIndex = valuesLength;
2795            while (valuesIndex--) {
2796              if (values[valuesIndex] === computed) {
2797                continue outer;
2798              }
2799            }
2800            result.push(value);
2801          }
2802          else if (!includes(values, computed, comparator)) {
2803            result.push(value);
2804          }
2805        }
2806        return result;
2807      }
2808  
2809      /**
2810       * The base implementation of `_.forEach` without support for iteratee shorthands.
2811       *
2812       * @private
2813       * @param {Array|Object} collection The collection to iterate over.
2814       * @param {Function} iteratee The function invoked per iteration.
2815       * @returns {Array|Object} Returns `collection`.
2816       */
2817      var baseEach = createBaseEach(baseForOwn);
2818  
2819      /**
2820       * The base implementation of `_.forEachRight` without support for iteratee shorthands.
2821       *
2822       * @private
2823       * @param {Array|Object} collection The collection to iterate over.
2824       * @param {Function} iteratee The function invoked per iteration.
2825       * @returns {Array|Object} Returns `collection`.
2826       */
2827      var baseEachRight = createBaseEach(baseForOwnRight, true);
2828  
2829      /**
2830       * The base implementation of `_.every` without support for iteratee shorthands.
2831       *
2832       * @private
2833       * @param {Array|Object} collection The collection to iterate over.
2834       * @param {Function} predicate The function invoked per iteration.
2835       * @returns {boolean} Returns `true` if all elements pass the predicate check,
2836       *  else `false`
2837       */
2838      function baseEvery(collection, predicate) {
2839        var result = true;
2840        baseEach(collection, function(value, index, collection) {
2841          result = !!predicate(value, index, collection);
2842          return result;
2843        });
2844        return result;
2845      }
2846  
2847      /**
2848       * The base implementation of methods like `_.max` and `_.min` which accepts a
2849       * `comparator` to determine the extremum value.
2850       *
2851       * @private
2852       * @param {Array} array The array to iterate over.
2853       * @param {Function} iteratee The iteratee invoked per iteration.
2854       * @param {Function} comparator The comparator used to compare values.
2855       * @returns {*} Returns the extremum value.
2856       */
2857      function baseExtremum(array, iteratee, comparator) {
2858        var index = -1,
2859            length = array.length;
2860  
2861        while (++index < length) {
2862          var value = array[index],
2863              current = iteratee(value);
2864  
2865          if (current != null && (computed === undefined
2866                ? (current === current && !isSymbol(current))
2867                : comparator(current, computed)
2868              )) {
2869            var computed = current,
2870                result = value;
2871          }
2872        }
2873        return result;
2874      }
2875  
2876      /**
2877       * The base implementation of `_.fill` without an iteratee call guard.
2878       *
2879       * @private
2880       * @param {Array} array The array to fill.
2881       * @param {*} value The value to fill `array` with.
2882       * @param {number} [start=0] The start position.
2883       * @param {number} [end=array.length] The end position.
2884       * @returns {Array} Returns `array`.
2885       */
2886      function baseFill(array, value, start, end) {
2887        var length = array.length;
2888  
2889        start = toInteger(start);
2890        if (start < 0) {
2891          start = -start > length ? 0 : (length + start);
2892        }
2893        end = (end === undefined || end > length) ? length : toInteger(end);
2894        if (end < 0) {
2895          end += length;
2896        }
2897        end = start > end ? 0 : toLength(end);
2898        while (start < end) {
2899          array[start++] = value;
2900        }
2901        return array;
2902      }
2903  
2904      /**
2905       * The base implementation of `_.filter` without support for iteratee shorthands.
2906       *
2907       * @private
2908       * @param {Array|Object} collection The collection to iterate over.
2909       * @param {Function} predicate The function invoked per iteration.
2910       * @returns {Array} Returns the new filtered array.
2911       */
2912      function baseFilter(collection, predicate) {
2913        var result = [];
2914        baseEach(collection, function(value, index, collection) {
2915          if (predicate(value, index, collection)) {
2916            result.push(value);
2917          }
2918        });
2919        return result;
2920      }
2921  
2922      /**
2923       * The base implementation of `_.flatten` with support for restricting flattening.
2924       *
2925       * @private
2926       * @param {Array} array The array to flatten.
2927       * @param {number} depth The maximum recursion depth.
2928       * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
2929       * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
2930       * @param {Array} [result=[]] The initial result value.
2931       * @returns {Array} Returns the new flattened array.
2932       */
2933      function baseFlatten(array, depth, predicate, isStrict, result) {
2934        var index = -1,
2935            length = array.length;
2936  
2937        predicate || (predicate = isFlattenable);
2938        result || (result = []);
2939  
2940        while (++index < length) {
2941          var value = array[index];
2942          if (depth > 0 && predicate(value)) {
2943            if (depth > 1) {
2944              // Recursively flatten arrays (susceptible to call stack limits).
2945              baseFlatten(value, depth - 1, predicate, isStrict, result);
2946            } else {
2947              arrayPush(result, value);
2948            }
2949          } else if (!isStrict) {
2950            result[result.length] = value;
2951          }
2952        }
2953        return result;
2954      }
2955  
2956      /**
2957       * The base implementation of `baseForOwn` which iterates over `object`
2958       * properties returned by `keysFunc` and invokes `iteratee` for each property.
2959       * Iteratee functions may exit iteration early by explicitly returning `false`.
2960       *
2961       * @private
2962       * @param {Object} object The object to iterate over.
2963       * @param {Function} iteratee The function invoked per iteration.
2964       * @param {Function} keysFunc The function to get the keys of `object`.
2965       * @returns {Object} Returns `object`.
2966       */
2967      var baseFor = createBaseFor();
2968  
2969      /**
2970       * This function is like `baseFor` except that it iterates over properties
2971       * in the opposite order.
2972       *
2973       * @private
2974       * @param {Object} object The object to iterate over.
2975       * @param {Function} iteratee The function invoked per iteration.
2976       * @param {Function} keysFunc The function to get the keys of `object`.
2977       * @returns {Object} Returns `object`.
2978       */
2979      var baseForRight = createBaseFor(true);
2980  
2981      /**
2982       * The base implementation of `_.forOwn` without support for iteratee shorthands.
2983       *
2984       * @private
2985       * @param {Object} object The object to iterate over.
2986       * @param {Function} iteratee The function invoked per iteration.
2987       * @returns {Object} Returns `object`.
2988       */
2989      function baseForOwn(object, iteratee) {
2990        return object && baseFor(object, iteratee, keys);
2991      }
2992  
2993      /**
2994       * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
2995       *
2996       * @private
2997       * @param {Object} object The object to iterate over.
2998       * @param {Function} iteratee The function invoked per iteration.
2999       * @returns {Object} Returns `object`.
3000       */
3001      function baseForOwnRight(object, iteratee) {
3002        return object && baseForRight(object, iteratee, keys);
3003      }
3004  
3005      /**
3006       * The base implementation of `_.functions` which creates an array of
3007       * `object` function property names filtered from `props`.
3008       *
3009       * @private
3010       * @param {Object} object The object to inspect.
3011       * @param {Array} props The property names to filter.
3012       * @returns {Array} Returns the function names.
3013       */
3014      function baseFunctions(object, props) {
3015        return arrayFilter(props, function(key) {
3016          return isFunction(object[key]);
3017        });
3018      }
3019  
3020      /**
3021       * The base implementation of `_.get` without support for default values.
3022       *
3023       * @private
3024       * @param {Object} object The object to query.
3025       * @param {Array|string} path The path of the property to get.
3026       * @returns {*} Returns the resolved value.
3027       */
3028      function baseGet(object, path) {
3029        path = castPath(path, object);
3030  
3031        var index = 0,
3032            length = path.length;
3033  
3034        while (object != null && index < length) {
3035          object = object[toKey(path[index++])];
3036        }
3037        return (index && index == length) ? object : undefined;
3038      }
3039  
3040      /**
3041       * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
3042       * `keysFunc` and `symbolsFunc` to get the enumerable property names and
3043       * symbols of `object`.
3044       *
3045       * @private
3046       * @param {Object} object The object to query.
3047       * @param {Function} keysFunc The function to get the keys of `object`.
3048       * @param {Function} symbolsFunc The function to get the symbols of `object`.
3049       * @returns {Array} Returns the array of property names and symbols.
3050       */
3051      function baseGetAllKeys(object, keysFunc, symbolsFunc) {
3052        var result = keysFunc(object);
3053        return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
3054      }
3055  
3056      /**
3057       * The base implementation of `getTag` without fallbacks for buggy environments.
3058       *
3059       * @private
3060       * @param {*} value The value to query.
3061       * @returns {string} Returns the `toStringTag`.
3062       */
3063      function baseGetTag(value) {
3064        if (value == null) {
3065          return value === undefined ? undefinedTag : nullTag;
3066        }
3067        return (symToStringTag && symToStringTag in Object(value))
3068          ? getRawTag(value)
3069          : objectToString(value);
3070      }
3071  
3072      /**
3073       * The base implementation of `_.gt` which doesn't coerce arguments.
3074       *
3075       * @private
3076       * @param {*} value The value to compare.
3077       * @param {*} other The other value to compare.
3078       * @returns {boolean} Returns `true` if `value` is greater than `other`,
3079       *  else `false`.
3080       */
3081      function baseGt(value, other) {
3082        return value > other;
3083      }
3084  
3085      /**
3086       * The base implementation of `_.has` without support for deep paths.
3087       *
3088       * @private
3089       * @param {Object} [object] The object to query.
3090       * @param {Array|string} key The key to check.
3091       * @returns {boolean} Returns `true` if `key` exists, else `false`.
3092       */
3093      function baseHas(object, key) {
3094        return object != null && hasOwnProperty.call(object, key);
3095      }
3096  
3097      /**
3098       * The base implementation of `_.hasIn` without support for deep paths.
3099       *
3100       * @private
3101       * @param {Object} [object] The object to query.
3102       * @param {Array|string} key The key to check.
3103       * @returns {boolean} Returns `true` if `key` exists, else `false`.
3104       */
3105      function baseHasIn(object, key) {
3106        return object != null && key in Object(object);
3107      }
3108  
3109      /**
3110       * The base implementation of `_.inRange` which doesn't coerce arguments.
3111       *
3112       * @private
3113       * @param {number} number The number to check.
3114       * @param {number} start The start of the range.
3115       * @param {number} end The end of the range.
3116       * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
3117       */
3118      function baseInRange(number, start, end) {
3119        return number >= nativeMin(start, end) && number < nativeMax(start, end);
3120      }
3121  
3122      /**
3123       * The base implementation of methods like `_.intersection`, without support
3124       * for iteratee shorthands, that accepts an array of arrays to inspect.
3125       *
3126       * @private
3127       * @param {Array} arrays The arrays to inspect.
3128       * @param {Function} [iteratee] The iteratee invoked per element.
3129       * @param {Function} [comparator] The comparator invoked per element.
3130       * @returns {Array} Returns the new array of shared values.
3131       */
3132      function baseIntersection(arrays, iteratee, comparator) {
3133        var includes = comparator ? arrayIncludesWith : arrayIncludes,
3134            length = arrays[0].length,
3135            othLength = arrays.length,
3136            othIndex = othLength,
3137            caches = Array(othLength),
3138            maxLength = Infinity,
3139            result = [];
3140  
3141        while (othIndex--) {
3142          var array = arrays[othIndex];
3143          if (othIndex && iteratee) {
3144            array = arrayMap(array, baseUnary(iteratee));
3145          }
3146          maxLength = nativeMin(array.length, maxLength);
3147          caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
3148            ? new SetCache(othIndex && array)
3149            : undefined;
3150        }
3151        array = arrays[0];
3152  
3153        var index = -1,
3154            seen = caches[0];
3155  
3156        outer:
3157        while (++index < length && result.length < maxLength) {
3158          var value = array[index],
3159              computed = iteratee ? iteratee(value) : value;
3160  
3161          value = (comparator || value !== 0) ? value : 0;
3162          if (!(seen
3163                ? cacheHas(seen, computed)
3164                : includes(result, computed, comparator)
3165              )) {
3166            othIndex = othLength;
3167            while (--othIndex) {
3168              var cache = caches[othIndex];
3169              if (!(cache
3170                    ? cacheHas(cache, computed)
3171                    : includes(arrays[othIndex], computed, comparator))
3172                  ) {
3173                continue outer;
3174              }
3175            }
3176            if (seen) {
3177              seen.push(computed);
3178            }
3179            result.push(value);
3180          }
3181        }
3182        return result;
3183      }
3184  
3185      /**
3186       * The base implementation of `_.invert` and `_.invertBy` which inverts
3187       * `object` with values transformed by `iteratee` and set by `setter`.
3188       *
3189       * @private
3190       * @param {Object} object The object to iterate over.
3191       * @param {Function} setter The function to set `accumulator` values.
3192       * @param {Function} iteratee The iteratee to transform values.
3193       * @param {Object} accumulator The initial inverted object.
3194       * @returns {Function} Returns `accumulator`.
3195       */
3196      function baseInverter(object, setter, iteratee, accumulator) {
3197        baseForOwn(object, function(value, key, object) {
3198          setter(accumulator, iteratee(value), key, object);
3199        });
3200        return accumulator;
3201      }
3202  
3203      /**
3204       * The base implementation of `_.invoke` without support for individual
3205       * method arguments.
3206       *
3207       * @private
3208       * @param {Object} object The object to query.
3209       * @param {Array|string} path The path of the method to invoke.
3210       * @param {Array} args The arguments to invoke the method with.
3211       * @returns {*} Returns the result of the invoked method.
3212       */
3213      function baseInvoke(object, path, args) {
3214        path = castPath(path, object);
3215        object = parent(object, path);
3216        var func = object == null ? object : object[toKey(last(path))];
3217        return func == null ? undefined : apply(func, object, args);
3218      }
3219  
3220      /**
3221       * The base implementation of `_.isArguments`.
3222       *
3223       * @private
3224       * @param {*} value The value to check.
3225       * @returns {boolean} Returns `true` if `value` is an `arguments` object,
3226       */
3227      function baseIsArguments(value) {
3228        return isObjectLike(value) && baseGetTag(value) == argsTag;
3229      }
3230  
3231      /**
3232       * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
3233       *
3234       * @private
3235       * @param {*} value The value to check.
3236       * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
3237       */
3238      function baseIsArrayBuffer(value) {
3239        return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
3240      }
3241  
3242      /**
3243       * The base implementation of `_.isDate` without Node.js optimizations.
3244       *
3245       * @private
3246       * @param {*} value The value to check.
3247       * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
3248       */
3249      function baseIsDate(value) {
3250        return isObjectLike(value) && baseGetTag(value) == dateTag;
3251      }
3252  
3253      /**
3254       * The base implementation of `_.isEqual` which supports partial comparisons
3255       * and tracks traversed objects.
3256       *
3257       * @private
3258       * @param {*} value The value to compare.
3259       * @param {*} other The other value to compare.
3260       * @param {boolean} bitmask The bitmask flags.
3261       *  1 - Unordered comparison
3262       *  2 - Partial comparison
3263       * @param {Function} [customizer] The function to customize comparisons.
3264       * @param {Object} [stack] Tracks traversed `value` and `other` objects.
3265       * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
3266       */
3267      function baseIsEqual(value, other, bitmask, customizer, stack) {
3268        if (value === other) {
3269          return true;
3270        }
3271        if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
3272          return value !== value && other !== other;
3273        }
3274        return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
3275      }
3276  
3277      /**
3278       * A specialized version of `baseIsEqual` for arrays and objects which performs
3279       * deep comparisons and tracks traversed objects enabling objects with circular
3280       * references to be compared.
3281       *
3282       * @private
3283       * @param {Object} object The object to compare.
3284       * @param {Object} other The other object to compare.
3285       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
3286       * @param {Function} customizer The function to customize comparisons.
3287       * @param {Function} equalFunc The function to determine equivalents of values.
3288       * @param {Object} [stack] Tracks traversed `object` and `other` objects.
3289       * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
3290       */
3291      function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
3292        var objIsArr = isArray(object),
3293            othIsArr = isArray(other),
3294            objTag = objIsArr ? arrayTag : getTag(object),
3295            othTag = othIsArr ? arrayTag : getTag(other);
3296  
3297        objTag = objTag == argsTag ? objectTag : objTag;
3298        othTag = othTag == argsTag ? objectTag : othTag;
3299  
3300        var objIsObj = objTag == objectTag,
3301            othIsObj = othTag == objectTag,
3302            isSameTag = objTag == othTag;
3303  
3304        if (isSameTag && isBuffer(object)) {
3305          if (!isBuffer(other)) {
3306            return false;
3307          }
3308          objIsArr = true;
3309          objIsObj = false;
3310        }
3311        if (isSameTag && !objIsObj) {
3312          stack || (stack = new Stack);
3313          return (objIsArr || isTypedArray(object))
3314            ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
3315            : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
3316        }
3317        if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
3318          var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
3319              othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
3320  
3321          if (objIsWrapped || othIsWrapped) {
3322            var objUnwrapped = objIsWrapped ? object.value() : object,
3323                othUnwrapped = othIsWrapped ? other.value() : other;
3324  
3325            stack || (stack = new Stack);
3326            return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
3327          }
3328        }
3329        if (!isSameTag) {
3330          return false;
3331        }
3332        stack || (stack = new Stack);
3333        return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
3334      }
3335  
3336      /**
3337       * The base implementation of `_.isMap` without Node.js optimizations.
3338       *
3339       * @private
3340       * @param {*} value The value to check.
3341       * @returns {boolean} Returns `true` if `value` is a map, else `false`.
3342       */
3343      function baseIsMap(value) {
3344        return isObjectLike(value) && getTag(value) == mapTag;
3345      }
3346  
3347      /**
3348       * The base implementation of `_.isMatch` without support for iteratee shorthands.
3349       *
3350       * @private
3351       * @param {Object} object The object to inspect.
3352       * @param {Object} source The object of property values to match.
3353       * @param {Array} matchData The property names, values, and compare flags to match.
3354       * @param {Function} [customizer] The function to customize comparisons.
3355       * @returns {boolean} Returns `true` if `object` is a match, else `false`.
3356       */
3357      function baseIsMatch(object, source, matchData, customizer) {
3358        var index = matchData.length,
3359            length = index,
3360            noCustomizer = !customizer;
3361  
3362        if (object == null) {
3363          return !length;
3364        }
3365        object = Object(object);
3366        while (index--) {
3367          var data = matchData[index];
3368          if ((noCustomizer && data[2])
3369                ? data[1] !== object[data[0]]
3370                : !(data[0] in object)
3371              ) {
3372            return false;
3373          }
3374        }
3375        while (++index < length) {
3376          data = matchData[index];
3377          var key = data[0],
3378              objValue = object[key],
3379              srcValue = data[1];
3380  
3381          if (noCustomizer && data[2]) {
3382            if (objValue === undefined && !(key in object)) {
3383              return false;
3384            }
3385          } else {
3386            var stack = new Stack;
3387            if (customizer) {
3388              var result = customizer(objValue, srcValue, key, object, source, stack);
3389            }
3390            if (!(result === undefined
3391                  ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
3392                  : result
3393                )) {
3394              return false;
3395            }
3396          }
3397        }
3398        return true;
3399      }
3400  
3401      /**
3402       * The base implementation of `_.isNative` without bad shim checks.
3403       *
3404       * @private
3405       * @param {*} value The value to check.
3406       * @returns {boolean} Returns `true` if `value` is a native function,
3407       *  else `false`.
3408       */
3409      function baseIsNative(value) {
3410        if (!isObject(value) || isMasked(value)) {
3411          return false;
3412        }
3413        var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
3414        return pattern.test(toSource(value));
3415      }
3416  
3417      /**
3418       * The base implementation of `_.isRegExp` without Node.js optimizations.
3419       *
3420       * @private
3421       * @param {*} value The value to check.
3422       * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
3423       */
3424      function baseIsRegExp(value) {
3425        return isObjectLike(value) && baseGetTag(value) == regexpTag;
3426      }
3427  
3428      /**
3429       * The base implementation of `_.isSet` without Node.js optimizations.
3430       *
3431       * @private
3432       * @param {*} value The value to check.
3433       * @returns {boolean} Returns `true` if `value` is a set, else `false`.
3434       */
3435      function baseIsSet(value) {
3436        return isObjectLike(value) && getTag(value) == setTag;
3437      }
3438  
3439      /**
3440       * The base implementation of `_.isTypedArray` without Node.js optimizations.
3441       *
3442       * @private
3443       * @param {*} value The value to check.
3444       * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
3445       */
3446      function baseIsTypedArray(value) {
3447        return isObjectLike(value) &&
3448          isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
3449      }
3450  
3451      /**
3452       * The base implementation of `_.iteratee`.
3453       *
3454       * @private
3455       * @param {*} [value=_.identity] The value to convert to an iteratee.
3456       * @returns {Function} Returns the iteratee.
3457       */
3458      function baseIteratee(value) {
3459        // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
3460        // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
3461        if (typeof value == 'function') {
3462          return value;
3463        }
3464        if (value == null) {
3465          return identity;
3466        }
3467        if (typeof value == 'object') {
3468          return isArray(value)
3469            ? baseMatchesProperty(value[0], value[1])
3470            : baseMatches(value);
3471        }
3472        return property(value);
3473      }
3474  
3475      /**
3476       * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
3477       *
3478       * @private
3479       * @param {Object} object The object to query.
3480       * @returns {Array} Returns the array of property names.
3481       */
3482      function baseKeys(object) {
3483        if (!isPrototype(object)) {
3484          return nativeKeys(object);
3485        }
3486        var result = [];
3487        for (var key in Object(object)) {
3488          if (hasOwnProperty.call(object, key) && key != 'constructor') {
3489            result.push(key);
3490          }
3491        }
3492        return result;
3493      }
3494  
3495      /**
3496       * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
3497       *
3498       * @private
3499       * @param {Object} object The object to query.
3500       * @returns {Array} Returns the array of property names.
3501       */
3502      function baseKeysIn(object) {
3503        if (!isObject(object)) {
3504          return nativeKeysIn(object);
3505        }
3506        var isProto = isPrototype(object),
3507            result = [];
3508  
3509        for (var key in object) {
3510          if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
3511            result.push(key);
3512          }
3513        }
3514        return result;
3515      }
3516  
3517      /**
3518       * The base implementation of `_.lt` which doesn't coerce arguments.
3519       *
3520       * @private
3521       * @param {*} value The value to compare.
3522       * @param {*} other The other value to compare.
3523       * @returns {boolean} Returns `true` if `value` is less than `other`,
3524       *  else `false`.
3525       */
3526      function baseLt(value, other) {
3527        return value < other;
3528      }
3529  
3530      /**
3531       * The base implementation of `_.map` without support for iteratee shorthands.
3532       *
3533       * @private
3534       * @param {Array|Object} collection The collection to iterate over.
3535       * @param {Function} iteratee The function invoked per iteration.
3536       * @returns {Array} Returns the new mapped array.
3537       */
3538      function baseMap(collection, iteratee) {
3539        var index = -1,
3540            result = isArrayLike(collection) ? Array(collection.length) : [];
3541  
3542        baseEach(collection, function(value, key, collection) {
3543          result[++index] = iteratee(value, key, collection);
3544        });
3545        return result;
3546      }
3547  
3548      /**
3549       * The base implementation of `_.matches` which doesn't clone `source`.
3550       *
3551       * @private
3552       * @param {Object} source The object of property values to match.
3553       * @returns {Function} Returns the new spec function.
3554       */
3555      function baseMatches(source) {
3556        var matchData = getMatchData(source);
3557        if (matchData.length == 1 && matchData[0][2]) {
3558          return matchesStrictComparable(matchData[0][0], matchData[0][1]);
3559        }
3560        return function(object) {
3561          return object === source || baseIsMatch(object, source, matchData);
3562        };
3563      }
3564  
3565      /**
3566       * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
3567       *
3568       * @private
3569       * @param {string} path The path of the property to get.
3570       * @param {*} srcValue The value to match.
3571       * @returns {Function} Returns the new spec function.
3572       */
3573      function baseMatchesProperty(path, srcValue) {
3574        if (isKey(path) && isStrictComparable(srcValue)) {
3575          return matchesStrictComparable(toKey(path), srcValue);
3576        }
3577        return function(object) {
3578          var objValue = get(object, path);
3579          return (objValue === undefined && objValue === srcValue)
3580            ? hasIn(object, path)
3581            : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
3582        };
3583      }
3584  
3585      /**
3586       * The base implementation of `_.merge` without support for multiple sources.
3587       *
3588       * @private
3589       * @param {Object} object The destination object.
3590       * @param {Object} source The source object.
3591       * @param {number} srcIndex The index of `source`.
3592       * @param {Function} [customizer] The function to customize merged values.
3593       * @param {Object} [stack] Tracks traversed source values and their merged
3594       *  counterparts.
3595       */
3596      function baseMerge(object, source, srcIndex, customizer, stack) {
3597        if (object === source) {
3598          return;
3599        }
3600        baseFor(source, function(srcValue, key) {
3601          stack || (stack = new Stack);
3602          if (isObject(srcValue)) {
3603            baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
3604          }
3605          else {
3606            var newValue = customizer
3607              ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
3608              : undefined;
3609  
3610            if (newValue === undefined) {
3611              newValue = srcValue;
3612            }
3613            assignMergeValue(object, key, newValue);
3614          }
3615        }, keysIn);
3616      }
3617  
3618      /**
3619       * A specialized version of `baseMerge` for arrays and objects which performs
3620       * deep merges and tracks traversed objects enabling objects with circular
3621       * references to be merged.
3622       *
3623       * @private
3624       * @param {Object} object The destination object.
3625       * @param {Object} source The source object.
3626       * @param {string} key The key of the value to merge.
3627       * @param {number} srcIndex The index of `source`.
3628       * @param {Function} mergeFunc The function to merge values.
3629       * @param {Function} [customizer] The function to customize assigned values.
3630       * @param {Object} [stack] Tracks traversed source values and their merged
3631       *  counterparts.
3632       */
3633      function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
3634        var objValue = safeGet(object, key),
3635            srcValue = safeGet(source, key),
3636            stacked = stack.get(srcValue);
3637  
3638        if (stacked) {
3639          assignMergeValue(object, key, stacked);
3640          return;
3641        }
3642        var newValue = customizer
3643          ? customizer(objValue, srcValue, (key + ''), object, source, stack)
3644          : undefined;
3645  
3646        var isCommon = newValue === undefined;
3647  
3648        if (isCommon) {
3649          var isArr = isArray(srcValue),
3650              isBuff = !isArr && isBuffer(srcValue),
3651              isTyped = !isArr && !isBuff && isTypedArray(srcValue);
3652  
3653          newValue = srcValue;
3654          if (isArr || isBuff || isTyped) {
3655            if (isArray(objValue)) {
3656              newValue = objValue;
3657            }
3658            else if (isArrayLikeObject(objValue)) {
3659              newValue = copyArray(objValue);
3660            }
3661            else if (isBuff) {
3662              isCommon = false;
3663              newValue = cloneBuffer(srcValue, true);
3664            }
3665            else if (isTyped) {
3666              isCommon = false;
3667              newValue = cloneTypedArray(srcValue, true);
3668            }
3669            else {
3670              newValue = [];
3671            }
3672          }
3673          else if (isPlainObject(srcValue) || isArguments(srcValue)) {
3674            newValue = objValue;
3675            if (isArguments(objValue)) {
3676              newValue = toPlainObject(objValue);
3677            }
3678            else if (!isObject(objValue) || isFunction(objValue)) {
3679              newValue = initCloneObject(srcValue);
3680            }
3681          }
3682          else {
3683            isCommon = false;
3684          }
3685        }
3686        if (isCommon) {
3687          // Recursively merge objects and arrays (susceptible to call stack limits).
3688          stack.set(srcValue, newValue);
3689          mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
3690          stack['delete'](srcValue);
3691        }
3692        assignMergeValue(object, key, newValue);
3693      }
3694  
3695      /**
3696       * The base implementation of `_.nth` which doesn't coerce arguments.
3697       *
3698       * @private
3699       * @param {Array} array The array to query.
3700       * @param {number} n The index of the element to return.
3701       * @returns {*} Returns the nth element of `array`.
3702       */
3703      function baseNth(array, n) {
3704        var length = array.length;
3705        if (!length) {
3706          return;
3707        }
3708        n += n < 0 ? length : 0;
3709        return isIndex(n, length) ? array[n] : undefined;
3710      }
3711  
3712      /**
3713       * The base implementation of `_.orderBy` without param guards.
3714       *
3715       * @private
3716       * @param {Array|Object} collection The collection to iterate over.
3717       * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
3718       * @param {string[]} orders The sort orders of `iteratees`.
3719       * @returns {Array} Returns the new sorted array.
3720       */
3721      function baseOrderBy(collection, iteratees, orders) {
3722        var index = -1;
3723        iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));
3724  
3725        var result = baseMap(collection, function(value, key, collection) {
3726          var criteria = arrayMap(iteratees, function(iteratee) {
3727            return iteratee(value);
3728          });
3729          return { 'criteria': criteria, 'index': ++index, 'value': value };
3730        });
3731  
3732        return baseSortBy(result, function(object, other) {
3733          return compareMultiple(object, other, orders);
3734        });
3735      }
3736  
3737      /**
3738       * The base implementation of `_.pick` without support for individual
3739       * property identifiers.
3740       *
3741       * @private
3742       * @param {Object} object The source object.
3743       * @param {string[]} paths The property paths to pick.
3744       * @returns {Object} Returns the new object.
3745       */
3746      function basePick(object, paths) {
3747        return basePickBy(object, paths, function(value, path) {
3748          return hasIn(object, path);
3749        });
3750      }
3751  
3752      /**
3753       * The base implementation of  `_.pickBy` without support for iteratee shorthands.
3754       *
3755       * @private
3756       * @param {Object} object The source object.
3757       * @param {string[]} paths The property paths to pick.
3758       * @param {Function} predicate The function invoked per property.
3759       * @returns {Object} Returns the new object.
3760       */
3761      function basePickBy(object, paths, predicate) {
3762        var index = -1,
3763            length = paths.length,
3764            result = {};
3765  
3766        while (++index < length) {
3767          var path = paths[index],
3768              value = baseGet(object, path);
3769  
3770          if (predicate(value, path)) {
3771            baseSet(result, castPath(path, object), value);
3772          }
3773        }
3774        return result;
3775      }
3776  
3777      /**
3778       * A specialized version of `baseProperty` which supports deep paths.
3779       *
3780       * @private
3781       * @param {Array|string} path The path of the property to get.
3782       * @returns {Function} Returns the new accessor function.
3783       */
3784      function basePropertyDeep(path) {
3785        return function(object) {
3786          return baseGet(object, path);
3787        };
3788      }
3789  
3790      /**
3791       * The base implementation of `_.pullAllBy` without support for iteratee
3792       * shorthands.
3793       *
3794       * @private
3795       * @param {Array} array The array to modify.
3796       * @param {Array} values The values to remove.
3797       * @param {Function} [iteratee] The iteratee invoked per element.
3798       * @param {Function} [comparator] The comparator invoked per element.
3799       * @returns {Array} Returns `array`.
3800       */
3801      function basePullAll(array, values, iteratee, comparator) {
3802        var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
3803            index = -1,
3804            length = values.length,
3805            seen = array;
3806  
3807        if (array === values) {
3808          values = copyArray(values);
3809        }
3810        if (iteratee) {
3811          seen = arrayMap(array, baseUnary(iteratee));
3812        }
3813        while (++index < length) {
3814          var fromIndex = 0,
3815              value = values[index],
3816              computed = iteratee ? iteratee(value) : value;
3817  
3818          while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
3819            if (seen !== array) {
3820              splice.call(seen, fromIndex, 1);
3821            }
3822            splice.call(array, fromIndex, 1);
3823          }
3824        }
3825        return array;
3826      }
3827  
3828      /**
3829       * The base implementation of `_.pullAt` without support for individual
3830       * indexes or capturing the removed elements.
3831       *
3832       * @private
3833       * @param {Array} array The array to modify.
3834       * @param {number[]} indexes The indexes of elements to remove.
3835       * @returns {Array} Returns `array`.
3836       */
3837      function basePullAt(array, indexes) {
3838        var length = array ? indexes.length : 0,
3839            lastIndex = length - 1;
3840  
3841        while (length--) {
3842          var index = indexes[length];
3843          if (length == lastIndex || index !== previous) {
3844            var previous = index;
3845            if (isIndex(index)) {
3846              splice.call(array, index, 1);
3847            } else {
3848              baseUnset(array, index);
3849            }
3850          }
3851        }
3852        return array;
3853      }
3854  
3855      /**
3856       * The base implementation of `_.random` without support for returning
3857       * floating-point numbers.
3858       *
3859       * @private
3860       * @param {number} lower The lower bound.
3861       * @param {number} upper The upper bound.
3862       * @returns {number} Returns the random number.
3863       */
3864      function baseRandom(lower, upper) {
3865        return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
3866      }
3867  
3868      /**
3869       * The base implementation of `_.range` and `_.rangeRight` which doesn't
3870       * coerce arguments.
3871       *
3872       * @private
3873       * @param {number} start The start of the range.
3874       * @param {number} end The end of the range.
3875       * @param {number} step The value to increment or decrement by.
3876       * @param {boolean} [fromRight] Specify iterating from right to left.
3877       * @returns {Array} Returns the range of numbers.
3878       */
3879      function baseRange(start, end, step, fromRight) {
3880        var index = -1,
3881            length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
3882            result = Array(length);
3883  
3884        while (length--) {
3885          result[fromRight ? length : ++index] = start;
3886          start += step;
3887        }
3888        return result;
3889      }
3890  
3891      /**
3892       * The base implementation of `_.repeat` which doesn't coerce arguments.
3893       *
3894       * @private
3895       * @param {string} string The string to repeat.
3896       * @param {number} n The number of times to repeat the string.
3897       * @returns {string} Returns the repeated string.
3898       */
3899      function baseRepeat(string, n) {
3900        var result = '';
3901        if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
3902          return result;
3903        }
3904        // Leverage the exponentiation by squaring algorithm for a faster repeat.
3905        // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
3906        do {
3907          if (n % 2) {
3908            result += string;
3909          }
3910          n = nativeFloor(n / 2);
3911          if (n) {
3912            string += string;
3913          }
3914        } while (n);
3915  
3916        return result;
3917      }
3918  
3919      /**
3920       * The base implementation of `_.rest` which doesn't validate or coerce arguments.
3921       *
3922       * @private
3923       * @param {Function} func The function to apply a rest parameter to.
3924       * @param {number} [start=func.length-1] The start position of the rest parameter.
3925       * @returns {Function} Returns the new function.
3926       */
3927      function baseRest(func, start) {
3928        return setToString(overRest(func, start, identity), func + '');
3929      }
3930  
3931      /**
3932       * The base implementation of `_.sample`.
3933       *
3934       * @private
3935       * @param {Array|Object} collection The collection to sample.
3936       * @returns {*} Returns the random element.
3937       */
3938      function baseSample(collection) {
3939        return arraySample(values(collection));
3940      }
3941  
3942      /**
3943       * The base implementation of `_.sampleSize` without param guards.
3944       *
3945       * @private
3946       * @param {Array|Object} collection The collection to sample.
3947       * @param {number} n The number of elements to sample.
3948       * @returns {Array} Returns the random elements.
3949       */
3950      function baseSampleSize(collection, n) {
3951        var array = values(collection);
3952        return shuffleSelf(array, baseClamp(n, 0, array.length));
3953      }
3954  
3955      /**
3956       * The base implementation of `_.set`.
3957       *
3958       * @private
3959       * @param {Object} object The object to modify.
3960       * @param {Array|string} path The path of the property to set.
3961       * @param {*} value The value to set.
3962       * @param {Function} [customizer] The function to customize path creation.
3963       * @returns {Object} Returns `object`.
3964       */
3965      function baseSet(object, path, value, customizer) {
3966        if (!isObject(object)) {
3967          return object;
3968        }
3969        path = castPath(path, object);
3970  
3971        var index = -1,
3972            length = path.length,
3973            lastIndex = length - 1,
3974            nested = object;
3975  
3976        while (nested != null && ++index < length) {
3977          var key = toKey(path[index]),
3978              newValue = value;
3979  
3980          if (index != lastIndex) {
3981            var objValue = nested[key];
3982            newValue = customizer ? customizer(objValue, key, nested) : undefined;
3983            if (newValue === undefined) {
3984              newValue = isObject(objValue)
3985                ? objValue
3986                : (isIndex(path[index + 1]) ? [] : {});
3987            }
3988          }
3989          assignValue(nested, key, newValue);
3990          nested = nested[key];
3991        }
3992        return object;
3993      }
3994  
3995      /**
3996       * The base implementation of `setData` without support for hot loop shorting.
3997       *
3998       * @private
3999       * @param {Function} func The function to associate metadata with.
4000       * @param {*} data The metadata.
4001       * @returns {Function} Returns `func`.
4002       */
4003      var baseSetData = !metaMap ? identity : function(func, data) {
4004        metaMap.set(func, data);
4005        return func;
4006      };
4007  
4008      /**
4009       * The base implementation of `setToString` without support for hot loop shorting.
4010       *
4011       * @private
4012       * @param {Function} func The function to modify.
4013       * @param {Function} string The `toString` result.
4014       * @returns {Function} Returns `func`.
4015       */
4016      var baseSetToString = !defineProperty ? identity : function(func, string) {
4017        return defineProperty(func, 'toString', {
4018          'configurable': true,
4019          'enumerable': false,
4020          'value': constant(string),
4021          'writable': true
4022        });
4023      };
4024  
4025      /**
4026       * The base implementation of `_.shuffle`.
4027       *
4028       * @private
4029       * @param {Array|Object} collection The collection to shuffle.
4030       * @returns {Array} Returns the new shuffled array.
4031       */
4032      function baseShuffle(collection) {
4033        return shuffleSelf(values(collection));
4034      }
4035  
4036      /**
4037       * The base implementation of `_.slice` without an iteratee call guard.
4038       *
4039       * @private
4040       * @param {Array} array The array to slice.
4041       * @param {number} [start=0] The start position.
4042       * @param {number} [end=array.length] The end position.
4043       * @returns {Array} Returns the slice of `array`.
4044       */
4045      function baseSlice(array, start, end) {
4046        var index = -1,
4047            length = array.length;
4048  
4049        if (start < 0) {
4050          start = -start > length ? 0 : (length + start);
4051        }
4052        end = end > length ? length : end;
4053        if (end < 0) {
4054          end += length;
4055        }
4056        length = start > end ? 0 : ((end - start) >>> 0);
4057        start >>>= 0;
4058  
4059        var result = Array(length);
4060        while (++index < length) {
4061          result[index] = array[index + start];
4062        }
4063        return result;
4064      }
4065  
4066      /**
4067       * The base implementation of `_.some` without support for iteratee shorthands.
4068       *
4069       * @private
4070       * @param {Array|Object} collection The collection to iterate over.
4071       * @param {Function} predicate The function invoked per iteration.
4072       * @returns {boolean} Returns `true` if any element passes the predicate check,
4073       *  else `false`.
4074       */
4075      function baseSome(collection, predicate) {
4076        var result;
4077  
4078        baseEach(collection, function(value, index, collection) {
4079          result = predicate(value, index, collection);
4080          return !result;
4081        });
4082        return !!result;
4083      }
4084  
4085      /**
4086       * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
4087       * performs a binary search of `array` to determine the index at which `value`
4088       * should be inserted into `array` in order to maintain its sort order.
4089       *
4090       * @private
4091       * @param {Array} array The sorted array to inspect.
4092       * @param {*} value The value to evaluate.
4093       * @param {boolean} [retHighest] Specify returning the highest qualified index.
4094       * @returns {number} Returns the index at which `value` should be inserted
4095       *  into `array`.
4096       */
4097      function baseSortedIndex(array, value, retHighest) {
4098        var low = 0,
4099            high = array == null ? low : array.length;
4100  
4101        if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
4102          while (low < high) {
4103            var mid = (low + high) >>> 1,
4104                computed = array[mid];
4105  
4106            if (computed !== null && !isSymbol(computed) &&
4107                (retHighest ? (computed <= value) : (computed < value))) {
4108              low = mid + 1;
4109            } else {
4110              high = mid;
4111            }
4112          }
4113          return high;
4114        }
4115        return baseSortedIndexBy(array, value, identity, retHighest);
4116      }
4117  
4118      /**
4119       * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
4120       * which invokes `iteratee` for `value` and each element of `array` to compute
4121       * their sort ranking. The iteratee is invoked with one argument; (value).
4122       *
4123       * @private
4124       * @param {Array} array The sorted array to inspect.
4125       * @param {*} value The value to evaluate.
4126       * @param {Function} iteratee The iteratee invoked per element.
4127       * @param {boolean} [retHighest] Specify returning the highest qualified index.
4128       * @returns {number} Returns the index at which `value` should be inserted
4129       *  into `array`.
4130       */
4131      function baseSortedIndexBy(array, value, iteratee, retHighest) {
4132        value = iteratee(value);
4133  
4134        var low = 0,
4135            high = array == null ? 0 : array.length,
4136            valIsNaN = value !== value,
4137            valIsNull = value === null,
4138            valIsSymbol = isSymbol(value),
4139            valIsUndefined = value === undefined;
4140  
4141        while (low < high) {
4142          var mid = nativeFloor((low + high) / 2),
4143              computed = iteratee(array[mid]),
4144              othIsDefined = computed !== undefined,
4145              othIsNull = computed === null,
4146              othIsReflexive = computed === computed,
4147              othIsSymbol = isSymbol(computed);
4148  
4149          if (valIsNaN) {
4150            var setLow = retHighest || othIsReflexive;
4151          } else if (valIsUndefined) {
4152            setLow = othIsReflexive && (retHighest || othIsDefined);
4153          } else if (valIsNull) {
4154            setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
4155          } else if (valIsSymbol) {
4156            setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
4157          } else if (othIsNull || othIsSymbol) {
4158            setLow = false;
4159          } else {
4160            setLow = retHighest ? (computed <= value) : (computed < value);
4161          }
4162          if (setLow) {
4163            low = mid + 1;
4164          } else {
4165            high = mid;
4166          }
4167        }
4168        return nativeMin(high, MAX_ARRAY_INDEX);
4169      }
4170  
4171      /**
4172       * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
4173       * support for iteratee shorthands.
4174       *
4175       * @private
4176       * @param {Array} array The array to inspect.
4177       * @param {Function} [iteratee] The iteratee invoked per element.
4178       * @returns {Array} Returns the new duplicate free array.
4179       */
4180      function baseSortedUniq(array, iteratee) {
4181        var index = -1,
4182            length = array.length,
4183            resIndex = 0,
4184            result = [];
4185  
4186        while (++index < length) {
4187          var value = array[index],
4188              computed = iteratee ? iteratee(value) : value;
4189  
4190          if (!index || !eq(computed, seen)) {
4191            var seen = computed;
4192            result[resIndex++] = value === 0 ? 0 : value;
4193          }
4194        }
4195        return result;
4196      }
4197  
4198      /**
4199       * The base implementation of `_.toNumber` which doesn't ensure correct
4200       * conversions of binary, hexadecimal, or octal string values.
4201       *
4202       * @private
4203       * @param {*} value The value to process.
4204       * @returns {number} Returns the number.
4205       */
4206      function baseToNumber(value) {
4207        if (typeof value == 'number') {
4208          return value;
4209        }
4210        if (isSymbol(value)) {
4211          return NAN;
4212        }
4213        return +value;
4214      }
4215  
4216      /**
4217       * The base implementation of `_.toString` which doesn't convert nullish
4218       * values to empty strings.
4219       *
4220       * @private
4221       * @param {*} value The value to process.
4222       * @returns {string} Returns the string.
4223       */
4224      function baseToString(value) {
4225        // Exit early for strings to avoid a performance hit in some environments.
4226        if (typeof value == 'string') {
4227          return value;
4228        }
4229        if (isArray(value)) {
4230          // Recursively convert values (susceptible to call stack limits).
4231          return arrayMap(value, baseToString) + '';
4232        }
4233        if (isSymbol(value)) {
4234          return symbolToString ? symbolToString.call(value) : '';
4235        }
4236        var result = (value + '');
4237        return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
4238      }
4239  
4240      /**
4241       * The base implementation of `_.uniqBy` without support for iteratee shorthands.
4242       *
4243       * @private
4244       * @param {Array} array The array to inspect.
4245       * @param {Function} [iteratee] The iteratee invoked per element.
4246       * @param {Function} [comparator] The comparator invoked per element.
4247       * @returns {Array} Returns the new duplicate free array.
4248       */
4249      function baseUniq(array, iteratee, comparator) {
4250        var index = -1,
4251            includes = arrayIncludes,
4252            length = array.length,
4253            isCommon = true,
4254            result = [],
4255            seen = result;
4256  
4257        if (comparator) {
4258          isCommon = false;
4259          includes = arrayIncludesWith;
4260        }
4261        else if (length >= LARGE_ARRAY_SIZE) {
4262          var set = iteratee ? null : createSet(array);
4263          if (set) {
4264            return setToArray(set);
4265          }
4266          isCommon = false;
4267          includes = cacheHas;
4268          seen = new SetCache;
4269        }
4270        else {
4271          seen = iteratee ? [] : result;
4272        }
4273        outer:
4274        while (++index < length) {
4275          var value = array[index],
4276              computed = iteratee ? iteratee(value) : value;
4277  
4278          value = (comparator || value !== 0) ? value : 0;
4279          if (isCommon && computed === computed) {
4280            var seenIndex = seen.length;
4281            while (seenIndex--) {
4282              if (seen[seenIndex] === computed) {
4283                continue outer;
4284              }
4285            }
4286            if (iteratee) {
4287              seen.push(computed);
4288            }
4289            result.push(value);
4290          }
4291          else if (!includes(seen, computed, comparator)) {
4292            if (seen !== result) {
4293              seen.push(computed);
4294            }
4295            result.push(value);
4296          }
4297        }
4298        return result;
4299      }
4300  
4301      /**
4302       * The base implementation of `_.unset`.
4303       *
4304       * @private
4305       * @param {Object} object The object to modify.
4306       * @param {Array|string} path The property path to unset.
4307       * @returns {boolean} Returns `true` if the property is deleted, else `false`.
4308       */
4309      function baseUnset(object, path) {
4310        path = castPath(path, object);
4311        object = parent(object, path);
4312        return object == null || delete object[toKey(last(path))];
4313      }
4314  
4315      /**
4316       * The base implementation of `_.update`.
4317       *
4318       * @private
4319       * @param {Object} object The object to modify.
4320       * @param {Array|string} path The path of the property to update.
4321       * @param {Function} updater The function to produce the updated value.
4322       * @param {Function} [customizer] The function to customize path creation.
4323       * @returns {Object} Returns `object`.
4324       */
4325      function baseUpdate(object, path, updater, customizer) {
4326        return baseSet(object, path, updater(baseGet(object, path)), customizer);
4327      }
4328  
4329      /**
4330       * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
4331       * without support for iteratee shorthands.
4332       *
4333       * @private
4334       * @param {Array} array The array to query.
4335       * @param {Function} predicate The function invoked per iteration.
4336       * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
4337       * @param {boolean} [fromRight] Specify iterating from right to left.
4338       * @returns {Array} Returns the slice of `array`.
4339       */
4340      function baseWhile(array, predicate, isDrop, fromRight) {
4341        var length = array.length,
4342            index = fromRight ? length : -1;
4343  
4344        while ((fromRight ? index-- : ++index < length) &&
4345          predicate(array[index], index, array)) {}
4346  
4347        return isDrop
4348          ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
4349          : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
4350      }
4351  
4352      /**
4353       * The base implementation of `wrapperValue` which returns the result of
4354       * performing a sequence of actions on the unwrapped `value`, where each
4355       * successive action is supplied the return value of the previous.
4356       *
4357       * @private
4358       * @param {*} value The unwrapped value.
4359       * @param {Array} actions Actions to perform to resolve the unwrapped value.
4360       * @returns {*} Returns the resolved value.
4361       */
4362      function baseWrapperValue(value, actions) {
4363        var result = value;
4364        if (result instanceof LazyWrapper) {
4365          result = result.value();
4366        }
4367        return arrayReduce(actions, function(result, action) {
4368          return action.func.apply(action.thisArg, arrayPush([result], action.args));
4369        }, result);
4370      }
4371  
4372      /**
4373       * The base implementation of methods like `_.xor`, without support for
4374       * iteratee shorthands, that accepts an array of arrays to inspect.
4375       *
4376       * @private
4377       * @param {Array} arrays The arrays to inspect.
4378       * @param {Function} [iteratee] The iteratee invoked per element.
4379       * @param {Function} [comparator] The comparator invoked per element.
4380       * @returns {Array} Returns the new array of values.
4381       */
4382      function baseXor(arrays, iteratee, comparator) {
4383        var length = arrays.length;
4384        if (length < 2) {
4385          return length ? baseUniq(arrays[0]) : [];
4386        }
4387        var index = -1,
4388            result = Array(length);
4389  
4390        while (++index < length) {
4391          var array = arrays[index],
4392              othIndex = -1;
4393  
4394          while (++othIndex < length) {
4395            if (othIndex != index) {
4396              result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
4397            }
4398          }
4399        }
4400        return baseUniq(baseFlatten(result, 1), iteratee, comparator);
4401      }
4402  
4403      /**
4404       * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
4405       *
4406       * @private
4407       * @param {Array} props The property identifiers.
4408       * @param {Array} values The property values.
4409       * @param {Function} assignFunc The function to assign values.
4410       * @returns {Object} Returns the new object.
4411       */
4412      function baseZipObject(props, values, assignFunc) {
4413        var index = -1,
4414            length = props.length,
4415            valsLength = values.length,
4416            result = {};
4417  
4418        while (++index < length) {
4419          var value = index < valsLength ? values[index] : undefined;
4420          assignFunc(result, props[index], value);
4421        }
4422        return result;
4423      }
4424  
4425      /**
4426       * Casts `value` to an empty array if it's not an array like object.
4427       *
4428       * @private
4429       * @param {*} value The value to inspect.
4430       * @returns {Array|Object} Returns the cast array-like object.
4431       */
4432      function castArrayLikeObject(value) {
4433        return isArrayLikeObject(value) ? value : [];
4434      }
4435  
4436      /**
4437       * Casts `value` to `identity` if it's not a function.
4438       *
4439       * @private
4440       * @param {*} value The value to inspect.
4441       * @returns {Function} Returns cast function.
4442       */
4443      function castFunction(value) {
4444        return typeof value == 'function' ? value : identity;
4445      }
4446  
4447      /**
4448       * Casts `value` to a path array if it's not one.
4449       *
4450       * @private
4451       * @param {*} value The value to inspect.
4452       * @param {Object} [object] The object to query keys on.
4453       * @returns {Array} Returns the cast property path array.
4454       */
4455      function castPath(value, object) {
4456        if (isArray(value)) {
4457          return value;
4458        }
4459        return isKey(value, object) ? [value] : stringToPath(toString(value));
4460      }
4461  
4462      /**
4463       * A `baseRest` alias which can be replaced with `identity` by module
4464       * replacement plugins.
4465       *
4466       * @private
4467       * @type {Function}
4468       * @param {Function} func The function to apply a rest parameter to.
4469       * @returns {Function} Returns the new function.
4470       */
4471      var castRest = baseRest;
4472  
4473      /**
4474       * Casts `array` to a slice if it's needed.
4475       *
4476       * @private
4477       * @param {Array} array The array to inspect.
4478       * @param {number} start The start position.
4479       * @param {number} [end=array.length] The end position.
4480       * @returns {Array} Returns the cast slice.
4481       */
4482      function castSlice(array, start, end) {
4483        var length = array.length;
4484        end = end === undefined ? length : end;
4485        return (!start && end >= length) ? array : baseSlice(array, start, end);
4486      }
4487  
4488      /**
4489       * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
4490       *
4491       * @private
4492       * @param {number|Object} id The timer id or timeout object of the timer to clear.
4493       */
4494      var clearTimeout = ctxClearTimeout || function(id) {
4495        return root.clearTimeout(id);
4496      };
4497  
4498      /**
4499       * Creates a clone of  `buffer`.
4500       *
4501       * @private
4502       * @param {Buffer} buffer The buffer to clone.
4503       * @param {boolean} [isDeep] Specify a deep clone.
4504       * @returns {Buffer} Returns the cloned buffer.
4505       */
4506      function cloneBuffer(buffer, isDeep) {
4507        if (isDeep) {
4508          return buffer.slice();
4509        }
4510        var length = buffer.length,
4511            result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
4512  
4513        buffer.copy(result);
4514        return result;
4515      }
4516  
4517      /**
4518       * Creates a clone of `arrayBuffer`.
4519       *
4520       * @private
4521       * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
4522       * @returns {ArrayBuffer} Returns the cloned array buffer.
4523       */
4524      function cloneArrayBuffer(arrayBuffer) {
4525        var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
4526        new Uint8Array(result).set(new Uint8Array(arrayBuffer));
4527        return result;
4528      }
4529  
4530      /**
4531       * Creates a clone of `dataView`.
4532       *
4533       * @private
4534       * @param {Object} dataView The data view to clone.
4535       * @param {boolean} [isDeep] Specify a deep clone.
4536       * @returns {Object} Returns the cloned data view.
4537       */
4538      function cloneDataView(dataView, isDeep) {
4539        var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
4540        return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
4541      }
4542  
4543      /**
4544       * Creates a clone of `regexp`.
4545       *
4546       * @private
4547       * @param {Object} regexp The regexp to clone.
4548       * @returns {Object} Returns the cloned regexp.
4549       */
4550      function cloneRegExp(regexp) {
4551        var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
4552        result.lastIndex = regexp.lastIndex;
4553        return result;
4554      }
4555  
4556      /**
4557       * Creates a clone of the `symbol` object.
4558       *
4559       * @private
4560       * @param {Object} symbol The symbol object to clone.
4561       * @returns {Object} Returns the cloned symbol object.
4562       */
4563      function cloneSymbol(symbol) {
4564        return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
4565      }
4566  
4567      /**
4568       * Creates a clone of `typedArray`.
4569       *
4570       * @private
4571       * @param {Object} typedArray The typed array to clone.
4572       * @param {boolean} [isDeep] Specify a deep clone.
4573       * @returns {Object} Returns the cloned typed array.
4574       */
4575      function cloneTypedArray(typedArray, isDeep) {
4576        var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
4577        return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
4578      }
4579  
4580      /**
4581       * Compares values to sort them in ascending order.
4582       *
4583       * @private
4584       * @param {*} value The value to compare.
4585       * @param {*} other The other value to compare.
4586       * @returns {number} Returns the sort order indicator for `value`.
4587       */
4588      function compareAscending(value, other) {
4589        if (value !== other) {
4590          var valIsDefined = value !== undefined,
4591              valIsNull = value === null,
4592              valIsReflexive = value === value,
4593              valIsSymbol = isSymbol(value);
4594  
4595          var othIsDefined = other !== undefined,
4596              othIsNull = other === null,
4597              othIsReflexive = other === other,
4598              othIsSymbol = isSymbol(other);
4599  
4600          if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
4601              (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
4602              (valIsNull && othIsDefined && othIsReflexive) ||
4603              (!valIsDefined && othIsReflexive) ||
4604              !valIsReflexive) {
4605            return 1;
4606          }
4607          if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
4608              (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
4609              (othIsNull && valIsDefined && valIsReflexive) ||
4610              (!othIsDefined && valIsReflexive) ||
4611              !othIsReflexive) {
4612            return -1;
4613          }
4614        }
4615        return 0;
4616      }
4617  
4618      /**
4619       * Used by `_.orderBy` to compare multiple properties of a value to another
4620       * and stable sort them.
4621       *
4622       * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
4623       * specify an order of "desc" for descending or "asc" for ascending sort order
4624       * of corresponding values.
4625       *
4626       * @private
4627       * @param {Object} object The object to compare.
4628       * @param {Object} other The other object to compare.
4629       * @param {boolean[]|string[]} orders The order to sort by for each property.
4630       * @returns {number} Returns the sort order indicator for `object`.
4631       */
4632      function compareMultiple(object, other, orders) {
4633        var index = -1,
4634            objCriteria = object.criteria,
4635            othCriteria = other.criteria,
4636            length = objCriteria.length,
4637            ordersLength = orders.length;
4638  
4639        while (++index < length) {
4640          var result = compareAscending(objCriteria[index], othCriteria[index]);
4641          if (result) {
4642            if (index >= ordersLength) {
4643              return result;
4644            }
4645            var order = orders[index];
4646            return result * (order == 'desc' ? -1 : 1);
4647          }
4648        }
4649        // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
4650        // that causes it, under certain circumstances, to provide the same value for
4651        // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
4652        // for more details.
4653        //
4654        // This also ensures a stable sort in V8 and other engines.
4655        // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
4656        return object.index - other.index;
4657      }
4658  
4659      /**
4660       * Creates an array that is the composition of partially applied arguments,
4661       * placeholders, and provided arguments into a single array of arguments.
4662       *
4663       * @private
4664       * @param {Array} args The provided arguments.
4665       * @param {Array} partials The arguments to prepend to those provided.
4666       * @param {Array} holders The `partials` placeholder indexes.
4667       * @params {boolean} [isCurried] Specify composing for a curried function.
4668       * @returns {Array} Returns the new array of composed arguments.
4669       */
4670      function composeArgs(args, partials, holders, isCurried) {
4671        var argsIndex = -1,
4672            argsLength = args.length,
4673            holdersLength = holders.length,
4674            leftIndex = -1,
4675            leftLength = partials.length,
4676            rangeLength = nativeMax(argsLength - holdersLength, 0),
4677            result = Array(leftLength + rangeLength),
4678            isUncurried = !isCurried;
4679  
4680        while (++leftIndex < leftLength) {
4681          result[leftIndex] = partials[leftIndex];
4682        }
4683        while (++argsIndex < holdersLength) {
4684          if (isUncurried || argsIndex < argsLength) {
4685            result[holders[argsIndex]] = args[argsIndex];
4686          }
4687        }
4688        while (rangeLength--) {
4689          result[leftIndex++] = args[argsIndex++];
4690        }
4691        return result;
4692      }
4693  
4694      /**
4695       * This function is like `composeArgs` except that the arguments composition
4696       * is tailored for `_.partialRight`.
4697       *
4698       * @private
4699       * @param {Array} args The provided arguments.
4700       * @param {Array} partials The arguments to append to those provided.
4701       * @param {Array} holders The `partials` placeholder indexes.
4702       * @params {boolean} [isCurried] Specify composing for a curried function.
4703       * @returns {Array} Returns the new array of composed arguments.
4704       */
4705      function composeArgsRight(args, partials, holders, isCurried) {
4706        var argsIndex = -1,
4707            argsLength = args.length,
4708            holdersIndex = -1,
4709            holdersLength = holders.length,
4710            rightIndex = -1,
4711            rightLength = partials.length,
4712            rangeLength = nativeMax(argsLength - holdersLength, 0),
4713            result = Array(rangeLength + rightLength),
4714            isUncurried = !isCurried;
4715  
4716        while (++argsIndex < rangeLength) {
4717          result[argsIndex] = args[argsIndex];
4718        }
4719        var offset = argsIndex;
4720        while (++rightIndex < rightLength) {
4721          result[offset + rightIndex] = partials[rightIndex];
4722        }
4723        while (++holdersIndex < holdersLength) {
4724          if (isUncurried || argsIndex < argsLength) {
4725            result[offset + holders[holdersIndex]] = args[argsIndex++];
4726          }
4727        }
4728        return result;
4729      }
4730  
4731      /**
4732       * Copies the values of `source` to `array`.
4733       *
4734       * @private
4735       * @param {Array} source The array to copy values from.
4736       * @param {Array} [array=[]] The array to copy values to.
4737       * @returns {Array} Returns `array`.
4738       */
4739      function copyArray(source, array) {
4740        var index = -1,
4741            length = source.length;
4742  
4743        array || (array = Array(length));
4744        while (++index < length) {
4745          array[index] = source[index];
4746        }
4747        return array;
4748      }
4749  
4750      /**
4751       * Copies properties of `source` to `object`.
4752       *
4753       * @private
4754       * @param {Object} source The object to copy properties from.
4755       * @param {Array} props The property identifiers to copy.
4756       * @param {Object} [object={}] The object to copy properties to.
4757       * @param {Function} [customizer] The function to customize copied values.
4758       * @returns {Object} Returns `object`.
4759       */
4760      function copyObject(source, props, object, customizer) {
4761        var isNew = !object;
4762        object || (object = {});
4763  
4764        var index = -1,
4765            length = props.length;
4766  
4767        while (++index < length) {
4768          var key = props[index];
4769  
4770          var newValue = customizer
4771            ? customizer(object[key], source[key], key, object, source)
4772            : undefined;
4773  
4774          if (newValue === undefined) {
4775            newValue = source[key];
4776          }
4777          if (isNew) {
4778            baseAssignValue(object, key, newValue);
4779          } else {
4780            assignValue(object, key, newValue);
4781          }
4782        }
4783        return object;
4784      }
4785  
4786      /**
4787       * Copies own symbols of `source` to `object`.
4788       *
4789       * @private
4790       * @param {Object} source The object to copy symbols from.
4791       * @param {Object} [object={}] The object to copy symbols to.
4792       * @returns {Object} Returns `object`.
4793       */
4794      function copySymbols(source, object) {
4795        return copyObject(source, getSymbols(source), object);
4796      }
4797  
4798      /**
4799       * Copies own and inherited symbols of `source` to `object`.
4800       *
4801       * @private
4802       * @param {Object} source The object to copy symbols from.
4803       * @param {Object} [object={}] The object to copy symbols to.
4804       * @returns {Object} Returns `object`.
4805       */
4806      function copySymbolsIn(source, object) {
4807        return copyObject(source, getSymbolsIn(source), object);
4808      }
4809  
4810      /**
4811       * Creates a function like `_.groupBy`.
4812       *
4813       * @private
4814       * @param {Function} setter The function to set accumulator values.
4815       * @param {Function} [initializer] The accumulator object initializer.
4816       * @returns {Function} Returns the new aggregator function.
4817       */
4818      function createAggregator(setter, initializer) {
4819        return function(collection, iteratee) {
4820          var func = isArray(collection) ? arrayAggregator : baseAggregator,
4821              accumulator = initializer ? initializer() : {};
4822  
4823          return func(collection, setter, getIteratee(iteratee, 2), accumulator);
4824        };
4825      }
4826  
4827      /**
4828       * Creates a function like `_.assign`.
4829       *
4830       * @private
4831       * @param {Function} assigner The function to assign values.
4832       * @returns {Function} Returns the new assigner function.
4833       */
4834      function createAssigner(assigner) {
4835        return baseRest(function(object, sources) {
4836          var index = -1,
4837              length = sources.length,
4838              customizer = length > 1 ? sources[length - 1] : undefined,
4839              guard = length > 2 ? sources[2] : undefined;
4840  
4841          customizer = (assigner.length > 3 && typeof customizer == 'function')
4842            ? (length--, customizer)
4843            : undefined;
4844  
4845          if (guard && isIterateeCall(sources[0], sources[1], guard)) {
4846            customizer = length < 3 ? undefined : customizer;
4847            length = 1;
4848          }
4849          object = Object(object);
4850          while (++index < length) {
4851            var source = sources[index];
4852            if (source) {
4853              assigner(object, source, index, customizer);
4854            }
4855          }
4856          return object;
4857        });
4858      }
4859  
4860      /**
4861       * Creates a `baseEach` or `baseEachRight` function.
4862       *
4863       * @private
4864       * @param {Function} eachFunc The function to iterate over a collection.
4865       * @param {boolean} [fromRight] Specify iterating from right to left.
4866       * @returns {Function} Returns the new base function.
4867       */
4868      function createBaseEach(eachFunc, fromRight) {
4869        return function(collection, iteratee) {
4870          if (collection == null) {
4871            return collection;
4872          }
4873          if (!isArrayLike(collection)) {
4874            return eachFunc(collection, iteratee);
4875          }
4876          var length = collection.length,
4877              index = fromRight ? length : -1,
4878              iterable = Object(collection);
4879  
4880          while ((fromRight ? index-- : ++index < length)) {
4881            if (iteratee(iterable[index], index, iterable) === false) {
4882              break;
4883            }
4884          }
4885          return collection;
4886        };
4887      }
4888  
4889      /**
4890       * Creates a base function for methods like `_.forIn` and `_.forOwn`.
4891       *
4892       * @private
4893       * @param {boolean} [fromRight] Specify iterating from right to left.
4894       * @returns {Function} Returns the new base function.
4895       */
4896      function createBaseFor(fromRight) {
4897        return function(object, iteratee, keysFunc) {
4898          var index = -1,
4899              iterable = Object(object),
4900              props = keysFunc(object),
4901              length = props.length;
4902  
4903          while (length--) {
4904            var key = props[fromRight ? length : ++index];
4905            if (iteratee(iterable[key], key, iterable) === false) {
4906              break;
4907            }
4908          }
4909          return object;
4910        };
4911      }
4912  
4913      /**
4914       * Creates a function that wraps `func` to invoke it with the optional `this`
4915       * binding of `thisArg`.
4916       *
4917       * @private
4918       * @param {Function} func The function to wrap.
4919       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
4920       * @param {*} [thisArg] The `this` binding of `func`.
4921       * @returns {Function} Returns the new wrapped function.
4922       */
4923      function createBind(func, bitmask, thisArg) {
4924        var isBind = bitmask & WRAP_BIND_FLAG,
4925            Ctor = createCtor(func);
4926  
4927        function wrapper() {
4928          var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
4929          return fn.apply(isBind ? thisArg : this, arguments);
4930        }
4931        return wrapper;
4932      }
4933  
4934      /**
4935       * Creates a function like `_.lowerFirst`.
4936       *
4937       * @private
4938       * @param {string} methodName The name of the `String` case method to use.
4939       * @returns {Function} Returns the new case function.
4940       */
4941      function createCaseFirst(methodName) {
4942        return function(string) {
4943          string = toString(string);
4944  
4945          var strSymbols = hasUnicode(string)
4946            ? stringToArray(string)
4947            : undefined;
4948  
4949          var chr = strSymbols
4950            ? strSymbols[0]
4951            : string.charAt(0);
4952  
4953          var trailing = strSymbols
4954            ? castSlice(strSymbols, 1).join('')
4955            : string.slice(1);
4956  
4957          return chr[methodName]() + trailing;
4958        };
4959      }
4960  
4961      /**
4962       * Creates a function like `_.camelCase`.
4963       *
4964       * @private
4965       * @param {Function} callback The function to combine each word.
4966       * @returns {Function} Returns the new compounder function.
4967       */
4968      function createCompounder(callback) {
4969        return function(string) {
4970          return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
4971        };
4972      }
4973  
4974      /**
4975       * Creates a function that produces an instance of `Ctor` regardless of
4976       * whether it was invoked as part of a `new` expression or by `call` or `apply`.
4977       *
4978       * @private
4979       * @param {Function} Ctor The constructor to wrap.
4980       * @returns {Function} Returns the new wrapped function.
4981       */
4982      function createCtor(Ctor) {
4983        return function() {
4984          // Use a `switch` statement to work with class constructors. See
4985          // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
4986          // for more details.
4987          var args = arguments;
4988          switch (args.length) {
4989            case 0: return new Ctor;
4990            case 1: return new Ctor(args[0]);
4991            case 2: return new Ctor(args[0], args[1]);
4992            case 3: return new Ctor(args[0], args[1], args[2]);
4993            case 4: return new Ctor(args[0], args[1], args[2], args[3]);
4994            case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
4995            case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
4996            case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
4997          }
4998          var thisBinding = baseCreate(Ctor.prototype),
4999              result = Ctor.apply(thisBinding, args);
5000  
5001          // Mimic the constructor's `return` behavior.
5002          // See https://es5.github.io/#x13.2.2 for more details.
5003          return isObject(result) ? result : thisBinding;
5004        };
5005      }
5006  
5007      /**
5008       * Creates a function that wraps `func` to enable currying.
5009       *
5010       * @private
5011       * @param {Function} func The function to wrap.
5012       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5013       * @param {number} arity The arity of `func`.
5014       * @returns {Function} Returns the new wrapped function.
5015       */
5016      function createCurry(func, bitmask, arity) {
5017        var Ctor = createCtor(func);
5018  
5019        function wrapper() {
5020          var length = arguments.length,
5021              args = Array(length),
5022              index = length,
5023              placeholder = getHolder(wrapper);
5024  
5025          while (index--) {
5026            args[index] = arguments[index];
5027          }
5028          var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
5029            ? []
5030            : replaceHolders(args, placeholder);
5031  
5032          length -= holders.length;
5033          if (length < arity) {
5034            return createRecurry(
5035              func, bitmask, createHybrid, wrapper.placeholder, undefined,
5036              args, holders, undefined, undefined, arity - length);
5037          }
5038          var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
5039          return apply(fn, this, args);
5040        }
5041        return wrapper;
5042      }
5043  
5044      /**
5045       * Creates a `_.find` or `_.findLast` function.
5046       *
5047       * @private
5048       * @param {Function} findIndexFunc The function to find the collection index.
5049       * @returns {Function} Returns the new find function.
5050       */
5051      function createFind(findIndexFunc) {
5052        return function(collection, predicate, fromIndex) {
5053          var iterable = Object(collection);
5054          if (!isArrayLike(collection)) {
5055            var iteratee = getIteratee(predicate, 3);
5056            collection = keys(collection);
5057            predicate = function(key) { return iteratee(iterable[key], key, iterable); };
5058          }
5059          var index = findIndexFunc(collection, predicate, fromIndex);
5060          return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
5061        };
5062      }
5063  
5064      /**
5065       * Creates a `_.flow` or `_.flowRight` function.
5066       *
5067       * @private
5068       * @param {boolean} [fromRight] Specify iterating from right to left.
5069       * @returns {Function} Returns the new flow function.
5070       */
5071      function createFlow(fromRight) {
5072        return flatRest(function(funcs) {
5073          var length = funcs.length,
5074              index = length,
5075              prereq = LodashWrapper.prototype.thru;
5076  
5077          if (fromRight) {
5078            funcs.reverse();
5079          }
5080          while (index--) {
5081            var func = funcs[index];
5082            if (typeof func != 'function') {
5083              throw new TypeError(FUNC_ERROR_TEXT);
5084            }
5085            if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
5086              var wrapper = new LodashWrapper([], true);
5087            }
5088          }
5089          index = wrapper ? index : length;
5090          while (++index < length) {
5091            func = funcs[index];
5092  
5093            var funcName = getFuncName(func),
5094                data = funcName == 'wrapper' ? getData(func) : undefined;
5095  
5096            if (data && isLaziable(data[0]) &&
5097                  data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
5098                  !data[4].length && data[9] == 1
5099                ) {
5100              wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
5101            } else {
5102              wrapper = (func.length == 1 && isLaziable(func))
5103                ? wrapper[funcName]()
5104                : wrapper.thru(func);
5105            }
5106          }
5107          return function() {
5108            var args = arguments,
5109                value = args[0];
5110  
5111            if (wrapper && args.length == 1 && isArray(value)) {
5112              return wrapper.plant(value).value();
5113            }
5114            var index = 0,
5115                result = length ? funcs[index].apply(this, args) : value;
5116  
5117            while (++index < length) {
5118              result = funcs[index].call(this, result);
5119            }
5120            return result;
5121          };
5122        });
5123      }
5124  
5125      /**
5126       * Creates a function that wraps `func` to invoke it with optional `this`
5127       * binding of `thisArg`, partial application, and currying.
5128       *
5129       * @private
5130       * @param {Function|string} func The function or method name to wrap.
5131       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5132       * @param {*} [thisArg] The `this` binding of `func`.
5133       * @param {Array} [partials] The arguments to prepend to those provided to
5134       *  the new function.
5135       * @param {Array} [holders] The `partials` placeholder indexes.
5136       * @param {Array} [partialsRight] The arguments to append to those provided
5137       *  to the new function.
5138       * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
5139       * @param {Array} [argPos] The argument positions of the new function.
5140       * @param {number} [ary] The arity cap of `func`.
5141       * @param {number} [arity] The arity of `func`.
5142       * @returns {Function} Returns the new wrapped function.
5143       */
5144      function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
5145        var isAry = bitmask & WRAP_ARY_FLAG,
5146            isBind = bitmask & WRAP_BIND_FLAG,
5147            isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
5148            isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
5149            isFlip = bitmask & WRAP_FLIP_FLAG,
5150            Ctor = isBindKey ? undefined : createCtor(func);
5151  
5152        function wrapper() {
5153          var length = arguments.length,
5154              args = Array(length),
5155              index = length;
5156  
5157          while (index--) {
5158            args[index] = arguments[index];
5159          }
5160          if (isCurried) {
5161            var placeholder = getHolder(wrapper),
5162                holdersCount = countHolders(args, placeholder);
5163          }
5164          if (partials) {
5165            args = composeArgs(args, partials, holders, isCurried);
5166          }
5167          if (partialsRight) {
5168            args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
5169          }
5170          length -= holdersCount;
5171          if (isCurried && length < arity) {
5172            var newHolders = replaceHolders(args, placeholder);
5173            return createRecurry(
5174              func, bitmask, createHybrid, wrapper.placeholder, thisArg,
5175              args, newHolders, argPos, ary, arity - length
5176            );
5177          }
5178          var thisBinding = isBind ? thisArg : this,
5179              fn = isBindKey ? thisBinding[func] : func;
5180  
5181          length = args.length;
5182          if (argPos) {
5183            args = reorder(args, argPos);
5184          } else if (isFlip && length > 1) {
5185            args.reverse();
5186          }
5187          if (isAry && ary < length) {
5188            args.length = ary;
5189          }
5190          if (this && this !== root && this instanceof wrapper) {
5191            fn = Ctor || createCtor(fn);
5192          }
5193          return fn.apply(thisBinding, args);
5194        }
5195        return wrapper;
5196      }
5197  
5198      /**
5199       * Creates a function like `_.invertBy`.
5200       *
5201       * @private
5202       * @param {Function} setter The function to set accumulator values.
5203       * @param {Function} toIteratee The function to resolve iteratees.
5204       * @returns {Function} Returns the new inverter function.
5205       */
5206      function createInverter(setter, toIteratee) {
5207        return function(object, iteratee) {
5208          return baseInverter(object, setter, toIteratee(iteratee), {});
5209        };
5210      }
5211  
5212      /**
5213       * Creates a function that performs a mathematical operation on two values.
5214       *
5215       * @private
5216       * @param {Function} operator The function to perform the operation.
5217       * @param {number} [defaultValue] The value used for `undefined` arguments.
5218       * @returns {Function} Returns the new mathematical operation function.
5219       */
5220      function createMathOperation(operator, defaultValue) {
5221        return function(value, other) {
5222          var result;
5223          if (value === undefined && other === undefined) {
5224            return defaultValue;
5225          }
5226          if (value !== undefined) {
5227            result = value;
5228          }
5229          if (other !== undefined) {
5230            if (result === undefined) {
5231              return other;
5232            }
5233            if (typeof value == 'string' || typeof other == 'string') {
5234              value = baseToString(value);
5235              other = baseToString(other);
5236            } else {
5237              value = baseToNumber(value);
5238              other = baseToNumber(other);
5239            }
5240            result = operator(value, other);
5241          }
5242          return result;
5243        };
5244      }
5245  
5246      /**
5247       * Creates a function like `_.over`.
5248       *
5249       * @private
5250       * @param {Function} arrayFunc The function to iterate over iteratees.
5251       * @returns {Function} Returns the new over function.
5252       */
5253      function createOver(arrayFunc) {
5254        return flatRest(function(iteratees) {
5255          iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
5256          return baseRest(function(args) {
5257            var thisArg = this;
5258            return arrayFunc(iteratees, function(iteratee) {
5259              return apply(iteratee, thisArg, args);
5260            });
5261          });
5262        });
5263      }
5264  
5265      /**
5266       * Creates the padding for `string` based on `length`. The `chars` string
5267       * is truncated if the number of characters exceeds `length`.
5268       *
5269       * @private
5270       * @param {number} length The padding length.
5271       * @param {string} [chars=' '] The string used as padding.
5272       * @returns {string} Returns the padding for `string`.
5273       */
5274      function createPadding(length, chars) {
5275        chars = chars === undefined ? ' ' : baseToString(chars);
5276  
5277        var charsLength = chars.length;
5278        if (charsLength < 2) {
5279          return charsLength ? baseRepeat(chars, length) : chars;
5280        }
5281        var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
5282        return hasUnicode(chars)
5283          ? castSlice(stringToArray(result), 0, length).join('')
5284          : result.slice(0, length);
5285      }
5286  
5287      /**
5288       * Creates a function that wraps `func` to invoke it with the `this` binding
5289       * of `thisArg` and `partials` prepended to the arguments it receives.
5290       *
5291       * @private
5292       * @param {Function} func The function to wrap.
5293       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5294       * @param {*} thisArg The `this` binding of `func`.
5295       * @param {Array} partials The arguments to prepend to those provided to
5296       *  the new function.
5297       * @returns {Function} Returns the new wrapped function.
5298       */
5299      function createPartial(func, bitmask, thisArg, partials) {
5300        var isBind = bitmask & WRAP_BIND_FLAG,
5301            Ctor = createCtor(func);
5302  
5303        function wrapper() {
5304          var argsIndex = -1,
5305              argsLength = arguments.length,
5306              leftIndex = -1,
5307              leftLength = partials.length,
5308              args = Array(leftLength + argsLength),
5309              fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
5310  
5311          while (++leftIndex < leftLength) {
5312            args[leftIndex] = partials[leftIndex];
5313          }
5314          while (argsLength--) {
5315            args[leftIndex++] = arguments[++argsIndex];
5316          }
5317          return apply(fn, isBind ? thisArg : this, args);
5318        }
5319        return wrapper;
5320      }
5321  
5322      /**
5323       * Creates a `_.range` or `_.rangeRight` function.
5324       *
5325       * @private
5326       * @param {boolean} [fromRight] Specify iterating from right to left.
5327       * @returns {Function} Returns the new range function.
5328       */
5329      function createRange(fromRight) {
5330        return function(start, end, step) {
5331          if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
5332            end = step = undefined;
5333          }
5334          // Ensure the sign of `-0` is preserved.
5335          start = toFinite(start);
5336          if (end === undefined) {
5337            end = start;
5338            start = 0;
5339          } else {
5340            end = toFinite(end);
5341          }
5342          step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
5343          return baseRange(start, end, step, fromRight);
5344        };
5345      }
5346  
5347      /**
5348       * Creates a function that performs a relational operation on two values.
5349       *
5350       * @private
5351       * @param {Function} operator The function to perform the operation.
5352       * @returns {Function} Returns the new relational operation function.
5353       */
5354      function createRelationalOperation(operator) {
5355        return function(value, other) {
5356          if (!(typeof value == 'string' && typeof other == 'string')) {
5357            value = toNumber(value);
5358            other = toNumber(other);
5359          }
5360          return operator(value, other);
5361        };
5362      }
5363  
5364      /**
5365       * Creates a function that wraps `func` to continue currying.
5366       *
5367       * @private
5368       * @param {Function} func The function to wrap.
5369       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5370       * @param {Function} wrapFunc The function to create the `func` wrapper.
5371       * @param {*} placeholder The placeholder value.
5372       * @param {*} [thisArg] The `this` binding of `func`.
5373       * @param {Array} [partials] The arguments to prepend to those provided to
5374       *  the new function.
5375       * @param {Array} [holders] The `partials` placeholder indexes.
5376       * @param {Array} [argPos] The argument positions of the new function.
5377       * @param {number} [ary] The arity cap of `func`.
5378       * @param {number} [arity] The arity of `func`.
5379       * @returns {Function} Returns the new wrapped function.
5380       */
5381      function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
5382        var isCurry = bitmask & WRAP_CURRY_FLAG,
5383            newHolders = isCurry ? holders : undefined,
5384            newHoldersRight = isCurry ? undefined : holders,
5385            newPartials = isCurry ? partials : undefined,
5386            newPartialsRight = isCurry ? undefined : partials;
5387  
5388        bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
5389        bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
5390  
5391        if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
5392          bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
5393        }
5394        var newData = [
5395          func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
5396          newHoldersRight, argPos, ary, arity
5397        ];
5398  
5399        var result = wrapFunc.apply(undefined, newData);
5400        if (isLaziable(func)) {
5401          setData(result, newData);
5402        }
5403        result.placeholder = placeholder;
5404        return setWrapToString(result, func, bitmask);
5405      }
5406  
5407      /**
5408       * Creates a function like `_.round`.
5409       *
5410       * @private
5411       * @param {string} methodName The name of the `Math` method to use when rounding.
5412       * @returns {Function} Returns the new round function.
5413       */
5414      function createRound(methodName) {
5415        var func = Math[methodName];
5416        return function(number, precision) {
5417          number = toNumber(number);
5418          precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
5419          if (precision && nativeIsFinite(number)) {
5420            // Shift with exponential notation to avoid floating-point issues.
5421            // See [MDN](https://mdn.io/round#Examples) for more details.
5422            var pair = (toString(number) + 'e').split('e'),
5423                value = func(pair[0] + 'e' + (+pair[1] + precision));
5424  
5425            pair = (toString(value) + 'e').split('e');
5426            return +(pair[0] + 'e' + (+pair[1] - precision));
5427          }
5428          return func(number);
5429        };
5430      }
5431  
5432      /**
5433       * Creates a set object of `values`.
5434       *
5435       * @private
5436       * @param {Array} values The values to add to the set.
5437       * @returns {Object} Returns the new set.
5438       */
5439      var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
5440        return new Set(values);
5441      };
5442  
5443      /**
5444       * Creates a `_.toPairs` or `_.toPairsIn` function.
5445       *
5446       * @private
5447       * @param {Function} keysFunc The function to get the keys of a given object.
5448       * @returns {Function} Returns the new pairs function.
5449       */
5450      function createToPairs(keysFunc) {
5451        return function(object) {
5452          var tag = getTag(object);
5453          if (tag == mapTag) {
5454            return mapToArray(object);
5455          }
5456          if (tag == setTag) {
5457            return setToPairs(object);
5458          }
5459          return baseToPairs(object, keysFunc(object));
5460        };
5461      }
5462  
5463      /**
5464       * Creates a function that either curries or invokes `func` with optional
5465       * `this` binding and partially applied arguments.
5466       *
5467       * @private
5468       * @param {Function|string} func The function or method name to wrap.
5469       * @param {number} bitmask The bitmask flags.
5470       *    1 - `_.bind`
5471       *    2 - `_.bindKey`
5472       *    4 - `_.curry` or `_.curryRight` of a bound function
5473       *    8 - `_.curry`
5474       *   16 - `_.curryRight`
5475       *   32 - `_.partial`
5476       *   64 - `_.partialRight`
5477       *  128 - `_.rearg`
5478       *  256 - `_.ary`
5479       *  512 - `_.flip`
5480       * @param {*} [thisArg] The `this` binding of `func`.
5481       * @param {Array} [partials] The arguments to be partially applied.
5482       * @param {Array} [holders] The `partials` placeholder indexes.
5483       * @param {Array} [argPos] The argument positions of the new function.
5484       * @param {number} [ary] The arity cap of `func`.
5485       * @param {number} [arity] The arity of `func`.
5486       * @returns {Function} Returns the new wrapped function.
5487       */
5488      function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
5489        var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
5490        if (!isBindKey && typeof func != 'function') {
5491          throw new TypeError(FUNC_ERROR_TEXT);
5492        }
5493        var length = partials ? partials.length : 0;
5494        if (!length) {
5495          bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
5496          partials = holders = undefined;
5497        }
5498        ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
5499        arity = arity === undefined ? arity : toInteger(arity);
5500        length -= holders ? holders.length : 0;
5501  
5502        if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
5503          var partialsRight = partials,
5504              holdersRight = holders;
5505  
5506          partials = holders = undefined;
5507        }
5508        var data = isBindKey ? undefined : getData(func);
5509  
5510        var newData = [
5511          func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
5512          argPos, ary, arity
5513        ];
5514  
5515        if (data) {
5516          mergeData(newData, data);
5517        }
5518        func = newData[0];
5519        bitmask = newData[1];
5520        thisArg = newData[2];
5521        partials = newData[3];
5522        holders = newData[4];
5523        arity = newData[9] = newData[9] === undefined
5524          ? (isBindKey ? 0 : func.length)
5525          : nativeMax(newData[9] - length, 0);
5526  
5527        if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
5528          bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
5529        }
5530        if (!bitmask || bitmask == WRAP_BIND_FLAG) {
5531          var result = createBind(func, bitmask, thisArg);
5532        } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
5533          result = createCurry(func, bitmask, arity);
5534        } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
5535          result = createPartial(func, bitmask, thisArg, partials);
5536        } else {
5537          result = createHybrid.apply(undefined, newData);
5538        }
5539        var setter = data ? baseSetData : setData;
5540        return setWrapToString(setter(result, newData), func, bitmask);
5541      }
5542  
5543      /**
5544       * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
5545       * of source objects to the destination object for all destination properties
5546       * that resolve to `undefined`.
5547       *
5548       * @private
5549       * @param {*} objValue The destination value.
5550       * @param {*} srcValue The source value.
5551       * @param {string} key The key of the property to assign.
5552       * @param {Object} object The parent object of `objValue`.
5553       * @returns {*} Returns the value to assign.
5554       */
5555      function customDefaultsAssignIn(objValue, srcValue, key, object) {
5556        if (objValue === undefined ||
5557            (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
5558          return srcValue;
5559        }
5560        return objValue;
5561      }
5562  
5563      /**
5564       * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
5565       * objects into destination objects that are passed thru.
5566       *
5567       * @private
5568       * @param {*} objValue The destination value.
5569       * @param {*} srcValue The source value.
5570       * @param {string} key The key of the property to merge.
5571       * @param {Object} object The parent object of `objValue`.
5572       * @param {Object} source The parent object of `srcValue`.
5573       * @param {Object} [stack] Tracks traversed source values and their merged
5574       *  counterparts.
5575       * @returns {*} Returns the value to assign.
5576       */
5577      function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
5578        if (isObject(objValue) && isObject(srcValue)) {
5579          // Recursively merge objects and arrays (susceptible to call stack limits).
5580          stack.set(srcValue, objValue);
5581          baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
5582          stack['delete'](srcValue);
5583        }
5584        return objValue;
5585      }
5586  
5587      /**
5588       * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
5589       * objects.
5590       *
5591       * @private
5592       * @param {*} value The value to inspect.
5593       * @param {string} key The key of the property to inspect.
5594       * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
5595       */
5596      function customOmitClone(value) {
5597        return isPlainObject(value) ? undefined : value;
5598      }
5599  
5600      /**
5601       * A specialized version of `baseIsEqualDeep` for arrays with support for
5602       * partial deep comparisons.
5603       *
5604       * @private
5605       * @param {Array} array The array to compare.
5606       * @param {Array} other The other array to compare.
5607       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
5608       * @param {Function} customizer The function to customize comparisons.
5609       * @param {Function} equalFunc The function to determine equivalents of values.
5610       * @param {Object} stack Tracks traversed `array` and `other` objects.
5611       * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
5612       */
5613      function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
5614        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
5615            arrLength = array.length,
5616            othLength = other.length;
5617  
5618        if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
5619          return false;
5620        }
5621        // Assume cyclic values are equal.
5622        var stacked = stack.get(array);
5623        if (stacked && stack.get(other)) {
5624          return stacked == other;
5625        }
5626        var index = -1,
5627            result = true,
5628            seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
5629  
5630        stack.set(array, other);
5631        stack.set(other, array);
5632  
5633        // Ignore non-index properties.
5634        while (++index < arrLength) {
5635          var arrValue = array[index],
5636              othValue = other[index];
5637  
5638          if (customizer) {
5639            var compared = isPartial
5640              ? customizer(othValue, arrValue, index, other, array, stack)
5641              : customizer(arrValue, othValue, index, array, other, stack);
5642          }
5643          if (compared !== undefined) {
5644            if (compared) {
5645              continue;
5646            }
5647            result = false;
5648            break;
5649          }
5650          // Recursively compare arrays (susceptible to call stack limits).
5651          if (seen) {
5652            if (!arraySome(other, function(othValue, othIndex) {
5653                  if (!cacheHas(seen, othIndex) &&
5654                      (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
5655                    return seen.push(othIndex);
5656                  }
5657                })) {
5658              result = false;
5659              break;
5660            }
5661          } else if (!(
5662                arrValue === othValue ||
5663                  equalFunc(arrValue, othValue, bitmask, customizer, stack)
5664              )) {
5665            result = false;
5666            break;
5667          }
5668        }
5669        stack['delete'](array);
5670        stack['delete'](other);
5671        return result;
5672      }
5673  
5674      /**
5675       * A specialized version of `baseIsEqualDeep` for comparing objects of
5676       * the same `toStringTag`.
5677       *
5678       * **Note:** This function only supports comparing values with tags of
5679       * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
5680       *
5681       * @private
5682       * @param {Object} object The object to compare.
5683       * @param {Object} other The other object to compare.
5684       * @param {string} tag The `toStringTag` of the objects to compare.
5685       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
5686       * @param {Function} customizer The function to customize comparisons.
5687       * @param {Function} equalFunc The function to determine equivalents of values.
5688       * @param {Object} stack Tracks traversed `object` and `other` objects.
5689       * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
5690       */
5691      function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
5692        switch (tag) {
5693          case dataViewTag:
5694            if ((object.byteLength != other.byteLength) ||
5695                (object.byteOffset != other.byteOffset)) {
5696              return false;
5697            }
5698            object = object.buffer;
5699            other = other.buffer;
5700  
5701          case arrayBufferTag:
5702            if ((object.byteLength != other.byteLength) ||
5703                !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
5704              return false;
5705            }
5706            return true;
5707  
5708          case boolTag:
5709          case dateTag:
5710          case numberTag:
5711            // Coerce booleans to `1` or `0` and dates to milliseconds.
5712            // Invalid dates are coerced to `NaN`.
5713            return eq(+object, +other);
5714  
5715          case errorTag:
5716            return object.name == other.name && object.message == other.message;
5717  
5718          case regexpTag:
5719          case stringTag:
5720            // Coerce regexes to strings and treat strings, primitives and objects,
5721            // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
5722            // for more details.
5723            return object == (other + '');
5724  
5725          case mapTag:
5726            var convert = mapToArray;
5727  
5728          case setTag:
5729            var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
5730            convert || (convert = setToArray);
5731  
5732            if (object.size != other.size && !isPartial) {
5733              return false;
5734            }
5735            // Assume cyclic values are equal.
5736            var stacked = stack.get(object);
5737            if (stacked) {
5738              return stacked == other;
5739            }
5740            bitmask |= COMPARE_UNORDERED_FLAG;
5741  
5742            // Recursively compare objects (susceptible to call stack limits).
5743            stack.set(object, other);
5744            var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
5745            stack['delete'](object);
5746            return result;
5747  
5748          case symbolTag:
5749            if (symbolValueOf) {
5750              return symbolValueOf.call(object) == symbolValueOf.call(other);
5751            }
5752        }
5753        return false;
5754      }
5755  
5756      /**
5757       * A specialized version of `baseIsEqualDeep` for objects with support for
5758       * partial deep comparisons.
5759       *
5760       * @private
5761       * @param {Object} object The object to compare.
5762       * @param {Object} other The other object to compare.
5763       * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
5764       * @param {Function} customizer The function to customize comparisons.
5765       * @param {Function} equalFunc The function to determine equivalents of values.
5766       * @param {Object} stack Tracks traversed `object` and `other` objects.
5767       * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
5768       */
5769      function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
5770        var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
5771            objProps = getAllKeys(object),
5772            objLength = objProps.length,
5773            othProps = getAllKeys(other),
5774            othLength = othProps.length;
5775  
5776        if (objLength != othLength && !isPartial) {
5777          return false;
5778        }
5779        var index = objLength;
5780        while (index--) {
5781          var key = objProps[index];
5782          if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
5783            return false;
5784          }
5785        }
5786        // Assume cyclic values are equal.
5787        var stacked = stack.get(object);
5788        if (stacked && stack.get(other)) {
5789          return stacked == other;
5790        }
5791        var result = true;
5792        stack.set(object, other);
5793        stack.set(other, object);
5794  
5795        var skipCtor = isPartial;
5796        while (++index < objLength) {
5797          key = objProps[index];
5798          var objValue = object[key],
5799              othValue = other[key];
5800  
5801          if (customizer) {
5802            var compared = isPartial
5803              ? customizer(othValue, objValue, key, other, object, stack)
5804              : customizer(objValue, othValue, key, object, other, stack);
5805          }
5806          // Recursively compare objects (susceptible to call stack limits).
5807          if (!(compared === undefined
5808                ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
5809                : compared
5810              )) {
5811            result = false;
5812            break;
5813          }
5814          skipCtor || (skipCtor = key == 'constructor');
5815        }
5816        if (result && !skipCtor) {
5817          var objCtor = object.constructor,
5818              othCtor = other.constructor;
5819  
5820          // Non `Object` object instances with different constructors are not equal.
5821          if (objCtor != othCtor &&
5822              ('constructor' in object && 'constructor' in other) &&
5823              !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
5824                typeof othCtor == 'function' && othCtor instanceof othCtor)) {
5825            result = false;
5826          }
5827        }
5828        stack['delete'](object);
5829        stack['delete'](other);
5830        return result;
5831      }
5832  
5833      /**
5834       * A specialized version of `baseRest` which flattens the rest array.
5835       *
5836       * @private
5837       * @param {Function} func The function to apply a rest parameter to.
5838       * @returns {Function} Returns the new function.
5839       */
5840      function flatRest(func) {
5841        return setToString(overRest(func, undefined, flatten), func + '');
5842      }
5843  
5844      /**
5845       * Creates an array of own enumerable property names and symbols of `object`.
5846       *
5847       * @private
5848       * @param {Object} object The object to query.
5849       * @returns {Array} Returns the array of property names and symbols.
5850       */
5851      function getAllKeys(object) {
5852        return baseGetAllKeys(object, keys, getSymbols);
5853      }
5854  
5855      /**
5856       * Creates an array of own and inherited enumerable property names and
5857       * symbols of `object`.
5858       *
5859       * @private
5860       * @param {Object} object The object to query.
5861       * @returns {Array} Returns the array of property names and symbols.
5862       */
5863      function getAllKeysIn(object) {
5864        return baseGetAllKeys(object, keysIn, getSymbolsIn);
5865      }
5866  
5867      /**
5868       * Gets metadata for `func`.
5869       *
5870       * @private
5871       * @param {Function} func The function to query.
5872       * @returns {*} Returns the metadata for `func`.
5873       */
5874      var getData = !metaMap ? noop : function(func) {
5875        return metaMap.get(func);
5876      };
5877  
5878      /**
5879       * Gets the name of `func`.
5880       *
5881       * @private
5882       * @param {Function} func The function to query.
5883       * @returns {string} Returns the function name.
5884       */
5885      function getFuncName(func) {
5886        var result = (func.name + ''),
5887            array = realNames[result],
5888            length = hasOwnProperty.call(realNames, result) ? array.length : 0;
5889  
5890        while (length--) {
5891          var data = array[length],
5892              otherFunc = data.func;
5893          if (otherFunc == null || otherFunc == func) {
5894            return data.name;
5895          }
5896        }
5897        return result;
5898      }
5899  
5900      /**
5901       * Gets the argument placeholder value for `func`.
5902       *
5903       * @private
5904       * @param {Function} func The function to inspect.
5905       * @returns {*} Returns the placeholder value.
5906       */
5907      function getHolder(func) {
5908        var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
5909        return object.placeholder;
5910      }
5911  
5912      /**
5913       * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
5914       * this function returns the custom method, otherwise it returns `baseIteratee`.
5915       * If arguments are provided, the chosen function is invoked with them and
5916       * its result is returned.
5917       *
5918       * @private
5919       * @param {*} [value] The value to convert to an iteratee.
5920       * @param {number} [arity] The arity of the created iteratee.
5921       * @returns {Function} Returns the chosen function or its result.
5922       */
5923      function getIteratee() {
5924        var result = lodash.iteratee || iteratee;
5925        result = result === iteratee ? baseIteratee : result;
5926        return arguments.length ? result(arguments[0], arguments[1]) : result;
5927      }
5928  
5929      /**
5930       * Gets the data for `map`.
5931       *
5932       * @private
5933       * @param {Object} map The map to query.
5934       * @param {string} key The reference key.
5935       * @returns {*} Returns the map data.
5936       */
5937      function getMapData(map, key) {
5938        var data = map.__data__;
5939        return isKeyable(key)
5940          ? data[typeof key == 'string' ? 'string' : 'hash']
5941          : data.map;
5942      }
5943  
5944      /**
5945       * Gets the property names, values, and compare flags of `object`.
5946       *
5947       * @private
5948       * @param {Object} object The object to query.
5949       * @returns {Array} Returns the match data of `object`.
5950       */
5951      function getMatchData(object) {
5952        var result = keys(object),
5953            length = result.length;
5954  
5955        while (length--) {
5956          var key = result[length],
5957              value = object[key];
5958  
5959          result[length] = [key, value, isStrictComparable(value)];
5960        }
5961        return result;
5962      }
5963  
5964      /**
5965       * Gets the native function at `key` of `object`.
5966       *
5967       * @private
5968       * @param {Object} object The object to query.
5969       * @param {string} key The key of the method to get.
5970       * @returns {*} Returns the function if it's native, else `undefined`.
5971       */
5972      function getNative(object, key) {
5973        var value = getValue(object, key);
5974        return baseIsNative(value) ? value : undefined;
5975      }
5976  
5977      /**
5978       * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
5979       *
5980       * @private
5981       * @param {*} value The value to query.
5982       * @returns {string} Returns the raw `toStringTag`.
5983       */
5984      function getRawTag(value) {
5985        var isOwn = hasOwnProperty.call(value, symToStringTag),
5986            tag = value[symToStringTag];
5987  
5988        try {
5989          value[symToStringTag] = undefined;
5990          var unmasked = true;
5991        } catch (e) {}
5992  
5993        var result = nativeObjectToString.call(value);
5994        if (unmasked) {
5995          if (isOwn) {
5996            value[symToStringTag] = tag;
5997          } else {
5998            delete value[symToStringTag];
5999          }
6000        }
6001        return result;
6002      }
6003  
6004      /**
6005       * Creates an array of the own enumerable symbols of `object`.
6006       *
6007       * @private
6008       * @param {Object} object The object to query.
6009       * @returns {Array} Returns the array of symbols.
6010       */
6011      var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
6012        if (object == null) {
6013          return [];
6014        }
6015        object = Object(object);
6016        return arrayFilter(nativeGetSymbols(object), function(symbol) {
6017          return propertyIsEnumerable.call(object, symbol);
6018        });
6019      };
6020  
6021      /**
6022       * Creates an array of the own and inherited enumerable symbols of `object`.
6023       *
6024       * @private
6025       * @param {Object} object The object to query.
6026       * @returns {Array} Returns the array of symbols.
6027       */
6028      var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
6029        var result = [];
6030        while (object) {
6031          arrayPush(result, getSymbols(object));
6032          object = getPrototype(object);
6033        }
6034        return result;
6035      };
6036  
6037      /**
6038       * Gets the `toStringTag` of `value`.
6039       *
6040       * @private
6041       * @param {*} value The value to query.
6042       * @returns {string} Returns the `toStringTag`.
6043       */
6044      var getTag = baseGetTag;
6045  
6046      // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
6047      if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
6048          (Map && getTag(new Map) != mapTag) ||
6049          (Promise && getTag(Promise.resolve()) != promiseTag) ||
6050          (Set && getTag(new Set) != setTag) ||
6051          (WeakMap && getTag(new WeakMap) != weakMapTag)) {
6052        getTag = function(value) {
6053          var result = baseGetTag(value),
6054              Ctor = result == objectTag ? value.constructor : undefined,
6055              ctorString = Ctor ? toSource(Ctor) : '';
6056  
6057          if (ctorString) {
6058            switch (ctorString) {
6059              case dataViewCtorString: return dataViewTag;
6060              case mapCtorString: return mapTag;
6061              case promiseCtorString: return promiseTag;
6062              case setCtorString: return setTag;
6063              case weakMapCtorString: return weakMapTag;
6064            }
6065          }
6066          return result;
6067        };
6068      }
6069  
6070      /**
6071       * Gets the view, applying any `transforms` to the `start` and `end` positions.
6072       *
6073       * @private
6074       * @param {number} start The start of the view.
6075       * @param {number} end The end of the view.
6076       * @param {Array} transforms The transformations to apply to the view.
6077       * @returns {Object} Returns an object containing the `start` and `end`
6078       *  positions of the view.
6079       */
6080      function getView(start, end, transforms) {
6081        var index = -1,
6082            length = transforms.length;
6083  
6084        while (++index < length) {
6085          var data = transforms[index],
6086              size = data.size;
6087  
6088          switch (data.type) {
6089            case 'drop':      start += size; break;
6090            case 'dropRight': end -= size; break;
6091            case 'take':      end = nativeMin(end, start + size); break;
6092            case 'takeRight': start = nativeMax(start, end - size); break;
6093          }
6094        }
6095        return { 'start': start, 'end': end };
6096      }
6097  
6098      /**
6099       * Extracts wrapper details from the `source` body comment.
6100       *
6101       * @private
6102       * @param {string} source The source to inspect.
6103       * @returns {Array} Returns the wrapper details.
6104       */
6105      function getWrapDetails(source) {
6106        var match = source.match(reWrapDetails);
6107        return match ? match[1].split(reSplitDetails) : [];
6108      }
6109  
6110      /**
6111       * Checks if `path` exists on `object`.
6112       *
6113       * @private
6114       * @param {Object} object The object to query.
6115       * @param {Array|string} path The path to check.
6116       * @param {Function} hasFunc The function to check properties.
6117       * @returns {boolean} Returns `true` if `path` exists, else `false`.
6118       */
6119      function hasPath(object, path, hasFunc) {
6120        path = castPath(path, object);
6121  
6122        var index = -1,
6123            length = path.length,
6124            result = false;
6125  
6126        while (++index < length) {
6127          var key = toKey(path[index]);
6128          if (!(result = object != null && hasFunc(object, key))) {
6129            break;
6130          }
6131          object = object[key];
6132        }
6133        if (result || ++index != length) {
6134          return result;
6135        }
6136        length = object == null ? 0 : object.length;
6137        return !!length && isLength(length) && isIndex(key, length) &&
6138          (isArray(object) || isArguments(object));
6139      }
6140  
6141      /**
6142       * Initializes an array clone.
6143       *
6144       * @private
6145       * @param {Array} array The array to clone.
6146       * @returns {Array} Returns the initialized clone.
6147       */
6148      function initCloneArray(array) {
6149        var length = array.length,
6150            result = new array.constructor(length);
6151  
6152        // Add properties assigned by `RegExp#exec`.
6153        if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
6154          result.index = array.index;
6155          result.input = array.input;
6156        }
6157        return result;
6158      }
6159  
6160      /**
6161       * Initializes an object clone.
6162       *
6163       * @private
6164       * @param {Object} object The object to clone.
6165       * @returns {Object} Returns the initialized clone.
6166       */
6167      function initCloneObject(object) {
6168        return (typeof object.constructor == 'function' && !isPrototype(object))
6169          ? baseCreate(getPrototype(object))
6170          : {};
6171      }
6172  
6173      /**
6174       * Initializes an object clone based on its `toStringTag`.
6175       *
6176       * **Note:** This function only supports cloning values with tags of
6177       * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
6178       *
6179       * @private
6180       * @param {Object} object The object to clone.
6181       * @param {string} tag The `toStringTag` of the object to clone.
6182       * @param {boolean} [isDeep] Specify a deep clone.
6183       * @returns {Object} Returns the initialized clone.
6184       */
6185      function initCloneByTag(object, tag, isDeep) {
6186        var Ctor = object.constructor;
6187        switch (tag) {
6188          case arrayBufferTag:
6189            return cloneArrayBuffer(object);
6190  
6191          case boolTag:
6192          case dateTag:
6193            return new Ctor(+object);
6194  
6195          case dataViewTag:
6196            return cloneDataView(object, isDeep);
6197  
6198          case float32Tag: case float64Tag:
6199          case int8Tag: case int16Tag: case int32Tag:
6200          case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
6201            return cloneTypedArray(object, isDeep);
6202  
6203          case mapTag:
6204            return new Ctor;
6205  
6206          case numberTag:
6207          case stringTag:
6208            return new Ctor(object);
6209  
6210          case regexpTag:
6211            return cloneRegExp(object);
6212  
6213          case setTag:
6214            return new Ctor;
6215  
6216          case symbolTag:
6217            return cloneSymbol(object);
6218        }
6219      }
6220  
6221      /**
6222       * Inserts wrapper `details` in a comment at the top of the `source` body.
6223       *
6224       * @private
6225       * @param {string} source The source to modify.
6226       * @returns {Array} details The details to insert.
6227       * @returns {string} Returns the modified source.
6228       */
6229      function insertWrapDetails(source, details) {
6230        var length = details.length;
6231        if (!length) {
6232          return source;
6233        }
6234        var lastIndex = length - 1;
6235        details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
6236        details = details.join(length > 2 ? ', ' : ' ');
6237        return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
6238      }
6239  
6240      /**
6241       * Checks if `value` is a flattenable `arguments` object or array.
6242       *
6243       * @private
6244       * @param {*} value The value to check.
6245       * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
6246       */
6247      function isFlattenable(value) {
6248        return isArray(value) || isArguments(value) ||
6249          !!(spreadableSymbol && value && value[spreadableSymbol]);
6250      }
6251  
6252      /**
6253       * Checks if `value` is a valid array-like index.
6254       *
6255       * @private
6256       * @param {*} value The value to check.
6257       * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
6258       * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
6259       */
6260      function isIndex(value, length) {
6261        var type = typeof value;
6262        length = length == null ? MAX_SAFE_INTEGER : length;
6263  
6264        return !!length &&
6265          (type == 'number' ||
6266            (type != 'symbol' && reIsUint.test(value))) &&
6267              (value > -1 && value % 1 == 0 && value < length);
6268      }
6269  
6270      /**
6271       * Checks if the given arguments are from an iteratee call.
6272       *
6273       * @private
6274       * @param {*} value The potential iteratee value argument.
6275       * @param {*} index The potential iteratee index or key argument.
6276       * @param {*} object The potential iteratee object argument.
6277       * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
6278       *  else `false`.
6279       */
6280      function isIterateeCall(value, index, object) {
6281        if (!isObject(object)) {
6282          return false;
6283        }
6284        var type = typeof index;
6285        if (type == 'number'
6286              ? (isArrayLike(object) && isIndex(index, object.length))
6287              : (type == 'string' && index in object)
6288            ) {
6289          return eq(object[index], value);
6290        }
6291        return false;
6292      }
6293  
6294      /**
6295       * Checks if `value` is a property name and not a property path.
6296       *
6297       * @private
6298       * @param {*} value The value to check.
6299       * @param {Object} [object] The object to query keys on.
6300       * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
6301       */
6302      function isKey(value, object) {
6303        if (isArray(value)) {
6304          return false;
6305        }
6306        var type = typeof value;
6307        if (type == 'number' || type == 'symbol' || type == 'boolean' ||
6308            value == null || isSymbol(value)) {
6309          return true;
6310        }
6311        return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
6312          (object != null && value in Object(object));
6313      }
6314  
6315      /**
6316       * Checks if `value` is suitable for use as unique object key.
6317       *
6318       * @private
6319       * @param {*} value The value to check.
6320       * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
6321       */
6322      function isKeyable(value) {
6323        var type = typeof value;
6324        return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
6325          ? (value !== '__proto__')
6326          : (value === null);
6327      }
6328  
6329      /**
6330       * Checks if `func` has a lazy counterpart.
6331       *
6332       * @private
6333       * @param {Function} func The function to check.
6334       * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
6335       *  else `false`.
6336       */
6337      function isLaziable(func) {
6338        var funcName = getFuncName(func),
6339            other = lodash[funcName];
6340  
6341        if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
6342          return false;
6343        }
6344        if (func === other) {
6345          return true;
6346        }
6347        var data = getData(other);
6348        return !!data && func === data[0];
6349      }
6350  
6351      /**
6352       * Checks if `func` has its source masked.
6353       *
6354       * @private
6355       * @param {Function} func The function to check.
6356       * @returns {boolean} Returns `true` if `func` is masked, else `false`.
6357       */
6358      function isMasked(func) {
6359        return !!maskSrcKey && (maskSrcKey in func);
6360      }
6361  
6362      /**
6363       * Checks if `func` is capable of being masked.
6364       *
6365       * @private
6366       * @param {*} value The value to check.
6367       * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
6368       */
6369      var isMaskable = coreJsData ? isFunction : stubFalse;
6370  
6371      /**
6372       * Checks if `value` is likely a prototype object.
6373       *
6374       * @private
6375       * @param {*} value The value to check.
6376       * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
6377       */
6378      function isPrototype(value) {
6379        var Ctor = value && value.constructor,
6380            proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
6381  
6382        return value === proto;
6383      }
6384  
6385      /**
6386       * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
6387       *
6388       * @private
6389       * @param {*} value The value to check.
6390       * @returns {boolean} Returns `true` if `value` if suitable for strict
6391       *  equality comparisons, else `false`.
6392       */
6393      function isStrictComparable(value) {
6394        return value === value && !isObject(value);
6395      }
6396  
6397      /**
6398       * A specialized version of `matchesProperty` for source values suitable
6399       * for strict equality comparisons, i.e. `===`.
6400       *
6401       * @private
6402       * @param {string} key The key of the property to get.
6403       * @param {*} srcValue The value to match.
6404       * @returns {Function} Returns the new spec function.
6405       */
6406      function matchesStrictComparable(key, srcValue) {
6407        return function(object) {
6408          if (object == null) {
6409            return false;
6410          }
6411          return object[key] === srcValue &&
6412            (srcValue !== undefined || (key in Object(object)));
6413        };
6414      }
6415  
6416      /**
6417       * A specialized version of `_.memoize` which clears the memoized function's
6418       * cache when it exceeds `MAX_MEMOIZE_SIZE`.
6419       *
6420       * @private
6421       * @param {Function} func The function to have its output memoized.
6422       * @returns {Function} Returns the new memoized function.
6423       */
6424      function memoizeCapped(func) {
6425        var result = memoize(func, function(key) {
6426          if (cache.size === MAX_MEMOIZE_SIZE) {
6427            cache.clear();
6428          }
6429          return key;
6430        });
6431  
6432        var cache = result.cache;
6433        return result;
6434      }
6435  
6436      /**
6437       * Merges the function metadata of `source` into `data`.
6438       *
6439       * Merging metadata reduces the number of wrappers used to invoke a function.
6440       * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
6441       * may be applied regardless of execution order. Methods like `_.ary` and
6442       * `_.rearg` modify function arguments, making the order in which they are
6443       * executed important, preventing the merging of metadata. However, we make
6444       * an exception for a safe combined case where curried functions have `_.ary`
6445       * and or `_.rearg` applied.
6446       *
6447       * @private
6448       * @param {Array} data The destination metadata.
6449       * @param {Array} source The source metadata.
6450       * @returns {Array} Returns `data`.
6451       */
6452      function mergeData(data, source) {
6453        var bitmask = data[1],
6454            srcBitmask = source[1],
6455            newBitmask = bitmask | srcBitmask,
6456            isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
6457  
6458        var isCombo =
6459          ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
6460          ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
6461          ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
6462  
6463        // Exit early if metadata can't be merged.
6464        if (!(isCommon || isCombo)) {
6465          return data;
6466        }
6467        // Use source `thisArg` if available.
6468        if (srcBitmask & WRAP_BIND_FLAG) {
6469          data[2] = source[2];
6470          // Set when currying a bound function.
6471          newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
6472        }
6473        // Compose partial arguments.
6474        var value = source[3];
6475        if (value) {
6476          var partials = data[3];
6477          data[3] = partials ? composeArgs(partials, value, source[4]) : value;
6478          data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
6479        }
6480        // Compose partial right arguments.
6481        value = source[5];
6482        if (value) {
6483          partials = data[5];
6484          data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
6485          data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
6486        }
6487        // Use source `argPos` if available.
6488        value = source[7];
6489        if (value) {
6490          data[7] = value;
6491        }
6492        // Use source `ary` if it's smaller.
6493        if (srcBitmask & WRAP_ARY_FLAG) {
6494          data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
6495        }
6496        // Use source `arity` if one is not provided.
6497        if (data[9] == null) {
6498          data[9] = source[9];
6499        }
6500        // Use source `func` and merge bitmasks.
6501        data[0] = source[0];
6502        data[1] = newBitmask;
6503  
6504        return data;
6505      }
6506  
6507      /**
6508       * This function is like
6509       * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
6510       * except that it includes inherited enumerable properties.
6511       *
6512       * @private
6513       * @param {Object} object The object to query.
6514       * @returns {Array} Returns the array of property names.
6515       */
6516      function nativeKeysIn(object) {
6517        var result = [];
6518        if (object != null) {
6519          for (var key in Object(object)) {
6520            result.push(key);
6521          }
6522        }
6523        return result;
6524      }
6525  
6526      /**
6527       * Converts `value` to a string using `Object.prototype.toString`.
6528       *
6529       * @private
6530       * @param {*} value The value to convert.
6531       * @returns {string} Returns the converted string.
6532       */
6533      function objectToString(value) {
6534        return nativeObjectToString.call(value);
6535      }
6536  
6537      /**
6538       * A specialized version of `baseRest` which transforms the rest array.
6539       *
6540       * @private
6541       * @param {Function} func The function to apply a rest parameter to.
6542       * @param {number} [start=func.length-1] The start position of the rest parameter.
6543       * @param {Function} transform The rest array transform.
6544       * @returns {Function} Returns the new function.
6545       */
6546      function overRest(func, start, transform) {
6547        start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
6548        return function() {
6549          var args = arguments,
6550              index = -1,
6551              length = nativeMax(args.length - start, 0),
6552              array = Array(length);
6553  
6554          while (++index < length) {
6555            array[index] = args[start + index];
6556          }
6557          index = -1;
6558          var otherArgs = Array(start + 1);
6559          while (++index < start) {
6560            otherArgs[index] = args[index];
6561          }
6562          otherArgs[start] = transform(array);
6563          return apply(func, this, otherArgs);
6564        };
6565      }
6566  
6567      /**
6568       * Gets the parent value at `path` of `object`.
6569       *
6570       * @private
6571       * @param {Object} object The object to query.
6572       * @param {Array} path The path to get the parent value of.
6573       * @returns {*} Returns the parent value.
6574       */
6575      function parent(object, path) {
6576        return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
6577      }
6578  
6579      /**
6580       * Reorder `array` according to the specified indexes where the element at
6581       * the first index is assigned as the first element, the element at
6582       * the second index is assigned as the second element, and so on.
6583       *
6584       * @private
6585       * @param {Array} array The array to reorder.
6586       * @param {Array} indexes The arranged array indexes.
6587       * @returns {Array} Returns `array`.
6588       */
6589      function reorder(array, indexes) {
6590        var arrLength = array.length,
6591            length = nativeMin(indexes.length, arrLength),
6592            oldArray = copyArray(array);
6593  
6594        while (length--) {
6595          var index = indexes[length];
6596          array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
6597        }
6598        return array;
6599      }
6600  
6601      /**
6602       * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
6603       *
6604       * @private
6605       * @param {Object} object The object to query.
6606       * @param {string} key The key of the property to get.
6607       * @returns {*} Returns the property value.
6608       */
6609      function safeGet(object, key) {
6610        if (key === 'constructor' && typeof object[key] === 'function') {
6611          return;
6612        }
6613  
6614        if (key == '__proto__') {
6615          return;
6616        }
6617  
6618        return object[key];
6619      }
6620  
6621      /**
6622       * Sets metadata for `func`.
6623       *
6624       * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
6625       * period of time, it will trip its breaker and transition to an identity
6626       * function to avoid garbage collection pauses in V8. See
6627       * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
6628       * for more details.
6629       *
6630       * @private
6631       * @param {Function} func The function to associate metadata with.
6632       * @param {*} data The metadata.
6633       * @returns {Function} Returns `func`.
6634       */
6635      var setData = shortOut(baseSetData);
6636  
6637      /**
6638       * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
6639       *
6640       * @private
6641       * @param {Function} func The function to delay.
6642       * @param {number} wait The number of milliseconds to delay invocation.
6643       * @returns {number|Object} Returns the timer id or timeout object.
6644       */
6645      var setTimeout = ctxSetTimeout || function(func, wait) {
6646        return root.setTimeout(func, wait);
6647      };
6648  
6649      /**
6650       * Sets the `toString` method of `func` to return `string`.
6651       *
6652       * @private
6653       * @param {Function} func The function to modify.
6654       * @param {Function} string The `toString` result.
6655       * @returns {Function} Returns `func`.
6656       */
6657      var setToString = shortOut(baseSetToString);
6658  
6659      /**
6660       * Sets the `toString` method of `wrapper` to mimic the source of `reference`
6661       * with wrapper details in a comment at the top of the source body.
6662       *
6663       * @private
6664       * @param {Function} wrapper The function to modify.
6665       * @param {Function} reference The reference function.
6666       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
6667       * @returns {Function} Returns `wrapper`.
6668       */
6669      function setWrapToString(wrapper, reference, bitmask) {
6670        var source = (reference + '');
6671        return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
6672      }
6673  
6674      /**
6675       * Creates a function that'll short out and invoke `identity` instead
6676       * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
6677       * milliseconds.
6678       *
6679       * @private
6680       * @param {Function} func The function to restrict.
6681       * @returns {Function} Returns the new shortable function.
6682       */
6683      function shortOut(func) {
6684        var count = 0,
6685            lastCalled = 0;
6686  
6687        return function() {
6688          var stamp = nativeNow(),
6689              remaining = HOT_SPAN - (stamp - lastCalled);
6690  
6691          lastCalled = stamp;
6692          if (remaining > 0) {
6693            if (++count >= HOT_COUNT) {
6694              return arguments[0];
6695            }
6696          } else {
6697            count = 0;
6698          }
6699          return func.apply(undefined, arguments);
6700        };
6701      }
6702  
6703      /**
6704       * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
6705       *
6706       * @private
6707       * @param {Array} array The array to shuffle.
6708       * @param {number} [size=array.length] The size of `array`.
6709       * @returns {Array} Returns `array`.
6710       */
6711      function shuffleSelf(array, size) {
6712        var index = -1,
6713            length = array.length,
6714            lastIndex = length - 1;
6715  
6716        size = size === undefined ? length : size;
6717        while (++index < size) {
6718          var rand = baseRandom(index, lastIndex),
6719              value = array[rand];
6720  
6721          array[rand] = array[index];
6722          array[index] = value;
6723        }
6724        array.length = size;
6725        return array;
6726      }
6727  
6728      /**
6729       * Converts `string` to a property path array.
6730       *
6731       * @private
6732       * @param {string} string The string to convert.
6733       * @returns {Array} Returns the property path array.
6734       */
6735      var stringToPath = memoizeCapped(function(string) {
6736        var result = [];
6737        if (string.charCodeAt(0) === 46 /* . */) {
6738          result.push('');
6739        }
6740        string.replace(rePropName, function(match, number, quote, subString) {
6741          result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
6742        });
6743        return result;
6744      });
6745  
6746      /**
6747       * Converts `value` to a string key if it's not a string or symbol.
6748       *
6749       * @private
6750       * @param {*} value The value to inspect.
6751       * @returns {string|symbol} Returns the key.
6752       */
6753      function toKey(value) {
6754        if (typeof value == 'string' || isSymbol(value)) {
6755          return value;
6756        }
6757        var result = (value + '');
6758        return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
6759      }
6760  
6761      /**
6762       * Converts `func` to its source code.
6763       *
6764       * @private
6765       * @param {Function} func The function to convert.
6766       * @returns {string} Returns the source code.
6767       */
6768      function toSource(func) {
6769        if (func != null) {
6770          try {
6771            return funcToString.call(func);
6772          } catch (e) {}
6773          try {
6774            return (func + '');
6775          } catch (e) {}
6776        }
6777        return '';
6778      }
6779  
6780      /**
6781       * Updates wrapper `details` based on `bitmask` flags.
6782       *
6783       * @private
6784       * @returns {Array} details The details to modify.
6785       * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
6786       * @returns {Array} Returns `details`.
6787       */
6788      function updateWrapDetails(details, bitmask) {
6789        arrayEach(wrapFlags, function(pair) {
6790          var value = '_.' + pair[0];
6791          if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
6792            details.push(value);
6793          }
6794        });
6795        return details.sort();
6796      }
6797  
6798      /**
6799       * Creates a clone of `wrapper`.
6800       *
6801       * @private
6802       * @param {Object} wrapper The wrapper to clone.
6803       * @returns {Object} Returns the cloned wrapper.
6804       */
6805      function wrapperClone(wrapper) {
6806        if (wrapper instanceof LazyWrapper) {
6807          return wrapper.clone();
6808        }
6809        var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
6810        result.__actions__ = copyArray(wrapper.__actions__);
6811        result.__index__  = wrapper.__index__;
6812        result.__values__ = wrapper.__values__;
6813        return result;
6814      }
6815  
6816      /*------------------------------------------------------------------------*/
6817  
6818      /**
6819       * Creates an array of elements split into groups the length of `size`.
6820       * If `array` can't be split evenly, the final chunk will be the remaining
6821       * elements.
6822       *
6823       * @static
6824       * @memberOf _
6825       * @since 3.0.0
6826       * @category Array
6827       * @param {Array} array The array to process.
6828       * @param {number} [size=1] The length of each chunk
6829       * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
6830       * @returns {Array} Returns the new array of chunks.
6831       * @example
6832       *
6833       * _.chunk(['a', 'b', 'c', 'd'], 2);
6834       * // => [['a', 'b'], ['c', 'd']]
6835       *
6836       * _.chunk(['a', 'b', 'c', 'd'], 3);
6837       * // => [['a', 'b', 'c'], ['d']]
6838       */
6839      function chunk(array, size, guard) {
6840        if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
6841          size = 1;
6842        } else {
6843          size = nativeMax(toInteger(size), 0);
6844        }
6845        var length = array == null ? 0 : array.length;
6846        if (!length || size < 1) {
6847          return [];
6848        }
6849        var index = 0,
6850            resIndex = 0,
6851            result = Array(nativeCeil(length / size));
6852  
6853        while (index < length) {
6854          result[resIndex++] = baseSlice(array, index, (index += size));
6855        }
6856        return result;
6857      }
6858  
6859      /**
6860       * Creates an array with all falsey values removed. The values `false`, `null`,
6861       * `0`, `""`, `undefined`, and `NaN` are falsey.
6862       *
6863       * @static
6864       * @memberOf _
6865       * @since 0.1.0
6866       * @category Array
6867       * @param {Array} array The array to compact.
6868       * @returns {Array} Returns the new array of filtered values.
6869       * @example
6870       *
6871       * _.compact([0, 1, false, 2, '', 3]);
6872       * // => [1, 2, 3]
6873       */
6874      function compact(array) {
6875        var index = -1,
6876            length = array == null ? 0 : array.length,
6877            resIndex = 0,
6878            result = [];
6879  
6880        while (++index < length) {
6881          var value = array[index];
6882          if (value) {
6883            result[resIndex++] = value;
6884          }
6885        }
6886        return result;
6887      }
6888  
6889      /**
6890       * Creates a new array concatenating `array` with any additional arrays
6891       * and/or values.
6892       *
6893       * @static
6894       * @memberOf _
6895       * @since 4.0.0
6896       * @category Array
6897       * @param {Array} array The array to concatenate.
6898       * @param {...*} [values] The values to concatenate.
6899       * @returns {Array} Returns the new concatenated array.
6900       * @example
6901       *
6902       * var array = [1];
6903       * var other = _.concat(array, 2, [3], [[4]]);
6904       *
6905       * console.log(other);
6906       * // => [1, 2, 3, [4]]
6907       *
6908       * console.log(array);
6909       * // => [1]
6910       */
6911      function concat() {
6912        var length = arguments.length;
6913        if (!length) {
6914          return [];
6915        }
6916        var args = Array(length - 1),
6917            array = arguments[0],
6918            index = length;
6919  
6920        while (index--) {
6921          args[index - 1] = arguments[index];
6922        }
6923        return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
6924      }
6925  
6926      /**
6927       * Creates an array of `array` values not included in the other given arrays
6928       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
6929       * for equality comparisons. The order and references of result values are
6930       * determined by the first array.
6931       *
6932       * **Note:** Unlike `_.pullAll`, this method returns a new array.
6933       *
6934       * @static
6935       * @memberOf _
6936       * @since 0.1.0
6937       * @category Array
6938       * @param {Array} array The array to inspect.
6939       * @param {...Array} [values] The values to exclude.
6940       * @returns {Array} Returns the new array of filtered values.
6941       * @see _.without, _.xor
6942       * @example
6943       *
6944       * _.difference([2, 1], [2, 3]);
6945       * // => [1]
6946       */
6947      var difference = baseRest(function(array, values) {
6948        return isArrayLikeObject(array)
6949          ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
6950          : [];
6951      });
6952  
6953      /**
6954       * This method is like `_.difference` except that it accepts `iteratee` which
6955       * is invoked for each element of `array` and `values` to generate the criterion
6956       * by which they're compared. The order and references of result values are
6957       * determined by the first array. The iteratee is invoked with one argument:
6958       * (value).
6959       *
6960       * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
6961       *
6962       * @static
6963       * @memberOf _
6964       * @since 4.0.0
6965       * @category Array
6966       * @param {Array} array The array to inspect.
6967       * @param {...Array} [values] The values to exclude.
6968       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
6969       * @returns {Array} Returns the new array of filtered values.
6970       * @example
6971       *
6972       * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
6973       * // => [1.2]
6974       *
6975       * // The `_.property` iteratee shorthand.
6976       * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
6977       * // => [{ 'x': 2 }]
6978       */
6979      var differenceBy = baseRest(function(array, values) {
6980        var iteratee = last(values);
6981        if (isArrayLikeObject(iteratee)) {
6982          iteratee = undefined;
6983        }
6984        return isArrayLikeObject(array)
6985          ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
6986          : [];
6987      });
6988  
6989      /**
6990       * This method is like `_.difference` except that it accepts `comparator`
6991       * which is invoked to compare elements of `array` to `values`. The order and
6992       * references of result values are determined by the first array. The comparator
6993       * is invoked with two arguments: (arrVal, othVal).
6994       *
6995       * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
6996       *
6997       * @static
6998       * @memberOf _
6999       * @since 4.0.0
7000       * @category Array
7001       * @param {Array} array The array to inspect.
7002       * @param {...Array} [values] The values to exclude.
7003       * @param {Function} [comparator] The comparator invoked per element.
7004       * @returns {Array} Returns the new array of filtered values.
7005       * @example
7006       *
7007       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
7008       *
7009       * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
7010       * // => [{ 'x': 2, 'y': 1 }]
7011       */
7012      var differenceWith = baseRest(function(array, values) {
7013        var comparator = last(values);
7014        if (isArrayLikeObject(comparator)) {
7015          comparator = undefined;
7016        }
7017        return isArrayLikeObject(array)
7018          ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
7019          : [];
7020      });
7021  
7022      /**
7023       * Creates a slice of `array` with `n` elements dropped from the beginning.
7024       *
7025       * @static
7026       * @memberOf _
7027       * @since 0.5.0
7028       * @category Array
7029       * @param {Array} array The array to query.
7030       * @param {number} [n=1] The number of elements to drop.
7031       * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
7032       * @returns {Array} Returns the slice of `array`.
7033       * @example
7034       *
7035       * _.drop([1, 2, 3]);
7036       * // => [2, 3]
7037       *
7038       * _.drop([1, 2, 3], 2);
7039       * // => [3]
7040       *
7041       * _.drop([1, 2, 3], 5);
7042       * // => []
7043       *
7044       * _.drop([1, 2, 3], 0);
7045       * // => [1, 2, 3]
7046       */
7047      function drop(array, n, guard) {
7048        var length = array == null ? 0 : array.length;
7049        if (!length) {
7050          return [];
7051        }
7052        n = (guard || n === undefined) ? 1 : toInteger(n);
7053        return baseSlice(array, n < 0 ? 0 : n, length);
7054      }
7055  
7056      /**
7057       * Creates a slice of `array` with `n` elements dropped from the end.
7058       *
7059       * @static
7060       * @memberOf _
7061       * @since 3.0.0
7062       * @category Array
7063       * @param {Array} array The array to query.
7064       * @param {number} [n=1] The number of elements to drop.
7065       * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
7066       * @returns {Array} Returns the slice of `array`.
7067       * @example
7068       *
7069       * _.dropRight([1, 2, 3]);
7070       * // => [1, 2]
7071       *
7072       * _.dropRight([1, 2, 3], 2);
7073       * // => [1]
7074       *
7075       * _.dropRight([1, 2, 3], 5);
7076       * // => []
7077       *
7078       * _.dropRight([1, 2, 3], 0);
7079       * // => [1, 2, 3]
7080       */
7081      function dropRight(array, n, guard) {
7082        var length = array == null ? 0 : array.length;
7083        if (!length) {
7084          return [];
7085        }
7086        n = (guard || n === undefined) ? 1 : toInteger(n);
7087        n = length - n;
7088        return baseSlice(array, 0, n < 0 ? 0 : n);
7089      }
7090  
7091      /**
7092       * Creates a slice of `array` excluding elements dropped from the end.
7093       * Elements are dropped until `predicate` returns falsey. The predicate is
7094       * invoked with three arguments: (value, index, array).
7095       *
7096       * @static
7097       * @memberOf _
7098       * @since 3.0.0
7099       * @category Array
7100       * @param {Array} array The array to query.
7101       * @param {Function} [predicate=_.identity] The function invoked per iteration.
7102       * @returns {Array} Returns the slice of `array`.
7103       * @example
7104       *
7105       * var users = [
7106       *   { 'user': 'barney',  'active': true },
7107       *   { 'user': 'fred',    'active': false },
7108       *   { 'user': 'pebbles', 'active': false }
7109       * ];
7110       *
7111       * _.dropRightWhile(users, function(o) { return !o.active; });
7112       * // => objects for ['barney']
7113       *
7114       * // The `_.matches` iteratee shorthand.
7115       * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
7116       * // => objects for ['barney', 'fred']
7117       *
7118       * // The `_.matchesProperty` iteratee shorthand.
7119       * _.dropRightWhile(users, ['active', false]);
7120       * // => objects for ['barney']
7121       *
7122       * // The `_.property` iteratee shorthand.
7123       * _.dropRightWhile(users, 'active');
7124       * // => objects for ['barney', 'fred', 'pebbles']
7125       */
7126      function dropRightWhile(array, predicate) {
7127        return (array && array.length)
7128          ? baseWhile(array, getIteratee(predicate, 3), true, true)
7129          : [];
7130      }
7131  
7132      /**
7133       * Creates a slice of `array` excluding elements dropped from the beginning.
7134       * Elements are dropped until `predicate` returns falsey. The predicate is
7135       * invoked with three arguments: (value, index, array).
7136       *
7137       * @static
7138       * @memberOf _
7139       * @since 3.0.0
7140       * @category Array
7141       * @param {Array} array The array to query.
7142       * @param {Function} [predicate=_.identity] The function invoked per iteration.
7143       * @returns {Array} Returns the slice of `array`.
7144       * @example
7145       *
7146       * var users = [
7147       *   { 'user': 'barney',  'active': false },
7148       *   { 'user': 'fred',    'active': false },
7149       *   { 'user': 'pebbles', 'active': true }
7150       * ];
7151       *
7152       * _.dropWhile(users, function(o) { return !o.active; });
7153       * // => objects for ['pebbles']
7154       *
7155       * // The `_.matches` iteratee shorthand.
7156       * _.dropWhile(users, { 'user': 'barney', 'active': false });
7157       * // => objects for ['fred', 'pebbles']
7158       *
7159       * // The `_.matchesProperty` iteratee shorthand.
7160       * _.dropWhile(users, ['active', false]);
7161       * // => objects for ['pebbles']
7162       *
7163       * // The `_.property` iteratee shorthand.
7164       * _.dropWhile(users, 'active');
7165       * // => objects for ['barney', 'fred', 'pebbles']
7166       */
7167      function dropWhile(array, predicate) {
7168        return (array && array.length)
7169          ? baseWhile(array, getIteratee(predicate, 3), true)
7170          : [];
7171      }
7172  
7173      /**
7174       * Fills elements of `array` with `value` from `start` up to, but not
7175       * including, `end`.
7176       *
7177       * **Note:** This method mutates `array`.
7178       *
7179       * @static
7180       * @memberOf _
7181       * @since 3.2.0
7182       * @category Array
7183       * @param {Array} array The array to fill.
7184       * @param {*} value The value to fill `array` with.
7185       * @param {number} [start=0] The start position.
7186       * @param {number} [end=array.length] The end position.
7187       * @returns {Array} Returns `array`.
7188       * @example
7189       *
7190       * var array = [1, 2, 3];
7191       *
7192       * _.fill(array, 'a');
7193       * console.log(array);
7194       * // => ['a', 'a', 'a']
7195       *
7196       * _.fill(Array(3), 2);
7197       * // => [2, 2, 2]
7198       *
7199       * _.fill([4, 6, 8, 10], '*', 1, 3);
7200       * // => [4, '*', '*', 10]
7201       */
7202      function fill(array, value, start, end) {
7203        var length = array == null ? 0 : array.length;
7204        if (!length) {
7205          return [];
7206        }
7207        if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
7208          start = 0;
7209          end = length;
7210        }
7211        return baseFill(array, value, start, end);
7212      }
7213  
7214      /**
7215       * This method is like `_.find` except that it returns the index of the first
7216       * element `predicate` returns truthy for instead of the element itself.
7217       *
7218       * @static
7219       * @memberOf _
7220       * @since 1.1.0
7221       * @category Array
7222       * @param {Array} array The array to inspect.
7223       * @param {Function} [predicate=_.identity] The function invoked per iteration.
7224       * @param {number} [fromIndex=0] The index to search from.
7225       * @returns {number} Returns the index of the found element, else `-1`.
7226       * @example
7227       *
7228       * var users = [
7229       *   { 'user': 'barney',  'active': false },
7230       *   { 'user': 'fred',    'active': false },
7231       *   { 'user': 'pebbles', 'active': true }
7232       * ];
7233       *
7234       * _.findIndex(users, function(o) { return o.user == 'barney'; });
7235       * // => 0
7236       *
7237       * // The `_.matches` iteratee shorthand.
7238       * _.findIndex(users, { 'user': 'fred', 'active': false });
7239       * // => 1
7240       *
7241       * // The `_.matchesProperty` iteratee shorthand.
7242       * _.findIndex(users, ['active', false]);
7243       * // => 0
7244       *
7245       * // The `_.property` iteratee shorthand.
7246       * _.findIndex(users, 'active');
7247       * // => 2
7248       */
7249      function findIndex(array, predicate, fromIndex) {
7250        var length = array == null ? 0 : array.length;
7251        if (!length) {
7252          return -1;
7253        }
7254        var index = fromIndex == null ? 0 : toInteger(fromIndex);
7255        if (index < 0) {
7256          index = nativeMax(length + index, 0);
7257        }
7258        return baseFindIndex(array, getIteratee(predicate, 3), index);
7259      }
7260  
7261      /**
7262       * This method is like `_.findIndex` except that it iterates over elements
7263       * of `collection` from right to left.
7264       *
7265       * @static
7266       * @memberOf _
7267       * @since 2.0.0
7268       * @category Array
7269       * @param {Array} array The array to inspect.
7270       * @param {Function} [predicate=_.identity] The function invoked per iteration.
7271       * @param {number} [fromIndex=array.length-1] The index to search from.
7272       * @returns {number} Returns the index of the found element, else `-1`.
7273       * @example
7274       *
7275       * var users = [
7276       *   { 'user': 'barney',  'active': true },
7277       *   { 'user': 'fred',    'active': false },
7278       *   { 'user': 'pebbles', 'active': false }
7279       * ];
7280       *
7281       * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
7282       * // => 2
7283       *
7284       * // The `_.matches` iteratee shorthand.
7285       * _.findLastIndex(users, { 'user': 'barney', 'active': true });
7286       * // => 0
7287       *
7288       * // The `_.matchesProperty` iteratee shorthand.
7289       * _.findLastIndex(users, ['active', false]);
7290       * // => 2
7291       *
7292       * // The `_.property` iteratee shorthand.
7293       * _.findLastIndex(users, 'active');
7294       * // => 0
7295       */
7296      function findLastIndex(array, predicate, fromIndex) {
7297        var length = array == null ? 0 : array.length;
7298        if (!length) {
7299          return -1;
7300        }
7301        var index = length - 1;
7302        if (fromIndex !== undefined) {
7303          index = toInteger(fromIndex);
7304          index = fromIndex < 0
7305            ? nativeMax(length + index, 0)
7306            : nativeMin(index, length - 1);
7307        }
7308        return baseFindIndex(array, getIteratee(predicate, 3), index, true);
7309      }
7310  
7311      /**
7312       * Flattens `array` a single level deep.
7313       *
7314       * @static
7315       * @memberOf _
7316       * @since 0.1.0
7317       * @category Array
7318       * @param {Array} array The array to flatten.
7319       * @returns {Array} Returns the new flattened array.
7320       * @example
7321       *
7322       * _.flatten([1, [2, [3, [4]], 5]]);
7323       * // => [1, 2, [3, [4]], 5]
7324       */
7325      function flatten(array) {
7326        var length = array == null ? 0 : array.length;
7327        return length ? baseFlatten(array, 1) : [];
7328      }
7329  
7330      /**
7331       * Recursively flattens `array`.
7332       *
7333       * @static
7334       * @memberOf _
7335       * @since 3.0.0
7336       * @category Array
7337       * @param {Array} array The array to flatten.
7338       * @returns {Array} Returns the new flattened array.
7339       * @example
7340       *
7341       * _.flattenDeep([1, [2, [3, [4]], 5]]);
7342       * // => [1, 2, 3, 4, 5]
7343       */
7344      function flattenDeep(array) {
7345        var length = array == null ? 0 : array.length;
7346        return length ? baseFlatten(array, INFINITY) : [];
7347      }
7348  
7349      /**
7350       * Recursively flatten `array` up to `depth` times.
7351       *
7352       * @static
7353       * @memberOf _
7354       * @since 4.4.0
7355       * @category Array
7356       * @param {Array} array The array to flatten.
7357       * @param {number} [depth=1] The maximum recursion depth.
7358       * @returns {Array} Returns the new flattened array.
7359       * @example
7360       *
7361       * var array = [1, [2, [3, [4]], 5]];
7362       *
7363       * _.flattenDepth(array, 1);
7364       * // => [1, 2, [3, [4]], 5]
7365       *
7366       * _.flattenDepth(array, 2);
7367       * // => [1, 2, 3, [4], 5]
7368       */
7369      function flattenDepth(array, depth) {
7370        var length = array == null ? 0 : array.length;
7371        if (!length) {
7372          return [];
7373        }
7374        depth = depth === undefined ? 1 : toInteger(depth);
7375        return baseFlatten(array, depth);
7376      }
7377  
7378      /**
7379       * The inverse of `_.toPairs`; this method returns an object composed
7380       * from key-value `pairs`.
7381       *
7382       * @static
7383       * @memberOf _
7384       * @since 4.0.0
7385       * @category Array
7386       * @param {Array} pairs The key-value pairs.
7387       * @returns {Object} Returns the new object.
7388       * @example
7389       *
7390       * _.fromPairs([['a', 1], ['b', 2]]);
7391       * // => { 'a': 1, 'b': 2 }
7392       */
7393      function fromPairs(pairs) {
7394        var index = -1,
7395            length = pairs == null ? 0 : pairs.length,
7396            result = {};
7397  
7398        while (++index < length) {
7399          var pair = pairs[index];
7400          result[pair[0]] = pair[1];
7401        }
7402        return result;
7403      }
7404  
7405      /**
7406       * Gets the first element of `array`.
7407       *
7408       * @static
7409       * @memberOf _
7410       * @since 0.1.0
7411       * @alias first
7412       * @category Array
7413       * @param {Array} array The array to query.
7414       * @returns {*} Returns the first element of `array`.
7415       * @example
7416       *
7417       * _.head([1, 2, 3]);
7418       * // => 1
7419       *
7420       * _.head([]);
7421       * // => undefined
7422       */
7423      function head(array) {
7424        return (array && array.length) ? array[0] : undefined;
7425      }
7426  
7427      /**
7428       * Gets the index at which the first occurrence of `value` is found in `array`
7429       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7430       * for equality comparisons. If `fromIndex` is negative, it's used as the
7431       * offset from the end of `array`.
7432       *
7433       * @static
7434       * @memberOf _
7435       * @since 0.1.0
7436       * @category Array
7437       * @param {Array} array The array to inspect.
7438       * @param {*} value The value to search for.
7439       * @param {number} [fromIndex=0] The index to search from.
7440       * @returns {number} Returns the index of the matched value, else `-1`.
7441       * @example
7442       *
7443       * _.indexOf([1, 2, 1, 2], 2);
7444       * // => 1
7445       *
7446       * // Search from the `fromIndex`.
7447       * _.indexOf([1, 2, 1, 2], 2, 2);
7448       * // => 3
7449       */
7450      function indexOf(array, value, fromIndex) {
7451        var length = array == null ? 0 : array.length;
7452        if (!length) {
7453          return -1;
7454        }
7455        var index = fromIndex == null ? 0 : toInteger(fromIndex);
7456        if (index < 0) {
7457          index = nativeMax(length + index, 0);
7458        }
7459        return baseIndexOf(array, value, index);
7460      }
7461  
7462      /**
7463       * Gets all but the last element of `array`.
7464       *
7465       * @static
7466       * @memberOf _
7467       * @since 0.1.0
7468       * @category Array
7469       * @param {Array} array The array to query.
7470       * @returns {Array} Returns the slice of `array`.
7471       * @example
7472       *
7473       * _.initial([1, 2, 3]);
7474       * // => [1, 2]
7475       */
7476      function initial(array) {
7477        var length = array == null ? 0 : array.length;
7478        return length ? baseSlice(array, 0, -1) : [];
7479      }
7480  
7481      /**
7482       * Creates an array of unique values that are included in all given arrays
7483       * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7484       * for equality comparisons. The order and references of result values are
7485       * determined by the first array.
7486       *
7487       * @static
7488       * @memberOf _
7489       * @since 0.1.0
7490       * @category Array
7491       * @param {...Array} [arrays] The arrays to inspect.
7492       * @returns {Array} Returns the new array of intersecting values.
7493       * @example
7494       *
7495       * _.intersection([2, 1], [2, 3]);
7496       * // => [2]
7497       */
7498      var intersection = baseRest(function(arrays) {
7499        var mapped = arrayMap(arrays, castArrayLikeObject);
7500        return (mapped.length && mapped[0] === arrays[0])
7501          ? baseIntersection(mapped)
7502          : [];
7503      });
7504  
7505      /**
7506       * This method is like `_.intersection` except that it accepts `iteratee`
7507       * which is invoked for each element of each `arrays` to generate the criterion
7508       * by which they're compared. The order and references of result values are
7509       * determined by the first array. The iteratee is invoked with one argument:
7510       * (value).
7511       *
7512       * @static
7513       * @memberOf _
7514       * @since 4.0.0
7515       * @category Array
7516       * @param {...Array} [arrays] The arrays to inspect.
7517       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
7518       * @returns {Array} Returns the new array of intersecting values.
7519       * @example
7520       *
7521       * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
7522       * // => [2.1]
7523       *
7524       * // The `_.property` iteratee shorthand.
7525       * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
7526       * // => [{ 'x': 1 }]
7527       */
7528      var intersectionBy = baseRest(function(arrays) {
7529        var iteratee = last(arrays),
7530            mapped = arrayMap(arrays, castArrayLikeObject);
7531  
7532        if (iteratee === last(mapped)) {
7533          iteratee = undefined;
7534        } else {
7535          mapped.pop();
7536        }
7537        return (mapped.length && mapped[0] === arrays[0])
7538          ? baseIntersection(mapped, getIteratee(iteratee, 2))
7539          : [];
7540      });
7541  
7542      /**
7543       * This method is like `_.intersection` except that it accepts `comparator`
7544       * which is invoked to compare elements of `arrays`. The order and references
7545       * of result values are determined by the first array. The comparator is
7546       * invoked with two arguments: (arrVal, othVal).
7547       *
7548       * @static
7549       * @memberOf _
7550       * @since 4.0.0
7551       * @category Array
7552       * @param {...Array} [arrays] The arrays to inspect.
7553       * @param {Function} [comparator] The comparator invoked per element.
7554       * @returns {Array} Returns the new array of intersecting values.
7555       * @example
7556       *
7557       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
7558       * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
7559       *
7560       * _.intersectionWith(objects, others, _.isEqual);
7561       * // => [{ 'x': 1, 'y': 2 }]
7562       */
7563      var intersectionWith = baseRest(function(arrays) {
7564        var comparator = last(arrays),
7565            mapped = arrayMap(arrays, castArrayLikeObject);
7566  
7567        comparator = typeof comparator == 'function' ? comparator : undefined;
7568        if (comparator) {
7569          mapped.pop();
7570        }
7571        return (mapped.length && mapped[0] === arrays[0])
7572          ? baseIntersection(mapped, undefined, comparator)
7573          : [];
7574      });
7575  
7576      /**
7577       * Converts all elements in `array` into a string separated by `separator`.
7578       *
7579       * @static
7580       * @memberOf _
7581       * @since 4.0.0
7582       * @category Array
7583       * @param {Array} array The array to convert.
7584       * @param {string} [separator=','] The element separator.
7585       * @returns {string} Returns the joined string.
7586       * @example
7587       *
7588       * _.join(['a', 'b', 'c'], '~');
7589       * // => 'a~b~c'
7590       */
7591      function join(array, separator) {
7592        return array == null ? '' : nativeJoin.call(array, separator);
7593      }
7594  
7595      /**
7596       * Gets the last element of `array`.
7597       *
7598       * @static
7599       * @memberOf _
7600       * @since 0.1.0
7601       * @category Array
7602       * @param {Array} array The array to query.
7603       * @returns {*} Returns the last element of `array`.
7604       * @example
7605       *
7606       * _.last([1, 2, 3]);
7607       * // => 3
7608       */
7609      function last(array) {
7610        var length = array == null ? 0 : array.length;
7611        return length ? array[length - 1] : undefined;
7612      }
7613  
7614      /**
7615       * This method is like `_.indexOf` except that it iterates over elements of
7616       * `array` from right to left.
7617       *
7618       * @static
7619       * @memberOf _
7620       * @since 0.1.0
7621       * @category Array
7622       * @param {Array} array The array to inspect.
7623       * @param {*} value The value to search for.
7624       * @param {number} [fromIndex=array.length-1] The index to search from.
7625       * @returns {number} Returns the index of the matched value, else `-1`.
7626       * @example
7627       *
7628       * _.lastIndexOf([1, 2, 1, 2], 2);
7629       * // => 3
7630       *
7631       * // Search from the `fromIndex`.
7632       * _.lastIndexOf([1, 2, 1, 2], 2, 2);
7633       * // => 1
7634       */
7635      function lastIndexOf(array, value, fromIndex) {
7636        var length = array == null ? 0 : array.length;
7637        if (!length) {
7638          return -1;
7639        }
7640        var index = length;
7641        if (fromIndex !== undefined) {
7642          index = toInteger(fromIndex);
7643          index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
7644        }
7645        return value === value
7646          ? strictLastIndexOf(array, value, index)
7647          : baseFindIndex(array, baseIsNaN, index, true);
7648      }
7649  
7650      /**
7651       * Gets the element at index `n` of `array`. If `n` is negative, the nth
7652       * element from the end is returned.
7653       *
7654       * @static
7655       * @memberOf _
7656       * @since 4.11.0
7657       * @category Array
7658       * @param {Array} array The array to query.
7659       * @param {number} [n=0] The index of the element to return.
7660       * @returns {*} Returns the nth element of `array`.
7661       * @example
7662       *
7663       * var array = ['a', 'b', 'c', 'd'];
7664       *
7665       * _.nth(array, 1);
7666       * // => 'b'
7667       *
7668       * _.nth(array, -2);
7669       * // => 'c';
7670       */
7671      function nth(array, n) {
7672        return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;
7673      }
7674  
7675      /**
7676       * Removes all given values from `array` using
7677       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7678       * for equality comparisons.
7679       *
7680       * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
7681       * to remove elements from an array by predicate.
7682       *
7683       * @static
7684       * @memberOf _
7685       * @since 2.0.0
7686       * @category Array
7687       * @param {Array} array The array to modify.
7688       * @param {...*} [values] The values to remove.
7689       * @returns {Array} Returns `array`.
7690       * @example
7691       *
7692       * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
7693       *
7694       * _.pull(array, 'a', 'c');
7695       * console.log(array);
7696       * // => ['b', 'b']
7697       */
7698      var pull = baseRest(pullAll);
7699  
7700      /**
7701       * This method is like `_.pull` except that it accepts an array of values to remove.
7702       *
7703       * **Note:** Unlike `_.difference`, this method mutates `array`.
7704       *
7705       * @static
7706       * @memberOf _
7707       * @since 4.0.0
7708       * @category Array
7709       * @param {Array} array The array to modify.
7710       * @param {Array} values The values to remove.
7711       * @returns {Array} Returns `array`.
7712       * @example
7713       *
7714       * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
7715       *
7716       * _.pullAll(array, ['a', 'c']);
7717       * console.log(array);
7718       * // => ['b', 'b']
7719       */
7720      function pullAll(array, values) {
7721        return (array && array.length && values && values.length)
7722          ? basePullAll(array, values)
7723          : array;
7724      }
7725  
7726      /**
7727       * This method is like `_.pullAll` except that it accepts `iteratee` which is
7728       * invoked for each element of `array` and `values` to generate the criterion
7729       * by which they're compared. The iteratee is invoked with one argument: (value).
7730       *
7731       * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
7732       *
7733       * @static
7734       * @memberOf _
7735       * @since 4.0.0
7736       * @category Array
7737       * @param {Array} array The array to modify.
7738       * @param {Array} values The values to remove.
7739       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
7740       * @returns {Array} Returns `array`.
7741       * @example
7742       *
7743       * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
7744       *
7745       * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
7746       * console.log(array);
7747       * // => [{ 'x': 2 }]
7748       */
7749      function pullAllBy(array, values, iteratee) {
7750        return (array && array.length && values && values.length)
7751          ? basePullAll(array, values, getIteratee(iteratee, 2))
7752          : array;
7753      }
7754  
7755      /**
7756       * This method is like `_.pullAll` except that it accepts `comparator` which
7757       * is invoked to compare elements of `array` to `values`. The comparator is
7758       * invoked with two arguments: (arrVal, othVal).
7759       *
7760       * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
7761       *
7762       * @static
7763       * @memberOf _
7764       * @since 4.6.0
7765       * @category Array
7766       * @param {Array} array The array to modify.
7767       * @param {Array} values The values to remove.
7768       * @param {Function} [comparator] The comparator invoked per element.
7769       * @returns {Array} Returns `array`.
7770       * @example
7771       *
7772       * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
7773       *
7774       * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
7775       * console.log(array);
7776       * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
7777       */
7778      function pullAllWith(array, values, comparator) {
7779        return (array && array.length && values && values.length)
7780          ? basePullAll(array, values, undefined, comparator)
7781          : array;
7782      }
7783  
7784      /**
7785       * Removes elements from `array` corresponding to `indexes` and returns an
7786       * array of removed elements.
7787       *
7788       * **Note:** Unlike `_.at`, this method mutates `array`.
7789       *
7790       * @static
7791       * @memberOf _
7792       * @since 3.0.0
7793       * @category Array
7794       * @param {Array} array The array to modify.
7795       * @param {...(number|number[])} [indexes] The indexes of elements to remove.
7796       * @returns {Array} Returns the new array of removed elements.
7797       * @example
7798       *
7799       * var array = ['a', 'b', 'c', 'd'];
7800       * var pulled = _.pullAt(array, [1, 3]);
7801       *
7802       * console.log(array);
7803       * // => ['a', 'c']
7804       *
7805       * console.log(pulled);
7806       * // => ['b', 'd']
7807       */
7808      var pullAt = flatRest(function(array, indexes) {
7809        var length = array == null ? 0 : array.length,
7810            result = baseAt(array, indexes);
7811  
7812        basePullAt(array, arrayMap(indexes, function(index) {
7813          return isIndex(index, length) ? +index : index;
7814        }).sort(compareAscending));
7815  
7816        return result;
7817      });
7818  
7819      /**
7820       * Removes all elements from `array` that `predicate` returns truthy for
7821       * and returns an array of the removed elements. The predicate is invoked
7822       * with three arguments: (value, index, array).
7823       *
7824       * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
7825       * to pull elements from an array by value.
7826       *
7827       * @static
7828       * @memberOf _
7829       * @since 2.0.0
7830       * @category Array
7831       * @param {Array} array The array to modify.
7832       * @param {Function} [predicate=_.identity] The function invoked per iteration.
7833       * @returns {Array} Returns the new array of removed elements.
7834       * @example
7835       *
7836       * var array = [1, 2, 3, 4];
7837       * var evens = _.remove(array, function(n) {
7838       *   return n % 2 == 0;
7839       * });
7840       *
7841       * console.log(array);
7842       * // => [1, 3]
7843       *
7844       * console.log(evens);
7845       * // => [2, 4]
7846       */
7847      function remove(array, predicate) {
7848        var result = [];
7849        if (!(array && array.length)) {
7850          return result;
7851        }
7852        var index = -1,
7853            indexes = [],
7854            length = array.length;
7855  
7856        predicate = getIteratee(predicate, 3);
7857        while (++index < length) {
7858          var value = array[index];
7859          if (predicate(value, index, array)) {
7860            result.push(value);
7861            indexes.push(index);
7862          }
7863        }
7864        basePullAt(array, indexes);
7865        return result;
7866      }
7867  
7868      /**
7869       * Reverses `array` so that the first element becomes the last, the second
7870       * element becomes the second to last, and so on.
7871       *
7872       * **Note:** This method mutates `array` and is based on
7873       * [`Array#reverse`](https://mdn.io/Array/reverse).
7874       *
7875       * @static
7876       * @memberOf _
7877       * @since 4.0.0
7878       * @category Array
7879       * @param {Array} array The array to modify.
7880       * @returns {Array} Returns `array`.
7881       * @example
7882       *
7883       * var array = [1, 2, 3];
7884       *
7885       * _.reverse(array);
7886       * // => [3, 2, 1]
7887       *
7888       * console.log(array);
7889       * // => [3, 2, 1]
7890       */
7891      function reverse(array) {
7892        return array == null ? array : nativeReverse.call(array);
7893      }
7894  
7895      /**
7896       * Creates a slice of `array` from `start` up to, but not including, `end`.
7897       *
7898       * **Note:** This method is used instead of
7899       * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
7900       * returned.
7901       *
7902       * @static
7903       * @memberOf _
7904       * @since 3.0.0
7905       * @category Array
7906       * @param {Array} array The array to slice.
7907       * @param {number} [start=0] The start position.
7908       * @param {number} [end=array.length] The end position.
7909       * @returns {Array} Returns the slice of `array`.
7910       */
7911      function slice(array, start, end) {
7912        var length = array == null ? 0 : array.length;
7913        if (!length) {
7914          return [];
7915        }
7916        if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
7917          start = 0;
7918          end = length;
7919        }
7920        else {
7921          start = start == null ? 0 : toInteger(start);
7922          end = end === undefined ? length : toInteger(end);
7923        }
7924        return baseSlice(array, start, end);
7925      }
7926  
7927      /**
7928       * Uses a binary search to determine the lowest index at which `value`
7929       * should be inserted into `array` in order to maintain its sort order.
7930       *
7931       * @static
7932       * @memberOf _
7933       * @since 0.1.0
7934       * @category Array
7935       * @param {Array} array The sorted array to inspect.
7936       * @param {*} value The value to evaluate.
7937       * @returns {number} Returns the index at which `value` should be inserted
7938       *  into `array`.
7939       * @example
7940       *
7941       * _.sortedIndex([30, 50], 40);
7942       * // => 1
7943       */
7944      function sortedIndex(array, value) {
7945        return baseSortedIndex(array, value);
7946      }
7947  
7948      /**
7949       * This method is like `_.sortedIndex` except that it accepts `iteratee`
7950       * which is invoked for `value` and each element of `array` to compute their
7951       * sort ranking. The iteratee is invoked with one argument: (value).
7952       *
7953       * @static
7954       * @memberOf _
7955       * @since 4.0.0
7956       * @category Array
7957       * @param {Array} array The sorted array to inspect.
7958       * @param {*} value The value to evaluate.
7959       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
7960       * @returns {number} Returns the index at which `value` should be inserted
7961       *  into `array`.
7962       * @example
7963       *
7964       * var objects = [{ 'x': 4 }, { 'x': 5 }];
7965       *
7966       * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
7967       * // => 0
7968       *
7969       * // The `_.property` iteratee shorthand.
7970       * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
7971       * // => 0
7972       */
7973      function sortedIndexBy(array, value, iteratee) {
7974        return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
7975      }
7976  
7977      /**
7978       * This method is like `_.indexOf` except that it performs a binary
7979       * search on a sorted `array`.
7980       *
7981       * @static
7982       * @memberOf _
7983       * @since 4.0.0
7984       * @category Array
7985       * @param {Array} array The array to inspect.
7986       * @param {*} value The value to search for.
7987       * @returns {number} Returns the index of the matched value, else `-1`.
7988       * @example
7989       *
7990       * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
7991       * // => 1
7992       */
7993      function sortedIndexOf(array, value) {
7994        var length = array == null ? 0 : array.length;
7995        if (length) {
7996          var index = baseSortedIndex(array, value);
7997          if (index < length && eq(array[index], value)) {
7998            return index;
7999          }
8000        }
8001        return -1;
8002      }
8003  
8004      /**
8005       * This method is like `_.sortedIndex` except that it returns the highest
8006       * index at which `value` should be inserted into `array` in order to
8007       * maintain its sort order.
8008       *
8009       * @static
8010       * @memberOf _
8011       * @since 3.0.0
8012       * @category Array
8013       * @param {Array} array The sorted array to inspect.
8014       * @param {*} value The value to evaluate.
8015       * @returns {number} Returns the index at which `value` should be inserted
8016       *  into `array`.
8017       * @example
8018       *
8019       * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
8020       * // => 4
8021       */
8022      function sortedLastIndex(array, value) {
8023        return baseSortedIndex(array, value, true);
8024      }
8025  
8026      /**
8027       * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
8028       * which is invoked for `value` and each element of `array` to compute their
8029       * sort ranking. The iteratee is invoked with one argument: (value).
8030       *
8031       * @static
8032       * @memberOf _
8033       * @since 4.0.0
8034       * @category Array
8035       * @param {Array} array The sorted array to inspect.
8036       * @param {*} value The value to evaluate.
8037       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
8038       * @returns {number} Returns the index at which `value` should be inserted
8039       *  into `array`.
8040       * @example
8041       *
8042       * var objects = [{ 'x': 4 }, { 'x': 5 }];
8043       *
8044       * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
8045       * // => 1
8046       *
8047       * // The `_.property` iteratee shorthand.
8048       * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
8049       * // => 1
8050       */
8051      function sortedLastIndexBy(array, value, iteratee) {
8052        return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
8053      }
8054  
8055      /**
8056       * This method is like `_.lastIndexOf` except that it performs a binary
8057       * search on a sorted `array`.
8058       *
8059       * @static
8060       * @memberOf _
8061       * @since 4.0.0
8062       * @category Array
8063       * @param {Array} array The array to inspect.
8064       * @param {*} value The value to search for.
8065       * @returns {number} Returns the index of the matched value, else `-1`.
8066       * @example
8067       *
8068       * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
8069       * // => 3
8070       */
8071      function sortedLastIndexOf(array, value) {
8072        var length = array == null ? 0 : array.length;
8073        if (length) {
8074          var index = baseSortedIndex(array, value, true) - 1;
8075          if (eq(array[index], value)) {
8076            return index;
8077          }
8078        }
8079        return -1;
8080      }
8081  
8082      /**
8083       * This method is like `_.uniq` except that it's designed and optimized
8084       * for sorted arrays.
8085       *
8086       * @static
8087       * @memberOf _
8088       * @since 4.0.0
8089       * @category Array
8090       * @param {Array} array The array to inspect.
8091       * @returns {Array} Returns the new duplicate free array.
8092       * @example
8093       *
8094       * _.sortedUniq([1, 1, 2]);
8095       * // => [1, 2]
8096       */
8097      function sortedUniq(array) {
8098        return (array && array.length)
8099          ? baseSortedUniq(array)
8100          : [];
8101      }
8102  
8103      /**
8104       * This method is like `_.uniqBy` except that it's designed and optimized
8105       * for sorted arrays.
8106       *
8107       * @static
8108       * @memberOf _
8109       * @since 4.0.0
8110       * @category Array
8111       * @param {Array} array The array to inspect.
8112       * @param {Function} [iteratee] The iteratee invoked per element.
8113       * @returns {Array} Returns the new duplicate free array.
8114       * @example
8115       *
8116       * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
8117       * // => [1.1, 2.3]
8118       */
8119      function sortedUniqBy(array, iteratee) {
8120        return (array && array.length)
8121          ? baseSortedUniq(array, getIteratee(iteratee, 2))
8122          : [];
8123      }
8124  
8125      /**
8126       * Gets all but the first element of `array`.
8127       *
8128       * @static
8129       * @memberOf _
8130       * @since 4.0.0
8131       * @category Array
8132       * @param {Array} array The array to query.
8133       * @returns {Array} Returns the slice of `array`.
8134       * @example
8135       *
8136       * _.tail([1, 2, 3]);
8137       * // => [2, 3]
8138       */
8139      function tail(array) {
8140        var length = array == null ? 0 : array.length;
8141        return length ? baseSlice(array, 1, length) : [];
8142      }
8143  
8144      /**
8145       * Creates a slice of `array` with `n` elements taken from the beginning.
8146       *
8147       * @static
8148       * @memberOf _
8149       * @since 0.1.0
8150       * @category Array
8151       * @param {Array} array The array to query.
8152       * @param {number} [n=1] The number of elements to take.
8153       * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
8154       * @returns {Array} Returns the slice of `array`.
8155       * @example
8156       *
8157       * _.take([1, 2, 3]);
8158       * // => [1]
8159       *
8160       * _.take([1, 2, 3], 2);
8161       * // => [1, 2]
8162       *
8163       * _.take([1, 2, 3], 5);
8164       * // => [1, 2, 3]
8165       *
8166       * _.take([1, 2, 3], 0);
8167       * // => []
8168       */
8169      function take(array, n, guard) {
8170        if (!(array && array.length)) {
8171          return [];
8172        }
8173        n = (guard || n === undefined) ? 1 : toInteger(n);
8174        return baseSlice(array, 0, n < 0 ? 0 : n);
8175      }
8176  
8177      /**
8178       * Creates a slice of `array` with `n` elements taken from the end.
8179       *
8180       * @static
8181       * @memberOf _
8182       * @since 3.0.0
8183       * @category Array
8184       * @param {Array} array The array to query.
8185       * @param {number} [n=1] The number of elements to take.
8186       * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
8187       * @returns {Array} Returns the slice of `array`.
8188       * @example
8189       *
8190       * _.takeRight([1, 2, 3]);
8191       * // => [3]
8192       *
8193       * _.takeRight([1, 2, 3], 2);
8194       * // => [2, 3]
8195       *
8196       * _.takeRight([1, 2, 3], 5);
8197       * // => [1, 2, 3]
8198       *
8199       * _.takeRight([1, 2, 3], 0);
8200       * // => []
8201       */
8202      function takeRight(array, n, guard) {
8203        var length = array == null ? 0 : array.length;
8204        if (!length) {
8205          return [];
8206        }
8207        n = (guard || n === undefined) ? 1 : toInteger(n);
8208        n = length - n;
8209        return baseSlice(array, n < 0 ? 0 : n, length);
8210      }
8211  
8212      /**
8213       * Creates a slice of `array` with elements taken from the end. Elements are
8214       * taken until `predicate` returns falsey. The predicate is invoked with
8215       * three arguments: (value, index, array).
8216       *
8217       * @static
8218       * @memberOf _
8219       * @since 3.0.0
8220       * @category Array
8221       * @param {Array} array The array to query.
8222       * @param {Function} [predicate=_.identity] The function invoked per iteration.
8223       * @returns {Array} Returns the slice of `array`.
8224       * @example
8225       *
8226       * var users = [
8227       *   { 'user': 'barney',  'active': true },
8228       *   { 'user': 'fred',    'active': false },
8229       *   { 'user': 'pebbles', 'active': false }
8230       * ];
8231       *
8232       * _.takeRightWhile(users, function(o) { return !o.active; });
8233       * // => objects for ['fred', 'pebbles']
8234       *
8235       * // The `_.matches` iteratee shorthand.
8236       * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
8237       * // => objects for ['pebbles']
8238       *
8239       * // The `_.matchesProperty` iteratee shorthand.
8240       * _.takeRightWhile(users, ['active', false]);
8241       * // => objects for ['fred', 'pebbles']
8242       *
8243       * // The `_.property` iteratee shorthand.
8244       * _.takeRightWhile(users, 'active');
8245       * // => []
8246       */
8247      function takeRightWhile(array, predicate) {
8248        return (array && array.length)
8249          ? baseWhile(array, getIteratee(predicate, 3), false, true)
8250          : [];
8251      }
8252  
8253      /**
8254       * Creates a slice of `array` with elements taken from the beginning. Elements
8255       * are taken until `predicate` returns falsey. The predicate is invoked with
8256       * three arguments: (value, index, array).
8257       *
8258       * @static
8259       * @memberOf _
8260       * @since 3.0.0
8261       * @category Array
8262       * @param {Array} array The array to query.
8263       * @param {Function} [predicate=_.identity] The function invoked per iteration.
8264       * @returns {Array} Returns the slice of `array`.
8265       * @example
8266       *
8267       * var users = [
8268       *   { 'user': 'barney',  'active': false },
8269       *   { 'user': 'fred',    'active': false },
8270       *   { 'user': 'pebbles', 'active': true }
8271       * ];
8272       *
8273       * _.takeWhile(users, function(o) { return !o.active; });
8274       * // => objects for ['barney', 'fred']
8275       *
8276       * // The `_.matches` iteratee shorthand.
8277       * _.takeWhile(users, { 'user': 'barney', 'active': false });
8278       * // => objects for ['barney']
8279       *
8280       * // The `_.matchesProperty` iteratee shorthand.
8281       * _.takeWhile(users, ['active', false]);
8282       * // => objects for ['barney', 'fred']
8283       *
8284       * // The `_.property` iteratee shorthand.
8285       * _.takeWhile(users, 'active');
8286       * // => []
8287       */
8288      function takeWhile(array, predicate) {
8289        return (array && array.length)
8290          ? baseWhile(array, getIteratee(predicate, 3))
8291          : [];
8292      }
8293  
8294      /**
8295       * Creates an array of unique values, in order, from all given arrays using
8296       * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
8297       * for equality comparisons.
8298       *
8299       * @static
8300       * @memberOf _
8301       * @since 0.1.0
8302       * @category Array
8303       * @param {...Array} [arrays] The arrays to inspect.
8304       * @returns {Array} Returns the new array of combined values.
8305       * @example
8306       *
8307       * _.union([2], [1, 2]);
8308       * // => [2, 1]
8309       */
8310      var union = baseRest(function(arrays) {
8311        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
8312      });
8313  
8314      /**
8315       * This method is like `_.union` except that it accepts `iteratee` which is
8316       * invoked for each element of each `arrays` to generate the criterion by
8317       * which uniqueness is computed. Result values are chosen from the first
8318       * array in which the value occurs. The iteratee is invoked with one argument:
8319       * (value).
8320       *
8321       * @static
8322       * @memberOf _
8323       * @since 4.0.0
8324       * @category Array
8325       * @param {...Array} [arrays] The arrays to inspect.
8326       * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
8327       * @returns {Array} Returns the new array of combined values.
8328       * @example
8329       *
8330       * _.unionBy([2.1], [1.2, 2.3], Math.floor);
8331       * // => [2.1, 1.2]
8332       *
8333       * // The `_.property` iteratee shorthand.
8334       * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
8335       * // => [{ 'x': 1 }, { 'x': 2 }]
8336       */
8337      var unionBy = baseRest(function(arrays) {
8338        var iteratee = last(arrays);
8339        if (isArrayLikeObject(iteratee)) {
8340          iteratee = undefined;
8341        }
8342        return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
8343      });
8344  
8345      /**
8346       * This method is like `_.union` except that it accepts `comparator` which
8347       * is invoked to compare elements of `arrays`. Result values are chosen from
8348       * the first array in which the value occurs. The comparator is invoked
8349       * with two arguments: (arrVal, othVal).
8350       *
8351       * @static
8352       * @memberOf _
8353       * @since 4.0.0
8354       * @category Array
8355       * @param {...Array} [arrays] The arrays to inspect.
8356       * @param {Function} [comparator] The comparator invoked per element.
8357       * @returns {Array} Returns the new array of combined values.
8358       * @example
8359       *
8360       * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
8361       * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
8362       *
8363       * _.unionWith(objects, others, _.isEqual);
8364       * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
8365       */
8366      var unionWith =