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