{"version":3,"file":"~~backbone.0fe7806a.js","mappings":"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","sources":["webpack://@ultradent/upi-dev-frontend/./node_modules/backbone/backbone.js"],"sourcesContent":["//     Backbone.js 1.3.3\n\n//     (c) 2010-2017 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(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  // NOTE --> UMD support has been removed from the initialization of this module\n  // this was done due to issues attempting to disable AMD support through\n  // implementing the imports-loader from webpack - this approach did not work as expected\n  // and both jQuery and Underscore were packaged when backbone was imported\n  root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\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.3.3';\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  // 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(length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return _[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return _[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return _[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return _[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 _[method].apply(_, args);\n      };\n    }\n  };\n  var addUnderscoreMethods = function(Class, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (_[method]) Class.prototype[method] = addMethod(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  // 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  // 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    return internalOn(this, name, callback, context);\n  };\n\n  // Guard the `listening` argument from the public API.\n  var internalOn = function(obj, name, callback, context, listening) {\n    obj._events = eventsApi(onApi, obj._events || {}, name, callback, {\n      context: context,\n      ctx: obj,\n      listening: listening\n    });\n\n    if (listening) {\n      var listeners = obj._listeners || (obj._listeners = {});\n      listeners[listening.id] = listening;\n    }\n\n    return obj;\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 = 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      var thisId = this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};\n    }\n\n    // Bind callbacks on obj, and keep track of them on listening.\n    internalOn(obj, name, callback, this, listening);\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  // 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    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\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    }\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 i = 0, listening;\n    var context = options.context, listeners = options.listeners;\n\n    // Delete all events listeners and \"drop\" events.\n    if (!name && !callback && !context) {\n      var ids = _.keys(listeners);\n      for (; i < ids.length; i++) {\n        listening = listeners[ids[i]];\n        delete listeners[listening.id];\n        delete listening.listeningTo[listening.objId];\n      }\n      return;\n    }\n\n    var 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      // Replace events if there are any remaining.  Otherwise, clean up.\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          listening = handler.listening;\n          if (listening && --listening.count === 0) {\n            delete listeners[listening.id];\n            delete listening.listeningTo[listening.objId];\n          }\n        }\n      }\n\n      // Update tail event if the list has any events.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\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, _.bind(this.off, 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, _.bind(this.stopListening, 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  // 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    attrs = _.defaults(_.extend({}, defaults, attrs), 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    // 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) this.id = this.get(this.idAttribute);\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  // 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 `Model#attributes`.\n  addUnderscoreMethods(Model, modelMethods, 'attributes');\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)] ||\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 = _.bind(comparator, 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) collection.add(m, callbackOpts);\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\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) {\n      return attrs[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      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 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);\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      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);\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);\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 === 'change') {\n          var prevId = this.modelId(model.previousAttributes());\n          var id = this.modelId(model.attributes);\n          if (prevId !== id) {\n            if (prevId != null) delete this._byId[prevId];\n            if (id != null) this._byId[id] = model;\n          }\n        }\n      }\n      this.trigger.apply(this, arguments);\n    }\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);\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  // 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  // Mix in each Underscore method as a proxy to `Collection#models`.\n  addUnderscoreMethods(Collection, collectionMethods, 'models');\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], _.bind(method, 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  // 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 = _.bind(this.checkUrl, 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._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) 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      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return false;\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      });\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      // Don't include a trailing slash on the root.\n      var rootPath = this.root;\n      if (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  return Backbone;\n});\n"],"names":["root","self","g","global","Backbone","_","$","previousBackbone","slice","Array","prototype","VERSION","noConflict","this","emulateHTTP","emulateJSON","addMethod","length","method","attribute","value","iteratee","context","cb","defaultVal","args","call","arguments","unshift","apply","addUnderscoreMethods","Class","methods","each","instance","isFunction","isObject","_isModel","modelMatcher","isString","model","get","attrs","matcher","matches","attributes","Events","eventSplitter","eventsApi","events","name","callback","opts","names","i","keys","test","split","on","internalOn","obj","listening","_events","onApi","ctx","_listeners","id","listenTo","_listenId","uniqueId","listeningTo","_listeningTo","thisId","objId","count","options","handlers","push","off","offApi","listeners","stopListening","ids","remaining","j","handler","_callback","once","onceMap","bind","listenToOnce","map","offer","trigger","Math","max","triggerApi","objEvents","allEvents","all","triggerEvents","concat","ev","l","a1","a2","a3","unbind","extend","Model","preinitialize","cid","cidPrefix","collection","parse","defaults","result","set","changed","initialize","validationError","idAttribute","toJSON","clone","sync","attr","escape","has","key","val","_validate","unset","silent","changes","changing","_changing","_previousAttributes","current","prev","isEqual","_pending","clear","hasChanged","isEmpty","changedAttributes","diff","old","previous","previousAttributes","fetch","success","resp","serverAttrs","wrapError","save","wait","validate","isNew","patch","xhr","destroy","defer","url","base","urlError","replace","encodeURIComponent","constructor","isValid","error","values","pairs","invert","pick","omit","chain","Collection","models","comparator","_reset","reset","setOptions","add","remove","merge","addOptions","splice","array","insert","at","min","tail","singular","isArray","removed","_removeModels","added","merged","toAdd","toMerge","toRemove","modelMap","sort","sortable","sortAttr","existing","_prepareModel","_addReference","orderChanged","some","m","index","_removeReference","previousModels","pop","shift","_byId","modelId","where","first","findWhere","Error","sortBy","pluck","create","callbackOpts","CollectionIterator","ITERATOR_VALUES","ITERATOR_KEYS","entries","ITERATOR_KEYSVALUES","indexOf","_onModelEvent","event","prevId","$$iterator","Symbol","iterator","kind","_collection","_kind","_index","next","done","forEach","collect","reduce","foldl","inject","reduceRight","foldr","find","detect","filter","select","reject","every","any","include","includes","contains","invoke","toArray","size","head","take","initial","rest","drop","last","without","difference","shuffle","lastIndexOf","sample","partition","groupBy","countBy","indexBy","findIndex","findLastIndex","View","viewOptions","_ensureElement","delegateEventSplitter","tagName","selector","$el","render","_removeElement","setElement","element","undelegateEvents","_setElement","delegateEvents","el","match","delegate","eventName","listener","undelegate","_createElement","document","createElement","className","_setAttributes","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","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","e","decodedFragment","title","assign","_updateHash","protoProps","staticProps","child","parent","__super__","factory","jQuery","Zepto","ender"],"sourceRoot":""}