384f9aa5b1bc99620e61c83bdc7cfad389e1b702
[rails.git] / vendor / assets / iD / iD.js
1 (function () {
2 function actionAddEntity(way) {
3     return function(graph) {
4         return graph.replace(way);
5     };
6 }
7
8 var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
9
10 function commonjsRequire () {
11         throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
12 }
13
14
15
16 function createCommonjsModule(fn, module) {
17         return module = { exports: {} }, fn(module, module.exports), module.exports;
18 }
19
20 var lodash = createCommonjsModule(function (module, exports) {
21 /**
22  * @license
23  * Lodash <https://lodash.com/>
24  * Copyright JS Foundation and other contributors <https://js.foundation/>
25  * Released under MIT license <https://lodash.com/license>
26  * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
27  * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
28  */
29 (function() {
30
31   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
32   var undefined;
33
34   /** Used as the semantic version number. */
35   var VERSION = '4.17.4';
36
37   /** Used as the size to enable large array optimizations. */
38   var LARGE_ARRAY_SIZE = 200;
39
40   /** Error message constants. */
41   var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
42       FUNC_ERROR_TEXT = 'Expected a function';
43
44   /** Used to stand-in for `undefined` hash values. */
45   var HASH_UNDEFINED = '__lodash_hash_undefined__';
46
47   /** Used as the maximum memoize cache size. */
48   var MAX_MEMOIZE_SIZE = 500;
49
50   /** Used as the internal argument placeholder. */
51   var PLACEHOLDER = '__lodash_placeholder__';
52
53   /** Used to compose bitmasks for cloning. */
54   var CLONE_DEEP_FLAG = 1,
55       CLONE_FLAT_FLAG = 2,
56       CLONE_SYMBOLS_FLAG = 4;
57
58   /** Used to compose bitmasks for value comparisons. */
59   var COMPARE_PARTIAL_FLAG = 1,
60       COMPARE_UNORDERED_FLAG = 2;
61
62   /** Used to compose bitmasks for function metadata. */
63   var WRAP_BIND_FLAG = 1,
64       WRAP_BIND_KEY_FLAG = 2,
65       WRAP_CURRY_BOUND_FLAG = 4,
66       WRAP_CURRY_FLAG = 8,
67       WRAP_CURRY_RIGHT_FLAG = 16,
68       WRAP_PARTIAL_FLAG = 32,
69       WRAP_PARTIAL_RIGHT_FLAG = 64,
70       WRAP_ARY_FLAG = 128,
71       WRAP_REARG_FLAG = 256,
72       WRAP_FLIP_FLAG = 512;
73
74   /** Used as default options for `_.truncate`. */
75   var DEFAULT_TRUNC_LENGTH = 30,
76       DEFAULT_TRUNC_OMISSION = '...';
77
78   /** Used to detect hot functions by number of calls within a span of milliseconds. */
79   var HOT_COUNT = 800,
80       HOT_SPAN = 16;
81
82   /** Used to indicate the type of lazy iteratees. */
83   var LAZY_FILTER_FLAG = 1,
84       LAZY_MAP_FLAG = 2,
85       LAZY_WHILE_FLAG = 3;
86
87   /** Used as references for various `Number` constants. */
88   var INFINITY = 1 / 0,
89       MAX_SAFE_INTEGER = 9007199254740991,
90       MAX_INTEGER = 1.7976931348623157e+308,
91       NAN = 0 / 0;
92
93   /** Used as references for the maximum length and index of an array. */
94   var MAX_ARRAY_LENGTH = 4294967295,
95       MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
96       HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
97
98   /** Used to associate wrap methods with their bit flags. */
99   var wrapFlags = [
100     ['ary', WRAP_ARY_FLAG],
101     ['bind', WRAP_BIND_FLAG],
102     ['bindKey', WRAP_BIND_KEY_FLAG],
103     ['curry', WRAP_CURRY_FLAG],
104     ['curryRight', WRAP_CURRY_RIGHT_FLAG],
105     ['flip', WRAP_FLIP_FLAG],
106     ['partial', WRAP_PARTIAL_FLAG],
107     ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
108     ['rearg', WRAP_REARG_FLAG]
109   ];
110
111   /** `Object#toString` result references. */
112   var argsTag = '[object Arguments]',
113       arrayTag = '[object Array]',
114       asyncTag = '[object AsyncFunction]',
115       boolTag = '[object Boolean]',
116       dateTag = '[object Date]',
117       domExcTag = '[object DOMException]',
118       errorTag = '[object Error]',
119       funcTag = '[object Function]',
120       genTag = '[object GeneratorFunction]',
121       mapTag = '[object Map]',
122       numberTag = '[object Number]',
123       nullTag = '[object Null]',
124       objectTag = '[object Object]',
125       promiseTag = '[object Promise]',
126       proxyTag = '[object Proxy]',
127       regexpTag = '[object RegExp]',
128       setTag = '[object Set]',
129       stringTag = '[object String]',
130       symbolTag = '[object Symbol]',
131       undefinedTag = '[object Undefined]',
132       weakMapTag = '[object WeakMap]',
133       weakSetTag = '[object WeakSet]';
134
135   var arrayBufferTag = '[object ArrayBuffer]',
136       dataViewTag = '[object DataView]',
137       float32Tag = '[object Float32Array]',
138       float64Tag = '[object Float64Array]',
139       int8Tag = '[object Int8Array]',
140       int16Tag = '[object Int16Array]',
141       int32Tag = '[object Int32Array]',
142       uint8Tag = '[object Uint8Array]',
143       uint8ClampedTag = '[object Uint8ClampedArray]',
144       uint16Tag = '[object Uint16Array]',
145       uint32Tag = '[object Uint32Array]';
146
147   /** Used to match empty string literals in compiled template source. */
148   var reEmptyStringLeading = /\b__p \+= '';/g,
149       reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
150       reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
151
152   /** Used to match HTML entities and HTML characters. */
153   var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
154       reUnescapedHtml = /[&<>"']/g,
155       reHasEscapedHtml = RegExp(reEscapedHtml.source),
156       reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
157
158   /** Used to match template delimiters. */
159   var reEscape = /<%-([\s\S]+?)%>/g,
160       reEvaluate = /<%([\s\S]+?)%>/g,
161       reInterpolate = /<%=([\s\S]+?)%>/g;
162
163   /** Used to match property names within property paths. */
164   var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
165       reIsPlainProp = /^\w*$/,
166       reLeadingDot = /^\./,
167       rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
168
169   /**
170    * Used to match `RegExp`
171    * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
172    */
173   var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
174       reHasRegExpChar = RegExp(reRegExpChar.source);
175
176   /** Used to match leading and trailing whitespace. */
177   var reTrim = /^\s+|\s+$/g,
178       reTrimStart = /^\s+/,
179       reTrimEnd = /\s+$/;
180
181   /** Used to match wrap detail comments. */
182   var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
183       reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
184       reSplitDetails = /,? & /;
185
186   /** Used to match words composed of alphanumeric characters. */
187   var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
188
189   /** Used to match backslashes in property paths. */
190   var reEscapeChar = /\\(\\)?/g;
191
192   /**
193    * Used to match
194    * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
195    */
196   var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
197
198   /** Used to match `RegExp` flags from their coerced string values. */
199   var reFlags = /\w*$/;
200
201   /** Used to detect bad signed hexadecimal string values. */
202   var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
203
204   /** Used to detect binary string values. */
205   var reIsBinary = /^0b[01]+$/i;
206
207   /** Used to detect host constructors (Safari). */
208   var reIsHostCtor = /^\[object .+?Constructor\]$/;
209
210   /** Used to detect octal string values. */
211   var reIsOctal = /^0o[0-7]+$/i;
212
213   /** Used to detect unsigned integer values. */
214   var reIsUint = /^(?:0|[1-9]\d*)$/;
215
216   /** Used to match Latin Unicode letters (excluding mathematical operators). */
217   var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
218
219   /** Used to ensure capturing order of template delimiters. */
220   var reNoMatch = /($^)/;
221
222   /** Used to match unescaped characters in compiled string literals. */
223   var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
224
225   /** Used to compose unicode character classes. */
226   var rsAstralRange = '\\ud800-\\udfff',
227       rsComboMarksRange = '\\u0300-\\u036f',
228       reComboHalfMarksRange = '\\ufe20-\\ufe2f',
229       rsComboSymbolsRange = '\\u20d0-\\u20ff',
230       rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
231       rsDingbatRange = '\\u2700-\\u27bf',
232       rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
233       rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
234       rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
235       rsPunctuationRange = '\\u2000-\\u206f',
236       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',
237       rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
238       rsVarRange = '\\ufe0e\\ufe0f',
239       rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
240
241   /** Used to compose unicode capture groups. */
242   var rsApos = "['\u2019]",
243       rsAstral = '[' + rsAstralRange + ']',
244       rsBreak = '[' + rsBreakRange + ']',
245       rsCombo = '[' + rsComboRange + ']',
246       rsDigits = '\\d+',
247       rsDingbat = '[' + rsDingbatRange + ']',
248       rsLower = '[' + rsLowerRange + ']',
249       rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
250       rsFitz = '\\ud83c[\\udffb-\\udfff]',
251       rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
252       rsNonAstral = '[^' + rsAstralRange + ']',
253       rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
254       rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
255       rsUpper = '[' + rsUpperRange + ']',
256       rsZWJ = '\\u200d';
257
258   /** Used to compose unicode regexes. */
259   var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
260       rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
261       rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
262       rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
263       reOptMod = rsModifier + '?',
264       rsOptVar = '[' + rsVarRange + ']?',
265       rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
266       rsOrdLower = '\\d*(?:(?:1st|2nd|3rd|(?![123])\\dth)\\b)',
267       rsOrdUpper = '\\d*(?:(?:1ST|2ND|3RD|(?![123])\\dTH)\\b)',
268       rsSeq = rsOptVar + reOptMod + rsOptJoin,
269       rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
270       rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
271
272   /** Used to match apostrophes. */
273   var reApos = RegExp(rsApos, 'g');
274
275   /**
276    * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
277    * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
278    */
279   var reComboMark = RegExp(rsCombo, 'g');
280
281   /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
282   var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
283
284   /** Used to match complex or compound words. */
285   var reUnicodeWord = RegExp([
286     rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
287     rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
288     rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
289     rsUpper + '+' + rsOptContrUpper,
290     rsOrdUpper,
291     rsOrdLower,
292     rsDigits,
293     rsEmoji
294   ].join('|'), 'g');
295
296   /** 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/). */
297   var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');
298
299   /** Used to detect strings that need a more robust regexp to match words. */
300   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 ]/;
301
302   /** Used to assign default `context` object properties. */
303   var contextProps = [
304     'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
305     'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
306     'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
307     'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
308     '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
309   ];
310
311   /** Used to make template sourceURLs easier to identify. */
312   var templateCounter = -1;
313
314   /** Used to identify `toStringTag` values of typed arrays. */
315   var typedArrayTags = {};
316   typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
317   typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
318   typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
319   typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
320   typedArrayTags[uint32Tag] = true;
321   typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
322   typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
323   typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
324   typedArrayTags[errorTag] = typedArrayTags[funcTag] =
325   typedArrayTags[mapTag] = typedArrayTags[numberTag] =
326   typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
327   typedArrayTags[setTag] = typedArrayTags[stringTag] =
328   typedArrayTags[weakMapTag] = false;
329
330   /** Used to identify `toStringTag` values supported by `_.clone`. */
331   var cloneableTags = {};
332   cloneableTags[argsTag] = cloneableTags[arrayTag] =
333   cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
334   cloneableTags[boolTag] = cloneableTags[dateTag] =
335   cloneableTags[float32Tag] = cloneableTags[float64Tag] =
336   cloneableTags[int8Tag] = cloneableTags[int16Tag] =
337   cloneableTags[int32Tag] = cloneableTags[mapTag] =
338   cloneableTags[numberTag] = cloneableTags[objectTag] =
339   cloneableTags[regexpTag] = cloneableTags[setTag] =
340   cloneableTags[stringTag] = cloneableTags[symbolTag] =
341   cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
342   cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
343   cloneableTags[errorTag] = cloneableTags[funcTag] =
344   cloneableTags[weakMapTag] = false;
345
346   /** Used to map Latin Unicode letters to basic Latin letters. */
347   var deburredLetters = {
348     // Latin-1 Supplement block.
349     '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
350     '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
351     '\xc7': 'C',  '\xe7': 'c',
352     '\xd0': 'D',  '\xf0': 'd',
353     '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
354     '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
355     '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
356     '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
357     '\xd1': 'N',  '\xf1': 'n',
358     '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
359     '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
360     '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
361     '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
362     '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
363     '\xc6': 'Ae', '\xe6': 'ae',
364     '\xde': 'Th', '\xfe': 'th',
365     '\xdf': 'ss',
366     // Latin Extended-A block.
367     '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
368     '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
369     '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
370     '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
371     '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
372     '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
373     '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
374     '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
375     '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
376     '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
377     '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
378     '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
379     '\u0134': 'J',  '\u0135': 'j',
380     '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
381     '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
382     '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
383     '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
384     '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
385     '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
386     '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
387     '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
388     '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
389     '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
390     '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
391     '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
392     '\u0163': 't',  '\u0165': 't', '\u0167': 't',
393     '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
394     '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
395     '\u0174': 'W',  '\u0175': 'w',
396     '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
397     '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
398     '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
399     '\u0132': 'IJ', '\u0133': 'ij',
400     '\u0152': 'Oe', '\u0153': 'oe',
401     '\u0149': "'n", '\u017f': 's'
402   };
403
404   /** Used to map characters to HTML entities. */
405   var htmlEscapes = {
406     '&': '&amp;',
407     '<': '&lt;',
408     '>': '&gt;',
409     '"': '&quot;',
410     "'": '&#39;'
411   };
412
413   /** Used to map HTML entities to characters. */
414   var htmlUnescapes = {
415     '&amp;': '&',
416     '&lt;': '<',
417     '&gt;': '>',
418     '&quot;': '"',
419     '&#39;': "'"
420   };
421
422   /** Used to escape characters for inclusion in compiled string literals. */
423   var stringEscapes = {
424     '\\': '\\',
425     "'": "'",
426     '\n': 'n',
427     '\r': 'r',
428     '\u2028': 'u2028',
429     '\u2029': 'u2029'
430   };
431
432   /** Built-in method references without a dependency on `root`. */
433   var freeParseFloat = parseFloat,
434       freeParseInt = parseInt;
435
436   /** Detect free variable `global` from Node.js. */
437   var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
438
439   /** Detect free variable `self`. */
440   var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
441
442   /** Used as a reference to the global object. */
443   var root = freeGlobal || freeSelf || Function('return this')();
444
445   /** Detect free variable `exports`. */
446   var freeExports = 'object' == 'object' && exports && !exports.nodeType && exports;
447
448   /** Detect free variable `module`. */
449   var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
450
451   /** Detect the popular CommonJS extension `module.exports`. */
452   var moduleExports = freeModule && freeModule.exports === freeExports;
453
454   /** Detect free variable `process` from Node.js. */
455   var freeProcess = moduleExports && freeGlobal.process;
456
457   /** Used to access faster Node.js helpers. */
458   var nodeUtil = (function() {
459     try {
460       return freeProcess && freeProcess.binding && freeProcess.binding('util');
461     } catch (e) {}
462   }());
463
464   /* Node.js helper references. */
465   var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
466       nodeIsDate = nodeUtil && nodeUtil.isDate,
467       nodeIsMap = nodeUtil && nodeUtil.isMap,
468       nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
469       nodeIsSet = nodeUtil && nodeUtil.isSet,
470       nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
471
472   /*--------------------------------------------------------------------------*/
473
474   /**
475    * Adds the key-value `pair` to `map`.
476    *
477    * @private
478    * @param {Object} map The map to modify.
479    * @param {Array} pair The key-value pair to add.
480    * @returns {Object} Returns `map`.
481    */
482   function addMapEntry(map, pair) {
483     // Don't return `map.set` because it's not chainable in IE 11.
484     map.set(pair[0], pair[1]);
485     return map;
486   }
487
488   /**
489    * Adds `value` to `set`.
490    *
491    * @private
492    * @param {Object} set The set to modify.
493    * @param {*} value The value to add.
494    * @returns {Object} Returns `set`.
495    */
496   function addSetEntry(set, value) {
497     // Don't return `set.add` because it's not chainable in IE 11.
498     set.add(value);
499     return set;
500   }
501
502   /**
503    * A faster alternative to `Function#apply`, this function invokes `func`
504    * with the `this` binding of `thisArg` and the arguments of `args`.
505    *
506    * @private
507    * @param {Function} func The function to invoke.
508    * @param {*} thisArg The `this` binding of `func`.
509    * @param {Array} args The arguments to invoke `func` with.
510    * @returns {*} Returns the result of `func`.
511    */
512   function apply(func, thisArg, args) {
513     switch (args.length) {
514       case 0: return func.call(thisArg);
515       case 1: return func.call(thisArg, args[0]);
516       case 2: return func.call(thisArg, args[0], args[1]);
517       case 3: return func.call(thisArg, args[0], args[1], args[2]);
518     }
519     return func.apply(thisArg, args);
520   }
521
522   /**
523    * A specialized version of `baseAggregator` for arrays.
524    *
525    * @private
526    * @param {Array} [array] The array to iterate over.
527    * @param {Function} setter The function to set `accumulator` values.
528    * @param {Function} iteratee The iteratee to transform keys.
529    * @param {Object} accumulator The initial aggregated object.
530    * @returns {Function} Returns `accumulator`.
531    */
532   function arrayAggregator(array, setter, iteratee, accumulator) {
533     var index = -1,
534         length = array == null ? 0 : array.length;
535
536     while (++index < length) {
537       var value = array[index];
538       setter(accumulator, value, iteratee(value), array);
539     }
540     return accumulator;
541   }
542
543   /**
544    * A specialized version of `_.forEach` for arrays without support for
545    * iteratee shorthands.
546    *
547    * @private
548    * @param {Array} [array] The array to iterate over.
549    * @param {Function} iteratee The function invoked per iteration.
550    * @returns {Array} Returns `array`.
551    */
552   function arrayEach(array, iteratee) {
553     var index = -1,
554         length = array == null ? 0 : array.length;
555
556     while (++index < length) {
557       if (iteratee(array[index], index, array) === false) {
558         break;
559       }
560     }
561     return array;
562   }
563
564   /**
565    * A specialized version of `_.forEachRight` for arrays without support for
566    * iteratee shorthands.
567    *
568    * @private
569    * @param {Array} [array] The array to iterate over.
570    * @param {Function} iteratee The function invoked per iteration.
571    * @returns {Array} Returns `array`.
572    */
573   function arrayEachRight(array, iteratee) {
574     var length = array == null ? 0 : array.length;
575
576     while (length--) {
577       if (iteratee(array[length], length, array) === false) {
578         break;
579       }
580     }
581     return array;
582   }
583
584   /**
585    * A specialized version of `_.every` for arrays without support for
586    * iteratee shorthands.
587    *
588    * @private
589    * @param {Array} [array] The array to iterate over.
590    * @param {Function} predicate The function invoked per iteration.
591    * @returns {boolean} Returns `true` if all elements pass the predicate check,
592    *  else `false`.
593    */
594   function arrayEvery(array, predicate) {
595     var index = -1,
596         length = array == null ? 0 : array.length;
597
598     while (++index < length) {
599       if (!predicate(array[index], index, array)) {
600         return false;
601       }
602     }
603     return true;
604   }
605
606   /**
607    * A specialized version of `_.filter` for arrays without support for
608    * iteratee shorthands.
609    *
610    * @private
611    * @param {Array} [array] The array to iterate over.
612    * @param {Function} predicate The function invoked per iteration.
613    * @returns {Array} Returns the new filtered array.
614    */
615   function arrayFilter(array, predicate) {
616     var index = -1,
617         length = array == null ? 0 : array.length,
618         resIndex = 0,
619         result = [];
620
621     while (++index < length) {
622       var value = array[index];
623       if (predicate(value, index, array)) {
624         result[resIndex++] = value;
625       }
626     }
627     return result;
628   }
629
630   /**
631    * A specialized version of `_.includes` for arrays without support for
632    * specifying an index to search from.
633    *
634    * @private
635    * @param {Array} [array] The array to inspect.
636    * @param {*} target The value to search for.
637    * @returns {boolean} Returns `true` if `target` is found, else `false`.
638    */
639   function arrayIncludes(array, value) {
640     var length = array == null ? 0 : array.length;
641     return !!length && baseIndexOf(array, value, 0) > -1;
642   }
643
644   /**
645    * This function is like `arrayIncludes` except that it accepts a comparator.
646    *
647    * @private
648    * @param {Array} [array] The array to inspect.
649    * @param {*} target The value to search for.
650    * @param {Function} comparator The comparator invoked per element.
651    * @returns {boolean} Returns `true` if `target` is found, else `false`.
652    */
653   function arrayIncludesWith(array, value, comparator) {
654     var index = -1,
655         length = array == null ? 0 : array.length;
656
657     while (++index < length) {
658       if (comparator(value, array[index])) {
659         return true;
660       }
661     }
662     return false;
663   }
664
665   /**
666    * A specialized version of `_.map` for arrays without support for iteratee
667    * shorthands.
668    *
669    * @private
670    * @param {Array} [array] The array to iterate over.
671    * @param {Function} iteratee The function invoked per iteration.
672    * @returns {Array} Returns the new mapped array.
673    */
674   function arrayMap(array, iteratee) {
675     var index = -1,
676         length = array == null ? 0 : array.length,
677         result = Array(length);
678
679     while (++index < length) {
680       result[index] = iteratee(array[index], index, array);
681     }
682     return result;
683   }
684
685   /**
686    * Appends the elements of `values` to `array`.
687    *
688    * @private
689    * @param {Array} array The array to modify.
690    * @param {Array} values The values to append.
691    * @returns {Array} Returns `array`.
692    */
693   function arrayPush(array, values) {
694     var index = -1,
695         length = values.length,
696         offset = array.length;
697
698     while (++index < length) {
699       array[offset + index] = values[index];
700     }
701     return array;
702   }
703
704   /**
705    * A specialized version of `_.reduce` for arrays without support for
706    * iteratee shorthands.
707    *
708    * @private
709    * @param {Array} [array] The array to iterate over.
710    * @param {Function} iteratee The function invoked per iteration.
711    * @param {*} [accumulator] The initial value.
712    * @param {boolean} [initAccum] Specify using the first element of `array` as
713    *  the initial value.
714    * @returns {*} Returns the accumulated value.
715    */
716   function arrayReduce(array, iteratee, accumulator, initAccum) {
717     var index = -1,
718         length = array == null ? 0 : array.length;
719
720     if (initAccum && length) {
721       accumulator = array[++index];
722     }
723     while (++index < length) {
724       accumulator = iteratee(accumulator, array[index], index, array);
725     }
726     return accumulator;
727   }
728
729   /**
730    * A specialized version of `_.reduceRight` for arrays without support for
731    * iteratee shorthands.
732    *
733    * @private
734    * @param {Array} [array] The array to iterate over.
735    * @param {Function} iteratee The function invoked per iteration.
736    * @param {*} [accumulator] The initial value.
737    * @param {boolean} [initAccum] Specify using the last element of `array` as
738    *  the initial value.
739    * @returns {*} Returns the accumulated value.
740    */
741   function arrayReduceRight(array, iteratee, accumulator, initAccum) {
742     var length = array == null ? 0 : array.length;
743     if (initAccum && length) {
744       accumulator = array[--length];
745     }
746     while (length--) {
747       accumulator = iteratee(accumulator, array[length], length, array);
748     }
749     return accumulator;
750   }
751
752   /**
753    * A specialized version of `_.some` for arrays without support for iteratee
754    * shorthands.
755    *
756    * @private
757    * @param {Array} [array] The array to iterate over.
758    * @param {Function} predicate The function invoked per iteration.
759    * @returns {boolean} Returns `true` if any element passes the predicate check,
760    *  else `false`.
761    */
762   function arraySome(array, predicate) {
763     var index = -1,
764         length = array == null ? 0 : array.length;
765
766     while (++index < length) {
767       if (predicate(array[index], index, array)) {
768         return true;
769       }
770     }
771     return false;
772   }
773
774   /**
775    * Gets the size of an ASCII `string`.
776    *
777    * @private
778    * @param {string} string The string inspect.
779    * @returns {number} Returns the string size.
780    */
781   var asciiSize = baseProperty('length');
782
783   /**
784    * Converts an ASCII `string` to an array.
785    *
786    * @private
787    * @param {string} string The string to convert.
788    * @returns {Array} Returns the converted array.
789    */
790   function asciiToArray(string) {
791     return string.split('');
792   }
793
794   /**
795    * Splits an ASCII `string` into an array of its words.
796    *
797    * @private
798    * @param {string} The string to inspect.
799    * @returns {Array} Returns the words of `string`.
800    */
801   function asciiWords(string) {
802     return string.match(reAsciiWord) || [];
803   }
804
805   /**
806    * The base implementation of methods like `_.findKey` and `_.findLastKey`,
807    * without support for iteratee shorthands, which iterates over `collection`
808    * using `eachFunc`.
809    *
810    * @private
811    * @param {Array|Object} collection The collection to inspect.
812    * @param {Function} predicate The function invoked per iteration.
813    * @param {Function} eachFunc The function to iterate over `collection`.
814    * @returns {*} Returns the found element or its key, else `undefined`.
815    */
816   function baseFindKey(collection, predicate, eachFunc) {
817     var result;
818     eachFunc(collection, function(value, key, collection) {
819       if (predicate(value, key, collection)) {
820         result = key;
821         return false;
822       }
823     });
824     return result;
825   }
826
827   /**
828    * The base implementation of `_.findIndex` and `_.findLastIndex` without
829    * support for iteratee shorthands.
830    *
831    * @private
832    * @param {Array} array The array to inspect.
833    * @param {Function} predicate The function invoked per iteration.
834    * @param {number} fromIndex The index to search from.
835    * @param {boolean} [fromRight] Specify iterating from right to left.
836    * @returns {number} Returns the index of the matched value, else `-1`.
837    */
838   function baseFindIndex(array, predicate, fromIndex, fromRight) {
839     var length = array.length,
840         index = fromIndex + (fromRight ? 1 : -1);
841
842     while ((fromRight ? index-- : ++index < length)) {
843       if (predicate(array[index], index, array)) {
844         return index;
845       }
846     }
847     return -1;
848   }
849
850   /**
851    * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
852    *
853    * @private
854    * @param {Array} array The array to inspect.
855    * @param {*} value The value to search for.
856    * @param {number} fromIndex The index to search from.
857    * @returns {number} Returns the index of the matched value, else `-1`.
858    */
859   function baseIndexOf(array, value, fromIndex) {
860     return value === value
861       ? strictIndexOf(array, value, fromIndex)
862       : baseFindIndex(array, baseIsNaN, fromIndex);
863   }
864
865   /**
866    * This function is like `baseIndexOf` except that it accepts a comparator.
867    *
868    * @private
869    * @param {Array} array The array to inspect.
870    * @param {*} value The value to search for.
871    * @param {number} fromIndex The index to search from.
872    * @param {Function} comparator The comparator invoked per element.
873    * @returns {number} Returns the index of the matched value, else `-1`.
874    */
875   function baseIndexOfWith(array, value, fromIndex, comparator) {
876     var index = fromIndex - 1,
877         length = array.length;
878
879     while (++index < length) {
880       if (comparator(array[index], value)) {
881         return index;
882       }
883     }
884     return -1;
885   }
886
887   /**
888    * The base implementation of `_.isNaN` without support for number objects.
889    *
890    * @private
891    * @param {*} value The value to check.
892    * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
893    */
894   function baseIsNaN(value) {
895     return value !== value;
896   }
897
898   /**
899    * The base implementation of `_.mean` and `_.meanBy` without support for
900    * iteratee shorthands.
901    *
902    * @private
903    * @param {Array} array The array to iterate over.
904    * @param {Function} iteratee The function invoked per iteration.
905    * @returns {number} Returns the mean.
906    */
907   function baseMean(array, iteratee) {
908     var length = array == null ? 0 : array.length;
909     return length ? (baseSum(array, iteratee) / length) : NAN;
910   }
911
912   /**
913    * The base implementation of `_.property` without support for deep paths.
914    *
915    * @private
916    * @param {string} key The key of the property to get.
917    * @returns {Function} Returns the new accessor function.
918    */
919   function baseProperty(key) {
920     return function(object) {
921       return object == null ? undefined : object[key];
922     };
923   }
924
925   /**
926    * The base implementation of `_.propertyOf` without support for deep paths.
927    *
928    * @private
929    * @param {Object} object The object to query.
930    * @returns {Function} Returns the new accessor function.
931    */
932   function basePropertyOf(object) {
933     return function(key) {
934       return object == null ? undefined : object[key];
935     };
936   }
937
938   /**
939    * The base implementation of `_.reduce` and `_.reduceRight`, without support
940    * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
941    *
942    * @private
943    * @param {Array|Object} collection The collection to iterate over.
944    * @param {Function} iteratee The function invoked per iteration.
945    * @param {*} accumulator The initial value.
946    * @param {boolean} initAccum Specify using the first or last element of
947    *  `collection` as the initial value.
948    * @param {Function} eachFunc The function to iterate over `collection`.
949    * @returns {*} Returns the accumulated value.
950    */
951   function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
952     eachFunc(collection, function(value, index, collection) {
953       accumulator = initAccum
954         ? (initAccum = false, value)
955         : iteratee(accumulator, value, index, collection);
956     });
957     return accumulator;
958   }
959
960   /**
961    * The base implementation of `_.sortBy` which uses `comparer` to define the
962    * sort order of `array` and replaces criteria objects with their corresponding
963    * values.
964    *
965    * @private
966    * @param {Array} array The array to sort.
967    * @param {Function} comparer The function to define sort order.
968    * @returns {Array} Returns `array`.
969    */
970   function baseSortBy(array, comparer) {
971     var length = array.length;
972
973     array.sort(comparer);
974     while (length--) {
975       array[length] = array[length].value;
976     }
977     return array;
978   }
979
980   /**
981    * The base implementation of `_.sum` and `_.sumBy` without support for
982    * iteratee shorthands.
983    *
984    * @private
985    * @param {Array} array The array to iterate over.
986    * @param {Function} iteratee The function invoked per iteration.
987    * @returns {number} Returns the sum.
988    */
989   function baseSum(array, iteratee) {
990     var result,
991         index = -1,
992         length = array.length;
993
994     while (++index < length) {
995       var current = iteratee(array[index]);
996       if (current !== undefined) {
997         result = result === undefined ? current : (result + current);
998       }
999     }
1000     return result;
1001   }
1002
1003   /**
1004    * The base implementation of `_.times` without support for iteratee shorthands
1005    * or max array length checks.
1006    *
1007    * @private
1008    * @param {number} n The number of times to invoke `iteratee`.
1009    * @param {Function} iteratee The function invoked per iteration.
1010    * @returns {Array} Returns the array of results.
1011    */
1012   function baseTimes(n, iteratee) {
1013     var index = -1,
1014         result = Array(n);
1015
1016     while (++index < n) {
1017       result[index] = iteratee(index);
1018     }
1019     return result;
1020   }
1021
1022   /**
1023    * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
1024    * of key-value pairs for `object` corresponding to the property names of `props`.
1025    *
1026    * @private
1027    * @param {Object} object The object to query.
1028    * @param {Array} props The property names to get values for.
1029    * @returns {Object} Returns the key-value pairs.
1030    */
1031   function baseToPairs(object, props) {
1032     return arrayMap(props, function(key) {
1033       return [key, object[key]];
1034     });
1035   }
1036
1037   /**
1038    * The base implementation of `_.unary` without support for storing metadata.
1039    *
1040    * @private
1041    * @param {Function} func The function to cap arguments for.
1042    * @returns {Function} Returns the new capped function.
1043    */
1044   function baseUnary(func) {
1045     return function(value) {
1046       return func(value);
1047     };
1048   }
1049
1050   /**
1051    * The base implementation of `_.values` and `_.valuesIn` which creates an
1052    * array of `object` property values corresponding to the property names
1053    * of `props`.
1054    *
1055    * @private
1056    * @param {Object} object The object to query.
1057    * @param {Array} props The property names to get values for.
1058    * @returns {Object} Returns the array of property values.
1059    */
1060   function baseValues(object, props) {
1061     return arrayMap(props, function(key) {
1062       return object[key];
1063     });
1064   }
1065
1066   /**
1067    * Checks if a `cache` value for `key` exists.
1068    *
1069    * @private
1070    * @param {Object} cache The cache to query.
1071    * @param {string} key The key of the entry to check.
1072    * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
1073    */
1074   function cacheHas(cache, key) {
1075     return cache.has(key);
1076   }
1077
1078   /**
1079    * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
1080    * that is not found in the character symbols.
1081    *
1082    * @private
1083    * @param {Array} strSymbols The string symbols to inspect.
1084    * @param {Array} chrSymbols The character symbols to find.
1085    * @returns {number} Returns the index of the first unmatched string symbol.
1086    */
1087   function charsStartIndex(strSymbols, chrSymbols) {
1088     var index = -1,
1089         length = strSymbols.length;
1090
1091     while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1092     return index;
1093   }
1094
1095   /**
1096    * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
1097    * that is not found in the character symbols.
1098    *
1099    * @private
1100    * @param {Array} strSymbols The string symbols to inspect.
1101    * @param {Array} chrSymbols The character symbols to find.
1102    * @returns {number} Returns the index of the last unmatched string symbol.
1103    */
1104   function charsEndIndex(strSymbols, chrSymbols) {
1105     var index = strSymbols.length;
1106
1107     while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1108     return index;
1109   }
1110
1111   /**
1112    * Gets the number of `placeholder` occurrences in `array`.
1113    *
1114    * @private
1115    * @param {Array} array The array to inspect.
1116    * @param {*} placeholder The placeholder to search for.
1117    * @returns {number} Returns the placeholder count.
1118    */
1119   function countHolders(array, placeholder) {
1120     var length = array.length,
1121         result = 0;
1122
1123     while (length--) {
1124       if (array[length] === placeholder) {
1125         ++result;
1126       }
1127     }
1128     return result;
1129   }
1130
1131   /**
1132    * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
1133    * letters to basic Latin letters.
1134    *
1135    * @private
1136    * @param {string} letter The matched letter to deburr.
1137    * @returns {string} Returns the deburred letter.
1138    */
1139   var deburrLetter = basePropertyOf(deburredLetters);
1140
1141   /**
1142    * Used by `_.escape` to convert characters to HTML entities.
1143    *
1144    * @private
1145    * @param {string} chr The matched character to escape.
1146    * @returns {string} Returns the escaped character.
1147    */
1148   var escapeHtmlChar = basePropertyOf(htmlEscapes);
1149
1150   /**
1151    * Used by `_.template` to escape characters for inclusion in compiled string literals.
1152    *
1153    * @private
1154    * @param {string} chr The matched character to escape.
1155    * @returns {string} Returns the escaped character.
1156    */
1157   function escapeStringChar(chr) {
1158     return '\\' + stringEscapes[chr];
1159   }
1160
1161   /**
1162    * Gets the value at `key` of `object`.
1163    *
1164    * @private
1165    * @param {Object} [object] The object to query.
1166    * @param {string} key The key of the property to get.
1167    * @returns {*} Returns the property value.
1168    */
1169   function getValue(object, key) {
1170     return object == null ? undefined : object[key];
1171   }
1172
1173   /**
1174    * Checks if `string` contains Unicode symbols.
1175    *
1176    * @private
1177    * @param {string} string The string to inspect.
1178    * @returns {boolean} Returns `true` if a symbol is found, else `false`.
1179    */
1180   function hasUnicode(string) {
1181     return reHasUnicode.test(string);
1182   }
1183
1184   /**
1185    * Checks if `string` contains a word composed of Unicode symbols.
1186    *
1187    * @private
1188    * @param {string} string The string to inspect.
1189    * @returns {boolean} Returns `true` if a word is found, else `false`.
1190    */
1191   function hasUnicodeWord(string) {
1192     return reHasUnicodeWord.test(string);
1193   }
1194
1195   /**
1196    * Converts `iterator` to an array.
1197    *
1198    * @private
1199    * @param {Object} iterator The iterator to convert.
1200    * @returns {Array} Returns the converted array.
1201    */
1202   function iteratorToArray(iterator) {
1203     var data,
1204         result = [];
1205
1206     while (!(data = iterator.next()).done) {
1207       result.push(data.value);
1208     }
1209     return result;
1210   }
1211
1212   /**
1213    * Converts `map` to its key-value pairs.
1214    *
1215    * @private
1216    * @param {Object} map The map to convert.
1217    * @returns {Array} Returns the key-value pairs.
1218    */
1219   function mapToArray(map) {
1220     var index = -1,
1221         result = Array(map.size);
1222
1223     map.forEach(function(value, key) {
1224       result[++index] = [key, value];
1225     });
1226     return result;
1227   }
1228
1229   /**
1230    * Creates a unary function that invokes `func` with its argument transformed.
1231    *
1232    * @private
1233    * @param {Function} func The function to wrap.
1234    * @param {Function} transform The argument transform.
1235    * @returns {Function} Returns the new function.
1236    */
1237   function overArg(func, transform) {
1238     return function(arg) {
1239       return func(transform(arg));
1240     };
1241   }
1242
1243   /**
1244    * Replaces all `placeholder` elements in `array` with an internal placeholder
1245    * and returns an array of their indexes.
1246    *
1247    * @private
1248    * @param {Array} array The array to modify.
1249    * @param {*} placeholder The placeholder to replace.
1250    * @returns {Array} Returns the new array of placeholder indexes.
1251    */
1252   function replaceHolders(array, placeholder) {
1253     var index = -1,
1254         length = array.length,
1255         resIndex = 0,
1256         result = [];
1257
1258     while (++index < length) {
1259       var value = array[index];
1260       if (value === placeholder || value === PLACEHOLDER) {
1261         array[index] = PLACEHOLDER;
1262         result[resIndex++] = index;
1263       }
1264     }
1265     return result;
1266   }
1267
1268   /**
1269    * Converts `set` to an array of its values.
1270    *
1271    * @private
1272    * @param {Object} set The set to convert.
1273    * @returns {Array} Returns the values.
1274    */
1275   function setToArray(set) {
1276     var index = -1,
1277         result = Array(set.size);
1278
1279     set.forEach(function(value) {
1280       result[++index] = value;
1281     });
1282     return result;
1283   }
1284
1285   /**
1286    * Converts `set` to its value-value pairs.
1287    *
1288    * @private
1289    * @param {Object} set The set to convert.
1290    * @returns {Array} Returns the value-value pairs.
1291    */
1292   function setToPairs(set) {
1293     var index = -1,
1294         result = Array(set.size);
1295
1296     set.forEach(function(value) {
1297       result[++index] = [value, value];
1298     });
1299     return result;
1300   }
1301
1302   /**
1303    * A specialized version of `_.indexOf` which performs strict equality
1304    * comparisons of values, i.e. `===`.
1305    *
1306    * @private
1307    * @param {Array} array The array to inspect.
1308    * @param {*} value The value to search for.
1309    * @param {number} fromIndex The index to search from.
1310    * @returns {number} Returns the index of the matched value, else `-1`.
1311    */
1312   function strictIndexOf(array, value, fromIndex) {
1313     var index = fromIndex - 1,
1314         length = array.length;
1315
1316     while (++index < length) {
1317       if (array[index] === value) {
1318         return index;
1319       }
1320     }
1321     return -1;
1322   }
1323
1324   /**
1325    * A specialized version of `_.lastIndexOf` which performs strict equality
1326    * comparisons of values, i.e. `===`.
1327    *
1328    * @private
1329    * @param {Array} array The array to inspect.
1330    * @param {*} value The value to search for.
1331    * @param {number} fromIndex The index to search from.
1332    * @returns {number} Returns the index of the matched value, else `-1`.
1333    */
1334   function strictLastIndexOf(array, value, fromIndex) {
1335     var index = fromIndex + 1;
1336     while (index--) {
1337       if (array[index] === value) {
1338         return index;
1339       }
1340     }
1341     return index;
1342   }
1343
1344   /**
1345    * Gets the number of symbols in `string`.
1346    *
1347    * @private
1348    * @param {string} string The string to inspect.
1349    * @returns {number} Returns the string size.
1350    */
1351   function stringSize(string) {
1352     return hasUnicode(string)
1353       ? unicodeSize(string)
1354       : asciiSize(string);
1355   }
1356
1357   /**
1358    * Converts `string` to an array.
1359    *
1360    * @private
1361    * @param {string} string The string to convert.
1362    * @returns {Array} Returns the converted array.
1363    */
1364   function stringToArray(string) {
1365     return hasUnicode(string)
1366       ? unicodeToArray(string)
1367       : asciiToArray(string);
1368   }
1369
1370   /**
1371    * Used by `_.unescape` to convert HTML entities to characters.
1372    *
1373    * @private
1374    * @param {string} chr The matched character to unescape.
1375    * @returns {string} Returns the unescaped character.
1376    */
1377   var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
1378
1379   /**
1380    * Gets the size of a Unicode `string`.
1381    *
1382    * @private
1383    * @param {string} string The string inspect.
1384    * @returns {number} Returns the string size.
1385    */
1386   function unicodeSize(string) {
1387     var result = reUnicode.lastIndex = 0;
1388     while (reUnicode.test(string)) {
1389       ++result;
1390     }
1391     return result;
1392   }
1393
1394   /**
1395    * Converts a Unicode `string` to an array.
1396    *
1397    * @private
1398    * @param {string} string The string to convert.
1399    * @returns {Array} Returns the converted array.
1400    */
1401   function unicodeToArray(string) {
1402     return string.match(reUnicode) || [];
1403   }
1404
1405   /**
1406    * Splits a Unicode `string` into an array of its words.
1407    *
1408    * @private
1409    * @param {string} The string to inspect.
1410    * @returns {Array} Returns the words of `string`.
1411    */
1412   function unicodeWords(string) {
1413     return string.match(reUnicodeWord) || [];
1414   }
1415
1416   /*--------------------------------------------------------------------------*/
1417
1418   /**
1419    * Create a new pristine `lodash` function using the `context` object.
1420    *
1421    * @static
1422    * @memberOf _
1423    * @since 1.1.0
1424    * @category Util
1425    * @param {Object} [context=root] The context object.
1426    * @returns {Function} Returns a new `lodash` function.
1427    * @example
1428    *
1429    * _.mixin({ 'foo': _.constant('foo') });
1430    *
1431    * var lodash = _.runInContext();
1432    * lodash.mixin({ 'bar': lodash.constant('bar') });
1433    *
1434    * _.isFunction(_.foo);
1435    * // => true
1436    * _.isFunction(_.bar);
1437    * // => false
1438    *
1439    * lodash.isFunction(lodash.foo);
1440    * // => false
1441    * lodash.isFunction(lodash.bar);
1442    * // => true
1443    *
1444    * // Create a suped-up `defer` in Node.js.
1445    * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
1446    */
1447   var runInContext = (function runInContext(context) {
1448     context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
1449
1450     /** Built-in constructor references. */
1451     var Array = context.Array,
1452         Date = context.Date,
1453         Error = context.Error,
1454         Function = context.Function,
1455         Math = context.Math,
1456         Object = context.Object,
1457         RegExp = context.RegExp,
1458         String = context.String,
1459         TypeError = context.TypeError;
1460
1461     /** Used for built-in method references. */
1462     var arrayProto = Array.prototype,
1463         funcProto = Function.prototype,
1464         objectProto = Object.prototype;
1465
1466     /** Used to detect overreaching core-js shims. */
1467     var coreJsData = context['__core-js_shared__'];
1468
1469     /** Used to resolve the decompiled source of functions. */
1470     var funcToString = funcProto.toString;
1471
1472     /** Used to check objects for own properties. */
1473     var hasOwnProperty = objectProto.hasOwnProperty;
1474
1475     /** Used to generate unique IDs. */
1476     var idCounter = 0;
1477
1478     /** Used to detect methods masquerading as native. */
1479     var maskSrcKey = (function() {
1480       var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
1481       return uid ? ('Symbol(src)_1.' + uid) : '';
1482     }());
1483
1484     /**
1485      * Used to resolve the
1486      * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
1487      * of values.
1488      */
1489     var nativeObjectToString = objectProto.toString;
1490
1491     /** Used to infer the `Object` constructor. */
1492     var objectCtorString = funcToString.call(Object);
1493
1494     /** Used to restore the original `_` reference in `_.noConflict`. */
1495     var oldDash = root._;
1496
1497     /** Used to detect if a method is native. */
1498     var reIsNative = RegExp('^' +
1499       funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
1500       .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
1501     );
1502
1503     /** Built-in value references. */
1504     var Buffer = moduleExports ? context.Buffer : undefined,
1505         Symbol = context.Symbol,
1506         Uint8Array = context.Uint8Array,
1507         allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
1508         getPrototype = overArg(Object.getPrototypeOf, Object),
1509         objectCreate = Object.create,
1510         propertyIsEnumerable = objectProto.propertyIsEnumerable,
1511         splice = arrayProto.splice,
1512         spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,
1513         symIterator = Symbol ? Symbol.iterator : undefined,
1514         symToStringTag = Symbol ? Symbol.toStringTag : undefined;
1515
1516     var defineProperty = (function() {
1517       try {
1518         var func = getNative(Object, 'defineProperty');
1519         func({}, '', {});
1520         return func;
1521       } catch (e) {}
1522     }());
1523
1524     /** Mocked built-ins. */
1525     var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
1526         ctxNow = Date && Date.now !== root.Date.now && Date.now,
1527         ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
1528
1529     /* Built-in method references for those with the same name as other `lodash` methods. */
1530     var nativeCeil = Math.ceil,
1531         nativeFloor = Math.floor,
1532         nativeGetSymbols = Object.getOwnPropertySymbols,
1533         nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
1534         nativeIsFinite = context.isFinite,
1535         nativeJoin = arrayProto.join,
1536         nativeKeys = overArg(Object.keys, Object),
1537         nativeMax = Math.max,
1538         nativeMin = Math.min,
1539         nativeNow = Date.now,
1540         nativeParseInt = context.parseInt,
1541         nativeRandom = Math.random,
1542         nativeReverse = arrayProto.reverse;
1543
1544     /* Built-in method references that are verified to be native. */
1545     var DataView = getNative(context, 'DataView'),
1546         Map = getNative(context, 'Map'),
1547         Promise = getNative(context, 'Promise'),
1548         Set = getNative(context, 'Set'),
1549         WeakMap = getNative(context, 'WeakMap'),
1550         nativeCreate = getNative(Object, 'create');
1551
1552     /** Used to store function metadata. */
1553     var metaMap = WeakMap && new WeakMap;
1554
1555     /** Used to lookup unminified function names. */
1556     var realNames = {};
1557
1558     /** Used to detect maps, sets, and weakmaps. */
1559     var dataViewCtorString = toSource(DataView),
1560         mapCtorString = toSource(Map),
1561         promiseCtorString = toSource(Promise),
1562         setCtorString = toSource(Set),
1563         weakMapCtorString = toSource(WeakMap);
1564
1565     /** Used to convert symbols to primitives and strings. */
1566     var symbolProto = Symbol ? Symbol.prototype : undefined,
1567         symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
1568         symbolToString = symbolProto ? symbolProto.toString : undefined;
1569
1570     /*------------------------------------------------------------------------*/
1571
1572     /**
1573      * Creates a `lodash` object which wraps `value` to enable implicit method
1574      * chain sequences. Methods that operate on and return arrays, collections,
1575      * and functions can be chained together. Methods that retrieve a single value
1576      * or may return a primitive value will automatically end the chain sequence
1577      * and return the unwrapped value. Otherwise, the value must be unwrapped
1578      * with `_#value`.
1579      *
1580      * Explicit chain sequences, which must be unwrapped with `_#value`, may be
1581      * enabled using `_.chain`.
1582      *
1583      * The execution of chained methods is lazy, that is, it's deferred until
1584      * `_#value` is implicitly or explicitly called.
1585      *
1586      * Lazy evaluation allows several methods to support shortcut fusion.
1587      * Shortcut fusion is an optimization to merge iteratee calls; this avoids
1588      * the creation of intermediate arrays and can greatly reduce the number of
1589      * iteratee executions. Sections of a chain sequence qualify for shortcut
1590      * fusion if the section is applied to an array and iteratees accept only
1591      * one argument. The heuristic for whether a section qualifies for shortcut
1592      * fusion is subject to change.
1593      *
1594      * Chaining is supported in custom builds as long as the `_#value` method is
1595      * directly or indirectly included in the build.
1596      *
1597      * In addition to lodash methods, wrappers have `Array` and `String` methods.
1598      *
1599      * The wrapper `Array` methods are:
1600      * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
1601      *
1602      * The wrapper `String` methods are:
1603      * `replace` and `split`
1604      *
1605      * The wrapper methods that support shortcut fusion are:
1606      * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
1607      * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
1608      * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
1609      *
1610      * The chainable wrapper methods are:
1611      * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
1612      * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
1613      * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
1614      * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
1615      * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
1616      * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
1617      * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
1618      * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
1619      * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
1620      * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
1621      * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
1622      * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
1623      * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
1624      * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
1625      * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
1626      * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
1627      * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
1628      * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
1629      * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
1630      * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
1631      * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
1632      * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
1633      * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
1634      * `zipObject`, `zipObjectDeep`, and `zipWith`
1635      *
1636      * The wrapper methods that are **not** chainable by default are:
1637      * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
1638      * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
1639      * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
1640      * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
1641      * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
1642      * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
1643      * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
1644      * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
1645      * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
1646      * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
1647      * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
1648      * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
1649      * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
1650      * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
1651      * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
1652      * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
1653      * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
1654      * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
1655      * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
1656      * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
1657      * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
1658      * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
1659      * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
1660      * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
1661      * `upperFirst`, `value`, and `words`
1662      *
1663      * @name _
1664      * @constructor
1665      * @category Seq
1666      * @param {*} value The value to wrap in a `lodash` instance.
1667      * @returns {Object} Returns the new `lodash` wrapper instance.
1668      * @example
1669      *
1670      * function square(n) {
1671      *   return n * n;
1672      * }
1673      *
1674      * var wrapped = _([1, 2, 3]);
1675      *
1676      * // Returns an unwrapped value.
1677      * wrapped.reduce(_.add);
1678      * // => 6
1679      *
1680      * // Returns a wrapped value.
1681      * var squares = wrapped.map(square);
1682      *
1683      * _.isArray(squares);
1684      * // => false
1685      *
1686      * _.isArray(squares.value());
1687      * // => true
1688      */
1689     function lodash(value) {
1690       if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
1691         if (value instanceof LodashWrapper) {
1692           return value;
1693         }
1694         if (hasOwnProperty.call(value, '__wrapped__')) {
1695           return wrapperClone(value);
1696         }
1697       }
1698       return new LodashWrapper(value);
1699     }
1700
1701     /**
1702      * The base implementation of `_.create` without support for assigning
1703      * properties to the created object.
1704      *
1705      * @private
1706      * @param {Object} proto The object to inherit from.
1707      * @returns {Object} Returns the new object.
1708      */
1709     var baseCreate = (function() {
1710       function object() {}
1711       return function(proto) {
1712         if (!isObject(proto)) {
1713           return {};
1714         }
1715         if (objectCreate) {
1716           return objectCreate(proto);
1717         }
1718         object.prototype = proto;
1719         var result = new object;
1720         object.prototype = undefined;
1721         return result;
1722       };
1723     }());
1724
1725     /**
1726      * The function whose prototype chain sequence wrappers inherit from.
1727      *
1728      * @private
1729      */
1730     function baseLodash() {
1731       // No operation performed.
1732     }
1733
1734     /**
1735      * The base constructor for creating `lodash` wrapper objects.
1736      *
1737      * @private
1738      * @param {*} value The value to wrap.
1739      * @param {boolean} [chainAll] Enable explicit method chain sequences.
1740      */
1741     function LodashWrapper(value, chainAll) {
1742       this.__wrapped__ = value;
1743       this.__actions__ = [];
1744       this.__chain__ = !!chainAll;
1745       this.__index__ = 0;
1746       this.__values__ = undefined;
1747     }
1748
1749     /**
1750      * By default, the template delimiters used by lodash are like those in
1751      * embedded Ruby (ERB) as well as ES2015 template strings. Change the
1752      * following template settings to use alternative delimiters.
1753      *
1754      * @static
1755      * @memberOf _
1756      * @type {Object}
1757      */
1758     lodash.templateSettings = {
1759
1760       /**
1761        * Used to detect `data` property values to be HTML-escaped.
1762        *
1763        * @memberOf _.templateSettings
1764        * @type {RegExp}
1765        */
1766       'escape': reEscape,
1767
1768       /**
1769        * Used to detect code to be evaluated.
1770        *
1771        * @memberOf _.templateSettings
1772        * @type {RegExp}
1773        */
1774       'evaluate': reEvaluate,
1775
1776       /**
1777        * Used to detect `data` property values to inject.
1778        *
1779        * @memberOf _.templateSettings
1780        * @type {RegExp}
1781        */
1782       'interpolate': reInterpolate,
1783
1784       /**
1785        * Used to reference the data object in the template text.
1786        *
1787        * @memberOf _.templateSettings
1788        * @type {string}
1789        */
1790       'variable': '',
1791
1792       /**
1793        * Used to import variables into the compiled template.
1794        *
1795        * @memberOf _.templateSettings
1796        * @type {Object}
1797        */
1798       'imports': {
1799
1800         /**
1801          * A reference to the `lodash` function.
1802          *
1803          * @memberOf _.templateSettings.imports
1804          * @type {Function}
1805          */
1806         '_': lodash
1807       }
1808     };
1809
1810     // Ensure wrappers are instances of `baseLodash`.
1811     lodash.prototype = baseLodash.prototype;
1812     lodash.prototype.constructor = lodash;
1813
1814     LodashWrapper.prototype = baseCreate(baseLodash.prototype);
1815     LodashWrapper.prototype.constructor = LodashWrapper;
1816
1817     /*------------------------------------------------------------------------*/
1818
1819     /**
1820      * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
1821      *
1822      * @private
1823      * @constructor
1824      * @param {*} value The value to wrap.
1825      */
1826     function LazyWrapper(value) {
1827       this.__wrapped__ = value;
1828       this.__actions__ = [];
1829       this.__dir__ = 1;
1830       this.__filtered__ = false;
1831       this.__iteratees__ = [];
1832       this.__takeCount__ = MAX_ARRAY_LENGTH;
1833       this.__views__ = [];
1834     }
1835
1836     /**
1837      * Creates a clone of the lazy wrapper object.
1838      *
1839      * @private
1840      * @name clone
1841      * @memberOf LazyWrapper
1842      * @returns {Object} Returns the cloned `LazyWrapper` object.
1843      */
1844     function lazyClone() {
1845       var result = new LazyWrapper(this.__wrapped__);
1846       result.__actions__ = copyArray(this.__actions__);
1847       result.__dir__ = this.__dir__;
1848       result.__filtered__ = this.__filtered__;
1849       result.__iteratees__ = copyArray(this.__iteratees__);
1850       result.__takeCount__ = this.__takeCount__;
1851       result.__views__ = copyArray(this.__views__);
1852       return result;
1853     }
1854
1855     /**
1856      * Reverses the direction of lazy iteration.
1857      *
1858      * @private
1859      * @name reverse
1860      * @memberOf LazyWrapper
1861      * @returns {Object} Returns the new reversed `LazyWrapper` object.
1862      */
1863     function lazyReverse() {
1864       if (this.__filtered__) {
1865         var result = new LazyWrapper(this);
1866         result.__dir__ = -1;
1867         result.__filtered__ = true;
1868       } else {
1869         result = this.clone();
1870         result.__dir__ *= -1;
1871       }
1872       return result;
1873     }
1874
1875     /**
1876      * Extracts the unwrapped value from its lazy wrapper.
1877      *
1878      * @private
1879      * @name value
1880      * @memberOf LazyWrapper
1881      * @returns {*} Returns the unwrapped value.
1882      */
1883     function lazyValue() {
1884       var array = this.__wrapped__.value(),
1885           dir = this.__dir__,
1886           isArr = isArray(array),
1887           isRight = dir < 0,
1888           arrLength = isArr ? array.length : 0,
1889           view = getView(0, arrLength, this.__views__),
1890           start = view.start,
1891           end = view.end,
1892           length = end - start,
1893           index = isRight ? end : (start - 1),
1894           iteratees = this.__iteratees__,
1895           iterLength = iteratees.length,
1896           resIndex = 0,
1897           takeCount = nativeMin(length, this.__takeCount__);
1898
1899       if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
1900         return baseWrapperValue(array, this.__actions__);
1901       }
1902       var result = [];
1903
1904       outer:
1905       while (length-- && resIndex < takeCount) {
1906         index += dir;
1907
1908         var iterIndex = -1,
1909             value = array[index];
1910
1911         while (++iterIndex < iterLength) {
1912           var data = iteratees[iterIndex],
1913               iteratee = data.iteratee,
1914               type = data.type,
1915               computed = iteratee(value);
1916
1917           if (type == LAZY_MAP_FLAG) {
1918             value = computed;
1919           } else if (!computed) {
1920             if (type == LAZY_FILTER_FLAG) {
1921               continue outer;
1922             } else {
1923               break outer;
1924             }
1925           }
1926         }
1927         result[resIndex++] = value;
1928       }
1929       return result;
1930     }
1931
1932     // Ensure `LazyWrapper` is an instance of `baseLodash`.
1933     LazyWrapper.prototype = baseCreate(baseLodash.prototype);
1934     LazyWrapper.prototype.constructor = LazyWrapper;
1935
1936     /*------------------------------------------------------------------------*/
1937
1938     /**
1939      * Creates a hash object.
1940      *
1941      * @private
1942      * @constructor
1943      * @param {Array} [entries] The key-value pairs to cache.
1944      */
1945     function Hash(entries) {
1946       var index = -1,
1947           length = entries == null ? 0 : entries.length;
1948
1949       this.clear();
1950       while (++index < length) {
1951         var entry = entries[index];
1952         this.set(entry[0], entry[1]);
1953       }
1954     }
1955
1956     /**
1957      * Removes all key-value entries from the hash.
1958      *
1959      * @private
1960      * @name clear
1961      * @memberOf Hash
1962      */
1963     function hashClear() {
1964       this.__data__ = nativeCreate ? nativeCreate(null) : {};
1965       this.size = 0;
1966     }
1967
1968     /**
1969      * Removes `key` and its value from the hash.
1970      *
1971      * @private
1972      * @name delete
1973      * @memberOf Hash
1974      * @param {Object} hash The hash to modify.
1975      * @param {string} key The key of the value to remove.
1976      * @returns {boolean} Returns `true` if the entry was removed, else `false`.
1977      */
1978     function hashDelete(key) {
1979       var result = this.has(key) && delete this.__data__[key];
1980       this.size -= result ? 1 : 0;
1981       return result;
1982     }
1983
1984     /**
1985      * Gets the hash value for `key`.
1986      *
1987      * @private
1988      * @name get
1989      * @memberOf Hash
1990      * @param {string} key The key of the value to get.
1991      * @returns {*} Returns the entry value.
1992      */
1993     function hashGet(key) {
1994       var data = this.__data__;
1995       if (nativeCreate) {
1996         var result = data[key];
1997         return result === HASH_UNDEFINED ? undefined : result;
1998       }
1999       return hasOwnProperty.call(data, key) ? data[key] : undefined;
2000     }
2001
2002     /**
2003      * Checks if a hash value for `key` exists.
2004      *
2005      * @private
2006      * @name has
2007      * @memberOf Hash
2008      * @param {string} key The key of the entry to check.
2009      * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2010      */
2011     function hashHas(key) {
2012       var data = this.__data__;
2013       return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
2014     }
2015
2016     /**
2017      * Sets the hash `key` to `value`.
2018      *
2019      * @private
2020      * @name set
2021      * @memberOf Hash
2022      * @param {string} key The key of the value to set.
2023      * @param {*} value The value to set.
2024      * @returns {Object} Returns the hash instance.
2025      */
2026     function hashSet(key, value) {
2027       var data = this.__data__;
2028       this.size += this.has(key) ? 0 : 1;
2029       data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
2030       return this;
2031     }
2032
2033     // Add methods to `Hash`.
2034     Hash.prototype.clear = hashClear;
2035     Hash.prototype['delete'] = hashDelete;
2036     Hash.prototype.get = hashGet;
2037     Hash.prototype.has = hashHas;
2038     Hash.prototype.set = hashSet;
2039
2040     /*------------------------------------------------------------------------*/
2041
2042     /**
2043      * Creates an list cache object.
2044      *
2045      * @private
2046      * @constructor
2047      * @param {Array} [entries] The key-value pairs to cache.
2048      */
2049     function ListCache(entries) {
2050       var index = -1,
2051           length = entries == null ? 0 : entries.length;
2052
2053       this.clear();
2054       while (++index < length) {
2055         var entry = entries[index];
2056         this.set(entry[0], entry[1]);
2057       }
2058     }
2059
2060     /**
2061      * Removes all key-value entries from the list cache.
2062      *
2063      * @private
2064      * @name clear
2065      * @memberOf ListCache
2066      */
2067     function listCacheClear() {
2068       this.__data__ = [];
2069       this.size = 0;
2070     }
2071
2072     /**
2073      * Removes `key` and its value from the list cache.
2074      *
2075      * @private
2076      * @name delete
2077      * @memberOf ListCache
2078      * @param {string} key The key of the value to remove.
2079      * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2080      */
2081     function listCacheDelete(key) {
2082       var data = this.__data__,
2083           index = assocIndexOf(data, key);
2084
2085       if (index < 0) {
2086         return false;
2087       }
2088       var lastIndex = data.length - 1;
2089       if (index == lastIndex) {
2090         data.pop();
2091       } else {
2092         splice.call(data, index, 1);
2093       }
2094       --this.size;
2095       return true;
2096     }
2097
2098     /**
2099      * Gets the list cache value for `key`.
2100      *
2101      * @private
2102      * @name get
2103      * @memberOf ListCache
2104      * @param {string} key The key of the value to get.
2105      * @returns {*} Returns the entry value.
2106      */
2107     function listCacheGet(key) {
2108       var data = this.__data__,
2109           index = assocIndexOf(data, key);
2110
2111       return index < 0 ? undefined : data[index][1];
2112     }
2113
2114     /**
2115      * Checks if a list cache value for `key` exists.
2116      *
2117      * @private
2118      * @name has
2119      * @memberOf ListCache
2120      * @param {string} key The key of the entry to check.
2121      * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2122      */
2123     function listCacheHas(key) {
2124       return assocIndexOf(this.__data__, key) > -1;
2125     }
2126
2127     /**
2128      * Sets the list cache `key` to `value`.
2129      *
2130      * @private
2131      * @name set
2132      * @memberOf ListCache
2133      * @param {string} key The key of the value to set.
2134      * @param {*} value The value to set.
2135      * @returns {Object} Returns the list cache instance.
2136      */
2137     function listCacheSet(key, value) {
2138       var data = this.__data__,
2139           index = assocIndexOf(data, key);
2140
2141       if (index < 0) {
2142         ++this.size;
2143         data.push([key, value]);
2144       } else {
2145         data[index][1] = value;
2146       }
2147       return this;
2148     }
2149
2150     // Add methods to `ListCache`.
2151     ListCache.prototype.clear = listCacheClear;
2152     ListCache.prototype['delete'] = listCacheDelete;
2153     ListCache.prototype.get = listCacheGet;
2154     ListCache.prototype.has = listCacheHas;
2155     ListCache.prototype.set = listCacheSet;
2156
2157     /*------------------------------------------------------------------------*/
2158
2159     /**
2160      * Creates a map cache object to store key-value pairs.
2161      *
2162      * @private
2163      * @constructor
2164      * @param {Array} [entries] The key-value pairs to cache.
2165      */
2166     function MapCache(entries) {
2167       var index = -1,
2168           length = entries == null ? 0 : entries.length;
2169
2170       this.clear();
2171       while (++index < length) {
2172         var entry = entries[index];
2173         this.set(entry[0], entry[1]);
2174       }
2175     }
2176
2177     /**
2178      * Removes all key-value entries from the map.
2179      *
2180      * @private
2181      * @name clear
2182      * @memberOf MapCache
2183      */
2184     function mapCacheClear() {
2185       this.size = 0;
2186       this.__data__ = {
2187         'hash': new Hash,
2188         'map': new (Map || ListCache),
2189         'string': new Hash
2190       };
2191     }
2192
2193     /**
2194      * Removes `key` and its value from the map.
2195      *
2196      * @private
2197      * @name delete
2198      * @memberOf MapCache
2199      * @param {string} key The key of the value to remove.
2200      * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2201      */
2202     function mapCacheDelete(key) {
2203       var result = getMapData(this, key)['delete'](key);
2204       this.size -= result ? 1 : 0;
2205       return result;
2206     }
2207
2208     /**
2209      * Gets the map value for `key`.
2210      *
2211      * @private
2212      * @name get
2213      * @memberOf MapCache
2214      * @param {string} key The key of the value to get.
2215      * @returns {*} Returns the entry value.
2216      */
2217     function mapCacheGet(key) {
2218       return getMapData(this, key).get(key);
2219     }
2220
2221     /**
2222      * Checks if a map value for `key` exists.
2223      *
2224      * @private
2225      * @name has
2226      * @memberOf MapCache
2227      * @param {string} key The key of the entry to check.
2228      * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2229      */
2230     function mapCacheHas(key) {
2231       return getMapData(this, key).has(key);
2232     }
2233
2234     /**
2235      * Sets the map `key` to `value`.
2236      *
2237      * @private
2238      * @name set
2239      * @memberOf MapCache
2240      * @param {string} key The key of the value to set.
2241      * @param {*} value The value to set.
2242      * @returns {Object} Returns the map cache instance.
2243      */
2244     function mapCacheSet(key, value) {
2245       var data = getMapData(this, key),
2246           size = data.size;
2247
2248       data.set(key, value);
2249       this.size += data.size == size ? 0 : 1;
2250       return this;
2251     }
2252
2253     // Add methods to `MapCache`.
2254     MapCache.prototype.clear = mapCacheClear;
2255     MapCache.prototype['delete'] = mapCacheDelete;
2256     MapCache.prototype.get = mapCacheGet;
2257     MapCache.prototype.has = mapCacheHas;
2258     MapCache.prototype.set = mapCacheSet;
2259
2260     /*------------------------------------------------------------------------*/
2261
2262     /**
2263      *
2264      * Creates an array cache object to store unique values.
2265      *
2266      * @private
2267      * @constructor
2268      * @param {Array} [values] The values to cache.
2269      */
2270     function SetCache(values) {
2271       var index = -1,
2272           length = values == null ? 0 : values.length;
2273
2274       this.__data__ = new MapCache;
2275       while (++index < length) {
2276         this.add(values[index]);
2277       }
2278     }
2279
2280     /**
2281      * Adds `value` to the array cache.
2282      *
2283      * @private
2284      * @name add
2285      * @memberOf SetCache
2286      * @alias push
2287      * @param {*} value The value to cache.
2288      * @returns {Object} Returns the cache instance.
2289      */
2290     function setCacheAdd(value) {
2291       this.__data__.set(value, HASH_UNDEFINED);
2292       return this;
2293     }
2294
2295     /**
2296      * Checks if `value` is in the array cache.
2297      *
2298      * @private
2299      * @name has
2300      * @memberOf SetCache
2301      * @param {*} value The value to search for.
2302      * @returns {number} Returns `true` if `value` is found, else `false`.
2303      */
2304     function setCacheHas(value) {
2305       return this.__data__.has(value);
2306     }
2307
2308     // Add methods to `SetCache`.
2309     SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
2310     SetCache.prototype.has = setCacheHas;
2311
2312     /*------------------------------------------------------------------------*/
2313
2314     /**
2315      * Creates a stack cache object to store key-value pairs.
2316      *
2317      * @private
2318      * @constructor
2319      * @param {Array} [entries] The key-value pairs to cache.
2320      */
2321     function Stack(entries) {
2322       var data = this.__data__ = new ListCache(entries);
2323       this.size = data.size;
2324     }
2325
2326     /**
2327      * Removes all key-value entries from the stack.
2328      *
2329      * @private
2330      * @name clear
2331      * @memberOf Stack
2332      */
2333     function stackClear() {
2334       this.__data__ = new ListCache;
2335       this.size = 0;
2336     }
2337
2338     /**
2339      * Removes `key` and its value from the stack.
2340      *
2341      * @private
2342      * @name delete
2343      * @memberOf Stack
2344      * @param {string} key The key of the value to remove.
2345      * @returns {boolean} Returns `true` if the entry was removed, else `false`.
2346      */
2347     function stackDelete(key) {
2348       var data = this.__data__,
2349           result = data['delete'](key);
2350
2351       this.size = data.size;
2352       return result;
2353     }
2354
2355     /**
2356      * Gets the stack value for `key`.
2357      *
2358      * @private
2359      * @name get
2360      * @memberOf Stack
2361      * @param {string} key The key of the value to get.
2362      * @returns {*} Returns the entry value.
2363      */
2364     function stackGet(key) {
2365       return this.__data__.get(key);
2366     }
2367
2368     /**
2369      * Checks if a stack value for `key` exists.
2370      *
2371      * @private
2372      * @name has
2373      * @memberOf Stack
2374      * @param {string} key The key of the entry to check.
2375      * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
2376      */
2377     function stackHas(key) {
2378       return this.__data__.has(key);
2379     }
2380
2381     /**
2382      * Sets the stack `key` to `value`.
2383      *
2384      * @private
2385      * @name set
2386      * @memberOf Stack
2387      * @param {string} key The key of the value to set.
2388      * @param {*} value The value to set.
2389      * @returns {Object} Returns the stack cache instance.
2390      */
2391     function stackSet(key, value) {
2392       var data = this.__data__;
2393       if (data instanceof ListCache) {
2394         var pairs = data.__data__;
2395         if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
2396           pairs.push([key, value]);
2397           this.size = ++data.size;
2398           return this;
2399         }
2400         data = this.__data__ = new MapCache(pairs);
2401       }
2402       data.set(key, value);
2403       this.size = data.size;
2404       return this;
2405     }
2406
2407     // Add methods to `Stack`.
2408     Stack.prototype.clear = stackClear;
2409     Stack.prototype['delete'] = stackDelete;
2410     Stack.prototype.get = stackGet;
2411     Stack.prototype.has = stackHas;
2412     Stack.prototype.set = stackSet;
2413
2414     /*------------------------------------------------------------------------*/
2415
2416     /**
2417      * Creates an array of the enumerable property names of the array-like `value`.
2418      *
2419      * @private
2420      * @param {*} value The value to query.
2421      * @param {boolean} inherited Specify returning inherited property names.
2422      * @returns {Array} Returns the array of property names.
2423      */
2424     function arrayLikeKeys(value, inherited) {
2425       var isArr = isArray(value),
2426           isArg = !isArr && isArguments(value),
2427           isBuff = !isArr && !isArg && isBuffer(value),
2428           isType = !isArr && !isArg && !isBuff && isTypedArray(value),
2429           skipIndexes = isArr || isArg || isBuff || isType,
2430           result = skipIndexes ? baseTimes(value.length, String) : [],
2431           length = result.length;
2432
2433       for (var key in value) {
2434         if ((inherited || hasOwnProperty.call(value, key)) &&
2435             !(skipIndexes && (
2436                // Safari 9 has enumerable `arguments.length` in strict mode.
2437                key == 'length' ||
2438                // Node.js 0.10 has enumerable non-index properties on buffers.
2439                (isBuff && (key == 'offset' || key == 'parent')) ||
2440                // PhantomJS 2 has enumerable non-index properties on typed arrays.
2441                (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
2442                // Skip index properties.
2443                isIndex(key, length)
2444             ))) {
2445           result.push(key);
2446         }
2447       }
2448       return result;
2449     }
2450
2451     /**
2452      * A specialized version of `_.sample` for arrays.
2453      *
2454      * @private
2455      * @param {Array} array The array to sample.
2456      * @returns {*} Returns the random element.
2457      */
2458     function arraySample(array) {
2459       var length = array.length;
2460       return length ? array[baseRandom(0, length - 1)] : undefined;
2461     }
2462
2463     /**
2464      * A specialized version of `_.sampleSize` for arrays.
2465      *
2466      * @private
2467      * @param {Array} array The array to sample.
2468      * @param {number} n The number of elements to sample.
2469      * @returns {Array} Returns the random elements.
2470      */
2471     function arraySampleSize(array, n) {
2472       return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
2473     }
2474
2475     /**
2476      * A specialized version of `_.shuffle` for arrays.
2477      *
2478      * @private
2479      * @param {Array} array The array to shuffle.
2480      * @returns {Array} Returns the new shuffled array.
2481      */
2482     function arrayShuffle(array) {
2483       return shuffleSelf(copyArray(array));
2484     }
2485
2486     /**
2487      * This function is like `assignValue` except that it doesn't assign
2488      * `undefined` values.
2489      *
2490      * @private
2491      * @param {Object} object The object to modify.
2492      * @param {string} key The key of the property to assign.
2493      * @param {*} value The value to assign.
2494      */
2495     function assignMergeValue(object, key, value) {
2496       if ((value !== undefined && !eq(object[key], value)) ||
2497           (value === undefined && !(key in object))) {
2498         baseAssignValue(object, key, value);
2499       }
2500     }
2501
2502     /**
2503      * Assigns `value` to `key` of `object` if the existing value is not equivalent
2504      * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
2505      * for equality comparisons.
2506      *
2507      * @private
2508      * @param {Object} object The object to modify.
2509      * @param {string} key The key of the property to assign.
2510      * @param {*} value The value to assign.
2511      */
2512     function assignValue(object, key, value) {
2513       var objValue = object[key];
2514       if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
2515           (value === undefined && !(key in object))) {
2516         baseAssignValue(object, key, value);
2517       }
2518     }
2519
2520     /**
2521      * Gets the index at which the `key` is found in `array` of key-value pairs.
2522      *
2523      * @private
2524      * @param {Array} array The array to inspect.
2525      * @param {*} key The key to search for.
2526      * @returns {number} Returns the index of the matched value, else `-1`.
2527      */
2528     function assocIndexOf(array, key) {
2529       var length = array.length;
2530       while (length--) {
2531         if (eq(array[length][0], key)) {
2532           return length;
2533         }
2534       }
2535       return -1;
2536     }
2537
2538     /**
2539      * Aggregates elements of `collection` on `accumulator` with keys transformed
2540      * by `iteratee` and values set by `setter`.
2541      *
2542      * @private
2543      * @param {Array|Object} collection The collection to iterate over.
2544      * @param {Function} setter The function to set `accumulator` values.
2545      * @param {Function} iteratee The iteratee to transform keys.
2546      * @param {Object} accumulator The initial aggregated object.
2547      * @returns {Function} Returns `accumulator`.
2548      */
2549     function baseAggregator(collection, setter, iteratee, accumulator) {
2550       baseEach(collection, function(value, key, collection) {
2551         setter(accumulator, value, iteratee(value), collection);
2552       });
2553       return accumulator;
2554     }
2555
2556     /**
2557      * The base implementation of `_.assign` without support for multiple sources
2558      * or `customizer` functions.
2559      *
2560      * @private
2561      * @param {Object} object The destination object.
2562      * @param {Object} source The source object.
2563      * @returns {Object} Returns `object`.
2564      */
2565     function baseAssign(object, source) {
2566       return object && copyObject(source, keys(source), object);
2567     }
2568
2569     /**
2570      * The base implementation of `_.assignIn` without support for multiple sources
2571      * or `customizer` functions.
2572      *
2573      * @private
2574      * @param {Object} object The destination object.
2575      * @param {Object} source The source object.
2576      * @returns {Object} Returns `object`.
2577      */
2578     function baseAssignIn(object, source) {
2579       return object && copyObject(source, keysIn(source), object);
2580     }
2581
2582     /**
2583      * The base implementation of `assignValue` and `assignMergeValue` without
2584      * value checks.
2585      *
2586      * @private
2587      * @param {Object} object The object to modify.
2588      * @param {string} key The key of the property to assign.
2589      * @param {*} value The value to assign.
2590      */
2591     function baseAssignValue(object, key, value) {
2592       if (key == '__proto__' && defineProperty) {
2593         defineProperty(object, key, {
2594           'configurable': true,
2595           'enumerable': true,
2596           'value': value,
2597           'writable': true
2598         });
2599       } else {
2600         object[key] = value;
2601       }
2602     }
2603
2604     /**
2605      * The base implementation of `_.at` without support for individual paths.
2606      *
2607      * @private
2608      * @param {Object} object The object to iterate over.
2609      * @param {string[]} paths The property paths to pick.
2610      * @returns {Array} Returns the picked elements.
2611      */
2612     function baseAt(object, paths) {
2613       var index = -1,
2614           length = paths.length,
2615           result = Array(length),
2616           skip = object == null;
2617
2618       while (++index < length) {
2619         result[index] = skip ? undefined : get(object, paths[index]);
2620       }
2621       return result;
2622     }
2623
2624     /**
2625      * The base implementation of `_.clamp` which doesn't coerce arguments.
2626      *
2627      * @private
2628      * @param {number} number The number to clamp.
2629      * @param {number} [lower] The lower bound.
2630      * @param {number} upper The upper bound.
2631      * @returns {number} Returns the clamped number.
2632      */
2633     function baseClamp(number, lower, upper) {
2634       if (number === number) {
2635         if (upper !== undefined) {
2636           number = number <= upper ? number : upper;
2637         }
2638         if (lower !== undefined) {
2639           number = number >= lower ? number : lower;
2640         }
2641       }
2642       return number;
2643     }
2644
2645     /**
2646      * The base implementation of `_.clone` and `_.cloneDeep` which tracks
2647      * traversed objects.
2648      *
2649      * @private
2650      * @param {*} value The value to clone.
2651      * @param {boolean} bitmask The bitmask flags.
2652      *  1 - Deep clone
2653      *  2 - Flatten inherited properties
2654      *  4 - Clone symbols
2655      * @param {Function} [customizer] The function to customize cloning.
2656      * @param {string} [key] The key of `value`.
2657      * @param {Object} [object] The parent object of `value`.
2658      * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
2659      * @returns {*} Returns the cloned value.
2660      */
2661     function baseClone(value, bitmask, customizer, key, object, stack) {
2662       var result,
2663           isDeep = bitmask & CLONE_DEEP_FLAG,
2664           isFlat = bitmask & CLONE_FLAT_FLAG,
2665           isFull = bitmask & CLONE_SYMBOLS_FLAG;
2666
2667       if (customizer) {
2668         result = object ? customizer(value, key, object, stack) : customizer(value);
2669       }
2670       if (result !== undefined) {
2671         return result;
2672       }
2673       if (!isObject(value)) {
2674         return value;
2675       }
2676       var isArr = isArray(value);
2677       if (isArr) {
2678         result = initCloneArray(value);
2679         if (!isDeep) {
2680           return copyArray(value, result);
2681         }
2682       } else {
2683         var tag = getTag(value),
2684             isFunc = tag == funcTag || tag == genTag;
2685
2686         if (isBuffer(value)) {
2687           return cloneBuffer(value, isDeep);
2688         }
2689         if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
2690           result = (isFlat || isFunc) ? {} : initCloneObject(value);
2691           if (!isDeep) {
2692             return isFlat
2693               ? copySymbolsIn(value, baseAssignIn(result, value))
2694               : copySymbols(value, baseAssign(result, value));
2695           }
2696         } else {
2697           if (!cloneableTags[tag]) {
2698             return object ? value : {};
2699           }
2700           result = initCloneByTag(value, tag, baseClone, isDeep);
2701         }
2702       }
2703       // Check for circular references and return its corresponding clone.
2704       stack || (stack = new Stack);
2705       var stacked = stack.get(value);
2706       if (stacked) {
2707         return stacked;
2708       }
2709       stack.set(value, result);
2710
2711       var keysFunc = isFull
2712         ? (isFlat ? getAllKeysIn : getAllKeys)
2713         : (isFlat ? keysIn : keys);
2714
2715       var props = isArr ? undefined : keysFunc(value);
2716       arrayEach(props || value, function(subValue, key) {
2717         if (props) {
2718           key = subValue;
2719           subValue = value[key];
2720         }
2721         // Recursively populate clone (susceptible to call stack limits).
2722         assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
2723       });
2724       return result;
2725     }
2726
2727     /**
2728      * The base implementation of `_.conforms` which doesn't clone `source`.
2729      *
2730      * @private
2731      * @param {Object} source The object of property predicates to conform to.
2732      * @returns {Function} Returns the new spec function.
2733      */
2734     function baseConforms(source) {
2735       var props = keys(source);
2736       return function(object) {
2737         return baseConformsTo(object, source, props);
2738       };
2739     }
2740
2741     /**
2742      * The base implementation of `_.conformsTo` which accepts `props` to check.
2743      *
2744      * @private
2745      * @param {Object} object The object to inspect.
2746      * @param {Object} source The object of property predicates to conform to.
2747      * @returns {boolean} Returns `true` if `object` conforms, else `false`.
2748      */
2749     function baseConformsTo(object, source, props) {
2750       var length = props.length;
2751       if (object == null) {
2752         return !length;
2753       }
2754       object = Object(object);
2755       while (length--) {
2756         var key = props[length],
2757             predicate = source[key],
2758             value = object[key];
2759
2760         if ((value === undefined && !(key in object)) || !predicate(value)) {
2761           return false;
2762         }
2763       }
2764       return true;
2765     }
2766
2767     /**
2768      * The base implementation of `_.delay` and `_.defer` which accepts `args`
2769      * to provide to `func`.
2770      *
2771      * @private
2772      * @param {Function} func The function to delay.
2773      * @param {number} wait The number of milliseconds to delay invocation.
2774      * @param {Array} args The arguments to provide to `func`.
2775      * @returns {number|Object} Returns the timer id or timeout object.
2776      */
2777     function baseDelay(func, wait, args) {
2778       if (typeof func != 'function') {
2779         throw new TypeError(FUNC_ERROR_TEXT);
2780       }
2781       return setTimeout(function() { func.apply(undefined, args); }, wait);
2782     }
2783
2784     /**
2785      * The base implementation of methods like `_.difference` without support
2786      * for excluding multiple arrays or iteratee shorthands.
2787      *
2788      * @private
2789      * @param {Array} array The array to inspect.
2790      * @param {Array} values The values to exclude.
2791      * @param {Function} [iteratee] The iteratee invoked per element.
2792      * @param {Function} [comparator] The comparator invoked per element.
2793      * @returns {Array} Returns the new array of filtered values.
2794      */
2795     function baseDifference(array, values, iteratee, comparator) {
2796       var index = -1,
2797           includes = arrayIncludes,
2798           isCommon = true,
2799           length = array.length,
2800           result = [],
2801           valuesLength = values.length;
2802
2803       if (!length) {
2804         return result;
2805       }
2806       if (iteratee) {
2807         values = arrayMap(values, baseUnary(iteratee));
2808       }
2809       if (comparator) {
2810         includes = arrayIncludesWith;
2811         isCommon = false;
2812       }
2813       else if (values.length >= LARGE_ARRAY_SIZE) {
2814         includes = cacheHas;
2815         isCommon = false;
2816         values = new SetCache(values);
2817       }
2818       outer:
2819       while (++index < length) {
2820         var value = array[index],
2821             computed = iteratee == null ? value : iteratee(value);
2822
2823         value = (comparator || value !== 0) ? value : 0;
2824         if (isCommon && computed === computed) {
2825           var valuesIndex = valuesLength;
2826           while (valuesIndex--) {
2827             if (values[valuesIndex] === computed) {
2828               continue outer;
2829             }
2830           }
2831           result.push(value);
2832         }
2833         else if (!includes(values, computed, comparator)) {
2834           result.push(value);
2835         }
2836       }
2837       return result;
2838     }
2839
2840     /**
2841      * The base implementation of `_.forEach` without support for iteratee shorthands.
2842      *
2843      * @private
2844      * @param {Array|Object} collection The collection to iterate over.
2845      * @param {Function} iteratee The function invoked per iteration.
2846      * @returns {Array|Object} Returns `collection`.
2847      */
2848     var baseEach = createBaseEach(baseForOwn);
2849
2850     /**
2851      * The base implementation of `_.forEachRight` without support for iteratee shorthands.
2852      *
2853      * @private
2854      * @param {Array|Object} collection The collection to iterate over.
2855      * @param {Function} iteratee The function invoked per iteration.
2856      * @returns {Array|Object} Returns `collection`.
2857      */
2858     var baseEachRight = createBaseEach(baseForOwnRight, true);
2859
2860     /**
2861      * The base implementation of `_.every` without support for iteratee shorthands.
2862      *
2863      * @private
2864      * @param {Array|Object} collection The collection to iterate over.
2865      * @param {Function} predicate The function invoked per iteration.
2866      * @returns {boolean} Returns `true` if all elements pass the predicate check,
2867      *  else `false`
2868      */
2869     function baseEvery(collection, predicate) {
2870       var result = true;
2871       baseEach(collection, function(value, index, collection) {
2872         result = !!predicate(value, index, collection);
2873         return result;
2874       });
2875       return result;
2876     }
2877
2878     /**
2879      * The base implementation of methods like `_.max` and `_.min` which accepts a
2880      * `comparator` to determine the extremum value.
2881      *
2882      * @private
2883      * @param {Array} array The array to iterate over.
2884      * @param {Function} iteratee The iteratee invoked per iteration.
2885      * @param {Function} comparator The comparator used to compare values.
2886      * @returns {*} Returns the extremum value.
2887      */
2888     function baseExtremum(array, iteratee, comparator) {
2889       var index = -1,
2890           length = array.length;
2891
2892       while (++index < length) {
2893         var value = array[index],
2894             current = iteratee(value);
2895
2896         if (current != null && (computed === undefined
2897               ? (current === current && !isSymbol(current))
2898               : comparator(current, computed)
2899             )) {
2900           var computed = current,
2901               result = value;
2902         }
2903       }
2904       return result;
2905     }
2906
2907     /**
2908      * The base implementation of `_.fill` without an iteratee call guard.
2909      *
2910      * @private
2911      * @param {Array} array The array to fill.
2912      * @param {*} value The value to fill `array` with.
2913      * @param {number} [start=0] The start position.
2914      * @param {number} [end=array.length] The end position.
2915      * @returns {Array} Returns `array`.
2916      */
2917     function baseFill(array, value, start, end) {
2918       var length = array.length;
2919
2920       start = toInteger(start);
2921       if (start < 0) {
2922         start = -start > length ? 0 : (length + start);
2923       }
2924       end = (end === undefined || end > length) ? length : toInteger(end);
2925       if (end < 0) {
2926         end += length;
2927       }
2928       end = start > end ? 0 : toLength(end);
2929       while (start < end) {
2930         array[start++] = value;
2931       }
2932       return array;
2933     }
2934
2935     /**
2936      * The base implementation of `_.filter` without support for iteratee shorthands.
2937      *
2938      * @private
2939      * @param {Array|Object} collection The collection to iterate over.
2940      * @param {Function} predicate The function invoked per iteration.
2941      * @returns {Array} Returns the new filtered array.
2942      */
2943     function baseFilter(collection, predicate) {
2944       var result = [];
2945       baseEach(collection, function(value, index, collection) {
2946         if (predicate(value, index, collection)) {
2947           result.push(value);
2948         }
2949       });
2950       return result;
2951     }
2952
2953     /**
2954      * The base implementation of `_.flatten` with support for restricting flattening.
2955      *
2956      * @private
2957      * @param {Array} array The array to flatten.
2958      * @param {number} depth The maximum recursion depth.
2959      * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
2960      * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
2961      * @param {Array} [result=[]] The initial result value.
2962      * @returns {Array} Returns the new flattened array.
2963      */
2964     function baseFlatten(array, depth, predicate, isStrict, result) {
2965       var index = -1,
2966           length = array.length;
2967
2968       predicate || (predicate = isFlattenable);
2969       result || (result = []);
2970
2971       while (++index < length) {
2972         var value = array[index];
2973         if (depth > 0 && predicate(value)) {
2974           if (depth > 1) {
2975             // Recursively flatten arrays (susceptible to call stack limits).
2976             baseFlatten(value, depth - 1, predicate, isStrict, result);
2977           } else {
2978             arrayPush(result, value);
2979           }
2980         } else if (!isStrict) {
2981           result[result.length] = value;
2982         }
2983       }
2984       return result;
2985     }
2986
2987     /**
2988      * The base implementation of `baseForOwn` which iterates over `object`
2989      * properties returned by `keysFunc` and invokes `iteratee` for each property.
2990      * Iteratee functions may exit iteration early by explicitly returning `false`.
2991      *
2992      * @private
2993      * @param {Object} object The object to iterate over.
2994      * @param {Function} iteratee The function invoked per iteration.
2995      * @param {Function} keysFunc The function to get the keys of `object`.
2996      * @returns {Object} Returns `object`.
2997      */
2998     var baseFor = createBaseFor();
2999
3000     /**
3001      * This function is like `baseFor` except that it iterates over properties
3002      * in the opposite order.
3003      *
3004      * @private
3005      * @param {Object} object The object to iterate over.
3006      * @param {Function} iteratee The function invoked per iteration.
3007      * @param {Function} keysFunc The function to get the keys of `object`.
3008      * @returns {Object} Returns `object`.
3009      */
3010     var baseForRight = createBaseFor(true);
3011
3012     /**
3013      * The base implementation of `_.forOwn` without support for iteratee shorthands.
3014      *
3015      * @private
3016      * @param {Object} object The object to iterate over.
3017      * @param {Function} iteratee The function invoked per iteration.
3018      * @returns {Object} Returns `object`.
3019      */
3020     function baseForOwn(object, iteratee) {
3021       return object && baseFor(object, iteratee, keys);
3022     }
3023
3024     /**
3025      * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
3026      *
3027      * @private
3028      * @param {Object} object The object to iterate over.
3029      * @param {Function} iteratee The function invoked per iteration.
3030      * @returns {Object} Returns `object`.
3031      */
3032     function baseForOwnRight(object, iteratee) {
3033       return object && baseForRight(object, iteratee, keys);
3034     }
3035
3036     /**
3037      * The base implementation of `_.functions` which creates an array of
3038      * `object` function property names filtered from `props`.
3039      *
3040      * @private
3041      * @param {Object} object The object to inspect.
3042      * @param {Array} props The property names to filter.
3043      * @returns {Array} Returns the function names.
3044      */
3045     function baseFunctions(object, props) {
3046       return arrayFilter(props, function(key) {
3047         return isFunction(object[key]);
3048       });
3049     }
3050
3051     /**
3052      * The base implementation of `_.get` without support for default values.
3053      *
3054      * @private
3055      * @param {Object} object The object to query.
3056      * @param {Array|string} path The path of the property to get.
3057      * @returns {*} Returns the resolved value.
3058      */
3059     function baseGet(object, path) {
3060       path = castPath(path, object);
3061
3062       var index = 0,
3063           length = path.length;
3064
3065       while (object != null && index < length) {
3066         object = object[toKey(path[index++])];
3067       }
3068       return (index && index == length) ? object : undefined;
3069     }
3070
3071     /**
3072      * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
3073      * `keysFunc` and `symbolsFunc` to get the enumerable property names and
3074      * symbols of `object`.
3075      *
3076      * @private
3077      * @param {Object} object The object to query.
3078      * @param {Function} keysFunc The function to get the keys of `object`.
3079      * @param {Function} symbolsFunc The function to get the symbols of `object`.
3080      * @returns {Array} Returns the array of property names and symbols.
3081      */
3082     function baseGetAllKeys(object, keysFunc, symbolsFunc) {
3083       var result = keysFunc(object);
3084       return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
3085     }
3086
3087     /**
3088      * The base implementation of `getTag` without fallbacks for buggy environments.
3089      *
3090      * @private
3091      * @param {*} value The value to query.
3092      * @returns {string} Returns the `toStringTag`.
3093      */
3094     function baseGetTag(value) {
3095       if (value == null) {
3096         return value === undefined ? undefinedTag : nullTag;
3097       }
3098       return (symToStringTag && symToStringTag in Object(value))
3099         ? getRawTag(value)
3100         : objectToString(value);
3101     }
3102
3103     /**
3104      * The base implementation of `_.gt` which doesn't coerce arguments.
3105      *
3106      * @private
3107      * @param {*} value The value to compare.
3108      * @param {*} other The other value to compare.
3109      * @returns {boolean} Returns `true` if `value` is greater than `other`,
3110      *  else `false`.
3111      */
3112     function baseGt(value, other) {
3113       return value > other;
3114     }
3115
3116     /**
3117      * The base implementation of `_.has` without support for deep paths.
3118      *
3119      * @private
3120      * @param {Object} [object] The object to query.
3121      * @param {Array|string} key The key to check.
3122      * @returns {boolean} Returns `true` if `key` exists, else `false`.
3123      */
3124     function baseHas(object, key) {
3125       return object != null && hasOwnProperty.call(object, key);
3126     }
3127
3128     /**
3129      * The base implementation of `_.hasIn` without support for deep paths.
3130      *
3131      * @private
3132      * @param {Object} [object] The object to query.
3133      * @param {Array|string} key The key to check.
3134      * @returns {boolean} Returns `true` if `key` exists, else `false`.
3135      */
3136     function baseHasIn(object, key) {
3137       return object != null && key in Object(object);
3138     }
3139
3140     /**
3141      * The base implementation of `_.inRange` which doesn't coerce arguments.
3142      *
3143      * @private
3144      * @param {number} number The number to check.
3145      * @param {number} start The start of the range.
3146      * @param {number} end The end of the range.
3147      * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
3148      */
3149     function baseInRange(number, start, end) {
3150       return number >= nativeMin(start, end) && number < nativeMax(start, end);
3151     }
3152
3153     /**
3154      * The base implementation of methods like `_.intersection`, without support
3155      * for iteratee shorthands, that accepts an array of arrays to inspect.
3156      *
3157      * @private
3158      * @param {Array} arrays The arrays to inspect.
3159      * @param {Function} [iteratee] The iteratee invoked per element.
3160      * @param {Function} [comparator] The comparator invoked per element.
3161      * @returns {Array} Returns the new array of shared values.
3162      */
3163     function baseIntersection(arrays, iteratee, comparator) {
3164       var includes = comparator ? arrayIncludesWith : arrayIncludes,
3165           length = arrays[0].length,
3166           othLength = arrays.length,
3167           othIndex = othLength,
3168           caches = Array(othLength),
3169           maxLength = Infinity,
3170           result = [];
3171
3172       while (othIndex--) {
3173         var array = arrays[othIndex];
3174         if (othIndex && iteratee) {
3175           array = arrayMap(array, baseUnary(iteratee));
3176         }
3177         maxLength = nativeMin(array.length, maxLength);
3178         caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
3179           ? new SetCache(othIndex && array)
3180           : undefined;
3181       }
3182       array = arrays[0];
3183
3184       var index = -1,
3185           seen = caches[0];
3186
3187       outer:
3188       while (++index < length && result.length < maxLength) {
3189         var value = array[index],
3190             computed = iteratee ? iteratee(value) : value;
3191
3192         value = (comparator || value !== 0) ? value : 0;
3193         if (!(seen
3194               ? cacheHas(seen, computed)
3195               : includes(result, computed, comparator)
3196             )) {
3197           othIndex = othLength;
3198           while (--othIndex) {
3199             var cache = caches[othIndex];
3200             if (!(cache
3201                   ? cacheHas(cache, computed)
3202                   : includes(arrays[othIndex], computed, comparator))
3203                 ) {
3204               continue outer;
3205             }
3206           }
3207           if (seen) {
3208             seen.push(computed);
3209           }
3210           result.push(value);
3211         }
3212       }
3213       return result;
3214     }
3215
3216     /**
3217      * The base implementation of `_.invert` and `_.invertBy` which inverts
3218      * `object` with values transformed by `iteratee` and set by `setter`.
3219      *
3220      * @private
3221      * @param {Object} object The object to iterate over.
3222      * @param {Function} setter The function to set `accumulator` values.
3223      * @param {Function} iteratee The iteratee to transform values.
3224      * @param {Object} accumulator The initial inverted object.
3225      * @returns {Function} Returns `accumulator`.
3226      */
3227     function baseInverter(object, setter, iteratee, accumulator) {
3228       baseForOwn(object, function(value, key, object) {
3229         setter(accumulator, iteratee(value), key, object);
3230       });
3231       return accumulator;
3232     }
3233
3234     /**
3235      * The base implementation of `_.invoke` without support for individual
3236      * method arguments.
3237      *
3238      * @private
3239      * @param {Object} object The object to query.
3240      * @param {Array|string} path The path of the method to invoke.
3241      * @param {Array} args The arguments to invoke the method with.
3242      * @returns {*} Returns the result of the invoked method.
3243      */
3244     function baseInvoke(object, path, args) {
3245       path = castPath(path, object);
3246       object = parent(object, path);
3247       var func = object == null ? object : object[toKey(last(path))];
3248       return func == null ? undefined : apply(func, object, args);
3249     }
3250
3251     /**
3252      * The base implementation of `_.isArguments`.
3253      *
3254      * @private
3255      * @param {*} value The value to check.
3256      * @returns {boolean} Returns `true` if `value` is an `arguments` object,
3257      */
3258     function baseIsArguments(value) {
3259       return isObjectLike(value) && baseGetTag(value) == argsTag;
3260     }
3261
3262     /**
3263      * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
3264      *
3265      * @private
3266      * @param {*} value The value to check.
3267      * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
3268      */
3269     function baseIsArrayBuffer(value) {
3270       return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
3271     }
3272
3273     /**
3274      * The base implementation of `_.isDate` without Node.js optimizations.
3275      *
3276      * @private
3277      * @param {*} value The value to check.
3278      * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
3279      */
3280     function baseIsDate(value) {
3281       return isObjectLike(value) && baseGetTag(value) == dateTag;
3282     }
3283
3284     /**
3285      * The base implementation of `_.isEqual` which supports partial comparisons
3286      * and tracks traversed objects.
3287      *
3288      * @private
3289      * @param {*} value The value to compare.
3290      * @param {*} other The other value to compare.
3291      * @param {boolean} bitmask The bitmask flags.
3292      *  1 - Unordered comparison
3293      *  2 - Partial comparison
3294      * @param {Function} [customizer] The function to customize comparisons.
3295      * @param {Object} [stack] Tracks traversed `value` and `other` objects.
3296      * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
3297      */
3298     function baseIsEqual(value, other, bitmask, customizer, stack) {
3299       if (value === other) {
3300         return true;
3301       }
3302       if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
3303         return value !== value && other !== other;
3304       }
3305       return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
3306     }
3307
3308     /**
3309      * A specialized version of `baseIsEqual` for arrays and objects which performs
3310      * deep comparisons and tracks traversed objects enabling objects with circular
3311      * references to be compared.
3312      *
3313      * @private
3314      * @param {Object} object The object to compare.
3315      * @param {Object} other The other object to compare.
3316      * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
3317      * @param {Function} customizer The function to customize comparisons.
3318      * @param {Function} equalFunc The function to determine equivalents of values.
3319      * @param {Object} [stack] Tracks traversed `object` and `other` objects.
3320      * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
3321      */
3322     function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
3323       var objIsArr = isArray(object),
3324           othIsArr = isArray(other),
3325           objTag = objIsArr ? arrayTag : getTag(object),
3326           othTag = othIsArr ? arrayTag : getTag(other);
3327
3328       objTag = objTag == argsTag ? objectTag : objTag;
3329       othTag = othTag == argsTag ? objectTag : othTag;
3330
3331       var objIsObj = objTag == objectTag,
3332           othIsObj = othTag == objectTag,
3333           isSameTag = objTag == othTag;
3334
3335       if (isSameTag && isBuffer(object)) {
3336         if (!isBuffer(other)) {
3337           return false;
3338         }
3339         objIsArr = true;
3340         objIsObj = false;
3341       }
3342       if (isSameTag && !objIsObj) {
3343         stack || (stack = new Stack);
3344         return (objIsArr || isTypedArray(object))
3345           ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
3346           : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
3347       }
3348       if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
3349         var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
3350             othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
3351
3352         if (objIsWrapped || othIsWrapped) {
3353           var objUnwrapped = objIsWrapped ? object.value() : object,
3354               othUnwrapped = othIsWrapped ? other.value() : other;
3355
3356           stack || (stack = new Stack);
3357           return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
3358         }
3359       }
3360       if (!isSameTag) {
3361         return false;
3362       }
3363       stack || (stack = new Stack);
3364       return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
3365     }
3366
3367     /**
3368      * The base implementation of `_.isMap` without Node.js optimizations.
3369      *
3370      * @private
3371      * @param {*} value The value to check.
3372      * @returns {boolean} Returns `true` if `value` is a map, else `false`.
3373      */
3374     function baseIsMap(value) {
3375       return isObjectLike(value) && getTag(value) == mapTag;
3376     }
3377
3378     /**
3379      * The base implementation of `_.isMatch` without support for iteratee shorthands.
3380      *
3381      * @private
3382      * @param {Object} object The object to inspect.
3383      * @param {Object} source The object of property values to match.
3384      * @param {Array} matchData The property names, values, and compare flags to match.
3385      * @param {Function} [customizer] The function to customize comparisons.
3386      * @returns {boolean} Returns `true` if `object` is a match, else `false`.
3387      */
3388     function baseIsMatch(object, source, matchData, customizer) {
3389       var index = matchData.length,
3390           length = index,
3391           noCustomizer = !customizer;
3392
3393       if (object == null) {
3394         return !length;
3395       }
3396       object = Object(object);
3397       while (index--) {
3398         var data = matchData[index];
3399         if ((noCustomizer && data[2])
3400               ? data[1] !== object[data[0]]
3401               : !(data[0] in object)
3402             ) {
3403           return false;
3404         }
3405       }
3406       while (++index < length) {
3407         data = matchData[index];
3408         var key = data[0],
3409             objValue = object[key],
3410             srcValue = data[1];
3411
3412         if (noCustomizer && data[2]) {
3413           if (objValue === undefined && !(key in object)) {
3414             return false;
3415           }
3416         } else {
3417           var stack = new Stack;
3418           if (customizer) {
3419             var result = customizer(objValue, srcValue, key, object, source, stack);
3420           }
3421           if (!(result === undefined
3422                 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
3423                 : result
3424               )) {
3425             return false;
3426           }
3427         }
3428       }
3429       return true;
3430     }
3431
3432     /**
3433      * The base implementation of `_.isNative` without bad shim checks.
3434      *
3435      * @private
3436      * @param {*} value The value to check.
3437      * @returns {boolean} Returns `true` if `value` is a native function,
3438      *  else `false`.
3439      */
3440     function baseIsNative(value) {
3441       if (!isObject(value) || isMasked(value)) {
3442         return false;
3443       }
3444       var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
3445       return pattern.test(toSource(value));
3446     }
3447
3448     /**
3449      * The base implementation of `_.isRegExp` without Node.js optimizations.
3450      *
3451      * @private
3452      * @param {*} value The value to check.
3453      * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
3454      */
3455     function baseIsRegExp(value) {
3456       return isObjectLike(value) && baseGetTag(value) == regexpTag;
3457     }
3458
3459     /**
3460      * The base implementation of `_.isSet` without Node.js optimizations.
3461      *
3462      * @private
3463      * @param {*} value The value to check.
3464      * @returns {boolean} Returns `true` if `value` is a set, else `false`.
3465      */
3466     function baseIsSet(value) {
3467       return isObjectLike(value) && getTag(value) == setTag;
3468     }
3469
3470     /**
3471      * The base implementation of `_.isTypedArray` without Node.js optimizations.
3472      *
3473      * @private
3474      * @param {*} value The value to check.
3475      * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
3476      */
3477     function baseIsTypedArray(value) {
3478       return isObjectLike(value) &&
3479         isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
3480     }
3481
3482     /**
3483      * The base implementation of `_.iteratee`.
3484      *
3485      * @private
3486      * @param {*} [value=_.identity] The value to convert to an iteratee.
3487      * @returns {Function} Returns the iteratee.
3488      */
3489     function baseIteratee(value) {
3490       // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
3491       // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
3492       if (typeof value == 'function') {
3493         return value;
3494       }
3495       if (value == null) {
3496         return identity;
3497       }
3498       if (typeof value == 'object') {
3499         return isArray(value)
3500           ? baseMatchesProperty(value[0], value[1])
3501           : baseMatches(value);
3502       }
3503       return property(value);
3504     }
3505
3506     /**
3507      * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
3508      *
3509      * @private
3510      * @param {Object} object The object to query.
3511      * @returns {Array} Returns the array of property names.
3512      */
3513     function baseKeys(object) {
3514       if (!isPrototype(object)) {
3515         return nativeKeys(object);
3516       }
3517       var result = [];
3518       for (var key in Object(object)) {
3519         if (hasOwnProperty.call(object, key) && key != 'constructor') {
3520           result.push(key);
3521         }
3522       }
3523       return result;
3524     }
3525
3526     /**
3527      * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
3528      *
3529      * @private
3530      * @param {Object} object The object to query.
3531      * @returns {Array} Returns the array of property names.
3532      */
3533     function baseKeysIn(object) {
3534       if (!isObject(object)) {
3535         return nativeKeysIn(object);
3536       }
3537       var isProto = isPrototype(object),
3538           result = [];
3539
3540       for (var key in object) {
3541         if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
3542           result.push(key);
3543         }
3544       }
3545       return result;
3546     }
3547
3548     /**
3549      * The base implementation of `_.lt` which doesn't coerce arguments.
3550      *
3551      * @private
3552      * @param {*} value The value to compare.
3553      * @param {*} other The other value to compare.
3554      * @returns {boolean} Returns `true` if `value` is less than `other`,
3555      *  else `false`.
3556      */
3557     function baseLt(value, other) {
3558       return value < other;
3559     }
3560
3561     /**
3562      * The base implementation of `_.map` without support for iteratee shorthands.
3563      *
3564      * @private
3565      * @param {Array|Object} collection The collection to iterate over.
3566      * @param {Function} iteratee The function invoked per iteration.
3567      * @returns {Array} Returns the new mapped array.
3568      */
3569     function baseMap(collection, iteratee) {
3570       var index = -1,
3571           result = isArrayLike(collection) ? Array(collection.length) : [];
3572
3573       baseEach(collection, function(value, key, collection) {
3574         result[++index] = iteratee(value, key, collection);
3575       });
3576       return result;
3577     }
3578
3579     /**
3580      * The base implementation of `_.matches` which doesn't clone `source`.
3581      *
3582      * @private
3583      * @param {Object} source The object of property values to match.
3584      * @returns {Function} Returns the new spec function.
3585      */
3586     function baseMatches(source) {
3587       var matchData = getMatchData(source);
3588       if (matchData.length == 1 && matchData[0][2]) {
3589         return matchesStrictComparable(matchData[0][0], matchData[0][1]);
3590       }
3591       return function(object) {
3592         return object === source || baseIsMatch(object, source, matchData);
3593       };
3594     }
3595
3596     /**
3597      * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
3598      *
3599      * @private
3600      * @param {string} path The path of the property to get.
3601      * @param {*} srcValue The value to match.
3602      * @returns {Function} Returns the new spec function.
3603      */
3604     function baseMatchesProperty(path, srcValue) {
3605       if (isKey(path) && isStrictComparable(srcValue)) {
3606         return matchesStrictComparable(toKey(path), srcValue);
3607       }
3608       return function(object) {
3609         var objValue = get(object, path);
3610         return (objValue === undefined && objValue === srcValue)
3611           ? hasIn(object, path)
3612           : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
3613       };
3614     }
3615
3616     /**
3617      * The base implementation of `_.merge` without support for multiple sources.
3618      *
3619      * @private
3620      * @param {Object} object The destination object.
3621      * @param {Object} source The source object.
3622      * @param {number} srcIndex The index of `source`.
3623      * @param {Function} [customizer] The function to customize merged values.
3624      * @param {Object} [stack] Tracks traversed source values and their merged
3625      *  counterparts.
3626      */
3627     function baseMerge(object, source, srcIndex, customizer, stack) {
3628       if (object === source) {
3629         return;
3630       }
3631       baseFor(source, function(srcValue, key) {
3632         if (isObject(srcValue)) {
3633           stack || (stack = new Stack);
3634           baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
3635         }
3636         else {
3637           var newValue = customizer
3638             ? customizer(object[key], srcValue, (key + ''), object, source, stack)
3639             : undefined;
3640
3641           if (newValue === undefined) {
3642             newValue = srcValue;
3643           }
3644           assignMergeValue(object, key, newValue);
3645         }
3646       }, keysIn);
3647     }
3648
3649     /**
3650      * A specialized version of `baseMerge` for arrays and objects which performs
3651      * deep merges and tracks traversed objects enabling objects with circular
3652      * references to be merged.
3653      *
3654      * @private
3655      * @param {Object} object The destination object.
3656      * @param {Object} source The source object.
3657      * @param {string} key The key of the value to merge.
3658      * @param {number} srcIndex The index of `source`.
3659      * @param {Function} mergeFunc The function to merge values.
3660      * @param {Function} [customizer] The function to customize assigned values.
3661      * @param {Object} [stack] Tracks traversed source values and their merged
3662      *  counterparts.
3663      */
3664     function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
3665       var objValue = object[key],
3666           srcValue = source[key],
3667           stacked = stack.get(srcValue);
3668
3669       if (stacked) {
3670         assignMergeValue(object, key, stacked);
3671         return;
3672       }
3673       var newValue = customizer
3674         ? customizer(objValue, srcValue, (key + ''), object, source, stack)
3675         : undefined;
3676
3677       var isCommon = newValue === undefined;
3678
3679       if (isCommon) {
3680         var isArr = isArray(srcValue),
3681             isBuff = !isArr && isBuffer(srcValue),
3682             isTyped = !isArr && !isBuff && isTypedArray(srcValue);
3683
3684         newValue = srcValue;
3685         if (isArr || isBuff || isTyped) {
3686           if (isArray(objValue)) {
3687             newValue = objValue;
3688           }
3689           else if (isArrayLikeObject(objValue)) {
3690             newValue = copyArray(objValue);
3691           }
3692           else if (isBuff) {
3693             isCommon = false;
3694             newValue = cloneBuffer(srcValue, true);
3695           }
3696           else if (isTyped) {
3697             isCommon = false;
3698             newValue = cloneTypedArray(srcValue, true);
3699           }
3700           else {
3701             newValue = [];
3702           }
3703         }
3704         else if (isPlainObject(srcValue) || isArguments(srcValue)) {
3705           newValue = objValue;
3706           if (isArguments(objValue)) {
3707             newValue = toPlainObject(objValue);
3708           }
3709           else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
3710             newValue = initCloneObject(srcValue);
3711           }
3712         }
3713         else {
3714           isCommon = false;
3715         }
3716       }
3717       if (isCommon) {
3718         // Recursively merge objects and arrays (susceptible to call stack limits).
3719         stack.set(srcValue, newValue);
3720         mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
3721         stack['delete'](srcValue);
3722       }
3723       assignMergeValue(object, key, newValue);
3724     }
3725
3726     /**
3727      * The base implementation of `_.nth` which doesn't coerce arguments.
3728      *
3729      * @private
3730      * @param {Array} array The array to query.
3731      * @param {number} n The index of the element to return.
3732      * @returns {*} Returns the nth element of `array`.
3733      */
3734     function baseNth(array, n) {
3735       var length = array.length;
3736       if (!length) {
3737         return;
3738       }
3739       n += n < 0 ? length : 0;
3740       return isIndex(n, length) ? array[n] : undefined;
3741     }
3742
3743     /**
3744      * The base implementation of `_.orderBy` without param guards.
3745      *
3746      * @private
3747      * @param {Array|Object} collection The collection to iterate over.
3748      * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
3749      * @param {string[]} orders The sort orders of `iteratees`.
3750      * @returns {Array} Returns the new sorted array.
3751      */
3752     function baseOrderBy(collection, iteratees, orders) {
3753       var index = -1;
3754       iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));
3755
3756       var result = baseMap(collection, function(value, key, collection) {
3757         var criteria = arrayMap(iteratees, function(iteratee) {
3758           return iteratee(value);
3759         });
3760         return { 'criteria': criteria, 'index': ++index, 'value': value };
3761       });
3762
3763       return baseSortBy(result, function(object, other) {
3764         return compareMultiple(object, other, orders);
3765       });
3766     }
3767
3768     /**
3769      * The base implementation of `_.pick` without support for individual
3770      * property identifiers.
3771      *
3772      * @private
3773      * @param {Object} object The source object.
3774      * @param {string[]} paths The property paths to pick.
3775      * @returns {Object} Returns the new object.
3776      */
3777     function basePick(object, paths) {
3778       return basePickBy(object, paths, function(value, path) {
3779         return hasIn(object, path);
3780       });
3781     }
3782
3783     /**
3784      * The base implementation of  `_.pickBy` without support for iteratee shorthands.
3785      *
3786      * @private
3787      * @param {Object} object The source object.
3788      * @param {string[]} paths The property paths to pick.
3789      * @param {Function} predicate The function invoked per property.
3790      * @returns {Object} Returns the new object.
3791      */
3792     function basePickBy(object, paths, predicate) {
3793       var index = -1,
3794           length = paths.length,
3795           result = {};
3796
3797       while (++index < length) {
3798         var path = paths[index],
3799             value = baseGet(object, path);
3800
3801         if (predicate(value, path)) {
3802           baseSet(result, castPath(path, object), value);
3803         }
3804       }
3805       return result;
3806     }
3807
3808     /**
3809      * A specialized version of `baseProperty` which supports deep paths.
3810      *
3811      * @private
3812      * @param {Array|string} path The path of the property to get.
3813      * @returns {Function} Returns the new accessor function.
3814      */
3815     function basePropertyDeep(path) {
3816       return function(object) {
3817         return baseGet(object, path);
3818       };
3819     }
3820
3821     /**
3822      * The base implementation of `_.pullAllBy` without support for iteratee
3823      * shorthands.
3824      *
3825      * @private
3826      * @param {Array} array The array to modify.
3827      * @param {Array} values The values to remove.
3828      * @param {Function} [iteratee] The iteratee invoked per element.
3829      * @param {Function} [comparator] The comparator invoked per element.
3830      * @returns {Array} Returns `array`.
3831      */
3832     function basePullAll(array, values, iteratee, comparator) {
3833       var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
3834           index = -1,
3835           length = values.length,
3836           seen = array;
3837
3838       if (array === values) {
3839         values = copyArray(values);
3840       }
3841       if (iteratee) {
3842         seen = arrayMap(array, baseUnary(iteratee));
3843       }
3844       while (++index < length) {
3845         var fromIndex = 0,
3846             value = values[index],
3847             computed = iteratee ? iteratee(value) : value;
3848
3849         while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
3850           if (seen !== array) {
3851             splice.call(seen, fromIndex, 1);
3852           }
3853           splice.call(array, fromIndex, 1);
3854         }
3855       }
3856       return array;
3857     }
3858
3859     /**
3860      * The base implementation of `_.pullAt` without support for individual
3861      * indexes or capturing the removed elements.
3862      *
3863      * @private
3864      * @param {Array} array The array to modify.
3865      * @param {number[]} indexes The indexes of elements to remove.
3866      * @returns {Array} Returns `array`.
3867      */
3868     function basePullAt(array, indexes) {
3869       var length = array ? indexes.length : 0,
3870           lastIndex = length - 1;
3871
3872       while (length--) {
3873         var index = indexes[length];
3874         if (length == lastIndex || index !== previous) {
3875           var previous = index;
3876           if (isIndex(index)) {
3877             splice.call(array, index, 1);
3878           } else {
3879             baseUnset(array, index);
3880           }
3881         }
3882       }
3883       return array;
3884     }
3885
3886     /**
3887      * The base implementation of `_.random` without support for returning
3888      * floating-point numbers.
3889      *
3890      * @private
3891      * @param {number} lower The lower bound.
3892      * @param {number} upper The upper bound.
3893      * @returns {number} Returns the random number.
3894      */
3895     function baseRandom(lower, upper) {
3896       return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
3897     }
3898
3899     /**
3900      * The base implementation of `_.range` and `_.rangeRight` which doesn't
3901      * coerce arguments.
3902      *
3903      * @private
3904      * @param {number} start The start of the range.
3905      * @param {number} end The end of the range.
3906      * @param {number} step The value to increment or decrement by.
3907      * @param {boolean} [fromRight] Specify iterating from right to left.
3908      * @returns {Array} Returns the range of numbers.
3909      */
3910     function baseRange(start, end, step, fromRight) {
3911       var index = -1,
3912           length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
3913           result = Array(length);
3914
3915       while (length--) {
3916         result[fromRight ? length : ++index] = start;
3917         start += step;
3918       }
3919       return result;
3920     }
3921
3922     /**
3923      * The base implementation of `_.repeat` which doesn't coerce arguments.
3924      *
3925      * @private
3926      * @param {string} string The string to repeat.
3927      * @param {number} n The number of times to repeat the string.
3928      * @returns {string} Returns the repeated string.
3929      */
3930     function baseRepeat(string, n) {
3931       var result = '';
3932       if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
3933         return result;
3934       }
3935       // Leverage the exponentiation by squaring algorithm for a faster repeat.
3936       // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
3937       do {
3938         if (n % 2) {
3939           result += string;
3940         }
3941         n = nativeFloor(n / 2);
3942         if (n) {
3943           string += string;
3944         }
3945       } while (n);
3946
3947       return result;
3948     }
3949
3950     /**
3951      * The base implementation of `_.rest` which doesn't validate or coerce arguments.
3952      *
3953      * @private
3954      * @param {Function} func The function to apply a rest parameter to.
3955      * @param {number} [start=func.length-1] The start position of the rest parameter.
3956      * @returns {Function} Returns the new function.
3957      */
3958     function baseRest(func, start) {
3959       return setToString(overRest(func, start, identity), func + '');
3960     }
3961
3962     /**
3963      * The base implementation of `_.sample`.
3964      *
3965      * @private
3966      * @param {Array|Object} collection The collection to sample.
3967      * @returns {*} Returns the random element.
3968      */
3969     function baseSample(collection) {
3970       return arraySample(values(collection));
3971     }
3972
3973     /**
3974      * The base implementation of `_.sampleSize` without param guards.
3975      *
3976      * @private
3977      * @param {Array|Object} collection The collection to sample.
3978      * @param {number} n The number of elements to sample.
3979      * @returns {Array} Returns the random elements.
3980      */
3981     function baseSampleSize(collection, n) {
3982       var array = values(collection);
3983       return shuffleSelf(array, baseClamp(n, 0, array.length));
3984     }
3985
3986     /**
3987      * The base implementation of `_.set`.
3988      *
3989      * @private
3990      * @param {Object} object The object to modify.
3991      * @param {Array|string} path The path of the property to set.
3992      * @param {*} value The value to set.
3993      * @param {Function} [customizer] The function to customize path creation.
3994      * @returns {Object} Returns `object`.
3995      */
3996     function baseSet(object, path, value, customizer) {
3997       if (!isObject(object)) {
3998         return object;
3999       }
4000       path = castPath(path, object);
4001
4002       var index = -1,
4003           length = path.length,
4004           lastIndex = length - 1,
4005           nested = object;
4006
4007       while (nested != null && ++index < length) {
4008         var key = toKey(path[index]),
4009             newValue = value;
4010
4011         if (index != lastIndex) {
4012           var objValue = nested[key];
4013           newValue = customizer ? customizer(objValue, key, nested) : undefined;
4014           if (newValue === undefined) {
4015             newValue = isObject(objValue)
4016               ? objValue
4017               : (isIndex(path[index + 1]) ? [] : {});
4018           }
4019         }
4020         assignValue(nested, key, newValue);
4021         nested = nested[key];
4022       }
4023       return object;
4024     }
4025
4026     /**
4027      * The base implementation of `setData` without support for hot loop shorting.
4028      *
4029      * @private
4030      * @param {Function} func The function to associate metadata with.
4031      * @param {*} data The metadata.
4032      * @returns {Function} Returns `func`.
4033      */
4034     var baseSetData = !metaMap ? identity : function(func, data) {
4035       metaMap.set(func, data);
4036       return func;
4037     };
4038
4039     /**
4040      * The base implementation of `setToString` without support for hot loop shorting.
4041      *
4042      * @private
4043      * @param {Function} func The function to modify.
4044      * @param {Function} string The `toString` result.
4045      * @returns {Function} Returns `func`.
4046      */
4047     var baseSetToString = !defineProperty ? identity : function(func, string) {
4048       return defineProperty(func, 'toString', {
4049         'configurable': true,
4050         'enumerable': false,
4051         'value': constant(string),
4052         'writable': true
4053       });
4054     };
4055
4056     /**
4057      * The base implementation of `_.shuffle`.
4058      *
4059      * @private
4060      * @param {Array|Object} collection The collection to shuffle.
4061      * @returns {Array} Returns the new shuffled array.
4062      */
4063     function baseShuffle(collection) {
4064       return shuffleSelf(values(collection));
4065     }
4066
4067     /**
4068      * The base implementation of `_.slice` without an iteratee call guard.
4069      *
4070      * @private
4071      * @param {Array} array The array to slice.
4072      * @param {number} [start=0] The start position.
4073      * @param {number} [end=array.length] The end position.
4074      * @returns {Array} Returns the slice of `array`.
4075      */
4076     function baseSlice(array, start, end) {
4077       var index = -1,
4078           length = array.length;
4079
4080       if (start < 0) {
4081         start = -start > length ? 0 : (length + start);
4082       }
4083       end = end > length ? length : end;
4084       if (end < 0) {
4085         end += length;
4086       }
4087       length = start > end ? 0 : ((end - start) >>> 0);
4088       start >>>= 0;
4089
4090       var result = Array(length);
4091       while (++index < length) {
4092         result[index] = array[index + start];
4093       }
4094       return result;
4095     }
4096
4097     /**
4098      * The base implementation of `_.some` without support for iteratee shorthands.
4099      *
4100      * @private
4101      * @param {Array|Object} collection The collection to iterate over.
4102      * @param {Function} predicate The function invoked per iteration.
4103      * @returns {boolean} Returns `true` if any element passes the predicate check,
4104      *  else `false`.
4105      */
4106     function baseSome(collection, predicate) {
4107       var result;
4108
4109       baseEach(collection, function(value, index, collection) {
4110         result = predicate(value, index, collection);
4111         return !result;
4112       });
4113       return !!result;
4114     }
4115
4116     /**
4117      * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
4118      * performs a binary search of `array` to determine the index at which `value`
4119      * should be inserted into `array` in order to maintain its sort order.
4120      *
4121      * @private
4122      * @param {Array} array The sorted array to inspect.
4123      * @param {*} value The value to evaluate.
4124      * @param {boolean} [retHighest] Specify returning the highest qualified index.
4125      * @returns {number} Returns the index at which `value` should be inserted
4126      *  into `array`.
4127      */
4128     function baseSortedIndex(array, value, retHighest) {
4129       var low = 0,
4130           high = array == null ? low : array.length;
4131
4132       if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
4133         while (low < high) {
4134           var mid = (low + high) >>> 1,
4135               computed = array[mid];
4136
4137           if (computed !== null && !isSymbol(computed) &&
4138               (retHighest ? (computed <= value) : (computed < value))) {
4139             low = mid + 1;
4140           } else {
4141             high = mid;
4142           }
4143         }
4144         return high;
4145       }
4146       return baseSortedIndexBy(array, value, identity, retHighest);
4147     }
4148
4149     /**
4150      * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
4151      * which invokes `iteratee` for `value` and each element of `array` to compute
4152      * their sort ranking. The iteratee is invoked with one argument; (value).
4153      *
4154      * @private
4155      * @param {Array} array The sorted array to inspect.
4156      * @param {*} value The value to evaluate.
4157      * @param {Function} iteratee The iteratee invoked per element.
4158      * @param {boolean} [retHighest] Specify returning the highest qualified index.
4159      * @returns {number} Returns the index at which `value` should be inserted
4160      *  into `array`.
4161      */
4162     function baseSortedIndexBy(array, value, iteratee, retHighest) {
4163       value = iteratee(value);
4164
4165       var low = 0,
4166           high = array == null ? 0 : array.length,
4167           valIsNaN = value !== value,
4168           valIsNull = value === null,
4169           valIsSymbol = isSymbol(value),
4170           valIsUndefined = value === undefined;
4171
4172       while (low < high) {
4173         var mid = nativeFloor((low + high) / 2),
4174             computed = iteratee(array[mid]),
4175             othIsDefined = computed !== undefined,
4176             othIsNull = computed === null,
4177             othIsReflexive = computed === computed,
4178             othIsSymbol = isSymbol(computed);
4179
4180         if (valIsNaN) {
4181           var setLow = retHighest || othIsReflexive;
4182         } else if (valIsUndefined) {
4183           setLow = othIsReflexive && (retHighest || othIsDefined);
4184         } else if (valIsNull) {
4185           setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
4186         } else if (valIsSymbol) {
4187           setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
4188         } else if (othIsNull || othIsSymbol) {
4189           setLow = false;
4190         } else {
4191           setLow = retHighest ? (computed <= value) : (computed < value);
4192         }
4193         if (setLow) {
4194           low = mid + 1;
4195         } else {
4196           high = mid;
4197         }
4198       }
4199       return nativeMin(high, MAX_ARRAY_INDEX);
4200     }
4201
4202     /**
4203      * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
4204      * support for iteratee shorthands.
4205      *
4206      * @private
4207      * @param {Array} array The array to inspect.
4208      * @param {Function} [iteratee] The iteratee invoked per element.
4209      * @returns {Array} Returns the new duplicate free array.
4210      */
4211     function baseSortedUniq(array, iteratee) {
4212       var index = -1,
4213           length = array.length,
4214           resIndex = 0,
4215           result = [];
4216
4217       while (++index < length) {
4218         var value = array[index],
4219             computed = iteratee ? iteratee(value) : value;
4220
4221         if (!index || !eq(computed, seen)) {
4222           var seen = computed;
4223           result[resIndex++] = value === 0 ? 0 : value;
4224         }
4225       }
4226       return result;
4227     }
4228
4229     /**
4230      * The base implementation of `_.toNumber` which doesn't ensure correct
4231      * conversions of binary, hexadecimal, or octal string values.
4232      *
4233      * @private
4234      * @param {*} value The value to process.
4235      * @returns {number} Returns the number.
4236      */
4237     function baseToNumber(value) {
4238       if (typeof value == 'number') {
4239         return value;
4240       }
4241       if (isSymbol(value)) {
4242         return NAN;
4243       }
4244       return +value;
4245     }
4246
4247     /**
4248      * The base implementation of `_.toString` which doesn't convert nullish
4249      * values to empty strings.
4250      *
4251      * @private
4252      * @param {*} value The value to process.
4253      * @returns {string} Returns the string.
4254      */
4255     function baseToString(value) {
4256       // Exit early for strings to avoid a performance hit in some environments.
4257       if (typeof value == 'string') {
4258         return value;
4259       }
4260       if (isArray(value)) {
4261         // Recursively convert values (susceptible to call stack limits).
4262         return arrayMap(value, baseToString) + '';
4263       }
4264       if (isSymbol(value)) {
4265         return symbolToString ? symbolToString.call(value) : '';
4266       }
4267       var result = (value + '');
4268       return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
4269     }
4270
4271     /**
4272      * The base implementation of `_.uniqBy` without support for iteratee shorthands.
4273      *
4274      * @private
4275      * @param {Array} array The array to inspect.
4276      * @param {Function} [iteratee] The iteratee invoked per element.
4277      * @param {Function} [comparator] The comparator invoked per element.
4278      * @returns {Array} Returns the new duplicate free array.
4279      */
4280     function baseUniq(array, iteratee, comparator) {
4281       var index = -1,
4282           includes = arrayIncludes,
4283           length = array.length,
4284           isCommon = true,
4285           result = [],
4286           seen = result;
4287
4288       if (comparator) {
4289         isCommon = false;
4290         includes = arrayIncludesWith;
4291       }
4292       else if (length >= LARGE_ARRAY_SIZE) {
4293         var set = iteratee ? null : createSet(array);
4294         if (set) {
4295           return setToArray(set);
4296         }
4297         isCommon = false;
4298         includes = cacheHas;
4299         seen = new SetCache;
4300       }
4301       else {
4302         seen = iteratee ? [] : result;
4303       }
4304       outer:
4305       while (++index < length) {
4306         var value = array[index],
4307             computed = iteratee ? iteratee(value) : value;
4308
4309         value = (comparator || value !== 0) ? value : 0;
4310         if (isCommon && computed === computed) {
4311           var seenIndex = seen.length;
4312           while (seenIndex--) {
4313             if (seen[seenIndex] === computed) {
4314               continue outer;
4315             }
4316           }
4317           if (iteratee) {
4318             seen.push(computed);
4319           }
4320           result.push(value);
4321         }
4322         else if (!includes(seen, computed, comparator)) {
4323           if (seen !== result) {
4324             seen.push(computed);
4325           }
4326           result.push(value);
4327         }
4328       }
4329       return result;
4330     }
4331
4332     /**
4333      * The base implementation of `_.unset`.
4334      *
4335      * @private
4336      * @param {Object} object The object to modify.
4337      * @param {Array|string} path The property path to unset.
4338      * @returns {boolean} Returns `true` if the property is deleted, else `false`.
4339      */
4340     function baseUnset(object, path) {
4341       path = castPath(path, object);
4342       object = parent(object, path);
4343       return object == null || delete object[toKey(last(path))];
4344     }
4345
4346     /**
4347      * The base implementation of `_.update`.
4348      *
4349      * @private
4350      * @param {Object} object The object to modify.
4351      * @param {Array|string} path The path of the property to update.
4352      * @param {Function} updater The function to produce the updated value.
4353      * @param {Function} [customizer] The function to customize path creation.
4354      * @returns {Object} Returns `object`.
4355      */
4356     function baseUpdate(object, path, updater, customizer) {
4357       return baseSet(object, path, updater(baseGet(object, path)), customizer);
4358     }
4359
4360     /**
4361      * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
4362      * without support for iteratee shorthands.
4363      *
4364      * @private
4365      * @param {Array} array The array to query.
4366      * @param {Function} predicate The function invoked per iteration.
4367      * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
4368      * @param {boolean} [fromRight] Specify iterating from right to left.
4369      * @returns {Array} Returns the slice of `array`.
4370      */
4371     function baseWhile(array, predicate, isDrop, fromRight) {
4372       var length = array.length,
4373           index = fromRight ? length : -1;
4374
4375       while ((fromRight ? index-- : ++index < length) &&
4376         predicate(array[index], index, array)) {}
4377
4378       return isDrop
4379         ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
4380         : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
4381     }
4382
4383     /**
4384      * The base implementation of `wrapperValue` which returns the result of
4385      * performing a sequence of actions on the unwrapped `value`, where each
4386      * successive action is supplied the return value of the previous.
4387      *
4388      * @private
4389      * @param {*} value The unwrapped value.
4390      * @param {Array} actions Actions to perform to resolve the unwrapped value.
4391      * @returns {*} Returns the resolved value.
4392      */
4393     function baseWrapperValue(value, actions) {
4394       var result = value;
4395       if (result instanceof LazyWrapper) {
4396         result = result.value();
4397       }
4398       return arrayReduce(actions, function(result, action) {
4399         return action.func.apply(action.thisArg, arrayPush([result], action.args));
4400       }, result);
4401     }
4402
4403     /**
4404      * The base implementation of methods like `_.xor`, without support for
4405      * iteratee shorthands, that accepts an array of arrays to inspect.
4406      *
4407      * @private
4408      * @param {Array} arrays The arrays to inspect.
4409      * @param {Function} [iteratee] The iteratee invoked per element.
4410      * @param {Function} [comparator] The comparator invoked per element.
4411      * @returns {Array} Returns the new array of values.
4412      */
4413     function baseXor(arrays, iteratee, comparator) {
4414       var length = arrays.length;
4415       if (length < 2) {
4416         return length ? baseUniq(arrays[0]) : [];
4417       }
4418       var index = -1,
4419           result = Array(length);
4420
4421       while (++index < length) {
4422         var array = arrays[index],
4423             othIndex = -1;
4424
4425         while (++othIndex < length) {
4426           if (othIndex != index) {
4427             result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
4428           }
4429         }
4430       }
4431       return baseUniq(baseFlatten(result, 1), iteratee, comparator);
4432     }
4433
4434     /**
4435      * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
4436      *
4437      * @private
4438      * @param {Array} props The property identifiers.
4439      * @param {Array} values The property values.
4440      * @param {Function} assignFunc The function to assign values.
4441      * @returns {Object} Returns the new object.
4442      */
4443     function baseZipObject(props, values, assignFunc) {
4444       var index = -1,
4445           length = props.length,
4446           valsLength = values.length,
4447           result = {};
4448
4449       while (++index < length) {
4450         var value = index < valsLength ? values[index] : undefined;
4451         assignFunc(result, props[index], value);
4452       }
4453       return result;
4454     }
4455
4456     /**
4457      * Casts `value` to an empty array if it's not an array like object.
4458      *
4459      * @private
4460      * @param {*} value The value to inspect.
4461      * @returns {Array|Object} Returns the cast array-like object.
4462      */
4463     function castArrayLikeObject(value) {
4464       return isArrayLikeObject(value) ? value : [];
4465     }
4466
4467     /**
4468      * Casts `value` to `identity` if it's not a function.
4469      *
4470      * @private
4471      * @param {*} value The value to inspect.
4472      * @returns {Function} Returns cast function.
4473      */
4474     function castFunction(value) {
4475       return typeof value == 'function' ? value : identity;
4476     }
4477
4478     /**
4479      * Casts `value` to a path array if it's not one.
4480      *
4481      * @private
4482      * @param {*} value The value to inspect.
4483      * @param {Object} [object] The object to query keys on.
4484      * @returns {Array} Returns the cast property path array.
4485      */
4486     function castPath(value, object) {
4487       if (isArray(value)) {
4488         return value;
4489       }
4490       return isKey(value, object) ? [value] : stringToPath(toString(value));
4491     }
4492
4493     /**
4494      * A `baseRest` alias which can be replaced with `identity` by module
4495      * replacement plugins.
4496      *
4497      * @private
4498      * @type {Function}
4499      * @param {Function} func The function to apply a rest parameter to.
4500      * @returns {Function} Returns the new function.
4501      */
4502     var castRest = baseRest;
4503
4504     /**
4505      * Casts `array` to a slice if it's needed.
4506      *
4507      * @private
4508      * @param {Array} array The array to inspect.
4509      * @param {number} start The start position.
4510      * @param {number} [end=array.length] The end position.
4511      * @returns {Array} Returns the cast slice.
4512      */
4513     function castSlice(array, start, end) {
4514       var length = array.length;
4515       end = end === undefined ? length : end;
4516       return (!start && end >= length) ? array : baseSlice(array, start, end);
4517     }
4518
4519     /**
4520      * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
4521      *
4522      * @private
4523      * @param {number|Object} id The timer id or timeout object of the timer to clear.
4524      */
4525     var clearTimeout = ctxClearTimeout || function(id) {
4526       return root.clearTimeout(id);
4527     };
4528
4529     /**
4530      * Creates a clone of  `buffer`.
4531      *
4532      * @private
4533      * @param {Buffer} buffer The buffer to clone.
4534      * @param {boolean} [isDeep] Specify a deep clone.
4535      * @returns {Buffer} Returns the cloned buffer.
4536      */
4537     function cloneBuffer(buffer, isDeep) {
4538       if (isDeep) {
4539         return buffer.slice();
4540       }
4541       var length = buffer.length,
4542           result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
4543
4544       buffer.copy(result);
4545       return result;
4546     }
4547
4548     /**
4549      * Creates a clone of `arrayBuffer`.
4550      *
4551      * @private
4552      * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
4553      * @returns {ArrayBuffer} Returns the cloned array buffer.
4554      */
4555     function cloneArrayBuffer(arrayBuffer) {
4556       var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
4557       new Uint8Array(result).set(new Uint8Array(arrayBuffer));
4558       return result;
4559     }
4560
4561     /**
4562   &nb