diff --git a/static/scripts/libs/backbone/backbone-relational.js b/static/scripts/libs/backbone/backbone-relational.js
index 62b48eee968..4f2910b845d 100644
--- a/static/scripts/libs/backbone/backbone-relational.js
+++ b/static/scripts/libs/backbone/backbone-relational.js
@@ -1,14 +1,15 @@
+/* vim: set tabstop=4 softtabstop=4 shiftwidth=4 noexpandtab: */
 /**
- * Backbone-relational.js 0.5.0
- * (c) 2011 Paul Uithol
+ * Backbone-relational.js 0.8.0
+ * (c) 2011-2013 Paul Uithol and contributors (https://github.com/PaulUithol/Backbone-relational/graphs/contributors)
  * 
- * Backbone-relational may be freely distributed under the MIT license.
+ * Backbone-relational may be freely distributed under the MIT license; see the accompanying LICENSE.txt.
  * For details and documentation: https://github.com/PaulUithol/Backbone-relational.
- * Depends on Backbone: https://github.com/documentcloud/backbone.
+ * Depends on Backbone (and thus on Underscore as well): https://github.com/documentcloud/backbone.
  */
 ( function( undefined ) {
 	"use strict";
-	
+
 	/**
 	 * CommonJS shim
 	 **/
@@ -34,7 +35,7 @@
 	Backbone.Semaphore = {
 		_permitsAvailable: null,
 		_permitsUsed: 0,
-		
+
 		acquire: function() {
 			if ( this._permitsAvailable && this._permitsUsed >= this._permitsAvailable ) {
 				throw new Error( 'Max permits acquired' );
@@ -43,7 +44,7 @@
 				this._permitsUsed++;
 			}
 		},
-		
+
 		release: function() {
 			if ( this._permitsUsed === 0 ) {
 				throw new Error( 'All permits released' );
@@ -52,11 +53,11 @@
 				this._permitsUsed--;
 			}
 		},
-		
+
 		isLocked: function() {
 			return this._permitsUsed > 0;
 		},
-		
+
 		setAvailablePermits: function( amount ) {
 			if ( this._permitsUsed > amount ) {
 				throw new Error( 'Available permits cannot be less than used permits' );
@@ -64,7 +65,7 @@
 			this._permitsAvailable = amount;
 		}
 	};
-	
+
 	/**
 	 * A BlockingQueue that accumulates items while blocked (via 'block'),
 	 * and processes them when unblocked (via 'unblock').
@@ -75,7 +76,7 @@
 	};
 	_.extend( Backbone.BlockingQueue.prototype, Backbone.Semaphore, {
 		_queue: null,
-		
+
 		add: function( func ) {
 			if ( this.isBlocked() ) {
 				this._queue.push( func );
@@ -84,34 +85,34 @@
 				func();
 			}
 		},
-		
+
 		process: function() {
 			while ( this._queue && this._queue.length ) {
 				this._queue.shift()();
 			}
 		},
-		
+
 		block: function() {
 			this.acquire();
 		},
-		
+
 		unblock: function() {
 			this.release();
 			if ( !this.isBlocked() ) {
 				this.process();
 			}
 		},
-		
+
 		isBlocked: function() {
 			return this.isLocked();
 		}
 	});
 	/**
-	 * Global event queue. Accumulates external events ('add:<key>', 'remove:<key>' and 'update:<key>')
+	 * Global event queue. Accumulates external events ('add:<key>', 'remove:<key>' and 'change:<key>')
 	 * until the top-level object is fully initialized (see 'Backbone.RelationalModel').
 	 */
 	Backbone.Relational.eventQueue = new Backbone.BlockingQueue();
-	
+
 	/**
 	 * Backbone.Store keeps track of all created (and destruction of) Backbone.RelationalModel.
 	 * Handles lookup for relations.
@@ -119,10 +120,31 @@
 	Backbone.Store = function() {
 		this._collections = [];
 		this._reverseRelations = [];
+		this._orphanRelations = [];
 		this._subModels = [];
 		this._modelScopes = [ exports ];
 	};
 	_.extend( Backbone.Store.prototype, Backbone.Events, {
+		/**
+		 * Create a new `Relation`.
+		 * @param {Backbone.RelationalModel} [model]
+		 * @param {Object} relation
+		 * @param {Object} [options]
+		 */
+		initializeRelation: function( model, relation, options ) {
+			var type = !_.isString( relation.type ) ? relation.type : Backbone[ relation.type ] || this.getObjectByName( relation.type );
+			if ( type && type.prototype instanceof Backbone.Relation ) {
+				new type( model, relation, options ); // Also pushes the new Relation into `model._relations`
+			}
+			else {
+				Backbone.Relational.showWarnings && typeof console !== 'undefined' && console.warn( 'Relation=%o; missing or invalid relation type!', relation );
+			}
+		},
+
+		/**
+		 * Add a scope for `getObjectByName` to look for model types by name.
+		 * @param {Object} scope
+		 */
 		addModelScope: function( scope ) {
 			this._modelScopes.push( scope );
 		},
@@ -149,7 +171,7 @@
 		 */
 		setupSuperModel: function( modelType ) {
 			_.find( this._subModels, function( subModelDef ) {
-				return _.find( subModelDef.subModels, function( subModelTypeName, typeValue ) {
+				return _.find( subModelDef.subModels || [], function( subModelTypeName, typeValue ) {
 					var subModelType = this.getObjectByName( subModelTypeName );
 
 					if ( modelType === subModelType ) {
@@ -165,7 +187,7 @@
 				}, this );
 			}, this );
 		},
-		
+
 		/**
 		 * Add a reverse relation. Is added to the 'relations' property on model's prototype, and to
 		 * existing instances of 'model' in the store as well.
@@ -177,74 +199,108 @@
 		 */
 		addReverseRelation: function( relation ) {
 			var exists = _.any( this._reverseRelations, function( rel ) {
-					return _.all( relation, function( val, key ) {
-							return val === rel[ key ];
-						});
+				return _.all( relation || [], function( val, key ) {
+					return val === rel[ key ];
 				});
+			});
 			
 			if ( !exists && relation.model && relation.type ) {
 				this._reverseRelations.push( relation );
-				
-				var addRelation = function( model, relation ) {
-					if ( !model.prototype.relations ) {
-						model.prototype.relations = [];
-					}
-					model.prototype.relations.push( relation );
-					
-					_.each( model._subModels, function( subModel ) {
-							addRelation( subModel, relation );
-						}, this );
-				};
-				
-				addRelation( relation.model, relation );
-				
+				this._addRelation( relation.model, relation );
 				this.retroFitRelation( relation );
 			}
 		},
-		
+
+		/**
+		 * Deposit a `relation` for which the `relatedModel` can't be resolved at the moment.
+		 *
+		 * @param {Object} relation
+		 */
+		addOrphanRelation: function( relation ) {
+			var exists = _.any( this._orphanRelations, function( rel ) {
+				return _.all( relation || [], function( val, key ) {
+					return val === rel[ key ];
+				});
+			});
+
+			if ( !exists && relation.model && relation.type ) {
+				this._orphanRelations.push( relation );
+			}
+		},
+
+		/**
+		 * Try to initialize any `_orphanRelation`s
+		 */
+		processOrphanRelations: function() {
+			// Make sure to operate on a copy since we're removing while iterating
+			_.each( this._orphanRelations.slice( 0 ), function( rel ) {
+				var relatedModel = Backbone.Relational.store.getObjectByName( rel.relatedModel );
+				if ( relatedModel ) {
+					this.initializeRelation( null, rel );
+					this._orphanRelations = _.without( this._orphanRelations, rel );
+				}
+			}, this );
+		},
+
+		/**
+		 *
+		 * @param {Backbone.RelationalModel.constructor} type
+		 * @param {Object} relation
+		 * @private
+		 */
+		_addRelation: function( type, relation ) {
+			if ( !type.prototype.relations ) {
+				type.prototype.relations = [];
+			}
+			type.prototype.relations.push( relation );
+
+			_.each( type._subModels || [], function( subModel ) {
+				this._addRelation( subModel, relation );
+			}, this );
+		},
+
 		/**
 		 * Add a 'relation' to all existing instances of 'relation.model' in the store
 		 * @param {Object} relation
 		 */
 		retroFitRelation: function( relation ) {
-			var coll = this.getCollection( relation.model );
-			coll.each( function( model ) {
+			var coll = this.getCollection( relation.model, false );
+			coll && coll.each( function( model ) {
 				if ( !( model instanceof relation.model ) ) {
 					return;
 				}
 
 				new relation.type( model, relation );
-			}, this);
+			}, this );
 		},
-		
+
 		/**
 		 * Find the Store's collection for a certain type of model.
-		 * @param {Backbone.RelationalModel} model
+		 * @param {Backbone.RelationalModel} type
+		 * @param {Boolean} [create=true] Should a collection be created if none is found?
 		 * @return {Backbone.Collection} A collection if found (or applicable for 'model'), or null
 		 */
-		getCollection: function( model ) {
-			if ( model instanceof Backbone.RelationalModel ) {
-				model = model.constructor;
+		getCollection: function( type, create ) {
+			if ( type instanceof Backbone.RelationalModel ) {
+				type = type.constructor;
 			}
 			
-			var rootModel = model;
+			var rootModel = type;
 			while ( rootModel._superModel ) {
 				rootModel = rootModel._superModel;
 			}
 			
-			var coll = _.detect( this._collections, function( c ) {
-					return c.model === rootModel;
-				});
+			var coll = _.findWhere( this._collections, { model: rootModel } );
 			
-			if ( !coll ) {
-				coll = this._createCollection( model );
+			if ( !coll && create !== false ) {
+				coll = this._createCollection( rootModel );
 			}
 			
 			return coll;
 		},
-		
+
 		/**
-		 * Find a type on the global object by name. Splits name on dots.
+		 * Find a model type on one of the modelScopes by name. Names are split on dots.
 		 * @param {String} name
 		 * @return {Object}
 		 */
@@ -253,8 +309,8 @@
 				type = null;
 
 			_.find( this._modelScopes, function( scope ) {
-				type = _.reduce( parts, function( memo, val ) {
-					return memo[ val ];
+				type = _.reduce( parts || [], function( memo, val ) {
+					return memo ? memo[ val ] : undefined;
 				}, scope );
 
 				if ( type && type !== scope ) {
@@ -264,7 +320,7 @@
 
 			return type;
 		},
-		
+
 		_createCollection: function( type ) {
 			var coll;
 			
@@ -288,11 +344,12 @@
 		 * Find the attribute that is to be used as the `id` on a given object
 		 * @param type
 		 * @param {String|Number|Object|Backbone.RelationalModel} item
+		 * @return {String|Number}
 		 */
 		resolveIdForItem: function( type, item ) {
 			var id = _.isString( item ) || _.isNumber( item ) ? item : null;
 
-			if ( id == null ) {
+			if ( id === null ) {
 				if ( item instanceof Backbone.RelationalModel ) {
 					id = item.id;
 				}
@@ -301,6 +358,11 @@
 				}
 			}
 
+			// Make all falsy values `null` (except for 0, which could be an id.. see '/issues/179')
+			if ( !id && id !== 0 ) {
+				id = null;
+			}
+
 			return id;
 		},
 
@@ -325,45 +387,67 @@
 
 			return null;
 		},
-		
+
 		/**
-		 * Add a 'model' to it's appropriate collection. Retain the original contents of 'model.collection'.
+		 * Add a 'model' to its appropriate collection. Retain the original contents of 'model.collection'.
 		 * @param {Backbone.RelationalModel} model
 		 */
 		register: function( model ) {
-			var modelColl = model.collection;
 			var coll = this.getCollection( model );
-			coll && coll.add( model );
-			model.bind( 'destroy', this.unregister, this );
-			model.collection = modelColl;
+
+			if ( coll ) {
+				if ( coll.get( model ) ) {
+					if ( Backbone.Relational.showWarnings && typeof console !== 'undefined' ) {
+						console.warn( 'Duplicate id! Old RelationalModel=%o, new RelationalModel=%o', coll.get( model ), model );
+					}
+					throw new Error( "Cannot instantiate more than one Backbone.RelationalModel with the same id per type!" );
+				}
+
+				var modelColl = model.collection;
+				coll.add( model );
+				this.listenTo( model, 'destroy', this.unregister, this );
+				model.collection = modelColl;
+			}
 		},
-		
+
 		/**
-		 * Explicitly update a model's id in it's store collection
+		 * Explicitly update a model's id in its store collection
 		 * @param {Backbone.RelationalModel} model
-		 */
+		*/
 		update: function( model ) {
 			var coll = this.getCollection( model );
 			coll._onModelEvent( 'change:' + model.idAttribute, model, coll );
 		},
-		
+
 		/**
 		 * Remove a 'model' from the store.
 		 * @param {Backbone.RelationalModel} model
 		 */
 		unregister: function( model ) {
-			model.unbind( 'destroy', this.unregister );
+			this.stopListening( model, 'destroy', this.unregister );
 			var coll = this.getCollection( model );
 			coll && coll.remove( model );
+		},
+
+		/**
+		 * Reset the `store` to it's original state. The `reverseRelations` are kept though, since attempting to
+		 * re-initialize these on models would lead to a large amount of warnings.
+		 */
+		reset: function() {
+			this.stopListening();
+			this._collections = [];
+			this._subModels = [];
+			this._modelScopes = [ exports ];
 		}
 	});
 	Backbone.Relational.store = new Backbone.Store();
-	
+
 	/**
 	 * The main Relation class, from which 'HasOne' and 'HasMany' inherit. Internally, 'relational:<key>' events
 	 * are used to regulate addition and removal of models from relations.
 	 *
-	 * @param {Backbone.RelationalModel} instance
+	 * @param {Backbone.RelationalModel} [instance] Model that this relation is created for. If no model is supplied,
+	 *      Relation just tries to instantiate it's `reverseRelation` if specified, and bails out after that.
 	 * @param {Object} options
 	 * @param {string} options.key
 	 * @param {Backbone.RelationalModel.constructor} options.relatedModel
@@ -372,41 +456,30 @@
 	 * @param {Object} [options.reverseRelation] Specify a bi-directional relation. If provided, Relation will reciprocate
 	 *    the relation to the 'relatedModel'. Required and optional properties match 'options', except that it also needs
 	 *    {Backbone.Relation|String} type ('HasOne' or 'HasMany').
+	 * @param {Object} opts
 	 */
-	Backbone.Relation = function( instance, options ) {
+	Backbone.Relation = function( instance, options, opts ) {
 		this.instance = instance;
 		// Make sure 'options' is sane, and fill with defaults from subclasses and this object's prototype
 		options = _.isObject( options ) ? options : {};
 		this.reverseRelation = _.defaults( options.reverseRelation || {}, this.options.reverseRelation );
+		this.options = _.defaults( options, this.options, Backbone.Relation.prototype.options );
+
 		this.reverseRelation.type = !_.isString( this.reverseRelation.type ) ? this.reverseRelation.type :
 			Backbone[ this.reverseRelation.type ] || Backbone.Relational.store.getObjectByName( this.reverseRelation.type );
-		this.model = options.model || this.instance.constructor;
-		this.options = _.defaults( options, this.options, Backbone.Relation.prototype.options );
-		
+
 		this.key = this.options.key;
 		this.keySource = this.options.keySource || this.key;
 		this.keyDestination = this.options.keyDestination || this.keySource || this.key;
 
-		// 'exports' should be the global object where 'relatedModel' can be found on if given as a string.
+		this.model = this.options.model || this.instance.constructor;
 		this.relatedModel = this.options.relatedModel;
 		if ( _.isString( this.relatedModel ) ) {
 			this.relatedModel = Backbone.Relational.store.getObjectByName( this.relatedModel );
 		}
 
 		if ( !this.checkPreconditions() ) {
-			return false;
-		}
-
-		if ( instance ) {
-			this.keyContents = this.instance.get( this.keySource );
-
-			// Explicitly clear 'keySource', to prevent a leaky abstraction if 'keySource' differs from 'key'.
-			if ( this.key !== this.keySource ) {
-				this.instance.unset( this.keySource, { silent: true } );
-			}
-
-			// Add this Relation to instance._relations
-			this.instance._relations.push( this );
+			return;
 		}
 
 		// Add the reverse relation on 'relatedModel' to the store's reverseRelations
@@ -415,25 +488,39 @@
 					isAutoRelation: true,
 					model: this.relatedModel,
 					relatedModel: this.model,
-					reverseRelation: this.options // current relation is the 'reverseRelation' for it's own reverseRelation
+					reverseRelation: this.options // current relation is the 'reverseRelation' for its own reverseRelation
 				},
 				this.reverseRelation // Take further properties from this.reverseRelation (type, key, etc.)
 			) );
 		}
 
-		_.bindAll( this, '_modelRemovedFromCollection', '_relatedModelAdded', '_relatedModelRemoved' );
-
 		if ( instance ) {
-			this.initialize();
+			var contentKey = this.keySource;
+			if ( contentKey !== this.key && typeof this.instance.get( this.key ) === 'object' ) {
+				contentKey = this.key;
+			}
 
-			// When a model in the store is destroyed, check if it is 'this.instance'.
-			Backbone.Relational.store.getCollection( this.instance )
-				.bind( 'relational:remove', this._modelRemovedFromCollection );
+			this.setKeyContents( this.instance.get( contentKey ) );
+			this.relatedCollection = Backbone.Relational.store.getCollection( this.relatedModel );
+
+			// Explicitly clear 'keySource', to prevent a leaky abstraction if 'keySource' differs from 'key'.
+			if ( this.keySource !== this.key ) {
+				this.instance.unset( this.keySource, { silent: true } );
+			}
+
+			// Add this Relation to instance._relations
+			this.instance._relations[ this.key ] = this;
+
+			this.initialize( opts );
+
+			if ( this.options.autoFetch ) {
+				this.instance.fetchRelated( this.key, _.isObject( this.options.autoFetch ) ? this.options.autoFetch : {} );
+			}
 
 			// When 'relatedModel' are created or destroyed, check if it affects this relation.
-			Backbone.Relational.store.getCollection( this.relatedModel )
-				.bind( 'relational:add', this._relatedModelAdded )
-				.bind( 'relational:remove', this._relatedModelRemoved );
+			this.listenTo( this.instance, 'destroy', this.destroy )
+				.listenTo( this.relatedCollection, 'relational:add', this.tryAddRelated )
+				.listenTo( this.relatedCollection, 'relational:remove', this.removeRelated )
 		}
 	};
 	// Fix inheritance :\
@@ -443,35 +530,19 @@
 		options: {
 			createModels: true,
 			includeInJSON: true,
-			isAutoRelation: false
+			isAutoRelation: false,
+			autoFetch: false,
+			parse: false
 		},
-		
+
 		instance: null,
 		key: null,
 		keyContents: null,
 		relatedModel: null,
+		relatedCollection: null,
 		reverseRelation: null,
 		related: null,
-		
-		_relatedModelAdded: function( model, coll, options ) {
-			// Allow 'model' to set up it's relations, before calling 'tryAddRelated'
-			// (which can result in a call to 'addRelated' on a relation of 'model')
-			var dit = this;
-			model.queue( function() {
-				dit.tryAddRelated( model, options );
-			});
-		},
-		
-		_relatedModelRemoved: function( model, coll, options ) {
-			this.removeRelated( model, options );
-		},
-		
-		_modelRemovedFromCollection: function( model ) {
-			if ( model === this.instance ) {
-				this.destroy();
-			}
-		},
-		
+
 		/**
 		 * Check several pre-conditions.
 		 * @return {Boolean} True if pre-conditions are satisfied, false if they're not.
@@ -484,36 +555,33 @@
 				warn = Backbone.Relational.showWarnings && typeof console !== 'undefined';
 
 			if ( !m || !k || !rm ) {
-				warn && console.warn( 'Relation=%o; no model, key or relatedModel (%o, %o, %o)', this, m, k, rm );
+				warn && console.warn( 'Relation=%o: missing model, key or relatedModel (%o, %o, %o).', this, m, k, rm );
 				return false;
 			}
-			// Check if the type in 'relatedModel' inherits from Backbone.RelationalModel
+			// Check if the type in 'model' inherits from Backbone.RelationalModel
 			if ( !( m.prototype instanceof Backbone.RelationalModel ) ) {
-				warn && console.warn( 'Relation=%o; model does not inherit from Backbone.RelationalModel (%o)', this, i );
+				warn && console.warn( 'Relation=%o: model does not inherit from Backbone.RelationalModel (%o).', this, i );
 				return false;
 			}
 			// Check if the type in 'relatedModel' inherits from Backbone.RelationalModel
 			if ( !( rm.prototype instanceof Backbone.RelationalModel ) ) {
-				warn && console.warn( 'Relation=%o; relatedModel does not inherit from Backbone.RelationalModel (%o)', this, rm );
+				warn && console.warn( 'Relation=%o: relatedModel does not inherit from Backbone.RelationalModel (%o).', this, rm );
 				return false;
 			}
 			// Check if this is not a HasMany, and the reverse relation is HasMany as well
 			if ( this instanceof Backbone.HasMany && this.reverseRelation.type === Backbone.HasMany ) {
-				warn && console.warn( 'Relation=%o; relation is a HasMany, and the reverseRelation is HasMany as well.', this );
+				warn && console.warn( 'Relation=%o: relation is a HasMany, and the reverseRelation is HasMany as well.', this );
 				return false;
 			}
+			// Check if we're not attempting to create a relationship on a `key` that's already used.
+			if ( i && _.keys( i._relations ).length ) {
+				var existing = _.find( i._relations, function( rel ) {
+					return rel.key === k;
+				}, this );
 
-			// Check if we're not attempting to create a duplicate relationship
-			if ( i && i._relations.length ) {
-				var exists = _.any( i._relations, function( rel ) {
-						var hasReverseRelation = this.reverseRelation.key && rel.reverseRelation.key;
-						return rel.relatedModel === rm && rel.key === k &&
-							( !hasReverseRelation || this.reverseRelation.key === rel.reverseRelation.key );
-					}, this );
-
-				if ( exists ) {
-					warn && console.warn( 'Relation=%o between instance=%o.%s and relatedModel=%o.%s already exists',
-						this, i, k, rm, this.reverseRelation.key );
+				if ( existing ) {
+					warn && console.warn( 'Cannot create relation=%o on %o for model=%o: already taken by relation=%o.',
+						this, k, i, existing );
 					return false;
 				}
 			}
@@ -523,17 +591,16 @@
 
 		/**
 		 * Set the related model(s) for this relation
-		 * @param {Backbone.Mode|Backbone.Collection} related
-		 * @param {Object} [options]
+		 * @param {Backbone.Model|Backbone.Collection} related
 		 */
-		setRelated: function( related, options ) {
+		setRelated: function( related ) {
 			this.related = related;
 
 			this.instance.acquire();
-			this.instance.set( this.key, related, _.defaults( options || {}, { silent: true } ) );
+			this.instance.attributes[ this.key ] = related;
 			this.instance.release();
 		},
-		
+
 		/**
 		 * Determine if a relation (on a different RelationalModel) is the reverse
 		 * relation of the current one.
@@ -541,13 +608,10 @@
 		 * @return {Boolean}
 		 */
 		_isReverseRelation: function( relation ) {
-			if ( relation.instance instanceof this.relatedModel && this.reverseRelation.key === relation.key &&
-					this.key === relation.reverseRelation.key ) {
-				return true;
-			}
-			return false;
+			return relation.instance instanceof this.relatedModel && this.reverseRelation.key === relation.key &&
+				this.key === relation.reverseRelation.key;
 		},
-		
+
 		/**
 		 * Get the reverse relations (pointing back to 'this.key' on 'this.instance') for the currently related model(s).
 		 * @param {Backbone.RelationalModel} [model] Get the reverse relations for a specific model.
@@ -558,97 +622,87 @@
 			var reverseRelations = [];
 			// Iterate over 'model', 'this.related.models' (if this.related is a Backbone.Collection), or wrap 'this.related' in an array.
 			var models = !_.isUndefined( model ) ? [ model ] : this.related && ( this.related.models || [ this.related ] );
-			_.each( models , function( related ) {
-					_.each( related.getRelations(), function( relation ) {
-							if ( this._isReverseRelation( relation ) ) {
-								reverseRelations.push( relation );
-							}
-						}, this );
-				}, this );
+			_.each( models || [], function( related ) {
+				_.each( related.getRelations() || [], function( relation ) {
+						if ( this._isReverseRelation( relation ) ) {
+							reverseRelations.push( relation );
+						}
+					}, this );
+			}, this );
 			
 			return reverseRelations;
 		},
-		
-		/**
-		 * Rename options.silent to options.silentChange, so events propagate properly.
-		 * (for example in HasMany, from 'addRelated'->'handleAddition')
-		 * @param {Object} [options]
-		 * @return {Object}
-		 */
-		sanitizeOptions: function( options ) {
-			options = options ? _.clone( options ) : {};
-			if ( options.silent ) {
-				options.silentChange = true;
-				delete options.silent;
-			}
-			return options;
-		},
 
 		/**
-		 * Rename options.silentChange to options.silent, so events are silenced as intended in Backbone's
-		 * original functions.
-		 * @param {Object} [options]
-		 * @return {Object}
+		 * When `this.instance` is destroyed, cleanup our relations.
+		 * Get reverse relation, call removeRelated on each.
 		 */
-		unsanitizeOptions: function( options ) {
-			options = options ? _.clone( options ) : {};
-			if ( options.silentChange ) {
-				options.silent = true;
-				delete options.silentChange;
-			}
-			return options;
-		},
-		
-		// Cleanup. Get reverse relation, call removeRelated on each.
 		destroy: function() {
-			Backbone.Relational.store.getCollection( this.instance )
-				.unbind( 'relational:remove', this._modelRemovedFromCollection );
-			
-			Backbone.Relational.store.getCollection( this.relatedModel )
-				.unbind( 'relational:add', this._relatedModelAdded )
-				.unbind( 'relational:remove', this._relatedModelRemoved );
+			this.stopListening();
+
+			if ( this instanceof Backbone.HasOne ) {
+				this.setRelated( null );
+			}
+			else if ( this instanceof Backbone.HasMany ) {
+				this.setRelated( this._prepareCollection() );
+			}
 			
 			_.each( this.getReverseRelations(), function( relation ) {
-					relation.removeRelated( this.instance );
-				}, this );
+				relation.removeRelated( this.instance );
+			}, this );
 		}
 	});
-	
+
 	Backbone.HasOne = Backbone.Relation.extend({
 		options: {
 			reverseRelation: { type: 'HasMany' }
 		},
-		
-		initialize: function() {
-			_.bindAll( this, 'onChange' );
 
-			this.instance.bind( 'relational:change:' + this.key, this.onChange );
+		initialize: function( opts ) {
+			this.listenTo( this.instance, 'relational:change:' + this.key, this.onChange );
 
-			var model = this.findRelated( { silent: true } );
-			this.setRelated( model );
+			var related = this.findRelated( opts );
+			this.setRelated( related );
 
 			// Notify new 'related' object of the new relation.
 			_.each( this.getReverseRelations(), function( relation ) {
-					relation.addRelated( this.instance );
-				}, this );
+				relation.addRelated( this.instance, opts );
+			}, this );
 		},
-		
-		findRelated: function( options ) {
-			var item = this.keyContents;
-			var model = null;
-			
-			if ( item instanceof this.relatedModel ) {
-				model = item;
-			}
-			else if ( item ) {
-				model = this.relatedModel.findOrCreate( item, { create: this.options.createModels } );
-			}
-			
-			return model;
-		},
-		
+
 		/**
-		 * If the key is changed, notify old & new reverse relations and initialize the new relation
+		 * Find related Models.
+		 * @param {Object} [options]
+		 * @return {Backbone.Model}
+		 */
+		findRelated: function( options ) {
+			var related = null;
+
+			options = _.defaults( { parse: this.options.parse }, options );
+
+			if ( this.keyContents instanceof this.relatedModel ) {
+				related = this.keyContents;
+			}
+			else if ( this.keyContents || this.keyContents === 0 ) { // since 0 can be a valid `id` as well
+				var opts = _.defaults( { create: this.options.createModels }, options );
+				related = this.relatedModel.findOrCreate( this.keyContents, opts );
+			}
+
+			return related;
+		},
+
+		/**
+		 * Normalize and reduce `keyContents` to an `id`, for easier comparison
+		 * @param {String|Number|Backbone.Model} keyContents
+		 */
+		setKeyContents: function( keyContents ) {
+			this.keyContents = keyContents;
+			this.keyId = Backbone.Relational.store.resolveIdForItem( this.relatedModel, this.keyContents );
+		},
+
+		/**
+		 * Event handler for `change:<key>`.
+		 * If the key is changed, notify old & new reverse relations and initialize the new relation.
 		 */
 		onChange: function( model, attr, options ) {
 			// Don't accept recursive calls to onChange (like onChange->findRelated->findOrCreate->initializeRelations->addRelated->onChange)
@@ -656,81 +710,70 @@
 				return;
 			}
 			this.acquire();
-			options = this.sanitizeOptions( options );
+			options = options ? _.clone( options ) : {};
 			
-			// 'options._related' is set by 'addRelated'/'removeRelated'. If it is set, the change
+			// 'options.__related' is set by 'addRelated'/'removeRelated'. If it is set, the change
 			// is the result of a call from a relation. If it's not, the change is the result of 
 			// a 'set' call on this.instance.
-			var changed = _.isUndefined( options._related );
-			var oldRelated = changed ? this.related : options._related;
+			var changed = _.isUndefined( options.__related ),
+				oldRelated = changed ? this.related : options.__related;
 			
-			if ( changed ) {	
-				this.keyContents = attr;
-				
-				// Set new 'related'
-				if ( attr instanceof this.relatedModel ) {
-					this.related = attr;
-				}
-				else if ( attr ) {
-					var related = this.findRelated( options );
-					this.setRelated( related );
-				}
-				else {
-					this.setRelated( null );
-				}
+			if ( changed ) {
+				this.setKeyContents( attr );
+				var related = this.findRelated( options );
+				this.setRelated( related );
 			}
 			
 			// Notify old 'related' object of the terminated relation
 			if ( oldRelated && this.related !== oldRelated ) {
 				_.each( this.getReverseRelations( oldRelated ), function( relation ) {
-						relation.removeRelated( this.instance, options );
-					}, this );
+					relation.removeRelated( this.instance, null, options );
+				}, this );
 			}
-			
+
 			// Notify new 'related' object of the new relation. Note we do re-apply even if this.related is oldRelated;
 			// that can be necessary for bi-directional relations if 'this.instance' was created after 'this.related'.
 			// In that case, 'this.instance' will already know 'this.related', but the reverse might not exist yet.
 			_.each( this.getReverseRelations(), function( relation ) {
-					relation.addRelated( this.instance, options );
-				}, this);
+				relation.addRelated( this.instance, options );
+			}, this );
 			
-			// Fire the 'update:<key>' event if 'related' was updated
-			if ( !options.silentChange && this.related !== oldRelated ) {
+			// Fire the 'change:<key>' event if 'related' was updated
+			if ( !options.silent && this.related !== oldRelated ) {
 				var dit = this;
+				this.changed = true;
 				Backbone.Relational.eventQueue.add( function() {
-					dit.instance.trigger( 'update:' + dit.key, dit.instance, dit.related, options );
+					dit.instance.trigger( 'change:' + dit.key, dit.instance, dit.related, options, true );
+					dit.changed = false;
 				});
 			}
 			this.release();
 		},
-		
+
 		/**
 		 * If a new 'this.relatedModel' appears in the 'store', try to match it to the last set 'keyContents'
 		 */
-		tryAddRelated: function( model, options ) {
-			if ( this.related ) {
-				return;
-			}
-			options = this.sanitizeOptions( options );
-			
-			var item = this.keyContents;
-			if ( item ) {
-				var id = Backbone.Relational.store.resolveIdForItem( this.relatedModel, item );
-				if ( model.id === id ) {
-					this.addRelated( model, options );
-				}
+		tryAddRelated: function( model, coll, options ) {
+			if ( ( this.keyId || this.keyId === 0 ) && model.id === this.keyId ) { // since 0 can be a valid `id` as well
+				this.addRelated( model, options );
+				this.keyId = null;
 			}
 		},
-		
+
 		addRelated: function( model, options ) {
-			if ( model !== this.related ) {
-				var oldRelated = this.related || null;
-				this.setRelated( model );
-				this.onChange( this.instance, model, { _related: oldRelated } );
-			}
+			// Allow 'model' to set up its relations before proceeding.
+			// (which can result in a call to 'addRelated' from a relation of 'model')
+			var dit = this;
+			model.queue( function() {
+				if ( model !== dit.related ) {
+					var oldRelated = dit.related || null;
+					dit.setRelated( model );
+					dit.onChange( dit.instance, model, _.defaults( { __related: oldRelated }, options ) );
+				}
+			});
 		},
-		
-		removeRelated: function( model, options ) {
+
+		removeRelated: function( model, coll, options ) {
 			if ( !this.related ) {
 				return;
 			}
@@ -738,24 +781,23 @@
 			if ( model === this.related ) {
 				var oldRelated = this.related || null;
 				this.setRelated( null );
-				this.onChange( this.instance, model, { _related: oldRelated } );
+				this.onChange( this.instance, model, _.defaults( { __related: oldRelated }, options ) );
 			}
 		}
 	});
-	
+
 	Backbone.HasMany = Backbone.Relation.extend({
 		collectionType: null,
-		
+
 		options: {
 			reverseRelation: { type: 'HasOne' },
 			collectionType: Backbone.Collection,
 			collectionKey: true,
 			collectionOptions: {}
 		},
-		
-		initialize: function() {
-			_.bindAll( this, 'onChange', 'handleAddition', 'handleRemoval', 'handleReset' );
-			this.instance.bind( 'relational:change:' + this.key, this.onChange );
+
+		initialize: function( opts ) {
+			this.listenTo( this.instance, 'relational:change:' + this.key, this.onChange );
 			
 			// Handle a custom 'collectionType'
 			this.collectionType = this.options.collectionType;
@@ -763,41 +805,29 @@
 				this.collectionType = Backbone.Relational.store.getObjectByName( this.collectionType );
 			}
 			if ( !this.collectionType.prototype instanceof Backbone.Collection ){
-				throw new Error( 'collectionType must inherit from Backbone.Collection' );
+				throw new Error( '`collectionType` must inherit from Backbone.Collection' );
 			}
 
-			// Handle cases where a model/relation is created with a collection passed straight into 'attributes'
-			if ( this.keyContents instanceof Backbone.Collection ) {
-				this.setRelated( this._prepareCollection( this.keyContents ) );
-			}
-			else {
-				this.setRelated( this._prepareCollection() );
-			}
-
-			this.findRelated( { silent: true } );
-		},
-		
-		_getCollectionOptions: function() {
-			return _.isFunction( this.options.collectionOptions ) ?
-				this.options.collectionOptions( this.instance ) :
-				this.options.collectionOptions;
+			var related = this.findRelated( opts );
+			this.setRelated( related );
 		},
 
 		/**
 		 * Bind events and setup collectionKeys for a collection that is to be used as the backing store for a HasMany.
 		 * If no 'collection' is supplied, a new collection will be created of the specified 'collectionType' option.
 		 * @param {Backbone.Collection} [collection]
+		 * @return {Backbone.Collection}
 		 */
 		_prepareCollection: function( collection ) {
 			if ( this.related ) {
-				this.related
-					.unbind( 'relational:add', this.handleAddition )
-					.unbind( 'relational:remove', this.handleRemoval )
-					.unbind( 'relational:reset', this.handleReset )
+				this.stopListening( this.related );
 			}
 
 			if ( !collection || !( collection instanceof Backbone.Collection ) ) {
-				collection = new this.collectionType( [], this._getCollectionOptions() );
+				var options = _.isFunction( this.options.collectionOptions ) ?
+					this.options.collectionOptions( this.instance ) : this.options.collectionOptions;
+
+				collection = new this.collectionType( null, options );
 			}
 
 			collection.model = this.relatedModel;
@@ -814,191 +844,184 @@
 					collection[ key ] = this.instance;
 				}
 			}
-			
-			collection
-				.bind( 'relational:add', this.handleAddition )
-				.bind( 'relational:remove', this.handleRemoval )
-				.bind( 'relational:reset', this.handleReset );
+
+			this.listenTo( collection, 'relational:add', this.handleAddition )
+				.listenTo( collection, 'relational:remove', this.handleRemoval )
+				.listenTo( collection, 'relational:reset', this.handleReset );
 			
 			return collection;
 		},
-		
-		findRelated: function( options ) {
-			if ( this.keyContents ) {
-				var models = [];
 
-				if ( this.keyContents instanceof Backbone.Collection ) {
-					models = this.keyContents.models;
-				}
-				else {
-					// Handle cases the an API/user supplies just an Object/id instead of an Array
-					this.keyContents = _.isArray( this.keyContents ) ? this.keyContents : [ this.keyContents ];
-
-					// Try to find instances of the appropriate 'relatedModel' in the store
-					_.each( this.keyContents, function( item ) {
-							var model = null;
-							if ( item instanceof this.relatedModel ) {
-								model = item;
-							}
-							else {
-								model = this.relatedModel.findOrCreate( item, { create: this.options.createModels } );
-							}
-
-							if ( model && !this.related.getByCid( model ) && !this.related.get( model ) ) {
-								models.push( model );
-							}
-						}, this );
-				}
-
-				// Add all found 'models' in on go, so 'add' will only be called once (and thus 'sort', etc.)
-				if ( models.length ) {
-					options = this.unsanitizeOptions( options );
-					this.related.add( models, options );
-				}
-			}
-		},
-		
 		/**
-		 * If the key is changed, notify old & new reverse relations and initialize the new relation
+		 * Find related Models.
+		 * @param {Object} [options]
+		 * @return {Backbone.Collection}
 		 */
-		onChange: function( model, attr, options ) {
-			options = this.sanitizeOptions( options );
-			this.keyContents = attr;
-			
-			// Notify old 'related' object of the terminated relation
-			_.each( this.getReverseRelations(), function( relation ) {
-					relation.removeRelated( this.instance, options );
-				}, this );
-			
-			// Replace 'this.related' by 'attr' if it is a Backbone.Collection
-			if ( attr instanceof Backbone.Collection ) {
-				this._prepareCollection( attr );
-				this.related = attr;
+		findRelated: function( options ) {
+			var related = null;
+
+			options = _.defaults( { parse: this.options.parse }, options );
+
+			// Replace 'this.related' by 'this.keyContents' if it is a Backbone.Collection
+			if ( this.keyContents instanceof Backbone.Collection ) {
+				this._prepareCollection( this.keyContents );
+				related = this.keyContents;
 			}
-			// Otherwise, 'attr' should be an array of related object ids.
-			// Re-use the current 'this.related' if it is a Backbone.Collection, and remove any current entries.
-			// Otherwise, create a new collection.
+			// Otherwise, 'this.keyContents' should be an array of related object ids.
+			// Re-use the current 'this.related' if it is a Backbone.Collection; otherwise, create a new collection.
 			else {
-				var coll;
+				var toAdd = [];
+
+				_.each( this.keyContents, function( attributes ) {
+					if ( attributes instanceof this.relatedModel ) {
+						var model = attributes;
+					}
+					else {
+						// If `merge` is true, update models here, instead of during update.
+						model = this.relatedModel.findOrCreate( attributes, _.extend( { merge: true }, options, { create: this.options.createModels } ) );
+					}
+
+					model && toAdd.push( model );
+				}, this );
 
 				if ( this.related instanceof Backbone.Collection ) {
-					coll = this.related;
-					coll.remove( coll.models );
+					related = this.related;
 				}
 				else {
-					coll = this._prepareCollection();
+					related = this._prepareCollection();
 				}
 
-				this.setRelated( coll );
-				this.findRelated( options );
+				related.update( toAdd, _.defaults( { merge: false, parse: false }, options ) );
 			}
-			
-			// Notify new 'related' object of the new relation
-			_.each( this.getReverseRelations(), function( relation ) {
-					relation.addRelated( this.instance, options );
+
+			return related;
+		},
+
+		/**
+		 * Normalize and reduce `keyContents` to a list of `ids`, for easier comparison
+		 * @param {String|Number|String[]|Number[]|Backbone.Collection} keyContents
+		 */
+		setKeyContents: function( keyContents ) {
+			this.keyContents = keyContents instanceof Backbone.Collection ? keyContents : null;
+			this.keyIds = [];
+
+			if ( !this.keyContents && ( keyContents || keyContents === 0 ) ) { // since 0 can be a valid `id` as well
+				// Handle cases the an API/user supplies just an Object/id instead of an Array
+				this.keyContents = _.isArray( keyContents ) ? keyContents : [ keyContents ];
+
+				_.each( this.keyContents, function( item ) {
+					var itemId = Backbone.Relational.store.resolveIdForItem( this.relatedModel, item );
+					if ( itemId || itemId === 0 ) {
+						this.keyIds.push( itemId );
+					}
 				}, this );
-			
-			var dit = this;
-			Backbone.Relational.eventQueue.add( function() {
-				!options.silentChange && dit.instance.trigger( 'update:' + dit.key, dit.instance, dit.related, options );
-			});
-		},
-		
-		tryAddRelated: function( model, options ) {
-			options = this.sanitizeOptions( options );
-			if ( !this.related.getByCid( model ) && !this.related.get( model ) ) {
-				// Check if this new model was specified in 'this.keyContents'
-				var item = _.any( this.keyContents, function( item ) {
-						var id = Backbone.Relational.store.resolveIdForItem( this.relatedModel, item );
-						return id && id === model.id;
-					}, this );
-				
-				if ( item ) {
-					this.related.add( model, options );
-				}
 			}
 		},
-		
+
+		/**
+		 * Event handler for `change:<key>`.
+		 * If the contents of the key are changed, notify old & new reverse relations and initialize the new relation.
+		 */
+		onChange: function( model, attr, options ) {
+			options = options ? _.clone( options ) : {};
+			this.setKeyContents( attr );
+			this.changed = false;
+
+			var related = this.findRelated( options );
+			this.setRelated( related );
+
+			if ( !options.silent ) {
+				var dit = this;
+				Backbone.Relational.eventQueue.add( function() {
+					// The `changed` flag can be set in `handleAddition` or `handleRemoval`
+					if ( dit.changed ) {
+						dit.instance.trigger( 'change:' + dit.key, dit.instance, dit.related, options, true );
+						dit.changed = false;
+					}
+				});
+			}
+		},
+
 		/**
 		 * When a model is added to a 'HasMany', trigger 'add' on 'this.instance' and notify reverse relations.
 		 * (should be 'HasOne', must set 'this.instance' as their related).
-		 */
+		*/
 		handleAddition: function( model, coll, options ) {
 			//console.debug('handleAddition called; args=%o', arguments);
-			// Make sure the model is in fact a valid model before continuing.
-			// (it can be invalid as a result of failing validation in Backbone.Collection._prepareModel)
-			if ( !( model instanceof Backbone.Model ) ) {
-				return;
-			}
-			
-			options = this.sanitizeOptions( options );
+			options = options ? _.clone( options ) : {};
+			this.changed = true;
 			
 			_.each( this.getReverseRelations( model ), function( relation ) {
-					relation.addRelated( this.instance, options );
-				}, this );
+				relation.addRelated( this.instance, options );
+			}, this );
 
-			// Only trigger 'add' once the newly added model is initialized (so, has it's relations set up)
+			// Only trigger 'add' once the newly added model is initialized (so, has its relations set up)
 			var dit = this;
-			Backbone.Relational.eventQueue.add( function() {
-				!options.silentChange && dit.instance.trigger( 'add:' + dit.key, model, dit.related, options );
+			!options.silent && Backbone.Relational.eventQueue.add( function() {
+				dit.instance.trigger( 'add:' + dit.key, model, dit.related, options );
 			});
 		},
-		
+
 		/**
 		 * When a model is removed from a 'HasMany', trigger 'remove' on 'this.instance' and notify reverse relations.
 		 * (should be 'HasOne', which should be nullified)
 		 */
 		handleRemoval: function( model, coll, options ) {
 			//console.debug('handleRemoval called; args=%o', arguments);
-			if ( !( model instanceof Backbone.Model ) ) {
-				return;
-			}
-
-			options = this.sanitizeOptions( options );
+			options = options ? _.clone( options ) : {};
+			this.changed = true;
 			
 			_.each( this.getReverseRelations( model ), function( relation ) {
-					relation.removeRelated( this.instance, options );
-				}, this );
+				relation.removeRelated( this.instance, null, options );
+			}, this );
 			
 			var dit = this;
-			Backbone.Relational.eventQueue.add( function() {
-				!options.silentChange && dit.instance.trigger( 'remove:' + dit.key, model, dit.related, options );
+			!options.silent && Backbone.Relational.eventQueue.add( function() {
+				 dit.instance.trigger( 'remove:' + dit.key, model, dit.related, options );
 			});
 		},
 
 		handleReset: function( coll, options ) {
-			options = this.sanitizeOptions( options );
-
 			var dit = this;
-			Backbone.Relational.eventQueue.add( function() {
-				!options.silentChange && dit.instance.trigger( 'reset:' + dit.key, dit.related, options );
+			options = options ? _.clone( options ) : {};
+			!options.silent && Backbone.Relational.eventQueue.add( function() {
+				dit.instance.trigger( 'reset:' + dit.key, dit.related, options );
 			});
 		},
-		
+
+		tryAddRelated: function( model, coll, options ) {
+			var item = _.contains( this.keyIds, model.id );
+
+			if ( item ) {
+				this.addRelated( model, options );
+				this.keyIds = _.without( this.keyIds, model.id );
+			}
+		},
+
 		addRelated: function( model, options ) {
+			// Allow 'model' to set up its relations before proceeding.
+			// (which can result in a call to 'addRelated' from a relation of 'model')
 			var dit = this;
-			options = this.unsanitizeOptions( options );
-			model.queue( function() { // Queued to avoid errors for adding 'model' to the 'this.related' set twice
-				if ( dit.related && !dit.related.getByCid( model ) && !dit.related.get( model ) ) {
+			model.queue( function() {
+				if ( dit.related && !dit.related.get( model ) ) {
 					dit.related.add( model, options );
 				}
 			});
 		},
-		
-		removeRelated: function( model, options ) {
-			options = this.unsanitizeOptions( options );
-			if ( this.related.getByCid( model ) || this.related.get( model ) ) {
+
+		removeRelated: function( model, coll, options ) {
+			if ( this.related.get( model ) ) {
 				this.related.remove( model, options );
 			}
 		}
 	});
-	
+
 	/**
 	 * A type of Backbone.Model that also maintains relations to other models and collections.
 	 * New events when compared to the original:
 	 *  - 'add:<key>' (model, related collection, options)
 	 *  - 'remove:<key>' (model, related collection, options)
-	 *  - 'update:<key>' (model, related model or collection, options)
+	 *  - 'change:<key>' (model, related model or collection, options)
 	 */
 	Backbone.RelationalModel = Backbone.Model.extend({
 		relations: null, // Relation descriptions on the prototype
@@ -1006,56 +1029,98 @@
 		_isInitialized: false,
 		_deferProcessing: false,
 		_queue: null,
-		
+
 		subModelTypeAttribute: 'type',
 		subModelTypes: null,
-		
+
 		constructor: function( attributes, options ) {
 			// Nasty hack, for cases like 'model.get( <HasMany key> ).add( item )'.
-			// Defer 'processQueue', so that when 'Relation.createModels' is used we:
-			// a) Survive 'Backbone.Collection.add'; this takes care we won't error on "can't add model to a set twice"
-			//    (by creating a model from properties, having the model add itself to the collection via one of
-			//    it's relations, then trying to add it to the collection).
-			// b) Trigger 'HasMany' collection events only after the model is really fully set up.
-			// Example that triggers both a and b: "p.get('jobs').add( { company: c, person: p } )".
-			var dit = this;
+			// Defer 'processQueue', so that when 'Relation.createModels' is used we trigger 'HasMany'
+			// collection events only after the model is really fully set up.
+			// Example: "p.get('jobs').add( { company: c, person: p } )".
 			if ( options && options.collection ) {
+				var dit = this,
+					collection = this.collection =  options.collection;
+
+				// Prevent this option from cascading down to related models; they shouldn't go into this `if` clause.
+				delete options.collection;
+
 				this._deferProcessing = true;
-				
+
 				var processQueue = function( model ) {
 					if ( model === dit ) {
 						dit._deferProcessing = false;
 						dit.processQueue();
-						options.collection.unbind( 'relational:add', processQueue );
+						collection.off( 'relational:add', processQueue );
 					}
 				};
-				options.collection.bind( 'relational:add', processQueue );
-				
-				// So we do process the queue eventually, regardless of whether this model really gets added to 'options.collection'.
+				collection.on( 'relational:add', processQueue );
+
+				// So we do process the queue eventually, regardless of whether this model actually gets added to 'options.collection'.
 				_.defer( function() {
 					processQueue( dit );
 				});
 			}
+
+			Backbone.Relational.store.processOrphanRelations();
 			
 			this._queue = new Backbone.BlockingQueue();
 			this._queue.block();
 			Backbone.Relational.eventQueue.block();
-			
-			Backbone.Model.apply( this, arguments );
-			
-			// Try to run the global queue holding external events
-			Backbone.Relational.eventQueue.unblock();
+
+			try {
+				Backbone.Model.apply( this, arguments );
+			}
+			finally {
+				// Try to run the global queue holding external events
+				Backbone.Relational.eventQueue.unblock();
+			}
 		},
-		
+
 		/**
 		 * Override 'trigger' to queue 'change' and 'change:*' events
 		 */
 		trigger: function( eventName ) {
-			if ( eventName.length > 5 && 'change' === eventName.substr( 0, 6 ) ) {
-				var dit = this, args = arguments;
+			if ( eventName.length > 5 && eventName.indexOf( 'change' ) === 0 ) {
+				var dit = this,
+					args = arguments;
+
 				Backbone.Relational.eventQueue.add( function() {
-						Backbone.Model.prototype.trigger.apply( dit, args );
-					});
+					if ( !dit._isInitialized ) {
+						return;
+					}
+
+					// Determine if the `change` event is still valid, now that all relations are populated
+					var changed = true;
+					if ( eventName === 'change' ) {
+						changed = dit.hasChanged();
+					}
+					else {
+						var attr = eventName.slice( 7 ),
+							rel = dit.getRelation( attr );
+
+						if ( rel ) {
+							// If `attr` is a relation, `change:attr` get triggered from `Relation.onChange`.
+							// These take precedence over `change:attr` events triggered by `Model.set`.
+							// The relation set a fourth attribute to `true`. If this attribute is present,
+							// continue triggering this event; otherwise, it's from `Model.set` and should be stopped.
+							changed = ( args[ 4 ] === true );
+
+							// If this event was triggered by a relation, set the right value in `this.changed`
+							// (a Collection or Model instead of raw data).
+							if ( changed ) {
+								dit.changed[ attr ] = args[ 2 ];
+							}
+							// Otherwise, this event is from `Model.set`. If the relation doesn't report a change,
+							// remove attr from `dit.changed` so `hasChanged` doesn't take it into account.
+							else if ( !rel.changed ) {
+								delete dit.changed[ attr ];
+							}
+						}
+					}
+
+					changed && Backbone.Model.prototype.trigger.apply( dit, args );
+				});
 			}
 			else {
 				Backbone.Model.prototype.trigger.apply( this, arguments );
@@ -1063,24 +1128,18 @@
 			
 			return this;
 		},
-		
+
 		/**
 		 * Initialize Relations present in this.relations; determine the type (HasOne/HasMany), then creates a new instance.
 		 * Invoked in the first call so 'set' (which is made from the Backbone.Model constructor).
 		 */
-		initializeRelations: function() {
+		initializeRelations: function( options ) {
 			this.acquire(); // Setting up relations often also involve calls to 'set', and we only want to enter this function once
-			this._relations = [];
+			this._relations = {};
 			
-			_.each( this.relations, function( rel ) {
-					var type = !_.isString( rel.type ) ? rel.type :	Backbone[ rel.type ] || Backbone.Relational.store.getObjectByName( rel.type );
-					if ( type && type.prototype instanceof Backbone.Relation ) {
-						new type( this, rel ); // Also pushes the new Relation into _relations
-					}
-					else {
-						Backbone.Relational.showWarnings && typeof console !== 'undefined' && console.warn( 'Relation=%o; missing or invalid type!', rel );
-					}
-				}, this );
+			_.each( this.relations || [], function( rel ) {
+				Backbone.Relational.store.initializeRelation( this, rel, options );
+			}, this );
 			
 			this._isInitialized = true;
 			this.release();
@@ -1102,14 +1161,14 @@
 				}, this );
 			}
 		},
-		
+
 		/**
 		 * Either add to the queue (if we're not initialized yet), or execute right away.
 		 */
 		queue: function( func ) {
 			this._queue.add( func );
 		},
-		
+
 		/**
 		 * Process _queue
 		 */
@@ -1118,62 +1177,58 @@
 				this._queue.unblock();
 			}
 		},
-		
+
 		/**
 		 * Get a specific relation.
 		 * @param key {string} The relation key to look for.
 		 * @return {Backbone.Relation} An instance of 'Backbone.Relation', if a relation was found for 'key', or null.
 		 */
 		getRelation: function( key ) {
-			return _.detect( this._relations, function( rel ) {
-				if ( rel.key === key ) {
-					return true;
-				}
-			}, this );
+			return this._relations[ key ];
 		},
-		
+
 		/**
 		 * Get all of the created relations.
 		 * @return {Backbone.Relation[]}
 		 */
 		getRelations: function() {
-			return this._relations;
+			return _.values( this._relations );
 		},
-		
+
 		/**
 		 * Retrieve related objects.
 		 * @param key {string} The relation key to fetch models for.
-		 * @param options {Object} Options for 'Backbone.Model.fetch' and 'Backbone.sync'.
-		 * @param update {boolean} Whether to force a fetch from the server (updating existing models).
+		 * @param [options] {Object} Options for 'Backbone.Model.fetch' and 'Backbone.sync'.
+		 * @param [refresh=false] {boolean} Fetch existing models from the server as well (in order to update them).
 		 * @return {jQuery.when[]} An array of request objects
 		 */
-		fetchRelated: function( key, options, update ) {
-			options || ( options = {} );
+		fetchRelated: function( key, options, refresh ) {
+			// Set default `options` for fetch
+			options = _.extend( { update: true, remove: false }, options );
+
 			var setUrl,
 				requests = [],
 				rel = this.getRelation( key ),
-				keyContents = rel && rel.keyContents,
-				toFetch = keyContents && _.select( _.isArray( keyContents ) ? keyContents : [ keyContents ], function( item ) {
-					var id = Backbone.Relational.store.resolveIdForItem( rel.relatedModel, item );
-					return id && ( update || !Backbone.Relational.store.find( rel.relatedModel, id ) );
+				keys = rel && ( rel.keyIds || [ rel.keyId ] ),
+				toFetch = keys && _.select( keys || [], function( id ) {
+					return ( id || id === 0 ) && ( refresh || !Backbone.Relational.store.find( rel.relatedModel, id ) );
 				}, this );
 			
 			if ( toFetch && toFetch.length ) {
-				// Create a model for each entry in 'keyContents' that is to be fetched
-				var models = _.map( toFetch, function( item ) {
-					var model;
+				// Find (or create) a model for each one that is to be fetched
+				var created = [],
+					models = _.map( toFetch, function( id ) {
+						var model = Backbone.Relational.store.find( rel.relatedModel, id );
+						
+						if ( !model ) {
+							var attrs = {};
+							attrs[ rel.relatedModel.prototype.idAttribute ] = id;
+							model = rel.relatedModel.findOrCreate( attrs, options );
+							created.push( model );
+						}
 
-					if ( _.isObject( item ) ) {
-						model = rel.relatedModel.build( item );
-					}
-					else {
-						var attrs = {};
-						attrs[ rel.relatedModel.prototype.idAttribute ] = item;
-						model = rel.relatedModel.build( attrs );
-					}
-
-					return model;
-				}, this );
+						return model;
+					}, this );
 				
 				// Try if the 'collection' can provide a url to fetch a set of models in one request.
 				if ( rel.related instanceof Backbone.Collection && _.isFunction( rel.related.url ) ) {
@@ -1188,15 +1243,14 @@
 						{
 							error: function() {
 								var args = arguments;
-								_.each( models, function( model ) {
-										model.trigger( 'destroy', model, model.collection, options );
-										options.error && options.error.apply( model, args );
-									});
+								_.each( created, function( model ) {
+									model.trigger( 'destroy', model, model.collection, options );
+									options.error && options.error.apply( model, args );
+								});
 							},
 							url: setUrl
 						},
-						options,
-						{ add: true }
+						options
 					);
 
 					requests = [ rel.related.fetch( opts ) ];
@@ -1206,8 +1260,10 @@
 						var opts = _.defaults(
 							{
 								error: function() {
-									model.trigger( 'destroy', model, model.collection, options );
-									options.error && options.error.apply( model, arguments );
+									if ( _.contains( created, model ) ) {
+										model.trigger( 'destroy', model, model.collection, options );
+										options.error && options.error.apply( model, arguments );
+									}
 								}
 							},
 							options
@@ -1219,7 +1275,32 @@
 			
 			return requests;
 		},
-		
+
+		get: function( attr ) {
+			var originalResult = Backbone.Model.prototype.get.call( this, attr );
+
+			// Use `originalResult` get if dotNotation not enabled or not required because no dot is in `attr`
+			if ( !this.dotNotation || attr.indexOf( '.' ) === -1 ) {
+				return originalResult;
+			}
+
+			// Go through all splits and return the final result
+			var splits = attr.split( '.' );
+			var result = _.reduce(splits, function( model, split ) {
+				if ( !( model instanceof Backbone.Model ) ) {
+					throw new Error( 'Attribute must be an instanceof Backbone.Model. Is: ' + model + ', currentSplit: ' + split );
+				}
+
+				return Backbone.Model.prototype.get.call( model, split );
+			}, this );
+
+			if ( originalResult !== undefined && result !== undefined ) {
+				throw new Error( "Ambiguous result for '" + attr + "'. direct result: " + originalResult + ", dotNotation: " + result );
+			}
+
+			return originalResult || result;
+		},
+
 		set: function( key, value, options ) {
 			Backbone.Relational.eventQueue.block();
 			
@@ -1237,28 +1318,31 @@
 			var result = Backbone.Model.prototype.set.apply( this, arguments );
 			
 			// Ideal place to set up relations :)
-			if ( !this._isInitialized && !this.isLocked() ) {
-				this.constructor.initializeModelHierarchy();
+			try {
+				if ( !this._isInitialized && !this.isLocked() ) {
+					this.constructor.initializeModelHierarchy();
 
-				Backbone.Relational.store.register( this );
+					Backbone.Relational.store.register( this );
 
-				this.initializeRelations();
+					this.initializeRelations( options );
+				}
+				// Update the 'idAttribute' in Backbone.store if; we don't want it to miss an 'id' update due to {silent:true}
+				else if ( attributes && this.idAttribute in attributes ) {
+					Backbone.Relational.store.update( this );
+				}
+
+				if ( attributes ) {
+					this.updateRelations( options );
+				}
 			}
-			// Update the 'idAttribute' in Backbone.store if; we don't want it to miss an 'id' update due to {silent:true}
-			else if ( attributes && this.idAttribute in attributes ) {
-				Backbone.Relational.store.update( this );
+			finally {
+				// Try to run the global queue holding external events
+				Backbone.Relational.eventQueue.unblock();
 			}
 			
-			if ( attributes ) {
-				this.updateRelations( options );
-			}
-			
-			// Try to run the global queue holding external events
-			Backbone.Relational.eventQueue.unblock();
-			
 			return result;
 		},
-		
+
 		unset: function( attribute, options ) {
 			Backbone.Relational.eventQueue.block();
 			
@@ -1270,7 +1354,7 @@
 			
 			return result;
 		},
-		
+
 		clear: function( options ) {
 			Backbone.Relational.eventQueue.block();
 			
@@ -1282,17 +1366,6 @@
 			
 			return result;
 		},
-		
-		/**
-		 * Override 'change', so the change will only execute after 'set' has finised (relations are updated),
-		 * and 'previousAttributes' will be available when the event is fired.
-		 */
-		change: function( options ) {
-			var dit = this, args = arguments;
-			Backbone.Relational.eventQueue.add( function() {
-					Backbone.Model.prototype.change.apply( dit, args );
-				});
-		},
 
 		clone: function() {
 			var attributes = _.clone( this.attributes );
@@ -1301,87 +1374,92 @@
 			}
 
 			_.each( this.getRelations(), function( rel ) {
-					delete attributes[ rel.key ];
-				});
+				delete attributes[ rel.key ];
+			});
 
 			return new this.constructor( attributes );
 		},
-		
+
 		/**
 		 * Convert relations to JSON, omits them when required
 		 */
-		toJSON: function() {
+		toJSON: function( options ) {
 			// If this Model has already been fully serialized in this branch once, return to avoid loops
 			if ( this.isLocked() ) {
 				return this.id;
 			}
 			
 			this.acquire();
-			var json = Backbone.Model.prototype.toJSON.call( this );
+			var json = Backbone.Model.prototype.toJSON.call( this, options );
 			
 			if ( this.constructor._superModel && !( this.constructor._subModelTypeAttribute in json ) ) {
 				json[ this.constructor._subModelTypeAttribute ] = this.constructor._subModelTypeValue;
 			}
 			
 			_.each( this._relations, function( rel ) {
-					var value = json[ rel.key ];
+				var value = json[ rel.key ];
 
-					if ( rel.options.includeInJSON === true) {
-						if ( value && _.isFunction( value.toJSON ) ) {
-							json[ rel.keyDestination ] = value.toJSON();
-						}
-						else {
-							json[ rel.keyDestination ] = null;
-						}
-					}
-					else if ( _.isString( rel.options.includeInJSON ) ) {
-						if ( value instanceof Backbone.Collection ) {
-							json[ rel.keyDestination ] = value.pluck( rel.options.includeInJSON );
-						}
-						else if ( value instanceof Backbone.Model ) {
-							json[ rel.keyDestination ] = value.get( rel.options.includeInJSON );
-						}	
-						else {
-							json[ rel.keyDestination ] = null;
-						}
-					}
-					else if ( _.isArray( rel.options.includeInJSON ) ) {
-						if ( value instanceof Backbone.Collection ) {
-							var valueSub = [];
-							value.each( function( model ) {
-								var curJson = {};
-								_.each( rel.options.includeInJSON, function( key ) {
-									curJson[ key ] = model.get( key );
-								});
-								valueSub.push( curJson );
-							});
-							json[ rel.keyDestination ] = valueSub;
-						}
-						else if ( value instanceof Backbone.Model ) {
-							var valueSub = {};
-							_.each( rel.options.includeInJSON, function( key ) {
-								valueSub[ key ] = value.get( key );
-							});
-							json[ rel.keyDestination ] = valueSub;
-						}
-						else {
-							json[ rel.keyDestination ] = null;
-						}
+				if ( rel.options.includeInJSON === true) {
+					if ( value && _.isFunction( value.toJSON ) ) {
+						json[ rel.keyDestination ] = value.toJSON( options );
 					}
 					else {
-						delete json[ rel.key ];
+						json[ rel.keyDestination ] = null;
 					}
+				}
+				else if ( _.isString( rel.options.includeInJSON ) ) {
+					if ( value instanceof Backbone.Collection ) {
+						json[ rel.keyDestination ] = value.pluck( rel.options.includeInJSON );
+					}
+					else if ( value instanceof Backbone.Model ) {
+						json[ rel.keyDestination ] = value.get( rel.options.includeInJSON );
+					}
+					else {
+						json[ rel.keyDestination ] = null;
+					}
+				}
+				else if ( _.isArray( rel.options.includeInJSON ) ) {
+					if ( value instanceof Backbone.Collection ) {
+						var valueSub = [];
+						value.each( function( model ) {
+							var curJson = {};
+							_.each( rel.options.includeInJSON, function( key ) {
+								curJson[ key ] = model.get( key );
+							});
+							valueSub.push( curJson );
+						});
+						json[ rel.keyDestination ] = valueSub;
+					}
+					else if ( value instanceof Backbone.Model ) {
+						var valueSub = {};
+						_.each( rel.options.includeInJSON, function( key ) {
+							valueSub[ key ] = value.get( key );
+						});
+						json[ rel.keyDestination ] = valueSub;
+					}
+					else {
+						json[ rel.keyDestination ] = null;
+					}
+				}
+				else {
+					delete json[ rel.key ];
+				}
 
-					if ( rel.keyDestination !== rel.key ) {
-						delete json[ rel.key ];
-					}
-				});
+				if ( rel.keyDestination !== rel.key ) {
+					delete json[ rel.key ];
+				}
+			});
 			
 			this.release();
 			return json;
 		}
 	},
 	{
+		/**
+		 *
+		 * @param superModel
+		 * @returns {Backbone.RelationalModel.constructor}
+		 */
 		setup: function( superModel ) {
 			// We don't want to share a relations array with a parent, as this will cause problems with
 			// reverse relations.
@@ -1400,30 +1478,37 @@
 			}
 
 			// Initialize all reverseRelations that belong to this new model.
-			_.each( this.prototype.relations, function( rel ) {
-					if ( !rel.model ) {
-						rel.model = this;
+			_.each( this.prototype.relations || [], function( rel ) {
+				if ( !rel.model ) {
+					rel.model = this;
+				}
+				
+				if ( rel.reverseRelation && rel.model === this ) {
+					var preInitialize = true;
+					if ( _.isString( rel.relatedModel ) ) {
+						/**
+						 * The related model might not be defined for two reasons
+						 *  1. it is related to itself
+						 *  2. it never gets defined, e.g. a typo
+						 *  3. the model hasn't been defined yet, but will be later
+						 * In neither of these cases do we need to pre-initialize reverse relations.
+						 * However, for 3. (which is, to us, indistinguishable from 2.), we do need to attempt
+						 * setting up this relation again later, in case the related model is defined later.
+						 */
+						var relatedModel = Backbone.Relational.store.getObjectByName( rel.relatedModel );
+						preInitialize = relatedModel && ( relatedModel.prototype instanceof Backbone.RelationalModel );
 					}
 
-					if ( rel.reverseRelation && rel.model === this ) {				
-						var preInitialize = true;
-						if ( _.isString( rel.relatedModel ) ) {
-							/**
-							 * The related model might not be defined for two reasons
-							 *  1. it never gets defined, e.g. a typo
-							 *  2. it is related to itself
-							 * In neither of these cases do we need to pre-initialize reverse relations.
-							 */
-							var relatedModel = Backbone.Relational.store.getObjectByName( rel.relatedModel );
-							preInitialize = relatedModel && ( relatedModel.prototype instanceof Backbone.RelationalModel );
-						}
-
-						var type = !_.isString( rel.type ) ? rel.type : Backbone[ rel.type ] || Backbone.Relational.store.getObjectByName( rel.type );
-						if ( preInitialize && type && type.prototype instanceof Backbone.Relation ) {
-							new type( null, rel );
-						}
+					if ( preInitialize ) {
+						Backbone.Relational.store.initializeRelation( null, rel );
 					}
-				}, this );
+					else if ( _.isString( rel.relatedModel ) ) {
+						Backbone.Relational.store.addOrphanRelation( rel );
+					}
+				}
+			}, this );
+			
+			return this;
 		},
 
 		/**
@@ -1451,6 +1536,9 @@
 			return new model( attributes, options );
 		},
 
+		/**
+		 *
+		 */
 		initializeModelHierarchy: function() {
 			// If we're here for the first time, try to determine if this modelType has a 'superModel'.
 			if ( _.isUndefined( this._superModel ) || _.isNull( this._superModel ) ) {
@@ -1463,7 +1551,7 @@
 				if ( this._superModel ) {
 					//
 					if ( this._superModel.prototype.relations ) {
-						var supermodelRelationsExist = _.any( this.prototype.relations, function( rel ) {
+						var supermodelRelationsExist = _.any( this.prototype.relations || [], function( rel ) {
 							return rel.model && rel.model !== this;
 						}, this );
 
@@ -1479,7 +1567,7 @@
 
 			// If we came here through 'build' for a model that has 'subModelTypes', and not all of them have been resolved yet, try to resolve each.
 			if ( this.prototype.subModelTypes && _.keys( this.prototype.subModelTypes ).length !== _.keys( this._subModels ).length ) {
-				_.each( this.prototype.subModelTypes, function( subModelTypeName ) {
+				_.each( this.prototype.subModelTypes || [], function( subModelTypeName ) {
 					var subModelType = Backbone.Relational.store.getObjectByName( subModelTypeName );
 					subModelType && subModelType.initializeModelHierarchy();
 				});
@@ -1489,24 +1577,30 @@
 		/**
 		 * Find an instance of `this` type in 'Backbone.Relational.store'.
 		 * - If `attributes` is a string or a number, `findOrCreate` will just query the `store` and return a model if found.
-		 * - If `attributes` is an object, the model will be updated with `attributes` if found.
+		 * - If `attributes` is an object and is found in the store, the model will be updated with `attributes` unless `options.update` is `false`.
 		 *   Otherwise, a new model is created with `attributes` (unless `options.create` is explicitly set to `false`).
 		 * @param {Object|String|Number} attributes Either a model's id, or the attributes used to create or update a model.
 		 * @param {Object} [options]
 		 * @param {Boolean} [options.create=true]
+		 * @param {Boolean} [options.merge=true]
+		 * @param {Boolean} [options.parse=false]
 		 * @return {Backbone.RelationalModel}
 		 */
 		findOrCreate: function( attributes, options ) {
-			// Try to find an instance of 'this' model type in the store
-			var model = Backbone.Relational.store.find( this, attributes );
+			options || ( options = {} );
+			var parsedAttributes = ( _.isObject( attributes ) && options.parse && this.prototype.parse ) ?
+				this.prototype.parse( attributes ) : attributes;
 
-			// If we found an instance, update it with the data in 'item'; if not, create an instance
-			// (unless 'options.create' is false).
+			// Try to find an instance of 'this' model type in the store
+			var model = Backbone.Relational.store.find( this, parsedAttributes );
+
+			// If we found an instance, update it with the data in 'item' (unless 'options.merge' is false).
+			// If not, create an instance (unless 'options.create' is false).
 			if ( _.isObject( attributes ) ) {
-				if ( model ) {
-					model.set( attributes, options );
+				if ( model && options.merge !== false ) {
+					model.set( parsedAttributes, options );
 				}
-				else if ( !options || ( options && options.create !== false ) ) {
+				else if ( !model && options.create !== false ) {
 					model = this.build( attributes, options );
 				}
 			}
@@ -1515,103 +1609,123 @@
 		}
 	});
 	_.extend( Backbone.RelationalModel.prototype, Backbone.Semaphore );
-	
+
 	/**
 	 * Override Backbone.Collection._prepareModel, so objects will be built using the correct type
 	 * if the collection.model has subModels.
+	 * Attempts to find a model for `attrs` in Backbone.store through `findOrCreate`
+	 * (which sets the new properties on it if found), or instantiates a new model.
 	 */
 	Backbone.Collection.prototype.__prepareModel = Backbone.Collection.prototype._prepareModel;
-	Backbone.Collection.prototype._prepareModel = function ( model, options ) {
-		options || (options = {});
-		if ( !( model instanceof Backbone.Model ) ) {
-			var attrs = model;
+	Backbone.Collection.prototype._prepareModel = function ( attrs, options ) {
+		var model;
+		
+		if ( attrs instanceof Backbone.Model ) {
+			if ( !attrs.collection ) {
+				attrs.collection = this;
+			}
+			model = attrs;
+		}
+		else {
+			options || (options = {});
 			options.collection = this;
 			
-			if ( typeof this.model.build !== 'undefined' ) {
-				model = this.model.build( attrs, options );
+			if ( typeof this.model.findOrCreate !== 'undefined' ) {
+				model = this.model.findOrCreate( attrs, options );
 			}
 			else {
 				model = new this.model( attrs, options );
 			}
 			
-			if ( !model._validate( model.attributes, options ) ) {
+			if ( model && model.isNew() && !model._validate( attrs, options ) ) {
+				this.trigger( 'invalid', this, attrs, options );
 				model = false;
 			}
 		}
-		else if ( !model.collection ) {
-			model.collection = this;
-		}
 		
 		return model;
-	}
-	
+	};
+
+
 	/**
-	 * Override Backbone.Collection.add, so objects fetched from the server multiple times will
-	 * update the existing Model. Also, trigger 'relational:add'.
+	 * Override Backbone.Collection.add, so we'll create objects from attributes where required,
+	 * and update the existing models. Also, trigger 'relational:add'.
 	 */
 	var add = Backbone.Collection.prototype.__add = Backbone.Collection.prototype.add;
 	Backbone.Collection.prototype.add = function( models, options ) {
-		options || (options = {});
-		if ( !_.isArray( models ) ) {
-			models = [ models ];
+		// Short-circuit if this Collection doesn't hold RelationalModels
+		if ( !( this.model.prototype instanceof Backbone.RelationalModel ) ) {
+			return add.apply( this, arguments );
 		}
 
-		var modelsToAdd = [];
+		models = _.isArray( models ) ? models.slice() : [ models ];
+		// Set default options to the same values as `add` uses, so `findOrCreate` will also respect those.
+		options = _.extend( { merge: false }, options );
+
+		var newModels = [],
+			toAdd = [];
 
 		//console.debug( 'calling add on coll=%o; model=%o, options=%o', this, models, options );
 		_.each( models, function( model ) {
-				if ( !( model instanceof Backbone.Model ) ) {
-					// Try to find 'model' in Backbone.store. If it already exists, set the new properties on it.
-					var existingModel = Backbone.Relational.store.find( this.model, model[ this.model.prototype.idAttribute ] );
-					if ( existingModel ) {
-						existingModel.set( existingModel.parse ? existingModel.parse( model ) : model, options );
-						model = existingModel;
-					}
-					else {
-						model = Backbone.Collection.prototype._prepareModel.call( this, model, options );
-					}
-				}
+			if ( !( model instanceof Backbone.Model ) ) {
+				model = Backbone.Collection.prototype._prepareModel.call( this, model, options );
+			}
 
-				if ( model instanceof Backbone.Model && !this.get( model ) && !this.getByCid( model ) ) {
-					modelsToAdd.push( model );
-				}
-			}, this );
+			if ( model ) {
+				toAdd.push( model );
 
+				if ( !( this.get( model ) || this.get( model.cid ) ) ) {
+					newModels.push( model );
+				}
+				// If we arrive in `add` while performing a `set` (after a create, so the model gains an `id`),
+				// we may get here before `_onModelEvent` has had the chance to update `_byId`.
+				else if ( model.id != null ) {
+					this._byId[ model.id ] = model;
+				}
+			}
+		}, this );
 
 		// Add 'models' in a single batch, so the original add will only be called once (and thus 'sort', etc).
-		if ( modelsToAdd.length ) {
-			add.call( this, modelsToAdd, options );
+		add.call( this, toAdd, options );
 
-			_.each( modelsToAdd, function( model ) {
-					this.trigger( 'relational:add', model, this, options );
-				}, this );
-		}
+		_.each( newModels, function( model ) {
+			// Fire a `relational:add` event for any model in `newModels` that has actually been added to the collection.
+			if ( this.get( model ) || this.get( model.cid ) ) {
+				this.trigger( 'relational:add', model, this, options );
+			}
+		}, this );
 		
 		return this;
 	};
-	
+
 	/**
 	 * Override 'Backbone.Collection.remove' to trigger 'relational:remove'.
 	 */
 	var remove = Backbone.Collection.prototype.__remove = Backbone.Collection.prototype.remove;
 	Backbone.Collection.prototype.remove = function( models, options ) {
-		options || (options = {});
-		if ( !_.isArray( models ) ) {
-			models = [ models ];
-		}
-		else {
-			models = models.slice( 0 );
+		// Short-circuit if this Collection doesn't hold RelationalModels
+		if ( !( this.model.prototype instanceof Backbone.RelationalModel ) ) {
+			return remove.apply( this, arguments );
 		}
 
+		models = _.isArray( models ) ? models.slice() : [ models ];
+		options || ( options = {} );
+
+		var toRemove = [];
+
 		//console.debug('calling remove on coll=%o; models=%o, options=%o', this, models, options );
 		_.each( models, function( model ) {
-				model = this.getByCid( model ) || this.get( model );
+			model = this.get( model ) || this.get( model.cid );
+			model && toRemove.push( model );
+		}, this );
 
-				if ( model instanceof Backbone.Model ) {
-					remove.call( this, model, options );
-					this.trigger('relational:remove', model, this, options);
-				}
+		if ( toRemove.length ) {
+			remove.call( this, toRemove, options );
+
+			_.each( toRemove, function( model ) {
+				this.trigger('relational:remove', model, this, options);
 			}, this );
+		}
 		
 		return this;
 	};
@@ -1622,7 +1736,10 @@
 	var reset = Backbone.Collection.prototype.__reset = Backbone.Collection.prototype.reset;
 	Backbone.Collection.prototype.reset = function( models, options ) {
 		reset.call( this, models, options );
-		this.trigger( 'relational:reset', this, options );
+
+		if ( this.model.prototype instanceof Backbone.RelationalModel ) {
+			this.trigger( 'relational:reset', this, options );
+		}
 
 		return this;
 	};
@@ -1633,22 +1750,39 @@
 	var sort = Backbone.Collection.prototype.__sort = Backbone.Collection.prototype.sort;
 	Backbone.Collection.prototype.sort = function( options ) {
 		sort.call( this, options );
-		this.trigger( 'relational:reset', this, options );
+
+		if ( this.model.prototype instanceof Backbone.RelationalModel ) {
+			this.trigger( 'relational:reset', this, options );
+		}
 
 		return this;
 	};
-	
+
 	/**
 	 * Override 'Backbone.Collection.trigger' so 'add', 'remove' and 'reset' events are queued until relations
 	 * are ready.
 	 */
 	var trigger = Backbone.Collection.prototype.__trigger = Backbone.Collection.prototype.trigger;
 	Backbone.Collection.prototype.trigger = function( eventName ) {
+		// Short-circuit if this Collection doesn't hold RelationalModels
+		if ( !( this.model.prototype instanceof Backbone.RelationalModel ) ) {
+			return trigger.apply( this, arguments );
+		}
+
 		if ( eventName === 'add' || eventName === 'remove' || eventName === 'reset' ) {
-			var dit = this, args = arguments;
+			var dit = this,
+				args = arguments;
+			
+			if ( _.isObject( args[ 3 ] ) ) {
+				args = _.toArray( args );
+				// the fourth argument is the option object.
+				// we need to clone it, as it could be modified while we wait on the eventQueue to be unblocked
+				args[ 3 ] = _.clone( args[ 3 ] );
+			}
+			
 			Backbone.Relational.eventQueue.add( function() {
-					trigger.apply( dit, args );
-				});
+				trigger.apply( dit, args );
+			});
 		}
 		else {
 			trigger.apply( this, arguments );
diff --git a/static/scripts/libs/backbone/backbone.js b/static/scripts/libs/backbone/backbone.js
index 3373c952bfa..3512d42fb43 100644
--- a/static/scripts/libs/backbone/backbone.js
+++ b/static/scripts/libs/backbone/backbone.js
@@ -1,6 +1,6 @@
-//     Backbone.js 0.9.2
+//     Backbone.js 1.0.0
 
-//     (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc.
+//     (c) 2010-2013 Jeremy Ashkenas, DocumentCloud Inc.
 //     Backbone may be freely distributed under the MIT license.
 //     For all details and documentation:
 //     http://backbonejs.org
@@ -10,7 +10,7 @@
   // Initial Setup
   // -------------
 
-  // Save a reference to the global object (`window` in the browser, `global`
+  // Save a reference to the global object (`window` in the browser, `exports`
   // on the server).
   var root = this;
 
@@ -18,12 +18,14 @@
   // restored later on, if `noConflict` is used.
   var previousBackbone = root.Backbone;
 
-  // Create a local reference to slice/splice.
-  var slice = Array.prototype.slice;
-  var splice = Array.prototype.splice;
+  // 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;
 
   // The top-level namespace. All public Backbone classes and modules will
-  // be attached to this. Exported for both CommonJS and the browser.
+  // be attached to this. Exported for both the browser and the server.
   var Backbone;
   if (typeof exports !== 'undefined') {
     Backbone = exports;
@@ -32,23 +34,15 @@
   }
 
   // Current version of the library. Keep in sync with `package.json`.
-  Backbone.VERSION = '0.9.2';
+  Backbone.VERSION = '1.0.0';
 
   // Require Underscore, if we're on the server, and it's not already present.
   var _ = root._;
   if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
 
-  // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable.
-  var $ = root.jQuery || root.Zepto || root.ender;
-
-  // Set the JavaScript library that will be used for DOM manipulation and
-  // Ajax calls (a.k.a. the `$` variable). By default Backbone will use: jQuery,
-  // Zepto, or Ender; but the `setDomLibrary()` method lets you inject an
-  // alternate JavaScript library (or a mock library for testing your views
-  // outside of a browser).
-  Backbone.setDomLibrary = function(lib) {
-    $ = lib;
-  };
+  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
+  // the `$` variable.
+  Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$;
 
   // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
   // to its previous owner. Returns a reference to this Backbone object.
@@ -69,14 +63,12 @@
   Backbone.emulateJSON = false;
 
   // Backbone.Events
-  // -----------------
-
-  // Regular expression used to split event strings
-  var eventSplitter = /\s+/;
+  // ---------------
 
   // A module that can be mixed in to *any object* in order to provide it with
-  // custom events. You may bind with `on` or remove with `off` callback functions
-  // to an event; trigger`-ing an event fires all callbacks in succession.
+  // custom events. You may bind with `on` or remove with `off` callback
+  // functions to an event; `trigger`-ing an event fires all callbacks in
+  // succession.
   //
   //     var object = {};
   //     _.extend(object, Backbone.Events);
@@ -85,58 +77,56 @@
   //
   var Events = Backbone.Events = {
 
-    // Bind one or more space separated events, `events`, to a `callback`
-    // function. Passing `"all"` will bind the callback to all events fired.
-    on: function(events, callback, context) {
-
-      var calls, event, node, tail, list;
-      if (!callback) return this;
-      events = events.split(eventSplitter);
-      calls = this._callbacks || (this._callbacks = {});
-
-      // Create an immutable callback list, allowing traversal during
-      // modification.  The tail is an empty object that will always be used
-      // as the next node.
-      while (event = events.shift()) {
-        list = calls[event];
-        node = list ? list.tail : {};
-        node.next = tail = {};
-        node.context = context;
-        node.callback = callback;
-        calls[event] = {tail: tail, next: list ? list.next : node};
-      }
-
+    // Bind an event to a `callback` function. Passing `"all"` will bind
+    // the callback to all events fired.
+    on: function(name, callback, context) {
+      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
+      this._events || (this._events = {});
+      var events = this._events[name] || (this._events[name] = []);
+      events.push({callback: callback, context: context, ctx: context || this});
       return this;
     },
 
-    // Remove one or many callbacks. If `context` is null, removes all callbacks
-    // with that function. If `callback` is null, removes all callbacks for the
-    // event. If `events` is null, removes all bound callbacks for all events.
-    off: function(events, callback, context) {
-      var event, calls, node, tail, cb, ctx;
+    // Bind an event to only be triggered a single time. After the first time
+    // the callback is invoked, it will be removed.
+    once: function(name, callback, context) {
+      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
+      var self = this;
+      var once = _.once(function() {
+        self.off(name, once);
+        callback.apply(this, arguments);
+      });
+      once._callback = callback;
+      return this.on(name, once, context);
+    },
 
-      // No events, or removing *all* events.
-      if (!(calls = this._callbacks)) return;
-      if (!(events || callback || context)) {
-        delete this._callbacks;
+    // Remove one or many callbacks. If `context` is null, removes all
+    // callbacks with that function. If `callback` is null, removes all
+    // 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;
+      if (!name && !callback && !context) {
+        this._events = {};
         return this;
       }
 
-      // Loop through the listed events and contexts, splicing them out of the
-      // linked list of callbacks if appropriate.
-      events = events ? events.split(eventSplitter) : _.keys(calls);
-      while (event = events.shift()) {
-        node = calls[event];
-        delete calls[event];
-        if (!node || !(callback || context)) continue;
-        // Create a new list, omitting the indicated callbacks.
-        tail = node.tail;
-        while ((node = node.next) !== tail) {
-          cb = node.callback;
-          ctx = node.context;
-          if ((callback && cb !== callback) || (context && ctx !== context)) {
-            this.on(event, cb, ctx);
+      names = name ? [name] : _.keys(this._events);
+      for (i = 0, l = names.length; i < l; 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);
+              }
+            }
           }
+          if (!retain.length) delete this._events[name];
         }
       }
 
@@ -147,81 +137,138 @@
     // passed the same arguments as `trigger` is, apart from the event name
     // (unless you're listening on `"all"`, which will cause your callback to
     // receive the true name of the event as the first argument).
-    trigger: function(events) {
-      var event, node, calls, tail, args, all, rest;
-      if (!(calls = this._callbacks)) return this;
-      all = calls.all;
-      events = events.split(eventSplitter);
-      rest = slice.call(arguments, 1);
+    trigger: function(name) {
+      if (!this._events) return this;
+      var args = slice.call(arguments, 1);
+      if (!eventsApi(this, 'trigger', name, args)) return this;
+      var events = this._events[name];
+      var allEvents = this._events.all;
+      if (events) triggerEvents(events, args);
+      if (allEvents) triggerEvents(allEvents, arguments);
+      return this;
+    },
 
-      // For each event, walk through the linked list of callbacks twice,
-      // first to trigger the event, then to trigger any `"all"` callbacks.
-      while (event = events.shift()) {
-        if (node = calls[event]) {
-          tail = node.tail;
-          while ((node = node.next) !== tail) {
-            node.callback.apply(node.context || this, rest);
-          }
-        }
-        if (node = all) {
-          tail = node.tail;
-          args = [event].concat(rest);
-          while ((node = node.next) !== tail) {
-            node.callback.apply(node.context || this, args);
-          }
-        }
+    // Tell this object to stop listening to either specific events ... or
+    // to every object it's currently listening to.
+    stopListening: function(obj, name, callback) {
+      var listeners = this._listeners;
+      if (!listeners) return this;
+      var deleteListener = !name && !callback;
+      if (typeof name === 'object') callback = this;
+      if (obj) (listeners = {})[obj._listenerId] = obj;
+      for (var id in listeners) {
+        listeners[id].off(name, callback, this);
+        if (deleteListener) delete this._listeners[id];
       }
-
       return this;
     }
 
   };
 
+  // Regular expression used to split event strings.
+  var eventSplitter = /\s+/;
+
+  // Implement fancy features of the Events API such as multiple event
+  // names `"change blur"` and jQuery-style event maps `{change: action}`
+  // in terms of the existing API.
+  var eventsApi = function(obj, action, name, rest) {
+    if (!name) return true;
+
+    // Handle event maps.
+    if (typeof name === 'object') {
+      for (var key in name) {
+        obj[action].apply(obj, [key, name[key]].concat(rest));
+      }
+      return false;
+    }
+
+    // Handle space separated event names.
+    if (eventSplitter.test(name)) {
+      var names = name.split(eventSplitter);
+      for (var i = 0, l = names.length; i < l; i++) {
+        obj[action].apply(obj, [names[i]].concat(rest));
+      }
+      return false;
+    }
+
+    return true;
+  };
+
+  // A difficult-to-believe, but optimized internal dispatch function for
+  // triggering events. Tries to keep the usual cases speedy (most internal
+  // Backbone events have 3 arguments).
+  var triggerEvents = function(events, args) {
+    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
+    switch (args.length) {
+      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
+      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
+      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
+      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
+      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+    }
+  };
+
+  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
+
+  // Inversion-of-control versions of `on` and `once`. Tell *this* object to
+  // listen to an event in another object ... keeping track of what it's
+  // listening to.
+  _.each(listenMethods, function(implementation, method) {
+    Events[method] = function(obj, name, callback) {
+      var listeners = this._listeners || (this._listeners = {});
+      var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
+      listeners[id] = obj;
+      if (typeof name === 'object') callback = this;
+      obj[implementation](name, callback, this);
+      return this;
+    };
+  });
+
   // Aliases for backwards compatibility.
   Events.bind   = Events.on;
   Events.unbind = Events.off;
 
+  // Allow the `Backbone` object to serve as a global event bus, for folks who
+  // want global "pubsub" in a convenient place.
+  _.extend(Backbone, Events);
+
   // Backbone.Model
   // --------------
 
-  // Create a new model, with defined attributes. A client id (`cid`)
+  // Backbone **Models** are the basic data object in the framework --
+  // frequently representing a row in a table in a database on your server.
+  // A discrete chunk of data and a bunch of useful, related methods for
+  // performing computations and transformations on that data.
+
+  // Create a new model with the specified attributes. A client id (`cid`)
   // is automatically generated and assigned for you.
   var Model = Backbone.Model = function(attributes, options) {
     var defaults;
-    attributes || (attributes = {});
-    if (options && options.parse) attributes = this.parse(attributes);
-    if (defaults = getValue(this, 'defaults')) {
-      attributes = _.extend({}, defaults, attributes);
-    }
-    if (options && options.collection) this.collection = options.collection;
-    this.attributes = {};
-    this._escapedAttributes = {};
+    var attrs = attributes || {};
+    options || (options = {});
     this.cid = _.uniqueId('c');
+    this.attributes = {};
+    _.extend(this, _.pick(options, modelOptions));
+    if (options.parse) attrs = this.parse(attrs, options) || {};
+    if (defaults = _.result(this, 'defaults')) {
+      attrs = _.defaults({}, attrs, defaults);
+    }
+    this.set(attrs, options);
     this.changed = {};
-    this._silent = {};
-    this._pending = {};
-    this.set(attributes, {silent: true});
-    // Reset change tracking.
-    this.changed = {};
-    this._silent = {};
-    this._pending = {};
-    this._previousAttributes = _.clone(this.attributes);
     this.initialize.apply(this, arguments);
   };
 
+  // A list of options to be attached directly to the model, if provided.
+  var modelOptions = ['url', 'urlRoot', 'collection'];
+
   // Attach all inheritable methods to the Model prototype.
   _.extend(Model.prototype, Events, {
 
     // A hash of attributes whose current and previous value differ.
     changed: null,
 
-    // A hash of attributes that have silently changed since the last time
-    // `change` was called.  Will become pending attributes on the next call.
-    _silent: null,
-
-    // A hash of attributes that have changed since the last `'change'` event
-    // began.
-    _pending: null,
+    // The value returned during the last failed validation.
+    validationError: null,
 
     // The default name for the JSON `id` attribute is `"id"`. MongoDB and
     // CouchDB users may want to set this to `"_id"`.
@@ -236,6 +283,12 @@
       return _.clone(this.attributes);
     },
 
+    // Proxy `Backbone.sync` by default -- but override this if you need
+    // custom syncing semantics for *this* particular model.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
+    },
+
     // Get the value of an attribute.
     get: function(attr) {
       return this.attributes[attr];
@@ -243,10 +296,7 @@
 
     // Get the HTML-escaped value of an attribute.
     escape: function(attr) {
-      var html;
-      if (html = this._escapedAttributes[attr]) return html;
-      var val = this.get(attr);
-      return this._escapedAttributes[attr] = _.escape(val == null ? '' : '' + val);
+      return _.escape(this.get(attr));
     },
 
     // Returns `true` if the attribute contains a value that is not null
@@ -255,146 +305,195 @@
       return this.get(attr) != null;
     },
 
-    // Set a hash of model attributes on the object, firing `"change"` unless
-    // you choose to silence it.
-    set: function(key, value, options) {
-      var attrs, attr, val;
+    // Set a hash of model attributes on the object, firing `"change"`. This is
+    // the core primitive operation of a model, updating the data and notifying
+    // anyone who needs to know about the change in state. The heart of the beast.
+    set: function(key, val, options) {
+      var attr, attrs, unset, changes, silent, changing, prev, current;
+      if (key == null) return this;
 
       // Handle both `"key", value` and `{key: value}` -style arguments.
-      if (_.isObject(key) || key == null) {
+      if (typeof key === 'object') {
         attrs = key;
-        options = value;
+        options = val;
       } else {
-        attrs = {};
-        attrs[key] = value;
+        (attrs = {})[key] = val;
       }
 
-      // Extract attributes and options.
       options || (options = {});
-      if (!attrs) return this;
-      if (attrs instanceof Model) attrs = attrs.attributes;
-      if (options.unset) for (attr in attrs) attrs[attr] = void 0;
 
       // Run validation.
       if (!this._validate(attrs, options)) return false;
 
+      // Extract attributes and options.
+      unset           = options.unset;
+      silent          = options.silent;
+      changes         = [];
+      changing        = this._changing;
+      this._changing  = true;
+
+      if (!changing) {
+        this._previousAttributes = _.clone(this.attributes);
+        this.changed = {};
+      }
+      current = this.attributes, prev = this._previousAttributes;
+
       // Check for changes of `id`.
       if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
 
-      var changes = options.changes = {};
-      var now = this.attributes;
-      var escaped = this._escapedAttributes;
-      var prev = this._previousAttributes || {};
-
-      // For each `set` attribute...
+      // For each `set` attribute, update or delete the current value.
       for (attr in attrs) {
         val = attrs[attr];
-
-        // If the new and current value differ, record the change.
-        if (!_.isEqual(now[attr], val) || (options.unset && _.has(now, attr))) {
-          delete escaped[attr];
-          (options.silent ? this._silent : changes)[attr] = true;
-        }
-
-        // Update or delete the current value.
-        options.unset ? delete now[attr] : now[attr] = val;
-
-        // If the new and previous value differ, record the change.  If not,
-        // then remove changes for this attribute.
-        if (!_.isEqual(prev[attr], val) || (_.has(now, attr) != _.has(prev, attr))) {
+        if (!_.isEqual(current[attr], val)) changes.push(attr);
+        if (!_.isEqual(prev[attr], val)) {
           this.changed[attr] = val;
-          if (!options.silent) this._pending[attr] = true;
         } else {
           delete this.changed[attr];
-          delete this._pending[attr];
+        }
+        unset ? delete current[attr] : current[attr] = val;
+      }
+
+      // Trigger all relevant attribute changes.
+      if (!silent) {
+        if (changes.length) this._pending = true;
+        for (var i = 0, l = changes.length; i < l; i++) {
+          this.trigger('change:' + changes[i], this, current[changes[i]], options);
         }
       }
 
-      // Fire the `"change"` events.
-      if (!options.silent) this.change(options);
+      // You might be wondering why there's a `while` loop here. Changes can
+      // be recursively nested within `"change"` events.
+      if (changing) return this;
+      if (!silent) {
+        while (this._pending) {
+          this._pending = false;
+          this.trigger('change', this, options);
+        }
+      }
+      this._pending = false;
+      this._changing = false;
       return this;
     },
 
-    // Remove an attribute from the model, firing `"change"` unless you choose
-    // to silence it. `unset` is a noop if the attribute doesn't exist.
+    // Remove an attribute from the model, firing `"change"`. `unset` is a noop
+    // if the attribute doesn't exist.
     unset: function(attr, options) {
-      (options || (options = {})).unset = true;
-      return this.set(attr, null, options);
+      return this.set(attr, void 0, _.extend({}, options, {unset: true}));
     },
 
-    // Clear all attributes on the model, firing `"change"` unless you choose
-    // to silence it.
+    // Clear all attributes on the model, firing `"change"`.
     clear: function(options) {
-      (options || (options = {})).unset = true;
-      return this.set(_.clone(this.attributes), options);
+      var attrs = {};
+      for (var key in this.attributes) attrs[key] = void 0;
+      return this.set(attrs, _.extend({}, options, {unset: true}));
+    },
+
+    // Determine if the model has changed since the last `"change"` event.
+    // If you specify an attribute name, determine if that attribute has changed.
+    hasChanged: function(attr) {
+      if (attr == null) return !_.isEmpty(this.changed);
+      return _.has(this.changed, attr);
+    },
+
+    // Return an object containing all the attributes that have changed, or
+    // false if there are no changed attributes. Useful for determining what
+    // parts of a view need to be updated and/or what attributes need to be
+    // persisted to the server. Unset attributes will be set to undefined.
+    // You can also pass an attributes object to diff against the model,
+    // determining if there *would be* a change.
+    changedAttributes: function(diff) {
+      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
+      var val, changed = false;
+      var old = this._changing ? this._previousAttributes : this.attributes;
+      for (var attr in diff) {
+        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
+        (changed || (changed = {}))[attr] = val;
+      }
+      return changed;
+    },
+
+    // Get the previous value of an attribute, recorded at the time the last
+    // `"change"` event was fired.
+    previous: function(attr) {
+      if (attr == null || !this._previousAttributes) return null;
+      return this._previousAttributes[attr];
+    },
+
+    // Get all of the attributes of the model at the time of the previous
+    // `"change"` event.
+    previousAttributes: function() {
+      return _.clone(this._previousAttributes);
     },
 
     // Fetch the model from the server. If the server's representation of the
-    // model differs from its current attributes, they will be overriden,
+    // model differs from its current attributes, they will be overridden,
     // triggering a `"change"` event.
     fetch: function(options) {
       options = options ? _.clone(options) : {};
+      if (options.parse === void 0) options.parse = true;
       var model = this;
       var success = options.success;
-      options.success = function(resp, status, xhr) {
-        if (!model.set(model.parse(resp, xhr), options)) return false;
-        if (success) success(model, resp);
+      options.success = function(resp) {
+        if (!model.set(model.parse(resp, options), options)) return false;
+        if (success) success(model, resp, options);
+        model.trigger('sync', model, resp, options);
       };
-      options.error = Backbone.wrapError(options.error, model, options);
-      return (this.sync || Backbone.sync).call(this, 'read', this, options);
+      wrapError(this, options);
+      return this.sync('read', this, options);
     },
 
     // Set a hash of model attributes, and sync the model to the server.
     // If the server returns an attributes hash that differs, the model's
     // state will be `set` again.
-    save: function(key, value, options) {
-      var attrs, current;
+    save: function(key, val, options) {
+      var attrs, method, xhr, attributes = this.attributes;
 
-      // Handle both `("key", value)` and `({key: value})` -style calls.
-      if (_.isObject(key) || key == null) {
+      // Handle both `"key", value` and `{key: value}` -style arguments.
+      if (key == null || typeof key === 'object') {
         attrs = key;
-        options = value;
+        options = val;
       } else {
-        attrs = {};
-        attrs[key] = value;
-      }
-      options = options ? _.clone(options) : {};
-
-      // If we're "wait"-ing to set changed attributes, validate early.
-      if (options.wait) {
-        if (!this._validate(attrs, options)) return false;
-        current = _.clone(this.attributes);
+        (attrs = {})[key] = val;
       }
 
-      // Regular saves `set` attributes before persisting to the server.
-      var silentOptions = _.extend({}, options, {silent: true});
-      if (attrs && !this.set(attrs, options.wait ? silentOptions : options)) {
-        return false;
+      // If we're not waiting and attributes exist, save acts as `set(attr).save(null, opts)`.
+      if (attrs && (!options || !options.wait) && !this.set(attrs, options)) return false;
+
+      options = _.extend({validate: true}, options);
+
+      // Do not persist invalid models.
+      if (!this._validate(attrs, options)) return false;
+
+      // Set temporary attributes if `{wait: true}`.
+      if (attrs && options.wait) {
+        this.attributes = _.extend({}, attributes, attrs);
       }
 
       // After a successful server-side save, the client is (optionally)
       // updated with the server-side state.
+      if (options.parse === void 0) options.parse = true;
       var model = this;
       var success = options.success;
-      options.success = function(resp, status, xhr) {
-        var serverAttrs = model.parse(resp, xhr);
-        if (options.wait) {
-          delete options.wait;
-          serverAttrs = _.extend(attrs || {}, serverAttrs);
-        }
-        if (!model.set(serverAttrs, options)) return false;
-        if (success) {
-          success(model, resp);
-        } else {
-          model.trigger('sync', model, resp, options);
+      options.success = function(resp) {
+        // Ensure attributes are restored during synchronous saves.
+        model.attributes = attributes;
+        var serverAttrs = model.parse(resp, options);
+        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
+        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
+          return false;
         }
+        if (success) success(model, resp, options);
+        model.trigger('sync', model, resp, options);
       };
+      wrapError(this, options);
+
+      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+      if (method === 'patch') options.attrs = attrs;
+      xhr = this.sync(method, this, options);
+
+      // Restore attributes.
+      if (attrs && options.wait) this.attributes = attributes;
 
-      // Finish configuring and sending the Ajax request.
-      options.error = Backbone.wrapError(options.error, model, options);
-      var method = this.isNew() ? 'create' : 'update';
-      var xhr = (this.sync || Backbone.sync).call(this, method, this, options);
-      if (options.wait) this.set(current, silentOptions);
       return xhr;
     },
 
@@ -406,27 +505,24 @@
       var model = this;
       var success = options.success;
 
-      var triggerDestroy = function() {
+      var destroy = function() {
         model.trigger('destroy', model, model.collection, options);
       };
 
-      if (this.isNew()) {
-        triggerDestroy();
-        return false;
-      }
-
       options.success = function(resp) {
-        if (options.wait) triggerDestroy();
-        if (success) {
-          success(model, resp);
-        } else {
-          model.trigger('sync', model, resp, options);
-        }
+        if (options.wait || model.isNew()) destroy();
+        if (success) success(model, resp, options);
+        if (!model.isNew()) model.trigger('sync', model, resp, options);
       };
 
-      options.error = Backbone.wrapError(options.error, model, options);
-      var xhr = (this.sync || Backbone.sync).call(this, 'delete', this, options);
-      if (!options.wait) triggerDestroy();
+      if (this.isNew()) {
+        options.success();
+        return false;
+      }
+      wrapError(this, options);
+
+      var xhr = this.sync('delete', this, options);
+      if (!options.wait) destroy();
       return xhr;
     },
 
@@ -434,14 +530,14 @@
     // using Backbone's restful methods, override this to change the endpoint
     // that will be called.
     url: function() {
-      var base = getValue(this, 'urlRoot') || getValue(this.collection, 'url') || urlError();
+      var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
       if (this.isNew()) return base;
-      return base + (base.charAt(base.length - 1) == '/' ? '' : '/') + encodeURIComponent(this.id);
+      return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);
     },
 
     // **parse** converts a response into the hash of attributes to be `set` on
     // the model. The default implementation is just to pass the response along.
-    parse: function(resp, xhr) {
+    parse: function(resp, options) {
       return resp;
     },
 
@@ -455,116 +551,63 @@
       return this.id == null;
     },
 
-    // Call this method to manually fire a `"change"` event for this model and
-    // a `"change:attribute"` event for each changed attribute.
-    // Calling this will cause all objects observing the model to update.
-    change: function(options) {
-      options || (options = {});
-      var changing = this._changing;
-      this._changing = true;
-
-      // Silent changes become pending changes.
-      for (var attr in this._silent) this._pending[attr] = true;
-
-      // Silent changes are triggered.
-      var changes = _.extend({}, options.changes, this._silent);
-      this._silent = {};
-      for (var attr in changes) {
-        this.trigger('change:' + attr, this, this.get(attr), options);
-      }
-      if (changing) return this;
-
-      // Continue firing `"change"` events while there are pending changes.
-      while (!_.isEmpty(this._pending)) {
-        this._pending = {};
-        this.trigger('change', this, options);
-        // Pending and silent changes still remain.
-        for (var attr in this.changed) {
-          if (this._pending[attr] || this._silent[attr]) continue;
-          delete this.changed[attr];
-        }
-        this._previousAttributes = _.clone(this.attributes);
-      }
-
-      this._changing = false;
-      return this;
-    },
-
-    // Determine if the model has changed since the last `"change"` event.
-    // If you specify an attribute name, determine if that attribute has changed.
-    hasChanged: function(attr) {
-      if (!arguments.length) return !_.isEmpty(this.changed);
-      return _.has(this.changed, attr);
-    },
-
-    // Return an object containing all the attributes that have changed, or
-    // false if there are no changed attributes. Useful for determining what
-    // parts of a view need to be updated and/or what attributes need to be
-    // persisted to the server. Unset attributes will be set to undefined.
-    // You can also pass an attributes object to diff against the model,
-    // determining if there *would be* a change.
-    changedAttributes: function(diff) {
-      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
-      var val, changed = false, old = this._previousAttributes;
-      for (var attr in diff) {
-        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
-        (changed || (changed = {}))[attr] = val;
-      }
-      return changed;
-    },
-
-    // Get the previous value of an attribute, recorded at the time the last
-    // `"change"` event was fired.
-    previous: function(attr) {
-      if (!arguments.length || !this._previousAttributes) return null;
-      return this._previousAttributes[attr];
-    },
-
-    // Get all of the attributes of the model at the time of the previous
-    // `"change"` event.
-    previousAttributes: function() {
-      return _.clone(this._previousAttributes);
-    },
-
-    // Check if the model is currently in a valid state. It's only possible to
-    // get into an *invalid* state if you're using silent changes.
-    isValid: function() {
-      return !this.validate(this.attributes);
+    // Check if the model is currently in a valid state.
+    isValid: function(options) {
+      return this._validate({}, _.extend(options || {}, { validate: true }));
     },
 
     // Run validation against the next complete set of model attributes,
-    // returning `true` if all is well. If a specific `error` callback has
-    // been passed, call that instead of firing the general `"error"` event.
+    // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
     _validate: function(attrs, options) {
-      if (options.silent || !this.validate) return true;
+      if (!options.validate || !this.validate) return true;
       attrs = _.extend({}, this.attributes, attrs);
-      var error = this.validate(attrs, options);
+      var error = this.validationError = this.validate(attrs, options) || null;
       if (!error) return true;
-      if (options && options.error) {
-        options.error(this, error, options);
-      } else {
-        this.trigger('error', this, error, options);
-      }
+      this.trigger('invalid', this, error, _.extend(options || {}, {validationError: error}));
       return false;
     }
 
   });
 
+  // Underscore methods that we want to implement on the Model.
+  var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
+
+  // Mix in each Underscore method as a proxy to `Model#attributes`.
+  _.each(modelMethods, function(method) {
+    Model.prototype[method] = function() {
+      var args = slice.call(arguments);
+      args.unshift(this.attributes);
+      return _[method].apply(_, args);
+    };
+  });
+
   // Backbone.Collection
   // -------------------
 
-  // Provides a standard collection class for our sets of models, ordered
-  // or unordered. If a `comparator` is specified, the Collection will maintain
+  // 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
+  // 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
+  // indexes of their models, both in order, and for lookup by `id`.
+
+  // Create a new **Collection**, perhaps to contain a specific type of `model`.
+  // If a `comparator` is specified, the Collection will maintain
   // its models in sort order, as they're added and removed.
   var Collection = Backbone.Collection = function(models, options) {
     options || (options = {});
+    if (options.url) this.url = options.url;
     if (options.model) this.model = options.model;
-    if (options.comparator) this.comparator = options.comparator;
+    if (options.comparator !== void 0) this.comparator = options.comparator;
     this._reset();
     this.initialize.apply(this, arguments);
-    if (models) this.reset(models, {silent: true, parse: options.parse});
+    if (models) this.reset(models, _.extend({silent: true}, options));
   };
 
+  // Default options for `Collection#set`.
+  var setOptions = {add: true, remove: true, merge: true};
+  var addOptions = {add: true, merge: false, remove: false};
+
   // Define the Collection's inheritable methods.
   _.extend(Collection.prototype, Events, {
 
@@ -582,68 +625,26 @@
       return this.map(function(model){ return model.toJSON(options); });
     },
 
-    // Add a model, or list of models to the set. Pass **silent** to avoid
-    // firing the `add` event for every new model.
-    add: function(models, options) {
-      var i, index, length, model, cid, id, cids = {}, ids = {}, dups = [];
-      options || (options = {});
-      models = _.isArray(models) ? models.slice() : [models];
-
-      // Begin by turning bare objects into model references, and preventing
-      // invalid models or duplicate models from being added.
-      for (i = 0, length = models.length; i < length; i++) {
-        if (!(model = models[i] = this._prepareModel(models[i], options))) {
-          throw new Error("Can't add an invalid model to a collection");
-        }
-        cid = model.cid;
-        id = model.id;
-        if (cids[cid] || this._byCid[cid] || ((id != null) && (ids[id] || this._byId[id]))) {
-          dups.push(i);
-          continue;
-        }
-        cids[cid] = ids[id] = model;
-      }
-
-      // Remove duplicates.
-      i = dups.length;
-      while (i--) {
-        models.splice(dups[i], 1);
-      }
-
-      // Listen to added models' events, and index models for lookup by
-      // `id` and by `cid`.
-      for (i = 0, length = models.length; i < length; i++) {
-        (model = models[i]).on('all', this._onModelEvent, this);
-        this._byCid[model.cid] = model;
-        if (model.id != null) this._byId[model.id] = model;
-      }
-
-      // Insert models into the collection, re-sorting if needed, and triggering
-      // `add` events unless silenced.
-      this.length += length;
-      index = options.at != null ? options.at : this.models.length;
-      splice.apply(this.models, [index, 0].concat(models));
-      if (this.comparator) this.sort({silent: true});
-      if (options.silent) return this;
-      for (i = 0, length = this.models.length; i < length; i++) {
-        if (!cids[(model = this.models[i]).cid]) continue;
-        options.index = i;
-        model.trigger('add', model, this, options);
-      }
-      return this;
+    // Proxy `Backbone.sync` by default.
+    sync: function() {
+      return Backbone.sync.apply(this, arguments);
     },
 
-    // Remove a model, or a list of models from the set. Pass silent to avoid
-    // firing the `remove` event for every model removed.
+    // Add a model, or list of models to the set.
+    add: function(models, options) {
+      return this.set(models, _.defaults(options || {}, addOptions));
+    },
+
+    // Remove a model, or a list of models from the set.
     remove: function(models, options) {
-      var i, l, index, model;
-      options || (options = {});
       models = _.isArray(models) ? models.slice() : [models];
+      options || (options = {});
+      var i, l, index, model;
       for (i = 0, l = models.length; i < l; i++) {
-        model = this.getByCid(models[i]) || this.get(models[i]);
+        model = this.get(models[i]);
         if (!model) continue;
         delete this._byId[model.id];
-        delete this._byCid[model.cid];
+        delete this._byId[model.cid];
         index = this.indexOf(model);
         this.models.splice(index, 1);
         this.length--;
@@ -656,10 +657,100 @@
       return this;
     },
 
+    // Update a collection by `set`-ing a new list of models, adding new ones,
+    // removing models that are no longer present, and merging models that
+    // already exist in the collection, as necessary. Similar to **Model#set**,
+    // the core operation for updating the data contained by the collection.
+    set: function(models, options) {
+      options = _.defaults(options || {}, setOptions);
+      if (options.parse) models = this.parse(models, options);
+      if (!_.isArray(models)) models = models ? [models] : [];
+      var i, l, model, attrs, existing, sort;
+      var at = options.at;
+      var sortable = this.comparator && (at == null) && options.sort !== false;
+      var sortAttr = _.isString(this.comparator) ? this.comparator : null;
+      var toAdd = [], toRemove = [], modelMap = {};
+
+      // Turn bare objects into model references, and prevent invalid models
+      // from being added.
+      for (i = 0, l = models.length; i < l; i++) {
+        if (!(model = this._prepareModel(models[i], options))) continue;
+
+        // If a duplicate is found, prevent it from being added and
+        // optionally merge it into the existing model.
+        if (existing = this.get(model)) {
+          if (options.remove) modelMap[existing.cid] = true;
+          if (options.merge) {
+            existing.set(model.attributes, options);
+            if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
+          }
+
+        // This is a new model, push it to the `toAdd` list.
+        } else if (options.add) {
+          toAdd.push(model);
+
+          // Listen to added models' events, and index models for lookup by
+          // `id` and by `cid`.
+          model.on('all', this._onModelEvent, this);
+          this._byId[model.cid] = model;
+          if (model.id != null) this._byId[model.id] = model;
+        }
+      }
+
+      // Remove nonexistent models if appropriate.
+      if (options.remove) {
+        for (i = 0, l = this.length; i < l; ++i) {
+          if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
+        }
+        if (toRemove.length) this.remove(toRemove, options);
+      }
+
+      // See if sorting is needed, update `length` and splice in new models.
+      if (toAdd.length) {
+        if (sortable) sort = true;
+        this.length += toAdd.length;
+        if (at != null) {
+          splice.apply(this.models, [at, 0].concat(toAdd));
+        } else {
+          push.apply(this.models, toAdd);
+        }
+      }
+
+      // Silently sort the collection if appropriate.
+      if (sort) this.sort({silent: true});
+
+      if (options.silent) return this;
+
+      // Trigger `add` events.
+      for (i = 0, l = toAdd.length; i < l; i++) {
+        (model = toAdd[i]).trigger('add', model, this, options);
+      }
+
+      // Trigger `sort` if the collection was sorted.
+      if (sort) this.trigger('sort', this, options);
+      return this;
+    },
+
+    // When you have more items than you want to add or remove individually,
+    // you can reset the entire set with a new list of models, without firing
+    // any granular `add` or `remove` events. Fires `reset` when finished.
+    // Useful for bulk operations and optimizations.
+    reset: function(models, options) {
+      options || (options = {});
+      for (var i = 0, l = this.models.length; i < l; i++) {
+        this._removeReference(this.models[i]);
+      }
+      options.previousModels = this.models;
+      this._reset();
+      this.add(models, _.extend({silent: true}, options));
+      if (!options.silent) this.trigger('reset', this, options);
+      return this;
+    },
+
     // Add a model to the end of the collection.
     push: function(model, options) {
       model = this._prepareModel(model, options);
-      this.add(model, options);
+      this.add(model, _.extend({at: this.length}, options));
       return model;
     },
 
@@ -684,15 +775,15 @@
       return model;
     },
 
-    // Get a model from the set by id.
-    get: function(id) {
-      if (id == null) return void 0;
-      return this._byId[id.id != null ? id.id : id];
+    // Slice out a sub-array of models from the collection.
+    slice: function(begin, end) {
+      return this.models.slice(begin, end);
     },
 
-    // Get a model from the set by client id.
-    getByCid: function(cid) {
-      return cid && this._byCid[cid.cid || cid];
+    // Get a model from the set by id.
+    get: function(obj) {
+      if (obj == null) return void 0;
+      return this._byId[obj.id != null ? obj.id : obj.cid || obj];
     },
 
     // Get the model at the given index.
@@ -700,10 +791,11 @@
       return this.models[index];
     },
 
-    // Return models with matching attributes. Useful for simple cases of `filter`.
-    where: function(attrs) {
-      if (_.isEmpty(attrs)) return [];
-      return this.filter(function(model) {
+    // Return models with matching attributes. Useful for simple cases of
+    // `filter`.
+    where: function(attrs, first) {
+      if (_.isEmpty(attrs)) return first ? void 0 : [];
+      return this[first ? 'find' : 'filter'](function(model) {
         for (var key in attrs) {
           if (attrs[key] !== model.get(key)) return false;
         }
@@ -711,75 +803,75 @@
       });
     },
 
+    // Return the first model with matching attributes. Useful for simple cases
+    // of `find`.
+    findWhere: function(attrs) {
+      return this.where(attrs, true);
+    },
+
     // Force the collection to re-sort itself. You don't need to call this under
     // normal circumstances, as the set will maintain sort order as each item
     // is added.
     sort: function(options) {
-      options || (options = {});
       if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
-      var boundComparator = _.bind(this.comparator, this);
-      if (this.comparator.length == 1) {
-        this.models = this.sortBy(boundComparator);
+      options || (options = {});
+
+      // Run sort based on type of `comparator`.
+      if (_.isString(this.comparator) || this.comparator.length === 1) {
+        this.models = this.sortBy(this.comparator, this);
       } else {
-        this.models.sort(boundComparator);
+        this.models.sort(_.bind(this.comparator, this));
       }
-      if (!options.silent) this.trigger('reset', this, options);
+
+      if (!options.silent) this.trigger('sort', this, options);
       return this;
     },
 
+    // Figure out the smallest index at which a model should be inserted so as
+    // to maintain order.
+    sortedIndex: function(model, value, context) {
+      value || (value = this.comparator);
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _.sortedIndex(this.models, model, iterator, context);
+    },
+
     // Pluck an attribute from each model in the collection.
     pluck: function(attr) {
-      return _.map(this.models, function(model){ return model.get(attr); });
-    },
-
-    // When you have more items than you want to add or remove individually,
-    // you can reset the entire set with a new list of models, without firing
-    // any `add` or `remove` events. Fires `reset` when finished.
-    reset: function(models, options) {
-      models  || (models = []);
-      options || (options = {});
-      for (var i = 0, l = this.models.length; i < l; i++) {
-        this._removeReference(this.models[i]);
-      }
-      this._reset();
-      this.add(models, _.extend({silent: true}, options));
-      if (!options.silent) this.trigger('reset', this, options);
-      return this;
+      return _.invoke(this.models, 'get', attr);
     },
 
     // Fetch the default set of models for this collection, resetting the
-    // collection when they arrive. If `add: true` is passed, appends the
-    // models to the collection instead of resetting.
+    // collection when they arrive. If `reset: true` is passed, the response
+    // data will be passed through the `reset` method instead of `set`.
     fetch: function(options) {
       options = options ? _.clone(options) : {};
-      if (options.parse === undefined) options.parse = true;
-      var collection = this;
+      if (options.parse === void 0) options.parse = true;
       var success = options.success;
-      options.success = function(resp, status, xhr) {
-        collection[options.add ? 'add' : 'reset'](collection.parse(resp, xhr), options);
-        if (success) success(collection, resp);
+      var collection = this;
+      options.success = function(resp) {
+        var method = options.reset ? 'reset' : 'set';
+        collection[method](resp, options);
+        if (success) success(collection, resp, options);
+        collection.trigger('sync', collection, resp, options);
       };
-      options.error = Backbone.wrapError(options.error, collection, options);
-      return (this.sync || Backbone.sync).call(this, 'read', this, options);
+      wrapError(this, options);
+      return this.sync('read', this, options);
     },
 
     // Create a new instance of a model in this collection. Add the model to the
     // collection immediately, unless `wait: true` is passed, in which case we
     // wait for the server to agree.
     create: function(model, options) {
-      var coll = this;
       options = options ? _.clone(options) : {};
-      model = this._prepareModel(model, options);
-      if (!model) return false;
-      if (!options.wait) coll.add(model, options);
+      if (!(model = this._prepareModel(model, options))) return false;
+      if (!options.wait) this.add(model, options);
+      var collection = this;
       var success = options.success;
-      options.success = function(nextModel, resp, xhr) {
-        if (options.wait) coll.add(nextModel, options);
-        if (success) {
-          success(nextModel, resp);
-        } else {
-          nextModel.trigger('sync', model, resp, options);
-        }
+      options.success = function(resp) {
+        if (options.wait) collection.add(model, options);
+        if (success) success(model, resp, options);
       };
       model.save(null, options);
       return model;
@@ -787,44 +879,43 @@
 
     // **parse** converts a response into a list of models to be added to the
     // collection. The default implementation is just to pass it through.
-    parse: function(resp, xhr) {
+    parse: function(resp, options) {
       return resp;
     },
 
-    // Proxy to _'s chain. Can't be proxied the same way the rest of the
-    // underscore methods are proxied because it relies on the underscore
-    // constructor.
-    chain: function () {
-      return _(this.models).chain();
+    // Create a new collection with an identical list of models as this one.
+    clone: function() {
+      return new this.constructor(this.models);
     },
 
-    // Reset all internal state. Called when the collection is reset.
-    _reset: function(options) {
+    // Private method to reset all internal state. Called when the collection
+    // is first initialized or reset.
+    _reset: function() {
       this.length = 0;
       this.models = [];
       this._byId  = {};
-      this._byCid = {};
     },
 
-    // Prepare a model or hash of attributes to be added to this collection.
-    _prepareModel: function(model, options) {
+    // Prepare a hash of attributes (or other model) to be added to this
+    // collection.
+    _prepareModel: function(attrs, options) {
+      if (attrs instanceof Model) {
+        if (!attrs.collection) attrs.collection = this;
+        return attrs;
+      }
       options || (options = {});
-      if (!(model instanceof Model)) {
-        var attrs = model;
-        options.collection = this;
-        model = new this.model(attrs, options);
-        if (!model._validate(model.attributes, options)) model = false;
-      } else if (!model.collection) {
-        model.collection = this;
+      options.collection = this;
+      var model = new this.model(attrs, options);
+      if (!model._validate(attrs, options)) {
+        this.trigger('invalid', this, attrs, options);
+        return false;
       }
       return model;
     },
 
-    // Internal method to remove a model's ties to a collection.
+    // Internal method to sever a model's ties to a collection.
     _removeReference: function(model) {
-      if (this == model.collection) {
-        delete model.collection;
-      }
+      if (this === model.collection) delete model.collection;
       model.off('all', this._onModelEvent, this);
     },
 
@@ -833,13 +924,11 @@
     // events simply proxy through. "add" and "remove" events that originate
     // in other collections are ignored.
     _onModelEvent: function(event, model, collection, options) {
-      if ((event == 'add' || event == 'remove') && collection != this) return;
-      if (event == 'destroy') {
-        this.remove(model, options);
-      }
+      if ((event === 'add' || event === 'remove') && collection !== this) return;
+      if (event === 'destroy') this.remove(model, options);
       if (model && event === 'change:' + model.idAttribute) {
         delete this._byId[model.previous(model.idAttribute)];
-        this._byId[model.id] = model;
+        if (model.id != null) this._byId[model.id] = model;
       }
       this.trigger.apply(this, arguments);
     }
@@ -847,21 +936,274 @@
   });
 
   // Underscore methods that we want to implement on the Collection.
-  var methods = ['forEach', 'each', 'map', 'reduce', 'reduceRight', 'find',
-    'detect', 'filter', 'select', 'reject', 'every', 'all', 'some', 'any',
-    'include', 'contains', 'invoke', 'max', 'min', 'sortBy', 'sortedIndex',
-    'toArray', 'size', 'first', 'initial', 'rest', 'last', 'without', 'indexOf',
-    'shuffle', 'lastIndexOf', 'isEmpty', 'groupBy'];
+  // 90% of the core usefulness of Backbone Collections is actually implemented
+  // right here:
+  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
+    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
+    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
+    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
+    'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
+    'isEmpty', 'chain'];
 
   // Mix in each Underscore method as a proxy to `Collection#models`.
   _.each(methods, function(method) {
     Collection.prototype[method] = function() {
-      return _[method].apply(_, [this.models].concat(_.toArray(arguments)));
+      var args = slice.call(arguments);
+      args.unshift(this.models);
+      return _[method].apply(_, args);
     };
   });
 
+  // Underscore methods that take a property name as an argument.
+  var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
+
+  // Use attributes instead of properties.
+  _.each(attributeMethods, function(method) {
+    Collection.prototype[method] = function(value, context) {
+      var iterator = _.isFunction(value) ? value : function(model) {
+        return model.get(value);
+      };
+      return _[method](this.models, iterator, context);
+    };
+  });
+
+  // Backbone.View
+  // -------------
+
+  // Backbone Views are almost more convention than they are actual code. A View
+  // is simply a JavaScript object that represents a logical chunk of UI in the
+  // DOM. This might be a single item, an entire list, a sidebar or panel, or
+  // even the surrounding frame which wraps your whole app. Defining a chunk of
+  // UI as a **View** allows you to define your DOM events declaratively, without
+  // having to worry about render order ... and makes it easy for the view to
+  // react to specific changes in the state of your models.
+
+  // Creating a Backbone.View creates its initial element outside of the DOM,
+  // if an existing element is not provided...
+  var View = Backbone.View = function(options) {
+    this.cid = _.uniqueId('view');
+    this._configure(options || {});
+    this._ensureElement();
+    this.initialize.apply(this, arguments);
+    this.delegateEvents();
+  };
+
+  // Cached regex to split keys for `delegate`.
+  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
+
+  // List of view options to be merged as properties.
+  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
+
+  // Set up all inheritable **Backbone.View** properties and methods.
+  _.extend(View.prototype, Events, {
+
+    // The default `tagName` of a View's element is `"div"`.
+    tagName: 'div',
+
+    // jQuery delegate for element lookup, scoped to DOM elements within the
+    // current view. This should be prefered to global lookups where possible.
+    $: function(selector) {
+      return this.$el.find(selector);
+    },
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // **render** is the core function that your view should override, in order
+    // to populate its element (`this.el`), with the appropriate HTML. The
+    // convention is for **render** to always return `this`.
+    render: function() {
+      return this;
+    },
+
+    // Remove this view by taking the element out of the DOM, and removing any
+    // applicable Backbone.Events listeners.
+    remove: function() {
+      this.$el.remove();
+      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();
+      return this;
+    },
+
+    // Set callbacks, where `this.events` is a hash of
+    //
+    // *{"event selector": "callback"}*
+    //
+    //     {
+    //       'mousedown .title':  'edit',
+    //       'click .button':     'save'
+    //       'click .open':       function(e) { ... }
+    //     }
+    //
+    // 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();
+      for (var key in events) {
+        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);
+        }
+      }
+      return this;
+    },
+
+    // Clears all callbacks previously bound to the view with `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);
+      return this;
+    },
+
+    // Performs the initial configuration of a View with a set of options.
+    // Keys with special meaning *(e.g. model, collection, id, className)* are
+    // attached directly to the view.  See `viewOptions` for an exhaustive
+    // list.
+    _configure: function(options) {
+      if (this.options) options = _.extend({}, _.result(this, 'options'), options);
+      _.extend(this, _.pick(options, viewOptions));
+      this.options = options;
+    },
+
+    // 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
+    // an element from the `id`, `className` and `tagName` properties.
+    _ensureElement: function() {
+      if (!this.el) {
+        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);
+      } else {
+        this.setElement(_.result(this, 'el'), false);
+      }
+    }
+
+  });
+
+  // Backbone.sync
+  // -------------
+
+  // Override this function to change the manner in which Backbone persists
+  // models to the server. You will be passed the type of request, and the
+  // model in question. By default, makes a RESTful Ajax request
+  // to the model's `url()`. Some possible customizations could be:
+  //
+  // * Use `setTimeout` to batch rapid-fire updates into a single request.
+  // * Send up the models as XML instead of JSON.
+  // * Persist models via WebSockets instead of Ajax.
+  //
+  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
+  // as `POST`, with a `_method` parameter containing the true HTTP method,
+  // as well as all requests with the body as `application/x-www-form-urlencoded`
+  // instead of `application/json` with the model in a param named `model`.
+  // Useful when interfacing with server-side languages like **PHP** that make
+  // it difficult to read the body of `PUT` requests.
+  Backbone.sync = function(method, model, options) {
+    var type = methodMap[method];
+
+    // Default options, unless specified.
+    _.defaults(options || (options = {}), {
+      emulateHTTP: Backbone.emulateHTTP,
+      emulateJSON: Backbone.emulateJSON
+    });
+
+    // Default JSON-request options.
+    var params = {type: type, dataType: 'json'};
+
+    // Ensure that we have a URL.
+    if (!options.url) {
+      params.url = _.result(model, 'url') || urlError();
+    }
+
+    // Ensure that we have the appropriate request data.
+    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
+      params.contentType = 'application/json';
+      params.data = JSON.stringify(options.attrs || model.toJSON(options));
+    }
+
+    // For older servers, emulate JSON by encoding the request into an HTML-form.
+    if (options.emulateJSON) {
+      params.contentType = 'application/x-www-form-urlencoded';
+      params.data = params.data ? {model: params.data} : {};
+    }
+
+    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
+    // And an `X-HTTP-Method-Override` header.
+    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
+      params.type = 'POST';
+      if (options.emulateJSON) params.data._method = type;
+      var beforeSend = options.beforeSend;
+      options.beforeSend = function(xhr) {
+        xhr.setRequestHeader('X-HTTP-Method-Override', type);
+        if (beforeSend) return beforeSend.apply(this, arguments);
+      };
+    }
+
+    // Don't process data on a non-GET request.
+    if (params.type !== 'GET' && !options.emulateJSON) {
+      params.processData = false;
+    }
+
+    // If we're sending a `PATCH` request, and we're in an old Internet Explorer
+    // that still has ActiveX enabled by default, override jQuery to use that
+    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
+    if (params.type === 'PATCH' && window.ActiveXObject &&
+          !(window.external && window.external.msActiveXFilteringEnabled)) {
+      params.xhr = function() {
+        return new ActiveXObject("Microsoft.XMLHTTP");
+      };
+    }
+
+    // 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);
+    return xhr;
+  };
+
+  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
+  var methodMap = {
+    'create': 'POST',
+    'update': 'PUT',
+    'patch':  'PATCH',
+    'delete': 'DELETE',
+    'read':   'GET'
+  };
+
+  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
+  // Override this if you'd like to use a different library.
+  Backbone.ajax = function() {
+    return Backbone.$.ajax.apply(Backbone.$, arguments);
+  };
+
   // Backbone.Router
-  // -------------------
+  // ---------------
 
   // Routers map faux-URLs to actions, and fire events when routes are
   // matched. Creating a new one sets its `routes` hash, if not set statically.
@@ -874,9 +1216,10 @@
 
   // Cached regular expressions for matching named param parts and splatted
   // parts of route strings.
-  var namedParam    = /:\w+/g;
+  var optionalParam = /\((.*?)\)/g;
+  var namedParam    = /(\(\?)?:\w+/g;
   var splatParam    = /\*\w+/g;
-  var escapeRegExp  = /[-[\]{}()+?.,\\^$|#\s]/g;
+  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
 
   // Set up all inheritable **Backbone.Router** properties and methods.
   _.extend(Router.prototype, Events, {
@@ -892,21 +1235,27 @@
     //     });
     //
     route: function(route, name, callback) {
-      Backbone.history || (Backbone.history = new History);
       if (!_.isRegExp(route)) route = this._routeToRegExp(route);
+      if (_.isFunction(name)) {
+        callback = name;
+        name = '';
+      }
       if (!callback) callback = this[name];
-      Backbone.history.route(route, _.bind(function(fragment) {
-        var args = this._extractParameters(route, fragment);
-        callback && callback.apply(this, args);
-        this.trigger.apply(this, ['route:' + name].concat(args));
-        Backbone.history.trigger('route', this, name, args);
-      }, this));
+      var router = this;
+      Backbone.history.route(route, function(fragment) {
+        var args = router._extractParameters(route, fragment);
+        callback && callback.apply(router, args);
+        router.trigger.apply(router, ['route:' + name].concat(args));
+        router.trigger('route', name, args);
+        Backbone.history.trigger('route', router, name, args);
+      });
       return this;
     },
 
     // Simple proxy to `Backbone.history` to save a fragment into the history.
     navigate: function(fragment, options) {
       Backbone.history.navigate(fragment, options);
+      return this;
     },
 
     // Bind all defined routes to `Backbone.history`. We have to reverse the
@@ -914,12 +1263,10 @@
     // routes can be defined at the bottom of the route map.
     _bindRoutes: function() {
       if (!this.routes) return;
-      var routes = [];
-      for (var route in this.routes) {
-        routes.unshift([route, this.routes[route]]);
-      }
-      for (var i = 0, l = routes.length; i < l; i++) {
-        this.route(routes[i][0], routes[i][1], this[routes[i][1]]);
+      this.routes = _.result(this, 'routes');
+      var route, routes = _.keys(this.routes);
+      while ((route = routes.pop()) != null) {
+        this.route(route, this.routes[route]);
       }
     },
 
@@ -927,15 +1274,22 @@
     // against the current location hash.
     _routeToRegExp: function(route) {
       route = route.replace(escapeRegExp, '\\$&')
-                   .replace(namedParam, '([^\/]+)')
+                   .replace(optionalParam, '(?:$1)?')
+                   .replace(namedParam, function(match, optional){
+                     return optional ? match : '([^\/]+)';
+                   })
                    .replace(splatParam, '(.*?)');
       return new RegExp('^' + route + '$');
     },
 
     // Given a route, and a URL fragment that it matches, return the array of
-    // extracted parameters.
+    // extracted decoded parameters. Empty or unmatched parameters will be
+    // treated as `null` to normalize cross-browser behavior.
     _extractParameters: function(route, fragment) {
-      return route.exec(fragment).slice(1);
+      var params = route.exec(fragment).slice(1);
+      return _.map(params, function(param) {
+        return param ? decodeURIComponent(param) : null;
+      });
     }
 
   });
@@ -943,19 +1297,34 @@
   // Backbone.History
   // ----------------
 
-  // Handles cross-browser history management, based on URL fragments. If the
-  // browser does not support `onhashchange`, falls back to polling.
+  // Handles cross-browser history management, based on either
+  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
+  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
+  // and URL fragments. If the browser supports neither (old IE, natch),
+  // falls back to polling.
   var History = Backbone.History = function() {
     this.handlers = [];
     _.bindAll(this, 'checkUrl');
+
+    // Ensure that `History` can be used outside of the browser.
+    if (typeof window !== 'undefined') {
+      this.location = window.location;
+      this.history = window.history;
+    }
   };
 
-  // Cached regex for cleaning leading hashes and slashes .
-  var routeStripper = /^[#\/]/;
+  // Cached regex for stripping a leading hash/slash and trailing space.
+  var routeStripper = /^[#\/]|\s+$/g;
+
+  // 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 = /\/$/;
+
   // Has the history handling already been started?
   History.started = false;
 
@@ -968,9 +1337,8 @@
 
     // Gets the true hash value. Cannot use location.hash directly due to bug
     // in Firefox where location.hash will always be decoded.
-    getHash: function(windowOverride) {
-      var loc = windowOverride ? windowOverride.location : window.location;
-      var match = loc.href.match(/#(.*)$/);
+    getHash: function(window) {
+      var match = (window || this).location.href.match(/#(.*)$/);
       return match ? match[1] : '';
     },
 
@@ -978,15 +1346,14 @@
     // the hash, or the override.
     getFragment: function(fragment, forcePushState) {
       if (fragment == null) {
-        if (this._hasPushState || forcePushState) {
-          fragment = window.location.pathname;
-          var search = window.location.search;
-          if (search) fragment += search;
+        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
+          fragment = this.location.pathname;
+          var root = this.root.replace(trailingSlash, '');
+          if (!fragment.indexOf(root)) fragment = fragment.substr(root.length);
         } else {
           fragment = this.getHash();
         }
       }
-      if (!fragment.indexOf(this.options.root)) fragment = fragment.substr(this.options.root.length);
       return fragment.replace(routeStripper, '');
     },
 
@@ -999,24 +1366,28 @@
       // Figure out the initial configuration. Do we need an iframe?
       // Is pushState desired ... is it available?
       this.options          = _.extend({}, {root: '/'}, this.options, options);
+      this.root             = this.options.root;
       this._wantsHashChange = this.options.hashChange !== false;
       this._wantsPushState  = !!this.options.pushState;
-      this._hasPushState    = !!(this.options.pushState && window.history && window.history.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));
 
-      if (oldIE) {
-        this.iframe = $('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
+      // Normalize root to always include a leading and trailing slash.
+      this.root = ('/' + this.root + '/').replace(rootStripper, '/');
+
+      if (oldIE && this._wantsHashChange) {
+        this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
         this.navigate(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) {
-        $(window).bind('popstate', this.checkUrl);
+        Backbone.$(window).on('popstate', this.checkUrl);
       } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
-        $(window).bind('hashchange', this.checkUrl);
+        Backbone.$(window).on('hashchange', this.checkUrl);
       } else if (this._wantsHashChange) {
         this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
       }
@@ -1024,14 +1395,14 @@
       // Determine if we need to change the base url, for a pushState link
       // opened by a non-pushState browser.
       this.fragment = fragment;
-      var loc = window.location;
-      var atRoot  = loc.pathname == this.options.root;
+      var loc = this.location;
+      var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;
 
       // 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._wantsHashChange && this._wantsPushState && !this._hasPushState && !atRoot) {
         this.fragment = this.getFragment(null, true);
-        window.location.replace(this.options.root + '#' + this.fragment);
+        this.location.replace(this.root + this.location.search + '#' + this.fragment);
         // Return immediately as browser will do redirect to new url
         return true;
 
@@ -1039,18 +1410,16 @@
       // in a browser where it could be `pushState`-based instead...
       } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) {
         this.fragment = this.getHash().replace(routeStripper, '');
-        window.history.replaceState({}, document.title, loc.protocol + '//' + loc.host + this.options.root + this.fragment);
+        this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
       }
 
-      if (!this.options.silent) {
-        return this.loadUrl();
-      }
+      if (!this.options.silent) return this.loadUrl();
     },
 
     // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
     // but possibly useful for unit testing Routers.
     stop: function() {
-      $(window).unbind('popstate', this.checkUrl).unbind('hashchange', this.checkUrl);
+      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
       clearInterval(this._checkUrlInterval);
       History.started = false;
     },
@@ -1065,8 +1434,10 @@
     // calls `loadUrl`, normalizing across the hidden iframe.
     checkUrl: function(e) {
       var current = this.getFragment();
-      if (current == this.fragment && this.iframe) current = this.getFragment(this.getHash(this.iframe));
-      if (current == this.fragment) return false;
+      if (current === this.fragment && this.iframe) {
+        current = this.getFragment(this.getHash(this.iframe));
+      }
+      if (current === this.fragment) return false;
       if (this.iframe) this.navigate(current);
       this.loadUrl() || this.loadUrl(this.getHash());
     },
@@ -1095,31 +1466,31 @@
     navigate: function(fragment, options) {
       if (!History.started) return false;
       if (!options || options === true) options = {trigger: options};
-      var frag = (fragment || '').replace(routeStripper, '');
-      if (this.fragment == frag) return;
+      fragment = this.getFragment(fragment || '');
+      if (this.fragment === fragment) return;
+      this.fragment = fragment;
+      var url = this.root + fragment;
 
       // If pushState is available, we use it to set the fragment as a real URL.
       if (this._hasPushState) {
-        if (frag.indexOf(this.options.root) != 0) frag = this.options.root + frag;
-        this.fragment = frag;
-        window.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, frag);
+        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
 
       // If hash changes haven't been explicitly disabled, update the hash
       // fragment to store history.
       } else if (this._wantsHashChange) {
-        this.fragment = frag;
-        this._updateHash(window.location, frag, options.replace);
-        if (this.iframe && (frag != this.getFragment(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.
+        this._updateHash(this.location, fragment, options.replace);
+        if (this.iframe && (fragment !== this.getFragment(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.
           if(!options.replace) this.iframe.document.open().close();
-          this._updateHash(this.iframe.location, frag, options.replace);
+          this._updateHash(this.iframe.location, fragment, options.replace);
         }
 
       // If you've told us that you explicitly don't want fallback hashchange-
       // based history, then `navigate` becomes a page refresh.
       } else {
-        window.location.assign(this.options.root + fragment);
+        return this.location.assign(url);
       }
       if (options.trigger) this.loadUrl(fragment);
     },
@@ -1128,304 +1499,73 @@
     // a new one to the browser history.
     _updateHash: function(location, fragment, replace) {
       if (replace) {
-        location.replace(location.toString().replace(/(javascript:|#).*$/, '') + '#' + fragment);
+        var href = location.href.replace(/(javascript:|#).*$/, '');
+        location.replace(href + '#' + fragment);
       } else {
-        location.hash = fragment;
-      }
-    }
-  });
-
-  // Backbone.View
-  // -------------
-
-  // Creating a Backbone.View creates its initial element outside of the DOM,
-  // if an existing element is not provided...
-  var View = Backbone.View = function(options) {
-    this.cid = _.uniqueId('view');
-    this._configure(options || {});
-    this._ensureElement();
-    this.initialize.apply(this, arguments);
-    this.delegateEvents();
-  };
-
-  // Cached regex to split keys for `delegate`.
-  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
-
-  // List of view options to be merged as properties.
-  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName'];
-
-  // Set up all inheritable **Backbone.View** properties and methods.
-  _.extend(View.prototype, Events, {
-
-    // The default `tagName` of a View's element is `"div"`.
-    tagName: 'div',
-
-    // jQuery delegate for element lookup, scoped to DOM elements within the
-    // current view. This should be prefered to global lookups where possible.
-    $: function(selector) {
-      return this.$el.find(selector);
-    },
-
-    // Initialize is an empty function by default. Override it with your own
-    // initialization logic.
-    initialize: function(){},
-
-    // **render** is the core function that your view should override, in order
-    // to populate its element (`this.el`), with the appropriate HTML. The
-    // convention is for **render** to always return `this`.
-    render: function() {
-      return this;
-    },
-
-    // Remove this view from the DOM. Note that the view isn't present in the
-    // DOM by default, so calling this method may be a no-op.
-    remove: function() {
-      this.$el.remove();
-      return this;
-    },
-
-    // For small amounts of DOM Elements, where a full-blown template isn't
-    // needed, use **make** to manufacture elements, one at a time.
-    //
-    //     var el = this.make('li', {'class': 'row'}, this.model.escape('title'));
-    //
-    make: function(tagName, attributes, content) {
-      var el = document.createElement(tagName);
-      if (attributes) $(el).attr(attributes);
-      if (content) $(el).html(content);
-      return el;
-    },
-
-    // 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 $) ? element : $(element);
-      this.el = this.$el[0];
-      if (delegate !== false) this.delegateEvents();
-      return this;
-    },
-
-    // Set callbacks, where `this.events` is a hash of
-    //
-    // *{"event selector": "callback"}*
-    //
-    //     {
-    //       'mousedown .title':  'edit',
-    //       'click .button':     'save'
-    //       'click .open':       function(e) { ... }
-    //     }
-    //
-    // 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 = getValue(this, 'events')))) return;
-      this.undelegateEvents();
-      for (var key in events) {
-        var method = events[key];
-        if (!_.isFunction(method)) method = this[events[key]];
-        if (!method) throw new Error('Method "' + events[key] + '" does not exist');
-        var match = key.match(delegateEventSplitter);
-        var eventName = match[1], selector = match[2];
-        method = _.bind(method, this);
-        eventName += '.delegateEvents' + this.cid;
-        if (selector === '') {
-          this.$el.bind(eventName, method);
-        } else {
-          this.$el.delegate(selector, eventName, method);
-        }
-      }
-    },
-
-    // Clears all callbacks previously bound to the view with `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.unbind('.delegateEvents' + this.cid);
-    },
-
-    // Performs the initial configuration of a View with a set of options.
-    // Keys with special meaning *(model, collection, id, className)*, are
-    // attached directly to the view.
-    _configure: function(options) {
-      if (this.options) options = _.extend({}, this.options, options);
-      for (var i = 0, l = viewOptions.length; i < l; i++) {
-        var attr = viewOptions[i];
-        if (options[attr]) this[attr] = options[attr];
-      }
-      this.options = options;
-    },
-
-    // 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
-    // an element from the `id`, `className` and `tagName` properties.
-    _ensureElement: function() {
-      if (!this.el) {
-        var attrs = getValue(this, 'attributes') || {};
-        if (this.id) attrs.id = this.id;
-        if (this.className) attrs['class'] = this.className;
-        this.setElement(this.make(this.tagName, attrs), false);
-      } else {
-        this.setElement(this.el, false);
+        // Some browsers require that `hash` contains a leading #.
+        location.hash = '#' + fragment;
       }
     }
 
   });
 
-  // The self-propagating extend function that Backbone classes use.
-  var extend = function (protoProps, classProps) {
-    var child = inherits(this, protoProps, classProps);
-    child.extend = this.extend;
-    return child;
-  };
-
-  // Set up inheritance for the model, collection, and view.
-  Model.extend = Collection.extend = Router.extend = View.extend = extend;
-
-  // Backbone.sync
-  // -------------
-
-  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
-  var methodMap = {
-    'create': 'POST',
-    'update': 'PUT',
-    'delete': 'DELETE',
-    'read':   'GET'
-  };
-
-  // Override this function to change the manner in which Backbone persists
-  // models to the server. You will be passed the type of request, and the
-  // model in question. By default, makes a RESTful Ajax request
-  // to the model's `url()`. Some possible customizations could be:
-  //
-  // * Use `setTimeout` to batch rapid-fire updates into a single request.
-  // * Send up the models as XML instead of JSON.
-  // * Persist models via WebSockets instead of Ajax.
-  //
-  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
-  // as `POST`, with a `_method` parameter containing the true HTTP method,
-  // as well as all requests with the body as `application/x-www-form-urlencoded`
-  // instead of `application/json` with the model in a param named `model`.
-  // Useful when interfacing with server-side languages like **PHP** that make
-  // it difficult to read the body of `PUT` requests.
-  Backbone.sync = function(method, model, options) {
-    var type = methodMap[method];
-
-    // Default options, unless specified.
-    options || (options = {});
-
-    // Default JSON-request options.
-    var params = {type: type, dataType: 'json'};
-
-    // Ensure that we have a URL.
-    if (!options.url) {
-      params.url = getValue(model, 'url') || urlError();
-    }
-
-    // Ensure that we have the appropriate request data.
-    if (!options.data && model && (method == 'create' || method == 'update')) {
-      params.contentType = 'application/json';
-      params.data = JSON.stringify(model.toJSON());
-    }
-
-    // For older servers, emulate JSON by encoding the request into an HTML-form.
-    if (Backbone.emulateJSON) {
-      params.contentType = 'application/x-www-form-urlencoded';
-      params.data = params.data ? {model: params.data} : {};
-    }
-
-    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
-    // And an `X-HTTP-Method-Override` header.
-    if (Backbone.emulateHTTP) {
-      if (type === 'PUT' || type === 'DELETE') {
-        if (Backbone.emulateJSON) params.data._method = type;
-        params.type = 'POST';
-        params.beforeSend = function(xhr) {
-          xhr.setRequestHeader('X-HTTP-Method-Override', type);
-        };
-      }
-    }
-
-    // Don't process data on a non-GET request.
-    if (params.type !== 'GET' && !Backbone.emulateJSON) {
-      params.processData = false;
-    }
-
-    // Make the request, allowing the user to override any Ajax options.
-    return $.ajax(_.extend(params, options));
-  };
-
-  // Wrap an optional error callback with a fallback error event.
-  Backbone.wrapError = function(onError, originalModel, options) {
-    return function(model, resp) {
-      resp = model === originalModel ? resp : model;
-      if (onError) {
-        onError(originalModel, resp, options);
-      } else {
-        originalModel.trigger('error', originalModel, resp, options);
-      }
-    };
-  };
+  // Create the default Backbone.history.
+  Backbone.history = new History;
 
   // Helpers
   // -------
 
-  // Shared empty constructor function to aid in prototype-chain creation.
-  var ctor = function(){};
-
   // Helper function to correctly set up the prototype chain, for subclasses.
   // Similar to `goog.inherits`, but uses a hash of prototype properties and
   // class properties to be extended.
-  var inherits = function(parent, protoProps, staticProps) {
+  var extend = function(protoProps, staticProps) {
+    var parent = this;
     var child;
 
     // The constructor function for the new subclass is either defined by you
     // (the "constructor" property in your `extend` definition), or defaulted
     // by us to simply call the parent's constructor.
-    if (protoProps && protoProps.hasOwnProperty('constructor')) {
+    if (protoProps && _.has(protoProps, 'constructor')) {
       child = protoProps.constructor;
     } else {
-      child = function(){ parent.apply(this, arguments); };
+      child = function(){ return parent.apply(this, arguments); };
     }
 
-    // Inherit class (static) properties from parent.
-    _.extend(child, parent);
+    // Add static properties to the constructor function, if supplied.
+    _.extend(child, parent, staticProps);
 
     // Set the prototype chain to inherit from `parent`, without calling
     // `parent`'s constructor function.
-    ctor.prototype = parent.prototype;
-    child.prototype = new ctor();
+    var Surrogate = function(){ this.constructor = child; };
+    Surrogate.prototype = parent.prototype;
+    child.prototype = new Surrogate;
 
     // Add prototype properties (instance properties) to the subclass,
     // if supplied.
     if (protoProps) _.extend(child.prototype, protoProps);
 
-    // Add static properties to the constructor function, if supplied.
-    if (staticProps) _.extend(child, staticProps);
-
-    // Correctly set child's `prototype.constructor`.
-    child.prototype.constructor = child;
-
-    // Set a convenience property in case the parent's prototype is needed later.
+    // Set a convenience property in case the parent's prototype is needed
+    // later.
     child.__super__ = parent.prototype;
 
     return child;
   };
 
-  // Helper function to get a value from a Backbone object as a property
-  // or as a function.
-  var getValue = function(object, prop) {
-    if (!(object && object[prop])) return null;
-    return _.isFunction(object[prop]) ? object[prop]() : object[prop];
-  };
+  // Set up inheritance for the model, collection, router, view and history.
+  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
 
   // Throw an error when a URL is needed, and none is supplied.
   var urlError = function() {
     throw new Error('A "url" property or function must be specified');
   };
 
+  // Wrap an optional error callback with a fallback error event.
+  var wrapError = function (model, options) {
+    var error = options.error;
+    options.error = function(resp) {
+      if (error) error(model, resp, options);
+      model.trigger('error', model, resp, options);
+    };
+  };
+
 }).call(this);
diff --git a/static/scripts/libs/handlebars.runtime.js b/static/scripts/libs/handlebars.runtime.js
index 987a5cd4d66..0866641947a 100644
--- a/static/scripts/libs/handlebars.runtime.js
+++ b/static/scripts/libs/handlebars.runtime.js
@@ -1,7 +1,11 @@
 // lib/handlebars/base.js
-var Handlebars = {};
 
-Handlebars.VERSION = "1.0.beta.6";
+/*jshint eqnull:true*/
+this.Handlebars = {};
+
+(function(Handlebars) {
+
+Handlebars.VERSION = "1.0.rc.1";
 
 Handlebars.helpers  = {};
 Handlebars.partials = {};
@@ -40,25 +44,36 @@ Handlebars.registerHelper('blockHelperMissing', function(context, options) {
     return inverse(this);
   } else if(type === "[object Array]") {
     if(context.length > 0) {
-      for(var i=0, j=context.length; i<j; i++) {
-        ret = ret + fn(context[i]);
-      }
+      return Handlebars.helpers.each(context, options);
     } else {
-      ret = inverse(this);
+      return inverse(this);
     }
-    return ret;
   } else {
     return fn(context);
   }
 });
 
+Handlebars.K = function() {};
+
+Handlebars.createFrame = Object.create || function(object) {
+  Handlebars.K.prototype = object;
+  var obj = new Handlebars.K();
+  Handlebars.K.prototype = null;
+  return obj;
+};
+
 Handlebars.registerHelper('each', function(context, options) {
   var fn = options.fn, inverse = options.inverse;
-  var ret = "";
+  var ret = "", data;
+
+  if (options.data) {
+    data = Handlebars.createFrame(options.data);
+  }
 
   if(context && context.length > 0) {
     for(var i=0, j=context.length; i<j; i++) {
-      ret = ret + fn(context[i]);
+      if (data) { data.index = i; }
+      ret = ret + fn(context[i], { data: data });
     }
   } else {
     ret = inverse(this);
@@ -92,6 +107,8 @@ Handlebars.registerHelper('with', function(context, options) {
 Handlebars.registerHelper('log', function(context) {
   Handlebars.log(context);
 });
+
+}(this.Handlebars));
 ;
 // lib/handlebars/utils.js
 Handlebars.Exception = function(message) {
@@ -103,7 +120,7 @@ Handlebars.Exception = function(message) {
 
   this.message = tmp.message;
 };
-Handlebars.Exception.prototype = new Error;
+Handlebars.Exception.prototype = new Error();
 
 // Build out our basic SafeString type
 Handlebars.SafeString = function(string) {
@@ -115,6 +132,7 @@ Handlebars.SafeString.prototype.toString = function() {
 
 (function() {
   var escape = {
+    "&": "&amp;",
     "<": "&lt;",
     ">": "&gt;",
     '"': "&quot;",
@@ -122,7 +140,7 @@ Handlebars.SafeString.prototype.toString = function() {
     "`": "&#x60;"
   };
 
-  var badChars = /&(?!\w+;)|[<>"'`]/g;
+  var badChars = /[&<>"'`]/g;
   var possible = /[&<>"'`]/;
 
   var escapeChar = function(chr) {
@@ -204,7 +222,7 @@ Handlebars.VM = {
   },
   noop: function() { return ""; },
   invokePartial: function(partial, name, context, helpers, partials, data) {
-    options = { helpers: helpers, partials: partials, data: data };
+    var options = { helpers: helpers, partials: partials, data: data };
 
     if(partial === undefined) {
       throw new Handlebars.Exception("The partial " + name + " could not be found");
@@ -213,7 +231,7 @@ Handlebars.VM = {
     } else if (!Handlebars.compile) {
       throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
     } else {
-      partials[name] = Handlebars.compile(partial);
+      partials[name] = Handlebars.compile(partial, {data: data !== undefined});
       return partials[name](context, options);
     }
   }
diff --git a/static/scripts/libs/underscore.js b/static/scripts/libs/underscore.js
index 208d4cd890c..1a22212cc43 100644
--- a/static/scripts/libs/underscore.js
+++ b/static/scripts/libs/underscore.js
@@ -1,10 +1,7 @@
-//     Underscore.js 1.3.1
-//     (c) 2009-2012 Jeremy Ashkenas, DocumentCloud Inc.
-//     Underscore is freely distributable under the MIT license.
-//     Portions of Underscore are inspired or borrowed from Prototype,
-//     Oliver Steele's Functional, and John Resig's Micro-Templating.
-//     For all details and documentation:
-//     http://documentcloud.github.com/underscore
+//     Underscore.js 1.4.4
+//     http://underscorejs.org
+//     (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+//     Underscore may be freely distributed under the MIT license.
 
 (function() {
 
@@ -24,8 +21,9 @@
   var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
 
   // Create quick reference variables for speed access to core prototypes.
-  var slice            = ArrayProto.slice,
-      unshift          = ArrayProto.unshift,
+  var push             = ArrayProto.push,
+      slice            = ArrayProto.slice,
+      concat           = ArrayProto.concat,
       toString         = ObjProto.toString,
       hasOwnProperty   = ObjProto.hasOwnProperty;
 
@@ -46,7 +44,11 @@
     nativeBind         = FuncProto.bind;
 
   // Create a safe reference to the Underscore object for use below.
-  var _ = function(obj) { return new wrapper(obj); };
+  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
@@ -58,11 +60,11 @@
     }
     exports._ = _;
   } else {
-    root['_'] = _;
+    root._ = _;
   }
 
   // Current version.
-  _.VERSION = '1.3.1';
+  _.VERSION = '1.4.4';
 
   // Collection Functions
   // --------------------
@@ -76,7 +78,7 @@
       obj.forEach(iterator, context);
     } else if (obj.length === +obj.length) {
       for (var i = 0, l = obj.length; i < l; i++) {
-        if (i in obj && iterator.call(context, obj[i], i, obj) === breaker) return;
+        if (iterator.call(context, obj[i], i, obj) === breaker) return;
       }
     } else {
       for (var key in obj) {
@@ -94,12 +96,13 @@
     if (obj == null) return results;
     if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
     each(obj, function(value, index, list) {
-      results[results.length] = iterator.call(context, value, index, list);
+      results.push(iterator.call(context, value, index, list));
     });
-    if (obj.length === +obj.length) results.length = obj.length;
     return results;
   };
 
+  var reduceError = 'Reduce of empty array with no initial value';
+
   // **Reduce** builds up a single result from a list of values, aka `inject`,
   // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
   _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
@@ -117,7 +120,7 @@
         memo = iterator.call(context, memo, value, index, list);
       }
     });
-    if (!initial) throw new TypeError('Reduce of empty array with no initial value');
+    if (!initial) throw new TypeError(reduceError);
     return memo;
   };
 
@@ -130,9 +133,22 @@
       if (context) iterator = _.bind(iterator, context);
       return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
     }
-    var reversed = _.toArray(obj).reverse();
-    if (context && !initial) iterator = _.bind(iterator, context);
-    return initial ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);
+    var length = obj.length;
+    if (length !== +length) {
+      var keys = _.keys(obj);
+      length = keys.length;
+    }
+    each(obj, function(value, index, list) {
+      index = keys ? keys[--length] : --length;
+      if (!initial) {
+        memo = obj[index];
+        initial = true;
+      } else {
+        memo = iterator.call(context, memo, obj[index], index, list);
+      }
+    });
+    if (!initial) throw new TypeError(reduceError);
+    return memo;
   };
 
   // Return the first value which passes a truth test. Aliased as `detect`.
@@ -155,32 +171,30 @@
     if (obj == null) return results;
     if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);
     each(obj, function(value, index, list) {
-      if (iterator.call(context, value, index, list)) results[results.length] = value;
+      if (iterator.call(context, value, index, list)) results.push(value);
     });
     return results;
   };
 
   // Return all the elements for which a truth test fails.
   _.reject = function(obj, iterator, context) {
-    var results = [];
-    if (obj == null) return results;
-    each(obj, function(value, index, list) {
-      if (!iterator.call(context, value, index, list)) results[results.length] = value;
-    });
-    return results;
+    return _.filter(obj, function(value, index, list) {
+      return !iterator.call(context, value, index, list);
+    }, context);
   };
 
   // Determine whether all of the elements match a truth test.
   // Delegates to **ECMAScript 5**'s native `every` if available.
   // Aliased as `all`.
   _.every = _.all = function(obj, iterator, context) {
+    iterator || (iterator = _.identity);
     var result = true;
     if (obj == null) return result;
     if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);
     each(obj, function(value, index, list) {
       if (!(result = result && iterator.call(context, value, index, list))) return breaker;
     });
-    return result;
+    return !!result;
   };
 
   // Determine if at least one element in the object matches a truth test.
@@ -197,23 +211,22 @@
     return !!result;
   };
 
-  // Determine if a given value is included in the array or object using `===`.
-  // Aliased as `contains`.
-  _.include = _.contains = function(obj, target) {
-    var found = false;
-    if (obj == null) return found;
+  // Determine if the array or object contains a given value (using `===`).
+  // Aliased as `include`.
+  _.contains = _.include = function(obj, target) {
+    if (obj == null) return false;
     if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
-    found = any(obj, function(value) {
+    return any(obj, function(value) {
       return value === target;
     });
-    return found;
   };
 
   // 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) {
-      return (_.isFunction(method) ? method || value : value[method]).apply(value, args);
+      return (isFunc ? method : value[method]).apply(value, args);
     });
   };
 
@@ -222,11 +235,33 @@
     return _.map(obj, function(value){ return value[key]; });
   };
 
+  // Convenience version of a common use case of `filter`: selecting only objects
+  // containing specific `key:value` pairs.
+  _.where = function(obj, attrs, first) {
+    if (_.isEmpty(attrs)) return first ? void 0 : [];
+    return _[first ? 'find' : 'filter'](obj, function(value) {
+      for (var key in attrs) {
+        if (attrs[key] !== value[key]) return false;
+      }
+      return true;
+    });
+  };
+
+  // Convenience version of a common use case of `find`: getting the first object
+  // containing specific `key:value` pairs.
+  _.findWhere = function(obj, attrs) {
+    return _.where(obj, attrs, true);
+  };
+
   // Return the maximum element or (element-based computation).
+  // Can't optimize arrays of integers longer than 65,535 elements.
+  // See: https://bugs.webkit.org/show_bug.cgi?id=80797
   _.max = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj)) return Math.max.apply(Math, obj);
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.max.apply(Math, obj);
+    }
     if (!iterator && _.isEmpty(obj)) return -Infinity;
-    var result = {computed : -Infinity};
+    var result = {computed : -Infinity, value: -Infinity};
     each(obj, function(value, index, list) {
       var computed = iterator ? iterator.call(context, value, index, list) : value;
       computed >= result.computed && (result = {value : value, computed : computed});
@@ -236,9 +271,11 @@
 
   // Return the minimum element (or element-based computation).
   _.min = function(obj, iterator, context) {
-    if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj);
+    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
+      return Math.min.apply(Math, obj);
+    }
     if (!iterator && _.isEmpty(obj)) return Infinity;
-    var result = {computed : Infinity};
+    var result = {computed : Infinity, value: Infinity};
     each(obj, function(value, index, list) {
       var computed = iterator ? iterator.call(context, value, index, list) : value;
       computed < result.computed && (result = {value : value, computed : computed});
@@ -248,81 +285,110 @@
 
   // Shuffle an array.
   _.shuffle = function(obj) {
-    var shuffled = [], rand;
-    each(obj, function(value, index, list) {
-      if (index == 0) {
-        shuffled[0] = value;
-      } else {
-        rand = Math.floor(Math.random() * (index + 1));
-        shuffled[index] = shuffled[rand];
-        shuffled[rand] = value;
-      }
+    var rand;
+    var index = 0;
+    var shuffled = [];
+    each(obj, function(value) {
+      rand = _.random(index++);
+      shuffled[index - 1] = shuffled[rand];
+      shuffled[rand] = value;
     });
     return shuffled;
   };
 
+  // An internal function to generate lookup iterators.
+  var lookupIterator = function(value) {
+    return _.isFunction(value) ? value : function(obj){ return obj[value]; };
+  };
+
   // Sort the object's values by a criterion produced by an iterator.
-  _.sortBy = function(obj, iterator, context) {
+  _.sortBy = function(obj, value, context) {
+    var iterator = lookupIterator(value);
     return _.pluck(_.map(obj, function(value, index, list) {
       return {
         value : value,
+        index : index,
         criteria : iterator.call(context, value, index, list)
       };
     }).sort(function(left, right) {
-      var a = left.criteria, b = right.criteria;
-      return a < b ? -1 : a > b ? 1 : 0;
+      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 ? -1 : 1;
     }), 'value');
   };
 
-  // Groups the object's values by a criterion. Pass either a string attribute
-  // to group by, or a function that returns the criterion.
-  _.groupBy = function(obj, val) {
+  // An internal function used for aggregate "group by" operations.
+  var group = function(obj, value, context, behavior) {
     var result = {};
-    var iterator = _.isFunction(val) ? val : function(obj) { return obj[val]; };
+    var iterator = lookupIterator(value == null ? _.identity : value);
     each(obj, function(value, index) {
-      var key = iterator(value, index);
-      (result[key] || (result[key] = [])).push(value);
+      var key = iterator.call(context, value, index, obj);
+      behavior(result, key, value);
     });
     return result;
   };
 
-  // Use a comparator function to figure out at what index an object should
-  // be inserted so as to maintain order. Uses binary search.
-  _.sortedIndex = function(array, obj, iterator) {
-    iterator || (iterator = _.identity);
+  // Groups the object's values by a criterion. Pass either a string attribute
+  // to group by, or a function that returns the criterion.
+  _.groupBy = function(obj, value, context) {
+    return group(obj, value, context, function(result, key, value) {
+      (_.has(result, key) ? result[key] : (result[key] = [])).push(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 = function(obj, value, context) {
+    return group(obj, value, context, function(result, key) {
+      if (!_.has(result, key)) result[key] = 0;
+      result[key]++;
+    });
+  };
+
+  // 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, iterator, context) {
+    iterator = iterator == null ? _.identity : lookupIterator(iterator);
+    var value = iterator.call(context, obj);
     var low = 0, high = array.length;
     while (low < high) {
-      var mid = (low + high) >> 1;
-      iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid;
+      var mid = (low + high) >>> 1;
+      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
     }
     return low;
   };
 
   // Safely convert anything iterable into a real, live array.
-  _.toArray = function(iterable) {
-    if (!iterable)                return [];
-    if (iterable.toArray)         return iterable.toArray();
-    if (_.isArray(iterable))      return slice.call(iterable);
-    if (_.isArguments(iterable))  return slice.call(iterable);
-    return _.values(iterable);
+  _.toArray = function(obj) {
+    if (!obj) return [];
+    if (_.isArray(obj)) return slice.call(obj);
+    if (obj.length === +obj.length) return _.map(obj, _.identity);
+    return _.values(obj);
   };
 
   // Return the number of elements in an object.
   _.size = function(obj) {
-    return _.toArray(obj).length;
+    if (obj == null) return 0;
+    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
   };
 
   // Array Functions
   // ---------------
 
   // Get the first element of an array. Passing **n** will return the first N
-  // values in the array. Aliased as `head`. The **guard** check allows it to work
-  // with `_.map`.
-  _.first = _.head = function(array, n, guard) {
+  // 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;
     return (n != null) && !guard ? slice.call(array, 0, n) : array[0];
   };
 
-  // Returns everything but the last entry of the array. Especcialy useful on
+  // 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. The **guard** check allows it to work with
   // `_.map`.
@@ -333,6 +399,7 @@
   // Get the last element of an array. Passing **n** will return the last N
   // values in the array. The **guard** check allows it to work with `_.map`.
   _.last = function(array, n, guard) {
+    if (array == null) return void 0;
     if ((n != null) && !guard) {
       return slice.call(array, Math.max(array.length - n, 0));
     } else {
@@ -340,26 +407,34 @@
     }
   };
 
-  // Returns everything but the first entry of the array. Aliased as `tail`.
-  // Especially useful on the arguments object. Passing an **index** will return
-  // the rest of the values in the array from that index onward. The **guard**
+  // 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. The **guard**
   // check allows it to work with `_.map`.
-  _.rest = _.tail = function(array, index, guard) {
-    return slice.call(array, (index == null) || guard ? 1 : index);
+  _.rest = _.tail = _.drop = function(array, n, guard) {
+    return slice.call(array, (n == null) || guard ? 1 : n);
   };
 
   // Trim out all falsy values from an array.
   _.compact = function(array) {
-    return _.filter(array, function(value){ return !!value; });
+    return _.filter(array, _.identity);
+  };
+
+  // Internal implementation of a recursive `flatten` function.
+  var flatten = function(input, shallow, output) {
+    each(input, function(value) {
+      if (_.isArray(value)) {
+        shallow ? push.apply(output, value) : flatten(value, shallow, output);
+      } else {
+        output.push(value);
+      }
+    });
+    return output;
   };
 
   // Return a completely flattened version of an array.
   _.flatten = function(array, shallow) {
-    return _.reduce(array, function(memo, value) {
-      if (_.isArray(value)) return memo.concat(shallow ? value : _.flatten(value));
-      memo[memo.length] = value;
-      return memo;
-    }, []);
+    return flatten(array, shallow, []);
   };
 
   // Return a version of the array that does not contain the specified value(s).
@@ -370,28 +445,33 @@
   // 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, iterator) {
-    var initial = iterator ? _.map(array, iterator) : array;
-    var result = [];
-    _.reduce(initial, function(memo, el, i) {
-      if (0 == i || (isSorted === true ? _.last(memo) != el : !_.include(memo, el))) {
-        memo[memo.length] = el;
-        result[result.length] = array[i];
+  _.uniq = _.unique = function(array, isSorted, iterator, context) {
+    if (_.isFunction(isSorted)) {
+      context = iterator;
+      iterator = isSorted;
+      isSorted = false;
+    }
+    var initial = iterator ? _.map(array, iterator, context) : array;
+    var results = [];
+    var seen = [];
+    each(initial, function(value, index) {
+      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
+        seen.push(value);
+        results.push(array[index]);
       }
-      return memo;
-    }, []);
-    return result;
+    });
+    return results;
   };
 
   // Produce an array that contains the union: each distinct element from all of
   // the passed-in arrays.
   _.union = function() {
-    return _.uniq(_.flatten(arguments, true));
+    return _.uniq(concat.apply(ArrayProto, arguments));
   };
 
   // Produce an array that contains every item shared between all the
-  // passed-in arrays. (Aliased as "intersect" for back-compat.)
-  _.intersection = _.intersect = function(array) {
+  // passed-in arrays.
+  _.intersection = function(array) {
     var rest = slice.call(arguments, 1);
     return _.filter(_.uniq(array), function(item) {
       return _.every(rest, function(other) {
@@ -403,8 +483,8 @@
   // 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(slice.call(arguments, 1));
-    return _.filter(array, function(value){ return !_.include(rest, value); });
+    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
+    return _.filter(array, function(value){ return !_.contains(rest, value); });
   };
 
   // Zip together multiple lists into a single array -- elements that share
@@ -413,10 +493,47 @@
     var args = slice.call(arguments);
     var length = _.max(_.pluck(args, 'length'));
     var results = new Array(length);
-    for (var i = 0; i < length; i++) results[i] = _.pluck(args, "" + i);
+    for (var i = 0; i < length; i++) {
+      results[i] = _.pluck(args, "" + i);
+    }
     return results;
   };
 
+  // The inverse operation to `_.zip`. If given an array of pairs it
+  // returns an array of the paired elements split into two left and
+  // right element arrays, if given an array of triples it returns a
+  // three element array and so on. For example, `_.unzip` given
+  // `[['a',1],['b',2],['c',3]]` returns the array
+  // [['a','b','c'],[1,2,3]].
+  _.unzip = function(tuples) {
+      var results = [];
+      _.each(tuples, function (tuple, tupleIndex) {
+          _.each(tuple, function (value, itemIndex) {
+              if (results.length <= itemIndex) {
+                  results[itemIndex] = [];
+              }
+              results[itemIndex][tupleIndex] = value;
+          });
+      });
+      return results;
+  };
+
+  // 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) {
+    if (list == null) return {};
+    var result = {};
+    for (var i = 0, l = list.length; i < l; i++) {
+      if (values) {
+        result[list[i]] = values[i];
+      } else {
+        result[list[i][0]] = list[i][1];
+      }
+    }
+    return result;
+  };
+
   // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
   // we need this function. Return the position of the first occurrence of an
   // item in an array, or -1 if the item is not included in the array.
@@ -425,22 +542,29 @@
   // for **isSorted** to use binary search.
   _.indexOf = function(array, item, isSorted) {
     if (array == null) return -1;
-    var i, l;
+    var i = 0, l = array.length;
     if (isSorted) {
-      i = _.sortedIndex(array, item);
-      return array[i] === item ? i : -1;
+      if (typeof isSorted == 'number') {
+        i = (isSorted < 0 ? Math.max(0, l + isSorted) : isSorted);
+      } else {
+        i = _.sortedIndex(array, item);
+        return array[i] === item ? i : -1;
+      }
     }
-    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item);
-    for (i = 0, l = array.length; i < l; i++) if (i in array && array[i] === item) return i;
+    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
+    for (; i < l; i++) if (array[i] === item) return i;
     return -1;
   };
 
   // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
-  _.lastIndexOf = function(array, item) {
+  _.lastIndexOf = function(array, item, from) {
     if (array == null) return -1;
-    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) return array.lastIndexOf(item);
-    var i = array.length;
-    while (i--) if (i in array && array[i] === item) return i;
+    var hasIndex = from != null;
+    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
+      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
+    }
+    var i = (hasIndex ? from : array.length);
+    while (i--) if (array[i] === item) return i;
     return -1;
   };
 
@@ -473,11 +597,10 @@
   var ctor = function(){};
 
   // Create a function bound to a given object (assigning `this`, and arguments,
-  // optionally). Binding with arguments is also known as `curry`.
-  // Delegates to **ECMAScript 5**'s native `Function.bind` if available.
-  // We check for `func.bind` first, to fail fast when `func` is undefined.
-  _.bind = function bind(func, context) {
-    var bound, args;
+  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
+  // available.
+  _.bind = function(func, context) {
+    var args, bound;
     if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
     if (!_.isFunction(func)) throw new TypeError;
     args = slice.call(arguments, 2);
@@ -485,17 +608,27 @@
       if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
       ctor.prototype = func.prototype;
       var self = new ctor;
+      ctor.prototype = null;
       var result = func.apply(self, args.concat(slice.call(arguments)));
       if (Object(result) === result) return result;
       return self;
     };
   };
 
+  // Partially apply a function by creating a version that has had some of its
+  // arguments pre-filled, without changing its dynamic `this` context.
+  _.partial = function(func) {
+    var args = slice.call(arguments, 1);
+    return function() {
+      return func.apply(this, args.concat(slice.call(arguments)));
+    };
+  };
+
   // Bind all of an object's methods to that object. Useful for ensuring that
   // all callbacks defined on an object belong to it.
   _.bindAll = function(obj) {
     var funcs = slice.call(arguments, 1);
-    if (funcs.length == 0) funcs = _.functions(obj);
+    if (funcs.length === 0) throw new Error("bindAll must be passed function names");
     each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
     return obj;
   };
@@ -514,7 +647,7 @@
   // it with the arguments supplied.
   _.delay = function(func, wait) {
     var args = slice.call(arguments, 2);
-    return setTimeout(function(){ return func.apply(func, args); }, wait);
+    return setTimeout(function(){ return func.apply(null, args); }, wait);
   };
 
   // Defers a function, scheduling it to run after the current call stack has
@@ -525,40 +658,49 @@
 
   // Returns a function, that, when invoked, will only be triggered at most once
   // during a given window of time.
-  _.throttle = function(func, wait) {
-    var context, args, timeout, throttling, more;
-    var whenDone = _.debounce(function(){ more = throttling = false; }, wait);
+  _.throttle = function(func, wait, immediate) {
+    var context, args, timeout, result;
+    var previous = 0;
+    var later = function() {
+      previous = new Date;
+      timeout = null;
+      result = func.apply(context, args);
+    };
     return function() {
-      context = this; args = arguments;
-      var later = function() {
+      var now = new Date;
+      if (!previous && immediate === false) previous = now;
+      var remaining = wait - (now - previous);
+      context = this;
+      args = arguments;
+      if (remaining <= 0) {
+        clearTimeout(timeout);
         timeout = null;
-        if (more) func.apply(context, args);
-        whenDone();
-      };
-      if (!timeout) timeout = setTimeout(later, wait);
-      if (throttling) {
-        more = true;
-      } else {
-        func.apply(context, args);
+        previous = now;
+        result = func.apply(context, args);
+      } else if (!timeout) {
+        timeout = setTimeout(later, remaining);
       }
-      whenDone();
-      throttling = true;
+      return result;
     };
   };
 
   // Returns a function, that, as long as it continues to be invoked, will not
   // be triggered. The function will be called after it stops being called for
-  // N milliseconds.
-  _.debounce = function(func, wait) {
-    var timeout;
+  // 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;
     return function() {
       var context = this, args = arguments;
       var later = function() {
         timeout = null;
-        func.apply(context, args);
+        if (!immediate) result = func.apply(context, args);
       };
+      var callNow = immediate && !timeout;
       clearTimeout(timeout);
       timeout = setTimeout(later, wait);
+      if (callNow) result = func.apply(context, args);
+      return result;
     };
   };
 
@@ -569,7 +711,9 @@
     return function() {
       if (ran) return memo;
       ran = true;
-      return memo = func.apply(this, arguments);
+      memo = func.apply(this, arguments);
+      func = null;
+      return memo;
     };
   };
 
@@ -578,7 +722,8 @@
   // conditionally execute the original function.
   _.wrap = function(func, wrapper) {
     return function() {
-      var args = [func].concat(slice.call(arguments, 0));
+      var args = [func];
+      push.apply(args, arguments);
       return wrapper.apply(this, args);
     };
   };
@@ -600,7 +745,9 @@
   _.after = function(times, func) {
     if (times <= 0) return func();
     return function() {
-      if (--times < 1) { return func.apply(this, arguments); }
+      if (--times < 1) {
+        return func.apply(this, arguments);
+      }
     };
   };
 
@@ -612,13 +759,29 @@
   _.keys = nativeKeys || function(obj) {
     if (obj !== Object(obj)) throw new TypeError('Invalid object');
     var keys = [];
-    for (var key in obj) if (_.has(obj, key)) keys[keys.length] = key;
+    for (var key in obj) if (_.has(obj, key)) keys.push(key);
     return keys;
   };
 
   // Retrieve the values of an object's properties.
   _.values = function(obj) {
-    return _.map(obj, _.identity);
+    var values = [];
+    for (var key in obj) if (_.has(obj, key)) values.push(obj[key]);
+    return values;
+  };
+
+  // Convert an object into a list of `[key, value]` pairs.
+  _.pairs = function(obj) {
+    var pairs = [];
+    for (var key in obj) if (_.has(obj, key)) pairs.push([key, obj[key]]);
+    return pairs;
+  };
+
+  // Invert the keys and values of an object. The values must be serializable.
+  _.invert = function(obj) {
+    var result = {};
+    for (var key in obj) if (_.has(obj, key)) result[obj[key]] = key;
+    return result;
   };
 
   // Return a sorted list of the function names available on the object.
@@ -634,18 +797,42 @@
   // Extend a given object with all the properties in passed-in object(s).
   _.extend = function(obj) {
     each(slice.call(arguments, 1), function(source) {
-      for (var prop in source) {
-        obj[prop] = source[prop];
+      if (source) {
+        for (var prop in source) {
+          obj[prop] = source[prop];
+        }
       }
     });
     return obj;
   };
 
+  // Return a copy of the object only containing the whitelisted properties.
+  _.pick = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    each(keys, function(key) {
+      if (key in obj) copy[key] = obj[key];
+    });
+    return copy;
+  };
+
+   // Return a copy of the object without the blacklisted properties.
+  _.omit = function(obj) {
+    var copy = {};
+    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
+    for (var key in obj) {
+      if (!_.contains(keys, key)) copy[key] = obj[key];
+    }
+    return copy;
+  };
+
   // Fill in a given object with default properties.
   _.defaults = function(obj) {
     each(slice.call(arguments, 1), function(source) {
-      for (var prop in source) {
-        if (obj[prop] == null) obj[prop] = source[prop];
+      if (source) {
+        for (var prop in source) {
+          if (obj[prop] === void 0) obj[prop] = source[prop];
+        }
       }
     });
     return obj;
@@ -665,19 +852,16 @@
     return obj;
   };
 
-  // Internal recursive comparison function.
-  function eq(a, b, stack) {
+  // 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._chain) a = a._wrapped;
-    if (b._chain) b = b._wrapped;
-    // Invoke a custom `isEqual` method if one is provided.
-    if (a.isEqual && _.isFunction(a.isEqual)) return a.isEqual(b);
-    if (b.isEqual && _.isFunction(b.isEqual)) return b.isEqual(a);
+    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;
@@ -707,14 +891,15 @@
     if (typeof a != 'object' || typeof b != 'object') 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`.
-    var length = stack.length;
+    var length = aStack.length;
     while (length--) {
       // Linear search. Performance is inversely proportional to the number of
       // unique nested structures.
-      if (stack[length] == a) return true;
+      if (aStack[length] == a) return bStack[length] == b;
     }
     // Add the first object to the stack of traversed objects.
-    stack.push(a);
+    aStack.push(a);
+    bStack.push(b);
     var size = 0, result = true;
     // Recursively compare objects and arrays.
     if (className == '[object Array]') {
@@ -724,20 +909,24 @@
       if (result) {
         // Deep compare the contents, ignoring non-numeric properties.
         while (size--) {
-          // Ensure commutative equality for sparse arrays.
-          if (!(result = size in a == size in b && eq(a[size], b[size], stack))) break;
+          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
         }
       }
     } else {
-      // Objects with different constructors are not equivalent.
-      if ('constructor' in a != 'constructor' in b || a.constructor != b.constructor) return false;
+      // Objects with different constructors are not equivalent, but `Object`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))) {
+        return false;
+      }
       // Deep compare objects.
       for (var key in a) {
         if (_.has(a, key)) {
           // Count the expected number of properties.
           size++;
           // Deep compare each member.
-          if (!(result = _.has(b, key) && eq(a[key], b[key], stack))) break;
+          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
         }
       }
       // Ensure that both objects contain the same number of properties.
@@ -749,18 +938,20 @@
       }
     }
     // Remove the first object from the stack of traversed objects.
-    stack.pop();
+    aStack.pop();
+    bStack.pop();
     return result;
-  }
+  };
 
   // Perform a deep comparison to check if two objects are equal.
   _.isEqual = function(a, b) {
-    return eq(a, b, []);
+    return eq(a, b, [], []);
   };
 
   // Is a given array, string, or object empty?
   // An "empty" object has no enumerable own-properties.
   _.isEmpty = function(obj) {
+    if (obj == null) return true;
     if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
     for (var key in obj) if (_.has(obj, key)) return false;
     return true;
@@ -768,7 +959,7 @@
 
   // Is a given value a DOM element?
   _.isElement = function(obj) {
-    return !!(obj && obj.nodeType == 1);
+    return !!(obj && obj.nodeType === 1);
   };
 
   // Is a given value an array?
@@ -782,35 +973,36 @@
     return obj === Object(obj);
   };
 
-  // Is a given variable an arguments object?
-  _.isArguments = function(obj) {
-    return toString.call(obj) == '[object Arguments]';
-  };
+  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
+  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
+    _['is' + name] = function(obj) {
+      return toString.call(obj) == '[object ' + name + ']';
+    };
+  });
+
+  // Define a fallback version of the method in browsers (ahem, IE), where
+  // there isn't any inspectable "Arguments" type.
   if (!_.isArguments(arguments)) {
     _.isArguments = function(obj) {
       return !!(obj && _.has(obj, 'callee'));
     };
   }
 
-  // Is a given value a function?
-  _.isFunction = function(obj) {
-    return toString.call(obj) == '[object Function]';
+  // Optimize `isFunction` if appropriate.
+  if (typeof (/./) !== 'function') {
+    _.isFunction = function(obj) {
+      return typeof obj === 'function';
+    };
+  }
+
+  // Is a given object a finite number?
+  _.isFinite = function(obj) {
+    return isFinite(obj) && !isNaN(parseFloat(obj));
   };
 
-  // Is a given value a string?
-  _.isString = function(obj) {
-    return toString.call(obj) == '[object String]';
-  };
-
-  // Is a given value a number?
-  _.isNumber = function(obj) {
-    return toString.call(obj) == '[object Number]';
-  };
-
-  // Is the given value `NaN`?
+  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
   _.isNaN = function(obj) {
-    // `NaN` is the only value for which `===` is not reflexive.
-    return obj !== obj;
+    return _.isNumber(obj) && obj != +obj;
   };
 
   // Is a given value a boolean?
@@ -818,16 +1010,6 @@
     return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
   };
 
-  // Is a given value a date?
-  _.isDate = function(obj) {
-    return toString.call(obj) == '[object Date]';
-  };
-
-  // Is the given value a regular expression?
-  _.isRegExp = function(obj) {
-    return toString.call(obj) == '[object RegExp]';
-  };
-
   // Is a given value equal to null?
   _.isNull = function(obj) {
     return obj === null;
@@ -838,7 +1020,8 @@
     return obj === void 0;
   };
 
-  // Has own property?
+  // 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);
   };
@@ -859,20 +1042,67 @@
   };
 
   // Run a function **n** times.
-  _.times = function (n, iterator, context) {
-    for (var i = 0; i < n; i++) iterator.call(context, i);
+  _.times = function(n, iterator, context) {
+    var accum = Array(n);
+    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
+    return accum;
   };
 
-  // Escape a string for HTML interpolation.
-  _.escape = function(string) {
-    return (''+string).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#x27;').replace(/\//g,'&#x2F;');
+  // 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));
   };
 
-  // Add your own custom functions to the Underscore object, ensuring that
-  // they're correctly added to the OOP wrapper as well.
+  // List of HTML entities for escaping.
+  var entityMap = {
+    escape: {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#x27;',
+      '/': '&#x2F;'
+    }
+  };
+  entityMap.unescape = _.invert(entityMap.escape);
+
+  // Regexes containing the keys and values listed immediately above.
+  var entityRegexes = {
+    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
+    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
+  };
+
+  // Functions for escaping and unescaping strings to/from HTML interpolation.
+  _.each(['escape', 'unescape'], function(method) {
+    _[method] = function(string) {
+      if (string == null) return '';
+      return ('' + string).replace(entityRegexes[method], function(match) {
+        return entityMap[method][match];
+      });
+    };
+  });
+
+  // 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) {
+    if (object == null) return void 0;
+    var value = object[property];
+    return _.isFunction(value) ? value.call(object) : value;
+  };
+
+  // Add your own custom functions to the Underscore object.
   _.mixin = function(obj) {
     each(_.functions(obj), function(name){
-      addToWrapper(name, _[name] = obj[name]);
+      var func = _[name] = obj[name];
+      _.prototype[name] = function() {
+        var args = [this._wrapped];
+        push.apply(args, arguments);
+        return result.call(this, func.apply(_, args));
+      };
     });
   };
 
@@ -880,7 +1110,7 @@
   // Useful for temporary DOM ids.
   var idCounter = 0;
   _.uniqueId = function(prefix) {
-    var id = idCounter++;
+    var id = ++idCounter + '';
     return prefix ? prefix + id : id;
   };
 
@@ -895,41 +1125,80 @@
   // 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 = /.^/;
+  var noMatch = /(.)^/;
 
-  // Within an interpolation, evaluation, or escaping, remove HTML escaping
-  // that had been previously added.
-  var unescape = function(code) {
-    return code.replace(/\\\\/g, '\\').replace(/\\'/g, "'");
+  // Certain characters need to be escaped so that they can be put into a
+  // string literal.
+  var escapes = {
+    "'":      "'",
+    '\\':     '\\',
+    '\r':     'r',
+    '\n':     'n',
+    '\t':     't',
+    '\u2028': 'u2028',
+    '\u2029': 'u2029'
   };
 
+  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;
+
   // JavaScript micro-templating, similar to John Resig's implementation.
   // Underscore templating handles arbitrary delimiters, preserves whitespace,
   // and correctly escapes quotes within interpolated code.
-  _.template = function(str, data) {
-    var c  = _.templateSettings;
-    var tmpl = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
-      'with(obj||{}){__p.push(\'' +
-      str.replace(/\\/g, '\\\\')
-         .replace(/'/g, "\\'")
-         .replace(c.escape || noMatch, function(match, code) {
-           return "',_.escape(" + unescape(code) + "),'";
-         })
-         .replace(c.interpolate || noMatch, function(match, code) {
-           return "'," + unescape(code) + ",'";
-         })
-         .replace(c.evaluate || noMatch, function(match, code) {
-           return "');" + unescape(code).replace(/[\r\n\t]/g, ' ') + ";__p.push('";
-         })
-         .replace(/\r/g, '\\r')
-         .replace(/\n/g, '\\n')
-         .replace(/\t/g, '\\t')
-         + "');}return __p.join('');";
-    var func = new Function('obj', '_', tmpl);
-    if (data) return func(data, _);
-    return function(data) {
-      return func.call(this, data, _);
+  _.template = function(text, data, settings) {
+    var render;
+    settings = _.defaults({}, settings, _.templateSettings);
+
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = new RegExp([
+      (settings.escape || noMatch).source,
+      (settings.interpolate || noMatch).source,
+      (settings.evaluate || noMatch).source
+    ].join('|') + '|$', 'g');
+
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
+      source += text.slice(index, offset)
+        .replace(escaper, function(match) { return '\\' + escapes[match]; });
+
+      if (escape) {
+        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+      }
+      if (interpolate) {
+        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+      }
+      if (evaluate) {
+        source += "';\n" + evaluate + "\n__p+='";
+      }
+      index = offset + match.length;
+      return match;
+    });
+    source += "';\n";
+
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
+
+    source = "var __t,__p='',__j=Array.prototype.join," +
+      "print=function(){__p+=__j.call(arguments,'');};\n" +
+      source + "return __p;\n";
+
+    try {
+      render = new Function(settings.variable || 'obj', '_', source);
+    } catch (e) {
+      e.source = source;
+      throw e;
+    }
+
+    if (data) return render(data, _);
+    var template = function(data) {
+      return render.call(this, data, _);
     };
+
+    // Provide the compiled function source as a convenience for precompilation.
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';
+
+    return template;
   };
 
   // Add a "chain" function, which will delegate to the wrapper.
@@ -937,29 +1206,15 @@
     return _(obj).chain();
   };
 
-  // The OOP Wrapper
+  // 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.
-  var wrapper = function(obj) { this._wrapped = obj; };
-
-  // Expose `wrapper.prototype` as `_.prototype`
-  _.prototype = wrapper.prototype;
 
   // Helper function to continue chaining intermediate results.
-  var result = function(obj, chain) {
-    return chain ? _(obj).chain() : obj;
-  };
-
-  // A method to easily add functions to the OOP wrapper.
-  var addToWrapper = function(name, func) {
-    wrapper.prototype[name] = function() {
-      var args = slice.call(arguments);
-      unshift.call(args, this._wrapped);
-      return result(func.apply(_, args), this._chain);
-    };
+  var result = function(obj) {
+    return this._chain ? _(obj).chain() : obj;
   };
 
   // Add all of the Underscore functions to the wrapper object.
@@ -968,32 +1223,35 @@
   // Add all mutator Array functions to the wrapper.
   each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
     var method = ArrayProto[name];
-    wrapper.prototype[name] = function() {
-      var wrapped = this._wrapped;
-      method.apply(wrapped, arguments);
-      var length = wrapped.length;
-      if ((name == 'shift' || name == 'splice') && length === 0) delete wrapped[0];
-      return result(wrapped, this._chain);
+    _.prototype[name] = function() {
+      var obj = this._wrapped;
+      method.apply(obj, arguments);
+      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
+      return result.call(this, obj);
     };
   });
 
   // Add all accessor Array functions to the wrapper.
   each(['concat', 'join', 'slice'], function(name) {
     var method = ArrayProto[name];
-    wrapper.prototype[name] = function() {
-      return result(method.apply(this._wrapped, arguments), this._chain);
+    _.prototype[name] = function() {
+      return result.call(this, method.apply(this._wrapped, arguments));
     };
   });
 
-  // Start chaining a wrapped Underscore object.
-  wrapper.prototype.chain = function() {
-    this._chain = true;
-    return this;
-  };
+  _.extend(_.prototype, {
 
-  // Extracts the result from a wrapped and chained object.
-  wrapper.prototype.value = function() {
-    return this._wrapped;
-  };
+    // Start chaining a wrapped Underscore object.
+    chain: function() {
+      this._chain = true;
+      return this;
+    },
+
+    // Extracts the result from a wrapped and chained object.
+    value: function() {
+      return this._wrapped;
+    }
+
+  });
 
 }).call(this);
diff --git a/static/scripts/packed/libs/backbone/backbone-relational.js b/static/scripts/packed/libs/backbone/backbone-relational.js
index 47d73029bcd..312206b8149 100644
--- a/static/scripts/packed/libs/backbone/backbone-relational.js
+++ b/static/scripts/packed/libs/backbone/backbone-relational.js
@@ -1 +1 @@
-(function(b){var h,g,c;if(typeof window==="undefined"){h=require("underscore");g=require("backbone");c=module.exports=g}else{h=window._;g=window.Backbone;c=window}g.Relational={showWarnings:true};g.Semaphore={_permitsAvailable:null,_permitsUsed:0,acquire:function(){if(this._permitsAvailable&&this._permitsUsed>=this._permitsAvailable){throw new Error("Max permits acquired")}else{this._permitsUsed++}},release:function(){if(this._permitsUsed===0){throw new Error("All permits released")}else{this._permitsUsed--}},isLocked:function(){return this._permitsUsed>0},setAvailablePermits:function(j){if(this._permitsUsed>j){throw new Error("Available permits cannot be less than used permits")}this._permitsAvailable=j}};g.BlockingQueue=function(){this._queue=[]};h.extend(g.BlockingQueue.prototype,g.Semaphore,{_queue:null,add:function(j){if(this.isBlocked()){this._queue.push(j)}else{j()}},process:function(){while(this._queue&&this._queue.length){this._queue.shift()()}},block:function(){this.acquire()},unblock:function(){this.release();if(!this.isBlocked()){this.process()}},isBlocked:function(){return this.isLocked()}});g.Relational.eventQueue=new g.BlockingQueue();g.Store=function(){this._collections=[];this._reverseRelations=[];this._subModels=[];this._modelScopes=[c]};h.extend(g.Store.prototype,g.Events,{addModelScope:function(j){this._modelScopes.push(j)},addSubModels:function(j,k){this._subModels.push({superModelType:k,subModels:j})},setupSuperModel:function(j){h.find(this._subModels,function(k){return h.find(k.subModels,function(m,n){var l=this.getObjectByName(m);if(j===l){k.superModelType._subModels[n]=j;j._superModel=k.superModelType;j._subModelTypeValue=n;j._subModelTypeAttribute=k.superModelType.prototype.subModelTypeAttribute;return true}},this)},this)},addReverseRelation:function(l){var k=h.any(this._reverseRelations,function(m){return h.all(l,function(o,n){return o===m[n]})});if(!k&&l.model&&l.type){this._reverseRelations.push(l);var j=function(m,n){if(!m.prototype.relations){m.prototype.relations=[]}m.prototype.relations.push(n);h.each(m._subModels,function(o){j(o,n)},this)};j(l.model,l);this.retroFitRelation(l)}},retroFitRelation:function(k){var j=this.getCollection(k.model);j.each(function(l){if(!(l instanceof k.model)){return}new k.type(l,k)},this)},getCollection:function(k){if(k instanceof g.RelationalModel){k=k.constructor}var j=k;while(j._superModel){j=j._superModel}var l=h.detect(this._collections,function(m){return m.model===j});if(!l){l=this._createCollection(k)}return l},getObjectByName:function(j){var l=j.split("."),k=null;h.find(this._modelScopes,function(m){k=h.reduce(l,function(n,o){return n[o]},m);if(k&&k!==m){return true}},this);return k},_createCollection:function(k){var j;if(k instanceof g.RelationalModel){k=k.constructor}if(k.prototype instanceof g.RelationalModel){j=new g.Collection();j.model=k;this._collections.push(j)}return j},resolveIdForItem:function(j,k){var l=h.isString(k)||h.isNumber(k)?k:null;if(l==null){if(k instanceof g.RelationalModel){l=k.id}else{if(h.isObject(k)){l=k[j.prototype.idAttribute]}}}return l},find:function(k,l){var n=this.resolveIdForItem(k,l);var j=this.getCollection(k);if(j){var m=j.get(n);if(m instanceof k){return m}}return null},register:function(k){var j=k.collection;var l=this.getCollection(k);l&&l.add(k);k.bind("destroy",this.unregister,this);k.collection=j},update:function(j){var k=this.getCollection(j);k._onModelEvent("change:"+j.idAttribute,j,k)},unregister:function(j){j.unbind("destroy",this.unregister);var k=this.getCollection(j);k&&k.remove(j)}});g.Relational.store=new g.Store();g.Relation=function(j,k){this.instance=j;k=h.isObject(k)?k:{};this.reverseRelation=h.defaults(k.reverseRelation||{},this.options.reverseRelation);this.reverseRelation.type=!h.isString(this.reverseRelation.type)?this.reverseRelation.type:g[this.reverseRelation.type]||g.Relational.store.getObjectByName(this.reverseRelation.type);this.model=k.model||this.instance.constructor;this.options=h.defaults(k,this.options,g.Relation.prototype.options);this.key=this.options.key;this.keySource=this.options.keySource||this.key;this.keyDestination=this.options.keyDestination||this.keySource||this.key;this.relatedModel=this.options.relatedModel;if(h.isString(this.relatedModel)){this.relatedModel=g.Relational.store.getObjectByName(this.relatedModel)}if(!this.checkPreconditions()){return false}if(j){this.keyContents=this.instance.get(this.keySource);if(this.key!==this.keySource){this.instance.unset(this.keySource,{silent:true})}this.instance._relations.push(this)}if(!this.options.isAutoRelation&&this.reverseRelation.type&&this.reverseRelation.key){g.Relational.store.addReverseRelation(h.defaults({isAutoRelation:true,model:this.relatedModel,relatedModel:this.model,reverseRelation:this.options},this.reverseRelation))}h.bindAll(this,"_modelRemovedFromCollection","_relatedModelAdded","_relatedModelRemoved");if(j){this.initialize();g.Relational.store.getCollection(this.instance).bind("relational:remove",this._modelRemovedFromCollection);g.Relational.store.getCollection(this.relatedModel).bind("relational:add",this._relatedModelAdded).bind("relational:remove",this._relatedModelRemoved)}};g.Relation.extend=g.Model.extend;h.extend(g.Relation.prototype,g.Events,g.Semaphore,{options:{createModels:true,includeInJSON:true,isAutoRelation:false},instance:null,key:null,keyContents:null,relatedModel:null,reverseRelation:null,related:null,_relatedModelAdded:function(l,m,k){var j=this;l.queue(function(){j.tryAddRelated(l,k)})},_relatedModelRemoved:function(k,l,j){this.removeRelated(k,j)},_modelRemovedFromCollection:function(j){if(j===this.instance){this.destroy()}},checkPreconditions:function(){var n=this.instance,l=this.key,j=this.model,p=this.relatedModel,q=g.Relational.showWarnings&&typeof console!=="undefined";if(!j||!l||!p){q&&console.warn("Relation=%o; no model, key or relatedModel (%o, %o, %o)",this,j,l,p);return false}if(!(j.prototype instanceof g.RelationalModel)){q&&console.warn("Relation=%o; model does not inherit from Backbone.RelationalModel (%o)",this,n);return false}if(!(p.prototype instanceof g.RelationalModel)){q&&console.warn("Relation=%o; relatedModel does not inherit from Backbone.RelationalModel (%o)",this,p);return false}if(this instanceof g.HasMany&&this.reverseRelation.type===g.HasMany){q&&console.warn("Relation=%o; relation is a HasMany, and the reverseRelation is HasMany as well.",this);return false}if(n&&n._relations.length){var o=h.any(n._relations,function(k){var m=this.reverseRelation.key&&k.reverseRelation.key;return k.relatedModel===p&&k.key===l&&(!m||this.reverseRelation.key===k.reverseRelation.key)},this);if(o){q&&console.warn("Relation=%o between instance=%o.%s and relatedModel=%o.%s already exists",this,n,l,p,this.reverseRelation.key);return false}}return true},setRelated:function(k,j){this.related=k;this.instance.acquire();this.instance.set(this.key,k,h.defaults(j||{},{silent:true}));this.instance.release()},_isReverseRelation:function(j){if(j.instance instanceof this.relatedModel&&this.reverseRelation.key===j.key&&this.key===j.reverseRelation.key){return true}return false},getReverseRelations:function(j){var k=[];var l=!h.isUndefined(j)?[j]:this.related&&(this.related.models||[this.related]);h.each(l,function(m){h.each(m.getRelations(),function(n){if(this._isReverseRelation(n)){k.push(n)}},this)},this);return k},sanitizeOptions:function(j){j=j?h.clone(j):{};if(j.silent){j.silentChange=true;delete j.silent}return j},unsanitizeOptions:function(j){j=j?h.clone(j):{};if(j.silentChange){j.silent=true;delete j.silentChange}return j},destroy:function(){g.Relational.store.getCollection(this.instance).unbind("relational:remove",this._modelRemovedFromCollection);g.Relational.store.getCollection(this.relatedModel).unbind("relational:add",this._relatedModelAdded).unbind("relational:remove",this._relatedModelRemoved);h.each(this.getReverseRelations(),function(j){j.removeRelated(this.instance)},this)}});g.HasOne=g.Relation.extend({options:{reverseRelation:{type:"HasMany"}},initialize:function(){h.bindAll(this,"onChange");this.instance.bind("relational:change:"+this.key,this.onChange);var j=this.findRelated({silent:true});this.setRelated(j);h.each(this.getReverseRelations(),function(k){k.addRelated(this.instance)},this)},findRelated:function(k){var l=this.keyContents;var j=null;if(l instanceof this.relatedModel){j=l}else{if(l){j=this.relatedModel.findOrCreate(l,{create:this.options.createModels})}}return j},onChange:function(m,j,l){if(this.isLocked()){return}this.acquire();l=this.sanitizeOptions(l);var p=h.isUndefined(l._related);var n=p?this.related:l._related;if(p){this.keyContents=j;if(j instanceof this.relatedModel){this.related=j}else{if(j){var o=this.findRelated(l);this.setRelated(o)}else{this.setRelated(null)}}}if(n&&this.related!==n){h.each(this.getReverseRelations(n),function(q){q.removeRelated(this.instance,l)},this)}h.each(this.getReverseRelations(),function(q){q.addRelated(this.instance,l)},this);if(!l.silentChange&&this.related!==n){var k=this;g.Relational.eventQueue.add(function(){k.instance.trigger("update:"+k.key,k.instance,k.related,l)})}this.release()},tryAddRelated:function(k,j){if(this.related){return}j=this.sanitizeOptions(j);var l=this.keyContents;if(l){var m=g.Relational.store.resolveIdForItem(this.relatedModel,l);if(k.id===m){this.addRelated(k,j)}}},addRelated:function(k,j){if(k!==this.related){var l=this.related||null;this.setRelated(k);this.onChange(this.instance,k,{_related:l})}},removeRelated:function(k,j){if(!this.related){return}if(k===this.related){var l=this.related||null;this.setRelated(null);this.onChange(this.instance,k,{_related:l})}}});g.HasMany=g.Relation.extend({collectionType:null,options:{reverseRelation:{type:"HasOne"},collectionType:g.Collection,collectionKey:true,collectionOptions:{}},initialize:function(){h.bindAll(this,"onChange","handleAddition","handleRemoval","handleReset");this.instance.bind("relational:change:"+this.key,this.onChange);this.collectionType=this.options.collectionType;if(h.isString(this.collectionType)){this.collectionType=g.Relational.store.getObjectByName(this.collectionType)}if(!this.collectionType.prototype instanceof g.Collection){throw new Error("collectionType must inherit from Backbone.Collection")}if(this.keyContents instanceof g.Collection){this.setRelated(this._prepareCollection(this.keyContents))}else{this.setRelated(this._prepareCollection())}this.findRelated({silent:true})},_getCollectionOptions:function(){return h.isFunction(this.options.collectionOptions)?this.options.collectionOptions(this.instance):this.options.collectionOptions},_prepareCollection:function(k){if(this.related){this.related.unbind("relational:add",this.handleAddition).unbind("relational:remove",this.handleRemoval).unbind("relational:reset",this.handleReset)}if(!k||!(k instanceof g.Collection)){k=new this.collectionType([],this._getCollectionOptions())}k.model=this.relatedModel;if(this.options.collectionKey){var j=this.options.collectionKey===true?this.options.reverseRelation.key:this.options.collectionKey;if(k[j]&&k[j]!==this.instance){if(g.Relational.showWarnings&&typeof console!=="undefined"){console.warn("Relation=%o; collectionKey=%s already exists on collection=%o",this,j,this.options.collectionKey)}}else{if(j){k[j]=this.instance}}}k.bind("relational:add",this.handleAddition).bind("relational:remove",this.handleRemoval).bind("relational:reset",this.handleReset);return k},findRelated:function(j){if(this.keyContents){var k=[];if(this.keyContents instanceof g.Collection){k=this.keyContents.models}else{this.keyContents=h.isArray(this.keyContents)?this.keyContents:[this.keyContents];h.each(this.keyContents,function(m){var l=null;if(m instanceof this.relatedModel){l=m}else{l=this.relatedModel.findOrCreate(m,{create:this.options.createModels})}if(l&&!this.related.getByCid(l)&&!this.related.get(l)){k.push(l)}},this)}if(k.length){j=this.unsanitizeOptions(j);this.related.add(k,j)}}},onChange:function(m,j,l){l=this.sanitizeOptions(l);this.keyContents=j;h.each(this.getReverseRelations(),function(o){o.removeRelated(this.instance,l)},this);if(j instanceof g.Collection){this._prepareCollection(j);this.related=j}else{var n;if(this.related instanceof g.Collection){n=this.related;n.remove(n.models)}else{n=this._prepareCollection()}this.setRelated(n);this.findRelated(l)}h.each(this.getReverseRelations(),function(o){o.addRelated(this.instance,l)},this);var k=this;g.Relational.eventQueue.add(function(){!l.silentChange&&k.instance.trigger("update:"+k.key,k.instance,k.related,l)})},tryAddRelated:function(k,j){j=this.sanitizeOptions(j);if(!this.related.getByCid(k)&&!this.related.get(k)){var l=h.any(this.keyContents,function(m){var n=g.Relational.store.resolveIdForItem(this.relatedModel,m);return n&&n===k.id},this);if(l){this.related.add(k,j)}}},handleAddition:function(l,m,k){if(!(l instanceof g.Model)){return}k=this.sanitizeOptions(k);h.each(this.getReverseRelations(l),function(n){n.addRelated(this.instance,k)},this);var j=this;g.Relational.eventQueue.add(function(){!k.silentChange&&j.instance.trigger("add:"+j.key,l,j.related,k)})},handleRemoval:function(l,m,k){if(!(l instanceof g.Model)){return}k=this.sanitizeOptions(k);h.each(this.getReverseRelations(l),function(n){n.removeRelated(this.instance,k)},this);var j=this;g.Relational.eventQueue.add(function(){!k.silentChange&&j.instance.trigger("remove:"+j.key,l,j.related,k)})},handleReset:function(l,k){k=this.sanitizeOptions(k);var j=this;g.Relational.eventQueue.add(function(){!k.silentChange&&j.instance.trigger("reset:"+j.key,j.related,k)})},addRelated:function(l,k){var j=this;k=this.unsanitizeOptions(k);l.queue(function(){if(j.related&&!j.related.getByCid(l)&&!j.related.get(l)){j.related.add(l,k)}})},removeRelated:function(k,j){j=this.unsanitizeOptions(j);if(this.related.getByCid(k)||this.related.get(k)){this.related.remove(k,j)}}});g.RelationalModel=g.Model.extend({relations:null,_relations:null,_isInitialized:false,_deferProcessing:false,_queue:null,subModelTypeAttribute:"type",subModelTypes:null,constructor:function(k,l){var j=this;if(l&&l.collection){this._deferProcessing=true;var m=function(n){if(n===j){j._deferProcessing=false;j.processQueue();l.collection.unbind("relational:add",m)}};l.collection.bind("relational:add",m);h.defer(function(){m(j)})}this._queue=new g.BlockingQueue();this._queue.block();g.Relational.eventQueue.block();g.Model.apply(this,arguments);g.Relational.eventQueue.unblock()},trigger:function(k){if(k.length>5&&"change"===k.substr(0,6)){var j=this,l=arguments;g.Relational.eventQueue.add(function(){g.Model.prototype.trigger.apply(j,l)})}else{g.Model.prototype.trigger.apply(this,arguments)}return this},initializeRelations:function(){this.acquire();this._relations=[];h.each(this.relations,function(j){var k=!h.isString(j.type)?j.type:g[j.type]||g.Relational.store.getObjectByName(j.type);if(k&&k.prototype instanceof g.Relation){new k(this,j)}else{g.Relational.showWarnings&&typeof console!=="undefined"&&console.warn("Relation=%o; missing or invalid type!",j)}},this);this._isInitialized=true;this.release();this.processQueue()},updateRelations:function(j){if(this._isInitialized&&!this.isLocked()){h.each(this._relations,function(k){var l=this.attributes[k.keySource]||this.attributes[k.key];if(k.related!==l){this.trigger("relational:change:"+k.key,this,l,j||{})}},this)}},queue:function(j){this._queue.add(j)},processQueue:function(){if(this._isInitialized&&!this._deferProcessing&&this._queue.isBlocked()){this._queue.unblock()}},getRelation:function(j){return h.detect(this._relations,function(k){if(k.key===j){return true}},this)},getRelations:function(){return this._relations},fetchRelated:function(p,r,n){r||(r={});var m,k=[],q=this.getRelation(p),s=q&&q.keyContents,o=s&&h.select(h.isArray(s)?s:[s],function(t){var u=g.Relational.store.resolveIdForItem(q.relatedModel,t);return u&&(n||!g.Relational.store.find(q.relatedModel,u))},this);if(o&&o.length){var l=h.map(o,function(v){var u;if(h.isObject(v)){u=q.relatedModel.build(v)}else{var t={};t[q.relatedModel.prototype.idAttribute]=v;u=q.relatedModel.build(t)}return u},this);if(q.related instanceof g.Collection&&h.isFunction(q.related.url)){m=q.related.url(l)}if(m&&m!==q.related.url()){var j=h.defaults({error:function(){var t=arguments;h.each(l,function(u){u.trigger("destroy",u,u.collection,r);r.error&&r.error.apply(u,t)})},url:m},r,{add:true});k=[q.related.fetch(j)]}else{k=h.map(l,function(t){var u=h.defaults({error:function(){t.trigger("destroy",t,t.collection,r);r.error&&r.error.apply(t,arguments)}},r);return t.fetch(u)},this)}}return k},set:function(m,n,l){g.Relational.eventQueue.block();var k;if(h.isObject(m)||m==null){k=m;l=n}else{k={};k[m]=n}var j=g.Model.prototype.set.apply(this,arguments);if(!this._isInitialized&&!this.isLocked()){this.constructor.initializeModelHierarchy();g.Relational.store.register(this);this.initializeRelations()}else{if(k&&this.idAttribute in k){g.Relational.store.update(this)}}if(k){this.updateRelations(l)}g.Relational.eventQueue.unblock();return j},unset:function(l,k){g.Relational.eventQueue.block();var j=g.Model.prototype.unset.apply(this,arguments);this.updateRelations(k);g.Relational.eventQueue.unblock();return j},clear:function(k){g.Relational.eventQueue.block();var j=g.Model.prototype.clear.apply(this,arguments);this.updateRelations(k);g.Relational.eventQueue.unblock();return j},change:function(l){var j=this,k=arguments;g.Relational.eventQueue.add(function(){g.Model.prototype.change.apply(j,k)})},clone:function(){var j=h.clone(this.attributes);if(!h.isUndefined(j[this.idAttribute])){j[this.idAttribute]=null}h.each(this.getRelations(),function(k){delete j[k.key]});return new this.constructor(j)},toJSON:function(){if(this.isLocked()){return this.id}this.acquire();var j=g.Model.prototype.toJSON.call(this);if(this.constructor._superModel&&!(this.constructor._subModelTypeAttribute in j)){j[this.constructor._subModelTypeAttribute]=this.constructor._subModelTypeValue}h.each(this._relations,function(k){var m=j[k.key];if(k.options.includeInJSON===true){if(m&&h.isFunction(m.toJSON)){j[k.keyDestination]=m.toJSON()}else{j[k.keyDestination]=null}}else{if(h.isString(k.options.includeInJSON)){if(m instanceof g.Collection){j[k.keyDestination]=m.pluck(k.options.includeInJSON)}else{if(m instanceof g.Model){j[k.keyDestination]=m.get(k.options.includeInJSON)}else{j[k.keyDestination]=null}}}else{if(h.isArray(k.options.includeInJSON)){if(m instanceof g.Collection){var l=[];m.each(function(o){var n={};h.each(k.options.includeInJSON,function(p){n[p]=o.get(p)});l.push(n)});j[k.keyDestination]=l}else{if(m instanceof g.Model){var l={};h.each(k.options.includeInJSON,function(n){l[n]=m.get(n)});j[k.keyDestination]=l}else{j[k.keyDestination]=null}}}else{delete j[k.key]}}}if(k.keyDestination!==k.key){delete j[k.key]}});this.release();return j}},{setup:function(j){this.prototype.relations=(this.prototype.relations||[]).slice(0);this._subModels={};this._superModel=null;if(this.prototype.hasOwnProperty("subModelTypes")){g.Relational.store.addSubModels(this.prototype.subModelTypes,this)}else{this.prototype.subModelTypes=null}h.each(this.prototype.relations,function(k){if(!k.model){k.model=this}if(k.reverseRelation&&k.model===this){var m=true;if(h.isString(k.relatedModel)){var l=g.Relational.store.getObjectByName(k.relatedModel);m=l&&(l.prototype instanceof g.RelationalModel)}var n=!h.isString(k.type)?k.type:g[k.type]||g.Relational.store.getObjectByName(k.type);if(m&&n&&n.prototype instanceof g.Relation){new n(null,k)}}},this)},build:function(l,n){var m=this;this.initializeModelHierarchy();if(this._subModels&&this.prototype.subModelTypeAttribute in l){var k=l[this.prototype.subModelTypeAttribute];var j=this._subModels[k];if(j){m=j}}return new m(l,n)},initializeModelHierarchy:function(){if(h.isUndefined(this._superModel)||h.isNull(this._superModel)){g.Relational.store.setupSuperModel(this);if(this._superModel){if(this._superModel.prototype.relations){var j=h.any(this.prototype.relations,function(k){return k.model&&k.model!==this},this);if(!j){this.prototype.relations=this._superModel.prototype.relations.concat(this.prototype.relations)}}}else{this._superModel=false}}if(this.prototype.subModelTypes&&h.keys(this.prototype.subModelTypes).length!==h.keys(this._subModels).length){h.each(this.prototype.subModelTypes,function(l){var k=g.Relational.store.getObjectByName(l);k&&k.initializeModelHierarchy()})}},findOrCreate:function(j,l){var k=g.Relational.store.find(this,j);if(h.isObject(j)){if(k){k.set(j,l)}else{if(!l||(l&&l.create!==false)){k=this.build(j,l)}}}return k}});h.extend(g.RelationalModel.prototype,g.Semaphore);g.Collection.prototype.__prepareModel=g.Collection.prototype._prepareModel;g.Collection.prototype._prepareModel=function(l,k){k||(k={});if(!(l instanceof g.Model)){var j=l;k.collection=this;if(typeof this.model.build!=="undefined"){l=this.model.build(j,k)}else{l=new this.model(j,k)}if(!l._validate(l.attributes,k)){l=false}}else{if(!l.collection){l.collection=this}}return l};var i=g.Collection.prototype.__add=g.Collection.prototype.add;g.Collection.prototype.add=function(l,j){j||(j={});if(!h.isArray(l)){l=[l]}var k=[];h.each(l,function(n){if(!(n instanceof g.Model)){var m=g.Relational.store.find(this.model,n[this.model.prototype.idAttribute]);if(m){m.set(m.parse?m.parse(n):n,j);n=m}else{n=g.Collection.prototype._prepareModel.call(this,n,j)}}if(n instanceof g.Model&&!this.get(n)&&!this.getByCid(n)){k.push(n)}},this);if(k.length){i.call(this,k,j);h.each(k,function(m){this.trigger("relational:add",m,this,j)},this)}return this};var e=g.Collection.prototype.__remove=g.Collection.prototype.remove;g.Collection.prototype.remove=function(k,j){j||(j={});if(!h.isArray(k)){k=[k]}else{k=k.slice(0)}h.each(k,function(l){l=this.getByCid(l)||this.get(l);if(l instanceof g.Model){e.call(this,l,j);this.trigger("relational:remove",l,this,j)}},this);return this};var f=g.Collection.prototype.__reset=g.Collection.prototype.reset;g.Collection.prototype.reset=function(k,j){f.call(this,k,j);this.trigger("relational:reset",this,j);return this};var d=g.Collection.prototype.__sort=g.Collection.prototype.sort;g.Collection.prototype.sort=function(j){d.call(this,j);this.trigger("relational:reset",this,j);return this};var a=g.Collection.prototype.__trigger=g.Collection.prototype.trigger;g.Collection.prototype.trigger=function(k){if(k==="add"||k==="remove"||k==="reset"){var j=this,l=arguments;g.Relational.eventQueue.add(function(){a.apply(j,l)})}else{a.apply(this,arguments)}return this};g.RelationalModel.extend=function(j,k){var l=g.Model.extend.apply(this,arguments);l.setup(this);return l}})();
\ No newline at end of file
+(function(b){var h,g,c;if(typeof window==="undefined"){h=require("underscore");g=require("backbone");c=module.exports=g}else{h=window._;g=window.Backbone;c=window}g.Relational={showWarnings:true};g.Semaphore={_permitsAvailable:null,_permitsUsed:0,acquire:function(){if(this._permitsAvailable&&this._permitsUsed>=this._permitsAvailable){throw new Error("Max permits acquired")}else{this._permitsUsed++}},release:function(){if(this._permitsUsed===0){throw new Error("All permits released")}else{this._permitsUsed--}},isLocked:function(){return this._permitsUsed>0},setAvailablePermits:function(j){if(this._permitsUsed>j){throw new Error("Available permits cannot be less than used permits")}this._permitsAvailable=j}};g.BlockingQueue=function(){this._queue=[]};h.extend(g.BlockingQueue.prototype,g.Semaphore,{_queue:null,add:function(j){if(this.isBlocked()){this._queue.push(j)}else{j()}},process:function(){while(this._queue&&this._queue.length){this._queue.shift()()}},block:function(){this.acquire()},unblock:function(){this.release();if(!this.isBlocked()){this.process()}},isBlocked:function(){return this.isLocked()}});g.Relational.eventQueue=new g.BlockingQueue();g.Store=function(){this._collections=[];this._reverseRelations=[];this._orphanRelations=[];this._subModels=[];this._modelScopes=[c]};h.extend(g.Store.prototype,g.Events,{initializeRelation:function(k,m,j){var l=!h.isString(m.type)?m.type:g[m.type]||this.getObjectByName(m.type);if(l&&l.prototype instanceof g.Relation){new l(k,m,j)}else{g.Relational.showWarnings&&typeof console!=="undefined"&&console.warn("Relation=%o; missing or invalid relation type!",m)}},addModelScope:function(j){this._modelScopes.push(j)},addSubModels:function(j,k){this._subModels.push({superModelType:k,subModels:j})},setupSuperModel:function(j){h.find(this._subModels,function(k){return h.find(k.subModels||[],function(m,n){var l=this.getObjectByName(m);if(j===l){k.superModelType._subModels[n]=j;j._superModel=k.superModelType;j._subModelTypeValue=n;j._subModelTypeAttribute=k.superModelType.prototype.subModelTypeAttribute;return true}},this)},this)},addReverseRelation:function(k){var j=h.any(this._reverseRelations,function(l){return h.all(k||[],function(n,m){return n===l[m]})});if(!j&&k.model&&k.type){this._reverseRelations.push(k);this._addRelation(k.model,k);this.retroFitRelation(k)}},addOrphanRelation:function(k){var j=h.any(this._orphanRelations,function(l){return h.all(k||[],function(n,m){return n===l[m]})});if(!j&&k.model&&k.type){this._orphanRelations.push(k)}},processOrphanRelations:function(){h.each(this._orphanRelations.slice(0),function(j){var k=g.Relational.store.getObjectByName(j.relatedModel);if(k){this.initializeRelation(null,j);this._orphanRelations=h.without(this._orphanRelations,j)}},this)},_addRelation:function(j,k){if(!j.prototype.relations){j.prototype.relations=[]}j.prototype.relations.push(k);h.each(j._subModels||[],function(l){this._addRelation(l,k)},this)},retroFitRelation:function(k){var j=this.getCollection(k.model,false);j&&j.each(function(l){if(!(l instanceof k.model)){return}new k.type(l,k)},this)},getCollection:function(m,l){if(m instanceof g.RelationalModel){m=m.constructor}var j=m;while(j._superModel){j=j._superModel}var k=h.findWhere(this._collections,{model:j});if(!k&&l!==false){k=this._createCollection(j)}return k},getObjectByName:function(j){var l=j.split("."),k=null;h.find(this._modelScopes,function(m){k=h.reduce(l||[],function(n,o){return n?n[o]:b},m);if(k&&k!==m){return true}},this);return k},_createCollection:function(k){var j;if(k instanceof g.RelationalModel){k=k.constructor}if(k.prototype instanceof g.RelationalModel){j=new g.Collection();j.model=k;this._collections.push(j)}return j},resolveIdForItem:function(j,k){var l=h.isString(k)||h.isNumber(k)?k:null;if(l===null){if(k instanceof g.RelationalModel){l=k.id}else{if(h.isObject(k)){l=k[j.prototype.idAttribute]}}}if(!l&&l!==0){l=null}return l},find:function(k,l){var n=this.resolveIdForItem(k,l);var j=this.getCollection(k);if(j){var m=j.get(n);if(m instanceof k){return m}}return null},register:function(k){var l=this.getCollection(k);if(l){if(l.get(k)){if(g.Relational.showWarnings&&typeof console!=="undefined"){console.warn("Duplicate id! Old RelationalModel=%o, new RelationalModel=%o",l.get(k),k)}throw new Error("Cannot instantiate more than one Backbone.RelationalModel with the same id per type!")}var j=k.collection;l.add(k);this.listenTo(k,"destroy",this.unregister,this);k.collection=j}},update:function(j){var k=this.getCollection(j);k._onModelEvent("change:"+j.idAttribute,j,k)},unregister:function(j){this.stopListening(j,"destroy",this.unregister);var k=this.getCollection(j);k&&k.remove(j)},reset:function(){this.stopListening();this._collections=[];this._subModels=[];this._modelScopes=[c]}});g.Relational.store=new g.Store();g.Relation=function(j,k,l){this.instance=j;k=h.isObject(k)?k:{};this.reverseRelation=h.defaults(k.reverseRelation||{},this.options.reverseRelation);this.options=h.defaults(k,this.options,g.Relation.prototype.options);this.reverseRelation.type=!h.isString(this.reverseRelation.type)?this.reverseRelation.type:g[this.reverseRelation.type]||g.Relational.store.getObjectByName(this.reverseRelation.type);this.key=this.options.key;this.keySource=this.options.keySource||this.key;this.keyDestination=this.options.keyDestination||this.keySource||this.key;this.model=this.options.model||this.instance.constructor;this.relatedModel=this.options.relatedModel;if(h.isString(this.relatedModel)){this.relatedModel=g.Relational.store.getObjectByName(this.relatedModel)}if(!this.checkPreconditions()){return}if(!this.options.isAutoRelation&&this.reverseRelation.type&&this.reverseRelation.key){g.Relational.store.addReverseRelation(h.defaults({isAutoRelation:true,model:this.relatedModel,relatedModel:this.model,reverseRelation:this.options},this.reverseRelation))}if(j){var m=this.keySource;if(m!==this.key&&typeof this.instance.get(this.key)==="object"){m=this.key}this.setKeyContents(this.instance.get(m));this.relatedCollection=g.Relational.store.getCollection(this.relatedModel);if(this.keySource!==this.key){this.instance.unset(this.keySource,{silent:true})}this.instance._relations[this.key]=this;this.initialize(l);if(this.options.autoFetch){this.instance.fetchRelated(this.key,h.isObject(this.options.autoFetch)?this.options.autoFetch:{})}this.listenTo(this.instance,"destroy",this.destroy).listenTo(this.relatedCollection,"relational:add",this.tryAddRelated).listenTo(this.relatedCollection,"relational:remove",this.removeRelated)}};g.Relation.extend=g.Model.extend;h.extend(g.Relation.prototype,g.Events,g.Semaphore,{options:{createModels:true,includeInJSON:true,isAutoRelation:false,autoFetch:false,parse:false},instance:null,key:null,keyContents:null,relatedModel:null,relatedCollection:null,reverseRelation:null,related:null,checkPreconditions:function(){var n=this.instance,l=this.key,j=this.model,p=this.relatedModel,q=g.Relational.showWarnings&&typeof console!=="undefined";if(!j||!l||!p){q&&console.warn("Relation=%o: missing model, key or relatedModel (%o, %o, %o).",this,j,l,p);return false}if(!(j.prototype instanceof g.RelationalModel)){q&&console.warn("Relation=%o: model does not inherit from Backbone.RelationalModel (%o).",this,n);return false}if(!(p.prototype instanceof g.RelationalModel)){q&&console.warn("Relation=%o: relatedModel does not inherit from Backbone.RelationalModel (%o).",this,p);return false}if(this instanceof g.HasMany&&this.reverseRelation.type===g.HasMany){q&&console.warn("Relation=%o: relation is a HasMany, and the reverseRelation is HasMany as well.",this);return false}if(n&&h.keys(n._relations).length){var o=h.find(n._relations,function(k){return k.key===l},this);if(o){q&&console.warn("Cannot create relation=%o on %o for model=%o: already taken by relation=%o.",this,l,n,o);return false}}return true},setRelated:function(j){this.related=j;this.instance.acquire();this.instance.attributes[this.key]=j;this.instance.release()},_isReverseRelation:function(j){return j.instance instanceof this.relatedModel&&this.reverseRelation.key===j.key&&this.key===j.reverseRelation.key},getReverseRelations:function(j){var k=[];var l=!h.isUndefined(j)?[j]:this.related&&(this.related.models||[this.related]);h.each(l||[],function(m){h.each(m.getRelations()||[],function(n){if(this._isReverseRelation(n)){k.push(n)}},this)},this);return k},destroy:function(){this.stopListening();if(this instanceof g.HasOne){this.setRelated(null)}else{if(this instanceof g.HasMany){this.setRelated(this._prepareCollection())}}h.each(this.getReverseRelations(),function(j){j.removeRelated(this.instance)},this)}});g.HasOne=g.Relation.extend({options:{reverseRelation:{type:"HasMany"}},initialize:function(j){this.listenTo(this.instance,"relational:change:"+this.key,this.onChange);var k=this.findRelated(j);this.setRelated(k);h.each(this.getReverseRelations(),function(l){l.addRelated(this.instance,j)},this)},findRelated:function(j){var l=null;j=h.defaults({parse:this.options.parse},j);if(this.keyContents instanceof this.relatedModel){l=this.keyContents}else{if(this.keyContents||this.keyContents===0){var k=h.defaults({create:this.options.createModels},j);l=this.relatedModel.findOrCreate(this.keyContents,k)}}return l},setKeyContents:function(j){this.keyContents=j;this.keyId=g.Relational.store.resolveIdForItem(this.relatedModel,this.keyContents)},onChange:function(m,j,l){if(this.isLocked()){return}this.acquire();l=l?h.clone(l):{};var p=h.isUndefined(l.__related),n=p?this.related:l.__related;if(p){this.setKeyContents(j);var o=this.findRelated(l);this.setRelated(o)}if(n&&this.related!==n){h.each(this.getReverseRelations(n),function(q){q.removeRelated(this.instance,null,l)},this)}h.each(this.getReverseRelations(),function(q){q.addRelated(this.instance,l)},this);if(!l.silent&&this.related!==n){var k=this;this.changed=true;g.Relational.eventQueue.add(function(){k.instance.trigger("change:"+k.key,k.instance,k.related,l,true);k.changed=false})}this.release()},tryAddRelated:function(k,l,j){if((this.keyId||this.keyId===0)&&k.id===this.keyId){this.addRelated(k,j);this.keyId=null}},addRelated:function(l,k){var j=this;l.queue(function(){if(l!==j.related){var m=j.related||null;j.setRelated(l);j.onChange(j.instance,l,h.defaults({__related:m},k))}})},removeRelated:function(k,l,j){if(!this.related){return}if(k===this.related){var m=this.related||null;this.setRelated(null);this.onChange(this.instance,k,h.defaults({__related:m},j))}}});g.HasMany=g.Relation.extend({collectionType:null,options:{reverseRelation:{type:"HasOne"},collectionType:g.Collection,collectionKey:true,collectionOptions:{}},initialize:function(j){this.listenTo(this.instance,"relational:change:"+this.key,this.onChange);this.collectionType=this.options.collectionType;if(h.isString(this.collectionType)){this.collectionType=g.Relational.store.getObjectByName(this.collectionType)}if(!this.collectionType.prototype instanceof g.Collection){throw new Error("`collectionType` must inherit from Backbone.Collection")}var k=this.findRelated(j);this.setRelated(k)},_prepareCollection:function(l){if(this.related){this.stopListening(this.related)}if(!l||!(l instanceof g.Collection)){var j=h.isFunction(this.options.collectionOptions)?this.options.collectionOptions(this.instance):this.options.collectionOptions;l=new this.collectionType(null,j)}l.model=this.relatedModel;if(this.options.collectionKey){var k=this.options.collectionKey===true?this.options.reverseRelation.key:this.options.collectionKey;if(l[k]&&l[k]!==this.instance){if(g.Relational.showWarnings&&typeof console!=="undefined"){console.warn("Relation=%o; collectionKey=%s already exists on collection=%o",this,k,this.options.collectionKey)}}else{if(k){l[k]=this.instance}}}this.listenTo(l,"relational:add",this.handleAddition).listenTo(l,"relational:remove",this.handleRemoval).listenTo(l,"relational:reset",this.handleReset);return l},findRelated:function(j){var l=null;j=h.defaults({parse:this.options.parse},j);if(this.keyContents instanceof g.Collection){this._prepareCollection(this.keyContents);l=this.keyContents}else{var k=[];h.each(this.keyContents,function(m){if(m instanceof this.relatedModel){var n=m}else{n=this.relatedModel.findOrCreate(m,h.extend({merge:true},j,{create:this.options.createModels}))}n&&k.push(n)},this);if(this.related instanceof g.Collection){l=this.related}else{l=this._prepareCollection()}l.update(k,h.defaults({merge:false,parse:false},j))}return l},setKeyContents:function(j){this.keyContents=j instanceof g.Collection?j:null;this.keyIds=[];if(!this.keyContents&&(j||j===0)){this.keyContents=h.isArray(j)?j:[j];h.each(this.keyContents,function(k){var l=g.Relational.store.resolveIdForItem(this.relatedModel,k);if(l||l===0){this.keyIds.push(l)}},this)}},onChange:function(m,j,l){l=l?h.clone(l):{};this.setKeyContents(j);this.changed=false;var n=this.findRelated(l);this.setRelated(n);if(!l.silent){var k=this;g.Relational.eventQueue.add(function(){if(k.changed){k.instance.trigger("change:"+k.key,k.instance,k.related,l,true);k.changed=false}})}},handleAddition:function(l,m,k){k=k?h.clone(k):{};this.changed=true;h.each(this.getReverseRelations(l),function(n){n.addRelated(this.instance,k)},this);var j=this;!k.silent&&g.Relational.eventQueue.add(function(){j.instance.trigger("add:"+j.key,l,j.related,k)})},handleRemoval:function(l,m,k){k=k?h.clone(k):{};this.changed=true;h.each(this.getReverseRelations(l),function(n){n.removeRelated(this.instance,null,k)},this);var j=this;!k.silent&&g.Relational.eventQueue.add(function(){j.instance.trigger("remove:"+j.key,l,j.related,k)})},handleReset:function(l,k){var j=this;k=k?h.clone(k):{};!k.silent&&g.Relational.eventQueue.add(function(){j.instance.trigger("reset:"+j.key,j.related,k)})},tryAddRelated:function(k,l,j){var m=h.contains(this.keyIds,k.id);if(m){this.addRelated(k,j);this.keyIds=h.without(this.keyIds,k.id)}},addRelated:function(l,k){var j=this;l.queue(function(){if(j.related&&!j.related.get(l)){j.related.add(l,k)}})},removeRelated:function(k,l,j){if(this.related.get(k)){this.related.remove(k,j)}}});g.RelationalModel=g.Model.extend({relations:null,_relations:null,_isInitialized:false,_deferProcessing:false,_queue:null,subModelTypeAttribute:"type",subModelTypes:null,constructor:function(k,l){if(l&&l.collection){var j=this,n=this.collection=l.collection;delete l.collection;this._deferProcessing=true;var m=function(o){if(o===j){j._deferProcessing=false;j.processQueue();n.off("relational:add",m)}};n.on("relational:add",m);h.defer(function(){m(j)})}g.Relational.store.processOrphanRelations();this._queue=new g.BlockingQueue();this._queue.block();g.Relational.eventQueue.block();try{g.Model.apply(this,arguments)}finally{g.Relational.eventQueue.unblock()}},trigger:function(k){if(k.length>5&&k.indexOf("change")===0){var j=this,l=arguments;g.Relational.eventQueue.add(function(){if(!j._isInitialized){return}var o=true;if(k==="change"){o=j.hasChanged()}else{var n=k.slice(7),m=j.getRelation(n);if(m){o=(l[4]===true);if(o){j.changed[n]=l[2]}else{if(!m.changed){delete j.changed[n]}}}}o&&g.Model.prototype.trigger.apply(j,l)})}else{g.Model.prototype.trigger.apply(this,arguments)}return this},initializeRelations:function(j){this.acquire();this._relations={};h.each(this.relations||[],function(k){g.Relational.store.initializeRelation(this,k,j)},this);this._isInitialized=true;this.release();this.processQueue()},updateRelations:function(j){if(this._isInitialized&&!this.isLocked()){h.each(this._relations,function(k){var l=this.attributes[k.keySource]||this.attributes[k.key];if(k.related!==l){this.trigger("relational:change:"+k.key,this,l,j||{})}},this)}},queue:function(j){this._queue.add(j)},processQueue:function(){if(this._isInitialized&&!this._deferProcessing&&this._queue.isBlocked()){this._queue.unblock()}},getRelation:function(j){return this._relations[j]},getRelations:function(){return h.values(this._relations)},fetchRelated:function(q,t,o){t=h.extend({update:true,remove:false},t);var n,k=[],s=this.getRelation(q),r=s&&(s.keyIds||[s.keyId]),p=r&&h.select(r||[],function(u){return(u||u===0)&&(o||!g.Relational.store.find(s.relatedModel,u))},this);if(p&&p.length){var m=[],l=h.map(p,function(w){var v=g.Relational.store.find(s.relatedModel,w);if(!v){var u={};u[s.relatedModel.prototype.idAttribute]=w;v=s.relatedModel.findOrCreate(u,t);m.push(v)}return v},this);if(s.related instanceof g.Collection&&h.isFunction(s.related.url)){n=s.related.url(l)}if(n&&n!==s.related.url()){var j=h.defaults({error:function(){var u=arguments;h.each(m,function(v){v.trigger("destroy",v,v.collection,t);t.error&&t.error.apply(v,u)})},url:n},t);k=[s.related.fetch(j)]}else{k=h.map(l,function(u){var v=h.defaults({error:function(){if(h.contains(m,u)){u.trigger("destroy",u,u.collection,t);t.error&&t.error.apply(u,arguments)}}},t);return u.fetch(v)},this)}}return k},get:function(k){var l=g.Model.prototype.get.call(this,k);if(!this.dotNotation||k.indexOf(".")===-1){return l}var m=k.split(".");var j=h.reduce(m,function(n,o){if(!(n instanceof g.Model)){throw new Error("Attribute must be an instanceof Backbone.Model. Is: "+n+", currentSplit: "+o)}return g.Model.prototype.get.call(n,o)},this);if(l!==b&&j!==b){throw new Error("Ambiguous result for '"+k+"'. direct result: "+l+", dotNotation: "+j)}return l||j},set:function(m,n,l){g.Relational.eventQueue.block();var k;if(h.isObject(m)||m==null){k=m;l=n}else{k={};k[m]=n}var j=g.Model.prototype.set.apply(this,arguments);try{if(!this._isInitialized&&!this.isLocked()){this.constructor.initializeModelHierarchy();g.Relational.store.register(this);this.initializeRelations(l)}else{if(k&&this.idAttribute in k){g.Relational.store.update(this)}}if(k){this.updateRelations(l)}}finally{g.Relational.eventQueue.unblock()}return j},unset:function(l,k){g.Relational.eventQueue.block();var j=g.Model.prototype.unset.apply(this,arguments);this.updateRelations(k);g.Relational.eventQueue.unblock();return j},clear:function(k){g.Relational.eventQueue.block();var j=g.Model.prototype.clear.apply(this,arguments);this.updateRelations(k);g.Relational.eventQueue.unblock();return j},clone:function(){var j=h.clone(this.attributes);if(!h.isUndefined(j[this.idAttribute])){j[this.idAttribute]=null}h.each(this.getRelations(),function(k){delete j[k.key]});return new this.constructor(j)},toJSON:function(j){if(this.isLocked()){return this.id}this.acquire();var k=g.Model.prototype.toJSON.call(this,j);if(this.constructor._superModel&&!(this.constructor._subModelTypeAttribute in k)){k[this.constructor._subModelTypeAttribute]=this.constructor._subModelTypeValue}h.each(this._relations,function(l){var n=k[l.key];if(l.options.includeInJSON===true){if(n&&h.isFunction(n.toJSON)){k[l.keyDestination]=n.toJSON(j)}else{k[l.keyDestination]=null}}else{if(h.isString(l.options.includeInJSON)){if(n instanceof g.Collection){k[l.keyDestination]=n.pluck(l.options.includeInJSON)}else{if(n instanceof g.Model){k[l.keyDestination]=n.get(l.options.includeInJSON)}else{k[l.keyDestination]=null}}}else{if(h.isArray(l.options.includeInJSON)){if(n instanceof g.Collection){var m=[];n.each(function(p){var o={};h.each(l.options.includeInJSON,function(q){o[q]=p.get(q)});m.push(o)});k[l.keyDestination]=m}else{if(n instanceof g.Model){var m={};h.each(l.options.includeInJSON,function(o){m[o]=n.get(o)});k[l.keyDestination]=m}else{k[l.keyDestination]=null}}}else{delete k[l.key]}}}if(l.keyDestination!==l.key){delete k[l.key]}});this.release();return k}},{setup:function(j){this.prototype.relations=(this.prototype.relations||[]).slice(0);this._subModels={};this._superModel=null;if(this.prototype.hasOwnProperty("subModelTypes")){g.Relational.store.addSubModels(this.prototype.subModelTypes,this)}else{this.prototype.subModelTypes=null}h.each(this.prototype.relations||[],function(k){if(!k.model){k.model=this}if(k.reverseRelation&&k.model===this){var m=true;if(h.isString(k.relatedModel)){var l=g.Relational.store.getObjectByName(k.relatedModel);m=l&&(l.prototype instanceof g.RelationalModel)}if(m){g.Relational.store.initializeRelation(null,k)}else{if(h.isString(k.relatedModel)){g.Relational.store.addOrphanRelation(k)}}}},this);return this},build:function(l,n){var m=this;this.initializeModelHierarchy();if(this._subModels&&this.prototype.subModelTypeAttribute in l){var k=l[this.prototype.subModelTypeAttribute];var j=this._subModels[k];if(j){m=j}}return new m(l,n)},initializeModelHierarchy:function(){if(h.isUndefined(this._superModel)||h.isNull(this._superModel)){g.Relational.store.setupSuperModel(this);if(this._superModel){if(this._superModel.prototype.relations){var j=h.any(this.prototype.relations||[],function(k){return k.model&&k.model!==this},this);if(!j){this.prototype.relations=this._superModel.prototype.relations.concat(this.prototype.relations)}}}else{this._superModel=false}}if(this.prototype.subModelTypes&&h.keys(this.prototype.subModelTypes).length!==h.keys(this._subModels).length){h.each(this.prototype.subModelTypes||[],function(l){var k=g.Relational.store.getObjectByName(l);k&&k.initializeModelHierarchy()})}},findOrCreate:function(j,l){l||(l={});var m=(h.isObject(j)&&l.parse&&this.prototype.parse)?this.prototype.parse(j):j;var k=g.Relational.store.find(this,m);if(h.isObject(j)){if(k&&l.merge!==false){k.set(m,l)}else{if(!k&&l.create!==false){k=this.build(j,l)}}}return k}});h.extend(g.RelationalModel.prototype,g.Semaphore);g.Collection.prototype.__prepareModel=g.Collection.prototype._prepareModel;g.Collection.prototype._prepareModel=function(l,k){var j;if(l instanceof g.Model){if(!l.collection){l.collection=this}j=l}else{k||(k={});k.collection=this;if(typeof this.model.findOrCreate!=="undefined"){j=this.model.findOrCreate(l,k)}else{j=new this.model(l,k)}if(j&&j.isNew()&&!j._validate(l,k)){this.trigger("invalid",this,l,k);j=false}}return j};var i=g.Collection.prototype.__add=g.Collection.prototype.add;g.Collection.prototype.add=function(m,k){if(!(this.model.prototype instanceof g.RelationalModel)){return i.apply(this,arguments)}m=h.isArray(m)?m.slice():[m];k=h.extend({merge:false},k);var j=[],l=[];h.each(m,function(n){if(!(n instanceof g.Model)){n=g.Collection.prototype._prepareModel.call(this,n,k)}if(n){l.push(n);if(!(this.get(n)||this.get(n.cid))){j.push(n)}else{if(n.id!=null){this._byId[n.id]=n}}}},this);i.call(this,l,k);h.each(j,function(n){if(this.get(n)||this.get(n.cid)){this.trigger("relational:add",n,this,k)}},this);return this};var e=g.Collection.prototype.__remove=g.Collection.prototype.remove;g.Collection.prototype.remove=function(l,j){if(!(this.model.prototype instanceof g.RelationalModel)){return e.apply(this,arguments)}l=h.isArray(l)?l.slice():[l];j||(j={});var k=[];h.each(l,function(m){m=this.get(m)||this.get(m.cid);m&&k.push(m)},this);if(k.length){e.call(this,k,j);h.each(k,function(m){this.trigger("relational:remove",m,this,j)},this)}return this};var f=g.Collection.prototype.__reset=g.Collection.prototype.reset;g.Collection.prototype.reset=function(k,j){f.call(this,k,j);if(this.model.prototype instanceof g.RelationalModel){this.trigger("relational:reset",this,j)}return this};var d=g.Collection.prototype.__sort=g.Collection.prototype.sort;g.Collection.prototype.sort=function(j){d.call(this,j);if(this.model.prototype instanceof g.RelationalModel){this.trigger("relational:reset",this,j)}return this};var a=g.Collection.prototype.__trigger=g.Collection.prototype.trigger;g.Collection.prototype.trigger=function(k){if(!(this.model.prototype instanceof g.RelationalModel)){return a.apply(this,arguments)}if(k==="add"||k==="remove"||k==="reset"){var j=this,l=arguments;if(h.isObject(l[3])){l=h.toArray(l);l[3]=h.clone(l[3])}g.Relational.eventQueue.add(function(){a.apply(j,l)})}else{a.apply(this,arguments)}return this};g.RelationalModel.extend=function(j,k){var l=g.Model.extend.apply(this,arguments);l.setup(this);return l}})();
\ No newline at end of file
diff --git a/static/scripts/packed/libs/backbone/backbone.js b/static/scripts/packed/libs/backbone/backbone.js
index 5238e90fb48..d2236235fd4 100644
--- a/static/scripts/packed/libs/backbone/backbone.js
+++ b/static/scripts/packed/libs/backbone/backbone.js
@@ -1 +1 @@
-(function(){var q=this;var o=q.Backbone;var p=Array.prototype.slice;var y=Array.prototype.splice;var c;if(typeof exports!=="undefined"){c=exports}else{c=q.Backbone={}}c.VERSION="0.9.2";var A=q._;if(!A&&(typeof require!=="undefined")){A=require("underscore")}var g=q.jQuery||q.Zepto||q.ender;c.setDomLibrary=function(C){g=C};c.noConflict=function(){q.Backbone=o;return this};c.emulateHTTP=false;c.emulateJSON=false;var a=/\s+/;var n=c.Events={on:function(F,J,E){var D,H,G,C,I;if(!J){return this}F=F.split(a);D=this._callbacks||(this._callbacks={});while(H=F.shift()){I=D[H];G=I?I.tail:{};G.next=C={};G.context=E;G.callback=J;D[H]={tail:C,next:I?I.next:G}}return this},off:function(J,H,D){var C,K,E,G,F,I;if(!(K=this._callbacks)){return}if(!(J||H||D)){delete this._callbacks;return this}J=J?J.split(a):A.keys(K);while(C=J.shift()){E=K[C];delete K[C];if(!E||!(H||D)){continue}G=E.tail;while((E=E.next)!==G){F=E.callback;I=E.context;if((H&&F!==H)||(D&&I!==D)){this.on(C,F,I)}}}return this},trigger:function(F){var J,I,E,D,C,H,G;if(!(E=this._callbacks)){return this}H=E.all;F=F.split(a);G=p.call(arguments,1);while(J=F.shift()){if(I=E[J]){D=I.tail;while((I=I.next)!==D){I.callback.apply(I.context||this,G)}}if(I=H){D=I.tail;C=[J].concat(G);while((I=I.next)!==D){I.callback.apply(I.context||this,C)}}}return this}};n.bind=n.on;n.unbind=n.off;var k=c.Model=function(C,D){var E;C||(C={});if(D&&D.parse){C=this.parse(C)}if(E=d(this,"defaults")){C=A.extend({},E,C)}if(D&&D.collection){this.collection=D.collection}this.attributes={};this._escapedAttributes={};this.cid=A.uniqueId("c");this.changed={};this._silent={};this._pending={};this.set(C,{silent:true});this.changed={};this._silent={};this._pending={};this._previousAttributes=A.clone(this.attributes);this.initialize.apply(this,arguments)};A.extend(k.prototype,n,{changed:null,_silent:null,_pending:null,idAttribute:"id",initialize:function(){},toJSON:function(C){return A.clone(this.attributes)},get:function(C){return this.attributes[C]},escape:function(C){var D;if(D=this._escapedAttributes[C]){return D}var E=this.get(C);return this._escapedAttributes[C]=A.escape(E==null?"":""+E)},has:function(C){return this.get(C)!=null},set:function(J,I,L){var K,G,E;if(A.isObject(J)||J==null){K=J;L=I}else{K={};K[J]=I}L||(L={});if(!K){return this}if(K instanceof k){K=K.attributes}if(L.unset){for(G in K){K[G]=void 0}}if(!this._validate(K,L)){return false}if(this.idAttribute in K){this.id=K[this.idAttribute]}var H=L.changes={};var D=this.attributes;var C=this._escapedAttributes;var F=this._previousAttributes||{};for(G in K){E=K[G];if(!A.isEqual(D[G],E)||(L.unset&&A.has(D,G))){delete C[G];(L.silent?this._silent:H)[G]=true}L.unset?delete D[G]:D[G]=E;if(!A.isEqual(F[G],E)||(A.has(D,G)!=A.has(F,G))){this.changed[G]=E;if(!L.silent){this._pending[G]=true}}else{delete this.changed[G];delete this._pending[G]}}if(!L.silent){this.change(L)}return this},unset:function(C,D){(D||(D={})).unset=true;return this.set(C,null,D)},clear:function(C){(C||(C={})).unset=true;return this.set(A.clone(this.attributes),C)},fetch:function(D){D=D?A.clone(D):{};var C=this;var E=D.success;D.success=function(H,F,G){if(!C.set(C.parse(H,G),D)){return false}if(E){E(C,H)}};D.error=c.wrapError(D.error,C,D);return(this.sync||c.sync).call(this,"read",this,D)},save:function(H,G,L){var I,F;if(A.isObject(H)||H==null){I=H;L=G}else{I={};I[H]=G}L=L?A.clone(L):{};if(L.wait){if(!this._validate(I,L)){return false}F=A.clone(this.attributes)}var D=A.extend({},L,{silent:true});if(I&&!this.set(I,L.wait?D:L)){return false}var E=this;var J=L.success;L.success=function(P,M,O){var N=E.parse(P,O);if(L.wait){delete L.wait;N=A.extend(I||{},N)}if(!E.set(N,L)){return false}if(J){J(E,P)}else{E.trigger("sync",E,P,L)}};L.error=c.wrapError(L.error,E,L);var C=this.isNew()?"create":"update";var K=(this.sync||c.sync).call(this,C,this,L);if(L.wait){this.set(F,D)}return K},destroy:function(D){D=D?A.clone(D):{};var C=this;var G=D.success;var F=function(){C.trigger("destroy",C,C.collection,D)};if(this.isNew()){F();return false}D.success=function(H){if(D.wait){F()}if(G){G(C,H)}else{C.trigger("sync",C,H,D)}};D.error=c.wrapError(D.error,C,D);var E=(this.sync||c.sync).call(this,"delete",this,D);if(!D.wait){F()}return E},url:function(){var C=d(this,"urlRoot")||d(this.collection,"url")||t();if(this.isNew()){return C}return C+(C.charAt(C.length-1)=="/"?"":"/")+encodeURIComponent(this.id)},parse:function(D,C){return D},clone:function(){return new this.constructor(this.attributes)},isNew:function(){return this.id==null},change:function(D){D||(D={});var F=this._changing;this._changing=true;for(var C in this._silent){this._pending[C]=true}var E=A.extend({},D.changes,this._silent);this._silent={};for(var C in E){this.trigger("change:"+C,this,this.get(C),D)}if(F){return this}while(!A.isEmpty(this._pending)){this._pending={};this.trigger("change",this,D);for(var C in this.changed){if(this._pending[C]||this._silent[C]){continue}delete this.changed[C]}this._previousAttributes=A.clone(this.attributes)}this._changing=false;return this},hasChanged:function(C){if(!arguments.length){return !A.isEmpty(this.changed)}return A.has(this.changed,C)},changedAttributes:function(E){if(!E){return this.hasChanged()?A.clone(this.changed):false}var G,F=false,D=this._previousAttributes;for(var C in E){if(A.isEqual(D[C],(G=E[C]))){continue}(F||(F={}))[C]=G}return F},previous:function(C){if(!arguments.length||!this._previousAttributes){return null}return this._previousAttributes[C]},previousAttributes:function(){return A.clone(this._previousAttributes)},isValid:function(){return !this.validate(this.attributes)},_validate:function(E,D){if(D.silent||!this.validate){return true}E=A.extend({},this.attributes,E);var C=this.validate(E,D);if(!C){return true}if(D&&D.error){D.error(this,C,D)}else{this.trigger("error",this,C,D)}return false}});var B=c.Collection=function(D,C){C||(C={});if(C.model){this.model=C.model}if(C.comparator){this.comparator=C.comparator}this._reset();this.initialize.apply(this,arguments);if(D){this.reset(D,{silent:true,parse:C.parse})}};A.extend(B.prototype,n,{model:k,initialize:function(){},toJSON:function(C){return this.map(function(D){return D.toJSON(C)})},add:function(D,M){var I,K,F,J,L,E,G={},C={},H=[];M||(M={});D=A.isArray(D)?D.slice():[D];for(I=0,F=D.length;I<F;I++){if(!(J=D[I]=this._prepareModel(D[I],M))){throw new Error("Can't add an invalid model to a collection")}L=J.cid;E=J.id;if(G[L]||this._byCid[L]||((E!=null)&&(C[E]||this._byId[E]))){H.push(I);continue}G[L]=C[E]=J}I=H.length;while(I--){D.splice(H[I],1)}for(I=0,F=D.length;I<F;I++){(J=D[I]).on("all",this._onModelEvent,this);this._byCid[J.cid]=J;if(J.id!=null){this._byId[J.id]=J}}this.length+=F;K=M.at!=null?M.at:this.models.length;y.apply(this.models,[K,0].concat(D));if(this.comparator){this.sort({silent:true})}if(M.silent){return this}for(I=0,F=this.models.length;I<F;I++){if(!G[(J=this.models[I]).cid]){continue}M.index=I;J.trigger("add",J,this,M)}return this},remove:function(H,F){var G,C,E,D;F||(F={});H=A.isArray(H)?H.slice():[H];for(G=0,C=H.length;G<C;G++){D=this.getByCid(H[G])||this.get(H[G]);if(!D){continue}delete this._byId[D.id];delete this._byCid[D.cid];E=this.indexOf(D);this.models.splice(E,1);this.length--;if(!F.silent){F.index=E;D.trigger("remove",D,this,F)}this._removeReference(D)}return this},push:function(D,C){D=this._prepareModel(D,C);this.add(D,C);return D},pop:function(D){var C=this.at(this.length-1);this.remove(C,D);return C},unshift:function(D,C){D=this._prepareModel(D,C);this.add(D,A.extend({at:0},C));return D},shift:function(D){var C=this.at(0);this.remove(C,D);return C},get:function(C){if(C==null){return void 0}return this._byId[C.id!=null?C.id:C]},getByCid:function(C){return C&&this._byCid[C.cid||C]},at:function(C){return this.models[C]},where:function(C){if(A.isEmpty(C)){return[]}return this.filter(function(D){for(var E in C){if(C[E]!==D.get(E)){return false}}return true})},sort:function(D){D||(D={});if(!this.comparator){throw new Error("Cannot sort a set without a comparator")}var C=A.bind(this.comparator,this);if(this.comparator.length==1){this.models=this.sortBy(C)}else{this.models.sort(C)}if(!D.silent){this.trigger("reset",this,D)}return this},pluck:function(C){return A.map(this.models,function(D){return D.get(C)})},reset:function(F,D){F||(F=[]);D||(D={});for(var E=0,C=this.models.length;E<C;E++){this._removeReference(this.models[E])}this._reset();this.add(F,A.extend({silent:true},D));if(!D.silent){this.trigger("reset",this,D)}return this},fetch:function(C){C=C?A.clone(C):{};if(C.parse===undefined){C.parse=true}var E=this;var D=C.success;C.success=function(H,F,G){E[C.add?"add":"reset"](E.parse(H,G),C);if(D){D(E,H)}};C.error=c.wrapError(C.error,E,C);return(this.sync||c.sync).call(this,"read",this,C)},create:function(D,C){var E=this;C=C?A.clone(C):{};D=this._prepareModel(D,C);if(!D){return false}if(!C.wait){E.add(D,C)}var F=C.success;C.success=function(G,I,H){if(C.wait){E.add(G,C)}if(F){F(G,I)}else{G.trigger("sync",D,I,C)}};D.save(null,C);return D},parse:function(D,C){return D},chain:function(){return A(this.models).chain()},_reset:function(C){this.length=0;this.models=[];this._byId={};this._byCid={}},_prepareModel:function(E,D){D||(D={});if(!(E instanceof k)){var C=E;D.collection=this;E=new this.model(C,D);if(!E._validate(E.attributes,D)){E=false}}else{if(!E.collection){E.collection=this}}return E},_removeReference:function(C){if(this==C.collection){delete C.collection}C.off("all",this._onModelEvent,this)},_onModelEvent:function(E,D,F,C){if((E=="add"||E=="remove")&&F!=this){return}if(E=="destroy"){this.remove(D,C)}if(D&&E==="change:"+D.idAttribute){delete this._byId[D.previous(D.idAttribute)];this._byId[D.id]=D}this.trigger.apply(this,arguments)}});var w=["forEach","each","map","reduce","reduceRight","find","detect","filter","select","reject","every","all","some","any","include","contains","invoke","max","min","sortBy","sortedIndex","toArray","size","first","initial","rest","last","without","indexOf","shuffle","lastIndexOf","isEmpty","groupBy"];A.each(w,function(C){B.prototype[C]=function(){return A[C].apply(A,[this.models].concat(A.toArray(arguments)))}});var z=c.Router=function(C){C||(C={});if(C.routes){this.routes=C.routes}this._bindRoutes();this.initialize.apply(this,arguments)};var i=/:\w+/g;var x=/\*\w+/g;var e=/[-[\]{}()+?.,\\^$|#\s]/g;A.extend(z.prototype,n,{initialize:function(){},route:function(C,D,E){c.history||(c.history=new b);if(!A.isRegExp(C)){C=this._routeToRegExp(C)}if(!E){E=this[D]}c.history.route(C,A.bind(function(G){var F=this._extractParameters(C,G);E&&E.apply(this,F);this.trigger.apply(this,["route:"+D].concat(F));c.history.trigger("route",this,D,F)},this));return this},navigate:function(D,C){c.history.navigate(D,C)},_bindRoutes:function(){if(!this.routes){return}var D=[];for(var E in this.routes){D.unshift([E,this.routes[E]])}for(var F=0,C=D.length;F<C;F++){this.route(D[F][0],D[F][1],this[D[F][1]])}},_routeToRegExp:function(C){C=C.replace(e,"\\$&").replace(i,"([^/]+)").replace(x,"(.*?)");return new RegExp("^"+C+"$")},_extractParameters:function(C,D){return C.exec(D).slice(1)}});var b=c.History=function(){this.handlers=[];A.bindAll(this,"checkUrl")};var m=/^[#\/]/;var j=/msie [\w.]+/;b.started=false;A.extend(b.prototype,n,{interval:50,getHash:function(E){var D=E?E.location:window.location;var C=D.href.match(/#(.*)$/);return C?C[1]:""},getFragment:function(D,C){if(D==null){if(this._hasPushState||C){D=window.location.pathname;var E=window.location.search;if(E){D+=E}}else{D=this.getHash()}}if(!D.indexOf(this.options.root)){D=D.substr(this.options.root.length)}return D.replace(m,"")},start:function(E){if(b.started){throw new Error("Backbone.history has already been started")}b.started=true;this.options=A.extend({},{root:"/"},this.options,E);this._wantsHashChange=this.options.hashChange!==false;this._wantsPushState=!!this.options.pushState;this._hasPushState=!!(this.options.pushState&&window.history&&window.history.pushState);var D=this.getFragment();var C=document.documentMode;var G=(j.exec(navigator.userAgent.toLowerCase())&&(!C||C<=7));if(G){this.iframe=g('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo("body")[0].contentWindow;this.navigate(D)}if(this._hasPushState){g(window).bind("popstate",this.checkUrl)}else{if(this._wantsHashChange&&("onhashchange" in window)&&!G){g(window).bind("hashchange",this.checkUrl)}else{if(this._wantsHashChange){this._checkUrlInterval=setInterval(this.checkUrl,this.interval)}}}this.fragment=D;var H=window.location;var F=H.pathname==this.options.root;if(this._wantsHashChange&&this._wantsPushState&&!this._hasPushState&&!F){this.fragment=this.getFragment(null,true);window.location.replace(this.options.root+"#"+this.fragment);return true}else{if(this._wantsPushState&&this._hasPushState&&F&&H.hash){this.fragment=this.getHash().replace(m,"");window.history.replaceState({},document.title,H.protocol+"//"+H.host+this.options.root+this.fragment)}}if(!this.options.silent){return this.loadUrl()}},stop:function(){g(window).unbind("popstate",this.checkUrl).unbind("hashchange",this.checkUrl);clearInterval(this._checkUrlInterval);b.started=false},route:function(C,D){this.handlers.unshift({route:C,callback:D})},checkUrl:function(D){var C=this.getFragment();if(C==this.fragment&&this.iframe){C=this.getFragment(this.getHash(this.iframe))}if(C==this.fragment){return false}if(this.iframe){this.navigate(C)}this.loadUrl()||this.loadUrl(this.getHash())},loadUrl:function(E){var D=this.fragment=this.getFragment(E);var C=A.any(this.handlers,function(F){if(F.route.test(D)){F.callback(D);return true}});return C},navigate:function(D,C){if(!b.started){return false}if(!C||C===true){C={trigger:C}}var E=(D||"").replace(m,"");if(this.fragment==E){return}if(this._hasPushState){if(E.indexOf(this.options.root)!=0){E=this.options.root+E}this.fragment=E;window.history[C.replace?"replaceState":"pushState"]({},document.title,E)}else{if(this._wantsHashChange){this.fragment=E;this._updateHash(window.location,E,C.replace);if(this.iframe&&(E!=this.getFragment(this.getHash(this.iframe)))){if(!C.replace){this.iframe.document.open().close()}this._updateHash(this.iframe.location,E,C.replace)}}else{window.location.assign(this.options.root+D)}}if(C.trigger){this.loadUrl(D)}},_updateHash:function(C,D,E){if(E){C.replace(C.toString().replace(/(javascript:|#).*$/,"")+"#"+D)}else{C.hash=D}}});var s=c.View=function(C){this.cid=A.uniqueId("view");this._configure(C||{});this._ensureElement();this.initialize.apply(this,arguments);this.delegateEvents()};var f=/^(\S+)\s*(.*)$/;var u=["model","collection","el","id","attributes","className","tagName"];A.extend(s.prototype,n,{tagName:"div",$:function(C){return this.$el.find(C)},initialize:function(){},render:function(){return this},remove:function(){this.$el.remove();return this},make:function(D,C,F){var E=document.createElement(D);if(C){g(E).attr(C)}if(F){g(E).html(F)}return E},setElement:function(C,D){if(this.$el){this.undelegateEvents()}this.$el=(C instanceof g)?C:g(C);this.el=this.$el[0];if(D!==false){this.delegateEvents()}return this},delegateEvents:function(G){if(!(G||(G=d(this,"events")))){return}this.undelegateEvents();for(var F in G){var H=G[F];if(!A.isFunction(H)){H=this[G[F]]}if(!H){throw new Error('Method "'+G[F]+'" does not exist')}var E=F.match(f);var D=E[1],C=E[2];H=A.bind(H,this);D+=".delegateEvents"+this.cid;if(C===""){this.$el.bind(D,H)}else{this.$el.delegate(C,D,H)}}},undelegateEvents:function(){this.$el.unbind(".delegateEvents"+this.cid)},_configure:function(E){if(this.options){E=A.extend({},this.options,E)}for(var F=0,D=u.length;F<D;F++){var C=u[F];if(E[C]){this[C]=E[C]}}this.options=E},_ensureElement:function(){if(!this.el){var C=d(this,"attributes")||{};if(this.id){C.id=this.id}if(this.className){C["class"]=this.className}this.setElement(this.make(this.tagName,C),false)}else{this.setElement(this.el,false)}}});var v=function(C,D){var E=l(this,C,D);E.extend=this.extend;return E};k.extend=B.extend=z.extend=s.extend=v;var r={create:"POST",update:"PUT","delete":"DELETE",read:"GET"};c.sync=function(G,D,C){var E=r[G];C||(C={});var F={type:E,dataType:"json"};if(!C.url){F.url=d(D,"url")||t()}if(!C.data&&D&&(G=="create"||G=="update")){F.contentType="application/json";F.data=JSON.stringify(D.toJSON())}if(c.emulateJSON){F.contentType="application/x-www-form-urlencoded";F.data=F.data?{model:F.data}:{}}if(c.emulateHTTP){if(E==="PUT"||E==="DELETE"){if(c.emulateJSON){F.data._method=E}F.type="POST";F.beforeSend=function(H){H.setRequestHeader("X-HTTP-Method-Override",E)}}}if(F.type!=="GET"&&!c.emulateJSON){F.processData=false}return g.ajax(A.extend(F,C))};c.wrapError=function(D,E,C){return function(F,G){G=F===E?G:F;if(D){D(E,G,C)}else{E.trigger("error",E,G,C)}}};var h=function(){};var l=function(D,C,E){var F;if(C&&C.hasOwnProperty("constructor")){F=C.constructor}else{F=function(){D.apply(this,arguments)}}A.extend(F,D);h.prototype=D.prototype;F.prototype=new h();if(C){A.extend(F.prototype,C)}if(E){A.extend(F,E)}F.prototype.constructor=F;F.__super__=D.prototype;return F};var d=function(C,D){if(!(C&&C[D])){return null}return A.isFunction(C[D])?C[D]():C[D]};var t=function(){throw new Error('A "url" property or function must be specified')}}).call(this);
\ No newline at end of file
+(function(){var u=this;var B=u.Backbone;var g=[];var D=g.push;var n=g.slice;var t=g.splice;var z;if(typeof exports!=="undefined"){z=exports}else{z=u.Backbone={}}z.VERSION="1.0.0";var L=u._;if(!L&&(typeof require!=="undefined")){L=require("underscore")}z.$=u.jQuery||u.Zepto||u.ender||u.$;z.noConflict=function(){u.Backbone=B;return this};z.emulateHTTP=false;z.emulateJSON=false;var J=z.Events={on:function(M,P,O){if(!x(this,"on",M,[P,O])||!P){return this}this._events||(this._events={});var N=this._events[M]||(this._events[M]=[]);N.push({callback:P,context:O,ctx:O||this});return this},once:function(N,Q,O){if(!x(this,"once",N,[Q,O])||!Q){return this}var M=this;var P=L.once(function(){M.off(N,P);Q.apply(this,arguments)});P._callback=Q;return this.on(N,P,O)},off:function(M,V,N){var T,U,W,S,R,O,Q,P;if(!this._events||!x(this,"off",M,[V,N])){return this}if(!M&&!V&&!N){this._events={};return this}S=M?[M]:L.keys(this._events);for(R=0,O=S.length;R<O;R++){M=S[R];if(W=this._events[M]){this._events[M]=T=[];if(V||N){for(Q=0,P=W.length;Q<P;Q++){U=W[Q];if((V&&V!==U.callback&&V!==U.callback._callback)||(N&&N!==U.context)){T.push(U)}}}if(!T.length){delete this._events[M]}}}return this},trigger:function(O){if(!this._events){return this}var N=n.call(arguments,1);if(!x(this,"trigger",O,N)){return this}var P=this._events[O];var M=this._events.all;if(P){b(P,N)}if(M){b(M,arguments)}return this},stopListening:function(P,M,R){var N=this._listeners;if(!N){return this}var O=!M&&!R;if(typeof M==="object"){R=this}if(P){(N={})[P._listenerId]=P}for(var Q in N){N[Q].off(M,R,this);if(O){delete this._listeners[Q]}}return this}};var w=/\s+/;var x=function(T,R,N,Q){if(!N){return true}if(typeof N==="object"){for(var P in N){T[R].apply(T,[P,N[P]].concat(Q))}return false}if(w.test(N)){var S=N.split(w);for(var O=0,M=S.length;O<M;O++){T[R].apply(T,[S[O]].concat(Q))}return false}return true};var b=function(R,P){var S,Q=-1,O=R.length,N=P[0],M=P[1],T=P[2];switch(P.length){case 0:while(++Q<O){(S=R[Q]).callback.call(S.ctx)}return;case 1:while(++Q<O){(S=R[Q]).callback.call(S.ctx,N)}return;case 2:while(++Q<O){(S=R[Q]).callback.call(S.ctx,N,M)}return;case 3:while(++Q<O){(S=R[Q]).callback.call(S.ctx,N,M,T)}return;default:while(++Q<O){(S=R[Q]).callback.apply(S.ctx,P)}}};var C={listenTo:"on",listenToOnce:"once"};L.each(C,function(M,N){J[N]=function(Q,O,S){var P=this._listeners||(this._listeners={});var R=Q._listenerId||(Q._listenerId=L.uniqueId("l"));P[R]=Q;if(typeof O==="object"){S=this}Q[M](O,S,this);return this}});J.bind=J.on;J.unbind=J.off;L.extend(z,J);var E=z.Model=function(M,O){var P;var N=M||{};O||(O={});this.cid=L.uniqueId("c");this.attributes={};L.extend(this,L.pick(O,F));if(O.parse){N=this.parse(N,O)||{}}if(P=L.result(this,"defaults")){N=L.defaults({},N,P)}this.set(N,O);this.changed={};this.initialize.apply(this,arguments)};var F=["url","urlRoot","collection"];L.extend(E.prototype,J,{changed:null,validationError:null,idAttribute:"id",initialize:function(){},toJSON:function(M){return L.clone(this.attributes)},sync:function(){return z.sync.apply(this,arguments)},get:function(M){return this.attributes[M]},escape:function(M){return L.escape(this.get(M))},has:function(M){return this.get(M)!=null},set:function(U,M,Y){var S,V,W,T,R,X,O,Q;if(U==null){return this}if(typeof U==="object"){V=U;Y=M}else{(V={})[U]=M}Y||(Y={});if(!this._validate(V,Y)){return false}W=Y.unset;R=Y.silent;T=[];X=this._changing;this._changing=true;if(!X){this._previousAttributes=L.clone(this.attributes);this.changed={}}Q=this.attributes,O=this._previousAttributes;if(this.idAttribute in V){this.id=V[this.idAttribute]}for(S in V){M=V[S];if(!L.isEqual(Q[S],M)){T.push(S)}if(!L.isEqual(O[S],M)){this.changed[S]=M}else{delete this.changed[S]}W?delete Q[S]:Q[S]=M}if(!R){if(T.length){this._pending=true}for(var P=0,N=T.length;P<N;P++){this.trigger("change:"+T[P],this,Q[T[P]],Y)}}if(X){return this}if(!R){while(this._pending){this._pending=false;this.trigger("change",this,Y)}}this._pending=false;this._changing=false;return this},unset:function(M,N){return this.set(M,void 0,L.extend({},N,{unset:true}))},clear:function(N){var M={};for(var O in this.attributes){M[O]=void 0}return this.set(M,L.extend({},N,{unset:true}))},hasChanged:function(M){if(M==null){return !L.isEmpty(this.changed)}return L.has(this.changed,M)},changedAttributes:function(O){if(!O){return this.hasChanged()?L.clone(this.changed):false}var Q,P=false;var N=this._changing?this._previousAttributes:this.attributes;for(var M in O){if(L.isEqual(N[M],(Q=O[M]))){continue}(P||(P={}))[M]=Q}return P},previous:function(M){if(M==null||!this._previousAttributes){return null}return this._previousAttributes[M]},previousAttributes:function(){return L.clone(this._previousAttributes)},fetch:function(N){N=N?L.clone(N):{};if(N.parse===void 0){N.parse=true}var M=this;var O=N.success;N.success=function(P){if(!M.set(M.parse(P,N),N)){return false}if(O){O(M,P,N)}M.trigger("sync",M,P,N)};H(this,N);return this.sync("read",this,N)},save:function(Q,N,U){var R,M,T,O=this.attributes;if(Q==null||typeof Q==="object"){R=Q;U=N}else{(R={})[Q]=N}if(R&&(!U||!U.wait)&&!this.set(R,U)){return false}U=L.extend({validate:true},U);if(!this._validate(R,U)){return false}if(R&&U.wait){this.attributes=L.extend({},O,R)}if(U.parse===void 0){U.parse=true}var P=this;var S=U.success;U.success=function(W){P.attributes=O;var V=P.parse(W,U);if(U.wait){V=L.extend(R||{},V)}if(L.isObject(V)&&!P.set(V,U)){return false}if(S){S(P,W,U)}P.trigger("sync",P,W,U)};H(this,U);M=this.isNew()?"create":(U.patch?"patch":"update");if(M==="patch"){U.attrs=R}T=this.sync(M,this,U);if(R&&U.wait){this.attributes=O}return T},destroy:function(N){N=N?L.clone(N):{};var M=this;var Q=N.success;var O=function(){M.trigger("destroy",M,M.collection,N)};N.success=function(R){if(N.wait||M.isNew()){O()}if(Q){Q(M,R,N)}if(!M.isNew()){M.trigger("sync",M,R,N)}};if(this.isNew()){N.success();return false}H(this,N);var P=this.sync("delete",this,N);if(!N.wait){O()}return P},url:function(){var M=L.result(this,"urlRoot")||L.result(this.collection,"url")||r();if(this.isNew()){return M}return M+(M.charAt(M.length-1)==="/"?"":"/")+encodeURIComponent(this.id)},parse:function(N,M){return N},clone:function(){return new this.constructor(this.attributes)},isNew:function(){return this.id==null},isValid:function(M){return this._validate({},L.extend(M||{},{validate:true}))},_validate:function(O,N){if(!N.validate||!this.validate){return true}O=L.extend({},this.attributes,O);var M=this.validationError=this.validate(O,N)||null;if(!M){return true}this.trigger("invalid",this,M,L.extend(N||{},{validationError:M}));return false}});var a=["keys","values","pairs","invert","pick","omit"];L.each(a,function(M){E.prototype[M]=function(){var N=n.call(arguments);N.unshift(this.attributes);return L[M].apply(L,N)}});var c=z.Collection=function(N,M){M||(M={});if(M.url){this.url=M.url}if(M.model){this.model=M.model}if(M.comparator!==void 0){this.comparator=M.comparator}this._reset();this.initialize.apply(this,arguments);if(N){this.reset(N,L.extend({silent:true},M))}};var o={add:true,remove:true,merge:true};var K={add:true,merge:false,remove:false};L.extend(c.prototype,J,{model:E,initialize:function(){},toJSON:function(M){return this.map(function(N){return N.toJSON(M)})},sync:function(){return z.sync.apply(this,arguments)},add:function(N,M){return this.set(N,L.defaults(M||{},K))},remove:function(R,P){R=L.isArray(R)?R.slice():[R];P||(P={});var Q,M,O,N;for(Q=0,M=R.length;Q<M;Q++){N=this.get(R[Q]);if(!N){continue}delete this._byId[N.id];delete this._byId[N.cid];O=this.indexOf(N);this.models.splice(O,1);this.length--;if(!P.silent){P.index=O;N.trigger("remove",N,this,P)}this._removeReference(N)}return this},set:function(N,Z){Z=L.defaults(Z||{},o);if(Z.parse){N=this.parse(N,Z)}if(!L.isArray(N)){N=N?[N]:[]}var U,Q,W,X,O,V;var P=Z.at;var T=this.comparator&&(P==null)&&Z.sort!==false;var R=L.isString(this.comparator)?this.comparator:null;var Y=[],M=[],S={};for(U=0,Q=N.length;U<Q;U++){if(!(W=this._prepareModel(N[U],Z))){continue}if(O=this.get(W)){if(Z.remove){S[O.cid]=true}if(Z.merge){O.set(W.attributes,Z);if(T&&!V&&O.hasChanged(R)){V=true}}}else{if(Z.add){Y.push(W);W.on("all",this._onModelEvent,this);this._byId[W.cid]=W;if(W.id!=null){this._byId[W.id]=W}}}}if(Z.remove){for(U=0,Q=this.length;U<Q;++U){if(!S[(W=this.models[U]).cid]){M.push(W)}}if(M.length){this.remove(M,Z)}}if(Y.length){if(T){V=true}this.length+=Y.length;if(P!=null){t.apply(this.models,[P,0].concat(Y))}else{D.apply(this.models,Y)}}if(V){this.sort({silent:true})}if(Z.silent){return this}for(U=0,Q=Y.length;U<Q;U++){(W=Y[U]).trigger("add",W,this,Z)}if(V){this.trigger("sort",this,Z)}return this},reset:function(P,N){N||(N={});for(var O=0,M=this.models.length;O<M;O++){this._removeReference(this.models[O])}N.previousModels=this.models;this._reset();this.add(P,L.extend({silent:true},N));if(!N.silent){this.trigger("reset",this,N)}return this},push:function(N,M){N=this._prepareModel(N,M);this.add(N,L.extend({at:this.length},M));return N},pop:function(N){var M=this.at(this.length-1);this.remove(M,N);return M},unshift:function(N,M){N=this._prepareModel(N,M);this.add(N,L.extend({at:0},M));return N},shift:function(N){var M=this.at(0);this.remove(M,N);return M},slice:function(N,M){return this.models.slice(N,M)},get:function(M){if(M==null){return void 0}return this._byId[M.id!=null?M.id:M.cid||M]},at:function(M){return this.models[M]},where:function(M,N){if(L.isEmpty(M)){return N?void 0:[]}return this[N?"find":"filter"](function(O){for(var P in M){if(M[P]!==O.get(P)){return false}}return true})},findWhere:function(M){return this.where(M,true)},sort:function(M){if(!this.comparator){throw new Error("Cannot sort a set without a comparator")}M||(M={});if(L.isString(this.comparator)||this.comparator.length===1){this.models=this.sortBy(this.comparator,this)}else{this.models.sort(L.bind(this.comparator,this))}if(!M.silent){this.trigger("sort",this,M)}return this},sortedIndex:function(M,P,N){P||(P=this.comparator);var O=L.isFunction(P)?P:function(Q){return Q.get(P)};return L.sortedIndex(this.models,M,O,N)},pluck:function(M){return L.invoke(this.models,"get",M)},fetch:function(M){M=M?L.clone(M):{};if(M.parse===void 0){M.parse=true}var O=M.success;var N=this;M.success=function(P){var Q=M.reset?"reset":"set";N[Q](P,M);if(O){O(N,P,M)}N.trigger("sync",N,P,M)};H(this,M);return this.sync("read",this,M)},create:function(N,M){M=M?L.clone(M):{};if(!(N=this._prepareModel(N,M))){return false}if(!M.wait){this.add(N,M)}var P=this;var O=M.success;M.success=function(Q){if(M.wait){P.add(N,M)}if(O){O(N,Q,M)}};N.save(null,M);return N},parse:function(N,M){return N},clone:function(){return new this.constructor(this.models)},_reset:function(){this.length=0;this.models=[];this._byId={}},_prepareModel:function(O,N){if(O instanceof E){if(!O.collection){O.collection=this}return O}N||(N={});N.collection=this;var M=new this.model(O,N);if(!M._validate(O,N)){this.trigger("invalid",this,O,N);return false}return M},_removeReference:function(M){if(this===M.collection){delete M.collection}M.off("all",this._onModelEvent,this)},_onModelEvent:function(O,N,P,M){if((O==="add"||O==="remove")&&P!==this){return}if(O==="destroy"){this.remove(N,M)}if(N&&O==="change:"+N.idAttribute){delete this._byId[N.previous(N.idAttribute)];if(N.id!=null){this._byId[N.id]=N}}this.trigger.apply(this,arguments)}});var y=["forEach","each","map","collect","reduce","foldl","inject","reduceRight","foldr","find","detect","filter","select","reject","every","all","some","any","include","contains","invoke","max","min","toArray","size","first","head","take","initial","rest","tail","drop","last","without","indexOf","shuffle","lastIndexOf","isEmpty","chain"];L.each(y,function(M){c.prototype[M]=function(){var N=n.call(arguments);N.unshift(this.models);return L[M].apply(L,N)}});var k=["groupBy","countBy","sortBy"];L.each(k,function(M){c.prototype[M]=function(P,N){var O=L.isFunction(P)?P:function(Q){return Q.get(P)};return L[M](this.models,O,N)}});var G=z.View=function(M){this.cid=L.uniqueId("view");this._configure(M||{});this._ensureElement();this.initialize.apply(this,arguments);this.delegateEvents()};var v=/^(\S+)\s*(.*)$/;var e=["model","collection","el","id","attributes","className","tagName","events"];L.extend(G.prototype,J,{tagName:"div",$:function(M){return this.$el.find(M)},initialize:function(){},render:function(){return this},remove:function(){this.$el.remove();this.stopListening();return this},setElement:function(M,N){if(this.$el){this.undelegateEvents()}this.$el=M instanceof z.$?M:z.$(M);this.el=this.$el[0];if(N!==false){this.delegateEvents()}return this},delegateEvents:function(Q){if(!(Q||(Q=L.result(this,"events")))){return this}this.undelegateEvents();for(var P in Q){var R=Q[P];if(!L.isFunction(R)){R=this[Q[P]]}if(!R){continue}var O=P.match(v);var N=O[1],M=O[2];R=L.bind(R,this);N+=".delegateEvents"+this.cid;if(M===""){this.$el.on(N,R)}else{this.$el.on(N,M,R)}}return this},undelegateEvents:function(){this.$el.off(".delegateEvents"+this.cid);return this},_configure:function(M){if(this.options){M=L.extend({},L.result(this,"options"),M)}L.extend(this,L.pick(M,e));this.options=M},_ensureElement:function(){if(!this.el){var M=L.extend({},L.result(this,"attributes"));if(this.id){M.id=L.result(this,"id")}if(this.className){M["class"]=L.result(this,"className")}var N=z.$("<"+L.result(this,"tagName")+">").attr(M);this.setElement(N,false)}else{this.setElement(L.result(this,"el"),false)}}});z.sync=function(S,N,M){var P=j[S];L.defaults(M||(M={}),{emulateHTTP:z.emulateHTTP,emulateJSON:z.emulateJSON});var R={type:P,dataType:"json"};if(!M.url){R.url=L.result(N,"url")||r()}if(M.data==null&&N&&(S==="create"||S==="update"||S==="patch")){R.contentType="application/json";R.data=JSON.stringify(M.attrs||N.toJSON(M))}if(M.emulateJSON){R.contentType="application/x-www-form-urlencoded";R.data=R.data?{model:R.data}:{}}if(M.emulateHTTP&&(P==="PUT"||P==="DELETE"||P==="PATCH")){R.type="POST";if(M.emulateJSON){R.data._method=P}var O=M.beforeSend;M.beforeSend=function(T){T.setRequestHeader("X-HTTP-Method-Override",P);if(O){return O.apply(this,arguments)}}}if(R.type!=="GET"&&!M.emulateJSON){R.processData=false}if(R.type==="PATCH"&&window.ActiveXObject&&!(window.external&&window.external.msActiveXFilteringEnabled)){R.xhr=function(){return new ActiveXObject("Microsoft.XMLHTTP")}}var Q=M.xhr=z.ajax(L.extend(R,M));N.trigger("request",N,Q,M);return Q};var j={create:"POST",update:"PUT",patch:"PATCH","delete":"DELETE",read:"GET"};z.ajax=function(){return z.$.ajax.apply(z.$,arguments)};var p=z.Router=function(M){M||(M={});if(M.routes){this.routes=M.routes}this._bindRoutes();this.initialize.apply(this,arguments)};var q=/\((.*?)\)/g;var s=/(\(\?)?:\w+/g;var d=/\*\w+/g;var h=/[\-{}\[\]+?.,\\\^$|#\s]/g;L.extend(p.prototype,J,{initialize:function(){},route:function(N,O,P){if(!L.isRegExp(N)){N=this._routeToRegExp(N)}if(L.isFunction(O)){P=O;O=""}if(!P){P=this[O]}var M=this;z.history.route(N,function(R){var Q=M._extractParameters(N,R);P&&P.apply(M,Q);M.trigger.apply(M,["route:"+O].concat(Q));M.trigger("route",O,Q);z.history.trigger("route",M,O,Q)});return this},navigate:function(N,M){z.history.navigate(N,M);return this},_bindRoutes:function(){if(!this.routes){return}this.routes=L.result(this,"routes");var N,M=L.keys(this.routes);while((N=M.pop())!=null){this.route(N,this.routes[N])}},_routeToRegExp:function(M){M=M.replace(h,"\\$&").replace(q,"(?:$1)?").replace(s,function(O,N){return N?O:"([^/]+)"}).replace(d,"(.*?)");return new RegExp("^"+M+"$")},_extractParameters:function(M,N){var O=M.exec(N).slice(1);return L.map(O,function(P){return P?decodeURIComponent(P):null})}});var i=z.History=function(){this.handlers=[];L.bindAll(this,"checkUrl");if(typeof window!=="undefined"){this.location=window.location;this.history=window.history}};var A=/^[#\/]|\s+$/g;var f=/^\/+|\/+$/g;var I=/msie [\w.]+/;var m=/\/$/;i.started=false;L.extend(i.prototype,J,{interval:50,getHash:function(N){var M=(N||this).location.href.match(/#(.*)$/);return M?M[1]:""},getFragment:function(O,N){if(O==null){if(this._hasPushState||!this._wantsHashChange||N){O=this.location.pathname;var M=this.root.replace(m,"");if(!O.indexOf(M)){O=O.substr(M.length)}}else{O=this.getHash()}}return O.replace(A,"")},start:function(O){if(i.started){throw new Error("Backbone.history has already been started")}i.started=true;this.options=L.extend({},{root:"/"},this.options,O);this.root=this.options.root;this._wantsHashChange=this.options.hashChange!==false;this._wantsPushState=!!this.options.pushState;this._hasPushState=!!(this.options.pushState&&this.history&&this.history.pushState);var N=this.getFragment();var M=document.documentMode;var Q=(I.exec(navigator.userAgent.toLowerCase())&&(!M||M<=7));this.root=("/"+this.root+"/").replace(f,"/");if(Q&&this._wantsHashChange){this.iframe=z.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo("body")[0].contentWindow;this.navigate(N)}if(this._hasPushState){z.$(window).on("popstate",this.checkUrl)}else{if(this._wantsHashChange&&("onhashchange" in window)&&!Q){z.$(window).on("hashchange",this.checkUrl)}else{if(this._wantsHashChange){this._checkUrlInterval=setInterval(this.checkUrl,this.interval)}}}this.fragment=N;var R=this.location;var P=R.pathname.replace(/[^\/]$/,"$&/")===this.root;if(this._wantsHashChange&&this._wantsPushState&&!this._hasPushState&&!P){this.fragment=this.getFragment(null,true);this.location.replace(this.root+this.location.search+"#"+this.fragment);return true}else{if(this._wantsPushState&&this._hasPushState&&P&&R.hash){this.fragment=this.getHash().replace(A,"");this.history.replaceState({},document.title,this.root+this.fragment+R.search)}}if(!this.options.silent){return this.loadUrl()}},stop:function(){z.$(window).off("popstate",this.checkUrl).off("hashchange",this.checkUrl);clearInterval(this._checkUrlInterval);i.started=false},route:function(M,N){this.handlers.unshift({route:M,callback:N})},checkUrl:function(N){var M=this.getFragment();if(M===this.fragment&&this.iframe){M=this.getFragment(this.getHash(this.iframe))}if(M===this.fragment){return false}if(this.iframe){this.navigate(M)}this.loadUrl()||this.loadUrl(this.getHash())},loadUrl:function(O){var N=this.fragment=this.getFragment(O);var M=L.any(this.handlers,function(P){if(P.route.test(N)){P.callback(N);return true}});return M},navigate:function(O,N){if(!i.started){return false}if(!N||N===true){N={trigger:N}}O=this.getFragment(O||"");if(this.fragment===O){return}this.fragment=O;var M=this.root+O;if(this._hasPushState){this.history[N.replace?"replaceState":"pushState"]({},document.title,M)}else{if(this._wantsHashChange){this._updateHash(this.location,O,N.replace);if(this.iframe&&(O!==this.getFragment(this.getHash(this.iframe)))){if(!N.replace){this.iframe.document.open().close()}this._updateHash(this.iframe.location,O,N.replace)}}else{return this.location.assign(M)}}if(N.trigger){this.loadUrl(O)}},_updateHash:function(M,O,P){if(P){var N=M.href.replace(/(javascript:|#).*$/,"");M.replace(N+"#"+O)}else{M.hash="#"+O}}});z.history=new i;var l=function(M,O){var N=this;var Q;if(M&&L.has(M,"constructor")){Q=M.constructor}else{Q=function(){return N.apply(this,arguments)}}L.extend(Q,N,O);var P=function(){this.constructor=Q};P.prototype=N.prototype;Q.prototype=new P;if(M){L.extend(Q.prototype,M)}Q.__super__=N.prototype;return Q};E.extend=c.extend=p.extend=G.extend=i.extend=l;var r=function(){throw new Error('A "url" property or function must be specified')};var H=function(O,N){var M=N.error;N.error=function(P){if(M){M(O,P,N)}O.trigger("error",O,P,N)}}}).call(this);
\ No newline at end of file
diff --git a/static/scripts/packed/libs/handlebars.runtime.js b/static/scripts/packed/libs/handlebars.runtime.js
index 0bd8ed85c6e..468be5b7c1a 100644
--- a/static/scripts/packed/libs/handlebars.runtime.js
+++ b/static/scripts/packed/libs/handlebars.runtime.js
@@ -1 +1 @@
-var Handlebars={};Handlebars.VERSION="1.0.beta.6";Handlebars.helpers={};Handlebars.partials={};Handlebars.registerHelper=function(b,c,a){if(a){c.not=a}this.helpers[b]=c};Handlebars.registerPartial=function(a,b){this.partials[a]=b};Handlebars.registerHelper("helperMissing",function(a){if(arguments.length===2){return undefined}else{throw new Error("Could not find property '"+a+"'")}});var toString=Object.prototype.toString,functionType="[object Function]";Handlebars.registerHelper("blockHelperMissing",function(f,d){var a=d.inverse||function(){},h=d.fn;var c="";var g=toString.call(f);if(g===functionType){f=f.call(this)}if(f===true){return h(this)}else{if(f===false||f==null){return a(this)}else{if(g==="[object Array]"){if(f.length>0){for(var e=0,b=f.length;e<b;e++){c=c+h(f[e])}}else{c=a(this)}return c}else{return h(f)}}}});Handlebars.registerHelper("each",function(f,d){var g=d.fn,a=d.inverse;var c="";if(f&&f.length>0){for(var e=0,b=f.length;e<b;e++){c=c+g(f[e])}}else{c=a(this)}return c});Handlebars.registerHelper("if",function(b,a){var c=toString.call(b);if(c===functionType){b=b.call(this)}if(!b||Handlebars.Utils.isEmpty(b)){return a.inverse(this)}else{return a.fn(this)}});Handlebars.registerHelper("unless",function(c,b){var d=b.fn,a=b.inverse;b.fn=a;b.inverse=d;return Handlebars.helpers["if"].call(this,c,b)});Handlebars.registerHelper("with",function(b,a){return a.fn(b)});Handlebars.registerHelper("log",function(a){Handlebars.log(a)});Handlebars.Exception=function(b){var a=Error.prototype.constructor.apply(this,arguments);for(var c in a){if(a.hasOwnProperty(c)){this[c]=a[c]}}this.message=a.message};Handlebars.Exception.prototype=new Error;Handlebars.SafeString=function(a){this.string=a};Handlebars.SafeString.prototype.toString=function(){return this.string.toString()};(function(){var c={"<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","`":"&#x60;"};var d=/&(?!\w+;)|[<>"'`]/g;var b=/[&<>"'`]/;var a=function(e){return c[e]||"&amp;"};Handlebars.Utils={escapeExpression:function(e){if(e instanceof Handlebars.SafeString){return e.toString()}else{if(e==null||e===false){return""}}if(!b.test(e)){return e}return e.replace(d,a)},isEmpty:function(e){if(typeof e==="undefined"){return true}else{if(e===null){return true}else{if(e===false){return true}else{if(Object.prototype.toString.call(e)==="[object Array]"&&e.length===0){return true}else{return false}}}}}}})();Handlebars.VM={template:function(a){var b={escapeExpression:Handlebars.Utils.escapeExpression,invokePartial:Handlebars.VM.invokePartial,programs:[],program:function(d,e,f){var c=this.programs[d];if(f){return Handlebars.VM.program(e,f)}else{if(c){return c}else{c=this.programs[d]=Handlebars.VM.program(e);return c}}},programWithDepth:Handlebars.VM.programWithDepth,noop:Handlebars.VM.noop};return function(d,c){c=c||{};return a.call(b,Handlebars,d,c.helpers,c.partials,c.data)}},programWithDepth:function(b,d,c){var a=Array.prototype.slice.call(arguments,2);return function(f,e){e=e||{};return b.apply(this,[f,e.data||d].concat(a))}},program:function(a,b){return function(d,c){c=c||{};return a(d,c.data||b)}},noop:function(){return""},invokePartial:function(a,b,d,e,c,f){options={helpers:e,partials:c,data:f};if(a===undefined){throw new Handlebars.Exception("The partial "+b+" could not be found")}else{if(a instanceof Function){return a(d,options)}else{if(!Handlebars.compile){throw new Handlebars.Exception("The partial "+b+" could not be compiled when running in runtime-only mode")}else{c[b]=Handlebars.compile(a);return c[b](d,options)}}}}};Handlebars.template=Handlebars.VM.template;
\ No newline at end of file
+this.Handlebars={};(function(c){c.VERSION="1.0.rc.1";c.helpers={};c.partials={};c.registerHelper=function(e,f,d){if(d){f.not=d}this.helpers[e]=f};c.registerPartial=function(d,e){this.partials[d]=e};c.registerHelper("helperMissing",function(d){if(arguments.length===2){return undefined}else{throw new Error("Could not find property '"+d+"'")}});var a=Object.prototype.toString,b="[object Function]";c.registerHelper("blockHelperMissing",function(g,f){var d=f.inverse||function(){},i=f.fn;var e="";var h=a.call(g);if(h===b){g=g.call(this)}if(g===true){return i(this)}else{if(g===false||g==null){return d(this)}else{if(h==="[object Array]"){if(g.length>0){return c.helpers.each(g,f)}else{return d(this)}}else{return i(g)}}}});c.K=function(){};c.createFrame=Object.create||function(d){c.K.prototype=d;var e=new c.K();c.K.prototype=null;return e};c.registerHelper("each",function(k,g){var l=g.fn,d=g.inverse;var f="",m;if(g.data){m=c.createFrame(g.data)}if(k&&k.length>0){for(var h=0,e=k.length;h<e;h++){if(m){m.index=h}f=f+l(k[h],{data:m})}}else{f=d(this)}return f});c.registerHelper("if",function(e,d){var f=a.call(e);if(f===b){e=e.call(this)}if(!e||c.Utils.isEmpty(e)){return d.inverse(this)}else{return d.fn(this)}});c.registerHelper("unless",function(f,e){var g=e.fn,d=e.inverse;e.fn=d;e.inverse=g;return c.helpers["if"].call(this,f,e)});c.registerHelper("with",function(e,d){return d.fn(e)});c.registerHelper("log",function(d){c.log(d)})}(this.Handlebars));Handlebars.Exception=function(b){var a=Error.prototype.constructor.apply(this,arguments);for(var c in a){if(a.hasOwnProperty(c)){this[c]=a[c]}}this.message=a.message};Handlebars.Exception.prototype=new Error();Handlebars.SafeString=function(a){this.string=a};Handlebars.SafeString.prototype.toString=function(){return this.string.toString()};(function(){var c={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","`":"&#x60;"};var d=/[&<>"'`]/g;var b=/[&<>"'`]/;var a=function(e){return c[e]||"&amp;"};Handlebars.Utils={escapeExpression:function(e){if(e instanceof Handlebars.SafeString){return e.toString()}else{if(e==null||e===false){return""}}if(!b.test(e)){return e}return e.replace(d,a)},isEmpty:function(e){if(typeof e==="undefined"){return true}else{if(e===null){return true}else{if(e===false){return true}else{if(Object.prototype.toString.call(e)==="[object Array]"&&e.length===0){return true}else{return false}}}}}}})();Handlebars.VM={template:function(a){var b={escapeExpression:Handlebars.Utils.escapeExpression,invokePartial:Handlebars.VM.invokePartial,programs:[],program:function(d,e,f){var c=this.programs[d];if(f){return Handlebars.VM.program(e,f)}else{if(c){return c}else{c=this.programs[d]=Handlebars.VM.program(e);return c}}},programWithDepth:Handlebars.VM.programWithDepth,noop:Handlebars.VM.noop};return function(d,c){c=c||{};return a.call(b,Handlebars,d,c.helpers,c.partials,c.data)}},programWithDepth:function(b,d,c){var a=Array.prototype.slice.call(arguments,2);return function(f,e){e=e||{};return b.apply(this,[f,e.data||d].concat(a))}},program:function(a,b){return function(d,c){c=c||{};return a(d,c.data||b)}},noop:function(){return""},invokePartial:function(a,c,e,f,d,g){var b={helpers:f,partials:d,data:g};if(a===undefined){throw new Handlebars.Exception("The partial "+c+" could not be found")}else{if(a instanceof Function){return a(e,b)}else{if(!Handlebars.compile){throw new Handlebars.Exception("The partial "+c+" could not be compiled when running in runtime-only mode")}else{d[c]=Handlebars.compile(a,{data:g!==undefined});return d[c](e,b)}}}}};Handlebars.template=Handlebars.VM.template;
\ No newline at end of file
diff --git a/static/scripts/packed/libs/underscore.js b/static/scripts/packed/libs/underscore.js
index 1cc8c740dac..ec0cd5258d4 100644
--- a/static/scripts/packed/libs/underscore.js
+++ b/static/scripts/packed/libs/underscore.js
@@ -1 +1 @@
-(function(){var x=this;var t=x._;var b={};var j=Array.prototype,D=Object.prototype,G=Function.prototype;var v=j.slice,z=j.unshift,y=D.toString,p=D.hasOwnProperty;var n=j.forEach,i=j.map,B=j.reduce,e=j.reduceRight,m=j.filter,a=j.every,A=j.some,w=j.indexOf,f=j.lastIndexOf,c=Array.isArray,C=Object.keys,k=G.bind;var F=function(I){return new g(I)};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports){exports=module.exports=F}exports._=F}else{x._=F}F.VERSION="1.3.1";var d=F.each=F.forEach=function(N,M,L){if(N==null){return}if(n&&N.forEach===n){N.forEach(M,L)}else{if(N.length===+N.length){for(var K=0,I=N.length;K<I;K++){if(K in N&&M.call(L,N[K],K,N)===b){return}}}else{for(var J in N){if(F.has(N,J)){if(M.call(L,N[J],J,N)===b){return}}}}}};F.map=F.collect=function(L,K,J){var I=[];if(L==null){return I}if(i&&L.map===i){return L.map(K,J)}d(L,function(O,M,N){I[I.length]=K.call(J,O,M,N)});if(L.length===+L.length){I.length=L.length}return I};F.reduce=F.foldl=F.inject=function(M,L,I,K){var J=arguments.length>2;if(M==null){M=[]}if(B&&M.reduce===B){if(K){L=F.bind(L,K)}return J?M.reduce(L,I):M.reduce(L)}d(M,function(P,N,O){if(!J){I=P;J=true}else{I=L.call(K,I,P,N,O)}});if(!J){throw new TypeError("Reduce of empty array with no initial value")}return I};F.reduceRight=F.foldr=function(M,L,I,K){var J=arguments.length>2;if(M==null){M=[]}if(e&&M.reduceRight===e){if(K){L=F.bind(L,K)}return J?M.reduceRight(L,I):M.reduceRight(L)}var N=F.toArray(M).reverse();if(K&&!J){L=F.bind(L,K)}return J?F.reduce(N,L,I,K):F.reduce(N,L)};F.find=F.detect=function(L,K,J){var I;r(L,function(O,M,N){if(K.call(J,O,M,N)){I=O;return true}});return I};F.filter=F.select=function(L,K,J){var I=[];if(L==null){return I}if(m&&L.filter===m){return L.filter(K,J)}d(L,function(O,M,N){if(K.call(J,O,M,N)){I[I.length]=O}});return I};F.reject=function(L,K,J){var I=[];if(L==null){return I}d(L,function(O,M,N){if(!K.call(J,O,M,N)){I[I.length]=O}});return I};F.every=F.all=function(L,K,J){var I=true;if(L==null){return I}if(a&&L.every===a){return L.every(K,J)}d(L,function(O,M,N){if(!(I=I&&K.call(J,O,M,N))){return b}});return I};var r=F.some=F.any=function(L,K,J){K||(K=F.identity);var I=false;if(L==null){return I}if(A&&L.some===A){return L.some(K,J)}d(L,function(O,M,N){if(I||(I=K.call(J,O,M,N))){return b}});return !!I};F.include=F.contains=function(K,J){var I=false;if(K==null){return I}if(w&&K.indexOf===w){return K.indexOf(J)!=-1}I=r(K,function(L){return L===J});return I};F.invoke=function(J,K){var I=v.call(arguments,2);return F.map(J,function(L){return(F.isFunction(K)?K||L:L[K]).apply(L,I)})};F.pluck=function(J,I){return F.map(J,function(K){return K[I]})};F.max=function(L,K,J){if(!K&&F.isArray(L)){return Math.max.apply(Math,L)}if(!K&&F.isEmpty(L)){return -Infinity}var I={computed:-Infinity};d(L,function(P,M,O){var N=K?K.call(J,P,M,O):P;N>=I.computed&&(I={value:P,computed:N})});return I.value};F.min=function(L,K,J){if(!K&&F.isArray(L)){return Math.min.apply(Math,L)}if(!K&&F.isEmpty(L)){return Infinity}var I={computed:Infinity};d(L,function(P,M,O){var N=K?K.call(J,P,M,O):P;N<I.computed&&(I={value:P,computed:N})});return I.value};F.shuffle=function(K){var I=[],J;d(K,function(N,L,M){if(L==0){I[0]=N}else{J=Math.floor(Math.random()*(L+1));I[L]=I[J];I[J]=N}});return I};F.sortBy=function(K,J,I){return F.pluck(F.map(K,function(N,L,M){return{value:N,criteria:J.call(I,N,L,M)}}).sort(function(O,N){var M=O.criteria,L=N.criteria;return M<L?-1:M>L?1:0}),"value")};F.groupBy=function(K,L){var I={};var J=F.isFunction(L)?L:function(M){return M[L]};d(K,function(O,M){var N=J(O,M);(I[N]||(I[N]=[])).push(O)});return I};F.sortedIndex=function(N,M,K){K||(K=F.identity);var I=0,L=N.length;while(I<L){var J=(I+L)>>1;K(N[J])<K(M)?I=J+1:L=J}return I};F.toArray=function(I){if(!I){return[]}if(I.toArray){return I.toArray()}if(F.isArray(I)){return v.call(I)}if(F.isArguments(I)){return v.call(I)}return F.values(I)};F.size=function(I){return F.toArray(I).length};F.first=F.head=function(K,J,I){return(J!=null)&&!I?v.call(K,0,J):K[0]};F.initial=function(K,J,I){return v.call(K,0,K.length-((J==null)||I?1:J))};F.last=function(K,J,I){if((J!=null)&&!I){return v.call(K,Math.max(K.length-J,0))}else{return K[K.length-1]}};F.rest=F.tail=function(K,I,J){return v.call(K,(I==null)||J?1:I)};F.compact=function(I){return F.filter(I,function(J){return !!J})};F.flatten=function(J,I){return F.reduce(J,function(K,L){if(F.isArray(L)){return K.concat(I?L:F.flatten(L))}K[K.length]=L;return K},[])};F.without=function(I){return F.difference(I,v.call(arguments,1))};F.uniq=F.unique=function(M,L,K){var J=K?F.map(M,K):M;var I=[];F.reduce(J,function(N,P,O){if(0==O||(L===true?F.last(N)!=P:!F.include(N,P))){N[N.length]=P;I[I.length]=M[O]}return N},[]);return I};F.union=function(){return F.uniq(F.flatten(arguments,true))};F.intersection=F.intersect=function(J){var I=v.call(arguments,1);return F.filter(F.uniq(J),function(K){return F.every(I,function(L){return F.indexOf(L,K)>=0})})};F.difference=function(J){var I=F.flatten(v.call(arguments,1));return F.filter(J,function(K){return !F.include(I,K)})};F.zip=function(){var I=v.call(arguments);var L=F.max(F.pluck(I,"length"));var K=new Array(L);for(var J=0;J<L;J++){K[J]=F.pluck(I,""+J)}return K};F.indexOf=function(M,K,L){if(M==null){return -1}var J,I;if(L){J=F.sortedIndex(M,K);return M[J]===K?J:-1}if(w&&M.indexOf===w){return M.indexOf(K)}for(J=0,I=M.length;J<I;J++){if(J in M&&M[J]===K){return J}}return -1};F.lastIndexOf=function(K,J){if(K==null){return -1}if(f&&K.lastIndexOf===f){return K.lastIndexOf(J)}var I=K.length;while(I--){if(I in K&&K[I]===J){return I}}return -1};F.range=function(N,L,M){if(arguments.length<=1){L=N||0;N=0}M=arguments[2]||1;var J=Math.max(Math.ceil((L-N)/M),0);var I=0;var K=new Array(J);while(I<J){K[I++]=N;N+=M}return K};var h=function(){};F.bind=function H(L,J){var K,I;if(L.bind===k&&k){return k.apply(L,v.call(arguments,1))}if(!F.isFunction(L)){throw new TypeError}I=v.call(arguments,2);return K=function(){if(!(this instanceof K)){return L.apply(J,I.concat(v.call(arguments)))}h.prototype=L.prototype;var N=new h;var M=L.apply(N,I.concat(v.call(arguments)));if(Object(M)===M){return M}return N}};F.bindAll=function(J){var I=v.call(arguments,1);if(I.length==0){I=F.functions(J)}d(I,function(K){J[K]=F.bind(J[K],J)});return J};F.memoize=function(K,J){var I={};J||(J=F.identity);return function(){var L=J.apply(this,arguments);return F.has(I,L)?I[L]:(I[L]=K.apply(this,arguments))}};F.delay=function(J,K){var I=v.call(arguments,2);return setTimeout(function(){return J.apply(J,I)},K)};F.defer=function(I){return F.delay.apply(F,[I,1].concat(v.call(arguments,1)))};F.throttle=function(N,P){var L,I,O,M,K;var J=F.debounce(function(){K=M=false},P);return function(){L=this;I=arguments;var Q=function(){O=null;if(K){N.apply(L,I)}J()};if(!O){O=setTimeout(Q,P)}if(M){K=true}else{N.apply(L,I)}J();M=true}};F.debounce=function(I,K){var J;return function(){var N=this,M=arguments;var L=function(){J=null;I.apply(N,M)};clearTimeout(J);J=setTimeout(L,K)}};F.once=function(K){var I=false,J;return function(){if(I){return J}I=true;return J=K.apply(this,arguments)}};F.wrap=function(I,J){return function(){var K=[I].concat(v.call(arguments,0));return J.apply(this,K)}};F.compose=function(){var I=arguments;return function(){var J=arguments;for(var K=I.length-1;K>=0;K--){J=[I[K].apply(this,J)]}return J[0]}};F.after=function(J,I){if(J<=0){return I()}return function(){if(--J<1){return I.apply(this,arguments)}}};F.keys=C||function(K){if(K!==Object(K)){throw new TypeError("Invalid object")}var J=[];for(var I in K){if(F.has(K,I)){J[J.length]=I}}return J};F.values=function(I){return F.map(I,F.identity)};F.functions=F.methods=function(K){var J=[];for(var I in K){if(F.isFunction(K[I])){J.push(I)}}return J.sort()};F.extend=function(I){d(v.call(arguments,1),function(J){for(var K in J){I[K]=J[K]}});return I};F.defaults=function(I){d(v.call(arguments,1),function(J){for(var K in J){if(I[K]==null){I[K]=J[K]}}});return I};F.clone=function(I){if(!F.isObject(I)){return I}return F.isArray(I)?I.slice():F.extend({},I)};F.tap=function(J,I){I(J);return J};function E(L,K,J){if(L===K){return L!==0||1/L==1/K}if(L==null||K==null){return L===K}if(L._chain){L=L._wrapped}if(K._chain){K=K._wrapped}if(L.isEqual&&F.isFunction(L.isEqual)){return L.isEqual(K)}if(K.isEqual&&F.isFunction(K.isEqual)){return K.isEqual(L)}var O=y.call(L);if(O!=y.call(K)){return false}switch(O){case"[object String]":return L==String(K);case"[object Number]":return L!=+L?K!=+K:(L==0?1/L==1/K:L==+K);case"[object Date]":case"[object Boolean]":return +L==+K;case"[object RegExp]":return L.source==K.source&&L.global==K.global&&L.multiline==K.multiline&&L.ignoreCase==K.ignoreCase}if(typeof L!="object"||typeof K!="object"){return false}var P=J.length;while(P--){if(J[P]==L){return true}}J.push(L);var N=0,I=true;if(O=="[object Array]"){N=L.length;I=N==K.length;if(I){while(N--){if(!(I=N in L==N in K&&E(L[N],K[N],J))){break}}}}else{if("constructor" in L!="constructor" in K||L.constructor!=K.constructor){return false}for(var M in L){if(F.has(L,M)){N++;if(!(I=F.has(K,M)&&E(L[M],K[M],J))){break}}}if(I){for(M in K){if(F.has(K,M)&&!(N--)){break}}I=!N}}J.pop();return I}F.isEqual=function(J,I){return E(J,I,[])};F.isEmpty=function(J){if(F.isArray(J)||F.isString(J)){return J.length===0}for(var I in J){if(F.has(J,I)){return false}}return true};F.isElement=function(I){return !!(I&&I.nodeType==1)};F.isArray=c||function(I){return y.call(I)=="[object Array]"};F.isObject=function(I){return I===Object(I)};F.isArguments=function(I){return y.call(I)=="[object Arguments]"};if(!F.isArguments(arguments)){F.isArguments=function(I){return !!(I&&F.has(I,"callee"))}}F.isFunction=function(I){return y.call(I)=="[object Function]"};F.isString=function(I){return y.call(I)=="[object String]"};F.isNumber=function(I){return y.call(I)=="[object Number]"};F.isNaN=function(I){return I!==I};F.isBoolean=function(I){return I===true||I===false||y.call(I)=="[object Boolean]"};F.isDate=function(I){return y.call(I)=="[object Date]"};F.isRegExp=function(I){return y.call(I)=="[object RegExp]"};F.isNull=function(I){return I===null};F.isUndefined=function(I){return I===void 0};F.has=function(J,I){return p.call(J,I)};F.noConflict=function(){x._=t;return this};F.identity=function(I){return I};F.times=function(L,K,J){for(var I=0;I<L;I++){K.call(J,I)}};F.escape=function(I){return(""+I).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;").replace(/\//g,"&#x2F;")};F.mixin=function(I){d(F.functions(I),function(J){s(J,F[J]=I[J])})};var l=0;F.uniqueId=function(I){var J=l++;return I?I+J:J};F.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var u=/.^/;var q=function(I){return I.replace(/\\\\/g,"\\").replace(/\\'/g,"'")};F.template=function(L,K){var M=F.templateSettings;var I="var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('"+L.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(M.escape||u,function(N,O){return"',_.escape("+q(O)+"),'"}).replace(M.interpolate||u,function(N,O){return"',"+q(O)+",'"}).replace(M.evaluate||u,function(N,O){return"');"+q(O).replace(/[\r\n\t]/g," ")+";__p.push('"}).replace(/\r/g,"\\r").replace(/\n/g,"\\n").replace(/\t/g,"\\t")+"');}return __p.join('');";var J=new Function("obj","_",I);if(K){return J(K,F)}return function(N){return J.call(this,N,F)}};F.chain=function(I){return F(I).chain()};var g=function(I){this._wrapped=I};F.prototype=g.prototype;var o=function(J,I){return I?F(J).chain():J};var s=function(I,J){g.prototype[I]=function(){var K=v.call(arguments);z.call(K,this._wrapped);return o(J.apply(F,K),this._chain)}};F.mixin(F);d(["pop","push","reverse","shift","sort","splice","unshift"],function(I){var J=j[I];g.prototype[I]=function(){var K=this._wrapped;J.apply(K,arguments);var L=K.length;if((I=="shift"||I=="splice")&&L===0){delete K[0]}return o(K,this._chain)}});d(["concat","join","slice"],function(I){var J=j[I];g.prototype[I]=function(){return o(J.apply(this._wrapped,arguments),this._chain)}});g.prototype.chain=function(){this._chain=true;return this};g.prototype.value=function(){return this._wrapped}}).call(this);
\ No newline at end of file
+(function(){var w=this;var k=w._;var D={};var C=Array.prototype,f=Object.prototype,r=Function.prototype;var H=C.push,o=C.slice,y=C.concat,d=f.toString,j=f.hasOwnProperty;var L=C.forEach,q=C.map,E=C.reduce,c=C.reduceRight,b=C.filter,B=C.every,p=C.some,n=C.indexOf,l=C.lastIndexOf,u=Array.isArray,e=Object.keys,F=r.bind;var M=function(N){if(N instanceof M){return N}if(!(this instanceof M)){return new M(N)}this._wrapped=N};if(typeof exports!=="undefined"){if(typeof module!=="undefined"&&module.exports){exports=module.exports=M}exports._=M}else{w._=M}M.VERSION="1.4.4";var I=M.each=M.forEach=function(S,R,Q){if(S==null){return}if(L&&S.forEach===L){S.forEach(R,Q)}else{if(S.length===+S.length){for(var P=0,N=S.length;P<N;P++){if(R.call(Q,S[P],P,S)===D){return}}}else{for(var O in S){if(M.has(S,O)){if(R.call(Q,S[O],O,S)===D){return}}}}}};M.map=M.collect=function(Q,P,O){var N=[];if(Q==null){return N}if(q&&Q.map===q){return Q.map(P,O)}I(Q,function(T,R,S){N.push(P.call(O,T,R,S))});return N};var g="Reduce of empty array with no initial value";M.reduce=M.foldl=M.inject=function(R,Q,N,P){var O=arguments.length>2;if(R==null){R=[]}if(E&&R.reduce===E){if(P){Q=M.bind(Q,P)}return O?R.reduce(Q,N):R.reduce(Q)}I(R,function(U,S,T){if(!O){N=U;O=true}else{N=Q.call(P,N,U,S,T)}});if(!O){throw new TypeError(g)}return N};M.reduceRight=M.foldr=function(T,Q,N,P){var O=arguments.length>2;if(T==null){T=[]}if(c&&T.reduceRight===c){if(P){Q=M.bind(Q,P)}return O?T.reduceRight(Q,N):T.reduceRight(Q)}var S=T.length;if(S!==+S){var R=M.keys(T);S=R.length}I(T,function(W,U,V){U=R?R[--S]:--S;if(!O){N=T[U];O=true}else{N=Q.call(P,N,T[U],U,V)}});if(!O){throw new TypeError(g)}return N};M.find=M.detect=function(Q,P,O){var N;A(Q,function(T,R,S){if(P.call(O,T,R,S)){N=T;return true}});return N};M.filter=M.select=function(Q,P,O){var N=[];if(Q==null){return N}if(b&&Q.filter===b){return Q.filter(P,O)}I(Q,function(T,R,S){if(P.call(O,T,R,S)){N.push(T)}});return N};M.reject=function(P,O,N){return M.filter(P,function(S,Q,R){return !O.call(N,S,Q,R)},N)};M.every=M.all=function(Q,P,O){P||(P=M.identity);var N=true;if(Q==null){return N}if(B&&Q.every===B){return Q.every(P,O)}I(Q,function(T,R,S){if(!(N=N&&P.call(O,T,R,S))){return D}});return !!N};var A=M.some=M.any=function(Q,P,O){P||(P=M.identity);var N=false;if(Q==null){return N}if(p&&Q.some===p){return Q.some(P,O)}I(Q,function(T,R,S){if(N||(N=P.call(O,T,R,S))){return D}});return !!N};M.contains=M.include=function(O,N){if(O==null){return false}if(n&&O.indexOf===n){return O.indexOf(N)!=-1}return A(O,function(P){return P===N})};M.invoke=function(P,Q){var N=o.call(arguments,2);var O=M.isFunction(Q);return M.map(P,function(R){return(O?Q:R[Q]).apply(R,N)})};M.pluck=function(O,N){return M.map(O,function(P){return P[N]})};M.where=function(O,N,P){if(M.isEmpty(N)){return P?void 0:[]}return M[P?"find":"filter"](O,function(R){for(var Q in N){if(N[Q]!==R[Q]){return false}}return true})};M.findWhere=function(O,N){return M.where(O,N,true)};M.max=function(Q,P,O){if(!P&&M.isArray(Q)&&Q[0]===+Q[0]&&Q.length<65535){return Math.max.apply(Math,Q)}if(!P&&M.isEmpty(Q)){return -Infinity}var N={computed:-Infinity,value:-Infinity};I(Q,function(U,R,T){var S=P?P.call(O,U,R,T):U;S>=N.computed&&(N={value:U,computed:S})});return N.value};M.min=function(Q,P,O){if(!P&&M.isArray(Q)&&Q[0]===+Q[0]&&Q.length<65535){return Math.min.apply(Math,Q)}if(!P&&M.isEmpty(Q)){return Infinity}var N={computed:Infinity,value:Infinity};I(Q,function(U,R,T){var S=P?P.call(O,U,R,T):U;S<N.computed&&(N={value:U,computed:S})});return N.value};M.shuffle=function(Q){var P;var O=0;var N=[];I(Q,function(R){P=M.random(O++);N[O-1]=N[P];N[P]=R});return N};var a=function(N){return M.isFunction(N)?N:function(O){return O[N]}};M.sortBy=function(Q,P,N){var O=a(P);return M.pluck(M.map(Q,function(T,R,S){return{value:T,index:R,criteria:O.call(N,T,R,S)}}).sort(function(U,T){var S=U.criteria;var R=T.criteria;if(S!==R){if(S>R||S===void 0){return 1}if(S<R||R===void 0){return -1}}return U.index<T.index?-1:1}),"value")};var t=function(S,R,O,Q){var N={};var P=a(R==null?M.identity:R);I(S,function(V,T){var U=P.call(O,V,T,S);Q(N,U,V)});return N};M.groupBy=function(P,O,N){return t(P,O,N,function(Q,R,S){(M.has(Q,R)?Q[R]:(Q[R]=[])).push(S)})};M.countBy=function(P,O,N){return t(P,O,N,function(Q,R){if(!M.has(Q,R)){Q[R]=0}Q[R]++})};M.sortedIndex=function(U,T,Q,P){Q=Q==null?M.identity:a(Q);var S=Q.call(P,T);var N=0,R=U.length;while(N<R){var O=(N+R)>>>1;Q.call(P,U[O])<S?N=O+1:R=O}return N};M.toArray=function(N){if(!N){return[]}if(M.isArray(N)){return o.call(N)}if(N.length===+N.length){return M.map(N,M.identity)}return M.values(N)};M.size=function(N){if(N==null){return 0}return(N.length===+N.length)?N.length:M.keys(N).length};M.first=M.head=M.take=function(P,O,N){if(P==null){return void 0}return(O!=null)&&!N?o.call(P,0,O):P[0]};M.initial=function(P,O,N){return o.call(P,0,P.length-((O==null)||N?1:O))};M.last=function(P,O,N){if(P==null){return void 0}if((O!=null)&&!N){return o.call(P,Math.max(P.length-O,0))}else{return P[P.length-1]}};M.rest=M.tail=M.drop=function(P,O,N){return o.call(P,(O==null)||N?1:O)};M.compact=function(N){return M.filter(N,M.identity)};var x=function(O,P,N){I(O,function(Q){if(M.isArray(Q)){P?H.apply(N,Q):x(Q,P,N)}else{N.push(Q)}});return N};M.flatten=function(O,N){return x(O,N,[])};M.without=function(N){return M.difference(N,o.call(arguments,1))};M.uniq=M.unique=function(T,S,R,Q){if(M.isFunction(S)){Q=R;R=S;S=false}var O=R?M.map(T,R,Q):T;var P=[];var N=[];I(O,function(V,U){if(S?(!U||N[N.length-1]!==V):!M.contains(N,V)){N.push(V);P.push(T[U])}});return P};M.union=function(){return M.uniq(y.apply(C,arguments))};M.intersection=function(O){var N=o.call(arguments,1);return M.filter(M.uniq(O),function(P){return M.every(N,function(Q){return M.indexOf(Q,P)>=0})})};M.difference=function(O){var N=y.apply(C,o.call(arguments,1));return M.filter(O,function(P){return !M.contains(N,P)})};M.zip=function(){var N=o.call(arguments);var Q=M.max(M.pluck(N,"length"));var P=new Array(Q);for(var O=0;O<Q;O++){P[O]=M.pluck(N,""+O)}return P};M.unzip=function(O){var N=[];M.each(O,function(Q,P){M.each(Q,function(S,R){if(N.length<=R){N[R]=[]}N[R][P]=S})});return N};M.object=function(R,P){if(R==null){return{}}var N={};for(var Q=0,O=R.length;Q<O;Q++){if(P){N[R[Q]]=P[Q]}else{N[R[Q][0]]=R[Q][1]}}return N};M.indexOf=function(R,P,Q){if(R==null){return -1}var O=0,N=R.length;if(Q){if(typeof Q=="number"){O=(Q<0?Math.max(0,N+Q):Q)}else{O=M.sortedIndex(R,P);return R[O]===P?O:-1}}if(n&&R.indexOf===n){return R.indexOf(P,Q)}for(;O<N;O++){if(R[O]===P){return O}}return -1};M.lastIndexOf=function(R,P,Q){if(R==null){return -1}var N=Q!=null;if(l&&R.lastIndexOf===l){return N?R.lastIndexOf(P,Q):R.lastIndexOf(P)}var O=(N?Q:R.length);while(O--){if(R[O]===P){return O}}return -1};M.range=function(S,Q,R){if(arguments.length<=1){Q=S||0;S=0}R=arguments[2]||1;var O=Math.max(Math.ceil((Q-S)/R),0);var N=0;var P=new Array(O);while(N<O){P[N++]=S;S+=R}return P};var G=function(){};M.bind=function(Q,O){var N,P;if(Q.bind===F&&F){return F.apply(Q,o.call(arguments,1))}if(!M.isFunction(Q)){throw new TypeError}N=o.call(arguments,2);return P=function(){if(!(this instanceof P)){return Q.apply(O,N.concat(o.call(arguments)))}G.prototype=Q.prototype;var S=new G;G.prototype=null;var R=Q.apply(S,N.concat(o.call(arguments)));if(Object(R)===R){return R}return S}};M.partial=function(O){var N=o.call(arguments,1);return function(){return O.apply(this,N.concat(o.call(arguments)))}};M.bindAll=function(O){var N=o.call(arguments,1);if(N.length===0){throw new Error("bindAll must be passed function names")}I(N,function(P){O[P]=M.bind(O[P],O)});return O};M.memoize=function(P,O){var N={};O||(O=M.identity);return function(){var Q=O.apply(this,arguments);return M.has(N,Q)?N[Q]:(N[Q]=P.apply(this,arguments))}};M.delay=function(O,P){var N=o.call(arguments,2);return setTimeout(function(){return O.apply(null,N)},P)};M.defer=function(N){return M.delay.apply(M,[N,1].concat(o.call(arguments,1)))};M.throttle=function(P,R,O){var N,T,U,V;var S=0;var Q=function(){S=new Date;U=null;V=P.apply(N,T)};return function(){var W=new Date;if(!S&&O===false){S=W}var X=R-(W-S);N=this;T=arguments;if(X<=0){clearTimeout(U);U=null;S=W;V=P.apply(N,T)}else{if(!U){U=setTimeout(Q,X)}}return V}};M.debounce=function(P,R,O){var Q,N;return function(){var V=this,U=arguments;var T=function(){Q=null;if(!O){N=P.apply(V,U)}};var S=O&&!Q;clearTimeout(Q);Q=setTimeout(T,R);if(S){N=P.apply(V,U)}return N}};M.once=function(P){var N=false,O;return function(){if(N){return O}N=true;O=P.apply(this,arguments);P=null;return O}};M.wrap=function(N,O){return function(){var P=[N];H.apply(P,arguments);return O.apply(this,P)}};M.compose=function(){var N=arguments;return function(){var O=arguments;for(var P=N.length-1;P>=0;P--){O=[N[P].apply(this,O)]}return O[0]}};M.after=function(O,N){if(O<=0){return N()}return function(){if(--O<1){return N.apply(this,arguments)}}};M.keys=e||function(P){if(P!==Object(P)){throw new TypeError("Invalid object")}var O=[];for(var N in P){if(M.has(P,N)){O.push(N)}}return O};M.values=function(P){var N=[];for(var O in P){if(M.has(P,O)){N.push(P[O])}}return N};M.pairs=function(P){var O=[];for(var N in P){if(M.has(P,N)){O.push([N,P[N]])}}return O};M.invert=function(P){var N={};for(var O in P){if(M.has(P,O)){N[P[O]]=O}}return N};M.functions=M.methods=function(P){var O=[];for(var N in P){if(M.isFunction(P[N])){O.push(N)}}return O.sort()};M.extend=function(N){I(o.call(arguments,1),function(O){if(O){for(var P in O){N[P]=O[P]}}});return N};M.pick=function(O){var P={};var N=y.apply(C,o.call(arguments,1));I(N,function(Q){if(Q in O){P[Q]=O[Q]}});return P};M.omit=function(P){var Q={};var O=y.apply(C,o.call(arguments,1));for(var N in P){if(!M.contains(O,N)){Q[N]=P[N]}}return Q};M.defaults=function(N){I(o.call(arguments,1),function(O){if(O){for(var P in O){if(N[P]===void 0){N[P]=O[P]}}}});return N};M.clone=function(N){if(!M.isObject(N)){return N}return M.isArray(N)?N.slice():M.extend({},N)};M.tap=function(O,N){N(O);return O};var J=function(U,T,O,P){if(U===T){return U!==0||1/U==1/T}if(U==null||T==null){return U===T}if(U instanceof M){U=U._wrapped}if(T instanceof M){T=T._wrapped}var R=d.call(U);if(R!=d.call(T)){return false}switch(R){case"[object String]":return U==String(T);case"[object Number]":return U!=+U?T!=+T:(U==0?1/U==1/T:U==+T);case"[object Date]":case"[object Boolean]":return +U==+T;case"[object RegExp]":return U.source==T.source&&U.global==T.global&&U.multiline==T.multiline&&U.ignoreCase==T.ignoreCase}if(typeof U!="object"||typeof T!="object"){return false}var N=O.length;while(N--){if(O[N]==U){return P[N]==T}}O.push(U);P.push(T);var W=0,X=true;if(R=="[object Array]"){W=U.length;X=W==T.length;if(X){while(W--){if(!(X=J(U[W],T[W],O,P))){break}}}}else{var S=U.constructor,Q=T.constructor;if(S!==Q&&!(M.isFunction(S)&&(S instanceof S)&&M.isFunction(Q)&&(Q instanceof Q))){return false}for(var V in U){if(M.has(U,V)){W++;if(!(X=M.has(T,V)&&J(U[V],T[V],O,P))){break}}}if(X){for(V in T){if(M.has(T,V)&&!(W--)){break}}X=!W}}O.pop();P.pop();return X};M.isEqual=function(O,N){return J(O,N,[],[])};M.isEmpty=function(O){if(O==null){return true}if(M.isArray(O)||M.isString(O)){return O.length===0}for(var N in O){if(M.has(O,N)){return false}}return true};M.isElement=function(N){return !!(N&&N.nodeType===1)};M.isArray=u||function(N){return d.call(N)=="[object Array]"};M.isObject=function(N){return N===Object(N)};I(["Arguments","Function","String","Number","Date","RegExp"],function(N){M["is"+N]=function(O){return d.call(O)=="[object "+N+"]"}});if(!M.isArguments(arguments)){M.isArguments=function(N){return !!(N&&M.has(N,"callee"))}}if(typeof(/./)!=="function"){M.isFunction=function(N){return typeof N==="function"}}M.isFinite=function(N){return isFinite(N)&&!isNaN(parseFloat(N))};M.isNaN=function(N){return M.isNumber(N)&&N!=+N};M.isBoolean=function(N){return N===true||N===false||d.call(N)=="[object Boolean]"};M.isNull=function(N){return N===null};M.isUndefined=function(N){return N===void 0};M.has=function(O,N){return j.call(O,N)};M.noConflict=function(){w._=k;return this};M.identity=function(N){return N};M.times=function(R,Q,P){var N=Array(R);for(var O=0;O<R;O++){N[O]=Q.call(P,O)}return N};M.random=function(O,N){if(N==null){N=O;O=0}return O+Math.floor(Math.random()*(N-O+1))};var m={escape:{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","/":"&#x2F;"}};m.unescape=M.invert(m.escape);var K={escape:new RegExp("["+M.keys(m.escape).join("")+"]","g"),unescape:new RegExp("("+M.keys(m.unescape).join("|")+")","g")};M.each(["escape","unescape"],function(N){M[N]=function(O){if(O==null){return""}return(""+O).replace(K[N],function(P){return m[N][P]})}});M.result=function(N,P){if(N==null){return void 0}var O=N[P];return M.isFunction(O)?O.call(N):O};M.mixin=function(N){I(M.functions(N),function(O){var P=M[O]=N[O];M.prototype[O]=function(){var Q=[this._wrapped];H.apply(Q,arguments);return s.call(this,P.apply(M,Q))}})};var z=0;M.uniqueId=function(N){var O=++z+"";return N?N+O:O};M.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var v=/(.)^/;var h={"'":"'","\\":"\\","\r":"r","\n":"n","\t":"t","\u2028":"u2028","\u2029":"u2029"};var i=/\\|'|\r|\n|\t|\u2028|\u2029/g;M.template=function(V,Q,P){var O;P=M.defaults({},P,M.templateSettings);var R=new RegExp([(P.escape||v).source,(P.interpolate||v).source,(P.evaluate||v).source].join("|")+"|$","g");var S=0;var N="__p+='";V.replace(R,function(X,Y,W,aa,Z){N+=V.slice(S,Z).replace(i,function(ab){return"\\"+h[ab]});if(Y){N+="'+\n((__t=("+Y+"))==null?'':_.escape(__t))+\n'"}if(W){N+="'+\n((__t=("+W+"))==null?'':__t)+\n'"}if(aa){N+="';\n"+aa+"\n__p+='"}S=Z+X.length;return X});N+="';\n";if(!P.variable){N="with(obj||{}){\n"+N+"}\n"}N="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+N+"return __p;\n";try{O=new Function(P.variable||"obj","_",N)}catch(T){T.source=N;throw T}if(Q){return O(Q,M)}var U=function(W){return O.call(this,W,M)};U.source="function("+(P.variable||"obj")+"){\n"+N+"}";return U};M.chain=function(N){return M(N).chain()};var s=function(N){return this._chain?M(N).chain():N};M.mixin(M);I(["pop","push","reverse","shift","sort","splice","unshift"],function(N){var O=C[N];M.prototype[N]=function(){var P=this._wrapped;O.apply(P,arguments);if((N=="shift"||N=="splice")&&P.length===0){delete P[0]}return s.call(this,P)}});I(["concat","join","slice"],function(N){var O=C[N];M.prototype[N]=function(){return s.call(this,O.apply(this._wrapped,arguments))}});M.extend(M.prototype,{chain:function(){this._chain=true;return this},value:function(){return this._wrapped}})}).call(this);
\ No newline at end of file