@govbr-ds/webcomponents 2.0.0-next.3 → 2.0.0-next.32

package/dist/components/p-D02C28Eq.js

@@ -0,0 +1,2042 @@
+/*!
+ * Construído com @govbr-ds/webcomponents
+ */
+const e = "webcomponents";
+
+const t = /* webcomponents */ {
+  hydratedSelectorName: "hydrated",
+  lazyLoad: false,
+  updatable: true
+};
+
+/*
+ Stencil Client Platform v4.28.2 | MIT Licensed | https://stenciljs.com
+ */ var n = Object.defineProperty;
+
+var __export = (e, t) => {
+  for (var l in t) n(e, l, {
+    get: t[l],
+    enumerable: true
+  });
+};
+
+// src/utils/es2022-rewire-class-members.ts
+var reWireGetterSetter = (e, t) => {
+  var n;
+  const l = t.t;
+  const i = Object.entries((n = l.l) != null ? n : {});
+  i.map((([n, [l]]) => {
+    if (l & 31 /* Prop */ || l & 32 /* State */) {
+      const l = e[n];
+      const i = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(e), n);
+      Object.defineProperty(e, n, {
+        get() {
+          return i.get.call(this);
+        },
+        set(e) {
+          i.set.call(this, e);
+        },
+        configurable: true,
+        enumerable: true
+      });
+      e[n] = t.i.has(n) ? t.i.get(n) : l;
+    }
+  }));
+};
+
+// src/client/client-host-ref.ts
+var getHostRef = e => {
+  if (e.__stencil__getHostRef) {
+    return e.__stencil__getHostRef();
+  }
+  return void 0;
+};
+
+var registerHost = (e, t) => {
+  const n = {
+    o: 0,
+    $hostElement$: e,
+    t,
+    i:  new Map
+  };
+  {
+    n.u = new Promise((e => n.v = e));
+    e["s-p"] = [];
+    e["s-rc"] = [];
+  }
+  const l = n;
+  e.__stencil__getHostRef = () => l;
+  {
+    reWireGetterSetter(e, n);
+  }
+  return l;
+};
+
+var isMemberInElement = (e, t) => t in e;
+
+var consoleError = (e, t) => (0, console.error)(e, t)
+// src/client/client-style.ts
+;
+
+var l =  new Map;
+
+// src/runtime/runtime-constants.ts
+var i = "r";
+
+var r = "o";
+
+var o = "s";
+
+var s = "t";
+
+var f = "c";
+
+var a = "s-id";
+
+var c = "sty-id";
+
+var u = "c-id";
+
+var v = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+
+var d = "http://www.w3.org/1999/xlink";
+
+var p = [ "formAssociatedCallback", "formResetCallback", "formDisabledCallback", "formStateRestoreCallback" ];
+
+var $ = typeof window !== "undefined" ? window : {};
+
+var m = $.HTMLElement || class {};
+
+var b = {
+  o: 0,
+  h: "",
+  jmp: e => e(),
+  raf: e => requestAnimationFrame(e),
+  ael: (e, t, n, l) => e.addEventListener(t, n, l),
+  rel: (e, t, n, l) => e.removeEventListener(t, n, l),
+  ce: (e, t) => new CustomEvent(e, t)
+};
+
+var g =  (() => {
+  var e;
+  let t = false;
+  try {
+    (e = $.document) == null ? void 0 : e.addEventListener("e", null, Object.defineProperty({}, "passive", {
+      get() {
+        t = true;
+      }
+    }));
+  } catch (e) {}
+  return t;
+})();
+
+var promiseResolve = e => Promise.resolve(e);
+
+var y =  (() => {
+  try {
+    new CSSStyleSheet;
+    return typeof (new CSSStyleSheet).replaceSync === "function";
+  } catch (e) {}
+  return false;
+})();
+
+var S = false;
+
+var w = [];
+
+var O = [];
+
+var queueTask = (e, t) => n => {
+  e.push(n);
+  if (!S) {
+    S = true;
+    if (t && b.o & 4 /* queueSync */) {
+      nextTick(flush);
+    } else {
+      b.raf(flush);
+    }
+  }
+};
+
+var consume = e => {
+  for (let t = 0; t < e.length; t++) {
+    try {
+      e[t](performance.now());
+    } catch (e) {
+      consoleError(e);
+    }
+  }
+  e.length = 0;
+};
+
+var flush = () => {
+  consume(w);
+  {
+    consume(O);
+    if (S = w.length > 0) {
+      b.raf(flush);
+    }
+  }
+};
+
+var nextTick = e => promiseResolve().then(e);
+
+var j =  queueTask(O, true);
+
+// src/runtime/asset-path.ts
+var getAssetPath = e => {
+  const t = new URL(e, b.h);
+  return t.origin !== $.location.origin ? t.href : t.pathname;
+};
+
+var setAssetPath = e => b.h = e;
+
+var isComplexType = e => {
+  e = typeof e;
+  return e === "object" || e === "function";
+};
+
+// src/utils/query-nonce-meta-tag-content.ts
+function queryNonceMetaTagContent(e) {
+  var t, n, l;
+  return (l = (n = (t = e.head) == null ? void 0 : t.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : n.getAttribute("content")) != null ? l : void 0;
+}
+
+// src/utils/result.ts
+var N = {};
+
+__export(N, {
+  err: () => err,
+  map: () => map,
+  ok: () => ok,
+  unwrap: () => unwrap,
+  unwrapErr: () => unwrapErr
+});
+
+var ok = e => ({
+  isOk: true,
+  isErr: false,
+  value: e
+});
+
+var err = e => ({
+  isOk: false,
+  isErr: true,
+  value: e
+});
+
+function map(e, t) {
+  if (e.isOk) {
+    const n = t(e.value);
+    if (n instanceof Promise) {
+      return n.then((e => ok(e)));
+    } else {
+      return ok(n);
+    }
+  }
+  if (e.isErr) {
+    const t = e.value;
+    return err(t);
+  }
+  throw "should never get here";
+}
+
+var unwrap = e => {
+  if (e.isOk) {
+    return e.value;
+  } else {
+    throw e.value;
+  }
+};
+
+var unwrapErr = e => {
+  if (e.isErr) {
+    return e.value;
+  } else {
+    throw e.value;
+  }
+};
+
+var getSlottedChildNodes = e => {
+  const t = [];
+  for (let n = 0; n < e.length; n++) {
+    const l = e[n]["s-nr"] || void 0;
+    if (l && l.isConnected) {
+      t.push(l);
+    }
+  }
+  return t;
+};
+
+function getHostSlotNodes(e, t, n) {
+  let l = 0;
+  let i = [];
+  let r;
+  for (;l < e.length; l++) {
+    r = e[l];
+    if (r["s-sr"] && (!t || r["s-hn"] === t) && (n === void 0 || getSlotName(r) === n)) {
+      i.push(r);
+      if (typeof n !== "undefined") return i;
+    }
+    i = [ ...i, ...getHostSlotNodes(r.childNodes, t, n) ];
+  }
+  return i;
+}
+
+var addSlotRelocateNode = (e, t, n, l) => {
+  if (e["s-ol"] && e["s-ol"].isConnected) {
+    return;
+  }
+  const i = document.createTextNode("");
+  i["s-nr"] = e;
+  if (!t["s-cr"] || !t["s-cr"].parentNode) return;
+  const r = t["s-cr"].parentNode;
+  const o = internalCall(r, "appendChild");
+  if (typeof l !== "undefined") {
+    i["s-oo"] = l;
+    const e = internalCall(r, "childNodes");
+    const t = [ i ];
+    e.forEach((e => {
+      if (e["s-nr"]) t.push(e);
+    }));
+    t.sort(((e, t) => {
+      if (!e["s-oo"] || e["s-oo"] < (t["s-oo"] || 0)) return -1; else if (!t["s-oo"] || t["s-oo"] < e["s-oo"]) return 1;
+      return 0;
+    }));
+    t.forEach((e => o.call(r, e)));
+  } else {
+    o.call(r, i);
+  }
+  e["s-ol"] = i;
+  e["s-sh"] = t["s-hn"];
+};
+
+var getSlotName = e => typeof e["s-sn"] === "string" ? e["s-sn"] : e.nodeType === 1 && e.getAttribute("slot") || void 0;
+
+function patchSlotNode(e) {
+  if (e.assignedElements || e.assignedNodes || !e["s-sr"]) return;
+  const assignedFactory = t => function(e) {
+    const n = [];
+    const l = this["s-sn"];
+    if (e == null ? void 0 : e.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 r = i.__childNodes ? i.childNodes : getSlottedChildNodes(i.childNodes);
+    r.forEach((e => {
+      if (l === getSlotName(e)) {
+        n.push(e);
+      }
+    }));
+    if (t) {
+      return n.filter((e => e.nodeType === 1 /* ElementNode */));
+    }
+    return n;
+  }.bind(e);
+  e.assignedElements = assignedFactory(true);
+  e.assignedNodes = assignedFactory(false);
+}
+
+function dispatchSlotChangeEvent(e) {
+  e.dispatchEvent(new CustomEvent("slotchange", {
+    bubbles: false,
+    cancelable: false,
+    composed: false
+  }));
+}
+
+function findSlotFromSlottedNode(e, t) {
+  var n;
+  t = t || ((n = e["s-ol"]) == null ? void 0 : n.parentElement);
+  if (!t) return {
+    slotNode: null,
+    slotName: ""
+  };
+  const l = e["s-sn"] = getSlotName(e) || "";
+  const i = internalCall(t, "childNodes");
+  const r = getHostSlotNodes(i, t.tagName, l)[0];
+  return {
+    slotNode: r,
+    slotName: l
+  };
+}
+
+var patchSlottedNode = e => {
+  if (!e || e.__nextSibling !== void 0 || !globalThis.Node) return;
+  patchNextSibling(e);
+  patchPreviousSibling(e);
+  patchParentNode(e);
+  if (e.nodeType === Node.ELEMENT_NODE) {
+    patchNextElementSibling(e);
+    patchPreviousElementSibling(e);
+  }
+};
+
+var patchNextSibling = e => {
+  if (!e || e.__nextSibling) return;
+  patchHostOriginalAccessor("nextSibling", e);
+  Object.defineProperty(e, "nextSibling", {
+    get: function() {
+      var e;
+      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.childNodes;
+      const n = t == null ? void 0 : t.indexOf(this);
+      if (t && n > -1) {
+        return t[n + 1];
+      }
+      return this.__nextSibling;
+    }
+  });
+};
+
+var patchNextElementSibling = e => {
+  if (!e || e.__nextElementSibling) return;
+  patchHostOriginalAccessor("nextElementSibling", e);
+  Object.defineProperty(e, "nextElementSibling", {
+    get: function() {
+      var e;
+      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.children;
+      const n = t == null ? void 0 : t.indexOf(this);
+      if (t && n > -1) {
+        return t[n + 1];
+      }
+      return this.__nextElementSibling;
+    }
+  });
+};
+
+var patchPreviousSibling = e => {
+  if (!e || e.__previousSibling) return;
+  patchHostOriginalAccessor("previousSibling", e);
+  Object.defineProperty(e, "previousSibling", {
+    get: function() {
+      var e;
+      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.childNodes;
+      const n = t == null ? void 0 : t.indexOf(this);
+      if (t && n > -1) {
+        return t[n - 1];
+      }
+      return this.__previousSibling;
+    }
+  });
+};
+
+var patchPreviousElementSibling = e => {
+  if (!e || e.__previousElementSibling) return;
+  patchHostOriginalAccessor("previousElementSibling", e);
+  Object.defineProperty(e, "previousElementSibling", {
+    get: function() {
+      var e;
+      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.children;
+      const n = t == null ? void 0 : t.indexOf(this);
+      if (t && n > -1) {
+        return t[n - 1];
+      }
+      return this.__previousElementSibling;
+    }
+  });
+};
+
+var patchParentNode = e => {
+  if (!e || e.__parentNode) return;
+  patchHostOriginalAccessor("parentNode", e);
+  Object.defineProperty(e, "parentNode", {
+    get: function() {
+      var e;
+      return ((e = this["s-ol"]) == null ? void 0 : e.parentNode) || this.__parentNode;
+    },
+    set: function(e) {
+      this.__parentNode = e;
+    }
+  });
+};
+
+var C = [ "children", "nextElementSibling", "previousElementSibling" ];
+
+var k = [ "childNodes", "firstChild", "lastChild", "nextSibling", "previousSibling", "textContent", "parentNode" ];
+
+function patchHostOriginalAccessor(e, t) {
+  let n;
+  if (C.includes(e)) {
+    n = Object.getOwnPropertyDescriptor(Element.prototype, e);
+  } else if (k.includes(e)) {
+    n = Object.getOwnPropertyDescriptor(Node.prototype, e);
+  }
+  if (!n) {
+    n = Object.getOwnPropertyDescriptor(t, e);
+  }
+  if (n) Object.defineProperty(t, "__" + e, n);
+}
+
+function internalCall(e, t) {
+  if ("__" + t in e) {
+    const n = e["__" + t];
+    if (typeof n !== "function") return n;
+    return n.bind(e);
+  } else {
+    if (typeof e[t] !== "function") return e[t];
+    return e[t].bind(e);
+  }
+}
+
+var createTime = (e, t = "") => {
+  {
+    return () => {};
+  }
+};
+
+var h = (e, t, ...n) => {
+  let l = null;
+  let i = null;
+  let r = false;
+  let o = false;
+  const s = [];
+  const walk = t => {
+    for (let n = 0; n < t.length; n++) {
+      l = t[n];
+      if (Array.isArray(l)) {
+        walk(l);
+      } else if (l != null && typeof l !== "boolean") {
+        if (r = typeof e !== "function" && !isComplexType(l)) {
+          l = String(l);
+        }
+        if (r && o) {
+          s[s.length - 1].p += l;
+        } else {
+          s.push(r ? newVNode(null, l) : l);
+        }
+        o = r;
+      }
+    }
+  };
+  walk(n);
+  if (t) {
+    if (t.key) {
+      i = t.key;
+    }
+    {
+      const e = t.className || t.class;
+      if (e) {
+        t.class = typeof e !== "object" ? e : Object.keys(e).filter((t => e[t])).join(" ");
+      }
+    }
+  }
+  if (typeof e === "function") {
+    return e(t === null ? {} : t, s, x);
+  }
+  const f = newVNode(e, null);
+  f.$ = t;
+  if (s.length > 0) {
+    f.m = s;
+  }
+  {
+    f.S = i;
+  }
+  return f;
+};
+
+var newVNode = (e, t) => {
+  const n = {
+    o: 0,
+    O: e,
+    p: t,
+    j: null,
+    m: null
+  };
+  {
+    n.$ = null;
+  }
+  {
+    n.S = null;
+  }
+  return n;
+};
+
+var E = {};
+
+var isHost = e => e && e.O === E;
+
+var x = {
+  forEach: (e, t) => e.map(convertToPublic).forEach(t),
+  map: (e, t) => e.map(convertToPublic).map(t).map(convertToPrivate)
+};
+
+var convertToPublic = e => ({
+  vattrs: e.$,
+  vchildren: e.m,
+  vkey: e.S,
+  vname: e.N,
+  vtag: e.O,
+  vtext: e.p
+});
+
+var convertToPrivate = e => {
+  if (typeof e.vtag === "function") {
+    const t = {
+      ...e.vattrs
+    };
+    if (e.vkey) {
+      t.key = e.vkey;
+    }
+    if (e.vname) {
+      t.name = e.vname;
+    }
+    return h(e.vtag, t, ...e.vchildren || []);
+  }
+  const t = newVNode(e.vtag, e.vtext);
+  t.$ = e.vattrs;
+  t.m = e.vchildren;
+  t.S = e.vkey;
+  t.N = e.vname;
+  return t;
+};
+
+// src/runtime/client-hydrate.ts
+var initializeClientHydrate = (e, t, n, l) => {
+  const i = createTime("hydrateClient", t);
+  const r = e.shadowRoot;
+  const o = [];
+  const s = [];
+  const f = [];
+  const c = r ? [] : null;
+  const u = newVNode(t, null);
+  u.j = e;
+  if ($.document && (!b.C || !b.C.size)) {
+    initializeDocumentHydrate($.document.body, b.C =  new Map);
+  }
+  e[a] = n;
+  e.removeAttribute(a);
+  l.k = clientHydrate(u, o, s, c, e, e, n, f);
+  let v = 0;
+  const d = o.length;
+  let p;
+  for (v; v < d; v++) {
+    p = o[v];
+    const n = p.A + "." + p._;
+    const l = b.C.get(n);
+    const i = p.j;
+    if (!r) {
+      i["s-hn"] = t.toUpperCase();
+      if (p.O === "slot") {
+        i["s-cr"] = e["s-cr"];
+      }
+    }
+    if (p.O === "slot") {
+      p.N = p.j["s-sn"] || p.j["name"] || null;
+      if (p.m) {
+        p.o |= 2 /* isSlotFallback */;
+        if (!p.j.childNodes.length) {
+          p.m.forEach((e => {
+            p.j.appendChild(e.j);
+          }));
+        }
+      } else {
+        p.o |= 1 /* isSlotReference */;
+      }
+    }
+    if (l && l.isConnected) {
+      if (r && l["s-en"] === "") {
+        l.parentNode.insertBefore(i, l.nextSibling);
+      }
+      l.parentNode.removeChild(l);
+      if (!r) {
+        i["s-oo"] = parseInt(p._);
+      }
+    }
+    b.C.delete(n);
+  }
+  const m = [];
+  const g = f.length;
+  let y = 0;
+  let S;
+  let w;
+  let O;
+  let j;
+  for (y; y < g; y++) {
+    S = f[y];
+    if (!S || !S.length) continue;
+    O = S.length;
+    w = 0;
+    for (w; w < O; w++) {
+      j = S[w];
+      if (!m[j.hostId]) {
+        m[j.hostId] = b.C.get(j.hostId);
+      }
+      if (!m[j.hostId]) continue;
+      const e = m[j.hostId];
+      if (!e.shadowRoot || !r) {
+        j.slot["s-cr"] = e["s-cr"];
+        if (!j.slot["s-cr"] && e.shadowRoot) {
+          j.slot["s-cr"] = e;
+        } else {
+          j.slot["s-cr"] = (e.__childNodes || e.childNodes)[0];
+        }
+        addSlotRelocateNode(j.node, j.slot, false, j.node["s-oo"]);
+        {
+          patchSlottedNode(j.node);
+        }
+      }
+      if (e.shadowRoot && j.node.parentElement !== e) {
+        e.appendChild(j.node);
+      }
+    }
+  }
+  if (r && !r.childNodes.length) {
+    let t = 0;
+    const n = c.length;
+    if (n) {
+      for (t; t < n; t++) {
+        r.appendChild(c[t]);
+      }
+      Array.from(e.childNodes).forEach((e => {
+        if (typeof e["s-sn"] !== "string") {
+          if (e.nodeType === 1 /* ElementNode */ && e.slot && e.hidden) {
+            e.removeAttribute("hidden");
+          } else if (e.nodeType === 8 /* CommentNode */ || e.nodeType === 3 /* TextNode */ && !e.wholeText.trim()) {
+            e.parentNode.removeChild(e);
+          }
+        }
+      }));
+    }
+  }
+  b.C.delete(e["s-id"]);
+  l.$hostElement$ = e;
+  i();
+};
+
+var clientHydrate = (e, t, n, l, r, a, c, v = []) => {
+  let d;
+  let p;
+  let $;
+  let m;
+  if (a.nodeType === 1 /* ElementNode */) {
+    d = a.getAttribute(u);
+    if (d) {
+      p = d.split(".");
+      if (p[0] === c || p[0] === "0") {
+        $ = createSimpleVNode({
+          o: 0,
+          A: p[0],
+          _: p[1],
+          H: p[2],
+          M: p[3],
+          O: a.tagName.toLowerCase(),
+          j: a,
+          // 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.
+          $: {
+            class: a.className || ""
+          }
+        });
+        t.push($);
+        a.removeAttribute(u);
+        if (!e.m) {
+          e.m = [];
+        }
+        const i = $.j.getAttribute("s-sn");
+        if (typeof i === "string") {
+          if ($.O === "slot-fb") {
+            addSlot(i, p[2], $, a, e, t, n, l, v);
+          }
+          $.j["s-sn"] = i;
+          $.j.removeAttribute("s-sn");
+        }
+        if ($.M !== void 0) {
+          e.m[$.M] = $;
+        }
+        e = $;
+        if (l && $.H === "0") {
+          l[$.M] = $.j;
+        }
+      }
+    }
+    if (a.shadowRoot) {
+      for (m = a.shadowRoot.childNodes.length - 1; m >= 0; m--) {
+        clientHydrate(e, t, n, l, r, a.shadowRoot.childNodes[m], c, v);
+      }
+    }
+    const i = a.__childNodes || a.childNodes;
+    for (m = i.length - 1; m >= 0; m--) {
+      clientHydrate(e, t, n, l, r, i[m], c, v);
+    }
+  } else if (a.nodeType === 8 /* CommentNode */) {
+    p = a.nodeValue.split(".");
+    if (p[1] === c || p[1] === "0") {
+      d = p[0];
+      $ = createSimpleVNode({
+        A: p[1],
+        _: p[2],
+        H: p[3],
+        M: p[4] || "0",
+        j: a,
+        $: null,
+        m: null,
+        S: null,
+        N: null,
+        O: null,
+        p: null
+      });
+      if (d === s) {
+        $.j = findCorrespondingNode(a, 3 /* TextNode */);
+        if ($.j && $.j.nodeType === 3 /* TextNode */) {
+          $.p = $.j.textContent;
+          t.push($);
+          a.remove();
+          if (c === $.A) {
+            if (!e.m) {
+              e.m = [];
+            }
+            e.m[$.M] = $;
+          }
+          if (l && $.H === "0") {
+            l[$.M] = $.j;
+          }
+        }
+      } else if (d === f) {
+        $.j = findCorrespondingNode(a, 8 /* CommentNode */);
+        if ($.j && $.j.nodeType === 8 /* CommentNode */) {
+          t.push($);
+          a.remove();
+        }
+      } else if ($.A === c) {
+        if (d === o) {
+          const i = a["s-sn"] = p[5] || "";
+          addSlot(i, p[2], $, a, e, t, n, l, v);
+        } else if (d === i) {
+          if (l) {
+            a.remove();
+          }
+        }
+      }
+    }
+  } else if (e && e.O === "style") {
+    const t = newVNode(null, a.textContent);
+    t.j = a;
+    t.M = "0";
+    e.m = [ t ];
+  } else {
+    if (a.nodeType === 3 /* TextNode */ && !a.wholeText.trim()) {
+      a.remove();
+    }
+  }
+  return e;
+};
+
+var initializeDocumentHydrate = (e, t) => {
+  if (e.nodeType === 1 /* ElementNode */) {
+    const n = e[a] || e.getAttribute(a);
+    if (n) {
+      t.set(n, e);
+    }
+    let l = 0;
+    if (e.shadowRoot) {
+      for (;l < e.shadowRoot.childNodes.length; l++) {
+        initializeDocumentHydrate(e.shadowRoot.childNodes[l], t);
+      }
+    }
+    const i = e.__childNodes || e.childNodes;
+    for (l = 0; l < i.length; l++) {
+      initializeDocumentHydrate(i[l], t);
+    }
+  } else if (e.nodeType === 8 /* CommentNode */) {
+    const n = e.nodeValue.split(".");
+    if (n[0] === r) {
+      t.set(n[1] + "." + n[2], e);
+      e.nodeValue = "";
+      e["s-en"] = n[3];
+    }
+  }
+};
+
+var createSimpleVNode = e => {
+  const t = {
+    o: 0,
+    A: null,
+    _: null,
+    H: null,
+    M: "0",
+    j: null,
+    $: null,
+    m: null,
+    S: null,
+    N: null,
+    O: null,
+    p: null
+  };
+  return {
+    ...t,
+    ...e
+  };
+};
+
+function addSlot(e, t, n, l, i, r, o, s, f) {
+  l["s-sr"] = true;
+  n.N = e || null;
+  n.O = "slot";
+  const a = (i == null ? void 0 : i.j) ? i.j["s-id"] || i.j.getAttribute("s-id") : "";
+  if (s && $.document) {
+    const r = n.j = $.document.createElement(n.O);
+    if (n.N) {
+      n.j.setAttribute("name", e);
+    }
+    if (a && a !== n.A) {
+      i.j.insertBefore(r, i.j.children[0]);
+    } else {
+      l.parentNode.insertBefore(n.j, l);
+    }
+    addSlottedNodes(f, t, e, l, n.A);
+    l.remove();
+    if (n.H === "0") {
+      s[n.M] = n.j;
+    }
+  } else {
+    const o = n.j;
+    const s = a && a !== n.A && i.j.shadowRoot;
+    addSlottedNodes(f, t, e, l, s ? a : n.A);
+    patchSlotNode(l);
+    if (s) {
+      i.j.insertBefore(o, i.j.children[0]);
+    }
+    r.push(n);
+  }
+  o.push(n);
+  if (!i.m) {
+    i.m = [];
+  }
+  i.m[n.M] = n;
+}
+
+var addSlottedNodes = (e, t, n, l, i) => {
+  let r = l.nextSibling;
+  e[t] = e[t] || [];
+  while (r && ((r["getAttribute"] && r.getAttribute("slot") || r["s-sn"]) === n || n === "" && !r["s-sn"] && (r.nodeType === 8 /* CommentNode */ && r.nodeValue.indexOf(".") !== 1 || r.nodeType === 3 /* TextNode */))) {
+    r["s-sn"] = n;
+    e[t].push({
+      slot: l,
+      node: r,
+      hostId: i
+    });
+    r = r.nextSibling;
+  }
+};
+
+var findCorrespondingNode = (e, t) => {
+  let n = e;
+  do {
+    n = n.nextSibling;
+  } while (n && (n.nodeType !== t || !n.nodeValue));
+  return n;
+};
+
+var parsePropertyValue = (e, t) => {
+  if (e != null && !isComplexType(e)) {
+    if (t & 4 /* Boolean */) {
+      return e === "false" ? false : e === "" || !!e;
+    }
+    if (t & 2 /* Number */) {
+      return parseFloat(e);
+    }
+    if (t & 1 /* String */) {
+      return String(e);
+    }
+    return e;
+  }
+  return e;
+};
+
+var getElement = e => e
+// src/runtime/event-emitter.ts
+;
+
+var createEvent = (e, t, n) => {
+  const l = getElement(e);
+  return {
+    emit: e => emitEvent(l, t, {
+      bubbles: true,
+      composed: true,
+      cancelable: true,
+      detail: e
+    })
+  };
+};
+
+var emitEvent = (e, t, n) => {
+  const l = b.ce(t, n);
+  e.dispatchEvent(l);
+  return l;
+};
+
+var A =  new WeakMap;
+
+var registerStyle = (e, t, n) => {
+  let i = l.get(e);
+  if (y && n) {
+    i = i || new CSSStyleSheet;
+    if (typeof i === "string") {
+      i = t;
+    } else {
+      i.replaceSync(t);
+    }
+  } else {
+    i = t;
+  }
+  l.set(e, i);
+};
+
+var addStyle = (e, t, n) => {
+  var i;
+  const r = getScopeId(t);
+  const o = l.get(r);
+  if (!$.document) {
+    return r;
+  }
+  e = e.nodeType === 11 /* DocumentFragment */ ? e : $.document;
+  if (o) {
+    if (typeof o === "string") {
+      e = e.head || e;
+      let n = A.get(e);
+      let l;
+      if (!n) {
+        A.set(e, n =  new Set);
+      }
+      if (!n.has(r)) {
+        if (e.host && (l = e.querySelector(`[${c}="${r}"]`))) {
+          l.innerHTML = o;
+        } else {
+          l = document.querySelector(`[${c}="${r}"]`) || $.document.createElement("style");
+          l.innerHTML = o;
+          const n = (i = b.I) != null ? i : queryNonceMetaTagContent($.document);
+          if (n != null) {
+            l.setAttribute("nonce", n);
+          }
+          if (!(t.o & 1 /* shadowDomEncapsulation */)) {
+            if (e.nodeName === "HEAD") {
+              const t = e.querySelectorAll("link[rel=preconnect]");
+              const n = t.length > 0 ? t[t.length - 1].nextSibling : e.querySelector("style");
+              e.insertBefore(l, (n == null ? void 0 : n.parentNode) === e ? n : null);
+            } else if ("host" in e) {
+              if (y) {
+                const t = new CSSStyleSheet;
+                t.replaceSync(o);
+                e.adoptedStyleSheets = [ t, ...e.adoptedStyleSheets ];
+              } else {
+                const t = e.querySelector("style");
+                if (t) {
+                  t.innerHTML = o + t.innerHTML;
+                } else {
+                  e.prepend(l);
+                }
+              }
+            } else {
+              e.append(l);
+            }
+          }
+          if (t.o & 1 /* shadowDomEncapsulation */) {
+            e.insertBefore(l, null);
+          }
+        }
+        if (t.o & 4 /* hasSlotRelocation */) {
+          l.innerHTML += v;
+        }
+        if (n) {
+          n.add(r);
+        }
+      }
+    } else if (!e.adoptedStyleSheets.includes(o)) {
+      e.adoptedStyleSheets = [ ...e.adoptedStyleSheets, o ];
+    }
+  }
+  return r;
+};
+
+var attachStyles = e => {
+  const t = e.t;
+  const n = e.$hostElement$;
+  const l = t.o;
+  const i = createTime("attachStyles", t.U);
+  const r = addStyle(n.shadowRoot ? n.shadowRoot : n.getRootNode(), t);
+  if (l & 10 /* needsScopedEncapsulation */ && l & 2 /* scopedCssEncapsulation */ || l & 128 /* shadowNeedsScopedCss */) {
+    n["s-sc"] = r;
+    n.classList.add(r + "-h");
+  }
+  i();
+};
+
+var getScopeId = (e, t) => "sc-" + e.U;
+
+var convertScopedToShadow = e => e.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, "$1{");
+
+var hydrateScopedToShadow = () => {
+  if (!$.document) {
+    return;
+  }
+  const e = $.document.querySelectorAll(`[${c}]`);
+  let t = 0;
+  for (;t < e.length; t++) {
+    registerStyle(e[t].getAttribute(c), convertScopedToShadow(e[t].innerHTML), true);
+  }
+};
+
+var setAccessor = (e, t, n, l, i, r, o) => {
+  if (n === l) {
+    return;
+  }
+  let s = isMemberInElement(e, t);
+  let f = t.toLowerCase();
+  if (t === "class") {
+    const t = e.classList;
+    const i = parseClassList(n);
+    let r = parseClassList(l);
+    if (e["s-si"] && o) {
+      r.push(e["s-si"]);
+      i.forEach((t => {
+        if (t.startsWith(e["s-si"])) r.push(t);
+      }));
+      r = [ ...new Set(r) ];
+      t.add(...r);
+    } else {
+      t.remove(...i.filter((e => e && !r.includes(e))));
+      t.add(...r.filter((e => e && !i.includes(e))));
+    }
+  } else if (t === "style") {
+    {
+      for (const t in n) {
+        if (!l || l[t] == null) {
+          if (t.includes("-")) {
+            e.style.removeProperty(t);
+          } else {
+            e.style[t] = "";
+          }
+        }
+      }
+    }
+    for (const t in l) {
+      if (!n || l[t] !== n[t]) {
+        if (t.includes("-")) {
+          e.style.setProperty(t, l[t]);
+        } else {
+          e.style[t] = l[t];
+        }
+      }
+    }
+  } else if (t === "key") ; else if (t === "ref") {
+    if (l) {
+      l(e);
+    }
+  } else if (!e.__lookupSetter__(t) && t[0] === "o" && t[1] === "n") {
+    if (t[2] === "-") {
+      t = t.slice(3);
+    } else if (isMemberInElement($, f)) {
+      t = f.slice(2);
+    } else {
+      t = f[2] + t.slice(3);
+    }
+    if (n || l) {
+      const i = t.endsWith(H);
+      t = t.replace(M, "");
+      if (n) {
+        b.rel(e, t, n, i);
+      }
+      if (l) {
+        b.ael(e, t, l, i);
+      }
+    }
+  } else {
+    const o = isComplexType(l);
+    if ((s || o && l !== null) && true) {
+      try {
+        if (!e.tagName.includes("-")) {
+          const i = l == null ? "" : l;
+          if (t === "list") {
+            s = false;
+          } else if (n == null || e[t] != i) {
+            if (typeof e.__lookupSetter__(t) === "function") {
+              e[t] = i;
+            } else {
+              e.setAttribute(t, i);
+            }
+          }
+        } else if (e[t] !== l) {
+          e[t] = l;
+        }
+      } catch (e) {}
+    }
+    let a = false;
+    {
+      if (f !== (f = f.replace(/^xlink\:?/, ""))) {
+        t = f;
+        a = true;
+      }
+    }
+    if (l == null || l === false) {
+      if (l !== false || e.getAttribute(t) === "") {
+        if (a) {
+          e.removeAttributeNS(d, t);
+        } else {
+          e.removeAttribute(t);
+        }
+      }
+    } else if ((!s || r & 4 /* isHost */ || i) && !o && e.nodeType === 1 /* ElementNode */) {
+      l = l === true ? "" : l;
+      if (a) {
+        e.setAttributeNS(d, t, l);
+      } else {
+        e.setAttribute(t, l);
+      }
+    }
+  }
+};
+
+var _ = /\s/;
+
+var parseClassList = e => {
+  if (typeof e === "object" && e && "baseVal" in e) {
+    e = e.baseVal;
+  }
+  if (!e || typeof e !== "string") {
+    return [];
+  }
+  return e.split(_);
+};
+
+var H = "Capture";
+
+var M = new RegExp(H + "$");
+
+// src/runtime/vdom/update-element.ts
+var updateElement = (e, t, n, l) => {
+  const i = t.j.nodeType === 11 /* DocumentFragment */ && t.j.host ? t.j.host : t.j;
+  const r = e && e.$ || {};
+  const o = t.$ || {};
+  {
+    for (const e of sortedAttrNames(Object.keys(r))) {
+      if (!(e in o)) {
+        setAccessor(i, e, r[e], void 0, n, t.o, l);
+      }
+    }
+  }
+  for (const e of sortedAttrNames(Object.keys(o))) {
+    setAccessor(i, e, r[e], o[e], n, t.o, l);
+  }
+};
+
+function sortedAttrNames(e) {
+  return e.includes("ref") ? 
+  // we need to sort these to ensure that `'ref'` is the last attr
+  [ ...e.filter((e => e !== "ref")), "ref" ] : 
+  // no need to sort, return the original array
+  e;
+}
+
+var I;
+
+var U = false;
+
+var D = false;
+
+var createElm = (e, t, n) => {
+  const l = t.m[n];
+  let i = 0;
+  let r;
+  let o;
+  if (l.p !== null) {
+    r = l.j = $.document.createTextNode(l.p);
+  } else {
+    if (!$.document) {
+      throw new Error("You are trying to render a Stencil component in an environment that doesn't support the DOM. Make sure to populate the [`window`](https://developer.mozilla.org/en-US/docs/Web/API/Window/window) object before rendering a component.");
+    }
+    r = l.j = $.document.createElement(l.O);
+    {
+      updateElement(null, l, D);
+    }
+    if (l.m) {
+      for (i = 0; i < l.m.length; ++i) {
+        o = createElm(e, l, i);
+        if (o) {
+          r.appendChild(o);
+        }
+      }
+    }
+  }
+  r["s-hn"] = I;
+  return r;
+};
+
+var relocateToHostRoot = e => {
+  b.o |= 1 /* isTmpDisconnected */;
+  const t = e.closest(I.toLowerCase());
+  if (t != null) {
+    const n = Array.from(t.__childNodes || t.childNodes).find((e => e["s-cr"]));
+    const l = Array.from(e.__childNodes || e.childNodes);
+    for (const e of n ? l.reverse() : l) {
+      if (e["s-sh"] != null) {
+        insertBefore(t, e, n != null ? n : null);
+        e["s-sh"] = void 0;
+      }
+    }
+  }
+  b.o &= -2 /* isTmpDisconnected */;
+};
+
+var addVnodes = (e, t, n, l, i, r) => {
+  let o = e;
+  let s;
+  if (o.shadowRoot && o.tagName === I) {
+    o = o.shadowRoot;
+  }
+  for (;i <= r; ++i) {
+    if (l[i]) {
+      s = createElm(null, n, i);
+      if (s) {
+        l[i].j = s;
+        insertBefore(o, s, t);
+      }
+    }
+  }
+};
+
+var removeVnodes = (e, t, n) => {
+  for (let l = t; l <= n; ++l) {
+    const t = e[l];
+    if (t) {
+      const e = t.j;
+      nullifyVNodeRefs(t);
+      if (e) {
+        e.remove();
+      }
+    }
+  }
+};
+
+var updateChildren = (e, t, n, l, i = false) => {
+  let r = 0;
+  let o = 0;
+  let s = 0;
+  let f = 0;
+  let a = t.length - 1;
+  let c = t[0];
+  let u = t[a];
+  let v = l.length - 1;
+  let d = l[0];
+  let p = l[v];
+  let $;
+  let m;
+  while (r <= a && o <= v) {
+    if (c == null) {
+      c = t[++r];
+    } else if (u == null) {
+      u = t[--a];
+    } else if (d == null) {
+      d = l[++o];
+    } else if (p == null) {
+      p = l[--v];
+    } else if (isSameVnode(c, d, i)) {
+      patch(c, d, i);
+      c = t[++r];
+      d = l[++o];
+    } else if (isSameVnode(u, p, i)) {
+      patch(u, p, i);
+      u = t[--a];
+      p = l[--v];
+    } else if (isSameVnode(c, p, i)) {
+      patch(c, p, i);
+      insertBefore(e, c.j, u.j.nextSibling);
+      c = t[++r];
+      p = l[--v];
+    } else if (isSameVnode(u, d, i)) {
+      patch(u, d, i);
+      insertBefore(e, u.j, c.j);
+      u = t[--a];
+      d = l[++o];
+    } else {
+      s = -1;
+      {
+        for (f = r; f <= a; ++f) {
+          if (t[f] && t[f].S !== null && t[f].S === d.S) {
+            s = f;
+            break;
+          }
+        }
+      }
+      if (s >= 0) {
+        m = t[s];
+        if (m.O !== d.O) {
+          $ = createElm(t && t[o], n, s);
+        } else {
+          patch(m, d, i);
+          t[s] = void 0;
+          $ = m.j;
+        }
+        d = l[++o];
+      } else {
+        $ = createElm(t && t[o], n, o);
+        d = l[++o];
+      }
+      if ($) {
+        {
+          insertBefore(c.j.parentNode, $, c.j);
+        }
+      }
+    }
+  }
+  if (r > a) {
+    addVnodes(e, l[v + 1] == null ? null : l[v + 1].j, n, l, o, v);
+  } else if (o > v) {
+    removeVnodes(t, r, a);
+  }
+};
+
+var isSameVnode = (e, t, n = false) => {
+  if (e.O === t.O) {
+    if (!n) {
+      return e.S === t.S;
+    }
+    if (n && !e.S && t.S) {
+      e.S = t.S;
+    }
+    return true;
+  }
+  return false;
+};
+
+var patch = (e, n, l = false) => {
+  const i = n.j = e.j;
+  const r = e.m;
+  const o = n.m;
+  const s = n.O;
+  const f = n.p;
+  if (f === null) {
+    {
+      if (s === "slot" && !U) {
+        if (e.N !== n.N) {
+          n.j["s-sn"] = n.N || "";
+          relocateToHostRoot(n.j.parentElement);
+        }
+      }
+      updateElement(e, n, D, l);
+    }
+    if (r !== null && o !== null) {
+      updateChildren(i, r, n, o, l);
+    } else if (o !== null) {
+      if (e.p !== null) {
+        i.textContent = "";
+      }
+      addVnodes(i, null, n, o, 0, o.length - 1);
+    } else if (
+    // don't do this on initial render as it can cause non-hydrated content to be removed
+    !l && t.updatable && r !== null) {
+      removeVnodes(r, 0, r.length - 1);
+    }
+  } else if (e.p !== f) {
+    i.data = f;
+  }
+};
+
+var nullifyVNodeRefs = e => {
+  {
+    e.$ && e.$.ref && e.$.ref(null);
+    e.m && e.m.map(nullifyVNodeRefs);
+  }
+};
+
+var insertBefore = (e, t, n) => {
+  if (typeof t["s-sn"] === "string") {
+    if (e.getRootNode().nodeType !== 11 /* DOCUMENT_FRAGMENT_NODE */) {
+      patchParentNode(t);
+    }
+    e.insertBefore(t, n);
+    const {slotNode: l} = findSlotFromSlottedNode(t);
+    if (l) dispatchSlotChangeEvent(l);
+    return t;
+  }
+  if (e.__insertBefore) {
+    return e.__insertBefore(t, n);
+  } else {
+    return e == null ? void 0 : e.insertBefore(t, n);
+  }
+};
+
+var renderVdom = (e, t, n = false) => {
+  var l;
+  const i = e.$hostElement$;
+  const r = e.t;
+  const o = e.k || newVNode(null, null);
+  const s = isHost(t) ? t : h(null, null, t);
+  I = i.tagName;
+  if (r.D) {
+    s.$ = s.$ || {};
+    r.D.map((([e, t]) => s.$[t] = i[e]));
+  }
+  if (n && s.$) {
+    for (const e of Object.keys(s.$)) {
+      if (i.hasAttribute(e) && ![ "key", "ref", "style", "class" ].includes(e)) {
+        s.$[e] = i[e];
+      }
+    }
+  }
+  s.O = null;
+  s.o |= 4 /* isHost */;
+  e.k = s;
+  s.j = o.j = i.shadowRoot || i;
+  U = !!(r.o & 1 /* shadowDomEncapsulation */) && !(r.o & 128 /* shadowNeedsScopedCss */);
+  patch(o, s, n);
+  if (r.o & 2 /* scopedCssEncapsulation */) {
+    const e = s.j.__childNodes || s.j.childNodes;
+    for (const t of e) {
+      if (t["s-hn"] !== I && !t["s-sh"]) {
+        if (n && t["s-ih"] == null) {
+          t["s-ih"] = (l = t.hidden) != null ? l : false;
+        }
+        t.hidden = true;
+      }
+    }
+  }
+};
+
+// src/runtime/update-component.ts
+var attachToAncestor = (e, t) => {
+  if (t && !e.R && t["s-p"]) {
+    const n = t["s-p"].push(new Promise((l => e.R = () => {
+      t["s-p"].splice(n - 1, 1);
+      l();
+    })));
+  }
+};
+
+var scheduleUpdate = (e, t) => {
+  {
+    e.o |= 16 /* isQueuedForUpdate */;
+  }
+  if (e.o & 4 /* isWaitingForChildren */) {
+    e.o |= 512 /* needsRerender */;
+    return;
+  }
+  attachToAncestor(e, e.W);
+  const dispatch = () => dispatchHooks(e, t);
+  return j(dispatch);
+};
+
+var dispatchHooks = (e, t) => {
+  const n = e.$hostElement$;
+  const l = createTime("scheduleUpdate", e.t.U);
+  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 r;
+  if (t) {
+    emitLifecycleEvent(n, "componentWillLoad");
+    r = safeCall(i, "componentWillLoad", void 0, n);
+  } else {
+    emitLifecycleEvent(n, "componentWillUpdate");
+    r = safeCall(i, "componentWillUpdate", void 0, n);
+  }
+  emitLifecycleEvent(n, "componentWillRender");
+  r = enqueue(r, (() => safeCall(i, "componentWillRender", void 0, n)));
+  l();
+  return enqueue(r, (() => updateComponent(e, i, t)));
+};
+
+var enqueue = (e, t) => isPromisey(e) ? e.then(t).catch((e => {
+  console.error(e);
+  t();
+})) : t();
+
+var isPromisey = e => e instanceof Promise || e && e.then && typeof e.then === "function";
+
+var updateComponent = async (e, t, n) => {
+  var l;
+  const i = e.$hostElement$;
+  const r = createTime("update", e.t.U);
+  const o = i["s-rc"];
+  if (n) {
+    attachStyles(e);
+  }
+  const s = createTime("render", e.t.U);
+  {
+    callRender(e, t, i, n);
+  }
+  if (o) {
+    o.map((e => e()));
+    i["s-rc"] = void 0;
+  }
+  s();
+  r();
+  {
+    const t = (l = i["s-p"]) != null ? l : [];
+    const postUpdate = () => postUpdateComponent(e);
+    if (t.length === 0) {
+      postUpdate();
+    } else {
+      Promise.all(t).then(postUpdate);
+      e.o |= 4 /* isWaitingForChildren */;
+      t.length = 0;
+    }
+  }
+};
+
+var callRender = (e, t, n, l) => {
+  try {
+    t = t.render();
+    {
+      e.o &= -17 /* isQueuedForUpdate */;
+    }
+    {
+      e.o |= 2 /* hasRendered */;
+    }
+    {
+      {
+        {
+          renderVdom(e, t, l);
+        }
+      }
+    }
+  } catch (t) {
+    consoleError(t, e.$hostElement$);
+  }
+  return null;
+};
+
+var postUpdateComponent = e => {
+  const t = e.t.U;
+  const n = e.$hostElement$;
+  const l = createTime("postUpdate", t);
+  const i = n;
+  const r = e.W;
+  safeCall(i, "componentDidRender", void 0, n);
+  emitLifecycleEvent(n, "componentDidRender");
+  if (!(e.o & 64 /* hasLoadedComponent */)) {
+    e.o |= 64 /* hasLoadedComponent */;
+    {
+      addHydratedFlag(n);
+    }
+    safeCall(i, "componentDidLoad", void 0, n);
+    emitLifecycleEvent(n, "componentDidLoad");
+    l();
+    {
+      e.v(n);
+      if (!r) {
+        appDidLoad();
+      }
+    }
+  } else {
+    safeCall(i, "componentDidUpdate", void 0, n);
+    emitLifecycleEvent(n, "componentDidUpdate");
+    l();
+  }
+  {
+    if (e.R) {
+      e.R();
+      e.R = void 0;
+    }
+    if (e.o & 512 /* needsRerender */) {
+      nextTick((() => scheduleUpdate(e, false)));
+    }
+    e.o &= -517;
+  }
+};
+
+var appDidLoad = t => {
+  nextTick((() => emitEvent($, "appload", {
+    detail: {
+      namespace: e
+    }
+  })));
+};
+
+var safeCall = (e, t, n, l) => {
+  if (e && e[t]) {
+    try {
+      return e[t](n);
+    } catch (e) {
+      consoleError(e, l);
+    }
+  }
+  return void 0;
+};
+
+var emitLifecycleEvent = (t, n) => {
+  {
+    emitEvent(t, "stencil_" + n, {
+      bubbles: true,
+      composed: true,
+      detail: {
+        namespace: e
+      }
+    });
+  }
+};
+
+var addHydratedFlag = e => {
+  var n;
+  return e.classList.add((n = t.hydratedSelectorName) != null ? n : "hydrated");
+};
+
+// src/runtime/set-value.ts
+var getValue = (e, t) => getHostRef(e).i.get(t);
+
+var setValue = (e, t, n, l) => {
+  const i = getHostRef(e);
+  const r = e;
+  const o = i.i.get(t);
+  const s = i.o;
+  const f = r;
+  n = parsePropertyValue(n, l.l[t][0]);
+  const a = Number.isNaN(o) && Number.isNaN(n);
+  const c = n !== o && !a;
+  if (c) {
+    i.i.set(t, n);
+    {
+      if (l.L && s & 128 /* isWatchReady */) {
+        const e = l.L[t];
+        if (e) {
+          e.map((e => {
+            try {
+              f[e](n, o, t);
+            } catch (e) {
+              consoleError(e, r);
+            }
+          }));
+        }
+      }
+      if ((s & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+        if (f.componentShouldUpdate) {
+          if (f.componentShouldUpdate(n, o, t) === false) {
+            return;
+          }
+        }
+        scheduleUpdate(i, false);
+      }
+    }
+  }
+};
+
+// src/runtime/proxy-component.ts
+var proxyComponent = (e, n, l) => {
+  var i, r;
+  const o = e.prototype;
+  if (n.o & 64 /* formAssociated */ && l & 1 /* isElementConstructor */) {
+    p.forEach((e => {
+      const t = o[e];
+      Object.defineProperty(o, e, {
+        value(...n) {
+          const l = getHostRef(this);
+          const i = this;
+          if (!i) {
+            l.u.then((t => {
+              const l = t[e];
+              typeof l === "function" && l.call(t, ...n);
+            }));
+          } else {
+            const e = t;
+            typeof e === "function" && e.call(i, ...n);
+          }
+        }
+      });
+    }));
+  }
+  if (n.l || (n.L || e.watchers)) {
+    if (e.watchers && !n.L) {
+      n.L = e.watchers;
+    }
+    const l = Object.entries((i = n.l) != null ? i : {});
+    l.map((([e, [t]]) => {
+      if (t & 31 /* Prop */ || t & 32 /* State */) {
+        const {get: l, set: i} = Object.getOwnPropertyDescriptor(o, e) || {};
+        if (l) n.l[e][0] |= 2048 /* Getter */;
+        if (i) n.l[e][0] |= 4096 /* Setter */;
+        {
+          Object.defineProperty(o, e, {
+            get() {
+              {
+                return l ? l.apply(this) : getValue(this, e);
+              }
+            },
+            configurable: true,
+            enumerable: true
+          });
+        }
+        Object.defineProperty(o, e, {
+          set(l) {
+            const r = getHostRef(this);
+            if (i) {
+              const o = t & 32 /* State */ ? this[e] : r.$hostElement$[e];
+              if (typeof o === "undefined" && r.i.get(e)) {
+                l = r.i.get(e);
+              } else if (!r.i.get(e) && o) {
+                r.i.set(e, o);
+              }
+              i.apply(this, [ parsePropertyValue(l, t) ]);
+              l = t & 32 /* State */ ? this[e] : r.$hostElement$[e];
+              setValue(this, e, l, n);
+              return;
+            }
+            {
+              setValue(this, e, l, n);
+              return;
+            }
+          }
+        });
+      }
+    }));
+    {
+      const i =  new Map;
+      o.attributeChangedCallback = function(e, l, r) {
+        b.jmp((() => {
+          var s;
+          const f = i.get(e);
+          if (this.hasOwnProperty(f) && t.lazyLoad) ; else if (o.hasOwnProperty(f) && typeof this[f] === "number" && // cast type to number to avoid TS compiler issues
+          this[f] == r) {
+            return;
+          } else if (f == null) {
+            const t = getHostRef(this);
+            const i = t == null ? void 0 : t.o;
+            if (i && !(i & 8 /* isConstructingInstance */) && i & 128 /* isWatchReady */ && r !== l) {
+              const t = this;
+              const i = t;
+              const o = (s = n.L) == null ? void 0 : s[e];
+              o == null ? void 0 : o.forEach((t => {
+                if (i[t] != null) {
+                  i[t].call(i, r, l, e);
+                }
+              }));
+            }
+            return;
+          }
+          const a = Object.getOwnPropertyDescriptor(o, f);
+          r = r === null && typeof this[f] === "boolean" ? false : r;
+          if (r !== this[f] && (!a.get || !!a.set)) {
+            this[f] = r;
+          }
+        }));
+      };
+      e.observedAttributes = Array.from(
+       new Set([ ...Object.keys((r = n.L) != null ? r : {}), ...l.filter((([e, t]) => t[0] & 15 /* HasAttribute */)).map((([e, t]) => {
+        var l;
+        const r = t[1] || e;
+        i.set(r, e);
+        if (t[0] & 512 /* ReflectAttr */) {
+          (l = n.D) == null ? void 0 : l.push([ e, r ]);
+        }
+        return r;
+      })) ]));
+    }
+  }
+  return e;
+};
+
+// src/runtime/initialize-component.ts
+var initializeComponent = async (e, t, n, i) => {
+  let r;
+  if ((t.o & 32 /* hasInitializedComponent */) === 0) {
+    t.o |= 32 /* hasInitializedComponent */;
+    {
+      r = e.constructor;
+      const n = e.localName;
+      customElements.whenDefined(n).then((() => t.o |= 128 /* isWatchReady */));
+    }
+    if (r && r.style) {
+      let e;
+      if (typeof r.style === "string") {
+        e = r.style;
+      }
+      const t = getScopeId(n);
+      if (!l.has(t)) {
+        const l = createTime("registerStyles", n.U);
+        registerStyle(t, e, !!(n.o & 1 /* shadowDomEncapsulation */));
+        l();
+      }
+    }
+  }
+  const o = t.W;
+  const schedule = () => scheduleUpdate(t, true);
+  if (o && o["s-rc"]) {
+    o["s-rc"].push(schedule);
+  } else {
+    schedule();
+  }
+};
+
+var fireConnectedCallback = (e, t) => {};
+
+// src/runtime/connected-callback.ts
+var connectedCallback = e => {
+  if ((b.o & 1 /* isTmpDisconnected */) === 0) {
+    const n = getHostRef(e);
+    const l = n.t;
+    const i = createTime("connectedCallback", l.U);
+    if (!(n.o & 1 /* hasConnected */)) {
+      n.o |= 1 /* hasConnected */;
+      let i;
+      {
+        i = e.getAttribute(a);
+        if (i) {
+          if (l.o & 1 /* shadowDomEncapsulation */) {
+            const t = addStyle(e.shadowRoot, l);
+            e.classList.remove(t + "-h", t + "-s");
+          }
+          initializeClientHydrate(e, l.U, i, n);
+        }
+      }
+      {
+        let t = e;
+        while (t = t.parentNode || t.host) {
+          if (t.nodeType === 1 /* ElementNode */ && t.hasAttribute("s-id") && t["s-p"] || t["s-p"]) {
+            attachToAncestor(n, n.W = t);
+            break;
+          }
+        }
+      }
+      if (l.l) {
+        Object.entries(l.l).map((([t, [n]]) => {
+          if (n & 31 /* Prop */ && e.hasOwnProperty(t)) {
+            const n = e[t];
+            delete e[t];
+            e[t] = n;
+          }
+        }));
+      }
+      if (t.initializeNextTick) {
+        nextTick((() => initializeComponent(e, n, l)));
+      } else {
+        initializeComponent(e, n, l);
+      }
+    } else {
+      addHostEventListeners(e, n, l.P);
+      if (n == null ? void 0 : n.F) ; else if (n == null ? void 0 : n.u) {
+        n.u.then((() => fireConnectedCallback()));
+      }
+    }
+    i();
+  }
+};
+
+var disconnectedCallback = async e => {
+  if ((b.o & 1 /* isTmpDisconnected */) === 0) {
+    const t = getHostRef(e);
+    {
+      if (t.q) {
+        t.q.map((e => e()));
+        t.q = void 0;
+      }
+    }
+  }
+  if (A.has(e)) {
+    A.delete(e);
+  }
+  if (e.shadowRoot && A.has(e.shadowRoot)) {
+    A.delete(e.shadowRoot);
+  }
+};
+
+var proxyCustomElement = (e, t) => {
+  const n = {
+    o: t[0],
+    U: t[1]
+  };
+  {
+    n.l = t[2];
+  }
+  {
+    n.P = t[3];
+  }
+  {
+    n.L = e.L;
+  }
+  {
+    n.D = [];
+  }
+  {
+    hydrateScopedToShadow();
+  }
+  const l = e.prototype.connectedCallback;
+  const i = e.prototype.disconnectedCallback;
+  Object.assign(e.prototype, {
+    __hasHostListenerAttached: false,
+    __registerHost() {
+      registerHost(this, n);
+    },
+    connectedCallback() {
+      if (!this.__hasHostListenerAttached) {
+        const e = getHostRef(this);
+        addHostEventListeners(this, e, n.P);
+        this.__hasHostListenerAttached = true;
+      }
+      connectedCallback(this);
+      if (l) {
+        l.call(this);
+      }
+    },
+    disconnectedCallback() {
+      disconnectedCallback(this);
+      if (i) {
+        i.call(this);
+      }
+    },
+    __attachShadow() {
+      {
+        if (!this.shadowRoot) {
+          {
+            this.attachShadow({
+              mode: "open"
+            });
+          }
+        } else {
+          if (this.shadowRoot.mode !== "open") {
+            throw new Error(`Unable to re-use existing shadow root for ${n.U}! Mode is set to ${this.shadowRoot.mode} but Stencil only supports open shadow roots.`);
+          }
+        }
+      }
+    }
+  });
+  e.is = n.U;
+  return proxyComponent(e, n, 1 /* isElementConstructor */ | 2 /* proxyState */);
+};
+
+var addHostEventListeners = (e, t, n, l) => {
+  if (n && $.document) {
+    n.map((([n, l, i]) => {
+      const r = getHostListenerTarget($.document, e, n);
+      const o = hostListenerProxy(t, i);
+      const s = hostListenerOpts(n);
+      b.ael(r, l, o, s);
+      (t.q = t.q || []).push((() => b.rel(r, l, o, s)));
+    }));
+  }
+};
+
+var hostListenerProxy = (e, t) => n => {
+  try {
+    {
+      e.$hostElement$[t](n);
+    }
+  } catch (t) {
+    consoleError(t, e.$hostElement$);
+  }
+};
+
+var getHostListenerTarget = (e, t, n) => {
+  if (n & 4 /* TargetDocument */) {
+    return e;
+  }
+  if (n & 8 /* TargetWindow */) {
+    return $;
+  }
+  return t;
+};
+
+var hostListenerOpts = e => g ? {
+  passive: (e & 1 /* Passive */) !== 0,
+  capture: (e & 2 /* Capture */) !== 0
+} : (e & 2 /* Capture */) !== 0
+// src/runtime/nonce.ts
+;
+
+var setNonce = e => b.I = e
+// src/runtime/platform-options.ts
+;
+
+var setPlatformOptions = e => Object.assign(b, e);
+
+export { m as H, setNonce as a, setPlatformOptions as b, createEvent as c, E as d, getAssetPath as g, h, proxyCustomElement as p, setAssetPath as s };
+//# sourceMappingURL=p-D02C28Eq.js.map
+//# sourceMappingURL=p-D02C28Eq.js.map