@webtides/element-js 0.3.3

package/dist/index.js

@@ -0,0 +1,1483 @@
+var __defProp = Object.defineProperty;
+var __publicField = (obj, key, value) => {
+  if (typeof key !== "symbol")
+    key += "";
+  if (key in obj)
+    return __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value});
+  return obj[key] = value;
+};
+
+// src/util/AttributeParser.js
+function isObjectLike(value) {
+  return typeof value == "object" && value !== null;
+}
+function isJSON(str) {
+  try {
+    return JSON.parse(str) && !!str;
+  } catch (e) {
+    return false;
+  }
+}
+function isBoolean(value) {
+  return value === "true" || value === "false";
+}
+function parseBoolean(value) {
+  return value === "true";
+}
+function isString(value) {
+  return typeof value === "string" || !!value && typeof value === "object" && Object.prototype.toString.call(value) === "[object String]";
+}
+function isNumber(value) {
+  return new RegExp("^-?(0|0\\.\\d+|[1-9]\\d*(\\.\\d+)?)$").test(value);
+}
+function isNaN(value) {
+  return Number.isNaN(value);
+}
+function parseAttribute(value) {
+  if (!isString(value)) {
+    return value;
+  }
+  let parsedValue = value;
+  if (isJSON(value))
+    parsedValue = JSON.parse(value);
+  else if (isBoolean(value))
+    parsedValue = parseBoolean(value);
+  else if (isNumber(value))
+    parsedValue = parseFloat(value);
+  return parsedValue;
+}
+function dashToCamel(string) {
+  if (string.indexOf("-") === -1)
+    return string;
+  return string.replace(/-[a-z]/g, (matches) => matches[1].toUpperCase());
+}
+function camelToDash(string) {
+  return string.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
+
+// src/util/DOMHelper.js
+function getShadowParentOrBody(element) {
+  if (element instanceof ShadowRoot) {
+    return element;
+  }
+  while (element.parentNode && (element = element.parentNode)) {
+    if (element instanceof ShadowRoot) {
+      return element;
+    }
+  }
+  return document.body;
+}
+var supportsAdoptingStyleSheets = () => "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype;
+var supportsAppendingStyleSheets = !window.ShadyDOM;
+
+// src/util/defineElement.js
+function defineElement(name, constructor) {
+  try {
+    customElements.define(name, constructor);
+  } catch (e) {
+  }
+}
+
+// src/util/toString.js
+function toString(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return "";
+  }
+}
+
+// src/BaseElement.js
+var BaseElement = class extends HTMLElement {
+  constructor(options = {}) {
+    super();
+    this.$refs = {};
+    this._state = {};
+    this._mutationObserver = null;
+    this._registeredEvents = [];
+    this._batchUpdate = null;
+    this._requestedUpdates = [];
+    this._options = {
+      autoUpdate: true,
+      deferUpdate: true,
+      mutationObserverOptions: {
+        attributes: true,
+        childList: true,
+        subtree: false,
+        ...options.mutationObserverOptions
+      },
+      propertyOptions: {},
+      ...options
+    };
+    if (options.childListUpdate !== void 0 && options.childListUpdate !== null) {
+      this._options.mutationObserverOptions.childList = options.childListUpdate;
+      console.warn(`[${this.localName}] Using the "childListUpdate" option is deprecated and will be removed before 1.0! Please use the "mutationObserverOptions" dictionary instead. See the docs for more info`);
+    }
+  }
+  connectedCallback() {
+    this.defineAttributesAsProperties();
+    this.defineProperties();
+    this.defineComputedProperties();
+    this.defineObserver();
+    if (this.hasAttribute("defer-update") || this._options.deferUpdate) {
+      this.registerEventsAndRefs();
+      this.triggerHook("connected");
+    } else {
+      this.requestUpdate({notify: false}).then(() => {
+        this.triggerHook("connected");
+      });
+    }
+  }
+  defineObserver() {
+    this._mutationObserver = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        if (mutation.type === "attributes" && mutation.target === this && this._state.hasOwnProperty(dashToCamel(mutation.attributeName))) {
+          this[dashToCamel(mutation.attributeName)] = parseAttribute(this.getAttribute(mutation.attributeName));
+        }
+        if (mutation.type === "attributes" && mutation.target !== this) {
+          this.requestUpdate();
+        }
+        if (mutation.type === "childList") {
+          this.requestUpdate();
+        }
+      });
+    });
+    this._mutationObserver.observe(this, {
+      attributes: true,
+      childList: true,
+      subtree: false,
+      ...this._options.mutationObserverOptions
+    });
+  }
+  disconnectedCallback() {
+    this.removeEvents();
+    if (this._mutationObserver)
+      this._mutationObserver.disconnect();
+    this.triggerHook("disconnected");
+  }
+  requestUpdate(options = {notify: true}) {
+    if (options.notify === true) {
+      this.triggerHook("beforeUpdate");
+    }
+    if (this._batchUpdate) {
+      cancelAnimationFrame(this._batchUpdate);
+      this._batchUpdate = false;
+    }
+    return new Promise((resolve, reject) => {
+      this._requestedUpdates.push({resolve, reject});
+      this._batchUpdate = requestAnimationFrame(() => {
+        try {
+          this.update(options);
+          this._requestedUpdates.forEach(({resolve: resolve2, reject: reject2}) => resolve2());
+        } catch (e) {
+          this._requestedUpdates.forEach(({resolve: resolve2, reject: reject2}) => reject2(e));
+        }
+        this._requestedUpdates = [];
+      });
+    });
+  }
+  update(options = {notify: true}) {
+    this.registerEventsAndRefs();
+    if (options.notify === true) {
+      this.triggerHook("afterUpdate");
+    }
+  }
+  registerEventsAndRefs() {
+    this.registerEvents();
+    this.registerRefs();
+  }
+  defineAttributesAsProperties() {
+    const ignoreAttributes = ["class", "style"];
+    Array.from(this.attributes).filter((attribute) => {
+      return !ignoreAttributes.includes(attribute.name);
+    }).forEach((attribute) => {
+      this.defineProperty(dashToCamel(attribute.name), parseAttribute(attribute.value), true);
+    });
+  }
+  properties() {
+    return {};
+  }
+  defineProperties() {
+    Object.keys(this.properties()).forEach((prop) => {
+      const value = this[prop] || this.properties()[prop];
+      this.defineProperty(prop, value);
+    });
+  }
+  defineProperty(property, value, reflectAttribute = false) {
+    var _a, _b;
+    if (this._state.hasOwnProperty(property)) {
+      return;
+    }
+    if (!reflectAttribute && ((_a = this._options.propertyOptions[property]) == null ? void 0 : _a.reflect) === true) {
+      this.reflectProperty({property, newValue: value});
+    }
+    if (((_b = this._options.propertyOptions[property]) == null ? void 0 : _b.reflect) === false) {
+      this.removeAttribute(camelToDash(property));
+    }
+    this._state[property] = value;
+    Object.defineProperty(this, property, {
+      get: () => {
+        return this._state[property];
+      },
+      set: (newValue) => {
+        var _a2;
+        const oldValue = this._state[property];
+        const newValueString = JSON.stringify(newValue);
+        if (JSON.stringify(oldValue) !== newValueString) {
+          this._state[property] = newValue;
+          if (reflectAttribute || ((_a2 = this._options.propertyOptions[property]) == null ? void 0 : _a2.reflect) === true) {
+            this.reflectProperty({property, newValue, newValueString});
+          }
+          const informWatchedPropertiesAndDispatchChangeEvent = () => {
+            if (property in this.watch()) {
+              this.watch()[property](newValue, oldValue);
+            }
+            if (property in this._options["propertyOptions"] && this._options["propertyOptions"][property]["notify"] === true) {
+              this.dispatch(`${camelToDash(property)}-changed`, newValue, true);
+            }
+          };
+          if (this._options.autoUpdate) {
+            this.requestUpdate({
+              notify: true,
+              property,
+              newValue,
+              newValueString,
+              oldValue
+            }).finally(() => {
+              informWatchedPropertiesAndDispatchChangeEvent();
+            });
+          } else {
+            informWatchedPropertiesAndDispatchChangeEvent();
+          }
+        }
+        return this;
+      }
+    });
+  }
+  reflectProperty(options) {
+    const {property, newValue} = options;
+    const newValueString = options.newValueString || JSON.stringify(newValue);
+    if (newValue === void 0 || newValue === null || isNaN(newValue)) {
+      this.setAttribute(camelToDash(property), "");
+    } else {
+      const attributeValue = isObjectLike(newValue) ? newValueString : newValue;
+      this.setAttribute(camelToDash(property), attributeValue);
+    }
+  }
+  hooks() {
+    return {};
+  }
+  connected() {
+  }
+  beforeUpdate() {
+  }
+  afterUpdate() {
+  }
+  disconnected() {
+  }
+  triggerHook(name) {
+    if (this.hooks && name in this.hooks()) {
+      console.warn(`[${this.localName}] Using the hooks() map for lifecycle hooks is deprecated! Please overwrite the existing lifecycle hook functions. See the docs for more info`);
+      this.hooks()[name]();
+      return;
+    }
+    if (name in this) {
+      this[name]();
+    }
+  }
+  watch() {
+    return {};
+  }
+  computed() {
+    return {};
+  }
+  defineComputedProperties() {
+    Object.keys(this.computed()).forEach((prop) => {
+      if (!this.hasOwnProperty(prop)) {
+        console.warn(`[${this.localName}] Using the computed() map for computed properties is deprecated! Please use regular JS getters and return the computed value. See the docs for more info`);
+        Object.defineProperty(this, prop, {
+          get: () => this.computed()[prop]()
+        });
+      }
+    });
+  }
+  events() {
+    return {};
+  }
+  registerEvents() {
+    this.removeEvents();
+    const eventDefinitions = this.events();
+    Object.keys(eventDefinitions).forEach((elementSelector) => {
+      const events = eventDefinitions[elementSelector];
+      const selectorWhiteList = {window, document, this: this.getRoot()};
+      const whiteListElement = selectorWhiteList[elementSelector];
+      const eventTargets = whiteListElement ? [whiteListElement] : this.getRoot().querySelectorAll(elementSelector);
+      eventTargets.forEach((eventTarget) => {
+        Object.keys(events).forEach((eventName) => {
+          var _a;
+          const notation = events[eventName];
+          if (typeof notation === "function") {
+            const callback = notation.bind(this);
+            eventTarget.addEventListener(eventName, callback);
+            this._registeredEvents.push({eventTarget, eventName, callback});
+          } else if (typeof notation === "object" && typeof notation.listener === "function") {
+            const callback = notation.listener.bind(this);
+            eventTarget.addEventListener(eventName, callback, (_a = notation.options) != null ? _a : {});
+            this._registeredEvents.push({eventTarget, eventName, callback});
+          }
+        });
+      });
+    });
+  }
+  removeEvents() {
+    this._registeredEvents.forEach(({eventTarget, eventName, callback}) => {
+      if (eventTarget === window || eventTarget === document || this.getRoot().contains(eventTarget)) {
+        eventTarget.removeEventListener(eventName, callback);
+      }
+    });
+    this._registeredEvents = [];
+  }
+  registerRefs() {
+    const refsNodeList = this.getRoot().querySelectorAll("[ref]");
+    const refsArray = Array.from(refsNodeList);
+    const refsMap = {};
+    refsArray.forEach((refNode) => {
+      const refKey = refNode.getAttribute("ref");
+      refsMap[refKey] = refNode;
+    });
+    this.$refs = refsMap;
+  }
+  dispatch(name, data, bubble = false, cancelable = false, composed = false) {
+    const event = new CustomEvent(name, {
+      bubbles: bubble,
+      cancelable,
+      composed,
+      detail: data
+    });
+    this.dispatchEvent(event);
+  }
+  getRoot() {
+    return this;
+  }
+};
+
+// src/util/i18n.js
+function i18n(key, fallback) {
+  try {
+    const translations = window.elementjs.i18n();
+    if (translations[key] === void 0) {
+      throw "Translation Missing";
+    }
+    return translations[key];
+  } catch (err) {
+    if (fallback)
+      return fallback;
+    else
+      return key;
+  }
+}
+
+// src/StyledElement.js
+var _StyledElement = class extends BaseElement {
+  static updateGlobalStyles() {
+    _StyledElement.globalStyles = document.getElementById("globalStyles");
+    if (_StyledElement.globalStyles && _StyledElement["globalStyleSheet"]) {
+      _StyledElement["globalStyleSheet"].replaceSync(_StyledElement.globalStyles.textContent);
+    }
+  }
+  constructor(options) {
+    super({
+      deferUpdate: false,
+      shadowRender: false,
+      styles: [],
+      adoptGlobalStyles: true,
+      ...options
+    });
+    this._styles = [...this._options.styles, ...this.styles()];
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (supportsAdoptingStyleSheets() && this._options.shadowRender) {
+      this.adoptStyleSheets();
+    } else if (this._options.shadowRender && window.ShadyCSS !== void 0) {
+      window.ShadyCSS.ScopingShim.prepareAdoptedCssText(this._styles, this.localName);
+    }
+    if (window.ShadyCSS !== void 0) {
+      window.ShadyCSS.styleElement(this);
+    }
+  }
+  styles() {
+    return [];
+  }
+  update(options) {
+    var _a, _b;
+    if (!supportsAdoptingStyleSheets() || this._options.shadowRender === false) {
+      const appendableStyles = [...this._styles];
+      if (this._options.shadowRender && this._options.adoptGlobalStyles && !window.ShadyCSS) {
+        appendableStyles.unshift((_b = (_a = _StyledElement.globalStyles) == null ? void 0 : _a.textContent) != null ? _b : "");
+      }
+      this.appendStyleSheets(appendableStyles);
+    }
+    super.update(options);
+  }
+  adoptStyleSheets() {
+    if (!this.constructor["cssStyleSheets"]) {
+      this.constructor["cssStyleSheets"] = this._styles.map((style) => {
+        const sheet = new CSSStyleSheet();
+        if (sheet && sheet.cssRules.length === 0) {
+          sheet.replaceSync(style);
+        }
+        return sheet;
+      });
+    }
+    if (_StyledElement.globalStyles && !_StyledElement["globalStyleSheet"]) {
+      _StyledElement["globalStyleSheet"] = new CSSStyleSheet();
+      _StyledElement["globalStyleSheet"].replaceSync(_StyledElement.globalStyles.textContent);
+    }
+    this.getRoot().adoptedStyleSheets = [
+      ...this._options.shadowRender && this._options.adoptGlobalStyles && _StyledElement["globalStyleSheet"] ? [_StyledElement["globalStyleSheet"]] : [],
+      ...this.constructor["cssStyleSheets"]
+    ];
+  }
+  appendStyleSheets(styles) {
+    const parentDocument = getShadowParentOrBody(this.getRoot());
+    styles.forEach((style, index) => {
+      const identifier = this.tagName + index;
+      if (!parentDocument.querySelector(`#${identifier}`)) {
+        const styleElement = document.createElement("style");
+        styleElement.id = identifier;
+        styleElement.style.display = "none";
+        styleElement.textContent = style;
+        parentDocument.appendChild(styleElement);
+      }
+    });
+  }
+};
+var StyledElement = _StyledElement;
+__publicField(StyledElement, "globalStyles", null);
+StyledElement.updateGlobalStyles();
+
+// node_modules/lit-html/lib/directive.js
+/**
+ * @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
+ */
+var directives = new WeakMap();
+var isDirective = (o) => {
+  return typeof o === "function" && directives.has(o);
+};
+
+// node_modules/lit-html/lib/dom.js
+/**
+ * @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
+ */
+var isCEPolyfill = typeof window !== "undefined" && window.customElements != null && window.customElements.polyfillWrapFlushCallback !== void 0;
+var removeNodes = (container, start, end = null) => {
+  while (start !== end) {
+    const n = start.nextSibling;
+    container.removeChild(start);
+    start = n;
+  }
+};
+
+// node_modules/lit-html/lib/part.js
+/**
+ * @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
+ */
+var noChange = {};
+var nothing = {};
+
+// node_modules/lit-html/lib/template.js
+/**
+ * @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
+ */
+var marker = `{{lit-${String(Math.random()).slice(2)}}}`;
+var nodeMarker = `<!--${marker}-->`;
+var markerRegex = new RegExp(`${marker}|${nodeMarker}`);
+var boundAttributeSuffix = "$lit$";
+var Template = class {
+  constructor(result, element) {
+    this.parts = [];
+    this.element = element;
+    const nodesToRemove = [];
+    const stack = [];
+    const walker = document.createTreeWalker(element.content, 133, null, false);
+    let lastPartIndex = 0;
+    let index = -1;
+    let partIndex = 0;
+    const {strings, values: {length}} = result;
+    while (partIndex < length) {
+      const node = walker.nextNode();
+      if (node === null) {
+        walker.currentNode = stack.pop();
+        continue;
+      }
+      index++;
+      if (node.nodeType === 1) {
+        if (node.hasAttributes()) {
+          const attributes = node.attributes;
+          const {length: length2} = attributes;
+          let count = 0;
+          for (let i = 0; i < length2; i++) {
+            if (endsWith(attributes[i].name, boundAttributeSuffix)) {
+              count++;
+            }
+          }
+          while (count-- > 0) {
+            const stringForPart = strings[partIndex];
+            const name = lastAttributeNameRegex.exec(stringForPart)[2];
+            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});
+            partIndex += statics.length - 1;
+          }
+        }
+        if (node.tagName === "TEMPLATE") {
+          stack.push(node);
+          walker.currentNode = node.content;
+        }
+      } else if (node.nodeType === 3) {
+        const data = node.data;
+        if (data.indexOf(marker) >= 0) {
+          const parent = node.parentNode;
+          const strings2 = data.split(markerRegex);
+          const lastIndex = strings2.length - 1;
+          for (let i = 0; i < lastIndex; i++) {
+            let insert;
+            let s = strings2[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 (strings2[lastIndex] === "") {
+            parent.insertBefore(createMarker(), node);
+            nodesToRemove.push(node);
+          } else {
+            node.data = strings2[lastIndex];
+          }
+          partIndex += lastIndex;
+        }
+      } else if (node.nodeType === 8) {
+        if (node.data === marker) {
+          const parent = node.parentNode;
+          if (node.previousSibling === null || index === lastPartIndex) {
+            index++;
+            parent.insertBefore(createMarker(), node);
+          }
+          lastPartIndex = index;
+          this.parts.push({type: "node", index});
+          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) {
+            this.parts.push({type: "node", index: -1});
+            partIndex++;
+          }
+        }
+      }
+    }
+    for (const n of nodesToRemove) {
+      n.parentNode.removeChild(n);
+    }
+  }
+};
+var endsWith = (str, suffix) => {
+  const index = str.length - suffix.length;
+  return index >= 0 && str.slice(index) === suffix;
+};
+var isTemplatePartActive = (part) => part.index !== -1;
+var createMarker = () => document.createComment("");
+var lastAttributeNameRegex = /([ \x09\x0a\x0c\x0d])([^\0-\x1F\x7F-\x9F "'>=/]+)([ \x09\x0a\x0c\x0d]*=[ \x09\x0a\x0c\x0d]*(?:[^ \x09\x0a\x0c\x0d"'`<>=]*|"[^"]*|'[^']*))$/;
+
+// node_modules/lit-html/lib/template-instance.js
+/**
+ * @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
+ */
+var TemplateInstance = class {
+  constructor(template, processor, options) {
+    this.__parts = [];
+    this.template = template;
+    this.processor = processor;
+    this.options = options;
+  }
+  update(values) {
+    let i = 0;
+    for (const part of this.__parts) {
+      if (part !== void 0) {
+        part.setValue(values[i]);
+      }
+      i++;
+    }
+    for (const part of this.__parts) {
+      if (part !== void 0) {
+        part.commit();
+      }
+    }
+  }
+  _clone() {
+    const fragment = isCEPolyfill ? this.template.element.content.cloneNode(true) : document.importNode(this.template.element.content, true);
+    const stack = [];
+    const parts2 = this.template.parts;
+    const walker = document.createTreeWalker(fragment, 133, null, false);
+    let partIndex = 0;
+    let nodeIndex = 0;
+    let part;
+    let node = walker.nextNode();
+    while (partIndex < parts2.length) {
+      part = parts2[partIndex];
+      if (!isTemplatePartActive(part)) {
+        this.__parts.push(void 0);
+        partIndex++;
+        continue;
+      }
+      while (nodeIndex < part.index) {
+        nodeIndex++;
+        if (node.nodeName === "TEMPLATE") {
+          stack.push(node);
+          walker.currentNode = node.content;
+        }
+        if ((node = walker.nextNode()) === null) {
+          walker.currentNode = stack.pop();
+          node = walker.nextNode();
+        }
+      }
+      if (part.type === "node") {
+        const part2 = this.processor.handleTextExpression(this.options);
+        part2.insertAfterNode(node.previousSibling);
+        this.__parts.push(part2);
+      } else {
+        this.__parts.push(...this.processor.handleAttributeExpressions(node, part.name, part.strings, this.options));
+      }
+      partIndex++;
+    }
+    if (isCEPolyfill) {
+      document.adoptNode(fragment);
+      customElements.upgrade(fragment);
+    }
+    return fragment;
+  }
+};
+
+// node_modules/lit-html/lib/template-result.js
+/**
+ * @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
+ */
+var commentMarker = ` ${marker} `;
+var TemplateResult = class {
+  constructor(strings, values, type, processor) {
+    this.strings = strings;
+    this.values = values;
+    this.type = type;
+    this.processor = processor;
+  }
+  getHTML() {
+    const l = this.strings.length - 1;
+    let html2 = "";
+    let isCommentBinding = false;
+    for (let i = 0; i < l; i++) {
+      const s = this.strings[i];
+      const commentOpen = s.lastIndexOf("<!--");
+      isCommentBinding = (commentOpen > -1 || isCommentBinding) && s.indexOf("-->", commentOpen + 1) === -1;
+      const attributeMatch = lastAttributeNameRegex.exec(s);
+      if (attributeMatch === null) {
+        html2 += s + (isCommentBinding ? commentMarker : nodeMarker);
+      } else {
+        html2 += s.substr(0, attributeMatch.index) + attributeMatch[1] + attributeMatch[2] + boundAttributeSuffix + attributeMatch[3] + marker;
+      }
+    }
+    html2 += this.strings[l];
+    return html2;
+  }
+  getTemplateElement() {
+    const template = document.createElement("template");
+    template.innerHTML = this.getHTML();
+    return template;
+  }
+};
+
+// node_modules/lit-html/lib/parts.js
+/**
+ * @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
+ */
+var isPrimitive = (value) => {
+  return value === null || !(typeof value === "object" || typeof value === "function");
+};
+var isIterable = (value) => {
+  return Array.isArray(value) || !!(value && value[Symbol.iterator]);
+};
+var AttributeCommitter = class {
+  constructor(element, name, strings) {
+    this.dirty = true;
+    this.element = element;
+    this.name = name;
+    this.strings = strings;
+    this.parts = [];
+    for (let i = 0; i < strings.length - 1; i++) {
+      this.parts[i] = this._createPart();
+    }
+  }
+  _createPart() {
+    return new AttributePart(this);
+  }
+  _getValue() {
+    const strings = this.strings;
+    const l = strings.length - 1;
+    let text = "";
+    for (let i = 0; i < l; i++) {
+      text += strings[i];
+      const part = this.parts[i];
+      if (part !== void 0) {
+        const v = part.value;
+        if (isPrimitive(v) || !isIterable(v)) {
+          text += typeof v === "string" ? v : String(v);
+        } else {
+          for (const t of v) {
+            text += typeof t === "string" ? t : String(t);
+          }
+        }
+      }
+    }
+    text += strings[l];
+    return text;
+  }
+  commit() {
+    if (this.dirty) {
+      this.dirty = false;
+      this.element.setAttribute(this.name, this._getValue());
+    }
+  }
+};
+var AttributePart = class {
+  constructor(committer) {
+    this.value = void 0;
+    this.committer = committer;
+  }
+  setValue(value) {
+    if (value !== noChange && (!isPrimitive(value) || value !== this.value)) {
+      this.value = value;
+      if (!isDirective(value)) {
+        this.committer.dirty = true;
+      }
+    }
+  }
+  commit() {
+    while (isDirective(this.value)) {
+      const directive2 = this.value;
+      this.value = noChange;
+      directive2(this);
+    }
+    if (this.value === noChange) {
+      return;
+    }
+    this.committer.commit();
+  }
+};
+var NodePart = class {
+  constructor(options) {
+    this.value = void 0;
+    this.__pendingValue = void 0;
+    this.options = options;
+  }
+  appendInto(container) {
+    this.startNode = container.appendChild(createMarker());
+    this.endNode = container.appendChild(createMarker());
+  }
+  insertAfterNode(ref) {
+    this.startNode = ref;
+    this.endNode = ref.nextSibling;
+  }
+  appendIntoPart(part) {
+    part.__insert(this.startNode = createMarker());
+    part.__insert(this.endNode = createMarker());
+  }
+  insertAfterPart(ref) {
+    ref.__insert(this.startNode = createMarker());
+    this.endNode = ref.endNode;
+    ref.endNode = this.startNode;
+  }
+  setValue(value) {
+    this.__pendingValue = value;
+  }
+  commit() {
+    if (this.startNode.parentNode === null) {
+      return;
+    }
+    while (isDirective(this.__pendingValue)) {
+      const directive2 = this.__pendingValue;
+      this.__pendingValue = noChange;
+      directive2(this);
+    }
+    const value = this.__pendingValue;
+    if (value === noChange) {
+      return;
+    }
+    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 {
+      this.__commitText(value);
+    }
+  }
+  __insert(node) {
+    this.endNode.parentNode.insertBefore(node, this.endNode);
+  }
+  __commitNode(value) {
+    if (this.value === value) {
+      return;
+    }
+    this.clear();
+    this.__insert(value);
+    this.value = value;
+  }
+  __commitText(value) {
+    const node = this.startNode.nextSibling;
+    value = value == null ? "" : value;
+    const valueAsString = typeof value === "string" ? value : String(value);
+    if (node === this.endNode.previousSibling && node.nodeType === 3) {
+      node.data = valueAsString;
+    } else {
+      this.__commitNode(document.createTextNode(valueAsString));
+    }
+    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 {
+      const instance = new TemplateInstance(template, value.processor, this.options);
+      const fragment = instance._clone();
+      instance.update(value.values);
+      this.__commitNode(fragment);
+      this.value = instance;
+    }
+  }
+  __commitIterable(value) {
+    if (!Array.isArray(this.value)) {
+      this.value = [];
+      this.clear();
+    }
+    const itemParts = this.value;
+    let partIndex = 0;
+    let itemPart;
+    for (const item of value) {
+      itemPart = itemParts[partIndex];
+      if (itemPart === void 0) {
+        itemPart = new NodePart(this.options);
+        itemParts.push(itemPart);
+        if (partIndex === 0) {
+          itemPart.appendIntoPart(this);
+        } else {
+          itemPart.insertAfterPart(itemParts[partIndex - 1]);
+        }
+      }
+      itemPart.setValue(item);
+      itemPart.commit();
+      partIndex++;
+    }
+    if (partIndex < itemParts.length) {
+      itemParts.length = partIndex;
+      this.clear(itemPart && itemPart.endNode);
+    }
+  }
+  clear(startNode = this.startNode) {
+    removeNodes(this.startNode.parentNode, startNode.nextSibling, this.endNode);
+  }
+};
+var BooleanAttributePart = class {
+  constructor(element, name, strings) {
+    this.value = void 0;
+    this.__pendingValue = void 0;
+    if (strings.length !== 2 || strings[0] !== "" || strings[1] !== "") {
+      throw new Error("Boolean attributes can only contain a single expression");
+    }
+    this.element = element;
+    this.name = name;
+    this.strings = strings;
+  }
+  setValue(value) {
+    this.__pendingValue = value;
+  }
+  commit() {
+    while (isDirective(this.__pendingValue)) {
+      const directive2 = this.__pendingValue;
+      this.__pendingValue = noChange;
+      directive2(this);
+    }
+    if (this.__pendingValue === noChange) {
+      return;
+    }
+    const value = !!this.__pendingValue;
+    if (this.value !== value) {
+      if (value) {
+        this.element.setAttribute(this.name, "");
+      } else {
+        this.element.removeAttribute(this.name);
+      }
+      this.value = value;
+    }
+    this.__pendingValue = noChange;
+  }
+};
+var PropertyCommitter = class extends AttributeCommitter {
+  constructor(element, name, strings) {
+    super(element, name, strings);
+    this.single = strings.length === 2 && strings[0] === "" && strings[1] === "";
+  }
+  _createPart() {
+    return new PropertyPart(this);
+  }
+  _getValue() {
+    if (this.single) {
+      return this.parts[0].value;
+    }
+    return super._getValue();
+  }
+  commit() {
+    if (this.dirty) {
+      this.dirty = false;
+      this.element[this.name] = this._getValue();
+    }
+  }
+};
+var PropertyPart = class extends AttributePart {
+};
+var eventOptionsSupported = false;
+(() => {
+  try {
+    const options = {
+      get capture() {
+        eventOptionsSupported = true;
+        return false;
+      }
+    };
+    window.addEventListener("test", options, options);
+    window.removeEventListener("test", options, options);
+  } catch (_e) {
+  }
+})();
+var EventPart = class {
+  constructor(element, eventName, eventContext) {
+    this.value = void 0;
+    this.__pendingValue = void 0;
+    this.element = element;
+    this.eventName = eventName;
+    this.eventContext = eventContext;
+    this.__boundHandleEvent = (e) => this.handleEvent(e);
+  }
+  setValue(value) {
+    this.__pendingValue = value;
+  }
+  commit() {
+    while (isDirective(this.__pendingValue)) {
+      const directive2 = this.__pendingValue;
+      this.__pendingValue = noChange;
+      directive2(this);
+    }
+    if (this.__pendingValue === noChange) {
+      return;
+    }
+    const newListener = this.__pendingValue;
+    const oldListener = this.value;
+    const shouldRemoveListener = newListener == null || oldListener != null && (newListener.capture !== oldListener.capture || newListener.once !== oldListener.once || newListener.passive !== oldListener.passive);
+    const shouldAddListener = newListener != null && (oldListener == null || shouldRemoveListener);
+    if (shouldRemoveListener) {
+      this.element.removeEventListener(this.eventName, this.__boundHandleEvent, this.__options);
+    }
+    if (shouldAddListener) {
+      this.__options = getOptions(newListener);
+      this.element.addEventListener(this.eventName, this.__boundHandleEvent, this.__options);
+    }
+    this.value = newListener;
+    this.__pendingValue = noChange;
+  }
+  handleEvent(event) {
+    if (typeof this.value === "function") {
+      this.value.call(this.eventContext || this.element, event);
+    } else {
+      this.value.handleEvent(event);
+    }
+  }
+};
+var getOptions = (o) => o && (eventOptionsSupported ? {capture: o.capture, passive: o.passive, once: o.once} : o.capture);
+
+// node_modules/lit-html/lib/default-template-processor.js
+/**
+ * @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
+ */
+var DefaultTemplateProcessor = class {
+  handleAttributeExpressions(element, name, strings, options) {
+    const prefix = name[0];
+    if (prefix === ".") {
+      const committer2 = new PropertyCommitter(element, name.slice(1), strings);
+      return committer2.parts;
+    }
+    if (prefix === "@") {
+      return [new EventPart(element, name.slice(1), options.eventContext)];
+    }
+    if (prefix === "?") {
+      return [new BooleanAttributePart(element, name.slice(1), strings)];
+    }
+    const committer = new AttributeCommitter(element, name, strings);
+    return committer.parts;
+  }
+  handleTextExpression(options) {
+    return new NodePart(options);
+  }
+};
+var defaultTemplateProcessor = new DefaultTemplateProcessor();
+
+// node_modules/lit-html/lib/template-factory.js
+/**
+ * @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
+ */
+function templateFactory(result) {
+  let templateCache = templateCaches.get(result.type);
+  if (templateCache === void 0) {
+    templateCache = {
+      stringsArray: new WeakMap(),
+      keyString: new Map()
+    };
+    templateCaches.set(result.type, templateCache);
+  }
+  let template = templateCache.stringsArray.get(result.strings);
+  if (template !== void 0) {
+    return template;
+  }
+  const key = result.strings.join(marker);
+  template = templateCache.keyString.get(key);
+  if (template === void 0) {
+    template = new Template(result, result.getTemplateElement());
+    templateCache.keyString.set(key, template);
+  }
+  templateCache.stringsArray.set(result.strings, template);
+  return template;
+}
+var templateCaches = new Map();
+
+// node_modules/lit-html/lib/render.js
+/**
+ * @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
+ */
+var parts = new WeakMap();
+var render = (result, container, options) => {
+  let part = parts.get(container);
+  if (part === void 0) {
+    removeNodes(container, container.firstChild);
+    parts.set(container, part = new NodePart(Object.assign({templateFactory}, options)));
+    part.appendInto(container);
+  }
+  part.setValue(result);
+  part.commit();
+};
+
+// node_modules/lit-html/lit-html.js
+/**
+ * @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
+ */
+if (typeof window !== "undefined") {
+  (window["litHtmlVersions"] || (window["litHtmlVersions"] = [])).push("1.2.1");
+}
+var html = (strings, ...values) => new TemplateResult(strings, values, "html", defaultTemplateProcessor);
+
+// node_modules/lit-html/lib/modify-template.js
+/**
+ * @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
+ */
+var walkerNodeFilter = 133;
+function removeNodesFromTemplate(template, nodesToRemove) {
+  const {element: {content}, parts: parts2} = template;
+  const walker = document.createTreeWalker(content, walkerNodeFilter, null, false);
+  let partIndex = nextActiveIndexInTemplateParts(parts2);
+  let part = parts2[partIndex];
+  let nodeIndex = -1;
+  let removeCount = 0;
+  const nodesToRemoveInTemplate = [];
+  let currentRemovingNode = null;
+  while (walker.nextNode()) {
+    nodeIndex++;
+    const node = walker.currentNode;
+    if (node.previousSibling === currentRemovingNode) {
+      currentRemovingNode = null;
+    }
+    if (nodesToRemove.has(node)) {
+      nodesToRemoveInTemplate.push(node);
+      if (currentRemovingNode === null) {
+        currentRemovingNode = node;
+      }
+    }
+    if (currentRemovingNode !== null) {
+      removeCount++;
+    }
+    while (part !== void 0 && part.index === nodeIndex) {
+      part.index = currentRemovingNode !== null ? -1 : part.index - removeCount;
+      partIndex = nextActiveIndexInTemplateParts(parts2, partIndex);
+      part = parts2[partIndex];
+    }
+  }
+  nodesToRemoveInTemplate.forEach((n) => n.parentNode.removeChild(n));
+}
+var countNodes = (node) => {
+  let count = node.nodeType === 11 ? 0 : 1;
+  const walker = document.createTreeWalker(node, walkerNodeFilter, null, false);
+  while (walker.nextNode()) {
+    count++;
+  }
+  return count;
+};
+var nextActiveIndexInTemplateParts = (parts2, startIndex = -1) => {
+  for (let i = startIndex + 1; i < parts2.length; i++) {
+    const part = parts2[i];
+    if (isTemplatePartActive(part)) {
+      return i;
+    }
+  }
+  return -1;
+};
+function insertNodeIntoTemplate(template, node, refNode = null) {
+  const {element: {content}, parts: parts2} = template;
+  if (refNode === null || refNode === void 0) {
+    content.appendChild(node);
+    return;
+  }
+  const walker = document.createTreeWalker(content, walkerNodeFilter, null, false);
+  let partIndex = nextActiveIndexInTemplateParts(parts2);
+  let insertCount = 0;
+  let walkerIndex = -1;
+  while (walker.nextNode()) {
+    walkerIndex++;
+    const walkerNode = walker.currentNode;
+    if (walkerNode === refNode) {
+      insertCount = countNodes(node);
+      refNode.parentNode.insertBefore(node, refNode);
+    }
+    while (partIndex !== -1 && parts2[partIndex].index === walkerIndex) {
+      if (insertCount > 0) {
+        while (partIndex !== -1) {
+          parts2[partIndex].index += insertCount;
+          partIndex = nextActiveIndexInTemplateParts(parts2, partIndex);
+        }
+        return;
+      }
+      partIndex = nextActiveIndexInTemplateParts(parts2, partIndex);
+    }
+  }
+}
+
+// node_modules/lit-html/lib/shady-render.js
+/**
+ * @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
+ */
+var getTemplateCacheKey = (type, scopeName) => `${type}--${scopeName}`;
+var compatibleShadyCSSVersion = true;
+if (typeof window.ShadyCSS === "undefined") {
+  compatibleShadyCSSVersion = false;
+} else if (typeof window.ShadyCSS.prepareTemplateDom === "undefined") {
+  console.warn(`Incompatible ShadyCSS version detected. Please update to at least @webcomponents/webcomponentsjs@2.0.2 and @webcomponents/shadycss@1.3.1.`);
+  compatibleShadyCSSVersion = false;
+}
+var shadyTemplateFactory = (scopeName) => (result) => {
+  const cacheKey = getTemplateCacheKey(result.type, scopeName);
+  let templateCache = templateCaches.get(cacheKey);
+  if (templateCache === void 0) {
+    templateCache = {
+      stringsArray: new WeakMap(),
+      keyString: new Map()
+    };
+    templateCaches.set(cacheKey, templateCache);
+  }
+  let template = templateCache.stringsArray.get(result.strings);
+  if (template !== void 0) {
+    return template;
+  }
+  const key = result.strings.join(marker);
+  template = templateCache.keyString.get(key);
+  if (template === void 0) {
+    const element = result.getTemplateElement();
+    if (compatibleShadyCSSVersion) {
+      window.ShadyCSS.prepareTemplateDom(element, scopeName);
+    }
+    template = new Template(result, element);
+    templateCache.keyString.set(key, template);
+  }
+  templateCache.stringsArray.set(result.strings, template);
+  return template;
+};
+var TEMPLATE_TYPES = ["html", "svg"];
+var removeStylesFromLitTemplates = (scopeName) => {
+  TEMPLATE_TYPES.forEach((type) => {
+    const templates = templateCaches.get(getTemplateCacheKey(type, scopeName));
+    if (templates !== void 0) {
+      templates.keyString.forEach((template) => {
+        const {element: {content}} = template;
+        const styles = new Set();
+        Array.from(content.querySelectorAll("style")).forEach((s) => {
+          styles.add(s);
+        });
+        removeNodesFromTemplate(template, styles);
+      });
+    }
+  });
+};
+var shadyRenderSet = new Set();
+var prepareTemplateStyles = (scopeName, renderedDOM, template) => {
+  shadyRenderSet.add(scopeName);
+  const templateElement = !!template ? template.element : document.createElement("template");
+  const styles = renderedDOM.querySelectorAll("style");
+  const {length} = styles;
+  if (length === 0) {
+    window.ShadyCSS.prepareTemplateStyles(templateElement, scopeName);
+    return;
+  }
+  const condensedStyle = document.createElement("style");
+  for (let i = 0; i < length; i++) {
+    const style2 = styles[i];
+    style2.parentNode.removeChild(style2);
+    condensedStyle.textContent += style2.textContent;
+  }
+  removeStylesFromLitTemplates(scopeName);
+  const content = templateElement.content;
+  if (!!template) {
+    insertNodeIntoTemplate(template, condensedStyle, content.firstChild);
+  } else {
+    content.insertBefore(condensedStyle, content.firstChild);
+  }
+  window.ShadyCSS.prepareTemplateStyles(templateElement, scopeName);
+  const style = content.querySelector("style");
+  if (window.ShadyCSS.nativeShadow && style !== null) {
+    renderedDOM.insertBefore(style.cloneNode(true), renderedDOM.firstChild);
+  } else if (!!template) {
+    content.insertBefore(condensedStyle, content.firstChild);
+    const removes = new Set();
+    removes.add(condensedStyle);
+    removeNodesFromTemplate(template, removes);
+  }
+};
+var render2 = (result, container, options) => {
+  if (!options || typeof options !== "object" || !options.scopeName) {
+    throw new Error("The `scopeName` option is required.");
+  }
+  const scopeName = options.scopeName;
+  const hasRendered = parts.has(container);
+  const needsScoping = compatibleShadyCSSVersion && container.nodeType === 11 && !!container.host;
+  const firstScopeRender = needsScoping && !shadyRenderSet.has(scopeName);
+  const renderContainer = firstScopeRender ? document.createDocumentFragment() : container;
+  render(result, renderContainer, Object.assign({templateFactory: shadyTemplateFactory(scopeName)}, options));
+  if (firstScopeRender) {
+    const part = parts.get(renderContainer);
+    parts.delete(renderContainer);
+    const template = part.value instanceof TemplateInstance ? part.value.template : void 0;
+    prepareTemplateStyles(scopeName, renderContainer, template);
+    removeNodes(container, container.firstChild);
+    container.appendChild(renderContainer);
+    parts.set(container, part);
+  }
+  if (!hasRendered && needsScoping) {
+    window.ShadyCSS.styleElement(container.host);
+  }
+};
+
+// src/TemplateElement.js
+var TemplateElement = class extends StyledElement {
+  constructor(options) {
+    super({
+      deferUpdate: false,
+      shadowRender: false,
+      styles: [],
+      adoptGlobalStyles: true,
+      mutationObserverOptions: {
+        childList: false
+      },
+      ...options
+    });
+    this._template = this._options.template;
+    if (this._options.shadowRender)
+      this.attachShadow({mode: "open"});
+  }
+  template() {
+    return html``;
+  }
+  update(options) {
+    this.renderTemplate();
+    super.update(options);
+  }
+  renderTemplate() {
+    const template = this._template || this.template();
+    if (typeof template === "string") {
+      this.getRoot().innerHTML = `${template}`;
+    } else {
+      render2(html` ${template} `, this.getRoot(), {
+        scopeName: this.localName,
+        eventContext: this
+      });
+    }
+  }
+  getRoot() {
+    return this.shadowRoot !== null ? this.shadowRoot : this;
+  }
+};
+export {
+  BaseElement,
+  StyledElement,
+  TemplateElement,
+  defineElement,
+  html,
+  i18n,
+  toString
+};
+//# sourceMappingURL=index.js.map