underscore.js in Sooperthemes GridStack 7

Same filename in this branch

Underscore.js 1.8.3
http://underscorejs.org
(c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
Underscore may be freely distributed under the MIT license.

(function() {

Baseline setup

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

  var root = this;

Save the previous value of the _ variable.

  var previousUnderscore = root._;

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

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

Create quick reference variables for speed access to core prototypes.

  var
    push             = ArrayProto.push,
    slice            = ArrayProto.slice,
    toString         = ObjProto.toString,
    hasOwnProperty   = ObjProto.hasOwnProperty;

All ECMAScript 5 native function implementations that we hope to use are declared here.

  var
    nativeIsArray      = Array.isArray,
    nativeKeys         = Object.keys,
    nativeBind         = FuncProto.bind,
    nativeCreate       = Object.create;

Naked function reference for surrogate-prototype-swapping.

  var Ctor = function(){};

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

  var _ = function(obj) {
    if (obj instanceof _) return obj;
    if (!(this instanceof _)) return new _(obj);
    this._wrapped = obj;
  };

Export the Underscore object for Node.js, with backwards-compatibility for the old require() API. If we’re in the browser, add _ as a global object.

  if (typeof exports !== 'undefined') {
    if (typeof module !== 'undefined' && module.exports) {
      exports = module.exports = _;
    }
    exports._ = _;
  } else {
    root._ = _;
  }

Current version.

  _.VERSION = '1.8.3';

Internal function that returns an efficient (for current engines) version of the passed-in callback, to be repeatedly applied in other Underscore functions.

  var optimizeCb = function(func, context, argCount) {
    if (context === void 0) return func;
    switch (argCount == null ? 3 : argCount) {
      case 1: return function(value) {
        return func.call(context, value);
      };
      case 2: return function(value, other) {
        return func.call(context, value, other);
      };
      case 3: return function(value, index, collection) {
        return func.call(context, value, index, collection);
      };
      case 4: return function(accumulator, value, index, collection) {
        return func.call(context, accumulator, value, index, collection);
      };
    }
    return function() {
      return func.apply(context, arguments);
    };
  };

A mostly-internal function to generate callbacks that can be applied to each element in a collection, returning the desired result — either identity, an arbitrary callback, a property matcher, or a property accessor.

  var cb = function(value, context, argCount) {
    if (value == null) return _.identity;
    if (_.isFunction(value)) return optimizeCb(value, context, argCount);
    if (_.isObject(value)) return _.matcher(value);
    return _.property(value);
  };
  _.iteratee = function(value, context) {
    return cb(value, context, Infinity);
  };

An internal function for creating assigner functions.

  var createAssigner = function(keysFunc, undefinedOnly) {
    return function(obj) {
      var length = arguments.length;
      if (length < 2 || obj == null) return obj;
      for (var index = 1; index < length; index++) {
        var source = arguments[index],
            keys = keysFunc(source),
            l = keys.length;
        for (var i = 0; i < l; i++) {
          var key = keys[i];
          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];
        }
      }
      return obj;
    };
  };

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

  var baseCreate = function(prototype) {
    if (!_.isObject(prototype)) return {};
    if (nativeCreate) return nativeCreate(prototype);
    Ctor.prototype = prototype;
    var result = new Ctor;
    Ctor.prototype = null;
    return result;
  };

  var property = function(key) {
    return function(obj) {
      return obj == null ? void 0 : obj[key];
    };
  };

Helper for collection methods to determine whether a collection should be iterated as an array or as an object Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094

  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
  var getLength = property('length');
  var isArrayLike = function(collection) {
    var length = getLength(collection);
    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
  };

Collection Functions

The cornerstone, an each implementation, aka forEach. Handles raw objects in addition to array-likes. Treats all sparse array-likes as if they were dense.

  _.each = _.forEach = function(obj, iteratee, context) {
    iteratee = optimizeCb(iteratee, context);
    var i, length;
    if (isArrayLike(obj)) {
      for (i = 0, length = obj.length; i < length; i++) {
        iteratee(obj[i], i, obj);
      }
    } else {
      var keys = _.keys(obj);
      for (i = 0, length = keys.length; i < length; i++) {
        iteratee(obj[keys[i]], keys[i], obj);
      }
    }
    return obj;
  };

Return the results of applying the iteratee to each element.

  _.map = _.collect = function(obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length,
        results = Array(length);
    for (var index = 0; index < length; index++) {
      var currentKey = keys ? keys[index] : index;
      results[index] = iteratee(obj[currentKey], currentKey, obj);
    }
    return results;
  };

Create a reducing function iterating left or right.

  function createReduce(dir) {

Optimized iterator function as using arguments.length in the main function will deoptimize the, see #1991.

    function iterator(obj, iteratee, memo, keys, index, length) {
      for (; index >= 0 && index < length; index += dir) {
        var currentKey = keys ? keys[index] : index;
        memo = iteratee(memo, obj[currentKey], currentKey, obj);
      }
      return memo;
    }

    return function(obj, iteratee, memo, context) {
      iteratee = optimizeCb(iteratee, context, 4);
      var keys = !isArrayLike(obj) && _.keys(obj),
          length = (keys || obj).length,
          index = dir > 0 ? 0 : length - 1;

Determine the initial value if none is provided.

      if (arguments.length < 3) {
        memo = obj[keys ? keys[index] : index];
        index += dir;
      }
      return iterator(obj, iteratee, memo, keys, index, length);
    };
  }

Reduce builds up a single result from a list of values, aka inject, or foldl.

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

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

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

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

  _.find = _.detect = function(obj, predicate, context) {
    var key;
    if (isArrayLike(obj)) {
      key = _.findIndex(obj, predicate, context);
    } else {
      key = _.findKey(obj, predicate, context);
    }
    if (key !== void 0 && key !== -1) return obj[key];
  };

Return all the elements that pass a truth test. Aliased as select.

  _.filter = _.select = function(obj, predicate, context) {
    var results = [];
    predicate = cb(predicate, context);
    _.each(obj, function(value, index, list) {
      if (predicate(value, index, list)) results.push(value);
    });
    return results;
  };

Return all the elements for which a truth test fails.

  _.reject = function(obj, predicate, context) {
    return _.filter(obj, _.negate(cb(predicate)), context);
  };

Determine whether all of the elements match a truth test. Aliased as all.

  _.every = _.all = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length;
    for (var index = 0; index < length; index++) {
      var currentKey = keys ? keys[index] : index;
      if (!predicate(obj[currentKey], currentKey, obj)) return false;
    }
    return true;
  };

Determine if at least one element in the object matches a truth test. Aliased as any.

  _.some = _.any = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length;
    for (var index = 0; index < length; index++) {
      var currentKey = keys ? keys[index] : index;
      if (predicate(obj[currentKey], currentKey, obj)) return true;
    }
    return false;
  };

Determine if the array or object contains a given item (using ===). Aliased as includes and include.

  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {
    if (!isArrayLike(obj)) obj = _.values(obj);
    if (typeof fromIndex != 'number' || guard) fromIndex = 0;
    return _.indexOf(obj, item, fromIndex) >= 0;
  };

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

  _.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    var isFunc = _.isFunction(method);
    return _.map(obj, function(value) {
      var func = isFunc ? method : value[method];
      return func == null ? func : func.apply(value, args);
    });
  };

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

  _.pluck = function(obj, key) {
    return _.map(obj, _.property(key));
  };

Convenience version of a common use case of filter: selecting only objects containing specific key:value pairs.

  _.where = function(obj, attrs) {
    return _.filter(obj, _.matcher(attrs));
  };

Convenience version of a common use case of find: getting the first object containing specific key:value pairs.

  _.findWhere = function(obj, attrs) {
    return _.find(obj, _.matcher(attrs));
  };

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

  _.max = function(obj, iteratee, context) {
    var result = -Infinity, lastComputed = -Infinity,
        value, computed;
    if (iteratee == null && obj != null) {
      obj = isArrayLike(obj) ? obj : _.values(obj);
      for (var i = 0, length = obj.length; i < length; i++) {
        value = obj[i];
        if (value > result) {
          result = value;
        }
      }
    } else {
      iteratee = cb(iteratee, context);
      _.each(obj, function(value, index, list) {
        computed = iteratee(value, index, list);
        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
          result = value;
          lastComputed = computed;
        }
      });
    }
    return result;
  };

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

  _.min = function(obj, iteratee, context) {
    var result = Infinity, lastComputed = Infinity,
        value, computed;
    if (iteratee == null && obj != null) {
      obj = isArrayLike(obj) ? obj : _.values(obj);
      for (var i = 0, length = obj.length; i < length; i++) {
        value = obj[i];
        if (value < result) {
          result = value;
        }
      }
    } else {
      iteratee = cb(iteratee, context);
      _.each(obj, function(value, index, list) {
        computed = iteratee(value, index, list);
        if (computed < lastComputed || computed === Infinity && result === Infinity) {
          result = value;
          lastComputed = computed;
        }
      });
    }
    return result;
  };

Shuffle a collection, using the modern version of the Fisher-Yates shuffle.

  _.shuffle = function(obj) {
    var set = isArrayLike(obj) ? obj : _.values(obj);
    var length = set.length;
    var shuffled = Array(length);
    for (var index = 0, rand; index < length; index++) {
      rand = _.random(0, index);
      if (rand !== index) shuffled[index] = shuffled[rand];
      shuffled[rand] = set[index];
    }
    return shuffled;
  };

Sample n random values from a collection. If n is not specified, returns a single random element. The internal guard argument allows it to work with map.

  _.sample = function(obj, n, guard) {
    if (n == null || guard) {
      if (!isArrayLike(obj)) obj = _.values(obj);
      return obj[_.random(obj.length - 1)];
    }
    return _.shuffle(obj).slice(0, Math.max(0, n));
  };

Sort the object’s values by a criterion produced by an iteratee.

  _.sortBy = function(obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    return _.pluck(_.map(obj, function(value, index, list) {
      return {
        value: value,
        index: index,
        criteria: iteratee(value, index, list)
      };
    }).sort(function(left, right) {
      var a = left.criteria;
      var b = right.criteria;
      if (a !== b) {
        if (a > b || a === void 0) return 1;
        if (a < b || b === void 0) return -1;
      }
      return left.index - right.index;
    }), 'value');
  };

An internal function used for aggregate “group by” operations.

  var group = function(behavior) {
    return function(obj, iteratee, context) {
      var result = {};
      iteratee = cb(iteratee, context);
      _.each(obj, function(value, index) {
        var key = iteratee(value, index, obj);
        behavior(result, value, key);
      });
      return result;
    };
  };

Groups the object’s values by a criterion. Pass either a string attribute to group by, or a function that returns the criterion.

  _.groupBy = group(function(result, value, key) {
    if (_.has(result, key)) result[key].push(value); else result[key] = [value];
  });

Indexes the object’s values by a criterion, similar to groupBy, but for when you know that your index values will be unique.

  _.indexBy = group(function(result, value, key) {
    result[key] = value;
  });

Counts instances of an object that group by a certain criterion. Pass either a string attribute to count by, or a function that returns the criterion.

  _.countBy = group(function(result, value, key) {
    if (_.has(result, key)) result[key]++; else result[key] = 1;
  });

Safely create a real, live array from anything iterable.

  _.toArray = function(obj) {
    if (!obj) return [];
    if (_.isArray(obj)) return slice.call(obj);
    if (isArrayLike(obj)) return _.map(obj, _.identity);
    return _.values(obj);
  };

Return the number of elements in an object.

  _.size = function(obj) {
    if (obj == null) return 0;
    return isArrayLike(obj) ? obj.length : _.keys(obj).length;
  };

Split a collection into two arrays: one whose elements all satisfy the given predicate, and one whose elements all do not satisfy the predicate.

  _.partition = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var pass = [], fail = [];
    _.each(obj, function(value, key, obj) {
      (predicate(value, key, obj) ? pass : fail).push(value);
    });
    return [pass, fail];
  };

Array Functions

Get the first element of an array. Passing n will return the first N values in the array. Aliased as head and take. The guard check allows it to work with _.map.

  _.first = _.head = _.take = function(array, n, guard) {
    if (array == null) return void 0;
    if (n == null || guard) return array[0];
    return _.initial(array, array.length - n);
  };

Returns everything but the last entry of the array. Especially useful on the arguments object. Passing n will return all the values in the array, excluding the last N.

  _.initial = function(array, n, guard) {
    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
  };

Get the last element of an array. Passing n will return the last N values in the array.

  _.last = function(array, n, guard) {
    if (array == null) return void 0;
    if (n == null || guard) return array[array.length - 1];
    return _.rest(array, Math.max(0, array.length - n));
  };

Returns everything but the first entry of the array. Aliased as tail and drop. Especially useful on the arguments object. Passing an n will return the rest N values in the array.

  _.rest = _.tail = _.drop = function(array, n, guard) {
    return slice.call(array, n == null || guard ? 1 : n);
  };

Trim out all falsy values from an array.

  _.compact = function(array) {
    return _.filter(array, _.identity);
  };

Internal implementation of a recursive flatten function.

  var flatten = function(input, shallow, strict, startIndex) {
    var output = [], idx = 0;
    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {
      var value = input[i];
      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {

flatten current level of array or arguments object

        if (!shallow) value = flatten(value, shallow, strict);
        var j = 0, len = value.length;
        output.length += len;
        while (j < len) {
          output[idx++] = value[j++];
        }
      } else if (!strict) {
        output[idx++] = value;
      }
    }
    return output;
  };

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

  _.flatten = function(array, shallow) {
    return flatten(array, shallow, false);
  };

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

  _.without = function(array) {
    return _.difference(array, slice.call(arguments, 1));
  };

Produce a duplicate-free version of the array. If the array has already been sorted, you have the option of using a faster algorithm. Aliased as unique.

  _.uniq = _.unique = function(array, isSorted, iteratee, context) {
    if (!_.isBoolean(isSorted)) {
      context = iteratee;
      iteratee = isSorted;
      isSorted = false;
    }
    if (iteratee != null) iteratee = cb(iteratee, context);
    var result = [];
    var seen = [];
    for (var i = 0, length = getLength(array); i < length; i++) {
      var value = array[i],
          computed = iteratee ? iteratee(value, i, array) : value;
      if (isSorted) {
        if (!i || seen !== computed) result.push(value);
        seen = computed;
      } else if (iteratee) {
        if (!_.contains(seen, computed)) {
          seen.push(computed);
          result.push(value);
        }
      } else if (!_.contains(result, value)) {
        result.push(value);
      }
    }
    return result;
  };

Produce an array that contains the union: each distinct element from all of the passed-in arrays.

  _.union = function() {
    return _.uniq(flatten(arguments, true, true));
  };

Produce an array that contains every item shared between all the passed-in arrays.

  _.intersection = function(array) {
    var result = [];
    var argsLength = arguments.length;
    for (var i = 0, length = getLength(array); i < length; i++) {
      var item = array[i];
      if (_.contains(result, item)) continue;
      for (var j = 1; j < argsLength; j++) {
        if (!_.contains(arguments[j], item)) break;
      }
      if (j === argsLength) result.push(item);
    }
    return result;
  };

Take the difference between one array and a number of other arrays. Only the elements present in just the first array will remain.

  _.difference = function(array) {
    var rest = flatten(arguments, true, true, 1);
    return _.filter(array, function(value){
      return !_.contains(rest, value);
    });
  };

Zip together multiple lists into a single array — elements that share an index go together.

  _.zip = function() {
    return _.unzip(arguments);
  };

Complement of _.zip. Unzip accepts an array of arrays and groups each array’s elements on shared indices

  _.unzip = function(array) {
    var length = array && _.max(array, getLength).length || 0;
    var result = Array(length);

    for (var index = 0; index < length; index++) {
      result[index] = _.pluck(array, index);
    }
    return result;
  };

Converts lists into objects. Pass either a single array of [key, value] pairs, or two parallel arrays of the same length — one of keys, and one of the corresponding values.

  _.object = function(list, values) {
    var result = {};
    for (var i = 0, length = getLength(list); i < length; i++) {
      if (values) {
        result[list[i]] = values[i];
      } else {
        result[list[i][0]] = list[i][1];
      }
    }
    return result;
  };

