1 //     Underscore.js 1.8.3

     1 (function (global, factory) {

     2 //     http://underscorejs.org

     2   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

     3 //     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors

     3   typeof define === 'function' && define.amd ? define('underscore', factory) :

     4 //     Underscore may be freely distributed under the MIT license.

     4   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, (function () {

     5 

     5     var current = global._;

     6 (function() {

     6     var exports = global._ = factory();

     7 

     7     exports.noConflict = function () { global._ = current; return exports; };

     8   // Baseline setup

     8   }()));

     9   // --------------

     9 }(this, (function () {

    10 

    10   //     Underscore.js 1.13.1

    11   // Establish the root object, `window` in the browser, or `exports` on the server.

    11   //     https://underscorejs.org

    12   var root = this;

    12   //     (c) 2009-2021 Jeremy Ashkenas, Julian Gonggrijp, and DocumentCloud and Investigative Reporters & Editors

    13 

    13   //     Underscore may be freely distributed under the MIT license.

    14   // Save the previous value of the `_` variable.

    14 

    15   var previousUnderscore = root._;

    15   // Current version.

    16   var VERSION = '1.13.1';

    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             {};

    18   var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;

    27   var ArrayProto = Array.prototype, ObjProto = Object.prototype;

    28   var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;

    21   var

    31   var push = ArrayProto.push,

    22     push             = ArrayProto.push,

    32       slice = ArrayProto.slice,

    23     slice            = ArrayProto.slice,

    33       toString = ObjProto.toString,

    24     toString         = ObjProto.toString,

    34       hasOwnProperty = ObjProto.hasOwnProperty;

    25     hasOwnProperty   = ObjProto.hasOwnProperty;

    35 

    26 

    36   // Modern feature detection.

    27   // All **ECMAScript 5** native function implementations that we hope to use

    37   var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',

    38       supportsDataView = typeof DataView !== 'undefined';

    39 

    40   // All **ECMAScript 5+** native function implementations that we hope to use

    29   var

    42   var nativeIsArray = Array.isArray,

    30     nativeIsArray      = Array.isArray,

    43       nativeKeys = Object.keys,

    31     nativeKeys         = Object.keys,

    44       nativeCreate = Object.create,

    32     nativeBind         = FuncProto.bind,

    45       nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;

    33     nativeCreate       = Object.create;

    46 

    34 

    47   // Create references to these builtin functions because we override them.

    35   // Naked function reference for surrogate-prototype-swapping.

    48   var _isNaN = isNaN,

    36   var Ctor = function(){};

    49       _isFinite = isFinite;

    37 

    38   // Create a safe reference to the Underscore object for use below.

    39   var _ = function(obj) {

    40     if (obj instanceof _) return obj;

    41     if (!(this instanceof _)) return new _(obj);

    42     this._wrapped = obj;

    43   };

    44 

    45   // Export the Underscore object for **Node.js**, with

    46   // backwards-compatibility for the old `require()` API. If we're in

    47   // the browser, add `_` as a global object.

    48   if (typeof exports !== 'undefined') {

    49     if (typeof module !== 'undefined' && module.exports) {

    50       exports = module.exports = _;

    51     }

    52     exports._ = _;

    53   } else {

    54     root._ = _;

    55   }

    56 

    57   // Current version.

    58   _.VERSION = '1.8.3';

    59 

    60   // Internal function that returns an efficient (for current engines) version

    61   // of the passed-in callback, to be repeatedly applied in other Underscore

    62   // functions.

    63   var optimizeCb = function(func, context, argCount) {

    64     if (context === void 0) return func;

    65     switch (argCount == null ? 3 : argCount) {

    66       case 1: return function(value) {

    67         return func.call(context, value);

    68       };

    69       case 2: return function(value, other) {

    70         return func.call(context, value, other);

    71       };

    72       case 3: return function(value, index, collection) {

    73         return func.call(context, value, index, collection);

    74       };

    75       case 4: return function(accumulator, value, index, collection) {

    76         return func.call(context, accumulator, value, index, collection);

    77       };

    78     }

    79     return function() {

    80       return func.apply(context, arguments);

    81     };

    82   };

    83 

    84   // A mostly-internal function to generate callbacks that can be applied

    85   // to each element in a collection, returning the desired result — either

    86   // identity, an arbitrary callback, a property matcher, or a property accessor.

    87   var cb = function(value, context, argCount) {

    88     if (value == null) return _.identity;

    89     if (_.isFunction(value)) return optimizeCb(value, context, argCount);

    90     if (_.isObject(value)) return _.matcher(value);

    91     return _.property(value);

    92   };

    93   _.iteratee = function(value, context) {

    94     return cb(value, context, Infinity);

    95   };

    96 

    97   // An internal function for creating assigner functions.

    98   var createAssigner = function(keysFunc, undefinedOnly) {

    99     return function(obj) {

   100       var length = arguments.length;

   101       if (length < 2 || obj == null) return obj;

   102       for (var index = 1; index < length; index++) {

   103         var source = arguments[index],

   104             keys = keysFunc(source),

   105             l = keys.length;

   106         for (var i = 0; i < l; i++) {

   107           var key = keys[i];

   108           if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];

   109         }

   110       }

   111       return obj;

   112     };

   113   };

   114 

   115   // An internal function for creating a new object that inherits from another.

   116   var baseCreate = function(prototype) {

   117     if (!_.isObject(prototype)) return {};

   118     if (nativeCreate) return nativeCreate(prototype);

   119     Ctor.prototype = prototype;

   120     var result = new Ctor;

   121     Ctor.prototype = null;

   122     return result;

   123   };

   124 

   125   var property = function(key) {

   126     return function(obj) {

   127       return obj == null ? void 0 : obj[key];

   128     };

   129   };

   130 

   131   // Helper for collection methods to determine whether a collection

   132   // should be iterated as an array or as an object

   133   // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength

   134   // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094

   135   var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;

   136   var getLength = property('length');

   137   var isArrayLike = function(collection) {

   138     var length = getLength(collection);

   139     return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;

   140   };

   141 

   142   // Collection Functions

   143   // --------------------

   144 

   145   // The cornerstone, an `each` implementation, aka `forEach`.

   146   // Handles raw objects in addition to array-likes. Treats all

   147   // sparse array-likes as if they were dense.

   148   _.each = _.forEach = function(obj, iteratee, context) {

   149     iteratee = optimizeCb(iteratee, context);

   150     var i, length;

   151     if (isArrayLike(obj)) {

   152       for (i = 0, length = obj.length; i < length; i++) {

   153         iteratee(obj[i], i, obj);

   154       }

   155     } else {

   156       var keys = _.keys(obj);

   157       for (i = 0, length = keys.length; i < length; i++) {

   158         iteratee(obj[keys[i]], keys[i], obj);

   159       }

   160     }

   161     return obj;

   162   };

   163 

   164   // Return the results of applying the iteratee to each element.

   165   _.map = _.collect = function(obj, iteratee, context) {

   166     iteratee = cb(iteratee, context);

   167     var keys = !isArrayLike(obj) && _.keys(obj),

   168         length = (keys || obj).length,

   169         results = Array(length);

   170     for (var index = 0; index < length; index++) {

   171       var currentKey = keys ? keys[index] : index;

   172       results[index] = iteratee(obj[currentKey], currentKey, obj);

   173     }

   174     return results;

   175   };

   176 

   177   // Create a reducing function iterating left or right.

   178   function createReduce(dir) {

   179     // Optimized iterator function as using arguments.length

   180     // in the main function will deoptimize the, see #1991.

   181     function iterator(obj, iteratee, memo, keys, index, length) {

   182       for (; index >= 0 && index < length; index += dir) {

   183         var currentKey = keys ? keys[index] : index;

   184         memo = iteratee(memo, obj[currentKey], currentKey, obj);

   185       }

   186       return memo;

   187     }

   188 

   189     return function(obj, iteratee, memo, context) {

   190       iteratee = optimizeCb(iteratee, context, 4);

   191       var keys = !isArrayLike(obj) && _.keys(obj),

   192           length = (keys || obj).length,

   193           index = dir > 0 ? 0 : length - 1;

   194       // Determine the initial value if none is provided.

   195       if (arguments.length < 3) {

   196         memo = obj[keys ? keys[index] : index];

   197         index += dir;

   198       }

   199       return iterator(obj, iteratee, memo, keys, index, length);

   200     };

   201   }

   202 

   203   // **Reduce** builds up a single result from a list of values, aka `inject`,

   204   // or `foldl`.

   205   _.reduce = _.foldl = _.inject = createReduce(1);

   206 

   207   // The right-associative version of reduce, also known as `foldr`.

   208   _.reduceRight = _.foldr = createReduce(-1);

   209 

   210   // Return the first value which passes a truth test. Aliased as `detect`.

   211   _.find = _.detect = function(obj, predicate, context) {

   212     var key;

   213     if (isArrayLike(obj)) {

   214       key = _.findIndex(obj, predicate, context);

   215     } else {

   216       key = _.findKey(obj, predicate, context);

   217     }

   218     if (key !== void 0 && key !== -1) return obj[key];

   219   };

   220 

   221   // Return all the elements that pass a truth test.

   222   // Aliased as `select`.

   223   _.filter = _.select = function(obj, predicate, context) {

   224     var results = [];

   225     predicate = cb(predicate, context);

   226     _.each(obj, function(value, index, list) {

   227       if (predicate(value, index, list)) results.push(value);

   228     });

   229     return results;

   230   };

   231 

   232   // Return all the elements for which a truth test fails.

   233   _.reject = function(obj, predicate, context) {

   234     return _.filter(obj, _.negate(cb(predicate)), context);

   235   };

   236 

   237   // Determine whether all of the elements match a truth test.

   238   // Aliased as `all`.

   239   _.every = _.all = function(obj, predicate, context) {

   240     predicate = cb(predicate, context);

   241     var keys = !isArrayLike(obj) && _.keys(obj),

   242         length = (keys || obj).length;

   243     for (var index = 0; index < length; index++) {

   244       var currentKey = keys ? keys[index] : index;

   245       if (!predicate(obj[currentKey], currentKey, obj)) return false;

   246     }

   247     return true;

   248   };

   249 

   250   // Determine if at least one element in the object matches a truth test.

   251   // Aliased as `any`.

   252   _.some = _.any = function(obj, predicate, context) {

   253     predicate = cb(predicate, context);

   254     var keys = !isArrayLike(obj) && _.keys(obj),

   255         length = (keys || obj).length;

   256     for (var index = 0; index < length; index++) {

   257       var currentKey = keys ? keys[index] : index;

   258       if (predicate(obj[currentKey], currentKey, obj)) return true;

   259     }

   260     return false;

   261   };

   262 

   263   // Determine if the array or object contains a given item (using `===`).

   264   // Aliased as `includes` and `include`.

   265   _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {

   266     if (!isArrayLike(obj)) obj = _.values(obj);

   267     if (typeof fromIndex != 'number' || guard) fromIndex = 0;

   268     return _.indexOf(obj, item, fromIndex) >= 0;

   269   };

   270 

   271   // Invoke a method (with arguments) on every item in a collection.

   272   _.invoke = function(obj, method) {

   273     var args = slice.call(arguments, 2);

   274     var isFunc = _.isFunction(method);

   275     return _.map(obj, function(value) {

   276       var func = isFunc ? method : value[method];

   277       return func == null ? func : func.apply(value, args);

   278     });

   279   };

   280 

   281   // Convenience version of a common use case of `map`: fetching a property.

   282   _.pluck = function(obj, key) {

   283     return _.map(obj, _.property(key));

   284   };

   285 

   286   // Convenience version of a common use case of `filter`: selecting only objects

   287   // containing specific `key:value` pairs.

   288   _.where = function(obj, attrs) {

   289     return _.filter(obj, _.matcher(attrs));

   290   };

   291 

   292   // Convenience version of a common use case of `find`: getting the first object

   293   // containing specific `key:value` pairs.

   294   _.findWhere = function(obj, attrs) {

   295     return _.find(obj, _.matcher(attrs));

   296   };

   297 

   298   // Return the maximum element (or element-based computation).

   299   _.max = function(obj, iteratee, context) {

   300     var result = -Infinity, lastComputed = -Infinity,

   301         value, computed;

   302     if (iteratee == null && obj != null) {

   303       obj = isArrayLike(obj) ? obj : _.values(obj);

   304       for (var i = 0, length = obj.length; i < length; i++) {

   305         value = obj[i];

   306         if (value > result) {

   307           result = value;

   308         }

   309       }

   310     } else {

   311       iteratee = cb(iteratee, context);

   312       _.each(obj, function(value, index, list) {

   313         computed = iteratee(value, index, list);

   314         if (computed > lastComputed || computed === -Infinity && result === -Infinity) {

   315           result = value;

   316           lastComputed = computed;

   317         }

   318       });

   319     }

   320     return result;

   321   };

   322 

   323   // Return the minimum element (or element-based computation).

   324   _.min = function(obj, iteratee, context) {

   325     var result = Infinity, lastComputed = Infinity,

   326         value, computed;

   327     if (iteratee == null && obj != null) {

   328       obj = isArrayLike(obj) ? obj : _.values(obj);

   329       for (var i = 0, length = obj.length; i < length; i++) {

   330         value = obj[i];

   331         if (value < result) {

   332           result = value;

   333         }

   334       }

   335     } else {

   336       iteratee = cb(iteratee, context);

   337       _.each(obj, function(value, index, list) {

   338         computed = iteratee(value, index, list);

   339         if (computed < lastComputed || computed === Infinity && result === Infinity) {

   340           result = value;

   341           lastComputed = computed;

   342         }

   343       });

   344     }

   345     return result;

   346   };

   347 

   348   // Shuffle a collection, using the modern version of the

   349   // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).

   350   _.shuffle = function(obj) {

   351     var set = isArrayLike(obj) ? obj : _.values(obj);

   352     var length = set.length;

   353     var shuffled = Array(length);

   354     for (var index = 0, rand; index < length; index++) {

   355       rand = _.random(0, index);

   356       if (rand !== index) shuffled[index] = shuffled[rand];

   357       shuffled[rand] = set[index];

   358     }

   359     return shuffled;

   360   };

   361 

   362   // Sample **n** random values from a collection.

   363   // If **n** is not specified, returns a single random element.

   364   // The internal `guard` argument allows it to work with `map`.

   365   _.sample = function(obj, n, guard) {

   366     if (n == null || guard) {

   367       if (!isArrayLike(obj)) obj = _.values(obj);

   368       return obj[_.random(obj.length - 1)];

   369     }

   370     return _.shuffle(obj).slice(0, Math.max(0, n));

   371   };

   372 

   373   // Sort the object's values by a criterion produced by an iteratee.

   374   _.sortBy = function(obj, iteratee, context) {

   375     iteratee = cb(iteratee, context);

   376     return _.pluck(_.map(obj, function(value, index, list) {

   377       return {

   378         value: value,

   379         index: index,

   380         criteria: iteratee(value, index, list)

   381       };

   382     }).sort(function(left, right) {

   383       var a = left.criteria;

   384       var b = right.criteria;

   385       if (a !== b) {

   386         if (a > b || a === void 0) return 1;

   387         if (a < b || b === void 0) return -1;

   388       }

   389       return left.index - right.index;

   390     }), 'value');

   391   };

   392 

   393   // An internal function used for aggregate "group by" operations.

   394   var group = function(behavior) {

   395     return function(obj, iteratee, context) {

   396       var result = {};

   397       iteratee = cb(iteratee, context);

   398       _.each(obj, function(value, index) {

   399         var key = iteratee(value, index, obj);

   400         behavior(result, value, key);

   401       });

   402       return result;

   403     };

   404   };

   405 

   406   // Groups the object's values by a criterion. Pass either a string attribute

   407   // to group by, or a function that returns the criterion.

   408   _.groupBy = group(function(result, value, key) {

   409     if (_.has(result, key)) result[key].push(value); else result[key] = [value];

   410   });

   411 

   412   // Indexes the object's values by a criterion, similar to `groupBy`, but for

   413   // when you know that your index values will be unique.

   414   _.indexBy = group(function(result, value, key) {

   415     result[key] = value;

   416   });

   417 

   418   // Counts instances of an object that group by a certain criterion. Pass

   419   // either a string attribute to count by, or a function that returns the

   420   // criterion.

   421   _.countBy = group(function(result, value, key) {

   422     if (_.has(result, key)) result[key]++; else result[key] = 1;

   423   });

   424 

   425   // Safely create a real, live array from anything iterable.

   426   _.toArray = function(obj) {

   427     if (!obj) return [];

   428     if (_.isArray(obj)) return slice.call(obj);

   429     if (isArrayLike(obj)) return _.map(obj, _.identity);

   430     return _.values(obj);

   431   };

   432 

   433   // Return the number of elements in an object.

   434   _.size = function(obj) {

   435     if (obj == null) return 0;

   436     return isArrayLike(obj) ? obj.length : _.keys(obj).length;

   437   };

   438 

   439   // Split a collection into two arrays: one whose elements all satisfy the given

   440   // predicate, and one whose elements all do not satisfy the predicate.

   441   _.partition = function(obj, predicate, context) {

   442     predicate = cb(predicate, context);

   443     var pass = [], fail = [];

   444     _.each(obj, function(value, key, obj) {

   445       (predicate(value, key, obj) ? pass : fail).push(value);

   446     });

   447     return [pass, fail];

   448   };

   449 

   450   // Array Functions

   451   // ---------------

   452 

   453   // Get the first element of an array. Passing **n** will return the first N

   454   // values in the array. Aliased as `head` and `take`. The **guard** check

   455   // allows it to work with `_.map`.

   456   _.first = _.head = _.take = function(array, n, guard) {

   457     if (array == null) return void 0;

   458     if (n == null || guard) return array[0];

   459     return _.initial(array, array.length - n);

   460   };

   461 

   462   // Returns everything but the last entry of the array. Especially useful on

   463   // the arguments object. Passing **n** will return all the values in

   464   // the array, excluding the last N.

   465   _.initial = function(array, n, guard) {

   466     return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));

   467   };

   468 

   469   // Get the last element of an array. Passing **n** will return the last N

   470   // values in the array.

   471   _.last = function(array, n, guard) {

   472     if (array == null) return void 0;

   473     if (n == null || guard) return array[array.length - 1];

   474     return _.rest(array, Math.max(0, array.length - n));

   475   };

   476 

   477   // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.

   478   // Especially useful on the arguments object. Passing an **n** will return

   479   // the rest N values in the array.

   480   _.rest = _.tail = _.drop = function(array, n, guard) {

   481     return slice.call(array, n == null || guard ? 1 : n);

   482   };

   483 

   484   // Trim out all falsy values from an array.

   485   _.compact = function(array) {

   486     return _.filter(array, _.identity);

   487   };

   488 

   489   // Internal implementation of a recursive `flatten` function.

   490   var flatten = function(input, shallow, strict, startIndex) {

   491     var output = [], idx = 0;

   492     for (var i = startIndex || 0, length = getLength(input); i < length; i++) {

   493       var value = input[i];

   494       if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {

   495         //flatten current level of array or arguments object

   496         if (!shallow) value = flatten(value, shallow, strict);

   497         var j = 0, len = value.length;

   498         output.length += len;

   499         while (j < len) {

   500           output[idx++] = value[j++];

   501         }

   502       } else if (!strict) {

   503         output[idx++] = value;

   504       }

   505     }

   506     return output;

   507   };

   508 

   509   // Flatten out an array, either recursively (by default), or just one level.

   510   _.flatten = function(array, shallow) {

   511     return flatten(array, shallow, false);

   512   };

   513 

   514   // Return a version of the array that does not contain the specified value(s).

   515   _.without = function(array) {

   516     return _.difference(array, slice.call(arguments, 1));

   517   };

   518 

   519   // Produce a duplicate-free version of the array. If the array has already

   520   // been sorted, you have the option of using a faster algorithm.

   521   // Aliased as `unique`.

   522   _.uniq = _.unique = function(array, isSorted, iteratee, context) {

   523     if (!_.isBoolean(isSorted)) {

   524       context = iteratee;

   525       iteratee = isSorted;

   526       isSorted = false;

   527     }

   528     if (iteratee != null) iteratee = cb(iteratee, context);

   529     var result = [];

   530     var seen = [];

   531     for (var i = 0, length = getLength(array); i < length; i++) {

   532       var value = array[i],

   533           computed = iteratee ? iteratee(value, i, array) : value;

   534       if (isSorted) {

   535         if (!i || seen !== computed) result.push(value);

   536         seen = computed;

   537       } else if (iteratee) {

   538         if (!_.contains(seen, computed)) {

   539           seen.push(computed);

   540           result.push(value);

   541         }

   542       } else if (!_.contains(result, value)) {

   543         result.push(value);

   544       }

   545     }

   546     return result;

   547   };

   548 

   549   // Produce an array that contains the union: each distinct element from all of

   550   // the passed-in arrays.

   551   _.union = function() {

   552     return _.uniq(flatten(arguments, true, true));

   553   };

   554 

   555   // Produce an array that contains every item shared between all the

   556   // passed-in arrays.

   557   _.intersection = function(array) {

   558     var result = [];

   559     var argsLength = arguments.length;

   560     for (var i = 0, length = getLength(array); i < length; i++) {

   561       var item = array[i];

   562       if (_.contains(result, item)) continue;

   563       for (var j = 1; j < argsLength; j++) {

   564         if (!_.contains(arguments[j], item)) break;

   565       }

   566       if (j === argsLength) result.push(item);

   567     }

   568     return result;

   569   };

   570 

   571   // Take the difference between one array and a number of other arrays.

   572   // Only the elements present in just the first array will remain.

   573   _.difference = function(array) {

   574     var rest = flatten(arguments, true, true, 1);

   575     return _.filter(array, function(value){

   576       return !_.contains(rest, value);

   577     });

   578   };

   579 

   580   // Zip together multiple lists into a single array -- elements that share

   581   // an index go together.

   582   _.zip = function() {

   583     return _.unzip(arguments);

   584   };

   585 

   586   // Complement of _.zip. Unzip accepts an array of arrays and groups

   587   // each array's elements on shared indices

   588   _.unzip = function(array) {

   589     var length = array && _.max(array, getLength).length || 0;

   590     var result = Array(length);

   591 

   592     for (var index = 0; index < length; index++) {

   593       result[index] = _.pluck(array, index);

   594     }

   595     return result;

   596   };

   597 

   598   // Converts lists into objects. Pass either a single array of `[key, value]`

   599   // pairs, or two parallel arrays of the same length -- one of keys, and one of

   600   // the corresponding values.

   601   _.object = function(list, values) {

   602     var result = {};

   603     for (var i = 0, length = getLength(list); i < length; i++) {

   604       if (values) {

   605         result[list[i]] = values[i];

   606       } else {

   607         result[list[i][0]] = list[i][1];

   608       }

   609     }

   610     return result;

   611   };

   612 

   613   // Generator function to create the findIndex and findLastIndex functions

   614   function createPredicateIndexFinder(dir) {

   615     return function(array, predicate, context) {

   616       predicate = cb(predicate, context);

   617       var length = getLength(array);

   618       var index = dir > 0 ? 0 : length - 1;

   619       for (; index >= 0 && index < length; index += dir) {

   620         if (predicate(array[index], index, array)) return index;

   621       }

   622       return -1;

   623     };

   624   }

   625 

   626   // Returns the first index on an array-like that passes a predicate test

   627   _.findIndex = createPredicateIndexFinder(1);

   628   _.findLastIndex = createPredicateIndexFinder(-1);

   629 

   630   // Use a comparator function to figure out the smallest index at which

   631   // an object should be inserted so as to maintain order. Uses binary search.

   632   _.sortedIndex = function(array, obj, iteratee, context) {

   633     iteratee = cb(iteratee, context, 1);

   634     var value = iteratee(obj);

   635     var low = 0, high = getLength(array);

   636     while (low < high) {

   637       var mid = Math.floor((low + high) / 2);

   638       if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;

   639     }

   640     return low;

   641   };

   642 

   643   // Generator function to create the indexOf and lastIndexOf functions

   644   function createIndexFinder(dir, predicateFind, sortedIndex) {

   645     return function(array, item, idx) {

   646       var i = 0, length = getLength(array);

   647       if (typeof idx == 'number') {

   648         if (dir > 0) {

   649             i = idx >= 0 ? idx : Math.max(idx + length, i);

   650         } else {

   651             length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;

   652         }

   653       } else if (sortedIndex && idx && length) {

   654         idx = sortedIndex(array, item);

   655         return array[idx] === item ? idx : -1;

   656       }

   657       if (item !== item) {

   658         idx = predicateFind(slice.call(array, i, length), _.isNaN);

   659         return idx >= 0 ? idx + i : -1;

   660       }

   661       for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {

   662         if (array[idx] === item) return idx;

   663       }

   664       return -1;

   665     };

   666   }

   667 

   668   // Return the position of the first occurrence of an item in an array,

   669   // or -1 if the item is not included in the array.

   670   // If the array is large and already in sort order, pass `true`

   671   // for **isSorted** to use binary search.

   672   _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);

   673   _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);

   674 

   675   // Generate an integer Array containing an arithmetic progression. A port of

   676   // the native Python `range()` function. See

   677   // [the Python documentation](http://docs.python.org/library/functions.html#range).

   678   _.range = function(start, stop, step) {

   679     if (stop == null) {

   680       stop = start || 0;

   681       start = 0;

   682     }

   683     step = step || 1;

   684 

   685     var length = Math.max(Math.ceil((stop - start) / step), 0);

   686     var range = Array(length);

   687 

   688     for (var idx = 0; idx < length; idx++, start += step) {

   689       range[idx] = start;

   690     }

   691 

   692     return range;

   693   };

   694 

   695   // Function (ahem) Functions

   696   // ------------------

   697 

   698   // Determines whether to execute a function as a constructor

   699   // or a normal function with the provided arguments

   700   var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {

   701     if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);

   702     var self = baseCreate(sourceFunc.prototype);

   703     var result = sourceFunc.apply(self, args);

   704     if (_.isObject(result)) return result;

   705     return self;

   706   };

   707 

   708   // Create a function bound to a given object (assigning `this`, and arguments,

   709   // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if

   710   // available.

   711   _.bind = function(func, context) {

   712     if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));

   713     if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');

   714     var args = slice.call(arguments, 2);

   715     var bound = function() {

   716       return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));

   717     };

   718     return bound;

   719   };

   720 

   721   // Partially apply a function by creating a version that has had some of its

   722   // arguments pre-filled, without changing its dynamic `this` context. _ acts

   723   // as a placeholder, allowing any combination of arguments to be pre-filled.

   724   _.partial = function(func) {

   725     var boundArgs = slice.call(arguments, 1);

   726     var bound = function() {

   727       var position = 0, length = boundArgs.length;

   728       var args = Array(length);

   729       for (var i = 0; i < length; i++) {

   730         args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];

   731       }

   732       while (position < arguments.length) args.push(arguments[position++]);

   733       return executeBound(func, bound, this, this, args);

   734     };

   735     return bound;

   736   };

   737 

   738   // Bind a number of an object's methods to that object. Remaining arguments

   739   // are the method names to be bound. Useful for ensuring that all callbacks

   740   // defined on an object belong to it.

   741   _.bindAll = function(obj) {

   742     var i, length = arguments.length, key;

   743     if (length <= 1) throw new Error('bindAll must be passed function names');

   744     for (i = 1; i < length; i++) {

   745       key = arguments[i];

   746       obj[key] = _.bind(obj[key], obj);

   747     }

   748     return obj;

   749   };

   750 

   751   // Memoize an expensive function by storing its results.

   752   _.memoize = function(func, hasher) {

   753     var memoize = function(key) {

   754       var cache = memoize.cache;

   755       var address = '' + (hasher ? hasher.apply(this, arguments) : key);

   756       if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);

   757       return cache[address];

   758     };

   759     memoize.cache = {};

   760     return memoize;

   761   };

   762 

   763   // Delays a function for the given number of milliseconds, and then calls

   764   // it with the arguments supplied.

   765   _.delay = function(func, wait) {

   766     var args = slice.call(arguments, 2);

   767     return setTimeout(function(){

   768       return func.apply(null, args);

   769     }, wait);

   770   };

   771 

   772   // Defers a function, scheduling it to run after the current call stack has

   773   // cleared.

   774   _.defer = _.partial(_.delay, _, 1);

   775 

   776   // Returns a function, that, when invoked, will only be triggered at most once

   777   // during a given window of time. Normally, the throttled function will run

   778   // as much as it can, without ever going more than once per `wait` duration;

   779   // but if you'd like to disable the execution on the leading edge, pass

   780   // `{leading: false}`. To disable execution on the trailing edge, ditto.

   781   _.throttle = function(func, wait, options) {

   782     var context, args, result;

   783     var timeout = null;

   784     var previous = 0;

   785     if (!options) options = {};

   786     var later = function() {

   787       previous = options.leading === false ? 0 : _.now();

   788       timeout = null;

   789       result = func.apply(context, args);

   790       if (!timeout) context = args = null;

   791     };

   792     return function() {

   793       var now = _.now();

   794       if (!previous && options.leading === false) previous = now;

   795       var remaining = wait - (now - previous);

   796       context = this;

   797       args = arguments;

   798       if (remaining <= 0 || remaining > wait) {

   799         if (timeout) {

   800           clearTimeout(timeout);

   801           timeout = null;

   802         }

   803         previous = now;

   804         result = func.apply(context, args);

   805         if (!timeout) context = args = null;

   806       } else if (!timeout && options.trailing !== false) {

   807         timeout = setTimeout(later, remaining);

   808       }

   809       return result;

   810     };

   811   };

   812 

   813   // Returns a function, that, as long as it continues to be invoked, will not

   814   // be triggered. The function will be called after it stops being called for

   815   // N milliseconds. If `immediate` is passed, trigger the function on the

   816   // leading edge, instead of the trailing.

   817   _.debounce = function(func, wait, immediate) {

   818     var timeout, args, context, timestamp, result;

   819 

   820     var later = function() {

   821       var last = _.now() - timestamp;

   822 

   823       if (last < wait && last >= 0) {

   824         timeout = setTimeout(later, wait - last);

   825       } else {

   826         timeout = null;

   827         if (!immediate) {

   828           result = func.apply(context, args);

   829           if (!timeout) context = args = null;

   830         }

   831       }

   832     };

   833 

   834     return function() {

   835       context = this;

   836       args = arguments;

   837       timestamp = _.now();

   838       var callNow = immediate && !timeout;

   839       if (!timeout) timeout = setTimeout(later, wait);

   840       if (callNow) {

   841         result = func.apply(context, args);

   842         context = args = null;

   843       }

   844 

   845       return result;

   846     };

   847   };

   848 

   849   // Returns the first function passed as an argument to the second,

   850   // allowing you to adjust arguments, run code before and after, and

   851   // conditionally execute the original function.

   852   _.wrap = function(func, wrapper) {

   853     return _.partial(wrapper, func);

   854   };

   855 

   856   // Returns a negated version of the passed-in predicate.

   857   _.negate = function(predicate) {

   858     return function() {

   859       return !predicate.apply(this, arguments);

   860     };

   861   };

   862 

   863   // Returns a function that is the composition of a list of functions, each

   864   // consuming the return value of the function that follows.

   865   _.compose = function() {

   866     var args = arguments;

   867     var start = args.length - 1;

   868     return function() {

   869       var i = start;

   870       var result = args[start].apply(this, arguments);

   871       while (i--) result = args[i].call(this, result);

   872       return result;

   873     };

   874   };

   875 

   876   // Returns a function that will only be executed on and after the Nth call.

   877   _.after = function(times, func) {

   878     return function() {

   879       if (--times < 1) {

   880         return func.apply(this, arguments);

   881       }

   882     };

   883   };

   884 

   885   // Returns a function that will only be executed up to (but not including) the Nth call.

   886   _.before = function(times, func) {

   887     var memo;

   888     return function() {

   889       if (--times > 0) {

   890         memo = func.apply(this, arguments);

   891       }

   892       if (times <= 1) func = null;

   893       return memo;

   894     };

   895   };

   896 

   897   // Returns a function that will be executed at most one time, no matter how

   898   // often you call it. Useful for lazy initialization.

   899   _.once = _.partial(_.before, 2);

   900 

   901   // Object Functions

   902   // ----------------

   907                       'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

    54     'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

   908 

    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]; },

   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.

   912     var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;

   267     var proto = isFunction$1(constructor) && constructor.prototype || ObjProto;