1(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
3 typeof define === 'function' && define.amd ? define('underscore', factory) :
4 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {
5 var current = global._;
6 var exports = global._ = factory();
7 exports.noConflict = function () { global._ = current; return exports; };
8 }()));
9}(this, (function () {
10 // Underscore.js 1.13.7
11 // https://underscorejs.org
12 // (c) 2009-2024 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors
13 // Underscore may be freely distributed under the MIT license.
14
15 // Current version.
16 var VERSION = '1.13.7';
17
18 // Establish the root object, `window` (`self`) in the browser, `global`
19 // on the server, or `this` in some virtual machines. We use `self`
20 // instead of `window` for `WebWorker` support.
21 var root = (typeof self == 'object' && self.self === self && self) ||
22 (typeof global == 'object' && global.global === global && global) ||
23 Function('return this')() ||
24 {};
25
26 // Save bytes in the minified (but not gzipped) version:
27 var ArrayProto = Array.prototype, ObjProto = Object.prototype;
28 var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;
29
30 // Create quick reference variables for speed access to core prototypes.
31 var push = ArrayProto.push,
32 slice = ArrayProto.slice,
33 toString = ObjProto.toString,
34 hasOwnProperty = ObjProto.hasOwnProperty;
35
36 // Modern feature detection.
37 var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',
38 supportsDataView = typeof DataView !== 'undefined';
39
40 // All **ECMAScript 5+** native function implementations that we hope to use
41 // are declared here.
42 var nativeIsArray = Array.isArray,
43 nativeKeys = Object.keys,
44 nativeCreate = Object.create,
45 nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;
46
47 // Create references to these builtin functions because we override them.
48 var _isNaN = isNaN,
49 _isFinite = isFinite;
50
51 // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
52 var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
53 var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
54 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
55
56 // The largest integer that can be represented exactly.
57 var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
58
59 // Some functions take a variable number of arguments, or a few expected
60 // arguments at the beginning and then a variable number of values to operate
61 // on. This helper accumulates all remaining arguments past the function’s
62 // argument length (or an explicit `startIndex`), into an array that becomes
63 // the last argument. Similar to ES6’s "rest parameter".
64 function restArguments(func, startIndex) {
65 startIndex = startIndex == null ? func.length - 1 : +startIndex;
66 return function() {
67 var length = Math.max(arguments.length - startIndex, 0),
68 rest = Array(length),
69 index = 0;
70 for (; index < length; index++) {
71 rest[index] = arguments[index + startIndex];
72 }
73 switch (startIndex) {
74 case 0: return func.call(this, rest);
75 case 1: return func.call(this, arguments[0], rest);
76 case 2: return func.call(this, arguments[0], arguments[1], rest);
77 }
78 var args = Array(startIndex + 1);
79 for (index = 0; index < startIndex; index++) {
80 args[index] = arguments[index];
81 }
82 args[startIndex] = rest;
83 return func.apply(this, args);
84 };
85 }
86
87 // Is a given variable an object?
88 function isObject(obj) {
89 var type = typeof obj;
90 return type === 'function' || (type === 'object' && !!obj);
91 }
92
93 // Is a given value equal to null?
94 function isNull(obj) {
95 return obj === null;
96 }
97
98 // Is a given variable undefined?
99 function isUndefined(obj) {
100 return obj === void 0;
101 }
102
103 // Is a given value a boolean?
104 function isBoolean(obj) {
105 return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
106 }
107
108 // Is a given value a DOM element?
109 function isElement(obj) {
110 return !!(obj && obj.nodeType === 1);
111 }
112
113 // Internal function for creating a `toString`-based type tester.
114 function tagTester(name) {
115 var tag = '[object ' + name + ']';
116 return function(obj) {
117 return toString.call(obj) === tag;
118 };
119 }
120
121 var isString = tagTester('String');
122
123 var isNumber = tagTester('Number');
124
125 var isDate = tagTester('Date');
126
127 var isRegExp = tagTester('RegExp');
128
129 var isError = tagTester('Error');
130
131 var isSymbol = tagTester('Symbol');
132
133 var isArrayBuffer = tagTester('ArrayBuffer');
134
135 var isFunction = tagTester('Function');
136
137 // Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old
138 // v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).
139 var nodelist = root.document && root.document.childNodes;
140 if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {
141 isFunction = function(obj) {
142 return typeof obj == 'function' || false;
143 };
144 }
145
146 var isFunction$1 = isFunction;
147
148 var hasObjectTag = tagTester('Object');
149
150 // In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.
151 // In IE 11, the most common among them, this problem also applies to
152 // `Map`, `WeakMap` and `Set`.
153 // Also, there are cases where an application can override the native
154 // `DataView` object, in cases like that we can't use the constructor
155 // safely and should just rely on alternate `DataView` checks
156 var hasDataViewBug = (
157 supportsDataView && (!/\[native code\]/.test(String(DataView)) || hasObjectTag(new DataView(new ArrayBuffer(8))))
158 ),
159 isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));
160
161 var isDataView = tagTester('DataView');
162
163 // In IE 10 - Edge 13, we need a different heuristic
164 // to determine whether an object is a `DataView`.
165 // Also, in cases where the native `DataView` is
166 // overridden we can't rely on the tag itself.
167 function alternateIsDataView(obj) {
168 return obj != null && isFunction$1(obj.getInt8) && isArrayBuffer(obj.buffer);
169 }
170
171 var isDataView$1 = (hasDataViewBug ? alternateIsDataView : isDataView);
172
173 // Is a given value an array?
174 // Delegates to ECMA5's native `Array.isArray`.
175 var isArray = nativeIsArray || tagTester('Array');
176
177 // Internal function to check whether `key` is an own property name of `obj`.
178 function has$1(obj, key) {
179 return obj != null && hasOwnProperty.call(obj, key);
180 }
181
182 var isArguments = tagTester('Arguments');
183
184 // Define a fallback version of the method in browsers (ahem, IE < 9), where
185 // there isn't any inspectable "Arguments" type.
186 (function() {
187 if (!isArguments(arguments)) {
188 isArguments = function(obj) {
189 return has$1(obj, 'callee');
190 };
191 }
192 }());
193
194 var isArguments$1 = isArguments;
195
196 // Is a given object a finite number?
197 function isFinite$1(obj) {
198 return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));
199 }
200
201 // Is the given value `NaN`?
202 function isNaN$1(obj) {
203 return isNumber(obj) && _isNaN(obj);
204 }
205
206 // Predicate-generating function. Often useful outside of Underscore.
207 function constant(value) {
208 return function() {
209 return value;
210 };
211 }
212
213 // Common internal logic for `isArrayLike` and `isBufferLike`.
214 function createSizePropertyCheck(getSizeProperty) {
215 return function(collection) {
216 var sizeProperty = getSizeProperty(collection);
217 return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;
218 }
219 }
220
221 // Internal helper to generate a function to obtain property `key` from `obj`.
222 function shallowProperty(key) {
223 return function(obj) {
224 return obj == null ? void 0 : obj[key];
225 };
226 }
227
228 // Internal helper to obtain the `byteLength` property of an object.
229 var getByteLength = shallowProperty('byteLength');
230
231 // Internal helper to determine whether we should spend extensive checks against
232 // `ArrayBuffer` et al.
233 var isBufferLike = createSizePropertyCheck(getByteLength);
234
235 // Is a given value a typed array?
236 var typedArrayPattern = /\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;
237 function isTypedArray(obj) {
238 // `ArrayBuffer.isView` is the most future-proof, so use it when available.
239 // Otherwise, fall back on the above regular expression.
240 return nativeIsView ? (nativeIsView(obj) && !isDataView$1(obj)) :
241 isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));
242 }
243
244 var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false);
245
246 // Internal helper to obtain the `length` property of an object.
247 var getLength = shallowProperty('length');
248
249 // Internal helper to create a simple lookup structure.
250 // `collectNonEnumProps` used to depend on `_.contains`, but this led to
251 // circular imports. `emulatedSet` is a one-off solution that only works for
252 // arrays of strings.
253 function emulatedSet(keys) {
254 var hash = {};
255 for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;
256 return {
257 contains: function(key) { return hash[key] === true; },
258 push: function(key) {
259 hash[key] = true;
260 return keys.push(key);
261 }
262 };
263 }
264
265 // Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't
266 // be iterated by `for key in ...` and thus missed. Extends `keys` in place if
267 // needed.
268 function collectNonEnumProps(obj, keys) {
269 keys = emulatedSet(keys);
270 var nonEnumIdx = nonEnumerableProps.length;
271 var constructor = obj.constructor;
272 var proto = (isFunction$1(constructor) && constructor.prototype) || ObjProto;
273
274 // Constructor is a special case.
275 var prop = 'constructor';
276 if (has$1(obj, prop) && !keys.contains(prop)) keys.push(prop);
277
278 while (nonEnumIdx--) {
279 prop = nonEnumerableProps[nonEnumIdx];
280 if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {
281 keys.push(prop);
282 }
283 }
284 }
285
286 // Retrieve the names of an object's own properties.
287 // Delegates to **ECMAScript 5**'s native `Object.keys`.
288 function keys(obj) {
289 if (!isObject(obj)) return [];
290 if (nativeKeys) return nativeKeys(obj);
291 var keys = [];
292 for (var key in obj) if (has$1(obj, key)) keys.push(key);
293 // Ahem, IE < 9.
294 if (hasEnumBug) collectNonEnumProps(obj, keys);
295 return keys;
296 }
297
298 // Is a given array, string, or object empty?
299 // An "empty" object has no enumerable own-properties.
300 function isEmpty(obj) {
301 if (obj == null) return true;
302 // Skip the more expensive `toString`-based type checks if `obj` has no
303 // `.length`.
304 var length = getLength(obj);
305 if (typeof length == 'number' && (
306 isArray(obj) || isString(obj) || isArguments$1(obj)
307 )) return length === 0;
308 return getLength(keys(obj)) === 0;
309 }
310
311 // Returns whether an object has a given set of `key:value` pairs.
312 function isMatch(object, attrs) {
313 var _keys = keys(attrs), length = _keys.length;
314 if (object == null) return !length;
315 var obj = Object(object);
316 for (var i = 0; i < length; i++) {
317 var key = _keys[i];
318 if (attrs[key] !== obj[key] || !(key in obj)) return false;
319 }
320 return true;
321 }
322
323 // If Underscore is called as a function, it returns a wrapped object that can
324 // be used OO-style. This wrapper holds altered versions of all functions added
325 // through `_.mixin`. Wrapped objects may be chained.
326 function _$1(obj) {
327 if (obj instanceof _$1) return obj;
328 if (!(this instanceof _$1)) return new _$1(obj);
329 this._wrapped = obj;
330 }
331
332 _$1.VERSION = VERSION;
333
334 // Extracts the result from a wrapped and chained object.
335 _$1.prototype.value = function() {
336 return this._wrapped;
337 };
338
339 // Provide unwrapping proxies for some methods used in engine operations
340 // such as arithmetic and JSON stringification.
341 _$1.prototype.valueOf = _$1.prototype.toJSON = _$1.prototype.value;
342
343 _$1.prototype.toString = function() {
344 return String(this._wrapped);
345 };
346
347 // Internal function to wrap or shallow-copy an ArrayBuffer,
348 // typed array or DataView to a new view, reusing the buffer.
349 function toBufferView(bufferSource) {
350 return new Uint8Array(
351 bufferSource.buffer || bufferSource,
352 bufferSource.byteOffset || 0,
353 getByteLength(bufferSource)
354 );
355 }
356
357 // We use this string twice, so give it a name for minification.
358 var tagDataView = '[object DataView]';
359
360 // Internal recursive comparison function for `_.isEqual`.
361 function eq(a, b, aStack, bStack) {
362 // Identical objects are equal. `0 === -0`, but they aren't identical.
363 // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).
364 if (a === b) return a !== 0 || 1 / a === 1 / b;
365 // `null` or `undefined` only equal to itself (strict comparison).
366 if (a == null || b == null) return false;
367 // `NaN`s are equivalent, but non-reflexive.
368 if (a !== a) return b !== b;
369 // Exhaust primitive checks
370 var type = typeof a;
371 if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
372 return deepEq(a, b, aStack, bStack);
373 }
374
375 // Internal recursive comparison function for `_.isEqual`.
376 function deepEq(a, b, aStack, bStack) {
377 // Unwrap any wrapped objects.
378 if (a instanceof _$1) a = a._wrapped;
379 if (b instanceof _$1) b = b._wrapped;
380 // Compare `[[Class]]` names.
381 var className = toString.call(a);
382 if (className !== toString.call(b)) return false;
383 // Work around a bug in IE 10 - Edge 13.
384 if (hasDataViewBug && className == '[object Object]' && isDataView$1(a)) {
385 if (!isDataView$1(b)) return false;
386 className = tagDataView;
387 }
388 switch (className) {
389 // These types are compared by value.
390 case '[object RegExp]':
391 // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
392 case '[object String]':
393 // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
394 // equivalent to `new String("5")`.
395 return '' + a === '' + b;
396 case '[object Number]':
397 // `NaN`s are equivalent, but non-reflexive.
398 // Object(NaN) is equivalent to NaN.
399 if (+a !== +a) return +b !== +b;
400 // An `egal` comparison is performed for other numeric values.
401 return +a === 0 ? 1 / +a === 1 / b : +a === +b;
402 case '[object Date]':
403 case '[object Boolean]':
404 // Coerce dates and booleans to numeric primitive values. Dates are compared by their
405 // millisecond representations. Note that invalid dates with millisecond representations
406 // of `NaN` are not equivalent.
407 return +a === +b;
408 case '[object Symbol]':
409 return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);
410 case '[object ArrayBuffer]':
411 case tagDataView:
412 // Coerce to typed array so we can fall through.
413 return deepEq(toBufferView(a), toBufferView(b), aStack, bStack);
414 }
415
416 var areArrays = className === '[object Array]';
417 if (!areArrays && isTypedArray$1(a)) {
418 var byteLength = getByteLength(a);
419 if (byteLength !== getByteLength(b)) return false;
420 if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true;
421 areArrays = true;
422 }
423 if (!areArrays) {
424 if (typeof a != 'object' || typeof b != 'object') return false;
425
426 // Objects with different constructors are not equivalent, but `Object`s or `Array`s
427 // from different frames are.
428 var aCtor = a.constructor, bCtor = b.constructor;
429 if (aCtor !== bCtor && !(isFunction$1(aCtor) && aCtor instanceof aCtor &&
430 isFunction$1(bCtor) && bCtor instanceof bCtor)
431 && ('constructor' in a && 'constructor' in b)) {
432 return false;
433 }
434 }
435 // Assume equality for cyclic structures. The algorithm for detecting cyclic
436 // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
437
438 // Initializing stack of traversed objects.
439 // It's done here since we only need them for objects and arrays comparison.
440 aStack = aStack || [];
441 bStack = bStack || [];
442 var length = aStack.length;
443 while (length--) {
444 // Linear search. Performance is inversely proportional to the number of
445 // unique nested structures.
446 if (aStack[length] === a) return bStack[length] === b;
447 }
448
449 // Add the first object to the stack of traversed objects.
450 aStack.push(a);
451 bStack.push(b);
452
453 // Recursively compare objects and arrays.
454 if (areArrays) {
455 // Compare array lengths to determine if a deep comparison is necessary.
456 length = a.length;
457 if (length !== b.length) return false;
458 // Deep compare the contents, ignoring non-numeric properties.
459 while (length--) {
460 if (!eq(a[length], b[length], aStack, bStack)) return false;
461 }
462 } else {
463 // Deep compare objects.
464 var _keys = keys(a), key;
465 length = _keys.length;
466 // Ensure that both objects contain the same number of properties before comparing deep equality.
467 if (keys(b).length !== length) return false;
468 while (length--) {
469 // Deep compare each member
470 key = _keys[length];
471 if (!(has$1(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
472 }
473 }
474 // Remove the first object from the stack of traversed objects.
475 aStack.pop();
476 bStack.pop();
477 return true;
478 }
479
480 // Perform a deep comparison to check if two objects are equal.
481 function isEqual(a, b) {
482 return eq(a, b);
483 }
484
485 // Retrieve all the enumerable property names of an object.
486 function allKeys(obj) {
487 if (!isObject(obj)) return [];
488 var keys = [];
489 for (var key in obj) keys.push(key);
490 // Ahem, IE < 9.
491 if (hasEnumBug) collectNonEnumProps(obj, keys);
492 return keys;
493 }
494
495 // Since the regular `Object.prototype.toString` type tests don't work for
496 // some types in IE 11, we use a fingerprinting heuristic instead, based
497 // on the methods. It's not great, but it's the best we got.
498 // The fingerprint method lists are defined below.
499 function ie11fingerprint(methods) {
500 var length = getLength(methods);
501 return function(obj) {
502 if (obj == null) return false;
503 // `Map`, `WeakMap` and `Set` have no enumerable keys.
504 var keys = allKeys(obj);
505 if (getLength(keys)) return false;
506 for (var i = 0; i < length; i++) {
507 if (!isFunction$1(obj[methods[i]])) return false;
508 }
509 // If we are testing against `WeakMap`, we need to ensure that
510 // `obj` doesn't have a `forEach` method in order to distinguish
511 // it from a regular `Map`.
512 return methods !== weakMapMethods || !isFunction$1(obj[forEachName]);
513 };
514 }
515
516 // In the interest of compact minification, we write
517 // each string in the fingerprints only once.
518 var forEachName = 'forEach',
519 hasName = 'has',
520 commonInit = ['clear', 'delete'],
521 mapTail = ['get', hasName, 'set'];
522
523 // `Map`, `WeakMap` and `Set` each have slightly different
524 // combinations of the above sublists.
525 var mapMethods = commonInit.concat(forEachName, mapTail),
526 weakMapMethods = commonInit.concat(mapTail),
527 setMethods = ['add'].concat(commonInit, forEachName, hasName);
528
529 var isMap = isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');
530
531 var isWeakMap = isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');
532
533 var isSet = isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');
534
535 var isWeakSet = tagTester('WeakSet');
536
537 // Retrieve the values of an object's properties.
538 function values(obj) {
539 var _keys = keys(obj);
540 var length = _keys.length;
541 var values = Array(length);
542 for (var i = 0; i < length; i++) {
543 values[i] = obj[_keys[i]];
544 }
545 return values;
546 }
547
548 // Convert an object into a list of `[key, value]` pairs.
549 // The opposite of `_.object` with one argument.
550 function pairs(obj) {
551 var _keys = keys(obj);
552 var length = _keys.length;
553 var pairs = Array(length);
554 for (var i = 0; i < length; i++) {
555 pairs[i] = [_keys[i], obj[_keys[i]]];
556 }
557 return pairs;
558 }
559
560 // Invert the keys and values of an object. The values must be serializable.
561 function invert(obj) {
562 var result = {};
563 var _keys = keys(obj);
564 for (var i = 0, length = _keys.length; i < length; i++) {
565 result[obj[_keys[i]]] = _keys[i];
566 }
567 return result;
568 }
569
570 // Return a sorted list of the function names available on the object.
571 function functions(obj) {
572 var names = [];
573 for (var key in obj) {
574 if (isFunction$1(obj[key])) names.push(key);
575 }
576 return names.sort();
577 }
578
579 // An internal function for creating assigner functions.
580 function createAssigner(keysFunc, defaults) {
581 return function(obj) {
582 var length = arguments.length;
583 if (defaults) obj = Object(obj);
584 if (length < 2 || obj == null) return obj;
585 for (var index = 1; index < length; index++) {
586 var source = arguments[index],
587 keys = keysFunc(source),
588 l = keys.length;
589 for (var i = 0; i < l; i++) {
590 var key = keys[i];
591 if (!defaults || obj[key] === void 0) obj[key] = source[key];
592 }
593 }
594 return obj;
595 };
596 }
597
598 // Extend a given object with all the properties in passed-in object(s).
599 var extend = createAssigner(allKeys);
600
601 // Assigns a given object with all the own properties in the passed-in
602 // object(s).
603 // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
604 var extendOwn = createAssigner(keys);
605
606 // Fill in a given object with default properties.
607 var defaults = createAssigner(allKeys, true);
608
609 // Create a naked function reference for surrogate-prototype-swapping.
610 function ctor() {
611 return function(){};
612 }
613
614 // An internal function for creating a new object that inherits from another.
615 function baseCreate(prototype) {
616 if (!isObject(prototype)) return {};
617 if (nativeCreate) return nativeCreate(prototype);
618 var Ctor = ctor();
619 Ctor.prototype = prototype;
620 var result = new Ctor;
621 Ctor.prototype = null;
622 return result;
623 }
624
625 // Creates an object that inherits from the given prototype object.
626 // If additional properties are provided then they will be added to the
627 // created object.
628 function create(prototype, props) {
629 var result = baseCreate(prototype);
630 if (props) extendOwn(result, props);
631 return result;
632 }
633
634 // Create a (shallow-cloned) duplicate of an object.
635 function clone(obj) {
636 if (!isObject(obj)) return obj;
637 return isArray(obj) ? obj.slice() : extend({}, obj);
638 }
639
640 // Invokes `interceptor` with the `obj` and then returns `obj`.
641 // The primary purpose of this method is to "tap into" a method chain, in
642 // order to perform operations on intermediate results within the chain.
643 function tap(obj, interceptor) {
644 interceptor(obj);
645 return obj;
646 }
647
648 // Normalize a (deep) property `path` to array.
649 // Like `_.iteratee`, this function can be customized.
650 function toPath$1(path) {
651 return isArray(path) ? path : [path];
652 }
653 _$1.toPath = toPath$1;
654
655 // Internal wrapper for `_.toPath` to enable minification.
656 // Similar to `cb` for `_.iteratee`.
657 function toPath(path) {
658 return _$1.toPath(path);
659 }
660
661 // Internal function to obtain a nested property in `obj` along `path`.
662 function deepGet(obj, path) {
663 var length = path.length;
664 for (var i = 0; i < length; i++) {
665 if (obj == null) return void 0;
666 obj = obj[path[i]];
667 }
668 return length ? obj : void 0;
669 }
670
671 // Get the value of the (deep) property on `path` from `object`.
672 // If any property in `path` does not exist or if the value is
673 // `undefined`, return `defaultValue` instead.
674 // The `path` is normalized through `_.toPath`.
675 function get(object, path, defaultValue) {
676 var value = deepGet(object, toPath(path));
677 return isUndefined(value) ? defaultValue : value;
678 }
679
680 // Shortcut function for checking if an object has a given property directly on
681 // itself (in other words, not on a prototype). Unlike the internal `has`
682 // function, this public version can also traverse nested properties.
683 function has(obj, path) {
684 path = toPath(path);
685 var length = path.length;
686 for (var i = 0; i < length; i++) {
687 var key = path[i];
688 if (!has$1(obj, key)) return false;
689 obj = obj[key];
690 }
691 return !!length;
692 }
693
694 // Keep the identity function around for default iteratees.
695 function identity(value) {
696 return value;
697 }
698
699 // Returns a predicate for checking whether an object has a given set of
700 // `key:value` pairs.
701 function matcher(attrs) {
702 attrs = extendOwn({}, attrs);
703 return function(obj) {
704 return isMatch(obj, attrs);
705 };
706 }
707
708 // Creates a function that, when passed an object, will traverse that object’s
709 // properties down the given `path`, specified as an array of keys or indices.
710 function property(path) {
711 path = toPath(path);
712 return function(obj) {
713 return deepGet(obj, path);
714 };
715 }
716
717 // Internal function that returns an efficient (for current engines) version
718 // of the passed-in callback, to be repeatedly applied in other Underscore
719 // functions.
720 function optimizeCb(func, context, argCount) {
721 if (context === void 0) return func;
722 switch (argCount == null ? 3 : argCount) {
723 case 1: return function(value) {
724 return func.call(context, value);
725 };
726 // The 2-argument case is omitted because we’re not using it.
727 case 3: return function(value, index, collection) {
728 return func.call(context, value, index, collection);
729 };
730 case 4: return function(accumulator, value, index, collection) {
731 return func.call(context, accumulator, value, index, collection);
732 };
733 }
734 return function() {
735 return func.apply(context, arguments);
736 };
737 }
738
739 // An internal function to generate callbacks that can be applied to each
740 // element in a collection, returning the desired result — either `_.identity`,
741 // an arbitrary callback, a property matcher, or a property accessor.
742 function baseIteratee(value, context, argCount) {
743 if (value == null) return identity;
744 if (isFunction$1(value)) return optimizeCb(value, context, argCount);
745 if (isObject(value) && !isArray(value)) return matcher(value);
746 return property(value);
747 }
748
749 // External wrapper for our callback generator. Users may customize
750 // `_.iteratee` if they want additional predicate/iteratee shorthand styles.
751 // This abstraction hides the internal-only `argCount` argument.
752 function iteratee(value, context) {
753 return baseIteratee(value, context, Infinity);
754 }
755 _$1.iteratee = iteratee;
756
757 // The function we call internally to generate a callback. It invokes
758 // `_.iteratee` if overridden, otherwise `baseIteratee`.
759 function cb(value, context, argCount) {
760 if (_$1.iteratee !== iteratee) return _$1.iteratee(value, context);
761 return baseIteratee(value, context, argCount);
762 }
763
764 // Returns the results of applying the `iteratee` to each element of `obj`.
765 // In contrast to `_.map` it returns an object.
766 function mapObject(obj, iteratee, context) {
767 iteratee = cb(iteratee, context);
768 var _keys = keys(obj),
769 length = _keys.length,
770 results = {};
771 for (var index = 0; index < length; index++) {
772 var currentKey = _keys[index];
773 results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
774 }
775 return results;
776 }
777
778 // Predicate-generating function. Often useful outside of Underscore.
779 function noop(){}
780
781 // Generates a function for a given object that returns a given property.
782 function propertyOf(obj) {
783 if (obj == null) return noop;
784 return function(path) {
785 return get(obj, path);
786 };
787 }
788
789 // Run a function **n** times.
790 function times(n, iteratee, context) {
791 var accum = Array(Math.max(0, n));
792 iteratee = optimizeCb(iteratee, context, 1);
793 for (var i = 0; i < n; i++) accum[i] = iteratee(i);
794 return accum;
795 }
796
797 // Return a random integer between `min` and `max` (inclusive).
798 function random(min, max) {
799 if (max == null) {
800 max = min;
801 min = 0;
802 }
803 return min + Math.floor(Math.random() * (max - min + 1));
804 }
805
806 // A (possibly faster) way to get the current timestamp as an integer.
807 var now = Date.now || function() {
808 return new Date().getTime();
809 };
810
811 // Internal helper to generate functions for escaping and unescaping strings
812 // to/from HTML interpolation.
813 function createEscaper(map) {
814 var escaper = function(match) {
815 return map[match];
816 };
817 // Regexes for identifying a key that needs to be escaped.
818 var source = '(?:' + keys(map).join('|') + ')';
819 var testRegexp = RegExp(source);
820 var replaceRegexp = RegExp(source, 'g');
821 return function(string) {
822 string = string == null ? '' : '' + string;
823 return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
824 };
825 }
826
827 // Internal list of HTML entities for escaping.
828 var escapeMap = {
829 '&': '&',
830 '<': '<',
831 '>': '>',
832 '"': '"',
833 "'": ''',
834 '`': '`'
835 };
836
837 // Function for escaping strings to HTML interpolation.
838 var _escape = createEscaper(escapeMap);
839
840 // Internal list of HTML entities for unescaping.
841 var unescapeMap = invert(escapeMap);
842
843 // Function for unescaping strings from HTML interpolation.
844 var _unescape = createEscaper(unescapeMap);
845
846 // By default, Underscore uses ERB-style template delimiters. Change the
847 // following template settings to use alternative delimiters.
848 var templateSettings = _$1.templateSettings = {
849 evaluate: /<%([\s\S]+?)%>/g,
850 interpolate: /<%=([\s\S]+?)%>/g,
851 escape: /<%-([\s\S]+?)%>/g
852 };
853
854 // When customizing `_.templateSettings`, if you don't want to define an
855 // interpolation, evaluation or escaping regex, we need one that is
856 // guaranteed not to match.
857 var noMatch = /(.)^/;
858
859 // Certain characters need to be escaped so that they can be put into a
860 // string literal.
861 var escapes = {
862 "'": "'",
863 '\\': '\\',
864 '\r': 'r',
865 '\n': 'n',
866 '\u2028': 'u2028',
867 '\u2029': 'u2029'
868 };
869
870 var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;
871
872 function escapeChar(match) {
873 return '\\' + escapes[match];
874 }
875
876 // In order to prevent third-party code injection through
877 // `_.templateSettings.variable`, we test it against the following regular
878 // expression. It is intentionally a bit more liberal than just matching valid
879 // identifiers, but still prevents possible loopholes through defaults or
880 // destructuring assignment.
881 var bareIdentifier = /^\s*(\w|\$)+\s*$/;
882
883 // JavaScript micro-templating, similar to John Resig's implementation.
884 // Underscore templating handles arbitrary delimiters, preserves whitespace,
885 // and correctly escapes quotes within interpolated code.
886 // NB: `oldSettings` only exists for backwards compatibility.
887 function template(text, settings, oldSettings) {
888 if (!settings && oldSettings) settings = oldSettings;
889 settings = defaults({}, settings, _$1.templateSettings);
890
891 // Combine delimiters into one regular expression via alternation.
892 var matcher = RegExp([
893 (settings.escape || noMatch).source,
894 (settings.interpolate || noMatch).source,
895 (settings.evaluate || noMatch).source
896 ].join('|') + '|$', 'g');
897
898 // Compile the template source, escaping string literals appropriately.
899 var index = 0;
900 var source = "__p+='";
901 text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
902 source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
903 index = offset + match.length;
904
905 if (escape) {
906 source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
907 } else if (interpolate) {
908 source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
909 } else if (evaluate) {
910 source += "';\n" + evaluate + "\n__p+='";
911 }
912
913 // Adobe VMs need the match returned to produce the correct offset.
914 return match;
915 });
916 source += "';\n";
917
918 var argument = settings.variable;
919 if (argument) {
920 // Insure against third-party code injection. (CVE-2021-23358)
921 if (!bareIdentifier.test(argument)) throw new Error(
922 'variable is not a bare identifier: ' + argument
923 );
924 } else {
925 // If a variable is not specified, place data values in local scope.
926 source = 'with(obj||{}){\n' + source + '}\n';
927 argument = 'obj';
928 }
929
930 source = "var __t,__p='',__j=Array.prototype.join," +
931 "print=function(){__p+=__j.call(arguments,'');};\n" +
932 source + 'return __p;\n';
933
934 var render;
935 try {
936 render = new Function(argument, '_', source);
937 } catch (e) {
938 e.source = source;
939 throw e;
940 }
941
942 var template = function(data) {
943 return render.call(this, data, _$1);
944 };
945
946 // Provide the compiled source as a convenience for precompilation.
947 template.source = 'function(' + argument + '){\n' + source + '}';
948
949 return template;
950 }
951
952 // Traverses the children of `obj` along `path`. If a child is a function, it
953 // is invoked with its parent as context. Returns the value of the final
954 // child, or `fallback` if any child is undefined.
955 function result(obj, path, fallback) {
956 path = toPath(path);
957 var length = path.length;
958 if (!length) {
959 return isFunction$1(fallback) ? fallback.call(obj) : fallback;
960 }
961 for (var i = 0; i < length; i++) {
962 var prop = obj == null ? void 0 : obj[path[i]];
963 if (prop === void 0) {
964 prop = fallback;
965 i = length; // Ensure we don't continue iterating.
966 }
967 obj = isFunction$1(prop) ? prop.call(obj) : prop;
968 }
969 return obj;
970 }
971
972 // Generate a unique integer id (unique within the entire client session).
973 // Useful for temporary DOM ids.
974 var idCounter = 0;
975 function uniqueId(prefix) {
976 var id = ++idCounter + '';
977 return prefix ? prefix + id : id;
978 }
979
980 // Start chaining a wrapped Underscore object.
981 function chain(obj) {
982 var instance = _$1(obj);
983 instance._chain = true;
984 return instance;
985 }
986
987 // Internal function to execute `sourceFunc` bound to `context` with optional
988 // `args`. Determines whether to execute a function as a constructor or as a
989 // normal function.
990 function executeBound(sourceFunc, boundFunc, context, callingContext, args) {
991 if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
992 var self = baseCreate(sourceFunc.prototype);
993 var result = sourceFunc.apply(self, args);
994 if (isObject(result)) return result;
995 return self;
996 }
997
998 // Partially apply a function by creating a version that has had some of its
999 // arguments pre-filled, without changing its dynamic `this` context. `_` acts
1000 // as a placeholder by default, allowing any combination of arguments to be
1001 // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.
1002 var partial = restArguments(function(func, boundArgs) {
1003 var placeholder = partial.placeholder;
1004 var bound = function() {
1005 var position = 0, length = boundArgs.length;
1006 var args = Array(length);
1007 for (var i = 0; i < length; i++) {
1008 args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];
1009 }
1010 while (position < arguments.length) args.push(arguments[position++]);
1011 return executeBound(func, bound, this, this, args);
1012 };
1013 return bound;
1014 });
1015
1016 partial.placeholder = _$1;
1017
1018 // Create a function bound to a given object (assigning `this`, and arguments,
1019 // optionally).
1020 var bind = restArguments(function(func, context, args) {
1021 if (!isFunction$1(func)) throw new TypeError('Bind must be called on a function');
1022 var bound = restArguments(function(callArgs) {
1023 return executeBound(func, bound, context, this, args.concat(callArgs));
1024 });
1025 return bound;
1026 });
1027
1028 // Internal helper for collection methods to determine whether a collection
1029 // should be iterated as an array or as an object.
1030 // Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
1031 // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
1032 var isArrayLike = createSizePropertyCheck(getLength);
1033
1034 // Internal implementation of a recursive `flatten` function.
1035 function flatten$1(input, depth, strict, output) {
1036 output = output || [];
1037 if (!depth && depth !== 0) {
1038 depth = Infinity;
1039 } else if (depth <= 0) {
1040 return output.concat(input);
1041 }
1042 var idx = output.length;
1043 for (var i = 0, length = getLength(input); i < length; i++) {
1044 var value = input[i];
1045 if (isArrayLike(value) && (isArray(value) || isArguments$1(value))) {
1046 // Flatten current level of array or arguments object.
1047 if (depth > 1) {
1048 flatten$1(value, depth - 1, strict, output);
1049 idx = output.length;
1050 } else {
1051 var j = 0, len = value.length;
1052 while (j < len) output[idx++] = value[j++];
1053 }
1054 } else if (!strict) {
1055 output[idx++] = value;
1056 }
1057 }
1058 return output;
1059 }
1060
1061 // Bind a number of an object's methods to that object. Remaining arguments
1062 // are the method names to be bound. Useful for ensuring that all callbacks
1063 // defined on an object belong to it.
1064 var bindAll = restArguments(function(obj, keys) {
1065 keys = flatten$1(keys, false, false);
1066 var index = keys.length;
1067 if (index < 1) throw new Error('bindAll must be passed function names');
1068 while (index--) {
1069 var key = keys[index];
1070 obj[key] = bind(obj[key], obj);
1071 }
1072 return obj;
1073 });
1074
1075 // Memoize an expensive function by storing its results.
1076 function memoize(func, hasher) {
1077 var memoize = function(key) {
1078 var cache = memoize.cache;
1079 var address = '' + (hasher ? hasher.apply(this, arguments) : key);
1080 if (!has$1(cache, address)) cache[address] = func.apply(this, arguments);
1081 return cache[address];
1082 };
1083 memoize.cache = {};
1084 return memoize;
1085 }
1086
1087 // Delays a function for the given number of milliseconds, and then calls
1088 // it with the arguments supplied.
1089 var delay = restArguments(function(func, wait, args) {
1090 return setTimeout(function() {
1091 return func.apply(null, args);
1092 }, wait);
1093 });
1094
1095 // Defers a function, scheduling it to run after the current call stack has
1096 // cleared.
1097 var defer = partial(delay, _$1, 1);
1098
1099 // Returns a function, that, when invoked, will only be triggered at most once
1100 // during a given window of time. Normally, the throttled function will run
1101 // as much as it can, without ever going more than once per `wait` duration;
1102 // but if you'd like to disable the execution on the leading edge, pass
1103 // `{leading: false}`. To disable execution on the trailing edge, ditto.
1104 function throttle(func, wait, options) {
1105 var timeout, context, args, result;
1106 var previous = 0;
1107 if (!options) options = {};
1108
1109 var later = function() {
1110 previous = options.leading === false ? 0 : now();
1111 timeout = null;
1112 result = func.apply(context, args);
1113 if (!timeout) context = args = null;
1114 };
1115
1116 var throttled = function() {
1117 var _now = now();
1118 if (!previous && options.leading === false) previous = _now;
1119 var remaining = wait - (_now - previous);
1120 context = this;
1121 args = arguments;
1122 if (remaining <= 0 || remaining > wait) {
1123 if (timeout) {
1124 clearTimeout(timeout);
1125 timeout = null;
1126 }
1127 previous = _now;
1128 result = func.apply(context, args);
1129 if (!timeout) context = args = null;
1130 } else if (!timeout && options.trailing !== false) {
1131 timeout = setTimeout(later, remaining);
1132 }
1133 return result;
1134 };
1135
1136 throttled.cancel = function() {
1137 clearTimeout(timeout);
1138 previous = 0;
1139 timeout = context = args = null;
1140 };
1141
1142 return throttled;
1143 }
1144
1145 // When a sequence of calls of the returned function ends, the argument
1146 // function is triggered. The end of a sequence is defined by the `wait`
1147 // parameter. If `immediate` is passed, the argument function will be
1148 // triggered at the beginning of the sequence instead of at the end.
1149 function debounce(func, wait, immediate) {
1150 var timeout, previous, args, result, context;
1151
1152 var later = function() {
1153 var passed = now() - previous;
1154 if (wait > passed) {
1155 timeout = setTimeout(later, wait - passed);
1156 } else {
1157 timeout = null;
1158 if (!immediate) result = func.apply(context, args);
1159 // This check is needed because `func` can recursively invoke `debounced`.
1160 if (!timeout) args = context = null;
1161 }
1162 };
1163
1164 var debounced = restArguments(function(_args) {
1165 context = this;
1166 args = _args;
1167 previous = now();
1168 if (!timeout) {
1169 timeout = setTimeout(later, wait);
1170 if (immediate) result = func.apply(context, args);
1171 }
1172 return result;
1173 });
1174
1175 debounced.cancel = function() {
1176 clearTimeout(timeout);
1177 timeout = args = context = null;
1178 };
1179
1180 return debounced;
1181 }
1182
1183 // Returns the first function passed as an argument to the second,
1184 // allowing you to adjust arguments, run code before and after, and
1185 // conditionally execute the original function.
1186 function wrap(func, wrapper) {
1187 return partial(wrapper, func);
1188 }
1189
1190 // Returns a negated version of the passed-in predicate.
1191 function negate(predicate) {
1192 return function() {
1193 return !predicate.apply(this, arguments);
1194 };
1195 }
1196
1197 // Returns a function that is the composition of a list of functions, each
1198 // consuming the return value of the function that follows.
1199 function compose() {
1200 var args = arguments;
1201 var start = args.length - 1;
1202 return function() {
1203 var i = start;
1204 var result = args[start].apply(this, arguments);
1205 while (i--) result = args[i].call(this, result);
1206 return result;
1207 };
1208 }
1209
1210 // Returns a function that will only be executed on and after the Nth call.
1211 function after(times, func) {
1212 return function() {
1213 if (--times < 1) {
1214 return func.apply(this, arguments);
1215 }
1216 };
1217 }
1218
1219 // Returns a function that will only be executed up to (but not including) the
1220 // Nth call.
1221 function before(times, func) {
1222 var memo;
1223 return function() {
1224 if (--times > 0) {
1225 memo = func.apply(this, arguments);
1226 }
1227 if (times <= 1) func = null;
1228 return memo;
1229 };
1230 }
1231
1232 // Returns a function that will be executed at most one time, no matter how
1233 // often you call it. Useful for lazy initialization.
1234 var once = partial(before, 2);
1235
1236 // Returns the first key on an object that passes a truth test.
1237 function findKey(obj, predicate, context) {
1238 predicate = cb(predicate, context);
1239 var _keys = keys(obj), key;
1240 for (var i = 0, length = _keys.length; i < length; i++) {
1241 key = _keys[i];
1242 if (predicate(obj[key], key, obj)) return key;
1243 }
1244 }
1245
1246 // Internal function to generate `_.findIndex` and `_.findLastIndex`.
1247 function createPredicateIndexFinder(dir) {
1248 return function(array, predicate, context) {
1249 predicate = cb(predicate, context);
1250 var length = getLength(array);
1251 var index = dir > 0 ? 0 : length - 1;
1252 for (; index >= 0 && index < length; index += dir) {
1253 if (predicate(array[index], index, array)) return index;
1254 }
1255 return -1;
1256 };
1257 }
1258
1259 // Returns the first index on an array-like that passes a truth test.
1260 var findIndex = createPredicateIndexFinder(1);
1261
1262 // Returns the last index on an array-like that passes a truth test.
1263 var findLastIndex = createPredicateIndexFinder(-1);
1264
1265 // Use a comparator function to figure out the smallest index at which
1266 // an object should be inserted so as to maintain order. Uses binary search.
1267 function sortedIndex(array, obj, iteratee, context) {
1268 iteratee = cb(iteratee, context, 1);
1269 var value = iteratee(obj);
1270 var low = 0, high = getLength(array);
1271 while (low < high) {
1272 var mid = Math.floor((low + high) / 2);
1273 if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
1274 }
1275 return low;
1276 }
1277
1278 // Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.
1279 function createIndexFinder(dir, predicateFind, sortedIndex) {
1280 return function(array, item, idx) {
1281 var i = 0, length = getLength(array);
1282 if (typeof idx == 'number') {
1283 if (dir > 0) {
1284 i = idx >= 0 ? idx : Math.max(idx + length, i);
1285 } else {
1286 length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
1287 }
1288 } else if (sortedIndex && idx && length) {
1289 idx = sortedIndex(array, item);
1290 return array[idx] === item ? idx : -1;
1291 }
1292 if (item !== item) {
1293 idx = predicateFind(slice.call(array, i, length), isNaN$1);
1294 return idx >= 0 ? idx + i : -1;
1295 }
1296 for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
1297 if (array[idx] === item) return idx;
1298 }
1299 return -1;
1300 };
1301 }
1302
1303 // Return the position of the first occurrence of an item in an array,
1304 // or -1 if the item is not included in the array.
1305 // If the array is large and already in sort order, pass `true`
1306 // for **isSorted** to use binary search.
1307 var indexOf = createIndexFinder(1, findIndex, sortedIndex);
1308
1309 // Return the position of the last occurrence of an item in an array,
1310 // or -1 if the item is not included in the array.
1311 var lastIndexOf = createIndexFinder(-1, findLastIndex);
1312
1313 // Return the first value which passes a truth test.
1314 function find(obj, predicate, context) {
1315 var keyFinder = isArrayLike(obj) ? findIndex : findKey;
1316 var key = keyFinder(obj, predicate, context);
1317 if (key !== void 0 && key !== -1) return obj[key];
1318 }
1319
1320 // Convenience version of a common use case of `_.find`: getting the first
1321 // object containing specific `key:value` pairs.
1322 function findWhere(obj, attrs) {
1323 return find(obj, matcher(attrs));
1324 }
1325
1326 // The cornerstone for collection functions, an `each`
1327 // implementation, aka `forEach`.
1328 // Handles raw objects in addition to array-likes. Treats all
1329 // sparse array-likes as if they were dense.
1330 function each(obj, iteratee, context) {
1331 iteratee = optimizeCb(iteratee, context);
1332 var i, length;
1333 if (isArrayLike(obj)) {
1334 for (i = 0, length = obj.length; i < length; i++) {
1335 iteratee(obj[i], i, obj);
1336 }
1337 } else {
1338 var _keys = keys(obj);
1339 for (i = 0, length = _keys.length; i < length; i++) {
1340 iteratee(obj[_keys[i]], _keys[i], obj);
1341 }
1342 }
1343 return obj;
1344 }
1345
1346 // Return the results of applying the iteratee to each element.
1347 function map(obj, iteratee, context) {
1348 iteratee = cb(iteratee, context);
1349 var _keys = !isArrayLike(obj) && keys(obj),
1350 length = (_keys || obj).length,
1351 results = Array(length);
1352 for (var index = 0; index < length; index++) {
1353 var currentKey = _keys ? _keys[index] : index;
1354 results[index] = iteratee(obj[currentKey], currentKey, obj);
1355 }
1356 return results;
1357 }
1358
1359 // Internal helper to create a reducing function, iterating left or right.
1360 function createReduce(dir) {
1361 // Wrap code that reassigns argument variables in a separate function than
1362 // the one that accesses `arguments.length` to avoid a perf hit. (#1991)
1363 var reducer = function(obj, iteratee, memo, initial) {
1364 var _keys = !isArrayLike(obj) && keys(obj),
1365 length = (_keys || obj).length,
1366 index = dir > 0 ? 0 : length - 1;
1367 if (!initial) {
1368 memo = obj[_keys ? _keys[index] : index];
1369 index += dir;
1370 }
1371 for (; index >= 0 && index < length; index += dir) {
1372 var currentKey = _keys ? _keys[index] : index;
1373 memo = iteratee(memo, obj[currentKey], currentKey, obj);
1374 }
1375 return memo;
1376 };
1377
1378 return function(obj, iteratee, memo, context) {
1379 var initial = arguments.length >= 3;
1380 return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);
1381 };
1382 }
1383
1384 // **Reduce** builds up a single result from a list of values, aka `inject`,
1385 // or `foldl`.
1386 var reduce = createReduce(1);
1387
1388 // The right-associative version of reduce, also known as `foldr`.
1389 var reduceRight = createReduce(-1);
1390
1391 // Return all the elements that pass a truth test.
1392 function filter(obj, predicate, context) {
1393 var results = [];
1394 predicate = cb(predicate, context);
1395 each(obj, function(value, index, list) {
1396 if (predicate(value, index, list)) results.push(value);
1397 });
1398 return results;
1399 }
1400
1401 // Return all the elements for which a truth test fails.
1402 function reject(obj, predicate, context) {
1403 return filter(obj, negate(cb(predicate)), context);
1404 }
1405
1406 // Determine whether all of the elements pass a truth test.
1407 function every(obj, predicate, context) {
1408 predicate = cb(predicate, context);
1409 var _keys = !isArrayLike(obj) && keys(obj),
1410 length = (_keys || obj).length;
1411 for (var index = 0; index < length; index++) {
1412 var currentKey = _keys ? _keys[index] : index;
1413 if (!predicate(obj[currentKey], currentKey, obj)) return false;
1414 }
1415 return true;
1416 }
1417
1418 // Determine if at least one element in the object passes a truth test.
1419 function some(obj, predicate, context) {
1420 predicate = cb(predicate, context);
1421 var _keys = !isArrayLike(obj) && keys(obj),
1422 length = (_keys || obj).length;
1423 for (var index = 0; index < length; index++) {
1424 var currentKey = _keys ? _keys[index] : index;
1425 if (predicate(obj[currentKey], currentKey, obj)) return true;
1426 }
1427 return false;
1428 }
1429
1430 // Determine if the array or object contains a given item (using `===`).
1431 function contains(obj, item, fromIndex, guard) {
1432 if (!isArrayLike(obj)) obj = values(obj);
1433 if (typeof fromIndex != 'number' || guard) fromIndex = 0;
1434 return indexOf(obj, item, fromIndex) >= 0;
1435 }
1436
1437 // Invoke a method (with arguments) on every item in a collection.
1438 var invoke = restArguments(function(obj, path, args) {
1439 var contextPath, func;
1440 if (isFunction$1(path)) {
1441 func = path;
1442 } else {
1443 path = toPath(path);
1444 contextPath = path.slice(0, -1);
1445 path = path[path.length - 1];
1446 }
1447 return map(obj, function(context) {
1448 var method = func;
1449 if (!method) {
1450 if (contextPath && contextPath.length) {
1451 context = deepGet(context, contextPath);
1452 }
1453 if (context == null) return void 0;
1454 method = context[path];
1455 }
1456 return method == null ? method : method.apply(context, args);
1457 });
1458 });
1459
1460 // Convenience version of a common use case of `_.map`: fetching a property.
1461 function pluck(obj, key) {
1462 return map(obj, property(key));
1463 }
1464
1465 // Convenience version of a common use case of `_.filter`: selecting only
1466 // objects containing specific `key:value` pairs.
1467 function where(obj, attrs) {
1468 return filter(obj, matcher(attrs));
1469 }
1470
1471 // Return the maximum element (or element-based computation).
1472 function max(obj, iteratee, context) {
1473 var result = -Infinity, lastComputed = -Infinity,
1474 value, computed;
1475 if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {
1476 obj = isArrayLike(obj) ? obj : values(obj);
1477 for (var i = 0, length = obj.length; i < length; i++) {
1478 value = obj[i];
1479 if (value != null && value > result) {
1480 result = value;
1481 }
1482 }
1483 } else {
1484 iteratee = cb(iteratee, context);
1485 each(obj, function(v, index, list) {
1486 computed = iteratee(v, index, list);
1487 if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {
1488 result = v;
1489 lastComputed = computed;
1490 }
1491 });
1492 }
1493 return result;
1494 }
1495
1496 // Return the minimum element (or element-based computation).
1497 function min(obj, iteratee, context) {
1498 var result = Infinity, lastComputed = Infinity,
1499 value, computed;
1500 if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {
1501 obj = isArrayLike(obj) ? obj : values(obj);
1502 for (var i = 0, length = obj.length; i < length; i++) {
1503 value = obj[i];
1504 if (value != null && value < result) {
1505 result = value;
1506 }
1507 }
1508 } else {
1509 iteratee = cb(iteratee, context);
1510 each(obj, function(v, index, list) {
1511 computed = iteratee(v, index, list);
1512 if (computed < lastComputed || (computed === Infinity && result === Infinity)) {
1513 result = v;
1514 lastComputed = computed;
1515 }
1516 });
1517 }
1518 return result;
1519 }
1520
1521 // Safely create a real, live array from anything iterable.
1522 var reStrSymbol = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
1523 function toArray(obj) {
1524 if (!obj) return [];
1525 if (isArray(obj)) return slice.call(obj);
1526 if (isString(obj)) {
1527 // Keep surrogate pair characters together.
1528 return obj.match(reStrSymbol);
1529 }
1530 if (isArrayLike(obj)) return map(obj, identity);
1531 return values(obj);
1532 }
1533
1534 // Sample **n** random values from a collection using the modern version of the
1535 // [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
1536 // If **n** is not specified, returns a single random element.
1537 // The internal `guard` argument allows it to work with `_.map`.
1538 function sample(obj, n, guard) {
1539 if (n == null || guard) {
1540 if (!isArrayLike(obj)) obj = values(obj);
1541 return obj[random(obj.length - 1)];
1542 }
1543 var sample = toArray(obj);
1544 var length = getLength(sample);
1545 n = Math.max(Math.min(n, length), 0);
1546 var last = length - 1;
1547 for (var index = 0; index < n; index++) {
1548 var rand = random(index, last);
1549 var temp = sample[index];
1550 sample[index] = sample[rand];
1551 sample[rand] = temp;
1552 }
1553 return sample.slice(0, n);
1554 }
1555
1556 // Shuffle a collection.
1557 function shuffle(obj) {
1558 return sample(obj, Infinity);
1559 }
1560
1561 // Sort the object's values by a criterion produced by an iteratee.
1562 function sortBy(obj, iteratee, context) {
1563 var index = 0;
1564 iteratee = cb(iteratee, context);
1565 return pluck(map(obj, function(value, key, list) {
1566 return {
1567 value: value,
1568 index: index++,
1569 criteria: iteratee(value, key, list)
1570 };
1571 }).sort(function(left, right) {
1572 var a = left.criteria;
1573 var b = right.criteria;
1574 if (a !== b) {
1575 if (a > b || a === void 0) return 1;
1576 if (a < b || b === void 0) return -1;
1577 }
1578 return left.index - right.index;
1579 }), 'value');
1580 }
1581
1582 // An internal function used for aggregate "group by" operations.
1583 function group(behavior, partition) {
1584 return function(obj, iteratee, context) {
1585 var result = partition ? [[], []] : {};
1586 iteratee = cb(iteratee, context);
1587 each(obj, function(value, index) {
1588 var key = iteratee(value, index, obj);
1589 behavior(result, value, key);
1590 });
1591 return result;
1592 };
1593 }
1594
1595 // Groups the object's values by a criterion. Pass either a string attribute
1596 // to group by, or a function that returns the criterion.
1597 var groupBy = group(function(result, value, key) {
1598 if (has$1(result, key)) result[key].push(value); else result[key] = [value];
1599 });
1600
1601 // Indexes the object's values by a criterion, similar to `_.groupBy`, but for
1602 // when you know that your index values will be unique.
1603 var indexBy = group(function(result, value, key) {
1604 result[key] = value;
1605 });
1606
1607 // Counts instances of an object that group by a certain criterion. Pass
1608 // either a string attribute to count by, or a function that returns the
1609 // criterion.
1610 var countBy = group(function(result, value, key) {
1611 if (has$1(result, key)) result[key]++; else result[key] = 1;
1612 });
1613
1614 // Split a collection into two arrays: one whose elements all pass the given
1615 // truth test, and one whose elements all do not pass the truth test.
1616 var partition = group(function(result, value, pass) {
1617 result[pass ? 0 : 1].push(value);
1618 }, true);
1619
1620 // Return the number of elements in a collection.
1621 function size(obj) {
1622 if (obj == null) return 0;
1623 return isArrayLike(obj) ? obj.length : keys(obj).length;
1624 }
1625
1626 // Internal `_.pick` helper function to determine whether `key` is an enumerable
1627 // property name of `obj`.
1628 function keyInObj(value, key, obj) {
1629 return key in obj;
1630 }
1631
1632 // Return a copy of the object only containing the allowed properties.
1633 var pick = restArguments(function(obj, keys) {
1634 var result = {}, iteratee = keys[0];
1635 if (obj == null) return result;
1636 if (isFunction$1(iteratee)) {
1637 if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);
1638 keys = allKeys(obj);
1639 } else {
1640 iteratee = keyInObj;
1641 keys = flatten$1(keys, false, false);
1642 obj = Object(obj);
1643 }
1644 for (var i = 0, length = keys.length; i < length; i++) {
1645 var key = keys[i];
1646 var value = obj[key];
1647 if (iteratee(value, key, obj)) result[key] = value;
1648 }
1649 return result;
1650 });
1651
1652 // Return a copy of the object without the disallowed properties.
1653 var omit = restArguments(function(obj, keys) {
1654 var iteratee = keys[0], context;
1655 if (isFunction$1(iteratee)) {
1656 iteratee = negate(iteratee);
1657 if (keys.length > 1) context = keys[1];
1658 } else {
1659 keys = map(flatten$1(keys, false, false), String);
1660 iteratee = function(value, key) {
1661 return !contains(keys, key);
1662 };
1663 }
1664 return pick(obj, iteratee, context);
1665 });
1666
1667 // Returns everything but the last entry of the array. Especially useful on
1668 // the arguments object. Passing **n** will return all the values in
1669 // the array, excluding the last N.
1670 function initial(array, n, guard) {
1671 return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
1672 }
1673
1674 // Get the first element of an array. Passing **n** will return the first N
1675 // values in the array. The **guard** check allows it to work with `_.map`.
1676 function first(array, n, guard) {
1677 if (array == null || array.length < 1) return n == null || guard ? void 0 : [];
1678 if (n == null || guard) return array[0];
1679 return initial(array, array.length - n);
1680 }
1681
1682 // Returns everything but the first entry of the `array`. Especially useful on
1683 // the `arguments` object. Passing an **n** will return the rest N values in the
1684 // `array`.
1685 function rest(array, n, guard) {
1686 return slice.call(array, n == null || guard ? 1 : n);
1687 }
1688
1689 // Get the last element of an array. Passing **n** will return the last N
1690 // values in the array.
1691 function last(array, n, guard) {
1692 if (array == null || array.length < 1) return n == null || guard ? void 0 : [];
1693 if (n == null || guard) return array[array.length - 1];
1694 return rest(array, Math.max(0, array.length - n));
1695 }
1696
1697 // Trim out all falsy values from an array.
1698 function compact(array) {
1699 return filter(array, Boolean);
1700 }
1701
1702 // Flatten out an array, either recursively (by default), or up to `depth`.
1703 // Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.
1704 function flatten(array, depth) {
1705 return flatten$1(array, depth, false);
1706 }
1707
1708 // Take the difference between one array and a number of other arrays.
1709 // Only the elements present in just the first array will remain.
1710 var difference = restArguments(function(array, rest) {
1711 rest = flatten$1(rest, true, true);
1712 return filter(array, function(value){
1713 return !contains(rest, value);
1714 });
1715 });
1716
1717 // Return a version of the array that does not contain the specified value(s).
1718 var without = restArguments(function(array, otherArrays) {
1719 return difference(array, otherArrays);
1720 });
1721
1722 // Produce a duplicate-free version of the array. If the array has already
1723 // been sorted, you have the option of using a faster algorithm.
1724 // The faster algorithm will not work with an iteratee if the iteratee
1725 // is not a one-to-one function, so providing an iteratee will disable
1726 // the faster algorithm.
1727 function uniq(array, isSorted, iteratee, context) {
1728 if (!isBoolean(isSorted)) {
1729 context = iteratee;
1730 iteratee = isSorted;
1731 isSorted = false;
1732 }
1733 if (iteratee != null) iteratee = cb(iteratee, context);
1734 var result = [];
1735 var seen = [];
1736 for (var i = 0, length = getLength(array); i < length; i++) {
1737 var value = array[i],
1738 computed = iteratee ? iteratee(value, i, array) : value;
1739 if (isSorted && !iteratee) {
1740 if (!i || seen !== computed) result.push(value);
1741 seen = computed;
1742 } else if (iteratee) {
1743 if (!contains(seen, computed)) {
1744 seen.push(computed);
1745 result.push(value);
1746 }
1747 } else if (!contains(result, value)) {
1748 result.push(value);
1749 }
1750 }
1751 return result;
1752 }
1753
1754 // Produce an array that contains the union: each distinct element from all of
1755 // the passed-in arrays.
1756 var union = restArguments(function(arrays) {
1757 return uniq(flatten$1(arrays, true, true));
1758 });
1759
1760 // Produce an array that contains every item shared between all the
1761 // passed-in arrays.
1762 function intersection(array) {
1763 var result = [];
1764 var argsLength = arguments.length;
1765 for (var i = 0, length = getLength(array); i < length; i++) {
1766 var item = array[i];
1767 if (contains(result, item)) continue;
1768 var j;
1769 for (j = 1; j < argsLength; j++) {
1770 if (!contains(arguments[j], item)) break;
1771 }
1772 if (j === argsLength) result.push(item);
1773 }
1774 return result;
1775 }
1776
1777 // Complement of zip. Unzip accepts an array of arrays and groups
1778 // each array's elements on shared indices.
1779 function unzip(array) {
1780 var length = (array && max(array, getLength).length) || 0;
1781 var result = Array(length);
1782
1783 for (var index = 0; index < length; index++) {
1784 result[index] = pluck(array, index);
1785 }
1786 return result;
1787 }
1788
1789 // Zip together multiple lists into a single array -- elements that share
1790 // an index go together.
1791 var zip = restArguments(unzip);
1792
1793 // Converts lists into objects. Pass either a single array of `[key, value]`
1794 // pairs, or two parallel arrays of the same length -- one of keys, and one of
1795 // the corresponding values. Passing by pairs is the reverse of `_.pairs`.
1796 function object(list, values) {
1797 var result = {};
1798 for (var i = 0, length = getLength(list); i < length; i++) {
1799 if (values) {
1800 result[list[i]] = values[i];
1801 } else {
1802 result[list[i][0]] = list[i][1];
1803 }
1804 }
1805 return result;
1806 }
1807
1808 // Generate an integer Array containing an arithmetic progression. A port of
1809 // the native Python `range()` function. See
1810 // [the Python documentation](https://docs.python.org/library/functions.html#range).
1811 function range(start, stop, step) {
1812 if (stop == null) {
1813 stop = start || 0;
1814 start = 0;
1815 }
1816 if (!step) {
1817 step = stop < start ? -1 : 1;
1818 }
1819
1820 var length = Math.max(Math.ceil((stop - start) / step), 0);
1821 var range = Array(length);
1822
1823 for (var idx = 0; idx < length; idx++, start += step) {
1824 range[idx] = start;
1825 }
1826
1827 return range;
1828 }
1829
1830 // Chunk a single array into multiple arrays, each containing `count` or fewer
1831 // items.
1832 function chunk(array, count) {
1833 if (count == null || count < 1) return [];
1834 var result = [];
1835 var i = 0, length = array.length;
1836 while (i < length) {
1837 result.push(slice.call(array, i, i += count));
1838 }
1839 return result;
1840 }
1841
1842 // Helper function to continue chaining intermediate results.
1843 function chainResult(instance, obj) {
1844 return instance._chain ? _$1(obj).chain() : obj;
1845 }
1846
1847 // Add your own custom functions to the Underscore object.
1848 function mixin(obj) {
1849 each(functions(obj), function(name) {
1850 var func = _$1[name] = obj[name];
1851 _$1.prototype[name] = function() {
1852 var args = [this._wrapped];
1853 push.apply(args, arguments);
1854 return chainResult(this, func.apply(_$1, args));
1855 };
1856 });
1857 return _$1;
1858 }
1859
1860 // Add all mutator `Array` functions to the wrapper.
1861 each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
1862 var method = ArrayProto[name];
1863 _$1.prototype[name] = function() {
1864 var obj = this._wrapped;
1865 if (obj != null) {
1866 method.apply(obj, arguments);
1867 if ((name === 'shift' || name === 'splice') && obj.length === 0) {
1868 delete obj[0];
1869 }
1870 }
1871 return chainResult(this, obj);
1872 };
1873 });
1874
1875 // Add all accessor `Array` functions to the wrapper.
1876 each(['concat', 'join', 'slice'], function(name) {
1877 var method = ArrayProto[name];
1878 _$1.prototype[name] = function() {
1879 var obj = this._wrapped;
1880 if (obj != null) obj = method.apply(obj, arguments);
1881 return chainResult(this, obj);
1882 };
1883 });
1884
1885 // Named Exports
1886
1887 var allExports = {
1888 __proto__: null,
1889 VERSION: VERSION,
1890 restArguments: restArguments,
1891 isObject: isObject,
1892 isNull: isNull,
1893 isUndefined: isUndefined,
1894 isBoolean: isBoolean,
1895 isElement: isElement,
1896 isString: isString,
1897 isNumber: isNumber,
1898 isDate: isDate,
1899 isRegExp: isRegExp,
1900 isError: isError,
1901 isSymbol: isSymbol,
1902 isArrayBuffer: isArrayBuffer,
1903 isDataView: isDataView$1,
1904 isArray: isArray,
1905 isFunction: isFunction$1,
1906 isArguments: isArguments$1,
1907 isFinite: isFinite$1,
1908 isNaN: isNaN$1,
1909 isTypedArray: isTypedArray$1,
1910 isEmpty: isEmpty,
1911 isMatch: isMatch,
1912 isEqual: isEqual,
1913 isMap: isMap,
1914 isWeakMap: isWeakMap,
1915 isSet: isSet,
1916 isWeakSet: isWeakSet,
1917 keys: keys,
1918 allKeys: allKeys,
1919 values: values,
1920 pairs: pairs,
1921 invert: invert,
1922 functions: functions,
1923 methods: functions,
1924 extend: extend,
1925 extendOwn: extendOwn,
1926 assign: extendOwn,
1927 defaults: defaults,
1928 create: create,
1929 clone: clone,
1930 tap: tap,
1931 get: get,
1932 has: has,
1933 mapObject: mapObject,
1934 identity: identity,
1935 constant: constant,
1936 noop: noop,
1937 toPath: toPath$1,
1938 property: property,
1939 propertyOf: propertyOf,
1940 matcher: matcher,
1941 matches: matcher,
1942 times: times,
1943 random: random,
1944 now: now,
1945 escape: _escape,
1946 unescape: _unescape,
1947 templateSettings: templateSettings,
1948 template: template,
1949 result: result,
1950 uniqueId: uniqueId,
1951 chain: chain,
1952 iteratee: iteratee,
1953 partial: partial,
1954 bind: bind,
1955 bindAll: bindAll,
1956 memoize: memoize,
1957 delay: delay,
1958 defer: defer,
1959 throttle: throttle,
1960 debounce: debounce,
1961 wrap: wrap,
1962 negate: negate,
1963 compose: compose,
1964 after: after,
1965 before: before,
1966 once: once,
1967 findKey: findKey,
1968 findIndex: findIndex,
1969 findLastIndex: findLastIndex,
1970 sortedIndex: sortedIndex,
1971 indexOf: indexOf,
1972 lastIndexOf: lastIndexOf,
1973 find: find,
1974 detect: find,
1975 findWhere: findWhere,
1976 each: each,
1977 forEach: each,
1978 map: map,
1979 collect: map,
1980 reduce: reduce,
1981 foldl: reduce,
1982 inject: reduce,
1983 reduceRight: reduceRight,
1984 foldr: reduceRight,
1985 filter: filter,
1986 select: filter,
1987 reject: reject,
1988 every: every,
1989 all: every,
1990 some: some,
1991 any: some,
1992 contains: contains,
1993 includes: contains,
1994 include: contains,
1995 invoke: invoke,
1996 pluck: pluck,
1997 where: where,
1998 max: max,
1999 min: min,
2000 shuffle: shuffle,
2001 sample: sample,
2002 sortBy: sortBy,
2003 groupBy: groupBy,
2004 indexBy: indexBy,
2005 countBy: countBy,
2006 partition: partition,
2007 toArray: toArray,
2008 size: size,
2009 pick: pick,
2010 omit: omit,
2011 first: first,
2012 head: first,
2013 take: first,
2014 initial: initial,
2015 last: last,
2016 rest: rest,
2017 tail: rest,
2018 drop: rest,
2019 compact: compact,
2020 flatten: flatten,
2021 without: without,
2022 uniq: uniq,
2023 unique: uniq,
2024 union: union,
2025 intersection: intersection,
2026 difference: difference,
2027 unzip: unzip,
2028 transpose: unzip,
2029 zip: zip,
2030 object: object,
2031 range: range,
2032 chunk: chunk,
2033 mixin: mixin,
2034 'default': _$1
2035 };
2036
2037 // Default Export
2038
2039 // Add all of the Underscore functions to the wrapper object.
2040 var _ = mixin(allExports);
2041 // Legacy Node.js API.
2042 _._ = _;
2043
2044 return _;
2045
2046})));
2047