Generator function to create the findIndex and findLastIndex functions

  function createPredicateIndexFinder(dir) {
    return function(array, predicate, context) {
      predicate = cb(predicate, context);
      var length = getLength(array);
      var index = dir > 0 ? 0 : length - 1;
      for (; index >= 0 && index < length; index += dir) {
        if (predicate(array[index], index, array)) return index;
      }
      return -1;
    };
  }

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

  _.findIndex = createPredicateIndexFinder(1);
  _.findLastIndex = createPredicateIndexFinder(-1);

Use a comparator function to figure out the smallest index at which an object should be inserted so as to maintain order. Uses binary search.

  _.sortedIndex = function(array, obj, iteratee, context) {
    iteratee = cb(iteratee, context, 1);
    var value = iteratee(obj);
    var low = 0, high = getLength(array);
    while (low < high) {
      var mid = Math.floor((low + high) / 2);
      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
    }
    return low;
  };

Generator function to create the indexOf and lastIndexOf functions

  function createIndexFinder(dir, predicateFind, sortedIndex) {
    return function(array, item, idx) {
      var i = 0, length = getLength(array);
      if (typeof idx == 'number') {
        if (dir > 0) {
            i = idx >= 0 ? idx : Math.max(idx + length, i);
        } else {
            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
        }
      } else if (sortedIndex && idx && length) {
        idx = sortedIndex(array, item);
        return array[idx] === item ? idx : -1;
      }
      if (item !== item) {
        idx = predicateFind(slice.call(array, i, length), _.isNaN);
        return idx >= 0 ? idx + i : -1;
      }
      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
        if (array[idx] === item) return idx;
      }
      return -1;
    };
  }

Return the position of the first occurrence of an item in an array, or -1 if the item is not included in the array. If the array is large and already in sort order, pass true for isSorted to use binary search.

  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);

Generate an integer Array containing an arithmetic progression. A port of the native Python range() function. See the Python documentation.

  _.range = function(start, stop, step) {
    if (stop == null) {
      stop = start || 0;
      start = 0;
    }
    step = step || 1;

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

    for (var idx = 0; idx < length; idx++, start += step) {
      range[idx] = start;
    }

    return range;
  };

Function (ahem) Functions

Determines whether to execute a function as a constructor or a normal function with the provided arguments

  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {
    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
    var self = baseCreate(sourceFunc.prototype);
    var result = sourceFunc.apply(self, args);
    if (_.isObject(result)) return result;
    return self;
  };

Create a function bound to a given object (assigning this, and arguments, optionally). Delegates to ECMAScript 5‘s native Function.bind if available.

  _.bind = function(func, context) {
    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
    var args = slice.call(arguments, 2);
    var bound = function() {
      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));
    };
    return bound;
  };

Partially apply a function by creating a version that has had some of its arguments pre-filled, without changing its dynamic this context. _ acts as a placeholder, allowing any combination of arguments to be pre-filled.

  _.partial = function(func) {
    var boundArgs = slice.call(arguments, 1);
    var bound = function() {
      var position = 0, length = boundArgs.length;
      var args = Array(length);
      for (var i = 0; i < length; i++) {
        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];
      }
      while (position < arguments.length) args.push(arguments[position++]);
      return executeBound(func, bound, this, this, args);
    };
    return bound;
  };

Bind a number of an object’s methods to that object. Remaining arguments are the method names to be bound. Useful for ensuring that all callbacks defined on an object belong to it.

  _.bindAll = function(obj) {
    var i, length = arguments.length, key;
    if (length <= 1) throw new Error('bindAll must be passed function names');
    for (i = 1; i < length; i++) {
      key = arguments[i];
      obj[key] = _.bind(obj[key], obj);
    }
    return obj;
  };

Memoize an expensive function by storing its results.

  _.memoize = function(func, hasher) {
    var memoize = function(key) {
      var cache = memoize.cache;
      var address = '' + (hasher ? hasher.apply(this, arguments) : key);
      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
      return cache[address];
    };
    memoize.cache = {};
    return memoize;
  };

Delays a function for the given number of milliseconds, and then calls it with the arguments supplied.

  _.delay = function(func, wait) {
    var args = slice.call(arguments, 2);
    return setTimeout(function(){
      return func.apply(null, args);
    }, wait);
  };

Defers a function, scheduling it to run after the current call stack has cleared.

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

Returns a function, that, when invoked, will only be triggered at most once during a given window of time. Normally, the throttled function will run as much as it can, without ever going more than once per wait duration; but if you’d like to disable the execution on the leading edge, pass {leading: false}. To disable execution on the trailing edge, ditto.

  _.throttle = function(func, wait, options) {
    var context, args, result;
    var timeout = null;
    var previous = 0;
    if (!options) options = {};
    var later = function() {
      previous = options.leading === false ? 0 : _.now();
      timeout = null;
      result = func.apply(context, args);
      if (!timeout) context = args = null;
    };
    return function() {
      var now = _.now();
      if (!previous && options.leading === false) previous = now;
      var remaining = wait - (now - previous);
      context = this;
      args = arguments;
      if (remaining <= 0 || remaining > wait) {
        if (timeout) {
          clearTimeout(timeout);
          timeout = null;
        }
        previous = now;
        result = func.apply(context, args);
        if (!timeout) context = args = null;
      } else if (!timeout && options.trailing !== false) {
        timeout = setTimeout(later, remaining);
      }
      return result;
    };
  };

Returns a function, that, as long as it continues to be invoked, will not be triggered. The function will be called after it stops being called for N milliseconds. If immediate is passed, trigger the function on the leading edge, instead of the trailing.

  _.debounce = function(func, wait, immediate) {
    var timeout, args, context, timestamp, result;

    var later = function() {
      var last = _.now() - timestamp;

      if (last < wait && last >= 0) {
        timeout = setTimeout(later, wait - last);
      } else {
        timeout = null;
        if (!immediate) {
          result = func.apply(context, args);
          if (!timeout) context = args = null;
        }
      }
    };

    return function() {
      context = this;
      args = arguments;
      timestamp = _.now();
      var callNow = immediate && !timeout;
      if (!timeout) timeout = setTimeout(later, wait);
      if (callNow) {
        result = func.apply(context, args);
        context = args = null;
      }

      return result;
    };
  };

Returns the first function passed as an argument to the second, allowing you to adjust arguments, run code before and after, and conditionally execute the original function.

  _.wrap = function(func, wrapper) {
    return _.partial(wrapper, func);
  };

Returns a negated version of the passed-in predicate.

  _.negate = function(predicate) {
    return function() {
      return !predicate.apply(this, arguments);
    };
  };

Returns a function that is the composition of a list of functions, each consuming the return value of the function that follows.

  _.compose = function() {
    var args = arguments;
    var start = args.length - 1;
    return function() {
      var i = start;
      var result = args[start].apply(this, arguments);
      while (i--) result = args[i].call(this, result);
      return result;
    };
  };

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

  _.after = function(times, func) {
    return function() {
      if (--times < 1) {
        return func.apply(this, arguments);
      }
    };
  };

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

  _.before = function(times, func) {
    var memo;
    return function() {
      if (--times > 0) {
        memo = func.apply(this, arguments);
      }
      if (times <= 1) func = null;
      return memo;
    };
  };

Returns a function that will be executed at most one time, no matter how often you call it. Useful for lazy initialization.

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

Object Functions

Keys in IE < 9 that won’t be iterated by for key in ... and thus missed.

  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

  function collectNonEnumProps(obj, keys) {
    var nonEnumIdx = nonEnumerableProps.length;
    var constructor = obj.constructor;
    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;

Constructor is a special case.

    var prop = 'constructor';
    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);

    while (nonEnumIdx--) {
      prop = nonEnumerableProps[nonEnumIdx];
      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
        keys.push(prop);
      }
    }
  }

Retrieve the names of an object’s own properties. Delegates to ECMAScript 5‘s native Object.keys

  _.keys = function(obj) {
    if (!_.isObject(obj)) return [];
    if (nativeKeys) return nativeKeys(obj);
    var keys = [];
    for (var key in obj) if (_.has(obj, key)) keys.push(key);

Ahem, IE < 9.

    if (hasEnumBug) collectNonEnumProps(obj, keys);
    return keys;
  };

Retrieve all the property names of an object.

  _.allKeys = function(obj) {
    if (!_.isObject(obj)) return [];
    var keys = [];
    for (var key in obj) keys.push(key);

Ahem, IE < 9.

    if (hasEnumBug) collectNonEnumProps(obj, keys);
    return keys;
  };

Retrieve the values of an object’s properties.

  _.values = function(obj) {
    var keys = _.keys(obj);
    var length = keys.length;
    var values = Array(length);
    for (var i = 0; i < length; i++) {
      values[i] = obj[keys[i]];
    }
    return values;
  };

Returns the results of applying the iteratee to each element of the object In contrast to _.map it returns an object

  _.mapObject = function(obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    var keys =  _.keys(obj),
          length = keys.length,
          results = {},
          currentKey;
      for (var index = 0; index < length; index++) {
        currentKey = keys[index];
        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
      }
      return results;
  };

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

  _.pairs = function(obj) {
    var keys = _.keys(obj);
    var length = keys.length;
    var pairs = Array(length);
    for (var i = 0; i < length; i++) {
      pairs[i] = [keys[i], obj[keys[i]]];
    }
    return pairs;
  };

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

  _.invert = function(obj) {
    var result = {};
    var keys = _.keys(obj);
    for (var i = 0, length = keys.length; i < length; i++) {
      result[obj[keys[i]]] = keys[i];
    }
    return result;
  };

Return a sorted list of the function names available on the object. Aliased as methods

  _.functions = _.methods = function(obj) {
    var names = [];
    for (var key in obj) {
      if (_.isFunction(obj[key])) names.push(key);
    }
    return names.sort();
  };

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

  _.extend = createAssigner(_.allKeys);

Assigns a given object with all the own properties in the passed-in object(s) (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)

  _.extendOwn = _.assign = createAssigner(_.keys);

Returns the first key on an object that passes a predicate test

  _.findKey = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = _.keys(obj), key;
    for (var i = 0, length = keys.length; i < length; i++) {
      key = keys[i];
      if (predicate(obj[key], key, obj)) return key;
    }
  };

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

  _.pick = function(object, oiteratee, context) {
    var result = {}, obj = object, iteratee, keys;
    if (obj == null) return result;
    if (_.isFunction(oiteratee)) {
      keys = _.allKeys(obj);
      iteratee = optimizeCb(oiteratee, context);
    } else {
      keys = flatten(arguments, false, false, 1);
      iteratee = function(value, key, obj) { return key in obj; };
      obj = Object(obj);
    }
    for (var i = 0, length = keys.length; i < length; i++) {
      var key = keys[i];
      var value = obj[key];
      if (iteratee(value, key, obj)) result[key] = value;
    }
    return result;
  };

Return a copy of the object without the blacklisted properties.

  _.omit = function(obj, iteratee, context) {
    if (_.isFunction(iteratee)) {
      iteratee = _.negate(iteratee);
    } else {
      var keys = _.map(flatten(arguments, false, false, 1), String);
      iteratee = function(value, key) {
        return !_.contains(keys, key);
      };
    }
    return _.pick(obj, iteratee, context);
  };

Fill in a given object with default properties.

  _.defaults = createAssigner(_.allKeys, true);

Creates an object that inherits from the given prototype object. If additional properties are provided then they will be added to the created object.

  _.create = function(prototype, props) {
    var result = baseCreate(prototype);
    if (props) _.extendOwn(result, props);
    return result;
  };

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

  _.clone = function(obj) {
    if (!_.isObject(obj)) return obj;
    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
  };

Invokes interceptor with the obj, and then returns obj. The primary purpose of this method is to “tap into” a method chain, in order to perform operations on intermediate results within the chain.

  _.tap = function(obj, interceptor) {
    interceptor(obj);
    return obj;
  };

Returns whether an object has a given set of key:value pairs.

  _.isMatch = function(object, attrs) {
    var keys = _.keys(attrs), length = keys.length;
    if (object == null) return !length;
    var obj = Object(object);
    for (var i = 0; i < length; i++) {
      var key = keys[i];
      if (attrs[key] !== obj[key] || !(key in obj)) return false;
    }
    return true;
  };

Internal recursive comparison function for isEqual.

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

Identical objects are equal. 0 === -0, but they aren’t identical. See the Harmony egal proposal.

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

A strict comparison is necessary because null == undefined.

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

Unwrap any wrapped objects.

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

Compare [[Class]] names.

    var className = toString.call(a);
    if (className !== toString.call(b)) return false;
    switch (className) {

Strings, numbers, regular expressions, dates, and booleans are compared by value.

      case '[object RegExp]':

RegExps are coerced to strings for comparison (Note: ‘’ + /a/i === ‘/a/i’)

      case '[object String]':

Primitives and their corresponding object wrappers are equivalent; thus, "5" is equivalent to new String("5").

        return '' + a === '' + b;
      case '[object Number]':

NaNs are equivalent, but non-reflexive. Object(NaN) is equivalent to NaN

        if (+a !== +a) return +b !== +b;

An egal comparison is performed for other numeric values.

        return +a === 0 ? 1 / +a === 1 / b : +a === +b;
      case '[object Date]':
      case '[object Boolean]':

Coerce dates and booleans to numeric primitive values. Dates are compared by their millisecond representations. Note that invalid dates with millisecond representations of NaN are not equivalent.

        return +a === +b;
    }

    var areArrays = className === '[object Array]';
    if (!areArrays) {
      if (typeof a != 'object' || typeof b != 'object') return false;

Objects with different constructors are not equivalent, but Objects or Arrays from different frames are.

      var aCtor = a.constructor, bCtor = b.constructor;
      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
                               _.isFunction(bCtor) && bCtor instanceof bCtor)
                          && ('constructor' in a && 'constructor' in b)) {
        return false;
      }
    }

Assume equality for cyclic structures. The algorithm for detecting cyclic structures is adapted from ES 5.1 section 15.12.3, abstract operation JO.

Initializing stack of traversed objects. It’s done here since we only need them for objects and arrays comparison.

    aStack = aStack || [];
    bStack = bStack || [];
    var length = aStack.length;
    while (length--) {

Linear search. Performance is inversely proportional to the number of unique nested structures.

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

Add the first object to the stack of traversed objects.

    aStack.push(a);
    bStack.push(b);

Recursively compare objects and arrays.

    if (areArrays) {

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

      length = a.length;
      if (length !== b.length) return false;

Deep compare the contents, ignoring non-numeric properties.

      while (length--) {
        if (!eq(a[length], b[length], aStack, bStack)) return false;
      }
    } else {

Deep compare objects.

      var keys = _.keys(a), key;
      length = keys.length;

Ensure that both objects contain the same number of properties before comparing deep equality.

      if (_.keys(b).length !== length) return false;
      while (length--) {

Deep compare each member

        key = keys[length];
        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
      }
    }

Remove the first object from the stack of traversed objects.

    aStack.pop();
    bStack.pop();
    return true;
  };

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

  _.isEqual = function(a, b) {
    return eq(a, b);
  };

Is a given array, string, or object empty? An “empty” object has no enumerable own-properties.

  _.isEmpty = function(obj) {
    if (obj == null) return true;
    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;
    return _.keys(obj).length === 0;
  };

Is a given value a DOM element?

  _.isElement = function(obj) {
    return !!(obj && obj.nodeType === 1);
  };

Is a given value an array? Delegates to ECMA5’s native Array.isArray

  _.isArray = nativeIsArray || function(obj) {
    return toString.call(obj) === '[object Array]';
  };

Is a given variable an object?

  _.isObject = function(obj) {
    var type = typeof obj;
    return type === 'function' || type === 'object' && !!obj;
  };

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

  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {
    _['is' + name] = function(obj) {
      return toString.call(obj) === '[object ' + name + ']';
    };
  });

Define a fallback version of the method in browsers (ahem, IE < 9), where there isn’t any inspectable “Arguments” type.

  if (!_.isArguments(arguments)) {
    _.isArguments = function(obj) {
      return _.has(obj, 'callee');
    };
  }

