Context Navigation

Back to Ticket #45785

Ticket #45785: 45785.diff

File 45785.diff, 149.8 KB (added by Hareesh Pillai, 5 years ago)
Patch for upgrading underscore to v 1.91.

wp-includes/js/underscore.js

 //     Underscore.js 1.8.3
+//     Underscore.js 1.9.1
 //     http://underscorejs.org
 //     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+//     (c) 2009-2018 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 //     Underscore may be freely distributed under the MIT license.
 (function() {
   // Baseline setup
   // --------------
+        // Baseline setup
+        // --------------
+  // Establish the root object, `window` in the browser, or `exports` on the server.
+  var root = this;
+        // Establish the root object, `window` (`self`) in the browser, `global`
+        // on the server, or `this` in some virtual machines. We use `self`
+        // instead of `window` for `WebWorker` support.
+        var root = typeof self == 'object' && self.self === self && self ||
+                typeof global == 'object' && global.global === global && global ||
+                this || {};
   // Save the previous value of the `_` variable.
   var previousUnderscore = root._;
+        // 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;
+        // Save bytes in the minified (but not gzipped) version:
+        var ArrayProto = Array.prototype,
+                ObjProto = Object.prototype;
+        var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;
+  // Create quick reference variables for speed access to core prototypes.
+  var
+    push             = ArrayProto.push,
+    slice            = ArrayProto.slice,
+    toString         = ObjProto.toString,
+    hasOwnProperty   = ObjProto.hasOwnProperty;
+        // 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;
+        // All **ECMAScript 5** native function implementations that we hope to use
+        // are declared here.
+        var nativeIsArray = Array.isArray,
+                nativeKeys = Object.keys,
+                nativeCreate = Object.create;
   // Naked function reference for surrogate-prototype-swapping.
   var Ctor = function(){};
+        // 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;
   };
+        // 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._ = _;
+  }
+        // Export the Underscore object for **Node.js**, with
+        // backwards-compatibility for their old module API. If we're in
+        // the browser, add `_` as a global object.
+        // (`nodeType` is checked to ensure that `module`
+        // and `exports` are not HTML elements.)
+        if (typeof exports != 'undefined' && !exports.nodeType) {
+                if (typeof module != 'undefined' && !module.nodeType && module.exports) {
+                        exports = module.exports = _;
+                }
+                exports._ = _;
+        } else {
+                root._ = _;
+        }
   // Current version.
   _.VERSION = '1.8.3';
+        // Current version.
+        _.VERSION = '1.9.1';
+  // 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);
+    };
+  };
+        // 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);
+                                };
+                                // The 2-argument case is omitted because we’re not using it.
+                        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);
+  };
+        var builtinIteratee;
+  // 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 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 (_.iteratee !== builtinIteratee) return _.iteratee(value, context);
+                if (value == null) return _.identity;
+                if (_.isFunction(value)) return optimizeCb(value, context, argCount);
+                if (_.isObject(value) && !_.isArray(value)) return _.matcher(value);
+                return _.property(value);
+        };
+  // 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;
+  };
+        // External wrapper for our callback generator. Users may customize
+        // `_.iteratee` if they want additional predicate/iteratee shorthand styles.
+        // This abstraction hides the internal-only argCount argument.
+        _.iteratee = builtinIteratee = function(value, context) {
+                return cb(value, context, Infinity);
+        };
+  var property = function(key) {
+    return function(obj) {
+      return obj == null ? void 0 : obj[key];
+    };
+  };
+        // Some functions take a variable number of arguments, or a few expected
+        // arguments at the beginning and then a variable number of values to operate
+        // on. This helper accumulates all remaining arguments past the function’s
+        // argument length (or an explicit `startIndex`), into an array that becomes
+        // the last argument. Similar to ES6’s "rest parameter".
+        var restArguments = function(func, startIndex) {
+                startIndex = startIndex == null ? func.length - 1 : +startIndex;
+                return function() {
+                        var length = Math.max(arguments.length - startIndex, 0),
+                                rest = Array(length),
+                                index = 0;
+                        for (; index < length; index++) {
+                                rest[index] = arguments[index + startIndex];
+                        }
+                        switch (startIndex) {
+                                case 0:
+                                        return func.call(this, rest);
+                                case 1:
+                                        return func.call(this, arguments[0], rest);
+                                case 2:
+                                        return func.call(this, arguments[0], arguments[1], rest);
+                        }
+                        var args = Array(startIndex + 1);
+                        for (index = 0; index < startIndex; index++) {
+                                args[index] = arguments[index];
+                        }
+                        args[startIndex] = rest;
+                        return func.apply(this, args);
+                };
+        };
+  // 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;
+  };
+        // 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;
+        };
+  // Collection Functions
+  // --------------------
+        var shallowProperty = function(key) {
+                return function(obj) {
+                        return obj == null ? void 0 : obj[key];
+                };
+        };
+  // 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;
+  };
+        var has = function(obj, path) {
+                return obj != null && hasOwnProperty.call(obj, path);
+        }
+  // 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;
+  };
+        var deepGet = function(obj, path) {
+                var length = path.length;
+                for (var i = 0; i < length; i++) {
+                        if (obj == null) return void 0;
+                        obj = obj[path[i]];
+                }
+                return length ? obj : void 0;
+        };
+  // 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;
+    }
+        // 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 = shallowProperty('length');
+        var isArrayLike = function(collection) {
+                var length = getLength(collection);
+                return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
+        };
+    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);
+    };
+  }
+        // Collection Functions
+        // --------------------
+  // **Reduce** builds up a single result from a list of values, aka `inject`,
+  // or `foldl`.
+  _.reduce = _.foldl = _.inject = createReduce(1);
+        // 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;
+        };
+  // The right-associative version of reduce, also known as `foldr`.
+  _.reduceRight = _.foldr = createReduce(-1);
+        // 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;
+        };
+  // 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];
+  };
+        // Create a reducing function iterating left or right.
+        var createReduce = function(dir) {
+                // Wrap code that reassigns argument variables in a separate function than
+                // the one that accesses `arguments.length` to avoid a perf hit. (#1991)
+                var reducer = function(obj, iteratee, memo, initial) {
+                        var keys = !isArrayLike(obj) && _.keys(obj),
+                                length = (keys || obj).length,
+                                index = dir > 0 ? 0 : length - 1;
+                        if (!initial) {
+                                memo = obj[keys ? keys[index] : index];
+                                index += dir;
+                        }
+                        for (; index >= 0 && index < length; index += dir) {
+                                var currentKey = keys ? keys[index] : index;
+                                memo = iteratee(memo, obj[currentKey], currentKey, obj);
+                        }
+                        return memo;
+                };
+  // 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 function(obj, iteratee, memo, context) {
+                        var initial = arguments.length >= 3;
+                        return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);
+                };
+        };
+  // Return all the elements for which a truth test fails.
+  _.reject = function(obj, predicate, context) {
+    return _.filter(obj, _.negate(cb(predicate)), context);
+  };
+        // **Reduce** builds up a single result from a list of values, aka `inject`,
+        // or `foldl`.
+        _.reduce = _.foldl = _.inject = createReduce(1);
+  // 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;
+  };
+        // The right-associative version of reduce, also known as `foldr`.
+        _.reduceRight = _.foldr = createReduce(-1);
+  // 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;
+  };
+        // Return the first value which passes a truth test. Aliased as `detect`.
+        _.find = _.detect = function(obj, predicate, context) {
+                var keyFinder = isArrayLike(obj) ? _.findIndex : _.findKey;
+                var key = keyFinder(obj, predicate, context);
+                if (key !== void 0 && key !== -1) return obj[key];
+        };
+  // 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;
+  };
+        // 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;
+        };
+  // 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);
+    });
+  };
+        // Return all the elements for which a truth test fails.
+        _.reject = function(obj, predicate, context) {
+                return _.filter(obj, _.negate(cb(predicate)), context);
+        };
+  // Convenience version of a common use case of `map`: fetching a property.
+  _.pluck = function(obj, key) {
+    return _.map(obj, _.property(key));
+  };
+        // 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;
+        };
+  // 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));
+  };
+        // 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;
+        };
+  // 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));
+  };
+        // 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;
+        };
+  // 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;
+  };
+        // Invoke a method (with arguments) on every item in a collection.
+        _.invoke = restArguments(function(obj, path, args) {
+                var contextPath, func;
+                if (_.isFunction(path)) {
+                        func = path;
+                } else if (_.isArray(path)) {
+                        contextPath = path.slice(0, -1);
+                        path = path[path.length - 1];
+                }
+                return _.map(obj, function(context) {
+                        var method = func;
+                        if (!method) {
+                                if (contextPath && contextPath.length) {
+                                        context = deepGet(context, contextPath);
+                                }
+                                if (context == null) return void 0;
+                                method = context[path];
+                        }
+                        return method == null ? method : method.apply(context, args);
+                });
+        });
+  // 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;
+  };
+        // Convenience version of a common use case of `map`: fetching a property.
+        _.pluck = function(obj, key) {
+                return _.map(obj, _.property(key));
+        };
+  // Shuffle a collection, using the modern version of the
+  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/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;
+  };
+        // 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));
+        };
+  // 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));
+  };
+        // 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));
+        };
+  // 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');
+  };
+        // Return the maximum element (or element-based computation).
+        _.max = function(obj, iteratee, context) {
+                var result = -Infinity,
+                        lastComputed = -Infinity,
+                        value, computed;
+                if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {
+                        obj = isArrayLike(obj) ? obj : _.values(obj);
+                        for (var i = 0, length = obj.length; i < length; i++) {
+                                value = obj[i];
+                                if (value != null && value > result) {
+                                        result = value;
+                                }
+                        }
+                } else {
+                        iteratee = cb(iteratee, context);
+                        _.each(obj, function(v, index, list) {
+                                computed = iteratee(v, index, list);
+                                if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
+                                        result = v;
+                                        lastComputed = computed;
+                                }
+                        });
+                }
+                return result;
+        };
+  // 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;
+    };
+  };
+        // Return the minimum element (or element-based computation).
+        _.min = function(obj, iteratee, context) {
+                var result = Infinity,
+                        lastComputed = Infinity,
+                        value, computed;
+                if (iteratee == null || typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null) {
+                        obj = isArrayLike(obj) ? obj : _.values(obj);
+                        for (var i = 0, length = obj.length; i < length; i++) {
+                                value = obj[i];
+                                if (value != null && value < result) {
+                                        result = value;
+                                }
+                        }
+                } else {
+                        iteratee = cb(iteratee, context);
+                        _.each(obj, function(v, index, list) {
+                                computed = iteratee(v, index, list);
+                                if (computed < lastComputed || computed === Infinity && result === Infinity) {
+                                        result = v;
+                                        lastComputed = computed;
+                                }
+                        });
+                }
+                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];
+  });
+        // Shuffle a collection.
+        _.shuffle = function(obj) {
+                return _.sample(obj, Infinity);
+        };
+  // 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;
+  });
+        // Sample **n** random values from a collection using the modern version of the
+        // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
+        // 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)];
+                }
+                var sample = isArrayLike(obj) ? _.clone(obj) : _.values(obj);
+                var length = getLength(sample);
+                n = Math.max(Math.min(n, length), 0);
+                var last = length - 1;
+                for (var index = 0; index < n; index++) {
+                        var rand = _.random(index, last);
+                        var temp = sample[index];
+                        sample[index] = sample[rand];
+                        sample[rand] = temp;
+                }
+                return sample.slice(0, n);
+        };
+  // 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;
+  });
+        // Sort the object's values by a criterion produced by an iteratee.
+        _.sortBy = function(obj, iteratee, context) {
+                var index = 0;
+                iteratee = cb(iteratee, context);
+                return _.pluck(_.map(obj, function(value, key, list) {
+                        return {
+                                value: value,
+                                index: index++,
+                                criteria: iteratee(value, key, 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');
+        };
+  // 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);
+  };
+        // An internal function used for aggregate "group by" operations.
+        var group = function(behavior, partition) {
+                return function(obj, iteratee, context) {
+                        var result = partition ? [
+                                [],
+                                []
+                        ] : {};
+                        iteratee = cb(iteratee, context);
+                        _.each(obj, function(value, index) {
+                                var key = iteratee(value, index, obj);
+                                behavior(result, value, key);
+                        });
+                        return result;
+                };
+        };
+  // Return the number of elements in an object.
+  _.size = function(obj) {
+    if (obj == null) return 0;
+    return isArrayLike(obj) ? obj.length : _.keys(obj).length;
+  };
+        // 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];
+        });
+  // 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];
+  };
+        // 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;
+        });
+  // Array Functions
+  // ---------------
+        // 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;
+        });
+  // 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);
+  };
+        var reStrSymbol = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
+        // Safely create a real, live array from anything iterable.
+        _.toArray = function(obj) {
+                if (!obj) return [];
+                if (_.isArray(obj)) return slice.call(obj);
+                if (_.isString(obj)) {
+                        // Keep surrogate pair characters together
+                        return obj.match(reStrSymbol);
+                }
+                if (isArrayLike(obj)) return _.map(obj, _.identity);
+                return _.values(obj);
+        };
+  // 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)));
+  };
+        // Return the number of elements in an object.
+        _.size = function(obj) {
+                if (obj == null) return 0;
+                return isArrayLike(obj) ? obj.length : _.keys(obj).length;
+        };
+  // 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));
+  };
+        // 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 = group(function(result, value, pass) {
+                result[pass ? 0 : 1].push(value);
+        }, true);
+  // 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);
+  };
+        // Array Functions
+        // ---------------
+  // Trim out all falsy values from an array.
+  _.compact = function(array) {
+    return _.filter(array, _.identity);
+  };
+        // 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 || array.length < 1) return n == null ? void 0 : [];
+                if (n == null || guard) return array[0];
+                return _.initial(array, array.length - n);
+        };
+  // 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;
+  };
+        // 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)));
+        };
+  // Flatten out an array, either recursively (by default), or just one level.
+  _.flatten = function(array, shallow) {
+    return flatten(array, shallow, false);
+  };
+        // 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 || array.length < 1) return n == null ? void 0 : [];
+                if (n == null || guard) return array[array.length - 1];
+                return _.rest(array, Math.max(0, array.length - n));
+        };
+  // Return a version of the array that does not contain the specified value(s).
+  _.without = function(array) {
+    return _.difference(array, slice.call(arguments, 1));
+  };
+        // 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);
+        };
+  // 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;
+  };
+        // Trim out all falsy values from an array.
+        _.compact = function(array) {
+                return _.filter(array, Boolean);
+        };
+  // 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));
+  };
+        // Internal implementation of a recursive `flatten` function.
+        var flatten = function(input, shallow, strict, output) {
+                output = output || [];
+                var idx = output.length;
+                for (var i = 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) {
+                                        var j = 0,
+                                                len = value.length;
+                                        while (j < len) output[idx++] = value[j++];
+                                } else {
+                                        flatten(value, shallow, strict, output);
+                                        idx = output.length;
+                                }
+                        } else if (!strict) {
+                                output[idx++] = value;
+                        }
+                }
+                return output;
+        };
+  // 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;
+  };
+        // Flatten out an array, either recursively (by default), or just one level.
+        _.flatten = function(array, shallow) {
+                return flatten(array, shallow, false);
+        };
+  // 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);
+    });
+  };
+        // Return a version of the array that does not contain the specified value(s).
+        _.without = restArguments(function(array, otherArrays) {
+                return _.difference(array, otherArrays);
+        });
+  // Zip together multiple lists into a single array -- elements that share
+  // an index go together.
+  _.zip = function() {
+    return _.unzip(arguments);
+  };
+        // Produce a duplicate-free version of the array. If the array has already
+        // been sorted, you have the option of using a faster algorithm.
+        // The faster algorithm will not work with an iteratee if the iteratee
+        // is not a one-to-one function, so providing an iteratee will disable
+        // the 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 && !iteratee) {
+                                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;
+        };
+  // 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);
+        // Produce an array that contains the union: each distinct element from all of
+        // the passed-in arrays.
+        _.union = restArguments(function(arrays) {
+                return _.uniq(flatten(arrays, true, true));
+        });
+    for (var index = 0; index < length; index++) {
+      result[index] = _.pluck(array, index);
+    }
+    return result;
+  };
+        // 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;
+                        var j;
+                        for (j = 1; j < argsLength; j++) {
+                                if (!_.contains(arguments[j], item)) break;
+                        }
+                        if (j === argsLength) result.push(item);
+                }
+                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;
+  };
+        // Take the difference between one array and a number of other arrays.
+        // Only the elements present in just the first array will remain.
+        _.difference = restArguments(function(array, rest) {
+                rest = flatten(rest, true, true);
+                return _.filter(array, function(value) {
+                        return !_.contains(rest, value);
+                });
+        });
+  // 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;
+    };
+  }
+        // 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);
+  // Returns the first index on an array-like that passes a predicate test
+  _.findIndex = createPredicateIndexFinder(1);
+  _.findLastIndex = createPredicateIndexFinder(-1);
+                for (var index = 0; index < length; index++) {
+                        result[index] = _.pluck(array, index);
+                }
+                return result;
+        };
+  // 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;
+  };
+        // Zip together multiple lists into a single array -- elements that share
+        // an index go together.
+        _.zip = restArguments(_.unzip);
+  // 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;
+    };
+  }
+        // 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. Passing by pairs is the reverse of _.pairs.
+        _.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;
+        };
+  // 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);
+        // Generator function to create the findIndex and findLastIndex functions.
+        var createPredicateIndexFinder = function(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;
+                };
+        };
+  // Generate an integer Array containing an arithmetic progression. A port of
+  // the native Python `range()` function. See
+  // [the Python documentation](http://docs.python.org/library/functions.html#range).
+  _.range = function(start, stop, step) {
+    if (stop == null) {
+      stop = start || 0;
+      start = 0;
+    }
+    step = step || 1;
+        // Returns the first index on an array-like that passes a predicate test.
+        _.findIndex = createPredicateIndexFinder(1);
+        _.findLastIndex = createPredicateIndexFinder(-1);
+    var length = Math.max(Math.ceil((stop - start) / step), 0);
+    var range = Array(length);
+        // 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;
+        };
+    for (var idx = 0; idx < length; idx++, start += step) {
+      range[idx] = start;
+    }
+        // Generator function to create the indexOf and lastIndexOf functions.
+        var createIndexFinder = function(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 range;
+  };
+        // 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);
+  // Function (ahem) Functions
+  // ------------------
+        // Generate an integer Array containing an arithmetic progression. A port of
+        // the native Python `range()` function. See
+        // [the Python documentation](http://docs.python.org/library/functions.html#range).
+        _.range = function(start, stop, step) {
+                if (stop == null) {
+                        stop = start || 0;
+                        start = 0;
+                }
+                if (!step) {
+                        step = stop < start ? -1 : 1;
+                }
+  // 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;
+  };
+                var length = Math.max(Math.ceil((stop - start) / step), 0);
+                var range = Array(length);
+  // 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;
+  };
+                for (var idx = 0; idx < length; idx++, start += step) {
+                        range[idx] = start;
+                }
+  // 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;
+  };
+                return range;
+        };
+  // 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;
   };
