//     Backbone.js 1.0.0
2	
3	//     (c) 2010-2013 Jeremy Ashkenas, DocumentCloud Inc.
4	//     Backbone may be freely distributed under the MIT license.
5	//     For all details and documentation:
6	//     http://backbonejs.org
7	
8	(function(){
9	
10	  // Initial Setup
11	  // -------------
12	
13	  // Save a reference to the global object (`window` in the browser, `exports`
14	  // on the server).
15	  var root = this;
16	
17	  // Save the previous value of the `Backbone` variable, so that it can be
18	  // restored later on, if `noConflict` is used.
19	  var previousBackbone = root.Backbone;
20	
21	  // Create local references to array methods we'll want to use later.
22	  var array = [];
23	  var push = array.push;
24	  var slice = array.slice;
25	  var splice = array.splice;
26	
27	  // The top-level namespace. All public Backbone classes and modules will
28	  // be attached to this. Exported for both the browser and the server.
29	  var Backbone;
30	  if (typeof exports !== 'undefined') {
31	    Backbone = exports;
32	  } else {
33	    Backbone = root.Backbone = {};
34	  }
35	
36	  // Current version of the library. Keep in sync with `package.json`.
37	  Backbone.VERSION = '1.0.0';
38	
39	  // Require Underscore, if we're on the server, and it's not already present.
40	  var _ = root._;
41	  if (!_ && (typeof require !== 'undefined')) _ = require('underscore');
42	
43	  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
44	  // the `$` variable.
45	  Backbone.$ = root.jQuery || root.Zepto || root.ender || root.$;
46	
47	  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
48	  // to its previous owner. Returns a reference to this Backbone object.
49	  Backbone.noConflict = function() {
50	    root.Backbone = previousBackbone;
51	    return this;
52	  };
53	
54	  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
55	  // will fake `"PUT"` and `"DELETE"` requests via the `_method` parameter and
56	  // set a `X-Http-Method-Override` header.
57	  Backbone.emulateHTTP = false;
58	
59	  // Turn on `emulateJSON` to support legacy servers that can't deal with direct
60	  // `application/json` requests ... will encode the body as
61	  // `application/x-www-form-urlencoded` instead and will send the model in a
62	  // form param named `model`.
63	  Backbone.emulateJSON = false;
64	
65	  // Backbone.Events
66	  // ---------------
67	
68	  // A module that can be mixed in to *any object* in order to provide it with
69	  // custom events. You may bind with `on` or remove with `off` callback
70	  // functions to an event; `trigger`-ing an event fires all callbacks in
71	  // succession.
72	  //
73	  //     var object = {};
74	  //     _.extend(object, Backbone.Events);
75	  //     object.on('expand', function(){ alert('expanded'); });
76	  //     object.trigger('expand');
77	  //
78	  var Events = Backbone.Events = {
79	
80	    // Bind an event to a `callback` function. Passing `"all"` will bind
81	    // the callback to all events fired.
82	    on: function(name, callback, context) {
83	      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
84	      this._events || (this._events = {});
85	      var events = this._events[name] || (this._events[name] = []);
86	      events.push({callback: callback, context: context, ctx: context || this});
87	      return this;
88	    },
89	
90	    // Bind an event to only be triggered a single time. After the first time
91	    // the callback is invoked, it will be removed.
92	    once: function(name, callback, context) {
93	      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
94	      var self = this;
95	      var once = _.once(function() {
96	        self.off(name, once);
97	        callback.apply(this, arguments);
98	      });
99	      once._callback = callback;
100	      return this.on(name, once, context);
101	    },
102	
103	    // Remove one or many callbacks. If `context` is null, removes all
104	    // callbacks with that function. If `callback` is null, removes all
105	    // callbacks for the event. If `name` is null, removes all bound
106	    // callbacks for all events.
107	    off: function(name, callback, context) {
108	      var retain, ev, events, names, i, l, j, k;
109	      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
110	      if (!name && !callback && !context) {
111	        this._events = {};
112	        return this;
113	      }
114	
115	      names = name ? [name] : _.keys(this._events);
116	      for (i = 0, l = names.length; i < l; i++) {
117	        name = names[i];
118	        if (events = this._events[name]) {
119	          this._events[name] = retain = [];
120	          if (callback || context) {
121	            for (j = 0, k = events.length; j < k; j++) {
122	              ev = events[j];
123	              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
124	                  (context && context !== ev.context)) {
125	                retain.push(ev);
126	              }
127	            }
128	          }
129	          if (!retain.length) delete this._events[name];
130	        }
131	      }
132	
133	      return this;
134	    },
135	
136	    // Trigger one or many events, firing all bound callbacks. Callbacks are
137	    // passed the same arguments as `trigger` is, apart from the event name
138	    // (unless you're listening on `"all"`, which will cause your callback to
139	    // receive the true name of the event as the first argument).
140	    trigger: function(name) {
141	      if (!this._events) return this;
142	      var args = slice.call(arguments, 1);
143	      if (!eventsApi(this, 'trigger', name, args)) return this;
144	      var events = this._events[name];
145	      var allEvents = this._events.all;
146	      if (events) triggerEvents(events, args);
147	      if (allEvents) triggerEvents(allEvents, arguments);
148	      return this;
149	    },
150	
151	    // Tell this object to stop listening to either specific events ... or
152	    // to every object it's currently listening to.
153	    stopListening: function(obj, name, callback) {
154	      var listeners = this._listeners;
155	      if (!listeners) return this;
156	      var deleteListener = !name && !callback;
157	      if (typeof name === 'object') callback = this;
158	      if (obj) (listeners = {})[obj._listenerId] = obj;
159	      for (var id in listeners) {
160	        listeners[id].off(name, callback, this);
161	        if (deleteListener) delete this._listeners[id];
162	      }
163	      return this;
164	    }
165	
166	  };
167	
168	  // Regular expression used to split event strings.
169	  var eventSplitter = /\s+/;
170	
171	  // Implement fancy features of the Events API such as multiple event
172	  // names `"change blur"` and jQuery-style event maps `{change: action}`
173	  // in terms of the existing API.
174	  var eventsApi = function(obj, action, name, rest) {
175	    if (!name) return true;
176	
177	    // Handle event maps.
178	    if (typeof name === 'object') {
179	      for (var key in name) {
180	        obj[action].apply(obj, [key, name[key]].concat(rest));
181	      }
182	      return false;
183	    }
184	
185	    // Handle space separated event names.
186	    if (eventSplitter.test(name)) {
187	      var names = name.split(eventSplitter);
188	      for (var i = 0, l = names.length; i < l; i++) {
189	        obj[action].apply(obj, [names[i]].concat(rest));
190	      }
191	      return false;
192	    }
193	
194	    return true;
195	  };
196	
197	  // A difficult-to-believe, but optimized internal dispatch function for
198	  // triggering events. Tries to keep the usual cases speedy (most internal
199	  // Backbone events have 3 arguments).
200	  var triggerEvents = function(events, args) {
201	    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
202	    switch (args.length) {
203	      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
204	      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
205	      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
206	      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
207	      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
208	    }
209	  };
210	
211	  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
212	
213	  // Inversion-of-control versions of `on` and `once`. Tell *this* object to
214	  // listen to an event in another object ... keeping track of what it's
215	  // listening to.
216	  _.each(listenMethods, function(implementation, method) {
217	    Events[method] = function(obj, name, callback) {
218	      var listeners = this._listeners || (this._listeners = {});
219	      var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
220	      listeners[id] = obj;
221	      if (typeof name === 'object') callback = this;
222	      obj[implementation](name, callback, this);
223	      return this;
224	    };
225	  });
226	
227	  // Aliases for backwards compatibility.
228	  Events.bind   = Events.on;
229	  Events.unbind = Events.off;
230	
231	  // Allow the `Backbone` object to serve as a global event bus, for folks who
232	  // want global "pubsub" in a convenient place.
233	  _.extend(Backbone, Events);
234	
235	  // Backbone.Model
236	  // --------------
237	
238	  // Backbone **Models** are the basic data object in the framework --
239	  // frequently representing a row in a table in a database on your server.
240	  // A discrete chunk of data and a bunch of useful, related methods for
241	  // performing computations and transformations on that data.
242	
243	  // Create a new model with the specified attributes. A client id (`cid`)
244	  // is automatically generated and assigned for you.
245	  var Model = Backbone.Model = function(attributes, options) {
246	    var defaults;
247	    var attrs = attributes || {};
248	    options || (options = {});
249	    this.cid = _.uniqueId('c');
250	    this.attributes = {};
251	    _.extend(this, _.pick(options, modelOptions));
252	    if (options.parse) attrs = this.parse(attrs, options) || {};
253	    if (defaults = _.result(this, 'defaults')) {
254	      attrs = _.defaults({}, attrs, defaults);
255	    }
256	    this.set(attrs, options);
257	    this.changed = {};
258	    this.initialize.apply(this, arguments);
259	  };
260	
261	  // A list of options to be attached directly to the model, if provided.
262	  var modelOptions = ['url', 'urlRoot', 'collection'];
263	
264	  // Attach all inheritable methods to the Model prototype.
265	  _.extend(Model.prototype, Events, {
266	
267	    // A hash of attributes whose current and previous value differ.
268	    changed: null,
269	
270	    // The value returned during the last failed validation.
271	    validationError: null,
272	
273	    // The default name for the JSON `id` attribute is `"id"`. MongoDB and
274	    // CouchDB users may want to set this to `"_id"`.
275	    idAttribute: 'id',
276	
277	    // Initialize is an empty function by default. Override it with your own
278	    // initialization logic.
279	    initialize: function(){},
280	
281	    // Return a copy of the model's `attributes` object.
282	    toJSON: function(options) {
283	      return _.clone(this.attributes);
284	    },
285	
286	    // Proxy `Backbone.sync` by default -- but override this if you need
287	    // custom syncing semantics for *this* particular model.
288	    sync: function() {
289	      return Backbone.sync.apply(this, arguments);
290	    },
291	
292	    // Get the value of an attribute.
293	    get: function(attr) {
294	      return this.attributes[attr];
295	    },
296	
297	    // Get the HTML-escaped value of an attribute.
298	    escape: function(attr) {
299	      return _.escape(this.get(attr));
300	    },
301	
302	    // Returns `true` if the attribute contains a value that is not null
303	    // or undefined.
304	    has: function(attr) {
305	      return this.get(attr) != null;
306	    },
307	
308	    // Set a hash of model attributes on the object, firing `"change"`. This is
309	    // the core primitive operation of a model, updating the data and notifying
310	    // anyone who needs to know about the change in state. The heart of the beast.
311	    set: function(key, val, options) {
312	      var attr, attrs, unset, changes, silent, changing, prev, current;
313	      if (key == null) return this;
314	
315	      // Handle both `"key", value` and `{key: value}` -style arguments.
316	      if (typeof key === 'object') {
317	        attrs = key;
318	        options = val;
319	      } else {
320	        (attrs = {})[key] = val;
321	      }
322	
323	      options || (options = {});
324	
325	      // Run validation.
326	      if (!this._validate(attrs, options)) return false;
327	
328	      // Extract attributes and options.
329	      unset           = options.unset;
330	      silent          = options.silent;
331	      changes         = [];
332	      changing        = this._changing;
333	      this._changing  = true;
334	
335	      if (!changing) {
336	        this._previousAttributes = _.clone(this.attributes);
337	        this.changed = {};
338	      }
339	      current = this.attributes, prev = this._previousAttributes;
340	
341	      // Check for changes of `id`.
342	      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
343	
344	      // For each `set` attribute, update or delete the current value.
345	      for (attr in attrs) {
346	        val = attrs[attr];
347	        if (!_.isEqual(current[attr], val)) changes.push(attr);
348	        if (!_.isEqual(prev[attr], val)) {
349	          this.changed[attr] = val;
350	        } else {
351	          delete this.changed[attr];
352	        }
353	        unset ? delete current[attr] : current[attr] = val;
354	      }
355	
356	      // Trigger all relevant attribute changes.
357	      if (!silent) {
358	        if (changes.length) this._pending = true;
359	        for (var i = 0, l = changes.length; i < l; i++) {
360	          this.trigger('change:' + changes[i], this, current[changes[i]], options);
361	        }
362	      }
363	
364	      // You might be wondering why there's a `while` loop here. Changes can
365	      // be recursively nested within `"change"` events.
366	      if (changing) return this;
367	      if (!silent) {
368	        while (this._pending) {
369	          this._pending = false;
370	          this.trigger('change', this, options);
371	        }
372	      }
373	      this._pending = false;
374	      this._changing = false;
375	      return this;
376	    },
377	
378	    // Remove an attribute from the model, firing `"change"`. `unset` is a noop
379	    // if the attribute doesn't exist.
380	    unset: function(attr, options) {
381	      return this.set(attr, void 0, _.extend({}, options, {unset: true}));
382	    },
383	
384	    // Clear all attributes on the model, firing `"change"`.
385	    clear: function(options) {
386	      var attrs = {};
387	      for (var key in this.attributes) attrs[key] = void 0;
388	      return this.set(attrs, _.extend({}, options, {unset: true}));
389	    },
390	
391	    // Determine if the model has changed since the last `"change"` event.
392	    // If you specify an attribute name, determine if that attribute has changed.
393	    hasChanged: function(attr) {
394	      if (attr == null) return !_.isEmpty(this.changed);
395	      return _.has(this.changed, attr);
396	    },
397	
398	    // Return an object containing all the attributes that have changed, or
399	    // false if there are no changed attributes. Useful for determining what
400	    // parts of a view need to be updated and/or what attributes need to be
401	    // persisted to the server. Unset attributes will be set to undefined.
402	    // You can also pass an attributes object to diff against the model,
403	    // determining if there *would be* a change.
404	    changedAttributes: function(diff) {
405	      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
406	      var val, changed = false;
407	      var old = this._changing ? this._previousAttributes : this.attributes;
408	      for (var attr in diff) {
409	        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
410	        (changed || (changed = {}))[attr] = val;
411	      }
412	      return changed;
413	    },
414	
415	    // Get the previous value of an attribute, recorded at the time the last
416	    // `"change"` event was fired.
417	    previous: function(attr) {
418	      if (attr == null || !this._previousAttributes) return null;
419	      return this._previousAttributes[attr];
420	    },
421	
422	    // Get all of the attributes of the model at the time of the previous
423	    // `"change"` event.
424	    previousAttributes: function() {
425	      return _.clone(this._previousAttributes);
426	    },
427	
428	    // Fetch the model from the server. If the server's representation of the
429	    // model differs from its current attributes, they will be overridden,
430	    // triggering a `"change"` event.
431	    fetch: function(options) {
432	      options = options ? _.clone(options) : {};
433	      if (options.parse === void 0) options.parse = true;
434	      var model = this;
435	      var success = options.success;
436	      options.success = function(resp) {
437	        if (!model.set(model.parse(resp, options), options)) return false;
438	        if (success) success(model, resp, options);
439	        model.trigger('sync', model, resp, options);
440	      };
441	      wrapError(this, options);
442	      return this.sync('read', this, options);
443	    },
444	
445	    // Set a hash of model attributes, and sync the model to the server.
446	    // If the server returns an attributes hash that differs, the model's
447	    // state will be `set` again.
448	    save: function(key, val, options) {
449	      var attrs, method, xhr, attributes = this.attributes;
450	
451	      // Handle both `"key", value` and `{key: value}` -style arguments.
452	      if (key == null || typeof key === 'object') {
453	        attrs = key;
454	        options = val;
455	      } else {
456	        (attrs = {})[key] = val;
457	      }
458	
459	      // If we're not waiting and attributes exist, save acts as `set(attr).save(null, opts)`.
460	      if (attrs && (!options || !options.wait) && !this.set(attrs, options)) return false;
461	
462	      options = _.extend({validate: true}, options);
463	
464	      // Do not persist invalid models.
465	      if (!this._validate(attrs, options)) return false;
466	
467	      // Set temporary attributes if `{wait: true}`.
468	      if (attrs && options.wait) {
469	        this.attributes = _.extend({}, attributes, attrs);
470	      }
471	
472	      // After a successful server-side save, the client is (optionally)
473	      // updated with the server-side state.
474	      if (options.parse === void 0) options.parse = true;
475	      var model = this;
476	      var success = options.success;
477	      options.success = function(resp) {
478	        // Ensure attributes are restored during synchronous saves.
479	        model.attributes = attributes;
480	        var serverAttrs = model.parse(resp, options);
481	        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
482	        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
483	          return false;
484	        }
485	        if (success) success(model, resp, options);
486	        model.trigger('sync', model, resp, options);
487	      };
488	      wrapError(this, options);
489	
490	      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
491	      if (method === 'patch') options.attrs = attrs;
492	      xhr = this.sync(method, this, options);
493	
494	      // Restore attributes.
495	      if (attrs && options.wait) this.attributes = attributes;
496	
497	      return xhr;
498	    },
499	
500	    // Destroy this model on the server if it was already persisted.
501	    // Optimistically removes the model from its collection, if it has one.
502	    // If `wait: true` is passed, waits for the server to respond before removal.
503	    destroy: function(options) {
504	      options = options ? _.clone(options) : {};
505	      var model = this;
506	      var success = options.success;
507	
508	      var destroy = function() {
509	        model.trigger('destroy', model, model.collection, options);
510	      };
511	
512	      options.success = function(resp) {
513	        if (options.wait || model.isNew()) destroy();
514	        if (success) success(model, resp, options);
515	        if (!model.isNew()) model.trigger('sync', model, resp, options);
516	      };
517	
518	      if (this.isNew()) {
519	        options.success();
520	        return false;
521	      }
522	      wrapError(this, options);
523	
524	      var xhr = this.sync('delete', this, options);
525	      if (!options.wait) destroy();
526	      return xhr;
527	    },
528	
529	    // Default URL for the model's representation on the server -- if you're
530	    // using Backbone's restful methods, override this to change the endpoint
531	    // that will be called.
532	    url: function() {
533	      var base = _.result(this, 'urlRoot') || _.result(this.collection, 'url') || urlError();
534	      if (this.isNew()) return base;
535	      return base + (base.charAt(base.length - 1) === '/' ? '' : '/') + encodeURIComponent(this.id);
536	    },
537	
538	    // **parse** converts a response into the hash of attributes to be `set` on
539	    // the model. The default implementation is just to pass the response along.
540	    parse: function(resp, options) {
541	      return resp;
542	    },
543	
544	    // Create a new model with identical attributes to this one.
545	    clone: function() {
546	      return new this.constructor(this.attributes);
547	    },
548	
549	    // A model is new if it has never been saved to the server, and lacks an id.
550	    isNew: function() {
551	      return this.id == null;
552	    },
553	
554	    // Check if the model is currently in a valid state.
555	    isValid: function(options) {
556	      return this._validate({}, _.extend(options || {}, { validate: true }));
557	    },
558	
559	    // Run validation against the next complete set of model attributes,
560	    // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
561	    _validate: function(attrs, options) {
562	      if (!options.validate || !this.validate) return true;
563	      attrs = _.extend({}, this.attributes, attrs);
564	      var error = this.validationError = this.validate(attrs, options) || null;
565	      if (!error) return true;
566	      this.trigger('invalid', this, error, _.extend(options || {}, {validationError: error}));
567	      return false;
568	    }
569	
570	  });
571	
572	  // Underscore methods that we want to implement on the Model.
573	  var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
574	
575	  // Mix in each Underscore method as a proxy to `Model#attributes`.
576	  _.each(modelMethods, function(method) {
577	    Model.prototype[method] = function() {
578	      var args = slice.call(arguments);
579	      args.unshift(this.attributes);
580	      return _[method].apply(_, args);
581	    };
582	  });
583	
584	  // Backbone.Collection
585	  // -------------------
586	
587	  // If models tend to represent a single row of data, a Backbone Collection is
588	  // more analagous to a table full of data ... or a small slice or page of that
589	  // table, or a collection of rows that belong together for a particular reason
590	  // -- all of the messages in this particular folder, all of the documents
591	  // belonging to this particular author, and so on. Collections maintain
592	  // indexes of their models, both in order, and for lookup by `id`.
593	
594	  // Create a new **Collection**, perhaps to contain a specific type of `model`.
595	  // If a `comparator` is specified, the Collection will maintain
596	  // its models in sort order, as they're added and removed.
597	  var Collection = Backbone.Collection = function(models, options) {
598	    options || (options = {});
599	    if (options.url) this.url = options.url;
600	    if (options.model) this.model = options.model;
601	    if (options.comparator !== void 0) this.comparator = options.comparator;
602	    this._reset();
603	    this.initialize.apply(this, arguments);
604	    if (models) this.reset(models, _.extend({silent: true}, options));
605	  };
606	
607	  // Default options for `Collection#set`.
608	  var setOptions = {add: true, remove: true, merge: true};
609	  var addOptions = {add: true, merge: false, remove: false};
610	
611	  // Define the Collection's inheritable methods.
612	  _.extend(Collection.prototype, Events, {
613	
614	    // The default model for a collection is just a **Backbone.Model**.
615	    // This should be overridden in most cases.
616	    model: Model,
617	
618	    // Initialize is an empty function by default. Override it with your own
619	    // initialization logic.
620	    initialize: function(){},
621	
622	    // The JSON representation of a Collection is an array of the
623	    // models' attributes.
624	    toJSON: function(options) {
625	      return this.map(function(model){ return model.toJSON(options); });
626	    },
627	
628	    // Proxy `Backbone.sync` by default.
629	    sync: function() {
630	      return Backbone.sync.apply(this, arguments);
631	    },
632	
633	    // Add a model, or list of models to the set.
634	    add: function(models, options) {
635	      return this.set(models, _.defaults(options || {}, addOptions));
636	    },
637	
638	    // Remove a model, or a list of models from the set.
639	    remove: function(models, options) {
640	      models = _.isArray(models) ? models.slice() : [models];
641	      options || (options = {});
642	      var i, l, index, model;
643	      for (i = 0, l = models.length; i < l; i++) {
644	        model = this.get(models[i]);
645	        if (!model) continue;
646	        delete this._byId[model.id];
647	        delete this._byId[model.cid];
648	        index = this.indexOf(model);
649	        this.models.splice(index, 1);
650	        this.length--;
651	        if (!options.silent) {
652	          options.index = index;
653	          model.trigger('remove', model, this, options);
654	        }
655	        this._removeReference(model);
656	      }
657	      return this;
658	    },
659	
660	    // Update a collection by `set`-ing a new list of models, adding new ones,
661	    // removing models that are no longer present, and merging models that
662	    // already exist in the collection, as necessary. Similar to **Model#set**,
663	    // the core operation for updating the data contained by the collection.
664	    set: function(models, options) {
665	      options = _.defaults(options || {}, setOptions);
666	      if (options.parse) models = this.parse(models, options);
667	      if (!_.isArray(models)) models = models ? [models] : [];
668	      var i, l, model, attrs, existing, sort;
669	      var at = options.at;
670	      var sortable = this.comparator && (at == null) && options.sort !== false;
671	      var sortAttr = _.isString(this.comparator) ? this.comparator : null;
672	      var toAdd = [], toRemove = [], modelMap = {};
673	
674	      // Turn bare objects into model references, and prevent invalid models
675	      // from being added.
676	      for (i = 0, l = models.length; i < l; i++) {
677	        if (!(model = this._prepareModel(models[i], options))) continue;
678	
679	        // If a duplicate is found, prevent it from being added and
680	        // optionally merge it into the existing model.
681	        if (existing = this.get(model)) {
682	          if (options.remove) modelMap[existing.cid] = true;
683	          if (options.merge) {
684	            existing.set(model.attributes, options);
685	            if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
686	          }
687	
688	        // This is a new model, push it to the `toAdd` list.
689	        } else if (options.add) {
690	          toAdd.push(model);
691	
692	          // Listen to added models' events, and index models for lookup by
693	          // `id` and by `cid`.
694	          model.on('all', this._onModelEvent, this);
695	          this._byId[model.cid] = model;
696	          if (model.id != null) this._byId[model.id] = model;
697	        }
698	      }
699	
700	      // Remove nonexistent models if appropriate.
701	      if (options.remove) {
702	        for (i = 0, l = this.length; i < l; ++i) {
703	          if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
704	        }
705	        if (toRemove.length) this.remove(toRemove, options);
706	      }
707	
708	      // See if sorting is needed, update `length` and splice in new models.
709	      if (toAdd.length) {
710	        if (sortable) sort = true;
711	        this.length += toAdd.length;
712	        if (at != null) {
713	          splice.apply(this.models, [at, 0].concat(toAdd));
714	        } else {
715	          push.apply(this.models, toAdd);
716	        }
717	      }
718	
719	      // Silently sort the collection if appropriate.
720	      if (sort) this.sort({silent: true});
721	
722	      if (options.silent) return this;
723	
724	      // Trigger `add` events.
725	      for (i = 0, l = toAdd.length; i < l; i++) {
726	        (model = toAdd[i]).trigger('add', model, this, options);
727	      }
728	
729	      // Trigger `sort` if the collection was sorted.
730	      if (sort) this.trigger('sort', this, options);
731	      return this;
732	    },
733	
734	    // When you have more items than you want to add or remove individually,
735	    // you can reset the entire set with a new list of models, without firing
736	    // any granular `add` or `remove` events. Fires `reset` when finished.
737	    // Useful for bulk operations and optimizations.
738	    reset: function(models, options) {
739	      options || (options = {});
740	      for (var i = 0, l = this.models.length; i < l; i++) {
741	        this._removeReference(this.models[i]);
742	      }
743	      options.previousModels = this.models;
744	      this._reset();
745	      this.add(models, _.extend({silent: true}, options));
746	      if (!options.silent) this.trigger('reset', this, options);
747	      return this;
748	    },
749	
750	    // Add a model to the end of the collection.
751	    push: function(model, options) {
752	      model = this._prepareModel(model, options);
753	      this.add(model, _.extend({at: this.length}, options));
754	      return model;
755	    },
756	
757	    // Remove a model from the end of the collection.
758	    pop: function(options) {
759	      var model = this.at(this.length - 1);
760	      this.remove(model, options);
761	      return model;
762	    },
763	
764	    // Add a model to the beginning of the collection.
765	    unshift: function(model, options) {
766	      model = this._prepareModel(model, options);
767	      this.add(model, _.extend({at: 0}, options));
768	      return model;
769	    },
770	
771	    // Remove a model from the beginning of the collection.
772	    shift: function(options) {
773	      var model = this.at(0);
774	      this.remove(model, options);
775	      return model;
776	    },
777	
778	    // Slice out a sub-array of models from the collection.
779	    slice: function(begin, end) {
780	      return this.models.slice(begin, end);
781	    },
782	
783	    // Get a model from the set by id.
784	    get: function(obj) {
785	      if (obj == null) return void 0;
786	      return this._byId[obj.id != null ? obj.id : obj.cid || obj];
787	    },
788	
789	    // Get the model at the given index.
790	    at: function(index) {
791	      return this.models[index];
792	    },
793	
794	    // Return models with matching attributes. Useful for simple cases of
795	    // `filter`.
796	    where: function(attrs, first) {
797	      if (_.isEmpty(attrs)) return first ? void 0 : [];
798	      return this[first ? 'find' : 'filter'](function(model) {
799	        for (var key in attrs) {
800	          if (attrs[key] !== model.get(key)) return false;
801	        }
802	        return true;
803	      });
804	    },
805	
806	    // Return the first model with matching attributes. Useful for simple cases
807	    // of `find`.
808	    findWhere: function(attrs) {
809	      return this.where(attrs, true);
810	    },
811	
812	    // Force the collection to re-sort itself. You don't need to call this under
813	    // normal circumstances, as the set will maintain sort order as each item
814	    // is added.
815	    sort: function(options) {
816	      if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
817	      options || (options = {});
818	
819	      // Run sort based on type of `comparator`.
820	      if (_.isString(this.comparator) || this.comparator.length === 1) {
821	        this.models = this.sortBy(this.comparator, this);
822	      } else {
823	        this.models.sort(_.bind(this.comparator, this));
824	      }
825	
826	      if (!options.silent) this.trigger('sort', this, options);
827	      return this;
828	    },
829	
830	    // Figure out the smallest index at which a model should be inserted so as
831	    // to maintain order.
832	    sortedIndex: function(model, value, context) {
833	      value || (value = this.comparator);
834	      var iterator = _.isFunction(value) ? value : function(model) {
835	        return model.get(value);
836	      };
837	      return _.sortedIndex(this.models, model, iterator, context);
838	    },
839	
840	    // Pluck an attribute from each model in the collection.
841	    pluck: function(attr) {
842	      return _.invoke(this.models, 'get', attr);
843	    },
844	
845	    // Fetch the default set of models for this collection, resetting the
846	    // collection when they arrive. If `reset: true` is passed, the response
847	    // data will be passed through the `reset` method instead of `set`.
848	    fetch: function(options) {
849	      options = options ? _.clone(options) : {};
850	      if (options.parse === void 0) options.parse = true;
851	      var success = options.success;
852	      var collection = this;
853	      options.success = function(resp) {
854	        var method = options.reset ? 'reset' : 'set';
855	        collection[method](resp, options);
856	        if (success) success(collection, resp, options);
857	        collection.trigger('sync', collection, resp, options);
858	      };
859	      wrapError(this, options);
860	      return this.sync('read', this, options);
861	    },
862	
863	    // Create a new instance of a model in this collection. Add the model to the
864	    // collection immediately, unless `wait: true` is passed, in which case we
865	    // wait for the server to agree.
866	    create: function(model, options) {
867	      options = options ? _.clone(options) : {};
868	      if (!(model = this._prepareModel(model, options))) return false;
869	      if (!options.wait) this.add(model, options);
870	      var collection = this;
871	      var success = options.success;
872	      options.success = function(resp) {
873	        if (options.wait) collection.add(model, options);
874	        if (success) success(model, resp, options);
875	      };
876	      model.save(null, options);
877	      return model;
878	    },
879	
880	    // **parse** converts a response into a list of models to be added to the
881	    // collection. The default implementation is just to pass it through.
882	    parse: function(resp, options) {
883	      return resp;
884	    },
885	
886	    // Create a new collection with an identical list of models as this one.
887	    clone: function() {
888	      return new this.constructor(this.models);
889	    },
890	
891	    // Private method to reset all internal state. Called when the collection
892	    // is first initialized or reset.
893	    _reset: function() {
894	      this.length = 0;
895	      this.models = [];
896	      this._byId  = {};
897	    },
898	
899	    // Prepare a hash of attributes (or other model) to be added to this
900	    // collection.
901	    _prepareModel: function(attrs, options) {
902	      if (attrs instanceof Model) {
903	        if (!attrs.collection) attrs.collection = this;
904	        return attrs;
905	      }
906	      options || (options = {});
907	      options.collection = this;
908	      var model = new this.model(attrs, options);
909	      if (!model._validate(attrs, options)) {
910	        this.trigger('invalid', this, attrs, options);
911	        return false;
912	      }
913	      return model;
914	    },
915	
916	    // Internal method to sever a model's ties to a collection.
917	    _removeReference: function(model) {
918	      if (this === model.collection) delete model.collection;
919	      model.off('all', this._onModelEvent, this);
920	    },
921	
922	    // Internal method called every time a model in the set fires an event.
923	    // Sets need to update their indexes when models change ids. All other
924	    // events simply proxy through. "add" and "remove" events that originate
925	    // in other collections are ignored.
926	    _onModelEvent: function(event, model, collection, options) {
927	      if ((event === 'add' || event === 'remove') && collection !== this) return;
928	      if (event === 'destroy') this.remove(model, options);
929	      if (model && event === 'change:' + model.idAttribute) {
930	        delete this._byId[model.previous(model.idAttribute)];
931	        if (model.id != null) this._byId[model.id] = model;
932	      }
933	      this.trigger.apply(this, arguments);
934	    }
935	
936	  });
937	
938	  // Underscore methods that we want to implement on the Collection.
939	  // 90% of the core usefulness of Backbone Collections is actually implemented
940	  // right here:
941	  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
942	    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
943	    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
944	    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
945	    'tail', 'drop', 'last', 'without', 'indexOf', 'shuffle', 'lastIndexOf',
946	    'isEmpty', 'chain'];
947	
948	  // Mix in each Underscore method as a proxy to `Collection#models`.
949	  _.each(methods, function(method) {
950	    Collection.prototype[method] = function() {
951	      var args = slice.call(arguments);
952	      args.unshift(this.models);
953	      return _[method].apply(_, args);
954	    };
955	  });
956	
957	  // Underscore methods that take a property name as an argument.
958	  var attributeMethods = ['groupBy', 'countBy', 'sortBy'];
959	
960	  // Use attributes instead of properties.
961	  _.each(attributeMethods, function(method) {
962	    Collection.prototype[method] = function(value, context) {
963	      var iterator = _.isFunction(value) ? value : function(model) {
964	        return model.get(value);
965	      };
966	      return _[method](this.models, iterator, context);
967	    };
968	  });
969	
970	  // Backbone.View
971	  // -------------
972	
973	  // Backbone Views are almost more convention than they are actual code. A View
974	  // is simply a JavaScript object that represents a logical chunk of UI in the
975	  // DOM. This might be a single item, an entire list, a sidebar or panel, or
976	  // even the surrounding frame which wraps your whole app. Defining a chunk of
977	  // UI as a **View** allows you to define your DOM events declaratively, without
978	  // having to worry about render order ... and makes it easy for the view to
979	  // react to specific changes in the state of your models.
980	
981	  // Creating a Backbone.View creates its initial element outside of the DOM,
982	  // if an existing element is not provided...
983	  var View = Backbone.View = function(options) {
984	    this.cid = _.uniqueId('view');
985	    this._configure(options || {});
986	    this._ensureElement();
987	    this.initialize.apply(this, arguments);
988	    this.delegateEvents();
989	  };
990	
991	  // Cached regex to split keys for `delegate`.
992	  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
993	
994	  // List of view options to be merged as properties.
995	  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
996	
997	  // Set up all inheritable **Backbone.View** properties and methods.
998	  _.extend(View.prototype, Events, {
999	
1000	    // The default `tagName` of a View's element is `"div"`.
1001	    tagName: 'div',
1002	
1003	    // jQuery delegate for element lookup, scoped to DOM elements within the
1004	    // current view. This should be prefered to global lookups where possible.
1005	    $: function(selector) {
1006	      return this.$el.find(selector);
1007	    },
1008	
1009	    // Initialize is an empty function by default. Override it with your own
1010	    // initialization logic.
1011	    initialize: function(){},
1012	
1013	    // **render** is the core function that your view should override, in order
1014	    // to populate its element (`this.el`), with the appropriate HTML. The
1015	    // convention is for **render** to always return `this`.
1016	    render: function() {
1017	      return this;
1018	    },
1019	
1020	    // Remove this view by taking the element out of the DOM, and removing any
1021	    // applicable Backbone.Events listeners.
1022	    remove: function() {
1023	      this.$el.remove();
1024	      this.stopListening();
1025	      return this;
1026	    },
1027	
1028	    // Change the view's element (`this.el` property), including event
1029	    // re-delegation.
1030	    setElement: function(element, delegate) {
1031	      if (this.$el) this.undelegateEvents();
1032	      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
1033	      this.el = this.$el[0];
1034	      if (delegate !== false) this.delegateEvents();
1035	      return this;
1036	    },
1037	
1038	    // Set callbacks, where `this.events` is a hash of
1039	    //
1040	    // *{"event selector": "callback"}*
1041	    //
1042	    //     {
1043	    //       'mousedown .title':  'edit',
1044	    //       'click .button':     'save'
1045	    //       'click .open':       function(e) { ... }
1046	    //     }
1047	    //
1048	    // pairs. Callbacks will be bound to the view, with `this` set properly.
1049	    // Uses event delegation for efficiency.
1050	    // Omitting the selector binds the event to `this.el`.
1051	    // This only works for delegate-able events: not `focus`, `blur`, and
1052	    // not `change`, `submit`, and `reset` in Internet Explorer.
1053	    delegateEvents: function(events) {
1054	      if (!(events || (events = _.result(this, 'events')))) return this;
1055	      this.undelegateEvents();
1056	      for (var key in events) {
1057	        var method = events[key];
1058	        if (!_.isFunction(method)) method = this[events[key]];
1059	        if (!method) continue;
1060	
1061	        var match = key.match(delegateEventSplitter);
1062	        var eventName = match[1], selector = match[2];
1063	        method = _.bind(method, this);
1064	        eventName += '.delegateEvents' + this.cid;
1065	        if (selector === '') {
1066	          this.$el.on(eventName, method);
1067	        } else {
1068	          this.$el.on(eventName, selector, method);
1069	        }
1070	      }
1071	      return this;
1072	    },
1073	
1074	    // Clears all callbacks previously bound to the view with `delegateEvents`.
1075	    // You usually don't need to use this, but may wish to if you have multiple
1076	    // Backbone views attached to the same DOM element.
1077	    undelegateEvents: function() {
1078	      this.$el.off('.delegateEvents' + this.cid);
1079	      return this;
1080	    },
1081	
1082	    // Performs the initial configuration of a View with a set of options.
1083	    // Keys with special meaning *(e.g. model, collection, id, className)* are
1084	    // attached directly to the view.  See `viewOptions` for an exhaustive
1085	    // list.
1086	    _configure: function(options) {
1087	      if (this.options) options = _.extend({}, _.result(this, 'options'), options);
1088	      _.extend(this, _.pick(options, viewOptions));
1089	      this.options = options;
1090	    },
1091	
1092	    // Ensure that the View has a DOM element to render into.
1093	    // If `this.el` is a string, pass it through `$()`, take the first
1094	    // matching element, and re-assign it to `el`. Otherwise, create
1095	    // an element from the `id`, `className` and `tagName` properties.
1096	    _ensureElement: function() {
1097	      if (!this.el) {
1098	        var attrs = _.extend({}, _.result(this, 'attributes'));
1099	        if (this.id) attrs.id = _.result(this, 'id');
1100	        if (this.className) attrs['class'] = _.result(this, 'className');
1101	        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
1102	        this.setElement($el, false);
1103	      } else {
1104	        this.setElement(_.result(this, 'el'), false);
1105	      }
1106	    }
1107	
1108	  });
1109	
1110	  // Backbone.sync
1111	  // -------------
1112	
1113	  // Override this function to change the manner in which Backbone persists
1114	  // models to the server. You will be passed the type of request, and the
1115	  // model in question. By default, makes a RESTful Ajax request
1116	  // to the model's `url()`. Some possible customizations could be:
1117	  //
1118	  // * Use `setTimeout` to batch rapid-fire updates into a single request.
1119	  // * Send up the models as XML instead of JSON.
1120	  // * Persist models via WebSockets instead of Ajax.
1121	  //
1122	  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
1123	  // as `POST`, with a `_method` parameter containing the true HTTP method,
1124	  // as well as all requests with the body as `application/x-www-form-urlencoded`
1125	  // instead of `application/json` with the model in a param named `model`.
1126	  // Useful when interfacing with server-side languages like **PHP** that make
1127	  // it difficult to read the body of `PUT` requests.
1128	  Backbone.sync = function(method, model, options) {
1129	    var type = methodMap[method];
1130	
1131	    // Default options, unless specified.
1132	    _.defaults(options || (options = {}), {
1133	      emulateHTTP: Backbone.emulateHTTP,
1134	      emulateJSON: Backbone.emulateJSON
1135	    });
1136	
1137	    // Default JSON-request options.
1138	    var params = {type: type, dataType: 'json'};
1139	
1140	    // Ensure that we have a URL.
1141	    if (!options.url) {
1142	      params.url = _.result(model, 'url') || urlError();
1143	    }
1144	
1145	    // Ensure that we have the appropriate request data.
1146	    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
1147	      params.contentType = 'application/json';
1148	      params.data = JSON.stringify(options.attrs || model.toJSON(options));
1149	    }
1150	
1151	    // For older servers, emulate JSON by encoding the request into an HTML-form.
1152	    if (options.emulateJSON) {
1153	      params.contentType = 'application/x-www-form-urlencoded';
1154	      params.data = params.data ? {model: params.data} : {};
1155	    }
1156	
1157	    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
1158	    // And an `X-HTTP-Method-Override` header.
1159	    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
1160	      params.type = 'POST';
1161	      if (options.emulateJSON) params.data._method = type;
1162	      var beforeSend = options.beforeSend;
1163	      options.beforeSend = function(xhr) {
1164	        xhr.setRequestHeader('X-HTTP-Method-Override', type);
1165	        if (beforeSend) return beforeSend.apply(this, arguments);
1166	      };
1167	    }
1168	
1169	    // Don't process data on a non-GET request.
1170	    if (params.type !== 'GET' && !options.emulateJSON) {
1171	      params.processData = false;
1172	    }
1173	
1174	    // If we're sending a `PATCH` request, and we're in an old Internet Explorer
1175	    // that still has ActiveX enabled by default, override jQuery to use that
1176	    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
1177	    if (params.type === 'PATCH' && window.ActiveXObject &&
1178	          !(window.external && window.external.msActiveXFilteringEnabled)) {
1179	      params.xhr = function() {
1180	        return new ActiveXObject("Microsoft.XMLHTTP");
1181	      };
1182	    }
1183	
1184	    // Make the request, allowing the user to override any Ajax options.
1185	    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
1186	    model.trigger('request', model, xhr, options);
1187	    return xhr;
1188	  };
1189	
1190	  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
1191	  var methodMap = {
1192	    'create': 'POST',
1193	    'update': 'PUT',
1194	    'patch':  'PATCH',
1195	    'delete': 'DELETE',
1196	    'read':   'GET'
1197	  };
1198	
1199	  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
1200	  // Override this if you'd like to use a different library.
1201	  Backbone.ajax = function() {
1202	    return Backbone.$.ajax.apply(Backbone.$, arguments);
1203	  };
1204	
1205	  // Backbone.Router
1206	  // ---------------
1207	
1208	  // Routers map faux-URLs to actions, and fire events when routes are
1209	  // matched. Creating a new one sets its `routes` hash, if not set statically.
1210	  var Router = Backbone.Router = function(options) {
1211	    options || (options = {});
1212	    if (options.routes) this.routes = options.routes;
1213	    this._bindRoutes();
1214	    this.initialize.apply(this, arguments);
1215	  };
1216	
1217	  // Cached regular expressions for matching named param parts and splatted
1218	  // parts of route strings.
1219	  var optionalParam = /\((.*?)\)/g;
1220	  var namedParam    = /(\(\?)?:\w+/g;
1221	  var splatParam    = /\*\w+/g;
1222	  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
1223	
1224	  // Set up all inheritable **Backbone.Router** properties and methods.
1225	  _.extend(Router.prototype, Events, {
1226	
1227	    // Initialize is an empty function by default. Override it with your own
1228	    // initialization logic.
1229	    initialize: function(){},
1230	
1231	    // Manually bind a single named route to a callback. For example:
1232	    //
1233	    //     this.route('search/:query/p:num', 'search', function(query, num) {
1234	    //       ...
1235	    //     });
1236	    //
1237	    route: function(route, name, callback) {
1238	      if (!_.isRegExp(route)) route = this._routeToRegExp(route);
1239	      if (_.isFunction(name)) {
1240	        callback = name;
1241	        name = '';
1242	      }
1243	      if (!callback) callback = this[name];
1244	      var router = this;
1245	      Backbone.history.route(route, function(fragment) {
1246	        var args = router._extractParameters(route, fragment);
1247	        callback && callback.apply(router, args);
1248	        router.trigger.apply(router, ['route:' + name].concat(args));
1249	        router.trigger('route', name, args);
1250	        Backbone.history.trigger('route', router, name, args);
1251	      });
1252	      return this;
1253	    },
1254	
1255	    // Simple proxy to `Backbone.history` to save a fragment into the history.
1256	    navigate: function(fragment, options) {
1257	      Backbone.history.navigate(fragment, options);
1258	      return this;
1259	    },
1260	
1261	    // Bind all defined routes to `Backbone.history`. We have to reverse the
1262	    // order of the routes here to support behavior where the most general
1263	    // routes can be defined at the bottom of the route map.
1264	    _bindRoutes: function() {
1265	      if (!this.routes) return;
1266	      this.routes = _.result(this, 'routes');
1267	      var route, routes = _.keys(this.routes);
1268	      while ((route = routes.pop()) != null) {
1269	        this.route(route, this.routes[route]);
1270	      }
1271	    },
1272	
1273	    // Convert a route string into a regular expression, suitable for matching
1274	    // against the current location hash.
1275	    _routeToRegExp: function(route) {
1276	      route = route.replace(escapeRegExp, '\\$&')
1277	                   .replace(optionalParam, '(?:$1)?')
1278	                   .replace(namedParam, function(match, optional){
1279	                     return optional ? match : '([^\/]+)';
1280	                   })
1281	                   .replace(splatParam, '(.*?)');
1282	      return new RegExp('^' + route + '$');
1283	    },
1284	
1285	    // Given a route, and a URL fragment that it matches, return the array of
1286	    // extracted decoded parameters. Empty or unmatched parameters will be
1287	    // treated as `null` to normalize cross-browser behavior.
1288	    _extractParameters: function(route, fragment) {
1289	      var params = route.exec(fragment).slice(1);
1290	      return _.map(params, function(param) {
1291	        return param ? decodeURIComponent(param) : null;
1292	      });
1293	    }
1294	
1295	  });
1296	
1297	  // Backbone.History
1298	  // ----------------
1299	
1300	  // Handles cross-browser history management, based on either
1301	  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
1302	  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
1303	  // and URL fragments. If the browser supports neither (old IE, natch),
1304	  // falls back to polling.
1305	  var History = Backbone.History = function() {
1306	    this.handlers = [];
1307	    _.bindAll(this, 'checkUrl');
1308	
1309	    // Ensure that `History` can be used outside of the browser.
1310	    if (typeof window !== 'undefined') {
1311	      this.location = window.location;
1312	      this.history = window.history;
1313	    }
1314	  };
1315	
1316	  // Cached regex for stripping a leading hash/slash and trailing space.
1317	  var routeStripper = /^[#\/]|\s+$/g;
1318	
1319	  // Cached regex for stripping leading and trailing slashes.
1320	  var rootStripper = /^\/+|\/+$/g;
1321	
1322	  // Cached regex for detecting MSIE.
1323	  var isExplorer = /msie [\w.]+/;
1324	
1325	  // Cached regex for removing a trailing slash.
1326	  var trailingSlash = /\/$/;
1327	
1328	  // Has the history handling already been started?
1329	  History.started = false;
1330	
1331	  // Set up all inheritable **Backbone.History** properties and methods.
1332	  _.extend(History.prototype, Events, {
1333	
1334	    // The default interval to poll for hash changes, if necessary, is
1335	    // twenty times a second.
1336	    interval: 50,
1337	
1338	    // Gets the true hash value. Cannot use location.hash directly due to bug
1339	    // in Firefox where location.hash will always be decoded.
1340	    getHash: function(window) {
1341	      var match = (window || this).location.href.match(/#(.*)$/);
1342	      return match ? match[1] : '';
1343	    },
1344	
1345	    // Get the cross-browser normalized URL fragment, either from the URL,
1346	    // the hash, or the override.
1347	    getFragment: function(fragment, forcePushState) {
1348	      if (fragment == null) {
1349	        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
1350	          fragment = this.location.pathname;
1351	          var root = this.root.replace(trailingSlash, '');
1352	          if (!fragment.indexOf(root)) fragment = fragment.substr(root.length);
1353	        } else {
1354	          fragment = this.getHash();
1355	        }
1356	      }
1357	      return fragment.replace(routeStripper, '');
1358	    },
1359	
1360	    // Start the hash change handling, returning `true` if the current URL matches
1361	    // an existing route, and `false` otherwise.
1362	    start: function(options) {
1363	      if (History.started) throw new Error("Backbone.history has already been started");
1364	      History.started = true;
1365	
1366	      // Figure out the initial configuration. Do we need an iframe?
1367	      // Is pushState desired ... is it available?
1368	      this.options          = _.extend({}, {root: '/'}, this.options, options);
1369	      this.root             = this.options.root;
1370	      this._wantsHashChange = this.options.hashChange !== false;
1371	      this._wantsPushState  = !!this.options.pushState;
1372	      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
1373	      var fragment          = this.getFragment();
1374	      var docMode           = document.documentMode;
1375	      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
1376	
1377	      // Normalize root to always include a leading and trailing slash.
1378	      this.root = ('/' + this.root + '/').replace(rootStripper, '/');
1379	
1380	      if (oldIE && this._wantsHashChange) {
1381	        this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
1382	        this.navigate(fragment);
1383	      }
1384	
1385	      // Depending on whether we're using pushState or hashes, and whether
1386	      // 'onhashchange' is supported, determine how we check the URL state.
1387	      if (this._hasPushState) {
1388	        Backbone.$(window).on('popstate', this.checkUrl);
1389	      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
1390	        Backbone.$(window).on('hashchange', this.checkUrl);
1391	      } else if (this._wantsHashChange) {
1392	        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
1393	      }
1394	
1395	      // Determine if we need to change the base url, for a pushState link
1396	      // opened by a non-pushState browser.
1397	      this.fragment = fragment;
1398	      var loc = this.location;
1399	      var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;
1400	
1401	      // If we've started off with a route from a `pushState`-enabled browser,
1402	      // but we're currently in a browser that doesn't support it...
1403	      if (this._wantsHashChange && this._wantsPushState && !this._hasPushState && !atRoot) {
1404	        this.fragment = this.getFragment(null, true);
1405	        this.location.replace(this.root + this.location.search + '#' + this.fragment);
1406	        // Return immediately as browser will do redirect to new url
1407	        return true;
1408	
1409	      // Or if we've started out with a hash-based route, but we're currently
1410	      // in a browser where it could be `pushState`-based instead...
1411	      } else if (this._wantsPushState && this._hasPushState && atRoot && loc.hash) {
1412	        this.fragment = this.getHash().replace(routeStripper, '');
1413	        this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
1414	      }
1415	
1416	      if (!this.options.silent) return this.loadUrl();
1417	    },
1418	
1419	    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
1420	    // but possibly useful for unit testing Routers.
1421	    stop: function() {
1422	      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
1423	      clearInterval(this._checkUrlInterval);
1424	      History.started = false;
1425	    },
1426	
1427	    // Add a route to be tested when the fragment changes. Routes added later
1428	    // may override previous routes.
1429	    route: function(route, callback) {
1430	      this.handlers.unshift({route: route, callback: callback});
1431	    },
1432	
1433	    // Checks the current URL to see if it has changed, and if it has,
1434	    // calls `loadUrl`, normalizing across the hidden iframe.
1435	    checkUrl: function(e) {
1436	      var current = this.getFragment();
1437	      if (current === this.fragment && this.iframe) {
1438	        current = this.getFragment(this.getHash(this.iframe));
1439	      }
1440	      if (current === this.fragment) return false;
1441	      if (this.iframe) this.navigate(current);
1442	      this.loadUrl() || this.loadUrl(this.getHash());
1443	    },
1444	
1445	    // Attempt to load the current URL fragment. If a route succeeds with a
1446	    // match, returns `true`. If no defined routes matches the fragment,
1447	    // returns `false`.
1448	    loadUrl: function(fragmentOverride) {
1449	      var fragment = this.fragment = this.getFragment(fragmentOverride);
1450	      var matched = _.any(this.handlers, function(handler) {
1451	        if (handler.route.test(fragment)) {
1452	          handler.callback(fragment);
1453	          return true;
1454	        }
1455	      });
1456	      return matched;
1457	    },
1458	
1459	    // Save a fragment into the hash history, or replace the URL state if the
1460	    // 'replace' option is passed. You are responsible for properly URL-encoding
1461	    // the fragment in advance.
1462	    //
1463	    // The options object can contain `trigger: true` if you wish to have the
1464	    // route callback be fired (not usually desirable), or `replace: true`, if
1465	    // you wish to modify the current URL without adding an entry to the history.
1466	    navigate: function(fragment, options) {
1467	      if (!History.started) return false;
1468	      if (!options || options === true) options = {trigger: options};
1469	      fragment = this.getFragment(fragment || '');
1470	      if (this.fragment === fragment) return;
1471	      this.fragment = fragment;
1472	      var url = this.root + fragment;
1473	
1474	      // If pushState is available, we use it to set the fragment as a real URL.
1475	      if (this._hasPushState) {
1476	        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
1477	
1478	      // If hash changes haven't been explicitly disabled, update the hash
1479	      // fragment to store history.
1480	      } else if (this._wantsHashChange) {
1481	        this._updateHash(this.location, fragment, options.replace);
1482	        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
1483	          // Opening and closing the iframe tricks IE7 and earlier to push a
1484	          // history entry on hash-tag change.  When replace is true, we don't
1485	          // want this.
1486	          if(!options.replace) this.iframe.document.open().close();
1487	          this._updateHash(this.iframe.location, fragment, options.replace);
1488	        }
1489	
1490	      // If you've told us that you explicitly don't want fallback hashchange-
1491	      // based history, then `navigate` becomes a page refresh.
1492	      } else {
1493	        return this.location.assign(url);
1494	      }
1495	      if (options.trigger) this.loadUrl(fragment);
1496	    },
1497	
1498	    // Update the hash location, either replacing the current entry, or adding
1499	    // a new one to the browser history.
1500	    _updateHash: function(location, fragment, replace) {
1501	      if (replace) {
1502	        var href = location.href.replace(/(javascript:|#).*$/, '');
1503	        location.replace(href + '#' + fragment);
1504	      } else {
1505	        // Some browsers require that `hash` contains a leading #.
1506	        location.hash = '#' + fragment;
1507	      }
1508	    }
1509	
1510	  });
1511	
1512	  // Create the default Backbone.history.
1513	  Backbone.history = new History;
1514	
1515	  // Helpers
1516	  // -------
1517	
1518	  // Helper function to correctly set up the prototype chain, for subclasses.
1519	  // Similar to `goog.inherits`, but uses a hash of prototype properties and
1520	  // class properties to be extended.
1521	  var extend = function(protoProps, staticProps) {
1522	    var parent = this;
1523	    var child;
1524	
1525	    // The constructor function for the new subclass is either defined by you
1526	    // (the "constructor" property in your `extend` definition), or defaulted
1527	    // by us to simply call the parent's constructor.
1528	    if (protoProps && _.has(protoProps, 'constructor')) {
1529	      child = protoProps.constructor;
1530	    } else {
1531	      child = function(){ return parent.apply(this, arguments); };
1532	    }
1533	
1534	    // Add static properties to the constructor function, if supplied.
1535	    _.extend(child, parent, staticProps);
1536	
1537	    // Set the prototype chain to inherit from `parent`, without calling
1538	    // `parent`'s constructor function.
1539	    var Surrogate = function(){ this.constructor = child; };
1540	    Surrogate.prototype = parent.prototype;
1541	    child.prototype = new Surrogate;
1542	
1543	    // Add prototype properties (instance properties) to the subclass,
1544	    // if supplied.
1545	    if (protoProps) _.extend(child.prototype, protoProps);
1546	
1547	    // Set a convenience property in case the parent's prototype is needed
1548	    // later.
1549	    child.__super__ = parent.prototype;
1550	
1551	    return child;
1552	  };
1553	
1554	  // Set up inheritance for the model, collection, router, view and history.
1555	  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
1556	
1557	  // Throw an error when a URL is needed, and none is supplied.
1558	  var urlError = function() {
1559	    throw new Error('A "url" property or function must be specified');
1560	  };
1561	
1562	  // Wrap an optional error callback with a fallback error event.
1563	  var wrapError = function (model, options) {
1564	    var error = options.error;
1565	    options.error = function(resp) {
1566	      if (error) error(model, resp, options);
1567	      model.trigger('error', model, resp, options);
1568	    };
1569	  };
1570	
1571	}).call(this);