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