+        // Chunk a single array into multiple arrays, each containing `count` or fewer
+        // items.
+        _.chunk = function(array, count) {
+                if (count == null || count < 1) return [];
+                var result = [];
+                var i = 0,
+                        length = array.length;
+                while (i < length) {
+                        result.push(slice.call(array, i, i += count));
+                }
+                return result;
+        };
+  // 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;
+  };
+        // Function (ahem) Functions
+        // ------------------
+  // 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);
+  };
+        // 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;
+        };
+  // Defers a function, scheduling it to run after the current call stack has
+  // cleared.
+  _.defer = _.partial(_.delay, _, 1);
+        // Create a function bound to a given object (assigning `this`, and arguments,
+        // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+        // available.
+        _.bind = restArguments(function(func, context, args) {
+                if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
+                var bound = restArguments(function(callArgs) {
+                        return executeBound(func, bound, context, this, args.concat(callArgs));
+                });
+                return bound;
+        });
+  // 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;
+    };
+  };
+        // 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 by default, allowing any combination of arguments to be
+        // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.
+        _.partial = restArguments(function(func, boundArgs) {
+                var placeholder = _.partial.placeholder;
+                var bound = function() {
+                        var position = 0,
+                                length = boundArgs.length;
+                        var args = Array(length);
+                        for (var i = 0; i < length; i++) {
+                                args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];
+                        }
+                        while (position < arguments.length) args.push(arguments[position++]);
+                        return executeBound(func, bound, this, this, args);
+                };
+                return bound;
+        });
+  // 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;
+        _.partial.placeholder = _;
+    var later = function() {
+      var last = _.now() - timestamp;
+        // 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 = restArguments(function(obj, keys) {
+                keys = flatten(keys, false, false);
+                var index = keys.length;
+                if (index < 1) throw new Error('bindAll must be passed function names');
+                while (index--) {
+                        var key = keys[index];
+                        obj[key] = _.bind(obj[key], obj);
+                }
+        });
+      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;
+        }
+      }
+    };
+        // 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;
+        };
+    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;
+      }
+        // Delays a function for the given number of milliseconds, and then calls
+        // it with the arguments supplied.
+        _.delay = restArguments(function(func, wait, args) {
+                return setTimeout(function() {
+                        return func.apply(null, args);
+                }, wait);
+        });
+      return result;
+    };
   };
+        // Defers a function, scheduling it to run after the current call stack has
+        // cleared.
+        _.defer = _.partial(_.delay, _, 1);
+  // 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 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 timeout, context, args, result;
+                var previous = 0;
+                if (!options) options = {};
+  // Returns a negated version of the passed-in predicate.
+  _.negate = function(predicate) {
+    return function() {
       return !predicate.apply(this, arguments);
     };
   };
