1 //     Underscore.js 1.6.0

     2 //     http://underscorejs.org

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

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

     5 

     6 (function() {

     7 

     8   // Baseline setup

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

    10 

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

    12   var root = this;

    13 

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

    15   var previousUnderscore = root._;

    16 

    17   // Establish the object that gets returned to break out of a loop iteration.

    18   var breaker = {};

    19 

    20   // Save bytes in the minified (but not gzipped) version:

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

    22 

    23   // Create quick reference variables for speed access to core prototypes.

    24   var

    25     push             = ArrayProto.push,

    26     slice            = ArrayProto.slice,

    27     concat           = ArrayProto.concat,

    28     toString         = ObjProto.toString,

    29     hasOwnProperty   = ObjProto.hasOwnProperty;

    30 

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

    32   // are declared here.

    33   var

    34     nativeForEach      = ArrayProto.forEach,

    35     nativeMap          = ArrayProto.map,

    36     nativeReduce       = ArrayProto.reduce,

    37     nativeReduceRight  = ArrayProto.reduceRight,

    38     nativeFilter       = ArrayProto.filter,

    39     nativeEvery        = ArrayProto.every,

    40     nativeSome         = ArrayProto.some,

    41     nativeIndexOf      = ArrayProto.indexOf,

    42     nativeLastIndexOf  = ArrayProto.lastIndexOf,

    43     nativeIsArray      = Array.isArray,

    44     nativeKeys         = Object.keys,

    45     nativeBind         = FuncProto.bind;

    46 

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

    48   var _ = function(obj) {

    49     if (obj instanceof _) return obj;

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

    51     this._wrapped = obj;

    52   };

    53 

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

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

    56   // the browser, add `_` as a global object via a string identifier,

    57   // for Closure Compiler "advanced" mode.

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

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

    60       exports = module.exports = _;

    61     }

    62     exports._ = _;

    63   } else {

    64     root._ = _;

    65   }

    66 

    67   // Current version.

    68   _.VERSION = '1.6.0';

    69 

    70   // Collection Functions

    71   // --------------------

    72 

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

    74   // Handles objects with the built-in `forEach`, arrays, and raw objects.

    75   // Delegates to **ECMAScript 5**'s native `forEach` if available.

    76   var each = _.each = _.forEach = function(obj, iterator, context) {

    77     if (obj == null) return obj;

    78     if (nativeForEach && obj.forEach === nativeForEach) {

    79       obj.forEach(iterator, context);

    80     } else if (obj.length === +obj.length) {

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

    82         if (iterator.call(context, obj[i], i, obj) === breaker) return;

    83       }

    84     } else {

    85       var keys = _.keys(obj);

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

    87         if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;

    88       }

    89     }

    90     return obj;

    91   };

    92 

    93   // Return the results of applying the iterator to each element.

    94   // Delegates to **ECMAScript 5**'s native `map` if available.

    95   _.map = _.collect = function(obj, iterator, context) {

    96     var results = [];

    97     if (obj == null) return results;

    98     if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);

    99     each(obj, function(value, index, list) {

   100       results.push(iterator.call(context, value, index, list));

   101     });

   102     return results;

   103   };

   104 

   105   var reduceError = 'Reduce of empty array with no initial value';

   106 

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

   108   // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.

   109   _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {

   110     var initial = arguments.length > 2;

   111     if (obj == null) obj = [];

   112     if (nativeReduce && obj.reduce === nativeReduce) {

   113       if (context) iterator = _.bind(iterator, context);

   114       return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);

   115     }

   116     each(obj, function(value, index, list) {

   117       if (!initial) {

   118         memo = value;

   119         initial = true;

   120       } else {

   121         memo = iterator.call(context, memo, value, index, list);

   122       }

   123     });

   124     if (!initial) throw new TypeError(reduceError);

   125     return memo;

   126   };

   127 

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

   129   // Delegates to **ECMAScript 5**'s native `reduceRight` if available.

   130   _.reduceRight = _.foldr = function(obj, iterator, memo, context) {

   131     var initial = arguments.length > 2;

   132     if (obj == null) obj = [];

   133     if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {

   134       if (context) iterator = _.bind(iterator, context);

   135       return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);

   136     }

   137     var length = obj.length;

   138     if (length !== +length) {

   139       var keys = _.keys(obj);

   140       length = keys.length;

   141     }

   142     each(obj, function(value, index, list) {

   143       index = keys ? keys[--length] : --length;

   144       if (!initial) {

   145         memo = obj[index];

   146         initial = true;

   147       } else {

   148         memo = iterator.call(context, memo, obj[index], index, list);

   149       }

   150     });

   151     if (!initial) throw new TypeError(reduceError);

   152     return memo;

   153   };

   154 

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

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

   157     var result;

   158     any(obj, function(value, index, list) {

   159       if (predicate.call(context, value, index, list)) {

   160         result = value;

   161         return true;

   162       }

   163     });

   164     return result;

   165   };

   166 

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

   168   // Delegates to **ECMAScript 5**'s native `filter` if available.

   169   // Aliased as `select`.

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

   171     var results = [];

   172     if (obj == null) return results;

   173     if (nativeFilter && obj.filter === nativeFilter) return obj.filter(predicate, context);

   174     each(obj, function(value, index, list) {

   175       if (predicate.call(context, value, index, list)) results.push(value);

   176     });

   177     return results;

   178   };

   179 

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

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

   182     return _.filter(obj, function(value, index, list) {

   183       return !predicate.call(context, value, index, list);

   184     }, context);

   185   };

   186 

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

   188   // Delegates to **ECMAScript 5**'s native `every` if available.

   189   // Aliased as `all`.

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

   191     predicate || (predicate = _.identity);

   192     var result = true;

   193     if (obj == null) return result;

   194     if (nativeEvery && obj.every === nativeEvery) return obj.every(predicate, context);

   195     each(obj, function(value, index, list) {

   196       if (!(result = result && predicate.call(context, value, index, list))) return breaker;

   197     });

   198     return !!result;

   199   };

   200 

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

   202   // Delegates to **ECMAScript 5**'s native `some` if available.

   203   // Aliased as `any`.

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

   205     predicate || (predicate = _.identity);

   206     var result = false;

   207     if (obj == null) return result;

   208     if (nativeSome && obj.some === nativeSome) return obj.some(predicate, context);

   209     each(obj, function(value, index, list) {

   210       if (result || (result = predicate.call(context, value, index, list))) return breaker;

   211     });

   212     return !!result;

   213   };

   214 

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

   216   // Aliased as `include`.

   217   _.contains = _.include = function(obj, target) {

   218     if (obj == null) return false;

   219     if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;

   220     return any(obj, function(value) {

   221       return value === target;

   222     });

   223   };

   224 

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

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

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

   228     var isFunc = _.isFunction(method);

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

   230       return (isFunc ? method : value[method]).apply(value, args);

   231     });

   232   };

   233 

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

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

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

   237   };

   238 

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

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

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

   242     return _.filter(obj, _.matches(attrs));

   243   };

   244 

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

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

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

   248     return _.find(obj, _.matches(attrs));

   249   };

   250 

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

   252   // Can't optimize arrays of integers longer than 65,535 elements.

   253   // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)

   254   _.max = function(obj, iterator, context) {

   255     if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {

   256       return Math.max.apply(Math, obj);

   257     }

   258     var result = -Infinity, lastComputed = -Infinity;

   259     each(obj, function(value, index, list) {

   260       var computed = iterator ? iterator.call(context, value, index, list) : value;

   261       if (computed > lastComputed) {

   262         result = value;

   263         lastComputed = computed;

   264       }

   265     });

   266     return result;

   267   };

   268 

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

   270   _.min = function(obj, iterator, context) {

   271     if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {

   272       return Math.min.apply(Math, obj);

   273     }

   274     var result = Infinity, lastComputed = Infinity;

   275     each(obj, function(value, index, list) {

   276       var computed = iterator ? iterator.call(context, value, index, list) : value;

   277       if (computed < lastComputed) {

   278         result = value;

   279         lastComputed = computed;

   280       }

   281     });

   282     return result;

   283   };

   284 

   285   // Shuffle an array, using the modern version of the

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

   287   _.shuffle = function(obj) {

   288     var rand;

   289     var index = 0;

   290     var shuffled = [];

   291     each(obj, function(value) {

   292       rand = _.random(index++);

   293       shuffled[index - 1] = shuffled[rand];

   294       shuffled[rand] = value;

   295     });

   296     return shuffled;

   297   };

   298 

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

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

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

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

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

   304       if (obj.length !== +obj.length) obj = _.values(obj);

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

   306     }

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

   308   };

   309 

   310   // An internal function to generate lookup iterators.

   311   var lookupIterator = function(value) {

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

   313     if (_.isFunction(value)) return value;

   314     return _.property(value);

   315   };

   316 

   317   // Sort the object's values by a criterion produced by an iterator.

   318   _.sortBy = function(obj, iterator, context) {

   319     iterator = lookupIterator(iterator);

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

   321       return {

   322         value: value,

   323         index: index,

   324         criteria: iterator.call(context, value, index, list)

   325       };

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

   327       var a = left.criteria;

   328       var b = right.criteria;

   329       if (a !== b) {

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

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

   332       }

   333       return left.index - right.index;

   334     }), 'value');

   335   };

   336 

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

   338   var group = function(behavior) {

   339     return function(obj, iterator, context) {

   340       var result = {};

   341       iterator = lookupIterator(iterator);

   342       each(obj, function(value, index) {

   343         var key = iterator.call(context, value, index, obj);

   344         behavior(result, key, value);

   345       });

   346       return result;

   347     };

   348   };

   349 

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

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

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

   353     _.has(result, key) ? result[key].push(value) : result[key] = [value];

   354   });

   355 

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

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

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

   359     result[key] = value;

   360   });

   361 

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

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

   364   // criterion.

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

   366     _.has(result, key) ? result[key]++ : result[key] = 1;

   367   });

   368 

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

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

   371   _.sortedIndex = function(array, obj, iterator, context) {

   372     iterator = lookupIterator(iterator);

   373     var value = iterator.call(context, obj);

   374     var low = 0, high = array.length;

   375     while (low < high) {

   376       var mid = (low + high) >>> 1;

   377       iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;

   378     }

   379     return low;

   380   };

   381 

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

   383   _.toArray = function(obj) {

   384     if (!obj) return [];

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

   386     if (obj.length === +obj.length) return _.map(obj, _.identity);

   387     return _.values(obj);

   388   };

   389 

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

   391   _.size = function(obj) {

   392     if (obj == null) return 0;

   393     return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;

   394   };

   395 

   396   // Array Functions

   397   // ---------------

   398 

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

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

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

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

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

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

   405     if (n < 0) return [];

   406     return slice.call(array, 0, n);

   407   };

   408 

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

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

   411   // the array, excluding the last N. The **guard** check allows it to work with

   412   // `_.map`.

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

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

   415   };

   416 

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

   418   // values in the array. The **guard** check allows it to work with `_.map`.

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

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

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

   422     return slice.call(array, Math.max(array.length - n, 0));

   423   };

   424 

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

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

   427   // the rest N values in the array. The **guard**

   428   // check allows it to work with `_.map`.

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

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

   431   };

   432 

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

   434   _.compact = function(array) {

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

   436   };

   437 

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

   439   var flatten = function(input, shallow, output) {

   440     if (shallow && _.every(input, _.isArray)) {

   441       return concat.apply(output, input);

   442     }

   443     each(input, function(value) {

   444       if (_.isArray(value) || _.isArguments(value)) {

   445         shallow ? push.apply(output, value) : flatten(value, shallow, output);

   446       } else {

   447         output.push(value);

   448       }

   449     });

   450     return output;

   451   };

   452 

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

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

   455     return flatten(array, shallow, []);

   456   };

   457 

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

   459   _.without = function(array) {

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

   461   };

   462 

   463   // Split an array into two arrays: one whose elements all satisfy the given

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

   465   _.partition = function(array, predicate, context) {

   466     predicate = lookupIterator(predicate);

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

   468     each(array, function(elem) {

   469       (predicate.call(context, elem) ? pass : fail).push(elem);

   470     });

   471     return [pass, fail];

   472   };

   473 

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

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

   476   // Aliased as `unique`.

   477   _.uniq = _.unique = function(array, isSorted, iterator, context) {

   478     if (_.isFunction(isSorted)) {

   479       context = iterator;

   480       iterator = isSorted;

   481       isSorted = false;

   482     }

   483     var initial = iterator ? _.map(array, iterator, context) : array;

   484     var results = [];

   485     var seen = [];

   486     each(initial, function(value, index) {

   487       if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {

   488         seen.push(value);

   489         results.push(array[index]);

   490       }

   491     });

   492     return results;

   493   };

   494 

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

   496   // the passed-in arrays.

   497   _.union = function() {

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

   499   };

   500 

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

   502   // passed-in arrays.

   503   _.intersection = function(array) {

   504     var rest = slice.call(arguments, 1);

   505     return _.filter(_.uniq(array), function(item) {

   506       return _.every(rest, function(other) {

   507         return _.contains(other, item);

   508       });

   509     });

   510   };

   511 

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

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

   514   _.difference = function(array) {

   515     var rest = concat.apply(ArrayProto, slice.call(arguments, 1));

   516     return _.filter(array, function(value){ return !_.contains(rest, value); });

   517   };

   518 

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

   520   // an index go together.

   521   _.zip = function() {

   522     var length = _.max(_.pluck(arguments, 'length').concat(0));

   523     var results = new Array(length);

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

   525       results[i] = _.pluck(arguments, '' + i);

   526     }

   527     return results;

   528   };

   529 

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

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

   532   // the corresponding values.

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

   534     if (list == null) return {};

   535     var result = {};

   536     for (var i = 0, length = list.length; i < length; i++) {

   537       if (values) {

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

   539       } else {

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

   541       }

   542     }

   543     return result;

   544   };

   545 

   546   // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),

   547   // we need this function. Return the position of the first occurrence of an

   548   // item in an array, or -1 if the item is not included in the array.

   549   // Delegates to **ECMAScript 5**'s native `indexOf` if available.

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

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

   552   _.indexOf = function(array, item, isSorted) {

   553     if (array == null) return -1;

   554     var i = 0, length = array.length;

   555     if (isSorted) {

   556       if (typeof isSorted == 'number') {

   557         i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);

   558       } else {

   559         i = _.sortedIndex(array, item);

   560         return array[i] === item ? i : -1;

   561       }

   562     }

   563     if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);

   564     for (; i < length; i++) if (array[i] === item) return i;

   565     return -1;

   566   };

   567 

   568   // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.

   569   _.lastIndexOf = function(array, item, from) {

   570     if (array == null) return -1;

   571     var hasIndex = from != null;

   572     if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {

   573       return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);

   574     }

   575     var i = (hasIndex ? from : array.length);

   576     while (i--) if (array[i] === item) return i;

   577     return -1;

   578   };

   579 

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

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

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

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

   584     if (arguments.length <= 1) {

   585       stop = start || 0;

   586       start = 0;

   587     }

   588     step = arguments[2] || 1;

   589 

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

   591     var idx = 0;

   592     var range = new Array(length);

   593 

   594     while(idx < length) {

   595       range[idx++] = start;

   596       start += step;

   597     }

   598 

   599     return range;

   600   };

   601 

   602   // Function (ahem) Functions

   603   // ------------------

   604 

   605   // Reusable constructor function for prototype setting.

   606   var ctor = function(){};

   607 

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

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

   610   // available.

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

   612     var args, bound;

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

   614     if (!_.isFunction(func)) throw new TypeError;

   615     args = slice.call(arguments, 2);

   616     return bound = function() {

   617       if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));

   618       ctor.prototype = func.prototype;

   619       var self = new ctor;

   620       ctor.prototype = null;

   621       var result = func.apply(self, args.concat(slice.call(arguments)));

   622       if (Object(result) === result) return result;

   623       return self;

   624     };

   625   };

   626 

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

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

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

   630   _.partial = function(func) {

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

   632     return function() {

   633       var position = 0;

   634       var args = boundArgs.slice();

   635       for (var i = 0, length = args.length; i < length; i++) {

   636         if (args[i] === _) args[i] = arguments[position++];

   637       }

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

   639       return func.apply(this, args);

   640     };

   641   };

   642 

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

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

   645   // defined on an object belong to it.

   646   _.bindAll = function(obj) {

   647     var funcs = slice.call(arguments, 1);

   648     if (funcs.length === 0) throw new Error('bindAll must be passed function names');

   649     each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });

   650     return obj;

   651   };

   652 

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

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

   655     var memo = {};

   656     hasher || (hasher = _.identity);

   657     return function() {

   658       var key = hasher.apply(this, arguments);

   659       return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));

   660     };

   661   };

   662 

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

   664   // it with the arguments supplied.

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

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

   667     return setTimeout(function(){ return func.apply(null, args); }, wait);

   668   };

   669 

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

   671   // cleared.

   672   _.defer = function(func) {

   673     return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));

   674   };

   675 

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

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

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

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

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

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

   682     var context, args, result;

   683     var timeout = null;

   684     var previous = 0;

   685     options || (options = {});

   686     var later = function() {

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

   688       timeout = null;

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

   690       context = args = null;

   691     };

   692     return function() {

   693       var now = _.now();

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

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

   696       context = this;

   697       args = arguments;

   698       if (remaining <= 0) {

   699         clearTimeout(timeout);

   700         timeout = null;

   701         previous = now;

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

   703         context = args = null;

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

   705         timeout = setTimeout(later, remaining);

   706       }

   707       return result;

   708     };

   709   };

   710 

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

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

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

   714   // leading edge, instead of the trailing.

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

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

   717 

   718     var later = function() {

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

   720       if (last < wait) {

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

   722       } else {

   723         timeout = null;

   724         if (!immediate) {

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

   726           context = args = null;

   727         }

   728       }

   729     };

   730 

   731     return function() {

   732       context = this;

   733       args = arguments;

   734       timestamp = _.now();

   735       var callNow = immediate && !timeout;

   736       if (!timeout) {

   737         timeout = setTimeout(later, wait);

   738       }

   739       if (callNow) {

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

   741         context = args = null;

   742       }

   743 

   744       return result;

   745     };

   746   };

   747 

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

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

   750   _.once = function(func) {

   751     var ran = false, memo;

   752     return function() {

   753       if (ran) return memo;

   754       ran = true;

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

   756       func = null;

   757       return memo;

   758     };

   759   };

   760 

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

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

   763   // conditionally execute the original function.

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

   765     return _.partial(wrapper, func);

   766   };

   767 

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

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

   770   _.compose = function() {

   771     var funcs = arguments;

   772     return function() {

   773       var args = arguments;

   774       for (var i = funcs.length - 1; i >= 0; i--) {

   775         args = [funcs[i].apply(this, args)];

   776       }

   777       return args[0];

   778     };

   779   };

   780 

   781   // Returns a function that will only be executed after being called N times.

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

   783     return function() {

   784       if (--times < 1) {

   785         return func.apply(this, arguments);

   786       }

   787     };

   788   };

   789 

   790   // Object Functions

   791   // ----------------

   792 

   793   // Retrieve the names of an object's properties.

   794   // Delegates to **ECMAScript 5**'s native `Object.keys`

   795   _.keys = function(obj) {

   796     if (!_.isObject(obj)) return [];

   797     if (nativeKeys) return nativeKeys(obj);

   798     var keys = [];

   799     for (var key in obj) if (_.has(obj, key)) keys.push(key);

   800     return keys;

   801   };

   802 

   803   // Retrieve the values of an object's properties.

   804   _.values = function(obj) {

   805     var keys = _.keys(obj);

   806     var length = keys.length;

   807     var values = new Array(length);

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

   809       values[i] = obj[keys[i]];

   810     }

   811     return values;

   812   };

   813 

   814   // Convert an object into a list of `[key, value]` pairs.

   815   _.pairs = function(obj) {

   816     var keys = _.keys(obj);

   817     var length = keys.length;

   818     var pairs = new Array(length);

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

   820       pairs[i] = [keys[i], obj[keys[i]]];

   821     }

   822     return pairs;

   823   };

   824 

   825   // Invert the keys and values of an object. The values must be serializable.

   826   _.invert = function(obj) {

   827     var result = {};

   828     var keys = _.keys(obj);

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

   830       result[obj[keys[i]]] = keys[i];

   831     }

   832     return result;

   833   };

   834 

   835   // Return a sorted list of the function names available on the object.

   836   // Aliased as `methods`

   837   _.functions = _.methods = function(obj) {

   838     var names = [];

   839     for (var key in obj) {

   840       if (_.isFunction(obj[key])) names.push(key);

   841     }

   842     return names.sort();

   843   };

   844 

   845   // Extend a given object with all the properties in passed-in object(s).

   846   _.extend = function(obj) {

   847     each(slice.call(arguments, 1), function(source) {

   848       if (source) {

   849         for (var prop in source) {

   850           obj[prop] = source[prop];

   851         }

   852       }

   853     });

   854     return obj;

   855   };

   856 

   857   // Return a copy of the object only containing the whitelisted properties.

   858   _.pick = function(obj) {

   859     var copy = {};

   860     var keys = concat.apply(ArrayProto, slice.call(arguments, 1));

   861     each(keys, function(key) {

   862       if (key in obj) copy[key] = obj[key];

   863     });

   864     return copy;

   865   };

   866 

   867    // Return a copy of the object without the blacklisted properties.

   868   _.omit = function(obj) {

   869     var copy = {};

   870     var keys = concat.apply(ArrayProto, slice.call(arguments, 1));

   871     for (var key in obj) {

   872       if (!_.contains(keys, key)) copy[key] = obj[key];

   873     }

   874     return copy;

   875   };

   876 

   877   // Fill in a given object with default properties.

   878   _.defaults = function(obj) {

   879     each(slice.call(arguments, 1), function(source) {

   880       if (source) {

   881         for (var prop in source) {

   882           if (obj[prop] === void 0) obj[prop] = source[prop];

   883         }

   884       }

   885     });

   886     return obj;

   887   };

   888 

   889   // Create a (shallow-cloned) duplicate of an object.

   890   _.clone = function(obj) {

   891     if (!_.isObject(obj)) return obj;

   892     return _.isArray(obj) ? obj.slice() : _.extend({}, obj);

   893   };

   894 

   895   // Invokes interceptor with the obj, and then returns obj.

   896   // The primary purpose of this method is to "tap into" a method chain, in

   897   // order to perform operations on intermediate results within the chain.

   898   _.tap = function(obj, interceptor) {

   899     interceptor(obj);

   900     return obj;

   901   };

   902 

   903   // Internal recursive comparison function for `isEqual`.

   904   var eq = function(a, b, aStack, bStack) {

   905     // Identical objects are equal. `0 === -0`, but they aren't identical.

   906     // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).

   907     if (a === b) return a !== 0 || 1 / a == 1 / b;

   908     // A strict comparison is necessary because `null == undefined`.

   909     if (a == null || b == null) return a === b;

   910     // Unwrap any wrapped objects.

   911     if (a instanceof _) a = a._wrapped;

   912     if (b instanceof _) b = b._wrapped;

   913     // Compare `[[Class]]` names.

   914     var className = toString.call(a);

   915     if (className != toString.call(b)) return false;

   916     switch (className) {

   917       // Strings, numbers, dates, and booleans are compared by value.

   918       case '[object String]':

   919         // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is

   920         // equivalent to `new String("5")`.

   921         return a == String(b);

   922       case '[object Number]':

   923         // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for

   924         // other numeric values.

   925         return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);

   926       case '[object Date]':

   927       case '[object Boolean]':

   928         // Coerce dates and booleans to numeric primitive values. Dates are compared by their

   929         // millisecond representations. Note that invalid dates with millisecond representations

   930         // of `NaN` are not equivalent.

   931         return +a == +b;

   932       // RegExps are compared by their source patterns and flags.

   933       case '[object RegExp]':

   934         return a.source == b.source &&

   935                a.global == b.global &&

   936                a.multiline == b.multiline &&

   937                a.ignoreCase == b.ignoreCase;

   938     }

   939     if (typeof a != 'object' || typeof b != 'object') return false;

   940     // Assume equality for cyclic structures. The algorithm for detecting cyclic

   941     // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.

   942     var length = aStack.length;

   943     while (length--) {

   944       // Linear search. Performance is inversely proportional to the number of

   945       // unique nested structures.

   946       if (aStack[length] == a) return bStack[length] == b;

   947     }

   948     // Objects with different constructors are not equivalent, but `Object`s

   949     // from different frames are.

   950     var aCtor = a.constructor, bCtor = b.constructor;

   951     if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&

   952                              _.isFunction(bCtor) && (bCtor instanceof bCtor))

   953                         && ('constructor' in a && 'constructor' in b)) {

   954       return false;

   955     }

   956     // Add the first object to the stack of traversed objects.

   957     aStack.push(a);

   958     bStack.push(b);

   959     var size = 0, result = true;

   960     // Recursively compare objects and arrays.

   961     if (className == '[object Array]') {

   962       // Compare array lengths to determine if a deep comparison is necessary.

   963       size = a.length;

   964       result = size == b.length;

   965       if (result) {

   966         // Deep compare the contents, ignoring non-numeric properties.

   967         while (size--) {

   968           if (!(result = eq(a[size], b[size], aStack, bStack))) break;

   969         }

   970       }

   971     } else {

   972       // Deep compare objects.

   973       for (var key in a) {

   974         if (_.has(a, key)) {

   975           // Count the expected number of properties.

   976           size++;

   977           // Deep compare each member.

   978           if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;

   979         }

   980       }

   981       // Ensure that both objects contain the same number of properties.

   982       if (result) {

   983         for (key in b) {

   984           if (_.has(b, key) && !(size--)) break;

   985         }

   986         result = !size;

   987       }

   988     }

   989     // Remove the first object from the stack of traversed objects.

   990     aStack.pop();

   991     bStack.pop();

   992     return result;

   993   };

   994 

   995   // Perform a deep comparison to check if two objects are equal.

   996   _.isEqual = function(a, b) {

   997     return eq(a, b, [], []);

   998   };

   999 

  1000   // Is a given array, string, or object empty?

  1001   // An "empty" object has no enumerable own-properties.

  1002   _.isEmpty = function(obj) {

  1003     if (obj == null) return true;

  1004     if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;

  1005     for (var key in obj) if (_.has(obj, key)) return false;

  1006     return true;

  1007   };

  1008 

  1009   // Is a given value a DOM element?

  1010   _.isElement = function(obj) {

  1011     return !!(obj && obj.nodeType === 1);

  1012   };

  1013 

  1014   // Is a given value an array?

  1015   // Delegates to ECMA5's native Array.isArray

  1016   _.isArray = nativeIsArray || function(obj) {

  1017     return toString.call(obj) == '[object Array]';

  1018   };

  1019 

  1020   // Is a given variable an object?

  1021   _.isObject = function(obj) {

  1022     return obj === Object(obj);

  1023   };

  1024 

  1025   // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.

  1026   each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {

  1027     _['is' + name] = function(obj) {

  1028       return toString.call(obj) == '[object ' + name + ']';

  1029     };

  1030   });

  1031 

  1032   // Define a fallback version of the method in browsers (ahem, IE), where

  1033   // there isn't any inspectable "Arguments" type.

  1034   if (!_.isArguments(arguments)) {

  1035     _.isArguments = function(obj) {

  1036       return !!(obj && _.has(obj, 'callee'));

  1037     };

  1038   }

  1039 

  1040   // Optimize `isFunction` if appropriate.

  1041   if (typeof (/./) !== 'function') {

  1042     _.isFunction = function(obj) {

  1043       return typeof obj === 'function';

  1044     };

  1045   }

  1046 

  1047   // Is a given object a finite number?

  1048   _.isFinite = function(obj) {

  1049     return isFinite(obj) && !isNaN(parseFloat(obj));

  1050   };

  1051 

  1052   // Is the given value `NaN`? (NaN is the only number which does not equal itself).

  1053   _.isNaN = function(obj) {

  1054     return _.isNumber(obj) && obj != +obj;

  1055   };

  1056 

  1057   // Is a given value a boolean?

  1058   _.isBoolean = function(obj) {

  1059     return obj === true || obj === false || toString.call(obj) == '[object Boolean]';

  1060   };

  1061 

  1062   // Is a given value equal to null?

  1063   _.isNull = function(obj) {

  1064     return obj === null;

  1065   };

  1066 

  1067   // Is a given variable undefined?

  1068   _.isUndefined = function(obj) {

  1069     return obj === void 0;

  1070   };

  1071 

  1072   // Shortcut function for checking if an object has a given property directly

  1073   // on itself (in other words, not on a prototype).

  1074   _.has = function(obj, key) {

  1075     return hasOwnProperty.call(obj, key);

  1076   };

  1077 

  1078   // Utility Functions

  1079   // -----------------

  1080 

  1081   // Run Underscore.js in *noConflict* mode, returning the `_` variable to its

  1082   // previous owner. Returns a reference to the Underscore object.

  1083   _.noConflict = function() {

  1084     root._ = previousUnderscore;

  1085     return this;

  1086   };

  1087 

  1088   // Keep the identity function around for default iterators.

  1089   _.identity = function(value) {

  1090     return value;

  1091   };

  1092 

  1093   _.constant = function(value) {

  1094     return function () {

  1095       return value;

  1096     };

  1097   };

  1098 

  1099   _.property = function(key) {

  1100     return function(obj) {

  1101       return obj[key];

  1102     };

  1103   };

  1104 

  1105   // Returns a predicate for checking whether an object has a given set of `key:value` pairs.

  1106   _.matches = function(attrs) {

  1107     return function(obj) {

  1108       if (obj === attrs) return true; //avoid comparing an object to itself.

  1109       for (var key in attrs) {

  1110         if (attrs[key] !== obj[key])

  1111           return false;

  1112       }

  1113       return true;

  1114     }

  1115   };

  1116 

  1117   // Run a function **n** times.

  1118   _.times = function(n, iterator, context) {

  1119     var accum = Array(Math.max(0, n));

  1120     for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);

  1121     return accum;

  1122   };

  1123 

  1124   // Return a random integer between min and max (inclusive).

  1125   _.random = function(min, max) {

  1126     if (max == null) {

  1127       max = min;

  1128       min = 0;

  1129     }

  1130     return min + Math.floor(Math.random() * (max - min + 1));

  1131   };

  1132 

  1133   // A (possibly faster) way to get the current timestamp as an integer.

  1134   _.now = Date.now || function() { return new Date().getTime(); };

  1135