@converse/skeletor 0.0.5 → 0.0.6

package/dist/skeletor.js

@@ -1903,7 +1903,7 @@
       throw new TypeError(FUNC_ERROR_TEXT);
     }
 
-    var memoized = function memoized() {
+    var memoized = function () {
       var args = arguments,
           key = resolver ? resolver.apply(this, args) : args[0],
           cache = memoized.cache;
@@ -2232,7 +2232,7 @@
     if (protoProps && has(protoProps, 'constructor')) {
       child = protoProps.constructor;
     } else {
-      child = function child() {
+      child = function () {
         return parent.apply(this, arguments);
       };
     } // Add static properties to the constructor function, if supplied.
@@ -2391,7 +2391,7 @@
   var getTag = baseGetTag; // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
 
   if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$1 || Map && getTag(new Map()) != mapTag$1 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set && getTag(new Set()) != setTag$1 || WeakMap$1 && getTag(new WeakMap$1()) != weakMapTag$1) {
-    getTag = function getTag(value) {
+    getTag = function (value) {
       var result = baseGetTag(value),
           Ctor = result == objectTag$1 ? value.constructor : undefined,
           ctorString = Ctor ? toSource(Ctor) : '';
@@ -2766,7 +2766,7 @@
   // maps `{event: callback}`).
 
 
-  const eventsApi = function eventsApi(iteratee, events, name, callback, opts) {
+  const eventsApi = function (iteratee, events, name, callback, opts) {
     let i = 0,
         names;
 
@@ -2835,7 +2835,7 @@
   }; // The reducing API that adds a callback to the `events` object.
 
 
-  const onApi = function onApi(events, name, callback, options) {
+  const onApi = function (events, name, callback, options) {
     if (callback) {
       const handlers = events[name] || (events[name] = []);
       const context = options.context,
@@ -2855,7 +2855,7 @@
   // `_listening` variable.
 
 
-  const tryCatchOn = function tryCatchOn(obj, name, callback, context) {
+  const tryCatchOn = function (obj, name, callback, context) {
     try {
       obj.on(name, callback, context);
     } catch (e) {
@@ -2897,7 +2897,7 @@
   }; // The reducing API that removes a callback from the `events` object.
 
 
-  const offApi = function offApi(events, name, callback, options) {
+  const offApi = function (events, name, callback, options) {
     if (!events) return;
     const context = options.context,
           listeners = options.listeners;
@@ -2967,7 +2967,7 @@
   // `offer` unbinds the `onceWrapper` after it has been called.
 
 
-  const onceMap = function onceMap(map, name, callback, offer) {
+  const onceMap = function (map, name, callback, offer) {
     if (callback) {
       const _once = map[name] = once(function () {
         offer(name, _once);
@@ -2996,7 +2996,7 @@
   }; // Handles triggering the appropriate event callbacks.
 
 
-  const triggerApi = function triggerApi(objEvents, name, callback, args) {
+  const triggerApi = function (objEvents, name, callback, args) {
     if (objEvents) {
       const events = objEvents[name];
       let allEvents = objEvents.all;
@@ -3011,7 +3011,7 @@
   // Backbone events have 3 arguments).
 
 
-  const triggerEvents = function triggerEvents(events, args) {
+  const triggerEvents = function (events, args) {
     let ev,
         i = -1;
     const l = events.length,
@@ -3049,7 +3049,7 @@
   // when all callbacks have been offed.
 
 
-  const Listening = function Listening(listener, obj) {
+  const Listening = function (listener, obj) {
     this.id = listener._listenId;
     this.listener = listener;
     this.obj = obj;
@@ -5555,7 +5555,7 @@
   });
 
   //     Backbone.js 1.4.0
-  const Model = function Model(attributes, options) {
+  const Model = function (attributes, options) {
     let attrs = attributes || {};
     options || (options = {});
     this.preinitialize.apply(this, arguments);
@@ -5584,72 +5584,72 @@
     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 preinitialize() {},
+    preinitialize: function () {},
     // Initialize is an empty function by default. Override it with your own
     // initialization logic.
-    initialize: function initialize() {},
+    initialize: function () {},
     // Return a copy of the model's `attributes` object.
-    toJSON: function toJSON(options) {
+    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 sync(method, model, options) {
+    sync: function (method, model, options) {
       return getSyncMethod(this)(method, model, options);
     },
     // Get the value of an attribute.
-    get: function get(attr) {
+    get: function (attr) {
       return this.attributes[attr];
     },
-    keys: function keys() {
+    keys: function () {
       return Object.keys(this.attributes);
     },
-    values: function values() {
+    values: function () {
       return Object.values(this.attributes);
     },
-    pairs: function pairs() {
+    pairs: function () {
       return this.entries();
     },
-    entries: function entries() {
+    entries: function () {
       return Object.entries(this.attributes);
     },
-    invert: function invert$1() {
+    invert: function () {
       return invert(this.attributes);
     },
-    pick: function pick$1(...args) {
+    pick: function (...args) {
       if (args.length === 1 && Array.isArray(args[0])) {
         args = args[0];
       }
 
       return pick(this.attributes, args);
     },
-    omit: function omit$1(...args) {
+    omit: function (...args) {
       if (args.length === 1 && Array.isArray(args[0])) {
         args = args[0];
       }
 
       return omit(this.attributes, args);
     },
-    isEmpty: function isEmpty$1() {
+    isEmpty: function () {
       return isEmpty(this.attributes);
     },
     // Get the HTML-escaped value of an attribute.
-    escape: function escape$1(attr) {
+    escape: function (attr) {
       return escape(this.get(attr));
     },
     // Returns `true` if the attribute contains a value that is not null
     // or undefined.
-    has: function has(attr) {
+    has: function (attr) {
       return this.get(attr) != null;
     },
     // Special-cased proxy to lodash's `matches` method.
-    matches: function matches(attrs) {
+    matches: function (attrs) {
       return !!iteratee(attrs)(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 set(key, val, options) {
+    set: function (key, val, options) {
       if (key == null) return this; // Handle both `"key", value` and `{key: value}` -style arguments.
 
       let attrs;
@@ -5722,13 +5722,13 @@
     },
     // Remove an attribute from the model, firing `"change"`. `unset` is a noop
     // if the attribute doesn't exist.
-    unset: function unset(attr, options) {
+    unset: function (attr, options) {
       return this.set(attr, undefined, assignIn({}, options, {
         unset: true
       }));
     },
     // Clear all attributes on the model, firing `"change"`.
-    clear: function clear(options) {
+    clear: function (options) {
       const attrs = {};
 
       for (const key in this.attributes) attrs[key] = undefined;
@@ -5739,7 +5739,7 @@
     },
     // 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 hasChanged(attr) {
+    hasChanged: function (attr) {
       if (attr == null) return !isEmpty(this.changed);
       return has(this.changed, attr);
     },
@@ -5749,7 +5749,7 @@
     // 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 changedAttributes(diff) {
+    changedAttributes: function (diff) {
       if (!diff) return this.hasChanged() ? clone(this.changed) : false;
       const old = this._changing ? this._previousAttributes : this.attributes;
       const changed = {};
@@ -5766,18 +5766,18 @@
     },
     // Get the previous value of an attribute, recorded at the time the last
     // `"change"` event was fired.
-    previous: function previous(attr) {
+    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 previousAttributes() {
+    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 fetch(options) {
+    fetch: function (options) {
       options = assignIn({
         parse: true
       }, options);
@@ -5797,7 +5797,7 @@
     // 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 save(key, val, options) {
+    save: function (key, val, options) {
       // Handle both `"key", value` and `{key: value}` -style arguments.
       let attrs;
 
@@ -5865,13 +5865,13 @@
     // 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 destroy(options) {
+    destroy: function (options) {
       options = options ? clone(options) : {};
       const model = this;
       const success = options.success;
       const wait = options.wait;
 
-      const destroy = function destroy() {
+      const destroy = function () {
         model.stopListening();
         model.trigger('destroy', model, model.collection, options);
       };
@@ -5897,7 +5897,7 @@
     // 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 url() {
+    url: function () {
       const base = result(this, 'urlRoot') || result(this.collection, 'url') || urlError();
       if (this.isNew()) return base;
       const id = this.get(this.idAttribute);
@@ -5905,26 +5905,26 @@
     },
     // **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 parse(resp, options) {
+    parse: function (resp, options) {
       return resp;
     },
     // Create a new model with identical attributes to this one.
-    clone: function clone() {
+    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 isNew() {
+    isNew: function () {
       return !this.has(this.idAttribute);
     },
     // Check if the model is currently in a valid state.
-    isValid: function isValid(options) {
+    isValid: function (options) {
       return this._validate({}, assignIn({}, 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 _validate(attrs, options) {
+    _validate: function (attrs, options) {
       if (!options.validate || !this.validate) return true;
       attrs = assignIn({}, this.attributes, attrs);
       const error = this.validationError = this.validate(attrs, options) || null;
@@ -6984,11 +6984,11 @@
   });
 
   //     Backbone.js 1.4.0
-  const _slice = Array.prototype.slice; // Create a new **Collection**, perhaps to contain a specific type of `model`.
+  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 Collection(models, options) {
+  const Collection = function (models, options) {
     options || (options = {});
     this.preinitialize.apply(this, arguments);
     if (options.model) this.model = options.model;
@@ -7013,7 +7013,7 @@
     remove: false
   }; // Splices `insert` into `array` at index `at`.
 
-  const splice$1 = function splice(array, insert, at) {
+  const splice$1 = function (array, insert, at) {
     at = Math.min(Math.max(at, 0), array.length);
     const tail = Array(array.length - at);
     const length = insert.length;
@@ -7033,31 +7033,31 @@
     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 preinitialize() {},
+    preinitialize: function () {},
     // Initialize is an empty function by default. Override it with your own
     // initialization logic.
-    initialize: function initialize() {},
+    initialize: function () {},
     // The JSON representation of a Collection is an array of the
     // models' attributes.
-    toJSON: function toJSON(options) {
+    toJSON: function (options) {
       return this.map(function (model) {
         return model.toJSON(options);
       });
     },
     // Proxy `Backbone.sync` by default.
-    sync: function sync(method, model, options) {
+    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 add(models, options) {
+    add: function (models, options) {
       return this.set(models, assignIn({
         merge: false
       }, options, addOptions));
     },
     // Remove a model, or a list of models from the set.
-    remove: function remove(models, options) {
+    remove: function (models, options) {
       options = assignIn({}, options);
       const singular = !Array.isArray(models);
       models = singular ? [models] : models.slice();
@@ -7079,7 +7079,7 @@
     // 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 set(models, options) {
+    set: function (models, options) {
       if (models == null) return;
       options = assignIn({}, setOptions, options);
 
@@ -7195,7 +7195,7 @@
 
       return singular ? models[0] : models;
     },
-    clearStore: async function clearStore(options = {}, filter = o => o) {
+    clearStore: async function (options = {}, filter = o => o) {
       await Promise.all(this.models.filter(filter).map(m => {
         return new Promise(resolve => {
           m.destroy(Object.assign(options, {
@@ -7214,7 +7214,7 @@
     // 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 reset(models, options) {
+    reset: function (models, options) {
       options = options ? clone(options) : {};
 
       for (let i = 0; i < this.models.length; i++) {
@@ -7232,146 +7232,146 @@
       return models;
     },
     // Add a model to the end of the collection.
-    push: function push(model, options) {
+    push: function (model, options) {
       return this.add(model, assignIn({
         at: this.length
       }, options));
     },
     // Remove a model from the end of the collection.
-    pop: function pop(options) {
+    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 unshift(model, options) {
+    unshift: function (model, options) {
       return this.add(model, assignIn({
         at: 0
       }, options));
     },
     // Remove a model from the beginning of the collection.
-    shift: function shift(options) {
+    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 slice() {
-      return _slice.apply(this.models, arguments);
+    slice: function () {
+      return slice.apply(this.models, arguments);
     },
-    filter: function filter(callback, thisArg) {
+    filter: function (callback, thisArg) {
       return this.models.filter(isFunction(callback) ? callback : m => m.matches(callback), thisArg);
     },
-    every: function every$1(pred) {
+    every: function (pred) {
       return every(this.models.map(m => m.attributes), pred);
     },
-    difference: function difference$1(values) {
+    difference: function (values) {
       return difference(this.models, values);
     },
-    max: function max() {
+    max: function () {
       return Math.max.apply(Math, this.models);
     },
-    min: function min() {
+    min: function () {
       return Math.min.apply(Math, this.models);
     },
-    drop: function drop(n = 1) {
+    drop: function (n = 1) {
       return this.models.slice(n);
     },
-    some: function some$1(pred) {
+    some: function (pred) {
       return some(this.models.map(m => m.attributes), pred);
     },
-    sortBy: function sortBy$1(iteratee) {
+    sortBy: function (iteratee) {
       return sortBy(this.models, isFunction(iteratee) ? iteratee : m => isString(iteratee) ? m.get(iteratee) : m.matches(iteratee));
     },
-    isEmpty: function isEmpty$1() {
+    isEmpty: function () {
       return isEmpty(this.models);
     },
-    keyBy: function keyBy$1(iteratee) {
+    keyBy: function (iteratee) {
       return keyBy(this.models, iteratee);
     },
-    each: function each(callback, thisArg) {
+    each: function (callback, thisArg) {
       return this.forEach(callback, thisArg);
     },
-    forEach: function forEach(callback, thisArg) {
+    forEach: function (callback, thisArg) {
       return this.models.forEach(callback, thisArg);
     },
-    includes: function includes(item) {
+    includes: function (item) {
       return this.models.includes(item);
     },
-    size: function size() {
+    size: function () {
       return this.models.length;
     },
-    countBy: function countBy$1(f) {
+    countBy: function (f) {
       return countBy(this.models, isFunction(f) ? f : m => isString(f) ? m.get(f) : m.matches(f));
     },
-    groupBy: function groupBy$1(pred) {
+    groupBy: function (pred) {
       return groupBy(this.models, isFunction(pred) ? pred : m => isString(pred) ? m.get(pred) : m.matches(pred));
     },
-    indexOf: function indexOf$1(fromIndex) {
+    indexOf: function (fromIndex) {
       return indexOf(this.models, fromIndex);
     },
-    findLastIndex: function findLastIndex$1(pred, fromIndex) {
+    findLastIndex: function (pred, fromIndex) {
       return findLastIndex(this.models, isFunction(pred) ? pred : m => isString(pred) ? m.get(pred) : m.matches(pred), fromIndex);
     },
-    lastIndexOf: function lastIndexOf$1(fromIndex) {
+    lastIndexOf: function (fromIndex) {
       return lastIndexOf(this.models, fromIndex);
     },
-    findIndex: function findIndex$1(pred) {
+    findIndex: function (pred) {
       return findIndex(this.models, isFunction(pred) ? pred : m => isString(pred) ? m.get(pred) : m.matches(pred));
     },
-    last: function last() {
+    last: function () {
       const length = this.models == null ? 0 : this.models.length;
       return length ? this.models[length - 1] : undefined;
     },
-    head: function head() {
+    head: function () {
       return this.models[0];
     },
-    first: function first() {
+    first: function () {
       return this.head();
     },
-    map: function map(cb, thisArg) {
+    map: function (cb, thisArg) {
       return this.models.map(isFunction(cb) ? cb : m => isString(cb) ? m.get(cb) : m.matches(cb), thisArg);
     },
-    reduce: function reduce(callback, initialValue) {
+    reduce: function (callback, initialValue) {
       return this.models.reduce(callback, initialValue || this.models[0]);
     },
-    reduceRight: function reduceRight(callback, initialValue) {
+    reduceRight: function (callback, initialValue) {
       return this.models.reduceRight(callback, initialValue || this.models[0]);
     },
-    toArray: function toArray() {
+    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 get(obj) {
+    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 has(obj) {
+    has: function (obj) {
       return this.get(obj) != null;
     },
     // Get the model at the given index.
-    at: function at(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 where(attrs, first) {
+    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 findWhere(attrs) {
+    findWhere: function (attrs) {
       return this.where(attrs, true);
     },
-    find: function find(predicate, fromIndex) {
+    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 sort(options) {
+    sort: function (options) {
       let comparator = this.comparator;
       if (!comparator) throw new Error('Cannot sort a set without a comparator');
       options || (options = {});
@@ -7388,13 +7388,13 @@
       return this;
     },
     // Pluck an attribute from each model in the collection.
-    pluck: function pluck(attr) {
+    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 fetch(options) {
+    fetch: function (options) {
       options = assignIn({
         parse: true
       }, options);
@@ -7416,7 +7416,7 @@
     // 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 create(model, options) {
+    create: function (model, options) {
       options = options ? clone(options) : {};
       const wait = options.wait;
       const return_promise = options.promise;
@@ -7459,44 +7459,44 @@
     },
     // **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 parse(resp, options) {
+    parse: function (resp, options) {
       return resp;
     },
     // Create a new collection with an identical list of models as this one.
-    clone: function clone() {
+    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 modelId(attrs) {
+    modelId: function (attrs) {
       var _this$model$prototype;
 
       return attrs[((_this$model$prototype = this.model.prototype) === null || _this$model$prototype === void 0 ? void 0 : _this$model$prototype.idAttribute) || 'id'];
     },
     // Get an iterator of all models in this collection.
-    values: function values() {
+    values: function () {
       return new CollectionIterator(this, ITERATOR_VALUES);
     },
     // Get an iterator of all model IDs in this collection.
-    keys: function keys() {
+    keys: function () {
       return new CollectionIterator(this, ITERATOR_KEYS);
     },
     // Get an iterator of all [ID, model] tuples in this collection.
-    entries: function entries() {
+    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 _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 _prepareModel(attrs, options) {
+    _prepareModel: function (attrs, options) {
       if (this._isModel(attrs)) {
         if (!attrs.collection) attrs.collection = this;
         return attrs;
@@ -7510,7 +7510,7 @@
       return false;
     },
     // Internal method called by both remove and set.
-    _removeModels: function _removeModels(models, options) {
+    _removeModels: function (models, options) {
       const removed = [];
 
       for (let i = 0; i < models.length; i++) {
@@ -7539,18 +7539,18 @@
     },
     // Method for checking whether an object should be considered a model for
     // the purposes of adding to the collection.
-    _isModel: function _isModel(model) {
+    _isModel: function (model) {
       return model instanceof Model;
     },
     // Internal method to create a model's ties to a collection.
-    _addReference: function _addReference(model, options) {
+    _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 _removeReference(model, options) {
+    _removeReference: function (model, options) {
       delete this._byId[model.cid];
       const id = this.modelId(model.attributes);
       if (id != null) delete this._byId[id];
@@ -7561,7 +7561,7 @@
     // 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 _onModelEvent(event, model, collection, options) {
+    _onModelEvent: function (event, model, collection, options) {
       if (model) {
         if ((event === 'add' || event === 'remove') && collection !== this) return;
         if (event === 'destroy') this.remove(model, options);
@@ -7596,7 +7596,7 @@
   // which can operate on Iterables.
 
 
-  const CollectionIterator = function CollectionIterator(collection, kind) {
+  const CollectionIterator = function (collection, kind) {
     this._collection = collection;
     this._kind = kind;
     this._index = 0;
@@ -7663,7 +7663,7 @@
   // and URL fragments. If the browser supports neither (old IE, natch),
   // falls back to polling.
 
-  const History = function History() {
+  const History = function () {
     this.handlers = [];
     this.checkUrl = this.checkUrl.bind(this); // Ensure that `History` can be used outside of the browser.
 
@@ -7688,12 +7688,12 @@
     // twenty times a second.
     interval: 50,
     // Are we at the app root?
-    atRoot: function atRoot() {
+    atRoot: function () {
       const path = this.location.pathname.replace(/[^\/]$/, '$&/');
       return path === this.root && !this.getSearch();
     },
     // Does the pathname match the root?
-    matchRoot: function matchRoot() {
+    matchRoot: function () {
       const path = this.decodeFragment(this.location.pathname);
       const rootPath = path.slice(0, this.root.length - 1) + '/';
       return rootPath === this.root;
@@ -7701,28 +7701,28 @@
     // 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 decodeFragment(fragment) {
+    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 getSearch() {
+    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 getHash(window) {
+    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 getPath() {
+    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 getFragment(fragment) {
+    getFragment: function (fragment) {
       if (fragment == null) {
         if (this._usePushState || !this._wantsHashChange) {
           fragment = this.getPath();
@@ -7735,7 +7735,7 @@
     },
     // Start the hash change handling, returning `true` if the current URL matches
     // an existing route, and `false` otherwise.
-    start: function start(options) {
+    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?
@@ -7801,7 +7801,7 @@
     },
     // Disable history, perhaps temporarily. Not useful in a real app,
     // but possibly useful for unit testing Routers.
-    stop: function stop() {
+    stop: function () {
       // Remove window listeners.
       if (this._usePushState) {
         removeEventListener('popstate', this.checkUrl, false);
@@ -7821,15 +7821,15 @@
     },
     // Add a route to be tested when the fragment changes. Routes added later
     // may override previous routes.
-    route: function route(_route, callback) {
+    route: function (route, callback) {
       this.handlers.unshift({
-        route: _route,
+        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 checkUrl(e) {
+    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.
 
@@ -7844,7 +7844,7 @@
     // 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 loadUrl(fragment) {
+    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);
@@ -7862,7 +7862,7 @@
     // 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 navigate(fragment, options) {
+    navigate: function (fragment, options) {
       if (!History.started) return false;
       if (!options || options === true) options = {
         trigger: !!options
@@ -7912,7 +7912,7 @@
     },
     // Update the hash location, either replacing the current entry, or adding
     // a new one to the browser history.
-    _updateHash: function _updateHash(location, fragment, replace) {
+    _updateHash: function (location, fragment, replace) {
       if (replace) {
         const href = location.href.replace(/(javascript:|#).*$/, '');
         location.replace(href + '#' + fragment);
@@ -7964,7 +7964,7 @@
   //     Backbone.js 1.4.0
   // matched. Creating a new one sets its `routes` hash, if not set statically.
 
-  const Router = function Router(options = {}) {
+  const Router = function (options = {}) {
     this.history = options.history || new History();
     this.preinitialize.apply(this, arguments);
     if (options.routes) this.routes = options.routes;
@@ -7984,18 +7984,18 @@
   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 preinitialize() {},
+    preinitialize: function () {},
     // Initialize is an empty function by default. Override it with your own
     // initialization logic.
-    initialize: function initialize() {},
+    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(_route, name, callback) {
-      if (!isRegExp(_route)) _route = this._routeToRegExp(_route);
+    route: function (route, name, callback) {
+      if (!isRegExp(route)) route = this._routeToRegExp(route);
 
       if (isFunction(name)) {
         callback = name;
@@ -8003,8 +8003,8 @@
       }
 
       if (!callback) callback = this[name];
-      this.history.route(_route, fragment => {
-        const args = this._extractParameters(_route, fragment);
+      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));
@@ -8016,18 +8016,18 @@
     },
     // Execute a route handler with the provided parameters.  This is an
     // excellent place to do pre-route setup or post-route cleanup.
-    execute: function execute(callback, args, name) {
+    execute: function (callback, args, name) {
       if (callback) callback.apply(this, args);
     },
     // Simple proxy to `history` to save a fragment into the history.
-    navigate: function navigate(fragment, options) {
+    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 _bindRoutes() {
+    _bindRoutes: function () {
       if (!this.routes) return;
       this.routes = result(this, 'routes');
       let route;
@@ -8039,7 +8039,7 @@
     },
     // Convert a route string into a regular expression, suitable for matching
     // against the current location hash.
-    _routeToRegExp: function _routeToRegExp(route) {
+    _routeToRegExp: function (route) {
       route = route.replace(escapeRegExp, '\\$&').replace(optionalParam, '(?:$1)?').replace(namedParam, function (match, optional) {
         return optional ? match : '([^/?]+)';
       }).replace(splatParam, '([^?]*?)');
@@ -8048,7 +8048,7 @@
     // 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 _extractParameters(route, fragment) {
+    _extractParameters: function (route, fragment) {
       const params = route.exec(fragment).slice(1);
       return params.map(function (param, i) {
         // Don't decode the search params.
@@ -8069,9 +8069,9 @@
         l = o ? o.createPolicy("lit-html", {
     createHTML: t => t
   }) : void 0,
-        n = "lit$".concat((Math.random() + "").slice(9), "$"),
+        n = `lit$${(Math.random() + "").slice(9)}$`,
         h = "?" + n,
-        r = "<".concat(h, ">"),
+        r = `<${h}>`,
         u = document,
         c = (t = "") => u.createComment(t),
         d = t => null === t || "object" != typeof t && "function" != typeof t,
@@ -8426,7 +8426,7 @@
   // if an existing element is not provided...
 
 
-  const View = function View(options) {
+  const View = function (options) {
     this.cid = uniqueId('view');
     this._domEvents = [];
     this.preinitialize.apply(this, arguments);
@@ -8445,19 +8445,19 @@
   Object.assign(View.prototype, Events, {
     // The default `tagName` of a View's element is `"div"`.
     tagName: 'div',
-    $: function $(selector) {
+    $: 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 preinitialize() {},
+    preinitialize: function () {},
     // Initialize is an empty function by default. Override it with your own
     // initialization logic.
-    initialize: function initialize() {},
+    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 render() {
+    render: function () {
       isFunction(this.beforeRender) && this.beforeRender();
       isFunction(this.toHTML) && V(this.toHTML(), this.el);
       isFunction(this.afterRender) && this.afterRender();
@@ -8465,7 +8465,7 @@
     },
     // Remove this view by taking the element out of the DOM, and removing any
     // applicable Backbone.Events listeners.
-    remove: function remove() {
+    remove: function () {
       this._removeElement();
 
       this.stopListening();
@@ -8474,13 +8474,13 @@
     // 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 _removeElement() {
+    _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 setElement(element) {
+    setElement: function (element) {
       this.undelegateEvents();
 
       this._setElement(element);
@@ -8491,7 +8491,7 @@
     // 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 _setElement(element) {
+    _setElement: function (element) {
       if (typeof element == 'string') {
         if (paddedLt.test(element)) {
           const el = document.createElement('div');
@@ -8519,7 +8519,7 @@
     // 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 delegateEvents(events) {
+    delegateEvents: function (events) {
       events || (events = result(this, 'events'));
       if (!events) return this;
       this.undelegateEvents();
@@ -8542,7 +8542,7 @@
     // 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 delegate(eventName, selector, listener) {
+    delegate: function (eventName, selector, listener) {
       const root = this.el;
 
       if (!root) {
@@ -8597,7 +8597,7 @@
     // 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 undelegateEvents() {
+    undelegateEvents: function () {
       if (this.el) {
         for (let i = 0, len = this._domEvents.length; i < len; i++) {
           const item = this._domEvents[i];
@@ -8611,7 +8611,7 @@
     },
     // A finer-grained `undelegateEvents` for removing a single delegated event.
     // `selector` and `listener` are both optional.
-    undelegate: function undelegate(eventName, selector, listener) {
+    undelegate: function (eventName, selector, listener) {
       if (typeof selector === 'function') {
         listener = selector;
         selector = null;
@@ -8640,14 +8640,14 @@
     },
     // Produces a DOM element to be assigned to your view. Exposed for
     // subclasses using an alternative DOM manipulation API.
-    _createElement: function _createElement(tagName) {
+    _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 _ensureElement() {
+    _ensureElement: function () {
       if (!this.el) {
         const attrs = assignIn({}, result(this, 'attributes'));
         if (this.id) attrs.id = result(this, 'id');
@@ -8661,7 +8661,7 @@
     },
     // Set attributes from a hash on this view's element.  Exposed for
     // subclasses using an alternative DOM manipulation API.
-    _setAttributes: function _setAttributes(attrs) {
+    _setAttributes: function (attrs) {
       for (const attr in attrs) {
         attr in this.el ? this.el[attr] = attrs[attr] : this.el.setAttribute(attr, attrs[attr]);
       }