+                var later = function() {
+                        previous = options.leading === false ? 0 : _.now();
+                        timeout = null;
+                        result = func.apply(context, args);
+                        if (!timeout) context = args = null;
+                };
+  // 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;
+    };
+  };
+                var throttled = 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 will only be executed on and after the Nth call.
+  _.after = function(times, func) {
+    return function() {
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
+    };
+  };
+                throttled.cancel = function() {
+                        clearTimeout(timeout);
+                        previous = 0;
+                        timeout = context = args = null;
+                };
+  // 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;
+    };
+  };
+                return throttled;
+        };
+  // 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);
+        // 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, result;
+  // Object Functions
+  // ----------------
+                var later = function(context, args) {
+                        timeout = null;
+                        if (args) result = func.apply(context, args);
+                };
+  // 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'];
+                var debounced = restArguments(function(args) {
+                        if (timeout) clearTimeout(timeout);
+                        if (immediate) {
+                                var callNow = !timeout;
+                                timeout = setTimeout(later, wait);
+                                if (callNow) result = func.apply(this, args);
+                        } else {
+                                timeout = _.delay(later, wait, this, args);
+                        }
+  function collectNonEnumProps(obj, keys) {
+    var nonEnumIdx = nonEnumerableProps.length;
+    var constructor = obj.constructor;
+    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;
+                        return result;
+                });
+    // Constructor is a special case.
+    var prop = 'constructor';
+    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);
+                debounced.cancel = function() {
+                        clearTimeout(timeout);
+                        timeout = null;
+                };
+    while (nonEnumIdx--) {
+      prop = nonEnumerableProps[nonEnumIdx];
+      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
+        keys.push(prop);
+      }
+    }
+  }
+                return debounced;
+        };
+  // 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;
+  };
+        // 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);
+        };
+  // 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;
+  };
+        // Returns a negated version of the passed-in predicate.
+        _.negate = function(predicate) {
+                return function() {
+                        return !predicate.apply(this, arguments);
+                };
+        };
+  // 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 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 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;
+  };
+        // 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);
+                        }
+                };
+        };
+  // 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;
+  };
+        // 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;
+                };
+        };
+  // 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;
+  };
+        // 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);
+  // 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();
+  };
+        _.restArguments = restArguments;
+  // Extend a given object with all the properties in passed-in object(s).
+  _.extend = createAssigner(_.allKeys);
+        // Object Functions
+        // ----------------
+  // 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);
+        // 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'
+        ];
+  // 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;
+    }
+  };
+        var collectNonEnumProps = function(obj, keys) {
+                var nonEnumIdx = nonEnumerableProps.length;
+                var constructor = obj.constructor;
+                var proto = _.isFunction(constructor) && constructor.prototype || ObjProto;
+  // 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;
+  };
+                // Constructor is a special case.
+                var prop = 'constructor';
+                if (has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);
+   // 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);
+  };
+                while (nonEnumIdx--) {
+                        prop = nonEnumerableProps[nonEnumIdx];
+                        if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
+                                keys.push(prop);
+                        }
+                }
+        };
+  // Fill in a given object with default properties.
+  _.defaults = createAssigner(_.allKeys, true);
+        // 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;
+        };
+  // 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;
+  };
+        // 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;
+        };
+  // Create a (shallow-cloned) duplicate of an object.
+  _.clone = function(obj) {
+    if (!_.isObject(obj)) return obj;
+    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
+  };
+        // 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;
+        };
+  // 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 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 = {};
+                for (var index = 0; index < length; index++) {
+                        var currentKey = keys[index];
+                        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
+                }
+                return results;
+        };
   // 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;
   };
+        // Convert an object into a list of `[key, value]` pairs.
+        // The opposite of _.object.
+        _.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;
+        };
+  // 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](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+    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]':
+        // `NaN`s 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;
+    }
+        // 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();
+        };
+    var areArrays = className === '[object Array]';
+    if (!areArrays) {
+      if (typeof a != 'object' || typeof b != 'object') return false;
+        // An internal function for creating assigner functions.
+        var createAssigner = function(keysFunc, defaults) {
+                return function(obj) {
+                        var length = arguments.length;
+                        if (defaults) obj = Object(obj);
+                        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 (!defaults || obj[key] === void 0) obj[key] = source[key];
+                                }
+                        }
+                        return obj;
+                };
+        };
+      // Objects with different constructors are not equivalent, but `Object`s or `Array`s
+      // 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`.
+        // Extend a given object with all the properties in passed-in object(s).
+        _.extend = createAssigner(_.allKeys);
+    // 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;
+    }
+        // 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);
+    // Add the first object to the stack of traversed objects.
+    aStack.push(a);
+    bStack.push(b);
+        // 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;
+                }
+        };
+    // 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;
+  };
+        // Internal pick helper function to determine if `obj` has key `key`.
+        var keyInObj = function(value, key, obj) {
+                return key in obj;
+        };
+  // Perform a deep comparison to check if two objects are equal.
+  _.isEqual = function(a, b) {
+    return eq(a, b);
+  };
+        // Return a copy of the object only containing the whitelisted properties.
+        _.pick = restArguments(function(obj, keys) {
+                var result = {},
+                        iteratee = keys[0];
+                if (obj == null) return result;
+                if (_.isFunction(iteratee)) {
+                        if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);
+                        keys = _.allKeys(obj);
+                } else {
+                        iteratee = keyInObj;
+                        keys = flatten(keys, false, false);
+                        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;
+        });
+  // 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;
+  };
+        // Return a copy of the object without the blacklisted properties.
+        _.omit = restArguments(function(obj, keys) {
+                var iteratee = keys[0],
+                        context;
+                if (_.isFunction(iteratee)) {
+                        iteratee = _.negate(iteratee);
+                        if (keys.length > 1) context = keys[1];
+                } else {
+                        keys = _.map(flatten(keys, false, false), String);
+                        iteratee = function(value, key) {
+                                return !_.contains(keys, key);
+                        };
+                }
+                return _.pick(obj, iteratee, context);
+        });
+  // Is a given value a DOM element?
+  _.isElement = function(obj) {
+    return !!(obj && obj.nodeType === 1);
+  };
+        // Fill in a given object with default properties.
+        _.defaults = createAssigner(_.allKeys, true);
+  // Is a given value an array?
+  // Delegates to ECMA5's native Array.isArray
+  _.isArray = nativeIsArray || function(obj) {
+    return toString.call(obj) === '[object Array]';
+  };
+        // 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;
+        };
+  // Is a given variable an object?
   _.isObject = function(obj) {
     var type = typeof obj;
     return type === 'function' || type === 'object' && !!obj;
   };
+        // Create a (shallow-cloned) duplicate of an object.
+        _.clone = function(obj) {
+                if (!_.isObject(obj)) return obj;
+                return _.isArray(obj) ? obj.slice() : _.extend({}, 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 + ']';
+    };
+  });
+        // 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;
+        };
+  // 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');
+    };
+  }
+        // 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;
+        };
-  // 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));
+  };
+        // Internal recursive comparison function for `isEqual`.
+        var eq, deepEq;
+        eq = function(a, b, aStack, bStack) {
+                // Identical objects are equal. `0 === -0`, but they aren't identical.
+                // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
+                if (a === b) return a !== 0 || 1 / a === 1 / b;
+                // `null` or `undefined` only equal to itself (strict comparison).
+                if (a == null || b == null) return false;
+                // `NaN`s are equivalent, but non-reflexive.
+                if (a !== a) return b !== b;
+                // Exhaust primitive checks
+                var type = typeof a;
+                if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
+                return deepEq(a, b, aStack, bStack);
+        };
+  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
+  _.isNaN = function(obj) {
+    return _.isNumber(obj) && obj !== +obj;
+  };
+        // Internal recursive comparison function for `isEqual`.
+        deepEq = function(a, b, aStack, bStack) {
+                // 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]':
+                                // `NaN`s 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;
+                        case '[object Symbol]':
+                                return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);
+                }
+  // Is a given value a boolean?
+  _.isBoolean = function(obj) {
+    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
+  };
+                var areArrays = className === '[object Array]';
+                if (!areArrays) {
+                        if (typeof a != 'object' || typeof b != 'object') return false;
+  // Is a given value equal to null?
+  _.isNull = function(obj) {
+    return obj === null;
+  };
+                        // Objects with different constructors are not equivalent, but `Object`s or `Array`s
+                        // 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`.
+  // Is a given variable undefined?
+  _.isUndefined = function(obj) {
+    return obj === void 0;
+  };
+                // 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;
+                }
+  // 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);
+  };
+                // Add the first object to the stack of traversed objects.
+                aStack.push(a);
+                bStack.push(b);
+  // Utility Functions
+  // -----------------
+                // 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;
+        };
+  // 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;
+  };
+        // Perform a deep comparison to check if two objects are equal.
+        _.isEqual = function(a, b) {
+                return eq(a, b);
+        };
+  // Keep the identity function around for default iteratees.
+  _.identity = function(value) {
+    return value;
+  };
+        // 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;
+        };
+  // Predicate-generating functions. Often useful outside of Underscore.
+  _.constant = function(value) {
+    return function() {
+      return value;
+    };
+  };
+        // Is a given value a DOM element?
+        _.isElement = function(obj) {
+                return !!(obj && obj.nodeType === 1);
+        };
+  _.noop = function(){};
+        // Is a given value an array?
+        // Delegates to ECMA5's native Array.isArray
+        _.isArray = nativeIsArray || function(obj) {
+                return toString.call(obj) === '[object Array]';
+        };
+  _.property = property;
+        // Is a given variable an object?
+        _.isObject = function(obj) {
+                var type = typeof obj;
+                return type === 'function' || type === 'object' && !!obj;
+        };
   // Generates a function for a given object that returns a given property.
   _.propertyOf = function(obj) {
     return obj == null ? function(){} : function(key) {
       return obj[key];
     };
   };
+        // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError, isMap, isWeakMap, isSet, isWeakSet.
+        _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error', 'Symbol', 'Map', 'WeakMap', 'Set', 'WeakSet'], function(name) {
+                _['is' + name] = function(obj) {
+                        return toString.call(obj) === '[object ' + name + ']';
+                };
+        });
+  // 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);
+    };
+  };
+        // 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');
+                };
+        }
+  // 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;
+  };
+        // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,
+        // IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).
+        var nodelist = root.document && root.document.childNodes;
+        if (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {
+                _.isFunction = function(obj) {
+                        return typeof obj == 'function' || false;
+                };
+        }
+  // 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));
+  };
+        // Is a given object a finite number?
+        _.isFinite = function(obj) {
+                return !_.isSymbol(obj) && isFinite(obj) && !isNaN(parseFloat(obj));
+        };
+  // A (possibly faster) way to get the current timestamp as an integer.
   _.now = Date.now || function() {
     return new Date().getTime();
   };
