@converse/skeletor 0.0.3 → 0.0.6

package/dist/skeletor.js

@@ -1323,7 +1323,7 @@
    * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
    */
 
-  function keysIn$1(object) {
+  function keysIn(object) {
     return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
   }
 
@@ -1360,7 +1360,7 @@
    */
 
   var assignIn = createAssigner(function (object, source) {
-    copyObject(source, keysIn$1(source), object);
+    copyObject(source, keysIn(source), object);
   });
 
   /** Used for built-in method references. */
@@ -1716,7 +1716,7 @@
 
   /* Built-in method references that are verified to be native. */
 
-  var Map$1 = getNative(root, 'Map');
+  var Map = getNative(root, 'Map');
 
   /**
    * Removes all key-value entries from the map.
@@ -1730,7 +1730,7 @@
     this.size = 0;
     this.__data__ = {
       'hash': new Hash(),
-      'map': new (Map$1 || ListCache)(),
+      'map': new (Map || ListCache)(),
       'string': new Hash()
     };
   }
@@ -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.
@@ -2376,7 +2376,7 @@
   /** Used to detect maps, sets, and weakmaps. */
 
   var dataViewCtorString = toSource(DataView),
-      mapCtorString = toSource(Map$1),
+      mapCtorString = toSource(Map),
       promiseCtorString = toSource(Promise$1),
       setCtorString = toSource(Set),
       weakMapCtorString = toSource(WeakMap$1);
@@ -2390,8 +2390,8 @@
 
   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$1 && getTag(new Map$1()) != 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) {
+  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 (value) {
       var result = baseGetTag(value),
           Ctor = result == objectTag$1 ? value.constructor : undefined,
           ctorString = Ctor ? toSource(Ctor) : '';
@@ -2493,12 +2493,43 @@
     return true;
   }
 
+  /** Used to match a single whitespace character. */
+  var reWhitespace = /\s/;
+  /**
+   * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+   * character of `string`.
+   *
+   * @private
+   * @param {string} string The string to inspect.
+   * @returns {number} Returns the index of the last non-whitespace character.
+   */
+
+  function trimmedEndIndex(string) {
+    var index = string.length;
+
+    while (index-- && reWhitespace.test(string.charAt(index))) {}
+
+    return index;
+  }
+
+  /** Used to match leading whitespace. */
+
+  var reTrimStart = /^\s+/;
+  /**
+   * The base implementation of `_.trim`.
+   *
+   * @private
+   * @param {string} string The string to trim.
+   * @returns {string} Returns the trimmed string.
+   */
+
+  function baseTrim(string) {
+    return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string;
+  }
+
   /** Used as references for various `Number` constants. */
 
   var NAN = 0 / 0;
-  /** Used to match leading and trailing whitespace. */
-
-  var reTrim = /^\s+|\s+$/g;
   /** Used to detect bad signed hexadecimal string values. */
 
   var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
@@ -2553,7 +2584,7 @@
       return value === 0 ? value : +value;
     }
 
-    value = value.replace(reTrim, '');
+    value = baseTrim(value);
     var isBinary = reIsBinary.test(value);
     return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
   }
@@ -2735,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;
 
@@ -2804,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,
@@ -2824,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) {
@@ -2866,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;
@@ -2936,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);
@@ -2965,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;
@@ -2980,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,
@@ -3018,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;
@@ -3134,7 +3165,7 @@
     if (data instanceof ListCache) {
       var pairs = data.__data__;
 
-      if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
         pairs.push([key, value]);
         this.size = ++data.size;
         return this;
@@ -3201,7 +3232,7 @@
    */
 
   function baseAssignIn(object, source) {
-    return object && copyObject(source, keysIn$1(source), object);
+    return object && copyObject(source, keysIn(source), object);
   }
 
   /** Detect free variable `exports`. */
@@ -3444,7 +3475,7 @@
    */
 
   function getAllKeysIn(object) {
-    return baseGetAllKeys(object, keysIn$1, getSymbolsIn);
+    return baseGetAllKeys(object, keysIn, getSymbolsIn);
   }
 
   /** Used for built-in method references. */
@@ -3927,7 +3958,7 @@
 
     while (++index < length) {
       var source = sources[index];
-      var props = keysIn$1(source);
+      var props = keysIn(source);
       var propsIndex = -1;
       var propsLength = props.length;
 
@@ -4381,13 +4412,14 @@
 
     if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
       return false;
-    } // Assume cyclic values are equal.
+    } // Check that cyclic values are equal.
 
 
-    var stacked = stack.get(array);
+    var arrStacked = stack.get(array);
+    var othStacked = stack.get(other);
 
-    if (stacked && stack.get(other)) {
-      return stacked == other;
+    if (arrStacked && othStacked) {
+      return arrStacked == other && othStacked == array;
     }
 
     var index = -1,
@@ -4616,13 +4648,14 @@
       if (!(isPartial ? key in other : hasOwnProperty$e.call(other, key))) {
         return false;
       }
-    } // Assume cyclic values are equal.
+    } // Check that cyclic values are equal.
 
 
-    var stacked = stack.get(object);
+    var objStacked = stack.get(object);
+    var othStacked = stack.get(other);
 
-    if (stacked && stack.get(other)) {
-      return stacked == other;
+    if (objStacked && othStacked) {
+      return objStacked == other && othStacked == object;
     }
 
     var result = true;
@@ -5436,6 +5469,10 @@
       var key = toKey(path[index]),
           newValue = value;
 
+      if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+        return object;
+      }
+
       if (index != lastIndex) {
         var objValue = nested[key];
         newValue = customizer ? customizer(objValue, key, nested) : undefined;
@@ -5518,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);
@@ -5547,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;
@@ -5685,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;
@@ -5702,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);
     },
@@ -5712,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 = {};
@@ -5729,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);
@@ -5760,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;
 
@@ -5828,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);
       };
@@ -5860,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);
@@ -5868,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;
@@ -6869,8 +6906,22 @@
    */
 
   function baseOrderBy(collection, iteratees, orders) {
+    if (iteratees.length) {
+      iteratees = arrayMap(iteratees, function (iteratee) {
+        if (isArray(iteratee)) {
+          return function (value) {
+            return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+          };
+        }
+
+        return iteratee;
+      });
+    } else {
+      iteratees = [identity];
+    }
+
     var index = -1;
-    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
+    iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
     var result = baseMap(collection, function (value, key, collection) {
       var criteria = arrayMap(iteratees, function (iteratee) {
         return iteratee(value);
@@ -6905,15 +6956,15 @@
    * var users = [
    *   { 'user': 'fred',   'age': 48 },
    *   { 'user': 'barney', 'age': 36 },
-   *   { 'user': 'fred',   'age': 40 },
+   *   { 'user': 'fred',   'age': 30 },
    *   { 'user': 'barney', 'age': 34 }
    * ];
    *
    * _.sortBy(users, [function(o) { return o.user; }]);
-   * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
+   * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
    *
    * _.sortBy(users, ['user', 'age']);
-   * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]
+   * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
    */
 
   var sortBy = baseRest(function (collection, iteratees) {
@@ -6933,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;
@@ -6962,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;
@@ -6982,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();
@@ -7028,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);
 
@@ -7144,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, {
@@ -7163,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++) {
@@ -7181,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 = {});
@@ -7337,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);
@@ -7365,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;
@@ -7408,42 +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) {
-      return attrs[this.model.prototype.idAttribute || 'id'];
+    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;
@@ -7457,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++) {
@@ -7486,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];
@@ -7508,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);
@@ -7543,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;
@@ -7610,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.
 
@@ -7635,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;
@@ -7648,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();
@@ -7682,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?
@@ -7748,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);
@@ -7768,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.
 
@@ -7791,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);
@@ -7809,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
@@ -7859,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);
@@ -7911,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;
@@ -7931,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;
@@ -7950,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));
@@ -7963,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;
@@ -7986,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, '([^?]*?)');
@@ -7995,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.
@@ -8007,966 +8060,373 @@
 
   /**
    * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-  const directives = new WeakMap();
-  const isDirective = o => {
-    return typeof o === 'function' && directives.has(o);
+   * Copyright 2017 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   */
+  var t, i, s, e;
+
+  const o = globalThis.trustedTypes,
+        l = o ? o.createPolicy("lit-html", {
+    createHTML: t => t
+  }) : void 0,
+        n = `lit$${(Math.random() + "").slice(9)}$`,
+        h = "?" + n,
+        r = `<${h}>`,
+        u = document,
+        c = (t = "") => u.createComment(t),
+        d = t => null === t || "object" != typeof t && "function" != typeof t,
+        v = Array.isArray,
+        a = t => {
+    var i;
+    return v(t) || "function" == typeof (null === (i = t) || void 0 === i ? void 0 : i[Symbol.iterator]);
+  },
+        f = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g,
+        _ = /-->/g,
+        m = />/g,
+        p = />|[ 	\n\r](?:([^\s"'>=/]+)([ 	\n\r]*=[ 	\n\r]*(?:[^ 	\n\r"'`<>=]|("|')|))|$)/g,
+        $ = /'/g,
+        g = /"/g,
+        y = /^(?:script|style|textarea)$/i,
+        w = Symbol.for("lit-noChange"),
+        A = Symbol.for("lit-nothing"),
+        P = new WeakMap(),
+        V = (t, i, s) => {
+    var e, o;
+    const l = null !== (e = null == s ? void 0 : s.renderBefore) && void 0 !== e ? e : i;
+    let n = l._$litPart$;
+
+    if (void 0 === n) {
+      const t = null !== (o = null == s ? void 0 : s.renderBefore) && void 0 !== o ? o : null;
+      l._$litPart$ = n = new C(i.insertBefore(c(), t), t, void 0, s);
+    }
+
+    return n.I(t), n;
+  },
+        E = u.createTreeWalker(u, 129, null, !1),
+        M = (t, i) => {
+    const s = t.length - 1,
+          e = [];
+    let o,
+        h = 2 === i ? "<svg>" : "",
+        u = f;
+
+    for (let i = 0; i < s; i++) {
+      const s = t[i];
+      let l,
+          c,
+          d = -1,
+          v = 0;
+
+      for (; v < s.length && (u.lastIndex = v, c = u.exec(s), null !== c);) v = u.lastIndex, u === f ? "!--" === c[1] ? u = _ : void 0 !== c[1] ? u = m : void 0 !== c[2] ? (y.test(c[2]) && (o = RegExp("</" + c[2], "g")), u = p) : void 0 !== c[3] && (u = p) : u === p ? ">" === c[0] ? (u = null != o ? o : f, d = -1) : void 0 === c[1] ? d = -2 : (d = u.lastIndex - c[2].length, l = c[1], u = void 0 === c[3] ? p : '"' === c[3] ? g : $) : u === g || u === $ ? u = p : u === _ || u === m ? u = f : (u = p, o = void 0);
+
+      const a = u === p && t[i + 1].startsWith("/>") ? " " : "";
+      h += u === f ? s + r : d >= 0 ? (e.push(l), s.slice(0, d) + "$lit$" + s.slice(d) + n + a) : s + n + (-2 === d ? (e.push(void 0), i) : a);
+    }
+
+    const c = h + (t[s] || "<?>") + (2 === i ? "</svg>" : "");
+    return [void 0 !== l ? l.createHTML(c) : c, e];
   };
 
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-
-  /**
-   * True if the custom elements polyfill is in use.
-   */
-  const isCEPolyfill = typeof window !== 'undefined' && window.customElements != null && window.customElements.polyfillWrapFlushCallback !== undefined;
-  /**
-   * Removes nodes, starting from `start` (inclusive) to `end` (exclusive), from
-   * `container`.
-   */
-
-  const removeNodes = (container, start, end = null) => {
-    while (start !== end) {
-      const n = start.nextSibling;
-      container.removeChild(start);
-      start = n;
-    }
-  };
-
-  /**
-   * @license
-   * Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-
-  /**
-   * A sentinel value that signals that a value was handled by a directive and
-   * should not be written to the DOM.
-   */
-  const noChange = {};
-  /**
-   * A sentinel value that signals a NodePart to fully clear its content.
-   */
-
-  const nothing = {};
-
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-
-  /**
-   * An expression marker with embedded unique key to avoid collision with
-   * possible text in templates.
-   */
-  const marker = "{{lit-".concat(String(Math.random()).slice(2), "}}");
-  /**
-   * An expression marker used text-positions, multi-binding attributes, and
-   * attributes with markup-like text values.
-   */
-
-  const nodeMarker = "<!--".concat(marker, "-->");
-  const markerRegex = new RegExp("".concat(marker, "|").concat(nodeMarker));
-  /**
-   * Suffix appended to all bound attribute names.
-   */
-
-  const boundAttributeSuffix = '$lit$';
-  /**
-   * An updatable Template that tracks the location of dynamic parts.
-   */
-
-  class Template {
-    constructor(result, element) {
+  class N {
+    constructor({
+      strings: t,
+      _$litType$: i
+    }, s) {
+      let e;
       this.parts = [];
-      this.element = element;
-      const nodesToRemove = [];
-      const stack = []; // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null
-
-      const walker = document.createTreeWalker(element.content, 133
-      /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */
-      , null, false); // Keeps track of the last index associated with a part. We try to delete
-      // unnecessary nodes, but we never want to associate two different parts
-      // to the same index. They must have a constant node between.
-
-      let lastPartIndex = 0;
-      let index = -1;
-      let partIndex = 0;
-      const {
-        strings,
-        values: {
-          length
-        }
-      } = result;
-
-      while (partIndex < length) {
-        const node = walker.nextNode();
-
-        if (node === null) {
-          // We've exhausted the content inside a nested template element.
-          // Because we still have parts (the outer for-loop), we know:
-          // - There is a template in the stack
-          // - The walker will find a nextNode outside the template
-          walker.currentNode = stack.pop();
-          continue;
-        }
+      let l = 0,
+          r = 0;
+      const u = t.length - 1,
+            d = this.parts,
+            [v, a] = M(t, i);
+
+      if (this.el = N.createElement(v, s), E.currentNode = this.el.content, 2 === i) {
+        const t = this.el.content,
+              i = t.firstChild;
+        i.remove(), t.append(...i.childNodes);
+      }
 
-        index++;
-
-        if (node.nodeType === 1
-        /* Node.ELEMENT_NODE */
-        ) {
-            if (node.hasAttributes()) {
-              const attributes = node.attributes;
-              const {
-                length
-              } = attributes; // Per
-              // https://developer.mozilla.org/en-US/docs/Web/API/NamedNodeMap,
-              // attributes are not guaranteed to be returned in document order.
-              // In particular, Edge/IE can return them out of order, so we cannot
-              // assume a correspondence between part index and attribute index.
-
-              let count = 0;
-
-              for (let i = 0; i < length; i++) {
-                if (endsWith(attributes[i].name, boundAttributeSuffix)) {
-                  count++;
-                }
-              }
-
-              while (count-- > 0) {
-                // Get the template literal section leading up to the first
-                // expression in this attribute
-                const stringForPart = strings[partIndex]; // Find the attribute name
-
-                const name = lastAttributeNameRegex.exec(stringForPart)[2]; // Find the corresponding attribute
-                // All bound attributes have had a suffix added in
-                // TemplateResult#getHTML to opt out of special attribute
-                // handling. To look up the attribute value we also need to add
-                // the suffix.
-
-                const attributeLookupName = name.toLowerCase() + boundAttributeSuffix;
-                const attributeValue = node.getAttribute(attributeLookupName);
-                node.removeAttribute(attributeLookupName);
-                const statics = attributeValue.split(markerRegex);
-                this.parts.push({
-                  type: 'attribute',
-                  index,
-                  name,
-                  strings: statics
+      for (; null !== (e = E.nextNode()) && d.length < u;) {
+        if (1 === e.nodeType) {
+          if (e.hasAttributes()) {
+            const t = [];
+
+            for (const i of e.getAttributeNames()) if (i.endsWith("$lit$") || i.startsWith(n)) {
+              const s = a[r++];
+
+              if (t.push(i), void 0 !== s) {
+                const t = e.getAttribute(s.toLowerCase() + "$lit$").split(n),
+                      i = /([.?@])?(.*)/.exec(s);
+                d.push({
+                  type: 1,
+                  index: l,
+                  name: i[2],
+                  strings: t,
+                  ctor: "." === i[1] ? I : "?" === i[1] ? L : "@" === i[1] ? R : H
                 });
-                partIndex += statics.length - 1;
-              }
+              } else d.push({
+                type: 6,
+                index: l
+              });
             }
 
-            if (node.tagName === 'TEMPLATE') {
-              stack.push(node);
-              walker.currentNode = node.content;
-            }
-          } else if (node.nodeType === 3
-        /* Node.TEXT_NODE */
-        ) {
-            const data = node.data;
-
-            if (data.indexOf(marker) >= 0) {
-              const parent = node.parentNode;
-              const strings = data.split(markerRegex);
-              const lastIndex = strings.length - 1; // Generate a new text node for each literal section
-              // These nodes are also used as the markers for node parts
-
-              for (let i = 0; i < lastIndex; i++) {
-                let insert;
-                let s = strings[i];
-
-                if (s === '') {
-                  insert = createMarker();
-                } else {
-                  const match = lastAttributeNameRegex.exec(s);
-
-                  if (match !== null && endsWith(match[2], boundAttributeSuffix)) {
-                    s = s.slice(0, match.index) + match[1] + match[2].slice(0, -boundAttributeSuffix.length) + match[3];
-                  }
-
-                  insert = document.createTextNode(s);
-                }
-
-                parent.insertBefore(insert, node);
-                this.parts.push({
-                  type: 'node',
-                  index: ++index
-                });
-              } // If there's no text, we must insert a comment to mark our place.
-              // Else, we can trust it will stick around after cloning.
+            for (const i of t) e.removeAttribute(i);
+          }
 
+          if (y.test(e.tagName)) {
+            const t = e.textContent.split(n),
+                  i = t.length - 1;
 
-              if (strings[lastIndex] === '') {
-                parent.insertBefore(createMarker(), node);
-                nodesToRemove.push(node);
-              } else {
-                node.data = strings[lastIndex];
-              } // We have a part for each match found
+            if (i > 0) {
+              e.textContent = o ? o.emptyScript : "";
 
+              for (let s = 0; s < i; s++) e.append(t[s], c()), E.nextNode(), d.push({
+                type: 2,
+                index: ++l
+              });
 
-              partIndex += lastIndex;
-            }
-          } else if (node.nodeType === 8
-        /* Node.COMMENT_NODE */
-        ) {
-            if (node.data === marker) {
-              const parent = node.parentNode; // Add a new marker node to be the startNode of the Part if any of
-              // the following are true:
-              //  * We don't have a previousSibling
-              //  * The previousSibling is already the start of a previous part
-
-              if (node.previousSibling === null || index === lastPartIndex) {
-                index++;
-                parent.insertBefore(createMarker(), node);
-              }
-
-              lastPartIndex = index;
-              this.parts.push({
-                type: 'node',
-                index
-              }); // If we don't have a nextSibling, keep this node so we have an end.
-              // Else, we can remove it to save future costs.
-
-              if (node.nextSibling === null) {
-                node.data = '';
-              } else {
-                nodesToRemove.push(node);
-                index--;
-              }
-
-              partIndex++;
-            } else {
-              let i = -1;
-
-              while ((i = node.data.indexOf(marker, i + 1)) !== -1) {
-                // Comment node has a binding marker inside, make an inactive part
-                // The binding won't work, but subsequent bindings will
-                // TODO (justinfagnani): consider whether it's even worth it to
-                // make bindings in comments work
-                this.parts.push({
-                  type: 'node',
-                  index: -1
-                });
-                partIndex++;
-              }
+              e.append(t[i], c());
             }
           }
-      } // Remove text binding nodes after the walk to not disturb the TreeWalker
-
+        } else if (8 === e.nodeType) if (e.data === h) d.push({
+          type: 2,
+          index: l
+        });else {
+          let t = -1;
+
+          for (; -1 !== (t = e.data.indexOf(n, t + 1));) d.push({
+            type: 7,
+            index: l
+          }), t += n.length - 1;
+        }
 
-      for (const n of nodesToRemove) {
-        n.parentNode.removeChild(n);
+        l++;
       }
     }
 
-  }
-
-  const endsWith = (str, suffix) => {
-    const index = str.length - suffix.length;
-    return index >= 0 && str.slice(index) === suffix;
-  };
-
-  const isTemplatePartActive = part => part.index !== -1; // Allows `document.createComment('')` to be renamed for a
-  // small manual size-savings.
-
-  const createMarker = () => document.createComment('');
-  /**
-   * This regex extracts the attribute name preceding an attribute-position
-   * expression. It does this by matching the syntax allowed for attributes
-   * against the string literal directly preceding the expression, assuming that
-   * the expression is in an attribute-value position.
-   *
-   * See attributes in the HTML spec:
-   * https://www.w3.org/TR/html5/syntax.html#elements-attributes
-   *
-   * " \x09\x0a\x0c\x0d" are HTML space characters:
-   * https://www.w3.org/TR/html5/infrastructure.html#space-characters
-   *
-   * "\0-\x1F\x7F-\x9F" are Unicode control characters, which includes every
-   * space character except " ".
-   *
-   * So an attribute is:
-   *  * The name: any character except a control character, space character, ('),
-   *    ("), ">", "=", or "/"
-   *  * Followed by zero or more space characters
-   *  * Followed by "="
-   *  * Followed by zero or more space characters
-   *  * Followed by:
-   *    * Any character except space, ('), ("), "<", ">", "=", (`), or
-   *    * (") then any non-("), or
-   *    * (') then any non-(')
-   */
+    static createElement(t, i) {
+      const s = u.createElement("template");
+      return s.innerHTML = t, s;
+    }
 
-  const lastAttributeNameRegex = // eslint-disable-next-line no-control-regex
-  /([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;
+  }
 
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-  /**
-   * An instance of a `Template` that can be attached to the DOM and updated
-   * with new values.
-   */
+  function S(t, i, s = t, e) {
+    var o, l, n, h;
+    if (i === w) return i;
+    let r = void 0 !== e ? null === (o = s.Σi) || void 0 === o ? void 0 : o[e] : s.Σo;
+    const u = d(i) ? void 0 : i._$litDirective$;
+    return (null == r ? void 0 : r.constructor) !== u && (null === (l = null == r ? void 0 : r.O) || void 0 === l || l.call(r, !1), void 0 === u ? r = void 0 : (r = new u(t), r.T(t, s, e)), void 0 !== e ? (null !== (n = (h = s).Σi) && void 0 !== n ? n : h.Σi = [])[e] = r : s.Σo = r), void 0 !== r && (i = S(t, r.S(t, i.values), r, e)), i;
+  }
 
-  class TemplateInstance {
-    constructor(template, processor, options) {
-      this.__parts = [];
-      this.template = template;
-      this.processor = processor;
-      this.options = options;
+  class k {
+    constructor(t, i) {
+      this.l = [], this.N = void 0, this.D = t, this.M = i;
     }
 
-    update(values) {
-      let i = 0;
-
-      for (const part of this.__parts) {
-        if (part !== undefined) {
-          part.setValue(values[i]);
+    u(t) {
+      var i;
+      const {
+        el: {
+          content: s
+        },
+        parts: e
+      } = this.D,
+            o = (null !== (i = null == t ? void 0 : t.creationScope) && void 0 !== i ? i : u).importNode(s, !0);
+      E.currentNode = o;
+      let l = E.nextNode(),
+          n = 0,
+          h = 0,
+          r = e[0];
+
+      for (; void 0 !== r;) {
+        if (n === r.index) {
+          let i;
+          2 === r.type ? i = new C(l, l.nextSibling, this, t) : 1 === r.type ? i = new r.ctor(l, r.name, r.strings, this, t) : 6 === r.type && (i = new z(l, this, t)), this.l.push(i), r = e[++h];
         }
 
-        i++;
+        n !== (null == r ? void 0 : r.index) && (l = E.nextNode(), n++);
       }
 
-      for (const part of this.__parts) {
-        if (part !== undefined) {
-          part.commit();
-        }
-      }
+      return o;
     }
 
-    _clone() {
-      // There are a number of steps in the lifecycle of a template instance's
-      // DOM fragment:
-      //  1. Clone - create the instance fragment
-      //  2. Adopt - adopt into the main document
-      //  3. Process - find part markers and create parts
-      //  4. Upgrade - upgrade custom elements
-      //  5. Update - set node, attribute, property, etc., values
-      //  6. Connect - connect to the document. Optional and outside of this
-      //     method.
-      //
-      // We have a few constraints on the ordering of these steps:
-      //  * We need to upgrade before updating, so that property values will pass
-      //    through any property setters.
-      //  * We would like to process before upgrading so that we're sure that the
-      //    cloned fragment is inert and not disturbed by self-modifying DOM.
-      //  * We want custom elements to upgrade even in disconnected fragments.
-      //
-      // Given these constraints, with full custom elements support we would
-      // prefer the order: Clone, Process, Adopt, Upgrade, Update, Connect
-      //
-      // But Safari does not implement CustomElementRegistry#upgrade, so we
-      // can not implement that order and still have upgrade-before-update and
-      // upgrade disconnected fragments. So we instead sacrifice the
-      // process-before-upgrade constraint, since in Custom Elements v1 elements
-      // must not modify their light DOM in the constructor. We still have issues
-      // when co-existing with CEv0 elements like Polymer 1, and with polyfills
-      // that don't strictly adhere to the no-modification rule because shadow
-      // DOM, which may be created in the constructor, is emulated by being placed
-      // in the light DOM.
-      //
-      // The resulting order is on native is: Clone, Adopt, Upgrade, Process,
-      // Update, Connect. document.importNode() performs Clone, Adopt, and Upgrade
-      // in one step.
-      //
-      // The Custom Elements v1 polyfill supports upgrade(), so the order when
-      // polyfilled is the more ideal: Clone, Process, Adopt, Upgrade, Update,
-      // Connect.
-      const fragment = isCEPolyfill ? this.template.element.content.cloneNode(true) : document.importNode(this.template.element.content, true);
-      const stack = [];
-      const parts = this.template.parts; // Edge needs all 4 parameters present; IE11 needs 3rd parameter to be null
-
-      const walker = document.createTreeWalker(fragment, 133
-      /* NodeFilter.SHOW_{ELEMENT|COMMENT|TEXT} */
-      , null, false);
-      let partIndex = 0;
-      let nodeIndex = 0;
-      let part;
-      let node = walker.nextNode(); // Loop through all the nodes and parts of a template
-
-      while (partIndex < parts.length) {
-        part = parts[partIndex];
-
-        if (!isTemplatePartActive(part)) {
-          this.__parts.push(undefined);
-
-          partIndex++;
-          continue;
-        } // Progress the tree walker until we find our next part's node.
-        // Note that multiple parts may share the same node (attribute parts
-        // on a single element), so this loop may not run at all.
-
-
-        while (nodeIndex < part.index) {
-          nodeIndex++;
-
-          if (node.nodeName === 'TEMPLATE') {
-            stack.push(node);
-            walker.currentNode = node.content;
-          }
-
-          if ((node = walker.nextNode()) === null) {
-            // We've exhausted the content inside a nested template element.
-            // Because we still have parts (the outer for-loop), we know:
-            // - There is a template in the stack
-            // - The walker will find a nextNode outside the template
-            walker.currentNode = stack.pop();
-            node = walker.nextNode();
-          }
-        } // We've arrived at our part's node.
-
-
-        if (part.type === 'node') {
-          const part = this.processor.handleTextExpression(this.options);
-          part.insertAfterNode(node.previousSibling);
-
-          this.__parts.push(part);
-        } else {
-          this.__parts.push(...this.processor.handleAttributeExpressions(node, part.name, part.strings, this.options));
-        }
-
-        partIndex++;
-      }
-
-      if (isCEPolyfill) {
-        document.adoptNode(fragment);
-        customElements.upgrade(fragment);
-      }
+    v(t) {
+      let i = 0;
 
-      return fragment;
+      for (const s of this.l) void 0 !== s && (void 0 !== s.strings ? (s.I(t, s, i), i += s.strings.length - 2) : s.I(t[i])), i++;
     }
 
   }
 
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-  const commentMarker = " ".concat(marker, " ");
-  /**
-   * The return type of `html`, which holds a Template and the values from
-   * interpolated expressions.
-   */
-
-  class TemplateResult {
-    constructor(strings, values, type, processor) {
-      this.strings = strings;
-      this.values = values;
-      this.type = type;
-      this.processor = processor;
-    }
-    /**
-     * Returns a string of HTML used to create a `<template>` element.
-     */
-
-
-    getHTML() {
-      const l = this.strings.length - 1;
-      let html = '';
-      let isCommentBinding = false;
-
-      for (let i = 0; i < l; i++) {
-        const s = this.strings[i]; // For each binding we want to determine the kind of marker to insert
-        // into the template source before it's parsed by the browser's HTML
-        // parser. The marker type is based on whether the expression is in an
-        // attribute, text, or comment position.
-        //   * For node-position bindings we insert a comment with the marker
-        //     sentinel as its text content, like <!--{{lit-guid}}-->.
-        //   * For attribute bindings we insert just the marker sentinel for the
-        //     first binding, so that we support unquoted attribute bindings.
-        //     Subsequent bindings can use a comment marker because multi-binding
-        //     attributes must be quoted.
-        //   * For comment bindings we insert just the marker sentinel so we don't
-        //     close the comment.
-        //
-        // The following code scans the template source, but is *not* an HTML
-        // parser. We don't need to track the tree structure of the HTML, only
-        // whether a binding is inside a comment, and if not, if it appears to be
-        // the first binding in an attribute.
-
-        const commentOpen = s.lastIndexOf('<!--'); // We're in comment position if we have a comment open with no following
-        // comment close. Because <-- can appear in an attribute value there can
-        // be false positives.
-
-        isCommentBinding = (commentOpen > -1 || isCommentBinding) && s.indexOf('-->', commentOpen + 1) === -1; // Check to see if we have an attribute-like sequence preceding the
-        // expression. This can match "name=value" like structures in text,
-        // comments, and attribute values, so there can be false-positives.
-
-        const attributeMatch = lastAttributeNameRegex.exec(s);
-
-        if (attributeMatch === null) {
-          // We're only in this branch if we don't have a attribute-like
-          // preceding sequence. For comments, this guards against unusual
-          // attribute values like <div foo="<!--${'bar'}">. Cases like
-          // <!-- foo=${'bar'}--> are handled correctly in the attribute branch
-          // below.
-          html += s + (isCommentBinding ? commentMarker : nodeMarker);
-        } else {
-          // For attributes we use just a marker sentinel, and also append a
-          // $lit$ suffix to the name to opt-out of attribute-specific parsing
-          // that IE and Edge do for style and certain SVG attributes.
-          html += s.substr(0, attributeMatch.index) + attributeMatch[1] + attributeMatch[2] + boundAttributeSuffix + attributeMatch[3] + marker;
-        }
-      }
-
-      html += this.strings[l];
-      return html;
+  class C {
+    constructor(t, i, s, e) {
+      this.type = 2, this.N = void 0, this.A = t, this.B = i, this.M = s, this.options = e;
     }
 
-    getTemplateElement() {
-      const template = document.createElement('template');
-      template.innerHTML = this.getHTML();
-      return template;
+    setConnected(t) {
+      var i;
+      null === (i = this.P) || void 0 === i || i.call(this, t);
     }
 
-  }
-
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-  const isPrimitive = value => {
-    return value === null || !(typeof value === 'object' || typeof value === 'function');
-  };
-  const isIterable = value => {
-    return Array.isArray(value) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    !!(value && value[Symbol.iterator]);
-  };
-  /**
-   * A Part that controls a location within a Node tree. Like a Range, NodePart
-   * has start and end locations and can set and update the Nodes between those
-   * locations.
-   *
-   * NodeParts support several value types: primitives, Nodes, TemplateResults,
-   * as well as arrays and iterables of those types.
-   */
-
-  class NodePart {
-    constructor(options) {
-      this.value = undefined;
-      this.__pendingValue = undefined;
-      this.options = options;
+    get parentNode() {
+      return this.A.parentNode;
     }
-    /**
-     * Appends this part into a container.
-     *
-     * This part must be empty, as its contents are not automatically moved.
-     */
-
 
-    appendInto(container) {
-      this.startNode = container.appendChild(createMarker());
-      this.endNode = container.appendChild(createMarker());
+    get startNode() {
+      return this.A;
     }
-    /**
-     * Inserts this part after the `ref` node (between `ref` and `ref`'s next
-     * sibling). Both `ref` and its next sibling must be static, unchanging nodes
-     * such as those that appear in a literal section of a template.
-     *
-     * This part must be empty, as its contents are not automatically moved.
-     */
 
-
-    insertAfterNode(ref) {
-      this.startNode = ref;
-      this.endNode = ref.nextSibling;
+    get endNode() {
+      return this.B;
     }
-    /**
-     * Appends this part into a parent part.
-     *
-     * This part must be empty, as its contents are not automatically moved.
-     */
-
-
-    appendIntoPart(part) {
-      part.__insert(this.startNode = createMarker());
 
-      part.__insert(this.endNode = createMarker());
+    I(t, i = this) {
+      t = S(this, t, i), d(t) ? t === A || null == t || "" === t ? (this.H !== A && this.R(), this.H = A) : t !== this.H && t !== w && this.m(t) : void 0 !== t._$litType$ ? this._(t) : void 0 !== t.nodeType ? this.$(t) : a(t) ? this.g(t) : this.m(t);
     }
-    /**
-     * Inserts this part after the `ref` part.
-     *
-     * This part must be empty, as its contents are not automatically moved.
-     */
 
-
-    insertAfterPart(ref) {
-      ref.__insert(this.startNode = createMarker());
-
-      this.endNode = ref.endNode;
-      ref.endNode = this.startNode;
+    k(t, i = this.B) {
+      return this.A.parentNode.insertBefore(t, i);
     }
 
-    setValue(value) {
-      this.__pendingValue = value;
+    $(t) {
+      this.H !== t && (this.R(), this.H = this.k(t));
     }
 
-    commit() {
-      if (this.startNode.parentNode === null) {
-        return;
-      }
-
-      while (isDirective(this.__pendingValue)) {
-        const directive = this.__pendingValue;
-        this.__pendingValue = noChange;
-        directive(this);
-      }
-
-      const value = this.__pendingValue;
-
-      if (value === noChange) {
-        return;
-      }
+    m(t) {
+      const i = this.A.nextSibling;
+      null !== i && 3 === i.nodeType && (null === this.B ? null === i.nextSibling : i === this.B.previousSibling) ? i.data = t : this.$(u.createTextNode(t)), this.H = t;
+    }
 
-      if (isPrimitive(value)) {
-        if (value !== this.value) {
-          this.__commitText(value);
-        }
-      } else if (value instanceof TemplateResult) {
-        this.__commitTemplateResult(value);
-      } else if (value instanceof Node) {
-        this.__commitNode(value);
-      } else if (isIterable(value)) {
-        this.__commitIterable(value);
-      } else if (value === nothing) {
-        this.value = nothing;
-        this.clear();
-      } else {
-        // Fallback, will render the string representation
-        this.__commitText(value);
+    _(t) {
+      var i;
+      const {
+        values: s,
+        _$litType$: e
+      } = t,
+            o = "number" == typeof e ? this.C(t) : (void 0 === e.el && (e.el = N.createElement(e.h, this.options)), e);
+      if ((null === (i = this.H) || void 0 === i ? void 0 : i.D) === o) this.H.v(s);else {
+        const t = new k(o, this),
+              i = t.u(this.options);
+        t.v(s), this.$(i), this.H = t;
       }
     }
 
-    __insert(node) {
-      this.endNode.parentNode.insertBefore(node, this.endNode);
+    C(t) {
+      let i = P.get(t.strings);
+      return void 0 === i && P.set(t.strings, i = new N(t)), i;
     }
 
-    __commitNode(value) {
-      if (this.value === value) {
-        return;
-      }
+    g(t) {
+      v(this.H) || (this.H = [], this.R());
+      const i = this.H;
+      let s,
+          e = 0;
 
-      this.clear();
+      for (const o of t) e === i.length ? i.push(s = new C(this.k(c()), this.k(c()), this, this.options)) : s = i[e], s.I(o), e++;
 
-      this.__insert(value);
-
-      this.value = value;
+      e < i.length && (this.R(s && s.B.nextSibling, e), i.length = e);
     }
 
-    __commitText(value) {
-      const node = this.startNode.nextSibling;
-      value = value == null ? '' : value; // If `value` isn't already a string, we explicitly convert it here in case
-      // it can't be implicitly converted - i.e. it's a symbol.
-
-      const valueAsString = typeof value === 'string' ? value : String(value);
+    R(t = this.A.nextSibling, i) {
+      var s;
 
-      if (node === this.endNode.previousSibling && node.nodeType === 3
-      /* Node.TEXT_NODE */
-      ) {
-          // If we only have a single text node between the markers, we can just
-          // set its value, rather than replacing it.
-          // TODO(justinfagnani): Can we just check if this.value is primitive?
-          node.data = valueAsString;
-        } else {
-        this.__commitNode(document.createTextNode(valueAsString));
+      for (null === (s = this.P) || void 0 === s || s.call(this, !1, !0, i); t && t !== this.B;) {
+        const i = t.nextSibling;
+        t.remove(), t = i;
       }
-
-      this.value = value;
     }
 
-    __commitTemplateResult(value) {
-      const template = this.options.templateFactory(value);
-
-      if (this.value instanceof TemplateInstance && this.value.template === template) {
-        this.value.update(value.values);
-      } else {
-        // Make sure we propagate the template processor from the TemplateResult
-        // so that we use its syntax extension, etc. The template factory comes
-        // from the render function options so that it can control template
-        // caching and preprocessing.
-        const instance = new TemplateInstance(template, value.processor, this.options);
-
-        const fragment = instance._clone();
-
-        instance.update(value.values);
-
-        this.__commitNode(fragment);
+  }
 
-        this.value = instance;
-      }
+  class H {
+    constructor(t, i, s, e, o) {
+      this.type = 1, this.H = A, this.N = void 0, this.V = void 0, this.element = t, this.name = i, this.M = e, this.options = o, s.length > 2 || "" !== s[0] || "" !== s[1] ? (this.H = Array(s.length - 1).fill(A), this.strings = s) : this.H = A;
     }
 
-    __commitIterable(value) {
-      // For an Iterable, we create a new InstancePart per item, then set its
-      // value to the item. This is a little bit of overhead for every item in
-      // an Iterable, but it lets us recurse easily and efficiently update Arrays
-      // of TemplateResults that will be commonly returned from expressions like:
-      // array.map((i) => html`${i}`), by reusing existing TemplateInstances.
-      // If _value is an array, then the previous render was of an
-      // iterable and _value will contain the NodeParts from the previous
-      // render. If _value is not an array, clear this part and make a new
-      // array for NodeParts.
-      if (!Array.isArray(this.value)) {
-        this.value = [];
-        this.clear();
-      } // Lets us keep track of how many items we stamped so we can clear leftover
-      // items from a previous render
-
-
-      const itemParts = this.value;
-      let partIndex = 0;
-      let itemPart;
-
-      for (const item of value) {
-        // Try to reuse an existing part
-        itemPart = itemParts[partIndex]; // If no existing part, create a new one
-
-        if (itemPart === undefined) {
-          itemPart = new NodePart(this.options);
-          itemParts.push(itemPart);
-
-          if (partIndex === 0) {
-            itemPart.appendIntoPart(this);
-          } else {
-            itemPart.insertAfterPart(itemParts[partIndex - 1]);
-          }
-        }
+    get tagName() {
+      return this.element.tagName;
+    }
 
-        itemPart.setValue(item);
-        itemPart.commit();
-        partIndex++;
-      }
+    I(t, i = this, s, e) {
+      const o = this.strings;
+      let l = !1;
+      if (void 0 === o) t = S(this, t, i, 0), l = !d(t) || t !== this.H && t !== w, l && (this.H = t);else {
+        const e = t;
+        let n, h;
 
-      if (partIndex < itemParts.length) {
-        // Truncate the parts array so _value reflects the current state
-        itemParts.length = partIndex;
-        this.clear(itemPart && itemPart.endNode);
+        for (t = o[0], n = 0; n < o.length - 1; n++) h = S(this, e[s + n], i, n), h === w && (h = this.H[n]), l || (l = !d(h) || h !== this.H[n]), h === A ? t = A : t !== A && (t += (null != h ? h : "") + o[n + 1]), this.H[n] = h;
       }
+      l && !e && this.W(t);
     }
 
-    clear(startNode = this.startNode) {
-      removeNodes(this.startNode.parentNode, startNode.nextSibling, this.endNode);
+    W(t) {
+      t === A ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, null != t ? t : "");
     }
 
   }
-  // from the options object, then options are supported. If not, then the third
-  // argument to add/removeEventListener is interpreted as the boolean capture
-  // value so we should only pass the `capture` property.
-
-  let eventOptionsSupported = false; // Wrap into an IIFE because MS Edge <= v41 does not support having try/catch
-  // blocks right into the body of a module
-
-  (() => {
-    try {
-      const options = {
-        get capture() {
-          eventOptionsSupported = true;
-          return false;
-        }
-
-      }; // eslint-disable-next-line @typescript-eslint/no-explicit-any
 
-      window.addEventListener('test', options, options); // eslint-disable-next-line @typescript-eslint/no-explicit-any
-
-      window.removeEventListener('test', options, options);
-    } catch (_e) {// event options not supported
+  class I extends H {
+    constructor() {
+      super(...arguments), this.type = 3;
     }
-  })();
-
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-  /**
-   * The default TemplateFactory which caches Templates keyed on
-   * result.type and result.strings.
-   */
 
-  function templateFactory(result) {
-    let templateCache = templateCaches.get(result.type);
-
-    if (templateCache === undefined) {
-      templateCache = {
-        stringsArray: new WeakMap(),
-        keyString: new Map()
-      };
-      templateCaches.set(result.type, templateCache);
+    W(t) {
+      this.element[this.name] = t === A ? void 0 : t;
     }
 
-    let template = templateCache.stringsArray.get(result.strings);
-
-    if (template !== undefined) {
-      return template;
-    } // If the TemplateStringsArray is new, generate a key from the strings
-    // This key is shared between all templates with identical content
+  }
 
+  class L extends H {
+    constructor() {
+      super(...arguments), this.type = 4;
+    }
 
-    const key = result.strings.join(marker); // Check if we already have a Template for this key
+    W(t) {
+      t && t !== A ? this.element.setAttribute(this.name, "") : this.element.removeAttribute(this.name);
+    }
 
-    template = templateCache.keyString.get(key);
+  }
 
-    if (template === undefined) {
-      // If we have not seen this key before, create a new Template
-      template = new Template(result, result.getTemplateElement()); // Cache the Template for this key
+  class R extends H {
+    constructor() {
+      super(...arguments), this.type = 5;
+    }
 
-      templateCache.keyString.set(key, template);
-    } // Cache all future queries for this TemplateStringsArray
+    I(t, i = this) {
+      var s;
+      if ((t = null !== (s = S(this, t, i, 0)) && void 0 !== s ? s : A) === w) return;
+      const e = this.H,
+            o = t === A && e !== A || t.capture !== e.capture || t.once !== e.once || t.passive !== e.passive,
+            l = t !== A && (e === A || o);
+      o && this.element.removeEventListener(this.name, this, e), l && this.element.addEventListener(this.name, this, t), this.H = t;
+    }
 
+    handleEvent(t) {
+      var i, s;
+      "function" == typeof this.H ? this.H.call(null !== (s = null === (i = this.options) || void 0 === i ? void 0 : i.host) && void 0 !== s ? s : this.element, t) : this.H.handleEvent(t);
+    }
 
-    templateCache.stringsArray.set(result.strings, template);
-    return template;
   }
-  const templateCaches = new Map();
 
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-  const parts = new WeakMap();
-  /**
-   * Renders a template result or other value to a container.
-   *
-   * To update a container with new values, reevaluate the template literal and
-   * call `render` with the new result.
-   *
-   * @param result Any value renderable by NodePart - typically a TemplateResult
-   *     created by evaluating a template tag like `html` or `svg`.
-   * @param container A DOM parent to render to. The entire contents are either
-   *     replaced, or efficiently updated if the same result type was previous
-   *     rendered there.
-   * @param options RenderOptions for the entire render tree rendered to this
-   *     container. Render options must *not* change between renders to the same
-   *     container, as those changes will not effect previously rendered DOM.
-   */
-
-  const render = (result, container, options) => {
-    let part = parts.get(container);
-
-    if (part === undefined) {
-      removeNodes(container, container.firstChild);
-      parts.set(container, part = new NodePart(Object.assign({
-        templateFactory
-      }, options)));
-      part.appendInto(container);
-    }
-
-    part.setValue(result);
-    part.commit();
-  };
+  class z {
+    constructor(t, i, s) {
+      this.element = t, this.type = 6, this.N = void 0, this.V = void 0, this.M = i, this.options = s;
+    }
 
-  /**
-   * @license
-   * Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
-   * This code may only be used under the BSD style license found at
-   * http://polymer.github.io/LICENSE.txt
-   * The complete set of authors may be found at
-   * http://polymer.github.io/AUTHORS.txt
-   * The complete set of contributors may be found at
-   * http://polymer.github.io/CONTRIBUTORS.txt
-   * Code distributed by Google as part of the polymer project is also
-   * subject to an additional IP rights grant found at
-   * http://polymer.github.io/PATENTS.txt
-   */
-  // This line will be used in regexes to search for lit-html usage.
-  // TODO(justinfagnani): inject version number at build time
+    I(t) {
+      S(this, t);
+    }
 
-  if (typeof window !== 'undefined') {
-    (window['litHtmlVersions'] || (window['litHtmlVersions'] = [])).push('1.2.1');
   }
+  null === (i = (t = globalThis).litHtmlPlatformSupport) || void 0 === i || i.call(t, N, C), (null !== (s = (e = globalThis).litHtmlVersions) && void 0 !== s ? s : e.litHtmlVersions = []).push("2.0.0-rc.2");
 
   //     Backbone.js 1.4.0
   const paddedLt = /^\s*</; // Caches a local reference to `Element.prototype` for faster access.
   // 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);
@@ -8985,27 +8445,27 @@
   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$1() {
+    render: function () {
       isFunction(this.beforeRender) && this.beforeRender();
-      isFunction(this.toHTML) && render(this.toHTML(), this.el);
+      isFunction(this.toHTML) && V(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 remove() {
+    remove: function () {
       this._removeElement();
 
       this.stopListening();
@@ -9014,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);
@@ -9031,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');
@@ -9059,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();
@@ -9082,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) {
@@ -9137,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];
@@ -9151,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;
@@ -9180,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');
@@ -9201,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]);
       }