Optimize isFunction if appropriate. Work around some typeof bugs in old v8, IE 11 (#1621), and in Safari 8 (#1929).

  if (typeof /./ != 'function' && typeof Int8Array != 'object') {
    _.isFunction = function(obj) {
      return typeof obj == 'function' || false;
    };
  }

Is a given object a finite number?

  _.isFinite = function(obj) {
    return isFinite(obj) && !isNaN(parseFloat(obj));
  };

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

  _.isNaN = function(obj) {
    return _.isNumber(obj) && obj !== +obj;
  };

Is a given value a boolean?

  _.isBoolean = function(obj) {
    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
  };

Is a given value equal to null?

  _.isNull = function(obj) {
    return obj === null;
  };

Is a given variable undefined?

  _.isUndefined = function(obj) {
    return obj === void 0;
  };

Shortcut function for checking if an object has a given property directly on itself (in other words, not on a prototype).

  _.has = function(obj, key) {
    return obj != null && hasOwnProperty.call(obj, key);
  };

Utility Functions

Run Underscore.js in noConflict mode, returning the _ variable to its previous owner. Returns a reference to the Underscore object.

  _.noConflict = function() {
    root._ = previousUnderscore;
    return this;
  };

Keep the identity function around for default iteratees.

  _.identity = function(value) {
    return value;
  };

Predicate-generating functions. Often useful outside of Underscore.

  _.constant = function(value) {
    return function() {
      return value;
    };
  };

  _.noop = function(){};

  _.property = property;

Generates a function for a given object that returns a given property.

  _.propertyOf = function(obj) {
    return obj == null ? function(){} : function(key) {
      return obj[key];
    };
  };

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

  _.matcher = _.matches = function(attrs) {
    attrs = _.extendOwn({}, attrs);
    return function(obj) {
      return _.isMatch(obj, attrs);
    };
  };

Run a function n times.

  _.times = function(n, iteratee, context) {
    var accum = Array(Math.max(0, n));
    iteratee = optimizeCb(iteratee, context, 1);
    for (var i = 0; i < n; i++) accum[i] = iteratee(i);
    return accum;
  };

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

  _.random = function(min, max) {
    if (max == null) {
      max = min;
      min = 0;
    }
    return min + Math.floor(Math.random() * (max - min + 1));
  };

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

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

List of HTML entities for escaping.

  var escapeMap = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#x27;',
    '`': '&#x60;'
  };
  var unescapeMap = _.invert(escapeMap);

Functions for escaping and unescaping strings to/from HTML interpolation.

  var createEscaper = function(map) {
    var escaper = function(match) {
      return map[match];
    };

Regexes for identifying a key that needs to be escaped

    var source = '(?:' + _.keys(map).join('|') + ')';
    var testRegexp = RegExp(source);
    var replaceRegexp = RegExp(source, 'g');
    return function(string) {
      string = string == null ? '' : '' + string;
      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
    };
  };
  _.escape = createEscaper(escapeMap);
  _.unescape = createEscaper(unescapeMap);

If the value of the named property is a function then invoke it with the object as context; otherwise, return it.

  _.result = function(object, property, fallback) {
    var value = object == null ? void 0 : object[property];
    if (value === void 0) {
      value = fallback;
    }
    return _.isFunction(value) ? value.call(object) : value;
  };

Generate a unique integer id (unique within the entire client session). Useful for temporary DOM ids.

  var idCounter = 0;
  _.uniqueId = function(prefix) {
    var id = ++idCounter + '';
    return prefix ? prefix + id : id;
  };

By default, Underscore uses ERB-style template delimiters, change the following template settings to use alternative delimiters.

  _.templateSettings = {
    evaluate    : /<%([\s\S]+?)%>/g,
    interpolate : /<%=([\s\S]+?)%>/g,
    escape      : /<%-([\s\S]+?)%>/g
  };

When customizing templateSettings, if you don’t want to define an interpolation, evaluation or escaping regex, we need one that is guaranteed not to match.

  var noMatch = /(.)^/;

Certain characters need to be escaped so that they can be put into a string literal.

  var escapes = {
    "'":      "'",
    '\\':     '\\',
    '\r':     'r',
    '\n':     'n',
    '\u2028': 'u2028',
    '\u2029': 'u2029'
  };

  var escaper = /\\|'|\r|\n|\u2028|\u2029/g;

  var escapeChar = function(match) {
    return '\\' + escapes[match];
  };

JavaScript micro-templating, similar to John Resig’s implementation. Underscore templating handles arbitrary delimiters, preserves whitespace, and correctly escapes quotes within interpolated code. NB: oldSettings only exists for backwards compatibility.

  _.template = function(text, settings, oldSettings) {
    if (!settings && oldSettings) settings = oldSettings;
    settings = _.defaults({}, settings, _.templateSettings);

Combine delimiters into one regular expression via alternation.

    var matcher = RegExp([
      (settings.escape || noMatch).source,
      (settings.interpolate || noMatch).source,
      (settings.evaluate || noMatch).source
    ].join('|') + '|$', 'g');

Compile the template source, escaping string literals appropriately.

    var index = 0;
    var source = "__p+='";
    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
      source += text.slice(index, offset).replace(escaper, escapeChar);
      index = offset + match.length;

      if (escape) {
        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
      } else if (interpolate) {
        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
      } else if (evaluate) {
        source += "';\n" + evaluate + "\n__p+='";
      }

Adobe VMs need the match returned to produce the correct offest.

      return match;
    });
    source += "';\n";

If a variable is not specified, place data values in local scope.

    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

    source = "var __t,__p='',__j=Array.prototype.join," +
      "print=function(){__p+=__j.call(arguments,'');};\n" +
      source + 'return __p;\n';

    try {
      var render = new Function(settings.variable || 'obj', '_', source);
    } catch (e) {
      e.source = source;
      throw e;
    }

    var template = function(data) {
      return render.call(this, data, _);
    };

Provide the compiled source as a convenience for precompilation.

    var argument = settings.variable || 'obj';
    template.source = 'function(' + argument + '){\n' + source + '}';

    return template;
  };

Add a “chain” function. Start chaining a wrapped Underscore object.

  _.chain = function(obj) {
    var instance = _(obj);
    instance._chain = true;
    return instance;
  };

OOP

If Underscore is called as a function, it returns a wrapped object that can be used OO-style. This wrapper holds altered versions of all the underscore functions. Wrapped objects may be chained.

Helper function to continue chaining intermediate results.

  var result = function(instance, obj) {
    return instance._chain ? _(obj).chain() : obj;
  };

Add your own custom functions to the Underscore object.

  _.mixin = function(obj) {
    _.each(_.functions(obj), function(name) {
      var func = _[name] = obj[name];
      _.prototype[name] = function() {
        var args = [this._wrapped];
        push.apply(args, arguments);
        return result(this, func.apply(_, args));
      };
    });
  };

Add all of the Underscore functions to the wrapper object.

  _.mixin(_);

Add all mutator Array functions to the wrapper.

  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      var obj = this._wrapped;
      method.apply(obj, arguments);
      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];
      return result(this, obj);
    };
  });

Add all accessor Array functions to the wrapper.

  _.each(['concat', 'join', 'slice'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      return result(this, method.apply(this._wrapped, arguments));
    };
  });

Extracts the result from a wrapped and chained object.

  _.prototype.value = function() {
    return this._wrapped;
  };

Provide unwrapping proxy for some methods used in engine operations such as arithmetic and JSON stringification.

  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;

  _.prototype.toString = function() {
    return '' + this._wrapped;
  };

AMD registration happens at the end for compatibility with AMD loaders that may not enforce next-turn semantics on modules. Even though general practice for AMD registration is to be anonymous, underscore registers as a named module because, like jQuery, it is a base library that is popular enough to be bundled in a third party lib, but not be part of an AMD load request. Those cases could generate an error when an anonymous define() is called outside of a loader request.

  if (typeof define === 'function' && define.amd) {
    define('underscore', [], function() {
      return _;
    });
  }
}.call(this));

File

vendor/underscore/docs/underscore.html

View source

<!DOCTYPE html>

<html>
<head>
  <title>underscore.js</title>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  <meta name="viewport" content="width=device-width, target-densitydpi=160dpi, initial-scale=1.0; maximum-scale=1.0; user-scalable=0;">
  <link rel="stylesheet" media="all" href="docco.css" />
</head>
<body>
  <div id="container">
    <div id="background"></div>
    
    <ul class="sections">
        
          <li id="title">
              <div class="annotation">
                  <h1>underscore.js</h1>
              </div>
          </li>
        
        
        
        <li id="section-1">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-1">&#182;</a>
              </div>
              <pre><code>Underscore.js <span class="hljs-number">1.8</span><span class="hljs-number">.3</span>
http:<span class="hljs-comment">//underscorejs.org</span>
(c) <span class="hljs-number">2009</span>-<span class="hljs-number">2015</span> Jeremy Ashkenas, DocumentCloud and Investigative Reporters &amp; Editors
Underscore may be freely distributed under the MIT license.
</code></pre>
            </div>
            
            <div class="content"><div class='highlight'><pre>
(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{</pre></div></div>
            
        </li>
        
        
        <li id="section-2">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-2">&#182;</a>
              </div>
              <h2 id="baseline-setup">Baseline setup</h2>

            </div>
            
        </li>
        
        
        <li id="section-3">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-3">&#182;</a>
              </div>
              
            </div>
            
        </li>
        
        
        <li id="section-4">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-4">&#182;</a>
              </div>
              <p>Establish the root object, <code>window</code> in the browser, or <code>exports</code> on the server.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> root = <span class="hljs-keyword">this</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-5">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-5">&#182;</a>
              </div>
              <p>Save the previous value of the <code>_</code> variable.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> previousUnderscore = root._;</pre></div></div>
            
        </li>
        
        
        <li id="section-6">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-6">&#182;</a>
              </div>
              <p>Save bytes in the minified (but not gzipped) version:</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> ArrayProto = <span class="hljs-built_in">Array</span>.prototype, ObjProto = <span class="hljs-built_in">Object</span>.prototype, FuncProto = <span class="hljs-built_in">Function</span>.prototype;</pre></div></div>
            
        </li>
        
        
        <li id="section-7">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-7">&#182;</a>
              </div>
              <p>Create quick reference variables for speed access to core prototypes.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span>
    push             = ArrayProto.push,
    slice            = ArrayProto.slice,
    toString         = ObjProto.toString,
    hasOwnProperty   = ObjProto.hasOwnProperty;</pre></div></div>
            
        </li>
        
        
        <li id="section-8">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-8">&#182;</a>
              </div>
              <p>All <strong>ECMAScript 5</strong> native function implementations that we hope to use
are declared here.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span>
    nativeIsArray      = <span class="hljs-built_in">Array</span>.isArray,
    nativeKeys         = <span class="hljs-built_in">Object</span>.keys,
    nativeBind         = FuncProto.bind,
    nativeCreate       = <span class="hljs-built_in">Object</span>.create;</pre></div></div>
            
        </li>
        
        
        <li id="section-9">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-9">&#182;</a>
              </div>
              <p>Naked function reference for surrogate-prototype-swapping.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> Ctor = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span></span>{};</pre></div></div>
            
        </li>
        
        
        <li id="section-10">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-10">&#182;</a>
              </div>
              <p>Create a safe reference to the Underscore object for use below.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> _ = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">if</span> (obj <span class="hljs-keyword">instanceof</span> _) <span class="hljs-keyword">return</span> obj;
    <span class="hljs-keyword">if</span> (!(<span class="hljs-keyword">this</span> <span class="hljs-keyword">instanceof</span> _)) <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> _(obj);
    <span class="hljs-keyword">this</span>._wrapped = obj;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-11">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-11">&#182;</a>
              </div>
              <p>Export the Underscore object for <strong>Node.js</strong>, with
backwards-compatibility for the old <code>require()</code> API. If we’re in
the browser, add <code>_</code> as a global object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> exports !== <span class="hljs-string">'undefined'</span>) {
    <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> <span class="hljs-built_in">module</span> !== <span class="hljs-string">'undefined'</span> &amp;&amp; <span class="hljs-built_in">module</span>.exports) {
      exports = <span class="hljs-built_in">module</span>.exports = _;
    }
    exports._ = _;
  } <span class="hljs-keyword">else</span> {
    root._ = _;
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-12">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-12">&#182;</a>
              </div>
              <p>Current version.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.VERSION = <span class="hljs-string">'1.8.3'</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-13">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-13">&#182;</a>
              </div>
              <p>Internal function that returns an efficient (for current engines) version
of the passed-in callback, to be repeatedly applied in other Underscore
functions.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> optimizeCb = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func, context, argCount)</span> </span>{
    <span class="hljs-keyword">if</span> (context === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> func;
    <span class="hljs-keyword">switch</span> (argCount == <span class="hljs-literal">null</span> ? <span class="hljs-number">3</span> : argCount) {
      <span class="hljs-keyword">case</span> <span class="hljs-number">1</span>: <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value)</span> </span>{
        <span class="hljs-keyword">return</span> func.call(context, value);
      };
      <span class="hljs-keyword">case</span> <span class="hljs-number">2</span>: <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, other)</span> </span>{
        <span class="hljs-keyword">return</span> func.call(context, value, other);
      };
      <span class="hljs-keyword">case</span> <span class="hljs-number">3</span>: <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, index, collection)</span> </span>{
        <span class="hljs-keyword">return</span> func.call(context, value, index, collection);
      };
      <span class="hljs-keyword">case</span> <span class="hljs-number">4</span>: <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(accumulator, value, index, collection)</span> </span>{
        <span class="hljs-keyword">return</span> func.call(context, accumulator, value, index, collection);
      };
    }
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">return</span> func.apply(context, <span class="hljs-built_in">arguments</span>);
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-14">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-14">&#182;</a>
              </div>
              <p>A mostly-internal function to generate callbacks that can be applied
to each element in a collection, returning the desired result — either
identity, an arbitrary callback, a property matcher, or a property accessor.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> cb = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, context, argCount)</span> </span>{
    <span class="hljs-keyword">if</span> (value == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> _.identity;
    <span class="hljs-keyword">if</span> (_.isFunction(value)) <span class="hljs-keyword">return</span> optimizeCb(value, context, argCount);
    <span class="hljs-keyword">if</span> (_.isObject(value)) <span class="hljs-keyword">return</span> _.matcher(value);
    <span class="hljs-keyword">return</span> _.property(value);
  };
  _.iteratee = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, context)</span> </span>{
    <span class="hljs-keyword">return</span> cb(value, context, <span class="hljs-literal">Infinity</span>);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-15">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-15">&#182;</a>
              </div>
              <p>An internal function for creating assigner functions.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> createAssigner = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(keysFunc, undefinedOnly)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
      <span class="hljs-keyword">var</span> length = <span class="hljs-built_in">arguments</span>.length;
      <span class="hljs-keyword">if</span> (length &lt; <span class="hljs-number">2</span> || obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> obj;
      <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">1</span>; index &lt; length; index++) {
        <span class="hljs-keyword">var</span> source = <span class="hljs-built_in">arguments</span>[index],
            keys = keysFunc(source),
            l = keys.length;
        <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; l; i++) {
          <span class="hljs-keyword">var</span> key = keys[i];
          <span class="hljs-keyword">if</span> (!undefinedOnly || obj[key] === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) obj[key] = source[key];
        }
      }
      <span class="hljs-keyword">return</span> obj;
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-16">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-16">&#182;</a>
              </div>
              <p>An internal function for creating a new object that inherits from another.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> baseCreate = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(prototype)</span> </span>{
    <span class="hljs-keyword">if</span> (!_.isObject(prototype)) <span class="hljs-keyword">return</span> {};
    <span class="hljs-keyword">if</span> (nativeCreate) <span class="hljs-keyword">return</span> nativeCreate(prototype);
    Ctor.prototype = prototype;
    <span class="hljs-keyword">var</span> result = <span class="hljs-keyword">new</span> Ctor;
    Ctor.prototype = <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">return</span> result;
  };

  <span class="hljs-keyword">var</span> property = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(key)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
      <span class="hljs-keyword">return</span> obj == <span class="hljs-literal">null</span> ? <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> : obj[key];
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-17">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-17">&#182;</a>
              </div>
              <p>Helper for collection methods to determine whether a collection
