Newer
Older
urbanLifeline_YanAn / public / static / libs / lodash / lodash.js
@wudi wudi on 20 Oct 547 KB 1
  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. '&': '&amp;',
  400. '<': '&lt;',
  401. '>': '&gt;',
  402. '"': '&quot;',
  403. "'": '&#39;'
  404. };
  405.  
  406. /** Used to map HTML entities to characters. */
  407. var htmlUnescapes = {
  408. '&amp;': '&',
  409. '&lt;': '<',
  410. '&gt;': '>',
  411. '&quot;': '"',
  412. '&#39;': "'"
  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, &amp; 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, &amp; 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>&lt;script&gt;</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. * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` 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, &amp; 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. return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
  16271. }
  16272.  
  16273. /*------------------------------------------------------------------------*/
  16274.  
  16275. /**
  16276. * Adds two numbers.
  16277. *
  16278. * @static
  16279. * @memberOf _
  16280. * @since 3.4.0
  16281. * @category Math
  16282. * @param {number} augend The first number in an addition.
  16283. * @param {number} addend The second number in an addition.
  16284. * @returns {number} Returns the total.
  16285. * @example
  16286. *
  16287. * _.add(6, 4);
  16288. * // => 10
  16289. */
  16290. var add = createMathOperation(function(augend, addend) {
  16291. return augend + addend;
  16292. }, 0);
  16293.  
  16294. /**
  16295. * Computes `number` rounded up to `precision`.
  16296. *
  16297. * @static
  16298. * @memberOf _
  16299. * @since 3.10.0
  16300. * @category Math
  16301. * @param {number} number The number to round up.
  16302. * @param {number} [precision=0] The precision to round up to.
  16303. * @returns {number} Returns the rounded up number.
  16304. * @example
  16305. *
  16306. * _.ceil(4.006);
  16307. * // => 5
  16308. *
  16309. * _.ceil(6.004, 2);
  16310. * // => 6.01
  16311. *
  16312. * _.ceil(6040, -2);
  16313. * // => 6100
  16314. */
  16315. var ceil = createRound('ceil');
  16316.  
  16317. /**
  16318. * Divide two numbers.
  16319. *
  16320. * @static
  16321. * @memberOf _
  16322. * @since 4.7.0
  16323. * @category Math
  16324. * @param {number} dividend The first number in a division.
  16325. * @param {number} divisor The second number in a division.
  16326. * @returns {number} Returns the quotient.
  16327. * @example
  16328. *
  16329. * _.divide(6, 4);
  16330. * // => 1.5
  16331. */
  16332. var divide = createMathOperation(function(dividend, divisor) {
  16333. return dividend / divisor;
  16334. }, 1);
  16335.  
  16336. /**
  16337. * Computes `number` rounded down to `precision`.
  16338. *
  16339. * @static
  16340. * @memberOf _
  16341. * @since 3.10.0
  16342. * @category Math
  16343. * @param {number} number The number to round down.
  16344. * @param {number} [precision=0] The precision to round down to.
  16345. * @returns {number} Returns the rounded down number.
  16346. * @example
  16347. *
  16348. * _.floor(4.006);
  16349. * // => 4
  16350. *
  16351. * _.floor(0.046, 2);
  16352. * // => 0.04
  16353. *
  16354. * _.floor(4060, -2);
  16355. * // => 4000
  16356. */
  16357. var floor = createRound('floor');
  16358.  
  16359. /**
  16360. * Computes the maximum value of `array`. If `array` is empty or falsey,
  16361. * `undefined` is returned.
  16362. *
  16363. * @static
  16364. * @since 0.1.0
  16365. * @memberOf _
  16366. * @category Math
  16367. * @param {Array} array The array to iterate over.
  16368. * @returns {*} Returns the maximum value.
  16369. * @example
  16370. *
  16371. * _.max([4, 2, 8, 6]);
  16372. * // => 8
  16373. *
  16374. * _.max([]);
  16375. * // => undefined
  16376. */
  16377. function max(array) {
  16378. return (array && array.length)
  16379. ? baseExtremum(array, identity, baseGt)
  16380. : undefined;
  16381. }
  16382.  
  16383. /**
  16384. * This method is like `_.max` except that it accepts `iteratee` which is
  16385. * invoked for each element in `array` to generate the criterion by which
  16386. * the value is ranked. The iteratee is invoked with one argument: (value).
  16387. *
  16388. * @static
  16389. * @memberOf _
  16390. * @since 4.0.0
  16391. * @category Math
  16392. * @param {Array} array The array to iterate over.
  16393. * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
  16394. * @returns {*} Returns the maximum value.
  16395. * @example
  16396. *
  16397. * var objects = [{ 'n': 1 }, { 'n': 2 }];
  16398. *
  16399. * _.maxBy(objects, function(o) { return o.n; });
  16400. * // => { 'n': 2 }
  16401. *
  16402. * // The `_.property` iteratee shorthand.
  16403. * _.maxBy(objects, 'n');
  16404. * // => { 'n': 2 }
  16405. */
  16406. function maxBy(array, iteratee) {
  16407. return (array && array.length)
  16408. ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
  16409. : undefined;
  16410. }
  16411.  
  16412. /**
  16413. * Computes the mean of the values in `array`.
  16414. *
  16415. * @static
  16416. * @memberOf _
  16417. * @since 4.0.0
  16418. * @category Math
  16419. * @param {Array} array The array to iterate over.
  16420. * @returns {number} Returns the mean.
  16421. * @example
  16422. *
  16423. * _.mean([4, 2, 8, 6]);
  16424. * // => 5
  16425. */
  16426. function mean(array) {
  16427. return baseMean(array, identity);
  16428. }
  16429.  
  16430. /**
  16431. * This method is like `_.mean` except that it accepts `iteratee` which is
  16432. * invoked for each element in `array` to generate the value to be averaged.
  16433. * The iteratee is invoked with one argument: (value).
  16434. *
  16435. * @static
  16436. * @memberOf _
  16437. * @since 4.7.0
  16438. * @category Math
  16439. * @param {Array} array The array to iterate over.
  16440. * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
  16441. * @returns {number} Returns the mean.
  16442. * @example
  16443. *
  16444. * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
  16445. *
  16446. * _.meanBy(objects, function(o) { return o.n; });
  16447. * // => 5
  16448. *
  16449. * // The `_.property` iteratee shorthand.
  16450. * _.meanBy(objects, 'n');
  16451. * // => 5
  16452. */
  16453. function meanBy(array, iteratee) {
  16454. return baseMean(array, getIteratee(iteratee, 2));
  16455. }
  16456.  
  16457. /**
  16458. * Computes the minimum value of `array`. If `array` is empty or falsey,
  16459. * `undefined` is returned.
  16460. *
  16461. * @static
  16462. * @since 0.1.0
  16463. * @memberOf _
  16464. * @category Math
  16465. * @param {Array} array The array to iterate over.
  16466. * @returns {*} Returns the minimum value.
  16467. * @example
  16468. *
  16469. * _.min([4, 2, 8, 6]);
  16470. * // => 2
  16471. *
  16472. * _.min([]);
  16473. * // => undefined
  16474. */
  16475. function min(array) {
  16476. return (array && array.length)
  16477. ? baseExtremum(array, identity, baseLt)
  16478. : undefined;
  16479. }
  16480.  
  16481. /**
  16482. * This method is like `_.min` except that it accepts `iteratee` which is
  16483. * invoked for each element in `array` to generate the criterion by which
  16484. * the value is ranked. The iteratee is invoked with one argument: (value).
  16485. *
  16486. * @static
  16487. * @memberOf _
  16488. * @since 4.0.0
  16489. * @category Math
  16490. * @param {Array} array The array to iterate over.
  16491. * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
  16492. * @returns {*} Returns the minimum value.
  16493. * @example
  16494. *
  16495. * var objects = [{ 'n': 1 }, { 'n': 2 }];
  16496. *
  16497. * _.minBy(objects, function(o) { return o.n; });
  16498. * // => { 'n': 1 }
  16499. *
  16500. * // The `_.property` iteratee shorthand.
  16501. * _.minBy(objects, 'n');
  16502. * // => { 'n': 1 }
  16503. */
  16504. function minBy(array, iteratee) {
  16505. return (array && array.length)
  16506. ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
  16507. : undefined;
  16508. }
  16509.  
  16510. /**
  16511. * Multiply two numbers.
  16512. *
  16513. * @static
  16514. * @memberOf _
  16515. * @since 4.7.0
  16516. * @category Math
  16517. * @param {number} multiplier The first number in a multiplication.
  16518. * @param {number} multiplicand The second number in a multiplication.
  16519. * @returns {number} Returns the product.
  16520. * @example
  16521. *
  16522. * _.multiply(6, 4);
  16523. * // => 24
  16524. */
  16525. var multiply = createMathOperation(function(multiplier, multiplicand) {
  16526. return multiplier * multiplicand;
  16527. }, 1);
  16528.  
  16529. /**
  16530. * Computes `number` rounded to `precision`.
  16531. *
  16532. * @static
  16533. * @memberOf _
  16534. * @since 3.10.0
  16535. * @category Math
  16536. * @param {number} number The number to round.
  16537. * @param {number} [precision=0] The precision to round to.
  16538. * @returns {number} Returns the rounded number.
  16539. * @example
  16540. *
  16541. * _.round(4.006);
  16542. * // => 4
  16543. *
  16544. * _.round(4.006, 2);
  16545. * // => 4.01
  16546. *
  16547. * _.round(4060, -2);
  16548. * // => 4100
  16549. */
  16550. var round = createRound('round');
  16551.  
  16552. /**
  16553. * Subtract two numbers.
  16554. *
  16555. * @static
  16556. * @memberOf _
  16557. * @since 4.0.0
  16558. * @category Math
  16559. * @param {number} minuend The first number in a subtraction.
  16560. * @param {number} subtrahend The second number in a subtraction.
  16561. * @returns {number} Returns the difference.
  16562. * @example
  16563. *
  16564. * _.subtract(6, 4);
  16565. * // => 2
  16566. */
  16567. var subtract = createMathOperation(function(minuend, subtrahend) {
  16568. return minuend - subtrahend;
  16569. }, 0);
  16570.  
  16571. /**
  16572. * Computes the sum of the values in `array`.
  16573. *
  16574. * @static
  16575. * @memberOf _
  16576. * @since 3.4.0
  16577. * @category Math
  16578. * @param {Array} array The array to iterate over.
  16579. * @returns {number} Returns the sum.
  16580. * @example
  16581. *
  16582. * _.sum([4, 2, 8, 6]);
  16583. * // => 20
  16584. */
  16585. function sum(array) {
  16586. return (array && array.length)
  16587. ? baseSum(array, identity)
  16588. : 0;
  16589. }
  16590.  
  16591. /**
  16592. * This method is like `_.sum` except that it accepts `iteratee` which is
  16593. * invoked for each element in `array` to generate the value to be summed.
  16594. * The iteratee is invoked with one argument: (value).
  16595. *
  16596. * @static
  16597. * @memberOf _
  16598. * @since 4.0.0
  16599. * @category Math
  16600. * @param {Array} array The array to iterate over.
  16601. * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
  16602. * @returns {number} Returns the sum.
  16603. * @example
  16604. *
  16605. * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
  16606. *
  16607. * _.sumBy(objects, function(o) { return o.n; });
  16608. * // => 20
  16609. *
  16610. * // The `_.property` iteratee shorthand.
  16611. * _.sumBy(objects, 'n');
  16612. * // => 20
  16613. */
  16614. function sumBy(array, iteratee) {
  16615. return (array && array.length)
  16616. ? baseSum(array, getIteratee(iteratee, 2))
  16617. : 0;
  16618. }
  16619.  
  16620. /*------------------------------------------------------------------------*/
  16621.  
  16622. // Add methods that return wrapped values in chain sequences.
  16623. lodash.after = after;
  16624. lodash.ary = ary;
  16625. lodash.assign = assign;
  16626. lodash.assignIn = assignIn;
  16627. lodash.assignInWith = assignInWith;
  16628. lodash.assignWith = assignWith;
  16629. lodash.at = at;
  16630. lodash.before = before;
  16631. lodash.bind = bind;
  16632. lodash.bindAll = bindAll;
  16633. lodash.bindKey = bindKey;
  16634. lodash.castArray = castArray;
  16635. lodash.chain = chain;
  16636. lodash.chunk = chunk;
  16637. lodash.compact = compact;
  16638. lodash.concat = concat;
  16639. lodash.cond = cond;
  16640. lodash.conforms = conforms;
  16641. lodash.constant = constant;
  16642. lodash.countBy = countBy;
  16643. lodash.create = create;
  16644. lodash.curry = curry;
  16645. lodash.curryRight = curryRight;
  16646. lodash.debounce = debounce;
  16647. lodash.defaults = defaults;
  16648. lodash.defaultsDeep = defaultsDeep;
  16649. lodash.defer = defer;
  16650. lodash.delay = delay;
  16651. lodash.difference = difference;
  16652. lodash.differenceBy = differenceBy;
  16653. lodash.differenceWith = differenceWith;
  16654. lodash.drop = drop;
  16655. lodash.dropRight = dropRight;
  16656. lodash.dropRightWhile = dropRightWhile;
  16657. lodash.dropWhile = dropWhile;
  16658. lodash.fill = fill;
  16659. lodash.filter = filter;
  16660. lodash.flatMap = flatMap;
  16661. lodash.flatMapDeep = flatMapDeep;
  16662. lodash.flatMapDepth = flatMapDepth;
  16663. lodash.flatten = flatten;
  16664. lodash.flattenDeep = flattenDeep;
  16665. lodash.flattenDepth = flattenDepth;
  16666. lodash.flip = flip;
  16667. lodash.flow = flow;
  16668. lodash.flowRight = flowRight;
  16669. lodash.fromPairs = fromPairs;
  16670. lodash.functions = functions;
  16671. lodash.functionsIn = functionsIn;
  16672. lodash.groupBy = groupBy;
  16673. lodash.initial = initial;
  16674. lodash.intersection = intersection;
  16675. lodash.intersectionBy = intersectionBy;
  16676. lodash.intersectionWith = intersectionWith;
  16677. lodash.invert = invert;
  16678. lodash.invertBy = invertBy;
  16679. lodash.invokeMap = invokeMap;
  16680. lodash.iteratee = iteratee;
  16681. lodash.keyBy = keyBy;
  16682. lodash.keys = keys;
  16683. lodash.keysIn = keysIn;
  16684. lodash.map = map;
  16685. lodash.mapKeys = mapKeys;
  16686. lodash.mapValues = mapValues;
  16687. lodash.matches = matches;
  16688. lodash.matchesProperty = matchesProperty;
  16689. lodash.memoize = memoize;
  16690. lodash.merge = merge;
  16691. lodash.mergeWith = mergeWith;
  16692. lodash.method = method;
  16693. lodash.methodOf = methodOf;
  16694. lodash.mixin = mixin;
  16695. lodash.negate = negate;
  16696. lodash.nthArg = nthArg;
  16697. lodash.omit = omit;
  16698. lodash.omitBy = omitBy;
  16699. lodash.once = once;
  16700. lodash.orderBy = orderBy;
  16701. lodash.over = over;
  16702. lodash.overArgs = overArgs;
  16703. lodash.overEvery = overEvery;
  16704. lodash.overSome = overSome;
  16705. lodash.partial = partial;
  16706. lodash.partialRight = partialRight;
  16707. lodash.partition = partition;
  16708. lodash.pick = pick;
  16709. lodash.pickBy = pickBy;
  16710. lodash.property = property;
  16711. lodash.propertyOf = propertyOf;
  16712. lodash.pull = pull;
  16713. lodash.pullAll = pullAll;
  16714. lodash.pullAllBy = pullAllBy;
  16715. lodash.pullAllWith = pullAllWith;
  16716. lodash.pullAt = pullAt;
  16717. lodash.range = range;
  16718. lodash.rangeRight = rangeRight;
  16719. lodash.rearg = rearg;
  16720. lodash.reject = reject;
  16721. lodash.remove = remove;
  16722. lodash.rest = rest;
  16723. lodash.reverse = reverse;
  16724. lodash.sampleSize = sampleSize;
  16725. lodash.set = set;
  16726. lodash.setWith = setWith;
  16727. lodash.shuffle = shuffle;
  16728. lodash.slice = slice;
  16729. lodash.sortBy = sortBy;
  16730. lodash.sortedUniq = sortedUniq;
  16731. lodash.sortedUniqBy = sortedUniqBy;
  16732. lodash.split = split;
  16733. lodash.spread = spread;
  16734. lodash.tail = tail;
  16735. lodash.take = take;
  16736. lodash.takeRight = takeRight;
  16737. lodash.takeRightWhile = takeRightWhile;
  16738. lodash.takeWhile = takeWhile;
  16739. lodash.tap = tap;
  16740. lodash.throttle = throttle;
  16741. lodash.thru = thru;
  16742. lodash.toArray = toArray;
  16743. lodash.toPairs = toPairs;
  16744. lodash.toPairsIn = toPairsIn;
  16745. lodash.toPath = toPath;
  16746. lodash.toPlainObject = toPlainObject;
  16747. lodash.transform = transform;
  16748. lodash.unary = unary;
  16749. lodash.union = union;
  16750. lodash.unionBy = unionBy;
  16751. lodash.unionWith = unionWith;
  16752. lodash.uniq = uniq;
  16753. lodash.uniqBy = uniqBy;
  16754. lodash.uniqWith = uniqWith;
  16755. lodash.unset = unset;
  16756. lodash.unzip = unzip;
  16757. lodash.unzipWith = unzipWith;
  16758. lodash.update = update;
  16759. lodash.updateWith = updateWith;
  16760. lodash.values = values;
  16761. lodash.valuesIn = valuesIn;
  16762. lodash.without = without;
  16763. lodash.words = words;
  16764. lodash.wrap = wrap;
  16765. lodash.xor = xor;
  16766. lodash.xorBy = xorBy;
  16767. lodash.xorWith = xorWith;
  16768. lodash.zip = zip;
  16769. lodash.zipObject = zipObject;
  16770. lodash.zipObjectDeep = zipObjectDeep;
  16771. lodash.zipWith = zipWith;
  16772.  
  16773. // Add aliases.
  16774. lodash.entries = toPairs;
  16775. lodash.entriesIn = toPairsIn;
  16776. lodash.extend = assignIn;
  16777. lodash.extendWith = assignInWith;
  16778.  
  16779. // Add methods to `lodash.prototype`.
  16780. mixin(lodash, lodash);
  16781.  
  16782. /*------------------------------------------------------------------------*/
  16783.  
  16784. // Add methods that return unwrapped values in chain sequences.
  16785. lodash.add = add;
  16786. lodash.attempt = attempt;
  16787. lodash.camelCase = camelCase;
  16788. lodash.capitalize = capitalize;
  16789. lodash.ceil = ceil;
  16790. lodash.clamp = clamp;
  16791. lodash.clone = clone;
  16792. lodash.cloneDeep = cloneDeep;
  16793. lodash.cloneDeepWith = cloneDeepWith;
  16794. lodash.cloneWith = cloneWith;
  16795. lodash.conformsTo = conformsTo;
  16796. lodash.deburr = deburr;
  16797. lodash.defaultTo = defaultTo;
  16798. lodash.divide = divide;
  16799. lodash.endsWith = endsWith;
  16800. lodash.eq = eq;
  16801. lodash.escape = escape;
  16802. lodash.escapeRegExp = escapeRegExp;
  16803. lodash.every = every;
  16804. lodash.find = find;
  16805. lodash.findIndex = findIndex;
  16806. lodash.findKey = findKey;
  16807. lodash.findLast = findLast;
  16808. lodash.findLastIndex = findLastIndex;
  16809. lodash.findLastKey = findLastKey;
  16810. lodash.floor = floor;
  16811. lodash.forEach = forEach;
  16812. lodash.forEachRight = forEachRight;
  16813. lodash.forIn = forIn;
  16814. lodash.forInRight = forInRight;
  16815. lodash.forOwn = forOwn;
  16816. lodash.forOwnRight = forOwnRight;
  16817. lodash.get = get;
  16818. lodash.gt = gt;
  16819. lodash.gte = gte;
  16820. lodash.has = has;
  16821. lodash.hasIn = hasIn;
  16822. lodash.head = head;
  16823. lodash.identity = identity;
  16824. lodash.includes = includes;
  16825. lodash.indexOf = indexOf;
  16826. lodash.inRange = inRange;
  16827. lodash.invoke = invoke;
  16828. lodash.isArguments = isArguments;
  16829. lodash.isArray = isArray;
  16830. lodash.isArrayBuffer = isArrayBuffer;
  16831. lodash.isArrayLike = isArrayLike;
  16832. lodash.isArrayLikeObject = isArrayLikeObject;
  16833. lodash.isBoolean = isBoolean;
  16834. lodash.isBuffer = isBuffer;
  16835. lodash.isDate = isDate;
  16836. lodash.isElement = isElement;
  16837. lodash.isEmpty = isEmpty;
  16838. lodash.isEqual = isEqual;
  16839. lodash.isEqualWith = isEqualWith;
  16840. lodash.isError = isError;
  16841. lodash.isFinite = isFinite;
  16842. lodash.isFunction = isFunction;
  16843. lodash.isInteger = isInteger;
  16844. lodash.isLength = isLength;
  16845. lodash.isMap = isMap;
  16846. lodash.isMatch = isMatch;
  16847. lodash.isMatchWith = isMatchWith;
  16848. lodash.isNaN = isNaN;
  16849. lodash.isNative = isNative;
  16850. lodash.isNil = isNil;
  16851. lodash.isNull = isNull;
  16852. lodash.isNumber = isNumber;
  16853. lodash.isObject = isObject;
  16854. lodash.isObjectLike = isObjectLike;
  16855. lodash.isPlainObject = isPlainObject;
  16856. lodash.isRegExp = isRegExp;
  16857. lodash.isSafeInteger = isSafeInteger;
  16858. lodash.isSet = isSet;
  16859. lodash.isString = isString;
  16860. lodash.isSymbol = isSymbol;
  16861. lodash.isTypedArray = isTypedArray;
  16862. lodash.isUndefined = isUndefined;
  16863. lodash.isWeakMap = isWeakMap;
  16864. lodash.isWeakSet = isWeakSet;
  16865. lodash.join = join;
  16866. lodash.kebabCase = kebabCase;
  16867. lodash.last = last;
  16868. lodash.lastIndexOf = lastIndexOf;
  16869. lodash.lowerCase = lowerCase;
  16870. lodash.lowerFirst = lowerFirst;
  16871. lodash.lt = lt;
  16872. lodash.lte = lte;
  16873. lodash.max = max;
  16874. lodash.maxBy = maxBy;
  16875. lodash.mean = mean;
  16876. lodash.meanBy = meanBy;
  16877. lodash.min = min;
  16878. lodash.minBy = minBy;
  16879. lodash.stubArray = stubArray;
  16880. lodash.stubFalse = stubFalse;
  16881. lodash.stubObject = stubObject;
  16882. lodash.stubString = stubString;
  16883. lodash.stubTrue = stubTrue;
  16884. lodash.multiply = multiply;
  16885. lodash.nth = nth;
  16886. lodash.noConflict = noConflict;
  16887. lodash.noop = noop;
  16888. lodash.now = now;
  16889. lodash.pad = pad;
  16890. lodash.padEnd = padEnd;
  16891. lodash.padStart = padStart;
  16892. lodash.parseInt = parseInt;
  16893. lodash.random = random;
  16894. lodash.reduce = reduce;
  16895. lodash.reduceRight = reduceRight;
  16896. lodash.repeat = repeat;
  16897. lodash.replace = replace;
  16898. lodash.result = result;
  16899. lodash.round = round;
  16900. lodash.runInContext = runInContext;
  16901. lodash.sample = sample;
  16902. lodash.size = size;
  16903. lodash.snakeCase = snakeCase;
  16904. lodash.some = some;
  16905. lodash.sortedIndex = sortedIndex;
  16906. lodash.sortedIndexBy = sortedIndexBy;
  16907. lodash.sortedIndexOf = sortedIndexOf;
  16908. lodash.sortedLastIndex = sortedLastIndex;
  16909. lodash.sortedLastIndexBy = sortedLastIndexBy;
  16910. lodash.sortedLastIndexOf = sortedLastIndexOf;
  16911. lodash.startCase = startCase;
  16912. lodash.startsWith = startsWith;
  16913. lodash.subtract = subtract;
  16914. lodash.sum = sum;
  16915. lodash.sumBy = sumBy;
  16916. lodash.template = template;
  16917. lodash.times = times;
  16918. lodash.toFinite = toFinite;
  16919. lodash.toInteger = toInteger;
  16920. lodash.toLength = toLength;
  16921. lodash.toLower = toLower;
  16922. lodash.toNumber = toNumber;
  16923. lodash.toSafeInteger = toSafeInteger;
  16924. lodash.toString = toString;
  16925. lodash.toUpper = toUpper;
  16926. lodash.trim = trim;
  16927. lodash.trimEnd = trimEnd;
  16928. lodash.trimStart = trimStart;
  16929. lodash.truncate = truncate;
  16930. lodash.unescape = unescape;
  16931. lodash.uniqueId = uniqueId;
  16932. lodash.upperCase = upperCase;
  16933. lodash.upperFirst = upperFirst;
  16934.  
  16935. // Add aliases.
  16936. lodash.each = forEach;
  16937. lodash.eachRight = forEachRight;
  16938. lodash.first = head;
  16939.  
  16940. mixin(lodash, (function() {
  16941. var source = {};
  16942. baseForOwn(lodash, function(func, methodName) {
  16943. if (!hasOwnProperty.call(lodash.prototype, methodName)) {
  16944. source[methodName] = func;
  16945. }
  16946. });
  16947. return source;
  16948. }()), { 'chain': false });
  16949.  
  16950. /*------------------------------------------------------------------------*/
  16951.  
  16952. /**
  16953. * The semantic version number.
  16954. *
  16955. * @static
  16956. * @memberOf _
  16957. * @type {string}
  16958. */
  16959. lodash.VERSION = VERSION;
  16960.  
  16961. // Assign default placeholders.
  16962. arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
  16963. lodash[methodName].placeholder = lodash;
  16964. });
  16965.  
  16966. // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
  16967. arrayEach(['drop', 'take'], function(methodName, index) {
  16968. LazyWrapper.prototype[methodName] = function(n) {
  16969. n = n === undefined ? 1 : nativeMax(toInteger(n), 0);
  16970.  
  16971. var result = (this.__filtered__ && !index)
  16972. ? new LazyWrapper(this)
  16973. : this.clone();
  16974.  
  16975. if (result.__filtered__) {
  16976. result.__takeCount__ = nativeMin(n, result.__takeCount__);
  16977. } else {
  16978. result.__views__.push({
  16979. 'size': nativeMin(n, MAX_ARRAY_LENGTH),
  16980. 'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
  16981. });
  16982. }
  16983. return result;
  16984. };
  16985.  
  16986. LazyWrapper.prototype[methodName + 'Right'] = function(n) {
  16987. return this.reverse()[methodName](n).reverse();
  16988. };
  16989. });
  16990.  
  16991. // Add `LazyWrapper` methods that accept an `iteratee` value.
  16992. arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
  16993. var type = index + 1,
  16994. isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
  16995.  
  16996. LazyWrapper.prototype[methodName] = function(iteratee) {
  16997. var result = this.clone();
  16998. result.__iteratees__.push({
  16999. 'iteratee': getIteratee(iteratee, 3),
  17000. 'type': type
  17001. });
  17002. result.__filtered__ = result.__filtered__ || isFilter;
  17003. return result;
  17004. };
  17005. });
  17006.  
  17007. // Add `LazyWrapper` methods for `_.head` and `_.last`.
  17008. arrayEach(['head', 'last'], function(methodName, index) {
  17009. var takeName = 'take' + (index ? 'Right' : '');
  17010.  
  17011. LazyWrapper.prototype[methodName] = function() {
  17012. return this[takeName](1).value()[0];
  17013. };
  17014. });
  17015.  
  17016. // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
  17017. arrayEach(['initial', 'tail'], function(methodName, index) {
  17018. var dropName = 'drop' + (index ? '' : 'Right');
  17019.  
  17020. LazyWrapper.prototype[methodName] = function() {
  17021. return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
  17022. };
  17023. });
  17024.  
  17025. LazyWrapper.prototype.compact = function() {
  17026. return this.filter(identity);
  17027. };
  17028.  
  17029. LazyWrapper.prototype.find = function(predicate) {
  17030. return this.filter(predicate).head();
  17031. };
  17032.  
  17033. LazyWrapper.prototype.findLast = function(predicate) {
  17034. return this.reverse().find(predicate);
  17035. };
  17036.  
  17037. LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
  17038. if (typeof path == 'function') {
  17039. return new LazyWrapper(this);
  17040. }
  17041. return this.map(function(value) {
  17042. return baseInvoke(value, path, args);
  17043. });
  17044. });
  17045.  
  17046. LazyWrapper.prototype.reject = function(predicate) {
  17047. return this.filter(negate(getIteratee(predicate)));
  17048. };
  17049.  
  17050. LazyWrapper.prototype.slice = function(start, end) {
  17051. start = toInteger(start);
  17052.  
  17053. var result = this;
  17054. if (result.__filtered__ && (start > 0 || end < 0)) {
  17055. return new LazyWrapper(result);
  17056. }
  17057. if (start < 0) {
  17058. result = result.takeRight(-start);
  17059. } else if (start) {
  17060. result = result.drop(start);
  17061. }
  17062. if (end !== undefined) {
  17063. end = toInteger(end);
  17064. result = end < 0 ? result.dropRight(-end) : result.take(end - start);
  17065. }
  17066. return result;
  17067. };
  17068.  
  17069. LazyWrapper.prototype.takeRightWhile = function(predicate) {
  17070. return this.reverse().takeWhile(predicate).reverse();
  17071. };
  17072.  
  17073. LazyWrapper.prototype.toArray = function() {
  17074. return this.take(MAX_ARRAY_LENGTH);
  17075. };
  17076.  
  17077. // Add `LazyWrapper` methods to `lodash.prototype`.
  17078. baseForOwn(LazyWrapper.prototype, function(func, methodName) {
  17079. var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
  17080. isTaker = /^(?:head|last)$/.test(methodName),
  17081. lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
  17082. retUnwrapped = isTaker || /^find/.test(methodName);
  17083.  
  17084. if (!lodashFunc) {
  17085. return;
  17086. }
  17087. lodash.prototype[methodName] = function() {
  17088. var value = this.__wrapped__,
  17089. args = isTaker ? [1] : arguments,
  17090. isLazy = value instanceof LazyWrapper,
  17091. iteratee = args[0],
  17092. useLazy = isLazy || isArray(value);
  17093.  
  17094. var interceptor = function(value) {
  17095. var result = lodashFunc.apply(lodash, arrayPush([value], args));
  17096. return (isTaker && chainAll) ? result[0] : result;
  17097. };
  17098.  
  17099. if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
  17100. // Avoid lazy use if the iteratee has a "length" value other than `1`.
  17101. isLazy = useLazy = false;
  17102. }
  17103. var chainAll = this.__chain__,
  17104. isHybrid = !!this.__actions__.length,
  17105. isUnwrapped = retUnwrapped && !chainAll,
  17106. onlyLazy = isLazy && !isHybrid;
  17107.  
  17108. if (!retUnwrapped && useLazy) {
  17109. value = onlyLazy ? value : new LazyWrapper(this);
  17110. var result = func.apply(value, args);
  17111. result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
  17112. return new LodashWrapper(result, chainAll);
  17113. }
  17114. if (isUnwrapped && onlyLazy) {
  17115. return func.apply(this, args);
  17116. }
  17117. result = this.thru(interceptor);
  17118. return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
  17119. };
  17120. });
  17121.  
  17122. // Add `Array` methods to `lodash.prototype`.
  17123. arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
  17124. var func = arrayProto[methodName],
  17125. chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
  17126. retUnwrapped = /^(?:pop|shift)$/.test(methodName);
  17127.  
  17128. lodash.prototype[methodName] = function() {
  17129. var args = arguments;
  17130. if (retUnwrapped && !this.__chain__) {
  17131. var value = this.value();
  17132. return func.apply(isArray(value) ? value : [], args);
  17133. }
  17134. return this[chainName](function(value) {
  17135. return func.apply(isArray(value) ? value : [], args);
  17136. });
  17137. };
  17138. });
  17139.  
  17140. // Map minified method names to their real names.
  17141. baseForOwn(LazyWrapper.prototype, function(func, methodName) {
  17142. var lodashFunc = lodash[methodName];
  17143. if (lodashFunc) {
  17144. var key = lodashFunc.name + '';
  17145. if (!hasOwnProperty.call(realNames, key)) {
  17146. realNames[key] = [];
  17147. }
  17148. realNames[key].push({ 'name': methodName, 'func': lodashFunc });
  17149. }
  17150. });
  17151.  
  17152. realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
  17153. 'name': 'wrapper',
  17154. 'func': undefined
  17155. }];
  17156.  
  17157. // Add methods to `LazyWrapper`.
  17158. LazyWrapper.prototype.clone = lazyClone;
  17159. LazyWrapper.prototype.reverse = lazyReverse;
  17160. LazyWrapper.prototype.value = lazyValue;
  17161.  
  17162. // Add chain sequence methods to the `lodash` wrapper.
  17163. lodash.prototype.at = wrapperAt;
  17164. lodash.prototype.chain = wrapperChain;
  17165. lodash.prototype.commit = wrapperCommit;
  17166. lodash.prototype.next = wrapperNext;
  17167. lodash.prototype.plant = wrapperPlant;
  17168. lodash.prototype.reverse = wrapperReverse;
  17169. lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
  17170.  
  17171. // Add lazy aliases.
  17172. lodash.prototype.first = lodash.prototype.head;
  17173.  
  17174. if (symIterator) {
  17175. lodash.prototype[symIterator] = wrapperToIterator;
  17176. }
  17177. return lodash;
  17178. });
  17179.  
  17180. /*--------------------------------------------------------------------------*/
  17181.  
  17182. // Export lodash.
  17183. var _ = runInContext();
  17184.  
  17185. // Some AMD build optimizers, like r.js, check for condition patterns like:
  17186. if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
  17187. // Expose Lodash on the global object to prevent errors when Lodash is
  17188. // loaded by a script tag in the presence of an AMD loader.
  17189. // See http://requirejs.org/docs/errors.html#mismatch for more details.
  17190. // Use `_.noConflict` to remove Lodash from the global object.
  17191. root._ = _;
  17192.  
  17193. // Define as an anonymous module so, through path mapping, it can be
  17194. // referenced as the "underscore" module.
  17195. define(function() {
  17196. return _;
  17197. });
  17198. }
  17199. // Check for `exports` after `define` in case a build optimizer adds it.
  17200. else if (freeModule) {
  17201. // Export for Node.js.
  17202. (freeModule.exports = _)._ = _;
  17203. // Export for CommonJS support.
  17204. freeExports._ = _;
  17205. }
  17206. else {
  17207. // Export to the global object.
  17208. root._ = _;
  17209. }
  17210. }.call(this));