@beeq/core 1.12.1 → 1.12.2-beta.0

package/dist/components/p-DDCN9O42.js

@@ -0,0 +1,2669 @@
+/*!
+ * Built by Endavans
+ * © https://beeq.design - Apache 2 License.
+ */
+const t = "beeq";
+
+const e = /* beeq */ {
+  hotModuleReplacement: false,
+  hydratedSelectorName: "hydrated",
+  lazyLoad: false,
+  shadowDom: true,
+  state: true,
+  updatable: true
+};
+
+/*
+ Stencil Client Platform v4.41.3 | MIT Licensed | https://stenciljs.com
+ */
+// src/utils/constants.ts
+var n = "http://www.w3.org/2000/svg";
+
+var r = "http://www.w3.org/1999/xhtml";
+
+var i =  (t => {
+  t["Undefined"] = "undefined";
+  t["Null"] = "null";
+  t["String"] = "string";
+  t["Number"] = "number";
+  t["SpecialNumber"] = "number";
+  t["Boolean"] = "boolean";
+  t["BigInt"] = "bigint";
+  return t;
+})(i || {});
+
+var s =  (t => {
+  t["Array"] = "array";
+  t["Date"] = "date";
+  t["Map"] = "map";
+  t["Object"] = "object";
+  t["RegularExpression"] = "regexp";
+  t["Set"] = "set";
+  t["Channel"] = "channel";
+  t["Symbol"] = "symbol";
+  return t;
+})(s || {});
+
+var l = "type";
+
+var o = "value";
+
+var f = "serialized:";
+
+var reWireGetterSetter = (t, e) => {
+  var n;
+  const r = e.t;
+  const i = Object.entries((n = r.i) != null ? n : {});
+  i.map((([n, [r]]) => {
+    if (r & 31 /* Prop */ || r & 32 /* State */) {
+      const r = t[n];
+      const i = getPropertyDescriptor(Object.getPrototypeOf(t), n) || Object.getOwnPropertyDescriptor(t, n);
+      if (i) {
+        Object.defineProperty(t, n, {
+          get() {
+            return i.get.call(this);
+          },
+          set(t) {
+            i.set.call(this, t);
+          },
+          configurable: true,
+          enumerable: true
+        });
+      }
+      t[n] = e.l.has(n) ? e.l.get(n) : r;
+    }
+  }));
+};
+
+function getPropertyDescriptor(t, e) {
+  while (t) {
+    const n = Object.getOwnPropertyDescriptor(t, e);
+    if (n == null ? void 0 : n.get) return n;
+    t = Object.getPrototypeOf(t);
+  }
+  return void 0;
+}
+
+// src/client/client-host-ref.ts
+var getHostRef = t => {
+  if (t.__stencil__getHostRef) {
+    return t.__stencil__getHostRef();
+  }
+  return void 0;
+};
+
+var registerHost = (t, n) => {
+  const r = {
+    o: 0,
+    $hostElement$: t,
+    t: n,
+    l:  new Map,
+    u:  new Map
+  };
+  {
+    r.v = new Promise((t => r.h = t));
+    t["s-p"] = [];
+    t["s-rc"] = [];
+  }
+  const i = r;
+  t.__stencil__getHostRef = () => i;
+  if (n.o & 512 /* hasModernPropertyDecls */ && e.state) {
+    reWireGetterSetter(t, r);
+  }
+  return i;
+};
+
+var isMemberInElement = (t, e) => e in t;
+
+var consoleError = (t, e) => (0, console.error)(t, e)
+// src/client/client-style.ts
+;
+
+var a =  new Map;
+
+// src/runtime/runtime-constants.ts
+var c = "r";
+
+var u = "o";
+
+var d = "s";
+
+var v = "t";
+
+var p = "c";
+
+var b = "s-id";
+
+var g = "sty-id";
+
+var m = "c-id";
+
+var $ = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+
+var y = "http://www.w3.org/1999/xlink";
+
+var S = [ "formAssociatedCallback", "formResetCallback", "formDisabledCallback", "formStateRestoreCallback" ];
+
+var w = typeof window !== "undefined" ? window : {};
+
+var j = w.HTMLElement || class {};
+
+var O = {
+  o: 0,
+  p: "",
+  jmp: t => t(),
+  raf: t => requestAnimationFrame(t),
+  ael: (t, e, n, r) => t.addEventListener(e, n, r),
+  rel: (t, e, n, r) => t.removeEventListener(e, n, r),
+  ce: (t, e) => new CustomEvent(t, e)
+};
+
+var N = e.shadowDom;
+
+var C =  (() => {
+  var t;
+  let e = false;
+  try {
+    (t = w.document) == null ? void 0 : t.addEventListener("e", null, Object.defineProperty({}, "passive", {
+      get() {
+        e = true;
+      }
+    }));
+  } catch (t) {}
+  return e;
+})();
+
+var promiseResolve = t => Promise.resolve(t);
+
+var x =  (() => {
+  try {
+    if (!w.document.adoptedStyleSheets) {
+      return false;
+    }
+    new CSSStyleSheet;
+    return typeof (new CSSStyleSheet).replaceSync === "function";
+  } catch (t) {}
+  return false;
+})();
+
+var A = x ?  (() => !!w.document && Object.getOwnPropertyDescriptor(w.document.adoptedStyleSheets, "length").writable)() : false;
+
+var E = false;
+
+var k = [];
+
+var H = [];
+
+var queueTask = (t, e) => n => {
+  t.push(n);
+  if (!E) {
+    E = true;
+    if (e && O.o & 4 /* queueSync */) {
+      nextTick(flush);
+    } else {
+      O.raf(flush);
+    }
+  }
+};
+
+var consume = t => {
+  for (let e = 0; e < t.length; e++) {
+    try {
+      t[e](performance.now());
+    } catch (t) {
+      consoleError(t);
+    }
+  }
+  t.length = 0;
+};
+
+var flush = () => {
+  consume(k);
+  {
+    consume(H);
+    if (E = k.length > 0) {
+      O.raf(flush);
+    }
+  }
+};
+
+var nextTick = t => promiseResolve().then(t);
+
+var I =  queueTask(H, true);
+
+// src/runtime/asset-path.ts
+var getAssetPath = t => {
+  const e = new URL(t, O.p);
+  return e.origin !== w.location.origin ? e.href : e.pathname;
+};
+
+var setAssetPath = t => O.p = t
+// src/utils/style.ts
+;
+
+function createStyleSheetIfNeededAndSupported(t) {
+  return void 0;
+}
+
+// src/utils/shadow-root.ts
+var M;
+
+function createShadowRoot(t) {
+  var e;
+  const n = {
+    mode: "open"
+  };
+  {
+    n.delegatesFocus = !!(t.o & 16 /* shadowDelegatesFocus */);
+  }
+  const r = this.attachShadow(n);
+  if (M === void 0) M = (e = createStyleSheetIfNeededAndSupported()) != null ? e : null;
+  if (M) {
+    if (A) {
+      r.adoptedStyleSheets.push(M);
+    } else {
+      r.adoptedStyleSheets = [ ...r.adoptedStyleSheets, M ];
+    }
+  }
+}
+
+var updateFallbackSlotVisibility = t => {
+  const e = internalCall(t, "childNodes");
+  if (t.tagName && t.tagName.includes("-") && t["s-cr"] && t.tagName !== "SLOT-FB") {
+    getHostSlotNodes(e, t.tagName).forEach((t => {
+      if (t.nodeType === 1 /* ElementNode */ && t.tagName === "SLOT-FB") {
+        if (getSlotChildSiblings(t, getSlotName(t), false).length) {
+          t.hidden = true;
+        } else {
+          t.hidden = false;
+        }
+      }
+    }));
+  }
+  let n = 0;
+  for (n = 0; n < e.length; n++) {
+    const t = e[n];
+    if (t.nodeType === 1 /* ElementNode */ && internalCall(t, "childNodes").length) {
+      updateFallbackSlotVisibility(t);
+    }
+  }
+};
+
+var getSlottedChildNodes = t => {
+  const e = [];
+  for (let n = 0; n < t.length; n++) {
+    const r = t[n]["s-nr"] || void 0;
+    if (r && r.isConnected) {
+      e.push(r);
+    }
+  }
+  return e;
+};
+
+function getHostSlotNodes(t, e, n) {
+  let r = 0;
+  let i = [];
+  let s;
+  for (;r < t.length; r++) {
+    s = t[r];
+    if (s["s-sr"] && (!e || s["s-hn"] === e) && (n === void 0 || getSlotName(s) === n)) {
+      i.push(s);
+      if (typeof n !== "undefined") return i;
+    }
+    i = [ ...i, ...getHostSlotNodes(s.childNodes, e, n) ];
+  }
+  return i;
+}
+
+var getSlotChildSiblings = (t, e, n = true) => {
+  const r = [];
+  if (n && t["s-sr"] || !t["s-sr"]) r.push(t);
+  let i = t;
+  while (i = i.nextSibling) {
+    if (getSlotName(i) === e && (n || !i["s-sr"])) r.push(i);
+  }
+  return r;
+};
+
+var addSlotRelocateNode = (t, e, n, r) => {
+  if (t["s-ol"] && t["s-ol"].isConnected) {
+    return;
+  }
+  const i = document.createTextNode("");
+  i["s-nr"] = t;
+  if (!e["s-cr"] || !e["s-cr"].parentNode) return;
+  const s = e["s-cr"].parentNode;
+  const l = n ? internalCall(s, "prepend") : internalCall(s, "appendChild");
+  if (typeof r !== "undefined") {
+    i["s-oo"] = r;
+    const t = internalCall(s, "childNodes");
+    const e = [ i ];
+    t.forEach((t => {
+      if (t["s-nr"]) e.push(t);
+    }));
+    e.sort(((t, e) => {
+      if (!t["s-oo"] || t["s-oo"] < (e["s-oo"] || 0)) return -1; else if (!e["s-oo"] || e["s-oo"] < t["s-oo"]) return 1;
+      return 0;
+    }));
+    e.forEach((t => l.call(s, t)));
+  } else {
+    l.call(s, i);
+  }
+  t["s-ol"] = i;
+  t["s-sh"] = e["s-hn"];
+};
+
+var getSlotName = t => typeof t["s-sn"] === "string" ? t["s-sn"] : t.nodeType === 1 && t.getAttribute("slot") || void 0;
+
+function patchSlotNode(t) {
+  if (t.assignedElements || t.assignedNodes || !t["s-sr"]) return;
+  const assignedFactory = e => function(t) {
+    const n = [];
+    const r = this["s-sn"];
+    if (t == null ? void 0 : t.flatten) {
+      console.error(`\n          Flattening is not supported for Stencil non-shadow slots.\n          You can use \`.childNodes\` to nested slot fallback content.\n          If you have a particular use case, please open an issue on the Stencil repo.\n        `);
+    }
+    const i = this["s-cr"].parentElement;
+    const s = i.__childNodes ? i.childNodes : getSlottedChildNodes(i.childNodes);
+    s.forEach((t => {
+      if (r === getSlotName(t)) {
+        n.push(t);
+      }
+    }));
+    if (e) {
+      return n.filter((t => t.nodeType === 1 /* ElementNode */));
+    }
+    return n;
+  }.bind(t);
+  t.assignedElements = assignedFactory(true);
+  t.assignedNodes = assignedFactory(false);
+}
+
+function dispatchSlotChangeEvent(t) {
+  t.dispatchEvent(new CustomEvent("slotchange", {
+    bubbles: false,
+    cancelable: false,
+    composed: false
+  }));
+}
+
+function findSlotFromSlottedNode(t, e) {
+  var n;
+  e = e || ((n = t["s-ol"]) == null ? void 0 : n.parentElement);
+  if (!e) return {
+    slotNode: null,
+    slotName: ""
+  };
+  const r = t["s-sn"] = getSlotName(t) || "";
+  const i = internalCall(e, "childNodes");
+  const s = getHostSlotNodes(i, e.tagName, r)[0];
+  return {
+    slotNode: s,
+    slotName: r
+  };
+}
+
+// src/runtime/dom-extras.ts
+var patchPseudoShadowDom = t => {
+  patchCloneNode(t);
+  patchSlotAppendChild(t);
+  patchSlotAppend(t);
+  patchSlotPrepend(t);
+  patchSlotInsertAdjacentElement(t);
+  patchSlotInsertAdjacentHTML(t);
+  patchSlotInsertAdjacentText(t);
+  patchInsertBefore(t);
+  patchTextContent(t);
+  patchChildSlotNodes(t);
+  patchSlotRemoveChild(t);
+};
+
+var patchCloneNode = t => {
+  if (t.__cloneNode) return;
+  const e = t.__cloneNode = t.cloneNode;
+  t.cloneNode = function(t) {
+    const n = this;
+    const r = n.shadowRoot && N;
+    const i = e.call(n, r ? t : false);
+    if (!r && t) {
+      let t = 0;
+      let e, n;
+      const r = [ "s-id", "s-cr", "s-lr", "s-rc", "s-sc", "s-p", "s-cn", "s-sr", "s-sn", "s-hn", "s-ol", "s-nr", "s-si", "s-rf", "s-scs" ];
+      const s = this.__childNodes || this.childNodes;
+      for (;t < s.length; t++) {
+        e = s[t]["s-nr"];
+        n = r.every((e => !s[t][e]));
+        if (e) {
+          if (i.__appendChild) {
+            i.__appendChild(e.cloneNode(true));
+          } else {
+            i.appendChild(e.cloneNode(true));
+          }
+        }
+        if (n) {
+          i.appendChild(s[t].cloneNode(true));
+        }
+      }
+    }
+    return i;
+  };
+};
+
+var patchSlotAppendChild = t => {
+  if (t.__appendChild) return;
+  t.__appendChild = t.appendChild;
+  t.appendChild = function(t) {
+    const {slotName: e, slotNode: n} = findSlotFromSlottedNode(t, this);
+    if (n) {
+      addSlotRelocateNode(t, n);
+      const r = getSlotChildSiblings(n, e);
+      const i = r[r.length - 1];
+      const s = internalCall(i, "parentNode");
+      const l = internalCall(s, "insertBefore")(t, i.nextSibling);
+      dispatchSlotChangeEvent(n);
+      updateFallbackSlotVisibility(this);
+      return l;
+    }
+    return this.__appendChild(t);
+  };
+};
+
+var patchSlotRemoveChild = t => {
+  if (t.__removeChild) return;
+  t.__removeChild = t.removeChild;
+  t.removeChild = function(t) {
+    if (t && typeof t["s-sn"] !== "undefined") {
+      const e = this.__childNodes || this.childNodes;
+      const n = getHostSlotNodes(e, this.tagName, t["s-sn"]);
+      if (n && t.isConnected) {
+        t.remove();
+        updateFallbackSlotVisibility(this);
+        return;
+      }
+    }
+    return this.__removeChild(t);
+  };
+};
+
+var patchSlotPrepend = t => {
+  if (t.__prepend) return;
+  t.__prepend = t.prepend;
+  t.prepend = function(...e) {
+    e.forEach((e => {
+      if (typeof e === "string") {
+        e = this.ownerDocument.createTextNode(e);
+      }
+      const n = (e["s-sn"] = getSlotName(e)) || "";
+      const r = internalCall(this, "childNodes");
+      const i = getHostSlotNodes(r, this.tagName, n)[0];
+      if (i) {
+        addSlotRelocateNode(e, i, true);
+        const t = getSlotChildSiblings(i, n);
+        const r = t[0];
+        const s = internalCall(r, "parentNode");
+        const l = internalCall(s, "insertBefore")(e, internalCall(r, "nextSibling"));
+        dispatchSlotChangeEvent(i);
+        return l;
+      }
+      if (e.nodeType === 1 && !!e.getAttribute("slot")) {
+        e.hidden = true;
+      }
+      return t.__prepend(e);
+    }));
+  };
+};
+
+var patchSlotAppend = t => {
+  if (t.__append) return;
+  t.__append = t.append;
+  t.append = function(...t) {
+    t.forEach((t => {
+      if (typeof t === "string") {
+        t = this.ownerDocument.createTextNode(t);
+      }
+      this.appendChild(t);
+    }));
+  };
+};
+
+var patchSlotInsertAdjacentHTML = t => {
+  if (t.__insertAdjacentHTML) return;
+  const e = t.insertAdjacentHTML;
+  t.insertAdjacentHTML = function(t, n) {
+    if (t !== "afterbegin" && t !== "beforeend") {
+      return e.call(this, t, n);
+    }
+    const r = this.ownerDocument.createElement("_");
+    let i;
+    r.innerHTML = n;
+    if (t === "afterbegin") {
+      while (i = r.firstChild) {
+        this.prepend(i);
+      }
+    } else if (t === "beforeend") {
+      while (i = r.firstChild) {
+        this.append(i);
+      }
+    }
+  };
+};
+
+var patchSlotInsertAdjacentText = t => {
+  t.insertAdjacentText = function(t, e) {
+    this.insertAdjacentHTML(t, e);
+  };
+};
+
+var patchInsertBefore = t => {
+  if (t.__insertBefore) return;
+  const e = t;
+  if (e.__insertBefore) return;
+  e.__insertBefore = t.insertBefore;
+  t.insertBefore = function(t, e) {
+    const {slotName: n, slotNode: r} = findSlotFromSlottedNode(t, this);
+    const i = this.__childNodes ? this.childNodes : getSlottedChildNodes(this.childNodes);
+    if (r) {
+      let s = false;
+      i.forEach((i => {
+        if (i === e || e === null) {
+          s = true;
+          if (e === null || n !== e["s-sn"]) {
+            this.appendChild(t);
+            return;
+          }
+          if (n === e["s-sn"]) {
+            addSlotRelocateNode(t, r);
+            const n = internalCall(e, "parentNode");
+            internalCall(n, "insertBefore")(t, e);
+            dispatchSlotChangeEvent(r);
+          }
+          return;
+        }
+      }));
+      if (s) return t;
+    }
+    const s = e == null ? void 0 : e.__parentNode;
+    if (s && !this.isSameNode(s)) {
+      return this.appendChild(t);
+    }
+    return this.__insertBefore(t, e);
+  };
+};
+
+var patchSlotInsertAdjacentElement = t => {
+  if (t.__insertAdjacentElement) return;
+  const e = t.insertAdjacentElement;
+  t.insertAdjacentElement = function(t, n) {
+    if (t !== "afterbegin" && t !== "beforeend") {
+      return e.call(this, t, n);
+    }
+    if (t === "afterbegin") {
+      this.prepend(n);
+      return n;
+    } else if (t === "beforeend") {
+      this.append(n);
+      return n;
+    }
+    return n;
+  };
+};
+
+var patchTextContent = t => {
+  patchHostOriginalAccessor("textContent", t);
+  Object.defineProperty(t, "textContent", {
+    get: function() {
+      let t = "";
+      const e = this.__childNodes ? this.childNodes : getSlottedChildNodes(this.childNodes);
+      e.forEach((e => t += e.textContent || ""));
+      return t;
+    },
+    set: function(t) {
+      const e = this.__childNodes ? this.childNodes : getSlottedChildNodes(this.childNodes);
+      e.forEach((t => {
+        if (t["s-ol"]) t["s-ol"].remove();
+        t.remove();
+      }));
+      this.insertAdjacentHTML("beforeend", t);
+    }
+  });
+};
+
+var patchChildSlotNodes = t => {
+  class e extends Array {
+    item(t) {
+      return this[t];
+    }
+  }
+  patchHostOriginalAccessor("children", t);
+  Object.defineProperty(t, "children", {
+    get() {
+      return this.childNodes.filter((t => t.nodeType === 1));
+    }
+  });
+  Object.defineProperty(t, "childElementCount", {
+    get() {
+      return this.children.length;
+    }
+  });
+  patchHostOriginalAccessor("firstChild", t);
+  Object.defineProperty(t, "firstChild", {
+    get() {
+      return this.childNodes[0];
+    }
+  });
+  patchHostOriginalAccessor("lastChild", t);
+  Object.defineProperty(t, "lastChild", {
+    get() {
+      return this.childNodes[this.childNodes.length - 1];
+    }
+  });
+  patchHostOriginalAccessor("childNodes", t);
+  Object.defineProperty(t, "childNodes", {
+    get() {
+      const t = new e;
+      t.push(...getSlottedChildNodes(this.__childNodes));
+      return t;
+    }
+  });
+};
+
+var patchSlottedNode = t => {
+  if (!t || t.__nextSibling !== void 0 || !globalThis.Node) return;
+  patchNextSibling(t);
+  patchPreviousSibling(t);
+  patchParentNode(t);
+  if (t.nodeType === Node.ELEMENT_NODE) {
+    patchNextElementSibling(t);
+    patchPreviousElementSibling(t);
+  }
+};
+
+var patchNextSibling = t => {
+  if (!t || t.__nextSibling) return;
+  patchHostOriginalAccessor("nextSibling", t);
+  Object.defineProperty(t, "nextSibling", {
+    get: function() {
+      var t;
+      const e = (t = this["s-ol"]) == null ? void 0 : t.parentNode.childNodes;
+      const n = e == null ? void 0 : e.indexOf(this);
+      if (e && n > -1) {
+        return e[n + 1];
+      }
+      return this.__nextSibling;
+    }
+  });
+};
+
+var patchNextElementSibling = t => {
+  if (!t || t.__nextElementSibling) return;
+  patchHostOriginalAccessor("nextElementSibling", t);
+  Object.defineProperty(t, "nextElementSibling", {
+    get: function() {
+      var t;
+      const e = (t = this["s-ol"]) == null ? void 0 : t.parentNode.children;
+      const n = e == null ? void 0 : e.indexOf(this);
+      if (e && n > -1) {
+        return e[n + 1];
+      }
+      return this.__nextElementSibling;
+    }
+  });
+};
+
+var patchPreviousSibling = t => {
+  if (!t || t.__previousSibling) return;
+  patchHostOriginalAccessor("previousSibling", t);
+  Object.defineProperty(t, "previousSibling", {
+    get: function() {
+      var t;
+      const e = (t = this["s-ol"]) == null ? void 0 : t.parentNode.childNodes;
+      const n = e == null ? void 0 : e.indexOf(this);
+      if (e && n > -1) {
+        return e[n - 1];
+      }
+      return this.__previousSibling;
+    }
+  });
+};
+
+var patchPreviousElementSibling = t => {
+  if (!t || t.__previousElementSibling) return;
+  patchHostOriginalAccessor("previousElementSibling", t);
+  Object.defineProperty(t, "previousElementSibling", {
+    get: function() {
+      var t;
+      const e = (t = this["s-ol"]) == null ? void 0 : t.parentNode.children;
+      const n = e == null ? void 0 : e.indexOf(this);
+      if (e && n > -1) {
+        return e[n - 1];
+      }
+      return this.__previousElementSibling;
+    }
+  });
+};
+
+var patchParentNode = t => {
+  if (!t || t.__parentNode) return;
+  patchHostOriginalAccessor("parentNode", t);
+  Object.defineProperty(t, "parentNode", {
+    get: function() {
+      var t;
+      return ((t = this["s-ol"]) == null ? void 0 : t.parentNode) || this.__parentNode;
+    },
+    set: function(t) {
+      this.__parentNode = t;
+    }
+  });
+};
+
+var _ = [ "children", "nextElementSibling", "previousElementSibling" ];
+
+var D = [ "childNodes", "firstChild", "lastChild", "nextSibling", "previousSibling", "textContent", "parentNode" ];
+
+function patchHostOriginalAccessor(t, e) {
+  if (!globalThis.Node || !globalThis.Element) {
+    return;
+  }
+  let n;
+  if (_.includes(t)) {
+    n = Object.getOwnPropertyDescriptor(Element.prototype, t);
+  } else if (D.includes(t)) {
+    n = Object.getOwnPropertyDescriptor(Node.prototype, t);
+  }
+  if (!n) {
+    n = Object.getOwnPropertyDescriptor(e, t);
+  }
+  if (n) Object.defineProperty(e, "__" + t, n);
+}
+
+function internalCall(t, e) {
+  if ("__" + e in t) {
+    const n = t["__" + e];
+    if (typeof n !== "function") return n;
+    return n.bind(t);
+  } else {
+    if (typeof t[e] !== "function") return t[e];
+    return t[e].bind(t);
+  }
+}
+
+var createTime = (t, e = "") => {
+  {
+    return () => {};
+  }
+};
+
+// src/utils/query-nonce-meta-tag-content.ts
+function queryNonceMetaTagContent(t) {
+  var e, n, r;
+  return (r = (n = (e = t.head) == null ? void 0 : e.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : n.getAttribute("content")) != null ? r : void 0;
+}
+
+// src/runtime/styles.ts
+var R =  new WeakMap;
+
+var registerStyle = (t, e, n) => {
+  let r = a.get(t);
+  if (x && n) {
+    r = r || new CSSStyleSheet;
+    if (typeof r === "string") {
+      r = e;
+    } else {
+      r.replaceSync(e);
+    }
+  } else {
+    r = e;
+  }
+  a.set(t, r);
+};
+
+var addStyle = (t, e, n) => {
+  var r, i, s;
+  const l = getScopeId(e);
+  const o = a.get(l);
+  if (!w.document) {
+    return l;
+  }
+  t = t.nodeType === 11 /* DocumentFragment */ ? t : w.document;
+  if (o) {
+    if (typeof o === "string") {
+      t = t.head || t;
+      let n = R.get(t);
+      let s;
+      if (!n) {
+        R.set(t, n =  new Set);
+      }
+      const f = t.querySelector(`[${g}="${l}"]`);
+      if (f) {
+        f.textContent = o;
+      } else if (!n.has(l)) {
+        s = w.document.createElement("style");
+        s.textContent = o;
+        const f = (r = O.m) != null ? r : queryNonceMetaTagContent(w.document);
+        if (f != null) {
+          s.setAttribute("nonce", f);
+        }
+        if (!(e.o & 1 /* shadowDomEncapsulation */)) {
+          if (t.nodeName === "HEAD") {
+            const e = t.querySelectorAll("link[rel=preconnect]");
+            const n = e.length > 0 ? e[e.length - 1].nextSibling : t.querySelector("style");
+            t.insertBefore(s, (n == null ? void 0 : n.parentNode) === t ? n : null);
+          } else if ("host" in t) {
+            if (x) {
+              const e = (i = t.defaultView) != null ? i : t.ownerDocument.defaultView;
+              const n = new e.CSSStyleSheet;
+              n.replaceSync(o);
+              if (A) {
+                t.adoptedStyleSheets.unshift(n);
+              } else {
+                t.adoptedStyleSheets = [ n, ...t.adoptedStyleSheets ];
+              }
+            } else {
+              const e = t.querySelector("style");
+              if (e) {
+                e.textContent = o + e.textContent;
+              } else {
+                t.prepend(s);
+              }
+            }
+          } else {
+            t.append(s);
+          }
+        }
+        if (e.o & 1 /* shadowDomEncapsulation */) {
+          t.insertBefore(s, null);
+        }
+        if (e.o & 4 /* hasSlotRelocation */) {
+          s.textContent += $;
+        }
+        if (n) {
+          n.add(l);
+        }
+      }
+    } else {
+      let e = R.get(t);
+      if (!e) {
+        R.set(t, e =  new Set);
+      }
+      if (!e.has(l)) {
+        const n = (s = t.defaultView) != null ? s : t.ownerDocument.defaultView;
+        let r;
+        if (o.constructor === n.CSSStyleSheet) {
+          r = o;
+        } else {
+          r = new n.CSSStyleSheet;
+          for (let t = 0; t < o.cssRules.length; t++) {
+            r.insertRule(o.cssRules[t].cssText, t);
+          }
+        }
+        if (A) {
+          t.adoptedStyleSheets.push(r);
+        } else {
+          t.adoptedStyleSheets = [ ...t.adoptedStyleSheets, r ];
+        }
+        e.add(l);
+      }
+    }
+  }
+  return l;
+};
+
+var attachStyles = t => {
+  const e = t.t;
+  const n = t.$hostElement$;
+  const r = e.o;
+  const i = createTime("attachStyles", e.$);
+  const s = addStyle(n.shadowRoot ? n.shadowRoot : n.getRootNode(), e);
+  if (r & 10 /* needsScopedEncapsulation */) {
+    n["s-sc"] = s;
+    n.classList.add(s + "-h");
+  }
+  i();
+};
+
+var getScopeId = (t, e) => "sc-" + t.$;
+
+var convertScopedToShadow = t => t.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, "$1{");
+
+var hydrateScopedToShadow = () => {
+  if (!w.document) {
+    return;
+  }
+  const t = w.document.querySelectorAll(`[${g}]`);
+  let e = 0;
+  for (;e < t.length; e++) {
+    registerStyle(t[e].getAttribute(g), convertScopedToShadow(t[e].innerHTML), true);
+  }
+};
+
+var isComplexType = t => {
+  t = typeof t;
+  return t === "object" || t === "function";
+};
+
+// src/runtime/vdom/h.ts
+var h = (t, e, ...n) => {
+  if (typeof t === "string") {
+    t = transformTag(t);
+  }
+  let r = null;
+  let i = null;
+  let s = false;
+  let l = false;
+  const o = [];
+  const walk = e => {
+    for (let n = 0; n < e.length; n++) {
+      r = e[n];
+      if (Array.isArray(r)) {
+        walk(r);
+      } else if (r != null && typeof r !== "boolean") {
+        if (s = typeof t !== "function" && !isComplexType(r)) {
+          r = String(r);
+        }
+        if (s && l) {
+          o[o.length - 1].S += r;
+        } else {
+          o.push(s ? newVNode(null, r) : r);
+        }
+        l = s;
+      }
+    }
+  };
+  walk(n);
+  if (e) {
+    if (e.key) {
+      i = e.key;
+    }
+    {
+      const t = e.className || e.class;
+      if (t) {
+        e.class = typeof t !== "object" ? t : Object.keys(t).filter((e => t[e])).join(" ");
+      }
+    }
+  }
+  if (typeof t === "function") {
+    return t(e === null ? {} : e, o, T);
+  }
+  const f = newVNode(t, null);
+  f.j = e;
+  if (o.length > 0) {
+    f.O = o;
+  }
+  {
+    f.N = i;
+  }
+  return f;
+};
+
+var newVNode = (t, e) => {
+  const n = {
+    o: 0,
+    C: t,
+    // Normalize undefined to null to prevent rendering "undefined" as text
+    S: e != null ? e : null,
+    A: null,
+    O: null
+  };
+  {
+    n.j = null;
+  }
+  {
+    n.N = null;
+  }
+  return n;
+};
+
+var L = {};
+
+var isHost = t => t && t.C === L;
+
+var T = {
+  forEach: (t, e) => t.map(convertToPublic).forEach(e),
+  map: (t, e) => t.map(convertToPublic).map(e).map(convertToPrivate)
+};
+
+var convertToPublic = t => ({
+  vattrs: t.j,
+  vchildren: t.O,
+  vkey: t.N,
+  vname: t.k,
+  vtag: t.C,
+  vtext: t.S
+});
+
+var convertToPrivate = t => {
+  if (typeof t.vtag === "function") {
+    const e = {
+      ...t.vattrs
+    };
+    if (t.vkey) {
+      e.key = t.vkey;
+    }
+    if (t.vname) {
+      e.name = t.vname;
+    }
+    return h(t.vtag, e, ...t.vchildren || []);
+  }
+  const e = newVNode(t.vtag, t.vtext);
+  e.j = t.vattrs;
+  e.O = t.vchildren;
+  e.N = t.vkey;
+  e.k = t.vname;
+  return e;
+};
+
+// src/runtime/client-hydrate.ts
+var initializeClientHydrate = (t, e, n, r) => {
+  var i, s, l, o;
+  const f = createTime("hydrateClient", e);
+  const a = t.shadowRoot;
+  const c = [];
+  const u = [];
+  const d = [];
+  const v = a ? [] : null;
+  const p = newVNode(e, null);
+  p.A = t;
+  if (w.document && (!O.H || !O.H.size)) {
+    initializeDocumentHydrate(w.document.body, O.H =  new Map);
+  }
+  t[b] = n;
+  t.removeAttribute(b);
+  r.I = clientHydrate(p, c, u, v, t, t, n, d);
+  let g = 0;
+  const m = c.length;
+  let $;
+  for (g; g < m; g++) {
+    $ = c[g];
+    const n = $.M + "." + $._;
+    const r = O.H.get(n);
+    const s = $.A;
+    if (!a) {
+      s["s-hn"] = transformTag(e).toUpperCase();
+      if ($.C === "slot") {
+        s["s-cr"] = t["s-cr"];
+      }
+    } else if (((i = $.C) == null ? void 0 : i.toString().includes("-")) && $.C !== "slot-fb" && !$.A.shadowRoot) {
+      const t = getHostRef($.A);
+      if (t) {
+        const e = getScopeId(t.t);
+        const n = w.document.querySelector(`style[sty-id="${e}"]`);
+        if (n) {
+          v.unshift(n.cloneNode(true));
+        }
+      }
+    }
+    if ($.C === "slot") {
+      $.k = $.A["s-sn"] || $.A["name"] || null;
+      if ($.O) {
+        $.o |= 2 /* isSlotFallback */;
+        if (!$.A.childNodes.length) {
+          $.O.forEach((t => {
+            $.A.appendChild(t.A);
+          }));
+        }
+      } else {
+        $.o |= 1 /* isSlotReference */;
+      }
+    }
+    if (r && r.isConnected) {
+      if (r.parentElement.shadowRoot && r["s-en"] === "") {
+        r.parentNode.insertBefore(s, r.nextSibling);
+      }
+      r.parentNode.removeChild(r);
+      if (!a) {
+        s["s-oo"] = parseInt($._);
+      }
+    }
+    if (r && !r["s-id"]) {
+      O.H.delete(n);
+    }
+  }
+  const y = [];
+  const S = d.length;
+  let j = 0;
+  let N;
+  let C;
+  let x;
+  let A;
+  let E = 0;
+  for (j; j < S; j++) {
+    N = d[j];
+    if (!N || !N.length) continue;
+    x = N.length;
+    C = 0;
+    for (C; C < x; C++) {
+      A = N[C];
+      if (!y[A.hostId]) {
+        y[A.hostId] = O.H.get(A.hostId);
+      }
+      if (!y[A.hostId]) continue;
+      const t = y[A.hostId];
+      if (t.shadowRoot && A.node.parentElement !== t) {
+        t.insertBefore(A.node, (l = (s = N[C - 1]) == null ? void 0 : s.node) == null ? void 0 : l.nextSibling);
+      }
+      if (!t.shadowRoot || !a) {
+        if (!A.slot["s-cr"]) {
+          A.slot["s-cr"] = t["s-cr"];
+          if (!A.slot["s-cr"] && t.shadowRoot) {
+            A.slot["s-cr"] = t;
+          } else {
+            A.slot["s-cr"] = (t.__childNodes || t.childNodes)[0];
+          }
+        }
+        addSlotRelocateNode(A.node, A.slot, false, A.node["s-oo"] || E);
+        if (((o = A.node.parentElement) == null ? void 0 : o.shadowRoot) && A.node["getAttribute"] && A.node.getAttribute("slot")) {
+          A.node.removeAttribute("slot");
+        }
+        {
+          patchSlottedNode(A.node);
+        }
+      }
+      E = (A.node["s-oo"] || E) + 1;
+    }
+  }
+  if (a && !a.childNodes.length) {
+    let e = 0;
+    const n = v.length;
+    if (n) {
+      for (e; e < n; e++) {
+        const t = v[e];
+        if (t) {
+          a.appendChild(t);
+        }
+      }
+      Array.from(t.childNodes).forEach((t => {
+        if (typeof t["s-en"] !== "string" && typeof t["s-sn"] !== "string") {
+          if (t.nodeType === 1 /* ElementNode */ && t.slot && t.hidden) {
+            t.removeAttribute("hidden");
+          } else if (t.nodeType === 8 /* CommentNode */ && !t.nodeValue) {
+            t.parentNode.removeChild(t);
+          }
+        }
+      }));
+    }
+  }
+  r.$hostElement$ = t;
+  f();
+};
+
+var clientHydrate = (t, e, n, r, i, s, l, o = []) => {
+  let f;
+  let a;
+  let u;
+  let b;
+  if (s.nodeType === 1 /* ElementNode */) {
+    f = s.getAttribute(m);
+    if (f) {
+      a = f.split(".");
+      if (a[0] === l || a[0] === "0") {
+        u = createSimpleVNode({
+          o: 0,
+          M: a[0],
+          _: a[1],
+          D: a[2],
+          R: a[3],
+          C: s.tagName.toLowerCase(),
+          A: s,
+          // If we don't add the initial classes to the VNode, the first `vdom-render.ts` patch
+          // won't try to reconcile them. Classes set on the node will be blown away.
+          j: {
+            class: s.className || ""
+          }
+        });
+        e.push(u);
+        s.removeAttribute(m);
+        if (!t.O) {
+          t.O = [];
+        }
+        const i = u.A.getAttribute("s-sn");
+        if (typeof i === "string") {
+          if (u.C === "slot-fb") {
+            addSlot(i, a[2], u, s, t, e, n, r, o);
+          }
+          u.A["s-sn"] = i;
+          u.A.removeAttribute("s-sn");
+        }
+        if (u.R !== void 0) {
+          t.O[u.R] = u;
+        }
+        t = u;
+        if (r && u.D === "0") {
+          r[u.R] = u.A;
+        }
+      }
+    }
+    if (s.shadowRoot) {
+      for (b = s.shadowRoot.childNodes.length - 1; b >= 0; b--) {
+        clientHydrate(t, e, n, r, i, s.shadowRoot.childNodes[b], l, o);
+      }
+    }
+    const c = s.__childNodes || s.childNodes;
+    for (b = c.length - 1; b >= 0; b--) {
+      clientHydrate(t, e, n, r, i, c[b], l, o);
+    }
+  } else if (s.nodeType === 8 /* CommentNode */) {
+    a = s.nodeValue.split(".");
+    if (a[1] === l || a[1] === "0") {
+      f = a[0];
+      u = createSimpleVNode({
+        M: a[1],
+        _: a[2],
+        D: a[3],
+        R: a[4] || "0",
+        A: s,
+        j: null,
+        O: null,
+        N: null,
+        k: null,
+        C: null,
+        S: null
+      });
+      if (f === v) {
+        u.A = findCorrespondingNode(s, 3 /* TextNode */);
+        if (u.A && u.A.nodeType === 3 /* TextNode */) {
+          u.S = u.A.textContent;
+          e.push(u);
+          s.remove();
+          if (l === u.M) {
+            if (!t.O) {
+              t.O = [];
+            }
+            t.O[u.R] = u;
+          }
+          if (r && u.D === "0") {
+            r[u.R] = u.A;
+          }
+        }
+      } else if (f === p) {
+        u.A = findCorrespondingNode(s, 8 /* CommentNode */);
+        if (u.A && u.A.nodeType === 8 /* CommentNode */) {
+          e.push(u);
+          s.remove();
+        }
+      } else if (u.M === l) {
+        if (f === d) {
+          const i = s["s-sn"] = a[5] || "";
+          addSlot(i, a[2], u, s, t, e, n, r, o);
+        } else if (f === c) {
+          if (r) {
+            s.remove();
+          }
+        }
+      }
+    }
+  } else if (t && t.C === "style") {
+    const e = newVNode(null, s.textContent);
+    e.A = s;
+    e.R = "0";
+    t.O = [ e ];
+  }
+  return t;
+};
+
+var initializeDocumentHydrate = (t, e) => {
+  if (t.nodeType === 1 /* ElementNode */) {
+    const n = t[b] || t.getAttribute(b);
+    if (n) {
+      e.set(n, t);
+    }
+    let r = 0;
+    if (t.shadowRoot) {
+      for (;r < t.shadowRoot.childNodes.length; r++) {
+        initializeDocumentHydrate(t.shadowRoot.childNodes[r], e);
+      }
+    }
+    const i = t.__childNodes || t.childNodes;
+    for (r = 0; r < i.length; r++) {
+      initializeDocumentHydrate(i[r], e);
+    }
+  } else if (t.nodeType === 8 /* CommentNode */) {
+    const n = t.nodeValue.split(".");
+    if (n[0] === u) {
+      e.set(n[1] + "." + n[2], t);
+      t.nodeValue = "";
+      t["s-en"] = n[3];
+    }
+  }
+};
+
+var createSimpleVNode = t => {
+  const e = {
+    o: 0,
+    M: null,
+    _: null,
+    D: null,
+    R: "0",
+    A: null,
+    j: null,
+    O: null,
+    N: null,
+    k: null,
+    C: null,
+    S: null
+  };
+  return {
+    ...e,
+    ...t
+  };
+};
+
+function addSlot(t, e, n, r, i, s, l, o, f) {
+  r["s-sr"] = true;
+  n.k = t || null;
+  n.C = "slot";
+  const a = (i == null ? void 0 : i.A) ? i.A["s-id"] || i.A.getAttribute("s-id") : "";
+  if (o && w.document) {
+    const s = n.A = w.document.createElement(n.C);
+    if (n.k) {
+      n.A.setAttribute("name", t);
+    }
+    if (i.A.shadowRoot && a && a !== n.M) {
+      internalCall(i.A, "insertBefore")(s, internalCall(i.A, "children")[0]);
+    } else {
+      internalCall(internalCall(r, "parentNode"), "insertBefore")(s, r);
+    }
+    addSlottedNodes(f, e, t, r, n.M);
+    r.remove();
+    if (n.D === "0") {
+      o[n.R] = n.A;
+    }
+  } else {
+    const s = n.A;
+    const l = a && a !== n.M && i.A.shadowRoot;
+    addSlottedNodes(f, e, t, r, l ? a : n.M);
+    patchSlotNode(r);
+    if (l) {
+      i.A.insertBefore(s, i.A.children[0]);
+    }
+  }
+  s.push(n);
+  l.push(n);
+  if (!i.O) {
+    i.O = [];
+  }
+  i.O[n.R] = n;
+}
+
+var addSlottedNodes = (t, e, n, r, i) => {
+  var s, l;
+  let o = r.nextSibling;
+  t[e] = t[e] || [];
+  if (!o || ((s = o.nodeValue) == null ? void 0 : s.startsWith(d + "."))) return;
+  do {
+    if (o && ((o["getAttribute"] && o.getAttribute("slot") || o["s-sn"]) === n || n === "" && !o["s-sn"] && (!o["getAttribute"] || !o.getAttribute("slot")) && (o.nodeType === 8 /* CommentNode */ || o.nodeType === 3 /* TextNode */))) {
+      o["s-sn"] = n;
+      t[e].push({
+        slot: r,
+        node: o,
+        hostId: i
+      });
+    }
+    o = o == null ? void 0 : o.nextSibling;
+  } while (o && !((l = o.nodeValue) == null ? void 0 : l.startsWith(d + ".")));
+};
+
+var findCorrespondingNode = (t, e) => {
+  let n = t;
+  do {
+    n = n.nextSibling;
+  } while (n && (n.nodeType !== e || !n.nodeValue));
+  return n;
+};
+
+// src/utils/remote-value.ts
+var U = class t {
+  /**
+   * Deserializes a LocalValue serialized object back to its original JavaScript representation
+   *
+   * @param serialized The serialized LocalValue object
+   * @returns The original JavaScript value/object
+   */
+  static fromLocalValue(e) {
+    const n = e[l];
+    const r = o in e ? e[o] : void 0;
+    switch (n) {
+     case "string" /* String */ :
+      return r;
+
+     case "boolean" /* Boolean */ :
+      return r;
+
+     case "bigint" /* BigInt */ :
+      return BigInt(r);
+
+     case "undefined" /* Undefined */ :
+      return void 0;
+
+     case "null" /* Null */ :
+      return null;
+
+     case "number" /* Number */ :
+      if (r === "NaN") return NaN;
+      if (r === "-0") return -0;
+      if (r === "Infinity") return Infinity;
+      if (r === "-Infinity") return -Infinity;
+      return r;
+
+     case "array" /* Array */ :
+      return r.map((e => t.fromLocalValue(e)));
+
+     case "date" /* Date */ :
+      return new Date(r);
+
+     case "map" /* Map */ :
+      const e =  new Map;
+      for (const [n, i] of r) {
+        const r = typeof n === "object" && n !== null ? t.fromLocalValue(n) : n;
+        const s = t.fromLocalValue(i);
+        e.set(r, s);
+      }
+      return e;
+
+     case "object" /* Object */ :
+      const i = {};
+      for (const [e, n] of r) {
+        i[e] = t.fromLocalValue(n);
+      }
+      return i;
+
+     case "regexp" /* RegularExpression */ :
+      const {pattern: s, flags: l} = r;
+      return new RegExp(s, l);
+
+     case "set" /* Set */ :
+      const o =  new Set;
+      for (const e of r) {
+        o.add(t.fromLocalValue(e));
+      }
+      return o;
+
+     case "symbol" /* Symbol */ :
+      return Symbol(r);
+
+     default:
+      throw new Error(`Unsupported type: ${n}`);
+    }
+  }
+  /**
+   * Utility method to deserialize multiple LocalValues at once
+   *
+   * @param serializedValues Array of serialized LocalValue objects
+   * @returns Array of deserialized JavaScript values
+   */  static fromLocalValueArray(e) {
+    return e.map((e => t.fromLocalValue(e)));
+  }
+  /**
+   * Verifies if the given object matches the structure of a serialized LocalValue
+   *
+   * @param obj Object to verify
+   * @returns boolean indicating if the object has LocalValue structure
+   */  static isLocalValueObject(t) {
+    if (typeof t !== "object" || t === null) {
+      return false;
+    }
+    if (!t.hasOwnProperty(l)) {
+      return false;
+    }
+    const e = t[l];
+    const n = Object.values({
+      ...i,
+      ...s
+    }).includes(e);
+    if (!n) {
+      return false;
+    }
+    if (e !== "null" /* Null */ && e !== "undefined" /* Undefined */) {
+      return t.hasOwnProperty(o);
+    }
+    return true;
+  }
+};
+
+// src/utils/serialize.ts
+function deserializeProperty(t) {
+  if (typeof t !== "string" || !t.startsWith(f)) {
+    return t;
+  }
+  return U.fromLocalValue(JSON.parse(atob(t.slice(f.length))));
+}
+
+// src/runtime/parse-property-value.ts
+var parsePropertyValue = (t, e, n) => {
+  if (typeof t === "string" && t.startsWith(f)) {
+    t = deserializeProperty(t);
+    return t;
+  }
+  if (t != null && !isComplexType(t)) {
+    if (e & 4 /* Boolean */) {
+      if (n && typeof t === "string") {
+        return t === "" || !!t;
+      } else {
+        return t === "false" ? false : t === "" || !!t;
+      }
+    }
+    if (e & 2 /* Number */) {
+      return typeof t === "string" ? parseFloat(t) : typeof t === "number" ? t : NaN;
+    }
+    if (e & 1 /* String */) {
+      return String(t);
+    }
+    return t;
+  }
+  return t;
+};
+
+var getElement = t => t;
+
+// src/runtime/event-emitter.ts
+var createEvent = (t, e, n) => {
+  const r = getElement(t);
+  return {
+    emit: t => emitEvent(r, e, {
+      bubbles: true,
+      composed: true,
+      cancelable: true,
+      detail: t
+    })
+  };
+};
+
+var emitEvent = (t, e, n) => {
+  const r = O.ce(e, n);
+  t.dispatchEvent(r);
+  return r;
+};
+
+var setAccessor = (t, e, n, r, i, s, l) => {
+  if (n === r) {
+    return;
+  }
+  let o = isMemberInElement(t, e);
+  let f = e.toLowerCase();
+  if (e === "class") {
+    const e = t.classList;
+    const i = parseClassList(n);
+    let s = parseClassList(r);
+    if ((t["s-si"] || t["s-sc"]) && l) {
+      const n = t["s-sc"] || t["s-si"];
+      s.push(n);
+      i.forEach((t => {
+        if (t.startsWith(n)) s.push(t);
+      }));
+      s = [ ...new Set(s) ].filter((t => t));
+      e.add(...s);
+    } else {
+      e.remove(...i.filter((t => t && !s.includes(t))));
+      e.add(...s.filter((t => t && !i.includes(t))));
+    }
+  } else if (e === "style") {
+    {
+      for (const e in n) {
+        if (!r || r[e] == null) {
+          if (e.includes("-")) {
+            t.style.removeProperty(e);
+          } else {
+            t.style[e] = "";
+          }
+        }
+      }
+    }
+    for (const e in r) {
+      if (!n || r[e] !== n[e]) {
+        if (e.includes("-")) {
+          t.style.setProperty(e, r[e]);
+        } else {
+          t.style[e] = r[e];
+        }
+      }
+    }
+  } else if (e === "key") ; else if (e === "ref") {
+    if (r) {
+      queueRefAttachment(r, t);
+    }
+  } else if (!t.__lookupSetter__(e) && e[0] === "o" && e[1] === "n") {
+    if (e[2] === "-") {
+      e = e.slice(3);
+    } else if (isMemberInElement(w, f)) {
+      e = f.slice(2);
+    } else {
+      e = f[2] + e.slice(3);
+    }
+    if (n || r) {
+      const i = e.endsWith(P);
+      e = e.replace(B, "");
+      if (n) {
+        O.rel(t, e, n, i);
+      }
+      if (r) {
+        O.ael(t, e, r, i);
+      }
+    }
+  } else {
+    const l = isComplexType(r);
+    if ((o || l && r !== null) && !i) {
+      try {
+        if (!t.tagName.includes("-")) {
+          const i = r == null ? "" : r;
+          if (e === "list") {
+            o = false;
+          } else if (n == null || t[e] != i) {
+            if (typeof t.__lookupSetter__(e) === "function") {
+              t[e] = i;
+            } else {
+              t.setAttribute(e, i);
+            }
+          }
+        } else if (t[e] !== r) {
+          t[e] = r;
+        }
+      } catch (t) {}
+    }
+    let a = false;
+    {
+      if (f !== (f = f.replace(/^xlink\:?/, ""))) {
+        e = f;
+        a = true;
+      }
+    }
+    if (r == null || r === false) {
+      if (r !== false || t.getAttribute(e) === "") {
+        if (a) {
+          t.removeAttributeNS(y, e);
+        } else {
+          t.removeAttribute(e);
+        }
+      }
+    } else if ((!o || s & 4 /* isHost */ || i) && !l && t.nodeType === 1 /* ElementNode */) {
+      r = r === true ? "" : r;
+      if (a) {
+        t.setAttributeNS(y, e, r);
+      } else {
+        t.setAttribute(e, r);
+      }
+    }
+  }
+};
+
+var F = /\s/;
+
+var parseClassList = t => {
+  if (typeof t === "object" && t && "baseVal" in t) {
+    t = t.baseVal;
+  }
+  if (!t || typeof t !== "string") {
+    return [];
+  }
+  return t.split(F);
+};
+
+var P = "Capture";
+
+var B = new RegExp(P + "$");
+
+// src/runtime/vdom/update-element.ts
+var updateElement = (t, e, n, r) => {
+  const i = e.A.nodeType === 11 /* DocumentFragment */ && e.A.host ? e.A.host : e.A;
+  const s = t && t.j || {};
+  const l = e.j || {};
+  {
+    for (const t of sortedAttrNames(Object.keys(s))) {
+      if (!(t in l)) {
+        setAccessor(i, t, s[t], void 0, n, e.o, r);
+      }
+    }
+  }
+  for (const t of sortedAttrNames(Object.keys(l))) {
+    setAccessor(i, t, s[t], l[t], n, e.o, r);
+  }
+};
+
+function sortedAttrNames(t) {
+  return t.includes("ref") ? 
+  // we need to sort these to ensure that `'ref'` is the last attr
+  [ ...t.filter((t => t !== "ref")), "ref" ] : 
+  // no need to sort, return the original array
+  t;
+}
+
+var W;
+
+var V = false;
+
+var q = false;
+
+var z = [];
+
+var Y = [];
+
+var createElm = (t, e, i) => {
+  const s = e.O[i];
+  let l = 0;
+  let o;
+  let f;
+  if (s.S != null) {
+    o = s.A = w.document.createTextNode(s.S);
+  } else {
+    if (!q) {
+      q = s.C === "svg";
+    }
+    if (!w.document) {
+      throw new Error("You are trying to render a Stencil component in an environment that doesn't support the DOM.");
+    }
+    o = s.A = w.document.createElementNS(q ? n : r, s.C);
+    if (q && s.C === "foreignObject") {
+      q = false;
+    }
+    {
+      updateElement(null, s, q);
+    }
+    if (s.O) {
+      const e = s.C === "template" ? o.content : o;
+      for (l = 0; l < s.O.length; ++l) {
+        f = createElm(t, s, l);
+        if (f) {
+          e.appendChild(f);
+        }
+      }
+    }
+    {
+      if (s.C === "svg") {
+        q = false;
+      } else if (o.tagName === "foreignObject") {
+        q = true;
+      }
+    }
+  }
+  o["s-hn"] = W;
+  return o;
+};
+
+var relocateToHostRoot = t => {
+  O.o |= 1 /* isTmpDisconnected */;
+  const e = t.closest(W.toLowerCase());
+  if (e != null) {
+    const n = Array.from(e.__childNodes || e.childNodes).find((t => t["s-cr"]));
+    const r = Array.from(t.__childNodes || t.childNodes);
+    for (const t of n ? r.reverse() : r) {
+      if (t["s-sh"] != null) {
+        insertBefore(e, t, n != null ? n : null);
+        t["s-sh"] = void 0;
+      }
+    }
+  }
+  O.o &= -2 /* isTmpDisconnected */;
+};
+
+var addVnodes = (t, e, n, r, i, s) => {
+  let l = t;
+  let o;
+  if (l.shadowRoot && l.tagName === W) {
+    l = l.shadowRoot;
+  }
+  if (n.C === "template") {
+    l = l.content;
+  }
+  for (;i <= s; ++i) {
+    if (r[i]) {
+      o = createElm(null, n, i);
+      if (o) {
+        r[i].A = o;
+        insertBefore(l, o, e);
+      }
+    }
+  }
+};
+
+var removeVnodes = (t, e, n) => {
+  for (let r = e; r <= n; ++r) {
+    const e = t[r];
+    if (e) {
+      const t = e.A;
+      nullifyVNodeRefs(e);
+      if (t) {
+        t.remove();
+      }
+    }
+  }
+};
+
+var updateChildren = (t, e, n, r, i = false) => {
+  let s = 0;
+  let l = 0;
+  let o = 0;
+  let f = 0;
+  let a = e.length - 1;
+  let c = e[0];
+  let u = e[a];
+  let d = r.length - 1;
+  let v = r[0];
+  let p = r[d];
+  let b;
+  let g;
+  const m = n.C === "template" ? t.content : t;
+  while (s <= a && l <= d) {
+    if (c == null) {
+      c = e[++s];
+    } else if (u == null) {
+      u = e[--a];
+    } else if (v == null) {
+      v = r[++l];
+    } else if (p == null) {
+      p = r[--d];
+    } else if (isSameVnode(c, v, i)) {
+      patch(c, v, i);
+      c = e[++s];
+      v = r[++l];
+    } else if (isSameVnode(u, p, i)) {
+      patch(u, p, i);
+      u = e[--a];
+      p = r[--d];
+    } else if (isSameVnode(c, p, i)) {
+      patch(c, p, i);
+      insertBefore(m, c.A, u.A.nextSibling);
+      c = e[++s];
+      p = r[--d];
+    } else if (isSameVnode(u, v, i)) {
+      patch(u, v, i);
+      insertBefore(m, u.A, c.A);
+      u = e[--a];
+      v = r[++l];
+    } else {
+      o = -1;
+      {
+        for (f = s; f <= a; ++f) {
+          if (e[f] && e[f].N !== null && e[f].N === v.N) {
+            o = f;
+            break;
+          }
+        }
+      }
+      if (o >= 0) {
+        g = e[o];
+        if (g.C !== v.C) {
+          b = createElm(e && e[l], n, o);
+        } else {
+          patch(g, v, i);
+          e[o] = void 0;
+          b = g.A;
+        }
+        v = r[++l];
+      } else {
+        b = createElm(e && e[l], n, l);
+        v = r[++l];
+      }
+      if (b) {
+        {
+          insertBefore(c.A.parentNode, b, c.A);
+        }
+      }
+    }
+  }
+  if (s > a) {
+    addVnodes(t, r[d + 1] == null ? null : r[d + 1].A, n, r, l, d);
+  } else if (l > d) {
+    removeVnodes(e, s, a);
+  }
+};
+
+var isSameVnode = (t, e, n = false) => {
+  if (t.C === e.C) {
+    if (!n) {
+      return t.N === e.N;
+    }
+    if (n && !t.N && e.N) {
+      t.N = e.N;
+    }
+    return true;
+  }
+  return false;
+};
+
+var patch = (t, n, r = false) => {
+  const i = n.A = t.A;
+  const s = t.O;
+  const l = n.O;
+  const o = n.C;
+  const f = n.S;
+  if (f == null) {
+    {
+      q = o === "svg" ? true : o === "foreignObject" ? false : q;
+    }
+    {
+      if (o === "slot" && !V) {
+        if (t.k !== n.k) {
+          n.A["s-sn"] = n.k || "";
+          relocateToHostRoot(n.A.parentElement);
+        }
+      }
+      updateElement(t, n, q, r);
+    }
+    if (s !== null && l !== null) {
+      updateChildren(i, s, n, l, r);
+    } else if (l !== null) {
+      if (t.S !== null) {
+        i.textContent = "";
+      }
+      addVnodes(i, null, n, l, 0, l.length - 1);
+    } else if (
+    // don't do this on initial render as it can cause non-hydrated content to be removed
+    !r && e.updatable && s !== null) {
+      removeVnodes(s, 0, s.length - 1);
+    } else if (r && e.updatable && s !== null && l === null) {
+      n.O = s;
+    }
+    if (q && o === "svg") {
+      q = false;
+    }
+  } else if (t.S !== f) {
+    i.data = f;
+  }
+};
+
+var nullifyVNodeRefs = t => {
+  {
+    if (t.j && t.j.ref) {
+      z.push((() => t.j.ref(null)));
+    }
+    t.O && t.O.map(nullifyVNodeRefs);
+  }
+};
+
+var queueRefAttachment = (t, e) => {
+  {
+    Y.push((() => t(e)));
+  }
+};
+
+var flushQueuedRefCallbacks = () => {
+  {
+    z.forEach((t => t()));
+    z.length = 0;
+    Y.forEach((t => t()));
+    Y.length = 0;
+  }
+};
+
+var insertBefore = (t, e, n, r) => {
+  if (t.__insertBefore) {
+    return t.__insertBefore(e, n);
+  } else {
+    return t == null ? void 0 : t.insertBefore(e, n);
+  }
+};
+
+var renderVdom = (t, e, n = false) => {
+  const r = t.$hostElement$;
+  const i = t.t;
+  const s = t.I || newVNode(null, null);
+  const l = isHost(e);
+  const o = l ? e : h(null, null, e);
+  W = r.tagName;
+  if (i.L) {
+    o.j = o.j || {};
+    i.L.forEach((([t, e]) => {
+      {
+        o.j[e] = r[t];
+      }
+    }));
+  }
+  if (n && o.j) {
+    for (const t of Object.keys(o.j)) {
+      if (r.hasAttribute(t) && ![ "key", "ref", "style", "class" ].includes(t)) {
+        o.j[t] = r[t];
+      }
+    }
+  }
+  o.C = null;
+  o.o |= 4 /* isHost */;
+  t.I = o;
+  o.A = s.A = r.shadowRoot || r;
+  V = !!(i.o & 1 /* shadowDomEncapsulation */) && !(i.o & 128 /* shadowNeedsScopedCss */);
+  patch(s, o, n);
+  flushQueuedRefCallbacks();
+};
+
+// src/runtime/update-component.ts
+var attachToAncestor = (t, e) => {
+  if (e && !t.T && e["s-p"]) {
+    const n = e["s-p"].push(new Promise((r => t.T = () => {
+      e["s-p"].splice(n - 1, 1);
+      r();
+    })));
+  }
+};
+
+var scheduleUpdate = (t, e) => {
+  {
+    t.o |= 16 /* isQueuedForUpdate */;
+  }
+  if (t.o & 4 /* isWaitingForChildren */) {
+    t.o |= 512 /* needsRerender */;
+    return;
+  }
+  attachToAncestor(t, t.U);
+  const dispatch = () => dispatchHooks(t, e);
+  if (e) {
+    queueMicrotask((() => {
+      dispatch();
+    }));
+    return;
+  }
+  return I(dispatch);
+};
+
+var dispatchHooks = (t, e) => {
+  const n = t.$hostElement$;
+  const r = createTime("scheduleUpdate", t.t.$);
+  const i = n;
+  if (!i) {
+    throw new Error(`Can't render component <${n.tagName.toLowerCase()} /> with invalid Stencil runtime! Make sure this imported component is compiled with a \`externalRuntime: true\` flag. For more information, please refer to https://stenciljs.com/docs/custom-elements#externalruntime`);
+  }
+  let s;
+  if (e) {
+    emitLifecycleEvent(n, "componentWillLoad");
+    s = safeCall(i, "componentWillLoad", void 0, n);
+  } else {
+    emitLifecycleEvent(n, "componentWillUpdate");
+    s = safeCall(i, "componentWillUpdate", void 0, n);
+  }
+  emitLifecycleEvent(n, "componentWillRender");
+  s = enqueue(s, (() => safeCall(i, "componentWillRender", void 0, n)));
+  r();
+  return enqueue(s, (() => updateComponent(t, i, e)));
+};
+
+var enqueue = (t, e) => isPromisey(t) ? t.then(e).catch((t => {
+  console.error(t);
+  e();
+})) : e();
+
+var isPromisey = t => t instanceof Promise || t && t.then && typeof t.then === "function";
+
+var updateComponent = async (t, e, n) => {
+  var r;
+  const i = t.$hostElement$;
+  const s = createTime("update", t.t.$);
+  const l = i["s-rc"];
+  if (n) {
+    attachStyles(t);
+  }
+  const o = createTime("render", t.t.$);
+  {
+    callRender(t, e, i, n);
+  }
+  if (l) {
+    l.map((t => t()));
+    i["s-rc"] = void 0;
+  }
+  o();
+  s();
+  {
+    const e = (r = i["s-p"]) != null ? r : [];
+    const postUpdate = () => postUpdateComponent(t);
+    if (e.length === 0) {
+      postUpdate();
+    } else {
+      Promise.all(e).then(postUpdate);
+      t.o |= 4 /* isWaitingForChildren */;
+      e.length = 0;
+    }
+  }
+};
+
+var callRender = (t, e, n, r) => {
+  try {
+    e = e.render();
+    {
+      t.o &= -17 /* isQueuedForUpdate */;
+    }
+    {
+      t.o |= 2 /* hasRendered */;
+    }
+    {
+      {
+        {
+          renderVdom(t, e, r);
+        }
+      }
+    }
+  } catch (e) {
+    consoleError(e, t.$hostElement$);
+  }
+  return null;
+};
+
+var postUpdateComponent = t => {
+  const e = t.t.$;
+  const n = t.$hostElement$;
+  const r = createTime("postUpdate", e);
+  const i = n;
+  const s = t.U;
+  safeCall(i, "componentDidRender", void 0, n);
+  emitLifecycleEvent(n, "componentDidRender");
+  if (!(t.o & 64 /* hasLoadedComponent */)) {
+    t.o |= 64 /* hasLoadedComponent */;
+    {
+      addHydratedFlag(n);
+    }
+    safeCall(i, "componentDidLoad", void 0, n);
+    emitLifecycleEvent(n, "componentDidLoad");
+    r();
+    {
+      t.h(n);
+      if (!s) {
+        appDidLoad();
+      }
+    }
+  } else {
+    safeCall(i, "componentDidUpdate", void 0, n);
+    emitLifecycleEvent(n, "componentDidUpdate");
+    r();
+  }
+  {
+    if (t.T) {
+      t.T();
+      t.T = void 0;
+    }
+    if (t.o & 512 /* needsRerender */) {
+      nextTick((() => scheduleUpdate(t, false)));
+    }
+    t.o &= -517;
+  }
+};
+
+var appDidLoad = e => {
+  var n;
+  nextTick((() => emitEvent(w, "appload", {
+    detail: {
+      namespace: t
+    }
+  })));
+  {
+    if ((n = O.H) == null ? void 0 : n.size) {
+      O.H.clear();
+    }
+  }
+};
+
+var safeCall = (t, e, n, r) => {
+  if (t && t[e]) {
+    try {
+      return t[e](n);
+    } catch (t) {
+      consoleError(t, r);
+    }
+  }
+  return void 0;
+};
+
+var emitLifecycleEvent = (e, n) => {
+  {
+    emitEvent(e, "stencil_" + n, {
+      bubbles: true,
+      composed: true,
+      detail: {
+        namespace: t
+      }
+    });
+  }
+};
+
+var addHydratedFlag = t => {
+  var n;
+  return t.classList.add((n = e.hydratedSelectorName) != null ? n : "hydrated");
+};
+
+// src/runtime/set-value.ts
+var getValue = (t, e) => getHostRef(t).l.get(e);
+
+var setValue = (t, e, n, r) => {
+  const i = getHostRef(t);
+  if (!i) {
+    return;
+  }
+  const s = t;
+  const l = i.l.get(e);
+  const o = i.o;
+  const f = s;
+  n = parsePropertyValue(n, r.i[e][0], !!(r.o & 64 /* formAssociated */));
+  const a = Number.isNaN(l) && Number.isNaN(n);
+  const c = n !== l && !a;
+  if (c) {
+    i.l.set(e, n);
+    if (r.F) {
+      const t = r.F[e];
+      if (t) {
+        t.map((t => {
+          try {
+            const [[r, s]] = Object.entries(t);
+            if (o & 128 /* isWatchReady */ || s & 1 /* Immediate */) {
+              if (!f) {
+                i.P.push((() => {
+                  i.B[r](n, l, e);
+                }));
+              } else {
+                f[r](n, l, e);
+              }
+            }
+          } catch (t) {
+            consoleError(t, s);
+          }
+        }));
+      }
+    }
+    if ((o & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+      if (f.componentShouldUpdate) {
+        if (f.componentShouldUpdate(n, l, e) === false) {
+          return;
+        }
+      }
+      scheduleUpdate(i, false);
+    }
+  }
+};
+
+// src/runtime/proxy-component.ts
+var proxyComponent = (t, n, r) => {
+  var i, s;
+  const l = t.prototype;
+  if (n.o & 64 /* formAssociated */ && r & 1 /* isElementConstructor */) {
+    S.forEach((t => {
+      const e = l[t];
+      Object.defineProperty(l, t, {
+        value(...n) {
+          var r;
+          const i = getHostRef(this);
+          const s = this;
+          if (!s) {
+            (r = i == null ? void 0 : i.v) == null ? void 0 : r.then((e => {
+              const r = e[t];
+              typeof r === "function" && r.call(e, ...n);
+            }));
+          } else {
+            const t = e;
+            typeof t === "function" && t.call(s, ...n);
+          }
+        }
+      });
+    }));
+  }
+  {
+    {
+      if (t.watchers && !n.F) {
+        n.F = t.watchers;
+      }
+      if (t.deserializers && !n.W) {
+        n.W = t.deserializers;
+      }
+      if (t.serializers && !n.V) {
+        n.V = t.serializers;
+      }
+    }
+    const r = Object.entries((i = n.i) != null ? i : {});
+    r.map((([t, [e]]) => {
+      if (e & 31 /* Prop */ || e & 32 /* State */) {
+        const {get: r, set: i} = Object.getOwnPropertyDescriptor(l, t) || {};
+        if (r) n.i[t][0] |= 2048 /* Getter */;
+        if (i) n.i[t][0] |= 4096 /* Setter */;
+        {
+          Object.defineProperty(l, t, {
+            get() {
+              {
+                return r ? r.apply(this) : getValue(this, t);
+              }
+            },
+            configurable: true,
+            enumerable: true
+          });
+        }
+        Object.defineProperty(l, t, {
+          set(r) {
+            const s = getHostRef(this);
+            if (!s) {
+              return;
+            }
+            if (i) {
+              const l = e & 32 /* State */ ? this[t] : s.$hostElement$[t];
+              if (typeof l === "undefined" && s.l.get(t)) {
+                r = s.l.get(t);
+              }
+              i.apply(this, [ parsePropertyValue(r, e, !!(n.o & 64 /* formAssociated */)) ]);
+              r = e & 32 /* State */ ? this[t] : s.$hostElement$[t];
+              setValue(this, t, r, n);
+              return;
+            }
+            {
+              setValue(this, t, r, n);
+              return;
+            }
+          }
+        });
+      }
+    }));
+    {
+      const i =  new Map;
+      l.attributeChangedCallback = function(t, s, o) {
+        O.jmp((() => {
+          var f;
+          const a = i.get(t);
+          const c = getHostRef(this);
+          if (this.hasOwnProperty(a) && e.lazyLoad) ;
+          if (l.hasOwnProperty(a) && typeof this[a] === "number" && // cast type to number to avoid TS compiler issues
+          this[a] == o) {
+            return;
+          } else if (a == null) {
+            const e = c == null ? void 0 : c.o;
+            if (c && e && !(e & 8 /* isConstructingInstance */) && o !== s) {
+              const r = this;
+              const i = r;
+              const l = (f = n.F) == null ? void 0 : f[t];
+              l == null ? void 0 : l.forEach((n => {
+                const [[r, l]] = Object.entries(n);
+                if (i[r] != null && (e & 128 /* isWatchReady */ || l & 1 /* Immediate */)) {
+                  i[r].call(i, o, s, t);
+                }
+              }));
+            }
+            return;
+          }
+          const u = r.find((([t]) => t === a));
+          if (u && u[1][0] & 4 /* Boolean */) {
+            o = o === null || o === "false" ? false : true;
+          }
+          const d = Object.getOwnPropertyDescriptor(l, a);
+          if (o != this[a] && (!d.get || !!d.set)) {
+            this[a] = o;
+          }
+        }));
+      };
+      t.observedAttributes = Array.from(
+       new Set([ ...Object.keys((s = n.F) != null ? s : {}), ...r.filter((([t, e]) => e[0] & 31 /* HasAttribute */)).map((([t, e]) => {
+        var r;
+        const s = e[1] || t;
+        i.set(s, t);
+        if (e[0] & 512 /* ReflectAttr */) {
+          (r = n.L) == null ? void 0 : r.push([ t, s ]);
+        }
+        return s;
+      })) ]));
+    }
+  }
+  return t;
+};
+
+// src/runtime/initialize-component.ts
+var initializeComponent = async (t, n, r, i) => {
+  let s;
+  if ((n.o & 32 /* hasInitializedComponent */) === 0) {
+    n.o |= 32 /* hasInitializedComponent */;
+    {
+      s = t.constructor;
+      const e = t.localName;
+      customElements.whenDefined(e).then((() => n.o |= 128 /* isWatchReady */));
+    }
+    if (s && s.style) {
+      let t;
+      if (typeof s.style === "string") {
+        t = s.style;
+      }
+      const n = getScopeId(r);
+      if (!a.has(n) || e.hotModuleReplacement) {
+        const e = createTime("registerStyles", r.$);
+        registerStyle(n, t, !!(r.o & 1 /* shadowDomEncapsulation */));
+        e();
+      }
+    }
+  }
+  const l = n.U;
+  const schedule = () => scheduleUpdate(n, true);
+  if (l && l["s-rc"]) {
+    l["s-rc"].push(schedule);
+  } else {
+    schedule();
+  }
+};
+
+var fireConnectedCallback = (t, e) => {};
+
+// src/runtime/connected-callback.ts
+var connectedCallback = t => {
+  if ((O.o & 1 /* isTmpDisconnected */) === 0) {
+    const e = getHostRef(t);
+    if (!e) {
+      return;
+    }
+    const n = e.t;
+    const r = createTime("connectedCallback", n.$);
+    if (!(e.o & 1 /* hasConnected */)) {
+      e.o |= 1 /* hasConnected */;
+      let r;
+      {
+        r = t.getAttribute(b);
+        if (r) {
+          if (n.o & 1 /* shadowDomEncapsulation */) {
+            const e = addStyle(t.shadowRoot, n);
+            t.classList.remove(e + "-h", e + "-s");
+          }
+          initializeClientHydrate(t, n.$, r, e);
+        }
+      }
+      {
+        let n = t;
+        while (n = n.parentNode || n.host) {
+          if (n.nodeType === 1 /* ElementNode */ && n.hasAttribute("s-id") && n["s-p"] || n["s-p"]) {
+            attachToAncestor(e, e.U = n);
+            break;
+          }
+        }
+      }
+      if (n.i) {
+        Object.entries(n.i).map((([e, [n]]) => {
+          if (n & 31 /* Prop */ && e in t && t[e] !== Object.prototype[e]) {
+            const n = t[e];
+            delete t[e];
+            t[e] = n;
+          }
+        }));
+      }
+      {
+        initializeComponent(t, e, n);
+      }
+    } else {
+      addHostEventListeners(t, e, n.q);
+      if (e == null ? void 0 : e.B) ; else if (e == null ? void 0 : e.v) {
+        e.v.then((() => fireConnectedCallback()));
+      }
+    }
+    r();
+  }
+};
+
+var disconnectedCallback = async t => {
+  if ((O.o & 1 /* isTmpDisconnected */) === 0) {
+    const e = getHostRef(t);
+    {
+      if (e == null ? void 0 : e.Y) {
+        e.Y.map((t => t()));
+        e.Y = void 0;
+      }
+    }
+  }
+  if (R.has(t)) {
+    R.delete(t);
+  }
+  if (t.shadowRoot && R.has(t.shadowRoot)) {
+    R.delete(t.shadowRoot);
+  }
+};
+
+var proxyCustomElement = (t, e) => {
+  const n = {
+    o: e[0],
+    $: e[1]
+  };
+  {
+    n.i = e[2];
+  }
+  {
+    n.q = e[3];
+  }
+  {
+    n.F = t.F;
+    n.W = t.W;
+    n.V = t.V;
+  }
+  {
+    n.L = [];
+  }
+  if (!(n.o & 1 /* shadowDomEncapsulation */) && n.o & 256 /* hasSlot */) {
+    {
+      patchPseudoShadowDom(t.prototype);
+    }
+  } else {
+    patchCloneNode(t.prototype);
+  }
+  {
+    hydrateScopedToShadow();
+  }
+  const r = t.prototype.connectedCallback;
+  const i = t.prototype.disconnectedCallback;
+  Object.assign(t.prototype, {
+    __hasHostListenerAttached: false,
+    __registerHost() {
+      registerHost(this, n);
+    },
+    connectedCallback() {
+      if (!this.__hasHostListenerAttached) {
+        const t = getHostRef(this);
+        if (!t) {
+          return;
+        }
+        addHostEventListeners(this, t, n.q);
+        this.__hasHostListenerAttached = true;
+      }
+      connectedCallback(this);
+      if (r) {
+        r.call(this);
+      }
+    },
+    disconnectedCallback() {
+      disconnectedCallback(this);
+      if (i) {
+        i.call(this);
+      }
+    },
+    __attachShadow() {
+      {
+        if (!this.shadowRoot) {
+          createShadowRoot.call(this, n);
+        } else {
+          if (this.shadowRoot.mode !== "open") {
+            throw new Error(`Unable to re-use existing shadow root for ${n.$}! Mode is set to ${this.shadowRoot.mode} but Stencil only supports open shadow roots.`);
+          }
+        }
+      }
+    }
+  });
+  t.is = n.$;
+  return proxyComponent(t, n, 1 /* isElementConstructor */ | 2 /* proxyState */);
+};
+
+var addHostEventListeners = (t, e, n, r) => {
+  if (n && w.document) {
+    n.map((([n, r, i]) => {
+      const s = getHostListenerTarget(w.document, t, n);
+      const l = hostListenerProxy(e, i);
+      const o = hostListenerOpts(n);
+      O.ael(s, r, l, o);
+      (e.Y = e.Y || []).push((() => O.rel(s, r, l, o)));
+    }));
+  }
+};
+
+var hostListenerProxy = (t, e) => n => {
+  try {
+    {
+      t.$hostElement$[e](n);
+    }
+  } catch (e) {
+    consoleError(e, t.$hostElement$);
+  }
+};
+
+var getHostListenerTarget = (t, e, n) => {
+  if (n & 4 /* TargetDocument */) {
+    return t;
+  }
+  if (n & 8 /* TargetWindow */) {
+    return w;
+  }
+  if (n & 16 /* TargetBody */) {
+    return t.body;
+  }
+  return e;
+};
+
+var hostListenerOpts = t => C ? {
+  passive: (t & 1 /* Passive */) !== 0,
+  capture: (t & 2 /* Capture */) !== 0
+} : (t & 2 /* Capture */) !== 0
+// src/runtime/nonce.ts
+;
+
+var setNonce = t => O.m = t
+// src/runtime/platform-options.ts
+;
+
+var setPlatformOptions = t => Object.assign(O, t)
+// src/runtime/render.ts
+;
+
+function render(t, e) {
+  const n = {
+    o: 0,
+    $: e.tagName
+  };
+  const r = {
+    t: n,
+    $hostElement$: e
+  };
+  renderVdom(r, t);
+}
+
+function transformTag(t) {
+  return t;
+}
+
+// src/runtime/vdom/jsx-runtime.ts
+function jsx(t, e, n) {
+  const r = e || {};
+  const {children: i, ...s} = r;
+  let l = s;
+  if (n !== void 0 && !("key" in s)) {
+    l = {
+      ...s,
+      key: n
+    };
+  }
+  if (l && Object.keys(l).length === 0) {
+    l = null;
+  }
+  if (i !== void 0) {
+    if (Array.isArray(i)) {
+      return h(t, l, ...i);
+    }
+    if (typeof i === "object" && i !== null && "o" in i) {
+      return h(t, l, i);
+    }
+    return h(t, l, i);
+  }
+  return h(t, l);
+}
+
+function jsxs(t, e, n) {
+  return jsx(t, e, n);
+}
+
+export { j as H, setNonce as a, setPlatformOptions as b, createEvent as c, jsx as d, L as e, getAssetPath as g, jsxs as j, proxyCustomElement as p, render as r, setAssetPath as s, transformTag as t };
+//# sourceMappingURL=p-DDCN9O42.js.map
+//# sourceMappingURL=p-DDCN9O42.js.map