should be iterated as an array or as an object
Related: <a href="http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength">http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength</a>
Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> MAX_ARRAY_INDEX = <span class="hljs-built_in">Math</span>.pow(<span class="hljs-number">2</span>, <span class="hljs-number">53</span>) - <span class="hljs-number">1</span>;
  <span class="hljs-keyword">var</span> getLength = property(<span class="hljs-string">'length'</span>);
  <span class="hljs-keyword">var</span> isArrayLike = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(collection)</span> </span>{
    <span class="hljs-keyword">var</span> length = getLength(collection);
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">typeof</span> length == <span class="hljs-string">'number'</span> &amp;&amp; length &gt;= <span class="hljs-number">0</span> &amp;&amp; length &lt;= MAX_ARRAY_INDEX;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-18">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-18">&#182;</a>
              </div>
              <h2 id="collection-functions">Collection Functions</h2>

            </div>
            
        </li>
        
        
        <li id="section-19">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-19">&#182;</a>
              </div>
              
            </div>
            
        </li>
        
        
        <li id="section-20">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-20">&#182;</a>
              </div>
              <p>The cornerstone, an <code>each</code> implementation, aka <code>forEach</code>.
Handles raw objects in addition to array-likes. Treats all
sparse array-likes as if they were dense.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.each = _.forEach = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
    iteratee = optimizeCb(iteratee, context);
    <span class="hljs-keyword">var</span> i, length;
    <span class="hljs-keyword">if</span> (isArrayLike(obj)) {
      <span class="hljs-keyword">for</span> (i = <span class="hljs-number">0</span>, length = obj.length; i &lt; length; i++) {
        iteratee(obj[i], i, obj);
      }
    } <span class="hljs-keyword">else</span> {
      <span class="hljs-keyword">var</span> keys = _.keys(obj);
      <span class="hljs-keyword">for</span> (i = <span class="hljs-number">0</span>, length = keys.length; i &lt; length; i++) {
        iteratee(obj[keys[i]], keys[i], obj);
      }
    }
    <span class="hljs-keyword">return</span> obj;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-21">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-21">&#182;</a>
              </div>
              <p>Return the results of applying the iteratee to each element.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.map = _.collect = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
    iteratee = cb(iteratee, context);
    <span class="hljs-keyword">var</span> keys = !isArrayLike(obj) &amp;&amp; _.keys(obj),
        length = (keys || obj).length,
        results = <span class="hljs-built_in">Array</span>(length);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
      <span class="hljs-keyword">var</span> currentKey = keys ? keys[index] : index;
      results[index] = iteratee(obj[currentKey], currentKey, obj);
    }
    <span class="hljs-keyword">return</span> results;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-22">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-22">&#182;</a>
              </div>
              <p>Create a reducing function iterating left or right.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">createReduce</span><span class="hljs-params">(dir)</span> </span>{</pre></div></div>
            
        </li>
        
        
        <li id="section-23">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-23">&#182;</a>
              </div>
              <p>Optimized iterator function as using arguments.length
in the main function will deoptimize the, see #1991.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">iterator</span><span class="hljs-params">(obj, iteratee, memo, keys, index, length)</span> </span>{
      <span class="hljs-keyword">for</span> (; index &gt;= <span class="hljs-number">0</span> &amp;&amp; index &lt; length; index += dir) {
        <span class="hljs-keyword">var</span> currentKey = keys ? keys[index] : index;
        memo = iteratee(memo, obj[currentKey], currentKey, obj);
      }
      <span class="hljs-keyword">return</span> memo;
    }

    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, memo, context)</span> </span>{
      iteratee = optimizeCb(iteratee, context, <span class="hljs-number">4</span>);
      <span class="hljs-keyword">var</span> keys = !isArrayLike(obj) &amp;&amp; _.keys(obj),
          length = (keys || obj).length,
          index = dir &gt; <span class="hljs-number">0</span> ? <span class="hljs-number">0</span> : length - <span class="hljs-number">1</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-24">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-24">&#182;</a>
              </div>
              <p>Determine the initial value if none is provided.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">if</span> (<span class="hljs-built_in">arguments</span>.length &lt; <span class="hljs-number">3</span>) {
        memo = obj[keys ? keys[index] : index];
        index += dir;
      }
      <span class="hljs-keyword">return</span> iterator(obj, iteratee, memo, keys, index, length);
    };
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-25">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-25">&#182;</a>
              </div>
              <p><strong>Reduce</strong> builds up a single result from a list of values, aka <code>inject</code>,
or <code>foldl</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.reduce = _.foldl = _.inject = createReduce(<span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-26">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-26">&#182;</a>
              </div>
              <p>The right-associative version of reduce, also known as <code>foldr</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.reduceRight = _.foldr = createReduce(-<span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-27">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-27">&#182;</a>
              </div>
              <p>Return the first value which passes a truth test. Aliased as <code>detect</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.find = _.detect = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, predicate, context)</span> </span>{
    <span class="hljs-keyword">var</span> key;
    <span class="hljs-keyword">if</span> (isArrayLike(obj)) {
      key = _.findIndex(obj, predicate, context);
    } <span class="hljs-keyword">else</span> {
      key = _.findKey(obj, predicate, context);
    }
    <span class="hljs-keyword">if</span> (key !== <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> &amp;&amp; key !== -<span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> obj[key];
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-28">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-28">&#182;</a>
              </div>
              <p>Return all the elements that pass a truth test.
Aliased as <code>select</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.filter = _.select = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, predicate, context)</span> </span>{
    <span class="hljs-keyword">var</span> results = [];
    predicate = cb(predicate, context);
    _.each(obj, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, index, list)</span> </span>{
      <span class="hljs-keyword">if</span> (predicate(value, index, list)) results.push(value);
    });
    <span class="hljs-keyword">return</span> results;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-29">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-29">&#182;</a>
              </div>
              <p>Return all the elements for which a truth test fails.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.reject = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, predicate, context)</span> </span>{
    <span class="hljs-keyword">return</span> _.filter(obj, _.negate(cb(predicate)), context);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-30">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-30">&#182;</a>
              </div>
              <p>Determine whether all of the elements match a truth test.
Aliased as <code>all</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.every = _.all = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, predicate, context)</span> </span>{
    predicate = cb(predicate, context);
    <span class="hljs-keyword">var</span> keys = !isArrayLike(obj) &amp;&amp; _.keys(obj),
        length = (keys || obj).length;
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
      <span class="hljs-keyword">var</span> currentKey = keys ? keys[index] : index;
      <span class="hljs-keyword">if</span> (!predicate(obj[currentKey], currentKey, obj)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
    <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-31">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-31">&#182;</a>
              </div>
              <p>Determine if at least one element in the object matches a truth test.
Aliased as <code>any</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.some = _.any = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, predicate, context)</span> </span>{
    predicate = cb(predicate, context);
    <span class="hljs-keyword">var</span> keys = !isArrayLike(obj) &amp;&amp; _.keys(obj),
        length = (keys || obj).length;
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
      <span class="hljs-keyword">var</span> currentKey = keys ? keys[index] : index;
      <span class="hljs-keyword">if</span> (predicate(obj[currentKey], currentKey, obj)) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }
    <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-32">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-32">&#182;</a>
              </div>
              <p>Determine if the array or object contains a given item (using <code>===</code>).
Aliased as <code>includes</code> and <code>include</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.contains = _.includes = _.include = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, item, fromIndex, guard)</span> </span>{
    <span class="hljs-keyword">if</span> (!isArrayLike(obj)) obj = _.values(obj);
    <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> fromIndex != <span class="hljs-string">'number'</span> || guard) fromIndex = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">return</span> _.indexOf(obj, item, fromIndex) &gt;= <span class="hljs-number">0</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-33">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-33">&#182;</a>
              </div>
              <p>Invoke a method (with arguments) on every item in a collection.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.invoke = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, method)</span> </span>{
    <span class="hljs-keyword">var</span> args = slice.call(<span class="hljs-built_in">arguments</span>, <span class="hljs-number">2</span>);
    <span class="hljs-keyword">var</span> isFunc = _.isFunction(method);
    <span class="hljs-keyword">return</span> _.map(obj, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value)</span> </span>{
      <span class="hljs-keyword">var</span> func = isFunc ? method : value[method];
      <span class="hljs-keyword">return</span> func == <span class="hljs-literal">null</span> ? func : func.apply(value, args);
    });
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-34">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-34">&#182;</a>
              </div>
              <p>Convenience version of a common use case of <code>map</code>: fetching a property.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.pluck = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, key)</span> </span>{
    <span class="hljs-keyword">return</span> _.map(obj, _.property(key));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-35">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-35">&#182;</a>
              </div>
              <p>Convenience version of a common use case of <code>filter</code>: selecting only objects
containing specific <code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.where = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, attrs)</span> </span>{
    <span class="hljs-keyword">return</span> _.filter(obj, _.matcher(attrs));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-36">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-36">&#182;</a>
              </div>
              <p>Convenience version of a common use case of <code>find</code>: getting the first object
containing specific <code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.findWhere = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, attrs)</span> </span>{
    <span class="hljs-keyword">return</span> _.find(obj, _.matcher(attrs));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-37">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-37">&#182;</a>
              </div>
              <p>Return the maximum element (or element-based computation).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.max = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
    <span class="hljs-keyword">var</span> result = -<span class="hljs-literal">Infinity</span>, lastComputed = -<span class="hljs-literal">Infinity</span>,
        value, computed;
    <span class="hljs-keyword">if</span> (iteratee == <span class="hljs-literal">null</span> &amp;&amp; obj != <span class="hljs-literal">null</span>) {
      obj = isArrayLike(obj) ? obj : _.values(obj);
      <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = obj.length; i &lt; length; i++) {
        value = obj[i];
        <span class="hljs-keyword">if</span> (value &gt; result) {
          result = value;
        }
      }
    } <span class="hljs-keyword">else</span> {
      iteratee = cb(iteratee, context);
      _.each(obj, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, index, list)</span> </span>{
        computed = iteratee(value, index, list);
        <span class="hljs-keyword">if</span> (computed &gt; lastComputed || computed === -<span class="hljs-literal">Infinity</span> &amp;&amp; result === -<span class="hljs-literal">Infinity</span>) {
          result = value;
          lastComputed = computed;
        }
      });
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-38">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-38">&#182;</a>
              </div>
              <p>Return the minimum element (or element-based computation).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.min = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
    <span class="hljs-keyword">var</span> result = <span class="hljs-literal">Infinity</span>, lastComputed = <span class="hljs-literal">Infinity</span>,
        value, computed;
    <span class="hljs-keyword">if</span> (iteratee == <span class="hljs-literal">null</span> &amp;&amp; obj != <span class="hljs-literal">null</span>) {
      obj = isArrayLike(obj) ? obj : _.values(obj);
      <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = obj.length; i &lt; length; i++) {
        value = obj[i];
        <span class="hljs-keyword">if</span> (value &lt; result) {
          result = value;
        }
      }
    } <span class="hljs-keyword">else</span> {
      iteratee = cb(iteratee, context);
      _.each(obj, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, index, list)</span> </span>{
        computed = iteratee(value, index, list);
        <span class="hljs-keyword">if</span> (computed &lt; lastComputed || computed === <span class="hljs-literal">Infinity</span> &amp;&amp; result === <span class="hljs-literal">Infinity</span>) {
          result = value;
          lastComputed = computed;
        }
      });
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-39">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-39">&#182;</a>
              </div>
              <p>Shuffle a collection, using the modern version of the
<a href="http://en.wikipedia.org/wiki/Fisher–Yates_shuffle">Fisher-Yates shuffle</a>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.shuffle = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> set = isArrayLike(obj) ? obj : _.values(obj);
    <span class="hljs-keyword">var</span> length = set.length;
    <span class="hljs-keyword">var</span> shuffled = <span class="hljs-built_in">Array</span>(length);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>, rand; index &lt; length; index++) {
      rand = _.random(<span class="hljs-number">0</span>, index);
      <span class="hljs-keyword">if</span> (rand !== index) shuffled[index] = shuffled[rand];
      shuffled[rand] = set[index];
    }
    <span class="hljs-keyword">return</span> shuffled;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-40">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-40">&#182;</a>
              </div>
              <p>Sample <strong>n</strong> random values from a collection.
If <strong>n</strong> is not specified, returns a single random element.
The internal <code>guard</code> argument allows it to work with <code>map</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.sample = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, n, guard)</span> </span>{
    <span class="hljs-keyword">if</span> (n == <span class="hljs-literal">null</span> || guard) {
      <span class="hljs-keyword">if</span> (!isArrayLike(obj)) obj = _.values(obj);
      <span class="hljs-keyword">return</span> obj[_.random(obj.length - <span class="hljs-number">1</span>)];
    }
    <span class="hljs-keyword">return</span> _.shuffle(obj).slice(<span class="hljs-number">0</span>, <span class="hljs-built_in">Math</span>.max(<span class="hljs-number">0</span>, n));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-41">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-41">&#182;</a>
              </div>
              <p>Sort the object’s values by a criterion produced by an iteratee.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.sortBy = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
    iteratee = cb(iteratee, context);
    <span class="hljs-keyword">return</span> _.pluck(_.map(obj, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, index, list)</span> </span>{
      <span class="hljs-keyword">return</span> {
        value: value,
        index: index,
        criteria: iteratee(value, index, list)
      };
    }).sort(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(left, right)</span> </span>{
      <span class="hljs-keyword">var</span> a = left.criteria;
      <span class="hljs-keyword">var</span> b = right.criteria;
      <span class="hljs-keyword">if</span> (a !== b) {
        <span class="hljs-keyword">if</span> (a &gt; b || a === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> <span class="hljs-number">1</span>;
        <span class="hljs-keyword">if</span> (a &lt; b || b === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>;
      }
      <span class="hljs-keyword">return</span> left.index - right.index;
    }), <span class="hljs-string">'value'</span>);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-42">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-42">&#182;</a>
              </div>
              <p>An internal function used for aggregate “group by” operations.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> group = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(behavior)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
      <span class="hljs-keyword">var</span> result = {};
      iteratee = cb(iteratee, context);
      _.each(obj, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, index)</span> </span>{
        <span class="hljs-keyword">var</span> key = iteratee(value, index, obj);
        behavior(result, value, key);
      });
      <span class="hljs-keyword">return</span> result;
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-43">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-43">&#182;</a>
              </div>
              <p>Groups the object’s values by a criterion. Pass either a string attribute
to group by, or a function that returns the criterion.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.groupBy = group(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(result, value, key)</span> </span>{
    <span class="hljs-keyword">if</span> (_.has(result, key)) result[key].push(value); <span class="hljs-keyword">else</span> result[key] = [value];
  });</pre></div></div>
            
        </li>
        
        
        <li id="section-44">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-44">&#182;</a>
              </div>
              <p>Indexes the object’s values by a criterion, similar to <code>groupBy</code>, but for
when you know that your index values will be unique.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.indexBy = group(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(result, value, key)</span> </span>{
    result[key] = value;
  });</pre></div></div>
            
        </li>
        
        
        <li id="section-45">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-45">&#182;</a>
              </div>
              <p>Counts instances of an object that group by a certain criterion. Pass
either a string attribute to count by, or a function that returns the
criterion.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.countBy = group(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(result, value, key)</span> </span>{
    <span class="hljs-keyword">if</span> (_.has(result, key)) result[key]++; <span class="hljs-keyword">else</span> result[key] = <span class="hljs-number">1</span>;
  });</pre></div></div>
            
        </li>
        
        
        <li id="section-46">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-46">&#182;</a>
              </div>
              <p>Safely create a real, live array from anything iterable.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.toArray = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">if</span> (!obj) <span class="hljs-keyword">return</span> [];
    <span class="hljs-keyword">if</span> (_.isArray(obj)) <span class="hljs-keyword">return</span> slice.call(obj);
    <span class="hljs-keyword">if</span> (isArrayLike(obj)) <span class="hljs-keyword">return</span> _.map(obj, _.identity);
    <span class="hljs-keyword">return</span> _.values(obj);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-47">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-47">&#182;</a>
              </div>
              <p>Return the number of elements in an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.size = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
    <span class="hljs-keyword">return</span> isArrayLike(obj) ? obj.length : _.keys(obj).length;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-48">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-48">&#182;</a>
              </div>
              <p>Split a collection into two arrays: one whose elements all satisfy the given
predicate, and one whose elements all do not satisfy the predicate.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.partition = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, predicate, context)</span> </span>{
    predicate = cb(predicate, context);
    <span class="hljs-keyword">var</span> pass = [], fail = [];
    _.each(obj, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key, obj)</span> </span>{
      (predicate(value, key, obj) ? pass : fail).push(value);
    });
    <span class="hljs-keyword">return</span> [pass, fail];
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-49">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-49">&#182;</a>
              </div>
              <h2 id="array-functions">Array Functions</h2>

            </div>
            
        </li>
        
        
        <li id="section-50">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-50">&#182;</a>
              </div>
              
            </div>
            
        </li>
        
        
        <li id="section-51">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-51">&#182;</a>
              </div>
              <p>Get the first element of an array. Passing <strong>n</strong> will return the first N
