{"version":3,"sources":["webpack://jrs-ui/./runtime_dependencies/backbone/backbone.js"],"names":["root","this","define","_","$","exports","Backbone","previousBackbone","array","slice","push","splice","VERSION","noConflict","emulateHTTP","emulateJSON","Events","on","name","callback","context","eventsApi","_events","ctx","once","self","off","apply","arguments","_callback","retain","ev","events","names","i","l","j","k","keys","length","trigger","args","call","allEvents","all","triggerEvents","stopListening","obj","listeningTo","_listeningTo","remove","id","_listenId","isEmpty","eventSplitter","action","rest","key","concat","test","split","a1","a2","a3","listenMethods","listenTo","listenToOnce","each","implementation","method","uniqueId","bind","unbind","extend","Model","attributes","options","attrs","cid","collection","parse","defaults","result","set","changed","initialize","prototype","validationError","idAttribute","toJSON","clone","sync","get","attr","escape","has","val","unset","changes","silent","changing","prev","current","_validate","_changing","_previousAttributes","isEqual","_pending","clear","hasChanged","changedAttributes","diff","old","previous","previousAttributes","fetch","model","success","resp","wrapError","save","xhr","validate","wait","serverAttrs","isObject","isNew","patch","destroy","url","base","urlError","replace","encodeURIComponent","constructor","isValid","error","modelMethods","unshift","Collection","models","comparator","_reset","reset","setOptions","add","merge","addOptions","map","index","singular","isArray","_byId","indexOf","_removeReference","existing","sort","at","targetModel","sortable","sortAttr","isString","toAdd","toRemove","modelMap","order","_prepareModel","_addReference","orderedModels","previousModels","pop","shift","where","first","findWhere","Error","sortBy","pluck","invoke","create","_onModelEvent","event","methods","attributeMethods","value","iterator","isFunction","View","pick","viewOptions","_ensureElement","delegateEvents","delegateEventSplitter","tagName","selector","$el","find","render","setElement","element","delegate","undelegateEvents","el","match","eventName","className","type","methodMap","params","dataType","data","contentType","JSON","stringify","_method","beforeSend","setRequestHeader","processData","noXhrPatch","ActiveXObject","ajax","window","XMLHttpRequest","dispatchEvent","Router","routes","_bindRoutes","optionalParam","namedParam","splatParam","escapeRegExp","route","isRegExp","_routeToRegExp","router","history","fragment","_extractParameters","execute","navigate","optional","RegExp","exec","param","decodeURIComponent","History","handlers","bindAll","location","routeStripper","rootStripper","isExplorer","trailingSlash","pathStripper","started","interval","atRoot","pathname","getHash","href","getFragment","forcePushState","_hasPushState","_wantsHashChange","decodeURI","search","start","hashChange","_wantsPushState","pushState","docMode","document","documentMode","oldIE","navigator","userAgent","toLowerCase","frame","iframe","hide","appendTo","contentWindow","checkUrl","_checkUrlInterval","setInterval","loc","hash","replaceState","title","loadUrl","stop","clearInterval","e","any","handler","assign","_updateHash","open","close","protoProps","staticProps","child","parent","Surrogate","__super__","factory"],"mappings":"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","file":"_chunks/chunk.5892.js","sourcesContent":["//     Backbone.js 1.1.1\n\n//     (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(root, factory) {\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}(this, 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 local references to array methods we'll want to use later.\n  var array = [];\n  var push = array.push;\n  var slice = array.slice;\n  var splice = array.splice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.1.1';\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 ... 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  // custom events. You may bind with `on` or remove with `off` callback\n  // functions to an event; `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    // Bind an event to a `callback` function. Passing `\"all\"` will bind\n    // the callback to all events fired.\n    on: function(name, callback, context) {\n      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;\n      this._events || (this._events = {});\n      var events = this._events[name] || (this._events[name] = []);\n      events.push({callback: callback, context: context, ctx: context || this});\n      return this;\n    },\n\n    // Bind an event to only be triggered a single time. After the first time\n    // the callback is invoked, it will be removed.\n    once: function(name, callback, context) {\n      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;\n      var self = this;\n      var once = _.once(function() {\n        self.off(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n      return this.on(name, once, context);\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    off: function(name, callback, context) {\n      var retain, ev, events, names, i, l, j, k;\n      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;\n      if (!name && !callback && !context) {\n        this._events = void 0;\n        return this;\n      }\n      names = name ? [name] : _.keys(this._events);\n      for (i = 0, l = names.length; i < l; i++) {\n        name = names[i];\n        if (events = this._events[name]) {\n          this._events[name] = retain = [];\n          if (callback || context) {\n            for (j = 0, k = events.length; j < k; j++) {\n              ev = events[j];\n              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||\n                  (context && context !== ev.context)) {\n                retain.push(ev);\n              }\n            }\n          }\n          if (!retain.length) delete this._events[name];\n        }\n      }\n\n      return this;\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    trigger: function(name) {\n      if (!this._events) return this;\n      var args = slice.call(arguments, 1);\n      if (!eventsApi(this, 'trigger', name, args)) return this;\n      var events = this._events[name];\n      var allEvents = this._events.all;\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, arguments);\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    stopListening: function(obj, name, callback) {\n      var listeningTo = this._listeningTo;\n      if (!listeningTo) return this;\n      var remove = !name && !callback;\n      if (!callback && typeof name === 'object') callback = this;\n      if (obj) (listeningTo = {})[obj._listenId] = obj;\n      for (var id in listeningTo) {\n        obj = listeningTo[id];\n        obj.off(name, callback, this);\n        if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];\n      }\n      return this;\n    }\n\n  };\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // Implement fancy features of the Events API such as multiple event\n  // names `\"change blur\"` and jQuery-style event maps `{change: action}`\n  // in terms of the existing API.\n  var eventsApi = function(obj, action, name, rest) {\n    if (!name) return true;\n\n    // Handle event maps.\n    if (typeof name === 'object') {\n      for (var key in name) {\n        obj[action].apply(obj, [key, name[key]].concat(rest));\n      }\n      return false;\n    }\n\n    // Handle space separated event names.\n    if (eventSplitter.test(name)) {\n      var names = name.split(eventSplitter);\n      for (var i = 0, l = names.length; i < l; i++) {\n        obj[action].apply(obj, [names[i]].concat(rest));\n      }\n      return false;\n    }\n\n    return true;\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  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};\n\n  // Inversion-of-control versions of `on` and `once`. Tell *this* object to\n  // listen to an event in another object ... keeping track of what it's\n  // listening to.\n  _.each(listenMethods, function(implementation, method) {\n    Events[method] = function(obj, name, callback) {\n      var listeningTo = this._listeningTo || (this._listeningTo = {});\n      var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n      listeningTo[id] = obj;\n      if (!callback && typeof name === 'object') callback = this;\n      obj[implementation](name, callback, this);\n      return this;\n    };\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.cid = _.uniqueId('c');\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    attrs = _.defaults({}, attrs, _.result(this, 'defaults'));\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    // 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    // 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      var attr, attrs, unset, changes, silent, changing, prev, current;\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\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      unset           = options.unset;\n      silent          = options.silent;\n      changes         = [];\n      changing        = this._changing;\n      this._changing  = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n      current = this.attributes, prev = this._previousAttributes;\n\n      // Check for changes of `id`.\n      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];\n\n      // For each `set` attribute, update or delete the current value.\n      for (attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          this.changed[attr] = val;\n        } else {\n          delete this.changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0, l = changes.length; i < l; 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 val, changed = false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      for (var attr in diff) {\n        if (_.isEqual(old[attr], (val = diff[attr]))) continue;\n        (changed || (changed = {}))[attr] = val;\n      }\n      return changed;\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. If the server's representation of the\n    // model differs from its current attributes, they will be overridden,\n    // triggering a `\"change\"` event.\n    fetch: function(options) {\n      options = options ? _.clone(options) : {};\n      if (options.parse === void 0) options.parse = true;\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        if (!model.set(model.parse(resp, options), options)) return false;\n        if (success) success(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      var attrs, method, xhr, attributes = this.attributes;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\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}, options);\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 && !options.wait) {\n        if (!this.set(attrs, options)) return false;\n      } else {\n        if (!this._validate(attrs, options)) return false;\n      }\n\n      // Set temporary attributes if `{wait: true}`.\n      if (attrs && options.wait) {\n        this.attributes = _.extend({}, attributes, attrs);\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      if (options.parse === void 0) options.parse = true;\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = model.parse(resp, options);\n        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);\n        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {\n          return false;\n        }\n        if (success) success(model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n      if (method === 'patch') options.attrs = attrs;\n      xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      if (attrs && options.wait) 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\n      var destroy = function() {\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (options.wait || model.isNew()) destroy();\n        if (success) success(model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      if (this.isNew()) {\n        options.success();\n        return false;\n      }\n      wrapError(this, options);\n\n      var xhr = this.sync('delete', this, options);\n      if (!options.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      return base.replace(/([^\\/])$/, '$1/') + encodeURIComponent(this.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  // Underscore methods that we want to implement on the Model.\n  var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];\n\n  // Mix in each Underscore method as a proxy to `Model#attributes`.\n  _.each(modelMethods, function(method) {\n    Model.prototype[method] = function() {\n      var args = slice.call(arguments);\n      args.unshift(this.attributes);\n      return _[method].apply(_, args);\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 analagous 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    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  // 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    // 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.\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      var singular = !_.isArray(models);\n      models = singular ? [models] : _.clone(models);\n      options || (options = {});\n      var i, l, index, model;\n      for (i = 0, l = models.length; i < l; i++) {\n        model = models[i] = this.get(models[i]);\n        if (!model) continue;\n        delete this._byId[model.id];\n        delete this._byId[model.cid];\n        index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n        this._removeReference(model, options);\n      }\n      return singular ? models[0] : models;\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      options = _.defaults({}, options, setOptions);\n      if (options.parse) models = this.parse(models, options);\n      var singular = !_.isArray(models);\n      models = singular ? (models ? [models] : []) : _.clone(models);\n      var i, l, id, model, attrs, existing, sort;\n      var at = options.at;\n      var targetModel = this.model;\n      var sortable = this.comparator && (at == null) && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n      var toAdd = [], toRemove = [], modelMap = {};\n      var add = options.add, merge = options.merge, remove = options.remove;\n      var order = !sortable && add && remove ? [] : false;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      for (i = 0, l = models.length; i < l; i++) {\n        attrs = models[i] || {};\n        if (attrs instanceof Model) {\n          id = model = attrs;\n        } else {\n          id = attrs[targetModel.prototype.idAttribute || 'id'];\n        }\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        if (existing = this.get(id)) {\n          if (remove) modelMap[existing.cid] = true;\n          if (merge) {\n            attrs = attrs === model ? model.attributes : attrs;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;\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(attrs, options);\n          if (!model) continue;\n          toAdd.push(model);\n          this._addReference(model, options);\n        }\n\n        // Do not add multiple models with the same `id`.\n        model = existing || model;\n        if (order && (model.isNew() || !modelMap[model.id])) order.push(model);\n        modelMap[model.id] = true;\n      }\n\n      // Remove nonexistent models if appropriate.\n      if (remove) {\n        for (i = 0, l = this.length; i < l; ++i) {\n          if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this.remove(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      if (toAdd.length || (order && order.length)) {\n        if (sortable) sort = true;\n        this.length += toAdd.length;\n        if (at != null) {\n          for (i = 0, l = toAdd.length; i < l; i++) {\n            this.models.splice(at + i, 0, toAdd[i]);\n          }\n        } else {\n          if (order) this.models.length = 0;\n          var orderedModels = order || toAdd;\n          for (i = 0, l = orderedModels.length; i < l; i++) {\n            this.models.push(orderedModels[i]);\n          }\n        }\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 events.\n      if (!options.silent) {\n        for (i = 0, l = toAdd.length; i < l; i++) {\n          (model = toAdd[i]).trigger('add', model, this, options);\n        }\n        if (sort || (order && order.length)) this.trigger('sort', this, options);\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 = {});\n      for (var i = 0, l = this.models.length; i < l; 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      this.remove(model, options);\n      return model;\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      this.remove(model, options);\n      return model;\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.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid];\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\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      if (_.isEmpty(attrs)) return first ? void 0 : [];\n      return this[first ? 'find' : 'filter'](function(model) {\n        for (var key in attrs) {\n          if (attrs[key] !== model.get(key)) return false;\n        }\n        return true;\n      });\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      if (!this.comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      // Run sort based on type of `comparator`.\n      if (_.isString(this.comparator) || this.comparator.length === 1) {\n        this.models = this.sortBy(this.comparator, this);\n      } else {\n        this.models.sort(_.bind(this.comparator, this));\n      }\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 _.invoke(this.models, 'get', 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 = options ? _.clone(options) : {};\n      if (options.parse === void 0) options.parse = true;\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(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      if (!(model = this._prepareModel(model, options))) return false;\n      if (!options.wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(model, resp) {\n        if (options.wait) collection.add(model, options);\n        if (success) success(model, resp, options);\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    },\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 (attrs instanceof Model) return attrs;\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n      var model = new this.model(attrs, options);\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\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      if (model.id != null) this._byId[model.id] = model;\n      if (!model.collection) model.collection = this;\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      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 ((event === 'add' || event === 'remove') && collection !== this) return;\n      if (event === 'destroy') this.remove(model, options);\n      if (model && event === 'change:' + model.idAttribute) {\n        delete this._byId[model.previous(model.idAttribute)];\n        if (model.id != null) this._byId[model.id] = model;\n      }\n      this.trigger.apply(this, arguments);\n    }\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 methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',\n    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',\n    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',\n    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',\n    'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',\n    'lastIndexOf', 'isEmpty', 'chain', 'sample'];\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n  _.each(methods, function(method) {\n    Collection.prototype[method] = function() {\n      var args = slice.call(arguments);\n      args.unshift(this.models);\n      return _[method].apply(_, args);\n    };\n  });\n\n  // Underscore methods that take a property name as an argument.\n  var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];\n\n  // Use attributes instead of properties.\n  _.each(attributeMethods, function(method) {\n    Collection.prototype[method] = function(value, context) {\n      var iterator = _.isFunction(value) ? value : function(model) {\n        return model.get(value);\n      };\n      return _[method](this.models, iterator, context);\n    };\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    options || (options = {});\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n    this.delegateEvents();\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be merged 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    // 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.$el.remove();\n      this.stopListening();\n      return this;\n    },\n\n    // Change the view's element (`this.el` property), including event\n    // re-delegation.\n    setElement: function(element, delegate) {\n      if (this.$el) this.undelegateEvents();\n      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);\n      this.el = this.$el[0];\n      if (delegate !== false) this.delegateEvents();\n      return this;\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    // This only works for delegate-able events: not `focus`, `blur`, and\n    // not `change`, `submit`, and `reset` in Internet Explorer.\n    delegateEvents: function(events) {\n      if (!(events || (events = _.result(this, 'events')))) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[events[key]];\n        if (!method) continue;\n\n        var match = key.match(delegateEventSplitter);\n        var eventName = match[1], selector = match[2];\n        method = _.bind(method, this);\n        eventName += '.delegateEvents' + this.cid;\n        if (selector === '') {\n          this.$el.on(eventName, method);\n        } else {\n          this.$el.on(eventName, selector, method);\n        }\n      }\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view with `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      this.$el.off('.delegateEvents' + this.cid);\n      return this;\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        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);\n        this.setElement($el, false);\n      } else {\n        this.setElement(_.result(this, 'el'), false);\n      }\n    }\n\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    // If we're sending a `PATCH` request, and we're in an old Internet Explorer\n    // that still has ActiveX enabled by default, override jQuery to use that\n    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.\n    if (params.type === 'PATCH' && noXhrPatch) {\n      params.xhr = function() {\n        return new ActiveXObject(\"Microsoft.XMLHTTP\");\n      };\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  var noXhrPatch =\n    typeof window !== 'undefined' && !!window.ActiveXObject &&\n      !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);\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    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    // 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        router.execute(callback, args);\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      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) {\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 + '(?:\\\\?(.*))?$');\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    _.bindAll(this, 'checkUrl');\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 detecting MSIE.\n  var isExplorer = /msie [\\w.]+/;\n\n  // Cached regex for removing a trailing slash.\n  var trailingSlash = /\\/$/;\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      return this.location.pathname.replace(/[^\\/]$/, '$&/') === this.root;\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 cross-browser normalized URL fragment, either from the URL,\n    // the hash, or the override.\n    getFragment: function(fragment, forcePushState) {\n      if (fragment == null) {\n        if (this._hasPushState || !this._wantsHashChange || forcePushState) {\n          fragment = decodeURI(this.location.pathname + this.location.search);\n          var root = this.root.replace(trailingSlash, '');\n          if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);\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._wantsHashChange = this.options.hashChange !== false;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);\n      var fragment          = this.getFragment();\n      var docMode           = document.documentMode;\n      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      if (oldIE && this._wantsHashChange) {\n        var frame = Backbone.$('<iframe src=\"javascript:0\" tabindex=\"-1\">');\n        this.iframe = frame.hide().appendTo('body')[0].contentWindow;\n        this.navigate(fragment);\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._hasPushState) {\n        Backbone.$(window).on('popstate', this.checkUrl);\n      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {\n        Backbone.$(window).on('hashchange', this.checkUrl);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      // Determine if we need to change the base url, for a pushState link\n      // opened by a non-pushState browser.\n      this.fragment = fragment;\n      var loc = this.location;\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          this.fragment = this.getFragment(null, true);\n          this.location.replace(this.root + '#' + this.fragment);\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() && loc.hash) {\n          this.fragment = this.getHash().replace(routeStripper, '');\n          this.history.replaceState({}, document.title, this.root + this.fragment);\n        }\n\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      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);\n      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      if (current === this.fragment && this.iframe) {\n        current = this.getFragment(this.getHash(this.iframe));\n      }\n      if (current === this.fragment) return false;\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      fragment = this.fragment = this.getFragment(fragment);\n      return _.any(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      });\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      var url = this.root + (fragment = this.getFragment(fragment || ''));\n\n      // Strip the hash for matching.\n      fragment = fragment.replace(pathStripper, '');\n\n      if (this.fragment === fragment) return;\n      this.fragment = fragment;\n\n      // Don't include a trailing slash on the root.\n      if (fragment === '' && url !== '/') url = url.slice(0, -1);\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._hasPushState) {\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.getFragment(this.getHash(this.iframe)))) {\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) this.iframe.document.open().close();\n          this._updateHash(this.iframe.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's 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.\n    var Surrogate = function(){ this.constructor = child; };\n    Surrogate.prototype = parent.prototype;\n    child.prototype = new Surrogate;\n\n    // Add prototype properties (instance properties) to the subclass,\n    // if supplied.\n    if (protoProps) _.extend(child.prototype, protoProps);\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(model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  return Backbone;\n\n}));\n"],"sourceRoot":""}