{"version":3,"file":"js/391-52d87cbfff643821b349.js","mappings":"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","sources":["webpack://app/./node_modules/backbone/backbone.js"],"sourcesContent":["//     Backbone.js 1.6.0\n\n//     (c) 2010-2024 Jeremy Ashkenas and DocumentCloud\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(factory) {\n\n  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.\n  // We use `self` instead of `window` for `WebWorker` support.\n  var root = typeof self == 'object' && self.self === self && self ||\n            typeof global == 'object' && global.global === global && global;\n\n  // Set up Backbone appropriately for the environment. Start with AMD.\n  if (typeof define === 'function' && define.amd) {\n    define(['underscore', 'jquery', 'exports'], function(_, $, exports) {\n      // Export global even in AMD case in case this script is loaded with\n      // others that may still expect a global Backbone.\n      root.Backbone = factory(root, exports, _, $);\n    });\n\n  // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n  } else if (typeof exports !== 'undefined') {\n    var _ = require('underscore'), $;\n    try { $ = require('jquery'); } catch (e) {}\n    factory(root, exports, _, $);\n\n  // Finally, as a browser global.\n  } else {\n    root.Backbone = factory(root, {}, root._, root.jQuery || root.Zepto || root.ender || root.$);\n  }\n\n})(function(root, Backbone, _, $) {\n\n  // Initial Setup\n  // -------------\n\n  // Save the previous value of the `Backbone` variable, so that it can be\n  // restored later on, if `noConflict` is used.\n  var previousBackbone = root.Backbone;\n\n  // Create a local reference to a common array method we'll want to use later.\n  var slice = Array.prototype.slice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.6.0';\n\n  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n  // the `$` variable.\n  Backbone.$ = $;\n\n  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n  // to its previous owner. Returns a reference to this Backbone object.\n  Backbone.noConflict = function() {\n    root.Backbone = previousBackbone;\n    return this;\n  };\n\n  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n  // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n  // set a `X-Http-Method-Override` header.\n  Backbone.emulateHTTP = false;\n\n  // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n  // `application/json` requests ... this will encode the body as\n  // `application/x-www-form-urlencoded` instead and will send the model in a\n  // form param named `model`.\n  Backbone.emulateJSON = false;\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // a custom event channel. You may bind a callback to an event with `on` or\n  // remove with `off`; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  var Events = Backbone.Events = {};\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // A private global variable to share between listeners and listenees.\n  var _listening;\n\n  // Iterates over the standard `event, callback` (as well as the fancy multiple\n  // space-separated events `\"change blur\", callback` and jQuery-style event\n  // maps `{event: callback}`).\n  var eventsApi = function(iteratee, events, name, callback, opts) {\n    var i = 0, names;\n    if (name && typeof name === 'object') {\n      // Handle event maps.\n      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;\n      for (names = _.keys(name); i < names.length ; i++) {\n        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);\n      }\n    } else if (name && eventSplitter.test(name)) {\n      // Handle space-separated event names by delegating them individually.\n      for (names = name.split(eventSplitter); i < names.length; i++) {\n        events = iteratee(events, names[i], callback, opts);\n      }\n    } else {\n      // Finally, standard events.\n      events = iteratee(events, name, callback, opts);\n    }\n    return events;\n  };\n\n  // Bind an event to a `callback` function. Passing `\"all\"` will bind\n  // the callback to all events fired.\n  Events.on = function(name, callback, context) {\n    this._events = eventsApi(onApi, this._events || {}, name, callback, {\n      context: context,\n      ctx: this,\n      listening: _listening\n    });\n\n    if (_listening) {\n      var listeners = this._listeners || (this._listeners = {});\n      listeners[_listening.id] = _listening;\n      // Allow the listening to use a counter, instead of tracking\n      // callbacks for library interop\n      _listening.interop = false;\n    }\n\n    return this;\n  };\n\n  // Inversion-of-control versions of `on`. Tell *this* object to listen to\n  // an event in another object... keeping track of what it's listening to\n  // for easier unbinding later.\n  Events.listenTo = function(obj, name, callback) {\n    if (!obj) return this;\n    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n    var listeningTo = this._listeningTo || (this._listeningTo = {});\n    var listening = _listening = listeningTo[id];\n\n    // This object is not listening to any other events on `obj` yet.\n    // Setup the necessary references to track the listening callbacks.\n    if (!listening) {\n      this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = _listening = listeningTo[id] = new Listening(this, obj);\n    }\n\n    // Bind callbacks on obj.\n    var error = tryCatchOn(obj, name, callback, this);\n    _listening = void 0;\n\n    if (error) throw error;\n    // If the target obj is not Backbone.Events, track events manually.\n    if (listening.interop) listening.on(name, callback);\n\n    return this;\n  };\n\n  // The reducing API that adds a callback to the `events` object.\n  var onApi = function(events, name, callback, options) {\n    if (callback) {\n      var handlers = events[name] || (events[name] = []);\n      var context = options.context, ctx = options.ctx, listening = options.listening;\n      if (listening) listening.count++;\n\n      handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});\n    }\n    return events;\n  };\n\n  // An try-catch guarded #on function, to prevent poisoning the global\n  // `_listening` variable.\n  var tryCatchOn = function(obj, name, callback, context) {\n    try {\n      obj.on(name, callback, context);\n    } catch (e) {\n      return e;\n    }\n  };\n\n  // Remove one or many callbacks. If `context` is null, removes all\n  // callbacks with that function. If `callback` is null, removes all\n  // callbacks for the event. If `name` is null, removes all bound\n  // callbacks for all events.\n  Events.off = function(name, callback, context) {\n    if (!this._events) return this;\n    this._events = eventsApi(offApi, this._events, name, callback, {\n      context: context,\n      listeners: this._listeners\n    });\n\n    return this;\n  };\n\n  // Tell this object to stop listening to either specific events ... or\n  // to every object it's currently listening to.\n  Events.stopListening = function(obj, name, callback) {\n    var listeningTo = this._listeningTo;\n    if (!listeningTo) return this;\n\n    var ids = obj ? [obj._listenId] : _.keys(listeningTo);\n    for (var i = 0; i < ids.length; i++) {\n      var listening = listeningTo[ids[i]];\n\n      // If listening doesn't exist, this object is not currently\n      // listening to obj. Break out early.\n      if (!listening) break;\n\n      listening.obj.off(name, callback, this);\n      if (listening.interop) listening.off(name, callback);\n    }\n    if (_.isEmpty(listeningTo)) this._listeningTo = void 0;\n\n    return this;\n  };\n\n  // The reducing API that removes a callback from the `events` object.\n  var offApi = function(events, name, callback, options) {\n    if (!events) return;\n\n    var context = options.context, listeners = options.listeners;\n    var i = 0, names;\n\n    // Delete all event listeners and \"drop\" events.\n    if (!name && !context && !callback) {\n      for (names = _.keys(listeners); i < names.length; i++) {\n        listeners[names[i]].cleanup();\n      }\n      return;\n    }\n\n    names = name ? [name] : _.keys(events);\n    for (; i < names.length; i++) {\n      name = names[i];\n      var handlers = events[name];\n\n      // Bail out if there are no events stored.\n      if (!handlers) break;\n\n      // Find any remaining events.\n      var remaining = [];\n      for (var j = 0; j < handlers.length; j++) {\n        var handler = handlers[j];\n        if (\n          callback && callback !== handler.callback &&\n            callback !== handler.callback._callback ||\n              context && context !== handler.context\n        ) {\n          remaining.push(handler);\n        } else {\n          var listening = handler.listening;\n          if (listening) listening.off(name, callback);\n        }\n      }\n\n      // Replace events if there are any remaining.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\n      }\n    }\n\n    return events;\n  };\n\n  // Bind an event to only be triggered a single time. After the first time\n  // the callback is invoked, its listener will be removed. If multiple events\n  // are passed in using the space-separated syntax, the handler will fire\n  // once for each event, not once for a combination of all events.\n  Events.once = function(name, callback, context) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, this.off.bind(this));\n    if (typeof name === 'string' && context == null) callback = void 0;\n    return this.on(events, callback, context);\n  };\n\n  // Inversion-of-control versions of `once`.\n  Events.listenToOnce = function(obj, name, callback) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, this.stopListening.bind(this, obj));\n    return this.listenTo(obj, events);\n  };\n\n  // Reduces the event callbacks into a map of `{event: onceWrapper}`.\n  // `offer` unbinds the `onceWrapper` after it has been called.\n  var onceMap = function(map, name, callback, offer) {\n    if (callback) {\n      var once = map[name] = _.once(function() {\n        offer(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n    }\n    return map;\n  };\n\n  // Trigger one or many events, firing all bound callbacks. Callbacks are\n  // passed the same arguments as `trigger` is, apart from the event name\n  // (unless you're listening on `\"all\"`, which will cause your callback to\n  // receive the true name of the event as the first argument).\n  Events.trigger = function(name) {\n    if (!this._events) return this;\n\n    var length = Math.max(0, arguments.length - 1);\n    var args = Array(length);\n    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];\n\n    eventsApi(triggerApi, this._events, name, void 0, args);\n    return this;\n  };\n\n  // Handles triggering the appropriate event callbacks.\n  var triggerApi = function(objEvents, name, callback, args) {\n    if (objEvents) {\n      var events = objEvents[name];\n      var allEvents = objEvents.all;\n      if (events && allEvents) allEvents = allEvents.slice();\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, [name].concat(args));\n    }\n    return objEvents;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n    }\n  };\n\n  // A listening class that tracks and cleans up memory bindings\n  // when all callbacks have been offed.\n  var Listening = function(listener, obj) {\n    this.id = listener._listenId;\n    this.listener = listener;\n    this.obj = obj;\n    this.interop = true;\n    this.count = 0;\n    this._events = void 0;\n  };\n\n  Listening.prototype.on = Events.on;\n\n  // Offs a callback (or several).\n  // Uses an optimized counter if the listenee uses Backbone.Events.\n  // Otherwise, falls back to manual tracking to support events\n  // library interop.\n  Listening.prototype.off = function(name, callback) {\n    var cleanup;\n    if (this.interop) {\n      this._events = eventsApi(offApi, this._events, name, callback, {\n        context: void 0,\n        listeners: void 0\n      });\n      cleanup = !this._events;\n    } else {\n      this.count--;\n      cleanup = this.count === 0;\n    }\n    if (cleanup) this.cleanup();\n  };\n\n  // Cleans up memory bindings between the listener and the listenee.\n  Listening.prototype.cleanup = function() {\n    delete this.listener._listeningTo[this.obj._listenId];\n    if (!this.interop) delete this.obj._listeners[this.id];\n  };\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Allow the `Backbone` object to serve as a global event bus, for folks who\n  // want global \"pubsub\" in a convenient place.\n  _.extend(Backbone, Events);\n\n  // Backbone.Model\n  // --------------\n\n  // Backbone **Models** are the basic data object in the framework --\n  // frequently representing a row in a table in a database on your server.\n  // A discrete chunk of data and a bunch of useful, related methods for\n  // performing computations and transformations on that data.\n\n  // Create a new model with the specified attributes. A client id (`cid`)\n  // is automatically generated and assigned for you.\n  var Model = Backbone.Model = function(attributes, options) {\n    var attrs = attributes || {};\n    options || (options = {});\n    this.preinitialize.apply(this, arguments);\n    this.cid = _.uniqueId(this.cidPrefix);\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    var defaults = _.result(this, 'defaults');\n\n    // Just _.defaults would work fine, but the additional _.extends\n    // is in there for historical reasons. See #3843.\n    attrs = _.defaults(_.extend({}, defaults, attrs), defaults);\n\n    this.set(attrs, options);\n    this.changed = {};\n    this.initialize.apply(this, arguments);\n  };\n\n  // Attach all inheritable methods to the Model prototype.\n  _.extend(Model.prototype, Events, {\n\n    // A hash of attributes whose current and previous value differ.\n    changed: null,\n\n    // The value returned during the last failed validation.\n    validationError: null,\n\n    // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n    // CouchDB users may want to set this to `\"_id\"`.\n    idAttribute: 'id',\n\n    // The prefix is used to create the client id which is used to identify models locally.\n    // You may want to override this if you're experiencing name clashes with model ids.\n    cidPrefix: 'c',\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the Model.\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Return a copy of the model's `attributes` object.\n    toJSON: function(options) {\n      return _.clone(this.attributes);\n    },\n\n    // Proxy `Backbone.sync` by default -- but override this if you need\n    // custom syncing semantics for *this* particular model.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Get the value of an attribute.\n    get: function(attr) {\n      return this.attributes[attr];\n    },\n\n    // Get the HTML-escaped value of an attribute.\n    escape: function(attr) {\n      return _.escape(this.get(attr));\n    },\n\n    // Returns `true` if the attribute contains a value that is not null\n    // or undefined.\n    has: function(attr) {\n      return this.get(attr) != null;\n    },\n\n    // Special-cased proxy to underscore's `_.matches` method.\n    matches: function(attrs) {\n      return !!_.iteratee(attrs, this)(this.attributes);\n    },\n\n    // Set a hash of model attributes on the object, firing `\"change\"`. This is\n    // the core primitive operation of a model, updating the data and notifying\n    // anyone who needs to know about the change in state. The heart of the beast.\n    set: function(key, val, options) {\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options || (options = {});\n\n      // Run validation.\n      if (!this._validate(attrs, options)) return false;\n\n      // Extract attributes and options.\n      var unset      = options.unset;\n      var silent     = options.silent;\n      var changes    = [];\n      var changing   = this._changing;\n      this._changing = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n\n      var current = this.attributes;\n      var changed = this.changed;\n      var prev    = this._previousAttributes;\n\n      // For each `set` attribute, update or delete the current value.\n      for (var attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          changed[attr] = val;\n        } else {\n          delete changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Update the `id`.\n      if (this.idAttribute in attrs) {\n        var prevId = this.id;\n        this.id = this.get(this.idAttribute);\n        this.trigger('changeId', this, prevId, options);\n      }\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0; i < changes.length; i++) {\n          this.trigger('change:' + changes[i], this, current[changes[i]], options);\n        }\n      }\n\n      // You might be wondering why there's a `while` loop here. Changes can\n      // be recursively nested within `\"change\"` events.\n      if (changing) return this;\n      if (!silent) {\n        while (this._pending) {\n          options = this._pending;\n          this._pending = false;\n          this.trigger('change', this, options);\n        }\n      }\n      this._pending = false;\n      this._changing = false;\n      return this;\n    },\n\n    // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n    // if the attribute doesn't exist.\n    unset: function(attr, options) {\n      return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n    },\n\n    // Clear all attributes on the model, firing `\"change\"`.\n    clear: function(options) {\n      var attrs = {};\n      for (var key in this.attributes) attrs[key] = void 0;\n      return this.set(attrs, _.extend({}, options, {unset: true}));\n    },\n\n    // Determine if the model has changed since the last `\"change\"` event.\n    // If you specify an attribute name, determine if that attribute has changed.\n    hasChanged: function(attr) {\n      if (attr == null) return !_.isEmpty(this.changed);\n      return _.has(this.changed, attr);\n    },\n\n    // Return an object containing all the attributes that have changed, or\n    // false if there are no changed attributes. Useful for determining what\n    // parts of a view need to be updated and/or what attributes need to be\n    // persisted to the server. Unset attributes will be set to undefined.\n    // You can also pass an attributes object to diff against the model,\n    // determining if there *would be* a change.\n    changedAttributes: function(diff) {\n      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      var changed = {};\n      var hasChanged;\n      for (var attr in diff) {\n        var val = diff[attr];\n        if (_.isEqual(old[attr], val)) continue;\n        changed[attr] = val;\n        hasChanged = true;\n      }\n      return hasChanged ? changed : false;\n    },\n\n    // Get the previous value of an attribute, recorded at the time the last\n    // `\"change\"` event was fired.\n    previous: function(attr) {\n      if (attr == null || !this._previousAttributes) return null;\n      return this._previousAttributes[attr];\n    },\n\n    // Get all of the attributes of the model at the time of the previous\n    // `\"change\"` event.\n    previousAttributes: function() {\n      return _.clone(this._previousAttributes);\n    },\n\n    // Fetch the model from the server, merging the response with the model's\n    // local attributes. Any changed attributes will trigger a \"change\" event.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (!model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Set a hash of model attributes, and sync the model to the server.\n    // If the server returns an attributes hash that differs, the model's\n    // state will be `set` again.\n    save: function(key, val, options) {\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (key == null || typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options = _.extend({validate: true, parse: true}, options);\n      var wait = options.wait;\n\n      // If we're not waiting and attributes exist, save acts as\n      // `set(attr).save(null, opts)` with validation. Otherwise, check if\n      // the model will be valid when the attributes, if any, are set.\n      if (attrs && !wait) {\n        if (!this.set(attrs, options)) return false;\n      } else if (!this._validate(attrs, options)) {\n        return false;\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      var model = this;\n      var success = options.success;\n      var attributes = this.attributes;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);\n        if (serverAttrs && !model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      // Set temporary attributes if `{wait: true}` to properly find new ids.\n      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);\n\n      var method = this.isNew() ? 'create' : options.patch ? 'patch' : 'update';\n      if (method === 'patch' && !options.attrs) options.attrs = attrs;\n      var xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      this.attributes = attributes;\n\n      return xhr;\n    },\n\n    // Destroy this model on the server if it was already persisted.\n    // Optimistically removes the model from its collection, if it has one.\n    // If `wait: true` is passed, waits for the server to respond before removal.\n    destroy: function(options) {\n      options = options ? _.clone(options) : {};\n      var model = this;\n      var success = options.success;\n      var wait = options.wait;\n\n      var destroy = function() {\n        model.stopListening();\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (wait) destroy();\n        if (success) success.call(options.context, model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      var xhr = false;\n      if (this.isNew()) {\n        _.defer(options.success);\n      } else {\n        wrapError(this, options);\n        xhr = this.sync('delete', this, options);\n      }\n      if (!wait) destroy();\n      return xhr;\n    },\n\n    // Default URL for the model's representation on the server -- if you're\n    // using Backbone's restful methods, override this to change the endpoint\n    // that will be called.\n    url: function() {\n      var base =\n        _.result(this, 'urlRoot') ||\n        _.result(this.collection, 'url') ||\n        urlError();\n      if (this.isNew()) return base;\n      var id = this.get(this.idAttribute);\n      return base.replace(/[^\\/]$/, '$&/') + encodeURIComponent(id);\n    },\n\n    // **parse** converts a response into the hash of attributes to be `set` on\n    // the model. The default implementation is just to pass the response along.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new model with identical attributes to this one.\n    clone: function() {\n      return new this.constructor(this.attributes);\n    },\n\n    // A model is new if it has never been saved to the server, and lacks an id.\n    isNew: function() {\n      return !this.has(this.idAttribute);\n    },\n\n    // Check if the model is currently in a valid state.\n    isValid: function(options) {\n      return this._validate({}, _.extend({}, options, {validate: true}));\n    },\n\n    // Run validation against the next complete set of model attributes,\n    // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n    _validate: function(attrs, options) {\n      if (!options.validate || !this.validate) return true;\n      attrs = _.extend({}, this.attributes, attrs);\n      var error = this.validationError = this.validate(attrs, options) || null;\n      if (!error) return true;\n      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n      return false;\n    }\n\n  });\n\n  // Backbone.Collection\n  // -------------------\n\n  // If models tend to represent a single row of data, a Backbone Collection is\n  // more analogous to a table full of data ... or a small slice or page of that\n  // table, or a collection of rows that belong together for a particular reason\n  // -- all of the messages in this particular folder, all of the documents\n  // belonging to this particular author, and so on. Collections maintain\n  // indexes of their models, both in order, and for lookup by `id`.\n\n  // Create a new **Collection**, perhaps to contain a specific type of `model`.\n  // If a `comparator` is specified, the Collection will maintain\n  // its models in sort order, as they're added and removed.\n  var Collection = Backbone.Collection = function(models, options) {\n    options || (options = {});\n    this.preinitialize.apply(this, arguments);\n    if (options.model) this.model = options.model;\n    if (options.comparator !== void 0) this.comparator = options.comparator;\n    this._reset();\n    this.initialize.apply(this, arguments);\n    if (models) this.reset(models, _.extend({silent: true}, options));\n  };\n\n  // Default options for `Collection#set`.\n  var setOptions = {add: true, remove: true, merge: true};\n  var addOptions = {add: true, remove: false};\n\n  // Splices `insert` into `array` at index `at`.\n  var splice = function(array, insert, at) {\n    at = Math.min(Math.max(at, 0), array.length);\n    var tail = Array(array.length - at);\n    var length = insert.length;\n    var i;\n    for (i = 0; i < tail.length; i++) tail[i] = array[i + at];\n    for (i = 0; i < length; i++) array[i + at] = insert[i];\n    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];\n  };\n\n  // Define the Collection's inheritable methods.\n  _.extend(Collection.prototype, Events, {\n\n    // The default model for a collection is just a **Backbone.Model**.\n    // This should be overridden in most cases.\n    model: Model,\n\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the Collection.\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // The JSON representation of a Collection is an array of the\n    // models' attributes.\n    toJSON: function(options) {\n      return this.map(function(model) { return model.toJSON(options); });\n    },\n\n    // Proxy `Backbone.sync` by default.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Add a model, or list of models to the set. `models` may be Backbone\n    // Models or raw JavaScript objects to be converted to Models, or any\n    // combination of the two.\n    add: function(models, options) {\n      return this.set(models, _.extend({merge: false}, options, addOptions));\n    },\n\n    // Remove a model, or a list of models from the set.\n    remove: function(models, options) {\n      options = _.extend({}, options);\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n      var removed = this._removeModels(models, options);\n      if (!options.silent && removed.length) {\n        options.changes = {added: [], merged: [], removed: removed};\n        this.trigger('update', this, options);\n      }\n      return singular ? removed[0] : removed;\n    },\n\n    // Update a collection by `set`-ing a new list of models, adding new ones,\n    // removing models that are no longer present, and merging models that\n    // already exist in the collection, as necessary. Similar to **Model#set**,\n    // the core operation for updating the data contained by the collection.\n    set: function(models, options) {\n      if (models == null) return;\n\n      options = _.extend({}, setOptions, options);\n      if (options.parse && !this._isModel(models)) {\n        models = this.parse(models, options) || [];\n      }\n\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n\n      var at = options.at;\n      if (at != null) at = +at;\n      if (at > this.length) at = this.length;\n      if (at < 0) at += this.length + 1;\n\n      var set = [];\n      var toAdd = [];\n      var toMerge = [];\n      var toRemove = [];\n      var modelMap = {};\n\n      var add = options.add;\n      var merge = options.merge;\n      var remove = options.remove;\n\n      var sort = false;\n      var sortable = this.comparator && at == null && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      var model, i;\n      for (i = 0; i < models.length; i++) {\n        model = models[i];\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        var existing = this.get(model);\n        if (existing) {\n          if (merge && model !== existing) {\n            var attrs = this._isModel(model) ? model.attributes : model;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            toMerge.push(existing);\n            if (sortable && !sort) sort = existing.hasChanged(sortAttr);\n          }\n          if (!modelMap[existing.cid]) {\n            modelMap[existing.cid] = true;\n            set.push(existing);\n          }\n          models[i] = existing;\n\n        // If this is a new, valid model, push it to the `toAdd` list.\n        } else if (add) {\n          model = models[i] = this._prepareModel(model, options);\n          if (model) {\n            toAdd.push(model);\n            this._addReference(model, options);\n            modelMap[model.cid] = true;\n            set.push(model);\n          }\n        }\n      }\n\n      // Remove stale models.\n      if (remove) {\n        for (i = 0; i < this.length; i++) {\n          model = this.models[i];\n          if (!modelMap[model.cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this._removeModels(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      var orderChanged = false;\n      var replace = !sortable && add && remove;\n      if (set.length && replace) {\n        orderChanged = this.length !== set.length || _.some(this.models, function(m, index) {\n          return m !== set[index];\n        });\n        this.models.length = 0;\n        splice(this.models, set, 0);\n        this.length = this.models.length;\n      } else if (toAdd.length) {\n        if (sortable) sort = true;\n        splice(this.models, toAdd, at == null ? this.length : at);\n        this.length = this.models.length;\n      }\n\n      // Silently sort the collection if appropriate.\n      if (sort) this.sort({silent: true});\n\n      // Unless silenced, it's time to fire all appropriate add/sort/update events.\n      if (!options.silent) {\n        for (i = 0; i < toAdd.length; i++) {\n          if (at != null) options.index = at + i;\n          model = toAdd[i];\n          model.trigger('add', model, this, options);\n        }\n        if (sort || orderChanged) this.trigger('sort', this, options);\n        if (toAdd.length || toRemove.length || toMerge.length) {\n          options.changes = {\n            added: toAdd,\n            removed: toRemove,\n            merged: toMerge\n          };\n          this.trigger('update', this, options);\n        }\n      }\n\n      // Return the added (or merged) model (or models).\n      return singular ? models[0] : models;\n    },\n\n    // When you have more items than you want to add or remove individually,\n    // you can reset the entire set with a new list of models, without firing\n    // any granular `add` or `remove` events. Fires `reset` when finished.\n    // Useful for bulk operations and optimizations.\n    reset: function(models, options) {\n      options = options ? _.clone(options) : {};\n      for (var i = 0; i < this.models.length; i++) {\n        this._removeReference(this.models[i], options);\n      }\n      options.previousModels = this.models;\n      this._reset();\n      models = this.add(models, _.extend({silent: true}, options));\n      if (!options.silent) this.trigger('reset', this, options);\n      return models;\n    },\n\n    // Add a model to the end of the collection.\n    push: function(model, options) {\n      return this.add(model, _.extend({at: this.length}, options));\n    },\n\n    // Remove a model from the end of the collection.\n    pop: function(options) {\n      var model = this.at(this.length - 1);\n      return this.remove(model, options);\n    },\n\n    // Add a model to the beginning of the collection.\n    unshift: function(model, options) {\n      return this.add(model, _.extend({at: 0}, options));\n    },\n\n    // Remove a model from the beginning of the collection.\n    shift: function(options) {\n      var model = this.at(0);\n      return this.remove(model, options);\n    },\n\n    // Slice out a sub-array of models from the collection.\n    slice: function() {\n      return slice.apply(this.models, arguments);\n    },\n\n    // Get a model from the set by id, cid, model object with id or cid\n    // properties, or an attributes object that is transformed through modelId.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] ||\n        this._byId[this.modelId(this._isModel(obj) ? obj.attributes : obj, obj.idAttribute)] ||\n        obj.cid && this._byId[obj.cid];\n    },\n\n    // Returns `true` if the model is in the collection.\n    has: function(obj) {\n      return this.get(obj) != null;\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\n      if (index < 0) index += this.length;\n      return this.models[index];\n    },\n\n    // Return models with matching attributes. Useful for simple cases of\n    // `filter`.\n    where: function(attrs, first) {\n      return this[first ? 'find' : 'filter'](attrs);\n    },\n\n    // Return the first model with matching attributes. Useful for simple cases\n    // of `find`.\n    findWhere: function(attrs) {\n      return this.where(attrs, true);\n    },\n\n    // Force the collection to re-sort itself. You don't need to call this under\n    // normal circumstances, as the set will maintain sort order as each item\n    // is added.\n    sort: function(options) {\n      var comparator = this.comparator;\n      if (!comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      var length = comparator.length;\n      if (_.isFunction(comparator)) comparator = comparator.bind(this);\n\n      // Run sort based on type of `comparator`.\n      if (length === 1 || _.isString(comparator)) {\n        this.models = this.sortBy(comparator);\n      } else {\n        this.models.sort(comparator);\n      }\n      if (!options.silent) this.trigger('sort', this, options);\n      return this;\n    },\n\n    // Pluck an attribute from each model in the collection.\n    pluck: function(attr) {\n      return this.map(attr + '');\n    },\n\n    // Fetch the default set of models for this collection, resetting the\n    // collection when they arrive. If `reset: true` is passed, the response\n    // data will be passed through the `reset` method instead of `set`.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var success = options.success;\n      var collection = this;\n      options.success = function(resp) {\n        var method = options.reset ? 'reset' : 'set';\n        collection[method](resp, options);\n        if (success) success.call(options.context, collection, resp, options);\n        collection.trigger('sync', collection, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Create a new instance of a model in this collection. Add the model to the\n    // collection immediately, unless `wait: true` is passed, in which case we\n    // wait for the server to agree.\n    create: function(model, options) {\n      options = options ? _.clone(options) : {};\n      var wait = options.wait;\n      model = this._prepareModel(model, options);\n      if (!model) return false;\n      if (!wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(m, resp, callbackOpts) {\n        if (wait) {\n          m.off('error', collection._forwardPristineError, collection);\n          collection.add(m, callbackOpts);\n        }\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\n      };\n      // In case of wait:true, our collection is not listening to any\n      // of the model's events yet, so it will not forward the error\n      // event. In this special case, we need to listen for it\n      // separately and handle the event just once.\n      // (The reason we don't need to do this for the sync event is\n      // in the success handler above: we add the model first, which\n      // causes the collection to listen, and then invoke the callback\n      // that triggers the event.)\n      if (wait) {\n        model.once('error', this._forwardPristineError, this);\n      }\n      model.save(null, options);\n      return model;\n    },\n\n    // **parse** converts a response into a list of models to be added to the\n    // collection. The default implementation is just to pass it through.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new collection with an identical list of models as this one.\n    clone: function() {\n      return new this.constructor(this.models, {\n        model: this.model,\n        comparator: this.comparator\n      });\n    },\n\n    // Define how to uniquely identify models in the collection.\n    modelId: function(attrs, idAttribute) {\n      return attrs[idAttribute || this.model.prototype.idAttribute || 'id'];\n    },\n\n    // Get an iterator of all models in this collection.\n    values: function() {\n      return new CollectionIterator(this, ITERATOR_VALUES);\n    },\n\n    // Get an iterator of all model IDs in this collection.\n    keys: function() {\n      return new CollectionIterator(this, ITERATOR_KEYS);\n    },\n\n    // Get an iterator of all [ID, model] tuples in this collection.\n    entries: function() {\n      return new CollectionIterator(this, ITERATOR_KEYSVALUES);\n    },\n\n    // Private method to reset all internal state. Called when the collection\n    // is first initialized or reset.\n    _reset: function() {\n      this.length = 0;\n      this.models = [];\n      this._byId  = {};\n    },\n\n    // Prepare a hash of attributes (or other model) to be added to this\n    // collection.\n    _prepareModel: function(attrs, options) {\n      if (this._isModel(attrs)) {\n        if (!attrs.collection) attrs.collection = this;\n        return attrs;\n      }\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n\n      var model;\n      if (this.model.prototype) {\n        model = new this.model(attrs, options);\n      } else {\n        // ES class methods didn't have prototype\n        model = this.model(attrs, options);\n      }\n\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\n    },\n\n    // Internal method called by both remove and set.\n    _removeModels: function(models, options) {\n      var removed = [];\n      for (var i = 0; i < models.length; i++) {\n        var model = this.get(models[i]);\n        if (!model) continue;\n\n        var index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n\n        // Remove references before triggering 'remove' event to prevent an\n        // infinite loop. #3693\n        delete this._byId[model.cid];\n        var id = this.modelId(model.attributes, model.idAttribute);\n        if (id != null) delete this._byId[id];\n\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n\n        removed.push(model);\n        this._removeReference(model, options);\n      }\n      if (models.length > 0 && !options.silent) delete options.index;\n      return removed;\n    },\n\n    // Method for checking whether an object should be considered a model for\n    // the purposes of adding to the collection.\n    _isModel: function(model) {\n      return model instanceof Model;\n    },\n\n    // Internal method to create a model's ties to a collection.\n    _addReference: function(model, options) {\n      this._byId[model.cid] = model;\n      var id = this.modelId(model.attributes, model.idAttribute);\n      if (id != null) this._byId[id] = model;\n      model.on('all', this._onModelEvent, this);\n    },\n\n    // Internal method to sever a model's ties to a collection.\n    _removeReference: function(model, options) {\n      delete this._byId[model.cid];\n      var id = this.modelId(model.attributes, model.idAttribute);\n      if (id != null) delete this._byId[id];\n      if (this === model.collection) delete model.collection;\n      model.off('all', this._onModelEvent, this);\n    },\n\n    // Internal method called every time a model in the set fires an event.\n    // Sets need to update their indexes when models change ids. All other\n    // events simply proxy through. \"add\" and \"remove\" events that originate\n    // in other collections are ignored.\n    _onModelEvent: function(event, model, collection, options) {\n      if (model) {\n        if ((event === 'add' || event === 'remove') && collection !== this) return;\n        if (event === 'destroy') this.remove(model, options);\n        if (event === 'changeId') {\n          var prevId = this.modelId(model.previousAttributes(), model.idAttribute);\n          var id = this.modelId(model.attributes, model.idAttribute);\n          if (prevId != null) delete this._byId[prevId];\n          if (id != null) this._byId[id] = model;\n        }\n      }\n      this.trigger.apply(this, arguments);\n    },\n\n    // Internal callback method used in `create`. It serves as a\n    // stand-in for the `_onModelEvent` method, which is not yet bound\n    // during the `wait` period of the `create` call. We still want to\n    // forward any `'error'` event at the end of the `wait` period,\n    // hence a customized callback.\n    _forwardPristineError: function(model, collection, options) {\n      // Prevent double forward if the model was already in the\n      // collection before the call to `create`.\n      if (this.has(model)) return;\n      this._onModelEvent('error', model, collection, options);\n    }\n  });\n\n  // Defining an @@iterator method implements JavaScript's Iterable protocol.\n  // In modern ES2015 browsers, this value is found at Symbol.iterator.\n  /* global Symbol */\n  var $$iterator = typeof Symbol === 'function' && Symbol.iterator;\n  if ($$iterator) {\n    Collection.prototype[$$iterator] = Collection.prototype.values;\n  }\n\n  // CollectionIterator\n  // ------------------\n\n  // A CollectionIterator implements JavaScript's Iterator protocol, allowing the\n  // use of `for of` loops in modern browsers and interoperation between\n  // Backbone.Collection and other JavaScript functions and third-party libraries\n  // which can operate on Iterables.\n  var CollectionIterator = function(collection, kind) {\n    this._collection = collection;\n    this._kind = kind;\n    this._index = 0;\n  };\n\n  // This \"enum\" defines the three possible kinds of values which can be emitted\n  // by a CollectionIterator that correspond to the values(), keys() and entries()\n  // methods on Collection, respectively.\n  var ITERATOR_VALUES = 1;\n  var ITERATOR_KEYS = 2;\n  var ITERATOR_KEYSVALUES = 3;\n\n  // All Iterators should themselves be Iterable.\n  if ($$iterator) {\n    CollectionIterator.prototype[$$iterator] = function() {\n      return this;\n    };\n  }\n\n  CollectionIterator.prototype.next = function() {\n    if (this._collection) {\n\n      // Only continue iterating if the iterated collection is long enough.\n      if (this._index < this._collection.length) {\n        var model = this._collection.at(this._index);\n        this._index++;\n\n        // Construct a value depending on what kind of values should be iterated.\n        var value;\n        if (this._kind === ITERATOR_VALUES) {\n          value = model;\n        } else {\n          var id = this._collection.modelId(model.attributes, model.idAttribute);\n          if (this._kind === ITERATOR_KEYS) {\n            value = id;\n          } else { // ITERATOR_KEYSVALUES\n            value = [id, model];\n          }\n        }\n        return {value: value, done: false};\n      }\n\n      // Once exhausted, remove the reference to the collection so future\n      // calls to the next method always return done.\n      this._collection = void 0;\n    }\n\n    return {value: void 0, done: true};\n  };\n\n  // Backbone.View\n  // -------------\n\n  // Backbone Views are almost more convention than they are actual code. A View\n  // is simply a JavaScript object that represents a logical chunk of UI in the\n  // DOM. This might be a single item, an entire list, a sidebar or panel, or\n  // even the surrounding frame which wraps your whole app. Defining a chunk of\n  // UI as a **View** allows you to define your DOM events declaratively, without\n  // having to worry about render order ... and makes it easy for the view to\n  // react to specific changes in the state of your models.\n\n  // Creating a Backbone.View creates its initial element outside of the DOM,\n  // if an existing element is not provided...\n  var View = Backbone.View = function(options) {\n    this.cid = _.uniqueId('view');\n    this.preinitialize.apply(this, arguments);\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be set as properties.\n  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n  // Set up all inheritable **Backbone.View** properties and methods.\n  _.extend(View.prototype, Events, {\n\n    // The default `tagName` of a View's element is `\"div\"`.\n    tagName: 'div',\n\n    // jQuery delegate for element lookup, scoped to DOM elements within the\n    // current view. This should be preferred to global lookups where possible.\n    $: function(selector) {\n      return this.$el.find(selector);\n    },\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the View\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // **render** is the core function that your view should override, in order\n    // to populate its element (`this.el`), with the appropriate HTML. The\n    // convention is for **render** to always return `this`.\n    render: function() {\n      return this;\n    },\n\n    // Remove this view by taking the element out of the DOM, and removing any\n    // applicable Backbone.Events listeners.\n    remove: function() {\n      this._removeElement();\n      this.stopListening();\n      return this;\n    },\n\n    // Remove this view's element from the document and all event listeners\n    // attached to it. Exposed for subclasses using an alternative DOM\n    // manipulation API.\n    _removeElement: function() {\n      this.$el.remove();\n    },\n\n    // Change the view's element (`this.el` property) and re-delegate the\n    // view's events on the new element.\n    setElement: function(element) {\n      this.undelegateEvents();\n      this._setElement(element);\n      this.delegateEvents();\n      return this;\n    },\n\n    // Creates the `this.el` and `this.$el` references for this view using the\n    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery\n    // context or an element. Subclasses can override this to utilize an\n    // alternative DOM manipulation API and are only required to set the\n    // `this.el` property.\n    _setElement: function(el) {\n      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);\n      this.el = this.$el[0];\n    },\n\n    // Set callbacks, where `this.events` is a hash of\n    //\n    // *{\"event selector\": \"callback\"}*\n    //\n    //     {\n    //       'mousedown .title':  'edit',\n    //       'click .button':     'save',\n    //       'click .open':       function(e) { ... }\n    //     }\n    //\n    // pairs. Callbacks will be bound to the view, with `this` set properly.\n    // Uses event delegation for efficiency.\n    // Omitting the selector binds the event to `this.el`.\n    delegateEvents: function(events) {\n      events || (events = _.result(this, 'events'));\n      if (!events) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[method];\n        if (!method) continue;\n        var match = key.match(delegateEventSplitter);\n        this.delegate(match[1], match[2], method.bind(this));\n      }\n      return this;\n    },\n\n    // Add a single event listener to the view's element (or a child element\n    // using `selector`). This only works for delegate-able events: not `focus`,\n    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.\n    delegate: function(eventName, selector, listener) {\n      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view by `delegateEvents`.\n    // You usually don't need to use this, but may wish to if you have multiple\n    // Backbone views attached to the same DOM element.\n    undelegateEvents: function() {\n      if (this.$el) this.$el.off('.delegateEvents' + this.cid);\n      return this;\n    },\n\n    // A finer-grained `undelegateEvents` for removing a single delegated event.\n    // `selector` and `listener` are both optional.\n    undelegate: function(eventName, selector, listener) {\n      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Produces a DOM element to be assigned to your view. Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _createElement: function(tagName) {\n      return document.createElement(tagName);\n    },\n\n    // Ensure that the View has a DOM element to render into.\n    // If `this.el` is a string, pass it through `$()`, take the first\n    // matching element, and re-assign it to `el`. Otherwise, create\n    // an element from the `id`, `className` and `tagName` properties.\n    _ensureElement: function() {\n      if (!this.el) {\n        var attrs = _.extend({}, _.result(this, 'attributes'));\n        if (this.id) attrs.id = _.result(this, 'id');\n        if (this.className) attrs['class'] = _.result(this, 'className');\n        this.setElement(this._createElement(_.result(this, 'tagName')));\n        this._setAttributes(attrs);\n      } else {\n        this.setElement(_.result(this, 'el'));\n      }\n    },\n\n    // Set attributes from a hash on this view's element.  Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _setAttributes: function(attributes) {\n      this.$el.attr(attributes);\n    }\n\n  });\n\n  // Proxy Backbone class methods to Underscore functions, wrapping the model's\n  // `attributes` object or collection's `models` array behind the scenes.\n  //\n  // collection.filter(function(model) { return model.get('age') > 10 });\n  // collection.each(this.addView);\n  //\n  // `Function#apply` can be slow so we use the method's arg count, if we know it.\n  var addMethod = function(base, length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return base[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return base[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return base[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return base[method](this[attribute], cb(iteratee, this), defaultVal, context);\n      };\n      default: return function() {\n        var args = slice.call(arguments);\n        args.unshift(this[attribute]);\n        return base[method].apply(base, args);\n      };\n    }\n  };\n\n  var addUnderscoreMethods = function(Class, base, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (base[method]) Class.prototype[method] = addMethod(base, length, method, attribute);\n    });\n  };\n\n  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.\n  var cb = function(iteratee, instance) {\n    if (_.isFunction(iteratee)) return iteratee;\n    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);\n    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };\n    return iteratee;\n  };\n  var modelMatcher = function(attrs) {\n    var matcher = _.matches(attrs);\n    return function(model) {\n      return matcher(model.attributes);\n    };\n  };\n\n  // Underscore methods that we want to implement on the Collection.\n  // 90% of the core usefulness of Backbone Collections is actually implemented\n  // right here:\n  var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,\n    foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,\n    select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,\n    contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,\n    head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,\n    without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,\n    isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,\n    sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};\n\n\n  // Underscore methods that we want to implement on the Model, mapped to the\n  // number of arguments they take.\n  var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,\n    omit: 0, chain: 1, isEmpty: 1};\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n\n  _.each([\n    [Collection, collectionMethods, 'models'],\n    [Model, modelMethods, 'attributes']\n  ], function(config) {\n    var Base = config[0],\n        methods = config[1],\n        attribute = config[2];\n\n    Base.mixin = function(obj) {\n      var mappings = _.reduce(_.functions(obj), function(memo, name) {\n        memo[name] = 0;\n        return memo;\n      }, {});\n      addUnderscoreMethods(Base, obj, mappings, attribute);\n    };\n\n    addUnderscoreMethods(Base, _, methods, attribute);\n  });\n\n  // Backbone.sync\n  // -------------\n\n  // Override this function to change the manner in which Backbone persists\n  // models to the server. You will be passed the type of request, and the\n  // model in question. By default, makes a RESTful Ajax request\n  // to the model's `url()`. Some possible customizations could be:\n  //\n  // * Use `setTimeout` to batch rapid-fire updates into a single request.\n  // * Send up the models as XML instead of JSON.\n  // * Persist models via WebSockets instead of Ajax.\n  //\n  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n  // as `POST`, with a `_method` parameter containing the true HTTP method,\n  // as well as all requests with the body as `application/x-www-form-urlencoded`\n  // instead of `application/json` with the model in a param named `model`.\n  // Useful when interfacing with server-side languages like **PHP** that make\n  // it difficult to read the body of `PUT` requests.\n  Backbone.sync = function(method, model, options) {\n    var type = methodMap[method];\n\n    // Default options, unless specified.\n    _.defaults(options || (options = {}), {\n      emulateHTTP: Backbone.emulateHTTP,\n      emulateJSON: Backbone.emulateJSON\n    });\n\n    // Default JSON-request options.\n    var params = {type: type, dataType: 'json'};\n\n    // Ensure that we have a URL.\n    if (!options.url) {\n      params.url = _.result(model, 'url') || urlError();\n    }\n\n    // Ensure that we have the appropriate request data.\n    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n      params.contentType = 'application/json';\n      params.data = JSON.stringify(options.attrs || model.toJSON(options));\n    }\n\n    // For older servers, emulate JSON by encoding the request into an HTML-form.\n    if (options.emulateJSON) {\n      params.contentType = 'application/x-www-form-urlencoded';\n      params.data = params.data ? {model: params.data} : {};\n    }\n\n    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n    // And an `X-HTTP-Method-Override` header.\n    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n      params.type = 'POST';\n      if (options.emulateJSON) params.data._method = type;\n      var beforeSend = options.beforeSend;\n      options.beforeSend = function(xhr) {\n        xhr.setRequestHeader('X-HTTP-Method-Override', type);\n        if (beforeSend) return beforeSend.apply(this, arguments);\n      };\n    }\n\n    // Don't process data on a non-GET request.\n    if (params.type !== 'GET' && !options.emulateJSON) {\n      params.processData = false;\n    }\n\n    // Pass along `textStatus` and `errorThrown` from jQuery.\n    var error = options.error;\n    options.error = function(xhr, textStatus, errorThrown) {\n      options.textStatus = textStatus;\n      options.errorThrown = errorThrown;\n      if (error) error.call(options.context, xhr, textStatus, errorThrown);\n    };\n\n    // Make the request, allowing the user to override any Ajax options.\n    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n    model.trigger('request', model, xhr, options);\n    return xhr;\n  };\n\n  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n  var methodMap = {\n    'create': 'POST',\n    'update': 'PUT',\n    'patch': 'PATCH',\n    'delete': 'DELETE',\n    'read': 'GET'\n  };\n\n  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n  // Override this if you'd like to use a different library.\n  Backbone.ajax = function() {\n    return Backbone.$.ajax.apply(Backbone.$, arguments);\n  };\n\n  // Backbone.Router\n  // ---------------\n\n  // Routers map faux-URLs to actions, and fire events when routes are\n  // matched. Creating a new one sets its `routes` hash, if not set statically.\n  var Router = Backbone.Router = function(options) {\n    options || (options = {});\n    this.preinitialize.apply(this, arguments);\n    if (options.routes) this.routes = options.routes;\n    this._bindRoutes();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regular expressions for matching named param parts and splatted\n  // parts of route strings.\n  var optionalParam = /\\((.*?)\\)/g;\n  var namedParam    = /(\\(\\?)?:\\w+/g;\n  var splatParam    = /\\*\\w+/g;\n  var escapeRegExp  = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n  // Set up all inheritable **Backbone.Router** properties and methods.\n  _.extend(Router.prototype, Events, {\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the Router.\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Manually bind a single named route to a callback. For example:\n    //\n    //     this.route('search/:query/p:num', 'search', function(query, num) {\n    //       ...\n    //     });\n    //\n    route: function(route, name, callback) {\n      if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n      if (_.isFunction(name)) {\n        callback = name;\n        name = '';\n      }\n      if (!callback) callback = this[name];\n      var router = this;\n      Backbone.history.route(route, function(fragment) {\n        var args = router._extractParameters(route, fragment);\n        if (router.execute(callback, args, name) !== false) {\n          router.trigger.apply(router, ['route:' + name].concat(args));\n          router.trigger('route', name, args);\n          Backbone.history.trigger('route', router, name, args);\n        }\n      });\n      return this;\n    },\n\n    // Execute a route handler with the provided parameters.  This is an\n    // excellent place to do pre-route setup or post-route cleanup.\n    execute: function(callback, args, name) {\n      if (callback) callback.apply(this, args);\n    },\n\n    // Simple proxy to `Backbone.history` to save a fragment into the history.\n    navigate: function(fragment, options) {\n      Backbone.history.navigate(fragment, options);\n      return this;\n    },\n\n    // Bind all defined routes to `Backbone.history`. We have to reverse the\n    // order of the routes here to support behavior where the most general\n    // routes can be defined at the bottom of the route map.\n    _bindRoutes: function() {\n      if (!this.routes) return;\n      this.routes = _.result(this, 'routes');\n      var route, routes = _.keys(this.routes);\n      while ((route = routes.pop()) != null) {\n        this.route(route, this.routes[route]);\n      }\n    },\n\n    // Convert a route string into a regular expression, suitable for matching\n    // against the current location hash.\n    _routeToRegExp: function(route) {\n      route = route.replace(escapeRegExp, '\\\\$&')\n      .replace(optionalParam, '(?:$1)?')\n      .replace(namedParam, function(match, optional) {\n        return optional ? match : '([^/?]+)';\n      })\n      .replace(splatParam, '([^?]*?)');\n      return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n    },\n\n    // Given a route, and a URL fragment that it matches, return the array of\n    // extracted decoded parameters. Empty or unmatched parameters will be\n    // treated as `null` to normalize cross-browser behavior.\n    _extractParameters: function(route, fragment) {\n      var params = route.exec(fragment).slice(1);\n      return _.map(params, function(param, i) {\n        // Don't decode the search params.\n        if (i === params.length - 1) return param || null;\n        return param ? decodeURIComponent(param) : null;\n      });\n    }\n\n  });\n\n  // Backbone.History\n  // ----------------\n\n  // Handles cross-browser history management, based on either\n  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n  // and URL fragments. If the browser supports neither (old IE, natch),\n  // falls back to polling.\n  var History = Backbone.History = function() {\n    this.handlers = [];\n    this.checkUrl = this.checkUrl.bind(this);\n\n    // Ensure that `History` can be used outside of the browser.\n    if (typeof window !== 'undefined') {\n      this.location = window.location;\n      this.history = window.history;\n    }\n  };\n\n  // Cached regex for stripping a leading hash/slash and trailing space.\n  var routeStripper = /^[#\\/]|\\s+$/g;\n\n  // Cached regex for stripping leading and trailing slashes.\n  var rootStripper = /^\\/+|\\/+$/g;\n\n  // Cached regex for stripping urls of hash.\n  var pathStripper = /#.*$/;\n\n  // Has the history handling already been started?\n  History.started = false;\n\n  // Set up all inheritable **Backbone.History** properties and methods.\n  _.extend(History.prototype, Events, {\n\n    // The default interval to poll for hash changes, if necessary, is\n    // twenty times a second.\n    interval: 50,\n\n    // Are we at the app root?\n    atRoot: function() {\n      var path = this.location.pathname.replace(/[^\\/]$/, '$&/');\n      return path === this.root && !this.getSearch();\n    },\n\n    // Does the pathname match the root?\n    matchRoot: function() {\n      var path = this.decodeFragment(this.location.pathname);\n      var rootPath = path.slice(0, this.root.length - 1) + '/';\n      return rootPath === this.root;\n    },\n\n    // Unicode characters in `location.pathname` are percent encoded so they're\n    // decoded for comparison. `%25` should not be decoded since it may be part\n    // of an encoded parameter.\n    decodeFragment: function(fragment) {\n      return decodeURI(fragment.replace(/%25/g, '%2525'));\n    },\n\n    // In IE6, the hash fragment and search params are incorrect if the\n    // fragment contains `?`.\n    getSearch: function() {\n      var match = this.location.href.replace(/#.*/, '').match(/\\?.+/);\n      return match ? match[0] : '';\n    },\n\n    // Gets the true hash value. Cannot use location.hash directly due to bug\n    // in Firefox where location.hash will always be decoded.\n    getHash: function(window) {\n      var match = (window || this).location.href.match(/#(.*)$/);\n      return match ? match[1] : '';\n    },\n\n    // Get the pathname and search params, without the root.\n    getPath: function() {\n      var path = this.decodeFragment(\n        this.location.pathname + this.getSearch()\n      ).slice(this.root.length - 1);\n      return path.charAt(0) === '/' ? path.slice(1) : path;\n    },\n\n    // Get the cross-browser normalized URL fragment from the path or hash.\n    getFragment: function(fragment) {\n      if (fragment == null) {\n        if (this._usePushState || !this._wantsHashChange) {\n          fragment = this.getPath();\n        } else {\n          fragment = this.getHash();\n        }\n      }\n      return fragment.replace(routeStripper, '');\n    },\n\n    // Start the hash change handling, returning `true` if the current URL matches\n    // an existing route, and `false` otherwise.\n    start: function(options) {\n      if (History.started) throw new Error('Backbone.history has already been started');\n      History.started = true;\n\n      // Figure out the initial configuration. Do we need an iframe?\n      // Is pushState desired ... is it available?\n      this.options          = _.extend({root: '/'}, this.options, options);\n      this.root             = this.options.root;\n      this._trailingSlash   = this.options.trailingSlash;\n      this._wantsHashChange = this.options.hashChange !== false;\n      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);\n      this._useHashChange   = this._wantsHashChange && this._hasHashChange;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.history && this.history.pushState);\n      this._usePushState    = this._wantsPushState && this._hasPushState;\n      this.fragment         = this.getFragment();\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      // Transition from hashChange to pushState or vice versa if both are\n      // requested.\n      if (this._wantsHashChange && this._wantsPushState) {\n\n        // If we've started off with a route from a `pushState`-enabled\n        // browser, but we're currently in a browser that doesn't support it...\n        if (!this._hasPushState && !this.atRoot()) {\n          var rootPath = this.root.slice(0, -1) || '/';\n          this.location.replace(rootPath + '#' + this.getPath());\n          // Return immediately as browser will do redirect to new url\n          return true;\n\n        // Or if we've started out with a hash-based route, but we're currently\n        // in a browser where it could be `pushState`-based instead...\n        } else if (this._hasPushState && this.atRoot()) {\n          this.navigate(this.getHash(), {replace: true});\n        }\n\n      }\n\n      // Proxy an iframe to handle location events if the browser doesn't\n      // support the `hashchange` event, HTML5 history, or the user wants\n      // `hashChange` but not `pushState`.\n      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {\n        this.iframe = document.createElement('iframe');\n        this.iframe.src = 'javascript:0';\n        this.iframe.style.display = 'none';\n        this.iframe.tabIndex = -1;\n        var body = document.body;\n        // Using `appendChild` will throw on IE < 9 if the document is not ready.\n        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;\n        iWindow.document.open();\n        iWindow.document.close();\n        iWindow.location.hash = '#' + this.fragment;\n      }\n\n      // Add a cross-platform `addEventListener` shim for older browsers.\n      var addEventListener = window.addEventListener || function(eventName, listener) {\n        return attachEvent('on' + eventName, listener);\n      };\n\n      // Depending on whether we're using pushState or hashes, and whether\n      // 'onhashchange' is supported, determine how we check the URL state.\n      if (this._usePushState) {\n        addEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        addEventListener('hashchange', this.checkUrl, false);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      if (!this.options.silent) return this.loadUrl();\n    },\n\n    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,\n    // but possibly useful for unit testing Routers.\n    stop: function() {\n      // Add a cross-platform `removeEventListener` shim for older browsers.\n      var removeEventListener = window.removeEventListener || function(eventName, listener) {\n        return detachEvent('on' + eventName, listener);\n      };\n\n      // Remove window listeners.\n      if (this._usePushState) {\n        removeEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        removeEventListener('hashchange', this.checkUrl, false);\n      }\n\n      // Clean up the iframe if necessary.\n      if (this.iframe) {\n        document.body.removeChild(this.iframe);\n        this.iframe = null;\n      }\n\n      // Some environments will throw when clearing an undefined interval.\n      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);\n      History.started = false;\n    },\n\n    // Add a route to be tested when the fragment changes. Routes added later\n    // may override previous routes.\n    route: function(route, callback) {\n      this.handlers.unshift({route: route, callback: callback});\n    },\n\n    // Checks the current URL to see if it has changed, and if it has,\n    // calls `loadUrl`, normalizing across the hidden iframe.\n    checkUrl: function(e) {\n      var current = this.getFragment();\n\n      // If the user pressed the back button, the iframe's hash will have\n      // changed and we should use that for comparison.\n      if (current === this.fragment && this.iframe) {\n        current = this.getHash(this.iframe.contentWindow);\n      }\n\n      if (current === this.fragment) {\n        if (!this.matchRoot()) return this.notfound();\n        return false;\n      }\n      if (this.iframe) this.navigate(current);\n      this.loadUrl();\n    },\n\n    // Attempt to load the current URL fragment. If a route succeeds with a\n    // match, returns `true`. If no defined routes matches the fragment,\n    // returns `false`.\n    loadUrl: function(fragment) {\n      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return this.notfound();\n      fragment = this.fragment = this.getFragment(fragment);\n      return _.some(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      }) || this.notfound();\n    },\n\n    // When no route could be matched, this method is called internally to\n    // trigger the `'notfound'` event. It returns `false` so that it can be used\n    // in tail position.\n    notfound: function() {\n      this.trigger('notfound');\n      return false;\n    },\n\n    // Save a fragment into the hash history, or replace the URL state if the\n    // 'replace' option is passed. You are responsible for properly URL-encoding\n    // the fragment in advance.\n    //\n    // The options object can contain `trigger: true` if you wish to have the\n    // route callback be fired (not usually desirable), or `replace: true`, if\n    // you wish to modify the current URL without adding an entry to the history.\n    navigate: function(fragment, options) {\n      if (!History.started) return false;\n      if (!options || options === true) options = {trigger: !!options};\n\n      // Normalize the fragment.\n      fragment = this.getFragment(fragment || '');\n\n      // Strip trailing slash on the root unless _trailingSlash is true\n      var rootPath = this.root;\n      if (!this._trailingSlash && (fragment === '' || fragment.charAt(0) === '?')) {\n        rootPath = rootPath.slice(0, -1) || '/';\n      }\n      var url = rootPath + fragment;\n\n      // Strip the fragment of the query and hash for matching.\n      fragment = fragment.replace(pathStripper, '');\n\n      // Decode for matching.\n      var decodedFragment = this.decodeFragment(fragment);\n\n      if (this.fragment === decodedFragment) return;\n      this.fragment = decodedFragment;\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._usePushState) {\n        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);\n\n      // If hash changes haven't been explicitly disabled, update the hash\n      // fragment to store history.\n      } else if (this._wantsHashChange) {\n        this._updateHash(this.location, fragment, options.replace);\n        if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {\n          var iWindow = this.iframe.contentWindow;\n\n          // Opening and closing the iframe tricks IE7 and earlier to push a\n          // history entry on hash-tag change.  When replace is true, we don't\n          // want this.\n          if (!options.replace) {\n            iWindow.document.open();\n            iWindow.document.close();\n          }\n\n          this._updateHash(iWindow.location, fragment, options.replace);\n        }\n\n      // If you've told us that you explicitly don't want fallback hashchange-\n      // based history, then `navigate` becomes a page refresh.\n      } else {\n        return this.location.assign(url);\n      }\n      if (options.trigger) return this.loadUrl(fragment);\n    },\n\n    // Update the hash location, either replacing the current entry, or adding\n    // a new one to the browser history.\n    _updateHash: function(location, fragment, replace) {\n      if (replace) {\n        var href = location.href.replace(/(javascript:|#).*$/, '');\n        location.replace(href + '#' + fragment);\n      } else {\n        // Some browsers require that `hash` contains a leading #.\n        location.hash = '#' + fragment;\n      }\n    }\n\n  });\n\n  // Create the default Backbone.history.\n  Backbone.history = new History;\n\n  // Helpers\n  // -------\n\n  // Helper function to correctly set up the prototype chain for subclasses.\n  // Similar to `goog.inherits`, but uses a hash of prototype properties and\n  // class properties to be extended.\n  var extend = function(protoProps, staticProps) {\n    var parent = this;\n    var child;\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent constructor.\n    if (protoProps && _.has(protoProps, 'constructor')) {\n      child = protoProps.constructor;\n    } else {\n      child = function(){ return parent.apply(this, arguments); };\n    }\n\n    // Add static properties to the constructor function, if supplied.\n    _.extend(child, parent, staticProps);\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function and add the prototype properties.\n    child.prototype = _.create(parent.prototype, protoProps);\n    child.prototype.constructor = child;\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    return child;\n  };\n\n  // Set up inheritance for the model, collection, router, view and history.\n  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;\n\n  // Throw an error when a URL is needed, and none is supplied.\n  var urlError = function() {\n    throw new Error('A \"url\" property or function must be specified');\n  };\n\n  // Wrap an optional error callback with a fallback error event.\n  var wrapError = function(model, options) {\n    var error = options.error;\n    options.error = function(resp) {\n      if (error) error.call(options.context, model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  // Provide useful information when things go wrong. This method is not meant\n  // to be used directly; it merely provides the necessary introspection for the\n  // external `debugInfo` function.\n  Backbone._debug = function() {\n    return {root: root, _: _};\n  };\n\n  return Backbone;\n});\n"],"names":["root","self","g","global","_","$","exports","Backbone","previousBackbone","slice","Array","prototype","VERSION","noConflict","this","emulateHTTP","emulateJSON","_listening","Events","eventSplitter","eventsApi","iteratee","events","name","callback","opts","names","i","context","keys","length","test","split","on","_events","onApi","ctx","listening","_listeners","id","interop","listenTo","obj","_listenId","uniqueId","listeningTo","_listeningTo","Listening","error","tryCatchOn","options","handlers","count","push","e","off","offApi","listeners","stopListening","ids","isEmpty","remaining","j","handler","_callback","cleanup","once","onceMap","bind","listenToOnce","map","offer","apply","arguments","trigger","Math","max","args","triggerApi","objEvents","allEvents","all","triggerEvents","concat","ev","l","a1","a2","a3","call","listener","unbind","extend","Model","attributes","attrs","preinitialize","cid","cidPrefix","collection","parse","defaults","result","set","changed","initialize","validationError","idAttribute","toJSON","clone","sync","get","attr","escape","has","matches","key","val","_validate","unset","silent","changes","changing","_changing","_previousAttributes","current","prev","isEqual","prevId","_pending","clear","hasChanged","changedAttributes","diff","old","previous","previousAttributes","fetch","model","success","resp","serverAttrs","wrapError","save","wait","validate","method","isNew","patch","xhr","destroy","defer","url","base","urlError","replace","encodeURIComponent","constructor","isValid","Collection","models","comparator","_reset","reset","setOptions","add","remove","merge","addOptions","splice","array","insert","at","min","tail","singular","isArray","removed","_removeModels","added","merged","_isModel","toAdd","toMerge","toRemove","modelMap","sort","sortable","sortAttr","isString","existing","_prepareModel","_addReference","orderChanged","some","m","index","_removeReference","previousModels","pop","unshift","shift","_byId","modelId","where","first","findWhere","Error","isFunction","sortBy","pluck","create","callbackOpts","_forwardPristineError","values","CollectionIterator","ITERATOR_VALUES","ITERATOR_KEYS","entries","ITERATOR_KEYSVALUES","indexOf","_onModelEvent","event","$$iterator","Symbol","iterator","kind","_collection","_kind","_index","next","value","done","View","pick","viewOptions","_ensureElement","delegateEventSplitter","tagName","selector","$el","find","render","_removeElement","setElement","element","undelegateEvents","_setElement","delegateEvents","el","match","delegate","eventName","undelegate","_createElement","document","createElement","className","_setAttributes","addMethod","attribute","cb","defaultVal","addUnderscoreMethods","Class","methods","each","instance","isObject","modelMatcher","matcher","collectionMethods","forEach","collect","reduce","foldl","inject","reduceRight","foldr","detect","filter","select","reject","every","any","include","includes","contains","invoke","toArray","size","head","take","initial","rest","drop","last","without","difference","shuffle","lastIndexOf","chain","sample","partition","groupBy","countBy","indexBy","findIndex","findLastIndex","modelMethods","pairs","invert","omit","config","Base","mixin","mappings","functions","memo","type","methodMap","params","dataType","data","contentType","JSON","stringify","_method","beforeSend","setRequestHeader","processData","textStatus","errorThrown","ajax","Router","routes","_bindRoutes","optionalParam","namedParam","splatParam","escapeRegExp","route","isRegExp","_routeToRegExp","router","history","fragment","_extractParameters","execute","navigate","optional","RegExp","exec","param","decodeURIComponent","History","checkUrl","window","location","routeStripper","rootStripper","pathStripper","started","interval","atRoot","pathname","getSearch","matchRoot","decodeFragment","decodeURI","href","getHash","getPath","path","charAt","getFragment","_usePushState","_wantsHashChange","start","_trailingSlash","trailingSlash","hashChange","_hasHashChange","documentMode","_useHashChange","_wantsPushState","pushState","_hasPushState","rootPath","iframe","src","style","display","tabIndex","body","iWindow","insertBefore","firstChild","contentWindow","open","close","hash","addEventListener","attachEvent","_checkUrlInterval","setInterval","loadUrl","stop","removeEventListener","detachEvent","removeChild","clearInterval","notfound","decodedFragment","title","assign","_updateHash","protoProps","staticProps","child","parent","__super__","_debug","factory"],"sourceRoot":""}