values in the array. Aliased as <code>head</code> and <code>take</code>. The <strong>guard</strong> check
allows it to work with <code>_.map</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.first = _.head = _.take = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, n, guard)</span> </span>{
    <span class="hljs-keyword">if</span> (array == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
    <span class="hljs-keyword">if</span> (n == <span class="hljs-literal">null</span> || guard) <span class="hljs-keyword">return</span> array[<span class="hljs-number">0</span>];
    <span class="hljs-keyword">return</span> _.initial(array, array.length - n);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-52">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-52">&#182;</a>
              </div>
              <p>Returns everything but the last entry of the array. Especially useful on
the arguments object. Passing <strong>n</strong> will return all the values in
the array, excluding the last N.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.initial = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, n, guard)</span> </span>{
    <span class="hljs-keyword">return</span> slice.call(array, <span class="hljs-number">0</span>, <span class="hljs-built_in">Math</span>.max(<span class="hljs-number">0</span>, array.length - (n == <span class="hljs-literal">null</span> || guard ? <span class="hljs-number">1</span> : n)));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-53">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-53">&#182;</a>
              </div>
              <p>Get the last element of an array. Passing <strong>n</strong> will return the last N
values in the array.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.last = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, n, guard)</span> </span>{
    <span class="hljs-keyword">if</span> (array == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
    <span class="hljs-keyword">if</span> (n == <span class="hljs-literal">null</span> || guard) <span class="hljs-keyword">return</span> array[array.length - <span class="hljs-number">1</span>];
    <span class="hljs-keyword">return</span> _.rest(array, <span class="hljs-built_in">Math</span>.max(<span class="hljs-number">0</span>, array.length - n));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-54">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-54">&#182;</a>
              </div>
              <p>Returns everything but the first entry of the array. Aliased as <code>tail</code> and <code>drop</code>.
Especially useful on the arguments object. Passing an <strong>n</strong> will return
the rest N values in the array.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.rest = _.tail = _.drop = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, n, guard)</span> </span>{
    <span class="hljs-keyword">return</span> slice.call(array, n == <span class="hljs-literal">null</span> || guard ? <span class="hljs-number">1</span> : n);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-55">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-55">&#182;</a>
              </div>
              <p>Trim out all falsy values from an array.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.compact = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array)</span> </span>{
    <span class="hljs-keyword">return</span> _.filter(array, _.identity);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-56">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-56">&#182;</a>
              </div>
              <p>Internal implementation of a recursive <code>flatten</code> function.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> flatten = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(input, shallow, strict, startIndex)</span> </span>{
    <span class="hljs-keyword">var</span> output = [], idx = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = startIndex || <span class="hljs-number">0</span>, length = getLength(input); i &lt; length; i++) {
      <span class="hljs-keyword">var</span> value = input[i];
      <span class="hljs-keyword">if</span> (isArrayLike(value) &amp;&amp; (_.isArray(value) || _.isArguments(value))) {</pre></div></div>
            
        </li>
        
        
        <li id="section-57">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-57">&#182;</a>
              </div>
              <p>flatten current level of array or arguments object</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>        <span class="hljs-keyword">if</span> (!shallow) value = flatten(value, shallow, strict);
        <span class="hljs-keyword">var</span> j = <span class="hljs-number">0</span>, len = value.length;
        output.length += len;
        <span class="hljs-keyword">while</span> (j &lt; len) {
          output[idx++] = value[j++];
        }
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!strict) {
        output[idx++] = value;
      }
    }
    <span class="hljs-keyword">return</span> output;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-58">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-58">&#182;</a>
              </div>
              <p>Flatten out an array, either recursively (by default), or just one level.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.flatten = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, shallow)</span> </span>{
    <span class="hljs-keyword">return</span> flatten(array, shallow, <span class="hljs-literal">false</span>);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-59">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-59">&#182;</a>
              </div>
              <p>Return a version of the array that does not contain the specified value(s).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.without = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array)</span> </span>{
    <span class="hljs-keyword">return</span> _.difference(array, slice.call(<span class="hljs-built_in">arguments</span>, <span class="hljs-number">1</span>));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-60">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-60">&#182;</a>
              </div>
              <p>Produce a duplicate-free version of the array. If the array has already
been sorted, you have the option of using a faster algorithm.
Aliased as <code>unique</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.uniq = _.unique = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, isSorted, iteratee, context)</span> </span>{
    <span class="hljs-keyword">if</span> (!_.isBoolean(isSorted)) {
      context = iteratee;
      iteratee = isSorted;
      isSorted = <span class="hljs-literal">false</span>;
    }
    <span class="hljs-keyword">if</span> (iteratee != <span class="hljs-literal">null</span>) iteratee = cb(iteratee, context);
    <span class="hljs-keyword">var</span> result = [];
    <span class="hljs-keyword">var</span> seen = [];
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = getLength(array); i &lt; length; i++) {
      <span class="hljs-keyword">var</span> value = array[i],
          computed = iteratee ? iteratee(value, i, array) : value;
      <span class="hljs-keyword">if</span> (isSorted) {
        <span class="hljs-keyword">if</span> (!i || seen !== computed) result.push(value);
        seen = computed;
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (iteratee) {
        <span class="hljs-keyword">if</span> (!_.contains(seen, computed)) {
          seen.push(computed);
          result.push(value);
        }
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!_.contains(result, value)) {
        result.push(value);
      }
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-61">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-61">&#182;</a>
              </div>
              <p>Produce an array that contains the union: each distinct element from all of
the passed-in arrays.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.union = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> _.uniq(flatten(<span class="hljs-built_in">arguments</span>, <span class="hljs-literal">true</span>, <span class="hljs-literal">true</span>));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-62">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-62">&#182;</a>
              </div>
              <p>Produce an array that contains every item shared between all the
passed-in arrays.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.intersection = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array)</span> </span>{
    <span class="hljs-keyword">var</span> result = [];
    <span class="hljs-keyword">var</span> argsLength = <span class="hljs-built_in">arguments</span>.length;
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = getLength(array); i &lt; length; i++) {
      <span class="hljs-keyword">var</span> item = array[i];
      <span class="hljs-keyword">if</span> (_.contains(result, item)) <span class="hljs-keyword">continue</span>;
      <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> j = <span class="hljs-number">1</span>; j &lt; argsLength; j++) {
        <span class="hljs-keyword">if</span> (!_.contains(<span class="hljs-built_in">arguments</span>[j], item)) <span class="hljs-keyword">break</span>;
      }
      <span class="hljs-keyword">if</span> (j === argsLength) result.push(item);
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-63">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-63">&#182;</a>
              </div>
              <p>Take the difference between one array and a number of other arrays.
Only the elements present in just the first array will remain.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.difference = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array)</span> </span>{
    <span class="hljs-keyword">var</span> rest = flatten(<span class="hljs-built_in">arguments</span>, <span class="hljs-literal">true</span>, <span class="hljs-literal">true</span>, <span class="hljs-number">1</span>);
    <span class="hljs-keyword">return</span> _.filter(array, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value)</span></span>{
      <span class="hljs-keyword">return</span> !_.contains(rest, value);
    });
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-64">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-64">&#182;</a>
              </div>
              <p>Zip together multiple lists into a single array — elements that share
an index go together.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.zip = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> _.unzip(<span class="hljs-built_in">arguments</span>);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-65">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-65">&#182;</a>
              </div>
              <p>Complement of _.zip. Unzip accepts an array of arrays and groups
each array’s elements on shared indices</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.unzip = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array)</span> </span>{
    <span class="hljs-keyword">var</span> length = array &amp;&amp; _.max(array, getLength).length || <span class="hljs-number">0</span>;
    <span class="hljs-keyword">var</span> result = <span class="hljs-built_in">Array</span>(length);

    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
      result[index] = _.pluck(array, index);
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-66">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-66">&#182;</a>
              </div>
              <p>Converts lists into objects. Pass either a single array of <code>[key, value]</code>
pairs, or two parallel arrays of the same length — one of keys, and one of
the corresponding values.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.object = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(list, values)</span> </span>{
    <span class="hljs-keyword">var</span> result = {};
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = getLength(list); i &lt; length; i++) {
      <span class="hljs-keyword">if</span> (values) {
        result[list[i]] = values[i];
      } <span class="hljs-keyword">else</span> {
        result[list[i][<span class="hljs-number">0</span>]] = list[i][<span class="hljs-number">1</span>];
      }
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-67">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-67">&#182;</a>
              </div>
              <p>Generator function to create the findIndex and findLastIndex functions</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">createPredicateIndexFinder</span><span class="hljs-params">(dir)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, predicate, context)</span> </span>{
      predicate = cb(predicate, context);
      <span class="hljs-keyword">var</span> length = getLength(array);
      <span class="hljs-keyword">var</span> index = dir &gt; <span class="hljs-number">0</span> ? <span class="hljs-number">0</span> : length - <span class="hljs-number">1</span>;
      <span class="hljs-keyword">for</span> (; index &gt;= <span class="hljs-number">0</span> &amp;&amp; index &lt; length; index += dir) {
        <span class="hljs-keyword">if</span> (predicate(array[index], index, array)) <span class="hljs-keyword">return</span> index;
      }
      <span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>;
    };
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-68">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-68">&#182;</a>
              </div>
              <p>Returns the first index on an array-like that passes a predicate test</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.findIndex = createPredicateIndexFinder(<span class="hljs-number">1</span>);
  _.findLastIndex = createPredicateIndexFinder(-<span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-69">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-69">&#182;</a>
              </div>
              <p>Use a comparator function to figure out the smallest index at which
an object should be inserted so as to maintain order. Uses binary search.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.sortedIndex = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, obj, iteratee, context)</span> </span>{
    iteratee = cb(iteratee, context, <span class="hljs-number">1</span>);
    <span class="hljs-keyword">var</span> value = iteratee(obj);
    <span class="hljs-keyword">var</span> low = <span class="hljs-number">0</span>, high = getLength(array);
    <span class="hljs-keyword">while</span> (low &lt; high) {
      <span class="hljs-keyword">var</span> mid = <span class="hljs-built_in">Math</span>.floor((low + high) / <span class="hljs-number">2</span>);
      <span class="hljs-keyword">if</span> (iteratee(array[mid]) &lt; value) low = mid + <span class="hljs-number">1</span>; <span class="hljs-keyword">else</span> high = mid;
    }
    <span class="hljs-keyword">return</span> low;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-70">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-70">&#182;</a>
              </div>
              <p>Generator function to create the indexOf and lastIndexOf functions</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">createIndexFinder</span><span class="hljs-params">(dir, predicateFind, sortedIndex)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(array, item, idx)</span> </span>{
      <span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = getLength(array);
      <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> idx == <span class="hljs-string">'number'</span>) {
        <span class="hljs-keyword">if</span> (dir &gt; <span class="hljs-number">0</span>) {
            i = idx &gt;= <span class="hljs-number">0</span> ? idx : <span class="hljs-built_in">Math</span>.max(idx + length, i);
        } <span class="hljs-keyword">else</span> {
            length = idx &gt;= <span class="hljs-number">0</span> ? <span class="hljs-built_in">Math</span>.min(idx + <span class="hljs-number">1</span>, length) : idx + length + <span class="hljs-number">1</span>;
        }
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (sortedIndex &amp;&amp; idx &amp;&amp; length) {
        idx = sortedIndex(array, item);
        <span class="hljs-keyword">return</span> array[idx] === item ? idx : -<span class="hljs-number">1</span>;
      }
      <span class="hljs-keyword">if</span> (item !== item) {
        idx = predicateFind(slice.call(array, i, length), _.isNaN);
        <span class="hljs-keyword">return</span> idx &gt;= <span class="hljs-number">0</span> ? idx + i : -<span class="hljs-number">1</span>;
      }
      <span class="hljs-keyword">for</span> (idx = dir &gt; <span class="hljs-number">0</span> ? i : length - <span class="hljs-number">1</span>; idx &gt;= <span class="hljs-number">0</span> &amp;&amp; idx &lt; length; idx += dir) {
        <span class="hljs-keyword">if</span> (array[idx] === item) <span class="hljs-keyword">return</span> idx;
      }
      <span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>;
    };
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-71">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-71">&#182;</a>
              </div>
              <p>Return the position of the first occurrence of an item in an array,
or -1 if the item is not included in the array.
If the array is large and already in sort order, pass <code>true</code>
for <strong>isSorted</strong> to use binary search.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.indexOf = createIndexFinder(<span class="hljs-number">1</span>, _.findIndex, _.sortedIndex);
  _.lastIndexOf = createIndexFinder(-<span class="hljs-number">1</span>, _.findLastIndex);</pre></div></div>
            
        </li>
        
        
        <li id="section-72">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-72">&#182;</a>
              </div>
              <p>Generate an integer Array containing an arithmetic progression. A port of
the native Python <code>range()</code> function. See
<a href="http://docs.python.org/library/functions.html#range">the Python documentation</a>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.range = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(start, stop, step)</span> </span>{
    <span class="hljs-keyword">if</span> (stop == <span class="hljs-literal">null</span>) {
      stop = start || <span class="hljs-number">0</span>;
      start = <span class="hljs-number">0</span>;
    }
    step = step || <span class="hljs-number">1</span>;

    <span class="hljs-keyword">var</span> length = <span class="hljs-built_in">Math</span>.max(<span class="hljs-built_in">Math</span>.ceil((stop - start) / step), <span class="hljs-number">0</span>);
    <span class="hljs-keyword">var</span> range = <span class="hljs-built_in">Array</span>(length);

    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> idx = <span class="hljs-number">0</span>; idx &lt; length; idx++, start += step) {
      range[idx] = start;
    }

    <span class="hljs-keyword">return</span> range;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-73">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-73">&#182;</a>
              </div>
              <h2 id="function-ahem-functions">Function (ahem) Functions</h2>

            </div>
            
        </li>
        
        
        <li id="section-74">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-74">&#182;</a>
              </div>
              
            </div>
            
        </li>
        
        
        <li id="section-75">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-75">&#182;</a>
              </div>
              <p>Determines whether to execute a function as a constructor
or a normal function with the provided arguments</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> executeBound = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(sourceFunc, boundFunc, context, callingContext, args)</span> </span>{
    <span class="hljs-keyword">if</span> (!(callingContext <span class="hljs-keyword">instanceof</span> boundFunc)) <span class="hljs-keyword">return</span> sourceFunc.apply(context, args);
    <span class="hljs-keyword">var</span> self = baseCreate(sourceFunc.prototype);
    <span class="hljs-keyword">var</span> result = sourceFunc.apply(self, args);
    <span class="hljs-keyword">if</span> (_.isObject(result)) <span class="hljs-keyword">return</span> result;
    <span class="hljs-keyword">return</span> self;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-76">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-76">&#182;</a>
              </div>
              <p>Create a function bound to a given object (assigning <code>this</code>, and arguments,
optionally). Delegates to <strong>ECMAScript 5</strong>‘s native <code>Function.bind</code> if
available.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.bind = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func, context)</span> </span>{
    <span class="hljs-keyword">if</span> (nativeBind &amp;&amp; func.bind === nativeBind) <span class="hljs-keyword">return</span> nativeBind.apply(func, slice.call(<span class="hljs-built_in">arguments</span>, <span class="hljs-number">1</span>));
    <span class="hljs-keyword">if</span> (!_.isFunction(func)) <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">TypeError</span>(<span class="hljs-string">'Bind must be called on a function'</span>);
    <span class="hljs-keyword">var</span> args = slice.call(<span class="hljs-built_in">arguments</span>, <span class="hljs-number">2</span>);
    <span class="hljs-keyword">var</span> bound = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">return</span> executeBound(func, bound, context, <span class="hljs-keyword">this</span>, args.concat(slice.call(<span class="hljs-built_in">arguments</span>)));
    };
    <span class="hljs-keyword">return</span> bound;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-77">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-77">&#182;</a>
              </div>
              <p>Partially apply a function by creating a version that has had some of its
arguments pre-filled, without changing its dynamic <code>this</code> context. _ acts
as a placeholder, allowing any combination of arguments to be pre-filled.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.partial = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func)</span> </span>{
    <span class="hljs-keyword">var</span> boundArgs = slice.call(<span class="hljs-built_in">arguments</span>, <span class="hljs-number">1</span>);
    <span class="hljs-keyword">var</span> bound = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">var</span> position = <span class="hljs-number">0</span>, length = boundArgs.length;
      <span class="hljs-keyword">var</span> args = <span class="hljs-built_in">Array</span>(length);
      <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
        args[i] = boundArgs[i] === _ ? <span class="hljs-built_in">arguments</span>[position++] : boundArgs[i];
      }
      <span class="hljs-keyword">while</span> (position &lt; <span class="hljs-built_in">arguments</span>.length) args.push(<span class="hljs-built_in">arguments</span>[position++]);
      <span class="hljs-keyword">return</span> executeBound(func, bound, <span class="hljs-keyword">this</span>, <span class="hljs-keyword">this</span>, args);
    };
    <span class="hljs-keyword">return</span> bound;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-78">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-78">&#182;</a>
              </div>
              <p>Bind a number of an object’s methods to that object. Remaining arguments
