{"version":3,"file":"js/391-47c3a0b6f2c17c0e5dca.js","mappings":"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","sources":["webpack:///./node_modules/backbone/backbone.js","webpack:///./node_modules/underscore/modules/_setup.js","webpack:///./node_modules/underscore/modules/restArguments.js","webpack:///./node_modules/underscore/modules/isObject.js","webpack:///./node_modules/underscore/modules/isNull.js","webpack:///./node_modules/underscore/modules/isUndefined.js","webpack:///./node_modules/underscore/modules/isBoolean.js","webpack:///./node_modules/underscore/modules/isElement.js","webpack:///./node_modules/underscore/modules/_tagTester.js","webpack:///./node_modules/underscore/modules/isString.js","webpack:///./node_modules/underscore/modules/isNumber.js","webpack:///./node_modules/underscore/modules/isDate.js","webpack:///./node_modules/underscore/modules/isRegExp.js","webpack:///./node_modules/underscore/modules/isError.js","webpack:///./node_modules/underscore/modules/isSymbol.js","webpack:///./node_modules/underscore/modules/isArrayBuffer.js","webpack:///./node_modules/underscore/modules/isFunction.js","webpack:///./node_modules/underscore/modules/_hasObjectTag.js","webpack:///./node_modules/underscore/modules/_stringTagBug.js","webpack:///./node_modules/underscore/modules/isDataView.js","webpack:///./node_modules/underscore/modules/isArray.js","webpack:///./node_modules/underscore/modules/_has.js","webpack:///./node_modules/underscore/modules/isArguments.js","webpack:///./node_modules/underscore/modules/isFinite.js","webpack:///./node_modules/underscore/modules/isNaN.js","webpack:///./node_modules/underscore/modules/constant.js","webpack:///./node_modules/underscore/modules/_createSizePropertyCheck.js","webpack:///./node_modules/underscore/modules/_shallowProperty.js","webpack:///./node_modules/underscore/modules/_getByteLength.js","webpack:///./node_modules/underscore/modules/_isBufferLike.js","webpack:///./node_modules/underscore/modules/isTypedArray.js","webpack:///./node_modules/underscore/modules/_getLength.js","webpack:///./node_modules/underscore/modules/_collectNonEnumProps.js","webpack:///./node_modules/underscore/modules/keys.js","webpack:///./node_modules/underscore/modules/isEmpty.js","webpack:///./node_modules/underscore/modules/isMatch.js","webpack:///./node_modules/underscore/modules/underscore.js","webpack:///./node_modules/underscore/modules/_toBufferView.js","webpack:///./node_modules/underscore/modules/isEqual.js","webpack:///./node_modules/underscore/modules/allKeys.js","webpack:///./node_modules/underscore/modules/_methodFingerprint.js","webpack:///./node_modules/underscore/modules/isMap.js","webpack:///./node_modules/underscore/modules/isWeakMap.js","webpack:///./node_modules/underscore/modules/isSet.js","webpack:///./node_modules/underscore/modules/isWeakSet.js","webpack:///./node_modules/underscore/modules/values.js","webpack:///./node_modules/underscore/modules/pairs.js","webpack:///./node_modules/underscore/modules/invert.js","webpack:///./node_modules/underscore/modules/functions.js","webpack:///./node_modules/underscore/modules/_createAssigner.js","webpack:///./node_modules/underscore/modules/extend.js","webpack:///./node_modules/underscore/modules/extendOwn.js","webpack:///./node_modules/underscore/modules/defaults.js","webpack:///./node_modules/underscore/modules/_baseCreate.js","webpack:///./node_modules/underscore/modules/create.js","webpack:///./node_modules/underscore/modules/clone.js","webpack:///./node_modules/underscore/modules/tap.js","webpack:///./node_modules/underscore/modules/toPath.js","webpack:///./node_modules/underscore/modules/_toPath.js","webpack:///./node_modules/underscore/modules/_deepGet.js","webpack:///./node_modules/underscore/modules/get.js","webpack:///./node_modules/underscore/modules/has.js","webpack:///./node_modules/underscore/modules/identity.js","webpack:///./node_modules/underscore/modules/matcher.js","webpack:///./node_modules/underscore/modules/property.js","webpack:///./node_modules/underscore/modules/_optimizeCb.js","webpack:///./node_modules/underscore/modules/_baseIteratee.js","webpack:///./node_modules/underscore/modules/iteratee.js","webpack:///./node_modules/underscore/modules/_cb.js","webpack:///./node_modules/underscore/modules/mapObject.js","webpack:///./node_modules/underscore/modules/noop.js","webpack:///./node_modules/underscore/modules/propertyOf.js","webpack:///./node_modules/underscore/modules/times.js","webpack:///./node_modules/underscore/modules/random.js","webpack:///./node_modules/underscore/modules/now.js","webpack:///./node_modules/underscore/modules/_createEscaper.js","webpack:///./node_modules/underscore/modules/_escapeMap.js","webpack:///./node_modules/underscore/modules/escape.js","webpack:///./node_modules/underscore/modules/unescape.js","webpack:///./node_modules/underscore/modules/_unescapeMap.js","webpack:///./node_modules/underscore/modules/templateSettings.js","webpack:///./node_modules/underscore/modules/template.js","webpack:///./node_modules/underscore/modules/result.js","webpack:///./node_modules/underscore/modules/uniqueId.js","webpack:///./node_modules/underscore/modules/chain.js","webpack:///./node_modules/underscore/modules/_executeBound.js","webpack:///./node_modules/underscore/modules/partial.js","webpack:///./node_modules/underscore/modules/bind.js","webpack:///./node_modules/underscore/modules/_isArrayLike.js","webpack:///./node_modules/underscore/modules/_flatten.js","webpack:///./node_modules/underscore/modules/bindAll.js","webpack:///./node_modules/underscore/modules/memoize.js","webpack:///./node_modules/underscore/modules/delay.js","webpack:///./node_modules/underscore/modules/defer.js","webpack:///./node_modules/underscore/modules/throttle.js","webpack:///./node_modules/underscore/modules/debounce.js","webpack:///./node_modules/underscore/modules/wrap.js","webpack:///./node_modules/underscore/modules/negate.js","webpack:///./node_modules/underscore/modules/compose.js","webpack:///./node_modules/underscore/modules/after.js","webpack:///./node_modules/underscore/modules/before.js","webpack:///./node_modules/underscore/modules/once.js","webpack:///./node_modules/underscore/modules/findKey.js","webpack:///./node_modules/underscore/modules/_createPredicateIndexFinder.js","webpack:///./node_modules/underscore/modules/findIndex.js","webpack:///./node_modules/underscore/modules/findLastIndex.js","webpack:///./node_modules/underscore/modules/sortedIndex.js","webpack:///./node_modules/underscore/modules/_createIndexFinder.js","webpack:///./node_modules/underscore/modules/indexOf.js","webpack:///./node_modules/underscore/modules/lastIndexOf.js","webpack:///./node_modules/underscore/modules/find.js","webpack:///./node_modules/underscore/modules/findWhere.js","webpack:///./node_modules/underscore/modules/each.js","webpack:///./node_modules/underscore/modules/map.js","webpack:///./node_modules/underscore/modules/_createReduce.js","webpack:///./node_modules/underscore/modules/reduce.js","webpack:///./node_modules/underscore/modules/reduceRight.js","webpack:///./node_modules/underscore/modules/filter.js","webpack:///./node_modules/underscore/modules/reject.js","webpack:///./node_modules/underscore/modules/every.js","webpack:///./node_modules/underscore/modules/some.js","webpack:///./node_modules/underscore/modules/contains.js","webpack:///./node_modules/underscore/modules/invoke.js","webpack:///./node_modules/underscore/modules/pluck.js","webpack:///./node_modules/underscore/modules/where.js","webpack:///./node_modules/underscore/modules/max.js","webpack:///./node_modules/underscore/modules/min.js","webpack:///./node_modules/underscore/modules/toArray.js","webpack:///./node_modules/underscore/modules/sample.js","webpack:///./node_modules/underscore/modules/shuffle.js","webpack:///./node_modules/underscore/modules/sortBy.js","webpack:///./node_modules/underscore/modules/_group.js","webpack:///./node_modules/underscore/modules/groupBy.js","webpack:///./node_modules/underscore/modules/indexBy.js","webpack:///./node_modules/underscore/modules/countBy.js","webpack:///./node_modules/underscore/modules/partition.js","webpack:///./node_modules/underscore/modules/size.js","webpack:///./node_modules/underscore/modules/_keyInObj.js","webpack:///./node_modules/underscore/modules/pick.js","webpack:///./node_modules/underscore/modules/omit.js","webpack:///./node_modules/underscore/modules/initial.js","webpack:///./node_modules/underscore/modules/first.js","webpack:///./node_modules/underscore/modules/rest.js","webpack:///./node_modules/underscore/modules/last.js","webpack:///./node_modules/underscore/modules/compact.js","webpack:///./node_modules/underscore/modules/flatten.js","webpack:///./node_modules/underscore/modules/difference.js","webpack:///./node_modules/underscore/modules/without.js","webpack:///./node_modules/underscore/modules/uniq.js","webpack:///./node_modules/underscore/modules/union.js","webpack:///./node_modules/underscore/modules/intersection.js","webpack:///./node_modules/underscore/modules/unzip.js","webpack:///./node_modules/underscore/modules/zip.js","webpack:///./node_modules/underscore/modules/object.js","webpack:///./node_modules/underscore/modules/range.js","webpack:///./node_modules/underscore/modules/chunk.js","webpack:///./node_modules/underscore/modules/_chainResult.js","webpack:///./node_modules/underscore/modules/mixin.js","webpack:///./node_modules/underscore/modules/underscore-array-methods.js","webpack:///./node_modules/underscore/modules/index-default.js"],"sourcesContent":["//     Backbone.js 1.6.0\n\n//     (c) 2010-2024 Jeremy Ashkenas and DocumentCloud\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(factory) {\n\n  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.\n  // We use `self` instead of `window` for `WebWorker` support.\n  var root = typeof self == 'object' && self.self === self && self ||\n            typeof global == 'object' && global.global === global && global;\n\n  // Set up Backbone appropriately for the environment. Start with AMD.\n  if (typeof define === 'function' && define.amd) {\n    define(['underscore', 'jquery', 'exports'], function(_, $, exports) {\n      // Export global even in AMD case in case this script is loaded with\n      // others that may still expect a global Backbone.\n      root.Backbone = factory(root, exports, _, $);\n    });\n\n  // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n  } else if (typeof exports !== 'undefined') {\n    var _ = require('underscore'), $;\n    try { $ = require('jquery'); } catch (e) {}\n    factory(root, exports, _, $);\n\n  // Finally, as a browser global.\n  } else {\n    root.Backbone = factory(root, {}, root._, root.jQuery || root.Zepto || root.ender || root.$);\n  }\n\n})(function(root, Backbone, _, $) {\n\n  // Initial Setup\n  // -------------\n\n  // Save the previous value of the `Backbone` variable, so that it can be\n  // restored later on, if `noConflict` is used.\n  var previousBackbone = root.Backbone;\n\n  // Create a local reference to a common array method we'll want to use later.\n  var slice = Array.prototype.slice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.6.0';\n\n  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n  // the `$` variable.\n  Backbone.$ = $;\n\n  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n  // to its previous owner. Returns a reference to this Backbone object.\n  Backbone.noConflict = function() {\n    root.Backbone = previousBackbone;\n    return this;\n  };\n\n  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n  // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n  // set a `X-Http-Method-Override` header.\n  Backbone.emulateHTTP = false;\n\n  // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n  // `application/json` requests ... this will encode the body as\n  // `application/x-www-form-urlencoded` instead and will send the model in a\n  // form param named `model`.\n  Backbone.emulateJSON = false;\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // a custom event channel. You may bind a callback to an event with `on` or\n  // remove with `off`; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  var Events = Backbone.Events = {};\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // A private global variable to share between listeners and listenees.\n  var _listening;\n\n  // Iterates over the standard `event, callback` (as well as the fancy multiple\n  // space-separated events `\"change blur\", callback` and jQuery-style event\n  // maps `{event: callback}`).\n  var eventsApi = function(iteratee, events, name, callback, opts) {\n    var i = 0, names;\n    if (name && typeof name === 'object') {\n      // Handle event maps.\n      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;\n      for (names = _.keys(name); i < names.length ; i++) {\n        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);\n      }\n    } else if (name && eventSplitter.test(name)) {\n      // Handle space-separated event names by delegating them individually.\n      for (names = name.split(eventSplitter); i < names.length; i++) {\n        events = iteratee(events, names[i], callback, opts);\n      }\n    } else {\n      // Finally, standard events.\n      events = iteratee(events, name, callback, opts);\n    }\n    return events;\n  };\n\n  // Bind an event to a `callback` function. Passing `\"all\"` will bind\n  // the callback to all events fired.\n  Events.on = function(name, callback, context) {\n    this._events = eventsApi(onApi, this._events || {}, name, callback, {\n      context: context,\n      ctx: this,\n      listening: _listening\n    });\n\n    if (_listening) {\n      var listeners = this._listeners || (this._listeners = {});\n      listeners[_listening.id] = _listening;\n      // Allow the listening to use a counter, instead of tracking\n      // callbacks for library interop\n      _listening.interop = false;\n    }\n\n    return this;\n  };\n\n  // Inversion-of-control versions of `on`. Tell *this* object to listen to\n  // an event in another object... keeping track of what it's listening to\n  // for easier unbinding later.\n  Events.listenTo = function(obj, name, callback) {\n    if (!obj) return this;\n    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n    var listeningTo = this._listeningTo || (this._listeningTo = {});\n    var listening = _listening = listeningTo[id];\n\n    // This object is not listening to any other events on `obj` yet.\n    // Setup the necessary references to track the listening callbacks.\n    if (!listening) {\n      this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = _listening = listeningTo[id] = new Listening(this, obj);\n    }\n\n    // Bind callbacks on obj.\n    var error = tryCatchOn(obj, name, callback, this);\n    _listening = void 0;\n\n    if (error) throw error;\n    // If the target obj is not Backbone.Events, track events manually.\n    if (listening.interop) listening.on(name, callback);\n\n    return this;\n  };\n\n  // The reducing API that adds a callback to the `events` object.\n  var onApi = function(events, name, callback, options) {\n    if (callback) {\n      var handlers = events[name] || (events[name] = []);\n      var context = options.context, ctx = options.ctx, listening = options.listening;\n      if (listening) listening.count++;\n\n      handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});\n    }\n    return events;\n  };\n\n  // An try-catch guarded #on function, to prevent poisoning the global\n  // `_listening` variable.\n  var tryCatchOn = function(obj, name, callback, context) {\n    try {\n      obj.on(name, callback, context);\n    } catch (e) {\n      return e;\n    }\n  };\n\n  // Remove one or many callbacks. If `context` is null, removes all\n  // callbacks with that function. If `callback` is null, removes all\n  // callbacks for the event. If `name` is null, removes all bound\n  // callbacks for all events.\n  Events.off = function(name, callback, context) {\n    if (!this._events) return this;\n    this._events = eventsApi(offApi, this._events, name, callback, {\n      context: context,\n      listeners: this._listeners\n    });\n\n    return this;\n  };\n\n  // Tell this object to stop listening to either specific events ... or\n  // to every object it's currently listening to.\n  Events.stopListening = function(obj, name, callback) {\n    var listeningTo = this._listeningTo;\n    if (!listeningTo) return this;\n\n    var ids = obj ? [obj._listenId] : _.keys(listeningTo);\n    for (var i = 0; i < ids.length; i++) {\n      var listening = listeningTo[ids[i]];\n\n      // If listening doesn't exist, this object is not currently\n      // listening to obj. Break out early.\n      if (!listening) break;\n\n      listening.obj.off(name, callback, this);\n      if (listening.interop) listening.off(name, callback);\n    }\n    if (_.isEmpty(listeningTo)) this._listeningTo = void 0;\n\n    return this;\n  };\n\n  // The reducing API that removes a callback from the `events` object.\n  var offApi = function(events, name, callback, options) {\n    if (!events) return;\n\n    var context = options.context, listeners = options.listeners;\n    var i = 0, names;\n\n    // Delete all event listeners and \"drop\" events.\n    if (!name && !context && !callback) {\n      for (names = _.keys(listeners); i < names.length; i++) {\n        listeners[names[i]].cleanup();\n      }\n      return;\n    }\n\n    names = name ? [name] : _.keys(events);\n    for (; i < names.length; i++) {\n      name = names[i];\n      var handlers = events[name];\n\n      // Bail out if there are no events stored.\n      if (!handlers) break;\n\n      // Find any remaining events.\n      var remaining = [];\n      for (var j = 0; j < handlers.length; j++) {\n        var handler = handlers[j];\n        if (\n          callback && callback !== handler.callback &&\n            callback !== handler.callback._callback ||\n              context && context !== handler.context\n        ) {\n          remaining.push(handler);\n        } else {\n          var listening = handler.listening;\n          if (listening) listening.off(name, callback);\n        }\n      }\n\n      // Replace events if there are any remaining.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\n      }\n    }\n\n    return events;\n  };\n\n  // Bind an event to only be triggered a single time. After the first time\n  // the callback is invoked, its listener will be removed. If multiple events\n  // are passed in using the space-separated syntax, the handler will fire\n  // once for each event, not once for a combination of all events.\n  Events.once = function(name, callback, context) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, this.off.bind(this));\n    if (typeof name === 'string' && context == null) callback = void 0;\n    return this.on(events, callback, context);\n  };\n\n  // Inversion-of-control versions of `once`.\n  Events.listenToOnce = function(obj, name, callback) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, this.stopListening.bind(this, obj));\n    return this.listenTo(obj, events);\n  };\n\n  // Reduces the event callbacks into a map of `{event: onceWrapper}`.\n  // `offer` unbinds the `onceWrapper` after it has been called.\n  var onceMap = function(map, name, callback, offer) {\n    if (callback) {\n      var once = map[name] = _.once(function() {\n        offer(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n    }\n    return map;\n  };\n\n  // Trigger one or many events, firing all bound callbacks. Callbacks are\n  // passed the same arguments as `trigger` is, apart from the event name\n  // (unless you're listening on `\"all\"`, which will cause your callback to\n  // receive the true name of the event as the first argument).\n  Events.trigger = function(name) {\n    if (!this._events) return this;\n\n    var length = Math.max(0, arguments.length - 1);\n    var args = Array(length);\n    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];\n\n    eventsApi(triggerApi, this._events, name, void 0, args);\n    return this;\n  };\n\n  // Handles triggering the appropriate event callbacks.\n  var triggerApi = function(objEvents, name, callback, args) {\n    if (objEvents) {\n      var events = objEvents[name];\n      var allEvents = objEvents.all;\n      if (events && allEvents) allEvents = allEvents.slice();\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, [name].concat(args));\n    }\n    return objEvents;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n    }\n  };\n\n  // A listening class that tracks and cleans up memory bindings\n  // when all callbacks have been offed.\n  var Listening = function(listener, obj) {\n    this.id = listener._listenId;\n    this.listener = listener;\n    this.obj = obj;\n    this.interop = true;\n    this.count = 0;\n    this._events = void 0;\n  };\n\n  Listening.prototype.on = Events.on;\n\n  // Offs a callback (or several).\n  // Uses an optimized counter if the listenee uses Backbone.Events.\n  // Otherwise, falls back to manual tracking to support events\n  // library interop.\n  Listening.prototype.off = function(name, callback) {\n    var cleanup;\n    if (this.interop) {\n      this._events = eventsApi(offApi, this._events, name, callback, {\n        context: void 0,\n        listeners: void 0\n      });\n      cleanup = !this._events;\n    } else {\n      this.count--;\n      cleanup = this.count === 0;\n    }\n    if (cleanup) this.cleanup();\n  };\n\n  // Cleans up memory bindings between the listener and the listenee.\n  Listening.prototype.cleanup = function() {\n    delete this.listener._listeningTo[this.obj._listenId];\n    if (!this.interop) delete this.obj._listeners[this.id];\n  };\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Allow the `Backbone` object to serve as a global event bus, for folks who\n  // want global \"pubsub\" in a convenient place.\n  _.extend(Backbone, Events);\n\n  // Backbone.Model\n  // --------------\n\n  // Backbone **Models** are the basic data object in the framework --\n  // frequently representing a row in a table in a database on your server.\n  // A discrete chunk of data and a bunch of useful, related methods for\n  // performing computations and transformations on that data.\n\n  // Create a new model with the specified attributes. A client id (`cid`)\n  // is automatically generated and assigned for you.\n  var Model = Backbone.Model = function(attributes, options) {\n    var attrs = attributes || {};\n    options || (options = {});\n    this.preinitialize.apply(this, arguments);\n    this.cid = _.uniqueId(this.cidPrefix);\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    var defaults = _.result(this, 'defaults');\n\n    // Just _.defaults would work fine, but the additional _.extends\n    // is in there for historical reasons. See #3843.\n    attrs = _.defaults(_.extend({}, defaults, attrs), defaults);\n\n    this.set(attrs, options);\n    this.changed = {};\n    this.initialize.apply(this, arguments);\n  };\n\n  // Attach all inheritable methods to the Model prototype.\n  _.extend(Model.prototype, Events, {\n\n    // A hash of attributes whose current and previous value differ.\n    changed: null,\n\n    // The value returned during the last failed validation.\n    validationError: null,\n\n    // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n    // CouchDB users may want to set this to `\"_id\"`.\n    idAttribute: 'id',\n\n    // The prefix is used to create the client id which is used to identify models locally.\n    // You may want to override this if you're experiencing name clashes with model ids.\n    cidPrefix: 'c',\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the Model.\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Return a copy of the model's `attributes` object.\n    toJSON: function(options) {\n      return _.clone(this.attributes);\n    },\n\n    // Proxy `Backbone.sync` by default -- but override this if you need\n    // custom syncing semantics for *this* particular model.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Get the value of an attribute.\n    get: function(attr) {\n      return this.attributes[attr];\n    },\n\n    // Get the HTML-escaped value of an attribute.\n    escape: function(attr) {\n      return _.escape(this.get(attr));\n    },\n\n    // Returns `true` if the attribute contains a value that is not null\n    // or undefined.\n    has: function(attr) {\n      return this.get(attr) != null;\n    },\n\n    // Special-cased proxy to underscore's `_.matches` method.\n    matches: function(attrs) {\n      return !!_.iteratee(attrs, this)(this.attributes);\n    },\n\n    // Set a hash of model attributes on the object, firing `\"change\"`. This is\n    // the core primitive operation of a model, updating the data and notifying\n    // anyone who needs to know about the change in state. The heart of the beast.\n    set: function(key, val, options) {\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options || (options = {});\n\n      // Run validation.\n      if (!this._validate(attrs, options)) return false;\n\n      // Extract attributes and options.\n      var unset      = options.unset;\n      var silent     = options.silent;\n      var changes    = [];\n      var changing   = this._changing;\n      this._changing = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n\n      var current = this.attributes;\n      var changed = this.changed;\n      var prev    = this._previousAttributes;\n\n      // For each `set` attribute, update or delete the current value.\n      for (var attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          changed[attr] = val;\n        } else {\n          delete changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Update the `id`.\n      if (this.idAttribute in attrs) {\n        var prevId = this.id;\n        this.id = this.get(this.idAttribute);\n        this.trigger('changeId', this, prevId, options);\n      }\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0; i < changes.length; i++) {\n          this.trigger('change:' + changes[i], this, current[changes[i]], options);\n        }\n      }\n\n      // You might be wondering why there's a `while` loop here. Changes can\n      // be recursively nested within `\"change\"` events.\n      if (changing) return this;\n      if (!silent) {\n        while (this._pending) {\n          options = this._pending;\n          this._pending = false;\n          this.trigger('change', this, options);\n        }\n      }\n      this._pending = false;\n      this._changing = false;\n      return this;\n    },\n\n    // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n    // if the attribute doesn't exist.\n    unset: function(attr, options) {\n      return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n    },\n\n    // Clear all attributes on the model, firing `\"change\"`.\n    clear: function(options) {\n      var attrs = {};\n      for (var key in this.attributes) attrs[key] = void 0;\n      return this.set(attrs, _.extend({}, options, {unset: true}));\n    },\n\n    // Determine if the model has changed since the last `\"change\"` event.\n    // If you specify an attribute name, determine if that attribute has changed.\n    hasChanged: function(attr) {\n      if (attr == null) return !_.isEmpty(this.changed);\n      return _.has(this.changed, attr);\n    },\n\n    // Return an object containing all the attributes that have changed, or\n    // false if there are no changed attributes. Useful for determining what\n    // parts of a view need to be updated and/or what attributes need to be\n    // persisted to the server. Unset attributes will be set to undefined.\n    // You can also pass an attributes object to diff against the model,\n    // determining if there *would be* a change.\n    changedAttributes: function(diff) {\n      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      var changed = {};\n      var hasChanged;\n      for (var attr in diff) {\n        var val = diff[attr];\n        if (_.isEqual(old[attr], val)) continue;\n        changed[attr] = val;\n        hasChanged = true;\n      }\n      return hasChanged ? changed : false;\n    },\n\n    // Get the previous value of an attribute, recorded at the time the last\n    // `\"change\"` event was fired.\n    previous: function(attr) {\n      if (attr == null || !this._previousAttributes) return null;\n      return this._previousAttributes[attr];\n    },\n\n    // Get all of the attributes of the model at the time of the previous\n    // `\"change\"` event.\n    previousAttributes: function() {\n      return _.clone(this._previousAttributes);\n    },\n\n    // Fetch the model from the server, merging the response with the model's\n    // local attributes. Any changed attributes will trigger a \"change\" event.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (!model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Set a hash of model attributes, and sync the model to the server.\n    // If the server returns an attributes hash that differs, the model's\n    // state will be `set` again.\n    save: function(key, val, options) {\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (key == null || typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options = _.extend({validate: true, parse: true}, options);\n      var wait = options.wait;\n\n      // If we're not waiting and attributes exist, save acts as\n      // `set(attr).save(null, opts)` with validation. Otherwise, check if\n      // the model will be valid when the attributes, if any, are set.\n      if (attrs && !wait) {\n        if (!this.set(attrs, options)) return false;\n      } else if (!this._validate(attrs, options)) {\n        return false;\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      var model = this;\n      var success = options.success;\n      var attributes = this.attributes;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);\n        if (serverAttrs && !model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      // Set temporary attributes if `{wait: true}` to properly find new ids.\n      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);\n\n      var method = this.isNew() ? 'create' : options.patch ? 'patch' : 'update';\n      if (method === 'patch' && !options.attrs) options.attrs = attrs;\n      var xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      this.attributes = attributes;\n\n      return xhr;\n    },\n\n    // Destroy this model on the server if it was already persisted.\n    // Optimistically removes the model from its collection, if it has one.\n    // If `wait: true` is passed, waits for the server to respond before removal.\n    destroy: function(options) {\n      options = options ? _.clone(options) : {};\n      var model = this;\n      var success = options.success;\n      var wait = options.wait;\n\n      var destroy = function() {\n        model.stopListening();\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (wait) destroy();\n        if (success) success.call(options.context, model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      var xhr = false;\n      if (this.isNew()) {\n        _.defer(options.success);\n      } else {\n        wrapError(this, options);\n        xhr = this.sync('delete', this, options);\n      }\n      if (!wait) destroy();\n      return xhr;\n    },\n\n    // Default URL for the model's representation on the server -- if you're\n    // using Backbone's restful methods, override this to change the endpoint\n    // that will be called.\n    url: function() {\n      var base =\n        _.result(this, 'urlRoot') ||\n        _.result(this.collection, 'url') ||\n        urlError();\n      if (this.isNew()) return base;\n      var id = this.get(this.idAttribute);\n      return base.replace(/[^\\/]$/, '$&/') + encodeURIComponent(id);\n    },\n\n    // **parse** converts a response into the hash of attributes to be `set` on\n    // the model. The default implementation is just to pass the response along.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new model with identical attributes to this one.\n    clone: function() {\n      return new this.constructor(this.attributes);\n    },\n\n    // A model is new if it has never been saved to the server, and lacks an id.\n    isNew: function() {\n      return !this.has(this.idAttribute);\n    },\n\n    // Check if the model is currently in a valid state.\n    isValid: function(options) {\n      return this._validate({}, _.extend({}, options, {validate: true}));\n    },\n\n    // Run validation against the next complete set of model attributes,\n    // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n    _validate: function(attrs, options) {\n      if (!options.validate || !this.validate) return true;\n      attrs = _.extend({}, this.attributes, attrs);\n      var error = this.validationError = this.validate(attrs, options) || null;\n      if (!error) return true;\n      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n      return false;\n    }\n\n  });\n\n  // Backbone.Collection\n  // -------------------\n\n  // If models tend to represent a single row of data, a Backbone Collection is\n  // more analogous to a table full of data ... or a small slice or page of that\n  // table, or a collection of rows that belong together for a particular reason\n  // -- all of the messages in this particular folder, all of the documents\n  // belonging to this particular author, and so on. Collections maintain\n  // indexes of their models, both in order, and for lookup by `id`.\n\n  // Create a new **Collection**, perhaps to contain a specific type of `model`.\n  // If a `comparator` is specified, the Collection will maintain\n  // its models in sort order, as they're added and removed.\n  var Collection = Backbone.Collection = function(models, options) {\n    options || (options = {});\n    this.preinitialize.apply(this, arguments);\n    if (options.model) this.model = options.model;\n    if (options.comparator !== void 0) this.comparator = options.comparator;\n    this._reset();\n    this.initialize.apply(this, arguments);\n    if (models) this.reset(models, _.extend({silent: true}, options));\n  };\n\n  // Default options for `Collection#set`.\n  var setOptions = {add: true, remove: true, merge: true};\n  var addOptions = {add: true, remove: false};\n\n  // Splices `insert` into `array` at index `at`.\n  var splice = function(array, insert, at) {\n    at = Math.min(Math.max(at, 0), array.length);\n    var tail = Array(array.length - at);\n    var length = insert.length;\n    var i;\n    for (i = 0; i < tail.length; i++) tail[i] = array[i + at];\n    for (i = 0; i < length; i++) array[i + at] = insert[i];\n    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];\n  };\n\n  // Define the Collection's inheritable methods.\n  _.extend(Collection.prototype, Events, {\n\n    // The default model for a collection is just a **Backbone.Model**.\n    // This should be overridden in most cases.\n    model: Model,\n\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the Collection.\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // The JSON representation of a Collection is an array of the\n    // models' attributes.\n    toJSON: function(options) {\n      return this.map(function(model) { return model.toJSON(options); });\n    },\n\n    // Proxy `Backbone.sync` by default.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Add a model, or list of models to the set. `models` may be Backbone\n    // Models or raw JavaScript objects to be converted to Models, or any\n    // combination of the two.\n    add: function(models, options) {\n      return this.set(models, _.extend({merge: false}, options, addOptions));\n    },\n\n    // Remove a model, or a list of models from the set.\n    remove: function(models, options) {\n      options = _.extend({}, options);\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n      var removed = this._removeModels(models, options);\n      if (!options.silent && removed.length) {\n        options.changes = {added: [], merged: [], removed: removed};\n        this.trigger('update', this, options);\n      }\n      return singular ? removed[0] : removed;\n    },\n\n    // Update a collection by `set`-ing a new list of models, adding new ones,\n    // removing models that are no longer present, and merging models that\n    // already exist in the collection, as necessary. Similar to **Model#set**,\n    // the core operation for updating the data contained by the collection.\n    set: function(models, options) {\n      if (models == null) return;\n\n      options = _.extend({}, setOptions, options);\n      if (options.parse && !this._isModel(models)) {\n        models = this.parse(models, options) || [];\n      }\n\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n\n      var at = options.at;\n      if (at != null) at = +at;\n      if (at > this.length) at = this.length;\n      if (at < 0) at += this.length + 1;\n\n      var set = [];\n      var toAdd = [];\n      var toMerge = [];\n      var toRemove = [];\n      var modelMap = {};\n\n      var add = options.add;\n      var merge = options.merge;\n      var remove = options.remove;\n\n      var sort = false;\n      var sortable = this.comparator && at == null && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      var model, i;\n      for (i = 0; i < models.length; i++) {\n        model = models[i];\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        var existing = this.get(model);\n        if (existing) {\n          if (merge && model !== existing) {\n            var attrs = this._isModel(model) ? model.attributes : model;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            toMerge.push(existing);\n            if (sortable && !sort) sort = existing.hasChanged(sortAttr);\n          }\n          if (!modelMap[existing.cid]) {\n            modelMap[existing.cid] = true;\n            set.push(existing);\n          }\n          models[i] = existing;\n\n        // If this is a new, valid model, push it to the `toAdd` list.\n        } else if (add) {\n          model = models[i] = this._prepareModel(model, options);\n          if (model) {\n            toAdd.push(model);\n            this._addReference(model, options);\n            modelMap[model.cid] = true;\n            set.push(model);\n          }\n        }\n      }\n\n      // Remove stale models.\n      if (remove) {\n        for (i = 0; i < this.length; i++) {\n          model = this.models[i];\n          if (!modelMap[model.cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this._removeModels(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      var orderChanged = false;\n      var replace = !sortable && add && remove;\n      if (set.length && replace) {\n        orderChanged = this.length !== set.length || _.some(this.models, function(m, index) {\n          return m !== set[index];\n        });\n        this.models.length = 0;\n        splice(this.models, set, 0);\n        this.length = this.models.length;\n      } else if (toAdd.length) {\n        if (sortable) sort = true;\n        splice(this.models, toAdd, at == null ? this.length : at);\n        this.length = this.models.length;\n      }\n\n      // Silently sort the collection if appropriate.\n      if (sort) this.sort({silent: true});\n\n      // Unless silenced, it's time to fire all appropriate add/sort/update events.\n      if (!options.silent) {\n        for (i = 0; i < toAdd.length; i++) {\n          if (at != null) options.index = at + i;\n          model = toAdd[i];\n          model.trigger('add', model, this, options);\n        }\n        if (sort || orderChanged) this.trigger('sort', this, options);\n        if (toAdd.length || toRemove.length || toMerge.length) {\n          options.changes = {\n            added: toAdd,\n            removed: toRemove,\n            merged: toMerge\n          };\n          this.trigger('update', this, options);\n        }\n      }\n\n      // Return the added (or merged) model (or models).\n      return singular ? models[0] : models;\n    },\n\n    // When you have more items than you want to add or remove individually,\n    // you can reset the entire set with a new list of models, without firing\n    // any granular `add` or `remove` events. Fires `reset` when finished.\n    // Useful for bulk operations and optimizations.\n    reset: function(models, options) {\n      options = options ? _.clone(options) : {};\n      for (var i = 0; i < this.models.length; i++) {\n        this._removeReference(this.models[i], options);\n      }\n      options.previousModels = this.models;\n      this._reset();\n      models = this.add(models, _.extend({silent: true}, options));\n      if (!options.silent) this.trigger('reset', this, options);\n      return models;\n    },\n\n    // Add a model to the end of the collection.\n    push: function(model, options) {\n      return this.add(model, _.extend({at: this.length}, options));\n    },\n\n    // Remove a model from the end of the collection.\n    pop: function(options) {\n      var model = this.at(this.length - 1);\n      return this.remove(model, options);\n    },\n\n    // Add a model to the beginning of the collection.\n    unshift: function(model, options) {\n      return this.add(model, _.extend({at: 0}, options));\n    },\n\n    // Remove a model from the beginning of the collection.\n    shift: function(options) {\n      var model = this.at(0);\n      return this.remove(model, options);\n    },\n\n    // Slice out a sub-array of models from the collection.\n    slice: function() {\n      return slice.apply(this.models, arguments);\n    },\n\n    // Get a model from the set by id, cid, model object with id or cid\n    // properties, or an attributes object that is transformed through modelId.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] ||\n        this._byId[this.modelId(this._isModel(obj) ? obj.attributes : obj, obj.idAttribute)] ||\n        obj.cid && this._byId[obj.cid];\n    },\n\n    // Returns `true` if the model is in the collection.\n    has: function(obj) {\n      return this.get(obj) != null;\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\n      if (index < 0) index += this.length;\n      return this.models[index];\n    },\n\n    // Return models with matching attributes. Useful for simple cases of\n    // `filter`.\n    where: function(attrs, first) {\n      return this[first ? 'find' : 'filter'](attrs);\n    },\n\n    // Return the first model with matching attributes. Useful for simple cases\n    // of `find`.\n    findWhere: function(attrs) {\n      return this.where(attrs, true);\n    },\n\n    // Force the collection to re-sort itself. You don't need to call this under\n    // normal circumstances, as the set will maintain sort order as each item\n    // is added.\n    sort: function(options) {\n      var comparator = this.comparator;\n      if (!comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      var length = comparator.length;\n      if (_.isFunction(comparator)) comparator = comparator.bind(this);\n\n      // Run sort based on type of `comparator`.\n      if (length === 1 || _.isString(comparator)) {\n        this.models = this.sortBy(comparator);\n      } else {\n        this.models.sort(comparator);\n      }\n      if (!options.silent) this.trigger('sort', this, options);\n      return this;\n    },\n\n    // Pluck an attribute from each model in the collection.\n    pluck: function(attr) {\n      return this.map(attr + '');\n    },\n\n    // Fetch the default set of models for this collection, resetting the\n    // collection when they arrive. If `reset: true` is passed, the response\n    // data will be passed through the `reset` method instead of `set`.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var success = options.success;\n      var collection = this;\n      options.success = function(resp) {\n        var method = options.reset ? 'reset' : 'set';\n        collection[method](resp, options);\n        if (success) success.call(options.context, collection, resp, options);\n        collection.trigger('sync', collection, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Create a new instance of a model in this collection. Add the model to the\n    // collection immediately, unless `wait: true` is passed, in which case we\n    // wait for the server to agree.\n    create: function(model, options) {\n      options = options ? _.clone(options) : {};\n      var wait = options.wait;\n      model = this._prepareModel(model, options);\n      if (!model) return false;\n      if (!wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(m, resp, callbackOpts) {\n        if (wait) {\n          m.off('error', collection._forwardPristineError, collection);\n          collection.add(m, callbackOpts);\n        }\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\n      };\n      // In case of wait:true, our collection is not listening to any\n      // of the model's events yet, so it will not forward the error\n      // event. In this special case, we need to listen for it\n      // separately and handle the event just once.\n      // (The reason we don't need to do this for the sync event is\n      // in the success handler above: we add the model first, which\n      // causes the collection to listen, and then invoke the callback\n      // that triggers the event.)\n      if (wait) {\n        model.once('error', this._forwardPristineError, this);\n      }\n      model.save(null, options);\n      return model;\n    },\n\n    // **parse** converts a response into a list of models to be added to the\n    // collection. The default implementation is just to pass it through.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new collection with an identical list of models as this one.\n    clone: function() {\n      return new this.constructor(this.models, {\n        model: this.model,\n        comparator: this.comparator\n      });\n    },\n\n    // Define how to uniquely identify models in the collection.\n    modelId: function(attrs, idAttribute) {\n      return attrs[idAttribute || this.model.prototype.idAttribute || 'id'];\n    },\n\n    // Get an iterator of all models in this collection.\n    values: function() {\n      return new CollectionIterator(this, ITERATOR_VALUES);\n    },\n\n    // Get an iterator of all model IDs in this collection.\n    keys: function() {\n      return new CollectionIterator(this, ITERATOR_KEYS);\n    },\n\n    // Get an iterator of all [ID, model] tuples in this collection.\n    entries: function() {\n      return new CollectionIterator(this, ITERATOR_KEYSVALUES);\n    },\n\n    // Private method to reset all internal state. Called when the collection\n    // is first initialized or reset.\n    _reset: function() {\n      this.length = 0;\n      this.models = [];\n      this._byId  = {};\n    },\n\n    // Prepare a hash of attributes (or other model) to be added to this\n    // collection.\n    _prepareModel: function(attrs, options) {\n      if (this._isModel(attrs)) {\n        if (!attrs.collection) attrs.collection = this;\n        return attrs;\n      }\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n\n      var model;\n      if (this.model.prototype) {\n        model = new this.model(attrs, options);\n      } else {\n        // ES class methods didn't have prototype\n        model = this.model(attrs, options);\n      }\n\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\n    },\n\n    // Internal method called by both remove and set.\n    _removeModels: function(models, options) {\n      var removed = [];\n      for (var i = 0; i < models.length; i++) {\n        var model = this.get(models[i]);\n        if (!model) continue;\n\n        var index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n\n        // Remove references before triggering 'remove' event to prevent an\n        // infinite loop. #3693\n        delete this._byId[model.cid];\n        var id = this.modelId(model.attributes, model.idAttribute);\n        if (id != null) delete this._byId[id];\n\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n\n        removed.push(model);\n        this._removeReference(model, options);\n      }\n      if (models.length > 0 && !options.silent) delete options.index;\n      return removed;\n    },\n\n    // Method for checking whether an object should be considered a model for\n    // the purposes of adding to the collection.\n    _isModel: function(model) {\n      return model instanceof Model;\n    },\n\n    // Internal method to create a model's ties to a collection.\n    _addReference: function(model, options) {\n      this._byId[model.cid] = model;\n      var id = this.modelId(model.attributes, model.idAttribute);\n      if (id != null) this._byId[id] = model;\n      model.on('all', this._onModelEvent, this);\n    },\n\n    // Internal method to sever a model's ties to a collection.\n    _removeReference: function(model, options) {\n      delete this._byId[model.cid];\n      var id = this.modelId(model.attributes, model.idAttribute);\n      if (id != null) delete this._byId[id];\n      if (this === model.collection) delete model.collection;\n      model.off('all', this._onModelEvent, this);\n    },\n\n    // Internal method called every time a model in the set fires an event.\n    // Sets need to update their indexes when models change ids. All other\n    // events simply proxy through. \"add\" and \"remove\" events that originate\n    // in other collections are ignored.\n    _onModelEvent: function(event, model, collection, options) {\n      if (model) {\n        if ((event === 'add' || event === 'remove') && collection !== this) return;\n        if (event === 'destroy') this.remove(model, options);\n        if (event === 'changeId') {\n          var prevId = this.modelId(model.previousAttributes(), model.idAttribute);\n          var id = this.modelId(model.attributes, model.idAttribute);\n          if (prevId != null) delete this._byId[prevId];\n          if (id != null) this._byId[id] = model;\n        }\n      }\n      this.trigger.apply(this, arguments);\n    },\n\n    // Internal callback method used in `create`. It serves as a\n    // stand-in for the `_onModelEvent` method, which is not yet bound\n    // during the `wait` period of the `create` call. We still want to\n    // forward any `'error'` event at the end of the `wait` period,\n    // hence a customized callback.\n    _forwardPristineError: function(model, collection, options) {\n      // Prevent double forward if the model was already in the\n      // collection before the call to `create`.\n      if (this.has(model)) return;\n      this._onModelEvent('error', model, collection, options);\n    }\n  });\n\n  // Defining an @@iterator method implements JavaScript's Iterable protocol.\n  // In modern ES2015 browsers, this value is found at Symbol.iterator.\n  /* global Symbol */\n  var $$iterator = typeof Symbol === 'function' && Symbol.iterator;\n  if ($$iterator) {\n    Collection.prototype[$$iterator] = Collection.prototype.values;\n  }\n\n  // CollectionIterator\n  // ------------------\n\n  // A CollectionIterator implements JavaScript's Iterator protocol, allowing the\n  // use of `for of` loops in modern browsers and interoperation between\n  // Backbone.Collection and other JavaScript functions and third-party libraries\n  // which can operate on Iterables.\n  var CollectionIterator = function(collection, kind) {\n    this._collection = collection;\n    this._kind = kind;\n    this._index = 0;\n  };\n\n  // This \"enum\" defines the three possible kinds of values which can be emitted\n  // by a CollectionIterator that correspond to the values(), keys() and entries()\n  // methods on Collection, respectively.\n  var ITERATOR_VALUES = 1;\n  var ITERATOR_KEYS = 2;\n  var ITERATOR_KEYSVALUES = 3;\n\n  // All Iterators should themselves be Iterable.\n  if ($$iterator) {\n    CollectionIterator.prototype[$$iterator] = function() {\n      return this;\n    };\n  }\n\n  CollectionIterator.prototype.next = function() {\n    if (this._collection) {\n\n      // Only continue iterating if the iterated collection is long enough.\n      if (this._index < this._collection.length) {\n        var model = this._collection.at(this._index);\n        this._index++;\n\n        // Construct a value depending on what kind of values should be iterated.\n        var value;\n        if (this._kind === ITERATOR_VALUES) {\n          value = model;\n        } else {\n          var id = this._collection.modelId(model.attributes, model.idAttribute);\n          if (this._kind === ITERATOR_KEYS) {\n            value = id;\n          } else { // ITERATOR_KEYSVALUES\n            value = [id, model];\n          }\n        }\n        return {value: value, done: false};\n      }\n\n      // Once exhausted, remove the reference to the collection so future\n      // calls to the next method always return done.\n      this._collection = void 0;\n    }\n\n    return {value: void 0, done: true};\n  };\n\n  // Backbone.View\n  // -------------\n\n  // Backbone Views are almost more convention than they are actual code. A View\n  // is simply a JavaScript object that represents a logical chunk of UI in the\n  // DOM. This might be a single item, an entire list, a sidebar or panel, or\n  // even the surrounding frame which wraps your whole app. Defining a chunk of\n  // UI as a **View** allows you to define your DOM events declaratively, without\n  // having to worry about render order ... and makes it easy for the view to\n  // react to specific changes in the state of your models.\n\n  // Creating a Backbone.View creates its initial element outside of the DOM,\n  // if an existing element is not provided...\n  var View = Backbone.View = function(options) {\n    this.cid = _.uniqueId('view');\n    this.preinitialize.apply(this, arguments);\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be set as properties.\n  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n  // Set up all inheritable **Backbone.View** properties and methods.\n  _.extend(View.prototype, Events, {\n\n    // The default `tagName` of a View's element is `\"div\"`.\n    tagName: 'div',\n\n    // jQuery delegate for element lookup, scoped to DOM elements within the\n    // current view. This should be preferred to global lookups where possible.\n    $: function(selector) {\n      return this.$el.find(selector);\n    },\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the View\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // **render** is the core function that your view should override, in order\n    // to populate its element (`this.el`), with the appropriate HTML. The\n    // convention is for **render** to always return `this`.\n    render: function() {\n      return this;\n    },\n\n    // Remove this view by taking the element out of the DOM, and removing any\n    // applicable Backbone.Events listeners.\n    remove: function() {\n      this._removeElement();\n      this.stopListening();\n      return this;\n    },\n\n    // Remove this view's element from the document and all event listeners\n    // attached to it. Exposed for subclasses using an alternative DOM\n    // manipulation API.\n    _removeElement: function() {\n      this.$el.remove();\n    },\n\n    // Change the view's element (`this.el` property) and re-delegate the\n    // view's events on the new element.\n    setElement: function(element) {\n      this.undelegateEvents();\n      this._setElement(element);\n      this.delegateEvents();\n      return this;\n    },\n\n    // Creates the `this.el` and `this.$el` references for this view using the\n    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery\n    // context or an element. Subclasses can override this to utilize an\n    // alternative DOM manipulation API and are only required to set the\n    // `this.el` property.\n    _setElement: function(el) {\n      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);\n      this.el = this.$el[0];\n    },\n\n    // Set callbacks, where `this.events` is a hash of\n    //\n    // *{\"event selector\": \"callback\"}*\n    //\n    //     {\n    //       'mousedown .title':  'edit',\n    //       'click .button':     'save',\n    //       'click .open':       function(e) { ... }\n    //     }\n    //\n    // pairs. Callbacks will be bound to the view, with `this` set properly.\n    // Uses event delegation for efficiency.\n    // Omitting the selector binds the event to `this.el`.\n    delegateEvents: function(events) {\n      events || (events = _.result(this, 'events'));\n      if (!events) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[method];\n        if (!method) continue;\n        var match = key.match(delegateEventSplitter);\n        this.delegate(match[1], match[2], method.bind(this));\n      }\n      return this;\n    },\n\n    // Add a single event listener to the view's element (or a child element\n    // using `selector`). This only works for delegate-able events: not `focus`,\n    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.\n    delegate: function(eventName, selector, listener) {\n      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view by `delegateEvents`.\n    // You usually don't need to use this, but may wish to if you have multiple\n    // Backbone views attached to the same DOM element.\n    undelegateEvents: function() {\n      if (this.$el) this.$el.off('.delegateEvents' + this.cid);\n      return this;\n    },\n\n    // A finer-grained `undelegateEvents` for removing a single delegated event.\n    // `selector` and `listener` are both optional.\n    undelegate: function(eventName, selector, listener) {\n      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Produces a DOM element to be assigned to your view. Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _createElement: function(tagName) {\n      return document.createElement(tagName);\n    },\n\n    // Ensure that the View has a DOM element to render into.\n    // If `this.el` is a string, pass it through `$()`, take the first\n    // matching element, and re-assign it to `el`. Otherwise, create\n    // an element from the `id`, `className` and `tagName` properties.\n    _ensureElement: function() {\n      if (!this.el) {\n        var attrs = _.extend({}, _.result(this, 'attributes'));\n        if (this.id) attrs.id = _.result(this, 'id');\n        if (this.className) attrs['class'] = _.result(this, 'className');\n        this.setElement(this._createElement(_.result(this, 'tagName')));\n        this._setAttributes(attrs);\n      } else {\n        this.setElement(_.result(this, 'el'));\n      }\n    },\n\n    // Set attributes from a hash on this view's element.  Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _setAttributes: function(attributes) {\n      this.$el.attr(attributes);\n    }\n\n  });\n\n  // Proxy Backbone class methods to Underscore functions, wrapping the model's\n  // `attributes` object or collection's `models` array behind the scenes.\n  //\n  // collection.filter(function(model) { return model.get('age') > 10 });\n  // collection.each(this.addView);\n  //\n  // `Function#apply` can be slow so we use the method's arg count, if we know it.\n  var addMethod = function(base, length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return base[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return base[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return base[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return base[method](this[attribute], cb(iteratee, this), defaultVal, context);\n      };\n      default: return function() {\n        var args = slice.call(arguments);\n        args.unshift(this[attribute]);\n        return base[method].apply(base, args);\n      };\n    }\n  };\n\n  var addUnderscoreMethods = function(Class, base, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (base[method]) Class.prototype[method] = addMethod(base, length, method, attribute);\n    });\n  };\n\n  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.\n  var cb = function(iteratee, instance) {\n    if (_.isFunction(iteratee)) return iteratee;\n    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);\n    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };\n    return iteratee;\n  };\n  var modelMatcher = function(attrs) {\n    var matcher = _.matches(attrs);\n    return function(model) {\n      return matcher(model.attributes);\n    };\n  };\n\n  // Underscore methods that we want to implement on the Collection.\n  // 90% of the core usefulness of Backbone Collections is actually implemented\n  // right here:\n  var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,\n    foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,\n    select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,\n    contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,\n    head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,\n    without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,\n    isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,\n    sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};\n\n\n  // Underscore methods that we want to implement on the Model, mapped to the\n  // number of arguments they take.\n  var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,\n    omit: 0, chain: 1, isEmpty: 1};\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n\n  _.each([\n    [Collection, collectionMethods, 'models'],\n    [Model, modelMethods, 'attributes']\n  ], function(config) {\n    var Base = config[0],\n        methods = config[1],\n        attribute = config[2];\n\n    Base.mixin = function(obj) {\n      var mappings = _.reduce(_.functions(obj), function(memo, name) {\n        memo[name] = 0;\n        return memo;\n      }, {});\n      addUnderscoreMethods(Base, obj, mappings, attribute);\n    };\n\n    addUnderscoreMethods(Base, _, methods, attribute);\n  });\n\n  // Backbone.sync\n  // -------------\n\n  // Override this function to change the manner in which Backbone persists\n  // models to the server. You will be passed the type of request, and the\n  // model in question. By default, makes a RESTful Ajax request\n  // to the model's `url()`. Some possible customizations could be:\n  //\n  // * Use `setTimeout` to batch rapid-fire updates into a single request.\n  // * Send up the models as XML instead of JSON.\n  // * Persist models via WebSockets instead of Ajax.\n  //\n  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n  // as `POST`, with a `_method` parameter containing the true HTTP method,\n  // as well as all requests with the body as `application/x-www-form-urlencoded`\n  // instead of `application/json` with the model in a param named `model`.\n  // Useful when interfacing with server-side languages like **PHP** that make\n  // it difficult to read the body of `PUT` requests.\n  Backbone.sync = function(method, model, options) {\n    var type = methodMap[method];\n\n    // Default options, unless specified.\n    _.defaults(options || (options = {}), {\n      emulateHTTP: Backbone.emulateHTTP,\n      emulateJSON: Backbone.emulateJSON\n    });\n\n    // Default JSON-request options.\n    var params = {type: type, dataType: 'json'};\n\n    // Ensure that we have a URL.\n    if (!options.url) {\n      params.url = _.result(model, 'url') || urlError();\n    }\n\n    // Ensure that we have the appropriate request data.\n    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n      params.contentType = 'application/json';\n      params.data = JSON.stringify(options.attrs || model.toJSON(options));\n    }\n\n    // For older servers, emulate JSON by encoding the request into an HTML-form.\n    if (options.emulateJSON) {\n      params.contentType = 'application/x-www-form-urlencoded';\n      params.data = params.data ? {model: params.data} : {};\n    }\n\n    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n    // And an `X-HTTP-Method-Override` header.\n    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n      params.type = 'POST';\n      if (options.emulateJSON) params.data._method = type;\n      var beforeSend = options.beforeSend;\n      options.beforeSend = function(xhr) {\n        xhr.setRequestHeader('X-HTTP-Method-Override', type);\n        if (beforeSend) return beforeSend.apply(this, arguments);\n      };\n    }\n\n    // Don't process data on a non-GET request.\n    if (params.type !== 'GET' && !options.emulateJSON) {\n      params.processData = false;\n    }\n\n    // Pass along `textStatus` and `errorThrown` from jQuery.\n    var error = options.error;\n    options.error = function(xhr, textStatus, errorThrown) {\n      options.textStatus = textStatus;\n      options.errorThrown = errorThrown;\n      if (error) error.call(options.context, xhr, textStatus, errorThrown);\n    };\n\n    // Make the request, allowing the user to override any Ajax options.\n    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n    model.trigger('request', model, xhr, options);\n    return xhr;\n  };\n\n  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n  var methodMap = {\n    'create': 'POST',\n    'update': 'PUT',\n    'patch': 'PATCH',\n    'delete': 'DELETE',\n    'read': 'GET'\n  };\n\n  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n  // Override this if you'd like to use a different library.\n  Backbone.ajax = function() {\n    return Backbone.$.ajax.apply(Backbone.$, arguments);\n  };\n\n  // Backbone.Router\n  // ---------------\n\n  // Routers map faux-URLs to actions, and fire events when routes are\n  // matched. Creating a new one sets its `routes` hash, if not set statically.\n  var Router = Backbone.Router = function(options) {\n    options || (options = {});\n    this.preinitialize.apply(this, arguments);\n    if (options.routes) this.routes = options.routes;\n    this._bindRoutes();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regular expressions for matching named param parts and splatted\n  // parts of route strings.\n  var optionalParam = /\\((.*?)\\)/g;\n  var namedParam    = /(\\(\\?)?:\\w+/g;\n  var splatParam    = /\\*\\w+/g;\n  var escapeRegExp  = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n  // Set up all inheritable **Backbone.Router** properties and methods.\n  _.extend(Router.prototype, Events, {\n\n    // preinitialize is an empty function by default. You can override it with a function\n    // or object.  preinitialize will run before any instantiation logic is run in the Router.\n    preinitialize: function(){},\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Manually bind a single named route to a callback. For example:\n    //\n    //     this.route('search/:query/p:num', 'search', function(query, num) {\n    //       ...\n    //     });\n    //\n    route: function(route, name, callback) {\n      if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n      if (_.isFunction(name)) {\n        callback = name;\n        name = '';\n      }\n      if (!callback) callback = this[name];\n      var router = this;\n      Backbone.history.route(route, function(fragment) {\n        var args = router._extractParameters(route, fragment);\n        if (router.execute(callback, args, name) !== false) {\n          router.trigger.apply(router, ['route:' + name].concat(args));\n          router.trigger('route', name, args);\n          Backbone.history.trigger('route', router, name, args);\n        }\n      });\n      return this;\n    },\n\n    // Execute a route handler with the provided parameters.  This is an\n    // excellent place to do pre-route setup or post-route cleanup.\n    execute: function(callback, args, name) {\n      if (callback) callback.apply(this, args);\n    },\n\n    // Simple proxy to `Backbone.history` to save a fragment into the history.\n    navigate: function(fragment, options) {\n      Backbone.history.navigate(fragment, options);\n      return this;\n    },\n\n    // Bind all defined routes to `Backbone.history`. We have to reverse the\n    // order of the routes here to support behavior where the most general\n    // routes can be defined at the bottom of the route map.\n    _bindRoutes: function() {\n      if (!this.routes) return;\n      this.routes = _.result(this, 'routes');\n      var route, routes = _.keys(this.routes);\n      while ((route = routes.pop()) != null) {\n        this.route(route, this.routes[route]);\n      }\n    },\n\n    // Convert a route string into a regular expression, suitable for matching\n    // against the current location hash.\n    _routeToRegExp: function(route) {\n      route = route.replace(escapeRegExp, '\\\\$&')\n      .replace(optionalParam, '(?:$1)?')\n      .replace(namedParam, function(match, optional) {\n        return optional ? match : '([^/?]+)';\n      })\n      .replace(splatParam, '([^?]*?)');\n      return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n    },\n\n    // Given a route, and a URL fragment that it matches, return the array of\n    // extracted decoded parameters. Empty or unmatched parameters will be\n    // treated as `null` to normalize cross-browser behavior.\n    _extractParameters: function(route, fragment) {\n      var params = route.exec(fragment).slice(1);\n      return _.map(params, function(param, i) {\n        // Don't decode the search params.\n        if (i === params.length - 1) return param || null;\n        return param ? decodeURIComponent(param) : null;\n      });\n    }\n\n  });\n\n  // Backbone.History\n  // ----------------\n\n  // Handles cross-browser history management, based on either\n  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n  // and URL fragments. If the browser supports neither (old IE, natch),\n  // falls back to polling.\n  var History = Backbone.History = function() {\n    this.handlers = [];\n    this.checkUrl = this.checkUrl.bind(this);\n\n    // Ensure that `History` can be used outside of the browser.\n    if (typeof window !== 'undefined') {\n      this.location = window.location;\n      this.history = window.history;\n    }\n  };\n\n  // Cached regex for stripping a leading hash/slash and trailing space.\n  var routeStripper = /^[#\\/]|\\s+$/g;\n\n  // Cached regex for stripping leading and trailing slashes.\n  var rootStripper = /^\\/+|\\/+$/g;\n\n  // Cached regex for stripping urls of hash.\n  var pathStripper = /#.*$/;\n\n  // Has the history handling already been started?\n  History.started = false;\n\n  // Set up all inheritable **Backbone.History** properties and methods.\n  _.extend(History.prototype, Events, {\n\n    // The default interval to poll for hash changes, if necessary, is\n    // twenty times a second.\n    interval: 50,\n\n    // Are we at the app root?\n    atRoot: function() {\n      var path = this.location.pathname.replace(/[^\\/]$/, '$&/');\n      return path === this.root && !this.getSearch();\n    },\n\n    // Does the pathname match the root?\n    matchRoot: function() {\n      var path = this.decodeFragment(this.location.pathname);\n      var rootPath = path.slice(0, this.root.length - 1) + '/';\n      return rootPath === this.root;\n    },\n\n    // Unicode characters in `location.pathname` are percent encoded so they're\n    // decoded for comparison. `%25` should not be decoded since it may be part\n    // of an encoded parameter.\n    decodeFragment: function(fragment) {\n      return decodeURI(fragment.replace(/%25/g, '%2525'));\n    },\n\n    // In IE6, the hash fragment and search params are incorrect if the\n    // fragment contains `?`.\n    getSearch: function() {\n      var match = this.location.href.replace(/#.*/, '').match(/\\?.+/);\n      return match ? match[0] : '';\n    },\n\n    // Gets the true hash value. Cannot use location.hash directly due to bug\n    // in Firefox where location.hash will always be decoded.\n    getHash: function(window) {\n      var match = (window || this).location.href.match(/#(.*)$/);\n      return match ? match[1] : '';\n    },\n\n    // Get the pathname and search params, without the root.\n    getPath: function() {\n      var path = this.decodeFragment(\n        this.location.pathname + this.getSearch()\n      ).slice(this.root.length - 1);\n      return path.charAt(0) === '/' ? path.slice(1) : path;\n    },\n\n    // Get the cross-browser normalized URL fragment from the path or hash.\n    getFragment: function(fragment) {\n      if (fragment == null) {\n        if (this._usePushState || !this._wantsHashChange) {\n          fragment = this.getPath();\n        } else {\n          fragment = this.getHash();\n        }\n      }\n      return fragment.replace(routeStripper, '');\n    },\n\n    // Start the hash change handling, returning `true` if the current URL matches\n    // an existing route, and `false` otherwise.\n    start: function(options) {\n      if (History.started) throw new Error('Backbone.history has already been started');\n      History.started = true;\n\n      // Figure out the initial configuration. Do we need an iframe?\n      // Is pushState desired ... is it available?\n      this.options          = _.extend({root: '/'}, this.options, options);\n      this.root             = this.options.root;\n      this._trailingSlash   = this.options.trailingSlash;\n      this._wantsHashChange = this.options.hashChange !== false;\n      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);\n      this._useHashChange   = this._wantsHashChange && this._hasHashChange;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.history && this.history.pushState);\n      this._usePushState    = this._wantsPushState && this._hasPushState;\n      this.fragment         = this.getFragment();\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      // Transition from hashChange to pushState or vice versa if both are\n      // requested.\n      if (this._wantsHashChange && this._wantsPushState) {\n\n        // If we've started off with a route from a `pushState`-enabled\n        // browser, but we're currently in a browser that doesn't support it...\n        if (!this._hasPushState && !this.atRoot()) {\n          var rootPath = this.root.slice(0, -1) || '/';\n          this.location.replace(rootPath + '#' + this.getPath());\n          // Return immediately as browser will do redirect to new url\n          return true;\n\n        // Or if we've started out with a hash-based route, but we're currently\n        // in a browser where it could be `pushState`-based instead...\n        } else if (this._hasPushState && this.atRoot()) {\n          this.navigate(this.getHash(), {replace: true});\n        }\n\n      }\n\n      // Proxy an iframe to handle location events if the browser doesn't\n      // support the `hashchange` event, HTML5 history, or the user wants\n      // `hashChange` but not `pushState`.\n      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {\n        this.iframe = document.createElement('iframe');\n        this.iframe.src = 'javascript:0';\n        this.iframe.style.display = 'none';\n        this.iframe.tabIndex = -1;\n        var body = document.body;\n        // Using `appendChild` will throw on IE < 9 if the document is not ready.\n        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;\n        iWindow.document.open();\n        iWindow.document.close();\n        iWindow.location.hash = '#' + this.fragment;\n      }\n\n      // Add a cross-platform `addEventListener` shim for older browsers.\n      var addEventListener = window.addEventListener || function(eventName, listener) {\n        return attachEvent('on' + eventName, listener);\n      };\n\n      // Depending on whether we're using pushState or hashes, and whether\n      // 'onhashchange' is supported, determine how we check the URL state.\n      if (this._usePushState) {\n        addEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        addEventListener('hashchange', this.checkUrl, false);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      if (!this.options.silent) return this.loadUrl();\n    },\n\n    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,\n    // but possibly useful for unit testing Routers.\n    stop: function() {\n      // Add a cross-platform `removeEventListener` shim for older browsers.\n      var removeEventListener = window.removeEventListener || function(eventName, listener) {\n        return detachEvent('on' + eventName, listener);\n      };\n\n      // Remove window listeners.\n      if (this._usePushState) {\n        removeEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        removeEventListener('hashchange', this.checkUrl, false);\n      }\n\n      // Clean up the iframe if necessary.\n      if (this.iframe) {\n        document.body.removeChild(this.iframe);\n        this.iframe = null;\n      }\n\n      // Some environments will throw when clearing an undefined interval.\n      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);\n      History.started = false;\n    },\n\n    // Add a route to be tested when the fragment changes. Routes added later\n    // may override previous routes.\n    route: function(route, callback) {\n      this.handlers.unshift({route: route, callback: callback});\n    },\n\n    // Checks the current URL to see if it has changed, and if it has,\n    // calls `loadUrl`, normalizing across the hidden iframe.\n    checkUrl: function(e) {\n      var current = this.getFragment();\n\n      // If the user pressed the back button, the iframe's hash will have\n      // changed and we should use that for comparison.\n      if (current === this.fragment && this.iframe) {\n        current = this.getHash(this.iframe.contentWindow);\n      }\n\n      if (current === this.fragment) {\n        if (!this.matchRoot()) return this.notfound();\n        return false;\n      }\n      if (this.iframe) this.navigate(current);\n      this.loadUrl();\n    },\n\n    // Attempt to load the current URL fragment. If a route succeeds with a\n    // match, returns `true`. If no defined routes matches the fragment,\n    // returns `false`.\n    loadUrl: function(fragment) {\n      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return this.notfound();\n      fragment = this.fragment = this.getFragment(fragment);\n      return _.some(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      }) || this.notfound();\n    },\n\n    // When no route could be matched, this method is called internally to\n    // trigger the `'notfound'` event. It returns `false` so that it can be used\n    // in tail position.\n    notfound: function() {\n      this.trigger('notfound');\n      return false;\n    },\n\n    // Save a fragment into the hash history, or replace the URL state if the\n    // 'replace' option is passed. You are responsible for properly URL-encoding\n    // the fragment in advance.\n    //\n    // The options object can contain `trigger: true` if you wish to have the\n    // route callback be fired (not usually desirable), or `replace: true`, if\n    // you wish to modify the current URL without adding an entry to the history.\n    navigate: function(fragment, options) {\n      if (!History.started) return false;\n      if (!options || options === true) options = {trigger: !!options};\n\n      // Normalize the fragment.\n      fragment = this.getFragment(fragment || '');\n\n      // Strip trailing slash on the root unless _trailingSlash is true\n      var rootPath = this.root;\n      if (!this._trailingSlash && (fragment === '' || fragment.charAt(0) === '?')) {\n        rootPath = rootPath.slice(0, -1) || '/';\n      }\n      var url = rootPath + fragment;\n\n      // Strip the fragment of the query and hash for matching.\n      fragment = fragment.replace(pathStripper, '');\n\n      // Decode for matching.\n      var decodedFragment = this.decodeFragment(fragment);\n\n      if (this.fragment === decodedFragment) return;\n      this.fragment = decodedFragment;\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._usePushState) {\n        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);\n\n      // If hash changes haven't been explicitly disabled, update the hash\n      // fragment to store history.\n      } else if (this._wantsHashChange) {\n        this._updateHash(this.location, fragment, options.replace);\n        if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {\n          var iWindow = this.iframe.contentWindow;\n\n          // Opening and closing the iframe tricks IE7 and earlier to push a\n          // history entry on hash-tag change.  When replace is true, we don't\n          // want this.\n          if (!options.replace) {\n            iWindow.document.open();\n            iWindow.document.close();\n          }\n\n          this._updateHash(iWindow.location, fragment, options.replace);\n        }\n\n      // If you've told us that you explicitly don't want fallback hashchange-\n      // based history, then `navigate` becomes a page refresh.\n      } else {\n        return this.location.assign(url);\n      }\n      if (options.trigger) return this.loadUrl(fragment);\n    },\n\n    // Update the hash location, either replacing the current entry, or adding\n    // a new one to the browser history.\n    _updateHash: function(location, fragment, replace) {\n      if (replace) {\n        var href = location.href.replace(/(javascript:|#).*$/, '');\n        location.replace(href + '#' + fragment);\n      } else {\n        // Some browsers require that `hash` contains a leading #.\n        location.hash = '#' + fragment;\n      }\n    }\n\n  });\n\n  // Create the default Backbone.history.\n  Backbone.history = new History;\n\n  // Helpers\n  // -------\n\n  // Helper function to correctly set up the prototype chain for subclasses.\n  // Similar to `goog.inherits`, but uses a hash of prototype properties and\n  // class properties to be extended.\n  var extend = function(protoProps, staticProps) {\n    var parent = this;\n    var child;\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent constructor.\n    if (protoProps && _.has(protoProps, 'constructor')) {\n      child = protoProps.constructor;\n    } else {\n      child = function(){ return parent.apply(this, arguments); };\n    }\n\n    // Add static properties to the constructor function, if supplied.\n    _.extend(child, parent, staticProps);\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function and add the prototype properties.\n    child.prototype = _.create(parent.prototype, protoProps);\n    child.prototype.constructor = child;\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    return child;\n  };\n\n  // Set up inheritance for the model, collection, router, view and history.\n  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;\n\n  // Throw an error when a URL is needed, and none is supplied.\n  var urlError = function() {\n    throw new Error('A \"url\" property or function must be specified');\n  };\n\n  // Wrap an optional error callback with a fallback error event.\n  var wrapError = function(model, options) {\n    var error = options.error;\n    options.error = function(resp) {\n      if (error) error.call(options.context, model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  // Provide useful information when things go wrong. This method is not meant\n  // to be used directly; it merely provides the necessary introspection for the\n  // external `debugInfo` function.\n  Backbone._debug = function() {\n    return {root: root, _: _};\n  };\n\n  return Backbone;\n});\n","// Current version.\nexport var VERSION = '1.13.6';\n\n// Establish the root object, `window` (`self`) in the browser, `global`\n// on the server, or `this` in some virtual machines. We use `self`\n// instead of `window` for `WebWorker` support.\nexport var root = (typeof self == 'object' && self.self === self && self) ||\n          (typeof global == 'object' && global.global === global && global) ||\n          Function('return this')() ||\n          {};\n\n// Save bytes in the minified (but not gzipped) version:\nexport var ArrayProto = Array.prototype, ObjProto = Object.prototype;\nexport var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;\n\n// Create quick reference variables for speed access to core prototypes.\nexport var push = ArrayProto.push,\n    slice = ArrayProto.slice,\n    toString = ObjProto.toString,\n    hasOwnProperty = ObjProto.hasOwnProperty;\n\n// Modern feature detection.\nexport var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',\n    supportsDataView = typeof DataView !== 'undefined';\n\n// All **ECMAScript 5+** native function implementations that we hope to use\n// are declared here.\nexport var nativeIsArray = Array.isArray,\n    nativeKeys = Object.keys,\n    nativeCreate = Object.create,\n    nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;\n\n// Create references to these builtin functions because we override them.\nexport var _isNaN = isNaN,\n    _isFinite = isFinite;\n\n// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\nexport var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\nexport var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n  'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n// The largest integer that can be represented exactly.\nexport var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n","// Some functions take a variable number of arguments, or a few expected\n// arguments at the beginning and then a variable number of values to operate\n// on. This helper accumulates all remaining arguments past the function’s\n// argument length (or an explicit `startIndex`), into an array that becomes\n// the last argument. Similar to ES6’s \"rest parameter\".\nexport default function restArguments(func, startIndex) {\n  startIndex = startIndex == null ? func.length - 1 : +startIndex;\n  return function() {\n    var length = Math.max(arguments.length - startIndex, 0),\n        rest = Array(length),\n        index = 0;\n    for (; index < length; index++) {\n      rest[index] = arguments[index + startIndex];\n    }\n    switch (startIndex) {\n      case 0: return func.call(this, rest);\n      case 1: return func.call(this, arguments[0], rest);\n      case 2: return func.call(this, arguments[0], arguments[1], rest);\n    }\n    var args = Array(startIndex + 1);\n    for (index = 0; index < startIndex; index++) {\n      args[index] = arguments[index];\n    }\n    args[startIndex] = rest;\n    return func.apply(this, args);\n  };\n}\n","// Is a given variable an object?\nexport default function isObject(obj) {\n  var type = typeof obj;\n  return type === 'function' || (type === 'object' && !!obj);\n}\n","// Is a given value equal to null?\nexport default function isNull(obj) {\n  return obj === null;\n}\n","// Is a given variable undefined?\nexport default function isUndefined(obj) {\n  return obj === void 0;\n}\n","import { toString } from './_setup.js';\n\n// Is a given value a boolean?\nexport default function isBoolean(obj) {\n  return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n}\n","// Is a given value a DOM element?\nexport default function isElement(obj) {\n  return !!(obj && obj.nodeType === 1);\n}\n","import { toString } from './_setup.js';\n\n// Internal function for creating a `toString`-based type tester.\nexport default function tagTester(name) {\n  var tag = '[object ' + name + ']';\n  return function(obj) {\n    return toString.call(obj) === tag;\n  };\n}\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('String');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Number');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Date');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('RegExp');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Error');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Symbol');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('ArrayBuffer');\n","import tagTester from './_tagTester.js';\nimport { root } from './_setup.js';\n\nvar isFunction = tagTester('Function');\n\n// Optimize `isFunction` if appropriate. Work around some `typeof` bugs in old\n// v8, IE 11 (#1621), Safari 8 (#1929), and PhantomJS (#2236).\nvar nodelist = root.document && root.document.childNodes;\nif (typeof /./ != 'function' && typeof Int8Array != 'object' && typeof nodelist != 'function') {\n  isFunction = function(obj) {\n    return typeof obj == 'function' || false;\n  };\n}\n\nexport default isFunction;\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('Object');\n","import { supportsDataView } from './_setup.js';\nimport hasObjectTag from './_hasObjectTag.js';\n\n// In IE 10 - Edge 13, `DataView` has string tag `'[object Object]'`.\n// In IE 11, the most common among them, this problem also applies to\n// `Map`, `WeakMap` and `Set`.\nexport var hasStringTagBug = (\n      supportsDataView && hasObjectTag(new DataView(new ArrayBuffer(8)))\n    ),\n    isIE11 = (typeof Map !== 'undefined' && hasObjectTag(new Map));\n","import tagTester from './_tagTester.js';\nimport isFunction from './isFunction.js';\nimport isArrayBuffer from './isArrayBuffer.js';\nimport { hasStringTagBug } from './_stringTagBug.js';\n\nvar isDataView = tagTester('DataView');\n\n// In IE 10 - Edge 13, we need a different heuristic\n// to determine whether an object is a `DataView`.\nfunction ie10IsDataView(obj) {\n  return obj != null && isFunction(obj.getInt8) && isArrayBuffer(obj.buffer);\n}\n\nexport default (hasStringTagBug ? ie10IsDataView : isDataView);\n","import { nativeIsArray } from './_setup.js';\nimport tagTester from './_tagTester.js';\n\n// Is a given value an array?\n// Delegates to ECMA5's native `Array.isArray`.\nexport default nativeIsArray || tagTester('Array');\n","import { hasOwnProperty } from './_setup.js';\n\n// Internal function to check whether `key` is an own property name of `obj`.\nexport default function has(obj, key) {\n  return obj != null && hasOwnProperty.call(obj, key);\n}\n","import tagTester from './_tagTester.js';\nimport has from './_has.js';\n\nvar isArguments = tagTester('Arguments');\n\n// Define a fallback version of the method in browsers (ahem, IE < 9), where\n// there isn't any inspectable \"Arguments\" type.\n(function() {\n  if (!isArguments(arguments)) {\n    isArguments = function(obj) {\n      return has(obj, 'callee');\n    };\n  }\n}());\n\nexport default isArguments;\n","import { _isFinite } from './_setup.js';\nimport isSymbol from './isSymbol.js';\n\n// Is a given object a finite number?\nexport default function isFinite(obj) {\n  return !isSymbol(obj) && _isFinite(obj) && !isNaN(parseFloat(obj));\n}\n","import { _isNaN } from './_setup.js';\nimport isNumber from './isNumber.js';\n\n// Is the given value `NaN`?\nexport default function isNaN(obj) {\n  return isNumber(obj) && _isNaN(obj);\n}\n","// Predicate-generating function. Often useful outside of Underscore.\nexport default function constant(value) {\n  return function() {\n    return value;\n  };\n}\n","import { MAX_ARRAY_INDEX } from './_setup.js';\n\n// Common internal logic for `isArrayLike` and `isBufferLike`.\nexport default function createSizePropertyCheck(getSizeProperty) {\n  return function(collection) {\n    var sizeProperty = getSizeProperty(collection);\n    return typeof sizeProperty == 'number' && sizeProperty >= 0 && sizeProperty <= MAX_ARRAY_INDEX;\n  }\n}\n","// Internal helper to generate a function to obtain property `key` from `obj`.\nexport default function shallowProperty(key) {\n  return function(obj) {\n    return obj == null ? void 0 : obj[key];\n  };\n}\n","import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `byteLength` property of an object.\nexport default shallowProperty('byteLength');\n","import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getByteLength from './_getByteLength.js';\n\n// Internal helper to determine whether we should spend extensive checks against\n// `ArrayBuffer` et al.\nexport default createSizePropertyCheck(getByteLength);\n","import { supportsArrayBuffer, nativeIsView, toString } from './_setup.js';\nimport isDataView from './isDataView.js';\nimport constant from './constant.js';\nimport isBufferLike from './_isBufferLike.js';\n\n// Is a given value a typed array?\nvar typedArrayPattern = /\\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\\]/;\nfunction isTypedArray(obj) {\n  // `ArrayBuffer.isView` is the most future-proof, so use it when available.\n  // Otherwise, fall back on the above regular expression.\n  return nativeIsView ? (nativeIsView(obj) && !isDataView(obj)) :\n                isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));\n}\n\nexport default supportsArrayBuffer ? isTypedArray : constant(false);\n","import shallowProperty from './_shallowProperty.js';\n\n// Internal helper to obtain the `length` property of an object.\nexport default shallowProperty('length');\n","import { nonEnumerableProps, ObjProto } from './_setup.js';\nimport isFunction from './isFunction.js';\nimport has from './_has.js';\n\n// Internal helper to create a simple lookup structure.\n// `collectNonEnumProps` used to depend on `_.contains`, but this led to\n// circular imports. `emulatedSet` is a one-off solution that only works for\n// arrays of strings.\nfunction emulatedSet(keys) {\n  var hash = {};\n  for (var l = keys.length, i = 0; i < l; ++i) hash[keys[i]] = true;\n  return {\n    contains: function(key) { return hash[key] === true; },\n    push: function(key) {\n      hash[key] = true;\n      return keys.push(key);\n    }\n  };\n}\n\n// Internal helper. Checks `keys` for the presence of keys in IE < 9 that won't\n// be iterated by `for key in ...` and thus missed. Extends `keys` in place if\n// needed.\nexport default function collectNonEnumProps(obj, keys) {\n  keys = emulatedSet(keys);\n  var nonEnumIdx = nonEnumerableProps.length;\n  var constructor = obj.constructor;\n  var proto = (isFunction(constructor) && constructor.prototype) || ObjProto;\n\n  // Constructor is a special case.\n  var prop = 'constructor';\n  if (has(obj, prop) && !keys.contains(prop)) keys.push(prop);\n\n  while (nonEnumIdx--) {\n    prop = nonEnumerableProps[nonEnumIdx];\n    if (prop in obj && obj[prop] !== proto[prop] && !keys.contains(prop)) {\n      keys.push(prop);\n    }\n  }\n}\n","import isObject from './isObject.js';\nimport { nativeKeys, hasEnumBug } from './_setup.js';\nimport has from './_has.js';\nimport collectNonEnumProps from './_collectNonEnumProps.js';\n\n// Retrieve the names of an object's own properties.\n// Delegates to **ECMAScript 5**'s native `Object.keys`.\nexport default function keys(obj) {\n  if (!isObject(obj)) return [];\n  if (nativeKeys) return nativeKeys(obj);\n  var keys = [];\n  for (var key in obj) if (has(obj, key)) keys.push(key);\n  // Ahem, IE < 9.\n  if (hasEnumBug) collectNonEnumProps(obj, keys);\n  return keys;\n}\n","import getLength from './_getLength.js';\nimport isArray from './isArray.js';\nimport isString from './isString.js';\nimport isArguments from './isArguments.js';\nimport keys from './keys.js';\n\n// Is a given array, string, or object empty?\n// An \"empty\" object has no enumerable own-properties.\nexport default function isEmpty(obj) {\n  if (obj == null) return true;\n  // Skip the more expensive `toString`-based type checks if `obj` has no\n  // `.length`.\n  var length = getLength(obj);\n  if (typeof length == 'number' && (\n    isArray(obj) || isString(obj) || isArguments(obj)\n  )) return length === 0;\n  return getLength(keys(obj)) === 0;\n}\n","import keys from './keys.js';\n\n// Returns whether an object has a given set of `key:value` pairs.\nexport default function isMatch(object, attrs) {\n  var _keys = keys(attrs), length = _keys.length;\n  if (object == null) return !length;\n  var obj = Object(object);\n  for (var i = 0; i < length; i++) {\n    var key = _keys[i];\n    if (attrs[key] !== obj[key] || !(key in obj)) return false;\n  }\n  return true;\n}\n","import { VERSION } from './_setup.js';\n\n// If Underscore is called as a function, it returns a wrapped object that can\n// be used OO-style. This wrapper holds altered versions of all functions added\n// through `_.mixin`. Wrapped objects may be chained.\nexport default function _(obj) {\n  if (obj instanceof _) return obj;\n  if (!(this instanceof _)) return new _(obj);\n  this._wrapped = obj;\n}\n\n_.VERSION = VERSION;\n\n// Extracts the result from a wrapped and chained object.\n_.prototype.value = function() {\n  return this._wrapped;\n};\n\n// Provide unwrapping proxies for some methods used in engine operations\n// such as arithmetic and JSON stringification.\n_.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n_.prototype.toString = function() {\n  return String(this._wrapped);\n};\n","import getByteLength from './_getByteLength.js';\n\n// Internal function to wrap or shallow-copy an ArrayBuffer,\n// typed array or DataView to a new view, reusing the buffer.\nexport default function toBufferView(bufferSource) {\n  return new Uint8Array(\n    bufferSource.buffer || bufferSource,\n    bufferSource.byteOffset || 0,\n    getByteLength(bufferSource)\n  );\n}\n","import _ from './underscore.js';\nimport { toString, SymbolProto } from './_setup.js';\nimport getByteLength from './_getByteLength.js';\nimport isTypedArray from './isTypedArray.js';\nimport isFunction from './isFunction.js';\nimport { hasStringTagBug }  from './_stringTagBug.js';\nimport isDataView from './isDataView.js';\nimport keys from './keys.js';\nimport has from './_has.js';\nimport toBufferView from './_toBufferView.js';\n\n// We use this string twice, so give it a name for minification.\nvar tagDataView = '[object DataView]';\n\n// Internal recursive comparison function for `_.isEqual`.\nfunction eq(a, b, aStack, bStack) {\n  // Identical objects are equal. `0 === -0`, but they aren't identical.\n  // See the [Harmony `egal` proposal](https://wiki.ecmascript.org/doku.php?id=harmony:egal).\n  if (a === b) return a !== 0 || 1 / a === 1 / b;\n  // `null` or `undefined` only equal to itself (strict comparison).\n  if (a == null || b == null) return false;\n  // `NaN`s are equivalent, but non-reflexive.\n  if (a !== a) return b !== b;\n  // Exhaust primitive checks\n  var type = typeof a;\n  if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;\n  return deepEq(a, b, aStack, bStack);\n}\n\n// Internal recursive comparison function for `_.isEqual`.\nfunction deepEq(a, b, aStack, bStack) {\n  // Unwrap any wrapped objects.\n  if (a instanceof _) a = a._wrapped;\n  if (b instanceof _) b = b._wrapped;\n  // Compare `[[Class]]` names.\n  var className = toString.call(a);\n  if (className !== toString.call(b)) return false;\n  // Work around a bug in IE 10 - Edge 13.\n  if (hasStringTagBug && className == '[object Object]' && isDataView(a)) {\n    if (!isDataView(b)) return false;\n    className = tagDataView;\n  }\n  switch (className) {\n    // These types are compared by value.\n    case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n    case '[object String]':\n      // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n      // equivalent to `new String(\"5\")`.\n      return '' + a === '' + b;\n    case '[object Number]':\n      // `NaN`s are equivalent, but non-reflexive.\n      // Object(NaN) is equivalent to NaN.\n      if (+a !== +a) return +b !== +b;\n      // An `egal` comparison is performed for other numeric values.\n      return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n    case '[object Date]':\n    case '[object Boolean]':\n      // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n      // millisecond representations. Note that invalid dates with millisecond representations\n      // of `NaN` are not equivalent.\n      return +a === +b;\n    case '[object Symbol]':\n      return SymbolProto.valueOf.call(a) === SymbolProto.valueOf.call(b);\n    case '[object ArrayBuffer]':\n    case tagDataView:\n      // Coerce to typed array so we can fall through.\n      return deepEq(toBufferView(a), toBufferView(b), aStack, bStack);\n  }\n\n  var areArrays = className === '[object Array]';\n  if (!areArrays && isTypedArray(a)) {\n      var byteLength = getByteLength(a);\n      if (byteLength !== getByteLength(b)) return false;\n      if (a.buffer === b.buffer && a.byteOffset === b.byteOffset) return true;\n      areArrays = true;\n  }\n  if (!areArrays) {\n    if (typeof a != 'object' || typeof b != 'object') return false;\n\n    // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n    // from different frames are.\n    var aCtor = a.constructor, bCtor = b.constructor;\n    if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor &&\n                             isFunction(bCtor) && bCtor instanceof bCtor)\n                        && ('constructor' in a && 'constructor' in b)) {\n      return false;\n    }\n  }\n  // Assume equality for cyclic structures. The algorithm for detecting cyclic\n  // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n  // Initializing stack of traversed objects.\n  // It's done here since we only need them for objects and arrays comparison.\n  aStack = aStack || [];\n  bStack = bStack || [];\n  var length = aStack.length;\n  while (length--) {\n    // Linear search. Performance is inversely proportional to the number of\n    // unique nested structures.\n    if (aStack[length] === a) return bStack[length] === b;\n  }\n\n  // Add the first object to the stack of traversed objects.\n  aStack.push(a);\n  bStack.push(b);\n\n  // Recursively compare objects and arrays.\n  if (areArrays) {\n    // Compare array lengths to determine if a deep comparison is necessary.\n    length = a.length;\n    if (length !== b.length) return false;\n    // Deep compare the contents, ignoring non-numeric properties.\n    while (length--) {\n      if (!eq(a[length], b[length], aStack, bStack)) return false;\n    }\n  } else {\n    // Deep compare objects.\n    var _keys = keys(a), key;\n    length = _keys.length;\n    // Ensure that both objects contain the same number of properties before comparing deep equality.\n    if (keys(b).length !== length) return false;\n    while (length--) {\n      // Deep compare each member\n      key = _keys[length];\n      if (!(has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n    }\n  }\n  // Remove the first object from the stack of traversed objects.\n  aStack.pop();\n  bStack.pop();\n  return true;\n}\n\n// Perform a deep comparison to check if two objects are equal.\nexport default function isEqual(a, b) {\n  return eq(a, b);\n}\n","import isObject from './isObject.js';\nimport { hasEnumBug } from './_setup.js';\nimport collectNonEnumProps from './_collectNonEnumProps.js';\n\n// Retrieve all the enumerable property names of an object.\nexport default function allKeys(obj) {\n  if (!isObject(obj)) return [];\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  // Ahem, IE < 9.\n  if (hasEnumBug) collectNonEnumProps(obj, keys);\n  return keys;\n}\n","import getLength from './_getLength.js';\nimport isFunction from './isFunction.js';\nimport allKeys from './allKeys.js';\n\n// Since the regular `Object.prototype.toString` type tests don't work for\n// some types in IE 11, we use a fingerprinting heuristic instead, based\n// on the methods. It's not great, but it's the best we got.\n// The fingerprint method lists are defined below.\nexport function ie11fingerprint(methods) {\n  var length = getLength(methods);\n  return function(obj) {\n    if (obj == null) return false;\n    // `Map`, `WeakMap` and `Set` have no enumerable keys.\n    var keys = allKeys(obj);\n    if (getLength(keys)) return false;\n    for (var i = 0; i < length; i++) {\n      if (!isFunction(obj[methods[i]])) return false;\n    }\n    // If we are testing against `WeakMap`, we need to ensure that\n    // `obj` doesn't have a `forEach` method in order to distinguish\n    // it from a regular `Map`.\n    return methods !== weakMapMethods || !isFunction(obj[forEachName]);\n  };\n}\n\n// In the interest of compact minification, we write\n// each string in the fingerprints only once.\nvar forEachName = 'forEach',\n    hasName = 'has',\n    commonInit = ['clear', 'delete'],\n    mapTail = ['get', hasName, 'set'];\n\n// `Map`, `WeakMap` and `Set` each have slightly different\n// combinations of the above sublists.\nexport var mapMethods = commonInit.concat(forEachName, mapTail),\n    weakMapMethods = commonInit.concat(mapTail),\n    setMethods = ['add'].concat(commonInit, forEachName, hasName);\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, mapMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(mapMethods) : tagTester('Map');\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, weakMapMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(weakMapMethods) : tagTester('WeakMap');\n","import tagTester from './_tagTester.js';\nimport { isIE11 } from './_stringTagBug.js';\nimport { ie11fingerprint, setMethods }  from './_methodFingerprint.js';\n\nexport default isIE11 ? ie11fingerprint(setMethods) : tagTester('Set');\n","import tagTester from './_tagTester.js';\n\nexport default tagTester('WeakSet');\n","import keys from './keys.js';\n\n// Retrieve the values of an object's properties.\nexport default function values(obj) {\n  var _keys = keys(obj);\n  var length = _keys.length;\n  var values = Array(length);\n  for (var i = 0; i < length; i++) {\n    values[i] = obj[_keys[i]];\n  }\n  return values;\n}\n","import keys from './keys.js';\n\n// Convert an object into a list of `[key, value]` pairs.\n// The opposite of `_.object` with one argument.\nexport default function pairs(obj) {\n  var _keys = keys(obj);\n  var length = _keys.length;\n  var pairs = Array(length);\n  for (var i = 0; i < length; i++) {\n    pairs[i] = [_keys[i], obj[_keys[i]]];\n  }\n  return pairs;\n}\n","import keys from './keys.js';\n\n// Invert the keys and values of an object. The values must be serializable.\nexport default function invert(obj) {\n  var result = {};\n  var _keys = keys(obj);\n  for (var i = 0, length = _keys.length; i < length; i++) {\n    result[obj[_keys[i]]] = _keys[i];\n  }\n  return result;\n}\n","import isFunction from './isFunction.js';\n\n// Return a sorted list of the function names available on the object.\nexport default function functions(obj) {\n  var names = [];\n  for (var key in obj) {\n    if (isFunction(obj[key])) names.push(key);\n  }\n  return names.sort();\n}\n","// An internal function for creating assigner functions.\nexport default function createAssigner(keysFunc, defaults) {\n  return function(obj) {\n    var length = arguments.length;\n    if (defaults) obj = Object(obj);\n    if (length < 2 || obj == null) return obj;\n    for (var index = 1; index < length; index++) {\n      var source = arguments[index],\n          keys = keysFunc(source),\n          l = keys.length;\n      for (var i = 0; i < l; i++) {\n        var key = keys[i];\n        if (!defaults || obj[key] === void 0) obj[key] = source[key];\n      }\n    }\n    return obj;\n  };\n}\n","import createAssigner from './_createAssigner.js';\nimport allKeys from './allKeys.js';\n\n// Extend a given object with all the properties in passed-in object(s).\nexport default createAssigner(allKeys);\n","import createAssigner from './_createAssigner.js';\nimport keys from './keys.js';\n\n// Assigns a given object with all the own properties in the passed-in\n// object(s).\n// (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\nexport default createAssigner(keys);\n","import createAssigner from './_createAssigner.js';\nimport allKeys from './allKeys.js';\n\n// Fill in a given object with default properties.\nexport default createAssigner(allKeys, true);\n","import isObject from './isObject.js';\nimport { nativeCreate } from './_setup.js';\n\n// Create a naked function reference for surrogate-prototype-swapping.\nfunction ctor() {\n  return function(){};\n}\n\n// An internal function for creating a new object that inherits from another.\nexport default function baseCreate(prototype) {\n  if (!isObject(prototype)) return {};\n  if (nativeCreate) return nativeCreate(prototype);\n  var Ctor = ctor();\n  Ctor.prototype = prototype;\n  var result = new Ctor;\n  Ctor.prototype = null;\n  return result;\n}\n","import baseCreate from './_baseCreate.js';\nimport extendOwn from './extendOwn.js';\n\n// Creates an object that inherits from the given prototype object.\n// If additional properties are provided then they will be added to the\n// created object.\nexport default function create(prototype, props) {\n  var result = baseCreate(prototype);\n  if (props) extendOwn(result, props);\n  return result;\n}\n","import isObject from './isObject.js';\nimport isArray from './isArray.js';\nimport extend from './extend.js';\n\n// Create a (shallow-cloned) duplicate of an object.\nexport default function clone(obj) {\n  if (!isObject(obj)) return obj;\n  return isArray(obj) ? obj.slice() : extend({}, obj);\n}\n","// Invokes `interceptor` with the `obj` and then returns `obj`.\n// The primary purpose of this method is to \"tap into\" a method chain, in\n// order to perform operations on intermediate results within the chain.\nexport default function tap(obj, interceptor) {\n  interceptor(obj);\n  return obj;\n}\n","import _ from './underscore.js';\nimport isArray from './isArray.js';\n\n// Normalize a (deep) property `path` to array.\n// Like `_.iteratee`, this function can be customized.\nexport default function toPath(path) {\n  return isArray(path) ? path : [path];\n}\n_.toPath = toPath;\n","import _ from './underscore.js';\nimport './toPath.js';\n\n// Internal wrapper for `_.toPath` to enable minification.\n// Similar to `cb` for `_.iteratee`.\nexport default function toPath(path) {\n  return _.toPath(path);\n}\n","// Internal function to obtain a nested property in `obj` along `path`.\nexport default function deepGet(obj, path) {\n  var length = path.length;\n  for (var i = 0; i < length; i++) {\n    if (obj == null) return void 0;\n    obj = obj[path[i]];\n  }\n  return length ? obj : void 0;\n}\n","import toPath from './_toPath.js';\nimport deepGet from './_deepGet.js';\nimport isUndefined from './isUndefined.js';\n\n// Get the value of the (deep) property on `path` from `object`.\n// If any property in `path` does not exist or if the value is\n// `undefined`, return `defaultValue` instead.\n// The `path` is normalized through `_.toPath`.\nexport default function get(object, path, defaultValue) {\n  var value = deepGet(object, toPath(path));\n  return isUndefined(value) ? defaultValue : value;\n}\n","import _has from './_has.js';\nimport toPath from './_toPath.js';\n\n// Shortcut function for checking if an object has a given property directly on\n// itself (in other words, not on a prototype). Unlike the internal `has`\n// function, this public version can also traverse nested properties.\nexport default function has(obj, path) {\n  path = toPath(path);\n  var length = path.length;\n  for (var i = 0; i < length; i++) {\n    var key = path[i];\n    if (!_has(obj, key)) return false;\n    obj = obj[key];\n  }\n  return !!length;\n}\n","// Keep the identity function around for default iteratees.\nexport default function identity(value) {\n  return value;\n}\n","import extendOwn from './extendOwn.js';\nimport isMatch from './isMatch.js';\n\n// Returns a predicate for checking whether an object has a given set of\n// `key:value` pairs.\nexport default function matcher(attrs) {\n  attrs = extendOwn({}, attrs);\n  return function(obj) {\n    return isMatch(obj, attrs);\n  };\n}\n","import deepGet from './_deepGet.js';\nimport toPath from './_toPath.js';\n\n// Creates a function that, when passed an object, will traverse that object’s\n// properties down the given `path`, specified as an array of keys or indices.\nexport default function property(path) {\n  path = toPath(path);\n  return function(obj) {\n    return deepGet(obj, path);\n  };\n}\n","// Internal function that returns an efficient (for current engines) version\n// of the passed-in callback, to be repeatedly applied in other Underscore\n// functions.\nexport default function optimizeCb(func, context, argCount) {\n  if (context === void 0) return func;\n  switch (argCount == null ? 3 : argCount) {\n    case 1: return function(value) {\n      return func.call(context, value);\n    };\n    // The 2-argument case is omitted because we’re not using it.\n    case 3: return function(value, index, collection) {\n      return func.call(context, value, index, collection);\n    };\n    case 4: return function(accumulator, value, index, collection) {\n      return func.call(context, accumulator, value, index, collection);\n    };\n  }\n  return function() {\n    return func.apply(context, arguments);\n  };\n}\n","import identity from './identity.js';\nimport isFunction from './isFunction.js';\nimport isObject from './isObject.js';\nimport isArray from './isArray.js';\nimport matcher from './matcher.js';\nimport property from './property.js';\nimport optimizeCb from './_optimizeCb.js';\n\n// An internal function to generate callbacks that can be applied to each\n// element in a collection, returning the desired result — either `_.identity`,\n// an arbitrary callback, a property matcher, or a property accessor.\nexport default function baseIteratee(value, context, argCount) {\n  if (value == null) return identity;\n  if (isFunction(value)) return optimizeCb(value, context, argCount);\n  if (isObject(value) && !isArray(value)) return matcher(value);\n  return property(value);\n}\n","import _ from './underscore.js';\nimport baseIteratee from './_baseIteratee.js';\n\n// External wrapper for our callback generator. Users may customize\n// `_.iteratee` if they want additional predicate/iteratee shorthand styles.\n// This abstraction hides the internal-only `argCount` argument.\nexport default function iteratee(value, context) {\n  return baseIteratee(value, context, Infinity);\n}\n_.iteratee = iteratee;\n","import _ from './underscore.js';\nimport baseIteratee from './_baseIteratee.js';\nimport iteratee from './iteratee.js';\n\n// The function we call internally to generate a callback. It invokes\n// `_.iteratee` if overridden, otherwise `baseIteratee`.\nexport default function cb(value, context, argCount) {\n  if (_.iteratee !== iteratee) return _.iteratee(value, context);\n  return baseIteratee(value, context, argCount);\n}\n","import cb from './_cb.js';\nimport keys from './keys.js';\n\n// Returns the results of applying the `iteratee` to each element of `obj`.\n// In contrast to `_.map` it returns an object.\nexport default function mapObject(obj, iteratee, context) {\n  iteratee = cb(iteratee, context);\n  var _keys = keys(obj),\n      length = _keys.length,\n      results = {};\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys[index];\n    results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n  }\n  return results;\n}\n","// Predicate-generating function. Often useful outside of Underscore.\nexport default function noop(){}\n","import noop from './noop.js';\nimport get from './get.js';\n\n// Generates a function for a given object that returns a given property.\nexport default function propertyOf(obj) {\n  if (obj == null) return noop;\n  return function(path) {\n    return get(obj, path);\n  };\n}\n","import optimizeCb from './_optimizeCb.js';\n\n// Run a function **n** times.\nexport default function times(n, iteratee, context) {\n  var accum = Array(Math.max(0, n));\n  iteratee = optimizeCb(iteratee, context, 1);\n  for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n  return accum;\n}\n","// Return a random integer between `min` and `max` (inclusive).\nexport default function random(min, max) {\n  if (max == null) {\n    max = min;\n    min = 0;\n  }\n  return min + Math.floor(Math.random() * (max - min + 1));\n}\n","// A (possibly faster) way to get the current timestamp as an integer.\nexport default Date.now || function() {\n  return new Date().getTime();\n};\n","import keys from './keys.js';\n\n// Internal helper to generate functions for escaping and unescaping strings\n// to/from HTML interpolation.\nexport default function createEscaper(map) {\n  var escaper = function(match) {\n    return map[match];\n  };\n  // Regexes for identifying a key that needs to be escaped.\n  var source = '(?:' + keys(map).join('|') + ')';\n  var testRegexp = RegExp(source);\n  var replaceRegexp = RegExp(source, 'g');\n  return function(string) {\n    string = string == null ? '' : '' + string;\n    return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n  };\n}\n","// Internal list of HTML entities for escaping.\nexport default {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#x27;',\n  '`': '&#x60;'\n};\n","import createEscaper from './_createEscaper.js';\nimport escapeMap from './_escapeMap.js';\n\n// Function for escaping strings to HTML interpolation.\nexport default createEscaper(escapeMap);\n","import createEscaper from './_createEscaper.js';\nimport unescapeMap from './_unescapeMap.js';\n\n// Function for unescaping strings from HTML interpolation.\nexport default createEscaper(unescapeMap);\n","import invert from './invert.js';\nimport escapeMap from './_escapeMap.js';\n\n// Internal list of HTML entities for unescaping.\nexport default invert(escapeMap);\n","import _ from './underscore.js';\n\n// By default, Underscore uses ERB-style template delimiters. Change the\n// following template settings to use alternative delimiters.\nexport default _.templateSettings = {\n  evaluate: /<%([\\s\\S]+?)%>/g,\n  interpolate: /<%=([\\s\\S]+?)%>/g,\n  escape: /<%-([\\s\\S]+?)%>/g\n};\n","import defaults from './defaults.js';\nimport _ from './underscore.js';\nimport './templateSettings.js';\n\n// When customizing `_.templateSettings`, if you don't want to define an\n// interpolation, evaluation or escaping regex, we need one that is\n// guaranteed not to match.\nvar noMatch = /(.)^/;\n\n// Certain characters need to be escaped so that they can be put into a\n// string literal.\nvar escapes = {\n  \"'\": \"'\",\n  '\\\\': '\\\\',\n  '\\r': 'r',\n  '\\n': 'n',\n  '\\u2028': 'u2028',\n  '\\u2029': 'u2029'\n};\n\nvar escapeRegExp = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\nfunction escapeChar(match) {\n  return '\\\\' + escapes[match];\n}\n\n// In order to prevent third-party code injection through\n// `_.templateSettings.variable`, we test it against the following regular\n// expression. It is intentionally a bit more liberal than just matching valid\n// identifiers, but still prevents possible loopholes through defaults or\n// destructuring assignment.\nvar bareIdentifier = /^\\s*(\\w|\\$)+\\s*$/;\n\n// JavaScript micro-templating, similar to John Resig's implementation.\n// Underscore templating handles arbitrary delimiters, preserves whitespace,\n// and correctly escapes quotes within interpolated code.\n// NB: `oldSettings` only exists for backwards compatibility.\nexport default function template(text, settings, oldSettings) {\n  if (!settings && oldSettings) settings = oldSettings;\n  settings = defaults({}, settings, _.templateSettings);\n\n  // Combine delimiters into one regular expression via alternation.\n  var matcher = RegExp([\n    (settings.escape || noMatch).source,\n    (settings.interpolate || noMatch).source,\n    (settings.evaluate || noMatch).source\n  ].join('|') + '|$', 'g');\n\n  // Compile the template source, escaping string literals appropriately.\n  var index = 0;\n  var source = \"__p+='\";\n  text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n    source += text.slice(index, offset).replace(escapeRegExp, escapeChar);\n    index = offset + match.length;\n\n    if (escape) {\n      source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n    } else if (interpolate) {\n      source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n    } else if (evaluate) {\n      source += \"';\\n\" + evaluate + \"\\n__p+='\";\n    }\n\n    // Adobe VMs need the match returned to produce the correct offset.\n    return match;\n  });\n  source += \"';\\n\";\n\n  var argument = settings.variable;\n  if (argument) {\n    // Insure against third-party code injection. (CVE-2021-23358)\n    if (!bareIdentifier.test(argument)) throw new Error(\n      'variable is not a bare identifier: ' + argument\n    );\n  } else {\n    // If a variable is not specified, place data values in local scope.\n    source = 'with(obj||{}){\\n' + source + '}\\n';\n    argument = 'obj';\n  }\n\n  source = \"var __t,__p='',__j=Array.prototype.join,\" +\n    \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n    source + 'return __p;\\n';\n\n  var render;\n  try {\n    render = new Function(argument, '_', source);\n  } catch (e) {\n    e.source = source;\n    throw e;\n  }\n\n  var template = function(data) {\n    return render.call(this, data, _);\n  };\n\n  // Provide the compiled source as a convenience for precompilation.\n  template.source = 'function(' + argument + '){\\n' + source + '}';\n\n  return template;\n}\n","import isFunction from './isFunction.js';\nimport toPath from './_toPath.js';\n\n// Traverses the children of `obj` along `path`. If a child is a function, it\n// is invoked with its parent as context. Returns the value of the final\n// child, or `fallback` if any child is undefined.\nexport default function result(obj, path, fallback) {\n  path = toPath(path);\n  var length = path.length;\n  if (!length) {\n    return isFunction(fallback) ? fallback.call(obj) : fallback;\n  }\n  for (var i = 0; i < length; i++) {\n    var prop = obj == null ? void 0 : obj[path[i]];\n    if (prop === void 0) {\n      prop = fallback;\n      i = length; // Ensure we don't continue iterating.\n    }\n    obj = isFunction(prop) ? prop.call(obj) : prop;\n  }\n  return obj;\n}\n","// Generate a unique integer id (unique within the entire client session).\n// Useful for temporary DOM ids.\nvar idCounter = 0;\nexport default function uniqueId(prefix) {\n  var id = ++idCounter + '';\n  return prefix ? prefix + id : id;\n}\n","import _ from './underscore.js';\n\n// Start chaining a wrapped Underscore object.\nexport default function chain(obj) {\n  var instance = _(obj);\n  instance._chain = true;\n  return instance;\n}\n","import baseCreate from './_baseCreate.js';\nimport isObject from './isObject.js';\n\n// Internal function to execute `sourceFunc` bound to `context` with optional\n// `args`. Determines whether to execute a function as a constructor or as a\n// normal function.\nexport default function executeBound(sourceFunc, boundFunc, context, callingContext, args) {\n  if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n  var self = baseCreate(sourceFunc.prototype);\n  var result = sourceFunc.apply(self, args);\n  if (isObject(result)) return result;\n  return self;\n}\n","import restArguments from './restArguments.js';\nimport executeBound from './_executeBound.js';\nimport _ from './underscore.js';\n\n// Partially apply a function by creating a version that has had some of its\n// arguments pre-filled, without changing its dynamic `this` context. `_` acts\n// as a placeholder by default, allowing any combination of arguments to be\n// pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.\nvar partial = restArguments(function(func, boundArgs) {\n  var placeholder = partial.placeholder;\n  var bound = function() {\n    var position = 0, length = boundArgs.length;\n    var args = Array(length);\n    for (var i = 0; i < length; i++) {\n      args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];\n    }\n    while (position < arguments.length) args.push(arguments[position++]);\n    return executeBound(func, bound, this, this, args);\n  };\n  return bound;\n});\n\npartial.placeholder = _;\nexport default partial;\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport executeBound from './_executeBound.js';\n\n// Create a function bound to a given object (assigning `this`, and arguments,\n// optionally).\nexport default restArguments(function(func, context, args) {\n  if (!isFunction(func)) throw new TypeError('Bind must be called on a function');\n  var bound = restArguments(function(callArgs) {\n    return executeBound(func, bound, context, this, args.concat(callArgs));\n  });\n  return bound;\n});\n","import createSizePropertyCheck from './_createSizePropertyCheck.js';\nimport getLength from './_getLength.js';\n\n// Internal helper for collection methods to determine whether a collection\n// should be iterated as an array or as an object.\n// Related: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n// Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\nexport default createSizePropertyCheck(getLength);\n","import getLength from './_getLength.js';\nimport isArrayLike from './_isArrayLike.js';\nimport isArray from './isArray.js';\nimport isArguments from './isArguments.js';\n\n// Internal implementation of a recursive `flatten` function.\nexport default function flatten(input, depth, strict, output) {\n  output = output || [];\n  if (!depth && depth !== 0) {\n    depth = Infinity;\n  } else if (depth <= 0) {\n    return output.concat(input);\n  }\n  var idx = output.length;\n  for (var i = 0, length = getLength(input); i < length; i++) {\n    var value = input[i];\n    if (isArrayLike(value) && (isArray(value) || isArguments(value))) {\n      // Flatten current level of array or arguments object.\n      if (depth > 1) {\n        flatten(value, depth - 1, strict, output);\n        idx = output.length;\n      } else {\n        var j = 0, len = value.length;\n        while (j < len) output[idx++] = value[j++];\n      }\n    } else if (!strict) {\n      output[idx++] = value;\n    }\n  }\n  return output;\n}\n","import restArguments from './restArguments.js';\nimport flatten from './_flatten.js';\nimport bind from './bind.js';\n\n// Bind a number of an object's methods to that object. Remaining arguments\n// are the method names to be bound. Useful for ensuring that all callbacks\n// defined on an object belong to it.\nexport default restArguments(function(obj, keys) {\n  keys = flatten(keys, false, false);\n  var index = keys.length;\n  if (index < 1) throw new Error('bindAll must be passed function names');\n  while (index--) {\n    var key = keys[index];\n    obj[key] = bind(obj[key], obj);\n  }\n  return obj;\n});\n","import has from './_has.js';\n\n// Memoize an expensive function by storing its results.\nexport default function memoize(func, hasher) {\n  var memoize = function(key) {\n    var cache = memoize.cache;\n    var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n    if (!has(cache, address)) cache[address] = func.apply(this, arguments);\n    return cache[address];\n  };\n  memoize.cache = {};\n  return memoize;\n}\n","import restArguments from './restArguments.js';\n\n// Delays a function for the given number of milliseconds, and then calls\n// it with the arguments supplied.\nexport default restArguments(function(func, wait, args) {\n  return setTimeout(function() {\n    return func.apply(null, args);\n  }, wait);\n});\n","import partial from './partial.js';\nimport delay from './delay.js';\nimport _ from './underscore.js';\n\n// Defers a function, scheduling it to run after the current call stack has\n// cleared.\nexport default partial(delay, _, 1);\n","import now from './now.js';\n\n// Returns a function, that, when invoked, will only be triggered at most once\n// during a given window of time. Normally, the throttled function will run\n// as much as it can, without ever going more than once per `wait` duration;\n// but if you'd like to disable the execution on the leading edge, pass\n// `{leading: false}`. To disable execution on the trailing edge, ditto.\nexport default function throttle(func, wait, options) {\n  var timeout, context, args, result;\n  var previous = 0;\n  if (!options) options = {};\n\n  var later = function() {\n    previous = options.leading === false ? 0 : now();\n    timeout = null;\n    result = func.apply(context, args);\n    if (!timeout) context = args = null;\n  };\n\n  var throttled = function() {\n    var _now = now();\n    if (!previous && options.leading === false) previous = _now;\n    var remaining = wait - (_now - previous);\n    context = this;\n    args = arguments;\n    if (remaining <= 0 || remaining > wait) {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = null;\n      }\n      previous = _now;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    } else if (!timeout && options.trailing !== false) {\n      timeout = setTimeout(later, remaining);\n    }\n    return result;\n  };\n\n  throttled.cancel = function() {\n    clearTimeout(timeout);\n    previous = 0;\n    timeout = context = args = null;\n  };\n\n  return throttled;\n}\n","import restArguments from './restArguments.js';\nimport now from './now.js';\n\n// When a sequence of calls of the returned function ends, the argument\n// function is triggered. The end of a sequence is defined by the `wait`\n// parameter. If `immediate` is passed, the argument function will be\n// triggered at the beginning of the sequence instead of at the end.\nexport default function debounce(func, wait, immediate) {\n  var timeout, previous, args, result, context;\n\n  var later = function() {\n    var passed = now() - previous;\n    if (wait > passed) {\n      timeout = setTimeout(later, wait - passed);\n    } else {\n      timeout = null;\n      if (!immediate) result = func.apply(context, args);\n      // This check is needed because `func` can recursively invoke `debounced`.\n      if (!timeout) args = context = null;\n    }\n  };\n\n  var debounced = restArguments(function(_args) {\n    context = this;\n    args = _args;\n    previous = now();\n    if (!timeout) {\n      timeout = setTimeout(later, wait);\n      if (immediate) result = func.apply(context, args);\n    }\n    return result;\n  });\n\n  debounced.cancel = function() {\n    clearTimeout(timeout);\n    timeout = args = context = null;\n  };\n\n  return debounced;\n}\n","import partial from './partial.js';\n\n// Returns the first function passed as an argument to the second,\n// allowing you to adjust arguments, run code before and after, and\n// conditionally execute the original function.\nexport default function wrap(func, wrapper) {\n  return partial(wrapper, func);\n}\n","// Returns a negated version of the passed-in predicate.\nexport default function negate(predicate) {\n  return function() {\n    return !predicate.apply(this, arguments);\n  };\n}\n","// Returns a function that is the composition of a list of functions, each\n// consuming the return value of the function that follows.\nexport default function compose() {\n  var args = arguments;\n  var start = args.length - 1;\n  return function() {\n    var i = start;\n    var result = args[start].apply(this, arguments);\n    while (i--) result = args[i].call(this, result);\n    return result;\n  };\n}\n","// Returns a function that will only be executed on and after the Nth call.\nexport default function after(times, func) {\n  return function() {\n    if (--times < 1) {\n      return func.apply(this, arguments);\n    }\n  };\n}\n","// Returns a function that will only be executed up to (but not including) the\n// Nth call.\nexport default function before(times, func) {\n  var memo;\n  return function() {\n    if (--times > 0) {\n      memo = func.apply(this, arguments);\n    }\n    if (times <= 1) func = null;\n    return memo;\n  };\n}\n","import partial from './partial.js';\nimport before from './before.js';\n\n// Returns a function that will be executed at most one time, no matter how\n// often you call it. Useful for lazy initialization.\nexport default partial(before, 2);\n","import cb from './_cb.js';\nimport keys from './keys.js';\n\n// Returns the first key on an object that passes a truth test.\nexport default function findKey(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = keys(obj), key;\n  for (var i = 0, length = _keys.length; i < length; i++) {\n    key = _keys[i];\n    if (predicate(obj[key], key, obj)) return key;\n  }\n}\n","import cb from './_cb.js';\nimport getLength from './_getLength.js';\n\n// Internal function to generate `_.findIndex` and `_.findLastIndex`.\nexport default function createPredicateIndexFinder(dir) {\n  return function(array, predicate, context) {\n    predicate = cb(predicate, context);\n    var length = getLength(array);\n    var index = dir > 0 ? 0 : length - 1;\n    for (; index >= 0 && index < length; index += dir) {\n      if (predicate(array[index], index, array)) return index;\n    }\n    return -1;\n  };\n}\n","import createPredicateIndexFinder from './_createPredicateIndexFinder.js';\n\n// Returns the first index on an array-like that passes a truth test.\nexport default createPredicateIndexFinder(1);\n","import createPredicateIndexFinder from './_createPredicateIndexFinder.js';\n\n// Returns the last index on an array-like that passes a truth test.\nexport default createPredicateIndexFinder(-1);\n","import cb from './_cb.js';\nimport getLength from './_getLength.js';\n\n// Use a comparator function to figure out the smallest index at which\n// an object should be inserted so as to maintain order. Uses binary search.\nexport default function sortedIndex(array, obj, iteratee, context) {\n  iteratee = cb(iteratee, context, 1);\n  var value = iteratee(obj);\n  var low = 0, high = getLength(array);\n  while (low < high) {\n    var mid = Math.floor((low + high) / 2);\n    if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n  }\n  return low;\n}\n","import getLength from './_getLength.js';\nimport { slice } from './_setup.js';\nimport isNaN from './isNaN.js';\n\n// Internal function to generate the `_.indexOf` and `_.lastIndexOf` functions.\nexport default function createIndexFinder(dir, predicateFind, sortedIndex) {\n  return function(array, item, idx) {\n    var i = 0, length = getLength(array);\n    if (typeof idx == 'number') {\n      if (dir > 0) {\n        i = idx >= 0 ? idx : Math.max(idx + length, i);\n      } else {\n        length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n      }\n    } else if (sortedIndex && idx && length) {\n      idx = sortedIndex(array, item);\n      return array[idx] === item ? idx : -1;\n    }\n    if (item !== item) {\n      idx = predicateFind(slice.call(array, i, length), isNaN);\n      return idx >= 0 ? idx + i : -1;\n    }\n    for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n      if (array[idx] === item) return idx;\n    }\n    return -1;\n  };\n}\n","import sortedIndex from './sortedIndex.js';\nimport findIndex from './findIndex.js';\nimport createIndexFinder from './_createIndexFinder.js';\n\n// Return the position of the first occurrence of an item in an array,\n// or -1 if the item is not included in the array.\n// If the array is large and already in sort order, pass `true`\n// for **isSorted** to use binary search.\nexport default createIndexFinder(1, findIndex, sortedIndex);\n","import findLastIndex from './findLastIndex.js';\nimport createIndexFinder from './_createIndexFinder.js';\n\n// Return the position of the last occurrence of an item in an array,\n// or -1 if the item is not included in the array.\nexport default createIndexFinder(-1, findLastIndex);\n","import isArrayLike from './_isArrayLike.js';\nimport findIndex from './findIndex.js';\nimport findKey from './findKey.js';\n\n// Return the first value which passes a truth test.\nexport default function find(obj, predicate, context) {\n  var keyFinder = isArrayLike(obj) ? findIndex : findKey;\n  var key = keyFinder(obj, predicate, context);\n  if (key !== void 0 && key !== -1) return obj[key];\n}\n","import find from './find.js';\nimport matcher from './matcher.js';\n\n// Convenience version of a common use case of `_.find`: getting the first\n// object containing specific `key:value` pairs.\nexport default function findWhere(obj, attrs) {\n  return find(obj, matcher(attrs));\n}\n","import optimizeCb from './_optimizeCb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// The cornerstone for collection functions, an `each`\n// implementation, aka `forEach`.\n// Handles raw objects in addition to array-likes. Treats all\n// sparse array-likes as if they were dense.\nexport default function each(obj, iteratee, context) {\n  iteratee = optimizeCb(iteratee, context);\n  var i, length;\n  if (isArrayLike(obj)) {\n    for (i = 0, length = obj.length; i < length; i++) {\n      iteratee(obj[i], i, obj);\n    }\n  } else {\n    var _keys = keys(obj);\n    for (i = 0, length = _keys.length; i < length; i++) {\n      iteratee(obj[_keys[i]], _keys[i], obj);\n    }\n  }\n  return obj;\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Return the results of applying the iteratee to each element.\nexport default function map(obj, iteratee, context) {\n  iteratee = cb(iteratee, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length,\n      results = Array(length);\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    results[index] = iteratee(obj[currentKey], currentKey, obj);\n  }\n  return results;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\nimport optimizeCb from './_optimizeCb.js';\n\n// Internal helper to create a reducing function, iterating left or right.\nexport default function createReduce(dir) {\n  // Wrap code that reassigns argument variables in a separate function than\n  // the one that accesses `arguments.length` to avoid a perf hit. (#1991)\n  var reducer = function(obj, iteratee, memo, initial) {\n    var _keys = !isArrayLike(obj) && keys(obj),\n        length = (_keys || obj).length,\n        index = dir > 0 ? 0 : length - 1;\n    if (!initial) {\n      memo = obj[_keys ? _keys[index] : index];\n      index += dir;\n    }\n    for (; index >= 0 && index < length; index += dir) {\n      var currentKey = _keys ? _keys[index] : index;\n      memo = iteratee(memo, obj[currentKey], currentKey, obj);\n    }\n    return memo;\n  };\n\n  return function(obj, iteratee, memo, context) {\n    var initial = arguments.length >= 3;\n    return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);\n  };\n}\n","import createReduce from './_createReduce.js';\n\n// **Reduce** builds up a single result from a list of values, aka `inject`,\n// or `foldl`.\nexport default createReduce(1);\n","import createReduce from './_createReduce.js';\n\n// The right-associative version of reduce, also known as `foldr`.\nexport default createReduce(-1);\n","import cb from './_cb.js';\nimport each from './each.js';\n\n// Return all the elements that pass a truth test.\nexport default function filter(obj, predicate, context) {\n  var results = [];\n  predicate = cb(predicate, context);\n  each(obj, function(value, index, list) {\n    if (predicate(value, index, list)) results.push(value);\n  });\n  return results;\n}\n","import filter from './filter.js';\nimport negate from './negate.js';\nimport cb from './_cb.js';\n\n// Return all the elements for which a truth test fails.\nexport default function reject(obj, predicate, context) {\n  return filter(obj, negate(cb(predicate)), context);\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Determine whether all of the elements pass a truth test.\nexport default function every(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length;\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    if (!predicate(obj[currentKey], currentKey, obj)) return false;\n  }\n  return true;\n}\n","import cb from './_cb.js';\nimport isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Determine if at least one element in the object passes a truth test.\nexport default function some(obj, predicate, context) {\n  predicate = cb(predicate, context);\n  var _keys = !isArrayLike(obj) && keys(obj),\n      length = (_keys || obj).length;\n  for (var index = 0; index < length; index++) {\n    var currentKey = _keys ? _keys[index] : index;\n    if (predicate(obj[currentKey], currentKey, obj)) return true;\n  }\n  return false;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport indexOf from './indexOf.js';\n\n// Determine if the array or object contains a given item (using `===`).\nexport default function contains(obj, item, fromIndex, guard) {\n  if (!isArrayLike(obj)) obj = values(obj);\n  if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n  return indexOf(obj, item, fromIndex) >= 0;\n}\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport map from './map.js';\nimport deepGet from './_deepGet.js';\nimport toPath from './_toPath.js';\n\n// Invoke a method (with arguments) on every item in a collection.\nexport default restArguments(function(obj, path, args) {\n  var contextPath, func;\n  if (isFunction(path)) {\n    func = path;\n  } else {\n    path = toPath(path);\n    contextPath = path.slice(0, -1);\n    path = path[path.length - 1];\n  }\n  return map(obj, function(context) {\n    var method = func;\n    if (!method) {\n      if (contextPath && contextPath.length) {\n        context = deepGet(context, contextPath);\n      }\n      if (context == null) return void 0;\n      method = context[path];\n    }\n    return method == null ? method : method.apply(context, args);\n  });\n});\n","import map from './map.js';\nimport property from './property.js';\n\n// Convenience version of a common use case of `_.map`: fetching a property.\nexport default function pluck(obj, key) {\n  return map(obj, property(key));\n}\n","import filter from './filter.js';\nimport matcher from './matcher.js';\n\n// Convenience version of a common use case of `_.filter`: selecting only\n// objects containing specific `key:value` pairs.\nexport default function where(obj, attrs) {\n  return filter(obj, matcher(attrs));\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport cb from './_cb.js';\nimport each from './each.js';\n\n// Return the maximum element (or element-based computation).\nexport default function max(obj, iteratee, context) {\n  var result = -Infinity, lastComputed = -Infinity,\n      value, computed;\n  if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n    obj = isArrayLike(obj) ? obj : values(obj);\n    for (var i = 0, length = obj.length; i < length; i++) {\n      value = obj[i];\n      if (value != null && value > result) {\n        result = value;\n      }\n    }\n  } else {\n    iteratee = cb(iteratee, context);\n    each(obj, function(v, index, list) {\n      computed = iteratee(v, index, list);\n      if (computed > lastComputed || (computed === -Infinity && result === -Infinity)) {\n        result = v;\n        lastComputed = computed;\n      }\n    });\n  }\n  return result;\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport cb from './_cb.js';\nimport each from './each.js';\n\n// Return the minimum element (or element-based computation).\nexport default function min(obj, iteratee, context) {\n  var result = Infinity, lastComputed = Infinity,\n      value, computed;\n  if (iteratee == null || (typeof iteratee == 'number' && typeof obj[0] != 'object' && obj != null)) {\n    obj = isArrayLike(obj) ? obj : values(obj);\n    for (var i = 0, length = obj.length; i < length; i++) {\n      value = obj[i];\n      if (value != null && value < result) {\n        result = value;\n      }\n    }\n  } else {\n    iteratee = cb(iteratee, context);\n    each(obj, function(v, index, list) {\n      computed = iteratee(v, index, list);\n      if (computed < lastComputed || (computed === Infinity && result === Infinity)) {\n        result = v;\n        lastComputed = computed;\n      }\n    });\n  }\n  return result;\n}\n","import isArray from './isArray.js';\nimport { slice } from './_setup.js';\nimport isString from './isString.js';\nimport isArrayLike from './_isArrayLike.js';\nimport map from './map.js';\nimport identity from './identity.js';\nimport values from './values.js';\n\n// Safely create a real, live array from anything iterable.\nvar reStrSymbol = /[^\\ud800-\\udfff]|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff]/g;\nexport default function toArray(obj) {\n  if (!obj) return [];\n  if (isArray(obj)) return slice.call(obj);\n  if (isString(obj)) {\n    // Keep surrogate pair characters together.\n    return obj.match(reStrSymbol);\n  }\n  if (isArrayLike(obj)) return map(obj, identity);\n  return values(obj);\n}\n","import isArrayLike from './_isArrayLike.js';\nimport values from './values.js';\nimport getLength from './_getLength.js';\nimport random from './random.js';\nimport toArray from './toArray.js';\n\n// Sample **n** random values from a collection using the modern version of the\n// [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n// If **n** is not specified, returns a single random element.\n// The internal `guard` argument allows it to work with `_.map`.\nexport default function sample(obj, n, guard) {\n  if (n == null || guard) {\n    if (!isArrayLike(obj)) obj = values(obj);\n    return obj[random(obj.length - 1)];\n  }\n  var sample = toArray(obj);\n  var length = getLength(sample);\n  n = Math.max(Math.min(n, length), 0);\n  var last = length - 1;\n  for (var index = 0; index < n; index++) {\n    var rand = random(index, last);\n    var temp = sample[index];\n    sample[index] = sample[rand];\n    sample[rand] = temp;\n  }\n  return sample.slice(0, n);\n}\n","import sample from './sample.js';\n\n// Shuffle a collection.\nexport default function shuffle(obj) {\n  return sample(obj, Infinity);\n}\n","import cb from './_cb.js';\nimport pluck from './pluck.js';\nimport map from './map.js';\n\n// Sort the object's values by a criterion produced by an iteratee.\nexport default function sortBy(obj, iteratee, context) {\n  var index = 0;\n  iteratee = cb(iteratee, context);\n  return pluck(map(obj, function(value, key, list) {\n    return {\n      value: value,\n      index: index++,\n      criteria: iteratee(value, key, list)\n    };\n  }).sort(function(left, right) {\n    var a = left.criteria;\n    var b = right.criteria;\n    if (a !== b) {\n      if (a > b || a === void 0) return 1;\n      if (a < b || b === void 0) return -1;\n    }\n    return left.index - right.index;\n  }), 'value');\n}\n","import cb from './_cb.js';\nimport each from './each.js';\n\n// An internal function used for aggregate \"group by\" operations.\nexport default function group(behavior, partition) {\n  return function(obj, iteratee, context) {\n    var result = partition ? [[], []] : {};\n    iteratee = cb(iteratee, context);\n    each(obj, function(value, index) {\n      var key = iteratee(value, index, obj);\n      behavior(result, value, key);\n    });\n    return result;\n  };\n}\n","import group from './_group.js';\nimport has from './_has.js';\n\n// Groups the object's values by a criterion. Pass either a string attribute\n// to group by, or a function that returns the criterion.\nexport default group(function(result, value, key) {\n  if (has(result, key)) result[key].push(value); else result[key] = [value];\n});\n","import group from './_group.js';\n\n// Indexes the object's values by a criterion, similar to `_.groupBy`, but for\n// when you know that your index values will be unique.\nexport default group(function(result, value, key) {\n  result[key] = value;\n});\n","import group from './_group.js';\nimport has from './_has.js';\n\n// Counts instances of an object that group by a certain criterion. Pass\n// either a string attribute to count by, or a function that returns the\n// criterion.\nexport default group(function(result, value, key) {\n  if (has(result, key)) result[key]++; else result[key] = 1;\n});\n","import group from './_group.js';\n\n// Split a collection into two arrays: one whose elements all pass the given\n// truth test, and one whose elements all do not pass the truth test.\nexport default group(function(result, value, pass) {\n  result[pass ? 0 : 1].push(value);\n}, true);\n","import isArrayLike from './_isArrayLike.js';\nimport keys from './keys.js';\n\n// Return the number of elements in a collection.\nexport default function size(obj) {\n  if (obj == null) return 0;\n  return isArrayLike(obj) ? obj.length : keys(obj).length;\n}\n","// Internal `_.pick` helper function to determine whether `key` is an enumerable\n// property name of `obj`.\nexport default function keyInObj(value, key, obj) {\n  return key in obj;\n}\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport optimizeCb from './_optimizeCb.js';\nimport allKeys from './allKeys.js';\nimport keyInObj from './_keyInObj.js';\nimport flatten from './_flatten.js';\n\n// Return a copy of the object only containing the allowed properties.\nexport default restArguments(function(obj, keys) {\n  var result = {}, iteratee = keys[0];\n  if (obj == null) return result;\n  if (isFunction(iteratee)) {\n    if (keys.length > 1) iteratee = optimizeCb(iteratee, keys[1]);\n    keys = allKeys(obj);\n  } else {\n    iteratee = keyInObj;\n    keys = flatten(keys, false, false);\n    obj = Object(obj);\n  }\n  for (var i = 0, length = keys.length; i < length; i++) {\n    var key = keys[i];\n    var value = obj[key];\n    if (iteratee(value, key, obj)) result[key] = value;\n  }\n  return result;\n});\n","import restArguments from './restArguments.js';\nimport isFunction from './isFunction.js';\nimport negate from './negate.js';\nimport map from './map.js';\nimport flatten from './_flatten.js';\nimport contains from './contains.js';\nimport pick from './pick.js';\n\n// Return a copy of the object without the disallowed properties.\nexport default restArguments(function(obj, keys) {\n  var iteratee = keys[0], context;\n  if (isFunction(iteratee)) {\n    iteratee = negate(iteratee);\n    if (keys.length > 1) context = keys[1];\n  } else {\n    keys = map(flatten(keys, false, false), String);\n    iteratee = function(value, key) {\n      return !contains(keys, key);\n    };\n  }\n  return pick(obj, iteratee, context);\n});\n","import { slice } from './_setup.js';\n\n// Returns everything but the last entry of the array. Especially useful on\n// the arguments object. Passing **n** will return all the values in\n// the array, excluding the last N.\nexport default function initial(array, n, guard) {\n  return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n}\n","import initial from './initial.js';\n\n// Get the first element of an array. Passing **n** will return the first N\n// values in the array. The **guard** check allows it to work with `_.map`.\nexport default function first(array, n, guard) {\n  if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n  if (n == null || guard) return array[0];\n  return initial(array, array.length - n);\n}\n","import { slice } from './_setup.js';\n\n// Returns everything but the first entry of the `array`. Especially useful on\n// the `arguments` object. Passing an **n** will return the rest N values in the\n// `array`.\nexport default function rest(array, n, guard) {\n  return slice.call(array, n == null || guard ? 1 : n);\n}\n","import rest from './rest.js';\n\n// Get the last element of an array. Passing **n** will return the last N\n// values in the array.\nexport default function last(array, n, guard) {\n  if (array == null || array.length < 1) return n == null || guard ? void 0 : [];\n  if (n == null || guard) return array[array.length - 1];\n  return rest(array, Math.max(0, array.length - n));\n}\n","import filter from './filter.js';\n\n// Trim out all falsy values from an array.\nexport default function compact(array) {\n  return filter(array, Boolean);\n}\n","import _flatten from './_flatten.js';\n\n// Flatten out an array, either recursively (by default), or up to `depth`.\n// Passing `true` or `false` as `depth` means `1` or `Infinity`, respectively.\nexport default function flatten(array, depth) {\n  return _flatten(array, depth, false);\n}\n","import restArguments from './restArguments.js';\nimport flatten from './_flatten.js';\nimport filter from './filter.js';\nimport contains from './contains.js';\n\n// Take the difference between one array and a number of other arrays.\n// Only the elements present in just the first array will remain.\nexport default restArguments(function(array, rest) {\n  rest = flatten(rest, true, true);\n  return filter(array, function(value){\n    return !contains(rest, value);\n  });\n});\n","import restArguments from './restArguments.js';\nimport difference from './difference.js';\n\n// Return a version of the array that does not contain the specified value(s).\nexport default restArguments(function(array, otherArrays) {\n  return difference(array, otherArrays);\n});\n","import isBoolean from './isBoolean.js';\nimport cb from './_cb.js';\nimport getLength from './_getLength.js';\nimport contains from './contains.js';\n\n// Produce a duplicate-free version of the array. If the array has already\n// been sorted, you have the option of using a faster algorithm.\n// The faster algorithm will not work with an iteratee if the iteratee\n// is not a one-to-one function, so providing an iteratee will disable\n// the faster algorithm.\nexport default function uniq(array, isSorted, iteratee, context) {\n  if (!isBoolean(isSorted)) {\n    context = iteratee;\n    iteratee = isSorted;\n    isSorted = false;\n  }\n  if (iteratee != null) iteratee = cb(iteratee, context);\n  var result = [];\n  var seen = [];\n  for (var i = 0, length = getLength(array); i < length; i++) {\n    var value = array[i],\n        computed = iteratee ? iteratee(value, i, array) : value;\n    if (isSorted && !iteratee) {\n      if (!i || seen !== computed) result.push(value);\n      seen = computed;\n    } else if (iteratee) {\n      if (!contains(seen, computed)) {\n        seen.push(computed);\n        result.push(value);\n      }\n    } else if (!contains(result, value)) {\n      result.push(value);\n    }\n  }\n  return result;\n}\n","import restArguments from './restArguments.js';\nimport uniq from './uniq.js';\nimport flatten from './_flatten.js';\n\n// Produce an array that contains the union: each distinct element from all of\n// the passed-in arrays.\nexport default restArguments(function(arrays) {\n  return uniq(flatten(arrays, true, true));\n});\n","import getLength from './_getLength.js';\nimport contains from './contains.js';\n\n// Produce an array that contains every item shared between all the\n// passed-in arrays.\nexport default function intersection(array) {\n  var result = [];\n  var argsLength = arguments.length;\n  for (var i = 0, length = getLength(array); i < length; i++) {\n    var item = array[i];\n    if (contains(result, item)) continue;\n    var j;\n    for (j = 1; j < argsLength; j++) {\n      if (!contains(arguments[j], item)) break;\n    }\n    if (j === argsLength) result.push(item);\n  }\n  return result;\n}\n","import max from './max.js';\nimport getLength from './_getLength.js';\nimport pluck from './pluck.js';\n\n// Complement of zip. Unzip accepts an array of arrays and groups\n// each array's elements on shared indices.\nexport default function unzip(array) {\n  var length = (array && max(array, getLength).length) || 0;\n  var result = Array(length);\n\n  for (var index = 0; index < length; index++) {\n    result[index] = pluck(array, index);\n  }\n  return result;\n}\n","import restArguments from './restArguments.js';\nimport unzip from './unzip.js';\n\n// Zip together multiple lists into a single array -- elements that share\n// an index go together.\nexport default restArguments(unzip);\n","import getLength  from './_getLength.js';\n\n// Converts lists into objects. Pass either a single array of `[key, value]`\n// pairs, or two parallel arrays of the same length -- one of keys, and one of\n// the corresponding values. Passing by pairs is the reverse of `_.pairs`.\nexport default function object(list, values) {\n  var result = {};\n  for (var i = 0, length = getLength(list); i < length; i++) {\n    if (values) {\n      result[list[i]] = values[i];\n    } else {\n      result[list[i][0]] = list[i][1];\n    }\n  }\n  return result;\n}\n","// Generate an integer Array containing an arithmetic progression. A port of\n// the native Python `range()` function. See\n// [the Python documentation](https://docs.python.org/library/functions.html#range).\nexport default function range(start, stop, step) {\n  if (stop == null) {\n    stop = start || 0;\n    start = 0;\n  }\n  if (!step) {\n    step = stop < start ? -1 : 1;\n  }\n\n  var length = Math.max(Math.ceil((stop - start) / step), 0);\n  var range = Array(length);\n\n  for (var idx = 0; idx < length; idx++, start += step) {\n    range[idx] = start;\n  }\n\n  return range;\n}\n","import { slice } from './_setup.js';\n\n// Chunk a single array into multiple arrays, each containing `count` or fewer\n// items.\nexport default function chunk(array, count) {\n  if (count == null || count < 1) return [];\n  var result = [];\n  var i = 0, length = array.length;\n  while (i < length) {\n    result.push(slice.call(array, i, i += count));\n  }\n  return result;\n}\n","import _ from './underscore.js';\n\n// Helper function to continue chaining intermediate results.\nexport default function chainResult(instance, obj) {\n  return instance._chain ? _(obj).chain() : obj;\n}\n","import _ from './underscore.js';\nimport each from './each.js';\nimport functions from './functions.js';\nimport { push } from './_setup.js';\nimport chainResult from './_chainResult.js';\n\n// Add your own custom functions to the Underscore object.\nexport default function mixin(obj) {\n  each(functions(obj), function(name) {\n    var func = _[name] = obj[name];\n    _.prototype[name] = function() {\n      var args = [this._wrapped];\n      push.apply(args, arguments);\n      return chainResult(this, func.apply(_, args));\n    };\n  });\n  return _;\n}\n","import _ from './underscore.js';\nimport each from './each.js';\nimport { ArrayProto } from './_setup.js';\nimport chainResult from './_chainResult.js';\n\n// Add all mutator `Array` functions to the wrapper.\neach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n  var method = ArrayProto[name];\n  _.prototype[name] = function() {\n    var obj = this._wrapped;\n    if (obj != null) {\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) {\n        delete obj[0];\n      }\n    }\n    return chainResult(this, obj);\n  };\n});\n\n// Add all accessor `Array` functions to the wrapper.\neach(['concat', 'join', 'slice'], function(name) {\n  var method = ArrayProto[name];\n  _.prototype[name] = function() {\n    var obj = this._wrapped;\n    if (obj != null) obj = method.apply(obj, arguments);\n    return chainResult(this, obj);\n  };\n});\n\nexport default _;\n","// Default Export\n// ==============\n// In this module, we mix our bundled exports into the `_` object and export\n// the result. This is analogous to setting `module.exports = _` in CommonJS.\n// Hence, this module is also the entry point of our UMD bundle and the package\n// entry point for CommonJS and AMD users. In other words, this is (the source\n// of) the module you are interfacing with when you do any of the following:\n//\n// ```js\n// // CommonJS\n// var _ = require('underscore');\n//\n// // AMD\n// define(['underscore'], function(_) {...});\n//\n// // UMD in the browser\n// // _ is available as a global variable\n// ```\nimport * as allExports from './index.js';\nimport { mixin } from './index.js';\n\n// Add all of the Underscore functions to the wrapper object.\nvar _ = mixin(allExports);\n// Legacy Node.js API.\n_._ = _;\n// Export the Underscore API.\nexport default _;\n"],"names":["root","self","g","global","_","$","exports","Backbone","previousBackbone","slice","Array","prototype","VERSION","noConflict","this","emulateHTTP","emulateJSON","_listening","Events","eventSplitter","eventsApi","iteratee","events","name","callback","opts","names","i","context","keys","length","test","split","on","_events","onApi","ctx","listening","_listeners","id","interop","listenTo","obj","_listenId","uniqueId","listeningTo","_listeningTo","Listening","error","tryCatchOn","options","handlers","count","push","e","off","offApi","listeners","stopListening","ids","isEmpty","remaining","j","handler","_callback","cleanup","once","onceMap","bind","listenToOnce","map","offer","apply","arguments","trigger","Math","max","args","triggerApi","objEvents","allEvents","all","triggerEvents","concat","ev","l","a1","a2","a3","call","listener","unbind","extend","Model","attributes","attrs","preinitialize","cid","cidPrefix","collection","parse","defaults","result","set","changed","initialize","validationError","idAttribute","toJSON","clone","sync","get","attr","escape","has","matches","key","val","_validate","unset","silent","changes","changing","_changing","_previousAttributes","current","prev","isEqual","prevId","_pending","clear","hasChanged","changedAttributes","diff","old","previous","previousAttributes","fetch","model","success","resp","serverAttrs","wrapError","save","wait","validate","method","isNew","patch","xhr","destroy","defer","url","base","urlError","replace","encodeURIComponent","constructor","isValid","Collection","models","comparator","_reset","reset","setOptions","add","remove","merge","addOptions","splice","array","insert","at","min","tail","singular","isArray","removed","_removeModels","added","merged","_isModel","toAdd","toMerge","toRemove","modelMap","sort","sortable","sortAttr","isString","existing","_prepareModel","_addReference","orderChanged","some","m","index","_removeReference","previousModels","pop","unshift","shift","_byId","modelId","where","first","findWhere","Error","isFunction","sortBy","pluck","create","callbackOpts","_forwardPristineError","values","CollectionIterator","ITERATOR_VALUES","ITERATOR_KEYS","entries","ITERATOR_KEYSVALUES","indexOf","_onModelEvent","event","$$iterator","Symbol","iterator","kind","_collection","_kind","_index","next","value","done","View","pick","viewOptions","_ensureElement","delegateEventSplitter","tagName","selector","$el","find","render","_removeElement","setElement","element","undelegateEvents","_setElement","delegateEvents","el","match","delegate","eventName","undelegate","_createElement","document","createElement","className","_setAttributes","addMethod","attribute","cb","defaultVal","addUnderscoreMethods","Class","methods","each","instance","isObject","modelMatcher","matcher","collectionMethods","forEach","collect","reduce","foldl","inject","reduceRight","foldr","detect","filter","select","reject","every","any","include","includes","contains","invoke","toArray","size","head","take","initial","rest","drop","last","without","difference","shuffle","lastIndexOf","chain","sample","partition","groupBy","countBy","indexBy","findIndex","findLastIndex","modelMethods","pairs","invert","omit","config","Base","mixin","mappings","functions","memo","type","methodMap","params","dataType","data","contentType","JSON","stringify","_method","beforeSend","setRequestHeader","processData","textStatus","errorThrown","ajax","Router","routes","_bindRoutes","optionalParam","namedParam","splatParam","escapeRegExp","route","isRegExp","_routeToRegExp","router","history","fragment","_extractParameters","execute","navigate","optional","RegExp","exec","param","decodeURIComponent","History","checkUrl","window","location","routeStripper","rootStripper","pathStripper","started","interval","atRoot","pathname","getSearch","matchRoot","decodeFragment","decodeURI","href","getHash","getPath","path","charAt","getFragment","_usePushState","_wantsHashChange","start","_trailingSlash","trailingSlash","hashChange","_hasHashChange","documentMode","_useHashChange","_wantsPushState","pushState","_hasPushState","rootPath","iframe","src","style","display","tabIndex","body","iWindow","insertBefore","firstChild","contentWindow","open","close","hash","addEventListener","attachEvent","_checkUrlInterval","setInterval","loadUrl","stop","removeEventListener","detachEvent","removeChild","clearInterval","notfound","decodedFragment","title","assign","_updateHash","protoProps","staticProps","child","parent","__super__","_debug","factory","Function","ArrayProto","ObjProto","Object","SymbolProto","toString","hasOwnProperty","supportsArrayBuffer","ArrayBuffer","supportsDataView","DataView","nativeIsArray","nativeKeys","nativeCreate","nativeIsView","isView","_isNaN","isNaN","_isFinite","isFinite","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","MAX_ARRAY_INDEX","pow","restArguments","func","startIndex","isNull","isUndefined","isBoolean","isElement","nodeType","tagTester","tag","nodelist","childNodes","Int8Array","hasStringTagBug","isIE11","Map","isDataView","getInt8","isArrayBuffer","buffer","isArguments","isSymbol","parseFloat","isNumber","constant","createSizePropertyCheck","getSizeProperty","sizeProperty","shallowProperty","typedArrayPattern","collectNonEnumProps","emulatedSet","nonEnumIdx","proto","prop","isMatch","object","_keys","_wrapped","toBufferView","bufferSource","Uint8Array","byteOffset","valueOf","String","tagDataView","eq","a","b","aStack","bStack","deepEq","areArrays","aCtor","bCtor","allKeys","ie11fingerprint","weakMapMethods","forEachName","commonInit","mapTail","mapMethods","setMethods","createAssigner","keysFunc","source","baseCreate","Ctor","props","extendOwn","tap","interceptor","toPath","deepGet","defaultValue","identity","property","optimizeCb","argCount","accumulator","baseIteratee","Infinity","mapObject","results","currentKey","noop","propertyOf","times","n","accum","random","floor","Date","now","getTime","createEscaper","escaper","join","testRegexp","replaceRegexp","string","templateSettings","evaluate","interpolate","noMatch","escapes","escapeChar","bareIdentifier","template","text","settings","oldSettings","offset","argument","variable","fallback","idCounter","prefix","_chain","executeBound","sourceFunc","boundFunc","callingContext","partial","boundArgs","placeholder","bound","position","TypeError","callArgs","flatten","input","depth","strict","output","idx","len","memoize","hasher","cache","address","setTimeout","delay","throttle","timeout","later","leading","throttled","_now","clearTimeout","trailing","cancel","debounce","immediate","passed","debounced","_args","wrap","wrapper","negate","predicate","compose","after","before","findKey","createPredicateIndexFinder","dir","sortedIndex","low","high","mid","createIndexFinder","predicateFind","item","createReduce","reducer","list","fromIndex","guard","contextPath","computed","lastComputed","v","reStrSymbol","rand","temp","criteria","left","right","group","behavior","pass","keyInObj","compact","Boolean","otherArrays","uniq","isSorted","seen","arrays","intersection","argsLength","unzip","range","step","ceil","chunk","chainResult"],"sourceRoot":""}