diff --git a/vendor/backbone/backbone.js b/vendor/backbone/backbone.js
index 24a550a0a..28e9e30eb 100644
--- a/vendor/backbone/backbone.js
+++ b/vendor/backbone/backbone.js
@@ -36,9 +36,7 @@
 
   // Create local references to array methods we'll want to use later.
   var array = [];
-  var push = array.push;
   var slice = array.slice;
-  var splice = array.splice;
 
   // Current version of the library. Keep in sync with `package.json`.
   Backbone.VERSION = '1.1.2';
@@ -108,27 +106,46 @@
     // callbacks for the event. If `name` is null, removes all bound
     // callbacks for all events.
     off: function(name, callback, context) {
-      var retain, ev, events, names, i, l, j, k;
       if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+
+      // Remove all callbacks for all events.
       if (!name && !callback && !context) {
         this._events = void 0;
         return this;
       }
-      names = name ? [name] : _.keys(this._events);
-      for (i = 0, l = names.length; i < l; i++) {
+
+      var names = name ? [name] : _.keys(this._events);
+      for (var i = 0, length = names.length; i < length; i++) {
         name = names[i];
-        if (events = this._events[name]) {
-          this._events[name] = retain = [];
-          if (callback || context) {
-            for (j = 0, k = events.length; j < k; j++) {
-              ev = events[j];
-              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
-                  (context && context !== ev.context)) {
-                retain.push(ev);
-              }
-            }
+
+        // Bail out if there are no events stored.
+        var events = this._events[name];
+        if (!events) continue;
+
+        // Remove all callbacks for this event.
+        if (!callback && !context) {
+          delete this._events[name];
+          continue;
+        }
+
+        // Find any remaining events.
+        var remaining = [];
+        for (var j = 0, k = events.length; j < k; j++) {
+          var event = events[j];
+          if (
+            callback && callback !== event.callback &&
+            callback !== event.callback._callback ||
+            context && context !== event.context
+          ) {
+            remaining.push(event);
           }
-          if (!retain.length) delete this._events[name];
+        }
+
+        // Replace events if there are any remaining.  Otherwise, clean up.
+        if (remaining.length) {
+          this._events[name] = remaining;
+        } else {
+          delete this._events[name];
         }
       }
 
@@ -188,7 +205,7 @@
     // Handle space separated event names.
     if (eventSplitter.test(name)) {
       var names = name.split(eventSplitter);
-      for (var i = 0, l = names.length; i < l; i++) {
+      for (var i = 0, length = names.length; i < length; i++) {
         obj[action].apply(obj, [names[i]].concat(rest));
       }
       return false;
@@ -353,7 +370,7 @@
       // Trigger all relevant attribute changes.
       if (!silent) {
         if (changes.length) this._pending = options;
-        for (var i = 0, l = changes.length; i < l; i++) {
+        for (var i = 0, length = changes.length; i < length; i++) {
           this.trigger('change:' + changes[i], this, current[changes[i]], options);
         }
       }
@@ -578,6 +595,7 @@
 
   // Mix in each Underscore method as a proxy to `Model#attributes`.
   _.each(modelMethods, function(method) {
+    if (!_[method]) return;
     Model.prototype[method] = function() {
       var args = slice.call(arguments);
       args.unshift(this.attributes);
@@ -589,7 +607,7 @@
   // -------------------
 
   // If models tend to represent a single row of data, a Backbone Collection is
-  // more analagous to a table full of data ... or a small slice or page of that
+  // more analogous to a table full of data ... or a small slice or page of that
   // table, or a collection of rows that belong together for a particular reason
   // -- all of the messages in this particular folder, all of the documents
   // belonging to this particular author, and so on. Collections maintain
@@ -643,13 +661,12 @@
       var singular = !_.isArray(models);
       models = singular ? [models] : _.clone(models);
       options || (options = {});
-      var i, l, index, model;
-      for (i = 0, l = models.length; i < l; i++) {
-        model = models[i] = this.get(models[i]);
+      for (var i = 0, length = models.length; i < length; i++) {
+        var model = models[i] = this.get(models[i]);
         if (!model) continue;
         delete this._byId[model.id];
         delete this._byId[model.cid];
-        index = this.indexOf(model);
+        var index = this.indexOf(model);
         this.models.splice(index, 1);
         this.length--;
         if (!options.silent) {
@@ -669,10 +686,9 @@
       options = _.defaults({}, options, setOptions);
       if (options.parse) models = this.parse(models, options);
       var singular = !_.isArray(models);
-      models = singular ? (models ? [models] : []) : _.clone(models);
-      var i, l, id, model, attrs, existing, sort;
+      models = singular ? (models ? [models] : []) : models.slice();
+      var id, model, attrs, existing, sort;
       var at = options.at;
-      var targetModel = this.model;
       var sortable = this.comparator && (at == null) && options.sort !== false;
       var sortAttr = _.isString(this.comparator) ? this.comparator : null;
       var toAdd = [], toRemove = [], modelMap = {};
@@ -681,12 +697,12 @@
 
       // Turn bare objects into model references, and prevent invalid models
       // from being added.
-      for (i = 0, l = models.length; i < l; i++) {
+      for (var i = 0, length = models.length; i < length; i++) {
         attrs = models[i] || {};
-        if (attrs instanceof Model) {
+        if (this._isModel(attrs)) {
           id = model = attrs;
         } else {
-          id = attrs[targetModel.prototype.idAttribute || 'id'];
+          id = attrs[this.model.prototype.idAttribute || 'id'];
         }
 
         // If a duplicate is found, prevent it from being added and
@@ -711,13 +727,14 @@
 
         // Do not add multiple models with the same `id`.
         model = existing || model;
+        if (!model) continue;
         if (order && (model.isNew() || !modelMap[model.id])) order.push(model);
         modelMap[model.id] = true;
       }
 
       // Remove nonexistent models if appropriate.
       if (remove) {
-        for (i = 0, l = this.length; i < l; ++i) {
+        for (var i = 0, length = this.length; i < length; i++) {
           if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
         }
         if (toRemove.length) this.remove(toRemove, options);
@@ -728,13 +745,13 @@
         if (sortable) sort = true;
         this.length += toAdd.length;
         if (at != null) {
-          for (i = 0, l = toAdd.length; i < l; i++) {
+          for (var i = 0, length = toAdd.length; i < length; i++) {
             this.models.splice(at + i, 0, toAdd[i]);
           }
         } else {
           if (order) this.models.length = 0;
           var orderedModels = order || toAdd;
-          for (i = 0, l = orderedModels.length; i < l; i++) {
+          for (var i = 0, length = orderedModels.length; i < length; i++) {
             this.models.push(orderedModels[i]);
           }
         }
@@ -745,7 +762,7 @@
 
       // Unless silenced, it's time to fire all appropriate add/sort events.
       if (!options.silent) {
-        for (i = 0, l = toAdd.length; i < l; i++) {
+        for (var i = 0, length = toAdd.length; i < length; i++) {
           (model = toAdd[i]).trigger('add', model, this, options);
         }
         if (sort || (order && order.length)) this.trigger('sort', this, options);
@@ -761,7 +778,7 @@
     // Useful for bulk operations and optimizations.
     reset: function(models, options) {
       options || (options = {});
-      for (var i = 0, l = this.models.length; i < l; i++) {
+      for (var i = 0, length = this.models.length; i < length; i++) {
         this._removeReference(this.models[i], options);
       }
       options.previousModels = this.models;
@@ -895,7 +912,10 @@
 
     // Create a new collection with an identical list of models as this one.
     clone: function() {
-      return new this.constructor(this.models);
+      return new this.constructor(this.models, {
+        model: this.model,
+        comparator: this.comparator
+      });
     },
 
     // Private method to reset all internal state. Called when the collection
@@ -909,7 +929,10 @@
     // Prepare a hash of attributes (or other model) to be added to this
     // collection.
     _prepareModel: function(attrs, options) {
-      if (attrs instanceof Model) return attrs;
+      if (this._isModel(attrs)) {
+        if (!attrs.collection) attrs.collection = this;
+        return attrs;
+      }
       options = options ? _.clone(options) : {};
       options.collection = this;
       var model = new this.model(attrs, options);
@@ -918,11 +941,16 @@
       return false;
     },
 
+    // Method for checking whether an object should be considered a model for
+    // the purposes of adding to the collection.
+    _isModel: function (model) {
+      return model instanceof Model;
+    },
+
     // Internal method to create a model's ties to a collection.
     _addReference: function(model, options) {
       this._byId[model.cid] = model;
       if (model.id != null) this._byId[model.id] = model;
-      if (!model.collection) model.collection = this;
       model.on('all', this._onModelEvent, this);
     },
 
@@ -956,10 +984,11 @@
     'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
     'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
     'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
-    'lastIndexOf', 'isEmpty', 'chain', 'sample'];
+    'lastIndexOf', 'isEmpty', 'chain', 'sample', 'partition'];
 
   // Mix in each Underscore method as a proxy to `Collection#models`.
   _.each(methods, function(method) {
+    if (!_[method]) return;
     Collection.prototype[method] = function() {
       var args = slice.call(arguments);
       args.unshift(this.models);
@@ -972,6 +1001,7 @@
 
   // Use attributes instead of properties.
   _.each(attributeMethods, function(method) {
+    if (!_[method]) return;
     Collection.prototype[method] = function(value, context) {
       var iterator = _.isFunction(value) ? value : function(model) {
         return model.get(value);
@@ -999,7 +1029,6 @@
     _.extend(this, _.pick(options, viewOptions));
     this._ensureElement();
     this.initialize.apply(this, arguments);
-    this.delegateEvents();
   };
 
   // Cached regex to split keys for `delegate`.
@@ -1034,21 +1063,37 @@
     // Remove this view by taking the element out of the DOM, and removing any
     // applicable Backbone.Events listeners.
     remove: function() {
-      this.$el.remove();
+      this._removeElement();
       this.stopListening();
       return this;
     },
 
-    // Change the view's element (`this.el` property), including event
-    // re-delegation.
-    setElement: function(element, delegate) {
-      if (this.$el) this.undelegateEvents();
-      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
-      this.el = this.$el[0];
-      if (delegate !== false) this.delegateEvents();
+    // Remove this view's element from the document and all event listeners
+    // attached to it. Exposed for subclasses using an alternative DOM
+    // manipulation API.
+    _removeElement: function() {
+      this.$el.remove();
+    },
+
+    // Change the view's element (`this.el` property) and re-delegate the
+    // view's events on the new element.
+    setElement: function(element) {
+      this.undelegateEvents();
+      this._setElement(element);
+      this.delegateEvents();
       return this;
     },
 
+    // Creates the `this.el` and `this.$el` references for this view using the
+    // given `el` and a hash of `attributes`. `el` can be a CSS selector or an
+    // HTML string, a jQuery context or an element. Subclasses can override
+    // this to utilize an alternative DOM manipulation API and are only required
+    // to set the `this.el` property.
+    _setElement: function(el) {
+      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);
+      this.el = this.$el[0];
+    },
+
     // Set callbacks, where `this.events` is a hash of
     //
     // *{"event selector": "callback"}*
@@ -1062,8 +1107,6 @@
     // pairs. Callbacks will be bound to the view, with `this` set properly.
     // Uses event delegation for efficiency.
     // Omitting the selector binds the event to `this.el`.
-    // This only works for delegate-able events: not `focus`, `blur`, and
-    // not `change`, `submit`, and `reset` in Internet Explorer.
     delegateEvents: function(events) {
       if (!(events || (events = _.result(this, 'events')))) return this;
       this.undelegateEvents();
@@ -1071,28 +1114,39 @@
         var method = events[key];
         if (!_.isFunction(method)) method = this[events[key]];
         if (!method) continue;
-
         var match = key.match(delegateEventSplitter);
-        var eventName = match[1], selector = match[2];
-        method = _.bind(method, this);
-        eventName += '.delegateEvents' + this.cid;
-        if (selector === '') {
-          this.$el.on(eventName, method);
-        } else {
-          this.$el.on(eventName, selector, method);
-        }
+        this.delegate(match[1], match[2], _.bind(method, this));
       }
       return this;
     },
 
-    // Clears all callbacks previously bound to the view with `delegateEvents`.
+    // Add a single event listener to the view's element (or a child element
+    // using `selector`). This only works for delegate-able events: not `focus`,
+    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.
+    delegate: function(eventName, selector, listener) {
+      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);
+    },
+
+    // Clears all callbacks previously bound to the view by `delegateEvents`.
     // You usually don't need to use this, but may wish to if you have multiple
     // Backbone views attached to the same DOM element.
     undelegateEvents: function() {
-      this.$el.off('.delegateEvents' + this.cid);
+      if (this.$el) this.$el.off('.delegateEvents' + this.cid);
       return this;
     },
 
+    // A finer-grained `undelegateEvents` for removing a single delegated event.
+    // `selector` and `listener` are both optional.
+    undelegate: function(eventName, selector, listener) {
+      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);
+    },
+
+    // Produces a DOM element to be assigned to your view. Exposed for
+    // subclasses using an alternative DOM manipulation API.
+    _createElement: function(tagName) {
+      return document.createElement(tagName);
+    },
+
     // Ensure that the View has a DOM element to render into.
     // If `this.el` is a string, pass it through `$()`, take the first
     // matching element, and re-assign it to `el`. Otherwise, create
@@ -1102,11 +1156,17 @@
         var attrs = _.extend({}, _.result(this, 'attributes'));
         if (this.id) attrs.id = _.result(this, 'id');
         if (this.className) attrs['class'] = _.result(this, 'className');
-        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
-        this.setElement($el, false);
+        this.setElement(this._createElement(_.result(this, 'tagName')));
+        this._setAttributes(attrs);
       } else {
-        this.setElement(_.result(this, 'el'), false);
+        this.setElement(_.result(this, 'el'));
       }
+    },
+
+    // Set attributes from a hash on this view's element.  Exposed for
+    // subclasses using an alternative DOM manipulation API.
+    _setAttributes: function(attributes) {
+      this.$el.attr(attributes);
     }
 
   });
@@ -1184,6 +1244,14 @@
       };
     }
 
+    // Pass along `textStatus` and `errorThrown` from jQuery.
+    var error = options.error;
+    options.error = function(xhr, textStatus, errorThrown) {
+      options.textStatus = textStatus;
+      options.errorThrown = errorThrown;
+      if (error) error.apply(this, arguments);
+    };
+
     // Make the request, allowing the user to override any Ajax options.
     var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
     model.trigger('request', model, xhr, options);
@@ -1251,17 +1319,18 @@
       var router = this;
       Backbone.history.route(route, function(fragment) {
         var args = router._extractParameters(route, fragment);
-        router.execute(callback, args);
-        router.trigger.apply(router, ['route:' + name].concat(args));
-        router.trigger('route', name, args);
-        Backbone.history.trigger('route', router, name, args);
+        if (router.execute(callback, args, name) !== false) {
+          router.trigger.apply(router, ['route:' + name].concat(args));
+          router.trigger('route', name, args);
+          Backbone.history.trigger('route', router, name, args);
+        }
       });
       return this;
     },
 
     // Execute a route handler with the provided parameters.  This is an
     // excellent place to do pre-route setup or post-route cleanup.
-    execute: function(callback, args) {
+    execute: function(callback, args, name) {
       if (callback) callback.apply(this, args);
     },
 
@@ -1334,12 +1403,6 @@
   // Cached regex for stripping leading and trailing slashes.
   var rootStripper = /^\/+|\/+$/g;
 
-  // Cached regex for detecting MSIE.
-  var isExplorer = /msie [\w.]+/;
-
-  // Cached regex for removing a trailing slash.
-  var trailingSlash = /\/$/;
-
   // Cached regex for stripping urls of hash.
   var pathStripper = /#.*$/;
 
@@ -1355,7 +1418,8 @@
 
     // Are we at the app root?
     atRoot: function() {
-      return this.location.pathname.replace(/[^\/]$/, '$&/') === this.root;
+      var path = this.location.pathname.replace(/[^\/]$/, '$&/');
+      return path === this.root && !this.location.search;
     },
 
     // Gets the true hash value. Cannot use location.hash directly due to bug
@@ -1365,14 +1429,19 @@
       return match ? match[1] : '';
     },
 
-    // Get the cross-browser normalized URL fragment, either from the URL,
-    // the hash, or the override.
-    getFragment: function(fragment, forcePushState) {
+    // Get the pathname and search params, without the root.
+    getPath: function() {
+      var path = decodeURI(this.location.pathname + this.location.search);
+      var root = this.root.slice(0, -1);
+      if (!path.indexOf(root)) path = path.slice(root.length);
+      return path.slice(1);
+    },
+
+    // Get the cross-browser normalized URL fragment from the path or hash.
+    getFragment: function(fragment) {
       if (fragment == null) {
-        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
-          fragment = decodeURI(this.location.pathname + this.location.search);
-          var root = this.root.replace(trailingSlash, '');
-          if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
+        if (this._hasPushState || !this._wantsHashChange) {
+          fragment = this.getPath();
         } else {
           fragment = this.getHash();
         }
@@ -1391,36 +1460,43 @@
       this.options          = _.extend({root: '/'}, this.options, options);
       this.root             = this.options.root;
       this._wantsHashChange = this.options.hashChange !== false;
+      this._hasHashChange   = 'onhashchange' in window;
       this._wantsPushState  = !!this.options.pushState;
       this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
-      var fragment          = this.getFragment();
-      var docMode           = document.documentMode;
-      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+      this.fragment         = this.getFragment();
+
+      // Add a cross-platform `addEventListener` shim for older browsers.
+      var addEventListener = window.addEventListener || function (eventName, listener) {
+        return attachEvent('on' + eventName, listener);
+      };
 
       // Normalize root to always include a leading and trailing slash.
       this.root = ('/' + this.root + '/').replace(rootStripper, '/');
 
-      if (oldIE && this._wantsHashChange) {
-        var frame = Backbone.$('<iframe src="javascript:0" tabindex="-1">');
-        this.iframe = frame.hide().appendTo('body')[0].contentWindow;
-        this.navigate(fragment);
+      // Proxy an iframe to handle location events if the browser doesn't
+      // support the `hashchange` event, HTML5 history, or the user wants
+      // `hashChange` but not `pushState`.
+      if (!this._hasHashChange && this._wantsHashChange && (!this._wantsPushState || !this._hasPushState)) {
+        var iframe = document.createElement('iframe');
+        iframe.src = 'javascript:0';
+        iframe.style.display = 'none';
+        iframe.tabIndex = -1;
+        var body = document.body;
+        // Using `appendChild` will throw on IE < 9 if the document is not ready.
+        this.iframe = body.insertBefore(iframe, body.firstChild).contentWindow;
+        this.navigate(this.fragment);
       }
 
       // Depending on whether we're using pushState or hashes, and whether
       // 'onhashchange' is supported, determine how we check the URL state.
       if (this._hasPushState) {
-        Backbone.$(window).on('popstate', this.checkUrl);
-      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
-        Backbone.$(window).on('hashchange', this.checkUrl);
+        addEventListener('popstate', this.checkUrl, false);
+      } else if (this._wantsHashChange && this._hasHashChange && !this.iframe) {
+        addEventListener('hashchange', this.checkUrl, false);
       } else if (this._wantsHashChange) {
         this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
       }
 
-      // Determine if we need to change the base url, for a pushState link
-      // opened by a non-pushState browser.
-      this.fragment = fragment;
-      var loc = this.location;
-
       // Transition from hashChange to pushState or vice versa if both are
       // requested.
       if (this._wantsHashChange && this._wantsPushState) {
@@ -1428,16 +1504,14 @@
         // If we've started off with a route from a `pushState`-enabled
         // browser, but we're currently in a browser that doesn't support it...
         if (!this._hasPushState && !this.atRoot()) {
-          this.fragment = this.getFragment(null, true);
-          this.location.replace(this.root + '#' + this.fragment);
+          this.location.replace(this.root + '#' + this.getPath());
           // Return immediately as browser will do redirect to new url
           return true;
 
         // Or if we've started out with a hash-based route, but we're currently
         // in a browser where it could be `pushState`-based instead...
-        } else if (this._hasPushState && this.atRoot() && loc.hash) {
-          this.fragment = this.getHash().replace(routeStripper, '');
-          this.history.replaceState({}, document.title, this.root + this.fragment);
+        } else if (this._hasPushState && this.atRoot()) {
+          this.navigate(this.getHash(), {replace: true});
         }
 
       }
@@ -1448,7 +1522,25 @@
     // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
     // but possibly useful for unit testing Routers.
     stop: function() {
-      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
+      // Add a cross-platform `removeEventListener` shim for older browsers.
+      var removeEventListener = window.removeEventListener || function (eventName, listener) {
+        return detachEvent('on' + eventName, listener);
+      };
+
+      // Remove window listeners.
+      if (this._hasPushState) {
+        removeEventListener('popstate', this.checkUrl, false);
+      } else if (this._wantsHashChange && this._hasHashChange && !this.iframe) {
+        removeEventListener('hashchange', this.checkUrl, false);
+      }
+
+      // Clean up the iframe if necessary.
+      if (this.iframe) {
+        document.body.removeChild(this.iframe.frameElement);
+        this.iframe = null;
+      }
+
+      // Some environments will throw when clearing an undefined interval.
       if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);
       History.started = false;
     },
@@ -1464,7 +1556,7 @@
     checkUrl: function(e) {
       var current = this.getFragment();
       if (current === this.fragment && this.iframe) {
-        current = this.getFragment(this.getHash(this.iframe));
+        current = this.getHash(this.iframe);
       }
       if (current === this.fragment) return false;
       if (this.iframe) this.navigate(current);
@@ -1497,8 +1589,8 @@
 
       var url = this.root + (fragment = this.getFragment(fragment || ''));
 
-      // Strip the hash for matching.
-      fragment = fragment.replace(pathStripper, '');
+      // Strip the hash and decode for matching.
+      fragment = decodeURI(fragment.replace(pathStripper, ''));
 
       if (this.fragment === fragment) return;
       this.fragment = fragment;
@@ -1514,7 +1606,7 @@
       // fragment to store history.
       } else if (this._wantsHashChange) {
         this._updateHash(this.location, fragment, options.replace);
-        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
+        if (this.iframe && (fragment !== this.getHash(this.iframe))) {
           // Opening and closing the iframe tricks IE7 and earlier to push a
           // history entry on hash-tag change.  When replace is true, we don't
           // want this.
diff --git a/vendor/backbone/test/collection.js b/vendor/backbone/test/collection.js
index 37be41707..8f518143d 100644
--- a/vendor/backbone/test/collection.js
+++ b/vendor/backbone/test/collection.js
@@ -60,6 +60,20 @@
     strictEqual(collection.last().get('a'), 4);
   });
 
+  test("clone preserves model and comparator", 3, function() {
+    var Model = Backbone.Model.extend();
+    var comparator = function(model){ return model.id; };
+
+    var collection = new Backbone.Collection([{id: 1}], {
+      model: Model,
+      comparator: comparator
+    }).clone();
+    collection.add({id: 2});
+    ok(collection.at(0) instanceof Model);
+    ok(collection.at(1) instanceof Model);
+    strictEqual(collection.comparator, comparator);
+  });
+
   test("get", 6, function() {
     equal(col.get(0), d);
     equal(col.get(d.clone()), d);
@@ -1335,4 +1349,20 @@
     equal(c.models.length, 1);
   });
 
+  test('#3020: #set with {add: false} should not throw.', 2, function() {
+    var collection = new Backbone.Collection;
+    collection.set([{id: 1}], {add: false});
+    strictEqual(collection.length, 0);
+    strictEqual(collection.models.length, 0);
+  });
+
+  test("create with wait, model instance, #3028", 1, function() {
+    var collection = new Backbone.Collection();
+    var model = new Backbone.Model({id: 1});
+    model.sync = function(){
+      equal(this.collection, collection);
+    };
+    collection.create(model, {wait: true});
+  });
+
 })();
diff --git a/vendor/backbone/test/router.js b/vendor/backbone/test/router.js
index 57e138d78..91df8740e 100644
--- a/vendor/backbone/test/router.js
+++ b/vendor/backbone/test/router.js
@@ -331,6 +331,36 @@
     Backbone.history.checkUrl();
   });
 
+  test("No events are triggered if #execute returns false.", 1, function() {
+    var Router = Backbone.Router.extend({
+
+      routes: {
+        foo: function() {
+          ok(true);
+        }
+      },
+
+      execute: function(callback, args) {
+        callback.apply(this, args);
+        return false;
+      }
+
+    });
+
+    var router = new Router;
+
+    router.on('route route:foo', function() {
+      ok(false);
+    });
+
+    Backbone.history.on('route', function() {
+      ok(false);
+    });
+
+    location.replace('http://example.com#foo');
+    Backbone.history.checkUrl();
+  });
+
   test("#933, #908 - leading slash", 2, function() {
     location.replace('http://example.com/root/foo');
 
@@ -375,7 +405,7 @@
     Backbone.history.navigate('charñ', {trigger: true});
     equal(router.charType, 'UTF');
     Backbone.history.navigate('char%C3%B1', {trigger: true});
-    equal(router.charType, 'escaped');
+    equal(router.charType, 'UTF');
   });
 
   test("#1185 - Use pathname when hashChange is not wanted.", 1, function() {
@@ -738,7 +768,7 @@
     var Router = Backbone.Router.extend({
       routes: {
         path: function(params){
-          strictEqual(params, 'x=y%20z');
+          strictEqual(params, 'x=y z');
         }
       }
     });
@@ -807,4 +837,49 @@
     Backbone.history.start({pushState: true});
   });
 
+  test('Router#execute receives callback, args, name.', 3, function() {
+    location.replace('http://example.com#foo/123/bar?x=y');
+    Backbone.history.stop();
+    Backbone.history = _.extend(new Backbone.History, {location: location});
+    var Router = Backbone.Router.extend({
+      routes: {'foo/:id/bar': 'foo'},
+      foo: function(){},
+      execute: function(callback, args, name) {
+        strictEqual(callback, this.foo);
+        deepEqual(args, ['123', 'x=y']);
+        strictEqual(name, 'foo');
+      }
+    });
+    var router = new Router;
+    Backbone.history.start();
+  });
+
+  test("pushState to hashChange with only search params.", 1, function() {
+    Backbone.history.stop();
+    location.replace('http://example.com?a=b');
+    location.replace = function(url) {
+      strictEqual(url, '/#?a=b');
+    };
+    Backbone.history = _.extend(new Backbone.History, {
+      location: location,
+      history: null
+    });
+    Backbone.history.start({pushState: true});
+  });
+
+  test("#3123 - History#navigate decodes before comparison.", 1, function() {
+    Backbone.history.stop();
+    location.replace('http://example.com/shop/search?keyword=short%20dress');
+    Backbone.history = _.extend(new Backbone.History, {
+      location: location,
+      history: {
+        pushState: function(){ ok(false); },
+        replaceState: function(){ ok(false); }
+      }
+    });
+    Backbone.history.start({pushState: true});
+    Backbone.history.navigate('shop/search?keyword=short%20dress', true);
+    strictEqual(Backbone.history.fragment, 'shop/search?keyword=short dress');
+  });
+
 })();
diff --git a/vendor/backbone/test/sync.js b/vendor/backbone/test/sync.js
index d54a7963b..29593d996 100644
--- a/vendor/backbone/test/sync.js
+++ b/vendor/backbone/test/sync.js
@@ -207,4 +207,15 @@
     strictEqual(this.ajaxSettings.beforeSend(xhr), false);
   });
 
+  test('#2928 - Pass along `textStatus` and `errorThrown`.', 2, function() {
+    var model = new Backbone.Model;
+    model.url = '/test';
+    model.on('error', function(model, xhr, options) {
+      strictEqual(options.textStatus, 'textStatus');
+      strictEqual(options.errorThrown, 'errorThrown');
+    });
+    model.fetch();
+    this.ajaxSettings.error({}, 'textStatus', 'errorThrown');
+  });
+
 })();
diff --git a/vendor/backbone/test/view.js b/vendor/backbone/test/view.js
index 76f0f1db1..392a50f79 100644
--- a/vendor/backbone/test/view.js
+++ b/vendor/backbone/test/view.js
@@ -20,10 +20,22 @@
     equal(view.el.other, void 0);
   });
 
-  test("jQuery", 1, function() {
+  test("$", 2, function() {
     var view = new Backbone.View;
     view.setElement('<p><a><b>test</b></a></p>');
-    strictEqual(view.$('a b').html(), 'test');
+    var result = view.$('a b');
+
+    strictEqual(result[0].innerHTML, 'test');
+    ok(result.length === +result.length);
+  });
+
+  test("$el", 3, function() {
+    var view = new Backbone.View;
+    view.setElement('<p><a><b>test</b></a></p>');
+    strictEqual(view.el.nodeType, 1);
+
+    ok(view.$el instanceof Backbone.$);
+    strictEqual(view.$el[0], view.el);
   });
 
   test("initialize", 1, function() {
@@ -60,6 +72,17 @@
     equal(counter2, 3);
   });
 
+  test("delegate", 2, function() {
+    var view = new Backbone.View({el: '#testElement'});
+    view.delegate('click', 'h1', function() {
+      ok(true);
+    });
+    view.delegate('click', function() {
+      ok(true);
+    });
+    view.$('h1').trigger('click');
+  });
+
   test("delegateEvents allows functions for callbacks", 3, function() {
     var view = new Backbone.View({el: '<p></p>'});
     view.counter = 0;
@@ -114,6 +137,63 @@
     equal(counter2, 3);
   });
 
+  test("undelegate", 0, function() {
+    view = new Backbone.View({el: '#testElement'});
+    view.delegate('click', function() { ok(false); });
+    view.delegate('click', 'h1', function() { ok(false); });
+
+    view.undelegate('click');
+
+    view.$('h1').trigger('click');
+    view.$el.trigger('click');
+  });
+
+  test("undelegate with passed handler", 1, function() {
+    view = new Backbone.View({el: '#testElement'});
+    var listener = function() { ok(false); };
+    view.delegate('click', listener);
+    view.delegate('click', function() { ok(true); });
+    view.undelegate('click', listener);
+    view.$el.trigger('click');
+  });
+
+  test("undelegate with selector", 2, function() {
+    view = new Backbone.View({el: '#testElement'});
+    view.delegate('click', function() { ok(true); });
+    view.delegate('click', 'h1', function() { ok(false); });
+    view.undelegate('click', 'h1');
+    view.$('h1').trigger('click');
+    view.$el.trigger('click');
+  });
+
+  test("undelegate with handler and selector", 2, function() {
+    view = new Backbone.View({el: '#testElement'});
+    view.delegate('click', function() { ok(true); });
+    var handler = function(){ ok(false); };
+    view.delegate('click', 'h1', handler);
+    view.undelegate('click', 'h1', handler);
+    view.$('h1').trigger('click');
+    view.$el.trigger('click');
+  });
+
+  test("tagName can be provided as a string", 1, function() {
+    var View = Backbone.View.extend({
+      tagName: 'span'
+    });
+
+    equal(new View().el.tagName, 'SPAN');
+  });
+
+  test("tagName can be provided as a function", 1, function() {
+    var View = Backbone.View.extend({
+      tagName: function() {
+        return 'p';
+      }
+    });
+
+    ok(new View().$el.is('p'));
+  });
+
   test("_ensureElement with DOM node el", 1, function() {
     var View = Backbone.View.extend({
       el: document.body
@@ -201,26 +281,19 @@
     equal(5, count);
   });
 
-  test("custom events, with namespaces", 2, function() {
-    var count = 0;
-
+  test("custom events", 2, function() {
     var View = Backbone.View.extend({
       el: $('body'),
-      events: function() {
-        return {"fake$event.namespaced": "run"};
-      },
-      run: function() {
-        count++;
+      events: {
+        "fake$event": function() { ok(true); }
       }
     });
 
     var view = new View;
     $('body').trigger('fake$event').trigger('fake$event');
-    equal(count, 2);
 
-    $('body').off('.namespaced');
+    $('body').off('fake$event');
     $('body').trigger('fake$event');
-    equal(count, 2);
   });
 
   test("#1048 - setElement uses provided object.", 2, function() {
@@ -264,21 +337,11 @@
     ok(!view2.el.id);
   });
 
-  test("#1228 - tagName can be provided as a function", 1, function() {
-    var View = Backbone.View.extend({
-      tagName: function() {
-        return 'p';
-      }
-    });
-
-    ok(new View().$el.is('p'));
-  });
-
   test("views stopListening", 0, function() {
     var View = Backbone.View.extend({
       initialize: function() {
-        this.listenTo(this.model, 'all x', function(){ ok(false); }, this);
-        this.listenTo(this.collection, 'all x', function(){ ok(false); }, this);
+        this.listenTo(this.model, 'all x', function(){ ok(false); });
+        this.listenTo(this.collection, 'all x', function(){ ok(false); });
       }
     });
 
@@ -324,4 +387,19 @@
     equal(counter, 2);
   });
 
+  test("remove", 1, function() {
+    var view = new Backbone.View;
+    document.body.appendChild(view.el);
+
+    view.delegate('click', function() { ok(false); });
+    view.listenTo(view, 'all x', function() { ok(false); });
+
+    view.remove();
+    view.$el.trigger('click');
+    view.trigger('x');
+
+    // In IE8 and below, parentNode still exists but is not document.body.
+    notEqual(view.el.parentNode, document.body);
+  });
+
 })();
diff --git a/vendor/qunit-extras/qunit-extras.js b/vendor/qunit-extras/qunit-extras.js
index 048e111d5..1f1a7a51e 100644
--- a/vendor/qunit-extras/qunit-extras.js
+++ b/vendor/qunit-extras/qunit-extras.js
@@ -84,6 +84,19 @@
     return false;
   }
 
+  /**
+   * Checks if `value` is the language type of `Object`.
+   * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+   */
+  function isObject(value) {
+    var type = typeof value;
+    return type == 'function' || (value && type == 'object') || false;
+  }
+
   /**
    * Creates a string with `text` repeated `n` number of times.
    *
@@ -151,25 +164,18 @@
         modulePrinted;
 
     /** Object shortcuts */
-    var console = context.console,
-        phantom = context.phantom,
-        process = phantom || context.process,
+    var phantom = context.phantom,
+        define = context.define,
         document = !phantom && context.document,
-        java = !document && context.java;
+        process = phantom || context.process,
+        amd = define && define.amd,
+        console = context.console,
+        java = !document && context.java,
+        print = context.print,
+        require = context.require;
 
-    /** Detect the OS of the platform */
-    var os = (function() {
-      if (java) {
-        return java.lang.System.getProperty('os.name');
-      }
-      if (phantom) {
-        return require('system').os.name;
-      }
-      if (process) {
-        return process.platform;
-      }
-      return '';
-    }());
+    /** Detects if running on Node.js */
+    var isNode = isObject(process) && typeof process.on == 'function';
 
     /** Detects if running in a PhantomJS web page */
     var isPhantomPage = typeof context.callPhantom == 'function';
@@ -178,7 +184,18 @@
     var isSilent = document && !isPhantomPage;
 
     /** Used to indicate if running in Windows */
-    var isWindows = /\bwin/i.test(os);
+    var isWindows = isNode && process.platform == 'win32';
+
+    /** Used to indicate if ANSI escape codes are supported */
+    var isAnsiSupported = (function() {
+      if (isNode && process.stdout && !process.stdout.isTTY) {
+        return false;
+      }
+      if (isWindows || getEnv('COLORTERM')) {
+        return true;
+      }
+      return /^(?:ansi|cygwin|linux|screen|xterm|vt100)$|color/i.test(getEnv('TERM'));
+    }());
 
     /** Used to display the wait throbber */
     var throbberDelay = 500,
@@ -267,6 +284,27 @@
 
     /*------------------------------------------------------------------------*/
 
+    /**
+     * Gets the environment variable value by a given name.
+     *
+     * @private
+     * @param {string} name The name of the environment variable to get.
+     * @returns {*} Returns the environment variable value.
+     */
+    function getEnv(name) {
+      if (isNode) {
+        return process.env[name];
+      }
+      if (java) {
+        return java.lang.System.getenv(name);
+      }
+      if (!amd && typeof require == 'function') {
+        try {
+          return require('system').env[name];
+        } catch(e) { }
+      }
+    }
+
     /**
      * Adds text color to the terminal output of `string`.
      *
@@ -276,10 +314,9 @@
      * @returns {string} Returns the colored string.
      */
     function color(colorName, string) {
-      var code = ansiCodes[colorName];
-      return isWindows
-        ? string
-        : ('\x1B[' + code + 'm' + string + '\x1B[0m');
+      return isAnsiSupported
+        ? ('\x1B[' + ansiCodes[colorName] + 'm' + string + '\x1B[0m')
+        : string;
     }
 
     /**
@@ -289,9 +326,7 @@
      * @param {string} [text=''] The text to log.
      */
     var logInline = (function() {
-      // exit early if not Node.js
-      if (!(typeof process == 'object' && process &&
-          process.on && process.stdout && process.platform != 'win32')) {
+      if (!isNode || isWindows) {
         return function() {};
       }
       // cleanup any inline logs when exited via `ctrl+c`
@@ -613,7 +648,11 @@
 
       // add `console.log` support to Narwhal, Rhino, and RingoJS
       if (!console) {
-        console = context.console = { 'log': context.print };
+        console = context.console = { 'log': function() {} };
+      }
+      // RingoJS removes ANSI escape codes in `console.log`, but not in `print`
+      if (java && typeof print == 'function') {
+        console.log = print;
       }
       // start log throbber
       if (!isSilent) {
diff --git a/vendor/underscore/test/arrays.js b/vendor/underscore/test/arrays.js
index 4f3f72788..ae640f691 100644
--- a/vendor/underscore/test/arrays.js
+++ b/vendor/underscore/test/arrays.js
@@ -3,16 +3,16 @@
   module('Arrays');
 
   test('first', function() {
-    equal(_.first([1,2,3]), 1, 'can pull out the first element of an array');
+    equal(_.first([1, 2, 3]), 1, 'can pull out the first element of an array');
     equal(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
     deepEqual(_.first([1, 2, 3], 0), [], 'can pass an index to first');
     deepEqual(_.first([1, 2, 3], 2), [1, 2], 'can pass an index to first');
     deepEqual(_.first([1, 2, 3], 5), [1, 2, 3], 'can pass an index to first');
     var result = (function(){ return _.first(arguments); })(4, 3, 2, 1);
     equal(result, 4, 'works on an arguments object.');
-    result = _.map([[1,2,3],[1,2,3]], _.first);
+    result = _.map([[1, 2, 3], [1, 2, 3]], _.first);
     deepEqual(result, [1, 1], 'works well with _.map');
-    result = (function() { return _.take([1,2,3], 2); })();
+    result = (function() { return _.take([1, 2, 3], 2); })();
     deepEqual(result, [1, 2], 'aliased as take');
 
     equal(_.first(null), undefined, 'handles nulls');
@@ -26,7 +26,7 @@
     deepEqual(_.rest(numbers, 2), [3, 4], 'rest can take an index');
     var result = (function(){ return _(arguments).tail(); })(1, 2, 3, 4);
     deepEqual(result, [2, 3, 4], 'aliased as tail and works on arguments object');
-    result = _.map([[1,2,3],[1,2,3]], _.rest);
+    result = _.map([[1, 2, 3], [1, 2, 3]], _.rest);
     deepEqual(_.flatten(result), [2, 3, 2, 3], 'works well with _.map');
     result = (function(){ return _(arguments).drop(); })(1, 2, 3, 4);
     deepEqual(result, [2, 3, 4], 'aliased as drop and works on arguments object');
@@ -38,18 +38,18 @@
     deepEqual(_.initial([1, 2, 3, 4], 6), [], 'initial can take a large index');
     var result = (function(){ return _(arguments).initial(); })(1, 2, 3, 4);
     deepEqual(result, [1, 2, 3], 'initial works on arguments object');
-    result = _.map([[1,2,3],[1,2,3]], _.initial);
+    result = _.map([[1, 2, 3], [1, 2, 3]], _.initial);
     deepEqual(_.flatten(result), [1, 2, 1, 2], 'initial works with _.map');
   });
 
   test('last', function() {
-    equal(_.last([1,2,3]), 3, 'can pull out the last element of an array');
+    equal(_.last([1, 2, 3]), 3, 'can pull out the last element of an array');
     deepEqual(_.last([1, 2, 3], 0), [], 'can pass an index to last');
     deepEqual(_.last([1, 2, 3], 2), [2, 3], 'can pass an index to last');
     deepEqual(_.last([1, 2, 3], 5), [1, 2, 3], 'can pass an index to last');
     var result = (function(){ return _(arguments).last(); })(1, 2, 3, 4);
     equal(result, 4, 'works on an arguments object');
-    result = _.map([[1,2,3],[1,2,3]], _.last);
+    result = _.map([[1, 2, 3], [1, 2, 3]], _.last);
     deepEqual(result, [3, 3], 'works well with _.map');
 
     equal(_.last(null), undefined, 'handles nulls');
@@ -64,10 +64,10 @@
 
   test('flatten', function() {
     var list = [1, [2], [3, [[[4]]]]];
-    deepEqual(_.flatten(list), [1,2,3,4], 'can flatten nested arrays');
-    deepEqual(_.flatten(list, true), [1,2,3,[[[4]]]], 'can shallowly flatten nested arrays');
+    deepEqual(_.flatten(list), [1, 2, 3, 4], 'can flatten nested arrays');
+    deepEqual(_.flatten(list, true), [1, 2, 3, [[[4]]]], 'can shallowly flatten nested arrays');
     var result = (function(){ return _.flatten(arguments); })(1, [2], [3, [[[4]]]]);
-    deepEqual(result, [1,2,3,4], 'works on an arguments object');
+    deepEqual(result, [1, 2, 3, 4], 'works on an arguments object');
     list = [[1], [2], [3], [[4]]];
     deepEqual(_.flatten(list, true), [1, 2, 3, [4]], 'can shallowly flatten arrays containing only other arrays');
   });
@@ -90,7 +90,7 @@
     list = [1, 1, 1, 2, 2, 3];
     deepEqual(_.uniq(list, true), [1, 2, 3], 'can find the unique values of a sorted array faster');
 
-    list = [{name:'moe'}, {name:'curly'}, {name:'larry'}, {name:'curly'}];
+    list = [{name: 'moe'}, {name: 'curly'}, {name: 'larry'}, {name: 'curly'}];
     var iterator = function(value) { return value.name; };
     deepEqual(_.map(_.uniq(list, false, iterator), iterator), ['moe', 'curly', 'larry'], 'can find the unique values of an array using a custom iterator');
 
@@ -161,16 +161,19 @@
 
   test('zip', function() {
     var names = ['moe', 'larry', 'curly'], ages = [30, 40, 50], leaders = [true];
-    var stooges = _.zip(names, ages, leaders);
-    equal(String(stooges), 'moe,30,true,larry,40,,curly,50,', 'zipped together arrays of different lengths');
+    deepEqual(_.zip(names, ages, leaders), [
+      ['moe', 30, true],
+      ['larry', 40, undefined],
+      ['curly', 50, undefined]
+    ], 'zipped together arrays of different lengths');
 
-    stooges = _.zip(['moe',30, 'stooge 1'],['larry',40, 'stooge 2'],['curly',50, 'stooge 3']);
-    deepEqual(stooges, [['moe','larry','curly'],[30,40,50], ['stooge 1', 'stooge 2', 'stooge 3']], 'zipped pairs');
+    var stooges = _.zip(['moe', 30, 'stooge 1'], ['larry', 40, 'stooge 2'], ['curly', 50, 'stooge 3']);
+    deepEqual(stooges, [['moe', 'larry', 'curly'], [30, 40, 50], ['stooge 1', 'stooge 2', 'stooge 3']], 'zipped pairs');
 
     // In the case of difference lengths of the tuples undefineds
     // should be used as placeholder
-    stooges = _.zip(['moe',30],['larry',40],['curly',50, 'extra data']);
-    deepEqual(stooges, [['moe','larry','curly'],[30,40,50], [undefined, undefined, 'extra data']], 'zipped pairs with empties');
+    stooges = _.zip(['moe', 30], ['larry', 40], ['curly', 50, 'extra data']);
+    deepEqual(stooges, [['moe', 'larry', 'curly'], [30, 40, 50], [undefined, undefined, 'extra data']], 'zipped pairs with empties');
 
     var empty = _.zip([]);
     deepEqual(empty, [], 'unzipped empty');
diff --git a/vendor/underscore/test/chaining.js b/vendor/underscore/test/chaining.js
index c23e82889..0f377e2bc 100644
--- a/vendor/underscore/test/chaining.js
+++ b/vendor/underscore/test/chaining.js
@@ -21,7 +21,7 @@
   });
 
   test('select/reject/sortBy', function() {
-    var numbers = [1,2,3,4,5,6,7,8,9,10];
+    var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     numbers = _(numbers).chain().select(function(n) {
       return n % 2 === 0;
     }).reject(function(n) {
@@ -33,7 +33,7 @@
   });
 
   test('select/reject/sortBy in functional style', function() {
-    var numbers = [1,2,3,4,5,6,7,8,9,10];
+    var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     numbers = _.chain(numbers).select(function(n) {
       return n % 2 === 0;
     }).reject(function(n) {
@@ -45,7 +45,7 @@
   });
 
   test('reverse/concat/unshift/pop/map', function() {
-    var numbers = [1,2,3,4,5];
+    var numbers = [1, 2, 3, 4, 5];
     numbers = _(numbers).chain()
       .reverse()
       .concat([5, 5, 5])
diff --git a/vendor/underscore/test/collections.js b/vendor/underscore/test/collections.js
index c8fa73b8d..ad9fa4bc2 100644
--- a/vendor/underscore/test/collections.js
+++ b/vendor/underscore/test/collections.js
@@ -221,10 +221,10 @@
   });
 
   test('include', function() {
-    ok(_.include([1,2,3], 2), 'two is in the array');
-    ok(!_.include([1,3,9], 2), 'two is not in the array');
-    ok(_.contains({moe:1, larry:3, curly:9}, 3) === true, '_.include on objects checks their values');
-    ok(_([1,2,3]).include(2), 'OO-style include');
+    ok(_.include([1, 2, 3], 2), 'two is in the array');
+    ok(!_.include([1, 3, 9], 2), 'two is not in the array');
+    ok(_.contains({moe: 1, larry: 3, curly: 9}, 3) === true, '_.include on objects checks their values');
+    ok(_([1, 2, 3]).include(2), 'OO-style include');
   });
 
   test('invoke', function() {
@@ -280,10 +280,10 @@
     result = _.findWhere(list, {b: 4});
     deepEqual(result, {a: 1, b: 4});
 
-    result = _.findWhere(list, {c:1})
+    result = _.findWhere(list, {c: 1})
     ok(_.isUndefined(result), 'undefined when not found');
 
-    result = _.findWhere([], {c:1});
+    result = _.findWhere([], {c: 1});
     ok(_.isUndefined(result), 'undefined when searching empty list');
   });
 
@@ -297,10 +297,15 @@
     equal(-Infinity, _.max([]), 'Maximum value of an empty array');
     equal(_.max({'a': 'a'}), -Infinity, 'Maximum value of a non-numeric collection');
 
-    equal(299999, _.max(_.range(1,300000)), 'Maximum value of a too-big array');
+    equal(299999, _.max(_.range(1, 300000)), 'Maximum value of a too-big array');
 
     equal(3, _.max([1, 2, 3, 'test']), 'Finds correct max in array starting with num and containing a NaN');
     equal(3, _.max(['test', 1, 2, 3]), 'Finds correct max in array starting with NaN');
+
+    var a = {x: -Infinity};
+    var b = {x: -Infinity};
+    var iterator = function(o){ return o.x; };
+    equal(_.max([a, b], iterator), a, 'Respects iterator return value of -Infinity');
   });
 
   test('min', function() {
@@ -317,10 +322,15 @@
     var then = new Date(0);
     equal(_.min([now, then]), then);
 
-    equal(1, _.min(_.range(1,300000)), 'Minimum value of a too-big array');
+    equal(1, _.min(_.range(1, 300000)), 'Minimum value of a too-big array');
 
     equal(1, _.min([1, 2, 3, 'test']), 'Finds correct min in array starting with num and containing a NaN');
     equal(1, _.min(['test', 1, 2, 3]), 'Finds correct min in array starting with NaN');
+
+    var a = {x: Infinity};
+    var b = {x: Infinity};
+    var iterator = function(o){ return o.x; };
+    equal(_.min([a, b], iterator), a, 'Respects iterator return value of Infinity');
   });
 
   test('sortBy', function() {
@@ -391,12 +401,12 @@
     equal(grouped['3'].length, 1);
 
     var matrix = [
-      [1,2],
-      [1,3],
-      [2,3]
+      [1, 2],
+      [1, 3],
+      [2, 3]
     ];
-    deepEqual(_.groupBy(matrix, 0), {1: [[1,2], [1,3]], 2: [[2,3]]})
-    deepEqual(_.groupBy(matrix, 1), {2: [[1,2]], 3: [[1,3], [2,3]]})
+    deepEqual(_.groupBy(matrix, 0), {1: [[1, 2], [1, 3]], 2: [[2, 3]]})
+    deepEqual(_.groupBy(matrix, 1), {2: [[1, 2]], 3: [[1, 3], [2, 3]]})
   });
 
   test('indexBy', function() {
@@ -488,7 +498,7 @@
   test('toArray', function() {
     ok(!_.isArray(arguments), 'arguments object is not an array');
     ok(_.isArray(_.toArray(arguments)), 'arguments object converted into array');
-    var a = [1,2,3];
+    var a = [1, 2, 3];
     ok(_.toArray(a) !== a, 'array is cloned');
     deepEqual(_.toArray(a), [1, 2, 3], 'cloned array contains same elements');
 
@@ -522,13 +532,16 @@
 
   test('partition', function() {
     var list = [0, 1, 2, 3, 4, 5];
-    deepEqual(_.partition(list, function(x) { return x < 4; }), [[0,1,2,3],[4,5]], 'handles bool return values');
-    deepEqual(_.partition(list, function(x) { return x & 1; }), [[1,3,5],[0,2,4]], 'handles 0 and 1 return values');
-    deepEqual(_.partition(list, function(x) { return x - 3; }), [[0,1,2,4,5],[3]], 'handles other numeric return values');
-    deepEqual(_.partition(list, function(x) { return x > 1 ? null : true; }), [[0,1],[2,3,4,5]], 'handles null return values');
-    deepEqual(_.partition(list, function(x) { if(x < 2) return true; }), [[0,1],[2,3,4,5]], 'handles undefined return values');
+    deepEqual(_.partition(list, function(x) { return x < 4; }), [[0, 1, 2, 3], [4, 5]], 'handles bool return values');
+    deepEqual(_.partition(list, function(x) { return x & 1; }), [[1, 3, 5], [0, 2, 4]], 'handles 0 and 1 return values');
+    deepEqual(_.partition(list, function(x) { return x - 3; }), [[0, 1, 2, 4, 5], [3]], 'handles other numeric return values');
+    deepEqual(_.partition(list, function(x) { return x > 1 ? null : true; }), [[0, 1], [2, 3, 4, 5]], 'handles null return values');
+    deepEqual(_.partition(list, function(x) { if(x < 2) return true; }), [[0, 1], [2, 3, 4, 5]], 'handles undefined return values');
     deepEqual(_.partition({a: 1, b: 2, c: 3}, function(x) { return x > 1; }), [[2, 3], [1]], 'handles objects');
 
+    deepEqual(_.partition(list, function(x, index) { return index % 2; }), [[1, 3, 5], [0, 2, 4]], 'can reference the array index');
+    deepEqual(_.partition(list, function(x, index, arr) { return x === arr.length - 1; }), [[5], [0, 1, 2, 3, 4]], 'can reference the collection');
+
     // Default iterator
     deepEqual(_.partition([1, false, true, '']), [[1, true], [false, '']], 'Default iterator');
     deepEqual(_.partition([{x: 1}, {x: 0}, {x: 1}], 'x'), [[{x: 1}, {x: 1}], [{x: 0}]], 'Takes a string');
diff --git a/vendor/underscore/test/functions.js b/vendor/underscore/test/functions.js
index f0db7e57c..cf03cda1f 100644
--- a/vendor/underscore/test/functions.js
+++ b/vendor/underscore/test/functions.js
@@ -38,6 +38,8 @@
     equal(newBoundf.hello, undefined, 'function should not be bound to the context, to comply with ECMAScript 5');
     equal(Boundf().hello, 'moe curly', "When called without the new operator, it's OK to be bound to the context");
     ok(newBoundf instanceof F, 'a bound instance is an instance of the original function');
+
+    raises(function() { _.bind('notafunction'); }, TypeError, 'throws an error when binding to a non-function');
   });
 
   test('partial', function() {
@@ -98,6 +100,17 @@
     var fastO = _.memoize(o);
     equal(o('toString'), 'toString', 'checks hasOwnProperty');
     equal(fastO('toString'), 'toString', 'checks hasOwnProperty');
+
+    // Expose the cache.
+    var upper = _.memoize(function(s) {
+      return s.toUpperCase();
+    });
+    equal(upper('foo'), 'FOO');
+    equal(upper('bar'), 'BAR');
+    deepEqual(upper.cache, {foo: 'FOO', bar: 'BAR'});
+    upper.cache = {foo: 'BAR', bar: 'FOO'};
+    equal(upper('foo'), 'BAR');
+    equal(upper('bar'), 'FOO');
   });
 
   asyncTest('delay', 2, function() {
@@ -298,6 +311,29 @@
     }, 200);
   });
 
+  asyncTest('throttle re-entrant', 2, function() {
+    var sequence = [
+      ['b1', 'b2'],
+      ['c1', 'c2']
+    ];
+    var value = '';
+    var throttledAppend;
+    var append = function(arg){
+      value += this + arg;
+      var args = sequence.pop()
+      if (args) {
+        throttledAppend.call(args[0], args[1]);
+      }
+    };
+    throttledAppend = _.throttle(append, 32);
+    throttledAppend.call('a1', 'a2');
+    equal(value, 'a1a2');
+    _.delay(function(){
+      equal(value, 'a1a2c1c2b1b2', 'append was throttled successfully');
+      start();
+    }, 100);
+  });
+
   asyncTest('debounce', 1, function() {
     var counter = 0;
     var incr = function(){ counter++; };
@@ -353,7 +389,29 @@
       equal(counter, 2, 'incr was debounced successfully');
       start();
       _.now = origNowFunc;
-    },200);
+    }, 200);
+  });
+
+  asyncTest('debounce re-entrant', 2, function() {
+    var sequence = [
+      ['b1', 'b2']
+    ];
+    var value = '';
+    var debouncedAppend;
+    var append = function(arg){
+      value += this + arg;
+      var args = sequence.pop()
+      if (args) {
+        debouncedAppend.call(args[0], args[1]);
+      }
+    };
+    debouncedAppend = _.debounce(append, 32);
+    debouncedAppend.call('a1', 'a2');
+    equal(value, '');
+    _.delay(function(){
+      equal(value, 'a1a2b1b2', 'append was debounced successfully');
+      start();
+    }, 100);
   });
 
   test('once', function() {
diff --git a/vendor/underscore/test/objects.js b/vendor/underscore/test/objects.js
index 15cd31158..c29cd6d4a 100644
--- a/vendor/underscore/test/objects.js
+++ b/vendor/underscore/test/objects.js
@@ -44,22 +44,25 @@
 
   test('extend', function() {
     var result;
-    equal(_.extend({}, {a:'b'}).a, 'b', 'can extend an object with the attributes of another');
-    equal(_.extend({a:'x'}, {a:'b'}).a, 'b', 'properties in source override destination');
-    equal(_.extend({x:'x'}, {a:'b'}).x, 'x', "properties not in source don't get overriden");
-    result = _.extend({x:'x'}, {a:'a'}, {b:'b'});
-    ok(_.isEqual(result, {x:'x', a:'a', b:'b'}), 'can extend from multiple source objects');
-    result = _.extend({x:'x'}, {a:'a', x:2}, {a:'b'});
-    ok(_.isEqual(result, {x:2, a:'b'}), 'extending from multiple source objects last property trumps');
+    equal(_.extend({}, {a: 'b'}).a, 'b', 'can extend an object with the attributes of another');
+    equal(_.extend({a: 'x'}, {a: 'b'}).a, 'b', 'properties in source override destination');
+    equal(_.extend({x: 'x'}, {a: 'b'}).x, 'x', "properties not in source don't get overriden");
+    result = _.extend({x: 'x'}, {a: 'a'}, {b: 'b'});
+    ok(_.isEqual(result, {x: 'x', a: 'a', b: 'b'}), 'can extend from multiple source objects');
+    result = _.extend({x: 'x'}, {a: 'a', x: 2}, {a: 'b'});
+    ok(_.isEqual(result, {x: 2, a: 'b'}), 'extending from multiple source objects last property trumps');
     result = _.extend({}, {a: void 0, b: null});
     deepEqual(_.keys(result), ['a', 'b'], 'extend copies undefined values');
 
     try {
       result = {};
-      _.extend(result, null, undefined, {a:1});
+      _.extend(result, null, undefined, {a: 1});
     } catch(ex) {}
 
     equal(result.a, 1, 'should not error on `null` or `undefined` sources');
+
+    strictEqual(_.extend(null, {a: 1}), null, 'extending null results in null');
+    strictEqual(_.extend(undefined, {a: 1}), undefined, 'extending undefined results in undefined');
   });
 
   test('pick', function() {
@@ -129,10 +132,13 @@
 
     try {
       options = {};
-      _.defaults(options, null, undefined, {a:1});
+      _.defaults(options, null, undefined, {a: 1});
     } catch(ex) {}
 
     equal(options.a, 1, 'should not error on `null` or `undefined` sources');
+
+    strictEqual(_.defaults(null, {a: 1}), null, 'result is null if destination is null');
+    strictEqual(_.defaults(undefined, {a: 1}), undefined, 'result is undefined if destination is undefined');
   });
 
   test('clone', function() {
@@ -350,7 +356,7 @@
     // More circular objects #767.
     a = {everything: 'is checked', but: 'this', is: 'not'};
     a.but = a;
-    b = {everything: 'is checked', but: {that:'object'}, is: 'not'};
+    b = {everything: 'is checked', but: {that: 'object'}, is: 'not'};
     ok(!_.isEqual(a, b), 'Comparison of circular references with non-circular object references are not equal');
 
     // Cyclic Structures.
@@ -453,7 +459,7 @@
     ok(!_.isArguments(_.isArguments), 'a function is not an arguments object');
     ok(_.isArguments(args), 'but the arguments object is an arguments object');
     ok(!_.isArguments(_.toArray(args)), 'but not when it\'s converted into an array');
-    ok(!_.isArguments([1,2,3]), 'and not vanilla arrays.');
+    ok(!_.isArguments([1, 2, 3]), 'and not vanilla arrays.');
     ok(_.isArguments(iArguments), 'even from another frame');
   });
 
@@ -596,7 +602,7 @@
     equal(intercepted, 1, 'passes tapped object to interceptor');
     equal(returned, 1, 'returns tapped object');
 
-    returned = _([1,2,3]).chain().
+    returned = _([1, 2, 3]).chain().
       map(function(n){ return n * 2; }).
       max().
       tap(interceptor).
@@ -614,6 +620,8 @@
     var child = {};
     child.prototype = obj;
     ok(_.has(child, "foo") == false, "has() does not check the prototype chain for a property.");
+    strictEqual(_.has(null, 'foo'), false, 'has() returns false for null');
+    strictEqual(_.has(undefined, 'foo'), false, 'has() returns false for undefined');
   });
 
   test("matches", function() {
diff --git a/vendor/underscore/test/utility.js b/vendor/underscore/test/utility.js
index a370750a8..bfa2a1110 100644
--- a/vendor/underscore/test/utility.js
+++ b/vendor/underscore/test/utility.js
@@ -67,11 +67,11 @@
   test('times', function() {
     var vals = [];
     _.times(3, function (i) { vals.push(i); });
-    ok(_.isEqual(vals, [0,1,2]), 'is 0 indexed');
+    ok(_.isEqual(vals, [0, 1, 2]), 'is 0 indexed');
     //
     vals = [];
     _(3).times(function(i) { vals.push(i); });
-    ok(_.isEqual(vals, [0,1,2]), 'works as a wrapper');
+    ok(_.isEqual(vals, [0, 1, 2]), 'works as a wrapper');
     // collects return values
     ok(_.isEqual([0, 1, 2], _.times(3, function(i) { return i; })), 'collects return values');
 
diff --git a/vendor/underscore/underscore.js b/vendor/underscore/underscore.js
index b68279acc..776c5c5ae 100644
--- a/vendor/underscore/underscore.js
+++ b/vendor/underscore/underscore.js
@@ -232,7 +232,7 @@
     } else {
       _.each(obj, function(value, index, list) {
         computed = iterator ? iterator.call(context, value, index, list) : value;
-        if (computed > lastComputed) {
+        if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {
           result = value;
           lastComputed = computed;
         }
@@ -255,7 +255,7 @@
     } else {
       _.each(obj, function(value, index, list) {
         computed = iterator ? iterator.call(context, value, index, list) : value;
-        if (computed < lastComputed) {
+        if (computed < lastComputed || (computed === Infinity && result === Infinity)) {
           result = value;
           lastComputed = computed;
         }
@@ -326,7 +326,7 @@
       iterator = lookupIterator(iterator, context);
       _.each(obj, function(value, index) {
         var key = iterator(value, index, obj);
-        behavior(result, key, value);
+        behavior(result, value, key);
       });
       return result;
     };
@@ -334,20 +334,20 @@
 
   // 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, key, value) {
+  _.groupBy = group(function(result, value, key) {
     _.has(result, key) ? result[key].push(value) : result[key] = [value];
   });
 
   // Indexes the object's values by a criterion, similar to `groupBy`, but for
   // when you know that your index values will be unique.
-  _.indexBy = group(function(result, key, value) {
+  _.indexBy = group(function(result, value, key) {
     result[key] = value;
   });
 
   // Counts instances of an object that group by a certain criterion. Pass
   // either a string attribute to count by, or a function that returns the
   // criterion.
-  _.countBy = group(function(result, key) {
+  _.countBy = group(function(result, value, key) {
     _.has(result, key) ? result[key]++ : result[key] = 1;
   });
 
@@ -453,8 +453,8 @@
   _.partition = function(obj, predicate, context) {
     predicate = lookupIterator(predicate, context);
     var pass = [], fail = [];
-    _.each(obj, function(elem) {
-      (predicate(elem) ? pass : fail).push(elem);
+    _.each(obj, function(value, key, obj) {
+      (predicate(value, key, obj) ? pass : fail).push(value);
     });
     return [pass, fail];
   };
@@ -600,7 +600,7 @@
   _.bind = function(func, context) {
     var args, bound;
     if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
-    if (!_.isFunction(func)) throw new TypeError;
+    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
     args = slice.call(arguments, 2);
     return bound = function() {
       if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
@@ -641,12 +641,15 @@
 
   // Memoize an expensive function by storing its results.
   _.memoize = function(func, hasher) {
-    var memo = {};
-    hasher || (hasher = _.identity);
-    return function() {
+    if (!hasher) hasher = _.identity;
+    var memoize = function() {
+      var cache = memoize.cache;
       var key = hasher.apply(this, arguments);
-      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
+      if (!_.has(cache, key)) cache[key] = func.apply(this, arguments);
+      return cache[key];
     };
+    memoize.cache = {};
+    return memoize;
   };
 
   // Delays a function for the given number of milliseconds, and then calls
@@ -676,7 +679,7 @@
       previous = options.leading === false ? 0 : _.now();
       timeout = null;
       result = func.apply(context, args);
-      context = args = null;
+      if (!timeout) context = args = null;
     };
     return function() {
       var now = _.now();
@@ -689,7 +692,7 @@
         timeout = null;
         previous = now;
         result = func.apply(context, args);
-        context = args = null;
+        if (!timeout) context = args = null;
       } else if (!timeout && options.trailing !== false) {
         timeout = setTimeout(later, remaining);
       }
@@ -713,7 +716,7 @@
         timeout = null;
         if (!immediate) {
           result = func.apply(context, args);
-          context = args = null;
+          if (!timeout) context = args = null;
         }
       }
     };
@@ -723,9 +726,7 @@
       args = arguments;
       timestamp = _.now();
       var callNow = immediate && !timeout;
-      if (!timeout) {
-        timeout = setTimeout(later, wait);
-      }
+      if (!timeout) timeout = setTimeout(later, wait);
       if (callNow) {
         result = func.apply(context, args);
         context = args = null;
@@ -841,11 +842,10 @@
 
   // Extend a given object with all the properties in passed-in object(s).
   _.extend = function(obj) {
+    if (!_.isObject(obj)) return obj;
     _.each(slice.call(arguments, 1), function(source) {
-      if (source) {
-        for (var prop in source) {
-          obj[prop] = source[prop];
-        }
+      for (var prop in source) {
+        obj[prop] = source[prop];
       }
     });
     return obj;
@@ -883,11 +883,10 @@
 
   // Fill in a given object with default properties.
   _.defaults = function(obj) {
+    if (!_.isObject(obj)) return obj;
     _.each(slice.call(arguments, 1), function(source) {
-      if (source) {
-        for (var prop in source) {
-          if (obj[prop] === void 0) obj[prop] = source[prop];
-        }
+      for (var prop in source) {
+        if (obj[prop] === void 0) obj[prop] = source[prop];
       }
     });
     return obj;
@@ -1040,7 +1039,7 @@
   // there isn't any inspectable "Arguments" type.
   if (!_.isArguments(arguments)) {
     _.isArguments = function(obj) {
-      return !!(obj && _.has(obj, 'callee'));
+      return _.has(obj, 'callee');
     };
   }
 
@@ -1079,7 +1078,7 @@
   // 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 hasOwnProperty.call(obj, key);
+    return obj != null && hasOwnProperty.call(obj, key);
   };
 
   // Utility Functions