@converse/skeletor 0.0.3 → 0.0.6

package/dist/skeletor.js~

@@ -1,2291 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('lodash-es/create'), require('lodash-es/extend'), require('lodash-es/has'), require('lodash-es/result'), require('lodash-es/uniqueId'), require('lodash-es/isEmpty'), require('lodash-es/clone'), require('lodash-es/defaults'), require('lodash-es/defer'), require('lodash-es/escape'), require('lodash-es/invert'), require('lodash-es/isElement'), require('lodash-es/isEqual'), require('lodash-es/isFunction'), require('lodash-es/iteratee'), require('lodash-es/omit'), require('lodash-es/pick'), require('lodash-es/countBy'), require('lodash-es/difference'), require('lodash-es/every'), require('lodash-es/findIndex'), require('lodash-es/findLastIndex'), require('lodash-es/groupBy'), require('lodash-es/indexOf'), require('lodash-es/isString'), require('lodash-es/keyBy'), require('lodash-es/lastIndexOf'), require('lodash-es/some'), require('lodash-es/sortBy'), require('lodash-es/isRegExp'), require('lit-html')) :
-    typeof define === 'function' && define.amd ? define(['lodash-es/create', 'lodash-es/extend', 'lodash-es/has', 'lodash-es/result', 'lodash-es/uniqueId', 'lodash-es/isEmpty', 'lodash-es/clone', 'lodash-es/defaults', 'lodash-es/defer', 'lodash-es/escape', 'lodash-es/invert', 'lodash-es/isElement', 'lodash-es/isEqual', 'lodash-es/isFunction', 'lodash-es/iteratee', 'lodash-es/omit', 'lodash-es/pick', 'lodash-es/countBy', 'lodash-es/difference', 'lodash-es/every', 'lodash-es/findIndex', 'lodash-es/findLastIndex', 'lodash-es/groupBy', 'lodash-es/indexOf', 'lodash-es/isString', 'lodash-es/keyBy', 'lodash-es/lastIndexOf', 'lodash-es/some', 'lodash-es/sortBy', 'lodash-es/isRegExp', 'lit-html'], factory) :
-    (global = global || self, global.skeletor = factory(global.create, global.extend, global.has, global.result, global.uniqueId, global.isEmpty, global.clone, global.defaults, global.defer, global.escape, global.invert, global.isElement, global.isEqual, global.isFunction, global.iteratee, global.omit, global.pick, global.countBy, global.difference, global.every, global.findIndex, global.findLastIndex, global.groupBy, global.indexOf$1, global.isString, global.keyBy, global.lastIndexOf, global.some, global.sortBy, global.isRegExp, global.render));
-}(this, (function (create, extend, has, result, uniqueId, isEmpty, clone, defaults, defer, escape, invert, isElement, isEqual, isFunction, iteratee, omit, pick, countBy, difference, every, findIndex, findLastIndex, groupBy, indexOf$1, isString, keyBy, lastIndexOf, some, sortBy, isRegExp, render) { 'use strict';
-
-    debugger;
-    create = create && Object.prototype.hasOwnProperty.call(create, 'default') ? create['default'] : create;
-    extend = extend && Object.prototype.hasOwnProperty.call(extend, 'default') ? extend['default'] : extend;
-    has = has && Object.prototype.hasOwnProperty.call(has, 'default') ? has['default'] : has;
-    result = result && Object.prototype.hasOwnProperty.call(result, 'default') ? result['default'] : result;
-    uniqueId = uniqueId && Object.prototype.hasOwnProperty.call(uniqueId, 'default') ? uniqueId['default'] : uniqueId;
-    isEmpty = isEmpty && Object.prototype.hasOwnProperty.call(isEmpty, 'default') ? isEmpty['default'] : isEmpty;
-    clone = clone && Object.prototype.hasOwnProperty.call(clone, 'default') ? clone['default'] : clone;
-    defaults = defaults && Object.prototype.hasOwnProperty.call(defaults, 'default') ? defaults['default'] : defaults;
-    defer = defer && Object.prototype.hasOwnProperty.call(defer, 'default') ? defer['default'] : defer;
-    escape = escape && Object.prototype.hasOwnProperty.call(escape, 'default') ? escape['default'] : escape;
-    invert = invert && Object.prototype.hasOwnProperty.call(invert, 'default') ? invert['default'] : invert;
-    isElement = isElement && Object.prototype.hasOwnProperty.call(isElement, 'default') ? isElement['default'] : isElement;
-    isEqual = isEqual && Object.prototype.hasOwnProperty.call(isEqual, 'default') ? isEqual['default'] : isEqual;
-    isFunction = isFunction && Object.prototype.hasOwnProperty.call(isFunction, 'default') ? isFunction['default'] : isFunction;
-    iteratee = iteratee && Object.prototype.hasOwnProperty.call(iteratee, 'default') ? iteratee['default'] : iteratee;
-    omit = omit && Object.prototype.hasOwnProperty.call(omit, 'default') ? omit['default'] : omit;
-    pick = pick && Object.prototype.hasOwnProperty.call(pick, 'default') ? pick['default'] : pick;
-    countBy = countBy && Object.prototype.hasOwnProperty.call(countBy, 'default') ? countBy['default'] : countBy;
-    difference = difference && Object.prototype.hasOwnProperty.call(difference, 'default') ? difference['default'] : difference;
-    every = every && Object.prototype.hasOwnProperty.call(every, 'default') ? every['default'] : every;
-    findIndex = findIndex && Object.prototype.hasOwnProperty.call(findIndex, 'default') ? findIndex['default'] : findIndex;
-    findLastIndex = findLastIndex && Object.prototype.hasOwnProperty.call(findLastIndex, 'default') ? findLastIndex['default'] : findLastIndex;
-    groupBy = groupBy && Object.prototype.hasOwnProperty.call(groupBy, 'default') ? groupBy['default'] : groupBy;
-    indexOf$1 = indexOf$1 && Object.prototype.hasOwnProperty.call(indexOf$1, 'default') ? indexOf$1['default'] : indexOf$1;
-    isString = isString && Object.prototype.hasOwnProperty.call(isString, 'default') ? isString['default'] : isString;
-    keyBy = keyBy && Object.prototype.hasOwnProperty.call(keyBy, 'default') ? keyBy['default'] : keyBy;
-    lastIndexOf = lastIndexOf && Object.prototype.hasOwnProperty.call(lastIndexOf, 'default') ? lastIndexOf['default'] : lastIndexOf;
-    some = some && Object.prototype.hasOwnProperty.call(some, 'default') ? some['default'] : some;
-    sortBy = sortBy && Object.prototype.hasOwnProperty.call(sortBy, 'default') ? sortBy['default'] : sortBy;
-    isRegExp = isRegExp && Object.prototype.hasOwnProperty.call(isRegExp, 'default') ? isRegExp['default'] : isRegExp;
-    render = render && Object.prototype.hasOwnProperty.call(render, 'default') ? render['default'] : render;
-
-    //     (c) 2010-2019 Jeremy Ashkenas and DocumentCloud
-
-    // Helpers
-    // -------
-
-    // Helper function to correctly set up the prototype chain for subclasses.
-    // Similar to `goog.inherits`, but uses a hash of prototype properties and
-    // class properties to be extended.
-    //
-    function inherits(protoProps, staticProps) {
-        const parent = this;
-        let child;
-
-        // The constructor function for the new subclass is either defined by you
-        // (the "constructor" property in your `extend` definition), or defaulted
-        // by us to simply call the parent constructor.
-        if (protoProps && has(protoProps, 'constructor')) {
-            child = protoProps.constructor;
-        } else {
-            child = function(){ return parent.apply(this, arguments); };
-        }
-
-        // Add static properties to the constructor function, if supplied.
-        extend(child, parent, staticProps);
-
-        // Set the prototype chain to inherit from `parent`, without calling
-        // `parent`'s constructor function and add the prototype properties.
-        child.prototype = create(parent.prototype, protoProps);
-        child.prototype.constructor = child;
-
-        // Set a convenience property in case the parent's prototype is needed
-        // later.
-        child.__super__ = parent.prototype;
-
-        return child;
-    }
-
-
-    function getResolveablePromise () {
-        const wrapper = {
-            isResolved: false,
-            isPending: true,
-            isRejected: false
-        };
-        const promise = new Promise((resolve, reject) => {
-            wrapper.resolve = resolve;
-            wrapper.reject = reject;
-        });
-        Object.assign(promise, wrapper);
-        promise.then(
-            function (v) {
-                promise.isResolved = true;
-                promise.isPending = false;
-                promise.isRejected = false;
-                return v;
-            },
-            function (e) {
-                promise.isResolved = false;
-                promise.isPending = false;
-                promise.isRejected = true;
-                throw (e);
-            }
-        );
-        return promise;
-    }
-
-
-    // Throw an error when a URL is needed, and none is supplied.
-    function urlError() {
-        throw new Error('A "url" property or function must be specified');
-    }
-
-    // Wrap an optional error callback with a fallback error event.
-    function wrapError(model, options) {
-        const error = options.error;
-        options.error = function(resp) {
-            if (error) error.call(options.context, model, resp, options);
-            model.trigger('error', model, resp, options);
-        };
-    }
-
-    // Map from CRUD to HTTP for our default `sync` implementation.
-    const methodMap = {
-        create: 'POST',
-        update: 'PUT',
-        patch: 'PATCH',
-        delete: 'DELETE',
-        read: 'GET'
-    };
-
-    function getSyncMethod(model) {
-        const store = result(model, 'browserStorage') || result(model.collection, 'browserStorage');
-        return store ? store.sync() : sync;
-    }
-
-    // sync
-    // ----
-
-    // Override this function to change the manner in which Backbone persists
-    // models to the server. You will be passed the type of request, and the
-    // model in question. By default, makes a RESTful Ajax request
-    // to the model's `url()`. Some possible customizations could be:
-    //
-    // * Use `setTimeout` to batch rapid-fire updates into a single request.
-    // * Send up the models as XML instead of JSON.
-    // * Persist models via WebSockets instead of Ajax.
-    //
-    function sync(method, model, options={}) {
-        const type = methodMap[method];
-
-        // Default JSON-request options.
-        const params = {type: type, dataType: 'json'};
-
-        // Ensure that we have a URL.
-        if (!options.url) {
-            params.url = result(model, 'url') || urlError();
-        }
-
-        // Ensure that we have the appropriate request data.
-        if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
-            params.contentType = 'application/json';
-            params.data = JSON.stringify(options.attrs || model.toJSON(options));
-        }
-
-        // Don't process data on a non-GET request.
-        if (params.type !== 'GET') {
-            params.processData = false;
-        }
-
-        // Pass along `textStatus` and `errorThrown` from jQuery.
-        const error = options.error;
-        options.error = function(xhr, textStatus, errorThrown) {
-            options.textStatus = textStatus;
-            options.errorThrown = errorThrown;
-            if (error) error.call(options.context, xhr, textStatus, errorThrown);
-        };
-
-        // Make the request, allowing the user to override any Ajax options.
-        const xhr = options.xhr = ajax(extend(params, options));
-        model.trigger('request', model, xhr, options);
-        return xhr;
-    }
-
-    function ajax() {
-        return fetch.apply(this, arguments);
-    }
-
-    //     Backbone.js 1.4.0
-
-    const Events = {};
-
-    // Regular expression used to split event strings.
-    const eventSplitter = /\s+/;
-
-    // A private global variable to share between listeners and listenees.
-    let _listening;
-
-    // Iterates over the standard `event, callback` (as well as the fancy multiple
-    // space-separated events `"change blur", callback` and jQuery-style event
-    // maps `{event: callback}`).
-    const eventsApi = function(iteratee, events, name, callback, opts) {
-      let i = 0, names;
-      if (name && typeof name === 'object') {
-        // Handle event maps.
-        if (callback !== undefined && 'context' in opts && opts.context === undefined) opts.context = callback;
-        for (names = Object.keys(name); i < names.length ; i++) {
-          events = eventsApi(iteratee, events, names[i], name[names[i]], opts);
-        }
-      } else if (name && eventSplitter.test(name)) {
-        // Handle space-separated event names by delegating them individually.
-        for (names = name.split(eventSplitter); i < names.length; i++) {
-          events = iteratee(events, names[i], callback, opts);
-        }
-      } else {
-        // Finally, standard events.
-        events = iteratee(events, name, callback, opts);
-      }
-      return events;
-    };
-
-    // Bind an event to a `callback` function. Passing `"all"` will bind
-    // the callback to all events fired.
-    Events.on = function(name, callback, context) {
-      this._events = eventsApi(onApi, this._events || {}, name, callback, {
-        context: context,
-        ctx: this,
-        listening: _listening
-      });
-
-      if (_listening) {
-        const listeners = this._listeners || (this._listeners = {});
-        listeners[_listening.id] = _listening;
-        // Allow the listening to use a counter, instead of tracking
-        // callbacks for library interop
-        _listening.interop = false;
-      }
-
-      return this;
-    };
-
-    // Inversion-of-control versions of `on`. Tell *this* object to listen to
-    // an event in another object... keeping track of what it's listening to
-    // for easier unbinding later.
-    Events.listenTo = function(obj, name, callback) {
-      if (!obj) return this;
-      const id = obj._listenId || (obj._listenId = uniqueId('l'));
-      const listeningTo = this._listeningTo || (this._listeningTo = {});
-      let listening = _listening = listeningTo[id];
-
-      // This object is not listening to any other events on `obj` yet.
-      // Setup the necessary references to track the listening callbacks.
-      if (!listening) {
-        this._listenId || (this._listenId = uniqueId('l'));
-        listening = _listening = listeningTo[id] = new Listening(this, obj);
-      }
-
-      // Bind callbacks on obj.
-      const error = tryCatchOn(obj, name, callback, this);
-      _listening = undefined;
-
-      if (error) throw error;
-      // If the target obj is not Backbone.Events, track events manually.
-      if (listening.interop) listening.on(name, callback);
-
-      return this;
-    };
-
-    // The reducing API that adds a callback to the `events` object.
-    const onApi = function(events, name, callback, options) {
-      if (callback) {
-        const handlers = events[name] || (events[name] = []);
-        const context = options.context, ctx = options.ctx, listening = options.listening;
-        if (listening) listening.count++;
-
-        handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});
-      }
-      return events;
-    };
-
-    // An try-catch guarded #on function, to prevent poisoning the global
-    // `_listening` variable.
-    const tryCatchOn = function(obj, name, callback, context) {
-      try {
-        obj.on(name, callback, context);
-      } catch (e) {
-        return e;
-      }
-    };
-
-    // Remove one or many callbacks. If `context` is null, removes all
-    // callbacks with that function. If `callback` is null, removes all
-    // callbacks for the event. If `name` is null, removes all bound
-    // callbacks for all events.
-    Events.off = function(name, callback, context) {
-      if (!this._events) return this;
-      this._events = eventsApi(offApi, this._events, name, callback, {
-        context: context,
-        listeners: this._listeners
-      });
-
-      return this;
-    };
-
-    // Tell this object to stop listening to either specific events ... or
-    // to every object it's currently listening to.
-    Events.stopListening = function(obj, name, callback) {
-      const listeningTo = this._listeningTo;
-      if (!listeningTo) return this;
-
-      const ids = obj ? [obj._listenId] : Object.keys(listeningTo);
-      for (let i = 0; i < ids.length; i++) {
-        const listening = listeningTo[ids[i]];
-
-        // If listening doesn't exist, this object is not currently
-        // listening to obj. Break out early.
-        if (!listening) break;
-
-        listening.obj.off(name, callback, this);
-        if (listening.interop) listening.off(name, callback);
-      }
-      if (isEmpty(listeningTo)) this._listeningTo = undefined;
-
-      return this;
-    };
-
-    // The reducing API that removes a callback from the `events` object.
-    const offApi = function(events, name, callback, options) {
-      if (!events) return;
-
-      const context = options.context, listeners = options.listeners;
-      let i = 0, names;
-
-      // Delete all event listeners and "drop" events.
-      if (!name && !context && !callback) {
-        for (names = Object.keys(listeners); i < names.length; i++) {
-          listeners[names[i]].cleanup();
-        }
-        return;
-      }
-
-      names = name ? [name] : Object.keys(events);
-      for (; i < names.length; i++) {
-        name = names[i];
-        const handlers = events[name];
-
-        // Bail out if there are no events stored.
-        if (!handlers) {
-          break;
-        }
-
-        // Find any remaining events.
-        const remaining = [];
-        for (let j = 0; j < handlers.length; j++) {
-          const handler = handlers[j];
-          if (
-            callback && callback !== handler.callback &&
-              callback !== handler.callback._callback ||
-                context && context !== handler.context
-          ) {
-            remaining.push(handler);
-          } else {
-            const listening = handler.listening;
-            if (listening) listening.off(name, callback);
-          }
-        }
-
-        // Replace events if there are any remaining.  Otherwise, clean up.
-        if (remaining.length) {
-          events[name] = remaining;
-        } else {
-          delete events[name];
-        }
-      }
-
-      return events;
-    };
-
-    // Bind an event to only be triggered a single time. After the first time
-    // the callback is invoked, its listener will be removed. If multiple events
-    // are passed in using the space-separated syntax, the handler will fire
-    // once for each event, not once for a combination of all events.
-    Events.once = function(name, callback, context) {
-      // Map the event into a `{event: once}` object.
-      const events = eventsApi(onceMap, {}, name, callback, this.off.bind(this));
-      if (typeof name === 'string' && (context === null || context === undefined)) callback = undefined;
-      return this.on(events, callback, context);
-    };
-
-    // Inversion-of-control versions of `once`.
-    Events.listenToOnce = function(obj, name, callback) {
-      // Map the event into a `{event: once}` object.
-      const events = eventsApi(onceMap, {}, name, callback, this.stopListening.bind(this, obj));
-      return this.listenTo(obj, events);
-    };
-
-    // Reduces the event callbacks into a map of `{event: onceWrapper}`.
-    // `offer` unbinds the `onceWrapper` after it has been called.
-    const onceMap = function(map, name, callback, offer) {
-      if (callback) {
-        const once = map[name] = once(function() {
-          offer(name, once);
-          callback.apply(this, arguments);
-        });
-        once._callback = callback;
-      }
-      return map;
-    };
-
-    // Trigger one or many events, firing all bound callbacks. Callbacks are
-    // passed the same arguments as `trigger` is, apart from the event name
-    // (unless you're listening on `"all"`, which will cause your callback to
-    // receive the true name of the event as the first argument).
-    Events.trigger = function(name) {
-      if (!this._events) return this;
-
-      const length = Math.max(0, arguments.length - 1);
-      const args = Array(length);
-      for (let i = 0; i < length; i++) args[i] = arguments[i + 1];
-
-      eventsApi(triggerApi, this._events, name, undefined, args);
-      return this;
-    };
-
-    // Handles triggering the appropriate event callbacks.
-    const triggerApi = function(objEvents, name, callback, args) {
-      if (objEvents) {
-        const events = objEvents[name];
-        let allEvents = objEvents.all;
-        if (events && allEvents) allEvents = allEvents.slice();
-        if (events) triggerEvents(events, args);
-        if (allEvents) triggerEvents(allEvents, [name].concat(args));
-      }
-      return objEvents;
-    };
-
-    // A difficult-to-believe, but optimized internal dispatch function for
-    // triggering events. Tries to keep the usual cases speedy (most internal
-    // Backbone events have 3 arguments).
-    const triggerEvents = function(events, args) {
-      let ev, i = -1;
-      const l = events.length,
-        a1 = args[0],
-        a2 = args[1],
-        a3 = args[2];
-      switch (args.length) {
-        case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
-        case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
-        case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
-        case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
-        default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;
-      }
-    };
-
-    // A listening class that tracks and cleans up memory bindings
-    // when all callbacks have been offed.
-    const Listening = function(listener, obj) {
-      this.id = listener._listenId;
-      this.listener = listener;
-      this.obj = obj;
-      this.interop = true;
-      this.count = 0;
-      this._events = undefined;
-    };
-
-    Listening.prototype.on = Events.on;
-
-    // Offs a callback (or several).
-    // Uses an optimized counter if the listenee uses Backbone.Events.
-    // Otherwise, falls back to manual tracking to support events
-    // library interop.
-    Listening.prototype.off = function(name, callback) {
-      let cleanup;
-      if (this.interop) {
-        this._events = eventsApi(offApi, this._events, name, callback, {
-          context: undefined,
-          listeners: undefined
-        });
-        cleanup = !this._events;
-      } else {
-        this.count--;
-        cleanup = this.count === 0;
-      }
-      if (cleanup) this.cleanup();
-    };
-
-    // Cleans up memory bindings between the listener and the listenee.
-    Listening.prototype.cleanup = function() {
-      delete this.listener._listeningTo[this.obj._listenId];
-      if (!this.interop) delete this.obj._listeners[this.id];
-    };
-
-    // Aliases for backwards compatibility.
-    Events.bind   = Events.on;
-    Events.unbind = Events.off;
-
-    //     Backbone.js 1.4.0
-
-
-    const Model = function(attributes, options) {
-      let attrs = attributes || {};
-      options || (options = {});
-      this.preinitialize.apply(this, arguments);
-      this.cid = uniqueId(this.cidPrefix);
-      this.attributes = {};
-      if (options.collection) this.collection = options.collection;
-      if (options.parse) attrs = this.parse(attrs, options) || {};
-      const default_attrs = result(this, 'defaults');
-      attrs = defaults(extend({}, default_attrs, attrs), default_attrs);
-      this.set(attrs, options);
-      this.changed = {};
-      this.initialize.apply(this, arguments);
-    };
-
-    Model.extend = inherits;
-
-    // Attach all inheritable methods to the Model prototype.
-    Object.assign(Model.prototype, Events, {
-
-      // A hash of attributes whose current and previous value differ.
-      changed: null,
-
-      // The value returned during the last failed validation.
-      validationError: null,
-
-      // The default name for the JSON `id` attribute is `"id"`. MongoDB and
-      // CouchDB users may want to set this to `"_id"`.
-      idAttribute: 'id',
-
-      // The prefix is used to create the client id which is used to identify models locally.
-      // You may want to override this if you're experiencing name clashes with model ids.
-      cidPrefix: 'c',
-
-      // preinitialize is an empty function by default. You can override it with a function
-      // or object.  preinitialize will run before any instantiation logic is run in the Model.
-      preinitialize: function(){},
-
-      // Initialize is an empty function by default. Override it with your own
-      // initialization logic.
-      initialize: function(){},
-
-      // Return a copy of the model's `attributes` object.
-      toJSON: function(options) {
-        return clone(this.attributes);
-      },
-
-      // Proxy `Backbone.sync` by default -- but override this if you need
-      // custom syncing semantics for *this* particular model.
-      sync: function(method, model, options) {
-        return getSyncMethod(this)(method, model, options);
-      },
-
-      // Get the value of an attribute.
-      get: function(attr) {
-        return this.attributes[attr];
-      },
-
-      keys: function() {
-        return Object.keys(this.attributes);
-      },
-
-      values: function() {
-        return Object.values(this.attributes);
-      },
-
-      pairs: function() {
-        return this.entries();
-      },
-
-      entries: function() {
-        return Object.entries(this.attributes);
-      },
-
-      invert: function() {
-        return invert(this.attributes);
-      },
-
-      pick: function(...args) {
-        if (args.length === 1 && Array.isArray(args[0])) {
-          args = args[0];
-        }
-        return pick(this.attributes, args);
-      },
-
-      omit: function(...args) {
-        if (args.length === 1 && Array.isArray(args[0])) {
-          args = args[0];
-        }
-        return omit(this.attributes, args);
-      },
-
-      isEmpty: function() {
-        return isEmpty(this.attributes);
-      },
-
-      // Get the HTML-escaped value of an attribute.
-      escape: function(attr) {
-        return escape(this.get(attr));
-      },
-
-      // Returns `true` if the attribute contains a value that is not null
-      // or undefined.
-      has: function(attr) {
-        return this.get(attr) != null;
-      },
-
-      // Special-cased proxy to lodash's `matches` method.
-      matches: function(attrs) {
-        return !!iteratee(attrs, this)(this.attributes);
-      },
-
-      // Set a hash of model attributes on the object, firing `"change"`. This is
-      // the core primitive operation of a model, updating the data and notifying
-      // anyone who needs to know about the change in state. The heart of the beast.
-      set: function(key, val, options) {
-        if (key == null) return this;
-
-        // Handle both `"key", value` and `{key: value}` -style arguments.
-        let attrs;
-        if (typeof key === 'object') {
-          attrs = key;
-          options = val;
-        } else {
-          (attrs = {})[key] = val;
-        }
-
-        options || (options = {});
-
-        // Run validation.
-        if (!this._validate(attrs, options)) return false;
-
-        // Extract attributes and options.
-        const unset      = options.unset;
-        const silent     = options.silent;
-        const changes    = [];
-        const changing   = this._changing;
-        this._changing = true;
-
-        if (!changing) {
-          this._previousAttributes = clone(this.attributes);
-          this.changed = {};
-        }
-
-        const current = this.attributes;
-        const changed = this.changed;
-        const prev    = this._previousAttributes;
-
-        // For each `set` attribute, update or delete the current value.
-        for (const attr in attrs) {
-          val = attrs[attr];
-          if (!isEqual(current[attr], val)) changes.push(attr);
-          if (!isEqual(prev[attr], val)) {
-            changed[attr] = val;
-          } else {
-            delete changed[attr];
-          }
-          unset ? delete current[attr] : current[attr] = val;
-        }
-
-        // Update the `id`.
-        if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);
-
-        // Trigger all relevant attribute changes.
-        if (!silent) {
-          if (changes.length) this._pending = options;
-          for (let i = 0; i < changes.length; i++) {
-            this.trigger('change:' + changes[i], this, current[changes[i]], options);
-          }
-        }
-
-        // You might be wondering why there's a `while` loop here. Changes can
-        // be recursively nested within `"change"` events.
-        if (changing) return this;
-        if (!silent) {
-          while (this._pending) {
-            options = this._pending;
-            this._pending = false;
-            this.trigger('change', this, options);
-          }
-        }
-        this._pending = false;
-        this._changing = false;
-        return this;
-      },
-
-      // Remove an attribute from the model, firing `"change"`. `unset` is a noop
-      // if the attribute doesn't exist.
-      unset: function(attr, options) {
-        return this.set(attr, undefined, extend({}, options, {unset: true}));
-      },
-
-      // Clear all attributes on the model, firing `"change"`.
-      clear: function(options) {
-        const attrs = {};
-        for (const key in this.attributes) attrs[key] = undefined;
-        return this.set(attrs, extend({}, options, {unset: true}));
-      },
-
-      // Determine if the model has changed since the last `"change"` event.
-      // If you specify an attribute name, determine if that attribute has changed.
-      hasChanged: function(attr) {
-        if (attr == null) return !isEmpty(this.changed);
-        return has(this.changed, attr);
-      },
-
-      // Return an object containing all the attributes that have changed, or
-      // false if there are no changed attributes. Useful for determining what
-      // parts of a view need to be updated and/or what attributes need to be
-      // persisted to the server. Unset attributes will be set to undefined.
-      // You can also pass an attributes object to diff against the model,
-      // determining if there *would be* a change.
-      changedAttributes: function(diff) {
-        if (!diff) return this.hasChanged() ? clone(this.changed) : false;
-        const old = this._changing ? this._previousAttributes : this.attributes;
-        const changed = {};
-        let hasChanged;
-        for (const attr in diff) {
-          const val = diff[attr];
-          if (isEqual(old[attr], val)) continue;
-          changed[attr] = val;
-          hasChanged = true;
-        }
-        return hasChanged ? changed : false;
-      },
-
-      // Get the previous value of an attribute, recorded at the time the last
-      // `"change"` event was fired.
-      previous: function(attr) {
-        if (attr == null || !this._previousAttributes) return null;
-        return this._previousAttributes[attr];
-      },
-
-      // Get all of the attributes of the model at the time of the previous
-      // `"change"` event.
-      previousAttributes: function() {
-        return clone(this._previousAttributes);
-      },
-
-      // Fetch the model from the server, merging the response with the model's
-      // local attributes. Any changed attributes will trigger a "change" event.
-      fetch: function(options) {
-        options = extend({parse: true}, options);
-        const model = this;
-        const success = options.success;
-        options.success = function(resp) {
-          const serverAttrs = options.parse ? model.parse(resp, options) : resp;
-          if (!model.set(serverAttrs, options)) return false;
-          if (success) success.call(options.context, model, resp, options);
-          model.trigger('sync', model, resp, options);
-        };
-        wrapError(this, options);
-        return this.sync('read', this, options);
-      },
-
-      // Set a hash of model attributes, and sync the model to the server.
-      // If the server returns an attributes hash that differs, the model's
-      // state will be `set` again.
-      save: function(key, val, options) {
-        // Handle both `"key", value` and `{key: value}` -style arguments.
-        let attrs;
-        if (key == null || typeof key === 'object') {
-          attrs = key;
-          options = val;
-        } else {
-          (attrs = {})[key] = val;
-        }
-
-        options = extend({validate: true, parse: true}, options);
-        const wait = options.wait;
-        const return_promise = options.promise;
-        const promise = return_promise && getResolveablePromise();
-
-        // If we're not waiting and attributes exist, save acts as
-        // `set(attr).save(null, opts)` with validation. Otherwise, check if
-        // the model will be valid when the attributes, if any, are set.
-        if (attrs && !wait) {
-          if (!this.set(attrs, options)) return false;
-        } else if (!this._validate(attrs, options)) {
-          return false;
-        }
-
-        // After a successful server-side save, the client is (optionally)
-        // updated with the server-side state.
-        const model = this;
-        const success = options.success;
-        const attributes = this.attributes;
-        options.success = function(resp) {
-          // Ensure attributes are restored during synchronous saves.
-          model.attributes = attributes;
-          let serverAttrs = options.parse ? model.parse(resp, options) : resp;
-          if (wait) serverAttrs = extend({}, attrs, serverAttrs);
-          if (serverAttrs && !model.set(serverAttrs, options)) return false;
-          if (success) success.call(options.context, model, resp, options);
-          model.trigger('sync', model, resp, options);
-          if (return_promise) promise.resolve();
-        };
-        wrapError(this, options);
-
-        // Set temporary attributes if `{wait: true}` to properly find new ids.
-        if (attrs && wait) this.attributes = extend({}, attributes, attrs);
-
-        const method = this.isNew() ? 'create' : options.patch ? 'patch' : 'update';
-        if (method === 'patch' && !options.attrs) options.attrs = attrs;
-        const xhr = this.sync(method, this, options);
-
-        // Restore attributes.
-        this.attributes = attributes;
-
-        if (return_promise) {
-          return promise;
-        } else {
-          return xhr;
-        }
-
-      },
-
-      // Destroy this model on the server if it was already persisted.
-      // Optimistically removes the model from its collection, if it has one.
-      // If `wait: true` is passed, waits for the server to respond before removal.
-      destroy: function(options) {
-        options = options ? clone(options) : {};
-        const model = this;
-        const success = options.success;
-        const wait = options.wait;
-
-        const destroy = function() {
-          model.stopListening();
-          model.trigger('destroy', model, model.collection, options);
-        };
-
-        options.success = function(resp) {
-          if (wait) destroy();
-          if (success) success.call(options.context, model, resp, options);
-          if (!model.isNew()) model.trigger('sync', model, resp, options);
-        };
-
-        let xhr = false;
-        if (this.isNew()) {
-          defer(options.success);
-        } else {
-          wrapError(this, options);
-          xhr = this.sync('delete', this, options);
-        }
-        if (!wait) destroy();
-        return xhr;
-      },
-
-      // Default URL for the model's representation on the server -- if you're
-      // using Backbone's restful methods, override this to change the endpoint
-      // that will be called.
-      url: function() {
-        const base =
-          result(this, 'urlRoot') ||
-          result(this.collection, 'url') ||
-          urlError();
-        if (this.isNew()) return base;
-        const id = this.get(this.idAttribute);
-        return base.replace(/[^\/]$/, '$&/') + encodeURIComponent(id);
-      },
-
-      // **parse** converts a response into the hash of attributes to be `set` on
-      // the model. The default implementation is just to pass the response along.
-      parse: function(resp, options) {
-        return resp;
-      },
-
-      // Create a new model with identical attributes to this one.
-      clone: function() {
-        return new this.constructor(this.attributes);
-      },
-
-      // A model is new if it has never been saved to the server, and lacks an id.
-      isNew: function() {
-        return !this.has(this.idAttribute);
-      },
-
-      // Check if the model is currently in a valid state.
-      isValid: function(options) {
-        return this._validate({}, extend({}, options, {validate: true}));
-      },
-
-      // Run validation against the next complete set of model attributes,
-      // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
-      _validate: function(attrs, options) {
-        if (!options.validate || !this.validate) return true;
-        attrs = extend({}, this.attributes, attrs);
-        const error = this.validationError = this.validate(attrs, options) || null;
-        if (!error) return true;
-        this.trigger('invalid', this, error, extend(options, {validationError: error}));
-        return false;
-      }
-    });
-
-    //     Backbone.js 1.4.0
-
-    const slice = Array.prototype.slice;
-
-    // Create a new **Collection**, perhaps to contain a specific type of `model`.
-    // If a `comparator` is specified, the Collection will maintain
-    // its models in sort order, as they're added and removed.
-    const Collection = function(models, options) {
-      options || (options = {});
-      this.preinitialize.apply(this, arguments);
-      if (options.model) this.model = options.model;
-      if (options.comparator !== undefined) this.comparator = options.comparator;
-      this._reset();
-      this.initialize.apply(this, arguments);
-      if (models) this.reset(models, extend({silent: true}, options));
-    };
-
-    Collection.extend = inherits;
-
-
-    // Default options for `Collection#set`.
-    const setOptions = {add: true, remove: true, merge: true};
-    const addOptions = {add: true, remove: false};
-
-    // Splices `insert` into `array` at index `at`.
-    const splice = function(array, insert, at) {
-      at = Math.min(Math.max(at, 0), array.length);
-      const tail = Array(array.length - at);
-      const length = insert.length;
-      let i;
-      for (i = 0; i < tail.length; i++) tail[i] = array[i + at];
-      for (i = 0; i < length; i++) array[i + at] = insert[i];
-      for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];
-    };
-
-    // Define the Collection's inheritable methods.
-    Object.assign(Collection.prototype, Events, {
-
-      // The default model for a collection is just a **Backbone.Model**.
-      // This should be overridden in most cases.
-      model: Model,
-
-
-      // preinitialize is an empty function by default. You can override it with a function
-      // or object.  preinitialize will run before any instantiation logic is run in the Collection.
-      preinitialize: function(){},
-
-      // Initialize is an empty function by default. Override it with your own
-      // initialization logic.
-      initialize: function(){},
-
-      // The JSON representation of a Collection is an array of the
-      // models' attributes.
-      toJSON: function(options) {
-        return this.map(function(model) { return model.toJSON(options); });
-      },
-
-      // Proxy `Backbone.sync` by default.
-      sync: function(method, model, options) {
-        return getSyncMethod(this)(method, model, options);
-      },
-
-      // Add a model, or list of models to the set. `models` may be Backbone
-      // Models or raw JavaScript objects to be converted to Models, or any
-      // combination of the two.
-      add: function(models, options) {
-        return this.set(models, extend({merge: false}, options, addOptions));
-      },
-
-      // Remove a model, or a list of models from the set.
-      remove: function(models, options) {
-        options = extend({}, options);
-        const singular = !Array.isArray(models);
-        models = singular ? [models] : models.slice();
-        const removed = this._removeModels(models, options);
-        if (!options.silent && removed.length) {
-          options.changes = {added: [], merged: [], removed: removed};
-          this.trigger('update', this, options);
-        }
-        return singular ? removed[0] : removed;
-      },
-
-      // Update a collection by `set`-ing a new list of models, adding new ones,
-      // removing models that are no longer present, and merging models that
-      // already exist in the collection, as necessary. Similar to **Model#set**,
-      // the core operation for updating the data contained by the collection.
-      set: function(models, options) {
-        if (models == null) return;
-
-        options = extend({}, setOptions, options);
-        if (options.parse && !this._isModel(models)) {
-          models = this.parse(models, options) || [];
-        }
-
-        const singular = !Array.isArray(models);
-        models = singular ? [models] : models.slice();
-
-        let at = options.at;
-        if (at != null) at = +at;
-        if (at > this.length) at = this.length;
-        if (at < 0) at += this.length + 1;
-
-        const set = [];
-        const toAdd = [];
-        const toMerge = [];
-        const toRemove = [];
-        const modelMap = {};
-
-        const add = options.add;
-        const merge = options.merge;
-        const remove = options.remove;
-
-        let sort = false;
-        const sortable = this.comparator && at == null && options.sort !== false;
-        const sortAttr = isString(this.comparator) ? this.comparator : null;
-
-        // Turn bare objects into model references, and prevent invalid models
-        // from being added.
-        let model, i;
-        for (i = 0; i < models.length; i++) {
-          model = models[i];
-
-          // If a duplicate is found, prevent it from being added and
-          // optionally merge it into the existing model.
-          const existing = this.get(model);
-          if (existing) {
-            if (merge && model !== existing) {
-              let attrs = this._isModel(model) ? model.attributes : model;
-              if (options.parse) attrs = existing.parse(attrs, options);
-              existing.set(attrs, options);
-              toMerge.push(existing);
-              if (sortable && !sort) sort = existing.hasChanged(sortAttr);
-            }
-            if (!modelMap[existing.cid]) {
-              modelMap[existing.cid] = true;
-              set.push(existing);
-            }
-            models[i] = existing;
-
-          // If this is a new, valid model, push it to the `toAdd` list.
-          } else if (add) {
-            model = models[i] = this._prepareModel(model, options);
-            if (model) {
-              toAdd.push(model);
-              this._addReference(model, options);
-              modelMap[model.cid] = true;
-              set.push(model);
-            }
-          }
-        }
-
-        // Remove stale models.
-        if (remove) {
-          for (i = 0; i < this.length; i++) {
-            model = this.models[i];
-            if (!modelMap[model.cid]) toRemove.push(model);
-          }
-          if (toRemove.length) this._removeModels(toRemove, options);
-        }
-
-        // See if sorting is needed, update `length` and splice in new models.
-        let orderChanged = false;
-        const replace = !sortable && add && remove;
-        if (set.length && replace) {
-          orderChanged = this.length !== set.length || some(this.models, (m, index) => m !== set[index]);
-          this.models.length = 0;
-          splice(this.models, set, 0);
-          this.length = this.models.length;
-        } else if (toAdd.length) {
-          if (sortable) sort = true;
-          splice(this.models, toAdd, at == null ? this.length : at);
-          this.length = this.models.length;
-        }
-
-        // Silently sort the collection if appropriate.
-        if (sort) this.sort({silent: true});
-
-        // Unless silenced, it's time to fire all appropriate add/sort/update events.
-        if (!options.silent) {
-          for (i = 0; i < toAdd.length; i++) {
-            if (at != null) options.index = at + i;
-            model = toAdd[i];
-            model.trigger('add', model, this, options);
-          }
-          if (sort || orderChanged) this.trigger('sort', this, options);
-          if (toAdd.length || toRemove.length || toMerge.length) {
-            options.changes = {
-              added: toAdd,
-              removed: toRemove,
-              merged: toMerge
-            };
-            this.trigger('update', this, options);
-          }
-        }
-
-        // Return the added (or merged) model (or models).
-        return singular ? models[0] : models;
-      },
-
-      clearStore: async function(options={}) {
-          await Promise.all(Array.from(this.models).map(m => {
-              return new Promise(
-                  resolve => {
-                      m.destroy(Object.assign(options, {
-                          'success': resolve,
-                          'error': (m, e) => { console.error(e); resolve(); }
-                      }));
-                  }
-              );
-          }));
-          await this.browserStorage.clear();
-          this.reset();
-      },
-
-      // When you have more items than you want to add or remove individually,
-      // you can reset the entire set with a new list of models, without firing
-      // any granular `add` or `remove` events. Fires `reset` when finished.
-      // Useful for bulk operations and optimizations.
-      reset: function(models, options) {
-        options = options ? clone(options) : {};
-        for (let i = 0; i < this.models.length; i++) {
-          this._removeReference(this.models[i], options);
-        }
-        options.previousModels = this.models;
-        this._reset();
-        models = this.add(models, extend({silent: true}, options));
-        if (!options.silent) this.trigger('reset', this, options);
-        return models;
-      },
-
-      // Add a model to the end of the collection.
-      push: function(model, options) {
-        return this.add(model, extend({at: this.length}, options));
-      },
-
-      // Remove a model from the end of the collection.
-      pop: function(options) {
-        const model = this.at(this.length - 1);
-        return this.remove(model, options);
-      },
-
-      // Add a model to the beginning of the collection.
-      unshift: function(model, options) {
-        return this.add(model, extend({at: 0}, options));
-      },
-
-      // Remove a model from the beginning of the collection.
-      shift: function(options) {
-        const model = this.at(0);
-        return this.remove(model, options);
-      },
-
-      // Slice out a sub-array of models from the collection.
-      slice: function() {
-        return slice.apply(this.models, arguments);
-      },
-
-      filter: function(callback, thisArg) {
-        return this.models.filter(
-          isFunction(callback) ? callback : m => m.matches(callback),
-          thisArg
-        );
-      },
-
-      every: function(pred) {
-        return every(this.models.map(m => m.attributes), pred);
-      },
-
-      difference: function(values) {
-        return difference(this.models, values);
-      },
-
-      max: function() {
-        return Math.max.apply(Math, this.models);
-      },
-
-      min: function() {
-        return Math.min.apply(Math, this.models);
-      },
-
-      drop: function(n=1) {
-        return this.models.slice(n);
-      },
-
-      some: function(pred) {
-        return some(this.models.map(m => m.attributes), pred);
-      },
-
-      sortBy: function(iteratee) {
-        return sortBy(
-          this.models,
-          isFunction(iteratee) ? iteratee : m => isString(iteratee) ? m.get(iteratee) : m.matches(iteratee),
-        );
-      },
-
-      isEmpty: function() {
-        return isEmpty(this.models);
-      },
-
-      keyBy: function(iteratee) {
-        return keyBy(this.models, iteratee);
-      },
-
-      each: function(callback, thisArg) {
-        return this.forEach(callback, thisArg);
-      },
-
-      forEach: function(callback, thisArg) {
-        return this.models.forEach(callback, thisArg);
-      },
-
-      includes: function(item) {
-        return this.models.includes(item);
-      },
-
-      size: function() {
-        return this.models.length;
-      },
-
-      countBy: function(f) {
-        return countBy(
-          this.models,
-          isFunction(f) ? f : m => isString(f) ? m.get(f) : m.matches(f),
-        );
-      },
-
-      groupBy: function(pred) {
-        return groupBy(
-          this.models,
-          isFunction(pred) ? pred : m => isString(pred) ? m.get(pred) : m.matches(pred),
-        );
-      },
-
-      indexOf: function(fromIndex) {
-        return indexOf$1(this.models, fromIndex);
-      },
-
-      findLastIndex: function(pred, fromIndex) {
-        return findLastIndex(
-          this.models,
-          isFunction(pred) ? pred : m => isString(pred) ? m.get(pred) : m.matches(pred),
-          fromIndex
-        );
-      },
-
-      lastIndexOf: function(fromIndex) {
-        return lastIndexOf(this.models, fromIndex);
-      },
-
-      findIndex: function(pred) {
-        return findIndex(
-          this.models,
-          isFunction(pred) ? pred : m => isString(pred) ? m.get(pred) : m.matches(pred),
-        );
-      },
-
-      last: function() {
-        const length = this.models == null ? 0 : this.models.length;
-        return length ? this.models[length - 1] : undefined;
-      },
-
-      head: function() {
-        return this.models[0];
-      },
-
-      first: function() {
-        return this.head();
-      },
-
-      map: function(cb, thisArg) {
-        return this.models.map(
-          isFunction(cb) ? cb : m => isString(cb) ? m.get(cb) : m.matches(cb),
-          thisArg
-        );
-      },
-
-      reduce: function(callback, initialValue) {
-        return this.models.reduce(callback, initialValue || this.models[0]);
-      },
-
-      reduceRight: function(callback, initialValue) {
-        return this.models.reduceRight(callback, initialValue || this.models[0]);
-      },
-
-      toArray: function() {
-        return Array.from(this.models);
-      },
-
-      // Get a model from the set by id, cid, model object with id or cid
-      // properties, or an attributes object that is transformed through modelId.
-      get: function(obj) {
-        if (obj == null) return undefined;
-        return this._byId[obj] ||
-          this._byId[this.modelId(this._isModel(obj) ? obj.attributes : obj)] ||
-          obj.cid && this._byId[obj.cid];
-      },
-
-      // Returns `true` if the model is in the collection.
-      has: function(obj) {
-        return this.get(obj) != null;
-      },
-
-      // Get the model at the given index.
-      at: function(index) {
-        if (index < 0) index += this.length;
-        return this.models[index];
-      },
-
-      // Return models with matching attributes. Useful for simple cases of
-      // `filter`.
-      where: function(attrs, first) {
-        return this[first ? 'find' : 'filter'](attrs);
-      },
-
-      // Return the first model with matching attributes. Useful for simple cases
-      // of `find`.
-      findWhere: function(attrs) {
-        return this.where(attrs, true);
-      },
-
-      find: function(predicate, fromIndex) {
-        const pred = isFunction(predicate) ? predicate : m => m.matches(predicate);
-        return this.models.find(pred, fromIndex);
-      },
-
-
-      // Force the collection to re-sort itself. You don't need to call this under
-      // normal circumstances, as the set will maintain sort order as each item
-      // is added.
-      sort: function(options) {
-        let comparator = this.comparator;
-        if (!comparator) throw new Error('Cannot sort a set without a comparator');
-        options || (options = {});
-
-        const length = comparator.length;
-        if (isFunction(comparator)) comparator = comparator.bind(this);
-
-        // Run sort based on type of `comparator`.
-        if (length === 1 || isString(comparator)) {
-          this.models = this.sortBy(comparator);
-        } else {
-          this.models.sort(comparator);
-        }
-        if (!options.silent) this.trigger('sort', this, options);
-        return this;
-      },
-
-      // Pluck an attribute from each model in the collection.
-      pluck: function(attr) {
-        return this.map(attr + '');
-      },
-
-      // Fetch the default set of models for this collection, resetting the
-      // collection when they arrive. If `reset: true` is passed, the response
-      // data will be passed through the `reset` method instead of `set`.
-      fetch: function(options) {
-        options = extend({parse: true}, options);
-        const success = options.success;
-        const collection = this;
-        const promise = options.promise && getResolveablePromise();
-        options.success = function(resp) {
-          const method = options.reset ? 'reset' : 'set';
-          collection[method](resp, options);
-          if (success) success.call(options.context, collection, resp, options);
-          promise && promise.resolve();
-          collection.trigger('sync', collection, resp, options);
-        };
-        wrapError(this, options);
-        return promise ? promise : this.sync('read', this, options);
-      },
-
-      // Create a new instance of a model in this collection. Add the model to the
-      // collection immediately, unless `wait: true` is passed, in which case we
-      // wait for the server to agree.
-      create: function(model, options) {
-        options = options ? clone(options) : {};
-        const wait = options.wait;
-        const return_promise = options.promise;
-        const promise = return_promise && getResolveablePromise();
-
-        model = this._prepareModel(model, options);
-        if (!model) return false;
-        if (!wait) this.add(model, options);
-        const collection = this;
-        const success = options.success;
-        options.success = function(m, resp, callbackOpts) {
-          if (wait) {
-            collection.add(m, callbackOpts);
-          }
-          if (success) {
-            success.call(callbackOpts.context, m, resp, callbackOpts);
-          }
-          if (return_promise) {
-            promise.resolve(m);
-          }
-        };
-        model.save(null, options);
-        if (return_promise) {
-          return promise;
-        } else {
-          return model;
-        }
-      },
-
-      // **parse** converts a response into a list of models to be added to the
-      // collection. The default implementation is just to pass it through.
-      parse: function(resp, options) {
-        return resp;
-      },
-
-      // Create a new collection with an identical list of models as this one.
-      clone: function() {
-        return new this.constructor(this.models, {
-          model: this.model,
-          comparator: this.comparator
-        });
-      },
-
-      // Define how to uniquely identify models in the collection.
-      modelId: function(attrs) {
-        return attrs[this.model.prototype.idAttribute || 'id'];
-      },
-
-      // Get an iterator of all models in this collection.
-      values: function() {
-        return new CollectionIterator(this, ITERATOR_VALUES);
-      },
-
-      // Get an iterator of all model IDs in this collection.
-      keys: function() {
-        return new CollectionIterator(this, ITERATOR_KEYS);
-      },
-
-      // Get an iterator of all [ID, model] tuples in this collection.
-      entries: function() {
-        return new CollectionIterator(this, ITERATOR_KEYSVALUES);
-      },
-
-      // Private method to reset all internal state. Called when the collection
-      // is first initialized or reset.
-      _reset: function() {
-        this.length = 0;
-        this.models = [];
-        this._byId  = {};
-      },
-
-      // Prepare a hash of attributes (or other model) to be added to this
-      // collection.
-      _prepareModel: function(attrs, options) {
-        if (this._isModel(attrs)) {
-          if (!attrs.collection) attrs.collection = this;
-          return attrs;
-        }
-        options = options ? clone(options) : {};
-        options.collection = this;
-        const model = new this.model(attrs, options);
-        if (!model.validationError) return model;
-        this.trigger('invalid', this, model.validationError, options);
-        return false;
-      },
-
-      // Internal method called by both remove and set.
-      _removeModels: function(models, options) {
-        const removed = [];
-        for (let i = 0; i < models.length; i++) {
-          const model = this.get(models[i]);
-          if (!model) continue;
-
-          const index = this.indexOf(model);
-          this.models.splice(index, 1);
-          this.length--;
-
-          // Remove references before triggering 'remove' event to prevent an
-          // infinite loop. #3693
-          delete this._byId[model.cid];
-          const id = this.modelId(model.attributes);
-          if (id != null) delete this._byId[id];
-
-          if (!options.silent) {
-            options.index = index;
-            model.trigger('remove', model, this, options);
-          }
-
-          removed.push(model);
-          this._removeReference(model, options);
-        }
-        return removed;
-      },
-
-      // Method for checking whether an object should be considered a model for
-      // the purposes of adding to the collection.
-      _isModel: function(model) {
-        return model instanceof Model;
-      },
-
-      // Internal method to create a model's ties to a collection.
-      _addReference: function(model, options) {
-        this._byId[model.cid] = model;
-        const id = this.modelId(model.attributes);
-        if (id != null) this._byId[id] = model;
-        model.on('all', this._onModelEvent, this);
-      },
-
-      // Internal method to sever a model's ties to a collection.
-      _removeReference: function(model, options) {
-        delete this._byId[model.cid];
-        const id = this.modelId(model.attributes);
-        if (id != null) delete this._byId[id];
-        if (this === model.collection) delete model.collection;
-        model.off('all', this._onModelEvent, this);
-      },
-
-      // Internal method called every time a model in the set fires an event.
-      // Sets need to update their indexes when models change ids. All other
-      // events simply proxy through. "add" and "remove" events that originate
-      // in other collections are ignored.
-      _onModelEvent: function(event, model, collection, options) {
-        if (model) {
-          if ((event === 'add' || event === 'remove') && collection !== this) return;
-          if (event === 'destroy') this.remove(model, options);
-          if (event === 'change') {
-            const prevId = this.modelId(model.previousAttributes());
-            const id = this.modelId(model.attributes);
-            if (prevId !== id) {
-              if (prevId != null) delete this._byId[prevId];
-              if (id != null) this._byId[id] = model;
-            }
-          }
-        }
-        this.trigger.apply(this, arguments);
-      }
-
-    });
-
-    // Defining an @@iterator method implements JavaScript's Iterable protocol.
-    // In modern ES2015 browsers, this value is found at Symbol.iterator.
-    /* global Symbol */
-    const $$iterator = typeof Symbol === 'function' && Symbol.iterator;
-    if ($$iterator) {
-      Collection.prototype[$$iterator] = Collection.prototype.values;
-    }
-
-    // CollectionIterator
-    // ------------------
-
-    // A CollectionIterator implements JavaScript's Iterator protocol, allowing the
-    // use of `for of` loops in modern browsers and interoperation between
-    // Collection and other JavaScript functions and third-party libraries
-    // which can operate on Iterables.
-    const CollectionIterator = function(collection, kind) {
-      this._collection = collection;
-      this._kind = kind;
-      this._index = 0;
-    };
-
-    // This "enum" defines the three possible kinds of values which can be emitted
-    // by a CollectionIterator that correspond to the values(), keys() and entries()
-    // methods on Collection, respectively.
-    const ITERATOR_VALUES = 1;
-    const ITERATOR_KEYS = 2;
-    const ITERATOR_KEYSVALUES = 3;
-
-    // All Iterators should themselves be Iterable.
-    if ($$iterator) {
-      CollectionIterator.prototype[$$iterator] = function() {
-        return this;
-      };
-    }
-
-    CollectionIterator.prototype.next = function() {
-      if (this._collection) {
-
-        // Only continue iterating if the iterated collection is long enough.
-        if (this._index < this._collection.length) {
-          const model = this._collection.at(this._index);
-          this._index++;
-
-          // Construct a value depending on what kind of values should be iterated.
-          let value;
-          if (this._kind === ITERATOR_VALUES) {
-            value = model;
-          } else {
-            const id = this._collection.modelId(model.attributes);
-            if (this._kind === ITERATOR_KEYS) {
-              value = id;
-            } else { // ITERATOR_KEYSVALUES
-              value = [id, model];
-            }
-          }
-          return {value: value, done: false};
-        }
-
-        // Once exhausted, remove the reference to the collection so future
-        // calls to the next method always return done.
-        this._collection = undefined;
-      }
-
-      return {value: undefined, done: true};
-    };
-
-    //  Backbone.js 1.4.0
-
-    // History
-    // -------
-
-    // Handles cross-browser history management, based on either
-    // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
-    // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
-    // and URL fragments. If the browser supports neither (old IE, natch),
-    // falls back to polling.
-    const History = function() {
-      this.handlers = [];
-      this.checkUrl = this.checkUrl.bind(this);
-
-      // Ensure that `History` can be used outside of the browser.
-      if (typeof window !== 'undefined') {
-        this.location = window.location;
-        this.history = window.history;
-      }
-    };
-
-    History.extend = inherits;
-
-    // Cached regex for stripping a leading hash/slash and trailing space.
-    const routeStripper = /^[#\/]|\s+$/g;
-    // Cached regex for stripping leading and trailing slashes.
-    const rootStripper = /^\/+|\/+$/g;
-    // Cached regex for stripping urls of hash.
-    const pathStripper = /#.*$/;
-
-    // Has the history handling already been started?
-    History.started = false;
-
-    // Set up all inheritable **History** properties and methods.
-    Object.assign(History.prototype, Events, {
-
-      // The default interval to poll for hash changes, if necessary, is
-      // twenty times a second.
-      interval: 50,
-
-      // Are we at the app root?
-      atRoot: function() {
-        const path = this.location.pathname.replace(/[^\/]$/, '$&/');
-        return path === this.root && !this.getSearch();
-      },
-
-      // Does the pathname match the root?
-      matchRoot: function() {
-        const path = this.decodeFragment(this.location.pathname);
-        const rootPath = path.slice(0, this.root.length - 1) + '/';
-        return rootPath === this.root;
-      },
-
-      // Unicode characters in `location.pathname` are percent encoded so they're
-      // decoded for comparison. `%25` should not be decoded since it may be part
-      // of an encoded parameter.
-      decodeFragment: function(fragment) {
-        return decodeURI(fragment.replace(/%25/g, '%2525'));
-      },
-
-      // In IE6, the hash fragment and search params are incorrect if the
-      // fragment contains `?`.
-      getSearch: function() {
-        const match = this.location.href.replace(/#.*/, '').match(/\?.+/);
-        return match ? match[0] : '';
-      },
-
-      // Gets the true hash value. Cannot use location.hash directly due to bug
-      // in Firefox where location.hash will always be decoded.
-      getHash: function(window) {
-        const match = (window || this).location.href.match(/#(.*)$/);
-        return match ? match[1] : '';
-      },
-
-      // Get the pathname and search params, without the root.
-      getPath: function() {
-        const path = this.decodeFragment(
-          this.location.pathname + this.getSearch()
-        ).slice(this.root.length - 1);
-        return path.charAt(0) === '/' ? path.slice(1) : path;
-      },
-
-      // Get the cross-browser normalized URL fragment from the path or hash.
-      getFragment: function(fragment) {
-        if (fragment == null) {
-          if (this._usePushState || !this._wantsHashChange) {
-            fragment = this.getPath();
-          } else {
-            fragment = this.getHash();
-          }
-        }
-        return fragment.replace(routeStripper, '');
-      },
-
-      // Start the hash change handling, returning `true` if the current URL matches
-      // an existing route, and `false` otherwise.
-      start: function(options) {
-        if (History.started) throw new Error('history has already been started');
-        History.started = true;
-
-        // Figure out the initial configuration. Do we need an iframe?
-        // Is pushState desired ... is it available?
-        this.options          = extend({root: '/'}, this.options, options);
-        this.root             = this.options.root;
-        this._wantsHashChange = this.options.hashChange !== false;
-        this._hasHashChange   = 'onhashchange' in window && (document.documentMode === undefined|| document.documentMode > 7);
-        this._useHashChange   = this._wantsHashChange && this._hasHashChange;
-        this._wantsPushState  = !!this.options.pushState;
-        this._hasPushState    = !!(this.history && this.history.pushState);
-        this._usePushState    = this._wantsPushState && this._hasPushState;
-        this.fragment         = this.getFragment();
-
-        // Normalize root to always include a leading and trailing slash.
-        this.root = ('/' + this.root + '/').replace(rootStripper, '/');
-
-        // Transition from hashChange to pushState or vice versa if both are
-        // requested.
-        if (this._wantsHashChange && this._wantsPushState) {
-
-          // If we've started off with a route from a `pushState`-enabled
-          // browser, but we're currently in a browser that doesn't support it...
-          if (!this._hasPushState && !this.atRoot()) {
-            const rootPath = this.root.slice(0, -1) || '/';
-            this.location.replace(rootPath + '#' + this.getPath());
-            // Return immediately as browser will do redirect to new url
-            return true;
-
-          // Or if we've started out with a hash-based route, but we're currently
-          // in a browser where it could be `pushState`-based instead...
-          } else if (this._hasPushState && this.atRoot()) {
-            this.navigate(this.getHash(), {replace: true});
-          }
-
-        }
-
-        // Proxy an iframe to handle location events if the browser doesn't
-        // support the `hashchange` event, HTML5 history, or the user wants
-        // `hashChange` but not `pushState`.
-        if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {
-          this.iframe = document.createElement('iframe');
-          this.iframe.src = 'javascript:0';
-          this.iframe.style.display = 'none';
-          this.iframe.tabIndex = -1;
-          const body = document.body;
-          // Using `appendChild` will throw on IE < 9 if the document is not ready.
-          const iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;
-          iWindow.document.open();
-          iWindow.document.close();
-          iWindow.location.hash = '#' + this.fragment;
-        }
-
-        // Depending on whether we're using pushState or hashes, and whether
-        // 'onhashchange' is supported, determine how we check the URL state.
-        if (this._usePushState) {
-          addEventListener('popstate', this.checkUrl, false);
-        } else if (this._useHashChange && !this.iframe) {
-          addEventListener('hashchange', this.checkUrl, false);
-        } else if (this._wantsHashChange) {
-          this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
-        }
-
-        if (!this.options.silent) return this.loadUrl();
-      },
-
-      // Disable history, perhaps temporarily. Not useful in a real app,
-      // but possibly useful for unit testing Routers.
-      stop: function() {
-        // Remove window listeners.
-        if (this._usePushState) {
-          removeEventListener('popstate', this.checkUrl, false);
-        } else if (this._useHashChange && !this.iframe) {
-          removeEventListener('hashchange', this.checkUrl, false);
-        }
-
-        // Clean up the iframe if necessary.
-        if (this.iframe) {
-          document.body.removeChild(this.iframe);
-          this.iframe = null;
-        }
-
-        // Some environments will throw when clearing an undefined interval.
-        if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);
-        History.started = false;
-      },
-
-      // Add a route to be tested when the fragment changes. Routes added later
-      // may override previous routes.
-      route: function(route, callback) {
-        this.handlers.unshift({route: route, callback: callback});
-      },
-
-      // Checks the current URL to see if it has changed, and if it has,
-      // calls `loadUrl`, normalizing across the hidden iframe.
-      checkUrl: function(e) {
-        let current = this.getFragment();
-
-        // If the user pressed the back button, the iframe's hash will have
-        // changed and we should use that for comparison.
-        if (current === this.fragment && this.iframe) {
-          current = this.getHash(this.iframe.contentWindow);
-        }
-
-        if (current === this.fragment) return false;
-        if (this.iframe) this.navigate(current);
-        this.loadUrl();
-      },
-
-      // Attempt to load the current URL fragment. If a route succeeds with a
-      // match, returns `true`. If no defined routes matches the fragment,
-      // returns `false`.
-      loadUrl: function(fragment) {
-        // If the root doesn't match, no routes can match either.
-        if (!this.matchRoot()) return false;
-        fragment = this.fragment = this.getFragment(fragment);
-        return some(this.handlers, function(handler) {
-          if (handler.route.test(fragment)) {
-            handler.callback(fragment);
-            return true;
-          }
-        });
-      },
-
-      // Save a fragment into the hash history, or replace the URL state if the
-      // 'replace' option is passed. You are responsible for properly URL-encoding
-      // the fragment in advance.
-      //
-      // The options object can contain `trigger: true` if you wish to have the
-      // route callback be fired (not usually desirable), or `replace: true`, if
-      // you wish to modify the current URL without adding an entry to the history.
-      navigate: function(fragment, options) {
-        if (!History.started) return false;
-        if (!options || options === true) options = {trigger: !!options};
-
-        // Normalize the fragment.
-        fragment = this.getFragment(fragment || '');
-
-        // Don't include a trailing slash on the root.
-        let rootPath = this.root;
-        if (fragment === '' || fragment.charAt(0) === '?') {
-          rootPath = rootPath.slice(0, -1) || '/';
-        }
-        const url = rootPath + fragment;
-
-        // Strip the fragment of the query and hash for matching.
-        fragment = fragment.replace(pathStripper, '');
-
-        // Decode for matching.
-        const decodedFragment = this.decodeFragment(fragment);
-
-        if (this.fragment === decodedFragment) return;
-        this.fragment = decodedFragment;
-
-        // If pushState is available, we use it to set the fragment as a real URL.
-        if (this._usePushState) {
-          this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
-
-        // If hash changes haven't been explicitly disabled, update the hash
-        // fragment to store history.
-        } else if (this._wantsHashChange) {
-          this._updateHash(this.location, fragment, options.replace);
-          if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {
-            const iWindow = this.iframe.contentWindow;
-
-            // Opening and closing the iframe tricks IE7 and earlier to push a
-            // history entry on hash-tag change.  When replace is true, we don't
-            // want this.
-            if (!options.replace) {
-              iWindow.document.open();
-              iWindow.document.close();
-            }
-            this._updateHash(iWindow.location, fragment, options.replace);
-          }
-        // If you've told us that you explicitly don't want fallback hashchange-
-        // based history, then `navigate` becomes a page refresh.
-        } else {
-          return this.location.assign(url);
-        }
-        if (options.trigger) return this.loadUrl(fragment);
-      },
-
-      // Update the hash location, either replacing the current entry, or adding
-      // a new one to the browser history.
-      _updateHash: function(location, fragment, replace) {
-        if (replace) {
-          const href = location.href.replace(/(javascript:|#).*$/, '');
-          location.replace(href + '#' + fragment);
-        } else {
-          // Some browsers require that `hash` contains a leading #.
-          location.hash = '#' + fragment;
-        }
-      }
-    });
-
-    //     Backbone.js 1.4.0
-
-    // Routers map faux-URLs to actions, and fire events when routes are
-    // matched. Creating a new one sets its `routes` hash, if not set statically.
-    const Router = function(options={}) {
-      this.history = options.history || new History();
-      this.preinitialize.apply(this, arguments);
-      if (options.routes) this.routes = options.routes;
-      this._bindRoutes();
-      this.initialize.apply(this, arguments);
-    };
-
-    Router.extend = inherits;
-
-    // Cached regular expressions for matching named param parts and splatted
-    // parts of route strings.
-    const optionalParam = /\((.*?)\)/g;
-    const namedParam    = /(\(\?)?:\w+/g;
-    const splatParam    = /\*\w+/g;
-    const escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
-
-    // Set up all inheritable **Router** properties and methods.
-    Object.assign(Router.prototype, Events, {
-
-      // preinitialize is an empty function by default. You can override it with a function
-      // or object.  preinitialize will run before any instantiation logic is run in the Router.
-      preinitialize: function(){},
-
-      // Initialize is an empty function by default. Override it with your own
-      // initialization logic.
-      initialize: function(){},
-
-      // Manually bind a single named route to a callback. For example:
-      //
-      //     this.route('search/:query/p:num', 'search', function(query, num) {
-      //       ...
-      //     });
-      //
-      route: function(route, name, callback) {
-        if (!isRegExp(route)) route = this._routeToRegExp(route);
-        if (isFunction(name)) {
-          callback = name;
-          name = '';
-        }
-        if (!callback) callback = this[name];
-        this.history.route(route, (fragment) => {
-          const args = this._extractParameters(route, fragment);
-          if (this.execute(callback, args, name) !== false) {
-            this.trigger.apply(this, ['route:' + name].concat(args));
-            this.trigger('route', name, args);
-            this.history.trigger('route', this, name, args);
-          }
-        });
-        return this;
-      },
-
-      // Execute a route handler with the provided parameters.  This is an
-      // excellent place to do pre-route setup or post-route cleanup.
-      execute: function(callback, args, name) {
-        if (callback) callback.apply(this, args);
-      },
-
-      // Simple proxy to `history` to save a fragment into the history.
-      navigate: function(fragment, options) {
-        this.history.navigate(fragment, options);
-        return this;
-      },
-
-      // Bind all defined routes to `history`. We have to reverse the
-      // order of the routes here to support behavior where the most general
-      // routes can be defined at the bottom of the route map.
-      _bindRoutes: function() {
-        if (!this.routes) return;
-        this.routes = result(this, 'routes');
-        let route;
-        const routes = Object.keys(this.routes);
-        while ((route = routes.pop()) != null) {
-          this.route(route, this.routes[route]);
-        }
-      },
-
-      // Convert a route string into a regular expression, suitable for matching
-      // against the current location hash.
-      _routeToRegExp: function(route) {
-        route = route.replace(escapeRegExp, '\\$&')
-          .replace(optionalParam, '(?:$1)?')
-          .replace(namedParam, function(match, optional) {
-            return optional ? match : '([^/?]+)';
-          })
-          .replace(splatParam, '([^?]*?)');
-        return new RegExp('^' + route + '(?:\\?([\\s\\S]*))?$');
-      },
-
-      // Given a route, and a URL fragment that it matches, return the array of
-      // extracted decoded parameters. Empty or unmatched parameters will be
-      // treated as `null` to normalize cross-browser behavior.
-      _extractParameters: function(route, fragment) {
-        const params = route.exec(fragment).slice(1);
-        return params.map(function(param, i) {
-          // Don't decode the search params.
-          if (i === params.length - 1) return param || null;
-          return param ? decodeURIComponent(param) : null;
-        });
-      }
-    });
-
-    //     Backbone.js 1.4.0
-
-    const paddedLt = /^\s*</;
-
-    // Caches a local reference to `Element.prototype` for faster access.
-    const ElementProto = (typeof Element !== 'undefined' && Element.prototype) || {};
-
-    const indexOf = function(array, item) {
-      for (let i = 0, len = array.length; i < len; i++) if (array[i] === item) return i;
-      return -1;
-    };
-
-    // Find the right `Element#matches` for IE>=9 and modern browsers.
-    const matchesSelector = ElementProto.matches ||
-        ElementProto.webkitMatchesSelector ||
-        ElementProto.mozMatchesSelector ||
-        ElementProto.msMatchesSelector ||
-        ElementProto.oMatchesSelector ||
-        // Make our own `Element#matches` for IE8
-        function(selector) {
-          // Use querySelectorAll to find all elements matching the selector,
-          // then check if the given element is included in that list.
-          // Executing the query on the parentNode reduces the resulting nodeList,
-          // (document doesn't have a parentNode).
-          const nodeList = (this.parentNode || document).querySelectorAll(selector) || [];
-          return ~indexOf(nodeList, this);
-        };
-
-
-    // Creating a View creates its initial element outside of the DOM,
-    // if an existing element is not provided...
-    const View = function(options) {
-      this.cid = uniqueId('view');
-      this._domEvents = [];
-      this.preinitialize.apply(this, arguments);
-      extend(this, pick(options, viewOptions));
-      this._ensureElement();
-      this.initialize.apply(this, arguments);
-    };
-
-    View.extend = inherits;
-
-    // Cached regex to split keys for `delegate`.
-    const delegateEventSplitter = /^(\S+)\s*(.*)$/;
-
-    // List of view options to be set as properties.
-    const viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
-
-    // Set up all inheritable **View** properties and methods.
-    Object.assign(View.prototype, Events, {
-
-      // The default `tagName` of a View's element is `"div"`.
-      tagName: 'div',
-
-      $: function(selector) {
-        return this.el.querySelectorAll(selector);
-      },
-
-      // preinitialize is an empty function by default. You can override it with a function
-      // or object.  preinitialize will run before any instantiation logic is run in the View
-      preinitialize: function(){},
-
-      // Initialize is an empty function by default. Override it with your own
-      // initialization logic.
-      initialize: function(){},
-
-      // **render** is the core function that your view should override, in order
-      // to populate its element (`this.el`), with the appropriate HTML. The
-      // convention is for **render** to always return `this`.
-      render: function() {
-        isFunction(this.beforeRender) && this.beforeRender();
-        isFunction(this.toHTML) && render(this.toHTML(), this.el);
-        isFunction(this.afterRender) && this.afterRender();
-        return this;
-      },
-
-      // Remove this view by taking the element out of the DOM, and removing any
-      // applicable Backbone.Events listeners.
-      remove: function() {
-        this._removeElement();
-        this.stopListening();
-        return this;
-      },
-
-      // Remove this view's element from the document and all event listeners
-      // attached to it. Exposed for subclasses using an alternative DOM
-      // manipulation API.
-      _removeElement: function() {
-        this.undelegateEvents();
-        if (this.el.parentNode) this.el.parentNode.removeChild(this.el);
-      },
-
-      // Change the view's element (`this.el` property) and re-delegate the
-      // view's events on the new element.
-      setElement: function(element) {
-        this.undelegateEvents();
-        this._setElement(element);
-        this.delegateEvents();
-        return this;
-      },
-
-      // Apply the `element` to the view. `element` can be a CSS selector,
-      // a string of HTML, or an Element node. If passed a NodeList or CSS
-      // selector, uses just the first match.
-      _setElement: function(element) {
-        if (typeof element == 'string') {
-          if (paddedLt.test(element)) {
-            const el = document.createElement('div');
-            el.innerHTML = element;
-            this.el = el.firstChild;
-          } else {
-            this.el = document.querySelector(element);
-          }
-        } else if (element && !isElement(element) && element.length) {
-          this.el = element[0];
-        } else {
-          this.el = element;
-        }
-      },
-
-      // Set callbacks, where `this.events` is a hash of
-      //
-      // *{"event selector": "callback"}*
-      //
-      //     {
-      //       'mousedown .title':  'edit',
-      //       'click .button':     'save',
-      //       'click .open':       function(e) { ... }
-      //     }
-      //
-      // pairs. Callbacks will be bound to the view, with `this` set properly.
-      // Uses event delegation for efficiency.
-      // Omitting the selector binds the event to `this.el`.
-      delegateEvents: function(events) {
-        events || (events = result(this, 'events'));
-        if (!events) return this;
-        this.undelegateEvents();
-        for (const key in events) {
-          let method = events[key];
-          if (!isFunction(method)) method = this[method];
-          if (!method) continue;
-          const match = key.match(delegateEventSplitter);
-          this.delegate(match[1], match[2], method.bind(this));
-        }
-        return this;
-      },
-
-      // Make a event delegation handler for the given `eventName` and `selector`
-      // and attach it to `this.el`.
-      // If selector is empty, the listener will be bound to `this.el`. If not, a
-      // new handler that will recursively traverse up the event target's DOM
-      // hierarchy looking for a node that matches the selector. If one is found,
-      // the event's `delegateTarget` property is set to it and the return the
-      // result of calling bound `listener` with the parameters given to the
-      // handler.
-      delegate: function(eventName, selector, listener) {
-        const root = this.el;
-        if (!root) {
-          return this;
-        }
-        if (typeof selector === 'function') {
-          listener = selector;
-          selector = null;
-        }
-        // Given that `focus` and `blur` events do not bubble, do not delegate these events
-        if (['focus', 'blur'].indexOf(eventName) !== -1) {
-          const els = this.el.querySelectorAll(selector);
-          for (let i = 0, len = els.length; i < len; i++) {
-            const item = els[i];
-            item.addEventListener(eventName, listener, false);
-            this._domEvents.push({el: item, eventName: eventName, handler: listener});
-          }
-          return listener;
-        }
-
-        const handler = selector ? function (e) {
-          let node = e.target || e.srcElement;
-          for (; node && node != root; node = node.parentNode) {
-            if (matchesSelector.call(node, selector)) {
-              e.delegateTarget = node;
-              listener(e);
-            }
-          }
-        } : listener;
-
-        this.el.addEventListener(eventName, handler, false);
-        this._domEvents.push({el: this.el, eventName: eventName, handler: handler, listener: listener, selector: selector});
-        return this;
-      },
-
-      // Clears all callbacks previously bound to the view by `delegateEvents`.
-      // You usually don't need to use this, but may wish to if you have multiple
-      // Backbone views attached to the same DOM element.
-      undelegateEvents: function() {
-        if (this.el) {
-          for (let i = 0, len = this._domEvents.length; i < len; i++) {
-            const item = this._domEvents[i];
-            item.el.removeEventListener(item.eventName, item.handler, false);
-          }
-          this._domEvents.length = 0;
-        }
-        return this;
-      },
-
-      // A finer-grained `undelegateEvents` for removing a single delegated event.
-      // `selector` and `listener` are both optional.
-      undelegate: function(eventName, selector, listener) {
-        if (typeof selector === 'function') {
-          listener = selector;
-          selector = null;
-        }
-        if (this.el) {
-          const handlers = this._domEvents.slice();
-          let i = handlers.length;
-          while (i--) {
-            const item = handlers[i];
-            const match = item.eventName === eventName &&
-                (listener ? item.listener === listener : true) &&
-                (selector ? item.selector === selector : true);
-
-            if (!match) {
-              continue;
-            }
-            item.el.removeEventListener(item.eventName, item.handler, false);
-            this._domEvents.splice(i, 1);
-          }
-        }
-        return this;
-      },
-
-      // Produces a DOM element to be assigned to your view. Exposed for
-      // subclasses using an alternative DOM manipulation API.
-      _createElement: function(tagName) {
-        return document.createElement(tagName);
-      },
-
-      // Ensure that the View has a DOM element to render into.
-      // If `this.el` is a string, pass it through `$()`, take the first
-      // matching element, and re-assign it to `el`. Otherwise, create
-      // an element from the `id`, `className` and `tagName` properties.
-      _ensureElement: function() {
-        if (!this.el) {
-          const attrs = extend({}, result(this, 'attributes'));
-          if (this.id) attrs.id = result(this, 'id');
-          if (this.className) attrs['class'] = result(this, 'className');
-          this.setElement(this._createElement(result(this, 'tagName')));
-          this._setAttributes(attrs);
-        } else {
-          this.setElement(result(this, 'el'));
-        }
-      },
-
-      // Set attributes from a hash on this view's element.  Exposed for
-      // subclasses using an alternative DOM manipulation API.
-      _setAttributes: function(attrs) {
-        for (const attr in attrs) {
-          attr in this.el ? this.el[attr] = attrs[attr] : this.el.setAttribute(attr, attrs[attr]);
-        }
-      },
-    });
-
-    /* global global */
-
-    const skeletor = {
-      Collection,
-      Events,
-      History,
-      Model,
-      Router,
-      View,
-      ajax,
-      sync
-    };
-
-    Object.assign(skeletor, Events);
-
-    // Establish the root object, `window` (`self`) in the browser, or `global` on the server.
-    // We use `self` instead of `window` for `WebWorker` support.
-    const root = typeof self == 'object' && self.self === self && self ||
-              typeof global == 'object' && global.global === global && global;
-
-    // Current version of the library. Keep in sync with `package.json`.
-    skeletor.VERSION = '0.0.1';
-
-    // Save the previous value of the `Skeletor` variable, so that it can be
-    // restored later on, if `noConflict` is used.
-    const previousSkeletor = root.Skeletor;
-
-    // Runs Skeletor.js in *noConflict* mode, returning the `Skeletor` variable
-    // to its previous owner. Returns a reference to this Skeletor object.
-    skeletor.noConflict = function() {
-      root.Skeletor = previousSkeletor;
-      return this;
-    };
-
-    root.Skeletor = skeletor;
-
-    return skeletor;
-
-})));
-//# sourceMappingURL=skeletor.js.map