are the method names to be bound. Useful for ensuring that all callbacks
defined on an object belong to it.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.bindAll = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> i, length = <span class="hljs-built_in">arguments</span>.length, key;
    <span class="hljs-keyword">if</span> (length &lt;= <span class="hljs-number">1</span>) <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Error</span>(<span class="hljs-string">'bindAll must be passed function names'</span>);
    <span class="hljs-keyword">for</span> (i = <span class="hljs-number">1</span>; i &lt; length; i++) {
      key = <span class="hljs-built_in">arguments</span>[i];
      obj[key] = _.bind(obj[key], obj);
    }
    <span class="hljs-keyword">return</span> obj;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-79">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-79">&#182;</a>
              </div>
              <p>Memoize an expensive function by storing its results.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.memoize = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func, hasher)</span> </span>{
    <span class="hljs-keyword">var</span> memoize = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(key)</span> </span>{
      <span class="hljs-keyword">var</span> cache = memoize.cache;
      <span class="hljs-keyword">var</span> address = <span class="hljs-string">''</span> + (hasher ? hasher.apply(<span class="hljs-keyword">this</span>, <span class="hljs-built_in">arguments</span>) : key);
      <span class="hljs-keyword">if</span> (!_.has(cache, address)) cache[address] = func.apply(<span class="hljs-keyword">this</span>, <span class="hljs-built_in">arguments</span>);
      <span class="hljs-keyword">return</span> cache[address];
    };
    memoize.cache = {};
    <span class="hljs-keyword">return</span> memoize;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-80">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-80">&#182;</a>
              </div>
              <p>Delays a function for the given number of milliseconds, and then calls
it with the arguments supplied.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.delay = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func, wait)</span> </span>{
    <span class="hljs-keyword">var</span> args = slice.call(<span class="hljs-built_in">arguments</span>, <span class="hljs-number">2</span>);
    <span class="hljs-keyword">return</span> setTimeout(<span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span></span>{
      <span class="hljs-keyword">return</span> func.apply(<span class="hljs-literal">null</span>, args);
    }, wait);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-81">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-81">&#182;</a>
              </div>
              <p>Defers a function, scheduling it to run after the current call stack has
cleared.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.defer = _.partial(_.delay, _, <span class="hljs-number">1</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-82">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-82">&#182;</a>
              </div>
              <p>Returns a function, that, when invoked, will only be triggered at most once
during a given window of time. Normally, the throttled function will run
as much as it can, without ever going more than once per <code>wait</code> duration;
but if you’d like to disable the execution on the leading edge, pass
<code>{leading: false}</code>. To disable execution on the trailing edge, ditto.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.throttle = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func, wait, options)</span> </span>{
    <span class="hljs-keyword">var</span> context, args, result;
    <span class="hljs-keyword">var</span> timeout = <span class="hljs-literal">null</span>;
    <span class="hljs-keyword">var</span> previous = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">if</span> (!options) options = {};
    <span class="hljs-keyword">var</span> later = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      previous = options.leading === <span class="hljs-literal">false</span> ? <span class="hljs-number">0</span> : _.now();
      timeout = <span class="hljs-literal">null</span>;
      result = func.apply(context, args);
      <span class="hljs-keyword">if</span> (!timeout) context = args = <span class="hljs-literal">null</span>;
    };
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">var</span> now = _.now();
      <span class="hljs-keyword">if</span> (!previous &amp;&amp; options.leading === <span class="hljs-literal">false</span>) previous = now;
      <span class="hljs-keyword">var</span> remaining = wait - (now - previous);
      context = <span class="hljs-keyword">this</span>;
      args = <span class="hljs-built_in">arguments</span>;
      <span class="hljs-keyword">if</span> (remaining &lt;= <span class="hljs-number">0</span> || remaining &gt; wait) {
        <span class="hljs-keyword">if</span> (timeout) {
          clearTimeout(timeout);
          timeout = <span class="hljs-literal">null</span>;
        }
        previous = now;
        result = func.apply(context, args);
        <span class="hljs-keyword">if</span> (!timeout) context = args = <span class="hljs-literal">null</span>;
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!timeout &amp;&amp; options.trailing !== <span class="hljs-literal">false</span>) {
        timeout = setTimeout(later, remaining);
      }
      <span class="hljs-keyword">return</span> result;
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-83">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-83">&#182;</a>
              </div>
              <p>Returns a function, that, as long as it continues to be invoked, will not
be triggered. The function will be called after it stops being called for
N milliseconds. If <code>immediate</code> is passed, trigger the function on the
leading edge, instead of the trailing.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.debounce = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func, wait, immediate)</span> </span>{
    <span class="hljs-keyword">var</span> timeout, args, context, timestamp, result;

    <span class="hljs-keyword">var</span> later = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">var</span> last = _.now() - timestamp;

      <span class="hljs-keyword">if</span> (last &lt; wait &amp;&amp; last &gt;= <span class="hljs-number">0</span>) {
        timeout = setTimeout(later, wait - last);
      } <span class="hljs-keyword">else</span> {
        timeout = <span class="hljs-literal">null</span>;
        <span class="hljs-keyword">if</span> (!immediate) {
          result = func.apply(context, args);
          <span class="hljs-keyword">if</span> (!timeout) context = args = <span class="hljs-literal">null</span>;
        }
      }
    };

    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      context = <span class="hljs-keyword">this</span>;
      args = <span class="hljs-built_in">arguments</span>;
      timestamp = _.now();
      <span class="hljs-keyword">var</span> callNow = immediate &amp;&amp; !timeout;
      <span class="hljs-keyword">if</span> (!timeout) timeout = setTimeout(later, wait);
      <span class="hljs-keyword">if</span> (callNow) {
        result = func.apply(context, args);
        context = args = <span class="hljs-literal">null</span>;
      }

      <span class="hljs-keyword">return</span> result;
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-84">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-84">&#182;</a>
              </div>
              <p>Returns the first function passed as an argument to the second,
allowing you to adjust arguments, run code before and after, and
conditionally execute the original function.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.wrap = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(func, wrapper)</span> </span>{
    <span class="hljs-keyword">return</span> _.partial(wrapper, func);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-85">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-85">&#182;</a>
              </div>
              <p>Returns a negated version of the passed-in predicate.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.negate = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(predicate)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">return</span> !predicate.apply(<span class="hljs-keyword">this</span>, <span class="hljs-built_in">arguments</span>);
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-86">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-86">&#182;</a>
              </div>
              <p>Returns a function that is the composition of a list of functions, each
consuming the return value of the function that follows.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.compose = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">var</span> args = <span class="hljs-built_in">arguments</span>;
    <span class="hljs-keyword">var</span> start = args.length - <span class="hljs-number">1</span>;
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">var</span> i = start;
      <span class="hljs-keyword">var</span> result = args[start].apply(<span class="hljs-keyword">this</span>, <span class="hljs-built_in">arguments</span>);
      <span class="hljs-keyword">while</span> (i--) result = args[i].call(<span class="hljs-keyword">this</span>, result);
      <span class="hljs-keyword">return</span> result;
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-87">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-87">&#182;</a>
              </div>
              <p>Returns a function that will only be executed on and after the Nth call.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.after = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(times, func)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">if</span> (--times &lt; <span class="hljs-number">1</span>) {
        <span class="hljs-keyword">return</span> func.apply(<span class="hljs-keyword">this</span>, <span class="hljs-built_in">arguments</span>);
      }
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-88">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-88">&#182;</a>
              </div>
              <p>Returns a function that will only be executed up to (but not including) the Nth call.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.before = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(times, func)</span> </span>{
    <span class="hljs-keyword">var</span> memo;
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">if</span> (--times &gt; <span class="hljs-number">0</span>) {
        memo = func.apply(<span class="hljs-keyword">this</span>, <span class="hljs-built_in">arguments</span>);
      }
      <span class="hljs-keyword">if</span> (times &lt;= <span class="hljs-number">1</span>) func = <span class="hljs-literal">null</span>;
      <span class="hljs-keyword">return</span> memo;
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-89">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-89">&#182;</a>
              </div>
              <p>Returns a function that will be executed at most one time, no matter how
often you call it. Useful for lazy initialization.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.once = _.partial(_.before, <span class="hljs-number">2</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-90">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-90">&#182;</a>
              </div>
              <h2 id="object-functions">Object Functions</h2>

            </div>
            
        </li>
        
        
        <li id="section-91">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-91">&#182;</a>
              </div>
              
            </div>
            
        </li>
        
        
        <li id="section-92">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-92">&#182;</a>
              </div>
              <p>Keys in IE &lt; 9 that won’t be iterated by <code>for key in ...</code> and thus missed.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> hasEnumBug = !{toString: <span class="hljs-literal">null</span>}.propertyIsEnumerable(<span class="hljs-string">'toString'</span>);
  <span class="hljs-keyword">var</span> nonEnumerableProps = [<span class="hljs-string">'valueOf'</span>, <span class="hljs-string">'isPrototypeOf'</span>, <span class="hljs-string">'toString'</span>,
                      <span class="hljs-string">'propertyIsEnumerable'</span>, <span class="hljs-string">'hasOwnProperty'</span>, <span class="hljs-string">'toLocaleString'</span>];

  <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">collectNonEnumProps</span><span class="hljs-params">(obj, keys)</span> </span>{
    <span class="hljs-keyword">var</span> nonEnumIdx = nonEnumerableProps.length;
    <span class="hljs-keyword">var</span> constructor = obj.constructor;
    <span class="hljs-keyword">var</span> proto = (_.isFunction(constructor) &amp;&amp; constructor.prototype) || ObjProto;</pre></div></div>
            
        </li>
        
        
        <li id="section-93">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-93">&#182;</a>
              </div>
              <p>Constructor is a special case.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> prop = <span class="hljs-string">'constructor'</span>;
    <span class="hljs-keyword">if</span> (_.has(obj, prop) &amp;&amp; !_.contains(keys, prop)) keys.push(prop);

    <span class="hljs-keyword">while</span> (nonEnumIdx--) {
      prop = nonEnumerableProps[nonEnumIdx];
      <span class="hljs-keyword">if</span> (prop <span class="hljs-keyword">in</span> obj &amp;&amp; obj[prop] !== proto[prop] &amp;&amp; !_.contains(keys, prop)) {
        keys.push(prop);
      }
    }
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-94">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-94">&#182;</a>
              </div>
              <p>Retrieve the names of an object’s own properties.
Delegates to <strong>ECMAScript 5</strong>‘s native <code>Object.keys</code></p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.keys = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">if</span> (!_.isObject(obj)) <span class="hljs-keyword">return</span> [];
    <span class="hljs-keyword">if</span> (nativeKeys) <span class="hljs-keyword">return</span> nativeKeys(obj);
    <span class="hljs-keyword">var</span> keys = [];
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> key <span class="hljs-keyword">in</span> obj) <span class="hljs-keyword">if</span> (_.has(obj, key)) keys.push(key);</pre></div></div>
            
        </li>
        
        
        <li id="section-95">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-95">&#182;</a>
              </div>
              <p>Ahem, IE &lt; 9.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (hasEnumBug) collectNonEnumProps(obj, keys);
    <span class="hljs-keyword">return</span> keys;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-96">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-96">&#182;</a>
              </div>
              <p>Retrieve all the property names of an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.allKeys = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">if</span> (!_.isObject(obj)) <span class="hljs-keyword">return</span> [];
    <span class="hljs-keyword">var</span> keys = [];
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> key <span class="hljs-keyword">in</span> obj) keys.push(key);</pre></div></div>
            
        </li>
        
        
        <li id="section-97">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-97">&#182;</a>
              </div>
              <p>Ahem, IE &lt; 9.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (hasEnumBug) collectNonEnumProps(obj, keys);
    <span class="hljs-keyword">return</span> keys;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-98">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-98">&#182;</a>
              </div>
              <p>Retrieve the values of an object’s properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.values = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> keys = _.keys(obj);
    <span class="hljs-keyword">var</span> length = keys.length;
    <span class="hljs-keyword">var</span> values = <span class="hljs-built_in">Array</span>(length);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
      values[i] = obj[keys[i]];
    }
    <span class="hljs-keyword">return</span> values;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-99">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-99">&#182;</a>
              </div>
              <p>Returns the results of applying the iteratee to each element of the object
In contrast to _.map it returns an object</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.mapObject = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
    iteratee = cb(iteratee, context);
    <span class="hljs-keyword">var</span> keys =  _.keys(obj),
          length = keys.length,
          results = {},
          currentKey;
      <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>; index &lt; length; index++) {
        currentKey = keys[index];
        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
      }
      <span class="hljs-keyword">return</span> results;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-100">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-100">&#182;</a>
              </div>
              <p>Convert an object into a list of <code>[key, value]</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.pairs = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> keys = _.keys(obj);
    <span class="hljs-keyword">var</span> length = keys.length;
    <span class="hljs-keyword">var</span> pairs = <span class="hljs-built_in">Array</span>(length);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
      pairs[i] = [keys[i], obj[keys[i]]];
    }
    <span class="hljs-keyword">return</span> pairs;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-101">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-101">&#182;</a>
              </div>
              <p>Invert the keys and values of an object. The values must be serializable.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.invert = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> result = {};
    <span class="hljs-keyword">var</span> keys = _.keys(obj);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = keys.length; i &lt; length; i++) {
      result[obj[keys[i]]] = keys[i];
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-102">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-102">&#182;</a>
              </div>
              <p>Return a sorted list of the function names available on the object.
Aliased as <code>methods</code></p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.functions = _.methods = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> names = [];
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> key <span class="hljs-keyword">in</span> obj) {
      <span class="hljs-keyword">if</span> (_.isFunction(obj[key])) names.push(key);
    }
    <span class="hljs-keyword">return</span> names.sort();
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-103">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-103">&#182;</a>
              </div>
              <p>Extend a given object with all the properties in passed-in object(s).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.extend = createAssigner(_.allKeys);</pre></div></div>
            
        </li>
        
        
        <li id="section-104">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-104">&#182;</a>
              </div>
              <p>Assigns a given object with all the own properties in the passed-in object(s)
(<a href="https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign">https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign</a>)</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.extendOwn = _.assign = createAssigner(_.keys);</pre></div></div>
            
        </li>
        
        
        <li id="section-105">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-105">&#182;</a>
              </div>
              <p>Returns the first key on an object that passes a predicate test</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.findKey = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, predicate, context)</span> </span>{
    predicate = cb(predicate, context);
    <span class="hljs-keyword">var</span> keys = _.keys(obj), key;
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = keys.length; i &lt; length; i++) {
      key = keys[i];
      <span class="hljs-keyword">if</span> (predicate(obj[key], key, obj)) <span class="hljs-keyword">return</span> key;
    }
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-106">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-106">&#182;</a>
              </div>
              <p>Return a copy of the object only containing the whitelisted properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.pick = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(object, oiteratee, context)</span> </span>{
    <span class="hljs-keyword">var</span> result = {}, obj = object, iteratee, keys;
    <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> result;
    <span class="hljs-keyword">if</span> (_.isFunction(oiteratee)) {
      keys = _.allKeys(obj);
      iteratee = optimizeCb(oiteratee, context);
    } <span class="hljs-keyword">else</span> {
      keys = flatten(<span class="hljs-built_in">arguments</span>, <span class="hljs-literal">false</span>, <span class="hljs-literal">false</span>, <span class="hljs-number">1</span>);
      iteratee = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key, obj)</span> </span>{ <span class="hljs-keyword">return</span> key <span class="hljs-keyword">in</span> obj; };
      obj = <span class="hljs-built_in">Object</span>(obj);
    }
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>, length = keys.length; i &lt; length; i++) {
      <span class="hljs-keyword">var</span> key = keys[i];
      <span class="hljs-keyword">var</span> value = obj[key];
      <span class="hljs-keyword">if</span> (iteratee(value, key, obj)) result[key] = value;
    }
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-107">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-107">&#182;</a>
              </div>
              <p>Return a copy of the object without the blacklisted properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.omit = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, iteratee, context)</span> </span>{
    <span class="hljs-keyword">if</span> (_.isFunction(iteratee)) {
      iteratee = _.negate(iteratee);
    } <span class="hljs-keyword">else</span> {
      <span class="hljs-keyword">var</span> keys = _.map(flatten(<span class="hljs-built_in">arguments</span>, <span class="hljs-literal">false</span>, <span class="hljs-literal">false</span>, <span class="hljs-number">1</span>), <span class="hljs-built_in">String</span>);
      iteratee = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value, key)</span> </span>{
        <span class="hljs-keyword">return</span> !_.contains(keys, key);
      };
    }
    <span class="hljs-keyword">return</span> _.pick(obj, iteratee, context);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-108">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-108">&#182;</a>
              </div>
              <p>Fill in a given object with default properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.defaults = createAssigner(_.allKeys, <span class="hljs-literal">true</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-109">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-109">&#182;</a>
              </div>
              <p>Creates an object that inherits from the given prototype object.
If additional properties are provided then they will be added to the
created object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.create = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(prototype, props)</span> </span>{
    <span class="hljs-keyword">var</span> result = baseCreate(prototype);
    <span class="hljs-keyword">if</span> (props) _.extendOwn(result, props);
    <span class="hljs-keyword">return</span> result;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-110">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-110">&#182;</a>
              </div>
              <p>Create a (shallow-cloned) duplicate of an object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.clone = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">if</span> (!_.isObject(obj)) <span class="hljs-keyword">return</span> obj;
    <span class="hljs-keyword">return</span> _.isArray(obj) ? obj.slice() : _.extend({}, obj);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-111">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-111">&#182;</a>
              </div>
              <p>Invokes interceptor with the obj, and then returns obj.
The primary purpose of this method is to “tap into” a method chain, in
order to perform operations on intermediate results within the chain.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.tap = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, interceptor)</span> </span>{
    interceptor(obj);
    <span class="hljs-keyword">return</span> obj;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-112">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-112">&#182;</a>
              </div>
              <p>Returns whether an object has a given set of <code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isMatch = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(object, attrs)</span> </span>{
    <span class="hljs-keyword">var</span> keys = _.keys(attrs), length = keys.length;
    <span class="hljs-keyword">if</span> (object == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> !length;
    <span class="hljs-keyword">var</span> obj = <span class="hljs-built_in">Object</span>(object);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; length; i++) {
      <span class="hljs-keyword">var</span> key = keys[i];
      <span class="hljs-keyword">if</span> (attrs[key] !== obj[key] || !(key <span class="hljs-keyword">in</span> obj)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
    <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-113">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-113">&#182;</a>
              </div>
              <p>Internal recursive comparison function for <code>isEqual</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> eq = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(a, b, aStack, bStack)</span> </span>{</pre></div></div>
            
        </li>
        
        
        <li id="section-114">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-114">&#182;</a>
              </div>
              <p>Identical objects are equal. <code>0 === -0</code>, but they aren’t identical.
See the <a href="http://wiki.ecmascript.org/doku.php?id=harmony:egal">Harmony <code>egal</code> proposal</a>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (a === b) <span class="hljs-keyword">return</span> a !== <span class="hljs-number">0</span> || <span class="hljs-number">1</span> / a === <span class="hljs-number">1</span> / b;</pre></div></div>
            
        </li>
        
        
        <li id="section-115">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-115">&#182;</a>
              </div>
              <p>A strict comparison is necessary because <code>null == undefined</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (a == <span class="hljs-literal">null</span> || b == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> a === b;</pre></div></div>
            
        </li>
        
        
        <li id="section-116">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-116">&#182;</a>
              </div>
              <p>Unwrap any wrapped objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (a <span class="hljs-keyword">instanceof</span> _) a = a._wrapped;
    <span class="hljs-keyword">if</span> (b <span class="hljs-keyword">instanceof</span> _) b = b._wrapped;</pre></div></div>
            
        </li>
        
        
        <li id="section-117">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-117">&#182;</a>
              </div>
              <p>Compare <code>[[Class]]</code> names.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> className = toString.call(a);
    <span class="hljs-keyword">if</span> (className !== toString.call(b)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    <span class="hljs-keyword">switch</span> (className) {</pre></div></div>
            
        </li>
        
        
        <li id="section-118">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-118">&#182;</a>
              </div>
              <p>Strings, numbers, regular expressions, dates, and booleans are compared by value.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">case</span> <span class="hljs-string">'[object RegExp]'</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-119">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-119">&#182;</a>
              </div>
              <p>RegExps are coerced to strings for comparison (Note: ‘’ + /a/i === ‘/a/i’)</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">case</span> <span class="hljs-string">'[object String]'</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-120">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-120">&#182;</a>
              </div>
              <p>Primitives and their corresponding object wrappers are equivalent; thus, <code>&quot;5&quot;</code> is
equivalent to <code>new String(&quot;5&quot;)</code>.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>        <span class="hljs-keyword">return</span> <span class="hljs-string">''</span> + a === <span class="hljs-string">''</span> + b;
      <span class="hljs-keyword">case</span> <span class="hljs-string">'[object Number]'</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-121">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-121">&#182;</a>
              </div>
              <p><code>NaN</code>s are equivalent, but non-reflexive.
Object(NaN) is equivalent to NaN</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>        <span class="hljs-keyword">if</span> (+a !== +a) <span class="hljs-keyword">return</span> +b !== +b;</pre></div></div>
            
        </li>
        
        
        <li id="section-122">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-122">&#182;</a>
              </div>
              <p>An <code>egal</code> comparison is performed for other numeric values.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>        <span class="hljs-keyword">return</span> +a === <span class="hljs-number">0</span> ? <span class="hljs-number">1</span> / +a === <span class="hljs-number">1</span> / b : +a === +b;
      <span class="hljs-keyword">case</span> <span class="hljs-string">'[object Date]'</span>:
      <span class="hljs-keyword">case</span> <span class="hljs-string">'[object Boolean]'</span>:</pre></div></div>
            
        </li>
        
        
        <li id="section-123">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-123">&#182;</a>
              </div>
              <p>Coerce dates and booleans to numeric primitive values. Dates are compared by their
millisecond representations. Note that invalid dates with millisecond representations
of <code>NaN</code> are not equivalent.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>        <span class="hljs-keyword">return</span> +a === +b;
    }

    <span class="hljs-keyword">var</span> areArrays = className === <span class="hljs-string">'[object Array]'</span>;
    <span class="hljs-keyword">if</span> (!areArrays) {
      <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> a != <span class="hljs-string">'object'</span> || <span class="hljs-keyword">typeof</span> b != <span class="hljs-string">'object'</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-124">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-124">&#182;</a>
              </div>
              <p>Objects with different constructors are not equivalent, but <code>Object</code>s or <code>Array</code>s
from different frames are.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">var</span> aCtor = a.constructor, bCtor = b.constructor;
      <span class="hljs-keyword">if</span> (aCtor !== bCtor &amp;&amp; !(_.isFunction(aCtor) &amp;&amp; aCtor <span class="hljs-keyword">instanceof</span> aCtor &amp;&amp;
                               _.isFunction(bCtor) &amp;&amp; bCtor <span class="hljs-keyword">instanceof</span> bCtor)
                          &amp;&amp; (<span class="hljs-string">'constructor'</span> <span class="hljs-keyword">in</span> a &amp;&amp; <span class="hljs-string">'constructor'</span> <span class="hljs-keyword">in</span> b)) {
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
      }
    }</pre></div></div>
            
        </li>
        
        
        <li id="section-125">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-125">&#182;</a>
              </div>
              <p>Assume equality for cyclic structures. The algorithm for detecting cyclic
structures is adapted from ES 5.1 section 15.12.3, abstract operation <code>JO</code>.</p>

            </div>
            
        </li>
        
        
        <li id="section-126">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-126">&#182;</a>
              </div>
              <p>Initializing stack of traversed objects.
It’s done here since we only need them for objects and arrays comparison.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    aStack = aStack || [];
    bStack = bStack || [];
    <span class="hljs-keyword">var</span> length = aStack.length;
    <span class="hljs-keyword">while</span> (length--) {</pre></div></div>
            
        </li>
        
        
        <li id="section-127">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-127">&#182;</a>
              </div>
              <p>Linear search. Performance is inversely proportional to the number of
unique nested structures.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">if</span> (aStack[length] === a) <span class="hljs-keyword">return</span> bStack[length] === b;
    }</pre></div></div>
            
        </li>
        
        
        <li id="section-128">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-128">&#182;</a>
              </div>
              <p>Add the first object to the stack of traversed objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    aStack.push(a);
    bStack.push(b);</pre></div></div>
            
        </li>
        
        
        <li id="section-129">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-129">&#182;</a>
              </div>
              <p>Recursively compare objects and arrays.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (areArrays) {</pre></div></div>
            
        </li>
        
        
        <li id="section-130">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-130">&#182;</a>
              </div>
              <p>Compare array lengths to determine if a deep comparison is necessary.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      length = a.length;
      <span class="hljs-keyword">if</span> (length !== b.length) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-131">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-131">&#182;</a>
              </div>
              <p>Deep compare the contents, ignoring non-numeric properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">while</span> (length--) {
        <span class="hljs-keyword">if</span> (!eq(a[length], b[length], aStack, bStack)) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
      }
    } <span class="hljs-keyword">else</span> {</pre></div></div>
            
        </li>
        
        
        <li id="section-132">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-132">&#182;</a>
              </div>
              <p>Deep compare objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">var</span> keys = _.keys(a), key;
      length = keys.length;</pre></div></div>
            
        </li>
        
        
        <li id="section-133">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-133">&#182;</a>
              </div>
              <p>Ensure that both objects contain the same number of properties before comparing deep equality.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">if</span> (_.keys(b).length !== length) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
      <span class="hljs-keyword">while</span> (length--) {</pre></div></div>
            
        </li>
        
        
        <li id="section-134">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-134">&#182;</a>
              </div>
              <p>Deep compare each member</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>        key = keys[length];
        <span class="hljs-keyword">if</span> (!(_.has(b, key) &amp;&amp; eq(a[key], b[key], aStack, bStack))) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
      }
    }</pre></div></div>
            
        </li>
        
        
        <li id="section-135">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-135">&#182;</a>
              </div>
              <p>Remove the first object from the stack of traversed objects.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    aStack.pop();
    bStack.pop();
    <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-136">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-136">&#182;</a>
              </div>
              <p>Perform a deep comparison to check if two objects are equal.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isEqual = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(a, b)</span> </span>{
    <span class="hljs-keyword">return</span> eq(a, b);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-137">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-137">&#182;</a>
              </div>
              <p>Is a given array, string, or object empty?
An “empty” object has no enumerable own-properties.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isEmpty = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">if</span> (obj == <span class="hljs-literal">null</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    <span class="hljs-keyword">if</span> (isArrayLike(obj) &amp;&amp; (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) <span class="hljs-keyword">return</span> obj.length === <span class="hljs-number">0</span>;
    <span class="hljs-keyword">return</span> _.keys(obj).length === <span class="hljs-number">0</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-138">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-138">&#182;</a>
              </div>
              <p>Is a given value a DOM element?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isElement = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> !!(obj &amp;&amp; obj.nodeType === <span class="hljs-number">1</span>);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-139">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-139">&#182;</a>
              </div>
              <p>Is a given value an array?
Delegates to ECMA5’s native Array.isArray</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isArray = nativeIsArray || <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> toString.call(obj) === <span class="hljs-string">'[object Array]'</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-140">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-140">&#182;</a>
              </div>
              <p>Is a given variable an object?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isObject = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> type = <span class="hljs-keyword">typeof</span> obj;
    <span class="hljs-keyword">return</span> type === <span class="hljs-string">'function'</span> || type === <span class="hljs-string">'object'</span> &amp;&amp; !!obj;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-141">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-141">&#182;</a>
              </div>
              <p>Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.each([<span class="hljs-string">'Arguments'</span>, <span class="hljs-string">'Function'</span>, <span class="hljs-string">'String'</span>, <span class="hljs-string">'Number'</span>, <span class="hljs-string">'Date'</span>, <span class="hljs-string">'RegExp'</span>, <span class="hljs-string">'Error'</span>], <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(name)</span> </span>{
    _[<span class="hljs-string">'is'</span> + name] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
      <span class="hljs-keyword">return</span> toString.call(obj) === <span class="hljs-string">'[object '</span> + name + <span class="hljs-string">']'</span>;
    };
  });</pre></div></div>
            
        </li>
        
        
        <li id="section-142">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-142">&#182;</a>
              </div>
              <p>Define a fallback version of the method in browsers (ahem, IE &lt; 9), where
there isn’t any inspectable “Arguments” type.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (!_.isArguments(<span class="hljs-built_in">arguments</span>)) {
    _.isArguments = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
      <span class="hljs-keyword">return</span> _.has(obj, <span class="hljs-string">'callee'</span>);
    };
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-143">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-143">&#182;</a>
              </div>
              <p>Optimize <code>isFunction</code> if appropriate. Work around some typeof bugs in old v8,
IE 11 (#1621), and in Safari 8 (#1929).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> /./ != <span class="hljs-string">'function'</span> &amp;&amp; <span class="hljs-keyword">typeof</span> <span class="hljs-built_in">Int8Array</span> != <span class="hljs-string">'object'</span>) {
    _.isFunction = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
      <span class="hljs-keyword">return</span> <span class="hljs-keyword">typeof</span> obj == <span class="hljs-string">'function'</span> || <span class="hljs-literal">false</span>;
    };
  }</pre></div></div>
            
        </li>
        
        
        <li id="section-144">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-144">&#182;</a>
              </div>
              <p>Is a given object a finite number?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isFinite = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-built_in">isFinite</span>(obj) &amp;&amp; !<span class="hljs-built_in">isNaN</span>(<span class="hljs-built_in">parseFloat</span>(obj));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-145">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-145">&#182;</a>
              </div>
              <p>Is the given value <code>NaN</code>? (NaN is the only number which does not equal itself).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isNaN = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> _.isNumber(obj) &amp;&amp; obj !== +obj;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-146">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-146">&#182;</a>
              </div>
              <p>Is a given value a boolean?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isBoolean = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> obj === <span class="hljs-literal">true</span> || obj === <span class="hljs-literal">false</span> || toString.call(obj) === <span class="hljs-string">'[object Boolean]'</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-147">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-147">&#182;</a>
              </div>
              <p>Is a given value equal to null?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isNull = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> obj === <span class="hljs-literal">null</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-148">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-148">&#182;</a>
              </div>
              <p>Is a given variable undefined?</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.isUndefined = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> obj === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-149">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-149">&#182;</a>
              </div>
              <p>Shortcut function for checking if an object has a given property directly
on itself (in other words, not on a prototype).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.has = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj, key)</span> </span>{
    <span class="hljs-keyword">return</span> obj != <span class="hljs-literal">null</span> &amp;&amp; hasOwnProperty.call(obj, key);
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-150">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-150">&#182;</a>
              </div>
              <h2 id="utility-functions">Utility Functions</h2>

            </div>
            
        </li>
        
        
        <li id="section-151">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-151">&#182;</a>
              </div>
              
            </div>
            
        </li>
        
        
        <li id="section-152">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-152">&#182;</a>
              </div>
              <p>Run Underscore.js in <em>noConflict</em> mode, returning the <code>_</code> variable to its
previous owner. Returns a reference to the Underscore object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.noConflict = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
    root._ = previousUnderscore;
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span>;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-153">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-153">&#182;</a>
              </div>
              <p>Keep the identity function around for default iteratees.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.identity = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value)</span> </span>{
    <span class="hljs-keyword">return</span> value;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-154">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-154">&#182;</a>
              </div>
              <p>Predicate-generating functions. Often useful outside of Underscore.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.constant = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(value)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">return</span> value;
    };
  };

  _.noop = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span></span>{};

  _.property = property;</pre></div></div>
            
        </li>
        
        
        <li id="section-155">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-155">&#182;</a>
              </div>
              <p>Generates a function for a given object that returns a given property.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.propertyOf = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">return</span> obj == <span class="hljs-literal">null</span> ? <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span></span>{} : <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(key)</span> </span>{
      <span class="hljs-keyword">return</span> obj[key];
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-156">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-156">&#182;</a>
              </div>
              <p>Returns a predicate for checking whether an object has a given set of
<code>key:value</code> pairs.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.matcher = _.matches = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(attrs)</span> </span>{
    attrs = _.extendOwn({}, attrs);
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
      <span class="hljs-keyword">return</span> _.isMatch(obj, attrs);
    };
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-157">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-157">&#182;</a>
              </div>
              <p>Run a function <strong>n</strong> times.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.times = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(n, iteratee, context)</span> </span>{
    <span class="hljs-keyword">var</span> accum = <span class="hljs-built_in">Array</span>(<span class="hljs-built_in">Math</span>.max(<span class="hljs-number">0</span>, n));
    iteratee = optimizeCb(iteratee, context, <span class="hljs-number">1</span>);
    <span class="hljs-keyword">for</span> (<span class="hljs-keyword">var</span> i = <span class="hljs-number">0</span>; i &lt; n; i++) accum[i] = iteratee(i);
    <span class="hljs-keyword">return</span> accum;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-158">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-158">&#182;</a>
              </div>
              <p>Return a random integer between min and max (inclusive).</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.random = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(min, max)</span> </span>{
    <span class="hljs-keyword">if</span> (max == <span class="hljs-literal">null</span>) {
      max = min;
      min = <span class="hljs-number">0</span>;
    }
    <span class="hljs-keyword">return</span> min + <span class="hljs-built_in">Math</span>.floor(<span class="hljs-built_in">Math</span>.random() * (max - min + <span class="hljs-number">1</span>));
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-159">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-159">&#182;</a>
              </div>
              <p>A (possibly faster) way to get the current timestamp as an integer.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.now = <span class="hljs-built_in">Date</span>.now || <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-built_in">Date</span>().getTime();
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-160">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-160">&#182;</a>
              </div>
              <p>List of HTML entities for escaping.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> escapeMap = {
    <span class="hljs-string">'&amp;'</span>: <span class="hljs-string">'&amp;amp;'</span>,
    <span class="hljs-string">'&lt;'</span>: <span class="hljs-string">'&amp;lt;'</span>,
    <span class="hljs-string">'&gt;'</span>: <span class="hljs-string">'&amp;gt;'</span>,
    <span class="hljs-string">'"'</span>: <span class="hljs-string">'&amp;quot;'</span>,
    <span class="hljs-string">"'"</span>: <span class="hljs-string">'&amp;#x27;'</span>,
    <span class="hljs-string">'`'</span>: <span class="hljs-string">'&amp;#x60;'</span>
  };
  <span class="hljs-keyword">var</span> unescapeMap = _.invert(escapeMap);</pre></div></div>
            
        </li>
        
        
        <li id="section-161">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-161">&#182;</a>
              </div>
              <p>Functions for escaping and unescaping strings to/from HTML interpolation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> createEscaper = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(map)</span> </span>{
    <span class="hljs-keyword">var</span> escaper = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(match)</span> </span>{
      <span class="hljs-keyword">return</span> map[match];
    };</pre></div></div>
            
        </li>
        
        
        <li id="section-162">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-162">&#182;</a>
              </div>
              <p>Regexes for identifying a key that needs to be escaped</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> source = <span class="hljs-string">'(?:'</span> + _.keys(map).join(<span class="hljs-string">'|'</span>) + <span class="hljs-string">')'</span>;
    <span class="hljs-keyword">var</span> testRegexp = <span class="hljs-built_in">RegExp</span>(source);
    <span class="hljs-keyword">var</span> replaceRegexp = <span class="hljs-built_in">RegExp</span>(source, <span class="hljs-string">'g'</span>);
    <span class="hljs-keyword">return</span> <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(string)</span> </span>{
      string = string == <span class="hljs-literal">null</span> ? <span class="hljs-string">''</span> : <span class="hljs-string">''</span> + string;
      <span class="hljs-keyword">return</span> testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
    };
  };
  _.escape = createEscaper(escapeMap);
  _.unescape = createEscaper(unescapeMap);</pre></div></div>
            
        </li>
        
        
        <li id="section-163">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-163">&#182;</a>
              </div>
              <p>If the value of the named <code>property</code> is a function then invoke it with the
<code>object</code> as context; otherwise, return it.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.result = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(object, property, fallback)</span> </span>{
    <span class="hljs-keyword">var</span> value = object == <span class="hljs-literal">null</span> ? <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> : object[property];
    <span class="hljs-keyword">if</span> (value === <span class="hljs-keyword">void</span> <span class="hljs-number">0</span>) {
      value = fallback;
    }
    <span class="hljs-keyword">return</span> _.isFunction(value) ? value.call(object) : value;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-164">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-164">&#182;</a>
              </div>
              <p>Generate a unique integer id (unique within the entire client session).
Useful for temporary DOM ids.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> idCounter = <span class="hljs-number">0</span>;
  _.uniqueId = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(prefix)</span> </span>{
    <span class="hljs-keyword">var</span> id = ++idCounter + <span class="hljs-string">''</span>;
    <span class="hljs-keyword">return</span> prefix ? prefix + id : id;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-165">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-165">&#182;</a>
              </div>
              <p>By default, Underscore uses ERB-style template delimiters, change the
following template settings to use alternative delimiters.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.templateSettings = {
    evaluate    : <span class="hljs-regexp">/&lt;%([\s\S]+?)%&gt;/g</span>,
    interpolate : <span class="hljs-regexp">/&lt;%=([\s\S]+?)%&gt;/g</span>,
    <span class="hljs-built_in">escape</span>      : <span class="hljs-regexp">/&lt;%-([\s\S]+?)%&gt;/g</span>
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-166">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-166">&#182;</a>
              </div>
              <p>When customizing <code>templateSettings</code>, if you don’t want to define an
interpolation, evaluation or escaping regex, we need one that is
guaranteed not to match.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> noMatch = <span class="hljs-regexp">/(.)^/</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-167">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-167">&#182;</a>
              </div>
              <p>Certain characters need to be escaped so that they can be put into a
string literal.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> escapes = {
    <span class="hljs-string">"'"</span>:      <span class="hljs-string">"'"</span>,
    <span class="hljs-string">'\\'</span>:     <span class="hljs-string">'\\'</span>,
    <span class="hljs-string">'\r'</span>:     <span class="hljs-string">'r'</span>,
    <span class="hljs-string">'\n'</span>:     <span class="hljs-string">'n'</span>,
    <span class="hljs-string">'\u2028'</span>: <span class="hljs-string">'u2028'</span>,
    <span class="hljs-string">'\u2029'</span>: <span class="hljs-string">'u2029'</span>
  };

  <span class="hljs-keyword">var</span> escaper = <span class="hljs-regexp">/\\|'|\r|\n|\u2028|\u2029/g</span>;

  <span class="hljs-keyword">var</span> escapeChar = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(match)</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">'\\'</span> + escapes[match];
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-168">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-168">&#182;</a>
              </div>
              <p>JavaScript micro-templating, similar to John Resig’s implementation.
Underscore templating handles arbitrary delimiters, preserves whitespace,
and correctly escapes quotes within interpolated code.
NB: <code>oldSettings</code> only exists for backwards compatibility.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.template = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(text, settings, oldSettings)</span> </span>{
    <span class="hljs-keyword">if</span> (!settings &amp;&amp; oldSettings) settings = oldSettings;
    settings = _.defaults({}, settings, _.templateSettings);</pre></div></div>
            
        </li>
        
        
        <li id="section-169">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-169">&#182;</a>
              </div>
              <p>Combine delimiters into one regular expression via alternation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> matcher = <span class="hljs-built_in">RegExp</span>([
      (settings.escape || noMatch).source,
      (settings.interpolate || noMatch).source,
      (settings.evaluate || noMatch).source
    ].join(<span class="hljs-string">'|'</span>) + <span class="hljs-string">'|$'</span>, <span class="hljs-string">'g'</span>);</pre></div></div>
            
        </li>
        
        
        <li id="section-170">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-170">&#182;</a>
              </div>
              <p>Compile the template source, escaping string literals appropriately.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> index = <span class="hljs-number">0</span>;
    <span class="hljs-keyword">var</span> source = <span class="hljs-string">"__p+='"</span>;
    text.replace(matcher, <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(match, escape, interpolate, evaluate, offset)</span> </span>{
      source += text.slice(index, offset).replace(escaper, escapeChar);
      index = offset + match.length;

      <span class="hljs-keyword">if</span> (<span class="hljs-built_in">escape</span>) {
        source += <span class="hljs-string">"'+\n((__t=("</span> + <span class="hljs-built_in">escape</span> + <span class="hljs-string">"))==null?'':_.escape(__t))+\n'"</span>;
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (interpolate) {
        source += <span class="hljs-string">"'+\n((__t=("</span> + interpolate + <span class="hljs-string">"))==null?'':__t)+\n'"</span>;
      } <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (evaluate) {
        source += <span class="hljs-string">"';\n"</span> + evaluate + <span class="hljs-string">"\n__p+='"</span>;
      }</pre></div></div>
            
        </li>
        
        
        <li id="section-171">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-171">&#182;</a>
              </div>
              <p>Adobe VMs need the match returned to produce the correct offest.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>      <span class="hljs-keyword">return</span> match;
    });
    source += <span class="hljs-string">"';\n"</span>;</pre></div></div>
            
        </li>
        
        
        <li id="section-172">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-172">&#182;</a>
              </div>
              <p>If a variable is not specified, place data values in local scope.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">if</span> (!settings.variable) source = <span class="hljs-string">'with(obj||{}){\n'</span> + source + <span class="hljs-string">'}\n'</span>;

    source = <span class="hljs-string">"var __t,__p='',__j=Array.prototype.join,"</span> +
      <span class="hljs-string">"print=function(){__p+=__j.call(arguments,'');};\n"</span> +
      source + <span class="hljs-string">'return __p;\n'</span>;

    <span class="hljs-keyword">try</span> {
      <span class="hljs-keyword">var</span> render = <span class="hljs-keyword">new</span> <span class="hljs-built_in">Function</span>(settings.variable || <span class="hljs-string">'obj'</span>, <span class="hljs-string">'_'</span>, source);
    } <span class="hljs-keyword">catch</span> (e) {
      e.source = source;
      <span class="hljs-keyword">throw</span> e;
    }

    <span class="hljs-keyword">var</span> template = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(data)</span> </span>{
      <span class="hljs-keyword">return</span> render.call(<span class="hljs-keyword">this</span>, data, _);
    };</pre></div></div>
            
        </li>
        
        
        <li id="section-173">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-173">&#182;</a>
              </div>
              <p>Provide the compiled source as a convenience for precompilation.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>    <span class="hljs-keyword">var</span> argument = settings.variable || <span class="hljs-string">'obj'</span>;
    template.source = <span class="hljs-string">'function('</span> + argument + <span class="hljs-string">'){\n'</span> + source + <span class="hljs-string">'}'</span>;

    <span class="hljs-keyword">return</span> template;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-174">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-174">&#182;</a>
              </div>
              <p>Add a “chain” function. Start chaining a wrapped Underscore object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.chain = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    <span class="hljs-keyword">var</span> instance = _(obj);
    instance._chain = <span class="hljs-literal">true</span>;
    <span class="hljs-keyword">return</span> instance;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-175">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-175">&#182;</a>
              </div>
              <h2 id="oop">OOP</h2>

            </div>
            
        </li>
        
        
        <li id="section-176">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-176">&#182;</a>
              </div>
              <p>If Underscore is called as a function, it returns a wrapped object that
can be used OO-style. This wrapper holds altered versions of all the
underscore functions. Wrapped objects may be chained.</p>

            </div>
            
        </li>
        
        
        <li id="section-177">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-177">&#182;</a>
              </div>
              <p>Helper function to continue chaining intermediate results.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">var</span> result = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(instance, obj)</span> </span>{
    <span class="hljs-keyword">return</span> instance._chain ? _(obj).chain() : obj;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-178">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-178">&#182;</a>
              </div>
              <p>Add your own custom functions to the Underscore object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.mixin = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(obj)</span> </span>{
    _.each(_.functions(obj), <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(name)</span> </span>{
      <span class="hljs-keyword">var</span> func = _[name] = obj[name];
      _.prototype[name] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
        <span class="hljs-keyword">var</span> args = [<span class="hljs-keyword">this</span>._wrapped];
        push.apply(args, <span class="hljs-built_in">arguments</span>);
        <span class="hljs-keyword">return</span> result(<span class="hljs-keyword">this</span>, func.apply(_, args));
      };
    });
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-179">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-179">&#182;</a>
              </div>
              <p>Add all of the Underscore functions to the wrapper object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.mixin(_);</pre></div></div>
            
        </li>
        
        
        <li id="section-180">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-180">&#182;</a>
              </div>
              <p>Add all mutator Array functions to the wrapper.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.each([<span class="hljs-string">'pop'</span>, <span class="hljs-string">'push'</span>, <span class="hljs-string">'reverse'</span>, <span class="hljs-string">'shift'</span>, <span class="hljs-string">'sort'</span>, <span class="hljs-string">'splice'</span>, <span class="hljs-string">'unshift'</span>], <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(name)</span> </span>{
    <span class="hljs-keyword">var</span> method = ArrayProto[name];
    _.prototype[name] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">var</span> obj = <span class="hljs-keyword">this</span>._wrapped;
      method.apply(obj, <span class="hljs-built_in">arguments</span>);
      <span class="hljs-keyword">if</span> ((name === <span class="hljs-string">'shift'</span> || name === <span class="hljs-string">'splice'</span>) &amp;&amp; obj.length === <span class="hljs-number">0</span>) <span class="hljs-keyword">delete</span> obj[<span class="hljs-number">0</span>];
      <span class="hljs-keyword">return</span> result(<span class="hljs-keyword">this</span>, obj);
    };
  });</pre></div></div>
            
        </li>
        
        
        <li id="section-181">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-181">&#182;</a>
              </div>
              <p>Add all accessor Array functions to the wrapper.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.each([<span class="hljs-string">'concat'</span>, <span class="hljs-string">'join'</span>, <span class="hljs-string">'slice'</span>], <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">(name)</span> </span>{
    <span class="hljs-keyword">var</span> method = ArrayProto[name];
    _.prototype[name] = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">return</span> result(<span class="hljs-keyword">this</span>, method.apply(<span class="hljs-keyword">this</span>._wrapped, <span class="hljs-built_in">arguments</span>));
    };
  });</pre></div></div>
            
        </li>
        
        
        <li id="section-182">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-182">&#182;</a>
              </div>
              <p>Extracts the result from a wrapped and chained object.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.prototype.value = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-keyword">this</span>._wrapped;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-183">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-183">&#182;</a>
              </div>
              <p>Provide unwrapping proxy for some methods used in engine operations
such as arithmetic and JSON stringification.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;

  _.prototype.toString = <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> <span class="hljs-string">''</span> + <span class="hljs-keyword">this</span>._wrapped;
  };</pre></div></div>
            
        </li>
        
        
        <li id="section-184">
            <div class="annotation">
              
              <div class="pilwrap ">
                <a class="pilcrow" href="#section-184">&#182;</a>
              </div>
              <p>AMD registration happens at the end for compatibility with AMD loaders
that may not enforce next-turn semantics on modules. Even though general
practice for AMD registration is to be anonymous, underscore registers
as a named module because, like jQuery, it is a base library that is
popular enough to be bundled in a third party lib, but not be part of
an AMD load request. Those cases could generate an error when an
anonymous define() is called outside of a loader request.</p>

            </div>
            
            <div class="content"><div class='highlight'><pre>  <span class="hljs-keyword">if</span> (<span class="hljs-keyword">typeof</span> define === <span class="hljs-string">'function'</span> &amp;&amp; define.amd) {
    define(<span class="hljs-string">'underscore'</span>, [], <span class="hljs-function"><span class="hljs-keyword">function</span><span class="hljs-params">()</span> </span>{
      <span class="hljs-keyword">return</span> _;
    });
  }
}.call(<span class="hljs-keyword">this</span>));</pre></div></div>
            
        </li>
        
    </ul>
  </div>
</body>
</html>

You are here