+        // Is the given value `NaN`?
+        _.isNaN = function(obj) {
+                return _.isNumber(obj) && isNaN(obj);
+        };
+   // List of HTML entities for escaping.
+  var escapeMap = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#x27;',
+    '`': '&#x60;'
+  };
+  var unescapeMap = _.invert(escapeMap);
+        // Is a given value a boolean?
+        _.isBoolean = function(obj) {
+                return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
+        };
+  // 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);
+        // Is a given value equal to null?
+        _.isNull = function(obj) {
+                return obj === null;
+        };
+  // 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;
+  };
+        // Is a given variable undefined?
+        _.isUndefined = function(obj) {
+                return obj === void 0;
+        };
+  // 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;
+  };
+        // Shortcut function for checking if an object has a given property directly
+        // on itself (in other words, not on a prototype).
+        _.has = function(obj, path) {
+                if (!_.isArray(path)) {
+                        return has(obj, path);
+                }
+                var length = path.length;
+                for (var i = 0; i < length; i++) {
+                        var key = path[i];
+                        if (obj == null || !hasOwnProperty.call(obj, key)) {
+                                return false;
+                        }
+                        obj = obj[key];
+                }
+                return !!length;
+        };
+  // 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
+  };
+        // Utility Functions
+        // -----------------
+  // 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 = /(.)^/;
+        // 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;
+        };
+  // 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'
+  };
+        // Keep the identity function around for default iteratees.
+        _.identity = function(value) {
+                return value;
+        };
+  var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
+        // Predicate-generating functions. Often useful outside of Underscore.
+        _.constant = function(value) {
+                return function() {
+                        return value;
+                };
+        };
+  var escapeChar = function(match) {
+    return '\\' + escapes[match];
+  };
+        _.noop = function() {};
+  // 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);
+        // Creates a function that, when passed an object, will traverse that object’s
+        // properties down the given `path`, specified as an array of keys or indexes.
+        _.property = function(path) {
+                if (!_.isArray(path)) {
+                        return shallowProperty(path);
+                }
+                return function(obj) {
+                        return deepGet(obj, path);
+                };
+        };
+    // 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');
+        // Generates a function for a given object that returns a given property.
+        _.propertyOf = function(obj) {
+                if (obj == null) {
+                        return function() {};
+                }
+                return function(path) {
+                        return !_.isArray(path) ? obj[path] : deepGet(obj, path);
+                };
+        };
+    // 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;
+        // 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);
+                };
+        };
+      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+='";
+      }
+        // 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;
+        };
+      // Adobe VMs need the match returned to produce the correct offest.
+      return match;
+    });
+    source += "';\n";
+        // 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));
+        };
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+        // A (possibly faster) way to get the current timestamp as an integer.
+        _.now = Date.now || function() {
+                return new Date().getTime();
+        };
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + 'return __p;\n';
+        // List of HTML entities for escaping.
+        var escapeMap = {
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '"': '&quot;',
+                "'": '&#x27;',
+                '`': '&#x60;'
+        };
+        var unescapeMap = _.invert(escapeMap);
+    try {
+      var render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+        // 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);
+    var template = function(data) {
+      return render.call(this, data, _);
+    };
+        // Traverses the children of `obj` along `path`. If a child is a function, it
+        // is invoked with its parent as context. Returns the value of the final
+        // child, or `fallback` if any child is undefined.
+        _.result = function(obj, path, fallback) {
+                if (!_.isArray(path)) path = [path];
+                var length = path.length;
+                if (!length) {
+                        return _.isFunction(fallback) ? fallback.call(obj) : fallback;
+                }
+                for (var i = 0; i < length; i++) {
+                        var prop = obj == null ? void 0 : obj[path[i]];
+                        if (prop === void 0) {
+                                prop = fallback;
+                                i = length; // Ensure we don't continue iterating.
+                        }
+                        obj = _.isFunction(prop) ? prop.call(obj) : prop;
+                }
+                return obj;
+        };
+    // Provide the compiled source as a convenience for precompilation.
+    var argument = settings.variable || 'obj';
+    template.source = 'function(' + argument + '){\n' + source + '}';
+        // 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;
+        };
+    return template;
+  };
+        // 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
+        };
+  // Add a "chain" function. Start chaining a wrapped Underscore object.
+  _.chain = function(obj) {
+    var instance = _(obj);
+    instance._chain = true;
+    return instance;
+  };
+        // 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 = /(.)^/;
+  // 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.
+        // 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'
+        };
+  // Helper function to continue chaining intermediate results.
+  var result = function(instance, obj) {
+    return instance._chain ? _(obj).chain() : obj;
+  };
+        var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;
+  // 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));
+      };
+    });
+  };
+        var escapeChar = function(match) {
+                return '\\' + escapes[match];
+        };
+  // Add all of the Underscore functions to the wrapper object.
+  _.mixin(_);
+        // 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);
+  // 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);
+    };
+  });
+                // 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');
+  // 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));
+    };
+  });
+                // 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(escapeRegExp, escapeChar);
+                        index = offset + match.length;
+  // Extracts the result from a wrapped and chained object.
+  _.prototype.value = function() {
+    return this._wrapped;
+  };
+                        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+='";
+                        }
+  // Provide unwrapping proxy for some methods used in engine operations
+  // such as arithmetic and JSON stringification.
+  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;
+                        // Adobe VMs need the match returned to produce the correct offset.
+                        return match;
+                });
+                source += "';\n";
+  _.prototype.toString = function() {
+    return '' + this._wrapped;
+  };
+                // If a variable is not specified, place data values in local scope.
+                if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+  // 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));
+                source = "var __t,__p='',__j=Array.prototype.join," +
+                        "print=function(){__p+=__j.call(arguments,'');};\n" +
+                        source + 'return __p;\n';
+                var render;
+                try {
+                        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 chainResult = 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 chainResult(this, func.apply(_, args));
+                        };
+                });
+                return _;
+        };
+        // 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 chainResult(this, obj);
+                };
+        });
+        // Add all accessor Array functions to the wrapper.
+        _.each(['concat', 'join', 'slice'], function(name) {
+                var method = ArrayProto[name];
+                _.prototype[name] = function() {
+                        return chainResult(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 String(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 _;
+                });
+        }
+}());
+ No newline at end of file

wp-includes/js/underscore.min.js

