| [ Index ] |
PHP Cross Reference of WordPress Trunk (Updated Daily) |
[Summary view] [Print] [Text view]
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 '&': '&', 386 '<': '<', 387 '>': '>', 388 '"': '"', 389 "'": ''' 390 }; 391 392 /** Used to map HTML entities to characters. */ 393 var htmlUnescapes = { 394 '&': '&', 395 '<': '<', 396 '>': '>', 397 '"': '"', 398 ''': "'" 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 = baseRest(function(arrays) { 8367 var comparator = last(arrays); 8368 comparator = typeof comparator == 'function' ? comparator : undefined; 8369 return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator); 8370 }); 8371 8372 /** 8373 * Creates a duplicate-free version of an array, using 8374 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) 8375 * for equality comparisons, in which only the first occurrence of each element 8376 * is kept. The order of result values is determined by the order they occur 8377 * in the array. 8378 * 8379 * @static 8380 * @memberOf _ 8381 * @since 0.1.0 8382 * @category Array 8383 * @param {Array} array The array to inspect. 8384 * @returns {Array} Returns the new duplicate free array. 8385 * @example 8386 * 8387 * _.uniq([2, 1, 2]); 8388 * // => [2, 1] 8389 */ 8390 function uniq(array) { 8391 return (array && array.length) ? baseUniq(array) : []; 8392 } 8393 8394 /** 8395 * This method is like `_.uniq` except that it accepts `iteratee` which is 8396 * invoked for each element in `array` to generate the criterion by which 8397 * uniqueness is computed. The order of result values is determined by the 8398 * order they occur in the array. The iteratee is invoked with one argument: 8399 * (value). 8400 * 8401 * @static 8402 * @memberOf _ 8403 * @since 4.0.0 8404 * @category Array 8405 * @param {Array} array The array to inspect. 8406 * @param {Function} [iteratee=_.identity] The iteratee invoked per element. 8407 * @returns {Array} Returns the new duplicate free array. 8408 * @example 8409 * 8410 * _.uniqBy([2.1, 1.2, 2.3], Math.floor); 8411 * // => [2.1, 1.2] 8412 * 8413 * // The `_.property` iteratee shorthand. 8414 * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); 8415 * // => [{ 'x': 1 }, { 'x': 2 }] 8416 */ 8417 function uniqBy(array, iteratee) { 8418 return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : []; 8419 } 8420 8421 /** 8422 * This method is like `_.uniq` except that it accepts `comparator` which 8423 * is invoked to compare elements of `array`. The order of result values is 8424 * determined by the order they occur in the array.The comparator is invoked 8425 * with two arguments: (arrVal, othVal). 8426 * 8427 * @static 8428 * @memberOf _ 8429 * @since 4.0.0 8430 * @category Array 8431 * @param {Array} array The array to inspect. 8432 * @param {Function} [comparator] The comparator invoked per element. 8433 * @returns {Array} Returns the new duplicate free array. 8434 * @example 8435 * 8436 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; 8437 * 8438 * _.uniqWith(objects, _.isEqual); 8439 * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] 8440 */ 8441 function uniqWith(array, comparator) { 8442 comparator = typeof comparator == 'function' ? comparator : undefined; 8443 return (array && array.length) ? baseUniq(array, undefined, comparator) : []; 8444 } 8445 8446 /** 8447 * This method is like `_.zip` except that it accepts an array of grouped 8448 * elements and creates an array regrouping the elements to their pre-zip 8449 * configuration. 8450 * 8451 * @static 8452 * @memberOf _ 8453 * @since 1.2.0 8454 * @category Array 8455 * @param {Array} array The array of grouped elements to process. 8456 * @returns {Array} Returns the new array of regrouped elements. 8457 * @example 8458 * 8459 * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); 8460 * // => [['a', 1, true], ['b', 2, false]] 8461 * 8462 * _.unzip(zipped); 8463 * // => [['a', 'b'], [1, 2], [true, false]] 8464 */ 8465 function unzip(array) { 8466 if (!(array && array.length)) { 8467 return []; 8468 } 8469 var length = 0; 8470 array = arrayFilter(array, function(group) { 8471 if (isArrayLikeObject(group)) { 8472 length = nativeMax(group.length, length); 8473 return true; 8474 } 8475 }); 8476 return baseTimes(length, function(index) { 8477 return arrayMap(array, baseProperty(index)); 8478 }); 8479 } 8480 8481 /** 8482 * This method is like `_.unzip` except that it accepts `iteratee` to specify 8483 * how regrouped values should be combined. The iteratee is invoked with the 8484 * elements of each group: (...group). 8485 * 8486 * @static 8487 * @memberOf _ 8488 * @since 3.8.0 8489 * @category Array 8490 * @param {Array} array The array of grouped elements to process. 8491 * @param {Function} [iteratee=_.identity] The function to combine 8492 * regrouped values. 8493 * @returns {Array} Returns the new array of regrouped elements. 8494 * @example 8495 * 8496 * var zipped = _.zip([1, 2], [10, 20], [100, 200]); 8497 * // => [[1, 10, 100], [2, 20, 200]] 8498 * 8499 * _.unzipWith(zipped, _.add); 8500 * // => [3, 30, 300] 8501 */ 8502 function unzipWith(array, iteratee) { 8503 if (!(array && array.length)) { 8504 return []; 8505 } 8506 var result = unzip(array); 8507 if (iteratee == null) { 8508 return result; 8509 } 8510 return arrayMap(result, function(group) { 8511 return apply(iteratee, undefined, group); 8512 }); 8513 } 8514 8515 /** 8516 * Creates an array excluding all given values using 8517 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) 8518 * for equality comparisons. 8519 * 8520 * **Note:** Unlike `_.pull`, this method returns a new array. 8521 * 8522 * @static 8523 * @memberOf _ 8524 * @since 0.1.0 8525 * @category Array 8526 * @param {Array} array The array to inspect. 8527 * @param {...*} [values] The values to exclude. 8528 * @returns {Array} Returns the new array of filtered values. 8529 * @see _.difference, _.xor 8530 * @example 8531 * 8532 * _.without([2, 1, 2, 3], 1, 2); 8533 * // => [3] 8534 */ 8535 var without = baseRest(function(array, values) { 8536 return isArrayLikeObject(array) 8537 ? baseDifference(array, values) 8538 : []; 8539 }); 8540 8541 /** 8542 * Creates an array of unique values that is the 8543 * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) 8544 * of the given arrays. The order of result values is determined by the order 8545 * they occur in the arrays. 8546 * 8547 * @static 8548 * @memberOf _ 8549 * @since 2.4.0 8550 * @category Array 8551 * @param {...Array} [arrays] The arrays to inspect. 8552 * @returns {Array} Returns the new array of filtered values. 8553 * @see _.difference, _.without 8554 * @example 8555 * 8556 * _.xor([2, 1], [2, 3]); 8557 * // => [1, 3] 8558 */ 8559 var xor = baseRest(function(arrays) { 8560 return baseXor(arrayFilter(arrays, isArrayLikeObject)); 8561 }); 8562 8563 /** 8564 * This method is like `_.xor` except that it accepts `iteratee` which is 8565 * invoked for each element of each `arrays` to generate the criterion by 8566 * which by which they're compared. The order of result values is determined 8567 * by the order they occur in the arrays. The iteratee is invoked with one 8568 * argument: (value). 8569 * 8570 * @static 8571 * @memberOf _ 8572 * @since 4.0.0 8573 * @category Array 8574 * @param {...Array} [arrays] The arrays to inspect. 8575 * @param {Function} [iteratee=_.identity] The iteratee invoked per element. 8576 * @returns {Array} Returns the new array of filtered values. 8577 * @example 8578 * 8579 * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); 8580 * // => [1.2, 3.4] 8581 * 8582 * // The `_.property` iteratee shorthand. 8583 * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); 8584 * // => [{ 'x': 2 }] 8585 */ 8586 var xorBy = baseRest(function(arrays) { 8587 var iteratee = last(arrays); 8588 if (isArrayLikeObject(iteratee)) { 8589 iteratee = undefined; 8590 } 8591 return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2)); 8592 }); 8593 8594 /** 8595 * This method is like `_.xor` except that it accepts `comparator` which is 8596 * invoked to compare elements of `arrays`. The order of result values is 8597 * determined by the order they occur in the arrays. The comparator is invoked 8598 * with two arguments: (arrVal, othVal). 8599 * 8600 * @static 8601 * @memberOf _ 8602 * @since 4.0.0 8603 * @category Array 8604 * @param {...Array} [arrays] The arrays to inspect. 8605 * @param {Function} [comparator] The comparator invoked per element. 8606 * @returns {Array} Returns the new array of filtered values. 8607 * @example 8608 * 8609 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; 8610 * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; 8611 * 8612 * _.xorWith(objects, others, _.isEqual); 8613 * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] 8614 */ 8615 var xorWith = baseRest(function(arrays) { 8616 var comparator = last(arrays); 8617 comparator = typeof comparator == 'function' ? comparator : undefined; 8618 return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator); 8619 }); 8620 8621 /** 8622 * Creates an array of grouped elements, the first of which contains the 8623 * first elements of the given arrays, the second of which contains the 8624 * second elements of the given arrays, and so on. 8625 * 8626 * @static 8627 * @memberOf _ 8628 * @since 0.1.0 8629 * @category Array 8630 * @param {...Array} [arrays] The arrays to process. 8631 * @returns {Array} Returns the new array of grouped elements. 8632 * @example 8633 * 8634 * _.zip(['a', 'b'], [1, 2], [true, false]); 8635 * // => [['a', 1, true], ['b', 2, false]] 8636 */ 8637 var zip = baseRest(unzip); 8638 8639 /** 8640 * This method is like `_.fromPairs` except that it accepts two arrays, 8641 * one of property identifiers and one of corresponding values. 8642 * 8643 * @static 8644 * @memberOf _ 8645 * @since 0.4.0 8646 * @category Array 8647 * @param {Array} [props=[]] The property identifiers. 8648 * @param {Array} [values=[]] The property values. 8649 * @returns {Object} Returns the new object. 8650 * @example 8651 * 8652 * _.zipObject(['a', 'b'], [1, 2]); 8653 * // => { 'a': 1, 'b': 2 } 8654 */ 8655 function zipObject(props, values) { 8656 return