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.21';
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 INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';
24
25 /** Used to stand-in for `undefined` hash values. */
26 var HASH_UNDEFINED = '__lodash_hash_undefined__';
27
28 /** Used as the maximum memoize cache size. */
29 var MAX_MEMOIZE_SIZE = 500;
30
31 /** Used as the internal argument placeholder. */
32 var PLACEHOLDER = '__lodash_placeholder__';
33
34 /** Used to compose bitmasks for cloning. */
35 var CLONE_DEEP_FLAG = 1,
36 CLONE_FLAT_FLAG = 2,
37 CLONE_SYMBOLS_FLAG = 4;
38
39 /** Used to compose bitmasks for value comparisons. */
40 var COMPARE_PARTIAL_FLAG = 1,
41 COMPARE_UNORDERED_FLAG = 2;
42
43 /** Used to compose bitmasks for function metadata. */
44 var WRAP_BIND_FLAG = 1,
45 WRAP_BIND_KEY_FLAG = 2,
46 WRAP_CURRY_BOUND_FLAG = 4,
47 WRAP_CURRY_FLAG = 8,
48 WRAP_CURRY_RIGHT_FLAG = 16,
49 WRAP_PARTIAL_FLAG = 32,
50 WRAP_PARTIAL_RIGHT_FLAG = 64,
51 WRAP_ARY_FLAG = 128,
52 WRAP_REARG_FLAG = 256,
53 WRAP_FLIP_FLAG = 512;
54
55 /** Used as default options for `_.truncate`. */
56 var DEFAULT_TRUNC_LENGTH = 30,
57 DEFAULT_TRUNC_OMISSION = '...';
58
59 /** Used to detect hot functions by number of calls within a span of milliseconds. */
60 var HOT_COUNT = 800,
61 HOT_SPAN = 16;
62
63 /** Used to indicate the type of lazy iteratees. */
64 var LAZY_FILTER_FLAG = 1,
65 LAZY_MAP_FLAG = 2,
66 LAZY_WHILE_FLAG = 3;
67
68 /** Used as references for various `Number` constants. */
69 var INFINITY = 1 / 0,
70 MAX_SAFE_INTEGER = 9007199254740991,
71 MAX_INTEGER = 1.7976931348623157e+308,
72 NAN = 0 / 0;
73
74 /** Used as references for the maximum length and index of an array. */
75 var MAX_ARRAY_LENGTH = 4294967295,
76 MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
77 HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
78
79 /** Used to associate wrap methods with their bit flags. */
80 var wrapFlags = [
81 ['ary', WRAP_ARY_FLAG],
82 ['bind', WRAP_BIND_FLAG],
83 ['bindKey', WRAP_BIND_KEY_FLAG],
84 ['curry', WRAP_CURRY_FLAG],
85 ['curryRight', WRAP_CURRY_RIGHT_FLAG],
86 ['flip', WRAP_FLIP_FLAG],
87 ['partial', WRAP_PARTIAL_FLAG],
88 ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
89 ['rearg', WRAP_REARG_FLAG]
90 ];
91
92 /** `Object#toString` result references. */
93 var argsTag = '[object Arguments]',
94 arrayTag = '[object Array]',
95 asyncTag = '[object AsyncFunction]',
96 boolTag = '[object Boolean]',
97 dateTag = '[object Date]',
98 domExcTag = '[object DOMException]',
99 errorTag = '[object Error]',
100 funcTag = '[object Function]',
101 genTag = '[object GeneratorFunction]',
102 mapTag = '[object Map]',
103 numberTag = '[object Number]',
104 nullTag = '[object Null]',
105 objectTag = '[object Object]',
106 promiseTag = '[object Promise]',
107 proxyTag = '[object Proxy]',
108 regexpTag = '[object RegExp]',
109 setTag = '[object Set]',
110 stringTag = '[object String]',
111 symbolTag = '[object Symbol]',
112 undefinedTag = '[object Undefined]',
113 weakMapTag = '[object WeakMap]',
114 weakSetTag = '[object WeakSet]';
115
116 var arrayBufferTag = '[object ArrayBuffer]',
117 dataViewTag = '[object DataView]',
118 float32Tag = '[object Float32Array]',
119 float64Tag = '[object Float64Array]',
120 int8Tag = '[object Int8Array]',
121 int16Tag = '[object Int16Array]',
122 int32Tag = '[object Int32Array]',
123 uint8Tag = '[object Uint8Array]',
124 uint8ClampedTag = '[object Uint8ClampedArray]',
125 uint16Tag = '[object Uint16Array]',
126 uint32Tag = '[object Uint32Array]';
127
128 /** Used to match empty string literals in compiled template source. */
129 var reEmptyStringLeading = /\b__p \+= '';/g,
130 reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
131 reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
132
133 /** Used to match HTML entities and HTML characters. */
134 var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
135 reUnescapedHtml = /[&<>"']/g,
136 reHasEscapedHtml = RegExp(reEscapedHtml.source),
137 reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
138
139 /** Used to match template delimiters. */
140 var reEscape = /<%-([\s\S]+?)%>/g,
141 reEvaluate = /<%([\s\S]+?)%>/g,
142 reInterpolate = /<%=([\s\S]+?)%>/g;
143
144 /** Used to match property names within property paths. */
145 var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
146 reIsPlainProp = /^\w*$/,
147 rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
148
149 /**
150 * Used to match `RegExp`
151 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
152 */
153 var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
154 reHasRegExpChar = RegExp(reRegExpChar.source);
155
156 /** Used to match leading whitespace. */
157 var reTrimStart = /^\s+/;
158
159 /** Used to match a single whitespace character. */
160 var reWhitespace = /\s/;
161
162 /** Used to match wrap detail comments. */
163 var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
164 reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
165 reSplitDetails = /,? & /;
166
167 /** Used to match words composed of alphanumeric characters. */
168 var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
169
170 /**
171 * Used to validate the `validate` option in `_.template` variable.
172 *
173 * Forbids characters which could potentially change the meaning of the function argument definition:
174 * - "()," (modification of function parameters)
175 * - "=" (default value)
176 * - "[]{}" (destructuring of function parameters)
177 * - "/" (beginning of a comment)
178 * - whitespace
179 */
180 var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
181
182 /** Used to match backslashes in property paths. */
183 var reEscapeChar = /\\(\\)?/g;
184
185 /**
186 * Used to match
187 * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
188 */
189 var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
190
191 /** Used to match `RegExp` flags from their coerced string values. */
192 var reFlags = /\w*$/;
193
194 /** Used to detect bad signed hexadecimal string values. */
195 var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
196
197 /** Used to detect binary string values. */
198 var reIsBinary = /^0b[01]+$/i;
199
200 /** Used to detect host constructors (Safari). */
201 var reIsHostCtor = /^\[object .+?Constructor\]$/;
202
203 /** Used to detect octal string values. */
204 var reIsOctal = /^0o[0-7]+$/i;
205
206 /** Used to detect unsigned integer values. */
207 var reIsUint = /^(?:0|[1-9]\d*)$/;
208
209 /** Used to match Latin Unicode letters (excluding mathematical operators). */
210 var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
211
212 /** Used to ensure capturing order of template delimiters. */
213 var reNoMatch = /($^)/;
214
215 /** Used to match unescaped characters in compiled string literals. */
216 var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
217
218 /** Used to compose unicode character classes. */
219 var rsAstralRange = '\\ud800-\\udfff',
220 rsComboMarksRange = '\\u0300-\\u036f',
221 reComboHalfMarksRange = '\\ufe20-\\ufe2f',
222 rsComboSymbolsRange = '\\u20d0-\\u20ff',
223 rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
224 rsDingbatRange = '\\u2700-\\u27bf',
225 rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
226 rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
227 rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
228 rsPunctuationRange = '\\u2000-\\u206f',
229 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',
230 rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
231 rsVarRange = '\\ufe0e\\ufe0f',
232 rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
233
234 /** Used to compose unicode capture groups. */
235 var rsApos = "['\u2019]",
236 rsAstral = '[' + rsAstralRange + ']',
237 rsBreak = '[' + rsBreakRange + ']',
238 rsCombo = '[' + rsComboRange + ']',
239 rsDigits = '\\d+',
240 rsDingbat = '[' + rsDingbatRange + ']',
241 rsLower = '[' + rsLowerRange + ']',
242 rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
243 rsFitz = '\\ud83c[\\udffb-\\udfff]',
244 rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
245 rsNonAstral = '[^' + rsAstralRange + ']',
246 rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
247 rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
248 rsUpper = '[' + rsUpperRange + ']',
249 rsZWJ = '\\u200d';
250
251 /** Used to compose unicode regexes. */
252 var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
253 rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
254 rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
255 rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
256 reOptMod = rsModifier + '?',
257 rsOptVar = '[' + rsVarRange + ']?',
258 rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
259 rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
260 rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
261 rsSeq = rsOptVar + reOptMod + rsOptJoin,
262 rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
263 rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
264
265 /** Used to match apostrophes. */
266 var reApos = RegExp(rsApos, 'g');
267
268 /**
269 * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
270 * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
271 */
272 var reComboMark = RegExp(rsCombo, 'g');
273
274 /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
275 var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
276
277 /** Used to match complex or compound words. */
278 var reUnicodeWord = RegExp([
279 rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
280 rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
281 rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
282 rsUpper + '+' + rsOptContrUpper,
283 rsOrdUpper,
284 rsOrdLower,
285 rsDigits,
286 rsEmoji
287 ].join('|'), 'g');
288
289 /** 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/). */
290 var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');
291
292 /** Used to detect strings that need a more robust regexp to match words. */
293 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 ]/;
294
295 /** Used to assign default `context` object properties. */
296 var contextProps = [
297 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
298 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
299 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
300 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
301 '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
302 ];
303
304 /** Used to make template sourceURLs easier to identify. */
305 var templateCounter = -1;
306
307 /** Used to identify `toStringTag` values of typed arrays. */
308 var typedArrayTags = {};
309 typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
310 typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
311 typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
312 typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
313 typedArrayTags[uint32Tag] = true;
314 typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
315 typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
316 typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
317 typedArrayTags[errorTag] = typedArrayTags[funcTag] =
318 typedArrayTags[mapTag] = typedArrayTags[numberTag] =
319 typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
320 typedArrayTags[setTag] = typedArrayTags[stringTag] =
321 typedArrayTags[weakMapTag] = false;
322
323 /** Used to identify `toStringTag` values supported by `_.clone`. */
324 var cloneableTags = {};
325 cloneableTags[argsTag] = cloneableTags[arrayTag] =
326 cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
327 cloneableTags[boolTag] = cloneableTags[dateTag] =
328 cloneableTags[float32Tag] = cloneableTags[float64Tag] =
329 cloneableTags[int8Tag] = cloneableTags[int16Tag] =
330 cloneableTags[int32Tag] = cloneableTags[mapTag] =
331 cloneableTags[numberTag] = cloneableTags[objectTag] =
332 cloneableTags[regexpTag] = cloneableTags[setTag] =
333 cloneableTags[stringTag] = cloneableTags[symbolTag] =
334 cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
335 cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
336 cloneableTags[errorTag] = cloneableTags[funcTag] =
337 cloneableTags[weakMapTag] = false;
338
339 /** Used to map Latin Unicode letters to basic Latin letters. */
340 var deburredLetters = {
341 // Latin-1 Supplement block.
342 '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
343 '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
344 '\xc7': 'C', '\xe7': 'c',
345 '\xd0': 'D', '\xf0': 'd',
346 '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
347 '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
348 '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
349 '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i',
350 '\xd1': 'N', '\xf1': 'n',
351 '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
352 '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
353 '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
354 '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
355 '\xdd': 'Y', '\xfd': 'y', '\xff': 'y',
356 '\xc6': 'Ae', '\xe6': 'ae',
357 '\xde': 'Th', '\xfe': 'th',
358 '\xdf': 'ss',
359 // Latin Extended-A block.
360 '\u0100': 'A', '\u0102': 'A', '\u0104': 'A',
361 '\u0101': 'a', '\u0103': 'a', '\u0105': 'a',
362 '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
363 '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
364 '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
365 '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
366 '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
367 '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
368 '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
369 '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
370 '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
371 '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
372 '\u0134': 'J', '\u0135': 'j',
373 '\u0136': 'K', '\u0137': 'k', '\u0138': 'k',
374 '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
375 '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
376 '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
377 '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
378 '\u014c': 'O', '\u014e': 'O', '\u0150': 'O',
379 '\u014d': 'o', '\u014f': 'o', '\u0151': 'o',
380 '\u0154': 'R', '\u0156': 'R', '\u0158': 'R',
381 '\u0155': 'r', '\u0157': 'r', '\u0159': 'r',
382 '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
383 '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',
384 '\u0162': 'T', '\u0164': 'T', '\u0166': 'T',
385 '\u0163': 't', '\u0165': 't', '\u0167': 't',
386 '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
387 '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
388 '\u0174': 'W', '\u0175': 'w',
389 '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',
390 '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',
391 '\u017a': 'z', '\u017c': 'z', '\u017e': 'z',
392 '\u0132': 'IJ', '\u0133': 'ij',
393 '\u0152': 'Oe', '\u0153': 'oe',
394 '\u0149': "'n", '\u017f': 's'
395 };
396
397 /** Used to map characters to HTML entities. */
398 var htmlEscapes = {
399 '&': '&',
400 '<': '<',
401 '>': '>',
402 '"': '"',
403 "'": '''
404 };
405
406 /** Used to map HTML entities to characters. */
407 var htmlUnescapes = {
408 '&': '&',
409 '<': '<',
410 '>': '>',
411 '"': '"',
412 ''': "'"
413 };
414
415 /** Used to escape characters for inclusion in compiled string literals. */
416 var stringEscapes = {
417 '\\': '\\',
418 "'": "'",
419 '\n': 'n',
420 '\r': 'r',
421 '\u2028': 'u2028',
422 '\u2029': 'u2029'
423 };
424
425 /** Built-in method references without a dependency on `root`. */
426 var freeParseFloat = parseFloat,
427 freeParseInt = parseInt;
428
429 /** Detect free variable `global` from Node.js. */
430 var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
431
432 /** Detect free variable `self`. */
433 var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
434
435 /** Used as a reference to the global object. */
436 var root = freeGlobal || freeSelf || Function('return this')();
437
438 /** Detect free variable `exports`. */
439 var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
440
441 /** Detect free variable `module`. */
442 var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
443
444 /** Detect the popular CommonJS extension `module.exports`. */
445 var moduleExports = freeModule && freeModule.exports === freeExports;
446
447 /** Detect free variable `process` from Node.js. */
448 var freeProcess = moduleExports && freeGlobal.process;
449
450 /** Used to access faster Node.js helpers. */
451 var nodeUtil = (function() {
452 try {
453 // Use `util.types` for Node.js 10+.
454 var types = freeModule && freeModule.require && freeModule.require('util').types;
455
456 if (types) {
457 return types;
458 }
459
460 // Legacy `process.binding('util')` for Node.js < 10.
461 return freeProcess && freeProcess.binding && freeProcess.binding('util');
462 } catch (e) {}
463 }());
464
465 /* Node.js helper references. */
466 var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
467 nodeIsDate = nodeUtil && nodeUtil.isDate,
468 nodeIsMap = nodeUtil && nodeUtil.isMap,
469 nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
470 nodeIsSet = nodeUtil && nodeUtil.isSet,
471 nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
472
473 /*--------------------------------------------------------------------------*/
474
475 /**
476 * A faster alternative to `Function#apply`, this function invokes `func`
477 * with the `this` binding of `thisArg` and the arguments of `args`.
478 *
479 * @private
480 * @param {Function} func The function to invoke.
481 * @param {*} thisArg The `this` binding of `func`.
482 * @param {Array} args The arguments to invoke `func` with.
483 * @returns {*} Returns the result of `func`.
484 */
485 function apply(func, thisArg, args) {
486 switch (args.length) {
487 case 0: return func.call(thisArg);
488 case 1: return func.call(thisArg, args[0]);
489 case 2: return func.call(thisArg, args[0], args[1]);
490 case 3: return func.call(thisArg, args[0], args[1], args[2]);
491 }
492 return func.apply(thisArg, args);
493 }
494
495 /**
496 * A specialized version of `baseAggregator` for arrays.
497 *
498 * @private
499 * @param {Array} [array] The array to iterate over.
500 * @param {Function} setter The function to set `accumulator` values.
501 * @param {Function} iteratee The iteratee to transform keys.
502 * @param {Object} accumulator The initial aggregated object.
503 * @returns {Function} Returns `accumulator`.
504 */
505 function arrayAggregator(array, setter, iteratee, accumulator) {
506 var index = -1,
507 length = array == null ? 0 : array.length;
508
509 while (++index < length) {
510 var value = array[index];
511 setter(accumulator, value, iteratee(value), array);
512 }
513 return accumulator;
514 }
515
516 /**
517 * A specialized version of `_.forEach` for arrays without support for
518 * iteratee shorthands.
519 *
520 * @private
521 * @param {Array} [array] The array to iterate over.
522 * @param {Function} iteratee The function invoked per iteration.
523 * @returns {Array} Returns `array`.
524 */
525 function arrayEach(array, iteratee) {
526 var index = -1,
527 length = array == null ? 0 : array.length;
528
529 while (++index < length) {
530 if (iteratee(array[index], index, array) === false) {
531 break;
532 }
533 }
534 return array;
535 }
536
537 /**
538 * A specialized version of `_.forEachRight` for arrays without support for
539 * iteratee shorthands.
540 *
541 * @private
542 * @param {Array} [array] The array to iterate over.
543 * @param {Function} iteratee The function invoked per iteration.
544 * @returns {Array} Returns `array`.
545 */
546 function arrayEachRight(array, iteratee) {
547 var length = array == null ? 0 : array.length;
548
549 while (length--) {
550 if (iteratee(array[length], length, array) === false) {
551 break;
552 }
553 }
554 return array;
555 }
556
557 /**
558 * A specialized version of `_.every` for arrays without support for
559 * iteratee shorthands.
560 *
561 * @private
562 * @param {Array} [array] The array to iterate over.
563 * @param {Function} predicate The function invoked per iteration.
564 * @returns {boolean} Returns `true` if all elements pass the predicate check,
565 * else `false`.
566 */
567 function arrayEvery(array, predicate) {
568 var index = -1,
569 length = array == null ? 0 : array.length;
570
571 while (++index < length) {
572 if (!predicate(array[index], index, array)) {
573 return false;
574 }
575 }
576 return true;
577 }
578
579 /**
580 * A specialized version of `_.filter` for arrays without support for
581 * iteratee shorthands.
582 *
583 * @private
584 * @param {Array} [array] The array to iterate over.
585 * @param {Function} predicate The function invoked per iteration.
586 * @returns {Array} Returns the new filtered array.
587 */
588 function arrayFilter(array, predicate) {
589 var index = -1,
590 length = array == null ? 0 : array.length,
591 resIndex = 0,
592 result = [];
593
594 while (++index < length) {
595 var value = array[index];
596 if (predicate(value, index, array)) {
597 result[resIndex++] = value;
598 }
599 }
600 return result;
601 }
602
603 /**
604 * A specialized version of `_.includes` for arrays without support for
605 * specifying an index to search from.
606 *
607 * @private
608 * @param {Array} [array] The array to inspect.
609 * @param {*} target The value to search for.
610 * @returns {boolean} Returns `true` if `target` is found, else `false`.
611 */
612 function arrayIncludes(array, value) {
613 var length = array == null ? 0 : array.length;
614 return !!length && baseIndexOf(array, value, 0) > -1;
615 }
616
617 /**
618 * This function is like `arrayIncludes` except that it accepts a comparator.
619 *
620 * @private
621 * @param {Array} [array] The array to inspect.
622 * @param {*} target The value to search for.
623 * @param {Function} comparator The comparator invoked per element.
624 * @returns {boolean} Returns `true` if `target` is found, else `false`.
625 */
626 function arrayIncludesWith(array, value, comparator) {
627 var index = -1,
628 length = array == null ? 0 : array.length;
629
630 while (++index < length) {
631 if (comparator(value, array[index])) {
632 return true;
633 }
634 }
635 return false;
636 }
637
638 /**
639 * A specialized version of `_.map` for arrays without support for iteratee
640 * shorthands.
641 *
642 * @private
643 * @param {Array} [array] The array to iterate over.
644 * @param {Function} iteratee The function invoked per iteration.
645 * @returns {Array} Returns the new mapped array.
646 */
647 function arrayMap(array, iteratee) {
648 var index = -1,
649 length = array == null ? 0 : array.length,
650 result = Array(length);
651
652 while (++index < length) {
653 result[index] = iteratee(array[index], index, array);
654 }
655 return result;
656 }
657
658 /**
659 * Appends the elements of `values` to `array`.
660 *
661 * @private
662 * @param {Array} array The array to modify.
663 * @param {Array} values The values to append.
664 * @returns {Array} Returns `array`.
665 */
666 function arrayPush(array, values) {
667 var index = -1,
668 length = values.length,
669 offset = array.length;
670
671 while (++index < length) {
672 array[offset + index] = values[index];
673 }
674 return array;
675 }
676
677 /**
678 * A specialized version of `_.reduce` for arrays without support for
679 * iteratee shorthands.
680 *
681 * @private
682 * @param {Array} [array] The array to iterate over.
683 * @param {Function} iteratee The function invoked per iteration.
684 * @param {*} [accumulator] The initial value.
685 * @param {boolean} [initAccum] Specify using the first element of `array` as
686 * the initial value.
687 * @returns {*} Returns the accumulated value.
688 */
689 function arrayReduce(array, iteratee, accumulator, initAccum) {
690 var index = -1,
691 length = array == null ? 0 : array.length;
692
693 if (initAccum && length) {
694 accumulator = array[++index];
695 }
696 while (++index < length) {
697 accumulator = iteratee(accumulator, array[index], index, array);
698 }
699 return accumulator;
700 }
701
702 /**
703 * A specialized version of `_.reduceRight` for arrays without support for
704 * iteratee shorthands.
705 *
706 * @private
707 * @param {Array} [array] The array to iterate over.
708 * @param {Function} iteratee The function invoked per iteration.
709 * @param {*} [accumulator] The initial value.
710 * @param {boolean} [initAccum] Specify using the last element of `array` as
711 * the initial value.
712 * @returns {*} Returns the accumulated value.
713 */
714 function arrayReduceRight(array, iteratee, accumulator, initAccum) {
715 var length = array == null ? 0 : array.length;
716 if (initAccum && length) {
717 accumulator = array[--length];
718 }
719 while (length--) {
720 accumulator = iteratee(accumulator, array[length], length, array);
721 }
722 return accumulator;
723 }
724
725 /**
726 * A specialized version of `_.some` for arrays without support for iteratee
727 * shorthands.
728 *
729 * @private
730 * @param {Array} [array] The array to iterate over.
731 * @param {Function} predicate The function invoked per iteration.
732 * @returns {boolean} Returns `true` if any element passes the predicate check,
733 * else `false`.
734 */
735 function arraySome(array, predicate) {
736 var index = -1,
737 length = array == null ? 0 : array.length;
738
739 while (++index < length) {
740 if (predicate(array[index], index, array)) {
741 return true;
742 }
743 }
744 return false;
745 }
746
747 /**
748 * Gets the size of an ASCII `string`.
749 *
750 * @private
751 * @param {string} string The string inspect.
752 * @returns {number} Returns the string size.
753 */
754 var asciiSize = baseProperty('length');
755
756 /**
757 * Converts an ASCII `string` to an array.
758 *
759 * @private
760 * @param {string} string The string to convert.
761 * @returns {Array} Returns the converted array.
762 */
763 function asciiToArray(string) {
764 return string.split('');
765 }
766
767 /**
768 * Splits an ASCII `string` into an array of its words.
769 *
770 * @private
771 * @param {string} The string to inspect.
772 * @returns {Array} Returns the words of `string`.
773 */
774 function asciiWords(string) {
775 return string.match(reAsciiWord) || [];
776 }
777
778 /**
779 * The base implementation of methods like `_.findKey` and `_.findLastKey`,
780 * without support for iteratee shorthands, which iterates over `collection`
781 * using `eachFunc`.
782 *
783 * @private
784 * @param {Array|Object} collection The collection to inspect.
785 * @param {Function} predicate The function invoked per iteration.
786 * @param {Function} eachFunc The function to iterate over `collection`.
787 * @returns {*} Returns the found element or its key, else `undefined`.
788 */
789 function baseFindKey(collection, predicate, eachFunc) {
790 var result;
791 eachFunc(collection, function(value, key, collection) {
792 if (predicate(value, key, collection)) {
793 result = key;
794 return false;
795 }
796 });
797 return result;
798 }
799
800 /**
801 * The base implementation of `_.findIndex` and `_.findLastIndex` without
802 * support for iteratee shorthands.
803 *
804 * @private
805 * @param {Array} array The array to inspect.
806 * @param {Function} predicate The function invoked per iteration.
807 * @param {number} fromIndex The index to search from.
808 * @param {boolean} [fromRight] Specify iterating from right to left.
809 * @returns {number} Returns the index of the matched value, else `-1`.
810 */
811 function baseFindIndex(array, predicate, fromIndex, fromRight) {
812 var length = array.length,
813 index = fromIndex + (fromRight ? 1 : -1);
814
815 while ((fromRight ? index-- : ++index < length)) {
816 if (predicate(array[index], index, array)) {
817 return index;
818 }
819 }
820 return -1;
821 }
822
823 /**
824 * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
825 *
826 * @private
827 * @param {Array} array The array to inspect.
828 * @param {*} value The value to search for.
829 * @param {number} fromIndex The index to search from.
830 * @returns {number} Returns the index of the matched value, else `-1`.
831 */
832 function baseIndexOf(array, value, fromIndex) {
833 return value === value
834 ? strictIndexOf(array, value, fromIndex)
835 : baseFindIndex(array, baseIsNaN, fromIndex);
836 }
837
838 /**
839 * This function is like `baseIndexOf` except that it accepts a comparator.
840 *
841 * @private
842 * @param {Array} array The array to inspect.
843 * @param {*} value The value to search for.
844 * @param {number} fromIndex The index to search from.
845 * @param {Function} comparator The comparator invoked per element.
846 * @returns {number} Returns the index of the matched value, else `-1`.
847 */
848 function baseIndexOfWith(array, value, fromIndex, comparator) {
849 var index = fromIndex - 1,
850 length = array.length;
851
852 while (++index < length) {
853 if (comparator(array[index], value)) {
854 return index;
855 }
856 }
857 return -1;
858 }
859
860 /**
861 * The base implementation of `_.isNaN` without support for number objects.
862 *
863 * @private
864 * @param {*} value The value to check.
865 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
866 */
867 function baseIsNaN(value) {
868 return value !== value;
869 }
870
871 /**
872 * The base implementation of `_.mean` and `_.meanBy` without support for
873 * iteratee shorthands.
874 *
875 * @private
876 * @param {Array} array The array to iterate over.
877 * @param {Function} iteratee The function invoked per iteration.
878 * @returns {number} Returns the mean.
879 */
880 function baseMean(array, iteratee) {
881 var length = array == null ? 0 : array.length;
882 return length ? (baseSum(array, iteratee) / length) : NAN;
883 }
884
885 /**
886 * The base implementation of `_.property` without support for deep paths.
887 *
888 * @private
889 * @param {string} key The key of the property to get.
890 * @returns {Function} Returns the new accessor function.
891 */
892 function baseProperty(key) {
893 return function(object) {
894 return object == null ? undefined : object[key];
895 };
896 }
897
898 /**
899 * The base implementation of `_.propertyOf` without support for deep paths.
900 *
901 * @private
902 * @param {Object} object The object to query.
903 * @returns {Function} Returns the new accessor function.
904 */
905 function basePropertyOf(object) {
906 return function(key) {
907 return object == null ? undefined : object[key];
908 };
909 }
910
911 /**
912 * The base implementation of `_.reduce` and `_.reduceRight`, without support
913 * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
914 *
915 * @private
916 * @param {Array|Object} collection The collection to iterate over.
917 * @param {Function} iteratee The function invoked per iteration.
918 * @param {*} accumulator The initial value.
919 * @param {boolean} initAccum Specify using the first or last element of
920 * `collection` as the initial value.
921 * @param {Function} eachFunc The function to iterate over `collection`.
922 * @returns {*} Returns the accumulated value.
923 */
924 function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
925 eachFunc(collection, function(value, index, collection) {
926 accumulator = initAccum
927 ? (initAccum = false, value)
928 : iteratee(accumulator, value, index, collection);
929 });
930 return accumulator;
931 }
932
933 /**
934 * The base implementation of `_.sortBy` which uses `comparer` to define the
935 * sort order of `array` and replaces criteria objects with their corresponding
936 * values.
937 *
938 * @private
939 * @param {Array} array The array to sort.
940 * @param {Function} comparer The function to define sort order.
941 * @returns {Array} Returns `array`.
942 */
943 function baseSortBy(array, comparer) {
944 var length = array.length;
945
946 array.sort(comparer);
947 while (length--) {
948 array[length] = array[length].value;
949 }
950 return array;
951 }
952
953 /**
954 * The base implementation of `_.sum` and `_.sumBy` without support for
955 * iteratee shorthands.
956 *
957 * @private
958 * @param {Array} array The array to iterate over.
959 * @param {Function} iteratee The function invoked per iteration.
960 * @returns {number} Returns the sum.
961 */
962 function baseSum(array, iteratee) {
963 var result,
964 index = -1,
965 length = array.length;
966
967 while (++index < length) {
968 var current = iteratee(array[index]);
969 if (current !== undefined) {
970 result = result === undefined ? current : (result + current);
971 }
972 }
973 return result;
974 }
975
976 /**
977 * The base implementation of `_.times` without support for iteratee shorthands
978 * or max array length checks.
979 *
980 * @private
981 * @param {number} n The number of times to invoke `iteratee`.
982 * @param {Function} iteratee The function invoked per iteration.
983 * @returns {Array} Returns the array of results.
984 */
985 function baseTimes(n, iteratee) {
986 var index = -1,
987 result = Array(n);
988
989 while (++index < n) {
990 result[index] = iteratee(index);
991 }
992 return result;
993 }
994
995 /**
996 * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
997 * of key-value pairs for `object` corresponding to the property names of `props`.
998 *
999 * @private
1000 * @param {Object} object The object to query.
1001 * @param {Array} props The property names to get values for.
1002 * @returns {Object} Returns the key-value pairs.
1003 */
1004 function baseToPairs(object, props) {
1005 return arrayMap(props, function(key) {
1006 return [key, object[key]];
1007 });
1008 }
1009
1010 /**
1011 * The base implementation of `_.trim`.
1012 *
1013 * @private
1014 * @param {string} string The string to trim.
1015 * @returns {string} Returns the trimmed string.
1016 */
1017 function baseTrim(string) {
1018 return string
1019 ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
1020 : string;
1021 }
1022
1023 /**
1024 * The base implementation of `_.unary` without support for storing metadata.
1025 *
1026 * @private
1027 * @param {Function} func The function to cap arguments for.
1028 * @returns {Function} Returns the new capped function.
1029 */
1030 function baseUnary(func) {
1031 return function(value) {
1032 return func(value);
1033 };
1034 }
1035
1036 /**
1037 * The base implementation of `_.values` and `_.valuesIn` which creates an
1038 * array of `object` property values corresponding to the property names
1039 * of `props`.
1040 *
1041 * @private
1042 * @param {Object} object The object to query.
1043 * @param {Array} props The property names to get values for.
1044 * @returns {Object} Returns the array of property values.
1045 */
1046 function baseValues(object, props) {
1047 return arrayMap(props, function(key) {
1048 return object[key];
1049 });
1050 }
1051
1052 /**
1053 * Checks if a `cache` value for `key` exists.
1054 *
1055 * @private
1056 * @param {Object} cache The cache to query.
1057 * @param {string} key The key of the entry to check.
1058 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
1059 */
1060 function cacheHas(cache, key) {
1061 return cache.has(key);
1062 }
1063
1064 /**
1065 * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
1066 * that is not found in the character symbols.
1067 *
1068 * @private
1069 * @param {Array} strSymbols The string symbols to inspect.
1070 * @param {Array} chrSymbols The character symbols to find.
1071 * @returns {number} Returns the index of the first unmatched string symbol.
1072 */
1073 function charsStartIndex(strSymbols, chrSymbols) {
1074 var index = -1,
1075 length = strSymbols.length;
1076
1077 while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1078 return index;
1079 }
1080
1081 /**
1082 * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
1083 * that is not found in the character symbols.
1084 *
1085 * @private
1086 * @param {Array} strSymbols The string symbols to inspect.
1087 * @param {Array} chrSymbols The character symbols to find.
1088 * @returns {number} Returns the index of the last unmatched string symbol.
1089 */
1090 function charsEndIndex(strSymbols, chrSymbols) {
1091 var index = strSymbols.length;
1092
1093 while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1094 return index;
1095 }
1096
1097 /**
1098 * Gets the number of `placeholder` occurrences in `array`.
1099 *
1100 * @private
1101 * @param {Array} array The array to inspect.
1102 * @param {*} placeholder The placeholder to search for.
1103 * @returns {number} Returns the placeholder count.
1104 */
1105 function countHolders(array, placeholder) {
1106 var length = array.length,
1107 result = 0;
1108
1109 while (length--) {
1110 if (array[length] === placeholder) {
1111 ++result;
1112 }
1113 }
1114 return result;
1115 }
1116
1117 /**
1118 * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
1119 * letters to basic Latin letters.
1120 *
1121 * @private
1122 * @param {string} letter The matched letter to deburr.
1123 * @returns {string} Returns the deburred letter.
1124 */
1125 var deburrLetter = basePropertyOf(deburredLetters);
1126
1127 /**
1128 * Used by `_.escape` to convert characters to HTML entities.
1129 *
1130 * @private
1131 * @param {string} chr The matched character to escape.
1132 * @returns {string} Returns the escaped character.
1133 */
1134 var escapeHtmlChar = basePropertyOf(htmlEscapes);
1135
1136 /**
1137 * Used by `_.template` to escape characters for inclusion in compiled string literals.
1138 *
1139 * @private
1140 * @param {string} chr The matched character to escape.
1141 * @returns {string} Returns the escaped character.
1142 */
1143 function escapeStringChar(chr) {
1144 return '\\' + stringEscapes[chr];
1145 }
1146
1147 /**
1148 * Gets the value at `key` of `object`.
1149 *
1150 * @private
1151 * @param {Object} [object] The object to query.
1152 * @param {string} key The key of the property to get.
1153 * @returns {*} Returns the property value.
1154 */
1155 function getValue(object, key) {
1156 return object == null ? undefined : object[key];
1157 }
1158
1159 /**
1160 * Checks if `string` contains Unicode symbols.
1161 *
1162 * @private
1163 * @param {string} string The string to inspect.
1164 * @returns {boolean} Returns `true` if a symbol is found, else `false`.
1165 */
1166 function hasUnicode(string) {
1167 return reHasUnicode.test(string);
1168 }
1169
1170 /**
1171 * Checks if `string` contains a word composed of Unicode symbols.
1172 *
1173 * @private
1174 * @param {string} string The string to inspect.
1175 * @returns {boolean} Returns `true` if a word is found, else `false`.
1176 */
1177 function hasUnicodeWord(string) {
1178 return reHasUnicodeWord.test(string);
1179 }
1180
1181 /**
1182 * Converts `iterator` to an array.
1183 *
1184 * @private
1185 * @param {Object} iterator The iterator to convert.
1186 * @returns {Array} Returns the converted array.
1187 */
1188 function iteratorToArray(iterator) {
1189 var data,
1190 result = [];
1191
1192 while (!(data = iterator.next()).done) {
1193 result.push(data.value);
1194 }
1195 return result;
1196 }
1197
1198 /**
1199 * Converts `map` to its key-value pairs.
1200 *
1201 * @private
1202 * @param {Object} map The map to convert.
1203 * @returns {Array} Returns the key-value pairs.
1204 */
1205 function mapToArray(map) {
1206 var index = -1,
1207 result = Array(map.size);
1208
1209 map.forEach(function(value, key) {
1210 result[++index] = [key, value];
1211 });
1212 return result;
1213 }
1214
1215 /**
1216 * Creates a unary function that invokes `func` with its argument transformed.
1217 *
1218 * @private
1219 * @param {Function} func The function to wrap.
1220 * @param {Function} transform The argument transform.
1221 * @returns {Function} Returns the new function.
1222 */
1223 function overArg(func, transform) {
1224 return function(arg) {
1225 return func(transform(arg));
1226 };
1227 }
1228
1229 /**
1230 * Replaces all `placeholder` elements in `array` with an internal placeholder
1231 * and returns an array of their indexes.
1232 *
1233 * @private
1234 * @param {Array} array The array to modify.
1235 * @param {*} placeholder The placeholder to replace.
1236 * @returns {Array} Returns the new array of placeholder indexes.
1237 */
1238 function replaceHolders(array, placeholder) {
1239 var index = -1,
1240 length = array.length,
1241 resIndex = 0,
1242 result = [];
1243
1244 while (++index < length) {
1245 var value = array[index];
1246 if (value === placeholder || value === PLACEHOLDER) {
1247 array[index] = PLACEHOLDER;
1248 result[resIndex++] = index;
1249 }
1250 }
1251 return result;
1252 }
1253
1254 /**
1255 * Converts `set` to an array of its values.
1256 *
1257 * @private
1258 * @param {Object} set The set to convert.
1259 * @returns {Array} Returns the values.
1260 */
1261 function setToArray(set) {
1262 var index = -1,
1263 result = Array(set.size);
1264
1265 set.forEach(function(value) {
1266 result[++index] = value;
1267 });
1268 return result;
1269 }
1270
1271 /**
1272 * Converts `set` to its value-value pairs.
1273 *
1274 * @private
1275 * @param {Object} set The set to convert.
1276 * @returns {Array} Returns the value-value pairs.
1277 */
1278 function setToPairs(set) {
1279 var index = -1,
1280 result = Array(set.size);
1281
1282 set.forEach(function(value) {
1283 result[++index] = [value, value];
1284 });
1285 return result;
1286 }
1287
1288 /**
1289 * A specialized version of `_.indexOf` which performs strict equality
1290 * comparisons of values, i.e. `===`.
1291 *
1292 * @private
1293 * @param {Array} array The array to inspect.
1294 * @param {*} value The value to search for.
1295 * @param {number} fromIndex The index to search from.
1296 * @returns {number} Returns the index of the matched value, else `-1`.
1297 */
1298 function strictIndexOf(array, value, fromIndex) {
1299 var index = fromIndex - 1,
1300 length = array.length;
1301
1302 while (++index < length) {
1303 if (array[index] === value) {
1304 return index;
1305 }
1306 }
1307 return -1;
1308 }
1309
1310 /**
1311 * A specialized version of `_.lastIndexOf` which performs strict equality
1312 * comparisons of values, i.e. `===`.
1313 *
1314 * @private
1315 * @param {Array} array The array to inspect.
1316 * @param {*} value The value to search for.
1317 * @param {number} fromIndex The index to search from.
1318 * @returns {number} Returns the index of the matched value, else `-1`.
1319 */
1320 function strictLastIndexOf(array, value, fromIndex) {
1321 var index = fromIndex + 1;
1322 while (index--) {
1323 if (array[index] === value) {
1324 return index;
1325 }
1326 }
1327 return index;
1328 }
1329
1330 /**
1331 * Gets the number of symbols in `string`.
1332 *
1333 * @private
1334 * @param {string} string The string to inspect.
1335 * @returns {number} Returns the string size.
1336 */
1337 function stringSize(string) {
1338 return hasUnicode(string)
1339 ? unicodeSize(string)
1340 : asciiSize(string);
1341 }
1342
1343 /**
1344 * Converts `string` to an array.
1345 *
1346 * @private
1347 * @param {string} string The string to convert.
1348 * @returns {Array} Returns the converted array.
1349 */
1350 function stringToArray(string) {
1351 return hasUnicode(string)
1352 ? unicodeToArray(string)
1353 : asciiToArray(string);
1354 }
1355
1356 /**
1357 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
1358 * character of `string`.
1359 *
1360 * @private
1361 * @param {string} string The string to inspect.
1362 * @returns {number} Returns the index of the last non-whitespace character.
1363 */
1364 function trimmedEndIndex(string) {
1365 var index = string.length;
1366
1367 while (index-- && reWhitespace.test(string.charAt(index))) {}
1368 return index;
1369 }
1370
1371 /**
1372 * Used by `_.unescape` to convert HTML entities to characters.
1373 *
1374 * @private
1375 * @param {string} chr The matched character to unescape.
1376 * @returns {string} Returns the unescaped character.
1377 */
1378 var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
1379
1380 /**
1381 * Gets the size of a Unicode `string`.
1382 *
1383 * @private
1384 * @param {string} string The string inspect.
1385 * @returns {number} Returns the string size.
1386 */
1387 function unicodeSize(string) {
1388 var result = reUnicode.lastIndex = 0;
1389 while (reUnicode.test(string)) {
1390 ++result;
1391 }
1392 return result;
1393 }
1394
1395 /**
1396 * Converts a Unicode `string` to an array.
1397 *
1398 * @private
1399 * @param {string} string The string to convert.
1400 * @returns {Array} Returns the converted array.
1401 */
1402 function unicodeToArray(string) {
1403 return string.match(reUnicode) || [];
1404 }
1405
1406 /**
1407 * Splits a Unicode `string` into an array of its words.
1408 *
1409 * @private
1410 * @param {string} The string to inspect.
1411 * @returns {Array} Returns the words of `string`.
1412 */
1413 function unicodeWords(string) {
1414 return string.match(reUnicodeWord) || [];
1415 }
1416
1417 /*--------------------------------------------------------------------------*/
1418
1419 /**
1420 * Create a new pristine `lodash` function using the `context` object.
1421 *
1422 * @static
1423 * @memberOf _
1424 * @since 1.1.0
1425 * @category Util
1426 * @param {Object} [context=root] The context object.
1427 * @returns {Function} Returns a new `lodash` function.
1428 * @example
1429 *
1430 * _.mixin({ 'foo': _.constant('foo') });
1431 *
1432 * var lodash = _.runInContext();
1433 * lodash.mixin({ 'bar': lodash.constant('bar') });
1434 *
1435 * _.isFunction(_.foo);
1436 * // => true
1437 * _.isFunction(_.bar);
1438 * // => false
1439 *
1440 * lodash.isFunction(lodash.foo);
1441 * // => false
1442 * lodash.isFunction(lodash.bar);
1443 * // => true
1444 *
1445 * // Create a suped-up `defer` in Node.js.
1446 * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
1447 */
1448 var runInContext = (function runInContext(context) {
1449 context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
1450
1451 /** Built-in constructor references. */
1452 var Array = context.Array,
1453 Date = context.Date,
1454 Error = context.Error,
1455 Function = context.Function,
1456 Math = context.Math,
1457 Object = context.Object,
1458 RegExp = context.RegExp,
1459 String = context.String,
1460 TypeError = context.TypeError;
1461
1462 /** Used for built-in method references. */
1463 var arrayProto = Array.prototype,
1464 funcProto = Function.prototype,
1465 objectProto = Object.prototype;
1466
1467 /** Used to detect overreaching core-js shims. */
1468 var coreJsData = context['__core-js_shared__'];
1469
1470 /** Used to resolve the decompiled source of functions. */
1471 var funcToString = funcProto.toString;
1472
1473 /** Used to check objects for own properties. */
1474 var hasOwnProperty = objectProto.hasOwnProperty;
1475
1476 /** Used to generate unique IDs. */
1477 var idCounter = 0;
1478
1479 /** Used to detect methods masquerading as native. */
1480 var maskSrcKey = (function() {
1481 var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
1482 return uid ? ('Symbol(src)_1.' + uid) : '';
1483 }());
1484
1485 /**
1486 * Used to resolve the
1487 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
1488 * of values.
1489 */
1490 var nativeObjectToString = objectProto.toString;
1491
1492 /** Used to infer the `Object` constructor. */
1493 var objectCtorString = funcToString.call(Object);
1494
1495 /** Used to restore the original `_` reference in `_.noConflict`. */
1496 var oldDash = root._;
1497
1498 /** Used to detect if a method is native. */
1499 var reIsNative = RegExp('^' +
1500 funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
1501 .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
1502 );
1503
1504 /** Built-in value references. */
1505 var Buffer = moduleExports ? context.Buffer : undefined,
1506 Symbol = context.Symbol,
1507 Uint8Array = context.Uint8Array,
1508 allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
1509 getPrototype = overArg(Object.getPrototypeOf, Object),
1510 objectCreate = Object.create,
1511 propertyIsEnumerable = objectProto.propertyIsEnumerable,
1512 splice = arrayProto.splice,
1513 spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,
1514 symIterator = Symbol ? Symbol.iterator : undefined,
1515 symToStringTag = Symbol ? Symbol.toStringTag : undefined;
1516
1517 var defineProperty = (function() {
1518 try {
1519 var func = getNative(Object, 'defineProperty');
1520 func({}, '', {});
1521 return func;
1522 } catch (e) {}
1523 }());
1524
1525 /** Mocked built-ins. */
1526 var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
1527 ctxNow = Date && Date.now !== root.Date.now && Date.now,
1528 ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
1529
1530 /* Built-in method references for those with the same name as other `lodash` methods. */
1531 var nativeCeil = Math.ceil,
1532 nativeFloor = Math.floor,
1533 nativeGetSymbols = Object.getOwnPropertySymbols,
1534 nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
1535 nativeIsFinite = context.isFinite,
1536 nativeJoin = arrayProto.join,
1537 nativeKeys = overArg(Object.keys, Object),
1538 nativeMax = Math.max,
1539 nativeMin = Math.min,
1540 nativeNow = Date.now,
1541 nativeParseInt = context.parseInt,
1542 nativeRandom = Math.random,
1543 nativeReverse = arrayProto.reverse;
1544
1545 /* Built-in method references that are verified to be native. */
1546 var DataView = getNative(context, 'DataView'),
1547 Map = getNative(context, 'Map'),
1548 Promise = getNative(context, 'Promise'),
1549 Set = getNative(context, 'Set'),
1550 WeakMap = getNative(context, 'WeakMap'),
1551 nativeCreate = getNative(Object, 'create');
1552
1553 /** Used to store function metadata. */
1554 var metaMap = WeakMap && new WeakMap;
1555
1556 /** Used to lookup unminified function names. */
1557 var realNames = {};
1558
1559 /** Used to detect maps, sets, and weakmaps. */
1560 var dataViewCtorString = toSource(DataView),
1561 mapCtorString = toSource(Map),
1562 promiseCtorString = toSource(Promise),
1563 setCtorString = toSource(Set),
1564 weakMapCtorString = toSource(WeakMap);
1565
1566 /** Used to convert symbols to primitives and strings. */
1567 var symbolProto = Symbol ? Symbol.prototype : undefined,
1568 symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
1569 symbolToString = symbolProto ? symbolProto.toString : undefined;
1570
1571 /*------------------------------------------------------------------------*/
1572
1573 /**
1574 * Creates a `lodash` object which wraps `value` to enable implicit method
1575 * chain sequences. Methods that operate on and return arrays, collections,
1576 * and functions can be chained together. Methods that retrieve a single value
1577 * or may return a primitive value will automatically end the chain sequence
1578 * and return the unwrapped value. Otherwise, the value must be unwrapped
1579 * with `_#value`.
1580 *
1581 * Explicit chain sequences, which must be unwrapped with `_#value`, may be
1582 * enabled using `_.chain`.
1583 *
1584 * The execution of chained methods is lazy, that is, it's deferred until
1585 * `_#value` is implicitly or explicitly called.
1586 *
1587 * Lazy evaluation allows several methods to support shortcut fusion.
1588 * Shortcut fusion is an optimization to merge iteratee calls; this avoids
1589 * the creation of intermediate arrays and can greatly reduce the number of
1590 * iteratee executions. Sections of a chain sequence qualify for shortcut
1591 * fusion if the section is applied to an array and iteratees accept only
1592 * one argument. The heuristic for whether a section qualifies for shortcut
1593 * fusion is subject to change.
1594 *
1595 * Chaining is supported in custom builds as long as the `_#value` method is
1596 * directly or indirectly included in the build.
1597 *
1598 * In addition to lodash methods, wrappers have `Array` and `String` methods.
1599 *
1600 * The wrapper `Array` methods are:
1601 * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
1602 *
1603 * The wrapper `String` methods are:
1604 * `replace` and `split`
1605 *
1606 * The wrapper methods that support shortcut fusion are:
1607 * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
1608 * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
1609 * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
1610 *
1611 * The chainable wrapper methods are:
1612 * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
1613 * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
1614 * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
1615 * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
1616 * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
1617 * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
1618 * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
1619 * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
1620 * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
1621 * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
1622 * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
1623 * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
1624 * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
1625 * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
1626 * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
1627 * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
1628 * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
1629 * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
1630 * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
1631 * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
1632 * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
1633 * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
1634 * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
1635 * `zipObject`, `zipObjectDeep`, and `zipWith`
1636 *
1637 * The wrapper methods that are **not** chainable by default are:
1638 * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
1639 * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
1640 * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
1641 * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
1642 * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
1643 * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
1644 * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
1645 * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
1646 * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
1647 * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
1648 * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
1649 * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
1650 * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
1651 * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
1652 * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
1653 * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
1654 * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
1655 * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
1656 * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
1657 * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
1658 * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
1659 * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
1660 * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
1661 * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
1662 * `upperFirst`, `value`, and `words`
1663 *
1664 * @name _
1665 * @constructor
1666 * @category Seq
1667 * @param {*} value The value to wrap in a `lodash` instance.
1668 * @returns {Object} Returns the new `lodash` wrapper instance.
1669 * @example
1670 *
1671 * function square(n) {
1672 * return n * n;
1673 * }
1674 *
1675 * var wrapped = _([1, 2, 3]);
1676 *
1677 * // Returns an unwrapped value.
1678 * wrapped.reduce(_.add);
1679 * // => 6
1680 *
1681 * // Returns a wrapped value.
1682 * var squares = wrapped.map(square);
1683 *
1684 * _.isArray(squares);
1685 * // => false
1686 *
1687 * _.isArray(squares.value());
1688 * // => true
1689 */
1690 function lodash(value) {
1691 if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
1692 if (value instanceof LodashWrapper) {
1693 return value;
1694 }
1695 if (hasOwnProperty.call(value, '__wrapped__')) {
1696 return wrapperClone(value);
1697 }
1698 }
1699 return new LodashWrapper(value);
1700 }
1701
1702 /**
1703 * The base implementation of `_.create` without support for assigning
1704 * properties to the created object.
1705 *
1706 * @private
1707 * @param {Object} proto The object to inherit from.
1708 * @returns {Object} Returns the new object.
1709 */
1710 var baseCreate = (function() {
1711 function object() {}
1712 return function(proto) {
1713 if (!isObject(proto)) {
1714 return {};
1715 }
1716 if (objectCreate) {
1717 return objectCreate(proto);
1718 }
1719 object.prototype = proto;
1720 var result = new object;
1721 object.prototype = undefined;
1722 return result;
1723 };
1724 }());
1725
1726 /**
1727 * The function whose prototype chain sequence wrappers inherit from.
1728 *
1729 * @private
1730 */
1731 function baseLodash() {
1732 // No operation performed.
1733 }
1734
1735 /**
1736 * The base constructor for creating `lodash` wrapper objects.
1737 *
1738 * @private
1739 * @param {*} value The value to wrap.
1740 * @param {boolean} [chainAll] Enable explicit method chain sequences.
1741 */
1742 function LodashWrapper(value, chainAll) {
1743 this.__wrapped__ = value;
1744 this.__actions__ = [];
1745 this.__chain__ = !!chainAll;
1746 this.__index__ = 0;
1747 this.__values__ = undefined;
1748 }
1749
1750 /**
1751 * By default, the template delimiters used by lodash are like those in
1752 * embedded Ruby (ERB) as well as ES2015 template strings. Change the
1753 * following template settings to use alternative delimiters.
1754 *
1755 * @static
1756 * @memberOf _
1757 * @type {Object}
1758 */
1759 lodash.templateSettings = {
1760
1761 /**
1762 * Used to detect `data` property values to be HTML-escaped.
1763 *
1764 * @memberOf _.templateSettings
1765 * @type {RegExp}
1766 */
1767 'escape': reEscape,
1768
1769 /**
1770 * Used to detect code to be evaluated.
1771 *
1772 * @memberOf _.templateSettings
1773 * @type {RegExp}
1774 */
1775 'evaluate': reEvaluate,
1776
1777 /**
1778 * Used to detect `data` property values to inject.
1779 *
1780 * @memberOf _.templateSettings
1781 * @type {RegExp}
1782 */
1783 'interpolate': reInterpolate,
1784
1785 /**
1786 * Used to reference the data object in the template text.
1787 *
1788 * @memberOf _.templateSettings
1789 * @type {string}
1790 */
1791 'variable': '',
1792
1793 /**
1794 * Used to import variables into the compiled template.
1795 *
1796 * @memberOf _.templateSettings
1797 * @type {Object}
1798 */
1799 'imports': {
1800
1801 /**
1802 * A reference to the `lodash` function.
1803 *
1804 * @memberOf _.templateSettings.imports
1805 * @type {Function}
1806 */
1807 '_': lodash
1808 }
1809 };
1810
1811 // Ensure wrappers are instances of `baseLodash`.
1812 lodash.prototype = baseLodash.prototype;
1813 lodash.prototype.constructor = lodash;
1814
1815 LodashWrapper.prototype = baseCreate(baseLodash.prototype);
1816 LodashWrapper.prototype.constructor = LodashWrapper;
1817
1818 /*------------------------------------------------------------------------*/
1819
1820 /**
1821 * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
1822 *
1823 * @private
1824 * @constructor
1825 * @param {*} value The value to wrap.
1826 */
1827 function LazyWrapper(value) {
1828 this.__wrapped__ = value;
1829 this.__actions__ = [];
1830 this.__dir__ = 1;
1831 this.__filtered__ = false;
1832 this.__iteratees__ = [];
1833 this.__takeCount__ = MAX_ARRAY_LENGTH;
1834 this.__views__ = [];
1835 }
1836
1837 /**
1838 * Creates a clone of the lazy wrapper object.
1839 *
1840 * @private
1841 * @name clone
1842 * @memberOf LazyWrapper
1843 * @returns {Object} Returns the cloned `LazyWrapper` object.
1844 */
1845 function lazyClone() {
1846 var result = new LazyWrapper(this.__wrapped__);
1847 result.__actions__ = copyArray(this.__actions__);
1848 result.__dir__ = this.__dir__;
1849 result.__filtered__ = this.__filtered__;
1850 result.__iteratees__ = copyArray(this.__iteratees__);
1851 result.__takeCount__ = this.__takeCount__;
1852 result.__views__ = copyArray(this.__views__);
1853 return result;
1854 }
1855
1856 /**
1857 * Reverses the direction of lazy iteration.
1858 *
1859 * @private
1860 * @name reverse
1861 * @memberOf LazyWrapper
1862 * @returns {Object} Returns the new reversed `LazyWrapper` object.
1863 */
1864 function lazyReverse() {
1865 if (this.__filtered__) {
1866 var result = new LazyWrapper(this);
1867 result.__dir__ = -1;
1868 result.__filtered__ = true;
1869 } else {
1870 result = this.clone();
1871 result.__dir__ *= -1;
1872 }
1873 return result;
1874 }
1875
1876 /**
1877 * Extracts the unwrapped value from its lazy wrapper.
1878 *
1879 * @private
1880 * @name value
1881 * @memberOf LazyWrapper
1882 * @returns {*} Returns the unwrapped value.
1883 */
1884 function lazyValue() {
1885 var array = this.__wrapped__.value(),
1886 dir = this.__dir__,
1887 isArr = isArray(array),
1888 isRight = dir < 0,
1889 arrLength = isArr ? array.length : 0,
1890 view = getView(0, arrLength, this.__views__),
1891 start = view.start,
1892 end = view.end,
1893 length = end - start,
1894 index = isRight ? end : (start - 1),
1895 iteratees = this.__iteratees__,
1896 iterLength = iteratees.length,
1897 resIndex = 0,
1898 takeCount = nativeMin(length, this.__takeCount__);
1899
1900 if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
1901 return baseWrapperValue(array, this.__actions__);
1902 }
1903 var result = [];
1904
1905 outer:
1906 while (length-- && resIndex < takeCount) {
1907 index += dir;
1908
1909 var iterIndex = -1,
1910 value = array[index];
1911
1912 while (++iterIndex < iterLength) {
1913 var data = iteratees[iterIndex],
1914 iteratee = data.iteratee,
1915 type = data.type,
1916 computed = iteratee(value);
1917
1918 if (type == LAZY_MAP_FLAG) {
1919 value = computed;
1920 } else if (!computed) {
1921 if (type == LAZY_FILTER_FLAG) {
1922 continue outer;
1923 } else {
1924 break outer;
1925 }
1926 }
1927 }
1928 result[resIndex++] = value;
1929 }
1930 return result;
1931 }
1932
1933 // Ensure `LazyWrapper` is an instance of `baseLodash`.
1934 LazyWrapper.prototype = baseCreate(baseLodash.prototype);
1935 LazyWrapper.prototype.constructor = LazyWrapper;
1936
1937 /*------------------------------------------------------------------------*/
1938
1939 /**
1940 * Creates a hash object.
1941 *
1942 * @private
1943 * @constructor
1944 * @param {Array} [entries] The key-value pairs to cache.
1945 */
1946 function Hash(entries) {
1947 var index = -1,
1948 length = entries == null ? 0 : entries.length;
1949
1950 this.clear();
1951 while (++index < length) {
1952 var entry = entries[index];
1953 this.set(entry[0], entry[1]);
1954 }
1955 }
1956
1957 /**
1958 * Removes all key-value entries from the hash.
1959 *
1960 * @private
1961 * @name clear
1962 * @memberOf Hash
1963 */
1964 function hashClear() {
1965 this.__data__ = nativeCreate ? nativeCreate(null) : {};
1966 this.size = 0;
1967 }
1968
1969 /**
1970 * Removes `key` and its value from the hash.
1971 *
1972 * @private
1973 * @name delete
1974 * @memberOf Hash
1975 * @param {Object} hash The hash to modify.
1976 * @param {string} key The key of the value to remove.
1977 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
1978 */
1979 function hashDelete(key) {
1980 var result = this.has(key) && delete this.__data__[key];
1981 this.size -= result ? 1 : 0;
1982 return result;
1983 }
1984
1985 /**
1986 * Gets the hash value for `key`.
1987 *
1988 * @private
1989 * @name get
1990 * @memberOf Hash
1991 * @param {string} key The key of the value to get.
1992 * @returns {*} Returns the entry value.
1993 */
1994 function hashGet(key) {
1995 var data = this.__data__;
1996 if (nativeCreate) {
1997 var result = data[key];
1998 return result === HASH_UNDEFINED ? undefined : result;
1999 }
2000 return hasOwnProperty.call(data, key) ? data[key] : undefined;
2001 }
2002
2003 /**
2004 * Checks if a hash value for `key` exists.
2005 *
2006 * @private
2007 * @name has
2008 * @memberOf Hash
2009 * @param {string} key The key of the entry to check.
2010 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2011 */
2012 function hashHas(key) {
2013 var data = this.__data__;
2014 return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
2015 }
2016
2017 /**
2018 * Sets the hash `key` to `value`.
2019 *
2020 * @private
2021 * @name set
2022 * @memberOf Hash
2023 * @param {string} key The key of the value to set.
2024 * @param {*} value The value to set.
2025 * @returns {Object} Returns the hash instance.
2026 */
2027 function hashSet(key, value) {
2028 var data = this.__data__;
2029 this.size += this.has(key) ? 0 : 1;
2030 data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
2031 return this;
2032 }
2033
2034 // Add methods to `Hash`.
2035 Hash.prototype.clear = hashClear;
2036 Hash.prototype['delete'] = hashDelete;
2037 Hash.prototype.get = hashGet;
2038 Hash.prototype.has = hashHas;
2039 Hash.prototype.set = hashSet;
2040
2041 /*------------------------------------------------------------------------*/
2042
2043 /**
2044 * Creates an list cache object.
2045 *
2046 * @private
2047 * @constructor
2048 * @param {Array} [entries] The key-value pairs to cache.
2049 */
2050 function ListCache(entries) {
2051 var index = -1,
2052 length = entries == null ? 0 : entries.length;
2053
2054 this.clear();
2055 while (++index < length) {
2056 var entry = entries[index];
2057 this.set(entry[0], entry[1]);
2058 }
2059 }
2060
2061 /**
2062 * Removes all key-value entries from the list cache.
2063 *
2064 * @private
2065 * @name clear
2066 * @memberOf ListCache
2067 */
2068 function listCacheClear() {
2069 this.__data__ = [];
2070 this.size = 0;
2071 }
2072
2073 /**
2074 * Removes `key` and its value from the list cache.
2075 *
2076 * @private
2077 * @name delete
2078 * @memberOf ListCache
2079 * @param {string} key The key of the value to remove.
2080 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2081 */
2082 function listCacheDelete(key) {
2083 var data = this.__data__,
2084 index = assocIndexOf(data, key);
2085
2086 if (index < 0) {
2087 return false;
2088 }
2089 var lastIndex = data.length - 1;
2090 if (index == lastIndex) {
2091 data.pop();
2092 } else {
2093 splice.call(data, index, 1);
2094 }
2095 --this.size;
2096 return true;
2097 }
2098
2099 /**
2100 * Gets the list cache value for `key`.
2101 *
2102 * @private
2103 * @name get
2104 * @memberOf ListCache
2105 * @param {string} key The key of the value to get.
2106 * @returns {*} Returns the entry value.
2107 */
2108 function listCacheGet(key) {
2109 var data = this.__data__,
2110 index = assocIndexOf(data, key);
2111
2112 return index < 0 ? undefined : data[index][1];
2113 }
2114
2115 /**
2116 * Checks if a list cache value for `key` exists.
2117 *
2118 * @private
2119 * @name has
2120 * @memberOf ListCache
2121 * @param {string} key The key of the entry to check.
2122 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2123 */
2124 function listCacheHas(key) {
2125 return assocIndexOf(this.__data__, key) > -1;
2126 }
2127
2128 /**
2129 * Sets the list cache `key` to `value`.
2130 *
2131 * @private
2132 * @name set
2133 * @memberOf ListCache
2134 * @param {string} key The key of the value to set.
2135 * @param {*} value The value to set.
2136 * @returns {Object} Returns the list cache instance.
2137 */
2138 function listCacheSet(key, value) {
2139 var data = this.__data__,
2140 index = assocIndexOf(data, key);
2141
2142 if (index < 0) {
2143 ++this.size;
2144 data.push([key, value]);
2145 } else {
2146 data[index][1] = value;
2147 }
2148 return this;
2149 }
2150
2151 // Add methods to `ListCache`.
2152 ListCache.prototype.clear = listCacheClear;
2153 ListCache.prototype['delete'] = listCacheDelete;
2154 ListCache.prototype.get = listCacheGet;
2155 ListCache.prototype.has = listCacheHas;
2156 ListCache.prototype.set = listCacheSet;
2157
2158 /*------------------------------------------------------------------------*/
2159
2160 /**
2161 * Creates a map cache object to store key-value pairs.
2162 *
2163 * @private
2164 * @constructor
2165 * @param {Array} [entries] The key-value pairs to cache.
2166 */
2167 function MapCache(entries) {
2168 var index = -1,
2169 length = entries == null ? 0 : entries.length;
2170
2171 this.clear();
2172 while (++index < length) {
2173 var entry = entries[index];
2174 this.set(entry[0], entry[1]);
2175 }
2176 }
2177
2178 /**
2179 * Removes all key-value entries from the map.
2180 *
2181 * @private
2182 * @name clear
2183 * @memberOf MapCache
2184 */
2185 function mapCacheClear() {
2186 this.size = 0;
2187 this.__data__ = {
2188 'hash': new Hash,
2189 'map': new (Map || ListCache),
2190 'string': new Hash
2191 };
2192 }
2193
2194 /**
2195 * Removes `key` and its value from the map.
2196 *
2197 * @private
2198 * @name delete
2199 * @memberOf MapCache
2200 * @param {string} key The key of the value to remove.
2201 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2202 */
2203 function mapCacheDelete(key) {
2204 var result = getMapData(this, key)['delete'](key);
2205 this.size -= result ? 1 : 0;
2206 return result;
2207 }
2208
2209 /**
2210 * Gets the map value for `key`.
2211 *
2212 * @private
2213 * @name get
2214 * @memberOf MapCache
2215 * @param {string} key The key of the value to get.
2216 * @returns {*} Returns the entry value.
2217 */
2218 function mapCacheGet(key) {
2219 return getMapData(this, key).get(key);
2220 }
2221
2222 /**
2223 * Checks if a map value for `key` exists.
2224 *
2225 * @private
2226 * @name has
2227 * @memberOf MapCache
2228 * @param {string} key The key of the entry to check.
2229 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2230 */
2231 function mapCacheHas(key) {
2232 return getMapData(this, key).has(key);
2233 }
2234
2235 /**
2236 * Sets the map `key` to `value`.
2237 *
2238 * @private
2239 * @name set
2240 * @memberOf MapCache
2241 * @param {string} key The key of the value to set.
2242 * @param {*} value The value to set.
2243 * @returns {Object} Returns the map cache instance.
2244 */
2245 function mapCacheSet(key, value) {
2246 var data = getMapData(this, key),
2247 size = data.size;
2248
2249 data.set(key, value);
2250 this.size += data.size == size ? 0 : 1;
2251 return this;
2252 }
2253
2254 // Add methods to `MapCache`.
2255 MapCache.prototype.clear = mapCacheClear;
2256 MapCache.prototype['delete'] = mapCacheDelete;
2257 MapCache.prototype.get = mapCacheGet;
2258 MapCache.prototype.has = mapCacheHas;
2259 MapCache.prototype.set = mapCacheSet;
2260
2261 /*------------------------------------------------------------------------*/
2262
2263 /**
2264 *
2265 * Creates an array cache object to store unique values.
2266 *
2267 * @private
2268 * @constructor
2269 * @param {Array} [values] The values to cache.
2270 */
2271 function SetCache(values) {
2272 var index = -1,
2273 length = values == null ? 0 : values.length;
2274
2275 this.__data__ = new MapCache;
2276 while (++index < length) {
2277 this.add(values[index]);
2278 }
2279 }
2280
2281 /**
2282 * Adds `value` to the array cache.
2283 *
2284 * @private
2285 * @name add
2286 * @memberOf SetCache
2287 * @alias push
2288 * @param {*} value The value to cache.
2289 * @returns {Object} Returns the cache instance.
2290 */
2291 function setCacheAdd(value) {
2292 this.__data__.set(value, HASH_UNDEFINED);
2293 return this;
2294 }
2295
2296 /**
2297 * Checks if `value` is in the array cache.
2298 *
2299 * @private
2300 * @name has
2301 * @memberOf SetCache
2302 * @param {*} value The value to search for.
2303 * @returns {number} Returns `true` if `value` is found, else `false`.
2304 */
2305 function setCacheHas(value) {
2306 return this.__data__.has(value);
2307 }
2308
2309 // Add methods to `SetCache`.
2310 SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
2311 SetCache.prototype.has = setCacheHas;
2312
2313 /*------------------------------------------------------------------------*/
2314
2315 /**
2316 * Creates a stack cache object to store key-value pairs.
2317 *
2318 * @private
2319 * @constructor
2320 * @param {Array} [entries] The key-value pairs to cache.
2321 */
2322 function Stack(entries) {
2323 var data = this.__data__ = new ListCache(entries);
2324 this.size = data.size;
2325 }
2326
2327 /**
2328 * Removes all key-value entries from the stack.
2329 *
2330 * @private
2331 * @name clear
2332 * @memberOf Stack
2333 */
2334 function stackClear() {
2335 this.__data__ = new ListCache;
2336 this.size = 0;
2337 }
2338
2339 /**
2340 * Removes `key` and its value from the stack.
2341 *
2342 * @private
2343 * @name delete
2344 * @memberOf Stack
2345 * @param {string} key The key of the value to remove.
2346 * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2347 */
2348 function stackDelete(key) {
2349 var data = this.__data__,
2350 result = data['delete'](key);
2351
2352 this.size = data.size;
2353 return result;
2354 }
2355
2356 /**
2357 * Gets the stack value for `key`.
2358 *
2359 * @private
2360 * @name get
2361 * @memberOf Stack
2362 * @param {string} key The key of the value to get.
2363 * @returns {*} Returns the entry value.
2364 */
2365 function stackGet(key) {
2366 return this.__data__.get(key);
2367 }
2368
2369 /**
2370 * Checks if a stack value for `key` exists.
2371 *
2372 * @private
2373 * @name has
2374 * @memberOf Stack
2375 * @param {string} key The key of the entry to check.
2376 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2377 */
2378 function stackHas(key) {
2379 return this.__data__.has(key);
2380 }
2381
2382 /**
2383 * Sets the stack `key` to `value`.
2384 *
2385 * @private
2386 * @name set
2387 * @memberOf Stack
2388 * @param {string} key The key of the value to set.
2389 * @param {*} value The value to set.
2390 * @returns {Object} Returns the stack cache instance.
2391 */
2392 function stackSet(key, value) {
2393 var data = this.__data__;
2394 if (data instanceof ListCache) {
2395 var pairs = data.__data__;
2396 if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
2397 pairs.push([key, value]);
2398 this.size = ++data.size;
2399 return this;
2400 }
2401 data = this.__data__ = new MapCache(pairs);
2402 }
2403 data.set(key, value);
2404 this.size = data.size;
2405 return this;
2406 }
2407
2408 // Add methods to `Stack`.
2409 Stack.prototype.clear = stackClear;
2410 Stack.prototype['delete'] = stackDelete;
2411 Stack.prototype.get = stackGet;
2412 Stack.prototype.has = stackHas;
2413 Stack.prototype.set = stackSet;
2414
2415 /*------------------------------------------------------------------------*/
2416
2417 /**
2418 * Creates an array of the enumerable property names of the array-like `value`.
2419 *
2420 * @private
2421 * @param {*} value The value to query.
2422 * @param {boolean} inherited Specify returning inherited property names.
2423 * @returns {Array} Returns the array of property names.
2424 */
2425 function arrayLikeKeys(value, inherited) {
2426 var isArr = isArray(value),
2427 isArg = !isArr && isArguments(value),
2428 isBuff = !isArr && !isArg && isBuffer(value),
2429 isType = !isArr && !isArg && !isBuff && isTypedArray(value),
2430 skipIndexes = isArr || isArg || isBuff || isType,
2431 result = skipIndexes ? baseTimes(value.length, String) : [],
2432 length = result.length;
2433
2434 for (var key in value) {
2435 if ((inherited || hasOwnProperty.call(value, key)) &&
2436 !(skipIndexes && (
2437 // Safari 9 has enumerable `arguments.length` in strict mode.
2438 key == 'length' ||
2439 // Node.js 0.10 has enumerable non-index properties on buffers.
2440 (isBuff && (key == 'offset' || key == 'parent')) ||
2441 // PhantomJS 2 has enumerable non-index properties on typed arrays.
2442 (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
2443 // Skip index properties.
2444 isIndex(key, length)
2445 ))) {
2446 result.push(key);
2447 }
2448 }
2449 return result;
2450 }
2451
2452 /**
2453 * A specialized version of `_.sample` for arrays.
2454 *
2455 * @private
2456 * @param {Array} array The array to sample.
2457 * @returns {*} Returns the random element.
2458 */
2459 function arraySample(array) {
2460 var length = array.length;
2461 return length ? array[baseRandom(0, length - 1)] : undefined;
2462 }
2463
2464 /**
2465 * A specialized version of `_.sampleSize` for arrays.
2466 *
2467 * @private
2468 * @param {Array} array The array to sample.
2469 * @param {number} n The number of elements to sample.
2470 * @returns {Array} Returns the random elements.
2471 */
2472 function arraySampleSize(array, n) {
2473 return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
2474 }
2475
2476 /**
2477 * A specialized version of `_.shuffle` for arrays.
2478 *
2479 * @private
2480 * @param {Array} array The array to shuffle.
2481 * @returns {Array} Returns the new shuffled array.
2482 */
2483 function arrayShuffle(array) {
2484 return shuffleSelf(copyArray(array));
2485 }
2486
2487 /**
2488 * This function is like `assignValue` except that it doesn't assign
2489 * `undefined` values.
2490 *
2491 * @private
2492 * @param {Object} object The object to modify.
2493 * @param {string} key The key of the property to assign.
2494 * @param {*} value The value to assign.
2495 */
2496 function assignMergeValue(object, key, value) {
2497 if ((value !== undefined && !eq(object[key], value)) ||
2498 (value === undefined && !(key in object))) {
2499 baseAssignValue(object, key, value);
2500 }
2501 }
2502
2503 /**
2504 * Assigns `value` to `key` of `object` if the existing value is not equivalent
2505 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2506 * for equality comparisons.
2507 *
2508 * @private
2509 * @param {Object} object The object to modify.
2510 * @param {string} key The key of the property to assign.
2511 * @param {*} value The value to assign.
2512 */
2513 function assignValue(object, key, value) {
2514 var objValue = object[key];
2515 if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
2516 (value === undefined && !(key in object))) {
2517 baseAssignValue(object, key, value);
2518 }
2519 }
2520
2521 /**
2522 * Gets the index at which the `key` is found in `array` of key-value pairs.
2523 *
2524 * @private
2525 * @param {Array} array The array to inspect.
2526 * @param {*} key The key to search for.
2527 * @returns {number} Returns the index of the matched value, else `-1`.
2528 */
2529 function assocIndexOf(array, key) {
2530 var length = array.length;
2531 while (length--) {
2532 if (eq(array[length][0], key)) {
2533 return length;
2534 }
2535 }
2536 return -1;
2537 }
2538
2539 /**
2540 * Aggregates elements of `collection` on `accumulator` with keys transformed
2541 * by `iteratee` and values set by `setter`.
2542 *
2543 * @private
2544 * @param {Array|Object} collection The collection to iterate over.
2545 * @param {Function} setter The function to set `accumulator` values.
2546 * @param {Function} iteratee The iteratee to transform keys.
2547 * @param {Object} accumulator The initial aggregated object.
2548 * @returns {Function} Returns `accumulator`.
2549 */
2550 function baseAggregator(collection, setter, iteratee, accumulator) {
2551 baseEach(collection, function(value, key, collection) {
2552 setter(accumulator, value, iteratee(value), collection);
2553 });
2554 return accumulator;
2555 }
2556
2557 /**
2558 * The base implementation of `_.assign` without support for multiple sources
2559 * or `customizer` functions.
2560 *
2561 * @private
2562 * @param {Object} object The destination object.
2563 * @param {Object} source The source object.
2564 * @returns {Object} Returns `object`.
2565 */
2566 function baseAssign(object, source) {
2567 return object && copyObject(source, keys(source), object);
2568 }
2569
2570 /**
2571 * The base implementation of `_.assignIn` without support for multiple sources
2572 * or `customizer` functions.
2573 *
2574 * @private
2575 * @param {Object} object The destination object.
2576 * @param {Object} source The source object.
2577 * @returns {Object} Returns `object`.
2578 */
2579 function baseAssignIn(object, source) {
2580 return object && copyObject(source, keysIn(source), object);
2581 }
2582
2583 /**
2584 * The base implementation of `assignValue` and `assignMergeValue` without
2585 * value checks.
2586 *
2587 * @private
2588 * @param {Object} object The object to modify.
2589 * @param {string} key The key of the property to assign.
2590 * @param {*} value The value to assign.
2591 */
2592 function baseAssignValue(object, key, value) {
2593 if (key == '__proto__' && defineProperty) {
2594 defineProperty(object, key, {
2595 'configurable': true,
2596 'enumerable': true,
2597 'value': value,
2598 'writable': true
2599 });
2600 } else {
2601 object[key] = value;
2602 }
2603 }
2604
2605 /**
2606 * The base implementation of `_.at` without support for individual paths.
2607 *
2608 * @private
2609 * @param {Object} object The object to iterate over.
2610 * @param {string[]} paths The property paths to pick.
2611 * @returns {Array} Returns the picked elements.
2612 */
2613 function baseAt(object, paths) {
2614 var index = -1,
2615 length = paths.length,
2616 result = Array(length),
2617 skip = object == null;
2618
2619 while (++index < length) {
2620 result[index] = skip ? undefined : get(object, paths[index]);
2621 }
2622 return result;
2623 }
2624
2625 /**
2626 * The base implementation of `_.clamp` which doesn't coerce arguments.
2627 *
2628 * @private
2629 * @param {number} number The number to clamp.
2630 * @param {number} [lower] The lower bound.
2631 * @param {number} upper The upper bound.
2632 * @returns {number} Returns the clamped number.
2633 */
2634 function baseClamp(number, lower, upper) {
2635 if (number === number) {
2636 if (upper !== undefined) {
2637 number = number <= upper ? number : upper;
2638 }
2639 if (lower !== undefined) {
2640 number = number >= lower ? number : lower;
2641 }
2642 }
2643 return number;
2644 }
2645
2646 /**
2647 * The base implementation of `_.clone` and `_.cloneDeep` which tracks
2648 * traversed objects.
2649 *
2650 * @private
2651 * @param {*} value The value to clone.
2652 * @param {boolean} bitmask The bitmask flags.
2653 * 1 - Deep clone
2654 * 2 - Flatten inherited properties
2655 * 4 - Clone symbols
2656 * @param {Function} [customizer] The function to customize cloning.
2657 * @param {string} [key] The key of `value`.
2658 * @param {Object} [object] The parent object of `value`.
2659 * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
2660 * @returns {*} Returns the cloned value.
2661 */
2662 function baseClone(value, bitmask, customizer, key, object, stack) {
2663 var result,
2664 isDeep = bitmask & CLONE_DEEP_FLAG,
2665 isFlat = bitmask & CLONE_FLAT_FLAG,
2666 isFull = bitmask & CLONE_SYMBOLS_FLAG;
2667
2668 if (customizer) {
2669 result = object ? customizer(value, key, object, stack) : customizer(value);
2670 }
2671 if (result !== undefined) {
2672 return result;
2673 }
2674 if (!isObject(value)) {
2675 return value;
2676 }
2677 var isArr = isArray(value);
2678 if (isArr) {
2679 result = initCloneArray(value);
2680 if (!isDeep) {
2681 return copyArray(value, result);
2682 }
2683 } else {
2684 var tag = getTag(value),
2685 isFunc = tag == funcTag || tag == genTag;
2686
2687 if (isBuffer(value)) {
2688 return cloneBuffer(value, isDeep);
2689 }
2690 if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
2691 result = (isFlat || isFunc) ? {} : initCloneObject(value);
2692 if (!isDeep) {
2693 return isFlat
2694 ? copySymbolsIn(value, baseAssignIn(result, value))
2695 : copySymbols(value, baseAssign(result, value));
2696 }
2697 } else {
2698 if (!cloneableTags[tag]) {
2699 return object ? value : {};
2700 }
2701 result = initCloneByTag(value, tag, isDeep);
2702 }
2703 }
2704 // Check for circular references and return its corresponding clone.
2705 stack || (stack = new Stack);
2706 var stacked = stack.get(value);
2707 if (stacked) {
2708 return stacked;
2709 }
2710 stack.set(value, result);
2711
2712 if (isSet(value)) {
2713 value.forEach(function(subValue) {
2714 result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
2715 });
2716 } else if (isMap(value)) {
2717 value.forEach(function(subValue, key) {
2718 result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
2719 });
2720 }
2721
2722 var keysFunc = isFull
2723 ? (isFlat ? getAllKeysIn : getAllKeys)
2724 : (isFlat ? keysIn : keys);
2725
2726 var props = isArr ? undefined : keysFunc(value);
2727 arrayEach(props || value, function(subValue, key) {
2728 if (props) {
2729 key = subValue;
2730 subValue = value[key];
2731 }
2732 // Recursively populate clone (susceptible to call stack limits).
2733 assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
2734 });
2735 return result;
2736 }
2737
2738 /**
2739 * The base implementation of `_.conforms` which doesn't clone `source`.
2740 *
2741 * @private
2742 * @param {Object} source The object of property predicates to conform to.
2743 * @returns {Function} Returns the new spec function.
2744 */
2745 function baseConforms(source) {
2746 var props = keys(source);
2747 return function(object) {
2748 return baseConformsTo(object, source, props);
2749 };
2750 }
2751
2752 /**
2753 * The base implementation of `_.conformsTo` which accepts `props` to check.
2754 *
2755 * @private
2756 * @param {Object} object The object to inspect.
2757 * @param {Object} source The object of property predicates to conform to.
2758 * @returns {boolean} Returns `true` if `object` conforms, else `false`.
2759 */
2760 function baseConformsTo(object, source, props) {
2761 var length = props.length;
2762 if (object == null) {
2763 return !length;
2764 }
2765 object = Object(object);
2766 while (length--) {
2767 var key = props[length],
2768 predicate = source[key],
2769 value = object[key];
2770
2771 if ((value === undefined && !(key in object)) || !predicate(value)) {
2772 return false;
2773 }
2774 }
2775 return true;
2776 }
2777
2778 /**
2779 * The base implementation of `_.delay` and `_.defer` which accepts `args`
2780 * to provide to `func`.
2781 *
2782 * @private
2783 * @param {Function} func The function to delay.
2784 * @param {number} wait The number of milliseconds to delay invocation.
2785 * @param {Array} args The arguments to provide to `func`.
2786 * @returns {number|Object} Returns the timer id or timeout object.
2787 */
2788 function baseDelay(func, wait, args) {
2789 if (typeof func != 'function') {
2790 throw new TypeError(FUNC_ERROR_TEXT);
2791 }
2792 return setTimeout(function() { func.apply(undefined, args); }, wait);
2793 }
2794
2795 /**
2796 * The base implementation of methods like `_.difference` without support
2797 * for excluding multiple arrays or iteratee shorthands.
2798 *
2799 * @private
2800 * @param {Array} array The array to inspect.
2801 * @param {Array} values The values to exclude.
2802 * @param {Function} [iteratee] The iteratee invoked per element.
2803 * @param {Function} [comparator] The comparator invoked per element.
2804 * @returns {Array} Returns the new array of filtered values.
2805 */
2806 function baseDifference(array, values, iteratee, comparator) {
2807 var index = -1,
2808 includes = arrayIncludes,
2809 isCommon = true,
2810 length = array.length,
2811 result = [],
2812 valuesLength = values.length;
2813
2814 if (!length) {
2815 return result;
2816 }
2817 if (iteratee) {
2818 values = arrayMap(values, baseUnary(iteratee));
2819 }
2820 if (comparator) {
2821 includes = arrayIncludesWith;
2822 isCommon = false;
2823 }
2824 else if (values.length >= LARGE_ARRAY_SIZE) {
2825 includes = cacheHas;
2826 isCommon = false;
2827 values = new SetCache(values);
2828 }
2829 outer:
2830 while (++index < length) {
2831 var value = array[index],
2832 computed = iteratee == null ? value : iteratee(value);
2833
2834 value = (comparator || value !== 0) ? value : 0;
2835 if (isCommon && computed === computed) {
2836 var valuesIndex = valuesLength;
2837 while (valuesIndex--) {
2838 if (values[valuesIndex] === computed) {
2839 continue outer;
2840 }
2841 }
2842 result.push(value);
2843 }
2844 else if (!includes(values, computed, comparator)) {
2845 result.push(value);
2846 }
2847 }
2848 return result;
2849 }
2850
2851 /**
2852 * The base implementation of `_.forEach` without support for iteratee shorthands.
2853 *
2854 * @private
2855 * @param {Array|Object} collection The collection to iterate over.
2856 * @param {Function} iteratee The function invoked per iteration.
2857 * @returns {Array|Object} Returns `collection`.
2858 */
2859 var baseEach = createBaseEach(baseForOwn);
2860
2861 /**
2862 * The base implementation of `_.forEachRight` without support for iteratee shorthands.
2863 *
2864 * @private
2865 * @param {Array|Object} collection The collection to iterate over.
2866 * @param {Function} iteratee The function invoked per iteration.
2867 * @returns {Array|Object} Returns `collection`.
2868 */
2869 var baseEachRight = createBaseEach(baseForOwnRight, true);
2870
2871 /**
2872 * The base implementation of `_.every` without support for iteratee shorthands.
2873 *
2874 * @private
2875 * @param {Array|Object} collection The collection to iterate over.
2876 * @param {Function} predicate The function invoked per iteration.
2877 * @returns {boolean} Returns `true` if all elements pass the predicate check,
2878 * else `false`
2879 */
2880 function baseEvery(collection, predicate) {
2881 var result = true;
2882 baseEach(collection, function(value, index, collection) {
2883 result = !!predicate(value, index, collection);
2884 return result;
2885 });
2886 return result;
2887 }
2888
2889 /**
2890 * The base implementation of methods like `_.max` and `_.min` which accepts a
2891 * `comparator` to determine the extremum value.
2892 *
2893 * @private
2894 * @param {Array} array The array to iterate over.
2895 * @param {Function} iteratee The iteratee invoked per iteration.
2896 * @param {Function} comparator The comparator used to compare values.
2897 * @returns {*} Returns the extremum value.
2898 */
2899 function baseExtremum(array, iteratee, comparator) {
2900 var index = -1,
2901 length = array.length;
2902
2903 while (++index < length) {
2904 var value = array[index],
2905 current = iteratee(value);
2906
2907 if (current != null && (computed === undefined
2908 ? (current === current && !isSymbol(current))
2909 : comparator(current, computed)
2910 )) {
2911 var computed = current,
2912 result = value;
2913 }
2914 }
2915 return result;
2916 }
2917
2918 /**
2919 * The base implementation of `_.fill` without an iteratee call guard.
2920 *
2921 * @private
2922 * @param {Array} array The array to fill.
2923 * @param {*} value The value to fill `array` with.
2924 * @param {number} [start=0] The start position.
2925 * @param {number} [end=array.length] The end position.
2926 * @returns {Array} Returns `array`.
2927 */
2928 function baseFill(array, value, start, end) {
2929 var length = array.length;
2930
2931 start = toInteger(start);
2932 if (start < 0) {
2933 start = -start > length ? 0 : (length + start);
2934 }
2935 end = (end === undefined || end > length) ? length : toInteger(end);
2936 if (end < 0) {
2937 end += length;
2938 }
2939 end = start > end ? 0 : toLength(end);
2940 while (start < end) {
2941 array[start++] = value;
2942 }
2943 return array;
2944 }
2945
2946 /**
2947 * The base implementation of `_.filter` without support for iteratee shorthands.
2948 *
2949 * @private
2950 * @param {Array|Object} collection The collection to iterate over.
2951 * @param {Function} predicate The function invoked per iteration.
2952 * @returns {Array} Returns the new filtered array.
2953 */
2954 function baseFilter(collection, predicate) {
2955 var result = [];
2956 baseEach(collection, function(value, index, collection) {
2957 if (predicate(value, index, collection)) {
2958 result.push(value);
2959 }
2960 });
2961 return result;
2962 }
2963
2964 /**
2965 * The base implementation of `_.flatten` with support for restricting flattening.
2966 *
2967 * @private
2968 * @param {Array} array The array to flatten.
2969 * @param {number} depth The maximum recursion depth.
2970 * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
2971 * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
2972 * @param {Array} [result=[]] The initial result value.
2973 * @returns {Array} Returns the new flattened array.
2974 */
2975 function baseFlatten(array, depth, predicate, isStrict, result) {
2976 var index = -1,
2977 length = array.length;
2978
2979 predicate || (predicate = isFlattenable);
2980 result || (result = []);
2981
2982 while (++index < length) {
2983 var value = array[index];
2984 if (depth > 0 && predicate(value)) {
2985 if (depth > 1) {
2986 // Recursively flatten arrays (susceptible to call stack limits).
2987 baseFlatten(value, depth - 1, predicate, isStrict, result);
2988 } else {
2989 arrayPush(result, value);
2990 }
2991 } else if (!isStrict) {
2992 result[result.length] = value;
2993 }
2994 }
2995 return result;
2996 }
2997
2998 /**
2999 * The base implementation of `baseForOwn` which iterates over `object`
3000 * properties returned by `keysFunc` and invokes `iteratee` for each property.
3001 * Iteratee functions may exit iteration early by explicitly returning `false`.
3002 *
3003 * @private
3004 * @param {Object} object The object to iterate over.
3005 * @param {Function} iteratee The function invoked per iteration.
3006 * @param {Function} keysFunc The function to get the keys of `object`.
3007 * @returns {Object} Returns `object`.
3008 */
3009 var baseFor = createBaseFor();
3010
3011 /**
3012 * This function is like `baseFor` except that it iterates over properties
3013 * in the opposite order.
3014 *
3015 * @private
3016 * @param {Object} object The object to iterate over.
3017 * @param {Function} iteratee The function invoked per iteration.
3018 * @param {Function} keysFunc The function to get the keys of `object`.
3019 * @returns {Object} Returns `object`.
3020 */
3021 var baseForRight = createBaseFor(true);
3022
3023 /**
3024 * The base implementation of `_.forOwn` without support for iteratee shorthands.
3025 *
3026 * @private
3027 * @param {Object} object The object to iterate over.
3028 * @param {Function} iteratee The function invoked per iteration.
3029 * @returns {Object} Returns `object`.
3030 */
3031 function baseForOwn(object, iteratee) {
3032 return object && baseFor(object, iteratee, keys);
3033 }
3034
3035 /**
3036 * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
3037 *
3038 * @private
3039 * @param {Object} object The object to iterate over.
3040 * @param {Function} iteratee The function invoked per iteration.
3041 * @returns {Object} Returns `object`.
3042 */
3043 function baseForOwnRight(object, iteratee) {
3044 return object && baseForRight(object, iteratee, keys);
3045 }
3046
3047 /**
3048 * The base implementation of `_.functions` which creates an array of
3049 * `object` function property names filtered from `props`.
3050 *
3051 * @private
3052 * @param {Object} object The object to inspect.
3053 * @param {Array} props The property names to filter.
3054 * @returns {Array} Returns the function names.
3055 */
3056 function baseFunctions(object, props) {
3057 return arrayFilter(props, function(key) {
3058 return isFunction(object[key]);
3059 });
3060 }
3061
3062 /**
3063 * The base implementation of `_.get` without support for default values.
3064 *
3065 * @private
3066 * @param {Object} object The object to query.
3067 * @param {Array|string} path The path of the property to get.
3068 * @returns {*} Returns the resolved value.
3069 */
3070 function baseGet(object, path) {
3071 path = castPath(path, object);
3072
3073 var index = 0,
3074 length = path.length;
3075
3076 while (object != null && index < length) {
3077 object = object[toKey(path[index++])];
3078 }
3079 return (index && index == length) ? object : undefined;
3080 }
3081
3082 /**
3083 * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
3084 * `keysFunc` and `symbolsFunc` to get the enumerable property names and
3085 * symbols of `object`.
3086 *
3087 * @private
3088 * @param {Object} object The object to query.
3089 * @param {Function} keysFunc The function to get the keys of `object`.
3090 * @param {Function} symbolsFunc The function to get the symbols of `object`.
3091 * @returns {Array} Returns the array of property names and symbols.
3092 */
3093 function baseGetAllKeys(object, keysFunc, symbolsFunc) {
3094 var result = keysFunc(object);
3095 return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
3096 }
3097
3098 /**
3099 * The base implementation of `getTag` without fallbacks for buggy environments.
3100 *
3101 * @private
3102 * @param {*} value The value to query.
3103 * @returns {string} Returns the `toStringTag`.
3104 */
3105 function baseGetTag(value) {
3106 if (value == null) {
3107 return value === undefined ? undefinedTag : nullTag;
3108 }
3109 return (symToStringTag && symToStringTag in Object(value))
3110 ? getRawTag(value)
3111 : objectToString(value);
3112 }
3113
3114 /**
3115 * The base implementation of `_.gt` which doesn't coerce arguments.
3116 *
3117 * @private
3118 * @param {*} value The value to compare.
3119 * @param {*} other The other value to compare.
3120 * @returns {boolean} Returns `true` if `value` is greater than `other`,
3121 * else `false`.
3122 */
3123 function baseGt(value, other) {
3124 return value > other;
3125 }
3126
3127 /**
3128 * The base implementation of `_.has` without support for deep paths.
3129 *
3130 * @private
3131 * @param {Object} [object] The object to query.
3132 * @param {Array|string} key The key to check.
3133 * @returns {boolean} Returns `true` if `key` exists, else `false`.
3134 */
3135 function baseHas(object, key) {
3136 return object != null && hasOwnProperty.call(object, key);
3137 }
3138
3139 /**
3140 * The base implementation of `_.hasIn` without support for deep paths.
3141 *
3142 * @private
3143 * @param {Object} [object] The object to query.
3144 * @param {Array|string} key The key to check.
3145 * @returns {boolean} Returns `true` if `key` exists, else `false`.
3146 */
3147 function baseHasIn(object, key) {
3148 return object != null && key in Object(object);
3149 }
3150
3151 /**
3152 * The base implementation of `_.inRange` which doesn't coerce arguments.
3153 *
3154 * @private
3155 * @param {number} number The number to check.
3156 * @param {number} start The start of the range.
3157 * @param {number} end The end of the range.
3158 * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
3159 */
3160 function baseInRange(number, start, end) {
3161 return number >= nativeMin(start, end) && number < nativeMax(start, end);
3162 }
3163
3164 /**
3165 * The base implementation of methods like `_.intersection`, without support
3166 * for iteratee shorthands, that accepts an array of arrays to inspect.
3167 *
3168 * @private
3169 * @param {Array} arrays The arrays to inspect.
3170 * @param {Function} [iteratee] The iteratee invoked per element.
3171 * @param {Function} [comparator] The comparator invoked per element.
3172 * @returns {Array} Returns the new array of shared values.
3173 */
3174 function baseIntersection(arrays, iteratee, comparator) {
3175 var includes = comparator ? arrayIncludesWith : arrayIncludes,
3176 length = arrays[0].length,
3177 othLength = arrays.length,
3178 othIndex = othLength,
3179 caches = Array(othLength),
3180 maxLength = Infinity,
3181 result = [];
3182
3183 while (othIndex--) {
3184 var array = arrays[othIndex];
3185 if (othIndex && iteratee) {
3186 array = arrayMap(array, baseUnary(iteratee));
3187 }
3188 maxLength = nativeMin(array.length, maxLength);
3189 caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
3190 ? new SetCache(othIndex && array)
3191 : undefined;
3192 }
3193 array = arrays[0];
3194
3195 var index = -1,
3196 seen = caches[0];
3197
3198 outer:
3199 while (++index < length && result.length < maxLength) {
3200 var value = array[index],
3201 computed = iteratee ? iteratee(value) : value;
3202
3203 value = (comparator || value !== 0) ? value : 0;
3204 if (!(seen
3205 ? cacheHas(seen, computed)
3206 : includes(result, computed, comparator)
3207 )) {
3208 othIndex = othLength;
3209 while (--othIndex) {
3210 var cache = caches[othIndex];
3211 if (!(cache
3212 ? cacheHas(cache, computed)
3213 : includes(arrays[othIndex], computed, comparator))
3214 ) {
3215 continue outer;
3216 }
3217 }
3218 if (seen) {
3219 seen.push(computed);
3220 }
3221 result.push(value);
3222 }
3223 }
3224 return result;
3225 }
3226
3227 /**
3228 * The base implementation of `_.invert` and `_.invertBy` which inverts
3229 * `object` with values transformed by `iteratee` and set by `setter`.
3230 *
3231 * @private
3232 * @param {Object} object The object to iterate over.
3233 * @param {Function} setter The function to set `accumulator` values.
3234 * @param {Function} iteratee The iteratee to transform values.
3235 * @param {Object} accumulator The initial inverted object.
3236 * @returns {Function} Returns `accumulator`.
3237 */
3238 function baseInverter(object, setter, iteratee, accumulator) {
3239 baseForOwn(object, function(value, key, object) {
3240 setter(accumulator, iteratee(value), key, object);
3241 });
3242 return accumulator;
3243 }
3244
3245 /**
3246 * The base implementation of `_.invoke` without support for individual
3247 * method arguments.
3248 *
3249 * @private
3250 * @param {Object} object The object to query.
3251 * @param {Array|string} path The path of the method to invoke.
3252 * @param {Array} args The arguments to invoke the method with.
3253 * @returns {*} Returns the result of the invoked method.
3254 */
3255 function baseInvoke(object, path, args) {
3256 path = castPath(path, object);
3257 object = parent(object, path);
3258 var func = object == null ? object : object[toKey(last(path))];
3259 return func == null ? undefined : apply(func, object, args);
3260 }
3261
3262 /**
3263 * The base implementation of `_.isArguments`.
3264 *
3265 * @private
3266 * @param {*} value The value to check.
3267 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
3268 */
3269 function baseIsArguments(value) {
3270 return isObjectLike(value) && baseGetTag(value) == argsTag;
3271 }
3272
3273 /**
3274 * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
3275 *
3276 * @private
3277 * @param {*} value The value to check.
3278 * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
3279 */
3280 function baseIsArrayBuffer(value) {
3281 return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
3282 }
3283
3284 /**
3285 * The base implementation of `_.isDate` without Node.js optimizations.
3286 *
3287 * @private
3288 * @param {*} value The value to check.
3289 * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
3290 */
3291 function baseIsDate(value) {
3292 return isObjectLike(value) && baseGetTag(value) == dateTag;
3293 }
3294
3295 /**
3296 * The base implementation of `_.isEqual` which supports partial comparisons
3297 * and tracks traversed objects.
3298 *
3299 * @private
3300 * @param {*} value The value to compare.
3301 * @param {*} other The other value to compare.
3302 * @param {boolean} bitmask The bitmask flags.
3303 * 1 - Unordered comparison
3304 * 2 - Partial comparison
3305 * @param {Function} [customizer] The function to customize comparisons.
3306 * @param {Object} [stack] Tracks traversed `value` and `other` objects.
3307 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
3308 */
3309 function baseIsEqual(value, other, bitmask, customizer, stack) {
3310 if (value === other) {
3311 return true;
3312 }
3313 if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
3314 return value !== value && other !== other;
3315 }
3316 return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
3317 }
3318
3319 /**
3320 * A specialized version of `baseIsEqual` for arrays and objects which performs
3321 * deep comparisons and tracks traversed objects enabling objects with circular
3322 * references to be compared.
3323 *
3324 * @private
3325 * @param {Object} object The object to compare.
3326 * @param {Object} other The other object to compare.
3327 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
3328 * @param {Function} customizer The function to customize comparisons.
3329 * @param {Function} equalFunc The function to determine equivalents of values.
3330 * @param {Object} [stack] Tracks traversed `object` and `other` objects.
3331 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
3332 */
3333 function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
3334 var objIsArr = isArray(object),
3335 othIsArr = isArray(other),
3336 objTag = objIsArr ? arrayTag : getTag(object),
3337 othTag = othIsArr ? arrayTag : getTag(other);
3338
3339 objTag = objTag == argsTag ? objectTag : objTag;
3340 othTag = othTag == argsTag ? objectTag : othTag;
3341
3342 var objIsObj = objTag == objectTag,
3343 othIsObj = othTag == objectTag,
3344 isSameTag = objTag == othTag;
3345
3346 if (isSameTag && isBuffer(object)) {
3347 if (!isBuffer(other)) {
3348 return false;
3349 }
3350 objIsArr = true;
3351 objIsObj = false;
3352 }
3353 if (isSameTag && !objIsObj) {
3354 stack || (stack = new Stack);
3355 return (objIsArr || isTypedArray(object))
3356 ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
3357 : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
3358 }
3359 if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
3360 var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
3361 othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
3362
3363 if (objIsWrapped || othIsWrapped) {
3364 var objUnwrapped = objIsWrapped ? object.value() : object,
3365 othUnwrapped = othIsWrapped ? other.value() : other;
3366
3367 stack || (stack = new Stack);
3368 return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
3369 }
3370 }
3371 if (!isSameTag) {
3372 return false;
3373 }
3374 stack || (stack = new Stack);
3375 return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
3376 }
3377
3378 /**
3379 * The base implementation of `_.isMap` without Node.js optimizations.
3380 *
3381 * @private
3382 * @param {*} value The value to check.
3383 * @returns {boolean} Returns `true` if `value` is a map, else `false`.
3384 */
3385 function baseIsMap(value) {
3386 return isObjectLike(value) && getTag(value) == mapTag;
3387 }
3388
3389 /**
3390 * The base implementation of `_.isMatch` without support for iteratee shorthands.
3391 *
3392 * @private
3393 * @param {Object} object The object to inspect.
3394 * @param {Object} source The object of property values to match.
3395 * @param {Array} matchData The property names, values, and compare flags to match.
3396 * @param {Function} [customizer] The function to customize comparisons.
3397 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
3398 */
3399 function baseIsMatch(object, source, matchData, customizer) {
3400 var index = matchData.length,
3401 length = index,
3402 noCustomizer = !customizer;
3403
3404 if (object == null) {
3405 return !length;
3406 }
3407 object = Object(object);
3408 while (index--) {
3409 var data = matchData[index];
3410 if ((noCustomizer && data[2])
3411 ? data[1] !== object[data[0]]
3412 : !(data[0] in object)
3413 ) {
3414 return false;
3415 }
3416 }
3417 while (++index < length) {
3418 data = matchData[index];
3419 var key = data[0],
3420 objValue = object[key],
3421 srcValue = data[1];
3422
3423 if (noCustomizer && data[2]) {
3424 if (objValue === undefined && !(key in object)) {
3425 return false;
3426 }
3427 } else {
3428 var stack = new Stack;
3429 if (customizer) {
3430 var result = customizer(objValue, srcValue, key, object, source, stack);
3431 }
3432 if (!(result === undefined
3433 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
3434 : result
3435 )) {
3436 return false;
3437 }
3438 }
3439 }
3440 return true;
3441 }
3442
3443 /**
3444 * The base implementation of `_.isNative` without bad shim checks.
3445 *
3446 * @private
3447 * @param {*} value The value to check.
3448 * @returns {boolean} Returns `true` if `value` is a native function,
3449 * else `false`.
3450 */
3451 function baseIsNative(value) {
3452 if (!isObject(value) || isMasked(value)) {
3453 return false;
3454 }
3455 var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
3456 return pattern.test(toSource(value));
3457 }
3458
3459 /**
3460 * The base implementation of `_.isRegExp` without Node.js optimizations.
3461 *
3462 * @private
3463 * @param {*} value The value to check.
3464 * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
3465 */
3466 function baseIsRegExp(value) {
3467 return isObjectLike(value) && baseGetTag(value) == regexpTag;
3468 }
3469
3470 /**
3471 * The base implementation of `_.isSet` without Node.js optimizations.
3472 *
3473 * @private
3474 * @param {*} value The value to check.
3475 * @returns {boolean} Returns `true` if `value` is a set, else `false`.
3476 */
3477 function baseIsSet(value) {
3478 return isObjectLike(value) && getTag(value) == setTag;
3479 }
3480
3481 /**
3482 * The base implementation of `_.isTypedArray` without Node.js optimizations.
3483 *
3484 * @private
3485 * @param {*} value The value to check.
3486 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
3487 */
3488 function baseIsTypedArray(value) {
3489 return isObjectLike(value) &&
3490 isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
3491 }
3492
3493 /**
3494 * The base implementation of `_.iteratee`.
3495 *
3496 * @private
3497 * @param {*} [value=_.identity] The value to convert to an iteratee.
3498 * @returns {Function} Returns the iteratee.
3499 */
3500 function baseIteratee(value) {
3501 // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
3502 // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
3503 if (typeof value == 'function') {
3504 return value;
3505 }
3506 if (value == null) {
3507 return identity;
3508 }
3509 if (typeof value == 'object') {
3510 return isArray(value)
3511 ? baseMatchesProperty(value[0], value[1])
3512 : baseMatches(value);
3513 }
3514 return property(value);
3515 }
3516
3517 /**
3518 * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
3519 *
3520 * @private
3521 * @param {Object} object The object to query.
3522 * @returns {Array} Returns the array of property names.
3523 */
3524 function baseKeys(object) {
3525 if (!isPrototype(object)) {
3526 return nativeKeys(object);
3527 }
3528 var result = [];
3529 for (var key in Object(object)) {
3530 if (hasOwnProperty.call(object, key) && key != 'constructor') {
3531 result.push(key);
3532 }
3533 }
3534 return result;
3535 }
3536
3537 /**
3538 * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
3539 *
3540 * @private
3541 * @param {Object} object The object to query.
3542 * @returns {Array} Returns the array of property names.
3543 */
3544 function baseKeysIn(object) {
3545 if (!isObject(object)) {
3546 return nativeKeysIn(object);
3547 }
3548 var isProto = isPrototype(object),
3549 result = [];
3550
3551 for (var key in object) {
3552 if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
3553 result.push(key);
3554 }
3555 }
3556 return result;
3557 }
3558
3559 /**
3560 * The base implementation of `_.lt` which doesn't coerce arguments.
3561 *
3562 * @private
3563 * @param {*} value The value to compare.
3564 * @param {*} other The other value to compare.
3565 * @returns {boolean} Returns `true` if `value` is less than `other`,
3566 * else `false`.
3567 */
3568 function baseLt(value, other) {
3569 return value < other;
3570 }
3571
3572 /**
3573 * The base implementation of `_.map` without support for iteratee shorthands.
3574 *
3575 * @private
3576 * @param {Array|Object} collection The collection to iterate over.
3577 * @param {Function} iteratee The function invoked per iteration.
3578 * @returns {Array} Returns the new mapped array.
3579 */
3580 function baseMap(collection, iteratee) {
3581 var index = -1,
3582 result = isArrayLike(collection) ? Array(collection.length) : [];
3583
3584 baseEach(collection, function(value, key, collection) {
3585 result[++index] = iteratee(value, key, collection);
3586 });
3587 return result;
3588 }
3589
3590 /**
3591 * The base implementation of `_.matches` which doesn't clone `source`.
3592 *
3593 * @private
3594 * @param {Object} source The object of property values to match.
3595 * @returns {Function} Returns the new spec function.
3596 */
3597 function baseMatches(source) {
3598 var matchData = getMatchData(source);
3599 if (matchData.length == 1 && matchData[0][2]) {
3600 return matchesStrictComparable(matchData[0][0], matchData[0][1]);
3601 }
3602 return function(object) {
3603 return object === source || baseIsMatch(object, source, matchData);
3604 };
3605 }
3606
3607 /**
3608 * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
3609 *
3610 * @private
3611 * @param {string} path The path of the property to get.
3612 * @param {*} srcValue The value to match.
3613 * @returns {Function} Returns the new spec function.
3614 */
3615 function baseMatchesProperty(path, srcValue) {
3616 if (isKey(path) && isStrictComparable(srcValue)) {
3617 return matchesStrictComparable(toKey(path), srcValue);
3618 }
3619 return function(object) {
3620 var objValue = get(object, path);
3621 return (objValue === undefined && objValue === srcValue)
3622 ? hasIn(object, path)
3623 : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
3624 };
3625 }
3626
3627 /**
3628 * The base implementation of `_.merge` without support for multiple sources.
3629 *
3630 * @private
3631 * @param {Object} object The destination object.
3632 * @param {Object} source The source object.
3633 * @param {number} srcIndex The index of `source`.
3634 * @param {Function} [customizer] The function to customize merged values.
3635 * @param {Object} [stack] Tracks traversed source values and their merged
3636 * counterparts.
3637 */
3638 function baseMerge(object, source, srcIndex, customizer, stack) {
3639 if (object === source) {
3640 return;
3641 }
3642 baseFor(source, function(srcValue, key) {
3643 stack || (stack = new Stack);
3644 if (isObject(srcValue)) {
3645 baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
3646 }
3647 else {
3648 var newValue = customizer
3649 ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
3650 : undefined;
3651
3652 if (newValue === undefined) {
3653 newValue = srcValue;
3654 }
3655 assignMergeValue(object, key, newValue);
3656 }
3657 }, keysIn);
3658 }
3659
3660 /**
3661 * A specialized version of `baseMerge` for arrays and objects which performs
3662 * deep merges and tracks traversed objects enabling objects with circular
3663 * references to be merged.
3664 *
3665 * @private
3666 * @param {Object} object The destination object.
3667 * @param {Object} source The source object.
3668 * @param {string} key The key of the value to merge.
3669 * @param {number} srcIndex The index of `source`.
3670 * @param {Function} mergeFunc The function to merge values.
3671 * @param {Function} [customizer] The function to customize assigned values.
3672 * @param {Object} [stack] Tracks traversed source values and their merged
3673 * counterparts.
3674 */
3675 function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
3676 var objValue = safeGet(object, key),
3677 srcValue = safeGet(source, key),
3678 stacked = stack.get(srcValue);
3679
3680 if (stacked) {
3681 assignMergeValue(object, key, stacked);
3682 return;
3683 }
3684 var newValue = customizer
3685 ? customizer(objValue, srcValue, (key + ''), object, source, stack)
3686 : undefined;
3687
3688 var isCommon = newValue === undefined;
3689
3690 if (isCommon) {
3691 var isArr = isArray(srcValue),
3692 isBuff = !isArr && isBuffer(srcValue),
3693 isTyped = !isArr && !isBuff && isTypedArray(srcValue);
3694
3695 newValue = srcValue;
3696 if (isArr || isBuff || isTyped) {
3697 if (isArray(objValue)) {
3698 newValue = objValue;
3699 }
3700 else if (isArrayLikeObject(objValue)) {
3701 newValue = copyArray(objValue);
3702 }
3703 else if (isBuff) {
3704 isCommon = false;
3705 newValue = cloneBuffer(srcValue, true);
3706 }
3707 else if (isTyped) {
3708 isCommon = false;
3709 newValue = cloneTypedArray(srcValue, true);
3710 }
3711 else {
3712 newValue = [];
3713 }
3714 }
3715 else if (isPlainObject(srcValue) || isArguments(srcValue)) {
3716 newValue = objValue;
3717 if (isArguments(objValue)) {
3718 newValue = toPlainObject(objValue);
3719 }
3720 else if (!isObject(objValue) || isFunction(objValue)) {
3721 newValue = initCloneObject(srcValue);
3722 }
3723 }
3724 else {
3725 isCommon = false;
3726 }
3727 }
3728 if (isCommon) {
3729 // Recursively merge objects and arrays (susceptible to call stack limits).
3730 stack.set(srcValue, newValue);
3731 mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
3732 stack['delete'](srcValue);
3733 }
3734 assignMergeValue(object, key, newValue);
3735 }
3736
3737 /**
3738 * The base implementation of `_.nth` which doesn't coerce arguments.
3739 *
3740 * @private
3741 * @param {Array} array The array to query.
3742 * @param {number} n The index of the element to return.
3743 * @returns {*} Returns the nth element of `array`.
3744 */
3745 function baseNth(array, n) {
3746 var length = array.length;
3747 if (!length) {
3748 return;
3749 }
3750 n += n < 0 ? length : 0;
3751 return isIndex(n, length) ? array[n] : undefined;
3752 }
3753
3754 /**
3755 * The base implementation of `_.orderBy` without param guards.
3756 *
3757 * @private
3758 * @param {Array|Object} collection The collection to iterate over.
3759 * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
3760 * @param {string[]} orders The sort orders of `iteratees`.
3761 * @returns {Array} Returns the new sorted array.
3762 */
3763 function baseOrderBy(collection, iteratees, orders) {
3764 if (iteratees.length) {
3765 iteratees = arrayMap(iteratees, function(iteratee) {
3766 if (isArray(iteratee)) {
3767 return function(value) {
3768 return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
3769 }
3770 }
3771 return iteratee;
3772 });
3773 } else {
3774 iteratees = [identity];
3775 }
3776
3777 var index = -1;
3778 iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
3779
3780 var result = baseMap(collection, function(value, key, collection) {
3781 var criteria = arrayMap(iteratees, function(iteratee) {
3782 return iteratee(value);
3783 });
3784 return { 'criteria': criteria, 'index': ++index, 'value': value };
3785 });
3786
3787 return baseSortBy(result, function(object, other) {
3788 return compareMultiple(object, other, orders);
3789 });
3790 }
3791
3792 /**
3793 * The base implementation of `_.pick` without support for individual
3794 * property identifiers.
3795 *
3796 * @private
3797 * @param {Object} object The source object.
3798 * @param {string[]} paths The property paths to pick.
3799 * @returns {Object} Returns the new object.
3800 */
3801 function basePick(object, paths) {
3802 return basePickBy(object, paths, function(value, path) {
3803 return hasIn(object, path);
3804 });
3805 }
3806
3807 /**
3808 * The base implementation of `_.pickBy` without support for iteratee shorthands.
3809 *
3810 * @private
3811 * @param {Object} object The source object.
3812 * @param {string[]} paths The property paths to pick.
3813 * @param {Function} predicate The function invoked per property.
3814 * @returns {Object} Returns the new object.
3815 */
3816 function basePickBy(object, paths, predicate) {
3817 var index = -1,
3818 length = paths.length,
3819 result = {};
3820
3821 while (++index < length) {
3822 var path = paths[index],
3823 value = baseGet(object, path);
3824
3825 if (predicate(value, path)) {
3826 baseSet(result, castPath(path, object), value);
3827 }
3828 }
3829 return result;
3830 }
3831
3832 /**
3833 * A specialized version of `baseProperty` which supports deep paths.
3834 *
3835 * @private
3836 * @param {Array|string} path The path of the property to get.
3837 * @returns {Function} Returns the new accessor function.
3838 */
3839 function basePropertyDeep(path) {
3840 return function(object) {
3841 return baseGet(object, path);
3842 };
3843 }
3844
3845 /**
3846 * The base implementation of `_.pullAllBy` without support for iteratee
3847 * shorthands.
3848 *
3849 * @private
3850 * @param {Array} array The array to modify.
3851 * @param {Array} values The values to remove.
3852 * @param {Function} [iteratee] The iteratee invoked per element.
3853 * @param {Function} [comparator] The comparator invoked per element.
3854 * @returns {Array} Returns `array`.
3855 */
3856 function basePullAll(array, values, iteratee, comparator) {
3857 var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
3858 index = -1,
3859 length = values.length,
3860 seen = array;
3861
3862 if (array === values) {
3863 values = copyArray(values);
3864 }
3865 if (iteratee) {
3866 seen = arrayMap(array, baseUnary(iteratee));
3867 }
3868 while (++index < length) {
3869 var fromIndex = 0,
3870 value = values[index],
3871 computed = iteratee ? iteratee(value) : value;
3872
3873 while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
3874 if (seen !== array) {
3875 splice.call(seen, fromIndex, 1);
3876 }
3877 splice.call(array, fromIndex, 1);
3878 }
3879 }
3880 return array;
3881 }
3882
3883 /**
3884 * The base implementation of `_.pullAt` without support for individual
3885 * indexes or capturing the removed elements.
3886 *
3887 * @private
3888 * @param {Array} array The array to modify.
3889 * @param {number[]} indexes The indexes of elements to remove.
3890 * @returns {Array} Returns `array`.
3891 */
3892 function basePullAt(array, indexes) {
3893 var length = array ? indexes.length : 0,
3894 lastIndex = length - 1;
3895
3896 while (length--) {
3897 var index = indexes[length];
3898 if (length == lastIndex || index !== previous) {
3899 var previous = index;
3900 if (isIndex(index)) {
3901 splice.call(array, index, 1);
3902 } else {
3903 baseUnset(array, index);
3904 }
3905 }
3906 }
3907 return array;
3908 }
3909
3910 /**
3911 * The base implementation of `_.random` without support for returning
3912 * floating-point numbers.
3913 *
3914 * @private
3915 * @param {number} lower The lower bound.
3916 * @param {number} upper The upper bound.
3917 * @returns {number} Returns the random number.
3918 */
3919 function baseRandom(lower, upper) {
3920 return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
3921 }
3922
3923 /**
3924 * The base implementation of `_.range` and `_.rangeRight` which doesn't
3925 * coerce arguments.
3926 *
3927 * @private
3928 * @param {number} start The start of the range.
3929 * @param {number} end The end of the range.
3930 * @param {number} step The value to increment or decrement by.
3931 * @param {boolean} [fromRight] Specify iterating from right to left.
3932 * @returns {Array} Returns the range of numbers.
3933 */
3934 function baseRange(start, end, step, fromRight) {
3935 var index = -1,
3936 length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
3937 result = Array(length);
3938
3939 while (length--) {
3940 result[fromRight ? length : ++index] = start;
3941 start += step;
3942 }
3943 return result;
3944 }
3945
3946 /**
3947 * The base implementation of `_.repeat` which doesn't coerce arguments.
3948 *
3949 * @private
3950 * @param {string} string The string to repeat.
3951 * @param {number} n The number of times to repeat the string.
3952 * @returns {string} Returns the repeated string.
3953 */
3954 function baseRepeat(string, n) {
3955 var result = '';
3956 if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
3957 return result;
3958 }
3959 // Leverage the exponentiation by squaring algorithm for a faster repeat.
3960 // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
3961 do {
3962 if (n % 2) {
3963 result += string;
3964 }
3965 n = nativeFloor(n / 2);
3966 if (n) {
3967 string += string;
3968 }
3969 } while (n);
3970
3971 return result;
3972 }
3973
3974 /**
3975 * The base implementation of `_.rest` which doesn't validate or coerce arguments.
3976 *
3977 * @private
3978 * @param {Function} func The function to apply a rest parameter to.
3979 * @param {number} [start=func.length-1] The start position of the rest parameter.
3980 * @returns {Function} Returns the new function.
3981 */
3982 function baseRest(func, start) {
3983 return setToString(overRest(func, start, identity), func + '');
3984 }
3985
3986 /**
3987 * The base implementation of `_.sample`.
3988 *
3989 * @private
3990 * @param {Array|Object} collection The collection to sample.
3991 * @returns {*} Returns the random element.
3992 */
3993 function baseSample(collection) {
3994 return arraySample(values(collection));
3995 }
3996
3997 /**
3998 * The base implementation of `_.sampleSize` without param guards.
3999 *
4000 * @private
4001 * @param {Array|Object} collection The collection to sample.
4002 * @param {number} n The number of elements to sample.
4003 * @returns {Array} Returns the random elements.
4004 */
4005 function baseSampleSize(collection, n) {
4006 var array = values(collection);
4007 return shuffleSelf(array, baseClamp(n, 0, array.length));
4008 }
4009
4010 /**
4011 * The base implementation of `_.set`.
4012 *
4013 * @private
4014 * @param {Object} object The object to modify.
4015 * @param {Array|string} path The path of the property to set.
4016 * @param {*} value The value to set.
4017 * @param {Function} [customizer] The function to customize path creation.
4018 * @returns {Object} Returns `object`.
4019 */
4020 function baseSet(object, path, value, customizer) {
4021 if (!isObject(object)) {
4022 return object;
4023 }
4024 path = castPath(path, object);
4025
4026 var index = -1,
4027 length = path.length,
4028 lastIndex = length - 1,
4029 nested = object;
4030
4031 while (nested != null && ++index < length) {
4032 var key = toKey(path[index]),
4033 newValue = value;
4034
4035 if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
4036 return object;
4037 }
4038
4039 if (index != lastIndex) {
4040 var objValue = nested[key];
4041 newValue = customizer ? customizer(objValue, key, nested) : undefined;
4042 if (newValue === undefined) {
4043 newValue = isObject(objValue)
4044 ? objValue
4045 : (isIndex(path[index + 1]) ? [] : {});
4046 }
4047 }
4048 assignValue(nested, key, newValue);
4049 nested = nested[key];
4050 }
4051 return object;
4052 }
4053
4054 /**
4055 * The base implementation of `setData` without support for hot loop shorting.
4056 *
4057 * @private
4058 * @param {Function} func The function to associate metadata with.
4059 * @param {*} data The metadata.
4060 * @returns {Function} Returns `func`.
4061 */
4062 var baseSetData = !metaMap ? identity : function(func, data) {
4063 metaMap.set(func, data);
4064 return func;
4065 };
4066
4067 /**
4068 * The base implementation of `setToString` without support for hot loop shorting.
4069 *
4070 * @private
4071 * @param {Function} func The function to modify.
4072 * @param {Function} string The `toString` result.
4073 * @returns {Function} Returns `func`.
4074 */
4075 var baseSetToString = !defineProperty ? identity : function(func, string) {
4076 return defineProperty(func, 'toString', {
4077 'configurable': true,
4078 'enumerable': false,
4079 'value': constant(string),
4080 'writable': true
4081 });
4082 };
4083
4084 /**
4085 * The base implementation of `_.shuffle`.
4086 *
4087 * @private
4088 * @param {Array|Object} collection The collection to shuffle.
4089 * @returns {Array} Returns the new shuffled array.
4090 */
4091 function baseShuffle(collection) {
4092 return shuffleSelf(values(collection));
4093 }
4094
4095 /**
4096 * The base implementation of `_.slice` without an iteratee call guard.
4097 *
4098 * @private
4099 * @param {Array} array The array to slice.
4100 * @param {number} [start=0] The start position.
4101 * @param {number} [end=array.length] The end position.
4102 * @returns {Array} Returns the slice of `array`.
4103 */
4104 function baseSlice(array, start, end) {
4105 var index = -1,
4106 length = array.length;
4107
4108 if (start < 0) {
4109 start = -start > length ? 0 : (length + start);
4110 }
4111 end = end > length ? length : end;
4112 if (end < 0) {
4113 end += length;
4114 }
4115 length = start > end ? 0 : ((end - start) >>> 0);
4116 start >>>= 0;
4117
4118 var result = Array(length);
4119 while (++index < length) {
4120 result[index] = array[index + start];
4121 }
4122 return result;
4123 }
4124
4125 /**
4126 * The base implementation of `_.some` without support for iteratee shorthands.
4127 *
4128 * @private
4129 * @param {Array|Object} collection The collection to iterate over.
4130 * @param {Function} predicate The function invoked per iteration.
4131 * @returns {boolean} Returns `true` if any element passes the predicate check,
4132 * else `false`.
4133 */
4134 function baseSome(collection, predicate) {
4135 var result;
4136
4137 baseEach(collection, function(value, index, collection) {
4138 result = predicate(value, index, collection);
4139 return !result;
4140 });
4141 return !!result;
4142 }
4143
4144 /**
4145 * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
4146 * performs a binary search of `array` to determine the index at which `value`
4147 * should be inserted into `array` in order to maintain its sort order.
4148 *
4149 * @private
4150 * @param {Array} array The sorted array to inspect.
4151 * @param {*} value The value to evaluate.
4152 * @param {boolean} [retHighest] Specify returning the highest qualified index.
4153 * @returns {number} Returns the index at which `value` should be inserted
4154 * into `array`.
4155 */
4156 function baseSortedIndex(array, value, retHighest) {
4157 var low = 0,
4158 high = array == null ? low : array.length;
4159
4160 if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
4161 while (low < high) {
4162 var mid = (low + high) >>> 1,
4163 computed = array[mid];
4164
4165 if (computed !== null && !isSymbol(computed) &&
4166 (retHighest ? (computed <= value) : (computed < value))) {
4167 low = mid + 1;
4168 } else {
4169 high = mid;
4170 }
4171 }
4172 return high;
4173 }
4174 return baseSortedIndexBy(array, value, identity, retHighest);
4175 }
4176
4177 /**
4178 * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
4179 * which invokes `iteratee` for `value` and each element of `array` to compute
4180 * their sort ranking. The iteratee is invoked with one argument; (value).
4181 *
4182 * @private
4183 * @param {Array} array The sorted array to inspect.
4184 * @param {*} value The value to evaluate.
4185 * @param {Function} iteratee The iteratee invoked per element.
4186 * @param {boolean} [retHighest] Specify returning the highest qualified index.
4187 * @returns {number} Returns the index at which `value` should be inserted
4188 * into `array`.
4189 */
4190 function baseSortedIndexBy(array, value, iteratee, retHighest) {
4191 var low = 0,
4192 high = array == null ? 0 : array.length;
4193 if (high === 0) {
4194 return 0;
4195 }
4196
4197 value = iteratee(value);
4198 var valIsNaN = value !== value,
4199 valIsNull = value === null,
4200 valIsSymbol = isSymbol(value),
4201 valIsUndefined = value === undefined;
4202
4203 while (low < high) {
4204 var mid = nativeFloor((low + high) / 2),
4205 computed = iteratee(array[mid]),
4206 othIsDefined = computed !== undefined,
4207 othIsNull = computed === null,
4208 othIsReflexive = computed === computed,
4209 othIsSymbol = isSymbol(computed);
4210
4211 if (valIsNaN) {
4212 var setLow = retHighest || othIsReflexive;
4213 } else if (valIsUndefined) {
4214 setLow = othIsReflexive && (retHighest || othIsDefined);
4215 } else if (valIsNull) {
4216 setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
4217 } else if (valIsSymbol) {
4218 setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
4219 } else if (othIsNull || othIsSymbol) {
4220 setLow = false;
4221 } else {
4222 setLow = retHighest ? (computed <= value) : (computed < value);
4223 }
4224 if (setLow) {
4225 low = mid + 1;
4226 } else {
4227 high = mid;
4228 }
4229 }
4230 return nativeMin(high, MAX_ARRAY_INDEX);
4231 }
4232
4233 /**
4234 * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
4235 * support for iteratee shorthands.
4236 *
4237 * @private
4238 * @param {Array} array The array to inspect.
4239 * @param {Function} [iteratee] The iteratee invoked per element.
4240 * @returns {Array} Returns the new duplicate free array.
4241 */
4242 function baseSortedUniq(array, iteratee) {
4243 var index = -1,
4244 length = array.length,
4245 resIndex = 0,
4246 result = [];
4247
4248 while (++index < length) {
4249 var value = array[index],
4250 computed = iteratee ? iteratee(value) : value;
4251
4252 if (!index || !eq(computed, seen)) {
4253 var seen = computed;
4254 result[resIndex++] = value === 0 ? 0 : value;
4255 }
4256 }
4257 return result;
4258 }
4259
4260 /**
4261 * The base implementation of `_.toNumber` which doesn't ensure correct
4262 * conversions of binary, hexadecimal, or octal string values.
4263 *
4264 * @private
4265 * @param {*} value The value to process.
4266 * @returns {number} Returns the number.
4267 */
4268 function baseToNumber(value) {
4269 if (typeof value == 'number') {
4270 return value;
4271 }
4272 if (isSymbol(value)) {
4273 return NAN;
4274 }
4275 return +value;
4276 }
4277
4278 /**
4279 * The base implementation of `_.toString` which doesn't convert nullish
4280 * values to empty strings.
4281 *
4282 * @private
4283 * @param {*} value The value to process.
4284 * @returns {string} Returns the string.
4285 */
4286 function baseToString(value) {
4287 // Exit early for strings to avoid a performance hit in some environments.
4288 if (typeof value == 'string') {
4289 return value;
4290 }
4291 if (isArray(value)) {
4292 // Recursively convert values (susceptible to call stack limits).
4293 return arrayMap(value, baseToString) + '';
4294 }
4295 if (isSymbol(value)) {
4296 return symbolToString ? symbolToString.call(value) : '';
4297 }
4298 var result = (value + '');
4299 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
4300 }
4301
4302 /**
4303 * The base implementation of `_.uniqBy` without support for iteratee shorthands.
4304 *
4305 * @private
4306 * @param {Array} array The array to inspect.
4307 * @param {Function} [iteratee] The iteratee invoked per element.
4308 * @param {Function} [comparator] The comparator invoked per element.
4309 * @returns {Array} Returns the new duplicate free array.
4310 */
4311 function baseUniq(array, iteratee, comparator) {
4312 var index = -1,
4313 includes = arrayIncludes,
4314 length = array.length,
4315 isCommon = true,
4316 result = [],
4317 seen = result;
4318
4319 if (comparator) {
4320 isCommon = false;
4321 includes = arrayIncludesWith;
4322 }
4323 else if (length >= LARGE_ARRAY_SIZE) {
4324 var set = iteratee ? null : createSet(array);
4325 if (set) {
4326 return setToArray(set);
4327 }
4328 isCommon = false;
4329 includes = cacheHas;
4330 seen = new SetCache;
4331 }
4332 else {
4333 seen = iteratee ? [] : result;
4334 }
4335 outer:
4336 while (++index < length) {
4337 var value = array[index],
4338 computed = iteratee ? iteratee(value) : value;
4339
4340 value = (comparator || value !== 0) ? value : 0;
4341 if (isCommon && computed === computed) {
4342 var seenIndex = seen.length;
4343 while (seenIndex--) {
4344 if (seen[seenIndex] === computed) {
4345 continue outer;
4346 }
4347 }
4348 if (iteratee) {
4349 seen.push(computed);
4350 }
4351 result.push(value);
4352 }
4353 else if (!includes(seen, computed, comparator)) {
4354 if (seen !== result) {
4355 seen.push(computed);
4356 }
4357 result.push(value);
4358 }
4359 }
4360 return result;
4361 }
4362
4363 /**
4364 * The base implementation of `_.unset`.
4365 *
4366 * @private
4367 * @param {Object} object The object to modify.
4368 * @param {Array|string} path The property path to unset.
4369 * @returns {boolean} Returns `true` if the property is deleted, else `false`.
4370 */
4371 function baseUnset(object, path) {
4372 path = castPath(path, object);
4373 object = parent(object, path);
4374 return object == null || delete object[toKey(last(path))];
4375 }
4376
4377 /**
4378 * The base implementation of `_.update`.
4379 *
4380 * @private
4381 * @param {Object} object The object to modify.
4382 * @param {Array|string} path The path of the property to update.
4383 * @param {Function} updater The function to produce the updated value.
4384 * @param {Function} [customizer] The function to customize path creation.
4385 * @returns {Object} Returns `object`.
4386 */
4387 function baseUpdate(object, path, updater, customizer) {
4388 return baseSet(object, path, updater(baseGet(object, path)), customizer);
4389 }
4390
4391 /**
4392 * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
4393 * without support for iteratee shorthands.
4394 *
4395 * @private
4396 * @param {Array} array The array to query.
4397 * @param {Function} predicate The function invoked per iteration.
4398 * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
4399 * @param {boolean} [fromRight] Specify iterating from right to left.
4400 * @returns {Array} Returns the slice of `array`.
4401 */
4402 function baseWhile(array, predicate, isDrop, fromRight) {
4403 var length = array.length,
4404 index = fromRight ? length : -1;
4405
4406 while ((fromRight ? index-- : ++index < length) &&
4407 predicate(array[index], index, array)) {}
4408
4409 return isDrop
4410 ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
4411 : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
4412 }
4413
4414 /**
4415 * The base implementation of `wrapperValue` which returns the result of
4416 * performing a sequence of actions on the unwrapped `value`, where each
4417 * successive action is supplied the return value of the previous.
4418 *
4419 * @private
4420 * @param {*} value The unwrapped value.
4421 * @param {Array} actions Actions to perform to resolve the unwrapped value.
4422 * @returns {*} Returns the resolved value.
4423 */
4424 function baseWrapperValue(value, actions) {
4425 var result = value;
4426 if (result instanceof LazyWrapper) {
4427 result = result.value();
4428 }
4429 return arrayReduce(actions, function(result, action) {
4430 return action.func.apply(action.thisArg, arrayPush([result], action.args));
4431 }, result);
4432 }
4433
4434 /**
4435 * The base implementation of methods like `_.xor`, without support for
4436 * iteratee shorthands, that accepts an array of arrays to inspect.
4437 *
4438 * @private
4439 * @param {Array} arrays The arrays to inspect.
4440 * @param {Function} [iteratee] The iteratee invoked per element.
4441 * @param {Function} [comparator] The comparator invoked per element.
4442 * @returns {Array} Returns the new array of values.
4443 */
4444 function baseXor(arrays, iteratee, comparator) {
4445 var length = arrays.length;
4446 if (length < 2) {
4447 return length ? baseUniq(arrays[0]) : [];
4448 }
4449 var index = -1,
4450 result = Array(length);
4451
4452 while (++index < length) {
4453 var array = arrays[index],
4454 othIndex = -1;
4455
4456 while (++othIndex < length) {
4457 if (othIndex != index) {
4458 result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
4459 }
4460 }
4461 }
4462 return baseUniq(baseFlatten(result, 1), iteratee, comparator);
4463 }
4464
4465 /**
4466 * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
4467 *
4468 * @private
4469 * @param {Array} props The property identifiers.
4470 * @param {Array} values The property values.
4471 * @param {Function} assignFunc The function to assign values.
4472 * @returns {Object} Returns the new object.
4473 */
4474 function baseZipObject(props, values, assignFunc) {
4475 var index = -1,
4476 length = props.length,
4477 valsLength = values.length,
4478 result = {};
4479
4480 while (++index < length) {
4481 var value = index < valsLength ? values[index] : undefined;
4482 assignFunc(result, props[index], value);
4483 }
4484 return result;
4485 }
4486
4487 /**
4488 * Casts `value` to an empty array if it's not an array like object.
4489 *
4490 * @private
4491 * @param {*} value The value to inspect.
4492 * @returns {Array|Object} Returns the cast array-like object.
4493 */
4494 function castArrayLikeObject(value) {
4495 return isArrayLikeObject(value) ? value : [];
4496 }
4497
4498 /**
4499 * Casts `value` to `identity` if it's not a function.
4500 *
4501 * @private
4502 * @param {*} value The value to inspect.
4503 * @returns {Function} Returns cast function.
4504 */
4505 function castFunction(value) {
4506 return typeof value == 'function' ? value : identity;
4507 }
4508
4509 /**
4510 * Casts `value` to a path array if it's not one.
4511 *
4512 * @private
4513 * @param {*} value The value to inspect.
4514 * @param {Object} [object] The object to query keys on.
4515 * @returns {Array} Returns the cast property path array.
4516 */
4517 function castPath(value, object) {
4518 if (isArray(value)) {
4519 return value;
4520 }
4521 return isKey(value, object) ? [value] : stringToPath(toString(value));
4522 }
4523
4524 /**
4525 * A `baseRest` alias which can be replaced with `identity` by module
4526 * replacement plugins.
4527 *
4528 * @private
4529 * @type {Function}
4530 * @param {Function} func The function to apply a rest parameter to.
4531 * @returns {Function} Returns the new function.
4532 */
4533 var castRest = baseRest;
4534
4535 /**
4536 * Casts `array` to a slice if it's needed.
4537 *
4538 * @private
4539 * @param {Array} array The array to inspect.
4540 * @param {number} start The start position.
4541 * @param {number} [end=array.length] The end position.
4542 * @returns {Array} Returns the cast slice.
4543 */
4544 function castSlice(array, start, end) {
4545 var length = array.length;
4546 end = end === undefined ? length : end;
4547 return (!start && end >= length) ? array : baseSlice(array, start, end);
4548 }
4549
4550 /**
4551 * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
4552 *
4553 * @private
4554 * @param {number|Object} id The timer id or timeout object of the timer to clear.
4555 */
4556 var clearTimeout = ctxClearTimeout || function(id) {
4557 return root.clearTimeout(id);
4558 };
4559
4560 /**
4561 * Creates a clone of `buffer`.
4562 *
4563 * @private
4564 * @param {Buffer} buffer The buffer to clone.
4565 * @param {boolean} [isDeep] Specify a deep clone.
4566 * @returns {Buffer} Returns the cloned buffer.
4567 */
4568 function cloneBuffer(buffer, isDeep) {
4569 if (isDeep) {
4570 return buffer.slice();
4571 }
4572 var length = buffer.length,
4573 result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
4574
4575 buffer.copy(result);
4576 return result;
4577 }
4578
4579 /**
4580 * Creates a clone of `arrayBuffer`.
4581 *
4582 * @private
4583 * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
4584 * @returns {ArrayBuffer} Returns the cloned array buffer.
4585 */
4586 function cloneArrayBuffer(arrayBuffer) {
4587 var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
4588 new Uint8Array(result).set(new Uint8Array(arrayBuffer));
4589 return result;
4590 }
4591
4592 /**
4593 * Creates a clone of `dataView`.
4594 *
4595 * @private
4596 * @param {Object} dataView The data view to clone.
4597 * @param {boolean} [isDeep] Specify a deep clone.
4598 * @returns {Object} Returns the cloned data view.
4599 */
4600 function cloneDataView(dataView, isDeep) {
4601 var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
4602 return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
4603 }
4604
4605 /**
4606 * Creates a clone of `regexp`.
4607 *
4608 * @private
4609 * @param {Object} regexp The regexp to clone.
4610 * @returns {Object} Returns the cloned regexp.
4611 */
4612 function cloneRegExp(regexp) {
4613 var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
4614 result.lastIndex = regexp.lastIndex;
4615 return result;
4616 }
4617
4618 /**
4619 * Creates a clone of the `symbol` object.
4620 *
4621 * @private
4622 * @param {Object} symbol The symbol object to clone.
4623 * @returns {Object} Returns the cloned symbol object.
4624 */
4625 function cloneSymbol(symbol) {
4626 return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
4627 }
4628
4629 /**
4630 * Creates a clone of `typedArray`.
4631 *
4632 * @private
4633 * @param {Object} typedArray The typed array to clone.
4634 * @param {boolean} [isDeep] Specify a deep clone.
4635 * @returns {Object} Returns the cloned typed array.
4636 */
4637 function cloneTypedArray(typedArray, isDeep) {
4638 var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
4639 return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
4640 }
4641
4642 /**
4643 * Compares values to sort them in ascending order.
4644 *
4645 * @private
4646 * @param {*} value The value to compare.
4647 * @param {*} other The other value to compare.
4648 * @returns {number} Returns the sort order indicator for `value`.
4649 */
4650 function compareAscending(value, other) {
4651 if (value !== other) {
4652 var valIsDefined = value !== undefined,
4653 valIsNull = value === null,
4654 valIsReflexive = value === value,
4655 valIsSymbol = isSymbol(value);
4656
4657 var othIsDefined = other !== undefined,
4658 othIsNull = other === null,
4659 othIsReflexive = other === other,
4660 othIsSymbol = isSymbol(other);
4661
4662 if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
4663 (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
4664 (valIsNull && othIsDefined && othIsReflexive) ||
4665 (!valIsDefined && othIsReflexive) ||
4666 !valIsReflexive) {
4667 return 1;
4668 }
4669 if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
4670 (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
4671 (othIsNull && valIsDefined && valIsReflexive) ||
4672 (!othIsDefined && valIsReflexive) ||
4673 !othIsReflexive) {
4674 return -1;
4675 }
4676 }
4677 return 0;
4678 }
4679
4680 /**
4681 * Used by `_.orderBy` to compare multiple properties of a value to another
4682 * and stable sort them.
4683 *
4684 * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
4685 * specify an order of "desc" for descending or "asc" for ascending sort order
4686 * of corresponding values.
4687 *
4688 * @private
4689 * @param {Object} object The object to compare.
4690 * @param {Object} other The other object to compare.
4691 * @param {boolean[]|string[]} orders The order to sort by for each property.
4692 * @returns {number} Returns the sort order indicator for `object`.
4693 */
4694 function compareMultiple(object, other, orders) {
4695 var index = -1,
4696 objCriteria = object.criteria,
4697 othCriteria = other.criteria,
4698 length = objCriteria.length,
4699 ordersLength = orders.length;
4700
4701 while (++index < length) {
4702 var result = compareAscending(objCriteria[index], othCriteria[index]);
4703 if (result) {
4704 if (index >= ordersLength) {
4705 return result;
4706 }
4707 var order = orders[index];
4708 return result * (order == 'desc' ? -1 : 1);
4709 }
4710 }
4711 // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
4712 // that causes it, under certain circumstances, to provide the same value for
4713 // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
4714 // for more details.
4715 //
4716 // This also ensures a stable sort in V8 and other engines.
4717 // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
4718 return object.index - other.index;
4719 }
4720
4721 /**
4722 * Creates an array that is the composition of partially applied arguments,
4723 * placeholders, and provided arguments into a single array of arguments.
4724 *
4725 * @private
4726 * @param {Array} args The provided arguments.
4727 * @param {Array} partials The arguments to prepend to those provided.
4728 * @param {Array} holders The `partials` placeholder indexes.
4729 * @params {boolean} [isCurried] Specify composing for a curried function.
4730 * @returns {Array} Returns the new array of composed arguments.
4731 */
4732 function composeArgs(args, partials, holders, isCurried) {
4733 var argsIndex = -1,
4734 argsLength = args.length,
4735 holdersLength = holders.length,
4736 leftIndex = -1,
4737 leftLength = partials.length,
4738 rangeLength = nativeMax(argsLength - holdersLength, 0),
4739 result = Array(leftLength + rangeLength),
4740 isUncurried = !isCurried;
4741
4742 while (++leftIndex < leftLength) {
4743 result[leftIndex] = partials[leftIndex];
4744 }
4745 while (++argsIndex < holdersLength) {
4746 if (isUncurried || argsIndex < argsLength) {
4747 result[holders[argsIndex]] = args[argsIndex];
4748 }
4749 }
4750 while (rangeLength--) {
4751 result[leftIndex++] = args[argsIndex++];
4752 }
4753 return result;
4754 }
4755
4756 /**
4757 * This function is like `composeArgs` except that the arguments composition
4758 * is tailored for `_.partialRight`.
4759 *
4760 * @private
4761 * @param {Array} args The provided arguments.
4762 * @param {Array} partials The arguments to append to those provided.
4763 * @param {Array} holders The `partials` placeholder indexes.
4764 * @params {boolean} [isCurried] Specify composing for a curried function.
4765 * @returns {Array} Returns the new array of composed arguments.
4766 */
4767 function composeArgsRight(args, partials, holders, isCurried) {
4768 var argsIndex = -1,
4769 argsLength = args.length,
4770 holdersIndex = -1,
4771 holdersLength = holders.length,
4772 rightIndex = -1,
4773 rightLength = partials.length,
4774 rangeLength = nativeMax(argsLength - holdersLength, 0),
4775 result = Array(rangeLength + rightLength),
4776 isUncurried = !isCurried;
4777
4778 while (++argsIndex < rangeLength) {
4779 result[argsIndex] = args[argsIndex];
4780 }
4781 var offset = argsIndex;
4782 while (++rightIndex < rightLength) {
4783 result[offset + rightIndex] = partials[rightIndex];
4784 }
4785 while (++holdersIndex < holdersLength) {
4786 if (isUncurried || argsIndex < argsLength) {
4787 result[offset + holders[holdersIndex]] = args[argsIndex++];
4788 }
4789 }
4790 return result;
4791 }
4792
4793 /**
4794 * Copies the values of `source` to `array`.
4795 *
4796 * @private
4797 * @param {Array} source The array to copy values from.
4798 * @param {Array} [array=[]] The array to copy values to.
4799 * @returns {Array} Returns `array`.
4800 */
4801 function copyArray(source, array) {
4802 var index = -1,
4803 length = source.length;
4804
4805 array || (array = Array(length));
4806 while (++index < length) {
4807 array[index] = source[index];
4808 }
4809 return array;
4810 }
4811
4812 /**
4813 * Copies properties of `source` to `object`.
4814 *
4815 * @private
4816 * @param {Object} source The object to copy properties from.
4817 * @param {Array} props The property identifiers to copy.
4818 * @param {Object} [object={}] The object to copy properties to.
4819 * @param {Function} [customizer] The function to customize copied values.
4820 * @returns {Object} Returns `object`.
4821 */
4822 function copyObject(source, props, object, customizer) {
4823 var isNew = !object;
4824 object || (object = {});
4825
4826 var index = -1,
4827 length = props.length;
4828
4829 while (++index < length) {
4830 var key = props[index];
4831
4832 var newValue = customizer
4833 ? customizer(object[key], source[key], key, object, source)
4834 : undefined;
4835
4836 if (newValue === undefined) {
4837 newValue = source[key];
4838 }
4839 if (isNew) {
4840 baseAssignValue(object, key, newValue);
4841 } else {
4842 assignValue(object, key, newValue);
4843 }
4844 }
4845 return object;
4846 }
4847
4848 /**
4849 * Copies own symbols of `source` to `object`.
4850 *
4851 * @private
4852 * @param {Object} source The object to copy symbols from.
4853 * @param {Object} [object={}] The object to copy symbols to.
4854 * @returns {Object} Returns `object`.
4855 */
4856 function copySymbols(source, object) {
4857 return copyObject(source, getSymbols(source), object);
4858 }
4859
4860 /**
4861 * Copies own and inherited symbols of `source` to `object`.
4862 *
4863 * @private
4864 * @param {Object} source The object to copy symbols from.
4865 * @param {Object} [object={}] The object to copy symbols to.
4866 * @returns {Object} Returns `object`.
4867 */
4868 function copySymbolsIn(source, object) {
4869 return copyObject(source, getSymbolsIn(source), object);
4870 }
4871
4872 /**
4873 * Creates a function like `_.groupBy`.
4874 *
4875 * @private
4876 * @param {Function} setter The function to set accumulator values.
4877 * @param {Function} [initializer] The accumulator object initializer.
4878 * @returns {Function} Returns the new aggregator function.
4879 */
4880 function createAggregator(setter, initializer) {
4881 return function(collection, iteratee) {
4882 var func = isArray(collection) ? arrayAggregator : baseAggregator,
4883 accumulator = initializer ? initializer() : {};
4884
4885 return func(collection, setter, getIteratee(iteratee, 2), accumulator);
4886 };
4887 }
4888
4889 /**
4890 * Creates a function like `_.assign`.
4891 *
4892 * @private
4893 * @param {Function} assigner The function to assign values.
4894 * @returns {Function} Returns the new assigner function.
4895 */
4896 function createAssigner(assigner) {
4897 return baseRest(function(object, sources) {
4898 var index = -1,
4899 length = sources.length,
4900 customizer = length > 1 ? sources[length - 1] : undefined,
4901 guard = length > 2 ? sources[2] : undefined;
4902
4903 customizer = (assigner.length > 3 && typeof customizer == 'function')
4904 ? (length--, customizer)
4905 : undefined;
4906
4907 if (guard && isIterateeCall(sources[0], sources[1], guard)) {
4908 customizer = length < 3 ? undefined : customizer;
4909 length = 1;
4910 }
4911 object = Object(object);
4912 while (++index < length) {
4913 var source = sources[index];
4914 if (source) {
4915 assigner(object, source, index, customizer);
4916 }
4917 }
4918 return object;
4919 });
4920 }
4921
4922 /**
4923 * Creates a `baseEach` or `baseEachRight` function.
4924 *
4925 * @private
4926 * @param {Function} eachFunc The function to iterate over a collection.
4927 * @param {boolean} [fromRight] Specify iterating from right to left.
4928 * @returns {Function} Returns the new base function.
4929 */
4930 function createBaseEach(eachFunc, fromRight) {
4931 return function(collection, iteratee) {
4932 if (collection == null) {
4933 return collection;
4934 }
4935 if (!isArrayLike(collection)) {
4936 return eachFunc(collection, iteratee);
4937 }
4938 var length = collection.length,
4939 index = fromRight ? length : -1,
4940 iterable = Object(collection);
4941
4942 while ((fromRight ? index-- : ++index < length)) {
4943 if (iteratee(iterable[index], index, iterable) === false) {
4944 break;
4945 }
4946 }
4947 return collection;
4948 };
4949 }
4950
4951 /**
4952 * Creates a base function for methods like `_.forIn` and `_.forOwn`.
4953 *
4954 * @private
4955 * @param {boolean} [fromRight] Specify iterating from right to left.
4956 * @returns {Function} Returns the new base function.
4957 */
4958 function createBaseFor(fromRight) {
4959 return function(object, iteratee, keysFunc) {
4960 var index = -1,
4961 iterable = Object(object),
4962 props = keysFunc(object),
4963 length = props.length;
4964
4965 while (length--) {
4966 var key = props[fromRight ? length : ++index];
4967 if (iteratee(iterable[key], key, iterable) === false) {
4968 break;
4969 }
4970 }
4971 return object;
4972 };
4973 }
4974
4975 /**
4976 * Creates a function that wraps `func` to invoke it with the optional `this`
4977 * binding of `thisArg`.
4978 *
4979 * @private
4980 * @param {Function} func The function to wrap.
4981 * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
4982 * @param {*} [thisArg] The `this` binding of `func`.
4983 * @returns {Function} Returns the new wrapped function.
4984 */
4985 function createBind(func, bitmask, thisArg) {
4986 var isBind = bitmask & WRAP_BIND_FLAG,
4987 Ctor = createCtor(func);
4988
4989 function wrapper() {
4990 var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
4991 return fn.apply(isBind ? thisArg : this, arguments);
4992 }
4993 return wrapper;
4994 }
4995
4996 /**
4997 * Creates a function like `_.lowerFirst`.
4998 *
4999 * @private
5000 * @param {string} methodName The name of the `String` case method to use.
5001 * @returns {Function} Returns the new case function.
5002 */
5003 function createCaseFirst(methodName) {
5004 return function(string) {
5005 string = toString(string);
5006
5007 var strSymbols = hasUnicode(string)
5008 ? stringToArray(string)
5009 : undefined;
5010
5011 var chr = strSymbols
5012 ? strSymbols[0]
5013 : string.charAt(0);
5014
5015 var trailing = strSymbols
5016 ? castSlice(strSymbols, 1).join('')
5017 : string.slice(1);
5018
5019 return chr[methodName]() + trailing;
5020 };
5021 }
5022
5023 /**
5024 * Creates a function like `_.camelCase`.
5025 *
5026 * @private
5027 * @param {Function} callback The function to combine each word.
5028 * @returns {Function} Returns the new compounder function.
5029 */
5030 function createCompounder(callback) {
5031 return function(string) {
5032 return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
5033 };
5034 }
5035
5036 /**
5037 * Creates a function that produces an instance of `Ctor` regardless of
5038 * whether it was invoked as part of a `new` expression or by `call` or `apply`.
5039 *
5040 * @private
5041 * @param {Function} Ctor The constructor to wrap.
5042 * @returns {Function} Returns the new wrapped function.
5043 */
5044 function createCtor(Ctor) {
5045 return function() {
5046 // Use a `switch` statement to work with class constructors. See
5047 // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
5048 // for more details.
5049 var args = arguments;
5050 switch (args.length) {
5051 case 0: return new Ctor;
5052 case 1: return new Ctor(args[0]);
5053 case 2: return new Ctor(args[0], args[1]);
5054 case 3: return new Ctor(args[0], args[1], args[2]);
5055 case 4: return new Ctor(args[0], args[1], args[2], args[3]);
5056 case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
5057 case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
5058 case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
5059 }
5060 var thisBinding = baseCreate(Ctor.prototype),
5061 result = Ctor.apply(thisBinding, args);
5062
5063 // Mimic the constructor's `return` behavior.
5064 // See https://es5.github.io/#x13.2.2 for more details.
5065 return isObject(result) ? result : thisBinding;
5066 };
5067 }
5068
5069 /**
5070 * Creates a function that wraps `func` to enable currying.
5071 *
5072 * @private
5073 * @param {Function} func The function to wrap.
5074 * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5075 * @param {number} arity The arity of `func`.
5076 * @returns {Function} Returns the new wrapped function.
5077 */
5078 function createCurry(func, bitmask, arity) {
5079 var Ctor = createCtor(func);
5080
5081 function wrapper() {
5082 var length = arguments.length,
5083 args = Array(length),
5084 index = length,
5085 placeholder = getHolder(wrapper);
5086
5087 while (index--) {
5088 args[index] = arguments[index];
5089 }
5090 var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
5091 ? []
5092 : replaceHolders(args, placeholder);
5093
5094 length -= holders.length;
5095 if (length < arity) {
5096 return createRecurry(
5097 func, bitmask, createHybrid, wrapper.placeholder, undefined,
5098 args, holders, undefined, undefined, arity - length);
5099 }
5100 var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
5101 return apply(fn, this, args);
5102 }
5103 return wrapper;
5104 }
5105
5106 /**
5107 * Creates a `_.find` or `_.findLast` function.
5108 *
5109 * @private
5110 * @param {Function} findIndexFunc The function to find the collection index.
5111 * @returns {Function} Returns the new find function.
5112 */
5113 function createFind(findIndexFunc) {
5114 return function(collection, predicate, fromIndex) {
5115 var iterable = Object(collection);
5116 if (!isArrayLike(collection)) {
5117 var iteratee = getIteratee(predicate, 3);
5118 collection = keys(collection);
5119 predicate = function(key) { return iteratee(iterable[key], key, iterable); };
5120 }
5121 var index = findIndexFunc(collection, predicate, fromIndex);
5122 return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
5123 };
5124 }
5125
5126 /**
5127 * Creates a `_.flow` or `_.flowRight` function.
5128 *
5129 * @private
5130 * @param {boolean} [fromRight] Specify iterating from right to left.
5131 * @returns {Function} Returns the new flow function.
5132 */
5133 function createFlow(fromRight) {
5134 return flatRest(function(funcs) {
5135 var length = funcs.length,
5136 index = length,
5137 prereq = LodashWrapper.prototype.thru;
5138
5139 if (fromRight) {
5140 funcs.reverse();
5141 }
5142 while (index--) {
5143 var func = funcs[index];
5144 if (typeof func != 'function') {
5145 throw new TypeError(FUNC_ERROR_TEXT);
5146 }
5147 if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
5148 var wrapper = new LodashWrapper([], true);
5149 }
5150 }
5151 index = wrapper ? index : length;
5152 while (++index < length) {
5153 func = funcs[index];
5154
5155 var funcName = getFuncName(func),
5156 data = funcName == 'wrapper' ? getData(func) : undefined;
5157
5158 if (data && isLaziable(data[0]) &&
5159 data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
5160 !data[4].length && data[9] == 1
5161 ) {
5162 wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
5163 } else {
5164 wrapper = (func.length == 1 && isLaziable(func))
5165 ? wrapper[funcName]()
5166 : wrapper.thru(func);
5167 }
5168 }
5169 return function() {
5170 var args = arguments,
5171 value = args[0];
5172
5173 if (wrapper && args.length == 1 && isArray(value)) {
5174 return wrapper.plant(value).value();
5175 }
5176 var index = 0,
5177 result = length ? funcs[index].apply(this, args) : value;
5178
5179 while (++index < length) {
5180 result = funcs[index].call(this, result);
5181 }
5182 return result;
5183 };
5184 });
5185 }
5186
5187 /**
5188 * Creates a function that wraps `func` to invoke it with optional `this`
5189 * binding of `thisArg`, partial application, and currying.
5190 *
5191 * @private
5192 * @param {Function|string} func The function or method name to wrap.
5193 * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5194 * @param {*} [thisArg] The `this` binding of `func`.
5195 * @param {Array} [partials] The arguments to prepend to those provided to
5196 * the new function.
5197 * @param {Array} [holders] The `partials` placeholder indexes.
5198 * @param {Array} [partialsRight] The arguments to append to those provided
5199 * to the new function.
5200 * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
5201 * @param {Array} [argPos] The argument positions of the new function.
5202 * @param {number} [ary] The arity cap of `func`.
5203 * @param {number} [arity] The arity of `func`.
5204 * @returns {Function} Returns the new wrapped function.
5205 */
5206 function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
5207 var isAry = bitmask & WRAP_ARY_FLAG,
5208 isBind = bitmask & WRAP_BIND_FLAG,
5209 isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
5210 isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
5211 isFlip = bitmask & WRAP_FLIP_FLAG,
5212 Ctor = isBindKey ? undefined : createCtor(func);
5213
5214 function wrapper() {
5215 var length = arguments.length,
5216 args = Array(length),
5217 index = length;
5218
5219 while (index--) {
5220 args[index] = arguments[index];
5221 }
5222 if (isCurried) {
5223 var placeholder = getHolder(wrapper),
5224 holdersCount = countHolders(args, placeholder);
5225 }
5226 if (partials) {
5227 args = composeArgs(args, partials, holders, isCurried);
5228 }
5229 if (partialsRight) {
5230 args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
5231 }
5232 length -= holdersCount;
5233 if (isCurried && length < arity) {
5234 var newHolders = replaceHolders(args, placeholder);
5235 return createRecurry(
5236 func, bitmask, createHybrid, wrapper.placeholder, thisArg,
5237 args, newHolders, argPos, ary, arity - length
5238 );
5239 }
5240 var thisBinding = isBind ? thisArg : this,
5241 fn = isBindKey ? thisBinding[func] : func;
5242
5243 length = args.length;
5244 if (argPos) {
5245 args = reorder(args, argPos);
5246 } else if (isFlip && length > 1) {
5247 args.reverse();
5248 }
5249 if (isAry && ary < length) {
5250 args.length = ary;
5251 }
5252 if (this && this !== root && this instanceof wrapper) {
5253 fn = Ctor || createCtor(fn);
5254 }
5255 return fn.apply(thisBinding, args);
5256 }
5257 return wrapper;
5258 }
5259
5260 /**
5261 * Creates a function like `_.invertBy`.
5262 *
5263 * @private
5264 * @param {Function} setter The function to set accumulator values.
5265 * @param {Function} toIteratee The function to resolve iteratees.
5266 * @returns {Function} Returns the new inverter function.
5267 */
5268 function createInverter(setter, toIteratee) {
5269 return function(object, iteratee) {
5270 return baseInverter(object, setter, toIteratee(iteratee), {});
5271 };
5272 }
5273
5274 /**
5275 * Creates a function that performs a mathematical operation on two values.
5276 *
5277 * @private
5278 * @param {Function} operator The function to perform the operation.
5279 * @param {number} [defaultValue] The value used for `undefined` arguments.
5280 * @returns {Function} Returns the new mathematical operation function.
5281 */
5282 function createMathOperation(operator, defaultValue) {
5283 return function(value, other) {
5284 var result;
5285 if (value === undefined && other === undefined) {
5286 return defaultValue;
5287 }
5288 if (value !== undefined) {
5289 result = value;
5290 }
5291 if (other !== undefined) {
5292 if (result === undefined) {
5293 return other;
5294 }
5295 if (typeof value == 'string' || typeof other == 'string') {
5296 value = baseToString(value);
5297 other = baseToString(other);
5298 } else {
5299 value = baseToNumber(value);
5300 other = baseToNumber(other);
5301 }
5302 result = operator(value, other);
5303 }
5304 return result;
5305 };
5306 }
5307
5308 /**
5309 * Creates a function like `_.over`.
5310 *
5311 * @private
5312 * @param {Function} arrayFunc The function to iterate over iteratees.
5313 * @returns {Function} Returns the new over function.
5314 */
5315 function createOver(arrayFunc) {
5316 return flatRest(function(iteratees) {
5317 iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
5318 return baseRest(function(args) {
5319 var thisArg = this;
5320 return arrayFunc(iteratees, function(iteratee) {
5321 return apply(iteratee, thisArg, args);
5322 });
5323 });
5324 });
5325 }
5326
5327 /**
5328 * Creates the padding for `string` based on `length`. The `chars` string
5329 * is truncated if the number of characters exceeds `length`.
5330 *
5331 * @private
5332 * @param {number} length The padding length.
5333 * @param {string} [chars=' '] The string used as padding.
5334 * @returns {string} Returns the padding for `string`.
5335 */
5336 function createPadding(length, chars) {
5337 chars = chars === undefined ? ' ' : baseToString(chars);
5338
5339 var charsLength = chars.length;
5340 if (charsLength < 2) {
5341 return charsLength ? baseRepeat(chars, length) : chars;
5342 }
5343 var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
5344 return hasUnicode(chars)
5345 ? castSlice(stringToArray(result), 0, length).join('')
5346 : result.slice(0, length);
5347 }
5348
5349 /**
5350 * Creates a function that wraps `func` to invoke it with the `this` binding
5351 * of `thisArg` and `partials` prepended to the arguments it receives.
5352 *
5353 * @private
5354 * @param {Function} func The function to wrap.
5355 * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5356 * @param {*} thisArg The `this` binding of `func`.
5357 * @param {Array} partials The arguments to prepend to those provided to
5358 * the new function.
5359 * @returns {Function} Returns the new wrapped function.
5360 */
5361 function createPartial(func, bitmask, thisArg, partials) {
5362 var isBind = bitmask & WRAP_BIND_FLAG,
5363 Ctor = createCtor(func);
5364
5365 function wrapper() {
5366 var argsIndex = -1,
5367 argsLength = arguments.length,
5368 leftIndex = -1,
5369 leftLength = partials.length,
5370 args = Array(leftLength + argsLength),
5371 fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
5372
5373 while (++leftIndex < leftLength) {
5374 args[leftIndex] = partials[leftIndex];
5375 }
5376 while (argsLength--) {
5377 args[leftIndex++] = arguments[++argsIndex];
5378 }
5379 return apply(fn, isBind ? thisArg : this, args);
5380 }
5381 return wrapper;
5382 }
5383
5384 /**
5385 * Creates a `_.range` or `_.rangeRight` function.
5386 *
5387 * @private
5388 * @param {boolean} [fromRight] Specify iterating from right to left.
5389 * @returns {Function} Returns the new range function.
5390 */
5391 function createRange(fromRight) {
5392 return function(start, end, step) {
5393 if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
5394 end = step = undefined;
5395 }
5396 // Ensure the sign of `-0` is preserved.
5397 start = toFinite(start);
5398 if (end === undefined) {
5399 end = start;
5400 start = 0;
5401 } else {
5402 end = toFinite(end);
5403 }
5404 step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
5405 return baseRange(start, end, step, fromRight);
5406 };
5407 }
5408
5409 /**
5410 * Creates a function that performs a relational operation on two values.
5411 *
5412 * @private
5413 * @param {Function} operator The function to perform the operation.
5414 * @returns {Function} Returns the new relational operation function.
5415 */
5416 function createRelationalOperation(operator) {
5417 return function(value, other) {
5418 if (!(typeof value == 'string' && typeof other == 'string')) {
5419 value = toNumber(value);
5420 other = toNumber(other);
5421 }
5422 return operator(value, other);
5423 };
5424 }
5425
5426 /**
5427 * Creates a function that wraps `func` to continue currying.
5428 *
5429 * @private
5430 * @param {Function} func The function to wrap.
5431 * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
5432 * @param {Function} wrapFunc The function to create the `func` wrapper.
5433 * @param {*} placeholder The placeholder value.
5434 * @param {*} [thisArg] The `this` binding of `func`.
5435 * @param {Array} [partials] The arguments to prepend to those provided to
5436 * the new function.
5437 * @param {Array} [holders] The `partials` placeholder indexes.
5438 * @param {Array} [argPos] The argument positions of the new function.
5439 * @param {number} [ary] The arity cap of `func`.
5440 * @param {number} [arity] The arity of `func`.
5441 * @returns {Function} Returns the new wrapped function.
5442 */
5443 function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
5444 var isCurry = bitmask & WRAP_CURRY_FLAG,
5445 newHolders = isCurry ? holders : undefined,
5446 newHoldersRight = isCurry ? undefined : holders,
5447 newPartials = isCurry ? partials : undefined,
5448 newPartialsRight = isCurry ? undefined : partials;
5449
5450 bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
5451 bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
5452
5453 if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
5454 bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
5455 }
5456 var newData = [
5457 func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
5458 newHoldersRight, argPos, ary, arity
5459 ];
5460
5461 var result = wrapFunc.apply(undefined, newData);
5462 if (isLaziable(func)) {
5463 setData(result, newData);
5464 }
5465 result.placeholder = placeholder;
5466 return setWrapToString(result, func, bitmask);
5467 }
5468
5469 /**
5470 * Creates a function like `_.round`.
5471 *
5472 * @private
5473 * @param {string} methodName The name of the `Math` method to use when rounding.
5474 * @returns {Function} Returns the new round function.
5475 */
5476 function createRound(methodName) {
5477 var func = Math[methodName];
5478 return function(number, precision) {
5479 number = toNumber(number);
5480 precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
5481 if (precision && nativeIsFinite(number)) {
5482 // Shift with exponential notation to avoid floating-point issues.
5483 // See [MDN](https://mdn.io/round#Examples) for more details.
5484 var pair = (toString(number) + 'e').split('e'),
5485 value = func(pair[0] + 'e' + (+pair[1] + precision));
5486
5487 pair = (toString(value) + 'e').split('e');
5488 return +(pair[0] + 'e' + (+pair[1] - precision));
5489 }
5490 return func(number);
5491 };
5492 }
5493
5494 /**
5495 * Creates a set object of `values`.
5496 *
5497 * @private
5498 * @param {Array} values The values to add to the set.
5499 * @returns {Object} Returns the new set.
5500 */
5501 var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
5502 return new Set(values);
5503 };
5504
5505 /**
5506 * Creates a `_.toPairs` or `_.toPairsIn` function.
5507 *
5508 * @private
5509 * @param {Function} keysFunc The function to get the keys of a given object.
5510 * @returns {Function} Returns the new pairs function.
5511 */
5512 function createToPairs(keysFunc) {
5513 return function(object) {
5514 var tag = getTag(object);
5515 if (tag == mapTag) {
5516 return mapToArray(object);
5517 }
5518 if (tag == setTag) {
5519 return setToPairs(object);
5520 }
5521 return baseToPairs(object, keysFunc(object));
5522 };
5523 }
5524
5525 /**
5526 * Creates a function that either curries or invokes `func` with optional
5527 * `this` binding and partially applied arguments.
5528 *
5529 * @private
5530 * @param {Function|string} func The function or method name to wrap.
5531 * @param {number} bitmask The bitmask flags.
5532 * 1 - `_.bind`
5533 * 2 - `_.bindKey`
5534 * 4 - `_.curry` or `_.curryRight` of a bound function
5535 * 8 - `_.curry`
5536 * 16 - `_.curryRight`
5537 * 32 - `_.partial`
5538 * 64 - `_.partialRight`
5539 * 128 - `_.rearg`
5540 * 256 - `_.ary`
5541 * 512 - `_.flip`
5542 * @param {*} [thisArg] The `this` binding of `func`.
5543 * @param {Array} [partials] The arguments to be partially applied.
5544 * @param {Array} [holders] The `partials` placeholder indexes.
5545 * @param {Array} [argPos] The argument positions of the new function.
5546 * @param {number} [ary] The arity cap of `func`.
5547 * @param {number} [arity] The arity of `func`.
5548 * @returns {Function} Returns the new wrapped function.
5549 */
5550 function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
5551 var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
5552 if (!isBindKey && typeof func != 'function') {
5553 throw new TypeError(FUNC_ERROR_TEXT);
5554 }
5555 var length = partials ? partials.length : 0;
5556 if (!length) {
5557 bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
5558 partials = holders = undefined;
5559 }
5560 ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
5561 arity = arity === undefined ? arity : toInteger(arity);
5562 length -= holders ? holders.length : 0;
5563
5564 if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
5565 var partialsRight = partials,
5566 holdersRight = holders;
5567
5568 partials = holders = undefined;
5569 }
5570 var data = isBindKey ? undefined : getData(func);
5571
5572 var newData = [
5573 func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
5574 argPos, ary, arity
5575 ];
5576
5577 if (data) {
5578 mergeData(newData, data);
5579 }
5580 func = newData[0];
5581 bitmask = newData[1];
5582 thisArg = newData[2];
5583 partials = newData[3];
5584 holders = newData[4];
5585 arity = newData[9] = newData[9] === undefined
5586 ? (isBindKey ? 0 : func.length)
5587 : nativeMax(newData[9] - length, 0);
5588
5589 if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
5590 bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
5591 }
5592 if (!bitmask || bitmask == WRAP_BIND_FLAG) {
5593 var result = createBind(func, bitmask, thisArg);
5594 } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
5595 result = createCurry(func, bitmask, arity);
5596 } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
5597 result = createPartial(func, bitmask, thisArg, partials);
5598 } else {
5599 result = createHybrid.apply(undefined, newData);
5600 }
5601 var setter = data ? baseSetData : setData;
5602 return setWrapToString(setter(result, newData), func, bitmask);
5603 }
5604
5605 /**
5606 * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
5607 * of source objects to the destination object for all destination properties
5608 * that resolve to `undefined`.
5609 *
5610 * @private
5611 * @param {*} objValue The destination value.
5612 * @param {*} srcValue The source value.
5613 * @param {string} key The key of the property to assign.
5614 * @param {Object} object The parent object of `objValue`.
5615 * @returns {*} Returns the value to assign.
5616 */
5617 function customDefaultsAssignIn(objValue, srcValue, key, object) {
5618 if (objValue === undefined ||
5619 (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
5620 return srcValue;
5621 }
5622 return objValue;
5623 }
5624
5625 /**
5626 * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
5627 * objects into destination objects that are passed thru.
5628 *
5629 * @private
5630 * @param {*} objValue The destination value.
5631 * @param {*} srcValue The source value.
5632 * @param {string} key The key of the property to merge.
5633 * @param {Object} object The parent object of `objValue`.
5634 * @param {Object} source The parent object of `srcValue`.
5635 * @param {Object} [stack] Tracks traversed source values and their merged
5636 * counterparts.
5637 * @returns {*} Returns the value to assign.
5638 */
5639 function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
5640 if (isObject(objValue) && isObject(srcValue)) {
5641 // Recursively merge objects and arrays (susceptible to call stack limits).
5642 stack.set(srcValue, objValue);
5643 baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
5644 stack['delete'](srcValue);
5645 }
5646 return objValue;
5647 }
5648
5649 /**
5650 * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
5651 * objects.
5652 *
5653 * @private
5654 * @param {*} value The value to inspect.
5655 * @param {string} key The key of the property to inspect.
5656 * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
5657 */
5658 function customOmitClone(value) {
5659 return isPlainObject(value) ? undefined : value;
5660 }
5661
5662 /**
5663 * A specialized version of `baseIsEqualDeep` for arrays with support for
5664 * partial deep comparisons.
5665 *
5666 * @private
5667 * @param {Array} array The array to compare.
5668 * @param {Array} other The other array to compare.
5669 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
5670 * @param {Function} customizer The function to customize comparisons.
5671 * @param {Function} equalFunc The function to determine equivalents of values.
5672 * @param {Object} stack Tracks traversed `array` and `other` objects.
5673 * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
5674 */
5675 function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
5676 var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
5677 arrLength = array.length,
5678 othLength = other.length;
5679
5680 if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
5681 return false;
5682 }
5683 // Check that cyclic values are equal.
5684 var arrStacked = stack.get(array);
5685 var othStacked = stack.get(other);
5686 if (arrStacked && othStacked) {
5687 return arrStacked == other && othStacked == array;
5688 }
5689 var index = -1,
5690 result = true,
5691 seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
5692
5693 stack.set(array, other);
5694 stack.set(other, array);
5695
5696 // Ignore non-index properties.
5697 while (++index < arrLength) {
5698 var arrValue = array[index],
5699 othValue = other[index];
5700
5701 if (customizer) {
5702 var compared = isPartial
5703 ? customizer(othValue, arrValue, index, other, array, stack)
5704 : customizer(arrValue, othValue, index, array, other, stack);
5705 }
5706 if (compared !== undefined) {
5707 if (compared) {
5708 continue;
5709 }
5710 result = false;
5711 break;
5712 }
5713 // Recursively compare arrays (susceptible to call stack limits).
5714 if (seen) {
5715 if (!arraySome(other, function(othValue, othIndex) {
5716 if (!cacheHas(seen, othIndex) &&
5717 (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
5718 return seen.push(othIndex);
5719 }
5720 })) {
5721 result = false;
5722 break;
5723 }
5724 } else if (!(
5725 arrValue === othValue ||
5726 equalFunc(arrValue, othValue, bitmask, customizer, stack)
5727 )) {
5728 result = false;
5729 break;
5730 }
5731 }
5732 stack['delete'](array);
5733 stack['delete'](other);
5734 return result;
5735 }
5736
5737 /**
5738 * A specialized version of `baseIsEqualDeep` for comparing objects of
5739 * the same `toStringTag`.
5740 *
5741 * **Note:** This function only supports comparing values with tags of
5742 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
5743 *
5744 * @private
5745 * @param {Object} object The object to compare.
5746 * @param {Object} other The other object to compare.
5747 * @param {string} tag The `toStringTag` of the objects to compare.
5748 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
5749 * @param {Function} customizer The function to customize comparisons.
5750 * @param {Function} equalFunc The function to determine equivalents of values.
5751 * @param {Object} stack Tracks traversed `object` and `other` objects.
5752 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
5753 */
5754 function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
5755 switch (tag) {
5756 case dataViewTag:
5757 if ((object.byteLength != other.byteLength) ||
5758 (object.byteOffset != other.byteOffset)) {
5759 return false;
5760 }
5761 object = object.buffer;
5762 other = other.buffer;
5763
5764 case arrayBufferTag:
5765 if ((object.byteLength != other.byteLength) ||
5766 !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
5767 return false;
5768 }
5769 return true;
5770
5771 case boolTag:
5772 case dateTag:
5773 case numberTag:
5774 // Coerce booleans to `1` or `0` and dates to milliseconds.
5775 // Invalid dates are coerced to `NaN`.
5776 return eq(+object, +other);
5777
5778 case errorTag:
5779 return object.name == other.name && object.message == other.message;
5780
5781 case regexpTag:
5782 case stringTag:
5783 // Coerce regexes to strings and treat strings, primitives and objects,
5784 // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
5785 // for more details.
5786 return object == (other + '');
5787
5788 case mapTag:
5789 var convert = mapToArray;
5790
5791 case setTag:
5792 var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
5793 convert || (convert = setToArray);
5794
5795 if (object.size != other.size && !isPartial) {
5796 return false;
5797 }
5798 // Assume cyclic values are equal.
5799 var stacked = stack.get(object);
5800 if (stacked) {
5801 return stacked == other;
5802 }
5803 bitmask |= COMPARE_UNORDERED_FLAG;
5804
5805 // Recursively compare objects (susceptible to call stack limits).
5806 stack.set(object, other);
5807 var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
5808 stack['delete'](object);
5809 return result;
5810
5811 case symbolTag:
5812 if (symbolValueOf) {
5813 return symbolValueOf.call(object) == symbolValueOf.call(other);
5814 }
5815 }
5816 return false;
5817 }
5818
5819 /**
5820 * A specialized version of `baseIsEqualDeep` for objects with support for
5821 * partial deep comparisons.
5822 *
5823 * @private
5824 * @param {Object} object The object to compare.
5825 * @param {Object} other The other object to compare.
5826 * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
5827 * @param {Function} customizer The function to customize comparisons.
5828 * @param {Function} equalFunc The function to determine equivalents of values.
5829 * @param {Object} stack Tracks traversed `object` and `other` objects.
5830 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
5831 */
5832 function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
5833 var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
5834 objProps = getAllKeys(object),
5835 objLength = objProps.length,
5836 othProps = getAllKeys(other),
5837 othLength = othProps.length;
5838
5839 if (objLength != othLength && !isPartial) {
5840 return false;
5841 }
5842 var index = objLength;
5843 while (index--) {
5844 var key = objProps[index];
5845 if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
5846 return false;
5847 }
5848 }
5849 // Check that cyclic values are equal.
5850 var objStacked = stack.get(object);
5851 var othStacked = stack.get(other);
5852 if (objStacked && othStacked) {
5853 return objStacked == other && othStacked == object;
5854 }
5855 var result = true;
5856 stack.set(object, other);
5857 stack.set(other, object);
5858
5859 var skipCtor = isPartial;
5860 while (++index < objLength) {
5861 key = objProps[index];
5862 var objValue = object[key],
5863 othValue = other[key];
5864
5865 if (customizer) {
5866 var compared = isPartial
5867 ? customizer(othValue, objValue, key, other, object, stack)
5868 : customizer(objValue, othValue, key, object, other, stack);
5869 }
5870 // Recursively compare objects (susceptible to call stack limits).
5871 if (!(compared === undefined
5872 ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
5873 : compared
5874 )) {
5875 result = false;
5876 break;
5877 }
5878 skipCtor || (skipCtor = key == 'constructor');
5879 }
5880 if (result && !skipCtor) {
5881 var objCtor = object.constructor,
5882 othCtor = other.constructor;
5883
5884 // Non `Object` object instances with different constructors are not equal.
5885 if (objCtor != othCtor &&
5886 ('constructor' in object && 'constructor' in other) &&
5887 !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
5888 typeof othCtor == 'function' && othCtor instanceof othCtor)) {
5889 result = false;
5890 }
5891 }
5892 stack['delete'](object);
5893 stack['delete'](other);
5894 return result;
5895 }
5896
5897 /**
5898 * A specialized version of `baseRest` which flattens the rest array.
5899 *
5900 * @private
5901 * @param {Function} func The function to apply a rest parameter to.
5902 * @returns {Function} Returns the new function.
5903 */
5904 function flatRest(func) {
5905 return setToString(overRest(func, undefined, flatten), func + '');
5906 }
5907
5908 /**
5909 * Creates an array of own enumerable property names and symbols of `object`.
5910 *
5911 * @private
5912 * @param {Object} object The object to query.
5913 * @returns {Array} Returns the array of property names and symbols.
5914 */
5915 function getAllKeys(object) {
5916 return baseGetAllKeys(object, keys, getSymbols);
5917 }
5918
5919 /**
5920 * Creates an array of own and inherited enumerable property names and
5921 * symbols of `object`.
5922 *
5923 * @private
5924 * @param {Object} object The object to query.
5925 * @returns {Array} Returns the array of property names and symbols.
5926 */
5927 function getAllKeysIn(object) {
5928 return baseGetAllKeys(object, keysIn, getSymbolsIn);
5929 }
5930
5931 /**
5932 * Gets metadata for `func`.
5933 *
5934 * @private
5935 * @param {Function} func The function to query.
5936 * @returns {*} Returns the metadata for `func`.
5937 */
5938 var getData = !metaMap ? noop : function(func) {
5939 return metaMap.get(func);
5940 };
5941
5942 /**
5943 * Gets the name of `func`.
5944 *
5945 * @private
5946 * @param {Function} func The function to query.
5947 * @returns {string} Returns the function name.
5948 */
5949 function getFuncName(func) {
5950 var result = (func.name + ''),
5951 array = realNames[result],
5952 length = hasOwnProperty.call(realNames, result) ? array.length : 0;
5953
5954 while (length--) {
5955 var data = array[length],
5956 otherFunc = data.func;
5957 if (otherFunc == null || otherFunc == func) {
5958 return data.name;
5959 }
5960 }
5961 return result;
5962 }
5963
5964 /**
5965 * Gets the argument placeholder value for `func`.
5966 *
5967 * @private
5968 * @param {Function} func The function to inspect.
5969 * @returns {*} Returns the placeholder value.
5970 */
5971 function getHolder(func) {
5972 var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
5973 return object.placeholder;
5974 }
5975
5976 /**
5977 * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
5978 * this function returns the custom method, otherwise it returns `baseIteratee`.
5979 * If arguments are provided, the chosen function is invoked with them and
5980 * its result is returned.
5981 *
5982 * @private
5983 * @param {*} [value] The value to convert to an iteratee.
5984 * @param {number} [arity] The arity of the created iteratee.
5985 * @returns {Function} Returns the chosen function or its result.
5986 */
5987 function getIteratee() {
5988 var result = lodash.iteratee || iteratee;
5989 result = result === iteratee ? baseIteratee : result;
5990 return arguments.length ? result(arguments[0], arguments[1]) : result;
5991 }
5992
5993 /**
5994 * Gets the data for `map`.
5995 *
5996 * @private
5997 * @param {Object} map The map to query.
5998 * @param {string} key The reference key.
5999 * @returns {*} Returns the map data.
6000 */
6001 function getMapData(map, key) {
6002 var data = map.__data__;
6003 return isKeyable(key)
6004 ? data[typeof key == 'string' ? 'string' : 'hash']
6005 : data.map;
6006 }
6007
6008 /**
6009 * Gets the property names, values, and compare flags of `object`.
6010 *
6011 * @private
6012 * @param {Object} object The object to query.
6013 * @returns {Array} Returns the match data of `object`.
6014 */
6015 function getMatchData(object) {
6016 var result = keys(object),
6017 length = result.length;
6018
6019 while (length--) {
6020 var key = result[length],
6021 value = object[key];
6022
6023 result[length] = [key, value, isStrictComparable(value)];
6024 }
6025 return result;
6026 }
6027
6028 /**
6029 * Gets the native function at `key` of `object`.
6030 *
6031 * @private
6032 * @param {Object} object The object to query.
6033 * @param {string} key The key of the method to get.
6034 * @returns {*} Returns the function if it's native, else `undefined`.
6035 */
6036 function getNative(object, key) {
6037 var value = getValue(object, key);
6038 return baseIsNative(value) ? value : undefined;
6039 }
6040
6041 /**
6042 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
6043 *
6044 * @private
6045 * @param {*} value The value to query.
6046 * @returns {string} Returns the raw `toStringTag`.
6047 */
6048 function getRawTag(value) {
6049 var isOwn = hasOwnProperty.call(value, symToStringTag),
6050 tag = value[symToStringTag];
6051
6052 try {
6053 value[symToStringTag] = undefined;
6054 var unmasked = true;
6055 } catch (e) {}
6056
6057 var result = nativeObjectToString.call(value);
6058 if (unmasked) {
6059 if (isOwn) {
6060 value[symToStringTag] = tag;
6061 } else {
6062 delete value[symToStringTag];
6063 }
6064 }
6065 return result;
6066 }
6067
6068 /**
6069 * Creates an array of the own enumerable symbols of `object`.
6070 *
6071 * @private
6072 * @param {Object} object The object to query.
6073 * @returns {Array} Returns the array of symbols.
6074 */
6075 var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
6076 if (object == null) {
6077 return [];
6078 }
6079 object = Object(object);
6080 return arrayFilter(nativeGetSymbols(object), function(symbol) {
6081 return propertyIsEnumerable.call(object, symbol);
6082 });
6083 };
6084
6085 /**
6086 * Creates an array of the own and inherited enumerable symbols of `object`.
6087 *
6088 * @private
6089 * @param {Object} object The object to query.
6090 * @returns {Array} Returns the array of symbols.
6091 */
6092 var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
6093 var result = [];
6094 while (object) {
6095 arrayPush(result, getSymbols(object));
6096 object = getPrototype(object);
6097 }
6098 return result;
6099 };
6100
6101 /**
6102 * Gets the `toStringTag` of `value`.
6103 *
6104 * @private
6105 * @param {*} value The value to query.
6106 * @returns {string} Returns the `toStringTag`.
6107 */
6108 var getTag = baseGetTag;
6109
6110 // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
6111 if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
6112 (Map && getTag(new Map) != mapTag) ||
6113 (Promise && getTag(Promise.resolve()) != promiseTag) ||
6114 (Set && getTag(new Set) != setTag) ||
6115 (WeakMap && getTag(new WeakMap) != weakMapTag)) {
6116 getTag = function(value) {
6117 var result = baseGetTag(value),
6118 Ctor = result == objectTag ? value.constructor : undefined,
6119 ctorString = Ctor ? toSource(Ctor) : '';
6120
6121 if (ctorString) {
6122 switch (ctorString) {
6123 case dataViewCtorString: return dataViewTag;
6124 case mapCtorString: return mapTag;
6125 case promiseCtorString: return promiseTag;
6126 case setCtorString: return setTag;
6127 case weakMapCtorString: return weakMapTag;
6128 }
6129 }
6130 return result;
6131 };
6132 }
6133
6134 /**
6135 * Gets the view, applying any `transforms` to the `start` and `end` positions.
6136 *
6137 * @private
6138 * @param {number} start The start of the view.
6139 * @param {number} end The end of the view.
6140 * @param {Array} transforms The transformations to apply to the view.
6141 * @returns {Object} Returns an object containing the `start` and `end`
6142 * positions of the view.
6143 */
6144 function getView(start, end, transforms) {
6145 var index = -1,
6146 length = transforms.length;
6147
6148 while (++index < length) {
6149 var data = transforms[index],
6150 size = data.size;
6151
6152 switch (data.type) {
6153 case 'drop': start += size; break;
6154 case 'dropRight': end -= size; break;
6155 case 'take': end = nativeMin(end, start + size); break;
6156 case 'takeRight': start = nativeMax(start, end - size); break;
6157 }
6158 }
6159 return { 'start': start, 'end': end };
6160 }
6161
6162 /**
6163 * Extracts wrapper details from the `source` body comment.
6164 *
6165 * @private
6166 * @param {string} source The source to inspect.
6167 * @returns {Array} Returns the wrapper details.
6168 */
6169 function getWrapDetails(source) {
6170 var match = source.match(reWrapDetails);
6171 return match ? match[1].split(reSplitDetails) : [];
6172 }
6173
6174 /**
6175 * Checks if `path` exists on `object`.
6176 *
6177 * @private
6178 * @param {Object} object The object to query.
6179 * @param {Array|string} path The path to check.
6180 * @param {Function} hasFunc The function to check properties.
6181 * @returns {boolean} Returns `true` if `path` exists, else `false`.
6182 */
6183 function hasPath(object, path, hasFunc) {
6184 path = castPath(path, object);
6185
6186 var index = -1,
6187 length = path.length,
6188 result = false;
6189
6190 while (++index < length) {
6191 var key = toKey(path[index]);
6192 if (!(result = object != null && hasFunc(object, key))) {
6193 break;
6194 }
6195 object = object[key];
6196 }
6197 if (result || ++index != length) {
6198 return result;
6199 }
6200 length = object == null ? 0 : object.length;
6201 return !!length && isLength(length) && isIndex(key, length) &&
6202 (isArray(object) || isArguments(object));
6203 }
6204
6205 /**
6206 * Initializes an array clone.
6207 *
6208 * @private
6209 * @param {Array} array The array to clone.
6210 * @returns {Array} Returns the initialized clone.
6211 */
6212 function initCloneArray(array) {
6213 var length = array.length,
6214 result = new array.constructor(length);
6215
6216 // Add properties assigned by `RegExp#exec`.
6217 if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
6218 result.index = array.index;
6219 result.input = array.input;
6220 }
6221 return result;
6222 }
6223
6224 /**
6225 * Initializes an object clone.
6226 *
6227 * @private
6228 * @param {Object} object The object to clone.
6229 * @returns {Object} Returns the initialized clone.
6230 */
6231 function initCloneObject(object) {
6232 return (typeof object.constructor == 'function' && !isPrototype(object))
6233 ? baseCreate(getPrototype(object))
6234 : {};
6235 }
6236
6237 /**
6238 * Initializes an object clone based on its `toStringTag`.
6239 *
6240 * **Note:** This function only supports cloning values with tags of
6241 * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
6242 *
6243 * @private
6244 * @param {Object} object The object to clone.
6245 * @param {string} tag The `toStringTag` of the object to clone.
6246 * @param {boolean} [isDeep] Specify a deep clone.
6247 * @returns {Object} Returns the initialized clone.
6248 */
6249 function initCloneByTag(object, tag, isDeep) {
6250 var Ctor = object.constructor;
6251 switch (tag) {
6252 case arrayBufferTag:
6253 return cloneArrayBuffer(object);
6254
6255 case boolTag:
6256 case dateTag:
6257 return new Ctor(+object);
6258
6259 case dataViewTag:
6260 return cloneDataView(object, isDeep);
6261
6262 case float32Tag: case float64Tag:
6263 case int8Tag: case int16Tag: case int32Tag:
6264 case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
6265 return cloneTypedArray(object, isDeep);
6266
6267 case mapTag:
6268 return new Ctor;
6269
6270 case numberTag:
6271 case stringTag:
6272 return new Ctor(object);
6273
6274 case regexpTag:
6275 return cloneRegExp(object);
6276
6277 case setTag:
6278 return new Ctor;
6279
6280 case symbolTag:
6281 return cloneSymbol(object);
6282 }
6283 }
6284
6285 /**
6286 * Inserts wrapper `details` in a comment at the top of the `source` body.
6287 *
6288 * @private
6289 * @param {string} source The source to modify.
6290 * @returns {Array} details The details to insert.
6291 * @returns {string} Returns the modified source.
6292 */
6293 function insertWrapDetails(source, details) {
6294 var length = details.length;
6295 if (!length) {
6296 return source;
6297 }
6298 var lastIndex = length - 1;
6299 details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
6300 details = details.join(length > 2 ? ', ' : ' ');
6301 return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
6302 }
6303
6304 /**
6305 * Checks if `value` is a flattenable `arguments` object or array.
6306 *
6307 * @private
6308 * @param {*} value The value to check.
6309 * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
6310 */
6311 function isFlattenable(value) {
6312 return isArray(value) || isArguments(value) ||
6313 !!(spreadableSymbol && value && value[spreadableSymbol]);
6314 }
6315
6316 /**
6317 * Checks if `value` is a valid array-like index.
6318 *
6319 * @private
6320 * @param {*} value The value to check.
6321 * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
6322 * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
6323 */
6324 function isIndex(value, length) {
6325 var type = typeof value;
6326 length = length == null ? MAX_SAFE_INTEGER : length;
6327
6328 return !!length &&
6329 (type == 'number' ||
6330 (type != 'symbol' && reIsUint.test(value))) &&
6331 (value > -1 && value % 1 == 0 && value < length);
6332 }
6333
6334 /**
6335 * Checks if the given arguments are from an iteratee call.
6336 *
6337 * @private
6338 * @param {*} value The potential iteratee value argument.
6339 * @param {*} index The potential iteratee index or key argument.
6340 * @param {*} object The potential iteratee object argument.
6341 * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
6342 * else `false`.
6343 */
6344 function isIterateeCall(value, index, object) {
6345 if (!isObject(object)) {
6346 return false;
6347 }
6348 var type = typeof index;
6349 if (type == 'number'
6350 ? (isArrayLike(object) && isIndex(index, object.length))
6351 : (type == 'string' && index in object)
6352 ) {
6353 return eq(object[index], value);
6354 }
6355 return false;
6356 }
6357
6358 /**
6359 * Checks if `value` is a property name and not a property path.
6360 *
6361 * @private
6362 * @param {*} value The value to check.
6363 * @param {Object} [object] The object to query keys on.
6364 * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
6365 */
6366 function isKey(value, object) {
6367 if (isArray(value)) {
6368 return false;
6369 }
6370 var type = typeof value;
6371 if (type == 'number' || type == 'symbol' || type == 'boolean' ||
6372 value == null || isSymbol(value)) {
6373 return true;
6374 }
6375 return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
6376 (object != null && value in Object(object));
6377 }
6378
6379 /**
6380 * Checks if `value` is suitable for use as unique object key.
6381 *
6382 * @private
6383 * @param {*} value The value to check.
6384 * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
6385 */
6386 function isKeyable(value) {
6387 var type = typeof value;
6388 return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
6389 ? (value !== '__proto__')
6390 : (value === null);
6391 }
6392
6393 /**
6394 * Checks if `func` has a lazy counterpart.
6395 *
6396 * @private
6397 * @param {Function} func The function to check.
6398 * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
6399 * else `false`.
6400 */
6401 function isLaziable(func) {
6402 var funcName = getFuncName(func),
6403 other = lodash[funcName];
6404
6405 if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
6406 return false;
6407 }
6408 if (func === other) {
6409 return true;
6410 }
6411 var data = getData(other);
6412 return !!data && func === data[0];
6413 }
6414
6415 /**
6416 * Checks if `func` has its source masked.
6417 *
6418 * @private
6419 * @param {Function} func The function to check.
6420 * @returns {boolean} Returns `true` if `func` is masked, else `false`.
6421 */
6422 function isMasked(func) {
6423 return !!maskSrcKey && (maskSrcKey in func);
6424 }
6425
6426 /**
6427 * Checks if `func` is capable of being masked.
6428 *
6429 * @private
6430 * @param {*} value The value to check.
6431 * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
6432 */
6433 var isMaskable = coreJsData ? isFunction : stubFalse;
6434
6435 /**
6436 * Checks if `value` is likely a prototype object.
6437 *
6438 * @private
6439 * @param {*} value The value to check.
6440 * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
6441 */
6442 function isPrototype(value) {
6443 var Ctor = value && value.constructor,
6444 proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
6445
6446 return value === proto;
6447 }
6448
6449 /**
6450 * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
6451 *
6452 * @private
6453 * @param {*} value The value to check.
6454 * @returns {boolean} Returns `true` if `value` if suitable for strict
6455 * equality comparisons, else `false`.
6456 */
6457 function isStrictComparable(value) {
6458 return value === value && !isObject(value);
6459 }
6460
6461 /**
6462 * A specialized version of `matchesProperty` for source values suitable
6463 * for strict equality comparisons, i.e. `===`.
6464 *
6465 * @private
6466 * @param {string} key The key of the property to get.
6467 * @param {*} srcValue The value to match.
6468 * @returns {Function} Returns the new spec function.
6469 */
6470 function matchesStrictComparable(key, srcValue) {
6471 return function(object) {
6472 if (object == null) {
6473 return false;
6474 }
6475 return object[key] === srcValue &&
6476 (srcValue !== undefined || (key in Object(object)));
6477 };
6478 }
6479
6480 /**
6481 * A specialized version of `_.memoize` which clears the memoized function's
6482 * cache when it exceeds `MAX_MEMOIZE_SIZE`.
6483 *
6484 * @private
6485 * @param {Function} func The function to have its output memoized.
6486 * @returns {Function} Returns the new memoized function.
6487 */
6488 function memoizeCapped(func) {
6489 var result = memoize(func, function(key) {
6490 if (cache.size === MAX_MEMOIZE_SIZE) {
6491 cache.clear();
6492 }
6493 return key;
6494 });
6495
6496 var cache = result.cache;
6497 return result;
6498 }
6499
6500 /**
6501 * Merges the function metadata of `source` into `data`.
6502 *
6503 * Merging metadata reduces the number of wrappers used to invoke a function.
6504 * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
6505 * may be applied regardless of execution order. Methods like `_.ary` and
6506 * `_.rearg` modify function arguments, making the order in which they are
6507 * executed important, preventing the merging of metadata. However, we make
6508 * an exception for a safe combined case where curried functions have `_.ary`
6509 * and or `_.rearg` applied.
6510 *
6511 * @private
6512 * @param {Array} data The destination metadata.
6513 * @param {Array} source The source metadata.
6514 * @returns {Array} Returns `data`.
6515 */
6516 function mergeData(data, source) {
6517 var bitmask = data[1],
6518 srcBitmask = source[1],
6519 newBitmask = bitmask | srcBitmask,
6520 isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
6521
6522 var isCombo =
6523 ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
6524 ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
6525 ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
6526
6527 // Exit early if metadata can't be merged.
6528 if (!(isCommon || isCombo)) {
6529 return data;
6530 }
6531 // Use source `thisArg` if available.
6532 if (srcBitmask & WRAP_BIND_FLAG) {
6533 data[2] = source[2];
6534 // Set when currying a bound function.
6535 newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
6536 }
6537 // Compose partial arguments.
6538 var value = source[3];
6539 if (value) {
6540 var partials = data[3];
6541 data[3] = partials ? composeArgs(partials, value, source[4]) : value;
6542 data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
6543 }
6544 // Compose partial right arguments.
6545 value = source[5];
6546 if (value) {
6547 partials = data[5];
6548 data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
6549 data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
6550 }
6551 // Use source `argPos` if available.
6552 value = source[7];
6553 if (value) {
6554 data[7] = value;
6555 }
6556 // Use source `ary` if it's smaller.
6557 if (srcBitmask & WRAP_ARY_FLAG) {
6558 data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
6559 }
6560 // Use source `arity` if one is not provided.
6561 if (data[9] == null) {
6562 data[9] = source[9];
6563 }
6564 // Use source `func` and merge bitmasks.
6565 data[0] = source[0];
6566 data[1] = newBitmask;
6567
6568 return data;
6569 }
6570
6571 /**
6572 * This function is like
6573 * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
6574 * except that it includes inherited enumerable properties.
6575 *
6576 * @private
6577 * @param {Object} object The object to query.
6578 * @returns {Array} Returns the array of property names.
6579 */
6580 function nativeKeysIn(object) {
6581 var result = [];
6582 if (object != null) {
6583 for (var key in Object(object)) {
6584 result.push(key);
6585 }
6586 }
6587 return result;
6588 }
6589
6590 /**
6591 * Converts `value` to a string using `Object.prototype.toString`.
6592 *
6593 * @private
6594 * @param {*} value The value to convert.
6595 * @returns {string} Returns the converted string.
6596 */
6597 function objectToString(value) {
6598 return nativeObjectToString.call(value);
6599 }
6600
6601 /**
6602 * A specialized version of `baseRest` which transforms the rest array.
6603 *
6604 * @private
6605 * @param {Function} func The function to apply a rest parameter to.
6606 * @param {number} [start=func.length-1] The start position of the rest parameter.
6607 * @param {Function} transform The rest array transform.
6608 * @returns {Function} Returns the new function.
6609 */
6610 function overRest(func, start, transform) {
6611 start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
6612 return function() {
6613 var args = arguments,
6614 index = -1,
6615 length = nativeMax(args.length - start, 0),
6616 array = Array(length);
6617
6618 while (++index < length) {
6619 array[index] = args[start + index];
6620 }
6621 index = -1;
6622 var otherArgs = Array(start + 1);
6623 while (++index < start) {
6624 otherArgs[index] = args[index];
6625 }
6626 otherArgs[start] = transform(array);
6627 return apply(func, this, otherArgs);
6628 };
6629 }
6630
6631 /**
6632 * Gets the parent value at `path` of `object`.
6633 *
6634 * @private
6635 * @param {Object} object The object to query.
6636 * @param {Array} path The path to get the parent value of.
6637 * @returns {*} Returns the parent value.
6638 */
6639 function parent(object, path) {
6640 return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
6641 }
6642
6643 /**
6644 * Reorder `array` according to the specified indexes where the element at
6645 * the first index is assigned as the first element, the element at
6646 * the second index is assigned as the second element, and so on.
6647 *
6648 * @private
6649 * @param {Array} array The array to reorder.
6650 * @param {Array} indexes The arranged array indexes.
6651 * @returns {Array} Returns `array`.
6652 */
6653 function reorder(array, indexes) {
6654 var arrLength = array.length,
6655 length = nativeMin(indexes.length, arrLength),
6656 oldArray = copyArray(array);
6657
6658 while (length--) {
6659 var index = indexes[length];
6660 array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
6661 }
6662 return array;
6663 }
6664
6665 /**
6666 * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
6667 *
6668 * @private
6669 * @param {Object} object The object to query.
6670 * @param {string} key The key of the property to get.
6671 * @returns {*} Returns the property value.
6672 */
6673 function safeGet(object, key) {
6674 if (key === 'constructor' && typeof object[key] === 'function') {
6675 return;
6676 }
6677
6678 if (key == '__proto__') {
6679 return;
6680 }
6681
6682 return object[key];
6683 }
6684
6685 /**
6686 * Sets metadata for `func`.
6687 *
6688 * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
6689 * period of time, it will trip its breaker and transition to an identity
6690 * function to avoid garbage collection pauses in V8. See
6691 * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
6692 * for more details.
6693 *
6694 * @private
6695 * @param {Function} func The function to associate metadata with.
6696 * @param {*} data The metadata.
6697 * @returns {Function} Returns `func`.
6698 */
6699 var setData = shortOut(baseSetData);
6700
6701 /**
6702 * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
6703 *
6704 * @private
6705 * @param {Function} func The function to delay.
6706 * @param {number} wait The number of milliseconds to delay invocation.
6707 * @returns {number|Object} Returns the timer id or timeout object.
6708 */
6709 var setTimeout = ctxSetTimeout || function(func, wait) {
6710 return root.setTimeout(func, wait);
6711 };
6712
6713 /**
6714 * Sets the `toString` method of `func` to return `string`.
6715 *
6716 * @private
6717 * @param {Function} func The function to modify.
6718 * @param {Function} string The `toString` result.
6719 * @returns {Function} Returns `func`.
6720 */
6721 var setToString = shortOut(baseSetToString);
6722
6723 /**
6724 * Sets the `toString` method of `wrapper` to mimic the source of `reference`
6725 * with wrapper details in a comment at the top of the source body.
6726 *
6727 * @private
6728 * @param {Function} wrapper The function to modify.
6729 * @param {Function} reference The reference function.
6730 * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
6731 * @returns {Function} Returns `wrapper`.
6732 */
6733 function setWrapToString(wrapper, reference, bitmask) {
6734 var source = (reference + '');
6735 return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
6736 }
6737
6738 /**
6739 * Creates a function that'll short out and invoke `identity` instead
6740 * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
6741 * milliseconds.
6742 *
6743 * @private
6744 * @param {Function} func The function to restrict.
6745 * @returns {Function} Returns the new shortable function.
6746 */
6747 function shortOut(func) {
6748 var count = 0,
6749 lastCalled = 0;
6750
6751 return function() {
6752 var stamp = nativeNow(),
6753 remaining = HOT_SPAN - (stamp - lastCalled);
6754
6755 lastCalled = stamp;
6756 if (remaining > 0) {
6757 if (++count >= HOT_COUNT) {
6758 return arguments[0];
6759 }
6760 } else {
6761 count = 0;
6762 }
6763 return func.apply(undefined, arguments);
6764 };
6765 }
6766
6767 /**
6768 * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
6769 *
6770 * @private
6771 * @param {Array} array The array to shuffle.
6772 * @param {number} [size=array.length] The size of `array`.
6773 * @returns {Array} Returns `array`.
6774 */
6775 function shuffleSelf(array, size) {
6776 var index = -1,
6777 length = array.length,
6778 lastIndex = length - 1;
6779
6780 size = size === undefined ? length : size;
6781 while (++index < size) {
6782 var rand = baseRandom(index, lastIndex),
6783 value = array[rand];
6784
6785 array[rand] = array[index];
6786 array[index] = value;
6787 }
6788 array.length = size;
6789 return array;
6790 }
6791
6792 /**
6793 * Converts `string` to a property path array.
6794 *
6795 * @private
6796 * @param {string} string The string to convert.
6797 * @returns {Array} Returns the property path array.
6798 */
6799 var stringToPath = memoizeCapped(function(string) {
6800 var result = [];
6801 if (string.charCodeAt(0) === 46 /* . */) {
6802 result.push('');
6803 }
6804 string.replace(rePropName, function(match, number, quote, subString) {
6805 result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
6806 });
6807 return result;
6808 });
6809
6810 /**
6811 * Converts `value` to a string key if it's not a string or symbol.
6812 *
6813 * @private
6814 * @param {*} value The value to inspect.
6815 * @returns {string|symbol} Returns the key.
6816 */
6817 function toKey(value) {
6818 if (typeof value == 'string' || isSymbol(value)) {
6819 return value;
6820 }
6821 var result = (value + '');
6822 return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
6823 }
6824
6825 /**
6826 * Converts `func` to its source code.
6827 *
6828 * @private
6829 * @param {Function} func The function to convert.
6830 * @returns {string} Returns the source code.
6831 */
6832 function toSource(func) {
6833 if (func != null) {
6834 try {
6835 return funcToString.call(func);
6836 } catch (e) {}
6837 try {
6838 return (func + '');
6839 } catch (e) {}
6840 }
6841 return '';
6842 }
6843
6844 /**
6845 * Updates wrapper `details` based on `bitmask` flags.
6846 *
6847 * @private
6848 * @returns {Array} details The details to modify.
6849 * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
6850 * @returns {Array} Returns `details`.
6851 */
6852 function updateWrapDetails(details, bitmask) {
6853 arrayEach(wrapFlags, function(pair) {
6854 var value = '_.' + pair[0];
6855 if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
6856 details.push(value);
6857 }
6858 });
6859 return details.sort();
6860 }
6861
6862 /**
6863 * Creates a clone of `wrapper`.
6864 *
6865 * @private
6866 * @param {Object} wrapper The wrapper to clone.
6867 * @returns {Object} Returns the cloned wrapper.
6868 */
6869 function wrapperClone(wrapper) {
6870 if (wrapper instanceof LazyWrapper) {
6871 return wrapper.clone();
6872 }
6873 var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
6874 result.__actions__ = copyArray(wrapper.__actions__);
6875 result.__index__ = wrapper.__index__;
6876 result.__values__ = wrapper.__values__;
6877 return result;
6878 }
6879
6880 /*------------------------------------------------------------------------*/
6881
6882 /**
6883 * Creates an array of elements split into groups the length of `size`.
6884 * If `array` can't be split evenly, the final chunk will be the remaining
6885 * elements.
6886 *
6887 * @static
6888 * @memberOf _
6889 * @since 3.0.0
6890 * @category Array
6891 * @param {Array} array The array to process.
6892 * @param {number} [size=1] The length of each chunk
6893 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
6894 * @returns {Array} Returns the new array of chunks.
6895 * @example
6896 *
6897 * _.chunk(['a', 'b', 'c', 'd'], 2);
6898 * // => [['a', 'b'], ['c', 'd']]
6899 *
6900 * _.chunk(['a', 'b', 'c', 'd'], 3);
6901 * // => [['a', 'b', 'c'], ['d']]
6902 */
6903 function chunk(array, size, guard) {
6904 if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
6905 size = 1;
6906 } else {
6907 size = nativeMax(toInteger(size), 0);
6908 }
6909 var length = array == null ? 0 : array.length;
6910 if (!length || size < 1) {
6911 return [];
6912 }
6913 var index = 0,
6914 resIndex = 0,
6915 result = Array(nativeCeil(length / size));
6916
6917 while (index < length) {
6918 result[resIndex++] = baseSlice(array, index, (index += size));
6919 }
6920 return result;
6921 }
6922
6923 /**
6924 * Creates an array with all falsey values removed. The values `false`, `null`,
6925 * `0`, `""`, `undefined`, and `NaN` are falsey.
6926 *
6927 * @static
6928 * @memberOf _
6929 * @since 0.1.0
6930 * @category Array
6931 * @param {Array} array The array to compact.
6932 * @returns {Array} Returns the new array of filtered values.
6933 * @example
6934 *
6935 * _.compact([0, 1, false, 2, '', 3]);
6936 * // => [1, 2, 3]
6937 */
6938 function compact(array) {
6939 var index = -1,
6940 length = array == null ? 0 : array.length,
6941 resIndex = 0,
6942 result = [];
6943
6944 while (++index < length) {
6945 var value = array[index];
6946 if (value) {
6947 result[resIndex++] = value;
6948 }
6949 }
6950 return result;
6951 }
6952
6953 /**
6954 * Creates a new array concatenating `array` with any additional arrays
6955 * and/or values.
6956 *
6957 * @static
6958 * @memberOf _
6959 * @since 4.0.0
6960 * @category Array
6961 * @param {Array} array The array to concatenate.
6962 * @param {...*} [values] The values to concatenate.
6963 * @returns {Array} Returns the new concatenated array.
6964 * @example
6965 *
6966 * var array = [1];
6967 * var other = _.concat(array, 2, [3], [[4]]);
6968 *
6969 * console.log(other);
6970 * // => [1, 2, 3, [4]]
6971 *
6972 * console.log(array);
6973 * // => [1]
6974 */
6975 function concat() {
6976 var length = arguments.length;
6977 if (!length) {
6978 return [];
6979 }
6980 var args = Array(length - 1),
6981 array = arguments[0],
6982 index = length;
6983
6984 while (index--) {
6985 args[index - 1] = arguments[index];
6986 }
6987 return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
6988 }
6989
6990 /**
6991 * Creates an array of `array` values not included in the other given arrays
6992 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
6993 * for equality comparisons. The order and references of result values are
6994 * determined by the first array.
6995 *
6996 * **Note:** Unlike `_.pullAll`, this method returns a new array.
6997 *
6998 * @static
6999 * @memberOf _
7000 * @since 0.1.0
7001 * @category Array
7002 * @param {Array} array The array to inspect.
7003 * @param {...Array} [values] The values to exclude.
7004 * @returns {Array} Returns the new array of filtered values.
7005 * @see _.without, _.xor
7006 * @example
7007 *
7008 * _.difference([2, 1], [2, 3]);
7009 * // => [1]
7010 */
7011 var difference = baseRest(function(array, values) {
7012 return isArrayLikeObject(array)
7013 ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
7014 : [];
7015 });
7016
7017 /**
7018 * This method is like `_.difference` except that it accepts `iteratee` which
7019 * is invoked for each element of `array` and `values` to generate the criterion
7020 * by which they're compared. The order and references of result values are
7021 * determined by the first array. The iteratee is invoked with one argument:
7022 * (value).
7023 *
7024 * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
7025 *
7026 * @static
7027 * @memberOf _
7028 * @since 4.0.0
7029 * @category Array
7030 * @param {Array} array The array to inspect.
7031 * @param {...Array} [values] The values to exclude.
7032 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
7033 * @returns {Array} Returns the new array of filtered values.
7034 * @example
7035 *
7036 * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
7037 * // => [1.2]
7038 *
7039 * // The `_.property` iteratee shorthand.
7040 * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
7041 * // => [{ 'x': 2 }]
7042 */
7043 var differenceBy = baseRest(function(array, values) {
7044 var iteratee = last(values);
7045 if (isArrayLikeObject(iteratee)) {
7046 iteratee = undefined;
7047 }
7048 return isArrayLikeObject(array)
7049 ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
7050 : [];
7051 });
7052
7053 /**
7054 * This method is like `_.difference` except that it accepts `comparator`
7055 * which is invoked to compare elements of `array` to `values`. The order and
7056 * references of result values are determined by the first array. The comparator
7057 * is invoked with two arguments: (arrVal, othVal).
7058 *
7059 * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
7060 *
7061 * @static
7062 * @memberOf _
7063 * @since 4.0.0
7064 * @category Array
7065 * @param {Array} array The array to inspect.
7066 * @param {...Array} [values] The values to exclude.
7067 * @param {Function} [comparator] The comparator invoked per element.
7068 * @returns {Array} Returns the new array of filtered values.
7069 * @example
7070 *
7071 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
7072 *
7073 * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
7074 * // => [{ 'x': 2, 'y': 1 }]
7075 */
7076 var differenceWith = baseRest(function(array, values) {
7077 var comparator = last(values);
7078 if (isArrayLikeObject(comparator)) {
7079 comparator = undefined;
7080 }
7081 return isArrayLikeObject(array)
7082 ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
7083 : [];
7084 });
7085
7086 /**
7087 * Creates a slice of `array` with `n` elements dropped from the beginning.
7088 *
7089 * @static
7090 * @memberOf _
7091 * @since 0.5.0
7092 * @category Array
7093 * @param {Array} array The array to query.
7094 * @param {number} [n=1] The number of elements to drop.
7095 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
7096 * @returns {Array} Returns the slice of `array`.
7097 * @example
7098 *
7099 * _.drop([1, 2, 3]);
7100 * // => [2, 3]
7101 *
7102 * _.drop([1, 2, 3], 2);
7103 * // => [3]
7104 *
7105 * _.drop([1, 2, 3], 5);
7106 * // => []
7107 *
7108 * _.drop([1, 2, 3], 0);
7109 * // => [1, 2, 3]
7110 */
7111 function drop(array, n, guard) {
7112 var length = array == null ? 0 : array.length;
7113 if (!length) {
7114 return [];
7115 }
7116 n = (guard || n === undefined) ? 1 : toInteger(n);
7117 return baseSlice(array, n < 0 ? 0 : n, length);
7118 }
7119
7120 /**
7121 * Creates a slice of `array` with `n` elements dropped from the end.
7122 *
7123 * @static
7124 * @memberOf _
7125 * @since 3.0.0
7126 * @category Array
7127 * @param {Array} array The array to query.
7128 * @param {number} [n=1] The number of elements to drop.
7129 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
7130 * @returns {Array} Returns the slice of `array`.
7131 * @example
7132 *
7133 * _.dropRight([1, 2, 3]);
7134 * // => [1, 2]
7135 *
7136 * _.dropRight([1, 2, 3], 2);
7137 * // => [1]
7138 *
7139 * _.dropRight([1, 2, 3], 5);
7140 * // => []
7141 *
7142 * _.dropRight([1, 2, 3], 0);
7143 * // => [1, 2, 3]
7144 */
7145 function dropRight(array, n, guard) {
7146 var length = array == null ? 0 : array.length;
7147 if (!length) {
7148 return [];
7149 }
7150 n = (guard || n === undefined) ? 1 : toInteger(n);
7151 n = length - n;
7152 return baseSlice(array, 0, n < 0 ? 0 : n);
7153 }
7154
7155 /**
7156 * Creates a slice of `array` excluding elements dropped from the end.
7157 * Elements are dropped until `predicate` returns falsey. The predicate is
7158 * invoked with three arguments: (value, index, array).
7159 *
7160 * @static
7161 * @memberOf _
7162 * @since 3.0.0
7163 * @category Array
7164 * @param {Array} array The array to query.
7165 * @param {Function} [predicate=_.identity] The function invoked per iteration.
7166 * @returns {Array} Returns the slice of `array`.
7167 * @example
7168 *
7169 * var users = [
7170 * { 'user': 'barney', 'active': true },
7171 * { 'user': 'fred', 'active': false },
7172 * { 'user': 'pebbles', 'active': false }
7173 * ];
7174 *
7175 * _.dropRightWhile(users, function(o) { return !o.active; });
7176 * // => objects for ['barney']
7177 *
7178 * // The `_.matches` iteratee shorthand.
7179 * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
7180 * // => objects for ['barney', 'fred']
7181 *
7182 * // The `_.matchesProperty` iteratee shorthand.
7183 * _.dropRightWhile(users, ['active', false]);
7184 * // => objects for ['barney']
7185 *
7186 * // The `_.property` iteratee shorthand.
7187 * _.dropRightWhile(users, 'active');
7188 * // => objects for ['barney', 'fred', 'pebbles']
7189 */
7190 function dropRightWhile(array, predicate) {
7191 return (array && array.length)
7192 ? baseWhile(array, getIteratee(predicate, 3), true, true)
7193 : [];
7194 }
7195
7196 /**
7197 * Creates a slice of `array` excluding elements dropped from the beginning.
7198 * Elements are dropped until `predicate` returns falsey. The predicate is
7199 * invoked with three arguments: (value, index, array).
7200 *
7201 * @static
7202 * @memberOf _
7203 * @since 3.0.0
7204 * @category Array
7205 * @param {Array} array The array to query.
7206 * @param {Function} [predicate=_.identity] The function invoked per iteration.
7207 * @returns {Array} Returns the slice of `array`.
7208 * @example
7209 *
7210 * var users = [
7211 * { 'user': 'barney', 'active': false },
7212 * { 'user': 'fred', 'active': false },
7213 * { 'user': 'pebbles', 'active': true }
7214 * ];
7215 *
7216 * _.dropWhile(users, function(o) { return !o.active; });
7217 * // => objects for ['pebbles']
7218 *
7219 * // The `_.matches` iteratee shorthand.
7220 * _.dropWhile(users, { 'user': 'barney', 'active': false });
7221 * // => objects for ['fred', 'pebbles']
7222 *
7223 * // The `_.matchesProperty` iteratee shorthand.
7224 * _.dropWhile(users, ['active', false]);
7225 * // => objects for ['pebbles']
7226 *
7227 * // The `_.property` iteratee shorthand.
7228 * _.dropWhile(users, 'active');
7229 * // => objects for ['barney', 'fred', 'pebbles']
7230 */
7231 function dropWhile(array, predicate) {
7232 return (array && array.length)
7233 ? baseWhile(array, getIteratee(predicate, 3), true)
7234 : [];
7235 }
7236
7237 /**
7238 * Fills elements of `array` with `value` from `start` up to, but not
7239 * including, `end`.
7240 *
7241 * **Note:** This method mutates `array`.
7242 *
7243 * @static
7244 * @memberOf _
7245 * @since 3.2.0
7246 * @category Array
7247 * @param {Array} array The array to fill.
7248 * @param {*} value The value to fill `array` with.
7249 * @param {number} [start=0] The start position.
7250 * @param {number} [end=array.length] The end position.
7251 * @returns {Array} Returns `array`.
7252 * @example
7253 *
7254 * var array = [1, 2, 3];
7255 *
7256 * _.fill(array, 'a');
7257 * console.log(array);
7258 * // => ['a', 'a', 'a']
7259 *
7260 * _.fill(Array(3), 2);
7261 * // => [2, 2, 2]
7262 *
7263 * _.fill([4, 6, 8, 10], '*', 1, 3);
7264 * // => [4, '*', '*', 10]
7265 */
7266 function fill(array, value, start, end) {
7267 var length = array == null ? 0 : array.length;
7268 if (!length) {
7269 return [];
7270 }
7271 if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
7272 start = 0;
7273 end = length;
7274 }
7275 return baseFill(array, value, start, end);
7276 }
7277
7278 /**
7279 * This method is like `_.find` except that it returns the index of the first
7280 * element `predicate` returns truthy for instead of the element itself.
7281 *
7282 * @static
7283 * @memberOf _
7284 * @since 1.1.0
7285 * @category Array
7286 * @param {Array} array The array to inspect.
7287 * @param {Function} [predicate=_.identity] The function invoked per iteration.
7288 * @param {number} [fromIndex=0] The index to search from.
7289 * @returns {number} Returns the index of the found element, else `-1`.
7290 * @example
7291 *
7292 * var users = [
7293 * { 'user': 'barney', 'active': false },
7294 * { 'user': 'fred', 'active': false },
7295 * { 'user': 'pebbles', 'active': true }
7296 * ];
7297 *
7298 * _.findIndex(users, function(o) { return o.user == 'barney'; });
7299 * // => 0
7300 *
7301 * // The `_.matches` iteratee shorthand.
7302 * _.findIndex(users, { 'user': 'fred', 'active': false });
7303 * // => 1
7304 *
7305 * // The `_.matchesProperty` iteratee shorthand.
7306 * _.findIndex(users, ['active', false]);
7307 * // => 0
7308 *
7309 * // The `_.property` iteratee shorthand.
7310 * _.findIndex(users, 'active');
7311 * // => 2
7312 */
7313 function findIndex(array, predicate, fromIndex) {
7314 var length = array == null ? 0 : array.length;
7315 if (!length) {
7316 return -1;
7317 }
7318 var index = fromIndex == null ? 0 : toInteger(fromIndex);
7319 if (index < 0) {
7320 index = nativeMax(length + index, 0);
7321 }
7322 return baseFindIndex(array, getIteratee(predicate, 3), index);
7323 }
7324
7325 /**
7326 * This method is like `_.findIndex` except that it iterates over elements
7327 * of `collection` from right to left.
7328 *
7329 * @static
7330 * @memberOf _
7331 * @since 2.0.0
7332 * @category Array
7333 * @param {Array} array The array to inspect.
7334 * @param {Function} [predicate=_.identity] The function invoked per iteration.
7335 * @param {number} [fromIndex=array.length-1] The index to search from.
7336 * @returns {number} Returns the index of the found element, else `-1`.
7337 * @example
7338 *
7339 * var users = [
7340 * { 'user': 'barney', 'active': true },
7341 * { 'user': 'fred', 'active': false },
7342 * { 'user': 'pebbles', 'active': false }
7343 * ];
7344 *
7345 * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
7346 * // => 2
7347 *
7348 * // The `_.matches` iteratee shorthand.
7349 * _.findLastIndex(users, { 'user': 'barney', 'active': true });
7350 * // => 0
7351 *
7352 * // The `_.matchesProperty` iteratee shorthand.
7353 * _.findLastIndex(users, ['active', false]);
7354 * // => 2
7355 *
7356 * // The `_.property` iteratee shorthand.
7357 * _.findLastIndex(users, 'active');
7358 * // => 0
7359 */
7360 function findLastIndex(array, predicate, fromIndex) {
7361 var length = array == null ? 0 : array.length;
7362 if (!length) {
7363 return -1;
7364 }
7365 var index = length - 1;
7366 if (fromIndex !== undefined) {
7367 index = toInteger(fromIndex);
7368 index = fromIndex < 0
7369 ? nativeMax(length + index, 0)
7370 : nativeMin(index, length - 1);
7371 }
7372 return baseFindIndex(array, getIteratee(predicate, 3), index, true);
7373 }
7374
7375 /**
7376 * Flattens `array` a single level deep.
7377 *
7378 * @static
7379 * @memberOf _
7380 * @since 0.1.0
7381 * @category Array
7382 * @param {Array} array The array to flatten.
7383 * @returns {Array} Returns the new flattened array.
7384 * @example
7385 *
7386 * _.flatten([1, [2, [3, [4]], 5]]);
7387 * // => [1, 2, [3, [4]], 5]
7388 */
7389 function flatten(array) {
7390 var length = array == null ? 0 : array.length;
7391 return length ? baseFlatten(array, 1) : [];
7392 }
7393
7394 /**
7395 * Recursively flattens `array`.
7396 *
7397 * @static
7398 * @memberOf _
7399 * @since 3.0.0
7400 * @category Array
7401 * @param {Array} array The array to flatten.
7402 * @returns {Array} Returns the new flattened array.
7403 * @example
7404 *
7405 * _.flattenDeep([1, [2, [3, [4]], 5]]);
7406 * // => [1, 2, 3, 4, 5]
7407 */
7408 function flattenDeep(array) {
7409 var length = array == null ? 0 : array.length;
7410 return length ? baseFlatten(array, INFINITY) : [];
7411 }
7412
7413 /**
7414 * Recursively flatten `array` up to `depth` times.
7415 *
7416 * @static
7417 * @memberOf _
7418 * @since 4.4.0
7419 * @category Array
7420 * @param {Array} array The array to flatten.
7421 * @param {number} [depth=1] The maximum recursion depth.
7422 * @returns {Array} Returns the new flattened array.
7423 * @example
7424 *
7425 * var array = [1, [2, [3, [4]], 5]];
7426 *
7427 * _.flattenDepth(array, 1);
7428 * // => [1, 2, [3, [4]], 5]
7429 *
7430 * _.flattenDepth(array, 2);
7431 * // => [1, 2, 3, [4], 5]
7432 */
7433 function flattenDepth(array, depth) {
7434 var length = array == null ? 0 : array.length;
7435 if (!length) {
7436 return [];
7437 }
7438 depth = depth === undefined ? 1 : toInteger(depth);
7439 return baseFlatten(array, depth);
7440 }
7441
7442 /**
7443 * The inverse of `_.toPairs`; this method returns an object composed
7444 * from key-value `pairs`.
7445 *
7446 * @static
7447 * @memberOf _
7448 * @since 4.0.0
7449 * @category Array
7450 * @param {Array} pairs The key-value pairs.
7451 * @returns {Object} Returns the new object.
7452 * @example
7453 *
7454 * _.fromPairs([['a', 1], ['b', 2]]);
7455 * // => { 'a': 1, 'b': 2 }
7456 */
7457 function fromPairs(pairs) {
7458 var index = -1,
7459 length = pairs == null ? 0 : pairs.length,
7460 result = {};
7461
7462 while (++index < length) {
7463 var pair = pairs[index];
7464 result[pair[0]] = pair[1];
7465 }
7466 return result;
7467 }
7468
7469 /**
7470 * Gets the first element of `array`.
7471 *
7472 * @static
7473 * @memberOf _
7474 * @since 0.1.0
7475 * @alias first
7476 * @category Array
7477 * @param {Array} array The array to query.
7478 * @returns {*} Returns the first element of `array`.
7479 * @example
7480 *
7481 * _.head([1, 2, 3]);
7482 * // => 1
7483 *
7484 * _.head([]);
7485 * // => undefined
7486 */
7487 function head(array) {
7488 return (array && array.length) ? array[0] : undefined;
7489 }
7490
7491 /**
7492 * Gets the index at which the first occurrence of `value` is found in `array`
7493 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7494 * for equality comparisons. If `fromIndex` is negative, it's used as the
7495 * offset from the end of `array`.
7496 *
7497 * @static
7498 * @memberOf _
7499 * @since 0.1.0
7500 * @category Array
7501 * @param {Array} array The array to inspect.
7502 * @param {*} value The value to search for.
7503 * @param {number} [fromIndex=0] The index to search from.
7504 * @returns {number} Returns the index of the matched value, else `-1`.
7505 * @example
7506 *
7507 * _.indexOf([1, 2, 1, 2], 2);
7508 * // => 1
7509 *
7510 * // Search from the `fromIndex`.
7511 * _.indexOf([1, 2, 1, 2], 2, 2);
7512 * // => 3
7513 */
7514 function indexOf(array, value, fromIndex) {
7515 var length = array == null ? 0 : array.length;
7516 if (!length) {
7517 return -1;
7518 }
7519 var index = fromIndex == null ? 0 : toInteger(fromIndex);
7520 if (index < 0) {
7521 index = nativeMax(length + index, 0);
7522 }
7523 return baseIndexOf(array, value, index);
7524 }
7525
7526 /**
7527 * Gets all but the last element of `array`.
7528 *
7529 * @static
7530 * @memberOf _
7531 * @since 0.1.0
7532 * @category Array
7533 * @param {Array} array The array to query.
7534 * @returns {Array} Returns the slice of `array`.
7535 * @example
7536 *
7537 * _.initial([1, 2, 3]);
7538 * // => [1, 2]
7539 */
7540 function initial(array) {
7541 var length = array == null ? 0 : array.length;
7542 return length ? baseSlice(array, 0, -1) : [];
7543 }
7544
7545 /**
7546 * Creates an array of unique values that are included in all given arrays
7547 * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7548 * for equality comparisons. The order and references of result values are
7549 * determined by the first array.
7550 *
7551 * @static
7552 * @memberOf _
7553 * @since 0.1.0
7554 * @category Array
7555 * @param {...Array} [arrays] The arrays to inspect.
7556 * @returns {Array} Returns the new array of intersecting values.
7557 * @example
7558 *
7559 * _.intersection([2, 1], [2, 3]);
7560 * // => [2]
7561 */
7562 var intersection = baseRest(function(arrays) {
7563 var mapped = arrayMap(arrays, castArrayLikeObject);
7564 return (mapped.length && mapped[0] === arrays[0])
7565 ? baseIntersection(mapped)
7566 : [];
7567 });
7568
7569 /**
7570 * This method is like `_.intersection` except that it accepts `iteratee`
7571 * which is invoked for each element of each `arrays` to generate the criterion
7572 * by which they're compared. The order and references of result values are
7573 * determined by the first array. The iteratee is invoked with one argument:
7574 * (value).
7575 *
7576 * @static
7577 * @memberOf _
7578 * @since 4.0.0
7579 * @category Array
7580 * @param {...Array} [arrays] The arrays to inspect.
7581 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
7582 * @returns {Array} Returns the new array of intersecting values.
7583 * @example
7584 *
7585 * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
7586 * // => [2.1]
7587 *
7588 * // The `_.property` iteratee shorthand.
7589 * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
7590 * // => [{ 'x': 1 }]
7591 */
7592 var intersectionBy = baseRest(function(arrays) {
7593 var iteratee = last(arrays),
7594 mapped = arrayMap(arrays, castArrayLikeObject);
7595
7596 if (iteratee === last(mapped)) {
7597 iteratee = undefined;
7598 } else {
7599 mapped.pop();
7600 }
7601 return (mapped.length && mapped[0] === arrays[0])
7602 ? baseIntersection(mapped, getIteratee(iteratee, 2))
7603 : [];
7604 });
7605
7606 /**
7607 * This method is like `_.intersection` except that it accepts `comparator`
7608 * which is invoked to compare elements of `arrays`. The order and references
7609 * of result values are determined by the first array. The comparator is
7610 * invoked with two arguments: (arrVal, othVal).
7611 *
7612 * @static
7613 * @memberOf _
7614 * @since 4.0.0
7615 * @category Array
7616 * @param {...Array} [arrays] The arrays to inspect.
7617 * @param {Function} [comparator] The comparator invoked per element.
7618 * @returns {Array} Returns the new array of intersecting values.
7619 * @example
7620 *
7621 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
7622 * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
7623 *
7624 * _.intersectionWith(objects, others, _.isEqual);
7625 * // => [{ 'x': 1, 'y': 2 }]
7626 */
7627 var intersectionWith = baseRest(function(arrays) {
7628 var comparator = last(arrays),
7629 mapped = arrayMap(arrays, castArrayLikeObject);
7630
7631 comparator = typeof comparator == 'function' ? comparator : undefined;
7632 if (comparator) {
7633 mapped.pop();
7634 }
7635 return (mapped.length && mapped[0] === arrays[0])
7636 ? baseIntersection(mapped, undefined, comparator)
7637 : [];
7638 });
7639
7640 /**
7641 * Converts all elements in `array` into a string separated by `separator`.
7642 *
7643 * @static
7644 * @memberOf _
7645 * @since 4.0.0
7646 * @category Array
7647 * @param {Array} array The array to convert.
7648 * @param {string} [separator=','] The element separator.
7649 * @returns {string} Returns the joined string.
7650 * @example
7651 *
7652 * _.join(['a', 'b', 'c'], '~');
7653 * // => 'a~b~c'
7654 */
7655 function join(array, separator) {
7656 return array == null ? '' : nativeJoin.call(array, separator);
7657 }
7658
7659 /**
7660 * Gets the last element of `array`.
7661 *
7662 * @static
7663 * @memberOf _
7664 * @since 0.1.0
7665 * @category Array
7666 * @param {Array} array The array to query.
7667 * @returns {*} Returns the last element of `array`.
7668 * @example
7669 *
7670 * _.last([1, 2, 3]);
7671 * // => 3
7672 */
7673 function last(array) {
7674 var length = array == null ? 0 : array.length;
7675 return length ? array[length - 1] : undefined;
7676 }
7677
7678 /**
7679 * This method is like `_.indexOf` except that it iterates over elements of
7680 * `array` from right to left.
7681 *
7682 * @static
7683 * @memberOf _
7684 * @since 0.1.0
7685 * @category Array
7686 * @param {Array} array The array to inspect.
7687 * @param {*} value The value to search for.
7688 * @param {number} [fromIndex=array.length-1] The index to search from.
7689 * @returns {number} Returns the index of the matched value, else `-1`.
7690 * @example
7691 *
7692 * _.lastIndexOf([1, 2, 1, 2], 2);
7693 * // => 3
7694 *
7695 * // Search from the `fromIndex`.
7696 * _.lastIndexOf([1, 2, 1, 2], 2, 2);
7697 * // => 1
7698 */
7699 function lastIndexOf(array, value, fromIndex) {
7700 var length = array == null ? 0 : array.length;
7701 if (!length) {
7702 return -1;
7703 }
7704 var index = length;
7705 if (fromIndex !== undefined) {
7706 index = toInteger(fromIndex);
7707 index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
7708 }
7709 return value === value
7710 ? strictLastIndexOf(array, value, index)
7711 : baseFindIndex(array, baseIsNaN, index, true);
7712 }
7713
7714 /**
7715 * Gets the element at index `n` of `array`. If `n` is negative, the nth
7716 * element from the end is returned.
7717 *
7718 * @static
7719 * @memberOf _
7720 * @since 4.11.0
7721 * @category Array
7722 * @param {Array} array The array to query.
7723 * @param {number} [n=0] The index of the element to return.
7724 * @returns {*} Returns the nth element of `array`.
7725 * @example
7726 *
7727 * var array = ['a', 'b', 'c', 'd'];
7728 *
7729 * _.nth(array, 1);
7730 * // => 'b'
7731 *
7732 * _.nth(array, -2);
7733 * // => 'c';
7734 */
7735 function nth(array, n) {
7736 return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;
7737 }
7738
7739 /**
7740 * Removes all given values from `array` using
7741 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
7742 * for equality comparisons.
7743 *
7744 * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
7745 * to remove elements from an array by predicate.
7746 *
7747 * @static
7748 * @memberOf _
7749 * @since 2.0.0
7750 * @category Array
7751 * @param {Array} array The array to modify.
7752 * @param {...*} [values] The values to remove.
7753 * @returns {Array} Returns `array`.
7754 * @example
7755 *
7756 * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
7757 *
7758 * _.pull(array, 'a', 'c');
7759 * console.log(array);
7760 * // => ['b', 'b']
7761 */
7762 var pull = baseRest(pullAll);
7763
7764 /**
7765 * This method is like `_.pull` except that it accepts an array of values to remove.
7766 *
7767 * **Note:** Unlike `_.difference`, this method mutates `array`.
7768 *
7769 * @static
7770 * @memberOf _
7771 * @since 4.0.0
7772 * @category Array
7773 * @param {Array} array The array to modify.
7774 * @param {Array} values The values to remove.
7775 * @returns {Array} Returns `array`.
7776 * @example
7777 *
7778 * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
7779 *
7780 * _.pullAll(array, ['a', 'c']);
7781 * console.log(array);
7782 * // => ['b', 'b']
7783 */
7784 function pullAll(array, values) {
7785 return (array && array.length && values && values.length)
7786 ? basePullAll(array, values)
7787 : array;
7788 }
7789
7790 /**
7791 * This method is like `_.pullAll` except that it accepts `iteratee` which is
7792 * invoked for each element of `array` and `values` to generate the criterion
7793 * by which they're compared. The iteratee is invoked with one argument: (value).
7794 *
7795 * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
7796 *
7797 * @static
7798 * @memberOf _
7799 * @since 4.0.0
7800 * @category Array
7801 * @param {Array} array The array to modify.
7802 * @param {Array} values The values to remove.
7803 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
7804 * @returns {Array} Returns `array`.
7805 * @example
7806 *
7807 * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
7808 *
7809 * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
7810 * console.log(array);
7811 * // => [{ 'x': 2 }]
7812 */
7813 function pullAllBy(array, values, iteratee) {
7814 return (array && array.length && values && values.length)
7815 ? basePullAll(array, values, getIteratee(iteratee, 2))
7816 : array;
7817 }
7818
7819 /**
7820 * This method is like `_.pullAll` except that it accepts `comparator` which
7821 * is invoked to compare elements of `array` to `values`. The comparator is
7822 * invoked with two arguments: (arrVal, othVal).
7823 *
7824 * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
7825 *
7826 * @static
7827 * @memberOf _
7828 * @since 4.6.0
7829 * @category Array
7830 * @param {Array} array The array to modify.
7831 * @param {Array} values The values to remove.
7832 * @param {Function} [comparator] The comparator invoked per element.
7833 * @returns {Array} Returns `array`.
7834 * @example
7835 *
7836 * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
7837 *
7838 * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
7839 * console.log(array);
7840 * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
7841 */
7842 function pullAllWith(array, values, comparator) {
7843 return (array && array.length && values && values.length)
7844 ? basePullAll(array, values, undefined, comparator)
7845 : array;
7846 }
7847
7848 /**
7849 * Removes elements from `array` corresponding to `indexes` and returns an
7850 * array of removed elements.
7851 *
7852 * **Note:** Unlike `_.at`, this method mutates `array`.
7853 *
7854 * @static
7855 * @memberOf _
7856 * @since 3.0.0
7857 * @category Array
7858 * @param {Array} array The array to modify.
7859 * @param {...(number|number[])} [indexes] The indexes of elements to remove.
7860 * @returns {Array} Returns the new array of removed elements.
7861 * @example
7862 *
7863 * var array = ['a', 'b', 'c', 'd'];
7864 * var pulled = _.pullAt(array, [1, 3]);
7865 *
7866 * console.log(array);
7867 * // => ['a', 'c']
7868 *
7869 * console.log(pulled);
7870 * // => ['b', 'd']
7871 */
7872 var pullAt = flatRest(function(array, indexes) {
7873 var length = array == null ? 0 : array.length,
7874 result = baseAt(array, indexes);
7875
7876 basePullAt(array, arrayMap(indexes, function(index) {
7877 return isIndex(index, length) ? +index : index;
7878 }).sort(compareAscending));
7879
7880 return result;
7881 });
7882
7883 /**
7884 * Removes all elements from `array` that `predicate` returns truthy for
7885 * and returns an array of the removed elements. The predicate is invoked
7886 * with three arguments: (value, index, array).
7887 *
7888 * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
7889 * to pull elements from an array by value.
7890 *
7891 * @static
7892 * @memberOf _
7893 * @since 2.0.0
7894 * @category Array
7895 * @param {Array} array The array to modify.
7896 * @param {Function} [predicate=_.identity] The function invoked per iteration.
7897 * @returns {Array} Returns the new array of removed elements.
7898 * @example
7899 *
7900 * var array = [1, 2, 3, 4];
7901 * var evens = _.remove(array, function(n) {
7902 * return n % 2 == 0;
7903 * });
7904 *
7905 * console.log(array);
7906 * // => [1, 3]
7907 *
7908 * console.log(evens);
7909 * // => [2, 4]
7910 */
7911 function remove(array, predicate) {
7912 var result = [];
7913 if (!(array && array.length)) {
7914 return result;
7915 }
7916 var index = -1,
7917 indexes = [],
7918 length = array.length;
7919
7920 predicate = getIteratee(predicate, 3);
7921 while (++index < length) {
7922 var value = array[index];
7923 if (predicate(value, index, array)) {
7924 result.push(value);
7925 indexes.push(index);
7926 }
7927 }
7928 basePullAt(array, indexes);
7929 return result;
7930 }
7931
7932 /**
7933 * Reverses `array` so that the first element becomes the last, the second
7934 * element becomes the second to last, and so on.
7935 *
7936 * **Note:** This method mutates `array` and is based on
7937 * [`Array#reverse`](https://mdn.io/Array/reverse).
7938 *
7939 * @static
7940 * @memberOf _
7941 * @since 4.0.0
7942 * @category Array
7943 * @param {Array} array The array to modify.
7944 * @returns {Array} Returns `array`.
7945 * @example
7946 *
7947 * var array = [1, 2, 3];
7948 *
7949 * _.reverse(array);
7950 * // => [3, 2, 1]
7951 *
7952 * console.log(array);
7953 * // => [3, 2, 1]
7954 */
7955 function reverse(array) {
7956 return array == null ? array : nativeReverse.call(array);
7957 }
7958
7959 /**
7960 * Creates a slice of `array` from `start` up to, but not including, `end`.
7961 *
7962 * **Note:** This method is used instead of
7963 * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
7964 * returned.
7965 *
7966 * @static
7967 * @memberOf _
7968 * @since 3.0.0
7969 * @category Array
7970 * @param {Array} array The array to slice.
7971 * @param {number} [start=0] The start position.
7972 * @param {number} [end=array.length] The end position.
7973 * @returns {Array} Returns the slice of `array`.
7974 */
7975 function slice(array, start, end) {
7976 var length = array == null ? 0 : array.length;
7977 if (!length) {
7978 return [];
7979 }
7980 if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
7981 start = 0;
7982 end = length;
7983 }
7984 else {
7985 start = start == null ? 0 : toInteger(start);
7986 end = end === undefined ? length : toInteger(end);
7987 }
7988 return baseSlice(array, start, end);
7989 }
7990
7991 /**
7992 * Uses a binary search to determine the lowest index at which `value`
7993 * should be inserted into `array` in order to maintain its sort order.
7994 *
7995 * @static
7996 * @memberOf _
7997 * @since 0.1.0
7998 * @category Array
7999 * @param {Array} array The sorted array to inspect.
8000 * @param {*} value The value to evaluate.
8001 * @returns {number} Returns the index at which `value` should be inserted
8002 * into `array`.
8003 * @example
8004 *
8005 * _.sortedIndex([30, 50], 40);
8006 * // => 1
8007 */
8008 function sortedIndex(array, value) {
8009 return baseSortedIndex(array, value);
8010 }
8011
8012 /**
8013 * This method is like `_.sortedIndex` except that it accepts `iteratee`
8014 * which is invoked for `value` and each element of `array` to compute their
8015 * sort ranking. The iteratee is invoked with one argument: (value).
8016 *
8017 * @static
8018 * @memberOf _
8019 * @since 4.0.0
8020 * @category Array
8021 * @param {Array} array The sorted array to inspect.
8022 * @param {*} value The value to evaluate.
8023 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
8024 * @returns {number} Returns the index at which `value` should be inserted
8025 * into `array`.
8026 * @example
8027 *
8028 * var objects = [{ 'x': 4 }, { 'x': 5 }];
8029 *
8030 * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
8031 * // => 0
8032 *
8033 * // The `_.property` iteratee shorthand.
8034 * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
8035 * // => 0
8036 */
8037 function sortedIndexBy(array, value, iteratee) {
8038 return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
8039 }
8040
8041 /**
8042 * This method is like `_.indexOf` except that it performs a binary
8043 * search on a sorted `array`.
8044 *
8045 * @static
8046 * @memberOf _
8047 * @since 4.0.0
8048 * @category Array
8049 * @param {Array} array The array to inspect.
8050 * @param {*} value The value to search for.
8051 * @returns {number} Returns the index of the matched value, else `-1`.
8052 * @example
8053 *
8054 * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
8055 * // => 1
8056 */
8057 function sortedIndexOf(array, value) {
8058 var length = array == null ? 0 : array.length;
8059 if (length) {
8060 var index = baseSortedIndex(array, value);
8061 if (index < length && eq(array[index], value)) {
8062 return index;
8063 }
8064 }
8065 return -1;
8066 }
8067
8068 /**
8069 * This method is like `_.sortedIndex` except that it returns the highest
8070 * index at which `value` should be inserted into `array` in order to
8071 * maintain its sort order.
8072 *
8073 * @static
8074 * @memberOf _
8075 * @since 3.0.0
8076 * @category Array
8077 * @param {Array} array The sorted array to inspect.
8078 * @param {*} value The value to evaluate.
8079 * @returns {number} Returns the index at which `value` should be inserted
8080 * into `array`.
8081 * @example
8082 *
8083 * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
8084 * // => 4
8085 */
8086 function sortedLastIndex(array, value) {
8087 return baseSortedIndex(array, value, true);
8088 }
8089
8090 /**
8091 * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
8092 * which is invoked for `value` and each element of `array` to compute their
8093 * sort ranking. The iteratee is invoked with one argument: (value).
8094 *
8095 * @static
8096 * @memberOf _
8097 * @since 4.0.0
8098 * @category Array
8099 * @param {Array} array The sorted array to inspect.
8100 * @param {*} value The value to evaluate.
8101 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
8102 * @returns {number} Returns the index at which `value` should be inserted
8103 * into `array`.
8104 * @example
8105 *
8106 * var objects = [{ 'x': 4 }, { 'x': 5 }];
8107 *
8108 * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
8109 * // => 1
8110 *
8111 * // The `_.property` iteratee shorthand.
8112 * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
8113 * // => 1
8114 */
8115 function sortedLastIndexBy(array, value, iteratee) {
8116 return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
8117 }
8118
8119 /**
8120 * This method is like `_.lastIndexOf` except that it performs a binary
8121 * search on a sorted `array`.
8122 *
8123 * @static
8124 * @memberOf _
8125 * @since 4.0.0
8126 * @category Array
8127 * @param {Array} array The array to inspect.
8128 * @param {*} value The value to search for.
8129 * @returns {number} Returns the index of the matched value, else `-1`.
8130 * @example
8131 *
8132 * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
8133 * // => 3
8134 */
8135 function sortedLastIndexOf(array, value) {
8136 var length = array == null ? 0 : array.length;
8137 if (length) {
8138 var index = baseSortedIndex(array, value, true) - 1;
8139 if (eq(array[index], value)) {
8140 return index;
8141 }
8142 }
8143 return -1;
8144 }
8145
8146 /**
8147 * This method is like `_.uniq` except that it's designed and optimized
8148 * for sorted arrays.
8149 *
8150 * @static
8151 * @memberOf _
8152 * @since 4.0.0
8153 * @category Array
8154 * @param {Array} array The array to inspect.
8155 * @returns {Array} Returns the new duplicate free array.
8156 * @example
8157 *
8158 * _.sortedUniq([1, 1, 2]);
8159 * // => [1, 2]
8160 */
8161 function sortedUniq(array) {
8162 return (array && array.length)
8163 ? baseSortedUniq(array)
8164 : [];
8165 }
8166
8167 /**
8168 * This method is like `_.uniqBy` except that it's designed and optimized
8169 * for sorted arrays.
8170 *
8171 * @static
8172 * @memberOf _
8173 * @since 4.0.0
8174 * @category Array
8175 * @param {Array} array The array to inspect.
8176 * @param {Function} [iteratee] The iteratee invoked per element.
8177 * @returns {Array} Returns the new duplicate free array.
8178 * @example
8179 *
8180 * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
8181 * // => [1.1, 2.3]
8182 */
8183 function sortedUniqBy(array, iteratee) {
8184 return (array && array.length)
8185 ? baseSortedUniq(array, getIteratee(iteratee, 2))
8186 : [];
8187 }
8188
8189 /**
8190 * Gets all but the first element of `array`.
8191 *
8192 * @static
8193 * @memberOf _
8194 * @since 4.0.0
8195 * @category Array
8196 * @param {Array} array The array to query.
8197 * @returns {Array} Returns the slice of `array`.
8198 * @example
8199 *
8200 * _.tail([1, 2, 3]);
8201 * // => [2, 3]
8202 */
8203 function tail(array) {
8204 var length = array == null ? 0 : array.length;
8205 return length ? baseSlice(array, 1, length) : [];
8206 }
8207
8208 /**
8209 * Creates a slice of `array` with `n` elements taken from the beginning.
8210 *
8211 * @static
8212 * @memberOf _
8213 * @since 0.1.0
8214 * @category Array
8215 * @param {Array} array The array to query.
8216 * @param {number} [n=1] The number of elements to take.
8217 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
8218 * @returns {Array} Returns the slice of `array`.
8219 * @example
8220 *
8221 * _.take([1, 2, 3]);
8222 * // => [1]
8223 *
8224 * _.take([1, 2, 3], 2);
8225 * // => [1, 2]
8226 *
8227 * _.take([1, 2, 3], 5);
8228 * // => [1, 2, 3]
8229 *
8230 * _.take([1, 2, 3], 0);
8231 * // => []
8232 */
8233 function take(array, n, guard) {
8234 if (!(array && array.length)) {
8235 return [];
8236 }
8237 n = (guard || n === undefined) ? 1 : toInteger(n);
8238 return baseSlice(array, 0, n < 0 ? 0 : n);
8239 }
8240
8241 /**
8242 * Creates a slice of `array` with `n` elements taken from the end.
8243 *
8244 * @static
8245 * @memberOf _
8246 * @since 3.0.0
8247 * @category Array
8248 * @param {Array} array The array to query.
8249 * @param {number} [n=1] The number of elements to take.
8250 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
8251 * @returns {Array} Returns the slice of `array`.
8252 * @example
8253 *
8254 * _.takeRight([1, 2, 3]);
8255 * // => [3]
8256 *
8257 * _.takeRight([1, 2, 3], 2);
8258 * // => [2, 3]
8259 *
8260 * _.takeRight([1, 2, 3], 5);
8261 * // => [1, 2, 3]
8262 *
8263 * _.takeRight([1, 2, 3], 0);
8264 * // => []
8265 */
8266 function takeRight(array, n, guard) {
8267 var length = array == null ? 0 : array.length;
8268 if (!length) {
8269 return [];
8270 }
8271 n = (guard || n === undefined) ? 1 : toInteger(n);
8272 n = length - n;
8273 return baseSlice(array, n < 0 ? 0 : n, length);
8274 }
8275
8276 /**
8277 * Creates a slice of `array` with elements taken from the end. Elements are
8278 * taken until `predicate` returns falsey. The predicate is invoked with
8279 * three arguments: (value, index, array).
8280 *
8281 * @static
8282 * @memberOf _
8283 * @since 3.0.0
8284 * @category Array
8285 * @param {Array} array The array to query.
8286 * @param {Function} [predicate=_.identity] The function invoked per iteration.
8287 * @returns {Array} Returns the slice of `array`.
8288 * @example
8289 *
8290 * var users = [
8291 * { 'user': 'barney', 'active': true },
8292 * { 'user': 'fred', 'active': false },
8293 * { 'user': 'pebbles', 'active': false }
8294 * ];
8295 *
8296 * _.takeRightWhile(users, function(o) { return !o.active; });
8297 * // => objects for ['fred', 'pebbles']
8298 *
8299 * // The `_.matches` iteratee shorthand.
8300 * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
8301 * // => objects for ['pebbles']
8302 *
8303 * // The `_.matchesProperty` iteratee shorthand.
8304 * _.takeRightWhile(users, ['active', false]);
8305 * // => objects for ['fred', 'pebbles']
8306 *
8307 * // The `_.property` iteratee shorthand.
8308 * _.takeRightWhile(users, 'active');
8309 * // => []
8310 */
8311 function takeRightWhile(array, predicate) {
8312 return (array && array.length)
8313 ? baseWhile(array, getIteratee(predicate, 3), false, true)
8314 : [];
8315 }
8316
8317 /**
8318 * Creates a slice of `array` with elements taken from the beginning. Elements
8319 * are taken until `predicate` returns falsey. The predicate is invoked with
8320 * three arguments: (value, index, array).
8321 *
8322 * @static
8323 * @memberOf _
8324 * @since 3.0.0
8325 * @category Array
8326 * @param {Array} array The array to query.
8327 * @param {Function} [predicate=_.identity] The function invoked per iteration.
8328 * @returns {Array} Returns the slice of `array`.
8329 * @example
8330 *
8331 * var users = [
8332 * { 'user': 'barney', 'active': false },
8333 * { 'user': 'fred', 'active': false },
8334 * { 'user': 'pebbles', 'active': true }
8335 * ];
8336 *
8337 * _.takeWhile(users, function(o) { return !o.active; });
8338 * // => objects for ['barney', 'fred']
8339 *
8340 * // The `_.matches` iteratee shorthand.
8341 * _.takeWhile(users, { 'user': 'barney', 'active': false });
8342 * // => objects for ['barney']
8343 *
8344 * // The `_.matchesProperty` iteratee shorthand.
8345 * _.takeWhile(users, ['active', false]);
8346 * // => objects for ['barney', 'fred']
8347 *
8348 * // The `_.property` iteratee shorthand.
8349 * _.takeWhile(users, 'active');
8350 * // => []
8351 */
8352 function takeWhile(array, predicate) {
8353 return (array && array.length)
8354 ? baseWhile(array, getIteratee(predicate, 3))
8355 : [];
8356 }
8357
8358 /**
8359 * Creates an array of unique values, in order, from all given arrays using
8360 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
8361 * for equality comparisons.
8362 *
8363 * @static
8364 * @memberOf _
8365 * @since 0.1.0
8366 * @category Array
8367 * @param {...Array} [arrays] The arrays to inspect.
8368 * @returns {Array} Returns the new array of combined values.
8369 * @example
8370 *
8371 * _.union([2], [1, 2]);
8372 * // => [2, 1]
8373 */
8374 var union = baseRest(function(arrays) {
8375 return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
8376 });
8377
8378 /**
8379 * This method is like `_.union` except that it accepts `iteratee` which is
8380 * invoked for each element of each `arrays` to generate the criterion by
8381 * which uniqueness is computed. Result values are chosen from the first
8382 * array in which the value occurs. The iteratee is invoked with one argument:
8383 * (value).
8384 *
8385 * @static
8386 * @memberOf _
8387 * @since 4.0.0
8388 * @category Array
8389 * @param {...Array} [arrays] The arrays to inspect.
8390 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
8391 * @returns {Array} Returns the new array of combined values.
8392 * @example
8393 *
8394 * _.unionBy([2.1], [1.2, 2.3], Math.floor);
8395 * // => [2.1, 1.2]
8396 *
8397 * // The `_.property` iteratee shorthand.
8398 * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
8399 * // => [{ 'x': 1 }, { 'x': 2 }]
8400 */
8401 var unionBy = baseRest(function(arrays) {
8402 var iteratee = last(arrays);
8403 if (isArrayLikeObject(iteratee)) {
8404 iteratee = undefined;
8405 }
8406 return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
8407 });
8408
8409 /**
8410 * This method is like `_.union` except that it accepts `comparator` which
8411 * is invoked to compare elements of `arrays`. Result values are chosen from
8412 * the first array in which the value occurs. The comparator is invoked
8413 * with two arguments: (arrVal, othVal).
8414 *
8415 * @static
8416 * @memberOf _
8417 * @since 4.0.0
8418 * @category Array
8419 * @param {...Array} [arrays] The arrays to inspect.
8420 * @param {Function} [comparator] The comparator invoked per element.
8421 * @returns {Array} Returns the new array of combined values.
8422 * @example
8423 *
8424 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
8425 * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
8426 *
8427 * _.unionWith(objects, others, _.isEqual);
8428 * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
8429 */
8430 var unionWith = baseRest(function(arrays) {
8431 var comparator = last(arrays);
8432 comparator = typeof comparator == 'function' ? comparator : undefined;
8433 return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
8434 });
8435
8436 /**
8437 * Creates a duplicate-free version of an array, using
8438 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
8439 * for equality comparisons, in which only the first occurrence of each element
8440 * is kept. The order of result values is determined by the order they occur
8441 * in the array.
8442 *
8443 * @static
8444 * @memberOf _
8445 * @since 0.1.0
8446 * @category Array
8447 * @param {Array} array The array to inspect.
8448 * @returns {Array} Returns the new duplicate free array.
8449 * @example
8450 *
8451 * _.uniq([2, 1, 2]);
8452 * // => [2, 1]
8453 */
8454 function uniq(array) {
8455 return (array && array.length) ? baseUniq(array) : [];
8456 }
8457
8458 /**
8459 * This method is like `_.uniq` except that it accepts `iteratee` which is
8460 * invoked for each element in `array` to generate the criterion by which
8461 * uniqueness is computed. The order of result values is determined by the
8462 * order they occur in the array. The iteratee is invoked with one argument:
8463 * (value).
8464 *
8465 * @static
8466 * @memberOf _
8467 * @since 4.0.0
8468 * @category Array
8469 * @param {Array} array The array to inspect.
8470 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
8471 * @returns {Array} Returns the new duplicate free array.
8472 * @example
8473 *
8474 * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
8475 * // => [2.1, 1.2]
8476 *
8477 * // The `_.property` iteratee shorthand.
8478 * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
8479 * // => [{ 'x': 1 }, { 'x': 2 }]
8480 */
8481 function uniqBy(array, iteratee) {
8482 return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
8483 }
8484
8485 /**
8486 * This method is like `_.uniq` except that it accepts `comparator` which
8487 * is invoked to compare elements of `array`. The order of result values is
8488 * determined by the order they occur in the array.The comparator is invoked
8489 * with two arguments: (arrVal, othVal).
8490 *
8491 * @static
8492 * @memberOf _
8493 * @since 4.0.0
8494 * @category Array
8495 * @param {Array} array The array to inspect.
8496 * @param {Function} [comparator] The comparator invoked per element.
8497 * @returns {Array} Returns the new duplicate free array.
8498 * @example
8499 *
8500 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
8501 *
8502 * _.uniqWith(objects, _.isEqual);
8503 * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
8504 */
8505 function uniqWith(array, comparator) {
8506 comparator = typeof comparator == 'function' ? comparator : undefined;
8507 return (array && array.length) ? baseUniq(array, undefined, comparator) : [];
8508 }
8509
8510 /**
8511 * This method is like `_.zip` except that it accepts an array of grouped
8512 * elements and creates an array regrouping the elements to their pre-zip
8513 * configuration.
8514 *
8515 * @static
8516 * @memberOf _
8517 * @since 1.2.0
8518 * @category Array
8519 * @param {Array} array The array of grouped elements to process.
8520 * @returns {Array} Returns the new array of regrouped elements.
8521 * @example
8522 *
8523 * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
8524 * // => [['a', 1, true], ['b', 2, false]]
8525 *
8526 * _.unzip(zipped);
8527 * // => [['a', 'b'], [1, 2], [true, false]]
8528 */
8529 function unzip(array) {
8530 if (!(array && array.length)) {
8531 return [];
8532 }
8533 var length = 0;
8534 array = arrayFilter(array, function(group) {
8535 if (isArrayLikeObject(group)) {
8536 length = nativeMax(group.length, length);
8537 return true;
8538 }
8539 });
8540 return baseTimes(length, function(index) {
8541 return arrayMap(array, baseProperty(index));
8542 });
8543 }
8544
8545 /**
8546 * This method is like `_.unzip` except that it accepts `iteratee` to specify
8547 * how regrouped values should be combined. The iteratee is invoked with the
8548 * elements of each group: (...group).
8549 *
8550 * @static
8551 * @memberOf _
8552 * @since 3.8.0
8553 * @category Array
8554 * @param {Array} array The array of grouped elements to process.
8555 * @param {Function} [iteratee=_.identity] The function to combine
8556 * regrouped values.
8557 * @returns {Array} Returns the new array of regrouped elements.
8558 * @example
8559 *
8560 * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
8561 * // => [[1, 10, 100], [2, 20, 200]]
8562 *
8563 * _.unzipWith(zipped, _.add);
8564 * // => [3, 30, 300]
8565 */
8566 function unzipWith(array, iteratee) {
8567 if (!(array && array.length)) {
8568 return [];
8569 }
8570 var result = unzip(array);
8571 if (iteratee == null) {
8572 return result;
8573 }
8574 return arrayMap(result, function(group) {
8575 return apply(iteratee, undefined, group);
8576 });
8577 }
8578
8579 /**
8580 * Creates an array excluding all given values using
8581 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
8582 * for equality comparisons.
8583 *
8584 * **Note:** Unlike `_.pull`, this method returns a new array.
8585 *
8586 * @static
8587 * @memberOf _
8588 * @since 0.1.0
8589 * @category Array
8590 * @param {Array} array The array to inspect.
8591 * @param {...*} [values] The values to exclude.
8592 * @returns {Array} Returns the new array of filtered values.
8593 * @see _.difference, _.xor
8594 * @example
8595 *
8596 * _.without([2, 1, 2, 3], 1, 2);
8597 * // => [3]
8598 */
8599 var without = baseRest(function(array, values) {
8600 return isArrayLikeObject(array)
8601 ? baseDifference(array, values)
8602 : [];
8603 });
8604
8605 /**
8606 * Creates an array of unique values that is the
8607 * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
8608 * of the given arrays. The order of result values is determined by the order
8609 * they occur in the arrays.
8610 *
8611 * @static
8612 * @memberOf _
8613 * @since 2.4.0
8614 * @category Array
8615 * @param {...Array} [arrays] The arrays to inspect.
8616 * @returns {Array} Returns the new array of filtered values.
8617 * @see _.difference, _.without
8618 * @example
8619 *
8620 * _.xor([2, 1], [2, 3]);
8621 * // => [1, 3]
8622 */
8623 var xor = baseRest(function(arrays) {
8624 return baseXor(arrayFilter(arrays, isArrayLikeObject));
8625 });
8626
8627 /**
8628 * This method is like `_.xor` except that it accepts `iteratee` which is
8629 * invoked for each element of each `arrays` to generate the criterion by
8630 * which by which they're compared. The order of result values is determined
8631 * by the order they occur in the arrays. The iteratee is invoked with one
8632 * argument: (value).
8633 *
8634 * @static
8635 * @memberOf _
8636 * @since 4.0.0
8637 * @category Array
8638 * @param {...Array} [arrays] The arrays to inspect.
8639 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
8640 * @returns {Array} Returns the new array of filtered values.
8641 * @example
8642 *
8643 * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
8644 * // => [1.2, 3.4]
8645 *
8646 * // The `_.property` iteratee shorthand.
8647 * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
8648 * // => [{ 'x': 2 }]
8649 */
8650 var xorBy = baseRest(function(arrays) {
8651 var iteratee = last(arrays);
8652 if (isArrayLikeObject(iteratee)) {
8653 iteratee = undefined;
8654 }
8655 return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
8656 });
8657
8658 /**
8659 * This method is like `_.xor` except that it accepts `comparator` which is
8660 * invoked to compare elements of `arrays`. The order of result values is
8661 * determined by the order they occur in the arrays. The comparator is invoked
8662 * with two arguments: (arrVal, othVal).
8663 *
8664 * @static
8665 * @memberOf _
8666 * @since 4.0.0
8667 * @category Array
8668 * @param {...Array} [arrays] The arrays to inspect.
8669 * @param {Function} [comparator] The comparator invoked per element.
8670 * @returns {Array} Returns the new array of filtered values.
8671 * @example
8672 *
8673 * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
8674 * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
8675 *
8676 * _.xorWith(objects, others, _.isEqual);
8677 * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
8678 */
8679 var xorWith = baseRest(function(arrays) {
8680 var comparator = last(arrays);
8681 comparator = typeof comparator == 'function' ? comparator : undefined;
8682 return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);
8683 });
8684
8685 /**
8686 * Creates an array of grouped elements, the first of which contains the
8687 * first elements of the given arrays, the second of which contains the
8688 * second elements of the given arrays, and so on.
8689 *
8690 * @static
8691 * @memberOf _
8692 * @since 0.1.0
8693 * @category Array
8694 * @param {...Array} [arrays] The arrays to process.
8695 * @returns {Array} Returns the new array of grouped elements.
8696 * @example
8697 *
8698 * _.zip(['a', 'b'], [1, 2], [true, false]);
8699 * // => [['a', 1, true], ['b', 2, false]]
8700 */
8701 var zip = baseRest(unzip);
8702
8703 /**
8704 * This method is like `_.fromPairs` except that it accepts two arrays,
8705 * one of property identifiers and one of corresponding values.
8706 *
8707 * @static
8708 * @memberOf _
8709 * @since 0.4.0
8710 * @category Array
8711 * @param {Array} [props=[]] The property identifiers.
8712 * @param {Array} [values=[]] The property values.
8713 * @returns {Object} Returns the new object.
8714 * @example
8715 *
8716 * _.zipObject(['a', 'b'], [1, 2]);
8717 * // => { 'a': 1, 'b': 2 }
8718 */
8719 function zipObject(props, values) {
8720 return baseZipObject(props || [], values || [], assignValue);
8721 }
8722
8723 /**
8724 * This method is like `_.zipObject` except that it supports property paths.
8725 *
8726 * @static
8727 * @memberOf _
8728 * @since 4.1.0
8729 * @category Array
8730 * @param {Array} [props=[]] The property identifiers.
8731 * @param {Array} [values=[]] The property values.
8732 * @returns {Object} Returns the new object.
8733 * @example
8734 *
8735 * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
8736 * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
8737 */
8738 function zipObjectDeep(props, values) {
8739 return baseZipObject(props || [], values || [], baseSet);
8740 }
8741
8742 /**
8743 * This method is like `_.zip` except that it accepts `iteratee` to specify
8744 * how grouped values should be combined. The iteratee is invoked with the
8745 * elements of each group: (...group).
8746 *
8747 * @static
8748 * @memberOf _
8749 * @since 3.8.0
8750 * @category Array
8751 * @param {...Array} [arrays] The arrays to process.
8752 * @param {Function} [iteratee=_.identity] The function to combine
8753 * grouped values.
8754 * @returns {Array} Returns the new array of grouped elements.
8755 * @example
8756 *
8757 * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
8758 * return a + b + c;
8759 * });
8760 * // => [111, 222]
8761 */
8762 var zipWith = baseRest(function(arrays) {
8763 var length = arrays.length,
8764 iteratee = length > 1 ? arrays[length - 1] : undefined;
8765
8766 iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;
8767 return unzipWith(arrays, iteratee);
8768 });
8769
8770 /*------------------------------------------------------------------------*/
8771
8772 /**
8773 * Creates a `lodash` wrapper instance that wraps `value` with explicit method
8774 * chain sequences enabled. The result of such sequences must be unwrapped
8775 * with `_#value`.
8776 *
8777 * @static
8778 * @memberOf _
8779 * @since 1.3.0
8780 * @category Seq
8781 * @param {*} value The value to wrap.
8782 * @returns {Object} Returns the new `lodash` wrapper instance.
8783 * @example
8784 *
8785 * var users = [
8786 * { 'user': 'barney', 'age': 36 },
8787 * { 'user': 'fred', 'age': 40 },
8788 * { 'user': 'pebbles', 'age': 1 }
8789 * ];
8790 *
8791 * var youngest = _
8792 * .chain(users)
8793 * .sortBy('age')
8794 * .map(function(o) {
8795 * return o.user + ' is ' + o.age;
8796 * })
8797 * .head()
8798 * .value();
8799 * // => 'pebbles is 1'
8800 */
8801 function chain(value) {
8802 var result = lodash(value);
8803 result.__chain__ = true;
8804 return result;
8805 }
8806
8807 /**
8808 * This method invokes `interceptor` and returns `value`. The interceptor
8809 * is invoked with one argument; (value). The purpose of this method is to
8810 * "tap into" a method chain sequence in order to modify intermediate results.
8811 *
8812 * @static
8813 * @memberOf _
8814 * @since 0.1.0
8815 * @category Seq
8816 * @param {*} value The value to provide to `interceptor`.
8817 * @param {Function} interceptor The function to invoke.
8818 * @returns {*} Returns `value`.
8819 * @example
8820 *
8821 * _([1, 2, 3])
8822 * .tap(function(array) {
8823 * // Mutate input array.
8824 * array.pop();
8825 * })
8826 * .reverse()
8827 * .value();
8828 * // => [2, 1]
8829 */
8830 function tap(value, interceptor) {
8831 interceptor(value);
8832 return value;
8833 }
8834
8835 /**
8836 * This method is like `_.tap` except that it returns the result of `interceptor`.
8837 * The purpose of this method is to "pass thru" values replacing intermediate
8838 * results in a method chain sequence.
8839 *
8840 * @static
8841 * @memberOf _
8842 * @since 3.0.0
8843 * @category Seq
8844 * @param {*} value The value to provide to `interceptor`.
8845 * @param {Function} interceptor The function to invoke.
8846 * @returns {*} Returns the result of `interceptor`.
8847 * @example
8848 *
8849 * _(' abc ')
8850 * .chain()
8851 * .trim()
8852 * .thru(function(value) {
8853 * return [value];
8854 * })
8855 * .value();
8856 * // => ['abc']
8857 */
8858 function thru(value, interceptor) {
8859 return interceptor(value);
8860 }
8861
8862 /**
8863 * This method is the wrapper version of `_.at`.
8864 *
8865 * @name at
8866 * @memberOf _
8867 * @since 1.0.0
8868 * @category Seq
8869 * @param {...(string|string[])} [paths] The property paths to pick.
8870 * @returns {Object} Returns the new `lodash` wrapper instance.
8871 * @example
8872 *
8873 * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
8874 *
8875 * _(object).at(['a[0].b.c', 'a[1]']).value();
8876 * // => [3, 4]
8877 */
8878 var wrapperAt = flatRest(function(paths) {
8879 var length = paths.length,
8880 start = length ? paths[0] : 0,
8881 value = this.__wrapped__,
8882 interceptor = function(object) { return baseAt(object, paths); };
8883
8884 if (length > 1 || this.__actions__.length ||
8885 !(value instanceof LazyWrapper) || !isIndex(start)) {
8886 return this.thru(interceptor);
8887 }
8888 value = value.slice(start, +start + (length ? 1 : 0));
8889 value.__actions__.push({
8890 'func': thru,
8891 'args': [interceptor],
8892 'thisArg': undefined
8893 });
8894 return new LodashWrapper(value, this.__chain__).thru(function(array) {
8895 if (length && !array.length) {
8896 array.push(undefined);
8897 }
8898 return array;
8899 });
8900 });
8901
8902 /**
8903 * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
8904 *
8905 * @name chain
8906 * @memberOf _
8907 * @since 0.1.0
8908 * @category Seq
8909 * @returns {Object} Returns the new `lodash` wrapper instance.
8910 * @example
8911 *
8912 * var users = [
8913 * { 'user': 'barney', 'age': 36 },
8914 * { 'user': 'fred', 'age': 40 }
8915 * ];
8916 *
8917 * // A sequence without explicit chaining.
8918 * _(users).head();
8919 * // => { 'user': 'barney', 'age': 36 }
8920 *
8921 * // A sequence with explicit chaining.
8922 * _(users)
8923 * .chain()
8924 * .head()
8925 * .pick('user')
8926 * .value();
8927 * // => { 'user': 'barney' }
8928 */
8929 function wrapperChain() {
8930 return chain(this);
8931 }
8932
8933 /**
8934 * Executes the chain sequence and returns the wrapped result.
8935 *
8936 * @name commit
8937 * @memberOf _
8938 * @since 3.2.0
8939 * @category Seq
8940 * @returns {Object} Returns the new `lodash` wrapper instance.
8941 * @example
8942 *
8943 * var array = [1, 2];
8944 * var wrapped = _(array).push(3);
8945 *
8946 * console.log(array);
8947 * // => [1, 2]
8948 *
8949 * wrapped = wrapped.commit();
8950 * console.log(array);
8951 * // => [1, 2, 3]
8952 *
8953 * wrapped.last();
8954 * // => 3
8955 *
8956 * console.log(array);
8957 * // => [1, 2, 3]
8958 */
8959 function wrapperCommit() {
8960 return new LodashWrapper(this.value(), this.__chain__);
8961 }
8962
8963 /**
8964 * Gets the next value on a wrapped object following the
8965 * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
8966 *
8967 * @name next
8968 * @memberOf _
8969 * @since 4.0.0
8970 * @category Seq
8971 * @returns {Object} Returns the next iterator value.
8972 * @example
8973 *
8974 * var wrapped = _([1, 2]);
8975 *
8976 * wrapped.next();
8977 * // => { 'done': false, 'value': 1 }
8978 *
8979 * wrapped.next();
8980 * // => { 'done': false, 'value': 2 }
8981 *
8982 * wrapped.next();
8983 * // => { 'done': true, 'value': undefined }
8984 */
8985 function wrapperNext() {
8986 if (this.__values__ === undefined) {
8987 this.__values__ = toArray(this.value());
8988 }
8989 var done = this.__index__ >= this.__values__.length,
8990 value = done ? undefined : this.__values__[this.__index__++];
8991
8992 return { 'done': done, 'value': value };
8993 }
8994
8995 /**
8996 * Enables the wrapper to be iterable.
8997 *
8998 * @name Symbol.iterator
8999 * @memberOf _
9000 * @since 4.0.0
9001 * @category Seq
9002 * @returns {Object} Returns the wrapper object.
9003 * @example
9004 *
9005 * var wrapped = _([1, 2]);
9006 *
9007 * wrapped[Symbol.iterator]() === wrapped;
9008 * // => true
9009 *
9010 * Array.from(wrapped);
9011 * // => [1, 2]
9012 */
9013 function wrapperToIterator() {
9014 return this;
9015 }
9016
9017 /**
9018 * Creates a clone of the chain sequence planting `value` as the wrapped value.
9019 *
9020 * @name plant
9021 * @memberOf _
9022 * @since 3.2.0
9023 * @category Seq
9024 * @param {*} value The value to plant.
9025 * @returns {Object} Returns the new `lodash` wrapper instance.
9026 * @example
9027 *
9028 * function square(n) {
9029 * return n * n;
9030 * }
9031 *
9032 * var wrapped = _([1, 2]).map(square);
9033 * var other = wrapped.plant([3, 4]);
9034 *
9035 * other.value();
9036 * // => [9, 16]
9037 *
9038 * wrapped.value();
9039 * // => [1, 4]
9040 */
9041 function wrapperPlant(value) {
9042 var result,
9043 parent = this;
9044
9045 while (parent instanceof baseLodash) {
9046 var clone = wrapperClone(parent);
9047 clone.__index__ = 0;
9048 clone.__values__ = undefined;
9049 if (result) {
9050 previous.__wrapped__ = clone;
9051 } else {
9052 result = clone;
9053 }
9054 var previous = clone;
9055 parent = parent.__wrapped__;
9056 }
9057 previous.__wrapped__ = value;
9058 return result;
9059 }
9060
9061 /**
9062 * This method is the wrapper version of `_.reverse`.
9063 *
9064 * **Note:** This method mutates the wrapped array.
9065 *
9066 * @name reverse
9067 * @memberOf _
9068 * @since 0.1.0
9069 * @category Seq
9070 * @returns {Object} Returns the new `lodash` wrapper instance.
9071 * @example
9072 *
9073 * var array = [1, 2, 3];
9074 *
9075 * _(array).reverse().value()
9076 * // => [3, 2, 1]
9077 *
9078 * console.log(array);
9079 * // => [3, 2, 1]
9080 */
9081 function wrapperReverse() {
9082 var value = this.__wrapped__;
9083 if (value instanceof LazyWrapper) {
9084 var wrapped = value;
9085 if (this.__actions__.length) {
9086 wrapped = new LazyWrapper(this);
9087 }
9088 wrapped = wrapped.reverse();
9089 wrapped.__actions__.push({
9090 'func': thru,
9091 'args': [reverse],
9092 'thisArg': undefined
9093 });
9094 return new LodashWrapper(wrapped, this.__chain__);
9095 }
9096 return this.thru(reverse);
9097 }
9098
9099 /**
9100 * Executes the chain sequence to resolve the unwrapped value.
9101 *
9102 * @name value
9103 * @memberOf _
9104 * @since 0.1.0
9105 * @alias toJSON, valueOf
9106 * @category Seq
9107 * @returns {*} Returns the resolved unwrapped value.
9108 * @example
9109 *
9110 * _([1, 2, 3]).value();
9111 * // => [1, 2, 3]
9112 */
9113 function wrapperValue() {
9114 return baseWrapperValue(this.__wrapped__, this.__actions__);
9115 }
9116
9117 /*------------------------------------------------------------------------*/
9118
9119 /**
9120 * Creates an object composed of keys generated from the results of running
9121 * each element of `collection` thru `iteratee`. The corresponding value of
9122 * each key is the number of times the key was returned by `iteratee`. The
9123 * iteratee is invoked with one argument: (value).
9124 *
9125 * @static
9126 * @memberOf _
9127 * @since 0.5.0
9128 * @category Collection
9129 * @param {Array|Object} collection The collection to iterate over.
9130 * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
9131 * @returns {Object} Returns the composed aggregate object.
9132 * @example
9133 *
9134 * _.countBy([6.1, 4.2, 6.3], Math.floor);
9135 * // => { '4': 1, '6': 2 }
9136 *
9137 * // The `_.property` iteratee shorthand.
9138 * _.countBy(['one', 'two', 'three'], 'length');
9139 * // => { '3': 2, '5': 1 }
9140 */
9141 var countBy = createAggregator(function(result, value, key) {
9142 if (hasOwnProperty.call(result, key)) {
9143 ++result[key];
9144 } else {
9145 baseAssignValue(result, key, 1);
9146 }
9147 });
9148
9149 /**
9150 * Checks if `predicate` returns truthy for **all** elements of `collection`.
9151 * Iteration is stopped once `predicate` returns falsey. The predicate is
9152 * invoked with three arguments: (value, index|key, collection).
9153 *
9154 * **Note:** This method returns `true` for
9155 * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
9156 * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
9157 * elements of empty collections.
9158 *
9159 * @static
9160 * @memberOf _
9161 * @since 0.1.0
9162 * @category Collection
9163 * @param {Array|Object} collection The collection to iterate over.
9164 * @param {Function} [predicate=_.identity] The function invoked per iteration.
9165 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
9166 * @returns {boolean} Returns `true` if all elements pass the predicate check,
9167 * else `false`.
9168 * @example
9169 *
9170 * _.every([true, 1, null, 'yes'], Boolean);
9171 * // => false
9172 *
9173 * var users = [
9174 * { 'user': 'barney', 'age': 36, 'active': false },
9175 * { 'user': 'fred', 'age': 40, 'active': false }
9176 * ];
9177 *
9178 * // The `_.matches` iteratee shorthand.
9179 * _.every(users, { 'user': 'barney', 'active': false });
9180 * // => false
9181 *
9182 * // The `_.matchesProperty` iteratee shorthand.
9183 * _.every(users, ['active', false]);
9184 * // => true
9185 *
9186 * // The `_.property` iteratee shorthand.
9187 * _.every(users, 'active');
9188 * // => false
9189 */
9190 function every(collection, predicate, guard) {
9191 var func = isArray(collection) ? arrayEvery : baseEvery;
9192 if (guard && isIterateeCall(collection, predicate, guard)) {
9193 predicate = undefined;
9194 }
9195 return func(collection, getIteratee(predicate, 3));
9196 }
9197
9198 /**
9199 * Iterates over elements of `collection`, returning an array of all elements
9200 * `predicate` returns truthy for. The predicate is invoked with three
9201 * arguments: (value, index|key, collection).
9202 *
9203 * **Note:** Unlike `_.remove`, this method returns a new array.
9204 *
9205 * @static
9206 * @memberOf _
9207 * @since 0.1.0
9208 * @category Collection
9209 * @param {Array|Object} collection The collection to iterate over.
9210 * @param {Function} [predicate=_.identity] The function invoked per iteration.
9211 * @returns {Array} Returns the new filtered array.
9212 * @see _.reject
9213 * @example
9214 *
9215 * var users = [
9216 * { 'user': 'barney', 'age': 36, 'active': true },
9217 * { 'user': 'fred', 'age': 40, 'active': false }
9218 * ];
9219 *
9220 * _.filter(users, function(o) { return !o.active; });
9221 * // => objects for ['fred']
9222 *
9223 * // The `_.matches` iteratee shorthand.
9224 * _.filter(users, { 'age': 36, 'active': true });
9225 * // => objects for ['barney']
9226 *
9227 * // The `_.matchesProperty` iteratee shorthand.
9228 * _.filter(users, ['active', false]);
9229 * // => objects for ['fred']
9230 *
9231 * // The `_.property` iteratee shorthand.
9232 * _.filter(users, 'active');
9233 * // => objects for ['barney']
9234 *
9235 * // Combining several predicates using `_.overEvery` or `_.overSome`.
9236 * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
9237 * // => objects for ['fred', 'barney']
9238 */
9239 function filter(collection, predicate) {
9240 var func = isArray(collection) ? arrayFilter : baseFilter;
9241 return func(collection, getIteratee(predicate, 3));
9242 }
9243
9244 /**
9245 * Iterates over elements of `collection`, returning the first element
9246 * `predicate` returns truthy for. The predicate is invoked with three
9247 * arguments: (value, index|key, collection).
9248 *
9249 * @static
9250 * @memberOf _
9251 * @since 0.1.0
9252 * @category Collection
9253 * @param {Array|Object} collection The collection to inspect.
9254 * @param {Function} [predicate=_.identity] The function invoked per iteration.
9255 * @param {number} [fromIndex=0] The index to search from.
9256 * @returns {*} Returns the matched element, else `undefined`.
9257 * @example
9258 *
9259 * var users = [
9260 * { 'user': 'barney', 'age': 36, 'active': true },
9261 * { 'user': 'fred', 'age': 40, 'active': false },
9262 * { 'user': 'pebbles', 'age': 1, 'active': true }
9263 * ];
9264 *
9265 * _.find(users, function(o) { return o.age < 40; });
9266 * // => object for 'barney'
9267 *
9268 * // The `_.matches` iteratee shorthand.
9269 * _.find(users, { 'age': 1, 'active': true });
9270 * // => object for 'pebbles'
9271 *
9272 * // The `_.matchesProperty` iteratee shorthand.
9273 * _.find(users, ['active', false]);
9274 * // => object for 'fred'
9275 *
9276 * // The `_.property` iteratee shorthand.
9277 * _.find(users, 'active');
9278 * // => object for 'barney'
9279 */
9280 var find = createFind(findIndex);
9281
9282 /**
9283 * This method is like `_.find` except that it iterates over elements of
9284 * `collection` from right to left.
9285 *
9286 * @static
9287 * @memberOf _
9288 * @since 2.0.0
9289 * @category Collection
9290 * @param {Array|Object} collection The collection to inspect.
9291 * @param {Function} [predicate=_.identity] The function invoked per iteration.
9292 * @param {number} [fromIndex=collection.length-1] The index to search from.
9293 * @returns {*} Returns the matched element, else `undefined`.
9294 * @example
9295 *
9296 * _.findLast([1, 2, 3, 4], function(n) {
9297 * return n % 2 == 1;
9298 * });
9299 * // => 3
9300 */
9301 var findLast = createFind(findLastIndex);
9302
9303 /**
9304 * Creates a flattened array of values by running each element in `collection`
9305 * thru `iteratee` and flattening the mapped results. The iteratee is invoked
9306 * with three arguments: (value, index|key, collection).
9307 *
9308 * @static
9309 * @memberOf _
9310 * @since 4.0.0
9311 * @category Collection
9312 * @param {Array|Object} collection The collection to iterate over.
9313 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9314 * @returns {Array} Returns the new flattened array.
9315 * @example
9316 *
9317 * function duplicate(n) {
9318 * return [n, n];
9319 * }
9320 *
9321 * _.flatMap([1, 2], duplicate);
9322 * // => [1, 1, 2, 2]
9323 */
9324 function flatMap(collection, iteratee) {
9325 return baseFlatten(map(collection, iteratee), 1);
9326 }
9327
9328 /**
9329 * This method is like `_.flatMap` except that it recursively flattens the
9330 * mapped results.
9331 *
9332 * @static
9333 * @memberOf _
9334 * @since 4.7.0
9335 * @category Collection
9336 * @param {Array|Object} collection The collection to iterate over.
9337 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9338 * @returns {Array} Returns the new flattened array.
9339 * @example
9340 *
9341 * function duplicate(n) {
9342 * return [[[n, n]]];
9343 * }
9344 *
9345 * _.flatMapDeep([1, 2], duplicate);
9346 * // => [1, 1, 2, 2]
9347 */
9348 function flatMapDeep(collection, iteratee) {
9349 return baseFlatten(map(collection, iteratee), INFINITY);
9350 }
9351
9352 /**
9353 * This method is like `_.flatMap` except that it recursively flattens the
9354 * mapped results up to `depth` times.
9355 *
9356 * @static
9357 * @memberOf _
9358 * @since 4.7.0
9359 * @category Collection
9360 * @param {Array|Object} collection The collection to iterate over.
9361 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9362 * @param {number} [depth=1] The maximum recursion depth.
9363 * @returns {Array} Returns the new flattened array.
9364 * @example
9365 *
9366 * function duplicate(n) {
9367 * return [[[n, n]]];
9368 * }
9369 *
9370 * _.flatMapDepth([1, 2], duplicate, 2);
9371 * // => [[1, 1], [2, 2]]
9372 */
9373 function flatMapDepth(collection, iteratee, depth) {
9374 depth = depth === undefined ? 1 : toInteger(depth);
9375 return baseFlatten(map(collection, iteratee), depth);
9376 }
9377
9378 /**
9379 * Iterates over elements of `collection` and invokes `iteratee` for each element.
9380 * The iteratee is invoked with three arguments: (value, index|key, collection).
9381 * Iteratee functions may exit iteration early by explicitly returning `false`.
9382 *
9383 * **Note:** As with other "Collections" methods, objects with a "length"
9384 * property are iterated like arrays. To avoid this behavior use `_.forIn`
9385 * or `_.forOwn` for object iteration.
9386 *
9387 * @static
9388 * @memberOf _
9389 * @since 0.1.0
9390 * @alias each
9391 * @category Collection
9392 * @param {Array|Object} collection The collection to iterate over.
9393 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9394 * @returns {Array|Object} Returns `collection`.
9395 * @see _.forEachRight
9396 * @example
9397 *
9398 * _.forEach([1, 2], function(value) {
9399 * console.log(value);
9400 * });
9401 * // => Logs `1` then `2`.
9402 *
9403 * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
9404 * console.log(key);
9405 * });
9406 * // => Logs 'a' then 'b' (iteration order is not guaranteed).
9407 */
9408 function forEach(collection, iteratee) {
9409 var func = isArray(collection) ? arrayEach : baseEach;
9410 return func(collection, getIteratee(iteratee, 3));
9411 }
9412
9413 /**
9414 * This method is like `_.forEach` except that it iterates over elements of
9415 * `collection` from right to left.
9416 *
9417 * @static
9418 * @memberOf _
9419 * @since 2.0.0
9420 * @alias eachRight
9421 * @category Collection
9422 * @param {Array|Object} collection The collection to iterate over.
9423 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9424 * @returns {Array|Object} Returns `collection`.
9425 * @see _.forEach
9426 * @example
9427 *
9428 * _.forEachRight([1, 2], function(value) {
9429 * console.log(value);
9430 * });
9431 * // => Logs `2` then `1`.
9432 */
9433 function forEachRight(collection, iteratee) {
9434 var func = isArray(collection) ? arrayEachRight : baseEachRight;
9435 return func(collection, getIteratee(iteratee, 3));
9436 }
9437
9438 /**
9439 * Creates an object composed of keys generated from the results of running
9440 * each element of `collection` thru `iteratee`. The order of grouped values
9441 * is determined by the order they occur in `collection`. The corresponding
9442 * value of each key is an array of elements responsible for generating the
9443 * key. The iteratee is invoked with one argument: (value).
9444 *
9445 * @static
9446 * @memberOf _
9447 * @since 0.1.0
9448 * @category Collection
9449 * @param {Array|Object} collection The collection to iterate over.
9450 * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
9451 * @returns {Object} Returns the composed aggregate object.
9452 * @example
9453 *
9454 * _.groupBy([6.1, 4.2, 6.3], Math.floor);
9455 * // => { '4': [4.2], '6': [6.1, 6.3] }
9456 *
9457 * // The `_.property` iteratee shorthand.
9458 * _.groupBy(['one', 'two', 'three'], 'length');
9459 * // => { '3': ['one', 'two'], '5': ['three'] }
9460 */
9461 var groupBy = createAggregator(function(result, value, key) {
9462 if (hasOwnProperty.call(result, key)) {
9463 result[key].push(value);
9464 } else {
9465 baseAssignValue(result, key, [value]);
9466 }
9467 });
9468
9469 /**
9470 * Checks if `value` is in `collection`. If `collection` is a string, it's
9471 * checked for a substring of `value`, otherwise
9472 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
9473 * is used for equality comparisons. If `fromIndex` is negative, it's used as
9474 * the offset from the end of `collection`.
9475 *
9476 * @static
9477 * @memberOf _
9478 * @since 0.1.0
9479 * @category Collection
9480 * @param {Array|Object|string} collection The collection to inspect.
9481 * @param {*} value The value to search for.
9482 * @param {number} [fromIndex=0] The index to search from.
9483 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
9484 * @returns {boolean} Returns `true` if `value` is found, else `false`.
9485 * @example
9486 *
9487 * _.includes([1, 2, 3], 1);
9488 * // => true
9489 *
9490 * _.includes([1, 2, 3], 1, 2);
9491 * // => false
9492 *
9493 * _.includes({ 'a': 1, 'b': 2 }, 1);
9494 * // => true
9495 *
9496 * _.includes('abcd', 'bc');
9497 * // => true
9498 */
9499 function includes(collection, value, fromIndex, guard) {
9500 collection = isArrayLike(collection) ? collection : values(collection);
9501 fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;
9502
9503 var length = collection.length;
9504 if (fromIndex < 0) {
9505 fromIndex = nativeMax(length + fromIndex, 0);
9506 }
9507 return isString(collection)
9508 ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
9509 : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
9510 }
9511
9512 /**
9513 * Invokes the method at `path` of each element in `collection`, returning
9514 * an array of the results of each invoked method. Any additional arguments
9515 * are provided to each invoked method. If `path` is a function, it's invoked
9516 * for, and `this` bound to, each element in `collection`.
9517 *
9518 * @static
9519 * @memberOf _
9520 * @since 4.0.0
9521 * @category Collection
9522 * @param {Array|Object} collection The collection to iterate over.
9523 * @param {Array|Function|string} path The path of the method to invoke or
9524 * the function invoked per iteration.
9525 * @param {...*} [args] The arguments to invoke each method with.
9526 * @returns {Array} Returns the array of results.
9527 * @example
9528 *
9529 * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
9530 * // => [[1, 5, 7], [1, 2, 3]]
9531 *
9532 * _.invokeMap([123, 456], String.prototype.split, '');
9533 * // => [['1', '2', '3'], ['4', '5', '6']]
9534 */
9535 var invokeMap = baseRest(function(collection, path, args) {
9536 var index = -1,
9537 isFunc = typeof path == 'function',
9538 result = isArrayLike(collection) ? Array(collection.length) : [];
9539
9540 baseEach(collection, function(value) {
9541 result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
9542 });
9543 return result;
9544 });
9545
9546 /**
9547 * Creates an object composed of keys generated from the results of running
9548 * each element of `collection` thru `iteratee`. The corresponding value of
9549 * each key is the last element responsible for generating the key. The
9550 * iteratee is invoked with one argument: (value).
9551 *
9552 * @static
9553 * @memberOf _
9554 * @since 4.0.0
9555 * @category Collection
9556 * @param {Array|Object} collection The collection to iterate over.
9557 * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
9558 * @returns {Object} Returns the composed aggregate object.
9559 * @example
9560 *
9561 * var array = [
9562 * { 'dir': 'left', 'code': 97 },
9563 * { 'dir': 'right', 'code': 100 }
9564 * ];
9565 *
9566 * _.keyBy(array, function(o) {
9567 * return String.fromCharCode(o.code);
9568 * });
9569 * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
9570 *
9571 * _.keyBy(array, 'dir');
9572 * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
9573 */
9574 var keyBy = createAggregator(function(result, value, key) {
9575 baseAssignValue(result, key, value);
9576 });
9577
9578 /**
9579 * Creates an array of values by running each element in `collection` thru
9580 * `iteratee`. The iteratee is invoked with three arguments:
9581 * (value, index|key, collection).
9582 *
9583 * Many lodash methods are guarded to work as iteratees for methods like
9584 * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
9585 *
9586 * The guarded methods are:
9587 * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
9588 * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
9589 * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
9590 * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
9591 *
9592 * @static
9593 * @memberOf _
9594 * @since 0.1.0
9595 * @category Collection
9596 * @param {Array|Object} collection The collection to iterate over.
9597 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9598 * @returns {Array} Returns the new mapped array.
9599 * @example
9600 *
9601 * function square(n) {
9602 * return n * n;
9603 * }
9604 *
9605 * _.map([4, 8], square);
9606 * // => [16, 64]
9607 *
9608 * _.map({ 'a': 4, 'b': 8 }, square);
9609 * // => [16, 64] (iteration order is not guaranteed)
9610 *
9611 * var users = [
9612 * { 'user': 'barney' },
9613 * { 'user': 'fred' }
9614 * ];
9615 *
9616 * // The `_.property` iteratee shorthand.
9617 * _.map(users, 'user');
9618 * // => ['barney', 'fred']
9619 */
9620 function map(collection, iteratee) {
9621 var func = isArray(collection) ? arrayMap : baseMap;
9622 return func(collection, getIteratee(iteratee, 3));
9623 }
9624
9625 /**
9626 * This method is like `_.sortBy` except that it allows specifying the sort
9627 * orders of the iteratees to sort by. If `orders` is unspecified, all values
9628 * are sorted in ascending order. Otherwise, specify an order of "desc" for
9629 * descending or "asc" for ascending sort order of corresponding values.
9630 *
9631 * @static
9632 * @memberOf _
9633 * @since 4.0.0
9634 * @category Collection
9635 * @param {Array|Object} collection The collection to iterate over.
9636 * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
9637 * The iteratees to sort by.
9638 * @param {string[]} [orders] The sort orders of `iteratees`.
9639 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
9640 * @returns {Array} Returns the new sorted array.
9641 * @example
9642 *
9643 * var users = [
9644 * { 'user': 'fred', 'age': 48 },
9645 * { 'user': 'barney', 'age': 34 },
9646 * { 'user': 'fred', 'age': 40 },
9647 * { 'user': 'barney', 'age': 36 }
9648 * ];
9649 *
9650 * // Sort by `user` in ascending order and by `age` in descending order.
9651 * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
9652 * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
9653 */
9654 function orderBy(collection, iteratees, orders, guard) {
9655 if (collection == null) {
9656 return [];
9657 }
9658 if (!isArray(iteratees)) {
9659 iteratees = iteratees == null ? [] : [iteratees];
9660 }
9661 orders = guard ? undefined : orders;
9662 if (!isArray(orders)) {
9663 orders = orders == null ? [] : [orders];
9664 }
9665 return baseOrderBy(collection, iteratees, orders);
9666 }
9667
9668 /**
9669 * Creates an array of elements split into two groups, the first of which
9670 * contains elements `predicate` returns truthy for, the second of which
9671 * contains elements `predicate` returns falsey for. The predicate is
9672 * invoked with one argument: (value).
9673 *
9674 * @static
9675 * @memberOf _
9676 * @since 3.0.0
9677 * @category Collection
9678 * @param {Array|Object} collection The collection to iterate over.
9679 * @param {Function} [predicate=_.identity] The function invoked per iteration.
9680 * @returns {Array} Returns the array of grouped elements.
9681 * @example
9682 *
9683 * var users = [
9684 * { 'user': 'barney', 'age': 36, 'active': false },
9685 * { 'user': 'fred', 'age': 40, 'active': true },
9686 * { 'user': 'pebbles', 'age': 1, 'active': false }
9687 * ];
9688 *
9689 * _.partition(users, function(o) { return o.active; });
9690 * // => objects for [['fred'], ['barney', 'pebbles']]
9691 *
9692 * // The `_.matches` iteratee shorthand.
9693 * _.partition(users, { 'age': 1, 'active': false });
9694 * // => objects for [['pebbles'], ['barney', 'fred']]
9695 *
9696 * // The `_.matchesProperty` iteratee shorthand.
9697 * _.partition(users, ['active', false]);
9698 * // => objects for [['barney', 'pebbles'], ['fred']]
9699 *
9700 * // The `_.property` iteratee shorthand.
9701 * _.partition(users, 'active');
9702 * // => objects for [['fred'], ['barney', 'pebbles']]
9703 */
9704 var partition = createAggregator(function(result, value, key) {
9705 result[key ? 0 : 1].push(value);
9706 }, function() { return [[], []]; });
9707
9708 /**
9709 * Reduces `collection` to a value which is the accumulated result of running
9710 * each element in `collection` thru `iteratee`, where each successive
9711 * invocation is supplied the return value of the previous. If `accumulator`
9712 * is not given, the first element of `collection` is used as the initial
9713 * value. The iteratee is invoked with four arguments:
9714 * (accumulator, value, index|key, collection).
9715 *
9716 * Many lodash methods are guarded to work as iteratees for methods like
9717 * `_.reduce`, `_.reduceRight`, and `_.transform`.
9718 *
9719 * The guarded methods are:
9720 * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
9721 * and `sortBy`
9722 *
9723 * @static
9724 * @memberOf _
9725 * @since 0.1.0
9726 * @category Collection
9727 * @param {Array|Object} collection The collection to iterate over.
9728 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9729 * @param {*} [accumulator] The initial value.
9730 * @returns {*} Returns the accumulated value.
9731 * @see _.reduceRight
9732 * @example
9733 *
9734 * _.reduce([1, 2], function(sum, n) {
9735 * return sum + n;
9736 * }, 0);
9737 * // => 3
9738 *
9739 * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
9740 * (result[value] || (result[value] = [])).push(key);
9741 * return result;
9742 * }, {});
9743 * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
9744 */
9745 function reduce(collection, iteratee, accumulator) {
9746 var func = isArray(collection) ? arrayReduce : baseReduce,
9747 initAccum = arguments.length < 3;
9748
9749 return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
9750 }
9751
9752 /**
9753 * This method is like `_.reduce` except that it iterates over elements of
9754 * `collection` from right to left.
9755 *
9756 * @static
9757 * @memberOf _
9758 * @since 0.1.0
9759 * @category Collection
9760 * @param {Array|Object} collection The collection to iterate over.
9761 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
9762 * @param {*} [accumulator] The initial value.
9763 * @returns {*} Returns the accumulated value.
9764 * @see _.reduce
9765 * @example
9766 *
9767 * var array = [[0, 1], [2, 3], [4, 5]];
9768 *
9769 * _.reduceRight(array, function(flattened, other) {
9770 * return flattened.concat(other);
9771 * }, []);
9772 * // => [4, 5, 2, 3, 0, 1]
9773 */
9774 function reduceRight(collection, iteratee, accumulator) {
9775 var func = isArray(collection) ? arrayReduceRight : baseReduce,
9776 initAccum = arguments.length < 3;
9777
9778 return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
9779 }
9780
9781 /**
9782 * The opposite of `_.filter`; this method returns the elements of `collection`
9783 * that `predicate` does **not** return truthy for.
9784 *
9785 * @static
9786 * @memberOf _
9787 * @since 0.1.0
9788 * @category Collection
9789 * @param {Array|Object} collection The collection to iterate over.
9790 * @param {Function} [predicate=_.identity] The function invoked per iteration.
9791 * @returns {Array} Returns the new filtered array.
9792 * @see _.filter
9793 * @example
9794 *
9795 * var users = [
9796 * { 'user': 'barney', 'age': 36, 'active': false },
9797 * { 'user': 'fred', 'age': 40, 'active': true }
9798 * ];
9799 *
9800 * _.reject(users, function(o) { return !o.active; });
9801 * // => objects for ['fred']
9802 *
9803 * // The `_.matches` iteratee shorthand.
9804 * _.reject(users, { 'age': 40, 'active': true });
9805 * // => objects for ['barney']
9806 *
9807 * // The `_.matchesProperty` iteratee shorthand.
9808 * _.reject(users, ['active', false]);
9809 * // => objects for ['fred']
9810 *
9811 * // The `_.property` iteratee shorthand.
9812 * _.reject(users, 'active');
9813 * // => objects for ['barney']
9814 */
9815 function reject(collection, predicate) {
9816 var func = isArray(collection) ? arrayFilter : baseFilter;
9817 return func(collection, negate(getIteratee(predicate, 3)));
9818 }
9819
9820 /**
9821 * Gets a random element from `collection`.
9822 *
9823 * @static
9824 * @memberOf _
9825 * @since 2.0.0
9826 * @category Collection
9827 * @param {Array|Object} collection The collection to sample.
9828 * @returns {*} Returns the random element.
9829 * @example
9830 *
9831 * _.sample([1, 2, 3, 4]);
9832 * // => 2
9833 */
9834 function sample(collection) {
9835 var func = isArray(collection) ? arraySample : baseSample;
9836 return func(collection);
9837 }
9838
9839 /**
9840 * Gets `n` random elements at unique keys from `collection` up to the
9841 * size of `collection`.
9842 *
9843 * @static
9844 * @memberOf _
9845 * @since 4.0.0
9846 * @category Collection
9847 * @param {Array|Object} collection The collection to sample.
9848 * @param {number} [n=1] The number of elements to sample.
9849 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
9850 * @returns {Array} Returns the random elements.
9851 * @example
9852 *
9853 * _.sampleSize([1, 2, 3], 2);
9854 * // => [3, 1]
9855 *
9856 * _.sampleSize([1, 2, 3], 4);
9857 * // => [2, 3, 1]
9858 */
9859 function sampleSize(collection, n, guard) {
9860 if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {
9861 n = 1;
9862 } else {
9863 n = toInteger(n);
9864 }
9865 var func = isArray(collection) ? arraySampleSize : baseSampleSize;
9866 return func(collection, n);
9867 }
9868
9869 /**
9870 * Creates an array of shuffled values, using a version of the
9871 * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
9872 *
9873 * @static
9874 * @memberOf _
9875 * @since 0.1.0
9876 * @category Collection
9877 * @param {Array|Object} collection The collection to shuffle.
9878 * @returns {Array} Returns the new shuffled array.
9879 * @example
9880 *
9881 * _.shuffle([1, 2, 3, 4]);
9882 * // => [4, 1, 3, 2]
9883 */
9884 function shuffle(collection) {
9885 var func = isArray(collection) ? arrayShuffle : baseShuffle;
9886 return func(collection);
9887 }
9888
9889 /**
9890 * Gets the size of `collection` by returning its length for array-like
9891 * values or the number of own enumerable string keyed properties for objects.
9892 *
9893 * @static
9894 * @memberOf _
9895 * @since 0.1.0
9896 * @category Collection
9897 * @param {Array|Object|string} collection The collection to inspect.
9898 * @returns {number} Returns the collection size.
9899 * @example
9900 *
9901 * _.size([1, 2, 3]);
9902 * // => 3
9903 *
9904 * _.size({ 'a': 1, 'b': 2 });
9905 * // => 2
9906 *
9907 * _.size('pebbles');
9908 * // => 7
9909 */
9910 function size(collection) {
9911 if (collection == null) {
9912 return 0;
9913 }
9914 if (isArrayLike(collection)) {
9915 return isString(collection) ? stringSize(collection) : collection.length;
9916 }
9917 var tag = getTag(collection);
9918 if (tag == mapTag || tag == setTag) {
9919 return collection.size;
9920 }
9921 return baseKeys(collection).length;
9922 }
9923
9924 /**
9925 * Checks if `predicate` returns truthy for **any** element of `collection`.
9926 * Iteration is stopped once `predicate` returns truthy. The predicate is
9927 * invoked with three arguments: (value, index|key, collection).
9928 *
9929 * @static
9930 * @memberOf _
9931 * @since 0.1.0
9932 * @category Collection
9933 * @param {Array|Object} collection The collection to iterate over.
9934 * @param {Function} [predicate=_.identity] The function invoked per iteration.
9935 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
9936 * @returns {boolean} Returns `true` if any element passes the predicate check,
9937 * else `false`.
9938 * @example
9939 *
9940 * _.some([null, 0, 'yes', false], Boolean);
9941 * // => true
9942 *
9943 * var users = [
9944 * { 'user': 'barney', 'active': true },
9945 * { 'user': 'fred', 'active': false }
9946 * ];
9947 *
9948 * // The `_.matches` iteratee shorthand.
9949 * _.some(users, { 'user': 'barney', 'active': false });
9950 * // => false
9951 *
9952 * // The `_.matchesProperty` iteratee shorthand.
9953 * _.some(users, ['active', false]);
9954 * // => true
9955 *
9956 * // The `_.property` iteratee shorthand.
9957 * _.some(users, 'active');
9958 * // => true
9959 */
9960 function some(collection, predicate, guard) {
9961 var func = isArray(collection) ? arraySome : baseSome;
9962 if (guard && isIterateeCall(collection, predicate, guard)) {
9963 predicate = undefined;
9964 }
9965 return func(collection, getIteratee(predicate, 3));
9966 }
9967
9968 /**
9969 * Creates an array of elements, sorted in ascending order by the results of
9970 * running each element in a collection thru each iteratee. This method
9971 * performs a stable sort, that is, it preserves the original sort order of
9972 * equal elements. The iteratees are invoked with one argument: (value).
9973 *
9974 * @static
9975 * @memberOf _
9976 * @since 0.1.0
9977 * @category Collection
9978 * @param {Array|Object} collection The collection to iterate over.
9979 * @param {...(Function|Function[])} [iteratees=[_.identity]]
9980 * The iteratees to sort by.
9981 * @returns {Array} Returns the new sorted array.
9982 * @example
9983 *
9984 * var users = [
9985 * { 'user': 'fred', 'age': 48 },
9986 * { 'user': 'barney', 'age': 36 },
9987 * { 'user': 'fred', 'age': 30 },
9988 * { 'user': 'barney', 'age': 34 }
9989 * ];
9990 *
9991 * _.sortBy(users, [function(o) { return o.user; }]);
9992 * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
9993 *
9994 * _.sortBy(users, ['user', 'age']);
9995 * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
9996 */
9997 var sortBy = baseRest(function(collection, iteratees) {
9998 if (collection == null) {
9999 return [];
10000 }
10001 var length = iteratees.length;
10002 if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
10003 iteratees = [];
10004 } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
10005 iteratees = [iteratees[0]];
10006 }
10007 return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
10008 });
10009
10010 /*------------------------------------------------------------------------*/
10011
10012 /**
10013 * Gets the timestamp of the number of milliseconds that have elapsed since
10014 * the Unix epoch (1 January 1970 00:00:00 UTC).
10015 *
10016 * @static
10017 * @memberOf _
10018 * @since 2.4.0
10019 * @category Date
10020 * @returns {number} Returns the timestamp.
10021 * @example
10022 *
10023 * _.defer(function(stamp) {
10024 * console.log(_.now() - stamp);
10025 * }, _.now());
10026 * // => Logs the number of milliseconds it took for the deferred invocation.
10027 */
10028 var now = ctxNow || function() {
10029 return root.Date.now();
10030 };
10031
10032 /*------------------------------------------------------------------------*/
10033
10034 /**
10035 * The opposite of `_.before`; this method creates a function that invokes
10036 * `func` once it's called `n` or more times.
10037 *
10038 * @static
10039 * @memberOf _
10040 * @since 0.1.0
10041 * @category Function
10042 * @param {number} n The number of calls before `func` is invoked.
10043 * @param {Function} func The function to restrict.
10044 * @returns {Function} Returns the new restricted function.
10045 * @example
10046 *
10047 * var saves = ['profile', 'settings'];
10048 *
10049 * var done = _.after(saves.length, function() {
10050 * console.log('done saving!');
10051 * });
10052 *
10053 * _.forEach(saves, function(type) {
10054 * asyncSave({ 'type': type, 'complete': done });
10055 * });
10056 * // => Logs 'done saving!' after the two async saves have completed.
10057 */
10058 function after(n, func) {
10059 if (typeof func != 'function') {
10060 throw new TypeError(FUNC_ERROR_TEXT);
10061 }
10062 n = toInteger(n);
10063 return function() {
10064 if (--n < 1) {
10065 return func.apply(this, arguments);
10066 }
10067 };
10068 }
10069
10070 /**
10071 * Creates a function that invokes `func`, with up to `n` arguments,
10072 * ignoring any additional arguments.
10073 *
10074 * @static
10075 * @memberOf _
10076 * @since 3.0.0
10077 * @category Function
10078 * @param {Function} func The function to cap arguments for.
10079 * @param {number} [n=func.length] The arity cap.
10080 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
10081 * @returns {Function} Returns the new capped function.
10082 * @example
10083 *
10084 * _.map(['6', '8', '10'], _.ary(parseInt, 1));
10085 * // => [6, 8, 10]
10086 */
10087 function ary(func, n, guard) {
10088 n = guard ? undefined : n;
10089 n = (func && n == null) ? func.length : n;
10090 return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
10091 }
10092
10093 /**
10094 * Creates a function that invokes `func`, with the `this` binding and arguments
10095 * of the created function, while it's called less than `n` times. Subsequent
10096 * calls to the created function return the result of the last `func` invocation.
10097 *
10098 * @static
10099 * @memberOf _
10100 * @since 3.0.0
10101 * @category Function
10102 * @param {number} n The number of calls at which `func` is no longer invoked.
10103 * @param {Function} func The function to restrict.
10104 * @returns {Function} Returns the new restricted function.
10105 * @example
10106 *
10107 * jQuery(element).on('click', _.before(5, addContactToList));
10108 * // => Allows adding up to 4 contacts to the list.
10109 */
10110 function before(n, func) {
10111 var result;
10112 if (typeof func != 'function') {
10113 throw new TypeError(FUNC_ERROR_TEXT);
10114 }
10115 n = toInteger(n);
10116 return function() {
10117 if (--n > 0) {
10118 result = func.apply(this, arguments);
10119 }
10120 if (n <= 1) {
10121 func = undefined;
10122 }
10123 return result;
10124 };
10125 }
10126
10127 /**
10128 * Creates a function that invokes `func` with the `this` binding of `thisArg`
10129 * and `partials` prepended to the arguments it receives.
10130 *
10131 * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
10132 * may be used as a placeholder for partially applied arguments.
10133 *
10134 * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
10135 * property of bound functions.
10136 *
10137 * @static
10138 * @memberOf _
10139 * @since 0.1.0
10140 * @category Function
10141 * @param {Function} func The function to bind.
10142 * @param {*} thisArg The `this` binding of `func`.
10143 * @param {...*} [partials] The arguments to be partially applied.
10144 * @returns {Function} Returns the new bound function.
10145 * @example
10146 *
10147 * function greet(greeting, punctuation) {
10148 * return greeting + ' ' + this.user + punctuation;
10149 * }
10150 *
10151 * var object = { 'user': 'fred' };
10152 *
10153 * var bound = _.bind(greet, object, 'hi');
10154 * bound('!');
10155 * // => 'hi fred!'
10156 *
10157 * // Bound with placeholders.
10158 * var bound = _.bind(greet, object, _, '!');
10159 * bound('hi');
10160 * // => 'hi fred!'
10161 */
10162 var bind = baseRest(function(func, thisArg, partials) {
10163 var bitmask = WRAP_BIND_FLAG;
10164 if (partials.length) {
10165 var holders = replaceHolders(partials, getHolder(bind));
10166 bitmask |= WRAP_PARTIAL_FLAG;
10167 }
10168 return createWrap(func, bitmask, thisArg, partials, holders);
10169 });
10170
10171 /**
10172 * Creates a function that invokes the method at `object[key]` with `partials`
10173 * prepended to the arguments it receives.
10174 *
10175 * This method differs from `_.bind` by allowing bound functions to reference
10176 * methods that may be redefined or don't yet exist. See
10177 * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
10178 * for more details.
10179 *
10180 * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
10181 * builds, may be used as a placeholder for partially applied arguments.
10182 *
10183 * @static
10184 * @memberOf _
10185 * @since 0.10.0
10186 * @category Function
10187 * @param {Object} object The object to invoke the method on.
10188 * @param {string} key The key of the method.
10189 * @param {...*} [partials] The arguments to be partially applied.
10190 * @returns {Function} Returns the new bound function.
10191 * @example
10192 *
10193 * var object = {
10194 * 'user': 'fred',
10195 * 'greet': function(greeting, punctuation) {
10196 * return greeting + ' ' + this.user + punctuation;
10197 * }
10198 * };
10199 *
10200 * var bound = _.bindKey(object, 'greet', 'hi');
10201 * bound('!');
10202 * // => 'hi fred!'
10203 *
10204 * object.greet = function(greeting, punctuation) {
10205 * return greeting + 'ya ' + this.user + punctuation;
10206 * };
10207 *
10208 * bound('!');
10209 * // => 'hiya fred!'
10210 *
10211 * // Bound with placeholders.
10212 * var bound = _.bindKey(object, 'greet', _, '!');
10213 * bound('hi');
10214 * // => 'hiya fred!'
10215 */
10216 var bindKey = baseRest(function(object, key, partials) {
10217 var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
10218 if (partials.length) {
10219 var holders = replaceHolders(partials, getHolder(bindKey));
10220 bitmask |= WRAP_PARTIAL_FLAG;
10221 }
10222 return createWrap(key, bitmask, object, partials, holders);
10223 });
10224
10225 /**
10226 * Creates a function that accepts arguments of `func` and either invokes
10227 * `func` returning its result, if at least `arity` number of arguments have
10228 * been provided, or returns a function that accepts the remaining `func`
10229 * arguments, and so on. The arity of `func` may be specified if `func.length`
10230 * is not sufficient.
10231 *
10232 * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
10233 * may be used as a placeholder for provided arguments.
10234 *
10235 * **Note:** This method doesn't set the "length" property of curried functions.
10236 *
10237 * @static
10238 * @memberOf _
10239 * @since 2.0.0
10240 * @category Function
10241 * @param {Function} func The function to curry.
10242 * @param {number} [arity=func.length] The arity of `func`.
10243 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
10244 * @returns {Function} Returns the new curried function.
10245 * @example
10246 *
10247 * var abc = function(a, b, c) {
10248 * return [a, b, c];
10249 * };
10250 *
10251 * var curried = _.curry(abc);
10252 *
10253 * curried(1)(2)(3);
10254 * // => [1, 2, 3]
10255 *
10256 * curried(1, 2)(3);
10257 * // => [1, 2, 3]
10258 *
10259 * curried(1, 2, 3);
10260 * // => [1, 2, 3]
10261 *
10262 * // Curried with placeholders.
10263 * curried(1)(_, 3)(2);
10264 * // => [1, 2, 3]
10265 */
10266 function curry(func, arity, guard) {
10267 arity = guard ? undefined : arity;
10268 var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
10269 result.placeholder = curry.placeholder;
10270 return result;
10271 }
10272
10273 /**
10274 * This method is like `_.curry` except that arguments are applied to `func`
10275 * in the manner of `_.partialRight` instead of `_.partial`.
10276 *
10277 * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
10278 * builds, may be used as a placeholder for provided arguments.
10279 *
10280 * **Note:** This method doesn't set the "length" property of curried functions.
10281 *
10282 * @static
10283 * @memberOf _
10284 * @since 3.0.0
10285 * @category Function
10286 * @param {Function} func The function to curry.
10287 * @param {number} [arity=func.length] The arity of `func`.
10288 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
10289 * @returns {Function} Returns the new curried function.
10290 * @example
10291 *
10292 * var abc = function(a, b, c) {
10293 * return [a, b, c];
10294 * };
10295 *
10296 * var curried = _.curryRight(abc);
10297 *
10298 * curried(3)(2)(1);
10299 * // => [1, 2, 3]
10300 *
10301 * curried(2, 3)(1);
10302 * // => [1, 2, 3]
10303 *
10304 * curried(1, 2, 3);
10305 * // => [1, 2, 3]
10306 *
10307 * // Curried with placeholders.
10308 * curried(3)(1, _)(2);
10309 * // => [1, 2, 3]
10310 */
10311 function curryRight(func, arity, guard) {
10312 arity = guard ? undefined : arity;
10313 var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
10314 result.placeholder = curryRight.placeholder;
10315 return result;
10316 }
10317
10318 /**
10319 * Creates a debounced function that delays invoking `func` until after `wait`
10320 * milliseconds have elapsed since the last time the debounced function was
10321 * invoked. The debounced function comes with a `cancel` method to cancel
10322 * delayed `func` invocations and a `flush` method to immediately invoke them.
10323 * Provide `options` to indicate whether `func` should be invoked on the
10324 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
10325 * with the last arguments provided to the debounced function. Subsequent
10326 * calls to the debounced function return the result of the last `func`
10327 * invocation.
10328 *
10329 * **Note:** If `leading` and `trailing` options are `true`, `func` is
10330 * invoked on the trailing edge of the timeout only if the debounced function
10331 * is invoked more than once during the `wait` timeout.
10332 *
10333 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
10334 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
10335 *
10336 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
10337 * for details over the differences between `_.debounce` and `_.throttle`.
10338 *
10339 * @static
10340 * @memberOf _
10341 * @since 0.1.0
10342 * @category Function
10343 * @param {Function} func The function to debounce.
10344 * @param {number} [wait=0] The number of milliseconds to delay.
10345 * @param {Object} [options={}] The options object.
10346 * @param {boolean} [options.leading=false]
10347 * Specify invoking on the leading edge of the timeout.
10348 * @param {number} [options.maxWait]
10349 * The maximum time `func` is allowed to be delayed before it's invoked.
10350 * @param {boolean} [options.trailing=true]
10351 * Specify invoking on the trailing edge of the timeout.
10352 * @returns {Function} Returns the new debounced function.
10353 * @example
10354 *
10355 * // Avoid costly calculations while the window size is in flux.
10356 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
10357 *
10358 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
10359 * jQuery(element).on('click', _.debounce(sendMail, 300, {
10360 * 'leading': true,
10361 * 'trailing': false
10362 * }));
10363 *
10364 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
10365 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
10366 * var source = new EventSource('/stream');
10367 * jQuery(source).on('message', debounced);
10368 *
10369 * // Cancel the trailing debounced invocation.
10370 * jQuery(window).on('popstate', debounced.cancel);
10371 */
10372 function debounce(func, wait, options) {
10373 var lastArgs,
10374 lastThis,
10375 maxWait,
10376 result,
10377 timerId,
10378 lastCallTime,
10379 lastInvokeTime = 0,
10380 leading = false,
10381 maxing = false,
10382 trailing = true;
10383
10384 if (typeof func != 'function') {
10385 throw new TypeError(FUNC_ERROR_TEXT);
10386 }
10387 wait = toNumber(wait) || 0;
10388 if (isObject(options)) {
10389 leading = !!options.leading;
10390 maxing = 'maxWait' in options;
10391 maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
10392 trailing = 'trailing' in options ? !!options.trailing : trailing;
10393 }
10394
10395 function invokeFunc(time) {
10396 var args = lastArgs,
10397 thisArg = lastThis;
10398
10399 lastArgs = lastThis = undefined;
10400 lastInvokeTime = time;
10401 result = func.apply(thisArg, args);
10402 return result;
10403 }
10404
10405 function leadingEdge(time) {
10406 // Reset any `maxWait` timer.
10407 lastInvokeTime = time;
10408 // Start the timer for the trailing edge.
10409 timerId = setTimeout(timerExpired, wait);
10410 // Invoke the leading edge.
10411 return leading ? invokeFunc(time) : result;
10412 }
10413
10414 function remainingWait(time) {
10415 var timeSinceLastCall = time - lastCallTime,
10416 timeSinceLastInvoke = time - lastInvokeTime,
10417 timeWaiting = wait - timeSinceLastCall;
10418
10419 return maxing
10420 ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
10421 : timeWaiting;
10422 }
10423
10424 function shouldInvoke(time) {
10425 var timeSinceLastCall = time - lastCallTime,
10426 timeSinceLastInvoke = time - lastInvokeTime;
10427
10428 // Either this is the first call, activity has stopped and we're at the
10429 // trailing edge, the system time has gone backwards and we're treating
10430 // it as the trailing edge, or we've hit the `maxWait` limit.
10431 return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
10432 (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
10433 }
10434
10435 function timerExpired() {
10436 var time = now();
10437 if (shouldInvoke(time)) {
10438 return trailingEdge(time);
10439 }
10440 // Restart the timer.
10441 timerId = setTimeout(timerExpired, remainingWait(time));
10442 }
10443
10444 function trailingEdge(time) {
10445 timerId = undefined;
10446
10447 // Only invoke if we have `lastArgs` which means `func` has been
10448 // debounced at least once.
10449 if (trailing && lastArgs) {
10450 return invokeFunc(time);
10451 }
10452 lastArgs = lastThis = undefined;
10453 return result;
10454 }
10455
10456 function cancel() {
10457 if (timerId !== undefined) {
10458 clearTimeout(timerId);
10459 }
10460 lastInvokeTime = 0;
10461 lastArgs = lastCallTime = lastThis = timerId = undefined;
10462 }
10463
10464 function flush() {
10465 return timerId === undefined ? result : trailingEdge(now());
10466 }
10467
10468 function debounced() {
10469 var time = now(),
10470 isInvoking = shouldInvoke(time);
10471
10472 lastArgs = arguments;
10473 lastThis = this;
10474 lastCallTime = time;
10475
10476 if (isInvoking) {
10477 if (timerId === undefined) {
10478 return leadingEdge(lastCallTime);
10479 }
10480 if (maxing) {
10481 // Handle invocations in a tight loop.
10482 clearTimeout(timerId);
10483 timerId = setTimeout(timerExpired, wait);
10484 return invokeFunc(lastCallTime);
10485 }
10486 }
10487 if (timerId === undefined) {
10488 timerId = setTimeout(timerExpired, wait);
10489 }
10490 return result;
10491 }
10492 debounced.cancel = cancel;
10493 debounced.flush = flush;
10494 return debounced;
10495 }
10496
10497 /**
10498 * Defers invoking the `func` until the current call stack has cleared. Any
10499 * additional arguments are provided to `func` when it's invoked.
10500 *
10501 * @static
10502 * @memberOf _
10503 * @since 0.1.0
10504 * @category Function
10505 * @param {Function} func The function to defer.
10506 * @param {...*} [args] The arguments to invoke `func` with.
10507 * @returns {number} Returns the timer id.
10508 * @example
10509 *
10510 * _.defer(function(text) {
10511 * console.log(text);
10512 * }, 'deferred');
10513 * // => Logs 'deferred' after one millisecond.
10514 */
10515 var defer = baseRest(function(func, args) {
10516 return baseDelay(func, 1, args);
10517 });
10518
10519 /**
10520 * Invokes `func` after `wait` milliseconds. Any additional arguments are
10521 * provided to `func` when it's invoked.
10522 *
10523 * @static
10524 * @memberOf _
10525 * @since 0.1.0
10526 * @category Function
10527 * @param {Function} func The function to delay.
10528 * @param {number} wait The number of milliseconds to delay invocation.
10529 * @param {...*} [args] The arguments to invoke `func` with.
10530 * @returns {number} Returns the timer id.
10531 * @example
10532 *
10533 * _.delay(function(text) {
10534 * console.log(text);
10535 * }, 1000, 'later');
10536 * // => Logs 'later' after one second.
10537 */
10538 var delay = baseRest(function(func, wait, args) {
10539 return baseDelay(func, toNumber(wait) || 0, args);
10540 });
10541
10542 /**
10543 * Creates a function that invokes `func` with arguments reversed.
10544 *
10545 * @static
10546 * @memberOf _
10547 * @since 4.0.0
10548 * @category Function
10549 * @param {Function} func The function to flip arguments for.
10550 * @returns {Function} Returns the new flipped function.
10551 * @example
10552 *
10553 * var flipped = _.flip(function() {
10554 * return _.toArray(arguments);
10555 * });
10556 *
10557 * flipped('a', 'b', 'c', 'd');
10558 * // => ['d', 'c', 'b', 'a']
10559 */
10560 function flip(func) {
10561 return createWrap(func, WRAP_FLIP_FLAG);
10562 }
10563
10564 /**
10565 * Creates a function that memoizes the result of `func`. If `resolver` is
10566 * provided, it determines the cache key for storing the result based on the
10567 * arguments provided to the memoized function. By default, the first argument
10568 * provided to the memoized function is used as the map cache key. The `func`
10569 * is invoked with the `this` binding of the memoized function.
10570 *
10571 * **Note:** The cache is exposed as the `cache` property on the memoized
10572 * function. Its creation may be customized by replacing the `_.memoize.Cache`
10573 * constructor with one whose instances implement the
10574 * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
10575 * method interface of `clear`, `delete`, `get`, `has`, and `set`.
10576 *
10577 * @static
10578 * @memberOf _
10579 * @since 0.1.0
10580 * @category Function
10581 * @param {Function} func The function to have its output memoized.
10582 * @param {Function} [resolver] The function to resolve the cache key.
10583 * @returns {Function} Returns the new memoized function.
10584 * @example
10585 *
10586 * var object = { 'a': 1, 'b': 2 };
10587 * var other = { 'c': 3, 'd': 4 };
10588 *
10589 * var values = _.memoize(_.values);
10590 * values(object);
10591 * // => [1, 2]
10592 *
10593 * values(other);
10594 * // => [3, 4]
10595 *
10596 * object.a = 2;
10597 * values(object);
10598 * // => [1, 2]
10599 *
10600 * // Modify the result cache.
10601 * values.cache.set(object, ['a', 'b']);
10602 * values(object);
10603 * // => ['a', 'b']
10604 *
10605 * // Replace `_.memoize.Cache`.
10606 * _.memoize.Cache = WeakMap;
10607 */
10608 function memoize(func, resolver) {
10609 if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
10610 throw new TypeError(FUNC_ERROR_TEXT);
10611 }
10612 var memoized = function() {
10613 var args = arguments,
10614 key = resolver ? resolver.apply(this, args) : args[0],
10615 cache = memoized.cache;
10616
10617 if (cache.has(key)) {
10618 return cache.get(key);
10619 }
10620 var result = func.apply(this, args);
10621 memoized.cache = cache.set(key, result) || cache;
10622 return result;
10623 };
10624 memoized.cache = new (memoize.Cache || MapCache);
10625 return memoized;
10626 }
10627
10628 // Expose `MapCache`.
10629 memoize.Cache = MapCache;
10630
10631 /**
10632 * Creates a function that negates the result of the predicate `func`. The
10633 * `func` predicate is invoked with the `this` binding and arguments of the
10634 * created function.
10635 *
10636 * @static
10637 * @memberOf _
10638 * @since 3.0.0
10639 * @category Function
10640 * @param {Function} predicate The predicate to negate.
10641 * @returns {Function} Returns the new negated function.
10642 * @example
10643 *
10644 * function isEven(n) {
10645 * return n % 2 == 0;
10646 * }
10647 *
10648 * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
10649 * // => [1, 3, 5]
10650 */
10651 function negate(predicate) {
10652 if (typeof predicate != 'function') {
10653 throw new TypeError(FUNC_ERROR_TEXT);
10654 }
10655 return function() {
10656 var args = arguments;
10657 switch (args.length) {
10658 case 0: return !predicate.call(this);
10659 case 1: return !predicate.call(this, args[0]);
10660 case 2: return !predicate.call(this, args[0], args[1]);
10661 case 3: return !predicate.call(this, args[0], args[1], args[2]);
10662 }
10663 return !predicate.apply(this, args);
10664 };
10665 }
10666
10667 /**
10668 * Creates a function that is restricted to invoking `func` once. Repeat calls
10669 * to the function return the value of the first invocation. The `func` is
10670 * invoked with the `this` binding and arguments of the created function.
10671 *
10672 * @static
10673 * @memberOf _
10674 * @since 0.1.0
10675 * @category Function
10676 * @param {Function} func The function to restrict.
10677 * @returns {Function} Returns the new restricted function.
10678 * @example
10679 *
10680 * var initialize = _.once(createApplication);
10681 * initialize();
10682 * initialize();
10683 * // => `createApplication` is invoked once
10684 */
10685 function once(func) {
10686 return before(2, func);
10687 }
10688
10689 /**
10690 * Creates a function that invokes `func` with its arguments transformed.
10691 *
10692 * @static
10693 * @since 4.0.0
10694 * @memberOf _
10695 * @category Function
10696 * @param {Function} func The function to wrap.
10697 * @param {...(Function|Function[])} [transforms=[_.identity]]
10698 * The argument transforms.
10699 * @returns {Function} Returns the new function.
10700 * @example
10701 *
10702 * function doubled(n) {
10703 * return n * 2;
10704 * }
10705 *
10706 * function square(n) {
10707 * return n * n;
10708 * }
10709 *
10710 * var func = _.overArgs(function(x, y) {
10711 * return [x, y];
10712 * }, [square, doubled]);
10713 *
10714 * func(9, 3);
10715 * // => [81, 6]
10716 *
10717 * func(10, 5);
10718 * // => [100, 10]
10719 */
10720 var overArgs = castRest(function(func, transforms) {
10721 transforms = (transforms.length == 1 && isArray(transforms[0]))
10722 ? arrayMap(transforms[0], baseUnary(getIteratee()))
10723 : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));
10724
10725 var funcsLength = transforms.length;
10726 return baseRest(function(args) {
10727 var index = -1,
10728 length = nativeMin(args.length, funcsLength);
10729
10730 while (++index < length) {
10731 args[index] = transforms[index].call(this, args[index]);
10732 }
10733 return apply(func, this, args);
10734 });
10735 });
10736
10737 /**
10738 * Creates a function that invokes `func` with `partials` prepended to the
10739 * arguments it receives. This method is like `_.bind` except it does **not**
10740 * alter the `this` binding.
10741 *
10742 * The `_.partial.placeholder` value, which defaults to `_` in monolithic
10743 * builds, may be used as a placeholder for partially applied arguments.
10744 *
10745 * **Note:** This method doesn't set the "length" property of partially
10746 * applied functions.
10747 *
10748 * @static
10749 * @memberOf _
10750 * @since 0.2.0
10751 * @category Function
10752 * @param {Function} func The function to partially apply arguments to.
10753 * @param {...*} [partials] The arguments to be partially applied.
10754 * @returns {Function} Returns the new partially applied function.
10755 * @example
10756 *
10757 * function greet(greeting, name) {
10758 * return greeting + ' ' + name;
10759 * }
10760 *
10761 * var sayHelloTo = _.partial(greet, 'hello');
10762 * sayHelloTo('fred');
10763 * // => 'hello fred'
10764 *
10765 * // Partially applied with placeholders.
10766 * var greetFred = _.partial(greet, _, 'fred');
10767 * greetFred('hi');
10768 * // => 'hi fred'
10769 */
10770 var partial = baseRest(function(func, partials) {
10771 var holders = replaceHolders(partials, getHolder(partial));
10772 return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);
10773 });
10774
10775 /**
10776 * This method is like `_.partial` except that partially applied arguments
10777 * are appended to the arguments it receives.
10778 *
10779 * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
10780 * builds, may be used as a placeholder for partially applied arguments.
10781 *
10782 * **Note:** This method doesn't set the "length" property of partially
10783 * applied functions.
10784 *
10785 * @static
10786 * @memberOf _
10787 * @since 1.0.0
10788 * @category Function
10789 * @param {Function} func The function to partially apply arguments to.
10790 * @param {...*} [partials] The arguments to be partially applied.
10791 * @returns {Function} Returns the new partially applied function.
10792 * @example
10793 *
10794 * function greet(greeting, name) {
10795 * return greeting + ' ' + name;
10796 * }
10797 *
10798 * var greetFred = _.partialRight(greet, 'fred');
10799 * greetFred('hi');
10800 * // => 'hi fred'
10801 *
10802 * // Partially applied with placeholders.
10803 * var sayHelloTo = _.partialRight(greet, 'hello', _);
10804 * sayHelloTo('fred');
10805 * // => 'hello fred'
10806 */
10807 var partialRight = baseRest(function(func, partials) {
10808 var holders = replaceHolders(partials, getHolder(partialRight));
10809 return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);
10810 });
10811
10812 /**
10813 * Creates a function that invokes `func` with arguments arranged according
10814 * to the specified `indexes` where the argument value at the first index is
10815 * provided as the first argument, the argument value at the second index is
10816 * provided as the second argument, and so on.
10817 *
10818 * @static
10819 * @memberOf _
10820 * @since 3.0.0
10821 * @category Function
10822 * @param {Function} func The function to rearrange arguments for.
10823 * @param {...(number|number[])} indexes The arranged argument indexes.
10824 * @returns {Function} Returns the new function.
10825 * @example
10826 *
10827 * var rearged = _.rearg(function(a, b, c) {
10828 * return [a, b, c];
10829 * }, [2, 0, 1]);
10830 *
10831 * rearged('b', 'c', 'a')
10832 * // => ['a', 'b', 'c']
10833 */
10834 var rearg = flatRest(function(func, indexes) {
10835 return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
10836 });
10837
10838 /**
10839 * Creates a function that invokes `func` with the `this` binding of the
10840 * created function and arguments from `start` and beyond provided as
10841 * an array.
10842 *
10843 * **Note:** This method is based on the
10844 * [rest parameter](https://mdn.io/rest_parameters).
10845 *
10846 * @static
10847 * @memberOf _
10848 * @since 4.0.0
10849 * @category Function
10850 * @param {Function} func The function to apply a rest parameter to.
10851 * @param {number} [start=func.length-1] The start position of the rest parameter.
10852 * @returns {Function} Returns the new function.
10853 * @example
10854 *
10855 * var say = _.rest(function(what, names) {
10856 * return what + ' ' + _.initial(names).join(', ') +
10857 * (_.size(names) > 1 ? ', & ' : '') + _.last(names);
10858 * });
10859 *
10860 * say('hello', 'fred', 'barney', 'pebbles');
10861 * // => 'hello fred, barney, & pebbles'
10862 */
10863 function rest(func, start) {
10864 if (typeof func != 'function') {
10865 throw new TypeError(FUNC_ERROR_TEXT);
10866 }
10867 start = start === undefined ? start : toInteger(start);
10868 return baseRest(func, start);
10869 }
10870
10871 /**
10872 * Creates a function that invokes `func` with the `this` binding of the
10873 * create function and an array of arguments much like
10874 * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
10875 *
10876 * **Note:** This method is based on the
10877 * [spread operator](https://mdn.io/spread_operator).
10878 *
10879 * @static
10880 * @memberOf _
10881 * @since 3.2.0
10882 * @category Function
10883 * @param {Function} func The function to spread arguments over.
10884 * @param {number} [start=0] The start position of the spread.
10885 * @returns {Function} Returns the new function.
10886 * @example
10887 *
10888 * var say = _.spread(function(who, what) {
10889 * return who + ' says ' + what;
10890 * });
10891 *
10892 * say(['fred', 'hello']);
10893 * // => 'fred says hello'
10894 *
10895 * var numbers = Promise.all([
10896 * Promise.resolve(40),
10897 * Promise.resolve(36)
10898 * ]);
10899 *
10900 * numbers.then(_.spread(function(x, y) {
10901 * return x + y;
10902 * }));
10903 * // => a Promise of 76
10904 */
10905 function spread(func, start) {
10906 if (typeof func != 'function') {
10907 throw new TypeError(FUNC_ERROR_TEXT);
10908 }
10909 start = start == null ? 0 : nativeMax(toInteger(start), 0);
10910 return baseRest(function(args) {
10911 var array = args[start],
10912 otherArgs = castSlice(args, 0, start);
10913
10914 if (array) {
10915 arrayPush(otherArgs, array);
10916 }
10917 return apply(func, this, otherArgs);
10918 });
10919 }
10920
10921 /**
10922 * Creates a throttled function that only invokes `func` at most once per
10923 * every `wait` milliseconds. The throttled function comes with a `cancel`
10924 * method to cancel delayed `func` invocations and a `flush` method to
10925 * immediately invoke them. Provide `options` to indicate whether `func`
10926 * should be invoked on the leading and/or trailing edge of the `wait`
10927 * timeout. The `func` is invoked with the last arguments provided to the
10928 * throttled function. Subsequent calls to the throttled function return the
10929 * result of the last `func` invocation.
10930 *
10931 * **Note:** If `leading` and `trailing` options are `true`, `func` is
10932 * invoked on the trailing edge of the timeout only if the throttled function
10933 * is invoked more than once during the `wait` timeout.
10934 *
10935 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
10936 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
10937 *
10938 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
10939 * for details over the differences between `_.throttle` and `_.debounce`.
10940 *
10941 * @static
10942 * @memberOf _
10943 * @since 0.1.0
10944 * @category Function
10945 * @param {Function} func The function to throttle.
10946 * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
10947 * @param {Object} [options={}] The options object.
10948 * @param {boolean} [options.leading=true]
10949 * Specify invoking on the leading edge of the timeout.
10950 * @param {boolean} [options.trailing=true]
10951 * Specify invoking on the trailing edge of the timeout.
10952 * @returns {Function} Returns the new throttled function.
10953 * @example
10954 *
10955 * // Avoid excessively updating the position while scrolling.
10956 * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
10957 *
10958 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
10959 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
10960 * jQuery(element).on('click', throttled);
10961 *
10962 * // Cancel the trailing throttled invocation.
10963 * jQuery(window).on('popstate', throttled.cancel);
10964 */
10965 function throttle(func, wait, options) {
10966 var leading = true,
10967 trailing = true;
10968
10969 if (typeof func != 'function') {
10970 throw new TypeError(FUNC_ERROR_TEXT);
10971 }
10972 if (isObject(options)) {
10973 leading = 'leading' in options ? !!options.leading : leading;
10974 trailing = 'trailing' in options ? !!options.trailing : trailing;
10975 }
10976 return debounce(func, wait, {
10977 'leading': leading,
10978 'maxWait': wait,
10979 'trailing': trailing
10980 });
10981 }
10982
10983 /**
10984 * Creates a function that accepts up to one argument, ignoring any
10985 * additional arguments.
10986 *
10987 * @static
10988 * @memberOf _
10989 * @since 4.0.0
10990 * @category Function
10991 * @param {Function} func The function to cap arguments for.
10992 * @returns {Function} Returns the new capped function.
10993 * @example
10994 *
10995 * _.map(['6', '8', '10'], _.unary(parseInt));
10996 * // => [6, 8, 10]
10997 */
10998 function unary(func) {
10999 return ary(func, 1);
11000 }
11001
11002 /**
11003 * Creates a function that provides `value` to `wrapper` as its first
11004 * argument. Any additional arguments provided to the function are appended
11005 * to those provided to the `wrapper`. The wrapper is invoked with the `this`
11006 * binding of the created function.
11007 *
11008 * @static
11009 * @memberOf _
11010 * @since 0.1.0
11011 * @category Function
11012 * @param {*} value The value to wrap.
11013 * @param {Function} [wrapper=identity] The wrapper function.
11014 * @returns {Function} Returns the new function.
11015 * @example
11016 *
11017 * var p = _.wrap(_.escape, function(func, text) {
11018 * return '<p>' + func(text) + '</p>';
11019 * });
11020 *
11021 * p('fred, barney, & pebbles');
11022 * // => '<p>fred, barney, & pebbles</p>'
11023 */
11024 function wrap(value, wrapper) {
11025 return partial(castFunction(wrapper), value);
11026 }
11027
11028 /*------------------------------------------------------------------------*/
11029
11030 /**
11031 * Casts `value` as an array if it's not one.
11032 *
11033 * @static
11034 * @memberOf _
11035 * @since 4.4.0
11036 * @category Lang
11037 * @param {*} value The value to inspect.
11038 * @returns {Array} Returns the cast array.
11039 * @example
11040 *
11041 * _.castArray(1);
11042 * // => [1]
11043 *
11044 * _.castArray({ 'a': 1 });
11045 * // => [{ 'a': 1 }]
11046 *
11047 * _.castArray('abc');
11048 * // => ['abc']
11049 *
11050 * _.castArray(null);
11051 * // => [null]
11052 *
11053 * _.castArray(undefined);
11054 * // => [undefined]
11055 *
11056 * _.castArray();
11057 * // => []
11058 *
11059 * var array = [1, 2, 3];
11060 * console.log(_.castArray(array) === array);
11061 * // => true
11062 */
11063 function castArray() {
11064 if (!arguments.length) {
11065 return [];
11066 }
11067 var value = arguments[0];
11068 return isArray(value) ? value : [value];
11069 }
11070
11071 /**
11072 * Creates a shallow clone of `value`.
11073 *
11074 * **Note:** This method is loosely based on the
11075 * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
11076 * and supports cloning arrays, array buffers, booleans, date objects, maps,
11077 * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
11078 * arrays. The own enumerable properties of `arguments` objects are cloned
11079 * as plain objects. An empty object is returned for uncloneable values such
11080 * as error objects, functions, DOM nodes, and WeakMaps.
11081 *
11082 * @static
11083 * @memberOf _
11084 * @since 0.1.0
11085 * @category Lang
11086 * @param {*} value The value to clone.
11087 * @returns {*} Returns the cloned value.
11088 * @see _.cloneDeep
11089 * @example
11090 *
11091 * var objects = [{ 'a': 1 }, { 'b': 2 }];
11092 *
11093 * var shallow = _.clone(objects);
11094 * console.log(shallow[0] === objects[0]);
11095 * // => true
11096 */
11097 function clone(value) {
11098 return baseClone(value, CLONE_SYMBOLS_FLAG);
11099 }
11100
11101 /**
11102 * This method is like `_.clone` except that it accepts `customizer` which
11103 * is invoked to produce the cloned value. If `customizer` returns `undefined`,
11104 * cloning is handled by the method instead. The `customizer` is invoked with
11105 * up to four arguments; (value [, index|key, object, stack]).
11106 *
11107 * @static
11108 * @memberOf _
11109 * @since 4.0.0
11110 * @category Lang
11111 * @param {*} value The value to clone.
11112 * @param {Function} [customizer] The function to customize cloning.
11113 * @returns {*} Returns the cloned value.
11114 * @see _.cloneDeepWith
11115 * @example
11116 *
11117 * function customizer(value) {
11118 * if (_.isElement(value)) {
11119 * return value.cloneNode(false);
11120 * }
11121 * }
11122 *
11123 * var el = _.cloneWith(document.body, customizer);
11124 *
11125 * console.log(el === document.body);
11126 * // => false
11127 * console.log(el.nodeName);
11128 * // => 'BODY'
11129 * console.log(el.childNodes.length);
11130 * // => 0
11131 */
11132 function cloneWith(value, customizer) {
11133 customizer = typeof customizer == 'function' ? customizer : undefined;
11134 return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
11135 }
11136
11137 /**
11138 * This method is like `_.clone` except that it recursively clones `value`.
11139 *
11140 * @static
11141 * @memberOf _
11142 * @since 1.0.0
11143 * @category Lang
11144 * @param {*} value The value to recursively clone.
11145 * @returns {*} Returns the deep cloned value.
11146 * @see _.clone
11147 * @example
11148 *
11149 * var objects = [{ 'a': 1 }, { 'b': 2 }];
11150 *
11151 * var deep = _.cloneDeep(objects);
11152 * console.log(deep[0] === objects[0]);
11153 * // => false
11154 */
11155 function cloneDeep(value) {
11156 return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
11157 }
11158
11159 /**
11160 * This method is like `_.cloneWith` except that it recursively clones `value`.
11161 *
11162 * @static
11163 * @memberOf _
11164 * @since 4.0.0
11165 * @category Lang
11166 * @param {*} value The value to recursively clone.
11167 * @param {Function} [customizer] The function to customize cloning.
11168 * @returns {*} Returns the deep cloned value.
11169 * @see _.cloneWith
11170 * @example
11171 *
11172 * function customizer(value) {
11173 * if (_.isElement(value)) {
11174 * return value.cloneNode(true);
11175 * }
11176 * }
11177 *
11178 * var el = _.cloneDeepWith(document.body, customizer);
11179 *
11180 * console.log(el === document.body);
11181 * // => false
11182 * console.log(el.nodeName);
11183 * // => 'BODY'
11184 * console.log(el.childNodes.length);
11185 * // => 20
11186 */
11187 function cloneDeepWith(value, customizer) {
11188 customizer = typeof customizer == 'function' ? customizer : undefined;
11189 return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
11190 }
11191
11192 /**
11193 * Checks if `object` conforms to `source` by invoking the predicate
11194 * properties of `source` with the corresponding property values of `object`.
11195 *
11196 * **Note:** This method is equivalent to `_.conforms` when `source` is
11197 * partially applied.
11198 *
11199 * @static
11200 * @memberOf _
11201 * @since 4.14.0
11202 * @category Lang
11203 * @param {Object} object The object to inspect.
11204 * @param {Object} source The object of property predicates to conform to.
11205 * @returns {boolean} Returns `true` if `object` conforms, else `false`.
11206 * @example
11207 *
11208 * var object = { 'a': 1, 'b': 2 };
11209 *
11210 * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
11211 * // => true
11212 *
11213 * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
11214 * // => false
11215 */
11216 function conformsTo(object, source) {
11217 return source == null || baseConformsTo(object, source, keys(source));
11218 }
11219
11220 /**
11221 * Performs a
11222 * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
11223 * comparison between two values to determine if they are equivalent.
11224 *
11225 * @static
11226 * @memberOf _
11227 * @since 4.0.0
11228 * @category Lang
11229 * @param {*} value The value to compare.
11230 * @param {*} other The other value to compare.
11231 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
11232 * @example
11233 *
11234 * var object = { 'a': 1 };
11235 * var other = { 'a': 1 };
11236 *
11237 * _.eq(object, object);
11238 * // => true
11239 *
11240 * _.eq(object, other);
11241 * // => false
11242 *
11243 * _.eq('a', 'a');
11244 * // => true
11245 *
11246 * _.eq('a', Object('a'));
11247 * // => false
11248 *
11249 * _.eq(NaN, NaN);
11250 * // => true
11251 */
11252 function eq(value, other) {
11253 return value === other || (value !== value && other !== other);
11254 }
11255
11256 /**
11257 * Checks if `value` is greater than `other`.
11258 *
11259 * @static
11260 * @memberOf _
11261 * @since 3.9.0
11262 * @category Lang
11263 * @param {*} value The value to compare.
11264 * @param {*} other The other value to compare.
11265 * @returns {boolean} Returns `true` if `value` is greater than `other`,
11266 * else `false`.
11267 * @see _.lt
11268 * @example
11269 *
11270 * _.gt(3, 1);
11271 * // => true
11272 *
11273 * _.gt(3, 3);
11274 * // => false
11275 *
11276 * _.gt(1, 3);
11277 * // => false
11278 */
11279 var gt = createRelationalOperation(baseGt);
11280
11281 /**
11282 * Checks if `value` is greater than or equal to `other`.
11283 *
11284 * @static
11285 * @memberOf _
11286 * @since 3.9.0
11287 * @category Lang
11288 * @param {*} value The value to compare.
11289 * @param {*} other The other value to compare.
11290 * @returns {boolean} Returns `true` if `value` is greater than or equal to
11291 * `other`, else `false`.
11292 * @see _.lte
11293 * @example
11294 *
11295 * _.gte(3, 1);
11296 * // => true
11297 *
11298 * _.gte(3, 3);
11299 * // => true
11300 *
11301 * _.gte(1, 3);
11302 * // => false
11303 */
11304 var gte = createRelationalOperation(function(value, other) {
11305 return value >= other;
11306 });
11307
11308 /**
11309 * Checks if `value` is likely an `arguments` object.
11310 *
11311 * @static
11312 * @memberOf _
11313 * @since 0.1.0
11314 * @category Lang
11315 * @param {*} value The value to check.
11316 * @returns {boolean} Returns `true` if `value` is an `arguments` object,
11317 * else `false`.
11318 * @example
11319 *
11320 * _.isArguments(function() { return arguments; }());
11321 * // => true
11322 *
11323 * _.isArguments([1, 2, 3]);
11324 * // => false
11325 */
11326 var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
11327 return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
11328 !propertyIsEnumerable.call(value, 'callee');
11329 };
11330
11331 /**
11332 * Checks if `value` is classified as an `Array` object.
11333 *
11334 * @static
11335 * @memberOf _
11336 * @since 0.1.0
11337 * @category Lang
11338 * @param {*} value The value to check.
11339 * @returns {boolean} Returns `true` if `value` is an array, else `false`.
11340 * @example
11341 *
11342 * _.isArray([1, 2, 3]);
11343 * // => true
11344 *
11345 * _.isArray(document.body.children);
11346 * // => false
11347 *
11348 * _.isArray('abc');
11349 * // => false
11350 *
11351 * _.isArray(_.noop);
11352 * // => false
11353 */
11354 var isArray = Array.isArray;
11355
11356 /**
11357 * Checks if `value` is classified as an `ArrayBuffer` object.
11358 *
11359 * @static
11360 * @memberOf _
11361 * @since 4.3.0
11362 * @category Lang
11363 * @param {*} value The value to check.
11364 * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
11365 * @example
11366 *
11367 * _.isArrayBuffer(new ArrayBuffer(2));
11368 * // => true
11369 *
11370 * _.isArrayBuffer(new Array(2));
11371 * // => false
11372 */
11373 var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
11374
11375 /**
11376 * Checks if `value` is array-like. A value is considered array-like if it's
11377 * not a function and has a `value.length` that's an integer greater than or
11378 * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
11379 *
11380 * @static
11381 * @memberOf _
11382 * @since 4.0.0
11383 * @category Lang
11384 * @param {*} value The value to check.
11385 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
11386 * @example
11387 *
11388 * _.isArrayLike([1, 2, 3]);
11389 * // => true
11390 *
11391 * _.isArrayLike(document.body.children);
11392 * // => true
11393 *
11394 * _.isArrayLike('abc');
11395 * // => true
11396 *
11397 * _.isArrayLike(_.noop);
11398 * // => false
11399 */
11400 function isArrayLike(value) {
11401 return value != null && isLength(value.length) && !isFunction(value);
11402 }
11403
11404 /**
11405 * This method is like `_.isArrayLike` except that it also checks if `value`
11406 * is an object.
11407 *
11408 * @static
11409 * @memberOf _
11410 * @since 4.0.0
11411 * @category Lang
11412 * @param {*} value The value to check.
11413 * @returns {boolean} Returns `true` if `value` is an array-like object,
11414 * else `false`.
11415 * @example
11416 *
11417 * _.isArrayLikeObject([1, 2, 3]);
11418 * // => true
11419 *
11420 * _.isArrayLikeObject(document.body.children);
11421 * // => true
11422 *
11423 * _.isArrayLikeObject('abc');
11424 * // => false
11425 *
11426 * _.isArrayLikeObject(_.noop);
11427 * // => false
11428 */
11429 function isArrayLikeObject(value) {
11430 return isObjectLike(value) && isArrayLike(value);
11431 }
11432
11433 /**
11434 * Checks if `value` is classified as a boolean primitive or object.
11435 *
11436 * @static
11437 * @memberOf _
11438 * @since 0.1.0
11439 * @category Lang
11440 * @param {*} value The value to check.
11441 * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
11442 * @example
11443 *
11444 * _.isBoolean(false);
11445 * // => true
11446 *
11447 * _.isBoolean(null);
11448 * // => false
11449 */
11450 function isBoolean(value) {
11451 return value === true || value === false ||
11452 (isObjectLike(value) && baseGetTag(value) == boolTag);
11453 }
11454
11455 /**
11456 * Checks if `value` is a buffer.
11457 *
11458 * @static
11459 * @memberOf _
11460 * @since 4.3.0
11461 * @category Lang
11462 * @param {*} value The value to check.
11463 * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
11464 * @example
11465 *
11466 * _.isBuffer(new Buffer(2));
11467 * // => true
11468 *
11469 * _.isBuffer(new Uint8Array(2));
11470 * // => false
11471 */
11472 var isBuffer = nativeIsBuffer || stubFalse;
11473
11474 /**
11475 * Checks if `value` is classified as a `Date` object.
11476 *
11477 * @static
11478 * @memberOf _
11479 * @since 0.1.0
11480 * @category Lang
11481 * @param {*} value The value to check.
11482 * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
11483 * @example
11484 *
11485 * _.isDate(new Date);
11486 * // => true
11487 *
11488 * _.isDate('Mon April 23 2012');
11489 * // => false
11490 */
11491 var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
11492
11493 /**
11494 * Checks if `value` is likely a DOM element.
11495 *
11496 * @static
11497 * @memberOf _
11498 * @since 0.1.0
11499 * @category Lang
11500 * @param {*} value The value to check.
11501 * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
11502 * @example
11503 *
11504 * _.isElement(document.body);
11505 * // => true
11506 *
11507 * _.isElement('<body>');
11508 * // => false
11509 */
11510 function isElement(value) {
11511 return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
11512 }
11513
11514 /**
11515 * Checks if `value` is an empty object, collection, map, or set.
11516 *
11517 * Objects are considered empty if they have no own enumerable string keyed
11518 * properties.
11519 *
11520 * Array-like values such as `arguments` objects, arrays, buffers, strings, or
11521 * jQuery-like collections are considered empty if they have a `length` of `0`.
11522 * Similarly, maps and sets are considered empty if they have a `size` of `0`.
11523 *
11524 * @static
11525 * @memberOf _
11526 * @since 0.1.0
11527 * @category Lang
11528 * @param {*} value The value to check.
11529 * @returns {boolean} Returns `true` if `value` is empty, else `false`.
11530 * @example
11531 *
11532 * _.isEmpty(null);
11533 * // => true
11534 *
11535 * _.isEmpty(true);
11536 * // => true
11537 *
11538 * _.isEmpty(1);
11539 * // => true
11540 *
11541 * _.isEmpty([1, 2, 3]);
11542 * // => false
11543 *
11544 * _.isEmpty({ 'a': 1 });
11545 * // => false
11546 */
11547 function isEmpty(value) {
11548 if (value == null) {
11549 return true;
11550 }
11551 if (isArrayLike(value) &&
11552 (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
11553 isBuffer(value) || isTypedArray(value) || isArguments(value))) {
11554 return !value.length;
11555 }
11556 var tag = getTag(value);
11557 if (tag == mapTag || tag == setTag) {
11558 return !value.size;
11559 }
11560 if (isPrototype(value)) {
11561 return !baseKeys(value).length;
11562 }
11563 for (var key in value) {
11564 if (hasOwnProperty.call(value, key)) {
11565 return false;
11566 }
11567 }
11568 return true;
11569 }
11570
11571 /**
11572 * Performs a deep comparison between two values to determine if they are
11573 * equivalent.
11574 *
11575 * **Note:** This method supports comparing arrays, array buffers, booleans,
11576 * date objects, error objects, maps, numbers, `Object` objects, regexes,
11577 * sets, strings, symbols, and typed arrays. `Object` objects are compared
11578 * by their own, not inherited, enumerable properties. Functions and DOM
11579 * nodes are compared by strict equality, i.e. `===`.
11580 *
11581 * @static
11582 * @memberOf _
11583 * @since 0.1.0
11584 * @category Lang
11585 * @param {*} value The value to compare.
11586 * @param {*} other The other value to compare.
11587 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
11588 * @example
11589 *
11590 * var object = { 'a': 1 };
11591 * var other = { 'a': 1 };
11592 *
11593 * _.isEqual(object, other);
11594 * // => true
11595 *
11596 * object === other;
11597 * // => false
11598 */
11599 function isEqual(value, other) {
11600 return baseIsEqual(value, other);
11601 }
11602
11603 /**
11604 * This method is like `_.isEqual` except that it accepts `customizer` which
11605 * is invoked to compare values. If `customizer` returns `undefined`, comparisons
11606 * are handled by the method instead. The `customizer` is invoked with up to
11607 * six arguments: (objValue, othValue [, index|key, object, other, stack]).
11608 *
11609 * @static
11610 * @memberOf _
11611 * @since 4.0.0
11612 * @category Lang
11613 * @param {*} value The value to compare.
11614 * @param {*} other The other value to compare.
11615 * @param {Function} [customizer] The function to customize comparisons.
11616 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
11617 * @example
11618 *
11619 * function isGreeting(value) {
11620 * return /^h(?:i|ello)$/.test(value);
11621 * }
11622 *
11623 * function customizer(objValue, othValue) {
11624 * if (isGreeting(objValue) && isGreeting(othValue)) {
11625 * return true;
11626 * }
11627 * }
11628 *
11629 * var array = ['hello', 'goodbye'];
11630 * var other = ['hi', 'goodbye'];
11631 *
11632 * _.isEqualWith(array, other, customizer);
11633 * // => true
11634 */
11635 function isEqualWith(value, other, customizer) {
11636 customizer = typeof customizer == 'function' ? customizer : undefined;
11637 var result = customizer ? customizer(value, other) : undefined;
11638 return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
11639 }
11640
11641 /**
11642 * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
11643 * `SyntaxError`, `TypeError`, or `URIError` object.
11644 *
11645 * @static
11646 * @memberOf _
11647 * @since 3.0.0
11648 * @category Lang
11649 * @param {*} value The value to check.
11650 * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
11651 * @example
11652 *
11653 * _.isError(new Error);
11654 * // => true
11655 *
11656 * _.isError(Error);
11657 * // => false
11658 */
11659 function isError(value) {
11660 if (!isObjectLike(value)) {
11661 return false;
11662 }
11663 var tag = baseGetTag(value);
11664 return tag == errorTag || tag == domExcTag ||
11665 (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
11666 }
11667
11668 /**
11669 * Checks if `value` is a finite primitive number.
11670 *
11671 * **Note:** This method is based on
11672 * [`Number.isFinite`](https://mdn.io/Number/isFinite).
11673 *
11674 * @static
11675 * @memberOf _
11676 * @since 0.1.0
11677 * @category Lang
11678 * @param {*} value The value to check.
11679 * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
11680 * @example
11681 *
11682 * _.isFinite(3);
11683 * // => true
11684 *
11685 * _.isFinite(Number.MIN_VALUE);
11686 * // => true
11687 *
11688 * _.isFinite(Infinity);
11689 * // => false
11690 *
11691 * _.isFinite('3');
11692 * // => false
11693 */
11694 function isFinite(value) {
11695 return typeof value == 'number' && nativeIsFinite(value);
11696 }
11697
11698 /**
11699 * Checks if `value` is classified as a `Function` object.
11700 *
11701 * @static
11702 * @memberOf _
11703 * @since 0.1.0
11704 * @category Lang
11705 * @param {*} value The value to check.
11706 * @returns {boolean} Returns `true` if `value` is a function, else `false`.
11707 * @example
11708 *
11709 * _.isFunction(_);
11710 * // => true
11711 *
11712 * _.isFunction(/abc/);
11713 * // => false
11714 */
11715 function isFunction(value) {
11716 if (!isObject(value)) {
11717 return false;
11718 }
11719 // The use of `Object#toString` avoids issues with the `typeof` operator
11720 // in Safari 9 which returns 'object' for typed arrays and other constructors.
11721 var tag = baseGetTag(value);
11722 return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
11723 }
11724
11725 /**
11726 * Checks if `value` is an integer.
11727 *
11728 * **Note:** This method is based on
11729 * [`Number.isInteger`](https://mdn.io/Number/isInteger).
11730 *
11731 * @static
11732 * @memberOf _
11733 * @since 4.0.0
11734 * @category Lang
11735 * @param {*} value The value to check.
11736 * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
11737 * @example
11738 *
11739 * _.isInteger(3);
11740 * // => true
11741 *
11742 * _.isInteger(Number.MIN_VALUE);
11743 * // => false
11744 *
11745 * _.isInteger(Infinity);
11746 * // => false
11747 *
11748 * _.isInteger('3');
11749 * // => false
11750 */
11751 function isInteger(value) {
11752 return typeof value == 'number' && value == toInteger(value);
11753 }
11754
11755 /**
11756 * Checks if `value` is a valid array-like length.
11757 *
11758 * **Note:** This method is loosely based on
11759 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
11760 *
11761 * @static
11762 * @memberOf _
11763 * @since 4.0.0
11764 * @category Lang
11765 * @param {*} value The value to check.
11766 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
11767 * @example
11768 *
11769 * _.isLength(3);
11770 * // => true
11771 *
11772 * _.isLength(Number.MIN_VALUE);
11773 * // => false
11774 *
11775 * _.isLength(Infinity);
11776 * // => false
11777 *
11778 * _.isLength('3');
11779 * // => false
11780 */
11781 function isLength(value) {
11782 return typeof value == 'number' &&
11783 value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
11784 }
11785
11786 /**
11787 * Checks if `value` is the
11788 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
11789 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
11790 *
11791 * @static
11792 * @memberOf _
11793 * @since 0.1.0
11794 * @category Lang
11795 * @param {*} value The value to check.
11796 * @returns {boolean} Returns `true` if `value` is an object, else `false`.
11797 * @example
11798 *
11799 * _.isObject({});
11800 * // => true
11801 *
11802 * _.isObject([1, 2, 3]);
11803 * // => true
11804 *
11805 * _.isObject(_.noop);
11806 * // => true
11807 *
11808 * _.isObject(null);
11809 * // => false
11810 */
11811 function isObject(value) {
11812 var type = typeof value;
11813 return value != null && (type == 'object' || type == 'function');
11814 }
11815
11816 /**
11817 * Checks if `value` is object-like. A value is object-like if it's not `null`
11818 * and has a `typeof` result of "object".
11819 *
11820 * @static
11821 * @memberOf _
11822 * @since 4.0.0
11823 * @category Lang
11824 * @param {*} value The value to check.
11825 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
11826 * @example
11827 *
11828 * _.isObjectLike({});
11829 * // => true
11830 *
11831 * _.isObjectLike([1, 2, 3]);
11832 * // => true
11833 *
11834 * _.isObjectLike(_.noop);
11835 * // => false
11836 *
11837 * _.isObjectLike(null);
11838 * // => false
11839 */
11840 function isObjectLike(value) {
11841 return value != null && typeof value == 'object';
11842 }
11843
11844 /**
11845 * Checks if `value` is classified as a `Map` object.
11846 *
11847 * @static
11848 * @memberOf _
11849 * @since 4.3.0
11850 * @category Lang
11851 * @param {*} value The value to check.
11852 * @returns {boolean} Returns `true` if `value` is a map, else `false`.
11853 * @example
11854 *
11855 * _.isMap(new Map);
11856 * // => true
11857 *
11858 * _.isMap(new WeakMap);
11859 * // => false
11860 */
11861 var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
11862
11863 /**
11864 * Performs a partial deep comparison between `object` and `source` to
11865 * determine if `object` contains equivalent property values.
11866 *
11867 * **Note:** This method is equivalent to `_.matches` when `source` is
11868 * partially applied.
11869 *
11870 * Partial comparisons will match empty array and empty object `source`
11871 * values against any array or object value, respectively. See `_.isEqual`
11872 * for a list of supported value comparisons.
11873 *
11874 * @static
11875 * @memberOf _
11876 * @since 3.0.0
11877 * @category Lang
11878 * @param {Object} object The object to inspect.
11879 * @param {Object} source The object of property values to match.
11880 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
11881 * @example
11882 *
11883 * var object = { 'a': 1, 'b': 2 };
11884 *
11885 * _.isMatch(object, { 'b': 2 });
11886 * // => true
11887 *
11888 * _.isMatch(object, { 'b': 1 });
11889 * // => false
11890 */
11891 function isMatch(object, source) {
11892 return object === source || baseIsMatch(object, source, getMatchData(source));
11893 }
11894
11895 /**
11896 * This method is like `_.isMatch` except that it accepts `customizer` which
11897 * is invoked to compare values. If `customizer` returns `undefined`, comparisons
11898 * are handled by the method instead. The `customizer` is invoked with five
11899 * arguments: (objValue, srcValue, index|key, object, source).
11900 *
11901 * @static
11902 * @memberOf _
11903 * @since 4.0.0
11904 * @category Lang
11905 * @param {Object} object The object to inspect.
11906 * @param {Object} source The object of property values to match.
11907 * @param {Function} [customizer] The function to customize comparisons.
11908 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
11909 * @example
11910 *
11911 * function isGreeting(value) {
11912 * return /^h(?:i|ello)$/.test(value);
11913 * }
11914 *
11915 * function customizer(objValue, srcValue) {
11916 * if (isGreeting(objValue) && isGreeting(srcValue)) {
11917 * return true;
11918 * }
11919 * }
11920 *
11921 * var object = { 'greeting': 'hello' };
11922 * var source = { 'greeting': 'hi' };
11923 *
11924 * _.isMatchWith(object, source, customizer);
11925 * // => true
11926 */
11927 function isMatchWith(object, source, customizer) {
11928 customizer = typeof customizer == 'function' ? customizer : undefined;
11929 return baseIsMatch(object, source, getMatchData(source), customizer);
11930 }
11931
11932 /**
11933 * Checks if `value` is `NaN`.
11934 *
11935 * **Note:** This method is based on
11936 * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
11937 * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
11938 * `undefined` and other non-number values.
11939 *
11940 * @static
11941 * @memberOf _
11942 * @since 0.1.0
11943 * @category Lang
11944 * @param {*} value The value to check.
11945 * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
11946 * @example
11947 *
11948 * _.isNaN(NaN);
11949 * // => true
11950 *
11951 * _.isNaN(new Number(NaN));
11952 * // => true
11953 *
11954 * isNaN(undefined);
11955 * // => true
11956 *
11957 * _.isNaN(undefined);
11958 * // => false
11959 */
11960 function isNaN(value) {
11961 // An `NaN` primitive is the only value that is not equal to itself.
11962 // Perform the `toStringTag` check first to avoid errors with some
11963 // ActiveX objects in IE.
11964 return isNumber(value) && value != +value;
11965 }
11966
11967 /**
11968 * Checks if `value` is a pristine native function.
11969 *
11970 * **Note:** This method can't reliably detect native functions in the presence
11971 * of the core-js package because core-js circumvents this kind of detection.
11972 * Despite multiple requests, the core-js maintainer has made it clear: any
11973 * attempt to fix the detection will be obstructed. As a result, we're left
11974 * with little choice but to throw an error. Unfortunately, this also affects
11975 * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
11976 * which rely on core-js.
11977 *
11978 * @static
11979 * @memberOf _
11980 * @since 3.0.0
11981 * @category Lang
11982 * @param {*} value The value to check.
11983 * @returns {boolean} Returns `true` if `value` is a native function,
11984 * else `false`.
11985 * @example
11986 *
11987 * _.isNative(Array.prototype.push);
11988 * // => true
11989 *
11990 * _.isNative(_);
11991 * // => false
11992 */
11993 function isNative(value) {
11994 if (isMaskable(value)) {
11995 throw new Error(CORE_ERROR_TEXT);
11996 }
11997 return baseIsNative(value);
11998 }
11999
12000 /**
12001 * Checks if `value` is `null`.
12002 *
12003 * @static
12004 * @memberOf _
12005 * @since 0.1.0
12006 * @category Lang
12007 * @param {*} value The value to check.
12008 * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
12009 * @example
12010 *
12011 * _.isNull(null);
12012 * // => true
12013 *
12014 * _.isNull(void 0);
12015 * // => false
12016 */
12017 function isNull(value) {
12018 return value === null;
12019 }
12020
12021 /**
12022 * Checks if `value` is `null` or `undefined`.
12023 *
12024 * @static
12025 * @memberOf _
12026 * @since 4.0.0
12027 * @category Lang
12028 * @param {*} value The value to check.
12029 * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
12030 * @example
12031 *
12032 * _.isNil(null);
12033 * // => true
12034 *
12035 * _.isNil(void 0);
12036 * // => true
12037 *
12038 * _.isNil(NaN);
12039 * // => false
12040 */
12041 function isNil(value) {
12042 return value == null;
12043 }
12044
12045 /**
12046 * Checks if `value` is classified as a `Number` primitive or object.
12047 *
12048 * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
12049 * classified as numbers, use the `_.isFinite` method.
12050 *
12051 * @static
12052 * @memberOf _
12053 * @since 0.1.0
12054 * @category Lang
12055 * @param {*} value The value to check.
12056 * @returns {boolean} Returns `true` if `value` is a number, else `false`.
12057 * @example
12058 *
12059 * _.isNumber(3);
12060 * // => true
12061 *
12062 * _.isNumber(Number.MIN_VALUE);
12063 * // => true
12064 *
12065 * _.isNumber(Infinity);
12066 * // => true
12067 *
12068 * _.isNumber('3');
12069 * // => false
12070 */
12071 function isNumber(value) {
12072 return typeof value == 'number' ||
12073 (isObjectLike(value) && baseGetTag(value) == numberTag);
12074 }
12075
12076 /**
12077 * Checks if `value` is a plain object, that is, an object created by the
12078 * `Object` constructor or one with a `[[Prototype]]` of `null`.
12079 *
12080 * @static
12081 * @memberOf _
12082 * @since 0.8.0
12083 * @category Lang
12084 * @param {*} value The value to check.
12085 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
12086 * @example
12087 *
12088 * function Foo() {
12089 * this.a = 1;
12090 * }
12091 *
12092 * _.isPlainObject(new Foo);
12093 * // => false
12094 *
12095 * _.isPlainObject([1, 2, 3]);
12096 * // => false
12097 *
12098 * _.isPlainObject({ 'x': 0, 'y': 0 });
12099 * // => true
12100 *
12101 * _.isPlainObject(Object.create(null));
12102 * // => true
12103 */
12104 function isPlainObject(value) {
12105 if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
12106 return false;
12107 }
12108 var proto = getPrototype(value);
12109 if (proto === null) {
12110 return true;
12111 }
12112 var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
12113 return typeof Ctor == 'function' && Ctor instanceof Ctor &&
12114 funcToString.call(Ctor) == objectCtorString;
12115 }
12116
12117 /**
12118 * Checks if `value` is classified as a `RegExp` object.
12119 *
12120 * @static
12121 * @memberOf _
12122 * @since 0.1.0
12123 * @category Lang
12124 * @param {*} value The value to check.
12125 * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
12126 * @example
12127 *
12128 * _.isRegExp(/abc/);
12129 * // => true
12130 *
12131 * _.isRegExp('/abc/');
12132 * // => false
12133 */
12134 var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
12135
12136 /**
12137 * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
12138 * double precision number which isn't the result of a rounded unsafe integer.
12139 *
12140 * **Note:** This method is based on
12141 * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
12142 *
12143 * @static
12144 * @memberOf _
12145 * @since 4.0.0
12146 * @category Lang
12147 * @param {*} value The value to check.
12148 * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
12149 * @example
12150 *
12151 * _.isSafeInteger(3);
12152 * // => true
12153 *
12154 * _.isSafeInteger(Number.MIN_VALUE);
12155 * // => false
12156 *
12157 * _.isSafeInteger(Infinity);
12158 * // => false
12159 *
12160 * _.isSafeInteger('3');
12161 * // => false
12162 */
12163 function isSafeInteger(value) {
12164 return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
12165 }
12166
12167 /**
12168 * Checks if `value` is classified as a `Set` object.
12169 *
12170 * @static
12171 * @memberOf _
12172 * @since 4.3.0
12173 * @category Lang
12174 * @param {*} value The value to check.
12175 * @returns {boolean} Returns `true` if `value` is a set, else `false`.
12176 * @example
12177 *
12178 * _.isSet(new Set);
12179 * // => true
12180 *
12181 * _.isSet(new WeakSet);
12182 * // => false
12183 */
12184 var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
12185
12186 /**
12187 * Checks if `value` is classified as a `String` primitive or object.
12188 *
12189 * @static
12190 * @since 0.1.0
12191 * @memberOf _
12192 * @category Lang
12193 * @param {*} value The value to check.
12194 * @returns {boolean} Returns `true` if `value` is a string, else `false`.
12195 * @example
12196 *
12197 * _.isString('abc');
12198 * // => true
12199 *
12200 * _.isString(1);
12201 * // => false
12202 */
12203 function isString(value) {
12204 return typeof value == 'string' ||
12205 (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
12206 }
12207
12208 /**
12209 * Checks if `value` is classified as a `Symbol` primitive or object.
12210 *
12211 * @static
12212 * @memberOf _
12213 * @since 4.0.0
12214 * @category Lang
12215 * @param {*} value The value to check.
12216 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
12217 * @example
12218 *
12219 * _.isSymbol(Symbol.iterator);
12220 * // => true
12221 *
12222 * _.isSymbol('abc');
12223 * // => false
12224 */
12225 function isSymbol(value) {
12226 return typeof value == 'symbol' ||
12227 (isObjectLike(value) && baseGetTag(value) == symbolTag);
12228 }
12229
12230 /**
12231 * Checks if `value` is classified as a typed array.
12232 *
12233 * @static
12234 * @memberOf _
12235 * @since 3.0.0
12236 * @category Lang
12237 * @param {*} value The value to check.
12238 * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
12239 * @example
12240 *
12241 * _.isTypedArray(new Uint8Array);
12242 * // => true
12243 *
12244 * _.isTypedArray([]);
12245 * // => false
12246 */
12247 var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
12248
12249 /**
12250 * Checks if `value` is `undefined`.
12251 *
12252 * @static
12253 * @since 0.1.0
12254 * @memberOf _
12255 * @category Lang
12256 * @param {*} value The value to check.
12257 * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
12258 * @example
12259 *
12260 * _.isUndefined(void 0);
12261 * // => true
12262 *
12263 * _.isUndefined(null);
12264 * // => false
12265 */
12266 function isUndefined(value) {
12267 return value === undefined;
12268 }
12269
12270 /**
12271 * Checks if `value` is classified as a `WeakMap` object.
12272 *
12273 * @static
12274 * @memberOf _
12275 * @since 4.3.0
12276 * @category Lang
12277 * @param {*} value The value to check.
12278 * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
12279 * @example
12280 *
12281 * _.isWeakMap(new WeakMap);
12282 * // => true
12283 *
12284 * _.isWeakMap(new Map);
12285 * // => false
12286 */
12287 function isWeakMap(value) {
12288 return isObjectLike(value) && getTag(value) == weakMapTag;
12289 }
12290
12291 /**
12292 * Checks if `value` is classified as a `WeakSet` object.
12293 *
12294 * @static
12295 * @memberOf _
12296 * @since 4.3.0
12297 * @category Lang
12298 * @param {*} value The value to check.
12299 * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
12300 * @example
12301 *
12302 * _.isWeakSet(new WeakSet);
12303 * // => true
12304 *
12305 * _.isWeakSet(new Set);
12306 * // => false
12307 */
12308 function isWeakSet(value) {
12309 return isObjectLike(value) && baseGetTag(value) == weakSetTag;
12310 }
12311
12312 /**
12313 * Checks if `value` is less than `other`.
12314 *
12315 * @static
12316 * @memberOf _
12317 * @since 3.9.0
12318 * @category Lang
12319 * @param {*} value The value to compare.
12320 * @param {*} other The other value to compare.
12321 * @returns {boolean} Returns `true` if `value` is less than `other`,
12322 * else `false`.
12323 * @see _.gt
12324 * @example
12325 *
12326 * _.lt(1, 3);
12327 * // => true
12328 *
12329 * _.lt(3, 3);
12330 * // => false
12331 *
12332 * _.lt(3, 1);
12333 * // => false
12334 */
12335 var lt = createRelationalOperation(baseLt);
12336
12337 /**
12338 * Checks if `value` is less than or equal to `other`.
12339 *
12340 * @static
12341 * @memberOf _
12342 * @since 3.9.0
12343 * @category Lang
12344 * @param {*} value The value to compare.
12345 * @param {*} other The other value to compare.
12346 * @returns {boolean} Returns `true` if `value` is less than or equal to
12347 * `other`, else `false`.
12348 * @see _.gte
12349 * @example
12350 *
12351 * _.lte(1, 3);
12352 * // => true
12353 *
12354 * _.lte(3, 3);
12355 * // => true
12356 *
12357 * _.lte(3, 1);
12358 * // => false
12359 */
12360 var lte = createRelationalOperation(function(value, other) {
12361 return value <= other;
12362 });
12363
12364 /**
12365 * Converts `value` to an array.
12366 *
12367 * @static
12368 * @since 0.1.0
12369 * @memberOf _
12370 * @category Lang
12371 * @param {*} value The value to convert.
12372 * @returns {Array} Returns the converted array.
12373 * @example
12374 *
12375 * _.toArray({ 'a': 1, 'b': 2 });
12376 * // => [1, 2]
12377 *
12378 * _.toArray('abc');
12379 * // => ['a', 'b', 'c']
12380 *
12381 * _.toArray(1);
12382 * // => []
12383 *
12384 * _.toArray(null);
12385 * // => []
12386 */
12387 function toArray(value) {
12388 if (!value) {
12389 return [];
12390 }
12391 if (isArrayLike(value)) {
12392 return isString(value) ? stringToArray(value) : copyArray(value);
12393 }
12394 if (symIterator && value[symIterator]) {
12395 return iteratorToArray(value[symIterator]());
12396 }
12397 var tag = getTag(value),
12398 func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);
12399
12400 return func(value);
12401 }
12402
12403 /**
12404 * Converts `value` to a finite number.
12405 *
12406 * @static
12407 * @memberOf _
12408 * @since 4.12.0
12409 * @category Lang
12410 * @param {*} value The value to convert.
12411 * @returns {number} Returns the converted number.
12412 * @example
12413 *
12414 * _.toFinite(3.2);
12415 * // => 3.2
12416 *
12417 * _.toFinite(Number.MIN_VALUE);
12418 * // => 5e-324
12419 *
12420 * _.toFinite(Infinity);
12421 * // => 1.7976931348623157e+308
12422 *
12423 * _.toFinite('3.2');
12424 * // => 3.2
12425 */
12426 function toFinite(value) {
12427 if (!value) {
12428 return value === 0 ? value : 0;
12429 }
12430 value = toNumber(value);
12431 if (value === INFINITY || value === -INFINITY) {
12432 var sign = (value < 0 ? -1 : 1);
12433 return sign * MAX_INTEGER;
12434 }
12435 return value === value ? value : 0;
12436 }
12437
12438 /**
12439 * Converts `value` to an integer.
12440 *
12441 * **Note:** This method is loosely based on
12442 * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
12443 *
12444 * @static
12445 * @memberOf _
12446 * @since 4.0.0
12447 * @category Lang
12448 * @param {*} value The value to convert.
12449 * @returns {number} Returns the converted integer.
12450 * @example
12451 *
12452 * _.toInteger(3.2);
12453 * // => 3
12454 *
12455 * _.toInteger(Number.MIN_VALUE);
12456 * // => 0
12457 *
12458 * _.toInteger(Infinity);
12459 * // => 1.7976931348623157e+308
12460 *
12461 * _.toInteger('3.2');
12462 * // => 3
12463 */
12464 function toInteger(value) {
12465 var result = toFinite(value),
12466 remainder = result % 1;
12467
12468 return result === result ? (remainder ? result - remainder : result) : 0;
12469 }
12470
12471 /**
12472 * Converts `value` to an integer suitable for use as the length of an
12473 * array-like object.
12474 *
12475 * **Note:** This method is based on
12476 * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
12477 *
12478 * @static
12479 * @memberOf _
12480 * @since 4.0.0
12481 * @category Lang
12482 * @param {*} value The value to convert.
12483 * @returns {number} Returns the converted integer.
12484 * @example
12485 *
12486 * _.toLength(3.2);
12487 * // => 3
12488 *
12489 * _.toLength(Number.MIN_VALUE);
12490 * // => 0
12491 *
12492 * _.toLength(Infinity);
12493 * // => 4294967295
12494 *
12495 * _.toLength('3.2');
12496 * // => 3
12497 */
12498 function toLength(value) {
12499 return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
12500 }
12501
12502 /**
12503 * Converts `value` to a number.
12504 *
12505 * @static
12506 * @memberOf _
12507 * @since 4.0.0
12508 * @category Lang
12509 * @param {*} value The value to process.
12510 * @returns {number} Returns the number.
12511 * @example
12512 *
12513 * _.toNumber(3.2);
12514 * // => 3.2
12515 *
12516 * _.toNumber(Number.MIN_VALUE);
12517 * // => 5e-324
12518 *
12519 * _.toNumber(Infinity);
12520 * // => Infinity
12521 *
12522 * _.toNumber('3.2');
12523 * // => 3.2
12524 */
12525 function toNumber(value) {
12526 if (typeof value == 'number') {
12527 return value;
12528 }
12529 if (isSymbol(value)) {
12530 return NAN;
12531 }
12532 if (isObject(value)) {
12533 var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
12534 value = isObject(other) ? (other + '') : other;
12535 }
12536 if (typeof value != 'string') {
12537 return value === 0 ? value : +value;
12538 }
12539 value = baseTrim(value);
12540 var isBinary = reIsBinary.test(value);
12541 return (isBinary || reIsOctal.test(value))
12542 ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
12543 : (reIsBadHex.test(value) ? NAN : +value);
12544 }
12545
12546 /**
12547 * Converts `value` to a plain object flattening inherited enumerable string
12548 * keyed properties of `value` to own properties of the plain object.
12549 *
12550 * @static
12551 * @memberOf _
12552 * @since 3.0.0
12553 * @category Lang
12554 * @param {*} value The value to convert.
12555 * @returns {Object} Returns the converted plain object.
12556 * @example
12557 *
12558 * function Foo() {
12559 * this.b = 2;
12560 * }
12561 *
12562 * Foo.prototype.c = 3;
12563 *
12564 * _.assign({ 'a': 1 }, new Foo);
12565 * // => { 'a': 1, 'b': 2 }
12566 *
12567 * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
12568 * // => { 'a': 1, 'b': 2, 'c': 3 }
12569 */
12570 function toPlainObject(value) {
12571 return copyObject(value, keysIn(value));
12572 }
12573
12574 /**
12575 * Converts `value` to a safe integer. A safe integer can be compared and
12576 * represented correctly.
12577 *
12578 * @static
12579 * @memberOf _
12580 * @since 4.0.0
12581 * @category Lang
12582 * @param {*} value The value to convert.
12583 * @returns {number} Returns the converted integer.
12584 * @example
12585 *
12586 * _.toSafeInteger(3.2);
12587 * // => 3
12588 *
12589 * _.toSafeInteger(Number.MIN_VALUE);
12590 * // => 0
12591 *
12592 * _.toSafeInteger(Infinity);
12593 * // => 9007199254740991
12594 *
12595 * _.toSafeInteger('3.2');
12596 * // => 3
12597 */
12598 function toSafeInteger(value) {
12599 return value
12600 ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
12601 : (value === 0 ? value : 0);
12602 }
12603
12604 /**
12605 * Converts `value` to a string. An empty string is returned for `null`
12606 * and `undefined` values. The sign of `-0` is preserved.
12607 *
12608 * @static
12609 * @memberOf _
12610 * @since 4.0.0
12611 * @category Lang
12612 * @param {*} value The value to convert.
12613 * @returns {string} Returns the converted string.
12614 * @example
12615 *
12616 * _.toString(null);
12617 * // => ''
12618 *
12619 * _.toString(-0);
12620 * // => '-0'
12621 *
12622 * _.toString([1, 2, 3]);
12623 * // => '1,2,3'
12624 */
12625 function toString(value) {
12626 return value == null ? '' : baseToString(value);
12627 }
12628
12629 /*------------------------------------------------------------------------*/
12630
12631 /**
12632 * Assigns own enumerable string keyed properties of source objects to the
12633 * destination object. Source objects are applied from left to right.
12634 * Subsequent sources overwrite property assignments of previous sources.
12635 *
12636 * **Note:** This method mutates `object` and is loosely based on
12637 * [`Object.assign`](https://mdn.io/Object/assign).
12638 *
12639 * @static
12640 * @memberOf _
12641 * @since 0.10.0
12642 * @category Object
12643 * @param {Object} object The destination object.
12644 * @param {...Object} [sources] The source objects.
12645 * @returns {Object} Returns `object`.
12646 * @see _.assignIn
12647 * @example
12648 *
12649 * function Foo() {
12650 * this.a = 1;
12651 * }
12652 *
12653 * function Bar() {
12654 * this.c = 3;
12655 * }
12656 *
12657 * Foo.prototype.b = 2;
12658 * Bar.prototype.d = 4;
12659 *
12660 * _.assign({ 'a': 0 }, new Foo, new Bar);
12661 * // => { 'a': 1, 'c': 3 }
12662 */
12663 var assign = createAssigner(function(object, source) {
12664 if (isPrototype(source) || isArrayLike(source)) {
12665 copyObject(source, keys(source), object);
12666 return;
12667 }
12668 for (var key in source) {
12669 if (hasOwnProperty.call(source, key)) {
12670 assignValue(object, key, source[key]);
12671 }
12672 }
12673 });
12674
12675 /**
12676 * This method is like `_.assign` except that it iterates over own and
12677 * inherited source properties.
12678 *
12679 * **Note:** This method mutates `object`.
12680 *
12681 * @static
12682 * @memberOf _
12683 * @since 4.0.0
12684 * @alias extend
12685 * @category Object
12686 * @param {Object} object The destination object.
12687 * @param {...Object} [sources] The source objects.
12688 * @returns {Object} Returns `object`.
12689 * @see _.assign
12690 * @example
12691 *
12692 * function Foo() {
12693 * this.a = 1;
12694 * }
12695 *
12696 * function Bar() {
12697 * this.c = 3;
12698 * }
12699 *
12700 * Foo.prototype.b = 2;
12701 * Bar.prototype.d = 4;
12702 *
12703 * _.assignIn({ 'a': 0 }, new Foo, new Bar);
12704 * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
12705 */
12706 var assignIn = createAssigner(function(object, source) {
12707 copyObject(source, keysIn(source), object);
12708 });
12709
12710 /**
12711 * This method is like `_.assignIn` except that it accepts `customizer`
12712 * which is invoked to produce the assigned values. If `customizer` returns
12713 * `undefined`, assignment is handled by the method instead. The `customizer`
12714 * is invoked with five arguments: (objValue, srcValue, key, object, source).
12715 *
12716 * **Note:** This method mutates `object`.
12717 *
12718 * @static
12719 * @memberOf _
12720 * @since 4.0.0
12721 * @alias extendWith
12722 * @category Object
12723 * @param {Object} object The destination object.
12724 * @param {...Object} sources The source objects.
12725 * @param {Function} [customizer] The function to customize assigned values.
12726 * @returns {Object} Returns `object`.
12727 * @see _.assignWith
12728 * @example
12729 *
12730 * function customizer(objValue, srcValue) {
12731 * return _.isUndefined(objValue) ? srcValue : objValue;
12732 * }
12733 *
12734 * var defaults = _.partialRight(_.assignInWith, customizer);
12735 *
12736 * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
12737 * // => { 'a': 1, 'b': 2 }
12738 */
12739 var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
12740 copyObject(source, keysIn(source), object, customizer);
12741 });
12742
12743 /**
12744 * This method is like `_.assign` except that it accepts `customizer`
12745 * which is invoked to produce the assigned values. If `customizer` returns
12746 * `undefined`, assignment is handled by the method instead. The `customizer`
12747 * is invoked with five arguments: (objValue, srcValue, key, object, source).
12748 *
12749 * **Note:** This method mutates `object`.
12750 *
12751 * @static
12752 * @memberOf _
12753 * @since 4.0.0
12754 * @category Object
12755 * @param {Object} object The destination object.
12756 * @param {...Object} sources The source objects.
12757 * @param {Function} [customizer] The function to customize assigned values.
12758 * @returns {Object} Returns `object`.
12759 * @see _.assignInWith
12760 * @example
12761 *
12762 * function customizer(objValue, srcValue) {
12763 * return _.isUndefined(objValue) ? srcValue : objValue;
12764 * }
12765 *
12766 * var defaults = _.partialRight(_.assignWith, customizer);
12767 *
12768 * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
12769 * // => { 'a': 1, 'b': 2 }
12770 */
12771 var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
12772 copyObject(source, keys(source), object, customizer);
12773 });
12774
12775 /**
12776 * Creates an array of values corresponding to `paths` of `object`.
12777 *
12778 * @static
12779 * @memberOf _
12780 * @since 1.0.0
12781 * @category Object
12782 * @param {Object} object The object to iterate over.
12783 * @param {...(string|string[])} [paths] The property paths to pick.
12784 * @returns {Array} Returns the picked values.
12785 * @example
12786 *
12787 * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
12788 *
12789 * _.at(object, ['a[0].b.c', 'a[1]']);
12790 * // => [3, 4]
12791 */
12792 var at = flatRest(baseAt);
12793
12794 /**
12795 * Creates an object that inherits from the `prototype` object. If a
12796 * `properties` object is given, its own enumerable string keyed properties
12797 * are assigned to the created object.
12798 *
12799 * @static
12800 * @memberOf _
12801 * @since 2.3.0
12802 * @category Object
12803 * @param {Object} prototype The object to inherit from.
12804 * @param {Object} [properties] The properties to assign to the object.
12805 * @returns {Object} Returns the new object.
12806 * @example
12807 *
12808 * function Shape() {
12809 * this.x = 0;
12810 * this.y = 0;
12811 * }
12812 *
12813 * function Circle() {
12814 * Shape.call(this);
12815 * }
12816 *
12817 * Circle.prototype = _.create(Shape.prototype, {
12818 * 'constructor': Circle
12819 * });
12820 *
12821 * var circle = new Circle;
12822 * circle instanceof Circle;
12823 * // => true
12824 *
12825 * circle instanceof Shape;
12826 * // => true
12827 */
12828 function create(prototype, properties) {
12829 var result = baseCreate(prototype);
12830 return properties == null ? result : baseAssign(result, properties);
12831 }
12832
12833 /**
12834 * Assigns own and inherited enumerable string keyed properties of source
12835 * objects to the destination object for all destination properties that
12836 * resolve to `undefined`. Source objects are applied from left to right.
12837 * Once a property is set, additional values of the same property are ignored.
12838 *
12839 * **Note:** This method mutates `object`.
12840 *
12841 * @static
12842 * @since 0.1.0
12843 * @memberOf _
12844 * @category Object
12845 * @param {Object} object The destination object.
12846 * @param {...Object} [sources] The source objects.
12847 * @returns {Object} Returns `object`.
12848 * @see _.defaultsDeep
12849 * @example
12850 *
12851 * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
12852 * // => { 'a': 1, 'b': 2 }
12853 */
12854 var defaults = baseRest(function(object, sources) {
12855 object = Object(object);
12856
12857 var index = -1;
12858 var length = sources.length;
12859 var guard = length > 2 ? sources[2] : undefined;
12860
12861 if (guard && isIterateeCall(sources[0], sources[1], guard)) {
12862 length = 1;
12863 }
12864
12865 while (++index < length) {
12866 var source = sources[index];
12867 var props = keysIn(source);
12868 var propsIndex = -1;
12869 var propsLength = props.length;
12870
12871 while (++propsIndex < propsLength) {
12872 var key = props[propsIndex];
12873 var value = object[key];
12874
12875 if (value === undefined ||
12876 (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
12877 object[key] = source[key];
12878 }
12879 }
12880 }
12881
12882 return object;
12883 });
12884
12885 /**
12886 * This method is like `_.defaults` except that it recursively assigns
12887 * default properties.
12888 *
12889 * **Note:** This method mutates `object`.
12890 *
12891 * @static
12892 * @memberOf _
12893 * @since 3.10.0
12894 * @category Object
12895 * @param {Object} object The destination object.
12896 * @param {...Object} [sources] The source objects.
12897 * @returns {Object} Returns `object`.
12898 * @see _.defaults
12899 * @example
12900 *
12901 * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
12902 * // => { 'a': { 'b': 2, 'c': 3 } }
12903 */
12904 var defaultsDeep = baseRest(function(args) {
12905 args.push(undefined, customDefaultsMerge);
12906 return apply(mergeWith, undefined, args);
12907 });
12908
12909 /**
12910 * This method is like `_.find` except that it returns the key of the first
12911 * element `predicate` returns truthy for instead of the element itself.
12912 *
12913 * @static
12914 * @memberOf _
12915 * @since 1.1.0
12916 * @category Object
12917 * @param {Object} object The object to inspect.
12918 * @param {Function} [predicate=_.identity] The function invoked per iteration.
12919 * @returns {string|undefined} Returns the key of the matched element,
12920 * else `undefined`.
12921 * @example
12922 *
12923 * var users = {
12924 * 'barney': { 'age': 36, 'active': true },
12925 * 'fred': { 'age': 40, 'active': false },
12926 * 'pebbles': { 'age': 1, 'active': true }
12927 * };
12928 *
12929 * _.findKey(users, function(o) { return o.age < 40; });
12930 * // => 'barney' (iteration order is not guaranteed)
12931 *
12932 * // The `_.matches` iteratee shorthand.
12933 * _.findKey(users, { 'age': 1, 'active': true });
12934 * // => 'pebbles'
12935 *
12936 * // The `_.matchesProperty` iteratee shorthand.
12937 * _.findKey(users, ['active', false]);
12938 * // => 'fred'
12939 *
12940 * // The `_.property` iteratee shorthand.
12941 * _.findKey(users, 'active');
12942 * // => 'barney'
12943 */
12944 function findKey(object, predicate) {
12945 return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
12946 }
12947
12948 /**
12949 * This method is like `_.findKey` except that it iterates over elements of
12950 * a collection in the opposite order.
12951 *
12952 * @static
12953 * @memberOf _
12954 * @since 2.0.0
12955 * @category Object
12956 * @param {Object} object The object to inspect.
12957 * @param {Function} [predicate=_.identity] The function invoked per iteration.
12958 * @returns {string|undefined} Returns the key of the matched element,
12959 * else `undefined`.
12960 * @example
12961 *
12962 * var users = {
12963 * 'barney': { 'age': 36, 'active': true },
12964 * 'fred': { 'age': 40, 'active': false },
12965 * 'pebbles': { 'age': 1, 'active': true }
12966 * };
12967 *
12968 * _.findLastKey(users, function(o) { return o.age < 40; });
12969 * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
12970 *
12971 * // The `_.matches` iteratee shorthand.
12972 * _.findLastKey(users, { 'age': 36, 'active': true });
12973 * // => 'barney'
12974 *
12975 * // The `_.matchesProperty` iteratee shorthand.
12976 * _.findLastKey(users, ['active', false]);
12977 * // => 'fred'
12978 *
12979 * // The `_.property` iteratee shorthand.
12980 * _.findLastKey(users, 'active');
12981 * // => 'pebbles'
12982 */
12983 function findLastKey(object, predicate) {
12984 return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
12985 }
12986
12987 /**
12988 * Iterates over own and inherited enumerable string keyed properties of an
12989 * object and invokes `iteratee` for each property. The iteratee is invoked
12990 * with three arguments: (value, key, object). Iteratee functions may exit
12991 * iteration early by explicitly returning `false`.
12992 *
12993 * @static
12994 * @memberOf _
12995 * @since 0.3.0
12996 * @category Object
12997 * @param {Object} object The object to iterate over.
12998 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
12999 * @returns {Object} Returns `object`.
13000 * @see _.forInRight
13001 * @example
13002 *
13003 * function Foo() {
13004 * this.a = 1;
13005 * this.b = 2;
13006 * }
13007 *
13008 * Foo.prototype.c = 3;
13009 *
13010 * _.forIn(new Foo, function(value, key) {
13011 * console.log(key);
13012 * });
13013 * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
13014 */
13015 function forIn(object, iteratee) {
13016 return object == null
13017 ? object
13018 : baseFor(object, getIteratee(iteratee, 3), keysIn);
13019 }
13020
13021 /**
13022 * This method is like `_.forIn` except that it iterates over properties of
13023 * `object` in the opposite order.
13024 *
13025 * @static
13026 * @memberOf _
13027 * @since 2.0.0
13028 * @category Object
13029 * @param {Object} object The object to iterate over.
13030 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
13031 * @returns {Object} Returns `object`.
13032 * @see _.forIn
13033 * @example
13034 *
13035 * function Foo() {
13036 * this.a = 1;
13037 * this.b = 2;
13038 * }
13039 *
13040 * Foo.prototype.c = 3;
13041 *
13042 * _.forInRight(new Foo, function(value, key) {
13043 * console.log(key);
13044 * });
13045 * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
13046 */
13047 function forInRight(object, iteratee) {
13048 return object == null
13049 ? object
13050 : baseForRight(object, getIteratee(iteratee, 3), keysIn);
13051 }
13052
13053 /**
13054 * Iterates over own enumerable string keyed properties of an object and
13055 * invokes `iteratee` for each property. The iteratee is invoked with three
13056 * arguments: (value, key, object). Iteratee functions may exit iteration
13057 * early by explicitly returning `false`.
13058 *
13059 * @static
13060 * @memberOf _
13061 * @since 0.3.0
13062 * @category Object
13063 * @param {Object} object The object to iterate over.
13064 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
13065 * @returns {Object} Returns `object`.
13066 * @see _.forOwnRight
13067 * @example
13068 *
13069 * function Foo() {
13070 * this.a = 1;
13071 * this.b = 2;
13072 * }
13073 *
13074 * Foo.prototype.c = 3;
13075 *
13076 * _.forOwn(new Foo, function(value, key) {
13077 * console.log(key);
13078 * });
13079 * // => Logs 'a' then 'b' (iteration order is not guaranteed).
13080 */
13081 function forOwn(object, iteratee) {
13082 return object && baseForOwn(object, getIteratee(iteratee, 3));
13083 }
13084
13085 /**
13086 * This method is like `_.forOwn` except that it iterates over properties of
13087 * `object` in the opposite order.
13088 *
13089 * @static
13090 * @memberOf _
13091 * @since 2.0.0
13092 * @category Object
13093 * @param {Object} object The object to iterate over.
13094 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
13095 * @returns {Object} Returns `object`.
13096 * @see _.forOwn
13097 * @example
13098 *
13099 * function Foo() {
13100 * this.a = 1;
13101 * this.b = 2;
13102 * }
13103 *
13104 * Foo.prototype.c = 3;
13105 *
13106 * _.forOwnRight(new Foo, function(value, key) {
13107 * console.log(key);
13108 * });
13109 * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
13110 */
13111 function forOwnRight(object, iteratee) {
13112 return object && baseForOwnRight(object, getIteratee(iteratee, 3));
13113 }
13114
13115 /**
13116 * Creates an array of function property names from own enumerable properties
13117 * of `object`.
13118 *
13119 * @static
13120 * @since 0.1.0
13121 * @memberOf _
13122 * @category Object
13123 * @param {Object} object The object to inspect.
13124 * @returns {Array} Returns the function names.
13125 * @see _.functionsIn
13126 * @example
13127 *
13128 * function Foo() {
13129 * this.a = _.constant('a');
13130 * this.b = _.constant('b');
13131 * }
13132 *
13133 * Foo.prototype.c = _.constant('c');
13134 *
13135 * _.functions(new Foo);
13136 * // => ['a', 'b']
13137 */
13138 function functions(object) {
13139 return object == null ? [] : baseFunctions(object, keys(object));
13140 }
13141
13142 /**
13143 * Creates an array of function property names from own and inherited
13144 * enumerable properties of `object`.
13145 *
13146 * @static
13147 * @memberOf _
13148 * @since 4.0.0
13149 * @category Object
13150 * @param {Object} object The object to inspect.
13151 * @returns {Array} Returns the function names.
13152 * @see _.functions
13153 * @example
13154 *
13155 * function Foo() {
13156 * this.a = _.constant('a');
13157 * this.b = _.constant('b');
13158 * }
13159 *
13160 * Foo.prototype.c = _.constant('c');
13161 *
13162 * _.functionsIn(new Foo);
13163 * // => ['a', 'b', 'c']
13164 */
13165 function functionsIn(object) {
13166 return object == null ? [] : baseFunctions(object, keysIn(object));
13167 }
13168
13169 /**
13170 * Gets the value at `path` of `object`. If the resolved value is
13171 * `undefined`, the `defaultValue` is returned in its place.
13172 *
13173 * @static
13174 * @memberOf _
13175 * @since 3.7.0
13176 * @category Object
13177 * @param {Object} object The object to query.
13178 * @param {Array|string} path The path of the property to get.
13179 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
13180 * @returns {*} Returns the resolved value.
13181 * @example
13182 *
13183 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
13184 *
13185 * _.get(object, 'a[0].b.c');
13186 * // => 3
13187 *
13188 * _.get(object, ['a', '0', 'b', 'c']);
13189 * // => 3
13190 *
13191 * _.get(object, 'a.b.c', 'default');
13192 * // => 'default'
13193 */
13194 function get(object, path, defaultValue) {
13195 var result = object == null ? undefined : baseGet(object, path);
13196 return result === undefined ? defaultValue : result;
13197 }
13198
13199 /**
13200 * Checks if `path` is a direct property of `object`.
13201 *
13202 * @static
13203 * @since 0.1.0
13204 * @memberOf _
13205 * @category Object
13206 * @param {Object} object The object to query.
13207 * @param {Array|string} path The path to check.
13208 * @returns {boolean} Returns `true` if `path` exists, else `false`.
13209 * @example
13210 *
13211 * var object = { 'a': { 'b': 2 } };
13212 * var other = _.create({ 'a': _.create({ 'b': 2 }) });
13213 *
13214 * _.has(object, 'a');
13215 * // => true
13216 *
13217 * _.has(object, 'a.b');
13218 * // => true
13219 *
13220 * _.has(object, ['a', 'b']);
13221 * // => true
13222 *
13223 * _.has(other, 'a');
13224 * // => false
13225 */
13226 function has(object, path) {
13227 return object != null && hasPath(object, path, baseHas);
13228 }
13229
13230 /**
13231 * Checks if `path` is a direct or inherited property of `object`.
13232 *
13233 * @static
13234 * @memberOf _
13235 * @since 4.0.0
13236 * @category Object
13237 * @param {Object} object The object to query.
13238 * @param {Array|string} path The path to check.
13239 * @returns {boolean} Returns `true` if `path` exists, else `false`.
13240 * @example
13241 *
13242 * var object = _.create({ 'a': _.create({ 'b': 2 }) });
13243 *
13244 * _.hasIn(object, 'a');
13245 * // => true
13246 *
13247 * _.hasIn(object, 'a.b');
13248 * // => true
13249 *
13250 * _.hasIn(object, ['a', 'b']);
13251 * // => true
13252 *
13253 * _.hasIn(object, 'b');
13254 * // => false
13255 */
13256 function hasIn(object, path) {
13257 return object != null && hasPath(object, path, baseHasIn);
13258 }
13259
13260 /**
13261 * Creates an object composed of the inverted keys and values of `object`.
13262 * If `object` contains duplicate values, subsequent values overwrite
13263 * property assignments of previous values.
13264 *
13265 * @static
13266 * @memberOf _
13267 * @since 0.7.0
13268 * @category Object
13269 * @param {Object} object The object to invert.
13270 * @returns {Object} Returns the new inverted object.
13271 * @example
13272 *
13273 * var object = { 'a': 1, 'b': 2, 'c': 1 };
13274 *
13275 * _.invert(object);
13276 * // => { '1': 'c', '2': 'b' }
13277 */
13278 var invert = createInverter(function(result, value, key) {
13279 if (value != null &&
13280 typeof value.toString != 'function') {
13281 value = nativeObjectToString.call(value);
13282 }
13283
13284 result[value] = key;
13285 }, constant(identity));
13286
13287 /**
13288 * This method is like `_.invert` except that the inverted object is generated
13289 * from the results of running each element of `object` thru `iteratee`. The
13290 * corresponding inverted value of each inverted key is an array of keys
13291 * responsible for generating the inverted value. The iteratee is invoked
13292 * with one argument: (value).
13293 *
13294 * @static
13295 * @memberOf _
13296 * @since 4.1.0
13297 * @category Object
13298 * @param {Object} object The object to invert.
13299 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
13300 * @returns {Object} Returns the new inverted object.
13301 * @example
13302 *
13303 * var object = { 'a': 1, 'b': 2, 'c': 1 };
13304 *
13305 * _.invertBy(object);
13306 * // => { '1': ['a', 'c'], '2': ['b'] }
13307 *
13308 * _.invertBy(object, function(value) {
13309 * return 'group' + value;
13310 * });
13311 * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
13312 */
13313 var invertBy = createInverter(function(result, value, key) {
13314 if (value != null &&
13315 typeof value.toString != 'function') {
13316 value = nativeObjectToString.call(value);
13317 }
13318
13319 if (hasOwnProperty.call(result, value)) {
13320 result[value].push(key);
13321 } else {
13322 result[value] = [key];
13323 }
13324 }, getIteratee);
13325
13326 /**
13327 * Invokes the method at `path` of `object`.
13328 *
13329 * @static
13330 * @memberOf _
13331 * @since 4.0.0
13332 * @category Object
13333 * @param {Object} object The object to query.
13334 * @param {Array|string} path The path of the method to invoke.
13335 * @param {...*} [args] The arguments to invoke the method with.
13336 * @returns {*} Returns the result of the invoked method.
13337 * @example
13338 *
13339 * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
13340 *
13341 * _.invoke(object, 'a[0].b.c.slice', 1, 3);
13342 * // => [2, 3]
13343 */
13344 var invoke = baseRest(baseInvoke);
13345
13346 /**
13347 * Creates an array of the own enumerable property names of `object`.
13348 *
13349 * **Note:** Non-object values are coerced to objects. See the
13350 * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
13351 * for more details.
13352 *
13353 * @static
13354 * @since 0.1.0
13355 * @memberOf _
13356 * @category Object
13357 * @param {Object} object The object to query.
13358 * @returns {Array} Returns the array of property names.
13359 * @example
13360 *
13361 * function Foo() {
13362 * this.a = 1;
13363 * this.b = 2;
13364 * }
13365 *
13366 * Foo.prototype.c = 3;
13367 *
13368 * _.keys(new Foo);
13369 * // => ['a', 'b'] (iteration order is not guaranteed)
13370 *
13371 * _.keys('hi');
13372 * // => ['0', '1']
13373 */
13374 function keys(object) {
13375 return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
13376 }
13377
13378 /**
13379 * Creates an array of the own and inherited enumerable property names of `object`.
13380 *
13381 * **Note:** Non-object values are coerced to objects.
13382 *
13383 * @static
13384 * @memberOf _
13385 * @since 3.0.0
13386 * @category Object
13387 * @param {Object} object The object to query.
13388 * @returns {Array} Returns the array of property names.
13389 * @example
13390 *
13391 * function Foo() {
13392 * this.a = 1;
13393 * this.b = 2;
13394 * }
13395 *
13396 * Foo.prototype.c = 3;
13397 *
13398 * _.keysIn(new Foo);
13399 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
13400 */
13401 function keysIn(object) {
13402 return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
13403 }
13404
13405 /**
13406 * The opposite of `_.mapValues`; this method creates an object with the
13407 * same values as `object` and keys generated by running each own enumerable
13408 * string keyed property of `object` thru `iteratee`. The iteratee is invoked
13409 * with three arguments: (value, key, object).
13410 *
13411 * @static
13412 * @memberOf _
13413 * @since 3.8.0
13414 * @category Object
13415 * @param {Object} object The object to iterate over.
13416 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
13417 * @returns {Object} Returns the new mapped object.
13418 * @see _.mapValues
13419 * @example
13420 *
13421 * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
13422 * return key + value;
13423 * });
13424 * // => { 'a1': 1, 'b2': 2 }
13425 */
13426 function mapKeys(object, iteratee) {
13427 var result = {};
13428 iteratee = getIteratee(iteratee, 3);
13429
13430 baseForOwn(object, function(value, key, object) {
13431 baseAssignValue(result, iteratee(value, key, object), value);
13432 });
13433 return result;
13434 }
13435
13436 /**
13437 * Creates an object with the same keys as `object` and values generated
13438 * by running each own enumerable string keyed property of `object` thru
13439 * `iteratee`. The iteratee is invoked with three arguments:
13440 * (value, key, object).
13441 *
13442 * @static
13443 * @memberOf _
13444 * @since 2.4.0
13445 * @category Object
13446 * @param {Object} object The object to iterate over.
13447 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
13448 * @returns {Object} Returns the new mapped object.
13449 * @see _.mapKeys
13450 * @example
13451 *
13452 * var users = {
13453 * 'fred': { 'user': 'fred', 'age': 40 },
13454 * 'pebbles': { 'user': 'pebbles', 'age': 1 }
13455 * };
13456 *
13457 * _.mapValues(users, function(o) { return o.age; });
13458 * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
13459 *
13460 * // The `_.property` iteratee shorthand.
13461 * _.mapValues(users, 'age');
13462 * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
13463 */
13464 function mapValues(object, iteratee) {
13465 var result = {};
13466 iteratee = getIteratee(iteratee, 3);
13467
13468 baseForOwn(object, function(value, key, object) {
13469 baseAssignValue(result, key, iteratee(value, key, object));
13470 });
13471 return result;
13472 }
13473
13474 /**
13475 * This method is like `_.assign` except that it recursively merges own and
13476 * inherited enumerable string keyed properties of source objects into the
13477 * destination object. Source properties that resolve to `undefined` are
13478 * skipped if a destination value exists. Array and plain object properties
13479 * are merged recursively. Other objects and value types are overridden by
13480 * assignment. Source objects are applied from left to right. Subsequent
13481 * sources overwrite property assignments of previous sources.
13482 *
13483 * **Note:** This method mutates `object`.
13484 *
13485 * @static
13486 * @memberOf _
13487 * @since 0.5.0
13488 * @category Object
13489 * @param {Object} object The destination object.
13490 * @param {...Object} [sources] The source objects.
13491 * @returns {Object} Returns `object`.
13492 * @example
13493 *
13494 * var object = {
13495 * 'a': [{ 'b': 2 }, { 'd': 4 }]
13496 * };
13497 *
13498 * var other = {
13499 * 'a': [{ 'c': 3 }, { 'e': 5 }]
13500 * };
13501 *
13502 * _.merge(object, other);
13503 * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
13504 */
13505 var merge = createAssigner(function(object, source, srcIndex) {
13506 baseMerge(object, source, srcIndex);
13507 });
13508
13509 /**
13510 * This method is like `_.merge` except that it accepts `customizer` which
13511 * is invoked to produce the merged values of the destination and source
13512 * properties. If `customizer` returns `undefined`, merging is handled by the
13513 * method instead. The `customizer` is invoked with six arguments:
13514 * (objValue, srcValue, key, object, source, stack).
13515 *
13516 * **Note:** This method mutates `object`.
13517 *
13518 * @static
13519 * @memberOf _
13520 * @since 4.0.0
13521 * @category Object
13522 * @param {Object} object The destination object.
13523 * @param {...Object} sources The source objects.
13524 * @param {Function} customizer The function to customize assigned values.
13525 * @returns {Object} Returns `object`.
13526 * @example
13527 *
13528 * function customizer(objValue, srcValue) {
13529 * if (_.isArray(objValue)) {
13530 * return objValue.concat(srcValue);
13531 * }
13532 * }
13533 *
13534 * var object = { 'a': [1], 'b': [2] };
13535 * var other = { 'a': [3], 'b': [4] };
13536 *
13537 * _.mergeWith(object, other, customizer);
13538 * // => { 'a': [1, 3], 'b': [2, 4] }
13539 */
13540 var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
13541 baseMerge(object, source, srcIndex, customizer);
13542 });
13543
13544 /**
13545 * The opposite of `_.pick`; this method creates an object composed of the
13546 * own and inherited enumerable property paths of `object` that are not omitted.
13547 *
13548 * **Note:** This method is considerably slower than `_.pick`.
13549 *
13550 * @static
13551 * @since 0.1.0
13552 * @memberOf _
13553 * @category Object
13554 * @param {Object} object The source object.
13555 * @param {...(string|string[])} [paths] The property paths to omit.
13556 * @returns {Object} Returns the new object.
13557 * @example
13558 *
13559 * var object = { 'a': 1, 'b': '2', 'c': 3 };
13560 *
13561 * _.omit(object, ['a', 'c']);
13562 * // => { 'b': '2' }
13563 */
13564 var omit = flatRest(function(object, paths) {
13565 var result = {};
13566 if (object == null) {
13567 return result;
13568 }
13569 var isDeep = false;
13570 paths = arrayMap(paths, function(path) {
13571 path = castPath(path, object);
13572 isDeep || (isDeep = path.length > 1);
13573 return path;
13574 });
13575 copyObject(object, getAllKeysIn(object), result);
13576 if (isDeep) {
13577 result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
13578 }
13579 var length = paths.length;
13580 while (length--) {
13581 baseUnset(result, paths[length]);
13582 }
13583 return result;
13584 });
13585
13586 /**
13587 * The opposite of `_.pickBy`; this method creates an object composed of
13588 * the own and inherited enumerable string keyed properties of `object` that
13589 * `predicate` doesn't return truthy for. The predicate is invoked with two
13590 * arguments: (value, key).
13591 *
13592 * @static
13593 * @memberOf _
13594 * @since 4.0.0
13595 * @category Object
13596 * @param {Object} object The source object.
13597 * @param {Function} [predicate=_.identity] The function invoked per property.
13598 * @returns {Object} Returns the new object.
13599 * @example
13600 *
13601 * var object = { 'a': 1, 'b': '2', 'c': 3 };
13602 *
13603 * _.omitBy(object, _.isNumber);
13604 * // => { 'b': '2' }
13605 */
13606 function omitBy(object, predicate) {
13607 return pickBy(object, negate(getIteratee(predicate)));
13608 }
13609
13610 /**
13611 * Creates an object composed of the picked `object` properties.
13612 *
13613 * @static
13614 * @since 0.1.0
13615 * @memberOf _
13616 * @category Object
13617 * @param {Object} object The source object.
13618 * @param {...(string|string[])} [paths] The property paths to pick.
13619 * @returns {Object} Returns the new object.
13620 * @example
13621 *
13622 * var object = { 'a': 1, 'b': '2', 'c': 3 };
13623 *
13624 * _.pick(object, ['a', 'c']);
13625 * // => { 'a': 1, 'c': 3 }
13626 */
13627 var pick = flatRest(function(object, paths) {
13628 return object == null ? {} : basePick(object, paths);
13629 });
13630
13631 /**
13632 * Creates an object composed of the `object` properties `predicate` returns
13633 * truthy for. The predicate is invoked with two arguments: (value, key).
13634 *
13635 * @static
13636 * @memberOf _
13637 * @since 4.0.0
13638 * @category Object
13639 * @param {Object} object The source object.
13640 * @param {Function} [predicate=_.identity] The function invoked per property.
13641 * @returns {Object} Returns the new object.
13642 * @example
13643 *
13644 * var object = { 'a': 1, 'b': '2', 'c': 3 };
13645 *
13646 * _.pickBy(object, _.isNumber);
13647 * // => { 'a': 1, 'c': 3 }
13648 */
13649 function pickBy(object, predicate) {
13650 if (object == null) {
13651 return {};
13652 }
13653 var props = arrayMap(getAllKeysIn(object), function(prop) {
13654 return [prop];
13655 });
13656 predicate = getIteratee(predicate);
13657 return basePickBy(object, props, function(value, path) {
13658 return predicate(value, path[0]);
13659 });
13660 }
13661
13662 /**
13663 * This method is like `_.get` except that if the resolved value is a
13664 * function it's invoked with the `this` binding of its parent object and
13665 * its result is returned.
13666 *
13667 * @static
13668 * @since 0.1.0
13669 * @memberOf _
13670 * @category Object
13671 * @param {Object} object The object to query.
13672 * @param {Array|string} path The path of the property to resolve.
13673 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
13674 * @returns {*} Returns the resolved value.
13675 * @example
13676 *
13677 * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
13678 *
13679 * _.result(object, 'a[0].b.c1');
13680 * // => 3
13681 *
13682 * _.result(object, 'a[0].b.c2');
13683 * // => 4
13684 *
13685 * _.result(object, 'a[0].b.c3', 'default');
13686 * // => 'default'
13687 *
13688 * _.result(object, 'a[0].b.c3', _.constant('default'));
13689 * // => 'default'
13690 */
13691 function result(object, path, defaultValue) {
13692 path = castPath(path, object);
13693
13694 var index = -1,
13695 length = path.length;
13696
13697 // Ensure the loop is entered when path is empty.
13698 if (!length) {
13699 length = 1;
13700 object = undefined;
13701 }
13702 while (++index < length) {
13703 var value = object == null ? undefined : object[toKey(path[index])];
13704 if (value === undefined) {
13705 index = length;
13706 value = defaultValue;
13707 }
13708 object = isFunction(value) ? value.call(object) : value;
13709 }
13710 return object;
13711 }
13712
13713 /**
13714 * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
13715 * it's created. Arrays are created for missing index properties while objects
13716 * are created for all other missing properties. Use `_.setWith` to customize
13717 * `path` creation.
13718 *
13719 * **Note:** This method mutates `object`.
13720 *
13721 * @static
13722 * @memberOf _
13723 * @since 3.7.0
13724 * @category Object
13725 * @param {Object} object The object to modify.
13726 * @param {Array|string} path The path of the property to set.
13727 * @param {*} value The value to set.
13728 * @returns {Object} Returns `object`.
13729 * @example
13730 *
13731 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
13732 *
13733 * _.set(object, 'a[0].b.c', 4);
13734 * console.log(object.a[0].b.c);
13735 * // => 4
13736 *
13737 * _.set(object, ['x', '0', 'y', 'z'], 5);
13738 * console.log(object.x[0].y.z);
13739 * // => 5
13740 */
13741 function set(object, path, value) {
13742 return object == null ? object : baseSet(object, path, value);
13743 }
13744
13745 /**
13746 * This method is like `_.set` except that it accepts `customizer` which is
13747 * invoked to produce the objects of `path`. If `customizer` returns `undefined`
13748 * path creation is handled by the method instead. The `customizer` is invoked
13749 * with three arguments: (nsValue, key, nsObject).
13750 *
13751 * **Note:** This method mutates `object`.
13752 *
13753 * @static
13754 * @memberOf _
13755 * @since 4.0.0
13756 * @category Object
13757 * @param {Object} object The object to modify.
13758 * @param {Array|string} path The path of the property to set.
13759 * @param {*} value The value to set.
13760 * @param {Function} [customizer] The function to customize assigned values.
13761 * @returns {Object} Returns `object`.
13762 * @example
13763 *
13764 * var object = {};
13765 *
13766 * _.setWith(object, '[0][1]', 'a', Object);
13767 * // => { '0': { '1': 'a' } }
13768 */
13769 function setWith(object, path, value, customizer) {
13770 customizer = typeof customizer == 'function' ? customizer : undefined;
13771 return object == null ? object : baseSet(object, path, value, customizer);
13772 }
13773
13774 /**
13775 * Creates an array of own enumerable string keyed-value pairs for `object`
13776 * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
13777 * entries are returned.
13778 *
13779 * @static
13780 * @memberOf _
13781 * @since 4.0.0
13782 * @alias entries
13783 * @category Object
13784 * @param {Object} object The object to query.
13785 * @returns {Array} Returns the key-value pairs.
13786 * @example
13787 *
13788 * function Foo() {
13789 * this.a = 1;
13790 * this.b = 2;
13791 * }
13792 *
13793 * Foo.prototype.c = 3;
13794 *
13795 * _.toPairs(new Foo);
13796 * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
13797 */
13798 var toPairs = createToPairs(keys);
13799
13800 /**
13801 * Creates an array of own and inherited enumerable string keyed-value pairs
13802 * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
13803 * or set, its entries are returned.
13804 *
13805 * @static
13806 * @memberOf _
13807 * @since 4.0.0
13808 * @alias entriesIn
13809 * @category Object
13810 * @param {Object} object The object to query.
13811 * @returns {Array} Returns the key-value pairs.
13812 * @example
13813 *
13814 * function Foo() {
13815 * this.a = 1;
13816 * this.b = 2;
13817 * }
13818 *
13819 * Foo.prototype.c = 3;
13820 *
13821 * _.toPairsIn(new Foo);
13822 * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
13823 */
13824 var toPairsIn = createToPairs(keysIn);
13825
13826 /**
13827 * An alternative to `_.reduce`; this method transforms `object` to a new
13828 * `accumulator` object which is the result of running each of its own
13829 * enumerable string keyed properties thru `iteratee`, with each invocation
13830 * potentially mutating the `accumulator` object. If `accumulator` is not
13831 * provided, a new object with the same `[[Prototype]]` will be used. The
13832 * iteratee is invoked with four arguments: (accumulator, value, key, object).
13833 * Iteratee functions may exit iteration early by explicitly returning `false`.
13834 *
13835 * @static
13836 * @memberOf _
13837 * @since 1.3.0
13838 * @category Object
13839 * @param {Object} object The object to iterate over.
13840 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
13841 * @param {*} [accumulator] The custom accumulator value.
13842 * @returns {*} Returns the accumulated value.
13843 * @example
13844 *
13845 * _.transform([2, 3, 4], function(result, n) {
13846 * result.push(n *= n);
13847 * return n % 2 == 0;
13848 * }, []);
13849 * // => [4, 9]
13850 *
13851 * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
13852 * (result[value] || (result[value] = [])).push(key);
13853 * }, {});
13854 * // => { '1': ['a', 'c'], '2': ['b'] }
13855 */
13856 function transform(object, iteratee, accumulator) {
13857 var isArr = isArray(object),
13858 isArrLike = isArr || isBuffer(object) || isTypedArray(object);
13859
13860 iteratee = getIteratee(iteratee, 4);
13861 if (accumulator == null) {
13862 var Ctor = object && object.constructor;
13863 if (isArrLike) {
13864 accumulator = isArr ? new Ctor : [];
13865 }
13866 else if (isObject(object)) {
13867 accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
13868 }
13869 else {
13870 accumulator = {};
13871 }
13872 }
13873 (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
13874 return iteratee(accumulator, value, index, object);
13875 });
13876 return accumulator;
13877 }
13878
13879 /**
13880 * Removes the property at `path` of `object`.
13881 *
13882 * **Note:** This method mutates `object`.
13883 *
13884 * @static
13885 * @memberOf _
13886 * @since 4.0.0
13887 * @category Object
13888 * @param {Object} object The object to modify.
13889 * @param {Array|string} path The path of the property to unset.
13890 * @returns {boolean} Returns `true` if the property is deleted, else `false`.
13891 * @example
13892 *
13893 * var object = { 'a': [{ 'b': { 'c': 7 } }] };
13894 * _.unset(object, 'a[0].b.c');
13895 * // => true
13896 *
13897 * console.log(object);
13898 * // => { 'a': [{ 'b': {} }] };
13899 *
13900 * _.unset(object, ['a', '0', 'b', 'c']);
13901 * // => true
13902 *
13903 * console.log(object);
13904 * // => { 'a': [{ 'b': {} }] };
13905 */
13906 function unset(object, path) {
13907 return object == null ? true : baseUnset(object, path);
13908 }
13909
13910 /**
13911 * This method is like `_.set` except that accepts `updater` to produce the
13912 * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
13913 * is invoked with one argument: (value).
13914 *
13915 * **Note:** This method mutates `object`.
13916 *
13917 * @static
13918 * @memberOf _
13919 * @since 4.6.0
13920 * @category Object
13921 * @param {Object} object The object to modify.
13922 * @param {Array|string} path The path of the property to set.
13923 * @param {Function} updater The function to produce the updated value.
13924 * @returns {Object} Returns `object`.
13925 * @example
13926 *
13927 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
13928 *
13929 * _.update(object, 'a[0].b.c', function(n) { return n * n; });
13930 * console.log(object.a[0].b.c);
13931 * // => 9
13932 *
13933 * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
13934 * console.log(object.x[0].y.z);
13935 * // => 0
13936 */
13937 function update(object, path, updater) {
13938 return object == null ? object : baseUpdate(object, path, castFunction(updater));
13939 }
13940
13941 /**
13942 * This method is like `_.update` except that it accepts `customizer` which is
13943 * invoked to produce the objects of `path`. If `customizer` returns `undefined`
13944 * path creation is handled by the method instead. The `customizer` is invoked
13945 * with three arguments: (nsValue, key, nsObject).
13946 *
13947 * **Note:** This method mutates `object`.
13948 *
13949 * @static
13950 * @memberOf _
13951 * @since 4.6.0
13952 * @category Object
13953 * @param {Object} object The object to modify.
13954 * @param {Array|string} path The path of the property to set.
13955 * @param {Function} updater The function to produce the updated value.
13956 * @param {Function} [customizer] The function to customize assigned values.
13957 * @returns {Object} Returns `object`.
13958 * @example
13959 *
13960 * var object = {};
13961 *
13962 * _.updateWith(object, '[0][1]', _.constant('a'), Object);
13963 * // => { '0': { '1': 'a' } }
13964 */
13965 function updateWith(object, path, updater, customizer) {
13966 customizer = typeof customizer == 'function' ? customizer : undefined;
13967 return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
13968 }
13969
13970 /**
13971 * Creates an array of the own enumerable string keyed property values of `object`.
13972 *
13973 * **Note:** Non-object values are coerced to objects.
13974 *
13975 * @static
13976 * @since 0.1.0
13977 * @memberOf _
13978 * @category Object
13979 * @param {Object} object The object to query.
13980 * @returns {Array} Returns the array of property values.
13981 * @example
13982 *
13983 * function Foo() {
13984 * this.a = 1;
13985 * this.b = 2;
13986 * }
13987 *
13988 * Foo.prototype.c = 3;
13989 *
13990 * _.values(new Foo);
13991 * // => [1, 2] (iteration order is not guaranteed)
13992 *
13993 * _.values('hi');
13994 * // => ['h', 'i']
13995 */
13996 function values(object) {
13997 return object == null ? [] : baseValues(object, keys(object));
13998 }
13999
14000 /**
14001 * Creates an array of the own and inherited enumerable string keyed property
14002 * values of `object`.
14003 *
14004 * **Note:** Non-object values are coerced to objects.
14005 *
14006 * @static
14007 * @memberOf _
14008 * @since 3.0.0
14009 * @category Object
14010 * @param {Object} object The object to query.
14011 * @returns {Array} Returns the array of property values.
14012 * @example
14013 *
14014 * function Foo() {
14015 * this.a = 1;
14016 * this.b = 2;
14017 * }
14018 *
14019 * Foo.prototype.c = 3;
14020 *
14021 * _.valuesIn(new Foo);
14022 * // => [1, 2, 3] (iteration order is not guaranteed)
14023 */
14024 function valuesIn(object) {
14025 return object == null ? [] : baseValues(object, keysIn(object));
14026 }
14027
14028 /*------------------------------------------------------------------------*/
14029
14030 /**
14031 * Clamps `number` within the inclusive `lower` and `upper` bounds.
14032 *
14033 * @static
14034 * @memberOf _
14035 * @since 4.0.0
14036 * @category Number
14037 * @param {number} number The number to clamp.
14038 * @param {number} [lower] The lower bound.
14039 * @param {number} upper The upper bound.
14040 * @returns {number} Returns the clamped number.
14041 * @example
14042 *
14043 * _.clamp(-10, -5, 5);
14044 * // => -5
14045 *
14046 * _.clamp(10, -5, 5);
14047 * // => 5
14048 */
14049 function clamp(number, lower, upper) {
14050 if (upper === undefined) {
14051 upper = lower;
14052 lower = undefined;
14053 }
14054 if (upper !== undefined) {
14055 upper = toNumber(upper);
14056 upper = upper === upper ? upper : 0;
14057 }
14058 if (lower !== undefined) {
14059 lower = toNumber(lower);
14060 lower = lower === lower ? lower : 0;
14061 }
14062 return baseClamp(toNumber(number), lower, upper);
14063 }
14064
14065 /**
14066 * Checks if `n` is between `start` and up to, but not including, `end`. If
14067 * `end` is not specified, it's set to `start` with `start` then set to `0`.
14068 * If `start` is greater than `end` the params are swapped to support
14069 * negative ranges.
14070 *
14071 * @static
14072 * @memberOf _
14073 * @since 3.3.0
14074 * @category Number
14075 * @param {number} number The number to check.
14076 * @param {number} [start=0] The start of the range.
14077 * @param {number} end The end of the range.
14078 * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
14079 * @see _.range, _.rangeRight
14080 * @example
14081 *
14082 * _.inRange(3, 2, 4);
14083 * // => true
14084 *
14085 * _.inRange(4, 8);
14086 * // => true
14087 *
14088 * _.inRange(4, 2);
14089 * // => false
14090 *
14091 * _.inRange(2, 2);
14092 * // => false
14093 *
14094 * _.inRange(1.2, 2);
14095 * // => true
14096 *
14097 * _.inRange(5.2, 4);
14098 * // => false
14099 *
14100 * _.inRange(-3, -2, -6);
14101 * // => true
14102 */
14103 function inRange(number, start, end) {
14104 start = toFinite(start);
14105 if (end === undefined) {
14106 end = start;
14107 start = 0;
14108 } else {
14109 end = toFinite(end);
14110 }
14111 number = toNumber(number);
14112 return baseInRange(number, start, end);
14113 }
14114
14115 /**
14116 * Produces a random number between the inclusive `lower` and `upper` bounds.
14117 * If only one argument is provided a number between `0` and the given number
14118 * is returned. If `floating` is `true`, or either `lower` or `upper` are
14119 * floats, a floating-point number is returned instead of an integer.
14120 *
14121 * **Note:** JavaScript follows the IEEE-754 standard for resolving
14122 * floating-point values which can produce unexpected results.
14123 *
14124 * @static
14125 * @memberOf _
14126 * @since 0.7.0
14127 * @category Number
14128 * @param {number} [lower=0] The lower bound.
14129 * @param {number} [upper=1] The upper bound.
14130 * @param {boolean} [floating] Specify returning a floating-point number.
14131 * @returns {number} Returns the random number.
14132 * @example
14133 *
14134 * _.random(0, 5);
14135 * // => an integer between 0 and 5
14136 *
14137 * _.random(5);
14138 * // => also an integer between 0 and 5
14139 *
14140 * _.random(5, true);
14141 * // => a floating-point number between 0 and 5
14142 *
14143 * _.random(1.2, 5.2);
14144 * // => a floating-point number between 1.2 and 5.2
14145 */
14146 function random(lower, upper, floating) {
14147 if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
14148 upper = floating = undefined;
14149 }
14150 if (floating === undefined) {
14151 if (typeof upper == 'boolean') {
14152 floating = upper;
14153 upper = undefined;
14154 }
14155 else if (typeof lower == 'boolean') {
14156 floating = lower;
14157 lower = undefined;
14158 }
14159 }
14160 if (lower === undefined && upper === undefined) {
14161 lower = 0;
14162 upper = 1;
14163 }
14164 else {
14165 lower = toFinite(lower);
14166 if (upper === undefined) {
14167 upper = lower;
14168 lower = 0;
14169 } else {
14170 upper = toFinite(upper);
14171 }
14172 }
14173 if (lower > upper) {
14174 var temp = lower;
14175 lower = upper;
14176 upper = temp;
14177 }
14178 if (floating || lower % 1 || upper % 1) {
14179 var rand = nativeRandom();
14180 return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
14181 }
14182 return baseRandom(lower, upper);
14183 }
14184
14185 /*------------------------------------------------------------------------*/
14186
14187 /**
14188 * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
14189 *
14190 * @static
14191 * @memberOf _
14192 * @since 3.0.0
14193 * @category String
14194 * @param {string} [string=''] The string to convert.
14195 * @returns {string} Returns the camel cased string.
14196 * @example
14197 *
14198 * _.camelCase('Foo Bar');
14199 * // => 'fooBar'
14200 *
14201 * _.camelCase('--foo-bar--');
14202 * // => 'fooBar'
14203 *
14204 * _.camelCase('__FOO_BAR__');
14205 * // => 'fooBar'
14206 */
14207 var camelCase = createCompounder(function(result, word, index) {
14208 word = word.toLowerCase();
14209 return result + (index ? capitalize(word) : word);
14210 });
14211
14212 /**
14213 * Converts the first character of `string` to upper case and the remaining
14214 * to lower case.
14215 *
14216 * @static
14217 * @memberOf _
14218 * @since 3.0.0
14219 * @category String
14220 * @param {string} [string=''] The string to capitalize.
14221 * @returns {string} Returns the capitalized string.
14222 * @example
14223 *
14224 * _.capitalize('FRED');
14225 * // => 'Fred'
14226 */
14227 function capitalize(string) {
14228 return upperFirst(toString(string).toLowerCase());
14229 }
14230
14231 /**
14232 * Deburrs `string` by converting
14233 * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
14234 * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
14235 * letters to basic Latin letters and removing
14236 * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
14237 *
14238 * @static
14239 * @memberOf _
14240 * @since 3.0.0
14241 * @category String
14242 * @param {string} [string=''] The string to deburr.
14243 * @returns {string} Returns the deburred string.
14244 * @example
14245 *
14246 * _.deburr('déjà vu');
14247 * // => 'deja vu'
14248 */
14249 function deburr(string) {
14250 string = toString(string);
14251 return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
14252 }
14253
14254 /**
14255 * Checks if `string` ends with the given target string.
14256 *
14257 * @static
14258 * @memberOf _
14259 * @since 3.0.0
14260 * @category String
14261 * @param {string} [string=''] The string to inspect.
14262 * @param {string} [target] The string to search for.
14263 * @param {number} [position=string.length] The position to search up to.
14264 * @returns {boolean} Returns `true` if `string` ends with `target`,
14265 * else `false`.
14266 * @example
14267 *
14268 * _.endsWith('abc', 'c');
14269 * // => true
14270 *
14271 * _.endsWith('abc', 'b');
14272 * // => false
14273 *
14274 * _.endsWith('abc', 'b', 2);
14275 * // => true
14276 */
14277 function endsWith(string, target, position) {
14278 string = toString(string);
14279 target = baseToString(target);
14280
14281 var length = string.length;
14282 position = position === undefined
14283 ? length
14284 : baseClamp(toInteger(position), 0, length);
14285
14286 var end = position;
14287 position -= target.length;
14288 return position >= 0 && string.slice(position, end) == target;
14289 }
14290
14291 /**
14292 * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
14293 * corresponding HTML entities.
14294 *
14295 * **Note:** No other characters are escaped. To escape additional
14296 * characters use a third-party library like [_he_](https://mths.be/he).
14297 *
14298 * Though the ">" character is escaped for symmetry, characters like
14299 * ">" and "/" don't need escaping in HTML and have no special meaning
14300 * unless they're part of a tag or unquoted attribute value. See
14301 * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
14302 * (under "semi-related fun fact") for more details.
14303 *
14304 * When working with HTML you should always
14305 * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
14306 * XSS vectors.
14307 *
14308 * @static
14309 * @since 0.1.0
14310 * @memberOf _
14311 * @category String
14312 * @param {string} [string=''] The string to escape.
14313 * @returns {string} Returns the escaped string.
14314 * @example
14315 *
14316 * _.escape('fred, barney, & pebbles');
14317 * // => 'fred, barney, & pebbles'
14318 */
14319 function escape(string) {
14320 string = toString(string);
14321 return (string && reHasUnescapedHtml.test(string))
14322 ? string.replace(reUnescapedHtml, escapeHtmlChar)
14323 : string;
14324 }
14325
14326 /**
14327 * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
14328 * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
14329 *
14330 * @static
14331 * @memberOf _
14332 * @since 3.0.0
14333 * @category String
14334 * @param {string} [string=''] The string to escape.
14335 * @returns {string} Returns the escaped string.
14336 * @example
14337 *
14338 * _.escapeRegExp('[lodash](https://lodash.com/)');
14339 * // => '\[lodash\]\(https://lodash\.com/\)'
14340 */
14341 function escapeRegExp(string) {
14342 string = toString(string);
14343 return (string && reHasRegExpChar.test(string))
14344 ? string.replace(reRegExpChar, '\\$&')
14345 : string;
14346 }
14347
14348 /**
14349 * Converts `string` to
14350 * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
14351 *
14352 * @static
14353 * @memberOf _
14354 * @since 3.0.0
14355 * @category String
14356 * @param {string} [string=''] The string to convert.
14357 * @returns {string} Returns the kebab cased string.
14358 * @example
14359 *
14360 * _.kebabCase('Foo Bar');
14361 * // => 'foo-bar'
14362 *
14363 * _.kebabCase('fooBar');
14364 * // => 'foo-bar'
14365 *
14366 * _.kebabCase('__FOO_BAR__');
14367 * // => 'foo-bar'
14368 */
14369 var kebabCase = createCompounder(function(result, word, index) {
14370 return result + (index ? '-' : '') + word.toLowerCase();
14371 });
14372
14373 /**
14374 * Converts `string`, as space separated words, to lower case.
14375 *
14376 * @static
14377 * @memberOf _
14378 * @since 4.0.0
14379 * @category String
14380 * @param {string} [string=''] The string to convert.
14381 * @returns {string} Returns the lower cased string.
14382 * @example
14383 *
14384 * _.lowerCase('--Foo-Bar--');
14385 * // => 'foo bar'
14386 *
14387 * _.lowerCase('fooBar');
14388 * // => 'foo bar'
14389 *
14390 * _.lowerCase('__FOO_BAR__');
14391 * // => 'foo bar'
14392 */
14393 var lowerCase = createCompounder(function(result, word, index) {
14394 return result + (index ? ' ' : '') + word.toLowerCase();
14395 });
14396
14397 /**
14398 * Converts the first character of `string` to lower case.
14399 *
14400 * @static
14401 * @memberOf _
14402 * @since 4.0.0
14403 * @category String
14404 * @param {string} [string=''] The string to convert.
14405 * @returns {string} Returns the converted string.
14406 * @example
14407 *
14408 * _.lowerFirst('Fred');
14409 * // => 'fred'
14410 *
14411 * _.lowerFirst('FRED');
14412 * // => 'fRED'
14413 */
14414 var lowerFirst = createCaseFirst('toLowerCase');
14415
14416 /**
14417 * Pads `string` on the left and right sides if it's shorter than `length`.
14418 * Padding characters are truncated if they can't be evenly divided by `length`.
14419 *
14420 * @static
14421 * @memberOf _
14422 * @since 3.0.0
14423 * @category String
14424 * @param {string} [string=''] The string to pad.
14425 * @param {number} [length=0] The padding length.
14426 * @param {string} [chars=' '] The string used as padding.
14427 * @returns {string} Returns the padded string.
14428 * @example
14429 *
14430 * _.pad('abc', 8);
14431 * // => ' abc '
14432 *
14433 * _.pad('abc', 8, '_-');
14434 * // => '_-abc_-_'
14435 *
14436 * _.pad('abc', 3);
14437 * // => 'abc'
14438 */
14439 function pad(string, length, chars) {
14440 string = toString(string);
14441 length = toInteger(length);
14442
14443 var strLength = length ? stringSize(string) : 0;
14444 if (!length || strLength >= length) {
14445 return string;
14446 }
14447 var mid = (length - strLength) / 2;
14448 return (
14449 createPadding(nativeFloor(mid), chars) +
14450 string +
14451 createPadding(nativeCeil(mid), chars)
14452 );
14453 }
14454
14455 /**
14456 * Pads `string` on the right side if it's shorter than `length`. Padding
14457 * characters are truncated if they exceed `length`.
14458 *
14459 * @static
14460 * @memberOf _
14461 * @since 4.0.0
14462 * @category String
14463 * @param {string} [string=''] The string to pad.
14464 * @param {number} [length=0] The padding length.
14465 * @param {string} [chars=' '] The string used as padding.
14466 * @returns {string} Returns the padded string.
14467 * @example
14468 *
14469 * _.padEnd('abc', 6);
14470 * // => 'abc '
14471 *
14472 * _.padEnd('abc', 6, '_-');
14473 * // => 'abc_-_'
14474 *
14475 * _.padEnd('abc', 3);
14476 * // => 'abc'
14477 */
14478 function padEnd(string, length, chars) {
14479 string = toString(string);
14480 length = toInteger(length);
14481
14482 var strLength = length ? stringSize(string) : 0;
14483 return (length && strLength < length)
14484 ? (string + createPadding(length - strLength, chars))
14485 : string;
14486 }
14487
14488 /**
14489 * Pads `string` on the left side if it's shorter than `length`. Padding
14490 * characters are truncated if they exceed `length`.
14491 *
14492 * @static
14493 * @memberOf _
14494 * @since 4.0.0
14495 * @category String
14496 * @param {string} [string=''] The string to pad.
14497 * @param {number} [length=0] The padding length.
14498 * @param {string} [chars=' '] The string used as padding.
14499 * @returns {string} Returns the padded string.
14500 * @example
14501 *
14502 * _.padStart('abc', 6);
14503 * // => ' abc'
14504 *
14505 * _.padStart('abc', 6, '_-');
14506 * // => '_-_abc'
14507 *
14508 * _.padStart('abc', 3);
14509 * // => 'abc'
14510 */
14511 function padStart(string, length, chars) {
14512 string = toString(string);
14513 length = toInteger(length);
14514
14515 var strLength = length ? stringSize(string) : 0;
14516 return (length && strLength < length)
14517 ? (createPadding(length - strLength, chars) + string)
14518 : string;
14519 }
14520
14521 /**
14522 * Converts `string` to an integer of the specified radix. If `radix` is
14523 * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
14524 * hexadecimal, in which case a `radix` of `16` is used.
14525 *
14526 * **Note:** This method aligns with the
14527 * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
14528 *
14529 * @static
14530 * @memberOf _
14531 * @since 1.1.0
14532 * @category String
14533 * @param {string} string The string to convert.
14534 * @param {number} [radix=10] The radix to interpret `value` by.
14535 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14536 * @returns {number} Returns the converted integer.
14537 * @example
14538 *
14539 * _.parseInt('08');
14540 * // => 8
14541 *
14542 * _.map(['6', '08', '10'], _.parseInt);
14543 * // => [6, 8, 10]
14544 */
14545 function parseInt(string, radix, guard) {
14546 if (guard || radix == null) {
14547 radix = 0;
14548 } else if (radix) {
14549 radix = +radix;
14550 }
14551 return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
14552 }
14553
14554 /**
14555 * Repeats the given string `n` times.
14556 *
14557 * @static
14558 * @memberOf _
14559 * @since 3.0.0
14560 * @category String
14561 * @param {string} [string=''] The string to repeat.
14562 * @param {number} [n=1] The number of times to repeat the string.
14563 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14564 * @returns {string} Returns the repeated string.
14565 * @example
14566 *
14567 * _.repeat('*', 3);
14568 * // => '***'
14569 *
14570 * _.repeat('abc', 2);
14571 * // => 'abcabc'
14572 *
14573 * _.repeat('abc', 0);
14574 * // => ''
14575 */
14576 function repeat(string, n, guard) {
14577 if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {
14578 n = 1;
14579 } else {
14580 n = toInteger(n);
14581 }
14582 return baseRepeat(toString(string), n);
14583 }
14584
14585 /**
14586 * Replaces matches for `pattern` in `string` with `replacement`.
14587 *
14588 * **Note:** This method is based on
14589 * [`String#replace`](https://mdn.io/String/replace).
14590 *
14591 * @static
14592 * @memberOf _
14593 * @since 4.0.0
14594 * @category String
14595 * @param {string} [string=''] The string to modify.
14596 * @param {RegExp|string} pattern The pattern to replace.
14597 * @param {Function|string} replacement The match replacement.
14598 * @returns {string} Returns the modified string.
14599 * @example
14600 *
14601 * _.replace('Hi Fred', 'Fred', 'Barney');
14602 * // => 'Hi Barney'
14603 */
14604 function replace() {
14605 var args = arguments,
14606 string = toString(args[0]);
14607
14608 return args.length < 3 ? string : string.replace(args[1], args[2]);
14609 }
14610
14611 /**
14612 * Converts `string` to
14613 * [snake case](https://en.wikipedia.org/wiki/Snake_case).
14614 *
14615 * @static
14616 * @memberOf _
14617 * @since 3.0.0
14618 * @category String
14619 * @param {string} [string=''] The string to convert.
14620 * @returns {string} Returns the snake cased string.
14621 * @example
14622 *
14623 * _.snakeCase('Foo Bar');
14624 * // => 'foo_bar'
14625 *
14626 * _.snakeCase('fooBar');
14627 * // => 'foo_bar'
14628 *
14629 * _.snakeCase('--FOO-BAR--');
14630 * // => 'foo_bar'
14631 */
14632 var snakeCase = createCompounder(function(result, word, index) {
14633 return result + (index ? '_' : '') + word.toLowerCase();
14634 });
14635
14636 /**
14637 * Splits `string` by `separator`.
14638 *
14639 * **Note:** This method is based on
14640 * [`String#split`](https://mdn.io/String/split).
14641 *
14642 * @static
14643 * @memberOf _
14644 * @since 4.0.0
14645 * @category String
14646 * @param {string} [string=''] The string to split.
14647 * @param {RegExp|string} separator The separator pattern to split by.
14648 * @param {number} [limit] The length to truncate results to.
14649 * @returns {Array} Returns the string segments.
14650 * @example
14651 *
14652 * _.split('a-b-c', '-', 2);
14653 * // => ['a', 'b']
14654 */
14655 function split(string, separator, limit) {
14656 if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
14657 separator = limit = undefined;
14658 }
14659 limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;
14660 if (!limit) {
14661 return [];
14662 }
14663 string = toString(string);
14664 if (string && (
14665 typeof separator == 'string' ||
14666 (separator != null && !isRegExp(separator))
14667 )) {
14668 separator = baseToString(separator);
14669 if (!separator && hasUnicode(string)) {
14670 return castSlice(stringToArray(string), 0, limit);
14671 }
14672 }
14673 return string.split(separator, limit);
14674 }
14675
14676 /**
14677 * Converts `string` to
14678 * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
14679 *
14680 * @static
14681 * @memberOf _
14682 * @since 3.1.0
14683 * @category String
14684 * @param {string} [string=''] The string to convert.
14685 * @returns {string} Returns the start cased string.
14686 * @example
14687 *
14688 * _.startCase('--foo-bar--');
14689 * // => 'Foo Bar'
14690 *
14691 * _.startCase('fooBar');
14692 * // => 'Foo Bar'
14693 *
14694 * _.startCase('__FOO_BAR__');
14695 * // => 'FOO BAR'
14696 */
14697 var startCase = createCompounder(function(result, word, index) {
14698 return result + (index ? ' ' : '') + upperFirst(word);
14699 });
14700
14701 /**
14702 * Checks if `string` starts with the given target string.
14703 *
14704 * @static
14705 * @memberOf _
14706 * @since 3.0.0
14707 * @category String
14708 * @param {string} [string=''] The string to inspect.
14709 * @param {string} [target] The string to search for.
14710 * @param {number} [position=0] The position to search from.
14711 * @returns {boolean} Returns `true` if `string` starts with `target`,
14712 * else `false`.
14713 * @example
14714 *
14715 * _.startsWith('abc', 'a');
14716 * // => true
14717 *
14718 * _.startsWith('abc', 'b');
14719 * // => false
14720 *
14721 * _.startsWith('abc', 'b', 1);
14722 * // => true
14723 */
14724 function startsWith(string, target, position) {
14725 string = toString(string);
14726 position = position == null
14727 ? 0
14728 : baseClamp(toInteger(position), 0, string.length);
14729
14730 target = baseToString(target);
14731 return string.slice(position, position + target.length) == target;
14732 }
14733
14734 /**
14735 * Creates a compiled template function that can interpolate data properties
14736 * in "interpolate" delimiters, HTML-escape interpolated data properties in
14737 * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
14738 * properties may be accessed as free variables in the template. If a setting
14739 * object is given, it takes precedence over `_.templateSettings` values.
14740 *
14741 * **Note:** In the development build `_.template` utilizes
14742 * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
14743 * for easier debugging.
14744 *
14745 * For more information on precompiling templates see
14746 * [lodash's custom builds documentation](https://lodash.com/custom-builds).
14747 *
14748 * For more information on Chrome extension sandboxes see
14749 * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
14750 *
14751 * @static
14752 * @since 0.1.0
14753 * @memberOf _
14754 * @category String
14755 * @param {string} [string=''] The template string.
14756 * @param {Object} [options={}] The options object.
14757 * @param {RegExp} [options.escape=_.templateSettings.escape]
14758 * The HTML "escape" delimiter.
14759 * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
14760 * The "evaluate" delimiter.
14761 * @param {Object} [options.imports=_.templateSettings.imports]
14762 * An object to import into the template as free variables.
14763 * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
14764 * The "interpolate" delimiter.
14765 * @param {string} [options.sourceURL='lodash.templateSources[n]']
14766 * The sourceURL of the compiled template.
14767 * @param {string} [options.variable='obj']
14768 * The data object variable name.
14769 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
14770 * @returns {Function} Returns the compiled template function.
14771 * @example
14772 *
14773 * // Use the "interpolate" delimiter to create a compiled template.
14774 * var compiled = _.template('hello <%= user %>!');
14775 * compiled({ 'user': 'fred' });
14776 * // => 'hello fred!'
14777 *
14778 * // Use the HTML "escape" delimiter to escape data property values.
14779 * var compiled = _.template('<b><%- value %></b>');
14780 * compiled({ 'value': '<script>' });
14781 * // => '<b><script></b>'
14782 *
14783 * // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
14784 * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
14785 * compiled({ 'users': ['fred', 'barney'] });
14786 * // => '<li>fred</li><li>barney</li>'
14787 *
14788 * // Use the internal `print` function in "evaluate" delimiters.
14789 * var compiled = _.template('<% print("hello " + user); %>!');
14790 * compiled({ 'user': 'barney' });
14791 * // => 'hello barney!'
14792 *
14793 * // Use the ES template literal delimiter as an "interpolate" delimiter.
14794 * // Disable support by replacing the "interpolate" delimiter.
14795 * var compiled = _.template('hello ${ user }!');
14796 * compiled({ 'user': 'pebbles' });
14797 * // => 'hello pebbles!'
14798 *
14799 * // Use backslashes to treat delimiters as plain text.
14800 * var compiled = _.template('<%= "\\<%- value %\\>" %>');
14801 * compiled({ 'value': 'ignored' });
14802 * // => '<%- value %>'
14803 *
14804 * // Use the `imports` option to import `jQuery` as `jq`.
14805 * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
14806 * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
14807 * compiled({ 'users': ['fred', 'barney'] });
14808 * // => '<li>fred</li><li>barney</li>'
14809 *
14810 * // Use the `sourceURL` option to specify a custom sourceURL for the template.
14811 * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
14812 * compiled(data);
14813 * // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
14814 *
14815 * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
14816 * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
14817 * compiled.source;
14818 * // => function(data) {
14819 * // var __t, __p = '';
14820 * // __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
14821 * // return __p;
14822 * // }
14823 *
14824 * // Use custom template delimiters.
14825 * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
14826 * var compiled = _.template('hello {{ user }}!');
14827 * compiled({ 'user': 'mustache' });
14828 * // => 'hello mustache!'
14829 *
14830 * // Use the `source` property to inline compiled templates for meaningful
14831 * // line numbers in error messages and stack traces.
14832 * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
14833 * var JST = {\
14834 * "main": ' + _.template(mainText).source + '\
14835 * };\
14836 * ');
14837 */
14838 function template(string, options, guard) {
14839 // Based on John Resig's `tmpl` implementation
14840 // (http://ejohn.org/blog/javascript-micro-templating/)
14841 // and Laura Doktorova's doT.js (https://github.com/olado/doT).
14842 var settings = lodash.templateSettings;
14843
14844 if (guard && isIterateeCall(string, options, guard)) {
14845 options = undefined;
14846 }
14847 string = toString(string);
14848 options = assignInWith({}, options, settings, customDefaultsAssignIn);
14849
14850 var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),
14851 importsKeys = keys(imports),
14852 importsValues = baseValues(imports, importsKeys);
14853
14854 var isEscaping,
14855 isEvaluating,
14856 index = 0,
14857 interpolate = options.interpolate || reNoMatch,
14858 source = "__p += '";
14859
14860 // Compile the regexp to match each delimiter.
14861 var reDelimiters = RegExp(
14862 (options.escape || reNoMatch).source + '|' +
14863 interpolate.source + '|' +
14864 (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
14865 (options.evaluate || reNoMatch).source + '|$'
14866 , 'g');
14867
14868 // Use a sourceURL for easier debugging.
14869 // The sourceURL gets injected into the source that's eval-ed, so be careful
14870 // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in
14871 // and escape the comment, thus injecting code that gets evaled.
14872 var sourceURL = '//# sourceURL=' +
14873 (hasOwnProperty.call(options, 'sourceURL')
14874 ? (options.sourceURL + '').replace(/\s/g, ' ')
14875 : ('lodash.templateSources[' + (++templateCounter) + ']')
14876 ) + '\n';
14877
14878 string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
14879 interpolateValue || (interpolateValue = esTemplateValue);
14880
14881 // Escape characters that can't be included in string literals.
14882 source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
14883
14884 // Replace delimiters with snippets.
14885 if (escapeValue) {
14886 isEscaping = true;
14887 source += "' +\n__e(" + escapeValue + ") +\n'";
14888 }
14889 if (evaluateValue) {
14890 isEvaluating = true;
14891 source += "';\n" + evaluateValue + ";\n__p += '";
14892 }
14893 if (interpolateValue) {
14894 source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
14895 }
14896 index = offset + match.length;
14897
14898 // The JS engine embedded in Adobe products needs `match` returned in
14899 // order to produce the correct `offset` value.
14900 return match;
14901 });
14902
14903 source += "';\n";
14904
14905 // If `variable` is not specified wrap a with-statement around the generated
14906 // code to add the data object to the top of the scope chain.
14907 var variable = hasOwnProperty.call(options, 'variable') && options.variable;
14908 if (!variable) {
14909 source = 'with (obj) {\n' + source + '\n}\n';
14910 }
14911 // Throw an error if a forbidden character was found in `variable`, to prevent
14912 // potential command injection attacks.
14913 else if (reForbiddenIdentifierChars.test(variable)) {
14914 throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
14915 }
14916
14917 // Cleanup code by stripping empty strings.
14918 source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
14919 .replace(reEmptyStringMiddle, '$1')
14920 .replace(reEmptyStringTrailing, '$1;');
14921
14922 // Frame code as the function body.
14923 source = 'function(' + (variable || 'obj') + ') {\n' +
14924 (variable
14925 ? ''
14926 : 'obj || (obj = {});\n'
14927 ) +
14928 "var __t, __p = ''" +
14929 (isEscaping
14930 ? ', __e = _.escape'
14931 : ''
14932 ) +
14933 (isEvaluating
14934 ? ', __j = Array.prototype.join;\n' +
14935 "function print() { __p += __j.call(arguments, '') }\n"
14936 : ';\n'
14937 ) +
14938 source +
14939 'return __p\n}';
14940
14941 var result = attempt(function() {
14942 return Function(importsKeys, sourceURL + 'return ' + source)
14943 .apply(undefined, importsValues);
14944 });
14945
14946 // Provide the compiled function's source by its `toString` method or
14947 // the `source` property as a convenience for inlining compiled templates.
14948 result.source = source;
14949 if (isError(result)) {
14950 throw result;
14951 }
14952 return result;
14953 }
14954
14955 /**
14956 * Converts `string`, as a whole, to lower case just like
14957 * [String#toLowerCase](https://mdn.io/toLowerCase).
14958 *
14959 * @static
14960 * @memberOf _
14961 * @since 4.0.0
14962 * @category String
14963 * @param {string} [string=''] The string to convert.
14964 * @returns {string} Returns the lower cased string.
14965 * @example
14966 *
14967 * _.toLower('--Foo-Bar--');
14968 * // => '--foo-bar--'
14969 *
14970 * _.toLower('fooBar');
14971 * // => 'foobar'
14972 *
14973 * _.toLower('__FOO_BAR__');
14974 * // => '__foo_bar__'
14975 */
14976 function toLower(value) {
14977 return toString(value).toLowerCase();
14978 }
14979
14980 /**
14981 * Converts `string`, as a whole, to upper case just like
14982 * [String#toUpperCase](https://mdn.io/toUpperCase).
14983 *
14984 * @static
14985 * @memberOf _
14986 * @since 4.0.0
14987 * @category String
14988 * @param {string} [string=''] The string to convert.
14989 * @returns {string} Returns the upper cased string.
14990 * @example
14991 *
14992 * _.toUpper('--foo-bar--');
14993 * // => '--FOO-BAR--'
14994 *
14995 * _.toUpper('fooBar');
14996 * // => 'FOOBAR'
14997 *
14998 * _.toUpper('__foo_bar__');
14999 * // => '__FOO_BAR__'
15000 */
15001 function toUpper(value) {
15002 return toString(value).toUpperCase();
15003 }
15004
15005 /**
15006 * Removes leading and trailing whitespace or specified characters from `string`.
15007 *
15008 * @static
15009 * @memberOf _
15010 * @since 3.0.0
15011 * @category String
15012 * @param {string} [string=''] The string to trim.
15013 * @param {string} [chars=whitespace] The characters to trim.
15014 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
15015 * @returns {string} Returns the trimmed string.
15016 * @example
15017 *
15018 * _.trim(' abc ');
15019 * // => 'abc'
15020 *
15021 * _.trim('-_-abc-_-', '_-');
15022 * // => 'abc'
15023 *
15024 * _.map([' foo ', ' bar '], _.trim);
15025 * // => ['foo', 'bar']
15026 */
15027 function trim(string, chars, guard) {
15028 string = toString(string);
15029 if (string && (guard || chars === undefined)) {
15030 return baseTrim(string);
15031 }
15032 if (!string || !(chars = baseToString(chars))) {
15033 return string;
15034 }
15035 var strSymbols = stringToArray(string),
15036 chrSymbols = stringToArray(chars),
15037 start = charsStartIndex(strSymbols, chrSymbols),
15038 end = charsEndIndex(strSymbols, chrSymbols) + 1;
15039
15040 return castSlice(strSymbols, start, end).join('');
15041 }
15042
15043 /**
15044 * Removes trailing whitespace or specified characters from `string`.
15045 *
15046 * @static
15047 * @memberOf _
15048 * @since 4.0.0
15049 * @category String
15050 * @param {string} [string=''] The string to trim.
15051 * @param {string} [chars=whitespace] The characters to trim.
15052 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
15053 * @returns {string} Returns the trimmed string.
15054 * @example
15055 *
15056 * _.trimEnd(' abc ');
15057 * // => ' abc'
15058 *
15059 * _.trimEnd('-_-abc-_-', '_-');
15060 * // => '-_-abc'
15061 */
15062 function trimEnd(string, chars, guard) {
15063 string = toString(string);
15064 if (string && (guard || chars === undefined)) {
15065 return string.slice(0, trimmedEndIndex(string) + 1);
15066 }
15067 if (!string || !(chars = baseToString(chars))) {
15068 return string;
15069 }
15070 var strSymbols = stringToArray(string),
15071 end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
15072
15073 return castSlice(strSymbols, 0, end).join('');
15074 }
15075
15076 /**
15077 * Removes leading whitespace or specified characters from `string`.
15078 *
15079 * @static
15080 * @memberOf _
15081 * @since 4.0.0
15082 * @category String
15083 * @param {string} [string=''] The string to trim.
15084 * @param {string} [chars=whitespace] The characters to trim.
15085 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
15086 * @returns {string} Returns the trimmed string.
15087 * @example
15088 *
15089 * _.trimStart(' abc ');
15090 * // => 'abc '
15091 *
15092 * _.trimStart('-_-abc-_-', '_-');
15093 * // => 'abc-_-'
15094 */
15095 function trimStart(string, chars, guard) {
15096 string = toString(string);
15097 if (string && (guard || chars === undefined)) {
15098 return string.replace(reTrimStart, '');
15099 }
15100 if (!string || !(chars = baseToString(chars))) {
15101 return string;
15102 }
15103 var strSymbols = stringToArray(string),
15104 start = charsStartIndex(strSymbols, stringToArray(chars));
15105
15106 return castSlice(strSymbols, start).join('');
15107 }
15108
15109 /**
15110 * Truncates `string` if it's longer than the given maximum string length.
15111 * The last characters of the truncated string are replaced with the omission
15112 * string which defaults to "...".
15113 *
15114 * @static
15115 * @memberOf _
15116 * @since 4.0.0
15117 * @category String
15118 * @param {string} [string=''] The string to truncate.
15119 * @param {Object} [options={}] The options object.
15120 * @param {number} [options.length=30] The maximum string length.
15121 * @param {string} [options.omission='...'] The string to indicate text is omitted.
15122 * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
15123 * @returns {string} Returns the truncated string.
15124 * @example
15125 *
15126 * _.truncate('hi-diddly-ho there, neighborino');
15127 * // => 'hi-diddly-ho there, neighbo...'
15128 *
15129 * _.truncate('hi-diddly-ho there, neighborino', {
15130 * 'length': 24,
15131 * 'separator': ' '
15132 * });
15133 * // => 'hi-diddly-ho there,...'
15134 *
15135 * _.truncate('hi-diddly-ho there, neighborino', {
15136 * 'length': 24,
15137 * 'separator': /,? +/
15138 * });
15139 * // => 'hi-diddly-ho there...'
15140 *
15141 * _.truncate('hi-diddly-ho there, neighborino', {
15142 * 'omission': ' [...]'
15143 * });
15144 * // => 'hi-diddly-ho there, neig [...]'
15145 */
15146 function truncate(string, options) {
15147 var length = DEFAULT_TRUNC_LENGTH,
15148 omission = DEFAULT_TRUNC_OMISSION;
15149
15150 if (isObject(options)) {
15151 var separator = 'separator' in options ? options.separator : separator;
15152 length = 'length' in options ? toInteger(options.length) : length;
15153 omission = 'omission' in options ? baseToString(options.omission) : omission;
15154 }
15155 string = toString(string);
15156
15157 var strLength = string.length;
15158 if (hasUnicode(string)) {
15159 var strSymbols = stringToArray(string);
15160 strLength = strSymbols.length;
15161 }
15162 if (length >= strLength) {
15163 return string;
15164 }
15165 var end = length - stringSize(omission);
15166 if (end < 1) {
15167 return omission;
15168 }
15169 var result = strSymbols
15170 ? castSlice(strSymbols, 0, end).join('')
15171 : string.slice(0, end);
15172
15173 if (separator === undefined) {
15174 return result + omission;
15175 }
15176 if (strSymbols) {
15177 end += (result.length - end);
15178 }
15179 if (isRegExp(separator)) {
15180 if (string.slice(end).search(separator)) {
15181 var match,
15182 substring = result;
15183
15184 if (!separator.global) {
15185 separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
15186 }
15187 separator.lastIndex = 0;
15188 while ((match = separator.exec(substring))) {
15189 var newEnd = match.index;
15190 }
15191 result = result.slice(0, newEnd === undefined ? end : newEnd);
15192 }
15193 } else if (string.indexOf(baseToString(separator), end) != end) {
15194 var index = result.lastIndexOf(separator);
15195 if (index > -1) {
15196 result = result.slice(0, index);
15197 }
15198 }
15199 return result + omission;
15200 }
15201
15202 /**
15203 * The inverse of `_.escape`; this method converts the HTML entities
15204 * `&`, `<`, `>`, `"`, and `'` in `string` to
15205 * their corresponding characters.
15206 *
15207 * **Note:** No other HTML entities are unescaped. To unescape additional
15208 * HTML entities use a third-party library like [_he_](https://mths.be/he).
15209 *
15210 * @static
15211 * @memberOf _
15212 * @since 0.6.0
15213 * @category String
15214 * @param {string} [string=''] The string to unescape.
15215 * @returns {string} Returns the unescaped string.
15216 * @example
15217 *
15218 * _.unescape('fred, barney, & pebbles');
15219 * // => 'fred, barney, & pebbles'
15220 */
15221 function unescape(string) {
15222 string = toString(string);
15223 return (string && reHasEscapedHtml.test(string))
15224 ? string.replace(reEscapedHtml, unescapeHtmlChar)
15225 : string;
15226 }
15227
15228 /**
15229 * Converts `string`, as space separated words, to upper case.
15230 *
15231 * @static
15232 * @memberOf _
15233 * @since 4.0.0
15234 * @category String
15235 * @param {string} [string=''] The string to convert.
15236 * @returns {string} Returns the upper cased string.
15237 * @example
15238 *
15239 * _.upperCase('--foo-bar');
15240 * // => 'FOO BAR'
15241 *
15242 * _.upperCase('fooBar');
15243 * // => 'FOO BAR'
15244 *
15245 * _.upperCase('__foo_bar__');
15246 * // => 'FOO BAR'
15247 */
15248 var upperCase = createCompounder(function(result, word, index) {
15249 return result + (index ? ' ' : '') + word.toUpperCase();
15250 });
15251
15252 /**
15253 * Converts the first character of `string` to upper case.
15254 *
15255 * @static
15256 * @memberOf _
15257 * @since 4.0.0
15258 * @category String
15259 * @param {string} [string=''] The string to convert.
15260 * @returns {string} Returns the converted string.
15261 * @example
15262 *
15263 * _.upperFirst('fred');
15264 * // => 'Fred'
15265 *
15266 * _.upperFirst('FRED');
15267 * // => 'FRED'
15268 */
15269 var upperFirst = createCaseFirst('toUpperCase');
15270
15271 /**
15272 * Splits `string` into an array of its words.
15273 *
15274 * @static
15275 * @memberOf _
15276 * @since 3.0.0
15277 * @category String
15278 * @param {string} [string=''] The string to inspect.
15279 * @param {RegExp|string} [pattern] The pattern to match words.
15280 * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
15281 * @returns {Array} Returns the words of `string`.
15282 * @example
15283 *
15284 * _.words('fred, barney, & pebbles');
15285 * // => ['fred', 'barney', 'pebbles']
15286 *
15287 * _.words('fred, barney, & pebbles', /[^, ]+/g);
15288 * // => ['fred', 'barney', '&', 'pebbles']
15289 */
15290 function words(string, pattern, guard) {
15291 string = toString(string);
15292 pattern = guard ? undefined : pattern;
15293
15294 if (pattern === undefined) {
15295 return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
15296 }
15297 return string.match(pattern) || [];
15298 }
15299
15300 /*------------------------------------------------------------------------*/
15301
15302 /**
15303 * Attempts to invoke `func`, returning either the result or the caught error
15304 * object. Any additional arguments are provided to `func` when it's invoked.
15305 *
15306 * @static
15307 * @memberOf _
15308 * @since 3.0.0
15309 * @category Util
15310 * @param {Function} func The function to attempt.
15311 * @param {...*} [args] The arguments to invoke `func` with.
15312 * @returns {*} Returns the `func` result or error object.
15313 * @example
15314 *
15315 * // Avoid throwing errors for invalid selectors.
15316 * var elements = _.attempt(function(selector) {
15317 * return document.querySelectorAll(selector);
15318 * }, '>_>');
15319 *
15320 * if (_.isError(elements)) {
15321 * elements = [];
15322 * }
15323 */
15324 var attempt = baseRest(function(func, args) {
15325 try {
15326 return apply(func, undefined, args);
15327 } catch (e) {
15328 return isError(e) ? e : new Error(e);
15329 }
15330 });
15331
15332 /**
15333 * Binds methods of an object to the object itself, overwriting the existing
15334 * method.
15335 *
15336 * **Note:** This method doesn't set the "length" property of bound functions.
15337 *
15338 * @static
15339 * @since 0.1.0
15340 * @memberOf _
15341 * @category Util
15342 * @param {Object} object The object to bind and assign the bound methods to.
15343 * @param {...(string|string[])} methodNames The object method names to bind.
15344 * @returns {Object} Returns `object`.
15345 * @example
15346 *
15347 * var view = {
15348 * 'label': 'docs',
15349 * 'click': function() {
15350 * console.log('clicked ' + this.label);
15351 * }
15352 * };
15353 *
15354 * _.bindAll(view, ['click']);
15355 * jQuery(element).on('click', view.click);
15356 * // => Logs 'clicked docs' when clicked.
15357 */
15358 var bindAll = flatRest(function(object, methodNames) {
15359 arrayEach(methodNames, function(key) {
15360 key = toKey(key);
15361 baseAssignValue(object, key, bind(object[key], object));
15362 });
15363 return object;
15364 });
15365
15366 /**
15367 * Creates a function that iterates over `pairs` and invokes the corresponding
15368 * function of the first predicate to return truthy. The predicate-function
15369 * pairs are invoked with the `this` binding and arguments of the created
15370 * function.
15371 *
15372 * @static
15373 * @memberOf _
15374 * @since 4.0.0
15375 * @category Util
15376 * @param {Array} pairs The predicate-function pairs.
15377 * @returns {Function} Returns the new composite function.
15378 * @example
15379 *
15380 * var func = _.cond([
15381 * [_.matches({ 'a': 1 }), _.constant('matches A')],
15382 * [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
15383 * [_.stubTrue, _.constant('no match')]
15384 * ]);
15385 *
15386 * func({ 'a': 1, 'b': 2 });
15387 * // => 'matches A'
15388 *
15389 * func({ 'a': 0, 'b': 1 });
15390 * // => 'matches B'
15391 *
15392 * func({ 'a': '1', 'b': '2' });
15393 * // => 'no match'
15394 */
15395 function cond(pairs) {
15396 var length = pairs == null ? 0 : pairs.length,
15397 toIteratee = getIteratee();
15398
15399 pairs = !length ? [] : arrayMap(pairs, function(pair) {
15400 if (typeof pair[1] != 'function') {
15401 throw new TypeError(FUNC_ERROR_TEXT);
15402 }
15403 return [toIteratee(pair[0]), pair[1]];
15404 });
15405
15406 return baseRest(function(args) {
15407 var index = -1;
15408 while (++index < length) {
15409 var pair = pairs[index];
15410 if (apply(pair[0], this, args)) {
15411 return apply(pair[1], this, args);
15412 }
15413 }
15414 });
15415 }
15416
15417 /**
15418 * Creates a function that invokes the predicate properties of `source` with
15419 * the corresponding property values of a given object, returning `true` if
15420 * all predicates return truthy, else `false`.
15421 *
15422 * **Note:** The created function is equivalent to `_.conformsTo` with
15423 * `source` partially applied.
15424 *
15425 * @static
15426 * @memberOf _
15427 * @since 4.0.0
15428 * @category Util
15429 * @param {Object} source The object of property predicates to conform to.
15430 * @returns {Function} Returns the new spec function.
15431 * @example
15432 *
15433 * var objects = [
15434 * { 'a': 2, 'b': 1 },
15435 * { 'a': 1, 'b': 2 }
15436 * ];
15437 *
15438 * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
15439 * // => [{ 'a': 1, 'b': 2 }]
15440 */
15441 function conforms(source) {
15442 return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
15443 }
15444
15445 /**
15446 * Creates a function that returns `value`.
15447 *
15448 * @static
15449 * @memberOf _
15450 * @since 2.4.0
15451 * @category Util
15452 * @param {*} value The value to return from the new function.
15453 * @returns {Function} Returns the new constant function.
15454 * @example
15455 *
15456 * var objects = _.times(2, _.constant({ 'a': 1 }));
15457 *
15458 * console.log(objects);
15459 * // => [{ 'a': 1 }, { 'a': 1 }]
15460 *
15461 * console.log(objects[0] === objects[1]);
15462 * // => true
15463 */
15464 function constant(value) {
15465 return function() {
15466 return value;
15467 };
15468 }
15469
15470 /**
15471 * Checks `value` to determine whether a default value should be returned in
15472 * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
15473 * or `undefined`.
15474 *
15475 * @static
15476 * @memberOf _
15477 * @since 4.14.0
15478 * @category Util
15479 * @param {*} value The value to check.
15480 * @param {*} defaultValue The default value.
15481 * @returns {*} Returns the resolved value.
15482 * @example
15483 *
15484 * _.defaultTo(1, 10);
15485 * // => 1
15486 *
15487 * _.defaultTo(undefined, 10);
15488 * // => 10
15489 */
15490 function defaultTo(value, defaultValue) {
15491 return (value == null || value !== value) ? defaultValue : value;
15492 }
15493
15494 /**
15495 * Creates a function that returns the result of invoking the given functions
15496 * with the `this` binding of the created function, where each successive
15497 * invocation is supplied the return value of the previous.
15498 *
15499 * @static
15500 * @memberOf _
15501 * @since 3.0.0
15502 * @category Util
15503 * @param {...(Function|Function[])} [funcs] The functions to invoke.
15504 * @returns {Function} Returns the new composite function.
15505 * @see _.flowRight
15506 * @example
15507 *
15508 * function square(n) {
15509 * return n * n;
15510 * }
15511 *
15512 * var addSquare = _.flow([_.add, square]);
15513 * addSquare(1, 2);
15514 * // => 9
15515 */
15516 var flow = createFlow();
15517
15518 /**
15519 * This method is like `_.flow` except that it creates a function that
15520 * invokes the given functions from right to left.
15521 *
15522 * @static
15523 * @since 3.0.0
15524 * @memberOf _
15525 * @category Util
15526 * @param {...(Function|Function[])} [funcs] The functions to invoke.
15527 * @returns {Function} Returns the new composite function.
15528 * @see _.flow
15529 * @example
15530 *
15531 * function square(n) {
15532 * return n * n;
15533 * }
15534 *
15535 * var addSquare = _.flowRight([square, _.add]);
15536 * addSquare(1, 2);
15537 * // => 9
15538 */
15539 var flowRight = createFlow(true);
15540
15541 /**
15542 * This method returns the first argument it receives.
15543 *
15544 * @static
15545 * @since 0.1.0
15546 * @memberOf _
15547 * @category Util
15548 * @param {*} value Any value.
15549 * @returns {*} Returns `value`.
15550 * @example
15551 *
15552 * var object = { 'a': 1 };
15553 *
15554 * console.log(_.identity(object) === object);
15555 * // => true
15556 */
15557 function identity(value) {
15558 return value;
15559 }
15560
15561 /**
15562 * Creates a function that invokes `func` with the arguments of the created
15563 * function. If `func` is a property name, the created function returns the
15564 * property value for a given element. If `func` is an array or object, the
15565 * created function returns `true` for elements that contain the equivalent
15566 * source properties, otherwise it returns `false`.
15567 *
15568 * @static
15569 * @since 4.0.0
15570 * @memberOf _
15571 * @category Util
15572 * @param {*} [func=_.identity] The value to convert to a callback.
15573 * @returns {Function} Returns the callback.
15574 * @example
15575 *
15576 * var users = [
15577 * { 'user': 'barney', 'age': 36, 'active': true },
15578 * { 'user': 'fred', 'age': 40, 'active': false }
15579 * ];
15580 *
15581 * // The `_.matches` iteratee shorthand.
15582 * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
15583 * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
15584 *
15585 * // The `_.matchesProperty` iteratee shorthand.
15586 * _.filter(users, _.iteratee(['user', 'fred']));
15587 * // => [{ 'user': 'fred', 'age': 40 }]
15588 *
15589 * // The `_.property` iteratee shorthand.
15590 * _.map(users, _.iteratee('user'));
15591 * // => ['barney', 'fred']
15592 *
15593 * // Create custom iteratee shorthands.
15594 * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
15595 * return !_.isRegExp(func) ? iteratee(func) : function(string) {
15596 * return func.test(string);
15597 * };
15598 * });
15599 *
15600 * _.filter(['abc', 'def'], /ef/);
15601 * // => ['def']
15602 */
15603 function iteratee(func) {
15604 return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
15605 }
15606
15607 /**
15608 * Creates a function that performs a partial deep comparison between a given
15609 * object and `source`, returning `true` if the given object has equivalent
15610 * property values, else `false`.
15611 *
15612 * **Note:** The created function is equivalent to `_.isMatch` with `source`
15613 * partially applied.
15614 *
15615 * Partial comparisons will match empty array and empty object `source`
15616 * values against any array or object value, respectively. See `_.isEqual`
15617 * for a list of supported value comparisons.
15618 *
15619 * **Note:** Multiple values can be checked by combining several matchers
15620 * using `_.overSome`
15621 *
15622 * @static
15623 * @memberOf _
15624 * @since 3.0.0
15625 * @category Util
15626 * @param {Object} source The object of property values to match.
15627 * @returns {Function} Returns the new spec function.
15628 * @example
15629 *
15630 * var objects = [
15631 * { 'a': 1, 'b': 2, 'c': 3 },
15632 * { 'a': 4, 'b': 5, 'c': 6 }
15633 * ];
15634 *
15635 * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
15636 * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
15637 *
15638 * // Checking for several possible values
15639 * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));
15640 * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
15641 */
15642 function matches(source) {
15643 return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
15644 }
15645
15646 /**
15647 * Creates a function that performs a partial deep comparison between the
15648 * value at `path` of a given object to `srcValue`, returning `true` if the
15649 * object value is equivalent, else `false`.
15650 *
15651 * **Note:** Partial comparisons will match empty array and empty object
15652 * `srcValue` values against any array or object value, respectively. See
15653 * `_.isEqual` for a list of supported value comparisons.
15654 *
15655 * **Note:** Multiple values can be checked by combining several matchers
15656 * using `_.overSome`
15657 *
15658 * @static
15659 * @memberOf _
15660 * @since 3.2.0
15661 * @category Util
15662 * @param {Array|string} path The path of the property to get.
15663 * @param {*} srcValue The value to match.
15664 * @returns {Function} Returns the new spec function.
15665 * @example
15666 *
15667 * var objects = [
15668 * { 'a': 1, 'b': 2, 'c': 3 },
15669 * { 'a': 4, 'b': 5, 'c': 6 }
15670 * ];
15671 *
15672 * _.find(objects, _.matchesProperty('a', 4));
15673 * // => { 'a': 4, 'b': 5, 'c': 6 }
15674 *
15675 * // Checking for several possible values
15676 * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));
15677 * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
15678 */
15679 function matchesProperty(path, srcValue) {
15680 return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
15681 }
15682
15683 /**
15684 * Creates a function that invokes the method at `path` of a given object.
15685 * Any additional arguments are provided to the invoked method.
15686 *
15687 * @static
15688 * @memberOf _
15689 * @since 3.7.0
15690 * @category Util
15691 * @param {Array|string} path The path of the method to invoke.
15692 * @param {...*} [args] The arguments to invoke the method with.
15693 * @returns {Function} Returns the new invoker function.
15694 * @example
15695 *
15696 * var objects = [
15697 * { 'a': { 'b': _.constant(2) } },
15698 * { 'a': { 'b': _.constant(1) } }
15699 * ];
15700 *
15701 * _.map(objects, _.method('a.b'));
15702 * // => [2, 1]
15703 *
15704 * _.map(objects, _.method(['a', 'b']));
15705 * // => [2, 1]
15706 */
15707 var method = baseRest(function(path, args) {
15708 return function(object) {
15709 return baseInvoke(object, path, args);
15710 };
15711 });
15712
15713 /**
15714 * The opposite of `_.method`; this method creates a function that invokes
15715 * the method at a given path of `object`. Any additional arguments are
15716 * provided to the invoked method.
15717 *
15718 * @static
15719 * @memberOf _
15720 * @since 3.7.0
15721 * @category Util
15722 * @param {Object} object The object to query.
15723 * @param {...*} [args] The arguments to invoke the method with.
15724 * @returns {Function} Returns the new invoker function.
15725 * @example
15726 *
15727 * var array = _.times(3, _.constant),
15728 * object = { 'a': array, 'b': array, 'c': array };
15729 *
15730 * _.map(['a[2]', 'c[0]'], _.methodOf(object));
15731 * // => [2, 0]
15732 *
15733 * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
15734 * // => [2, 0]
15735 */
15736 var methodOf = baseRest(function(object, args) {
15737 return function(path) {
15738 return baseInvoke(object, path, args);
15739 };
15740 });
15741
15742 /**
15743 * Adds all own enumerable string keyed function properties of a source
15744 * object to the destination object. If `object` is a function, then methods
15745 * are added to its prototype as well.
15746 *
15747 * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
15748 * avoid conflicts caused by modifying the original.
15749 *
15750 * @static
15751 * @since 0.1.0
15752 * @memberOf _
15753 * @category Util
15754 * @param {Function|Object} [object=lodash] The destination object.
15755 * @param {Object} source The object of functions to add.
15756 * @param {Object} [options={}] The options object.
15757 * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
15758 * @returns {Function|Object} Returns `object`.
15759 * @example
15760 *
15761 * function vowels(string) {
15762 * return _.filter(string, function(v) {
15763 * return /[aeiou]/i.test(v);
15764 * });
15765 * }
15766 *
15767 * _.mixin({ 'vowels': vowels });
15768 * _.vowels('fred');
15769 * // => ['e']
15770 *
15771 * _('fred').vowels().value();
15772 * // => ['e']
15773 *
15774 * _.mixin({ 'vowels': vowels }, { 'chain': false });
15775 * _('fred').vowels();
15776 * // => ['e']
15777 */
15778 function mixin(object, source, options) {
15779 var props = keys(source),
15780 methodNames = baseFunctions(source, props);
15781
15782 if (options == null &&
15783 !(isObject(source) && (methodNames.length || !props.length))) {
15784 options = source;
15785 source = object;
15786 object = this;
15787 methodNames = baseFunctions(source, keys(source));
15788 }
15789 var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
15790 isFunc = isFunction(object);
15791
15792 arrayEach(methodNames, function(methodName) {
15793 var func = source[methodName];
15794 object[methodName] = func;
15795 if (isFunc) {
15796 object.prototype[methodName] = function() {
15797 var chainAll = this.__chain__;
15798 if (chain || chainAll) {
15799 var result = object(this.__wrapped__),
15800 actions = result.__actions__ = copyArray(this.__actions__);
15801
15802 actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
15803 result.__chain__ = chainAll;
15804 return result;
15805 }
15806 return func.apply(object, arrayPush([this.value()], arguments));
15807 };
15808 }
15809 });
15810
15811 return object;
15812 }
15813
15814 /**
15815 * Reverts the `_` variable to its previous value and returns a reference to
15816 * the `lodash` function.
15817 *
15818 * @static
15819 * @since 0.1.0
15820 * @memberOf _
15821 * @category Util
15822 * @returns {Function} Returns the `lodash` function.
15823 * @example
15824 *
15825 * var lodash = _.noConflict();
15826 */
15827 function noConflict() {
15828 if (root._ === this) {
15829 root._ = oldDash;
15830 }
15831 return this;
15832 }
15833
15834 /**
15835 * This method returns `undefined`.
15836 *
15837 * @static
15838 * @memberOf _
15839 * @since 2.3.0
15840 * @category Util
15841 * @example
15842 *
15843 * _.times(2, _.noop);
15844 * // => [undefined, undefined]
15845 */
15846 function noop() {
15847 // No operation performed.
15848 }
15849
15850 /**
15851 * Creates a function that gets the argument at index `n`. If `n` is negative,
15852 * the nth argument from the end is returned.
15853 *
15854 * @static
15855 * @memberOf _
15856 * @since 4.0.0
15857 * @category Util
15858 * @param {number} [n=0] The index of the argument to return.
15859 * @returns {Function} Returns the new pass-thru function.
15860 * @example
15861 *
15862 * var func = _.nthArg(1);
15863 * func('a', 'b', 'c', 'd');
15864 * // => 'b'
15865 *
15866 * var func = _.nthArg(-2);
15867 * func('a', 'b', 'c', 'd');
15868 * // => 'c'
15869 */
15870 function nthArg(n) {
15871 n = toInteger(n);
15872 return baseRest(function(args) {
15873 return baseNth(args, n);
15874 });
15875 }
15876
15877 /**
15878 * Creates a function that invokes `iteratees` with the arguments it receives
15879 * and returns their results.
15880 *
15881 * @static
15882 * @memberOf _
15883 * @since 4.0.0
15884 * @category Util
15885 * @param {...(Function|Function[])} [iteratees=[_.identity]]
15886 * The iteratees to invoke.
15887 * @returns {Function} Returns the new function.
15888 * @example
15889 *
15890 * var func = _.over([Math.max, Math.min]);
15891 *
15892 * func(1, 2, 3, 4);
15893 * // => [4, 1]
15894 */
15895 var over = createOver(arrayMap);
15896
15897 /**
15898 * Creates a function that checks if **all** of the `predicates` return
15899 * truthy when invoked with the arguments it receives.
15900 *
15901 * Following shorthands are possible for providing predicates.
15902 * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
15903 * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
15904 *
15905 * @static
15906 * @memberOf _
15907 * @since 4.0.0
15908 * @category Util
15909 * @param {...(Function|Function[])} [predicates=[_.identity]]
15910 * The predicates to check.
15911 * @returns {Function} Returns the new function.
15912 * @example
15913 *
15914 * var func = _.overEvery([Boolean, isFinite]);
15915 *
15916 * func('1');
15917 * // => true
15918 *
15919 * func(null);
15920 * // => false
15921 *
15922 * func(NaN);
15923 * // => false
15924 */
15925 var overEvery = createOver(arrayEvery);
15926
15927 /**
15928 * Creates a function that checks if **any** of the `predicates` return
15929 * truthy when invoked with the arguments it receives.
15930 *
15931 * Following shorthands are possible for providing predicates.
15932 * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
15933 * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
15934 *
15935 * @static
15936 * @memberOf _
15937 * @since 4.0.0
15938 * @category Util
15939 * @param {...(Function|Function[])} [predicates=[_.identity]]
15940 * The predicates to check.
15941 * @returns {Function} Returns the new function.
15942 * @example
15943 *
15944 * var func = _.overSome([Boolean, isFinite]);
15945 *
15946 * func('1');
15947 * // => true
15948 *
15949 * func(null);
15950 * // => true
15951 *
15952 * func(NaN);
15953 * // => false
15954 *
15955 * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])
15956 * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])
15957 */
15958 var overSome = createOver(arraySome);
15959
15960 /**
15961 * Creates a function that returns the value at `path` of a given object.
15962 *
15963 * @static
15964 * @memberOf _
15965 * @since 2.4.0
15966 * @category Util
15967 * @param {Array|string} path The path of the property to get.
15968 * @returns {Function} Returns the new accessor function.
15969 * @example
15970 *
15971 * var objects = [
15972 * { 'a': { 'b': 2 } },
15973 * { 'a': { 'b': 1 } }
15974 * ];
15975 *
15976 * _.map(objects, _.property('a.b'));
15977 * // => [2, 1]
15978 *
15979 * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
15980 * // => [1, 2]
15981 */
15982 function property(path) {
15983 return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
15984 }
15985
15986 /**
15987 * The opposite of `_.property`; this method creates a function that returns
15988 * the value at a given path of `object`.
15989 *
15990 * @static
15991 * @memberOf _
15992 * @since 3.0.0
15993 * @category Util
15994 * @param {Object} object The object to query.
15995 * @returns {Function} Returns the new accessor function.
15996 * @example
15997 *
15998 * var array = [0, 1, 2],
15999 * object = { 'a': array, 'b': array, 'c': array };
16000 *
16001 * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
16002 * // => [2, 0]
16003 *
16004 * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
16005 * // => [2, 0]
16006 */
16007 function propertyOf(object) {
16008 return function(path) {
16009 return object == null ? undefined : baseGet(object, path);
16010 };
16011 }
16012
16013 /**
16014 * Creates an array of numbers (positive and/or negative) progressing from
16015 * `start` up to, but not including, `end`. A step of `-1` is used if a negative
16016 * `start` is specified without an `end` or `step`. If `end` is not specified,
16017 * it's set to `start` with `start` then set to `0`.
16018 *
16019 * **Note:** JavaScript follows the IEEE-754 standard for resolving
16020 * floating-point values which can produce unexpected results.
16021 *
16022 * @static
16023 * @since 0.1.0
16024 * @memberOf _
16025 * @category Util
16026 * @param {number} [start=0] The start of the range.
16027 * @param {number} end The end of the range.
16028 * @param {number} [step=1] The value to increment or decrement by.
16029 * @returns {Array} Returns the range of numbers.
16030 * @see _.inRange, _.rangeRight
16031 * @example
16032 *
16033 * _.range(4);
16034 * // => [0, 1, 2, 3]
16035 *
16036 * _.range(-4);
16037 * // => [0, -1, -2, -3]
16038 *
16039 * _.range(1, 5);
16040 * // => [1, 2, 3, 4]
16041 *
16042 * _.range(0, 20, 5);
16043 * // => [0, 5, 10, 15]
16044 *
16045 * _.range(0, -4, -1);
16046 * // => [0, -1, -2, -3]
16047 *
16048 * _.range(1, 4, 0);
16049 * // => [1, 1, 1]
16050 *
16051 * _.range(0);
16052 * // => []
16053 */
16054 var range = createRange();
16055
16056 /**
16057 * This method is like `_.range` except that it populates values in
16058 * descending order.
16059 *
16060 * @static
16061 * @memberOf _
16062 * @since 4.0.0
16063 * @category Util
16064 * @param {number} [start=0] The start of the range.
16065 * @param {number} end The end of the range.
16066 * @param {number} [step=1] The value to increment or decrement by.
16067 * @returns {Array} Returns the range of numbers.
16068 * @see _.inRange, _.range
16069 * @example
16070 *
16071 * _.rangeRight(4);
16072 * // => [3, 2, 1, 0]
16073 *
16074 * _.rangeRight(-4);
16075 * // => [-3, -2, -1, 0]
16076 *
16077 * _.rangeRight(1, 5);
16078 * // => [4, 3, 2, 1]
16079 *
16080 * _.rangeRight(0, 20, 5);
16081 * // => [15, 10, 5, 0]
16082 *
16083 * _.rangeRight(0, -4, -1);
16084 * // => [-3, -2, -1, 0]
16085 *
16086 * _.rangeRight(1, 4, 0);
16087 * // => [1, 1, 1]
16088 *
16089 * _.rangeRight(0);
16090 * // => []
16091 */
16092 var rangeRight = createRange(true);
16093
16094 /**
16095 * This method returns a new empty array.
16096 *
16097 * @static
16098 * @memberOf _
16099 * @since 4.13.0
16100 * @category Util
16101 * @returns {Array} Returns the new empty array.
16102 * @example
16103 *
16104 * var arrays = _.times(2, _.stubArray);
16105 *
16106 * console.log(arrays);
16107 * // => [[], []]
16108 *
16109 * console.log(arrays[0] === arrays[1]);
16110 * // => false
16111 */
16112 function stubArray() {
16113 return [];
16114 }
16115
16116 /**
16117 * This method returns `false`.
16118 *
16119 * @static
16120 * @memberOf _
16121 * @since 4.13.0
16122 * @category Util
16123 * @returns {boolean} Returns `false`.
16124 * @example
16125 *
16126 * _.times(2, _.stubFalse);
16127 * // => [false, false]
16128 */
16129 function stubFalse() {
16130 return false;
16131 }
16132
16133 /**
16134 * This method returns a new empty object.
16135 *
16136 * @static
16137 * @memberOf _
16138 * @since 4.13.0
16139 * @category Util
16140 * @returns {Object} Returns the new empty object.
16141 * @example
16142 *
16143 * var objects = _.times(2, _.stubObject);
16144 *
16145 * console.log(objects);
16146 * // => [{}, {}]
16147 *
16148 * console.log(objects[0] === objects[1]);
16149 * // => false
16150 */
16151 function stubObject() {
16152 return {};
16153 }
16154
16155 /**
16156 * This method returns an empty string.
16157 *
16158 * @static
16159 * @memberOf _
16160 * @since 4.13.0
16161 * @category Util
16162 * @returns {string} Returns the empty string.
16163 * @example
16164 *
16165 * _.times(2, _.stubString);
16166 * // => ['', '']
16167 */
16168 function stubString() {
16169 return '';
16170 }
16171
16172 /**
16173 * This method returns `true`.
16174 *
16175 * @static
16176 * @memberOf _
16177 * @since 4.13.0
16178 * @category Util
16179 * @returns {boolean} Returns `true`.
16180 * @example
16181 *
16182 * _.times(2, _.stubTrue);
16183 * // => [true, true]
16184 */
16185 function stubTrue() {
16186 return true;
16187 }
16188
16189 /**
16190 * Invokes the iteratee `n` times, returning an array of the results of
16191 * each invocation. The iteratee is invoked with one argument; (index).
16192 *
16193 * @static
16194 * @since 0.1.0
16195 * @memberOf _
16196 * @category Util
16197 * @param {number} n The number of times to invoke `iteratee`.
16198 * @param {Function} [iteratee=_.identity] The function invoked per iteration.
16199 * @returns {Array} Returns the array of results.
16200 * @example
16201 *
16202 * _.times(3, String);
16203 * // => ['0', '1', '2']
16204 *
16205 * _.times(4, _.constant(0));
16206 * // => [0, 0, 0, 0]
16207 */
16208 function times(n, iteratee) {
16209 n = toInteger(n);
16210 if (n < 1 || n > MAX_SAFE_INTEGER) {
16211 return [];
16212 }
16213 var index = MAX_ARRAY_LENGTH,
16214 length = nativeMin(n, MAX_ARRAY_LENGTH);
16215
16216 iteratee = getIteratee(iteratee);
16217 n -= MAX_ARRAY_LENGTH;
16218
16219 var result = baseTimes(length, iteratee);
16220 while (++index < n) {
16221 iteratee(index);
16222 }
16223 return result;
16224 }
16225
16226 /**
16227 * Converts `value` to a property path array.
16228 *
16229 * @static
16230 * @memberOf _
16231 * @since 4.0.0
16232 * @category Util
16233 * @param {*} value The value to convert.
16234 * @returns {Array} Returns the new property path array.
16235 * @example
16236 *
16237 * _.toPath('a.b.c');
16238 * // => ['a', 'b', 'c']
16239 *
16240 * _.toPath('a[0].b.c');
16241 * // => ['a', '0', 'b', 'c']
16242 */
16243 function toPath(value) {
16244 if (isArray(value)) {
16245 return arrayMap(value, toKey);
16246 }
16247 return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
16248 }
16249
16250 /**
16251 * Generates a unique ID. If `prefix` is given, the ID is appended to it.
16252 *
16253 * @static
16254 * @since 0.1.0
16255 * @memberOf _
16256 * @category Util
16257 * @param {string} [prefix=''] The value to prefix the ID with.
16258 * @returns {string} Returns the unique ID.
16259 * @example
16260 *
16261 * _.uniqueId('contact_');
16262 * // => 'contact_104'
16263 *
16264 * _.uniqueId();
16265 * // => '105'
16266 */
16267 function uniqueId(prefix) {
16268 var id = ++idCounter;
16269 return toString(prefix) + id;
16270 }
16271
16272 /*------------------------------------------------------------------------*/
16273
16274 /**
16275 * Adds two numbers.
16276 *
16277 * @static
16278 * @memberOf _
16279 * @since 3.4.0
16280 * @category Math
16281 * @param {number} augend The first number in an addition.
16282 * @param {number} addend The second number in an addition.
16283 * @returns {number} Returns the total.
16284 * @example
16285 *
16286 * _.add(6, 4);
16287 * // => 10
16288 */
16289 var add = createMathOperation(function(augend, addend) {
16290 return augend + addend;
16291 }, 0);
16292
16293 /**
16294 * Computes `number` rounded up to `precision`.
16295 *
16296 * @static
16297 * @memberOf _
16298 * @since 3.10.0
16299 * @category Math
16300 * @param {number} number The number to round up.
16301 * @param {number} [precision=0] The precision to round up to.
16302 * @returns {number} Returns the rounded up number.
16303 * @example
16304 *
16305 * _.ceil(4.006);
16306 * // => 5
16307 *
16308 * _.ceil(6.004, 2);
16309 * // => 6.01
16310 *
16311 * _.ceil(6040, -2);
16312 * // => 6100
16313 */
16314 var ceil = createRound('ceil');
16315
16316 /**
16317 * Divide two numbers.
16318 *
16319 * @static
16320 * @memberOf _
16321 * @since 4.7.0
16322 * @category Math
16323 * @param {number} dividend The first number in a division.
16324 * @param {number} divisor The second number in a division.
16325 * @returns {number} Returns the quotient.
16326 * @example
16327 *
16328 * _.divide(6, 4);
16329 * // => 1.5
16330 */
16331 var divide = createMathOperation(function(dividend, divisor) {
16332 return dividend / divisor;
16333 }, 1);
16334
16335 /**
16336 * Computes `number` rounded down to `precision`.
16337 *
16338 * @static
16339 * @memberOf _
16340 * @since 3.10.0
16341 * @category Math
16342 * @param {number} number The number to round down.
16343 * @param {number} [precision=0] The precision to round down to.
16344 * @returns {number} Returns the rounded down number.
16345 * @example
16346 *
16347 * _.floor(4.006);
16348 * // => 4
16349 *
16350 * _.floor(0.046, 2);
16351 * // => 0.04
16352 *
16353 * _.floor(4060, -2);
16354 * // => 4000
16355 */
16356 var floor = createRound('floor');
16357
16358 /**
16359 * Computes the maximum value of `array`. If `array` is empty or falsey,
16360 * `undefined` is returned.
16361 *
16362 * @static
16363 * @since 0.1.0
16364 * @memberOf _
16365 * @category Math
16366 * @param {Array} array The array to iterate over.
16367 * @returns {*} Returns the maximum value.
16368 * @example
16369 *
16370 * _.max([4, 2, 8, 6]);
16371 * // => 8
16372 *
16373 * _.max([]);
16374 * // => undefined
16375 */
16376 function max(array) {
16377 return (array && array.length)
16378 ? baseExtremum(array, identity, baseGt)
16379 : undefined;
16380 }
16381
16382 /**
16383 * This method is like `_.max` except that it accepts `iteratee` which is
16384 * invoked for each element in `array` to generate the criterion by which
16385 * the value is ranked. The iteratee is invoked with one argument: (value).
16386 *
16387 * @static
16388 * @memberOf _
16389 * @since 4.0.0
16390 * @category Math
16391 * @param {Array} array The array to iterate over.
16392 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
16393 * @returns {*} Returns the maximum value.
16394 * @example
16395 *
16396 * var objects = [{ 'n': 1 }, { 'n': 2 }];
16397 *
16398 * _.maxBy(objects, function(o) { return o.n; });
16399 * // => { 'n': 2 }
16400 *
16401 * // The `_.property` iteratee shorthand.
16402 * _.maxBy(objects, 'n');
16403 * // => { 'n': 2 }
16404 */
16405 function maxBy(array, iteratee) {
16406 return (array && array.length)
16407 ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
16408 : undefined;
16409 }
16410
16411 /**
16412 * Computes the mean of the values in `array`.
16413 *
16414 * @static
16415 * @memberOf _
16416 * @since 4.0.0
16417 * @category Math
16418 * @param {Array} array The array to iterate over.
16419 * @returns {number} Returns the mean.
16420 * @example
16421 *
16422 * _.mean([4, 2, 8, 6]);
16423 * // => 5
16424 */
16425 function mean(array) {
16426 return baseMean(array, identity);
16427 }
16428
16429 /**
16430 * This method is like `_.mean` except that it accepts `iteratee` which is
16431 * invoked for each element in `array` to generate the value to be averaged.
16432 * The iteratee is invoked with one argument: (value).
16433 *
16434 * @static
16435 * @memberOf _
16436 * @since 4.7.0
16437 * @category Math
16438 * @param {Array} array The array to iterate over.
16439 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
16440 * @returns {number} Returns the mean.
16441 * @example
16442 *
16443 * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
16444 *
16445 * _.meanBy(objects, function(o) { return o.n; });
16446 * // => 5
16447 *
16448 * // The `_.property` iteratee shorthand.
16449 * _.meanBy(objects, 'n');
16450 * // => 5
16451 */
16452 function meanBy(array, iteratee) {
16453 return baseMean(array, getIteratee(iteratee, 2));
16454 }
16455
16456 /**
16457 * Computes the minimum value of `array`. If `array` is empty or falsey,
16458 * `undefined` is returned.
16459 *
16460 * @static
16461 * @since 0.1.0
16462 * @memberOf _
16463 * @category Math
16464 * @param {Array} array The array to iterate over.
16465 * @returns {*} Returns the minimum value.
16466 * @example
16467 *
16468 * _.min([4, 2, 8, 6]);
16469 * // => 2
16470 *
16471 * _.min([]);
16472 * // => undefined
16473 */
16474 function min(array) {
16475 return (array && array.length)
16476 ? baseExtremum(array, identity, baseLt)
16477 : undefined;
16478 }
16479
16480 /**
16481 * This method is like `_.min` except that it accepts `iteratee` which is
16482 * invoked for each element in `array` to generate the criterion by which
16483 * the value is ranked. The iteratee is invoked with one argument: (value).
16484 *
16485 * @static
16486 * @memberOf _
16487 * @since 4.0.0
16488 * @category Math
16489 * @param {Array} array The array to iterate over.
16490 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
16491 * @returns {*} Returns the minimum value.
16492 * @example
16493 *
16494 * var objects = [{ 'n': 1 }, { 'n': 2 }];
16495 *
16496 * _.minBy(objects, function(o) { return o.n; });
16497 * // => { 'n': 1 }
16498 *
16499 * // The `_.property` iteratee shorthand.
16500 * _.minBy(objects, 'n');
16501 * // => { 'n': 1 }
16502 */
16503 function minBy(array, iteratee) {
16504 return (array && array.length)
16505 ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
16506 : undefined;
16507 }
16508
16509 /**
16510 * Multiply two numbers.
16511 *
16512 * @static
16513 * @memberOf _
16514 * @since 4.7.0
16515 * @category Math
16516 * @param {number} multiplier The first number in a multiplication.
16517 * @param {number} multiplicand The second number in a multiplication.
16518 * @returns {number} Returns the product.
16519 * @example
16520 *
16521 * _.multiply(6, 4);
16522 * // => 24
16523 */
16524 var multiply = createMathOperation(function(multiplier, multiplicand) {
16525 return multiplier * multiplicand;
16526 }, 1);
16527
16528 /**
16529 * Computes `number` rounded to `precision`.
16530 *
16531 * @static
16532 * @memberOf _
16533 * @since 3.10.0
16534 * @category Math
16535 * @param {number} number The number to round.
16536 * @param {number} [precision=0] The precision to round to.
16537 * @returns {number} Returns the rounded number.
16538 * @example
16539 *
16540 * _.round(4.006);
16541 * // => 4
16542 *
16543 * _.round(4.006, 2);
16544 * // => 4.01
16545 *
16546 * _.round(4060, -2);
16547 * // => 4100
16548 */
16549 var round = createRound('round');
16550
16551 /**
16552 * Subtract two numbers.
16553 *
16554 * @static
16555 * @memberOf _
16556 * @since 4.0.0
16557 * @category Math
16558 * @param {number} minuend The first number in a subtraction.
16559 * @param {number} subtrahend The second number in a subtraction.
16560 * @returns {number} Returns the difference.
16561 * @example
16562 *
16563 * _.subtract(6, 4);
16564 * // => 2
16565 */
16566 var subtract = createMathOperation(function(minuend, subtrahend) {
16567 return minuend - subtrahend;
16568 }, 0);
16569
16570 /**
16571 * Computes the sum of the values in `array`.
16572 *
16573 * @static
16574 * @memberOf _
16575 * @since 3.4.0
16576 * @category Math
16577 * @param {Array} array The array to iterate over.
16578 * @returns {number} Returns the sum.
16579 * @example
16580 *
16581 * _.sum([4, 2, 8, 6]);
16582 * // => 20
16583 */
16584 function sum(array) {
16585 return (array && array.length)
16586 ? baseSum(array, identity)
16587 : 0;
16588 }
16589
16590 /**
16591 * This method is like `_.sum` except that it accepts `iteratee` which is
16592 * invoked for each element in `array` to generate the value to be summed.
16593 * The iteratee is invoked with one argument: (value).
16594 *
16595 * @static
16596 * @memberOf _
16597 * @since 4.0.0
16598 * @category Math
16599 * @param {Array} array The array to iterate over.
16600 * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
16601 * @returns {number} Returns the sum.
16602 * @example
16603 *
16604 * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
16605 *
16606 * _.sumBy(objects, function(o) { return o.n; });
16607 * // => 20
16608 *
16609 * // The `_.property` iteratee shorthand.
16610 * _.sumBy(objects, 'n');
16611 * // => 20
16612 */
16613 function sumBy(array, iteratee) {
16614 return (array && array.length)
16615 ? baseSum(array, getIteratee(iteratee, 2))
16616 : 0;
16617 }
16618
16619 /*------------------------------------------------------------------------*/
16620
16621 // Add methods that return wrapped values in chain sequences.
16622 lodash.after = after;
16623 lodash.ary = ary;
16624 lodash.assign = assign;
16625 lodash.assignIn = assignIn;
16626 lodash.assignInWith = assignInWith;
16627 lodash.assignWith = assignWith;
16628 lodash.at = at;
16629 lodash.before = before;
16630 lodash.bind = bind;
16631 lodash.bindAll = bindAll;
16632 lodash.bindKey = bindKey;
16633 lodash.castArray = castArray;
16634 lodash.chain = chain;
16635 lodash.chunk = chunk;
16636 lodash.compact = compact;
16637 lodash.concat = concat;
16638 lodash.cond = cond;
16639 lodash.conforms = conforms;
16640 lodash.constant = constant;
16641 lodash.countBy = countBy;
16642 lodash.create = create;
16643 lodash.curry = curry;
16644 lodash.curryRight = curryRight;
16645 lodash.debounce = debounce;
16646 lodash.defaults = defaults;
16647 lodash.defaultsDeep = defaultsDeep;
16648 lodash.defer = defer;
16649 lodash.delay = delay;
16650 lodash.difference = difference;
16651 lodash.differenceBy = differenceBy;
16652 lodash.differenceWith = differenceWith;
16653 lodash.drop = drop;
16654 lodash.dropRight = dropRight;
16655 lodash.dropRightWhile = dropRightWhile;
16656 lodash.dropWhile = dropWhile;
16657 lodash.fill = fill;
16658 lodash.filter = filter;
16659 lodash.flatMap = flatMap;
16660 lodash.flatMapDeep = flatMapDeep;
16661 lodash.flatMapDepth = flatMapDepth;
16662 lodash.flatten = flatten;
16663 lodash.flattenDeep = flattenDeep;
16664 lodash.flattenDepth = flattenDepth;
16665 lodash.flip = flip;
16666 lodash.flow = flow;
16667 lodash.flowRight = flowRight;
16668 lodash.fromPairs = fromPairs;
16669 lodash.functions = functions;
16670 lodash.functionsIn = functionsIn;
16671 lodash.groupBy = groupBy;
16672 lodash.initial = initial;
16673 lodash.intersection = intersection;
16674 lodash.intersectionBy = intersectionBy;
16675 lodash.intersectionWith = intersectionWith;
16676 lodash.invert = invert;
16677 lodash.invertBy = invertBy;
16678 lodash.invokeMap = invokeMap;
16679 lodash.iteratee = iteratee;
16680 lodash.keyBy = keyBy;
16681 lodash.keys = keys;
16682 lodash.keysIn = keysIn;
16683 lodash.map = map;
16684 lodash.mapKeys = mapKeys;
16685 lodash.mapValues = mapValues;
16686 lodash.matches = matches;
16687 lodash.matchesProperty = matchesProperty;
16688 lodash.memoize = memoize;
16689 lodash.merge = merge;
16690 lodash.mergeWith = mergeWith;
16691 lodash.method = method;
16692 lodash.methodOf = methodOf;
16693 lodash.mixin = mixin;
16694 lodash.negate = negate;
16695 lodash.nthArg = nthArg;
16696 lodash.omit = omit;
16697 lodash.omitBy = omitBy;
16698 lodash.once = once;
16699 lodash.orderBy = orderBy;
16700 lodash.over = over;
16701 lodash.overArgs = overArgs;
16702 lodash.overEvery = overEvery;
16703 lodash.overSome = overSome;
16704 lodash.partial = partial;
16705 lodash.partialRight = partialRight;
16706 lodash.partition = partition;
16707 lodash.pick = pick;
16708 lodash.pickBy = pickBy;
16709 lodash.property = property;
16710 lodash.propertyOf = propertyOf;
16711 lodash.pull = pull;
16712 lodash.pullAll = pullAll;
16713 lodash.pullAllBy = pullAllBy;
16714 lodash.pullAllWith = pullAllWith;
16715 lodash.pullAt = pullAt;
16716 lodash.range = range;
16717 lodash.rangeRight = rangeRight;
16718 lodash.rearg = rearg;
16719 lodash.reject = reject;
16720 lodash.remove = remove;
16721 lodash.rest = rest;
16722 lodash.reverse = reverse;
16723 lodash.sampleSize = sampleSize;
16724 lodash.set = set;
16725 lodash.setWith = setWith;
16726 lodash.shuffle = shuffle;
16727 lodash.slice = slice;
16728 lodash.sortBy = sortBy;
16729 lodash.sortedUniq = sortedUniq;
16730 lodash.sortedUniqBy = sortedUniqBy;
16731 lodash.split = split;
16732 lodash.spread = spread;
16733 lodash.tail = tail;
16734 lodash.take = take;
16735 lodash.takeRight = takeRight;
16736 lodash.takeRightWhile = takeRightWhile;
16737 lodash.takeWhile = takeWhile;
16738 lodash.tap = tap;
16739 lodash.throttle = throttle;
16740 lodash.thru = thru;
16741 lodash.toArray = toArray;
16742 lodash.toPairs = toPairs;
16743 lodash.toPairsIn = toPairsIn;
16744 lodash.toPath = toPath;
16745 lodash.toPlainObject = toPlainObject;
16746 lodash.transform = transform;
16747 lodash.unary = unary;
16748 lodash.union = union;
16749 lodash.unionBy = unionBy;
16750 lodash.unionWith = unionWith;
16751 lodash.uniq = uniq;
16752 lodash.uniqBy = uniqBy;
16753 lodash.uniqWith = uniqWith;
16754 lodash.unset = unset;
16755 lodash.unzip = unzip;
16756 lodash.unzipWith = unzipWith;
16757 lodash.update = update;
16758 lodash.updateWith = updateWith;
16759 lodash.values = values;
16760 lodash.valuesIn = valuesIn;
16761 lodash.without = without;
16762 lodash.words = words;
16763 lodash.wrap = wrap;
16764 lodash.xor = xor;
16765 lodash.xorBy = xorBy;
16766 lodash.xorWith = xorWith;
16767 lodash.zip = zip;
16768 lodash.zipObject = zipObject;
16769 lodash.zipObjectDeep = zipObjectDeep;
16770 lodash.zipWith = zipWith;
16771
16772 // Add aliases.
16773 lodash.entries = toPairs;
16774 lodash.entriesIn = toPairsIn;
16775 lodash.extend = assignIn;
16776 lodash.extendWith = assignInWith;
16777
16778 // Add methods to `lodash.prototype`.
16779 mixin(lodash, lodash);
16780
16781 /*------------------------------------------------------------------------*/
16782
16783 // Add methods that return unwrapped values in chain sequences.
16784 lodash.add = add;
16785 lodash.attempt = attempt;
16786 lodash.camelCase = camelCase;
16787 lodash.capitalize = capitalize;
16788 lodash.ceil = ceil;
16789 lodash.clamp = clamp;
16790 lodash.clone = clone;
16791 lodash.cloneDeep = cloneDeep;
16792 lodash.cloneDeepWith = cloneDeepWith;
16793 lodash.cloneWith = cloneWith;
16794 lodash.conformsTo = conformsTo;
16795 lodash.deburr = deburr;
16796 lodash.defaultTo = defaultTo;
16797 lodash.divide = divide;
16798 lodash.endsWith = endsWith;
16799 lodash.eq = eq;
16800 lodash.escape = escape;
16801 lodash.escapeRegExp = escapeRegExp;
16802 lodash.every = every;
16803 lodash.find = find;
16804 lodash.findIndex = findIndex;
16805 lodash.findKey = findKey;
16806 lodash.findLast = findLast;
16807 lodash.findLastIndex = findLastIndex;
16808 lodash.findLastKey = findLastKey;
16809 lodash.floor = floor;
16810 lodash.forEach = forEach;
16811 lodash.forEachRight = forEachRight;
16812 lodash.forIn = forIn;
16813 lodash.forInRight = forInRight;
16814 lodash.forOwn = forOwn;
16815 lodash.forOwnRight = forOwnRight;
16816 lodash.get = get;
16817 lodash.gt = gt;
16818 lodash.gte = gte;
16819 lodash.has = has;
16820 lodash.hasIn = hasIn;
16821 lodash.head = head;
16822 lodash.identity = identity;
16823 lodash.includes = includes;
16824 lodash.indexOf = indexOf;
16825 lodash.inRange = inRange;
16826 lodash.invoke = invoke;
16827 lodash.isArguments = isArguments;
16828 lodash.isArray = isArray;
16829 lodash.isArrayBuffer = isArrayBuffer;
16830 lodash.isArrayLike = isArrayLike;
16831 lodash.isArrayLikeObject = isArrayLikeObject;
16832 lodash.isBoolean = isBoolean;
16833 lodash.isBuffer = isBuffer;
16834 lodash.isDate = isDate;
16835 lodash.isElement = isElement;
16836 lodash.isEmpty = isEmpty;
16837 lodash.isEqual = isEqual;
16838 lodash.isEqualWith = isEqualWith;
16839 lodash.isError = isError;
16840 lodash.isFinite = isFinite;
16841 lodash.isFunction = isFunction;
16842 lodash.isInteger = isInteger;
16843 lodash.isLength = isLength;
16844 lodash.isMap = isMap;
16845 lodash.isMatch = isMatch;
16846 lodash.isMatchWith = isMatchWith;
16847 lodash.isNaN = isNaN;
16848 lodash.isNative = isNative;
16849 lodash.isNil = isNil;
16850 lodash.isNull = isNull;
16851 lodash.isNumber = isNumber;
16852 lodash.isObject = isObject;
16853 lodash.isObjectLike = isObjectLike;
16854 lodash.isPlainObject = isPlainObject;
16855 lodash.isRegExp = isRegExp;
16856 lodash.isSafeInteger = isSafeInteger;
16857 lodash.isSet = isSet;
16858 lodash.isString = isString;
16859 lodash.isSymbol = isSymbol;
16860 lodash.isTypedArray = isTypedArray;
16861 lodash.isUndefined = isUndefined;
16862 lodash.isWeakMap = isWeakMap;
16863 lodash.isWeakSet = isWeakSet;
16864 lodash.join = join;
16865 lodash.kebabCase = kebabCase;
16866 lodash.last = last;
16867 lodash.lastIndexOf = lastIndexOf;
16868 lodash.lowerCase = lowerCase;
16869 lodash.lowerFirst = lowerFirst;
16870 lodash.lt = lt;
16871 lodash.lte = lte;
16872 lodash.max = max;
16873 lodash.maxBy = maxBy;
16874 lodash.mean = mean;
16875 lodash.meanBy = meanBy;
16876 lodash.min = min;
16877 lodash.minBy = minBy;
16878 lodash.stubArray = stubArray;
16879 lodash.stubFalse = stubFalse;
16880 lodash.stubObject = stubObject;
16881 lodash.stubString = stubString;
16882 lodash.stubTrue = stubTrue;
16883 lodash.multiply = multiply;
16884 lodash.nth = nth;
16885 lodash.noConflict = noConflict;
16886 lodash.noop = noop;
16887 lodash.now = now;
16888 lodash.pad = pad;
16889 lodash.padEnd = padEnd;
16890 lodash.padStart = padStart;
16891 lodash.parseInt = parseInt;
16892 lodash.random = random;
16893 lodash.reduce = reduce;
16894 lodash.reduceRight = reduceRight;
16895 lodash.repeat = repeat;
16896 lodash.replace = replace;
16897 lodash.result = result;
16898 lodash.round = round;
16899 lodash.runInContext = runInContext;
16900 lodash.sample = sample;
16901 lodash.size = size;
16902 lodash.snakeCase = snakeCase;
16903 lodash.some = some;
16904 lodash.sortedIndex = sortedIndex;
16905 lodash.sortedIndexBy = sortedIndexBy;
16906 lodash.sortedIndexOf = sortedIndexOf;
16907 lodash.sortedLastIndex = sortedLastIndex;
16908 lodash.sortedLastIndexBy = sortedLastIndexBy;
16909 lodash.sortedLastIndexOf = sortedLastIndexOf;
16910 lodash.startCase = startCase;
16911 lodash.startsWith = startsWith;
16912 lodash.subtract = subtract;
16913 lodash.sum = sum;
16914 lodash.sumBy = sumBy;
16915 lodash.template = template;
16916 lodash.times = times;
16917 lodash.toFinite = toFinite;
16918 lodash.toInteger = toInteger;
16919 lodash.toLength = toLength;
16920 lodash.toLower = toLower;
16921 lodash.toNumber = toNumber;
16922 lodash.toSafeInteger = toSafeInteger;
16923 lodash.toString = toString;
16924 lodash.toUpper = toUpper;
16925 lodash.trim = trim;
16926 lodash.trimEnd = trimEnd;
16927 lodash.trimStart = trimStart;
16928 lodash.truncate = truncate;
16929 lodash.unescape = unescape;
16930 lodash.uniqueId = uniqueId;
16931 lodash.upperCase = upperCase;
16932 lodash.upperFirst = upperFirst;
16933
16934 // Add aliases.
16935 lodash.each = forEach;
16936 lodash.eachRight = forEachRight;
16937 lodash.first = head;
16938
16939 mixin(lodash, (function() {
16940 var source = {};
16941 baseForOwn(lodash, function(func, methodName) {
16942 if (!hasOwnProperty.call(lodash.prototype, methodName)) {
16943 source[methodName] = func;
16944 }
16945 });
16946 return source;
16947 }()), { 'chain': false });
16948
16949 /*------------------------------------------------------------------------*/
16950
16951 /**
16952 * The semantic version number.
16953 *
16954 * @static
16955 * @memberOf _
16956 * @type {string}
16957 */
16958 lodash.VERSION = VERSION;
16959
16960 // Assign default placeholders.
16961 arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
16962 lodash[methodName].placeholder = lodash;
16963 });
16964
16965 // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
16966 arrayEach(['drop', 'take'], function(methodName, index) {
16967 LazyWrapper.prototype[methodName] = function(n) {
16968 n = n === undefined ? 1 : nativeMax(toInteger(n), 0);
16969
16970 var result = (this.__filtered__ && !index)
16971 ? new LazyWrapper(this)
16972 : this.clone();
16973
16974 if (result.__filtered__) {
16975 result.__takeCount__ = nativeMin(n, result.__takeCount__);
16976 } else {
16977 result.__views__.push({
16978 'size': nativeMin(n, MAX_ARRAY_LENGTH),
16979 'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
16980 });
16981 }
16982 return result;
16983 };
16984
16985 LazyWrapper.prototype[methodName + 'Right'] = function(n) {
16986 return this.reverse()[methodName](n).reverse();
16987 };
16988 });
16989
16990 // Add `LazyWrapper` methods that accept an `iteratee` value.
16991 arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
16992 var type = index + 1,
16993 isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
16994
16995 LazyWrapper.prototype[methodName] = function(iteratee) {
16996 var result = this.clone();
16997 result.__iteratees__.push({
16998 'iteratee': getIteratee(iteratee, 3),
16999 'type': type
17000 });
17001 result.__filtered__ = result.__filtered__ || isFilter;
17002 return result;
17003 };
17004 });
17005
17006 // Add `LazyWrapper` methods for `_.head` and `_.last`.
17007 arrayEach(['head', 'last'], function(methodName, index) {
17008 var takeName = 'take' + (index ? 'Right' : '');
17009
17010 LazyWrapper.prototype[methodName] = function() {
17011 return this[takeName](1).value()[0];
17012 };
17013 });
17014
17015 // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
17016 arrayEach(['initial', 'tail'], function(methodName, index) {
17017 var dropName = 'drop' + (index ? '' : 'Right');
17018
17019 LazyWrapper.prototype[methodName] = function() {
17020 return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
17021 };
17022 });
17023
17024 LazyWrapper.prototype.compact = function() {
17025 return this.filter(identity);
17026 };
17027
17028 LazyWrapper.prototype.find = function(predicate) {
17029 return this.filter(predicate).head();
17030 };
17031
17032 LazyWrapper.prototype.findLast = function(predicate) {
17033 return this.reverse().find(predicate);
17034 };
17035
17036 LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
17037 if (typeof path == 'function') {
17038 return new LazyWrapper(this);
17039 }
17040 return this.map(function(value) {
17041 return baseInvoke(value, path, args);
17042 });
17043 });
17044
17045 LazyWrapper.prototype.reject = function(predicate) {
17046 return this.filter(negate(getIteratee(predicate)));
17047 };
17048
17049 LazyWrapper.prototype.slice = function(start, end) {
17050 start = toInteger(start);
17051
17052 var result = this;
17053 if (result.__filtered__ && (start > 0 || end < 0)) {
17054 return new LazyWrapper(result);
17055 }
17056 if (start < 0) {
17057 result = result.takeRight(-start);
17058 } else if (start) {
17059 result = result.drop(start);
17060 }
17061 if (end !== undefined) {
17062 end = toInteger(end);
17063 result = end < 0 ? result.dropRight(-end) : result.take(end - start);
17064 }
17065 return result;
17066 };
17067
17068 LazyWrapper.prototype.takeRightWhile = function(predicate) {
17069 return this.reverse().takeWhile(predicate).reverse();
17070 };
17071
17072 LazyWrapper.prototype.toArray = function() {
17073 return this.take(MAX_ARRAY_LENGTH);
17074 };
17075
17076 // Add `LazyWrapper` methods to `lodash.prototype`.
17077 baseForOwn(LazyWrapper.prototype, function(func, methodName) {
17078 var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
17079 isTaker = /^(?:head|last)$/.test(methodName),
17080 lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
17081 retUnwrapped = isTaker || /^find/.test(methodName);
17082
17083 if (!lodashFunc) {
17084 return;
17085 }
17086 lodash.prototype[methodName] = function() {
17087 var value = this.__wrapped__,
17088 args = isTaker ? [1] : arguments,
17089 isLazy = value instanceof LazyWrapper,
17090 iteratee = args[0],
17091 useLazy = isLazy || isArray(value);
17092
17093 var interceptor = function(value) {
17094 var result = lodashFunc.apply(lodash, arrayPush([value], args));
17095 return (isTaker && chainAll) ? result[0] : result;
17096 };
17097
17098 if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
17099 // Avoid lazy use if the iteratee has a "length" value other than `1`.
17100 isLazy = useLazy = false;
17101 }
17102 var chainAll = this.__chain__,
17103 isHybrid = !!this.__actions__.length,
17104 isUnwrapped = retUnwrapped && !chainAll,
17105 onlyLazy = isLazy && !isHybrid;
17106
17107 if (!retUnwrapped && useLazy) {
17108 value = onlyLazy ? value : new LazyWrapper(this);
17109 var result = func.apply(value, args);
17110 result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
17111 return new LodashWrapper(result, chainAll);
17112 }
17113 if (isUnwrapped && onlyLazy) {
17114 return func.apply(this, args);
17115 }
17116 result = this.thru(interceptor);
17117 return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
17118 };
17119 });
17120
17121 // Add `Array` methods to `lodash.prototype`.
17122 arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
17123 var func = arrayProto[methodName],
17124 chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
17125 retUnwrapped = /^(?:pop|shift)$/.test(methodName);
17126
17127 lodash.prototype[methodName] = function() {
17128 var args = arguments;
17129 if (retUnwrapped && !this.__chain__) {
17130 var value = this.value();
17131 return func.apply(isArray(value) ? value : [], args);
17132 }
17133 return this[chainName](function(value) {
17134 return func.apply(isArray(value) ? value : [], args);
17135 });
17136 };
17137 });
17138
17139 // Map minified method names to their real names.
17140 baseForOwn(LazyWrapper.prototype, function(func, methodName) {
17141 var lodashFunc = lodash[methodName];
17142 if (lodashFunc) {
17143 var key = lodashFunc.name + '';
17144 if (!hasOwnProperty.call(realNames, key)) {
17145 realNames[key] = [];
17146 }
17147 realNames[key].push({ 'name': methodName, 'func': lodashFunc });
17148 }
17149 });
17150
17151 realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
17152 'name': 'wrapper',
17153 'func': undefined
17154 }];
17155
17156 // Add methods to `LazyWrapper`.
17157 LazyWrapper.prototype.clone = lazyClone;
17158 LazyWrapper.prototype.reverse = lazyReverse;
17159 LazyWrapper.prototype.value = lazyValue;
17160
17161 // Add chain sequence methods to the `lodash` wrapper.
17162 lodash.prototype.at = wrapperAt;
17163 lodash.prototype.chain = wrapperChain;
17164 lodash.prototype.commit = wrapperCommit;
17165 lodash.prototype.next = wrapperNext;
17166 lodash.prototype.plant = wrapperPlant;
17167 lodash.prototype.reverse = wrapperReverse;
17168 lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
17169
17170 // Add lazy aliases.
17171 lodash.prototype.first = lodash.prototype.head;
17172
17173 if (symIterator) {
17174 lodash.prototype[symIterator] = wrapperToIterator;
17175 }
17176 return lodash;
17177 });
17178
17179 /*--------------------------------------------------------------------------*/
17180
17181 // Export lodash.
17182 var _ = runInContext();
17183
17184 // Some AMD build optimizers, like r.js, check for condition patterns like:
17185 if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
17186 // Expose Lodash on the global object to prevent errors when Lodash is
17187 // loaded by a script tag in the presence of an AMD loader.
17188 // See http://requirejs.org/docs/errors.html#mismatch for more details.
17189 // Use `_.noConflict` to remove Lodash from the global object.
17190 root._ = _;
17191
17192 // Define as an anonymous module so, through path mapping, it can be
17193 // referenced as the "underscore" module.
17194 define(function() {
17195 return _;
17196 });
17197 }
17198 // Check for `exports` after `define` in case a build optimizer adds it.
17199 else if (freeModule) {
17200 // Export for Node.js.
17201 (freeModule.exports = _)._ = _;
17202 // Export for CommonJS support.
17203 freeExports._ = _;
17204 }
17205 else {
17206 // Export to the global object.
17207 root._ = _;
17208 }
17209}.call(this));
17210