+(function(){function a(a){function b(b,c,d,e,f,g){for(;f>=0&&f<g;f+=a){var h=e?e[f]:f;d=c(d,b[h],h,b)}return d}return function(c,d,e,f){d=t(d,f,4);var g=!A(c)&&s.keys(c),h=(g||c).length,i=a>0?0:h-1;return arguments.length<3&&(e=c[g?g[i]:i],i+=a),b(c,d,e,g,i,h)}}function b(a){return function(b,c,d){c=u(c,d);for(var e=z(b),f=a>0?0:e-1;f>=0&&f<e;f+=a)if(c(b[f],f,b))return f;return-1}}function c(a,b,c){return function(d,e,f){var g=0,h=z(d);if("number"==typeof f)a>0?g=f>=0?f:Math.max(f+h,g):h=f>=0?Math.min(f+1,h):f+h+1;else if(c&&f&&h)return f=c(d,e),d[f]===e?f:-1;if(e!==e)return f=b(k.call(d,g,h),s.isNaN),f>=0?f+g:-1;for(f=a>0?g:h-1;f>=0&&f<h;f+=a)if(d[f]===e)return f;return-1}}function d(a,b){var c=F.length,d=a.constructor,e=s.isFunction(d)&&d.prototype||h,f="constructor";for(s.has(a,f)&&!s.contains(b,f)&&b.push(f);c--;)f=F[c],f in a&&a[f]!==e[f]&&!s.contains(b,f)&&b.push(f)}var e=this,f=e._,g=Array.prototype,h=Object.prototype,i=Function.prototype,j=g.push,k=g.slice,l=h.toString,m=h.hasOwnProperty,n=Array.isArray,o=Object.keys,p=i.bind,q=Object.create,r=function(){},s=function(a){return a instanceof s?a:this instanceof s?void(this._wrapped=a):new s(a)};"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=s),exports._=s):e._=s,s.VERSION="1.8.3";var t=function(a,b,c){if(void 0===b)return a;switch(null==c?3:c){case 1:return function(c){return a.call(b,c)};case 2:return function(c,d){return a.call(b,c,d)};case 3:return function(c,d,e){return a.call(b,c,d,e)};case 4:return function(c,d,e,f){return a.call(b,c,d,e,f)}}return function(){return a.apply(b,arguments)}},u=function(a,b,c){return null==a?s.identity:s.isFunction(a)?t(a,b,c):s.isObject(a)?s.matcher(a):s.property(a)};s.iteratee=function(a,b){return u(a,b,1/0)};var v=function(a,b){return function(c){var d=arguments.length;if(d<2||null==c)return c;for(var e=1;e<d;e++)for(var f=arguments[e],g=a(f),h=g.length,i=0;i<h;i++){var j=g[i];b&&void 0!==c[j]||(c[j]=f[j])}return c}},w=function(a){if(!s.isObject(a))return{};if(q)return q(a);r.prototype=a;var b=new r;return r.prototype=null,b},x=function(a){return function(b){return null==b?void 0:b[a]}},y=Math.pow(2,53)-1,z=x("length"),A=function(a){var b=z(a);return"number"==typeof b&&b>=0&&b<=y};s.each=s.forEach=function(a,b,c){b=t(b,c);var d,e;if(A(a))for(d=0,e=a.length;d<e;d++)b(a[d],d,a);else{var f=s.keys(a);for(d=0,e=f.length;d<e;d++)b(a[f[d]],f[d],a)}return a},s.map=s.collect=function(a,b,c){b=u(b,c);for(var d=!A(a)&&s.keys(a),e=(d||a).length,f=Array(e),g=0;g<e;g++){var h=d?d[g]:g;f[g]=b(a[h],h,a)}return f},s.reduce=s.foldl=s.inject=a(1),s.reduceRight=s.foldr=a(-1),s.find=s.detect=function(a,b,c){var d;if(d=A(a)?s.findIndex(a,b,c):s.findKey(a,b,c),void 0!==d&&d!==-1)return a[d]},s.filter=s.select=function(a,b,c){var d=[];return b=u(b,c),s.each(a,function(a,c,e){b(a,c,e)&&d.push(a)}),d},s.reject=function(a,b,c){return s.filter(a,s.negate(u(b)),c)},s.every=s.all=function(a,b,c){b=u(b,c);for(var d=!A(a)&&s.keys(a),e=(d||a).length,f=0;f<e;f++){var g=d?d[f]:f;if(!b(a[g],g,a))return!1}return!0},s.some=s.any=function(a,b,c){b=u(b,c);for(var d=!A(a)&&s.keys(a),e=(d||a).length,f=0;f<e;f++){var g=d?d[f]:f;if(b(a[g],g,a))return!0}return!1},s.contains=s.includes=s.include=function(a,b,c,d){return A(a)||(a=s.values(a)),("number"!=typeof c||d)&&(c=0),s.indexOf(a,b,c)>=0},s.invoke=function(a,b){var c=k.call(arguments,2),d=s.isFunction(b);return s.map(a,function(a){var e=d?b:a[b];return null==e?e:e.apply(a,c)})},s.pluck=function(a,b){return s.map(a,s.property(b))},s.where=function(a,b){return s.filter(a,s.matcher(b))},s.findWhere=function(a,b){return s.find(a,s.matcher(b))},s.max=function(a,b,c){var d,e,f=-(1/0),g=-(1/0);if(null==b&&null!=a){a=A(a)?a:s.values(a);for(var h=0,i=a.length;h<i;h++)d=a[h],d>f&&(f=d)}else b=u(b,c),s.each(a,function(a,c,d){e=b(a,c,d),(e>g||e===-(1/0)&&f===-(1/0))&&(f=a,g=e)});return f},s.min=function(a,b,c){var d,e,f=1/0,g=1/0;if(null==b&&null!=a){a=A(a)?a:s.values(a);for(var h=0,i=a.length;h<i;h++)d=a[h],d<f&&(f=d)}else b=u(b,c),s.each(a,function(a,c,d){e=b(a,c,d),(e<g||e===1/0&&f===1/0)&&(f=a,g=e)});return f},s.shuffle=function(a){for(var b,c=A(a)?a:s.values(a),d=c.length,e=Array(d),f=0;f<d;f++)b=s.random(0,f),b!==f&&(e[f]=e[b]),e[b]=c[f];return e},s.sample=function(a,b,c){return null==b||c?(A(a)||(a=s.values(a)),a[s.random(a.length-1)]):s.shuffle(a).slice(0,Math.max(0,b))},s.sortBy=function(a,b,c){return b=u(b,c),s.pluck(s.map(a,function(a,c,d){return{value:a,index:c,criteria:b(a,c,d)}}).sort(function(a,b){var c=a.criteria,d=b.criteria;if(c!==d){if(c>d||void 0===c)return 1;if(c<d||void 0===d)return-1}return a.index-b.index}),"value")};var B=function(a){return function(b,c,d){var e={};return c=u(c,d),s.each(b,function(d,f){var g=c(d,f,b);a(e,d,g)}),e}};s.groupBy=B(function(a,b,c){s.has(a,c)?a[c].push(b):a[c]=[b]}),s.indexBy=B(function(a,b,c){a[c]=b}),s.countBy=B(function(a,b,c){s.has(a,c)?a[c]++:a[c]=1}),s.toArray=function(a){return a?s.isArray(a)?k.call(a):A(a)?s.map(a,s.identity):s.values(a):[]},s.size=function(a){return null==a?0:A(a)?a.length:s.keys(a).length},s.partition=function(a,b,c){b=u(b,c);var d=[],e=[];return s.each(a,function(a,c,f){(b(a,c,f)?d:e).push(a)}),[d,e]},s.first=s.head=s.take=function(a,b,c){if(null!=a)return null==b||c?a[0]:s.initial(a,a.length-b)},s.initial=function(a,b,c){return k.call(a,0,Math.max(0,a.length-(null==b||c?1:b)))},s.last=function(a,b,c){if(null!=a)return null==b||c?a[a.length-1]:s.rest(a,Math.max(0,a.length-b))},s.rest=s.tail=s.drop=function(a,b,c){return k.call(a,null==b||c?1:b)},s.compact=function(a){return s.filter(a,s.identity)};var C=function(a,b,c,d){for(var e=[],f=0,g=d||0,h=z(a);g<h;g++){var i=a[g];if(A(i)&&(s.isArray(i)||s.isArguments(i))){b||(i=C(i,b,c));var j=0,k=i.length;for(e.length+=k;j<k;)e[f++]=i[j++]}else c||(e[f++]=i)}return e};s.flatten=function(a,b){return C(a,b,!1)},s.without=function(a){return s.difference(a,k.call(arguments,1))},s.uniq=s.unique=function(a,b,c,d){s.isBoolean(b)||(d=c,c=b,b=!1),null!=c&&(c=u(c,d));for(var e=[],f=[],g=0,h=z(a);g<h;g++){var i=a[g],j=c?c(i,g,a):i;b?(g&&f===j||e.push(i),f=j):c?s.contains(f,j)||(f.push(j),e.push(i)):s.contains(e,i)||e.push(i)}return e},s.union=function(){return s.uniq(C(arguments,!0,!0))},s.intersection=function(a){for(var b=[],c=arguments.length,d=0,e=z(a);d<e;d++){var f=a[d];if(!s.contains(b,f)){for(var g=1;g<c&&s.contains(arguments[g],f);g++);g===c&&b.push(f)}}return b},s.difference=function(a){var b=C(arguments,!0,!0,1);return s.filter(a,function(a){return!s.contains(b,a)})},s.zip=function(){return s.unzip(arguments)},s.unzip=function(a){for(var b=a&&s.max(a,z).length||0,c=Array(b),d=0;d<b;d++)c[d]=s.pluck(a,d);return c},s.object=function(a,b){for(var c={},d=0,e=z(a);d<e;d++)b?c[a[d]]=b[d]:c[a[d][0]]=a[d][1];return c},s.findIndex=b(1),s.findLastIndex=b(-1),s.sortedIndex=function(a,b,c,d){c=u(c,d,1);for(var e=c(b),f=0,g=z(a);f<g;){var h=Math.floor((f+g)/2);c(a[h])<e?f=h+1:g=h}return f},s.indexOf=c(1,s.findIndex,s.sortedIndex),s.lastIndexOf=c(-1,s.findLastIndex),s.range=function(a,b,c){null==b&&(b=a||0,a=0),c=c||1;for(var d=Math.max(Math.ceil((b-a)/c),0),e=Array(d),f=0;f<d;f++,a+=c)e[f]=a;return e};var D=function(a,b,c,d,e){if(!(d instanceof b))return a.apply(c,e);var f=w(a.prototype),g=a.apply(f,e);return s.isObject(g)?g:f};s.bind=function(a,b){if(p&&a.bind===p)return p.apply(a,k.call(arguments,1));if(!s.isFunction(a))throw new TypeError("Bind must be called on a function");var c=k.call(arguments,2),d=function(){return D(a,d,b,this,c.concat(k.call(arguments)))};return d},s.partial=function(a){var b=k.call(arguments,1),c=function(){for(var d=0,e=b.length,f=Array(e),g=0;g<e;g++)f[g]=b[g]===s?arguments[d++]:b[g];for(;d<arguments.length;)f.push(arguments[d++]);return D(a,c,this,this,f)};return c},s.bindAll=function(a){var b,c,d=arguments.length;if(d<=1)throw new Error("bindAll must be passed function names");for(b=1;b<d;b++)c=arguments[b],a[c]=s.bind(a[c],a);return a},s.memoize=function(a,b){var c=function(d){var e=c.cache,f=""+(b?b.apply(this,arguments):d);return s.has(e,f)||(e[f]=a.apply(this,arguments)),e[f]};return c.cache={},c},s.delay=function(a,b){var c=k.call(arguments,2);return setTimeout(function(){return a.apply(null,c)},b)},s.defer=s.partial(s.delay,s,1),s.throttle=function(a,b,c){var d,e,f,g=null,h=0;c||(c={});var i=function(){h=c.leading===!1?0:s.now(),g=null,f=a.apply(d,e),g||(d=e=null)};return function(){var j=s.now();h||c.leading!==!1||(h=j);var k=b-(j-h);return d=this,e=arguments,k<=0||k>b?(g&&(clearTimeout(g),g=null),h=j,f=a.apply(d,e),g||(d=e=null)):g||c.trailing===!1||(g=setTimeout(i,k)),f}},s.debounce=function(a,b,c){var d,e,f,g,h,i=function(){var j=s.now()-g;j<b&&j>=0?d=setTimeout(i,b-j):(d=null,c||(h=a.apply(f,e),d||(f=e=null)))};return function(){f=this,e=arguments,g=s.now();var j=c&&!d;return d||(d=setTimeout(i,b)),j&&(h=a.apply(f,e),f=e=null),h}},s.wrap=function(a,b){return s.partial(b,a)},s.negate=function(a){return function(){return!a.apply(this,arguments)}},s.compose=function(){var a=arguments,b=a.length-1;return function(){for(var c=b,d=a[b].apply(this,arguments);c--;)d=a[c].call(this,d);return d}},s.after=function(a,b){return function(){if(--a<1)return b.apply(this,arguments)}},s.before=function(a,b){var c;return function(){return--a>0&&(c=b.apply(this,arguments)),a<=1&&(b=null),c}},s.once=s.partial(s.before,2);var E=!{toString:null}.propertyIsEnumerable("toString"),F=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"];s.keys=function(a){if(!s.isObject(a))return[];if(o)return o(a);var b=[];for(var c in a)s.has(a,c)&&b.push(c);return E&&d(a,b),b},s.allKeys=function(a){if(!s.isObject(a))return[];var b=[];for(var c in a)b.push(c);return E&&d(a,b),b},s.values=function(a){for(var b=s.keys(a),c=b.length,d=Array(c),e=0;e<c;e++)d[e]=a[b[e]];return d},s.mapObject=function(a,b,c){b=u(b,c);for(var d,e=s.keys(a),f=e.length,g={},h=0;h<f;h++)d=e[h],g[d]=b(a[d],d,a);return g},s.pairs=function(a){for(var b=s.keys(a),c=b.length,d=Array(c),e=0;e<c;e++)d[e]=[b[e],a[b[e]]];return d},s.invert=function(a){for(var b={},c=s.keys(a),d=0,e=c.length;d<e;d++)b[a[c[d]]]=c[d];return b},s.functions=s.methods=function(a){var b=[];for(var c in a)s.isFunction(a[c])&&b.push(c);return b.sort()},s.extend=v(s.allKeys),s.extendOwn=s.assign=v(s.keys),s.findKey=function(a,b,c){b=u(b,c);for(var d,e=s.keys(a),f=0,g=e.length;f<g;f++)if(d=e[f],b(a[d],d,a))return d},s.pick=function(a,b,c){var d,e,f={},g=a;if(null==g)return f;s.isFunction(b)?(e=s.allKeys(g),d=t(b,c)):(e=C(arguments,!1,!1,1),d=function(a,b,c){return b in c},g=Object(g));for(var h=0,i=e.length;h<i;h++){var j=e[h],k=g[j];d(k,j,g)&&(f[j]=k)}return f},s.omit=function(a,b,c){if(s.isFunction(b))b=s.negate(b);else{var d=s.map(C(arguments,!1,!1,1),String);b=function(a,b){return!s.contains(d,b)}}return s.pick(a,b,c)},s.defaults=v(s.allKeys,!0),s.create=function(a,b){var c=w(a);return b&&s.extendOwn(c,b),c},s.clone=function(a){return s.isObject(a)?s.isArray(a)?a.slice():s.extend({},a):a},s.tap=function(a,b){return b(a),a},s.isMatch=function(a,b){var c=s.keys(b),d=c.length;if(null==a)return!d;for(var e=Object(a),f=0;f<d;f++){var g=c[f];if(b[g]!==e[g]||!(g in e))return!1}return!0};var G=function(a,b,c,d){if(a===b)return 0!==a||1/a===1/b;if(null==a||null==b)return a===b;a instanceof s&&(a=a._wrapped),b instanceof s&&(b=b._wrapped);var e=l.call(a);if(e!==l.call(b))return!1;switch(e){case"[object RegExp]":case"[object String]":return""+a==""+b;case"[object Number]":return+a!==+a?+b!==+b:0===+a?1/+a===1/b:+a===+b;case"[object Date]":case"[object Boolean]":return+a===+b}var f="[object Array]"===e;if(!f){if("object"!=typeof a||"object"!=typeof b)return!1;var g=a.constructor,h=b.constructor;if(g!==h&&!(s.isFunction(g)&&g instanceof g&&s.isFunction(h)&&h instanceof h)&&"constructor"in a&&"constructor"in b)return!1}c=c||[],d=d||[];for(var i=c.length;i--;)if(c[i]===a)return d[i]===b;if(c.push(a),d.push(b),f){if(i=a.length,i!==b.length)return!1;for(;i--;)if(!G(a[i],b[i],c,d))return!1}else{var j,k=s.keys(a);if(i=k.length,s.keys(b).length!==i)return!1;for(;i--;)if(j=k[i],!s.has(b,j)||!G(a[j],b[j],c,d))return!1}return c.pop(),d.pop(),!0};s.isEqual=function(a,b){return G(a,b)},s.isEmpty=function(a){return null==a||(A(a)&&(s.isArray(a)||s.isString(a)||s.isArguments(a))?0===a.length:0===s.keys(a).length)},s.isElement=function(a){return!(!a||1!==a.nodeType)},s.isArray=n||function(a){return"[object Array]"===l.call(a)},s.isObject=function(a){var b=typeof a;return"function"===b||"object"===b&&!!a},s.each(["Arguments","Function","String","Number","Date","RegExp","Error"],function(a){s["is"+a]=function(b){return l.call(b)==="[object "+a+"]"}}),s.isArguments(arguments)||(s.isArguments=function(a){return s.has(a,"callee")}),"function"!=typeof/./&&"object"!=typeof Int8Array&&(s.isFunction=function(a){return"function"==typeof a||!1}),s.isFinite=function(a){return isFinite(a)&&!isNaN(parseFloat(a))},s.isNaN=function(a){return s.isNumber(a)&&a!==+a},s.isBoolean=function(a){return a===!0||a===!1||"[object Boolean]"===l.call(a)},s.isNull=function(a){return null===a},s.isUndefined=function(a){return void 0===a},s.has=function(a,b){return null!=a&&m.call(a,b)},s.noConflict=function(){return e._=f,this},s.identity=function(a){return a},s.constant=function(a){return function(){return a}},s.noop=function(){},s.property=x,s.propertyOf=function(a){return null==a?function(){}:function(b){return a[b]}},s.matcher=s.matches=function(a){return a=s.extendOwn({},a),function(b){return s.isMatch(b,a)}},s.times=function(a,b,c){var d=Array(Math.max(0,a));b=t(b,c,1);for(var e=0;e<a;e++)d[e]=b(e);return d},s.random=function(a,b){return null==b&&(b=a,a=0),a+Math.floor(Math.random()*(b-a+1))},s.now=Date.now||function(){return(new Date).getTime()};var H={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","`":"&#x60;"},I=s.invert(H),J=function(a){var b=function(b){return a[b]},c="(?:"+s.keys(a).join("|")+")",d=RegExp(c),e=RegExp(c,"g");return function(a){return a=null==a?"":""+a,d.test(a)?a.replace(e,b):a}};s.escape=J(H),s.unescape=J(I),s.result=function(a,b,c){var d=null==a?void 0:a[b];return void 0===d&&(d=c),s.isFunction(d)?d.call(a):d};var K=0;s.uniqueId=function(a){var b=++K+"";return a?a+b:b},s.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var L=/(.)^/,M={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},N=/\\|'|\r|\n|\u2028|\u2029/g,O=function(a){return"\\"+M[a]};s.template=function(a,b,c){!b&&c&&(b=c),b=s.defaults({},b,s.templateSettings);var d=RegExp([(b.escape||L).source,(b.interpolate||L).source,(b.evaluate||L).source].join("|")+"|$","g"),e=0,f="__p+='";a.replace(d,function(b,c,d,g,h){return f+=a.slice(e,h).replace(N,O),e=h+b.length,c?f+="'+\n((__t=("+c+"))==null?'':_.escape(__t))+\n'":d?f+="'+\n((__t=("+d+"))==null?'':__t)+\n'":g&&(f+="';\n"+g+"\n__p+='"),b}),f+="';\n",b.variable||(f="with(obj||{}){\n"+f+"}\n"),f="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+f+"return __p;\n";try{var g=new Function(b.variable||"obj","_",f)}catch(h){throw h.source=f,h}var i=function(a){return g.call(this,a,s)},j=b.variable||"obj";return i.source="function("+j+"){\n"+f+"}",i},s.chain=function(a){var b=s(a);return b._chain=!0,b};var P=function(a,b){return a._chain?s(b).chain():b};s.mixin=function(a){s.each(s.functions(a),function(b){var c=s[b]=a[b];s.prototype[b]=function(){var a=[this._wrapped];return j.apply(a,arguments),P(this,c.apply(s,a))}})},s.mixin(s),s.each(["pop","push","reverse","shift","sort","splice","unshift"],function(a){var b=g[a];s.prototype[a]=function(){var c=this._wrapped;return b.apply(c,arguments),"shift"!==a&&"splice"!==a||0!==c.length||delete c[0],P(this,c)}}),s.each(["concat","join","slice"],function(a){var b=g[a];s.prototype[a]=function(){return P(this,b.apply(this._wrapped,arguments))}}),s.prototype.value=function(){return this._wrapped},s.prototype.valueOf=s.prototype.toJSON=s.prototype.value,s.prototype.toString=function(){return""+this._wrapped},"function"==typeof define&&define.amd&&define("underscore",[],function(){return s})}).call(this);
+ No newline at end of file
+//     Underscore.js 1.9.1
+//     http://underscorejs.org
+//     (c) 2009-2018 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+//     Underscore may be freely distributed under the MIT license.
+! function() {
+        var n = "object" == typeof self && self.self === self && self || "object" == typeof global && global.global === global && global || this || {},
+                r = n._,
+                e = Array.prototype,
+                o = Object.prototype,
+                s = "undefined" != typeof Symbol ? Symbol.prototype : null,
+                u = e.push,
+                c = e.slice,
+                p = o.toString,
+                i = o.hasOwnProperty,
+                t = Array.isArray,
+                a = Object.keys,
+                l = Object.create,
+                f = function() {},
+                h = function(n) {
+                        return n instanceof h ? n : this instanceof h ? void(this._wrapped = n) : new h(n)
+                };
+        "undefined" == typeof exports || exports.nodeType ? n._ = h : ("undefined" != typeof module && !module.nodeType && module.exports && (exports = module.exports = h), exports._ = h), h.VERSION = "1.9.1";
+        var v, y = function(u, i, n) {
+                        if (void 0 === i) return u;
+                        switch (null == n ? 3 : n) {
+                                case 1:
+                                        return function(n) {
+                                                return u.call(i, n)
+                                        };
+                                case 3:
+                                        return function(n, r, t) {
+                                                return u.call(i, n, r, t)
+                                        };
+                                case 4:
+                                        return function(n, r, t, e) {
+                                                return u.call(i, n, r, t, e)
+                                        }
+                        }
+                        return function() {
+                                return u.apply(i, arguments)
+                        }
+                },
+                d = function(n, r, t) {
+                        return h.iteratee !== v ? h.iteratee(n, r) : null == n ? h.identity : h.isFunction(n) ? y(n, r, t) : h.isObject(n) && !h.isArray(n) ? h.matcher(n) : h.property(n)
+                };
+        h.iteratee = v = function(n, r) {
+                return d(n, r, 1 / 0)
+        };
+        var g = function(u, i) {
+                        return i = null == i ? u.length - 1 : +i,
+                                function() {
+                                        for (var n = Math.max(arguments.length - i, 0), r = Array(n), t = 0; t < n; t++) r[t] = arguments[t + i];
+                                        switch (i) {
+                                                case 0:
+                                                        return u.call(this, r);
+                                                case 1:
+                                                        return u.call(this, arguments[0], r);
+                                                case 2:
+                                                        return u.call(this, arguments[0], arguments[1], r)
+                                        }
+                                        var e = Array(i + 1);
+                                        for (t = 0; t < i; t++) e[t] = arguments[t];
+                                        return e[i] = r, u.apply(this, e)
+                                }
+                },
+                m = function(n) {
+                        if (!h.isObject(n)) return {};
+                        if (l) return l(n);
+                        f.prototype = n;
+                        var r = new f;
+                        return f.prototype = null, r
+                },
+                b = function(r) {
+                        return function(n) {
+                                return null == n ? void 0 : n[r]
+                        }
+                },
+                j = function(n, r) {
+                        return null != n && i.call(n, r)
+                },
+                x = function(n, r) {
+                        for (var t = r.length, e = 0; e < t; e++) {
+                                if (null == n) return;
+                                n = n[r[e]]
+                        }
+                        return t ? n : void 0
+                },
+                _ = Math.pow(2, 53) - 1,
+                A = b("length"),
+                w = function(n) {
+                        var r = A(n);
+                        return "number" == typeof r && 0 <= r && r <= _
+                };
+        h.each = h.forEach = function(n, r, t) {
+                var e, u;
+                if (r = y(r, t), w(n))
+                        for (e = 0, u = n.length; e < u; e++) r(n[e], e, n);
+                else {
+                        var i = h.keys(n);
+                        for (e = 0, u = i.length; e < u; e++) r(n[i[e]], i[e], n)
+                }
+                return n
+        }, h.map = h.collect = function(n, r, t) {
+                r = d(r, t);
+                for (var e = !w(n) && h.keys(n), u = (e || n).length, i = Array(u), o = 0; o < u; o++) {
+                        var a = e ? e[o] : o;
+                        i[o] = r(n[a], a, n)
+                }
+                return i
+        };
+        var O = function(c) {
+                return function(n, r, t, e) {
+                        var u = 3 <= arguments.length;
+                        return function(n, r, t, e) {
+                                var u = !w(n) && h.keys(n),
+                                        i = (u || n).length,
+                                        o = 0 < c ? 0 : i - 1;
+                                for (e || (t = n[u ? u[o] : o], o += c); 0 <= o && o < i; o += c) {
+                                        var a = u ? u[o] : o;
+                                        t = r(t, n[a], a, n)
+                                }
+                                return t
+                        }(n, y(r, e, 4), t, u)
+                }
+        };
+        h.reduce = h.foldl = h.inject = O(1), h.reduceRight = h.foldr = O(-1), h.find = h.detect = function(n, r, t) {
+                var e = (w(n) ? h.findIndex : h.findKey)(n, r, t);
+                if (void 0 !== e && -1 !== e) return n[e]
+        }, h.filter = h.select = function(n, e, r) {
+                var u = [];
+                return e = d(e, r), h.each(n, function(n, r, t) {
+                        e(n, r, t) && u.push(n)
+                }), u
+        }, h.reject = function(n, r, t) {
+                return h.filter(n, h.negate(d(r)), t)
+        }, h.every = h.all = function(n, r, t) {
+                r = d(r, t);
+                for (var e = !w(n) && h.keys(n), u = (e || n).length, i = 0; i < u; i++) {
+                        var o = e ? e[i] : i;
+                        if (!r(n[o], o, n)) return !1
+                }
+                return !0
+        }, h.some = h.any = function(n, r, t) {
+                r = d(r, t);
+                for (var e = !w(n) && h.keys(n), u = (e || n).length, i = 0; i < u; i++) {
+                        var o = e ? e[i] : i;
+                        if (r(n[o], o, n)) return !0
+                }
+                return !1
+        }, h.contains = h.includes = h.include = function(n, r, t, e) {
+                return w(n) || (n = h.values(n)), ("number" != typeof t || e) && (t = 0), 0 <= h.indexOf(n, r, t)
+        }, h.invoke = g(function(n, t, e) {
+                var u, i;
+                return h.isFunction(t) ? i = t : h.isArray(t) && (u = t.slice(0, -1), t = t[t.length - 1]), h.map(n, function(n) {
+                        var r = i;
+                        if (!r) {
+                                if (u && u.length && (n = x(n, u)), null == n) return;
+                                r = n[t]
+                        }
+                        return null == r ? r : r.apply(n, e)
+                })
+        }), h.pluck = function(n, r) {
+                return h.map(n, h.property(r))
+        }, h.where = function(n, r) {
+                return h.filter(n, h.matcher(r))
+        }, h.findWhere = function(n, r) {
+                return h.find(n, h.matcher(r))
+        }, h.max = function(n, e, r) {
+                var t, u, i = -1 / 0,
+                        o = -1 / 0;
+                if (null == e || "number" == typeof e && "object" != typeof n[0] && null != n)
+                        for (var a = 0, c = (n = w(n) ? n : h.values(n)).length; a < c; a++) null != (t = n[a]) && i < t && (i = t);
+                else e = d(e, r), h.each(n, function(n, r, t) {
+                        u = e(n, r, t), (o < u || u === -1 / 0 && i === -1 / 0) && (i = n, o = u)
+                });
+                return i
+        }, h.min = function(n, e, r) {
+                var t, u, i = 1 / 0,
+                        o = 1 / 0;
+                if (null == e || "number" == typeof e && "object" != typeof n[0] && null != n)
+                        for (var a = 0, c = (n = w(n) ? n : h.values(n)).length; a < c; a++) null != (t = n[a]) && t < i && (i = t);
+                else e = d(e, r), h.each(n, function(n, r, t) {
+                        ((u = e(n, r, t)) < o || u === 1 / 0 && i === 1 / 0) && (i = n, o = u)
+                });
+                return i
+        }, h.shuffle = function(n) {
+                return h.sample(n, 1 / 0)
+        }, h.sample = function(n, r, t) {
+                if (null == r || t) return w(n) || (n = h.values(n)), n[h.random(n.length - 1)];
+                var e = w(n) ? h.clone(n) : h.values(n),
+                        u = A(e);
+                r = Math.max(Math.min(r, u), 0);
+                for (var i = u - 1, o = 0; o < r; o++) {
+                        var a = h.random(o, i),
+                                c = e[o];
+                        e[o] = e[a], e[a] = c
+                }
+                return e.slice(0, r)
+        }, h.sortBy = function(n, e, r) {
+                var u = 0;
+                return e = d(e, r), h.pluck(h.map(n, function(n, r, t) {
+                        return {
+                                value: n,
+                                index: u++,
+                                criteria: e(n, r, t)
+                        }
+                }).sort(function(n, r) {
+                        var t = n.criteria,
+                                e = r.criteria;
+                        if (t !== e) {
+                                if (e < t || void 0 === t) return 1;
+                                if (t < e || void 0 === e) return -1
+                        }
+                        return n.index - r.index
+                }), "value")
+        };
+        var k = function(o, r) {
+                return function(e, u, n) {
+                        var i = r ? [
+                                [],
+                                []
+                        ] : {};
+                        return u = d(u, n), h.each(e, function(n, r) {
+                                var t = u(n, r, e);
+                                o(i, n, t)
+                        }), i
+                }
+        };
+        h.groupBy = k(function(n, r, t) {
+                j(n, t) ? n[t].push(r) : n[t] = [r]
+        }), h.indexBy = k(function(n, r, t) {
+                n[t] = r
+        }), h.countBy = k(function(n, r, t) {
+                j(n, t) ? n[t]++ : n[t] = 1
+        });
+        var S = /[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;
+        h.toArray = function(n) {
+                return n ? h.isArray(n) ? c.call(n) : h.isString(n) ? n.match(S) : w(n) ? h.map(n, h.identity) : h.values(n) : []
+        }, h.size = function(n) {
+                return null == n ? 0 : w(n) ? n.length : h.keys(n).length
+        }, h.partition = k(function(n, r, t) {
+                n[t ? 0 : 1].push(r)
+        }, !0), h.first = h.head = h.take = function(n, r, t) {
+                return null == n || n.length < 1 ? null == r ? void 0 : [] : null == r || t ? n[0] : h.initial(n, n.length - r)
+        }, h.initial = function(n, r, t) {
+                return c.call(n, 0, Math.max(0, n.length - (null == r || t ? 1 : r)))
+        }, h.last = function(n, r, t) {
+                return null == n || n.length < 1 ? null == r ? void 0 : [] : null == r || t ? n[n.length - 1] : h.rest(n, Math.max(0, n.length - r))
+        }, h.rest = h.tail = h.drop = function(n, r, t) {
+                return c.call(n, null == r || t ? 1 : r)
+        }, h.compact = function(n) {
+                return h.filter(n, Boolean)
+        };
+        var M = function(n, r, t, e) {
+                for (var u = (e = e || []).length, i = 0, o = A(n); i < o; i++) {
+                        var a = n[i];
+                        if (w(a) && (h.isArray(a) || h.isArguments(a)))
+                                if (r)
+                                        for (var c = 0, l = a.length; c < l;) e[u++] = a[c++];
+                                else M(a, r, t, e), u = e.length;
+                        else t || (e[u++] = a)
+                }
+                return e
+        };
+        h.flatten = function(n, r) {
+                return M(n, r, !1)
+        }, h.without = g(function(n, r) {
+                return h.difference(n, r)
+        }), h.uniq = h.unique = function(n, r, t, e) {
+                h.isBoolean(r) || (e = t, t = r, r = !1), null != t && (t = d(t, e));
+                for (var u = [], i = [], o = 0, a = A(n); o < a; o++) {
+                        var c = n[o],
+                                l = t ? t(c, o, n) : c;
+                        r && !t ? (o && i === l || u.push(c), i = l) : t ? h.contains(i, l) || (i.push(l), u.push(c)) : h.contains(u, c) || u.push(c)
+                }
+                return u
+        }, h.union = g(function(n) {
+                return h.uniq(M(n, !0, !0))
+        }), h.intersection = function(n) {
+                for (var r = [], t = arguments.length, e = 0, u = A(n); e < u; e++) {
+                        var i = n[e];
+                        if (!h.contains(r, i)) {
+                                var o;
+                                for (o = 1; o < t && h.contains(arguments[o], i); o++);
+                                o === t && r.push(i)
+                        }
+                }
+                return r
+        }, h.difference = g(function(n, r) {
+                return r = M(r, !0, !0), h.filter(n, function(n) {
+                        return !h.contains(r, n)
+                })
+        }), h.unzip = function(n) {
+                for (var r = n && h.max(n, A).length || 0, t = Array(r), e = 0; e < r; e++) t[e] = h.pluck(n, e);
+                return t
+        }, h.zip = g(h.unzip), h.object = function(n, r) {
+                for (var t = {}, e = 0, u = A(n); e < u; e++) r ? t[n[e]] = r[e] : t[n[e][0]] = n[e][1];
+                return t
+        };
+        var F = function(i) {
+                return function(n, r, t) {
+                        r = d(r, t);
+                        for (var e = A(n), u = 0 < i ? 0 : e - 1; 0 <= u && u < e; u += i)
+                                if (r(n[u], u, n)) return u;
+                        return -1
+                }
+        };
+        h.findIndex = F(1), h.findLastIndex = F(-1), h.sortedIndex = function(n, r, t, e) {
+                for (var u = (t = d(t, e, 1))(r), i = 0, o = A(n); i < o;) {
+                        var a = Math.floor((i + o) / 2);
+                        t(n[a]) < u ? i = a + 1 : o = a
+                }
+                return i
+        };
+        var E = function(i, o, a) {
+                return function(n, r, t) {
+                        var e = 0,
+                                u = A(n);
+                        if ("number" == typeof t) 0 < i ? e = 0 <= t ? t : Math.max(t + u, e) : u = 0 <= t ? Math.min(t + 1, u) : t + u + 1;
+                        else if (a && t && u) return n[t = a(n, r)] === r ? t : -1;
+                        if (r != r) return 0 <= (t = o(c.call(n, e, u), h.isNaN)) ? t + e : -1;
+                        for (t = 0 < i ? e : u - 1; 0 <= t && t < u; t += i)
+                                if (n[t] === r) return t;
+                        return -1
+                }
+        };
+        h.indexOf = E(1, h.findIndex, h.sortedIndex), h.lastIndexOf = E(-1, h.findLastIndex), h.range = function(n, r, t) {
+                null == r && (r = n || 0, n = 0), t || (t = r < n ? -1 : 1);
+                for (var e = Math.max(Math.ceil((r - n) / t), 0), u = Array(e), i = 0; i < e; i++, n += t) u[i] = n;
+                return u
+        }, h.chunk = function(n, r) {
+                if (null == r || r < 1) return [];
+                for (var t = [], e = 0, u = n.length; e < u;) t.push(c.call(n, e, e += r));
+                return t
+        };
+        var N = function(n, r, t, e, u) {
+                if (!(e instanceof r)) return n.apply(t, u);
+                var i = m(n.prototype),
+                        o = n.apply(i, u);
+                return h.isObject(o) ? o : i
+        };
+        h.bind = g(function(r, t, e) {
+                if (!h.isFunction(r)) throw new TypeError("Bind must be called on a function");
+                var u = g(function(n) {
+                        return N(r, u, t, this, e.concat(n))
+                });
+                return u
+        }), h.partial = g(function(u, i) {
+                var o = h.partial.placeholder,
+                        a = function() {
+                                for (var n = 0, r = i.length, t = Array(r), e = 0; e < r; e++) t[e] = i[e] === o ? arguments[n++] : i[e];
+                                for (; n < arguments.length;) t.push(arguments[n++]);
+                                return N(u, a, this, this, t)
+                        };
+                return a
+        }), (h.partial.placeholder = h).bindAll = g(function(n, r) {
+                var t = (r = M(r, !1, !1)).length;
+                if (t < 1) throw new Error("bindAll must be passed function names");
+                for (; t--;) {
+                        var e = r[t];
+                        n[e] = h.bind(n[e], n)
+                }
+        }), h.memoize = function(e, u) {
+                var i = function(n) {
+                        var r = i.cache,
+                                t = "" + (u ? u.apply(this, arguments) : n);
+                        return j(r, t) || (r[t] = e.apply(this, arguments)), r[t]
+                };
+                return i.cache = {}, i
+        }, h.delay = g(function(n, r, t) {
+                return setTimeout(function() {
+                        return n.apply(null, t)
+                }, r)
+        }), h.defer = h.partial(h.delay, h, 1), h.throttle = function(t, e, u) {
+                var i, o, a, c, l = 0;
+                u || (u = {});
+                var f = function() {
+                                l = !1 === u.leading ? 0 : h.now(), i = null, c = t.apply(o, a), i || (o = a = null)
+                        },
+                        n = function() {
+                                var n = h.now();
+                                l || !1 !== u.leading || (l = n);
+                                var r = e - (n - l);
+                                return o = this, a = arguments, r <= 0 || e < r ? (i && (clearTimeout(i), i = null), l = n, c = t.apply(o, a), i || (o = a = null)) : i || !1 === u.trailing || (i = setTimeout(f, r)), c
+                        };
+                return n.cancel = function() {
+                        clearTimeout(i), l = 0, i = o = a = null
+                }, n
+        }, h.debounce = function(t, e, u) {
+                var i, o, a = function(n, r) {
+                                i = null, r && (o = t.apply(n, r))
+                        },
+                        n = g(function(n) {
+                                if (i && clearTimeout(i), u) {
+                                        var r = !i;
+                                        i = setTimeout(a, e), r && (o = t.apply(this, n))
+                                } else i = h.delay(a, e, this, n);
+                                return o
+                        });
+                return n.cancel = function() {
+                        clearTimeout(i), i = null
+                }, n
+        }, h.wrap = function(n, r) {
+                return h.partial(r, n)
+        }, h.negate = function(n) {
+                return function() {
+                        return !n.apply(this, arguments)
+                }
+        }, h.compose = function() {
+                var t = arguments,
+                        e = t.length - 1;
+                return function() {
+                        for (var n = e, r = t[e].apply(this, arguments); n--;) r = t[n].call(this, r);
+                        return r
+                }
+        }, h.after = function(n, r) {
+                return function() {
+                        if (--n < 1) return r.apply(this, arguments)
+                }
+        }, h.before = function(n, r) {
+                var t;
+                return function() {
+                        return 0 < --n && (t = r.apply(this, arguments)), n <= 1 && (r = null), t
+                }
+        }, h.once = h.partial(h.before, 2), h.restArguments = g;
+        var I = !{
+                        toString: null
+                }.propertyIsEnumerable("toString"),
+                T = ["valueOf", "isPrototypeOf", "toString", "propertyIsEnumerable", "hasOwnProperty", "toLocaleString"],
+                B = function(n, r) {
+                        var t = T.length,
+                                e = n.constructor,
+                                u = h.isFunction(e) && e.prototype || o,
+                                i = "constructor";
+                        for (j(n, i) && !h.contains(r, i) && r.push(i); t--;)(i = T[t]) in n && n[i] !== u[i] && !h.contains(r, i) && r.push(i)
+                };
+        h.keys = function(n) {
+                if (!h.isObject(n)) return [];
+                if (a) return a(n);
+                var r = [];
+                for (var t in n) j(n, t) && r.push(t);
+                return I && B(n, r), r
+        }, h.allKeys = function(n) {
+                if (!h.isObject(n)) return [];
+                var r = [];
+                for (var t in n) r.push(t);
+                return I && B(n, r), r
+        }, h.values = function(n) {
+                for (var r = h.keys(n), t = r.length, e = Array(t), u = 0; u < t; u++) e[u] = n[r[u]];
+                return e
+        }, h.mapObject = function(n, r, t) {
+                r = d(r, t);
+                for (var e = h.keys(n), u = e.length, i = {}, o = 0; o < u; o++) {
+                        var a = e[o];
+                        i[a] = r(n[a], a, n)
+                }
+                return i
+        }, h.pairs = function(n) {
+                for (var r = h.keys(n), t = r.length, e = Array(t), u = 0; u < t; u++) e[u] = [r[u], n[r[u]]];
+                return e
+        }, h.invert = function(n) {
+                for (var r = {}, t = h.keys(n), e = 0, u = t.length; e < u; e++) r[n[t[e]]] = t[e];
+                return r
+        }, h.functions = h.methods = function(n) {
+                var r = [];
+                for (var t in n) h.isFunction(n[t]) && r.push(t);
+                return r.sort()
+        };
+        var R = function(c, l) {
+                return function(n) {
+                        var r = arguments.length;
+                        if (l && (n = Object(n)), r < 2 || null == n) return n;
+                        for (var t = 1; t < r; t++)
+                                for (var e = arguments[t], u = c(e), i = u.length, o = 0; o < i; o++) {
+                                        var a = u[o];
+                                        l && void 0 !== n[a] || (n[a] = e[a])
+                                }
+                        return n
+                }
+        };
+        h.extend = R(h.allKeys), h.extendOwn = h.assign = R(h.keys), h.findKey = function(n, r, t) {
+                r = d(r, t);
+                for (var e, u = h.keys(n), i = 0, o = u.length; i < o; i++)
+                        if (r(n[e = u[i]], e, n)) return e
+        };
+        var q, K, z = function(n, r, t) {
+                return r in t
+        };
+        h.pick = g(function(n, r) {
+                var t = {},
+                        e = r[0];
+                if (null == n) return t;
+                h.isFunction(e) ? (1 < r.length && (e = y(e, r[1])), r = h.allKeys(n)) : (e = z, r = M(r, !1, !1), n = Object(n));
+                for (var u = 0, i = r.length; u < i; u++) {
+                        var o = r[u],
+                                a = n[o];
+                        e(a, o, n) && (t[o] = a)
+                }
+                return t
+        }), h.omit = g(function(n, t) {
+                var r, e = t[0];
+                return h.isFunction(e) ? (e = h.negate(e), 1 < t.length && (r = t[1])) : (t = h.map(M(t, !1, !1), String), e = function(n, r) {
+                        return !h.contains(t, r)
+                }), h.pick(n, e, r)
+        }), h.defaults = R(h.allKeys, !0), h.create = function(n, r) {
+                var t = m(n);
+                return r && h.extendOwn(t, r), t
+        }, h.clone = function(n) {
+                return h.isObject(n) ? h.isArray(n) ? n.slice() : h.extend({}, n) : n
+        }, h.tap = function(n, r) {
+                return r(n), n
+        }, h.isMatch = function(n, r) {
+                var t = h.keys(r),
+                        e = t.length;
+                if (null == n) return !e;
+                for (var u = Object(n), i = 0; i < e; i++) {
+                        var o = t[i];
+                        if (r[o] !== u[o] || !(o in u)) return !1
+                }
+                return !0
+        }, q = function(n, r, t, e) {
+                if (n === r) return 0 !== n || 1 / n == 1 / r;
+                if (null == n || null == r) return !1;
+                if (n != n) return r != r;
+                var u = typeof n;
+                return ("function" === u || "object" === u || "object" == typeof r) && K(n, r, t, e)
+        }, K = function(n, r, t, e) {
+                n instanceof h && (n = n._wrapped), r instanceof h && (r = r._wrapped);
+                var u = p.call(n);
+                if (u !== p.call(r)) return !1;
+                switch (u) {
+                        case "[object RegExp]":
+                        case "[object String]":
+                                return "" + n == "" + r;
+                        case "[object Number]":
+                                return +n != +n ? +r != +r : 0 == +n ? 1 / +n == 1 / r : +n == +r;
+                        case "[object Date]":
+                        case "[object Boolean]":
+                                return +n == +r;
+                        case "[object Symbol]":
+                                return s.valueOf.call(n) === s.valueOf.call(r)
+                }
+                var i = "[object Array]" === u;
+                if (!i) {
+                        if ("object" != typeof n || "object" != typeof r) return !1;
+                        var o = n.constructor,
+                                a = r.constructor;
+                        if (o !== a && !(h.isFunction(o) && o instanceof o && h.isFunction(a) && a instanceof a) && "constructor" in n && "constructor" in r) return !1
+                }
+                e = e || [];
+                for (var c = (t = t || []).length; c--;)
+                        if (t[c] === n) return e[c] === r;
+                if (t.push(n), e.push(r), i) {
+                        if ((c = n.length) !== r.length) return !1;
+                        for (; c--;)
+                                if (!q(n[c], r[c], t, e)) return !1
+                } else {
+                        var l, f = h.keys(n);
+                        if (c = f.length, h.keys(r).length !== c) return !1;
+                        for (; c--;)
+                                if (l = f[c], !j(r, l) || !q(n[l], r[l], t, e)) return !1
+                }
+                return t.pop(), e.pop(), !0
+        }, h.isEqual = function(n, r) {
+                return q(n, r)
+        }, h.isEmpty = function(n) {
+                return null == n || (w(n) && (h.isArray(n) || h.isString(n) || h.isArguments(n)) ? 0 === n.length : 0 === h.keys(n).length)
+        }, h.isElement = function(n) {
+                return !(!n || 1 !== n.nodeType)
+        }, h.isArray = t || function(n) {
+                return "[object Array]" === p.call(n)
+        }, h.isObject = function(n) {
+                var r = typeof n;
+                return "function" === r || "object" === r && !!n
+        }, h.each(["Arguments", "Function", "String", "Number", "Date", "RegExp", "Error", "Symbol", "Map", "WeakMap", "Set", "WeakSet"], function(r) {
+                h["is" + r] = function(n) {
+                        return p.call(n) === "[object " + r + "]"
+                }
+        }), h.isArguments(arguments) || (h.isArguments = function(n) {
+                return j(n, "callee")
+        });
+        var D = n.document && n.document.childNodes;
+        "function" != typeof /./ && "object" != typeof Int8Array && "function" != typeof D && (h.isFunction = function(n) {
+                return "function" == typeof n || !1
+        }), h.isFinite = function(n) {
+                return !h.isSymbol(n) && isFinite(n) && !isNaN(parseFloat(n))
+        }, h.isNaN = function(n) {
+                return h.isNumber(n) && isNaN(n)
+        }, h.isBoolean = function(n) {
+                return !0 === n || !1 === n || "[object Boolean]" === p.call(n)
+        }, h.isNull = function(n) {
+                return null === n
+        }, h.isUndefined = function(n) {
+                return void 0 === n
+        }, h.has = function(n, r) {
+                if (!h.isArray(r)) return j(n, r);
+                for (var t = r.length, e = 0; e < t; e++) {
+                        var u = r[e];
+                        if (null == n || !i.call(n, u)) return !1;
+                        n = n[u]
+                }
+                return !!t
+        }, h.noConflict = function() {
+                return n._ = r, this
+        }, h.identity = function(n) {
+                return n
+        }, h.constant = function(n) {
+                return function() {
+                        return n
+                }
+        }, h.noop = function() {}, h.property = function(r) {
+                return h.isArray(r) ? function(n) {
+                        return x(n, r)
+                } : b(r)
+        }, h.propertyOf = function(r) {
+                return null == r ? function() {} : function(n) {
+                        return h.isArray(n) ? x(r, n) : r[n]
+                }
+        }, h.matcher = h.matches = function(r) {
+                return r = h.extendOwn({}, r),
+                        function(n) {
+                                return h.isMatch(n, r)
+                        }
+        }, h.times = function(n, r, t) {
+                var e = Array(Math.max(0, n));
+                r = y(r, t, 1);
+                for (var u = 0; u < n; u++) e[u] = r(u);
+                return e
+        }, h.random = function(n, r) {
+                return null == r && (r = n, n = 0), n + Math.floor(Math.random() * (r - n + 1))
+        }, h.now = Date.now || function() {
+                return (new Date).getTime()
+        };
+        var L = {
+                        "&": "&amp;",
+                        "<": "&lt;",
+                        ">": "&gt;",
+                        '"': "&quot;",
+                        "'": "&#x27;",
+                        "`": "&#x60;"
+                },
+                P = h.invert(L),
+                W = function(r) {
+                        var t = function(n) {
+                                        return r[n]
+                                },
+                                n = "(?:" + h.keys(r).join("|") + ")",
+                                e = RegExp(n),
+                                u = RegExp(n, "g");
+                        return function(n) {
+                                return n = null == n ? "" : "" + n, e.test(n) ? n.replace(u, t) : n
+                        }
+                };
+        h.escape = W(L), h.unescape = W(P), h.result = function(n, r, t) {
+                h.isArray(r) || (r = [r]);
+                var e = r.length;
+                if (!e) return h.isFunction(t) ? t.call(n) : t;
+                for (var u = 0; u < e; u++) {
+                        var i = null == n ? void 0 : n[r[u]];
+                        void 0 === i && (i = t, u = e), n = h.isFunction(i) ? i.call(n) : i
+                }
+                return n
+        };
+        var C = 0;
+        h.uniqueId = function(n) {
+                var r = ++C + "";
+                return n ? n + r : r
+        }, h.templateSettings = {
+                evaluate: /<%([\s\S]+?)%>/g,
+                interpolate: /<%=([\s\S]+?)%>/g,
+                escape: /<%-([\s\S]+?)%>/g
+        };
+        var J = /(.)^/,
+                U = {
+                        "'": "'",
+                        "\\": "\\",
+                        "\r": "r",
+                        "\n": "n",
+                        "\u2028": "u2028",
+                        "\u2029": "u2029"
+                },
+                V = /\\|'|\r|\n|\u2028|\u2029/g,
+                $ = function(n) {
+                        return "\\" + U[n]
+                };
+        h.template = function(i, n, r) {
+                !n && r && (n = r), n = h.defaults({}, n, h.templateSettings);
+                var t, e = RegExp([(n.escape || J).source, (n.interpolate || J).source, (n.evaluate || J).source].join("|") + "|$", "g"),
+                        o = 0,
+                        a = "__p+='";
+                i.replace(e, function(n, r, t, e, u) {
+                        return a += i.slice(o, u).replace(V, $), o = u + n.length, r ? a += "'+\n((__t=(" + r + "))==null?'':_.escape(__t))+\n'" : t ? a += "'+\n((__t=(" + t + "))==null?'':__t)+\n'" : e && (a += "';\n" + e + "\n__p+='"), n
+                }), a += "';\n", n.variable || (a = "with(obj||{}){\n" + a + "}\n"), a = "var __t,__p='',__j=Array.prototype.join," + "print=function(){__p+=__j.call(arguments,'');};\n" + a + "return __p;\n";
+                try {
+                        t = new Function(n.variable || "obj", "_", a)
+                } catch (n) {
+                        throw n.source = a, n
+                }
+                var u = function(n) {
+                                return t.call(this, n, h)
+                        },
+                        c = n.variable || "obj";
+                return u.source = "function(" + c + "){\n" + a + "}", u
+        }, h.chain = function(n) {
+                var r = h(n);
+                return r._chain = !0, r
+        };
+        var G = function(n, r) {
+                return n._chain ? h(r).chain() : r
+        };
+        h.mixin = function(t) {
+                return h.each(h.functions(t), function(n) {
+                        var r = h[n] = t[n];
+                        h.prototype[n] = function() {
+                                var n = [this._wrapped];
+                                return u.apply(n, arguments), G(this, r.apply(h, n))
+                        }
+                }), h
+        }, h.mixin(h), h.each(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function(r) {
+                var t = e[r];
+                h.prototype[r] = function() {
+                        var n = this._wrapped;
+                        return t.apply(n, arguments), "shift" !== r && "splice" !== r || 0 !== n.length || delete n[0], G(this, n)
+                }
+        }), h.each(["concat", "join", "slice"], function(n) {
+                var r = e[n];
+                h.prototype[n] = function() {
+                        return G(this, r.apply(this._wrapped, arguments))
+                }
+        }), h.prototype.value = function() {
+                return this._wrapped
+        }, h.prototype.valueOf = h.prototype.toJSON = h.prototype.value, h.prototype.toString = function() {
+                return String(this._wrapped)
+        }, "function" == typeof define && define.amd && define("underscore", [], function() {
+                return h
+        })
+}();
+ No newline at end of file

wp-includes/script-loader.php

         $scripts->add( 'json2', "/wp-includes/js/json2$suffix.js", array(), '2015-05-03' );
         did_action( 'init' ) && $scripts->add_data( 'json2', 'conditional', 'lt IE 8' );
         $scripts->add( 'underscore', "/wp-includes/js/underscore$dev_suffix.js", array(), '1.8.3', 1 );
+        $scripts->add( 'underscore', "/wp-includes/js/underscore$dev_suffix.js", array(), '1.9.1', 1 );
         $scripts->add( 'backbone', "/wp-includes/js/backbone$dev_suffix.js", array( 'underscore', 'jquery' ), '1.2.3', 1 );
         $scripts->add( 'wp-util', "/wp-includes/js/wp-util$suffix.js", array( 'underscore', 'jquery' ), false, 1 );

Trac UI Preferences

Download in other formats:

Original Format

Make WordPress Core

Context Navigation

Ticket #45785: 45785.diff

wp-includes/js/underscore.js

wp-includes/js/underscore.min.js

wp-includes/script-loader.php

Download in other formats: