@beeq/core 1.12.1 → 1.12.2-beta.0

package/dist/beeq/p-D0hQxkOP.js

@@ -0,0 +1,2816 @@
+/*!
+ * Built by Endavans
+ * © https://beeq.design - Apache 2 License.
+ */
+const t = "beeq";
+
+const e = /* beeq */ {
+  hotModuleReplacement: false,
+  hydratedSelectorName: "hydrated",
+  lazyLoad: true,
+  propChangeCallback: true,
+  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._$$cmpMeta$$_;
+  const i = Object.entries((n = r._$$members$$_) != 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._$$instanceValues$$_.has(n) ? e._$$instanceValues$$_.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 registerInstance = (t, n) => {
+  if (!n) return;
+  t.__stencil__getHostRef = () => n;
+  n._$$lazyInstance$$_ = t;
+  if (n._$$cmpMeta$$_._$$flags$$_ & 512 /* hasModernPropertyDecls */ && e.state) {
+    reWireGetterSetter(t, n);
+  }
+};
+
+var registerHost = (t, e) => {
+  const n = {
+    _$$flags$$_: 0,
+    $hostElement$: t,
+    _$$cmpMeta$$_: e,
+    _$$instanceValues$$_:  new Map,
+    _$$serializerValues$$_:  new Map
+  };
+  {
+    n._$$onInstancePromise$$_ = new Promise((t => n._$$onInstanceResolve$$_ = t));
+  }
+  {
+    n._$$onReadyPromise$$_ = new Promise((t => n._$$onReadyResolve$$_ = t));
+    t["s-p"] = [];
+    t["s-rc"] = [];
+  }
+  {
+    n._$$fetchedCbList$$_ = [];
+  }
+  const r = n;
+  t.__stencil__getHostRef = () => r;
+  return r;
+};
+
+var isMemberInElement = (t, e) => e in t;
+
+var consoleError = (t, e) => (0, console.error)(t, e)
+// src/client/client-load-module.ts
+;
+
+var a =  new Map;
+
+var loadModule = (t, e, n) => {
+  const r = t._$$tagName$$_.replace(/-/g, "_");
+  const i = t._$$lazyBundleId$$_;
+  if (!i) {
+    return void 0;
+  }
+  const s = a.get(i);
+  if (s) {
+    return s[r];
+  }
+  /*!__STENCIL_STATIC_IMPORT_SWITCH__*/  return import(
+  /* @vite-ignore */
+  /* webpackInclude: /\.entry\.js$/ */
+  /* webpackExclude: /\.system\.entry\.js$/ */
+  /* webpackMode: "lazy" */
+  `./${i}.entry.js${""}`).then((t => {
+    {
+      a.set(i, t);
+    }
+    return t[r];
+  }), (t => {
+    consoleError(t, e.$hostElement$);
+  }));
+};
+
+// src/client/client-style.ts
+var c =  new Map;
+
+// src/runtime/runtime-constants.ts
+var u = "r";
+
+var d = "o";
+
+var v = "s";
+
+var p = "t";
+
+var b = "c";
+
+var g = "s-id";
+
+var m = "sty-id";
+
+var y = "c-id";
+
+var $ = "{visibility:hidden}.hydrated{visibility:inherit}";
+
+var S = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+
+var w = "http://www.w3.org/1999/xlink";
+
+var O = [ "formAssociatedCallback", "formResetCallback", "formDisabledCallback", "formStateRestoreCallback" ];
+
+var C = typeof window !== "undefined" ? window : {};
+
+var N = C.HTMLElement || class {};
+
+var j = {
+  _$$flags$$_: 0,
+  _$$resourcesUrl$$_: "",
+  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 x = e.shadowDom;
+
+var E =  (() => {
+  var t;
+  let e = false;
+  try {
+    (t = C.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 A =  (() => {
+  try {
+    if (!C.document.adoptedStyleSheets) {
+      return false;
+    }
+    new CSSStyleSheet;
+    return typeof (new CSSStyleSheet).replaceSync === "function";
+  } catch (t) {}
+  return false;
+})();
+
+var k = A ?  (() => !!C.document && Object.getOwnPropertyDescriptor(C.document.adoptedStyleSheets, "length").writable)() : false;
+
+var H = false;
+
+var M = [];
+
+var I = [];
+
+var queueTask = (t, e) => n => {
+  t.push(n);
+  if (!H) {
+    H = true;
+    if (e && j._$$flags$$_ & 4 /* queueSync */) {
+      nextTick(flush);
+    } else {
+      j.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(M);
+  {
+    consume(I);
+    if (H = M.length > 0) {
+      j.raf(flush);
+    }
+  }
+};
+
+var nextTick = t => promiseResolve().then(t);
+
+var R =  queueTask(I, true);
+
+// src/utils/style.ts
+function createStyleSheetIfNeededAndSupported(t) {
+  return void 0;
+}
+
+// src/utils/shadow-root.ts
+var T;
+
+function createShadowRoot(t) {
+  var e;
+  const n = {
+    mode: "open"
+  };
+  {
+    n.delegatesFocus = !!(t._$$flags$$_ & 16 /* shadowDelegatesFocus */);
+  }
+  const r = this.attachShadow(n);
+  if (T === void 0) T = (e = createStyleSheetIfNeededAndSupported()) != null ? e : null;
+  if (T) {
+    if (k) {
+      r.adoptedStyleSheets.push(T);
+    } else {
+      r.adoptedStyleSheets = [ ...r.adoptedStyleSheets, T ];
+    }
+  }
+}
+
+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 && x;
+    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 D = [ "children", "nextElementSibling", "previousElementSibling" ];
+
+var L = [ "childNodes", "firstChild", "lastChild", "nextSibling", "previousSibling", "textContent", "parentNode" ];
+
+function patchHostOriginalAccessor(t, e) {
+  if (!globalThis.Node || !globalThis.Element) {
+    return;
+  }
+  let n;
+  if (D.includes(t)) {
+    n = Object.getOwnPropertyDescriptor(Element.prototype, t);
+  } else if (L.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 () => {};
+  }
+};
+
+var uniqueTime = (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 P =  new WeakMap;
+
+var registerStyle = (t, e, n) => {
+  let r = c.get(t);
+  if (A && n) {
+    r = r || new CSSStyleSheet;
+    if (typeof r === "string") {
+      r = e;
+    } else {
+      r.replaceSync(e);
+    }
+  } else {
+    r = e;
+  }
+  c.set(t, r);
+};
+
+var addStyle = (t, e, n) => {
+  var r, i, s;
+  const l = getScopeId(e);
+  const o = c.get(l);
+  if (!C.document) {
+    return l;
+  }
+  t = t.nodeType === 11 /* DocumentFragment */ ? t : C.document;
+  if (o) {
+    if (typeof o === "string") {
+      t = t.head || t;
+      let n = P.get(t);
+      let s;
+      if (!n) {
+        P.set(t, n =  new Set);
+      }
+      const f = t.querySelector(`[${m}="${l}"]`);
+      if (f) {
+        f.textContent = o;
+      } else if (!n.has(l)) {
+        s = C.document.createElement("style");
+        s.textContent = o;
+        const f = (r = j._$$nonce$$_) != null ? r : queryNonceMetaTagContent(C.document);
+        if (f != null) {
+          s.setAttribute("nonce", f);
+        }
+        if (!(e._$$flags$$_ & 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 (A) {
+              const e = (i = t.defaultView) != null ? i : t.ownerDocument.defaultView;
+              const n = new e.CSSStyleSheet;
+              n.replaceSync(o);
+              if (k) {
+                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._$$flags$$_ & 1 /* shadowDomEncapsulation */) {
+          t.insertBefore(s, null);
+        }
+        if (e._$$flags$$_ & 4 /* hasSlotRelocation */) {
+          s.textContent += S;
+        }
+        if (n) {
+          n.add(l);
+        }
+      }
+    } else {
+      let e = P.get(t);
+      if (!e) {
+        P.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 (k) {
+          t.adoptedStyleSheets.push(r);
+        } else {
+          t.adoptedStyleSheets = [ ...t.adoptedStyleSheets, r ];
+        }
+        e.add(l);
+      }
+    }
+  }
+  return l;
+};
+
+var attachStyles = t => {
+  const e = t._$$cmpMeta$$_;
+  const n = t.$hostElement$;
+  const r = e._$$flags$$_;
+  const i = createTime("attachStyles", e._$$tagName$$_);
+  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._$$tagName$$_;
+
+var convertScopedToShadow = t => t.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, "$1{");
+
+var hydrateScopedToShadow = () => {
+  if (!C.document) {
+    return;
+  }
+  const t = C.document.querySelectorAll(`[${m}]`);
+  let e = 0;
+  for (;e < t.length; e++) {
+    registerStyle(t[e].getAttribute(m), 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) => {
+  let r = null;
+  let i = null;
+  let s = false;
+  let l = false;
+  const o = [];
+  const walk = t => {
+    for (let e = 0; e < t.length; e++) {
+      r = t[e];
+      if (Array.isArray(r)) {
+        walk(r);
+      } else if (r != null && typeof r !== "boolean") {
+        if (s = !isComplexType(r)) {
+          r = String(r);
+        }
+        if (s && l) {
+          o[o.length - 1]._$$text$$_ += r;
+        } else {
+          o.push(s ? newVNode(null, r) : r);
+        }
+        l = s;
+      }
+    }
+  };
+  walk(n);
+  const f = newVNode(t, null);
+  f._$$attrs$$_ = e;
+  if (o.length > 0) {
+    f._$$children$$_ = o;
+  }
+  {
+    f._$$key$$_ = i;
+  }
+  return f;
+};
+
+var newVNode = (t, e) => {
+  const n = {
+    _$$flags$$_: 0,
+    _$$tag$$_: t,
+    // Normalize undefined to null to prevent rendering "undefined" as text
+    _$$text$$_: e != null ? e : null,
+    _$$elm$$_: null,
+    _$$children$$_: null
+  };
+  {
+    n._$$attrs$$_ = null;
+  }
+  {
+    n._$$key$$_ = null;
+  }
+  return n;
+};
+
+var U = {};
+
+var isHost = t => t && t._$$tag$$_ === U
+// 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._$$elm$$_ = t;
+  if (C.document && (!j._$$orgLocNodes$$_ || !j._$$orgLocNodes$$_.size)) {
+    initializeDocumentHydrate(C.document.body, j._$$orgLocNodes$$_ =  new Map);
+  }
+  t[g] = n;
+  t.removeAttribute(g);
+  r._$$vnode$$_ = clientHydrate(p, c, u, v, t, t, n, d);
+  let b = 0;
+  const m = c.length;
+  let y;
+  for (b; b < m; b++) {
+    y = c[b];
+    const n = y._$$hostId$$_ + "." + y._$$nodeId$$_;
+    const r = j._$$orgLocNodes$$_.get(n);
+    const s = y._$$elm$$_;
+    if (!a) {
+      s["s-hn"] = transformTag(e).toUpperCase();
+      if (y._$$tag$$_ === "slot") {
+        s["s-cr"] = t["s-cr"];
+      }
+    } else if (((i = y._$$tag$$_) == null ? void 0 : i.toString().includes("-")) && y._$$tag$$_ !== "slot-fb" && !y._$$elm$$_.shadowRoot) {
+      const t = getHostRef(y._$$elm$$_);
+      if (t) {
+        const e = getScopeId(t._$$cmpMeta$$_);
+        const n = C.document.querySelector(`style[sty-id="${e}"]`);
+        if (n) {
+          v.unshift(n.cloneNode(true));
+        }
+      }
+    }
+    if (y._$$tag$$_ === "slot") {
+      y._$$name$$_ = y._$$elm$$_["s-sn"] || y._$$elm$$_["name"] || null;
+      if (y._$$children$$_) {
+        y._$$flags$$_ |= 2 /* isSlotFallback */;
+        if (!y._$$elm$$_.childNodes.length) {
+          y._$$children$$_.forEach((t => {
+            y._$$elm$$_.appendChild(t._$$elm$$_);
+          }));
+        }
+      } else {
+        y._$$flags$$_ |= 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(y._$$nodeId$$_);
+      }
+    }
+    if (r && !r["s-id"]) {
+      j._$$orgLocNodes$$_.delete(n);
+    }
+  }
+  const $ = [];
+  const S = d.length;
+  let w = 0;
+  let O;
+  let N;
+  let x;
+  let E;
+  let A = 0;
+  for (w; w < S; w++) {
+    O = d[w];
+    if (!O || !O.length) continue;
+    x = O.length;
+    N = 0;
+    for (N; N < x; N++) {
+      E = O[N];
+      if (!$[E.hostId]) {
+        $[E.hostId] = j._$$orgLocNodes$$_.get(E.hostId);
+      }
+      if (!$[E.hostId]) continue;
+      const t = $[E.hostId];
+      if (t.shadowRoot && E.node.parentElement !== t) {
+        t.insertBefore(E.node, (l = (s = O[N - 1]) == null ? void 0 : s.node) == null ? void 0 : l.nextSibling);
+      }
+      if (!t.shadowRoot || !a) {
+        if (!E.slot["s-cr"]) {
+          E.slot["s-cr"] = t["s-cr"];
+          if (!E.slot["s-cr"] && t.shadowRoot) {
+            E.slot["s-cr"] = t;
+          } else {
+            E.slot["s-cr"] = (t.__childNodes || t.childNodes)[0];
+          }
+        }
+        addSlotRelocateNode(E.node, E.slot, false, E.node["s-oo"] || A);
+        if (((o = E.node.parentElement) == null ? void 0 : o.shadowRoot) && E.node["getAttribute"] && E.node.getAttribute("slot")) {
+          E.node.removeAttribute("slot");
+        }
+        {
+          patchSlottedNode(E.node);
+        }
+      }
+      A = (E.node["s-oo"] || A) + 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 c;
+  let d;
+  if (s.nodeType === 1 /* ElementNode */) {
+    f = s.getAttribute(y);
+    if (f) {
+      a = f.split(".");
+      if (a[0] === l || a[0] === "0") {
+        c = createSimpleVNode({
+          _$$flags$$_: 0,
+          _$$hostId$$_: a[0],
+          _$$nodeId$$_: a[1],
+          _$$depth$$_: a[2],
+          _$$index$$_: a[3],
+          _$$tag$$_: s.tagName.toLowerCase(),
+          _$$elm$$_: 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.
+          _$$attrs$$_: {
+            class: s.className || ""
+          }
+        });
+        e.push(c);
+        s.removeAttribute(y);
+        if (!t._$$children$$_) {
+          t._$$children$$_ = [];
+        }
+        const i = c._$$elm$$_.getAttribute("s-sn");
+        if (typeof i === "string") {
+          if (c._$$tag$$_ === "slot-fb") {
+            addSlot(i, a[2], c, s, t, e, n, r, o);
+          }
+          c._$$elm$$_["s-sn"] = i;
+          c._$$elm$$_.removeAttribute("s-sn");
+        }
+        if (c._$$index$$_ !== void 0) {
+          t._$$children$$_[c._$$index$$_] = c;
+        }
+        t = c;
+        if (r && c._$$depth$$_ === "0") {
+          r[c._$$index$$_] = c._$$elm$$_;
+        }
+      }
+    }
+    if (s.shadowRoot) {
+      for (d = s.shadowRoot.childNodes.length - 1; d >= 0; d--) {
+        clientHydrate(t, e, n, r, i, s.shadowRoot.childNodes[d], l, o);
+      }
+    }
+    const u = s.__childNodes || s.childNodes;
+    for (d = u.length - 1; d >= 0; d--) {
+      clientHydrate(t, e, n, r, i, u[d], l, o);
+    }
+  } else if (s.nodeType === 8 /* CommentNode */) {
+    a = s.nodeValue.split(".");
+    if (a[1] === l || a[1] === "0") {
+      f = a[0];
+      c = createSimpleVNode({
+        _$$hostId$$_: a[1],
+        _$$nodeId$$_: a[2],
+        _$$depth$$_: a[3],
+        _$$index$$_: a[4] || "0",
+        _$$elm$$_: s,
+        _$$attrs$$_: null,
+        _$$children$$_: null,
+        _$$key$$_: null,
+        _$$name$$_: null,
+        _$$tag$$_: null,
+        _$$text$$_: null
+      });
+      if (f === p) {
+        c._$$elm$$_ = findCorrespondingNode(s, 3 /* TextNode */);
+        if (c._$$elm$$_ && c._$$elm$$_.nodeType === 3 /* TextNode */) {
+          c._$$text$$_ = c._$$elm$$_.textContent;
+          e.push(c);
+          s.remove();
+          if (l === c._$$hostId$$_) {
+            if (!t._$$children$$_) {
+              t._$$children$$_ = [];
+            }
+            t._$$children$$_[c._$$index$$_] = c;
+          }
+          if (r && c._$$depth$$_ === "0") {
+            r[c._$$index$$_] = c._$$elm$$_;
+          }
+        }
+      } else if (f === b) {
+        c._$$elm$$_ = findCorrespondingNode(s, 8 /* CommentNode */);
+        if (c._$$elm$$_ && c._$$elm$$_.nodeType === 8 /* CommentNode */) {
+          e.push(c);
+          s.remove();
+        }
+      } else if (c._$$hostId$$_ === l) {
+        if (f === v) {
+          const i = s["s-sn"] = a[5] || "";
+          addSlot(i, a[2], c, s, t, e, n, r, o);
+        } else if (f === u) {
+          if (r) {
+            s.remove();
+          }
+        }
+      }
+    }
+  } else if (t && t._$$tag$$_ === "style") {
+    const e = newVNode(null, s.textContent);
+    e._$$elm$$_ = s;
+    e._$$index$$_ = "0";
+    t._$$children$$_ = [ e ];
+  }
+  return t;
+};
+
+var initializeDocumentHydrate = (t, e) => {
+  if (t.nodeType === 1 /* ElementNode */) {
+    const n = t[g] || t.getAttribute(g);
+    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] === d) {
+      e.set(n[1] + "." + n[2], t);
+      t.nodeValue = "";
+      t["s-en"] = n[3];
+    }
+  }
+};
+
+var createSimpleVNode = t => {
+  const e = {
+    _$$flags$$_: 0,
+    _$$hostId$$_: null,
+    _$$nodeId$$_: null,
+    _$$depth$$_: null,
+    _$$index$$_: "0",
+    _$$elm$$_: null,
+    _$$attrs$$_: null,
+    _$$children$$_: null,
+    _$$key$$_: null,
+    _$$name$$_: null,
+    _$$tag$$_: null,
+    _$$text$$_: null
+  };
+  return {
+    ...e,
+    ...t
+  };
+};
+
+function addSlot(t, e, n, r, i, s, l, o, f) {
+  r["s-sr"] = true;
+  n._$$name$$_ = t || null;
+  n._$$tag$$_ = "slot";
+  const a = (i == null ? void 0 : i._$$elm$$_) ? i._$$elm$$_["s-id"] || i._$$elm$$_.getAttribute("s-id") : "";
+  if (o && C.document) {
+    const s = n._$$elm$$_ = C.document.createElement(n._$$tag$$_);
+    if (n._$$name$$_) {
+      n._$$elm$$_.setAttribute("name", t);
+    }
+    if (i._$$elm$$_.shadowRoot && a && a !== n._$$hostId$$_) {
+      internalCall(i._$$elm$$_, "insertBefore")(s, internalCall(i._$$elm$$_, "children")[0]);
+    } else {
+      internalCall(internalCall(r, "parentNode"), "insertBefore")(s, r);
+    }
+    addSlottedNodes(f, e, t, r, n._$$hostId$$_);
+    r.remove();
+    if (n._$$depth$$_ === "0") {
+      o[n._$$index$$_] = n._$$elm$$_;
+    }
+  } else {
+    const s = n._$$elm$$_;
+    const l = a && a !== n._$$hostId$$_ && i._$$elm$$_.shadowRoot;
+    addSlottedNodes(f, e, t, r, l ? a : n._$$hostId$$_);
+    patchSlotNode(r);
+    if (l) {
+      i._$$elm$$_.insertBefore(s, i._$$elm$$_.children[0]);
+    }
+  }
+  s.push(n);
+  l.push(n);
+  if (!i._$$children$$_) {
+    i._$$children$$_ = [];
+  }
+  i._$$children$$_[n._$$index$$_] = 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(v + "."))) 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(v + ".")));
+};
+
+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 F = 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 F.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 => {
+  var e;
+  return (e = getHostRef(t)) == null ? void 0 : e.$hostElement$;
+};
+
+// 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 = j.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 (!o && e[0] === "o" && e[1] === "n") {
+    if (e[2] === "-") {
+      e = e.slice(3);
+    } else if (isMemberInElement(C, f)) {
+      e = f.slice(2);
+    } else {
+      e = f[2] + e.slice(3);
+    }
+    if (n || r) {
+      const i = e.endsWith(B);
+      e = e.replace(W, "");
+      if (n) {
+        j.rel(t, e, n, i);
+      }
+      if (r) {
+        j.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(w, 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(w, e, r);
+      } else {
+        t.setAttribute(e, r);
+      }
+    }
+  }
+};
+
+var _ = /\s/;
+
+var parseClassList = t => {
+  if (typeof t === "object" && t && "baseVal" in t) {
+    t = t.baseVal;
+  }
+  if (!t || typeof t !== "string") {
+    return [];
+  }
+  return t.split(_);
+};
+
+var B = "Capture";
+
+var W = new RegExp(B + "$");
+
+// src/runtime/vdom/update-element.ts
+var updateElement = (t, e, n, r) => {
+  const i = e._$$elm$$_.nodeType === 11 /* DocumentFragment */ && e._$$elm$$_.host ? e._$$elm$$_.host : e._$$elm$$_;
+  const s = t && t._$$attrs$$_ || {};
+  const l = e._$$attrs$$_ || {};
+  {
+    for (const t of sortedAttrNames(Object.keys(s))) {
+      if (!(t in l)) {
+        setAccessor(i, t, s[t], void 0, n, e._$$flags$$_, r);
+      }
+    }
+  }
+  for (const t of sortedAttrNames(Object.keys(l))) {
+    setAccessor(i, t, s[t], l[t], n, e._$$flags$$_, 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 q;
+
+var z = false;
+
+var V = false;
+
+var Y = [];
+
+var G = [];
+
+var createElm = (t, e, i) => {
+  const s = e._$$children$$_[i];
+  let l = 0;
+  let o;
+  let f;
+  if (s._$$text$$_ != null) {
+    o = s._$$elm$$_ = C.document.createTextNode(s._$$text$$_);
+  } else {
+    if (!V) {
+      V = s._$$tag$$_ === "svg";
+    }
+    if (!C.document) {
+      throw new Error("You are trying to render a Stencil component in an environment that doesn't support the DOM.");
+    }
+    o = s._$$elm$$_ = C.document.createElementNS(V ? n : r, s._$$tag$$_);
+    if (V && s._$$tag$$_ === "foreignObject") {
+      V = false;
+    }
+    {
+      updateElement(null, s, V);
+    }
+    if (s._$$children$$_) {
+      const e = s._$$tag$$_ === "template" ? o.content : o;
+      for (l = 0; l < s._$$children$$_.length; ++l) {
+        f = createElm(t, s, l);
+        if (f) {
+          e.appendChild(f);
+        }
+      }
+    }
+    {
+      if (s._$$tag$$_ === "svg") {
+        V = false;
+      } else if (o.tagName === "foreignObject") {
+        V = true;
+      }
+    }
+  }
+  o["s-hn"] = q;
+  return o;
+};
+
+var relocateToHostRoot = t => {
+  j._$$flags$$_ |= 1 /* isTmpDisconnected */;
+  const e = t.closest(q.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;
+      }
+    }
+  }
+  j._$$flags$$_ &= -2 /* isTmpDisconnected */;
+};
+
+var addVnodes = (t, e, n, r, i, s) => {
+  let l = t;
+  let o;
+  if (l.shadowRoot && l.tagName === q) {
+    l = l.shadowRoot;
+  }
+  if (n._$$tag$$_ === "template") {
+    l = l.content;
+  }
+  for (;i <= s; ++i) {
+    if (r[i]) {
+      o = createElm(null, n, i);
+      if (o) {
+        r[i]._$$elm$$_ = 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._$$elm$$_;
+      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._$$tag$$_ === "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._$$elm$$_, u._$$elm$$_.nextSibling);
+      c = e[++s];
+      p = r[--d];
+    } else if (isSameVnode(u, v, i)) {
+      patch(u, v, i);
+      insertBefore(m, u._$$elm$$_, c._$$elm$$_);
+      u = e[--a];
+      v = r[++l];
+    } else {
+      o = -1;
+      {
+        for (f = s; f <= a; ++f) {
+          if (e[f] && e[f]._$$key$$_ !== null && e[f]._$$key$$_ === v._$$key$$_) {
+            o = f;
+            break;
+          }
+        }
+      }
+      if (o >= 0) {
+        g = e[o];
+        if (g._$$tag$$_ !== v._$$tag$$_) {
+          b = createElm(e && e[l], n, o);
+        } else {
+          patch(g, v, i);
+          e[o] = void 0;
+          b = g._$$elm$$_;
+        }
+        v = r[++l];
+      } else {
+        b = createElm(e && e[l], n, l);
+        v = r[++l];
+      }
+      if (b) {
+        {
+          insertBefore(c._$$elm$$_.parentNode, b, c._$$elm$$_);
+        }
+      }
+    }
+  }
+  if (s > a) {
+    addVnodes(t, r[d + 1] == null ? null : r[d + 1]._$$elm$$_, n, r, l, d);
+  } else if (l > d) {
+    removeVnodes(e, s, a);
+  }
+};
+
+var isSameVnode = (t, e, n = false) => {
+  if (t._$$tag$$_ === e._$$tag$$_) {
+    if (!n) {
+      return t._$$key$$_ === e._$$key$$_;
+    }
+    if (n && !t._$$key$$_ && e._$$key$$_) {
+      t._$$key$$_ = e._$$key$$_;
+    }
+    return true;
+  }
+  return false;
+};
+
+var patch = (t, n, r = false) => {
+  const i = n._$$elm$$_ = t._$$elm$$_;
+  const s = t._$$children$$_;
+  const l = n._$$children$$_;
+  const o = n._$$tag$$_;
+  const f = n._$$text$$_;
+  if (f == null) {
+    {
+      V = o === "svg" ? true : o === "foreignObject" ? false : V;
+    }
+    {
+      if (o === "slot" && !z) {
+        if (t._$$name$$_ !== n._$$name$$_) {
+          n._$$elm$$_["s-sn"] = n._$$name$$_ || "";
+          relocateToHostRoot(n._$$elm$$_.parentElement);
+        }
+      }
+      updateElement(t, n, V, r);
+    }
+    if (s !== null && l !== null) {
+      updateChildren(i, s, n, l, r);
+    } else if (l !== null) {
+      if (t._$$text$$_ !== 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._$$children$$_ = s;
+    }
+    if (V && o === "svg") {
+      V = false;
+    }
+  } else if (t._$$text$$_ !== f) {
+    i.data = f;
+  }
+};
+
+var nullifyVNodeRefs = t => {
+  {
+    if (t._$$attrs$$_ && t._$$attrs$$_.ref) {
+      Y.push((() => t._$$attrs$$_.ref(null)));
+    }
+    t._$$children$$_ && t._$$children$$_.map(nullifyVNodeRefs);
+  }
+};
+
+var queueRefAttachment = (t, e) => {
+  {
+    G.push((() => t(e)));
+  }
+};
+
+var flushQueuedRefCallbacks = () => {
+  {
+    Y.forEach((t => t()));
+    Y.length = 0;
+    G.forEach((t => t()));
+    G.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._$$cmpMeta$$_;
+  const s = t._$$vnode$$_ || newVNode(null, null);
+  const l = isHost(e);
+  const o = l ? e : h(null, null, e);
+  q = r.tagName;
+  if (i._$$attrsToReflect$$_) {
+    o._$$attrs$$_ = o._$$attrs$$_ || {};
+    i._$$attrsToReflect$$_.forEach((([t, e]) => {
+      {
+        o._$$attrs$$_[e] = r[t];
+      }
+    }));
+  }
+  if (n && o._$$attrs$$_) {
+    for (const t of Object.keys(o._$$attrs$$_)) {
+      if (r.hasAttribute(t) && ![ "key", "ref", "style", "class" ].includes(t)) {
+        o._$$attrs$$_[t] = r[t];
+      }
+    }
+  }
+  o._$$tag$$_ = null;
+  o._$$flags$$_ |= 4 /* isHost */;
+  t._$$vnode$$_ = o;
+  o._$$elm$$_ = s._$$elm$$_ = r.shadowRoot || r;
+  z = !!(i._$$flags$$_ & 1 /* shadowDomEncapsulation */) && !(i._$$flags$$_ & 128 /* shadowNeedsScopedCss */);
+  patch(s, o, n);
+  flushQueuedRefCallbacks();
+};
+
+// src/runtime/update-component.ts
+var attachToAncestor = (t, e) => {
+  if (e && !t._$$onRenderResolve$$_ && e["s-p"]) {
+    const n = e["s-p"].push(new Promise((r => t._$$onRenderResolve$$_ = () => {
+      e["s-p"].splice(n - 1, 1);
+      r();
+    })));
+  }
+};
+
+var scheduleUpdate = (t, e) => {
+  {
+    t._$$flags$$_ |= 16 /* isQueuedForUpdate */;
+  }
+  if (t._$$flags$$_ & 4 /* isWaitingForChildren */) {
+    t._$$flags$$_ |= 512 /* needsRerender */;
+    return;
+  }
+  attachToAncestor(t, t._$$ancestorComponent$$_);
+  const dispatch = () => dispatchHooks(t, e);
+  if (e) {
+    queueMicrotask((() => {
+      dispatch();
+    }));
+    return;
+  }
+  return R(dispatch);
+};
+
+var dispatchHooks = (t, e) => {
+  const n = t.$hostElement$;
+  const r = createTime("scheduleUpdate", t._$$cmpMeta$$_._$$tagName$$_);
+  const i = t._$$lazyInstance$$_;
+  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) {
+    {
+      {
+        t._$$flags$$_ |= 256 /* isListenReady */;
+        if (t._$$queuedListeners$$_) {
+          t._$$queuedListeners$$_.map((([t, e]) => safeCall(i, t, e, n)));
+          t._$$queuedListeners$$_ = void 0;
+        }
+      }
+      if (t._$$fetchedCbList$$_.length) {
+        t._$$fetchedCbList$$_.forEach((t => t(n)));
+      }
+    }
+    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._$$cmpMeta$$_._$$tagName$$_);
+  const l = i["s-rc"];
+  if (n) {
+    attachStyles(t);
+  }
+  const o = createTime("render", t._$$cmpMeta$$_._$$tagName$$_);
+  {
+    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._$$flags$$_ |= 4 /* isWaitingForChildren */;
+      e.length = 0;
+    }
+  }
+};
+
+var callRender = (t, e, n, r) => {
+  try {
+    e = e.render();
+    {
+      t._$$flags$$_ &= -17 /* isQueuedForUpdate */;
+    }
+    {
+      t._$$flags$$_ |= 2 /* hasRendered */;
+    }
+    {
+      {
+        {
+          renderVdom(t, e, r);
+        }
+      }
+    }
+  } catch (e) {
+    consoleError(e, t.$hostElement$);
+  }
+  return null;
+};
+
+var postUpdateComponent = t => {
+  const e = t._$$cmpMeta$$_._$$tagName$$_;
+  const n = t.$hostElement$;
+  const r = createTime("postUpdate", e);
+  const i = t._$$lazyInstance$$_;
+  const s = t._$$ancestorComponent$$_;
+  safeCall(i, "componentDidRender", void 0, n);
+  emitLifecycleEvent(n, "componentDidRender");
+  if (!(t._$$flags$$_ & 64 /* hasLoadedComponent */)) {
+    t._$$flags$$_ |= 64 /* hasLoadedComponent */;
+    {
+      addHydratedFlag(n);
+    }
+    safeCall(i, "componentDidLoad", void 0, n);
+    emitLifecycleEvent(n, "componentDidLoad");
+    r();
+    {
+      t._$$onReadyResolve$$_(n);
+      if (!s) {
+        appDidLoad();
+      }
+    }
+  } else {
+    safeCall(i, "componentDidUpdate", void 0, n);
+    emitLifecycleEvent(n, "componentDidUpdate");
+    r();
+  }
+  {
+    t._$$onInstanceResolve$$_(n);
+  }
+  {
+    if (t._$$onRenderResolve$$_) {
+      t._$$onRenderResolve$$_();
+      t._$$onRenderResolve$$_ = void 0;
+    }
+    if (t._$$flags$$_ & 512 /* needsRerender */) {
+      nextTick((() => scheduleUpdate(t, false)));
+    }
+    t._$$flags$$_ &= -517;
+  }
+};
+
+var appDidLoad = e => {
+  var n;
+  nextTick((() => emitEvent(C, "appload", {
+    detail: {
+      namespace: t
+    }
+  })));
+  {
+    if ((n = j._$$orgLocNodes$$_) == null ? void 0 : n.size) {
+      j._$$orgLocNodes$$_.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)._$$instanceValues$$_.get(e);
+
+var setValue = (t, e, n, r) => {
+  const i = getHostRef(t);
+  if (!i) {
+    return;
+  }
+  if (!i) {
+    throw new Error(`Couldn't find host element for "${r._$$tagName$$_}" as it is unknown to this Stencil runtime. This usually happens when integrating a 3rd party Stencil component with another Stencil component or application. Please reach out to the maintainers of the 3rd party Stencil component or report this on the Stencil Discord server (https://chat.stenciljs.com) or comment on this similar [GitHub issue](https://github.com/stenciljs/core/issues/5457).`);
+  }
+  const s = i.$hostElement$;
+  const l = i._$$instanceValues$$_.get(e);
+  const o = i._$$flags$$_;
+  const f = i._$$lazyInstance$$_;
+  n = parsePropertyValue(n, r._$$members$$_[e][0], !!(r._$$flags$$_ & 64 /* formAssociated */));
+  const a = Number.isNaN(l) && Number.isNaN(n);
+  const c = n !== l && !a;
+  if ((!(o & 8 /* isConstructingInstance */) || l === void 0) && c) {
+    i._$$instanceValues$$_.set(e, n);
+    if (r._$$watchers$$_) {
+      const t = r._$$watchers$$_[e];
+      if (t) {
+        t.map((t => {
+          try {
+            const [[r, s]] = Object.entries(t);
+            if (o & 128 /* isWatchReady */ || s & 1 /* Immediate */) {
+              if (!f) {
+                i._$$fetchedCbList$$_.push((() => {
+                  i._$$lazyInstance$$_[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._$$flags$$_ & 64 /* formAssociated */ && r & 1 /* isElementConstructor */) {
+    O.forEach((t => {
+      Object.defineProperty(l, t, {
+        value(...e) {
+          var n;
+          const r = getHostRef(this);
+          const i = r == null ? void 0 : r._$$lazyInstance$$_;
+          if (!i) {
+            (n = r == null ? void 0 : r._$$onReadyPromise$$_) == null ? void 0 : n.then((n => {
+              const r = n[t];
+              typeof r === "function" && r.call(n, ...e);
+            }));
+          } else {
+            const n = i[t];
+            typeof n === "function" && n.call(i, ...e);
+          }
+        }
+      });
+    }));
+  }
+  if (n._$$members$$_ || e.propChangeCallback) {
+    {
+      if (t.watchers && !n._$$watchers$$_) {
+        n._$$watchers$$_ = t.watchers;
+      }
+      if (t.deserializers && !n._$$deserializers$$_) {
+        n._$$deserializers$$_ = t.deserializers;
+      }
+      if (t.serializers && !n._$$serializers$$_) {
+        n._$$serializers$$_ = t.serializers;
+      }
+    }
+    const o = Object.entries((i = n._$$members$$_) != null ? i : {});
+    o.map((([t, [e]]) => {
+      if (e & 31 /* Prop */ || r & 2 /* proxyState */ && e & 32 /* State */) {
+        const {get: i, set: s} = Object.getOwnPropertyDescriptor(l, t) || {};
+        if (i) n._$$members$$_[t][0] |= 2048 /* Getter */;
+        if (s) n._$$members$$_[t][0] |= 4096 /* Setter */;
+        if (r & 1 /* isElementConstructor */ || !i) {
+          Object.defineProperty(l, t, {
+            get() {
+              {
+                if ((n._$$members$$_[t][0] & 2048 /* Getter */) === 0) {
+                  return getValue(this, t);
+                }
+                const e = getHostRef(this);
+                const r = e ? e._$$lazyInstance$$_ : l;
+                if (!r) return;
+                return r[t];
+              }
+            },
+            configurable: true,
+            enumerable: true
+          });
+        }
+        Object.defineProperty(l, t, {
+          set(i) {
+            const l = getHostRef(this);
+            if (!l) {
+              return;
+            }
+            if (s) {
+              const r = e & 32 /* State */ ? this[t] : l.$hostElement$[t];
+              if (typeof r === "undefined" && l._$$instanceValues$$_.get(t)) {
+                i = l._$$instanceValues$$_.get(t);
+              }
+              s.apply(this, [ parsePropertyValue(i, e, !!(n._$$flags$$_ & 64 /* formAssociated */)) ]);
+              i = e & 32 /* State */ ? this[t] : l.$hostElement$[t];
+              setValue(this, t, i, n);
+              return;
+            }
+            {
+              if ((r & 1 /* isElementConstructor */) === 0 || (n._$$members$$_[t][0] & 4096 /* Setter */) === 0) {
+                setValue(this, t, i, n);
+                if (r & 1 /* isElementConstructor */ && !l._$$lazyInstance$$_) {
+                  l._$$fetchedCbList$$_.push((() => {
+                    if (n._$$members$$_[t][0] & 4096 /* Setter */ && l._$$lazyInstance$$_[t] !== l._$$instanceValues$$_.get(t)) {
+                      l._$$lazyInstance$$_[t] = i;
+                    }
+                  }));
+                }
+                return;
+              }
+              const setterSetVal = () => {
+                const r = l._$$lazyInstance$$_[t];
+                if (!l._$$instanceValues$$_.get(t) && r) {
+                  l._$$instanceValues$$_.set(t, r);
+                }
+                l._$$lazyInstance$$_[t] = parsePropertyValue(i, e, !!(n._$$flags$$_ & 64 /* formAssociated */));
+                setValue(this, t, l._$$lazyInstance$$_[t], n);
+              };
+              if (l._$$lazyInstance$$_) {
+                setterSetVal();
+              } else {
+                l._$$fetchedCbList$$_.push((() => {
+                  setterSetVal();
+                }));
+              }
+            }
+          }
+        });
+      } else if (r & 1 /* isElementConstructor */ && e & 64 /* Method */) {
+        Object.defineProperty(l, t, {
+          value(...e) {
+            var n;
+            const r = getHostRef(this);
+            return (n = r == null ? void 0 : r._$$onInstancePromise$$_) == null ? void 0 : n.then((() => {
+              var n;
+              return (n = r._$$lazyInstance$$_) == null ? void 0 : n[t](...e);
+            }));
+          }
+        });
+      }
+    }));
+    if (r & 1 /* isElementConstructor */) {
+      const r =  new Map;
+      l.attributeChangedCallback = function(t, i, s) {
+        j.jmp((() => {
+          var f;
+          const a = r.get(t);
+          const c = getHostRef(this);
+          if (this.hasOwnProperty(a) && e.lazyLoad) {
+            s = this[a];
+            delete this[a];
+          }
+          if (l.hasOwnProperty(a) && typeof this[a] === "number" && // cast type to number to avoid TS compiler issues
+          this[a] == s) {
+            return;
+          } else if (a == null) {
+            const e = c == null ? void 0 : c._$$flags$$_;
+            if (c && e && !(e & 8 /* isConstructingInstance */) && s !== i) {
+              const r = c._$$lazyInstance$$_;
+              const l = (f = n._$$watchers$$_) == null ? void 0 : f[t];
+              l == null ? void 0 : l.forEach((n => {
+                const [[l, o]] = Object.entries(n);
+                if (r[l] != null && (e & 128 /* isWatchReady */ || o & 1 /* Immediate */)) {
+                  r[l].call(r, s, i, t);
+                }
+              }));
+            }
+            return;
+          }
+          const u = o.find((([t]) => t === a));
+          if (u && u[1][0] & 4 /* Boolean */) {
+            s = s === null || s === "false" ? false : true;
+          }
+          const d = Object.getOwnPropertyDescriptor(l, a);
+          if (s != this[a] && (!d.get || !!d.set)) {
+            this[a] = s;
+          }
+        }));
+      };
+      t.observedAttributes = Array.from(
+       new Set([ ...Object.keys((s = n._$$watchers$$_) != null ? s : {}), ...o.filter((([t, e]) => e[0] & 31 /* HasAttribute */)).map((([t, e]) => {
+        var i;
+        const s = e[1] || t;
+        r.set(s, t);
+        if (e[0] & 512 /* ReflectAttr */) {
+          (i = n._$$attrsToReflect$$_) == null ? void 0 : i.push([ t, s ]);
+        }
+        return s;
+      })) ]));
+    }
+  }
+  return t;
+};
+
+// src/runtime/initialize-component.ts
+var initializeComponent = async (t, n, r, i) => {
+  let s;
+  if ((n._$$flags$$_ & 32 /* hasInitializedComponent */) === 0) {
+    n._$$flags$$_ |= 32 /* hasInitializedComponent */;
+    const i = r._$$lazyBundleId$$_;
+    if (i) {
+      const e = loadModule(r, n);
+      if (e && "then" in e) {
+        const t = uniqueTime();
+        s = await e;
+        t();
+      } else {
+        s = e;
+      }
+      if (!s) {
+        throw new Error(`Constructor for "${r._$$tagName$$_}#${n._$$modeName$$_}" was not found`);
+      }
+      if (!s.isProxied) {
+        {
+          r._$$watchers$$_ = s.watchers;
+          r._$$serializers$$_ = s.serializers;
+          r._$$deserializers$$_ = s.deserializers;
+        }
+        proxyComponent(s, r, 2 /* proxyState */);
+        s.isProxied = true;
+      }
+      const i = createTime("createInstance", r._$$tagName$$_);
+      {
+        n._$$flags$$_ |= 8 /* isConstructingInstance */;
+      }
+      try {
+        new s(n);
+      } catch (e) {
+        consoleError(e, t);
+      }
+      {
+        n._$$flags$$_ &= -9 /* isConstructingInstance */;
+      }
+      {
+        n._$$flags$$_ |= 128 /* isWatchReady */;
+      }
+      i();
+      {
+        fireConnectedCallback(n._$$lazyInstance$$_, t);
+      }
+    } else {
+      s = t.constructor;
+      const e = t.localName;
+      customElements.whenDefined(e).then((() => n._$$flags$$_ |= 128 /* isWatchReady */));
+    }
+    if (s && s.style) {
+      let t;
+      if (typeof s.style === "string") {
+        t = s.style;
+      }
+      const n = getScopeId(r);
+      if (!c.has(n) || e.hotModuleReplacement) {
+        const e = createTime("registerStyles", r._$$tagName$$_);
+        registerStyle(n, t, !!(r._$$flags$$_ & 1 /* shadowDomEncapsulation */));
+        e();
+      }
+    }
+  }
+  const l = n._$$ancestorComponent$$_;
+  const schedule = () => scheduleUpdate(n, true);
+  if (l && l["s-rc"]) {
+    l["s-rc"].push(schedule);
+  } else {
+    schedule();
+  }
+};
+
+var fireConnectedCallback = (t, e) => {
+  {
+    safeCall(t, "connectedCallback", void 0, e);
+  }
+};
+
+// src/runtime/connected-callback.ts
+var connectedCallback = t => {
+  if ((j._$$flags$$_ & 1 /* isTmpDisconnected */) === 0) {
+    const e = getHostRef(t);
+    if (!e) {
+      return;
+    }
+    const n = e._$$cmpMeta$$_;
+    const r = createTime("connectedCallback", n._$$tagName$$_);
+    if (!(e._$$flags$$_ & 1 /* hasConnected */)) {
+      e._$$flags$$_ |= 1 /* hasConnected */;
+      let r;
+      {
+        r = t.getAttribute(g);
+        if (r) {
+          if (n._$$flags$$_ & 1 /* shadowDomEncapsulation */) {
+            const e = addStyle(t.shadowRoot, n);
+            t.classList.remove(e + "-h", e + "-s");
+          }
+          initializeClientHydrate(t, n._$$tagName$$_, 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._$$ancestorComponent$$_ = n);
+            break;
+          }
+        }
+      }
+      if (n._$$members$$_) {
+        Object.entries(n._$$members$$_).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._$$listeners$$_);
+      if (e == null ? void 0 : e._$$lazyInstance$$_) {
+        fireConnectedCallback(e._$$lazyInstance$$_, t);
+      } else if (e == null ? void 0 : e._$$onReadyPromise$$_) {
+        e._$$onReadyPromise$$_.then((() => fireConnectedCallback(e._$$lazyInstance$$_, t)));
+      }
+    }
+    r();
+  }
+};
+
+var disconnectInstance = (t, e) => {
+  {
+    safeCall(t, "disconnectedCallback", void 0, e || t);
+  }
+};
+
+var disconnectedCallback = async t => {
+  if ((j._$$flags$$_ & 1 /* isTmpDisconnected */) === 0) {
+    const e = getHostRef(t);
+    {
+      if (e == null ? void 0 : e._$$rmListeners$$_) {
+        e._$$rmListeners$$_.map((t => t()));
+        e._$$rmListeners$$_ = void 0;
+      }
+    }
+    if (e == null ? void 0 : e._$$lazyInstance$$_) {
+      disconnectInstance(e._$$lazyInstance$$_, t);
+    } else if (e == null ? void 0 : e._$$onReadyPromise$$_) {
+      e._$$onReadyPromise$$_.then((() => disconnectInstance(e._$$lazyInstance$$_, t)));
+    }
+  }
+  if (P.has(t)) {
+    P.delete(t);
+  }
+  if (t.shadowRoot && P.has(t.shadowRoot)) {
+    P.delete(t.shadowRoot);
+  }
+};
+
+// src/runtime/bootstrap-lazy.ts
+var bootstrapLazy = (t, e = {}) => {
+  var n;
+  if (!C.document) {
+    console.warn("Stencil: No document found. Skipping bootstrapping lazy components.");
+    return;
+  }
+  const r = createTime();
+  const i = [];
+  const s = e.exclude || [];
+  const l = C.customElements;
+  const o = C.document.head;
+  const f =  o.querySelector("meta[charset]");
+  const a =  C.document.createElement("style");
+  const c = [];
+  let u;
+  let d = true;
+  Object.assign(j, e);
+  j._$$resourcesUrl$$_ = new URL(e.resourcesUrl || "./", C.document.baseURI).href;
+  {
+    j._$$flags$$_ |= 2 /* appLoaded */;
+  }
+  {
+    hydrateScopedToShadow();
+  }
+  t.map((t => {
+    t[1].map((e => {
+      var n, r, o;
+      const f = {
+        _$$flags$$_: e[0],
+        _$$tagName$$_: e[1],
+        _$$members$$_: e[2],
+        _$$listeners$$_: e[3]
+      };
+      {
+        f._$$members$$_ = e[2];
+      }
+      {
+        f._$$listeners$$_ = e[3];
+      }
+      {
+        f._$$attrsToReflect$$_ = [];
+      }
+      {
+        f._$$watchers$$_ = (n = e[4]) != null ? n : {};
+        f._$$serializers$$_ = (r = e[5]) != null ? r : {};
+        f._$$deserializers$$_ = (o = e[6]) != null ? o : {};
+      }
+      const a = transformTag(f._$$tagName$$_);
+      const v = class extends HTMLElement {
+        ["s-p"];
+        ["s-rc"];
+        hasRegisteredEventListeners=false;
+        // StencilLazyHost
+        constructor(t) {
+          super(t);
+          t = this;
+          registerHost(t, f);
+          if (f._$$flags$$_ & 1 /* shadowDomEncapsulation */) {
+            {
+              if (!t.shadowRoot) {
+                createShadowRoot.call(t, f);
+              } else {
+                if (t.shadowRoot.mode !== "open") {
+                  throw new Error(`Unable to re-use existing shadow root for ${f._$$tagName$$_}! Mode is set to ${t.shadowRoot.mode} but Stencil only supports open shadow roots.`);
+                }
+              }
+            }
+          }
+        }
+        connectedCallback() {
+          const t = getHostRef(this);
+          if (!t) {
+            return;
+          }
+          if (!this.hasRegisteredEventListeners) {
+            this.hasRegisteredEventListeners = true;
+            addHostEventListeners(this, t, f._$$listeners$$_);
+          }
+          if (u) {
+            clearTimeout(u);
+            u = null;
+          }
+          if (d) {
+            c.push(this);
+          } else {
+            j.jmp((() => connectedCallback(this)));
+          }
+        }
+        disconnectedCallback() {
+          j.jmp((() => disconnectedCallback(this)));
+          j.raf((() => {
+            var t;
+            const e = getHostRef(this);
+            if (!e) {
+              return;
+            }
+            const n = c.findIndex((t => t === this));
+            if (n > -1) {
+              c.splice(n, 1);
+            }
+            if (((t = e == null ? void 0 : e._$$vnode$$_) == null ? void 0 : t._$$elm$$_) instanceof Node && !e._$$vnode$$_._$$elm$$_.isConnected) {
+              delete e._$$vnode$$_._$$elm$$_;
+            }
+          }));
+        }
+        componentOnReady() {
+          var t;
+          return (t = getHostRef(this)) == null ? void 0 : t._$$onReadyPromise$$_;
+        }
+      };
+      if (!(f._$$flags$$_ & 1 /* shadowDomEncapsulation */) && f._$$flags$$_ & 256 /* hasSlot */) {
+        {
+          patchPseudoShadowDom(v.prototype);
+        }
+      } else {
+        patchCloneNode(v.prototype);
+      }
+      if (f._$$flags$$_ & 64 /* formAssociated */) {
+        v.formAssociated = true;
+      }
+      f._$$lazyBundleId$$_ = t[0];
+      if (!s.includes(a) && !l.get(a)) {
+        i.push(a);
+        l.define(a, proxyComponent(v, f, 1 /* isElementConstructor */));
+      }
+    }));
+  }));
+  if (i.length > 0) {
+    {
+      a.textContent += i.sort() + $;
+    }
+    if (a.innerHTML.length) {
+      a.setAttribute("data-styles", "");
+      const t = (n = j._$$nonce$$_) != null ? n : queryNonceMetaTagContent(C.document);
+      if (t != null) {
+        a.setAttribute("nonce", t);
+      }
+      o.insertBefore(a, f ? f.nextSibling : o.firstChild);
+    }
+  }
+  d = false;
+  if (c.length) {
+    c.map((t => t.connectedCallback()));
+  } else {
+    {
+      j.jmp((() => u = setTimeout(appDidLoad, 30)));
+    }
+  }
+  r();
+};
+
+var addHostEventListeners = (t, e, n, r) => {
+  if (n && C.document) {
+    n.map((([n, r, i]) => {
+      const s = getHostListenerTarget(C.document, t, n);
+      const l = hostListenerProxy(e, i);
+      const o = hostListenerOpts(n);
+      j.ael(s, r, l, o);
+      (e._$$rmListeners$$_ = e._$$rmListeners$$_ || []).push((() => j.rel(s, r, l, o)));
+    }));
+  }
+};
+
+var hostListenerProxy = (t, e) => n => {
+  var r;
+  try {
+    {
+      if (t._$$flags$$_ & 256 /* isListenReady */) {
+        (r = t._$$lazyInstance$$_) == null ? void 0 : r[e](n);
+      } else {
+        (t._$$queuedListeners$$_ = t._$$queuedListeners$$_ || []).push([ e, n ]);
+      }
+    }
+  } catch (e) {
+    consoleError(e, t.$hostElement$);
+  }
+};
+
+var getHostListenerTarget = (t, e, n) => {
+  if (n & 4 /* TargetDocument */) {
+    return t;
+  }
+  if (n & 8 /* TargetWindow */) {
+    return C;
+  }
+  if (n & 16 /* TargetBody */) {
+    return t.body;
+  }
+  return e;
+};
+
+var hostListenerOpts = t => E ? {
+  passive: (t & 1 /* Passive */) !== 0,
+  capture: (t & 2 /* Capture */) !== 0
+} : (t & 2 /* Capture */) !== 0
+// src/runtime/nonce.ts
+;
+
+var setNonce = t => j._$$nonce$$_ = t;
+
+function transformTag(t) {
+  return t;
+}
+
+export { N as H, U as a, bootstrapLazy as b, createEvent as c, getElement as g, promiseResolve as p, registerInstance as r, setNonce as s };
+//# sourceMappingURL=p-D0hQxkOP.js.map
+//# sourceMappingURL=p-D0hQxkOP.js.map