@govbr-ds/webcomponents 2.0.0-next.24 → 2.0.0-next.25

package/dist/webcomponents/p-bde61e4e.js

@@ -0,0 +1,2092 @@
+/*!
+ * Construído com @govbr-ds/webcomponents
+ */
+const e = "webcomponents";
+
+const t = /* webcomponents */ {
+  allRenderFn: true,
+  appendChildSlotFix: true,
+  asyncLoading: true,
+  asyncQueue: false,
+  attachStyles: true,
+  cloneNodeFix: true,
+  cmpDidLoad: true,
+  cmpDidRender: false,
+  cmpDidUnload: false,
+  cmpDidUpdate: false,
+  cmpShouldUpdate: false,
+  cmpWillLoad: true,
+  cmpWillRender: false,
+  cmpWillUpdate: false,
+  connectedCallback: true,
+  constructableCSS: true,
+  cssAnnotations: true,
+  devTools: false,
+  disconnectedCallback: true,
+  element: false,
+  event: true,
+  experimentalScopedSlotChanges: false,
+  experimentalSlotFixes: false,
+  formAssociated: true,
+  hasRenderFn: true,
+  hostListener: true,
+  hostListenerTarget: true,
+  hostListenerTargetBody: false,
+  hostListenerTargetDocument: true,
+  hostListenerTargetParent: false,
+  hostListenerTargetWindow: true,
+  hotModuleReplacement: false,
+  hydrateClientSide: true,
+  hydrateServerSide: false,
+  hydratedAttribute: false,
+  hydratedClass: true,
+  hydratedSelectorName: "hydrated",
+  initializeNextTick: false,
+  invisiblePrehydration: true,
+  isDebug: true,
+  isDev: false,
+  isTesting: false,
+  lazyLoad: true,
+  lifecycle: true,
+  lifecycleDOMEvents: true,
+  member: true,
+  method: true,
+  mode: false,
+  observeAttribute: true,
+  profile: false,
+  prop: true,
+  propBoolean: true,
+  propMutable: true,
+  propNumber: true,
+  propString: true,
+  reflect: true,
+  scoped: false,
+  scopedSlotTextContentFix: false,
+  scriptDataOpts: false,
+  shadowDelegatesFocus: false,
+  shadowDom: true,
+  slot: true,
+  slotChildNodesFix: false,
+  slotRelocation: false,
+  state: true,
+  style: true,
+  svg: false,
+  taskQueue: true,
+  transformTagName: false,
+  updatable: true,
+  vdomAttribute: true,
+  vdomClass: true,
+  vdomFunctional: true,
+  vdomKey: true,
+  vdomListener: true,
+  vdomPropOrAttr: true,
+  vdomRef: true,
+  vdomRender: true,
+  vdomStyle: true,
+  vdomText: true,
+  vdomXlink: true,
+  watchCallback: true
+};
+
+/*
+ Stencil Client Platform v4.23.0 | MIT Licensed | https://stenciljs.com
+ */ var n = Object.defineProperty;
+
+var __export = (e, t) => {
+  for (var s in t) n(e, s, {
+    get: t[s],
+    enumerable: true
+  });
+};
+
+var s =  new WeakMap;
+
+var getHostRef = e => s.get(e);
+
+var registerInstance = (e, t) => s.set(t._$$lazyInstance$$_ = e, t);
+
+var registerHost = (e, t) => {
+  const n = {
+    _$$flags$$_: 0,
+    $hostElement$: e,
+    _$$cmpMeta$$_: t,
+    _$$instanceValues$$_:  new Map
+  };
+  {
+    n._$$onInstancePromise$$_ = new Promise((e => n._$$onInstanceResolve$$_ = e));
+  }
+  {
+    n._$$onReadyPromise$$_ = new Promise((e => n._$$onReadyResolve$$_ = e));
+    e["s-p"] = [];
+    e["s-rc"] = [];
+  }
+  return s.set(e, n);
+};
+
+var isMemberInElement = (e, t) => t in e;
+
+var consoleError = (e, t) => (0, console.error)(e, t)
+// src/client/client-load-module.ts
+;
+
+var r =  new Map;
+
+var loadModule = (e, t, n) => {
+  const s = e._$$tagName$$_.replace(/-/g, "_");
+  const l = e._$$lazyBundleId$$_;
+  if (!l) {
+    return void 0;
+  }
+  const o = r.get(l);
+  if (o) {
+    return o[s];
+  }
+  /*!__STENCIL_STATIC_IMPORT_SWITCH__*/  return import(
+  /* @vite-ignore */
+  /* webpackInclude: /\.entry\.js$/ */
+  /* webpackExclude: /\.system\.entry\.js$/ */
+  /* webpackMode: "lazy" */
+  `./${l}.entry.js${""}`).then((e => {
+    {
+      r.set(l, e);
+    }
+    return e[s];
+  }), consoleError);
+};
+
+// src/client/client-style.ts
+var l =  new Map;
+
+// src/runtime/runtime-constants.ts
+var o = "r";
+
+var i = "o";
+
+var a = "s";
+
+var f = "t";
+
+var c = "c";
+
+var u = "s-id";
+
+var d = "sty-id";
+
+var v = "c-id";
+
+var p = "{visibility:hidden}.hydrated{visibility:inherit}";
+
+var m = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+
+var $ = "http://www.w3.org/1999/xlink";
+
+var y = [ "formAssociatedCallback", "formResetCallback", "formDisabledCallback", "formStateRestoreCallback" ];
+
+var b = typeof window !== "undefined" ? window : {};
+
+var w = b.document || {
+  head: {}
+};
+
+var g = b.HTMLElement || class {};
+
+var S = {
+  _$$flags$$_: 0,
+  _$$resourcesUrl$$_: "",
+  jmp: e => e(),
+  raf: e => requestAnimationFrame(e),
+  ael: (e, t, n, s) => e.addEventListener(t, n, s),
+  rel: (e, t, n, s) => e.removeEventListener(t, n, s),
+  ce: (e, t) => new CustomEvent(e, t)
+};
+
+var k = t.shadowDom;
+
+var C =  (() => {
+  let e = false;
+  try {
+    w.addEventListener("e", null, Object.defineProperty({}, "passive", {
+      get() {
+        e = true;
+      }
+    }));
+  } catch (e) {}
+  return e;
+})();
+
+var promiseResolve = e => Promise.resolve(e);
+
+var x =  (() => {
+  try {
+    new CSSStyleSheet;
+    return typeof (new CSSStyleSheet).replaceSync === "function";
+  } catch (e) {}
+  return false;
+})();
+
+var j = false;
+
+var O = [];
+
+var D = [];
+
+var queueTask = (e, t) => n => {
+  e.push(n);
+  if (!j) {
+    j = true;
+    if (t && S._$$flags$$_ & 4 /* queueSync */) {
+      nextTick(flush);
+    } else {
+      S.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(O);
+  {
+    consume(D);
+    if (j = O.length > 0) {
+      S.raf(flush);
+    }
+  }
+};
+
+var nextTick = e => promiseResolve().then(e);
+
+var T =  queueTask(D, true);
+
+// src/utils/constants.ts
+var L = {};
+
+// src/utils/helpers.ts
+var isDef = e => e != null;
+
+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, s;
+  return (s = (n = (t = e.head) == null ? void 0 : t.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : n.getAttribute("content")) != null ? s : void 0;
+}
+
+// src/utils/result.ts
+var M = {};
+
+__export(M, {
+  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 h = (e, t, ...n) => {
+  let s = null;
+  let r = null;
+  let l = false;
+  let o = false;
+  const i = [];
+  const walk = t => {
+    for (let n = 0; n < t.length; n++) {
+      s = t[n];
+      if (Array.isArray(s)) {
+        walk(s);
+      } else if (s != null && typeof s !== "boolean") {
+        if (l = typeof e !== "function" && !isComplexType(s)) {
+          s = String(s);
+        }
+        if (l && o) {
+          i[i.length - 1]._$$text$$_ += s;
+        } else {
+          i.push(l ? newVNode(null, s) : s);
+        }
+        o = l;
+      }
+    }
+  };
+  walk(n);
+  if (t) {
+    if (t.key) {
+      r = 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, i, E);
+  }
+  const a = newVNode(e, null);
+  a._$$attrs$$_ = t;
+  if (i.length > 0) {
+    a._$$children$$_ = i;
+  }
+  {
+    a._$$key$$_ = r;
+  }
+  return a;
+};
+
+var newVNode = (e, t) => {
+  const n = {
+    _$$flags$$_: 0,
+    _$$tag$$_: e,
+    _$$text$$_: t,
+    _$$elm$$_: null,
+    _$$children$$_: null
+  };
+  {
+    n._$$attrs$$_ = null;
+  }
+  {
+    n._$$key$$_ = null;
+  }
+  return n;
+};
+
+var A = {};
+
+var isHost = e => e && e._$$tag$$_ === A;
+
+var E = {
+  forEach: (e, t) => e.map(convertToPublic).forEach(t),
+  map: (e, t) => e.map(convertToPublic).map(t).map(convertToPrivate)
+};
+
+var convertToPublic = e => ({
+  vattrs: e._$$attrs$$_,
+  vchildren: e._$$children$$_,
+  vkey: e._$$key$$_,
+  vname: e._$$name$$_,
+  vtag: e._$$tag$$_,
+  vtext: e._$$text$$_
+});
+
+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._$$attrs$$_ = e.vattrs;
+  t._$$children$$_ = e.vchildren;
+  t._$$key$$_ = e.vkey;
+  t._$$name$$_ = e.vname;
+  return t;
+};
+
+var setAccessor = (e, t, n, s, r, l) => {
+  if (n !== s) {
+    let o = isMemberInElement(e, t);
+    let i = t.toLowerCase();
+    if (t === "class") {
+      const t = e.classList;
+      const r = parseClassList(n);
+      const l = parseClassList(s);
+      if (e["s-si"] && l.indexOf(e["s-si"]) < 0) {
+        l.push(e["s-si"]);
+      }
+      t.remove(...r.filter((e => e && !l.includes(e))));
+      t.add(...l.filter((e => e && !r.includes(e))));
+    } else if (t === "style") {
+      {
+        for (const t in n) {
+          if (!s || s[t] == null) {
+            if (t.includes("-")) {
+              e.style.removeProperty(t);
+            } else {
+              e.style[t] = "";
+            }
+          }
+        }
+      }
+      for (const t in s) {
+        if (!n || s[t] !== n[t]) {
+          if (t.includes("-")) {
+            e.style.setProperty(t, s[t]);
+          } else {
+            e.style[t] = s[t];
+          }
+        }
+      }
+    } else if (t === "key") ; else if (t === "ref") {
+      if (s) {
+        s(e);
+      }
+    } else if (!o && t[0] === "o" && t[1] === "n") {
+      if (t[2] === "-") {
+        t = t.slice(3);
+      } else if (isMemberInElement(b, i)) {
+        t = i.slice(2);
+      } else {
+        t = i[2] + t.slice(3);
+      }
+      if (n || s) {
+        const r = t.endsWith(N);
+        t = t.replace(F, "");
+        if (n) {
+          S.rel(e, t, n, r);
+        }
+        if (s) {
+          S.ael(e, t, s, r);
+        }
+      }
+    } else {
+      const a = isComplexType(s);
+      if ((o || a && s !== null) && !r) {
+        try {
+          if (!e.tagName.includes("-")) {
+            const r = s == null ? "" : s;
+            if (t === "list") {
+              o = false;
+            } else if (n == null || e[t] != r) {
+              if (typeof e.__lookupSetter__(t) === "function") {
+                e[t] = r;
+              } else {
+                e.setAttribute(t, r);
+              }
+            }
+          } else {
+            e[t] = s;
+          }
+        } catch (e) {}
+      }
+      let f = false;
+      {
+        if (i !== (i = i.replace(/^xlink\:?/, ""))) {
+          t = i;
+          f = true;
+        }
+      }
+      if (s == null || s === false) {
+        if (s !== false || e.getAttribute(t) === "") {
+          if (f) {
+            e.removeAttributeNS($, t);
+          } else {
+            e.removeAttribute(t);
+          }
+        }
+      } else if ((!o || l & 4 /* isHost */ || r) && !a) {
+        s = s === true ? "" : s;
+        if (f) {
+          e.setAttributeNS($, t, s);
+        } else {
+          e.setAttribute(t, s);
+        }
+      }
+    }
+  }
+};
+
+var R = /\s/;
+
+var parseClassList = e => !e ? [] : e.split(R);
+
+var N = "Capture";
+
+var F = new RegExp(N + "$");
+
+// src/runtime/vdom/update-element.ts
+var updateElement = (e, t, n) => {
+  const s = t._$$elm$$_.nodeType === 11 /* DocumentFragment */ && t._$$elm$$_.host ? t._$$elm$$_.host : t._$$elm$$_;
+  const r = e && e._$$attrs$$_ || L;
+  const l = t._$$attrs$$_ || L;
+  {
+    for (const e of sortedAttrNames(Object.keys(r))) {
+      if (!(e in l)) {
+        setAccessor(s, e, r[e], void 0, n, t._$$flags$$_);
+      }
+    }
+  }
+  for (const e of sortedAttrNames(Object.keys(l))) {
+    setAccessor(s, e, r[e], l[e], n, t._$$flags$$_);
+  }
+};
+
+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;
+}
+
+// src/runtime/vdom/vdom-render.ts
+var P;
+
+var U;
+
+var W = false;
+
+var I = false;
+
+var createElm = (e, n, s, r) => {
+  const l = n._$$children$$_[s];
+  let o = 0;
+  let i;
+  let a;
+  if (l._$$text$$_ !== null) {
+    i = l._$$elm$$_ = w.createTextNode(l._$$text$$_);
+  } else {
+    i = l._$$elm$$_ = w.createElement(!W && t.slotRelocation && l._$$flags$$_ & 2 /* isSlotFallback */ ? "slot-fb" : l._$$tag$$_);
+    {
+      updateElement(null, l, I);
+    }
+    const n = i.getRootNode();
+    const s = !n.querySelector("body");
+    if (!s && t.scoped && isDef(P) && i["s-si"] !== P) {
+      i.classList.add(i["s-si"] = P);
+    }
+    if (l._$$children$$_) {
+      for (o = 0; o < l._$$children$$_.length; ++o) {
+        a = createElm(e, l, o);
+        if (a) {
+          i.appendChild(a);
+        }
+      }
+    }
+  }
+  i["s-hn"] = U;
+  return i;
+};
+
+var addVnodes = (e, t, n, s, r, l) => {
+  let o = e;
+  let i;
+  if (o.shadowRoot && o.tagName === U) {
+    o = o.shadowRoot;
+  }
+  for (;r <= l; ++r) {
+    if (s[r]) {
+      i = createElm(null, n, r);
+      if (i) {
+        s[r]._$$elm$$_ = i;
+        insertBefore(o, i, t);
+      }
+    }
+  }
+};
+
+var removeVnodes = (e, t, n) => {
+  for (let s = t; s <= n; ++s) {
+    const t = e[s];
+    if (t) {
+      const e = t._$$elm$$_;
+      nullifyVNodeRefs(t);
+      if (e) {
+        e.remove();
+      }
+    }
+  }
+};
+
+var updateChildren = (e, t, n, s, r = false) => {
+  let l = 0;
+  let o = 0;
+  let i = 0;
+  let a = 0;
+  let f = t.length - 1;
+  let c = t[0];
+  let u = t[f];
+  let d = s.length - 1;
+  let v = s[0];
+  let p = s[d];
+  let m;
+  let $;
+  while (l <= f && o <= d) {
+    if (c == null) {
+      c = t[++l];
+    } else if (u == null) {
+      u = t[--f];
+    } else if (v == null) {
+      v = s[++o];
+    } else if (p == null) {
+      p = s[--d];
+    } else if (isSameVnode(c, v, r)) {
+      patch(c, v, r);
+      c = t[++l];
+      v = s[++o];
+    } else if (isSameVnode(u, p, r)) {
+      patch(u, p, r);
+      u = t[--f];
+      p = s[--d];
+    } else if (isSameVnode(c, p, r)) {
+      patch(c, p, r);
+      insertBefore(e, c._$$elm$$_, u._$$elm$$_.nextSibling);
+      c = t[++l];
+      p = s[--d];
+    } else if (isSameVnode(u, v, r)) {
+      patch(u, v, r);
+      insertBefore(e, u._$$elm$$_, c._$$elm$$_);
+      u = t[--f];
+      v = s[++o];
+    } else {
+      i = -1;
+      {
+        for (a = l; a <= f; ++a) {
+          if (t[a] && t[a]._$$key$$_ !== null && t[a]._$$key$$_ === v._$$key$$_) {
+            i = a;
+            break;
+          }
+        }
+      }
+      if (i >= 0) {
+        $ = t[i];
+        if ($._$$tag$$_ !== v._$$tag$$_) {
+          m = createElm(t && t[o], n, i);
+        } else {
+          patch($, v, r);
+          t[i] = void 0;
+          m = $._$$elm$$_;
+        }
+        v = s[++o];
+      } else {
+        m = createElm(t && t[o], n, o);
+        v = s[++o];
+      }
+      if (m) {
+        {
+          insertBefore(c._$$elm$$_.parentNode, m, c._$$elm$$_);
+        }
+      }
+    }
+  }
+  if (l > f) {
+    addVnodes(e, s[d + 1] == null ? null : s[d + 1]._$$elm$$_, n, s, o, d);
+  } else if (o > d) {
+    removeVnodes(t, l, f);
+  }
+};
+
+var isSameVnode = (e, t, n = false) => {
+  if (e._$$tag$$_ === t._$$tag$$_) {
+    if (!n) {
+      return e._$$key$$_ === t._$$key$$_;
+    }
+    return true;
+  }
+  return false;
+};
+
+var patch = (e, n, s = false) => {
+  const r = n._$$elm$$_ = e._$$elm$$_;
+  const l = e._$$children$$_;
+  const o = n._$$children$$_;
+  const i = n._$$tag$$_;
+  const a = n._$$text$$_;
+  if (a === null) {
+    {
+      if (i === "slot" && !W) ; else {
+        updateElement(e, n, I);
+      }
+    }
+    if (l !== null && o !== null) {
+      updateChildren(r, l, n, o, s);
+    } else if (o !== null) {
+      if (e._$$text$$_ !== null) {
+        r.textContent = "";
+      }
+      addVnodes(r, 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
+    !s && t.updatable && l !== null) {
+      removeVnodes(l, 0, l.length - 1);
+    }
+  } else if (e._$$text$$_ !== a) {
+    r.data = a;
+  }
+};
+
+var updateFallbackSlotVisibility = e => {
+  const t = e.__childNodes || e.childNodes;
+  for (const e of t) {
+    if (e.nodeType === 1 /* ElementNode */) {
+      if (e["s-sr"]) {
+        const n = e["s-sn"];
+        e.hidden = false;
+        for (const s of t) {
+          if (s !== e) {
+            if (s["s-hn"] !== e["s-hn"] || n !== "") {
+              if (s.nodeType === 1 /* ElementNode */ && (n === s.getAttribute("slot") || n === s["s-sn"]) || s.nodeType === 3 /* TextNode */ && n === s["s-sn"]) {
+                e.hidden = true;
+                break;
+              }
+            } else if (n === s["s-sn"]) {
+              if (s.nodeType === 1 /* ElementNode */ || s.nodeType === 3 /* TextNode */ && s.textContent.trim() !== "") {
+                e.hidden = true;
+                break;
+              }
+            }
+          }
+        }
+      }
+      updateFallbackSlotVisibility(e);
+    }
+  }
+};
+
+var nullifyVNodeRefs = e => {
+  {
+    e._$$attrs$$_ && e._$$attrs$$_.ref && e._$$attrs$$_.ref(null);
+    e._$$children$$_ && e._$$children$$_.map(nullifyVNodeRefs);
+  }
+};
+
+var insertBefore = (e, t, n) => {
+  const s = e == null ? void 0 : e.insertBefore(t, n);
+  return s;
+};
+
+var renderVdom = (e, t, n = false) => {
+  const s = e.$hostElement$;
+  const r = e._$$cmpMeta$$_;
+  const l = e._$$vnode$$_ || newVNode(null, null);
+  const o = isHost(t) ? t : h(null, null, t);
+  U = s.tagName;
+  if (r._$$attrsToReflect$$_) {
+    o._$$attrs$$_ = o._$$attrs$$_ || {};
+    r._$$attrsToReflect$$_.map((([e, t]) => o._$$attrs$$_[t] = s[e]));
+  }
+  if (n && o._$$attrs$$_) {
+    for (const e of Object.keys(o._$$attrs$$_)) {
+      if (s.hasAttribute(e) && ![ "key", "ref", "style", "class" ].includes(e)) {
+        o._$$attrs$$_[e] = s[e];
+      }
+    }
+  }
+  o._$$tag$$_ = null;
+  o._$$flags$$_ |= 4 /* isHost */;
+  e._$$vnode$$_ = o;
+  o._$$elm$$_ = l._$$elm$$_ = s.shadowRoot || s;
+  {
+    P = s["s-sc"];
+  }
+  W = (r._$$flags$$_ & 1 /* shadowDomEncapsulation */) !== 0;
+  patch(l, o, n);
+};
+
+var patchCloneNode = e => {
+  const t = e.cloneNode;
+  e.cloneNode = function(e) {
+    const n = this;
+    const s = n.shadowRoot && k;
+    const r = t.call(n, s ? e : false);
+    if (!s && e) {
+      let e = 0;
+      let t, n;
+      const s = [ "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 l = this.__childNodes || this.childNodes;
+      for (;e < l.length; e++) {
+        t = l[e]["s-nr"];
+        n = s.every((t => !l[e][t]));
+        if (t) {
+          if (r.__appendChild) {
+            r.__appendChild(t.cloneNode(true));
+          } else {
+            r.appendChild(t.cloneNode(true));
+          }
+        }
+        if (n) {
+          r.appendChild(l[e].cloneNode(true));
+        }
+      }
+    }
+    return r;
+  };
+};
+
+var patchSlotAppendChild = e => {
+  e.__appendChild = e.appendChild;
+  e.appendChild = function(e) {
+    const t = e["s-sn"] = getSlotName(e);
+    const n = getHostSlotNode(this.__childNodes || this.childNodes, t, this.tagName);
+    if (n) {
+      addSlotRelocateNode(e, n);
+      const s = getHostSlotChildNodes(n, t);
+      const r = s[s.length - 1];
+      const l = insertBefore(r.parentNode, e, r.nextSibling);
+      updateFallbackSlotVisibility(this);
+      return l;
+    }
+    return this.__appendChild(e);
+  };
+};
+
+var addSlotRelocateNode = (e, t, n, s) => {
+  let r;
+  if (e["s-ol"] && e["s-ol"].isConnected) {
+    r = e["s-ol"];
+  } else {
+    r = document.createTextNode("");
+    r["s-nr"] = e;
+  }
+  if (!t["s-cr"] || !t["s-cr"].parentNode) return;
+  const l = t["s-cr"].parentNode;
+  const o = n ? l.__prepend || l.prepend : l.__appendChild || l.appendChild;
+  if (typeof s !== "undefined") {
+    {
+      r["s-oo"] = s;
+      const e = l.__childNodes || l.childNodes;
+      const t = [ r ];
+      e.forEach((e => {
+        if (e["s-nr"]) t.push(e);
+      }));
+      t.sort(((e, t) => {
+        if (!e["s-oo"] || e["s-oo"] < t["s-oo"]) return -1; else if (!t["s-oo"] || t["s-oo"] < e["s-oo"]) return 1;
+        return 0;
+      }));
+      t.forEach((e => o.call(l, e)));
+    }
+  } else {
+    o.call(l, r);
+  }
+  e["s-ol"] = r;
+  e["s-sh"] = t["s-hn"];
+};
+
+var getSlotName = e => e["s-sn"] || e.nodeType === 1 && e.getAttribute("slot") || "";
+
+var getHostSlotNode = (e, t, n) => {
+  let s = 0;
+  let r;
+  for (;s < e.length; s++) {
+    r = e[s];
+    if (r["s-sr"] && r["s-sn"] === t && r["s-hn"] === n) {
+      return r;
+    }
+    r = getHostSlotNode(r.childNodes, t, n);
+    if (r) {
+      return r;
+    }
+  }
+  return null;
+};
+
+var getHostSlotChildNodes = (e, t) => {
+  const n = [ e ];
+  while ((e = e.nextSibling) && e["s-sn"] === t) {
+    n.push(e);
+  }
+  return n;
+};
+
+var createTime = (e, t = "") => {
+  {
+    return () => {};
+  }
+};
+
+var uniqueTime = (e, t) => {
+  {
+    return () => {};
+  }
+};
+
+// src/runtime/client-hydrate.ts
+var initializeClientHydrate = (e, t, n, s) => {
+  const r = createTime("hydrateClient", t);
+  const l = e.shadowRoot;
+  const o = [];
+  const i = [];
+  const a = [];
+  const f = l ? [] : null;
+  const c = newVNode(t, null);
+  c._$$elm$$_ = e;
+  if (!S._$$orgLocNodes$$_) {
+    initializeDocumentHydrate(w.body, S._$$orgLocNodes$$_ =  new Map);
+  }
+  e[u] = n;
+  e.removeAttribute(u);
+  s._$$vnode$$_ = clientHydrate(c, o, i, f, e, e, n, a);
+  let d = 0;
+  const v = o.length;
+  let p;
+  for (d; d < v; d++) {
+    p = o[d];
+    const n = p._$$hostId$$_ + "." + p._$$nodeId$$_;
+    const s = S._$$orgLocNodes$$_.get(n);
+    const r = p._$$elm$$_;
+    if (!l) {
+      r["s-hn"] = t.toUpperCase();
+      if (p._$$tag$$_ === "slot") {
+        r["s-cr"] = e["s-cr"];
+      }
+    }
+    if (s && s.isConnected) {
+      if (l && s["s-en"] === "") {
+        s.parentNode.insertBefore(r, s.nextSibling);
+      }
+      s.parentNode.removeChild(s);
+      if (!l) {
+        r["s-oo"] = parseInt(p._$$nodeId$$_);
+      }
+    }
+    S._$$orgLocNodes$$_.delete(n);
+  }
+  const m = [];
+  let $ = 0;
+  const y = a.length;
+  let b;
+  let g;
+  let k;
+  let C;
+  for ($; $ < y; $++) {
+    b = a[$];
+    if (!b || !b.length) continue;
+    k = b.length;
+    g = 0;
+    for (g; g < k; g++) {
+      C = b[g];
+      if (!m[C.hostId]) {
+        m[C.hostId] = S._$$orgLocNodes$$_.get(C.hostId);
+      }
+      if (!m[C.hostId]) continue;
+      const e = m[C.hostId];
+      if (!e.shadowRoot || !l) {
+        C.slot["s-cr"] = e["s-cr"];
+        if (!C.slot["s-cr"] && e.shadowRoot) {
+          C.slot["s-cr"] = e;
+        } else {
+          const t = e.__childNodes || e.childNodes;
+          C.slot["s-cr"] = t[0];
+        }
+        addSlotRelocateNode(C.node, C.slot, false, C.node["s-oo"]);
+      }
+      if (e.shadowRoot && C.node.parentElement !== e) {
+        e.appendChild(C.node);
+      }
+    }
+  }
+  if (l) {
+    let t = 0;
+    const n = f.length;
+    for (t; t < n; t++) {
+      l.appendChild(f[t]);
+    }
+    Array.from(e.childNodes).forEach((e => {
+      if (e.nodeType === 8 /* CommentNode */ && typeof e["s-sn"] !== "string") {
+        e.parentNode.removeChild(e);
+      }
+    }));
+  }
+  s.$hostElement$ = e;
+  r();
+};
+
+var clientHydrate = (e, t, n, s, r, l, i, u = []) => {
+  let d;
+  let p;
+  let m;
+  let $;
+  const y = r["s-sc"];
+  if (l.nodeType === 1 /* ElementNode */) {
+    d = l.getAttribute(v);
+    if (d) {
+      p = d.split(".");
+      if (p[0] === i || p[0] === "0") {
+        m = createSimpleVNode({
+          _$$flags$$_: 0,
+          _$$hostId$$_: p[0],
+          _$$nodeId$$_: p[1],
+          _$$depth$$_: p[2],
+          _$$index$$_: p[3],
+          _$$tag$$_: l.tagName.toLowerCase(),
+          _$$elm$$_: l,
+          // If we don't add the initial classes to the VNode, the first `vdom-render.ts` reconciliation will fail:
+          // client side changes before componentDidLoad will be ignored, `set-accessor.ts` will just take the element's initial classes
+          _$$attrs$$_: {
+            class: l.className
+          }
+        });
+        t.push(m);
+        l.removeAttribute(v);
+        if (!e._$$children$$_) {
+          e._$$children$$_ = [];
+        }
+        const r = m._$$elm$$_.getAttribute("s-sn");
+        if (typeof r === "string") {
+          if (m._$$tag$$_ === "slot-fb") {
+            addSlot(r, p[2], m, l, e, t, n, s, u);
+          }
+          m._$$elm$$_["s-sn"] = r;
+          m._$$elm$$_.removeAttribute("s-sn");
+        }
+        if (m._$$index$$_ !== void 0) {
+          e._$$children$$_[m._$$index$$_] = m;
+        }
+        if (y) l["s-si"] = y;
+        e = m;
+        if (s && m._$$depth$$_ === "0") {
+          s[m._$$index$$_] = m._$$elm$$_;
+        }
+      }
+    }
+    if (l.shadowRoot) {
+      for ($ = l.shadowRoot.childNodes.length - 1; $ >= 0; $--) {
+        clientHydrate(e, t, n, s, r, l.shadowRoot.childNodes[$], i, u);
+      }
+    }
+    const o = l.__childNodes || l.childNodes;
+    for ($ = o.length - 1; $ >= 0; $--) {
+      clientHydrate(e, t, n, s, r, o[$], i, u);
+    }
+  } else if (l.nodeType === 8 /* CommentNode */) {
+    p = l.nodeValue.split(".");
+    if (p[1] === i || p[1] === "0") {
+      d = p[0];
+      m = createSimpleVNode({
+        _$$hostId$$_: p[1],
+        _$$nodeId$$_: p[2],
+        _$$depth$$_: p[3],
+        _$$index$$_: p[4] || "0",
+        _$$elm$$_: l,
+        _$$attrs$$_: null,
+        _$$children$$_: null,
+        _$$key$$_: null,
+        _$$name$$_: null,
+        _$$tag$$_: null,
+        _$$text$$_: null
+      });
+      if (d === f) {
+        m._$$elm$$_ = l.nextSibling;
+        if (m._$$elm$$_ && m._$$elm$$_.nodeType === 3 /* TextNode */) {
+          m._$$text$$_ = m._$$elm$$_.textContent;
+          t.push(m);
+          l.remove();
+          if (i === m._$$hostId$$_) {
+            if (!e._$$children$$_) {
+              e._$$children$$_ = [];
+            }
+            e._$$children$$_[m._$$index$$_] = m;
+          }
+          if (s && m._$$depth$$_ === "0") {
+            s[m._$$index$$_] = m._$$elm$$_;
+          }
+        }
+      } else if (d === c) {
+        m._$$elm$$_ = l.nextSibling;
+        if (m._$$elm$$_ && m._$$elm$$_.nodeType === 8 /* CommentNode */) {
+          t.push(m);
+          l.remove();
+        }
+      } else if (m._$$hostId$$_ === i) {
+        if (d === a) {
+          m._$$tag$$_ = "slot";
+          const r = l["s-sn"] = m._$$name$$_ = p[5] || "";
+          addSlot(r, p[2], m, l, e, t, n, s, u);
+        } else if (d === o) {
+          if (s) {
+            l.remove();
+          }
+        }
+      }
+    }
+  } else if (e && e._$$tag$$_ === "style") {
+    const t = newVNode(null, l.textContent);
+    t._$$elm$$_ = l;
+    t._$$index$$_ = "0";
+    e._$$children$$_ = [ t ];
+  }
+  return e;
+};
+
+var initializeDocumentHydrate = (e, t) => {
+  if (e.nodeType === 1 /* ElementNode */) {
+    const n = e[u] || e.getAttribute(u);
+    if (n) {
+      t.set(n, e);
+    }
+    let s = 0;
+    if (e.shadowRoot) {
+      for (;s < e.shadowRoot.childNodes.length; s++) {
+        initializeDocumentHydrate(e.shadowRoot.childNodes[s], t);
+      }
+    }
+    const r = e.__childNodes || e.childNodes;
+    for (s = 0; s < r.length; s++) {
+      initializeDocumentHydrate(r[s], t);
+    }
+  } else if (e.nodeType === 8 /* CommentNode */) {
+    const n = e.nodeValue.split(".");
+    if (n[0] === i) {
+      t.set(n[1] + "." + n[2], e);
+      e.nodeValue = "";
+      e["s-en"] = n[3];
+    }
+  }
+};
+
+var createSimpleVNode = e => {
+  const t = {
+    _$$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 {
+    ...t,
+    ...e
+  };
+};
+
+function addSlot(e, t, n, s, r, l, o, i, a) {
+  s["s-sr"] = true;
+  const f = (r == null ? void 0 : r._$$elm$$_) ? r._$$elm$$_["s-id"] || r._$$elm$$_.getAttribute("s-id") : "";
+  if (i) {
+    const l = n._$$elm$$_ = w.createElement(n._$$tag$$_);
+    if (n._$$name$$_) {
+      n._$$elm$$_.setAttribute("name", e);
+    }
+    if (f && f !== n._$$hostId$$_) {
+      r._$$elm$$_.insertBefore(l, r._$$elm$$_.children[0]);
+    } else {
+      s.parentNode.insertBefore(n._$$elm$$_, s);
+    }
+    addSlottedNodes(a, t, e, s, n._$$hostId$$_);
+    s.remove();
+    if (n._$$depth$$_ === "0") {
+      i[n._$$index$$_] = n._$$elm$$_;
+    }
+  } else {
+    const o = n._$$elm$$_;
+    const i = f && f !== n._$$hostId$$_ && r._$$elm$$_.shadowRoot;
+    addSlottedNodes(a, t, e, s, i ? f : n._$$hostId$$_);
+    if (i) {
+      r._$$elm$$_.insertBefore(o, r._$$elm$$_.children[0]);
+    }
+    l.push(n);
+  }
+  o.push(n);
+  if (!r._$$children$$_) {
+    r._$$children$$_ = [];
+  }
+  r._$$children$$_[n._$$index$$_] = n;
+}
+
+var addSlottedNodes = (e, t, n, s, r) => {
+  let l = s.nextSibling;
+  e[t] = e[t] || [];
+  while (l && ((l["getAttribute"] && l.getAttribute("slot") || l["s-sn"]) === n || n === "" && !l["s-sn"] && (l.nodeType === 8 /* CommentNode */ && l.nodeValue.indexOf(".") !== 1 || l.nodeType === 3 /* TextNode */))) {
+    l["s-sn"] = n;
+    e[t].push({
+      slot: s,
+      node: l,
+      hostId: r
+    });
+    l = l.nextSibling;
+  }
+};
+
+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 => getHostRef(e).$hostElement$
+// src/runtime/event-emitter.ts
+;
+
+var createEvent = (e, t, n) => {
+  const s = getElement(e);
+  return {
+    emit: e => emitEvent(s, t, {
+      bubbles: !!(n & 4 /* Bubbles */),
+      composed: !!(n & 2 /* Composed */),
+      cancelable: !!(n & 1 /* Cancellable */),
+      detail: e
+    })
+  };
+};
+
+var emitEvent = (e, t, n) => {
+  const s = S.ce(t, n);
+  e.dispatchEvent(s);
+  return s;
+};
+
+var q =  new WeakMap;
+
+var registerStyle = (e, t, n) => {
+  let s = l.get(e);
+  if (x && n) {
+    s = s || new CSSStyleSheet;
+    if (typeof s === "string") {
+      s = t;
+    } else {
+      s.replaceSync(t);
+    }
+  } else {
+    s = t;
+  }
+  l.set(e, s);
+};
+
+var addStyle = (e, t, n) => {
+  var s;
+  const r = getScopeId(t);
+  const o = l.get(r);
+  e = e.nodeType === 11 /* DocumentFragment */ ? e : w;
+  if (o) {
+    if (typeof o === "string") {
+      e = e.head || e;
+      let n = q.get(e);
+      let l;
+      if (!n) {
+        q.set(e, n =  new Set);
+      }
+      if (!n.has(r)) {
+        if (e.host && (l = e.querySelector(`[${d}="${r}"]`))) {
+          l.innerHTML = o;
+        } else {
+          l = w.createElement("style");
+          l.innerHTML = o;
+          const n = (s = S._$$nonce$$_) != null ? s : queryNonceMetaTagContent(w);
+          if (n != null) {
+            l.setAttribute("nonce", n);
+          }
+          if (!(t._$$flags$$_ & 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);
+            } else if ("host" in e) {
+              if (x) {
+                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._$$flags$$_ & 1 /* shadowDomEncapsulation */ && e.nodeName !== "HEAD") {
+            e.insertBefore(l, null);
+          }
+        }
+        if (t._$$flags$$_ & 4 /* hasSlotRelocation */) {
+          l.innerHTML += m;
+        }
+        if (n) {
+          n.add(r);
+        }
+      }
+    } else if (!e.adoptedStyleSheets.includes(o)) {
+      e.adoptedStyleSheets = [ ...e.adoptedStyleSheets, o ];
+    }
+  }
+  return r;
+};
+
+var attachStyles = e => {
+  const t = e._$$cmpMeta$$_;
+  const n = e.$hostElement$;
+  const s = t._$$flags$$_;
+  const r = createTime("attachStyles", t._$$tagName$$_);
+  const l = addStyle(n.shadowRoot ? n.shadowRoot : n.getRootNode(), t);
+  if (s & 10 /* needsScopedEncapsulation */ && s & 2 /* scopedCssEncapsulation */) {
+    n["s-sc"] = l;
+    n.classList.add(l + "-h");
+  }
+  r();
+};
+
+var getScopeId = (e, t) => "sc-" + e._$$tagName$$_
+// src/runtime/update-component.ts
+;
+
+var attachToAncestor = (e, t) => {
+  if (t && !e._$$onRenderResolve$$_ && t["s-p"]) {
+    t["s-p"].push(new Promise((t => e._$$onRenderResolve$$_ = t)));
+  }
+};
+
+var scheduleUpdate = (e, t) => {
+  {
+    e._$$flags$$_ |= 16 /* isQueuedForUpdate */;
+  }
+  if (e._$$flags$$_ & 4 /* isWaitingForChildren */) {
+    e._$$flags$$_ |= 512 /* needsRerender */;
+    return;
+  }
+  attachToAncestor(e, e._$$ancestorComponent$$_);
+  const dispatch = () => dispatchHooks(e, t);
+  return T(dispatch);
+};
+
+var dispatchHooks = (e, t) => {
+  const n = e.$hostElement$;
+  const s = createTime("scheduleUpdate", e._$$cmpMeta$$_._$$tagName$$_);
+  const r = e._$$lazyInstance$$_;
+  if (!r) {
+    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 l;
+  if (t) {
+    {
+      e._$$flags$$_ |= 256 /* isListenReady */;
+      if (e._$$queuedListeners$$_) {
+        e._$$queuedListeners$$_.map((([e, t]) => safeCall(r, e, t)));
+        e._$$queuedListeners$$_ = void 0;
+      }
+    }
+    emitLifecycleEvent(n, "componentWillLoad");
+    {
+      l = safeCall(r, "componentWillLoad");
+    }
+  } else {
+    emitLifecycleEvent(n, "componentWillUpdate");
+  }
+  emitLifecycleEvent(n, "componentWillRender");
+  s();
+  return enqueue(l, (() => updateComponent(e, r, 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 s;
+  const r = e.$hostElement$;
+  const l = createTime("update", e._$$cmpMeta$$_._$$tagName$$_);
+  const o = r["s-rc"];
+  if (n) {
+    attachStyles(e);
+  }
+  const i = createTime("render", e._$$cmpMeta$$_._$$tagName$$_);
+  {
+    callRender(e, t, r, n);
+  }
+  if (o) {
+    o.map((e => e()));
+    r["s-rc"] = void 0;
+  }
+  i();
+  l();
+  {
+    const t = (s = r["s-p"]) != null ? s : [];
+    const postUpdate = () => postUpdateComponent(e);
+    if (t.length === 0) {
+      postUpdate();
+    } else {
+      Promise.all(t).then(postUpdate);
+      e._$$flags$$_ |= 4 /* isWaitingForChildren */;
+      t.length = 0;
+    }
+  }
+};
+
+var callRender = (e, t, n, s) => {
+  try {
+    t = t.render();
+    {
+      e._$$flags$$_ &= ~16 /* isQueuedForUpdate */;
+    }
+    {
+      e._$$flags$$_ |= 2 /* hasRendered */;
+    }
+    {
+      {
+        {
+          renderVdom(e, t, s);
+        }
+      }
+    }
+  } catch (t) {
+    consoleError(t, e.$hostElement$);
+  }
+  return null;
+};
+
+var postUpdateComponent = e => {
+  const t = e._$$cmpMeta$$_._$$tagName$$_;
+  const n = e.$hostElement$;
+  const s = createTime("postUpdate", t);
+  const r = e._$$lazyInstance$$_;
+  const l = e._$$ancestorComponent$$_;
+  emitLifecycleEvent(n, "componentDidRender");
+  if (!(e._$$flags$$_ & 64 /* hasLoadedComponent */)) {
+    e._$$flags$$_ |= 64 /* hasLoadedComponent */;
+    {
+      addHydratedFlag(n);
+    }
+    {
+      safeCall(r, "componentDidLoad");
+    }
+    emitLifecycleEvent(n, "componentDidLoad");
+    s();
+    {
+      e._$$onReadyResolve$$_(n);
+      if (!l) {
+        appDidLoad();
+      }
+    }
+  } else {
+    emitLifecycleEvent(n, "componentDidUpdate");
+    s();
+  }
+  {
+    e._$$onInstanceResolve$$_(n);
+  }
+  {
+    if (e._$$onRenderResolve$$_) {
+      e._$$onRenderResolve$$_();
+      e._$$onRenderResolve$$_ = void 0;
+    }
+    if (e._$$flags$$_ & 512 /* needsRerender */) {
+      nextTick((() => scheduleUpdate(e, false)));
+    }
+    e._$$flags$$_ &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */);
+  }
+};
+
+var appDidLoad = t => {
+  {
+    addHydratedFlag(w.documentElement);
+  }
+  nextTick((() => emitEvent(b, "appload", {
+    detail: {
+      namespace: e
+    }
+  })));
+};
+
+var safeCall = (e, t, n) => {
+  if (e && e[t]) {
+    try {
+      return e[t](n);
+    } catch (e) {
+      consoleError(e);
+    }
+  }
+  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)._$$instanceValues$$_.get(t);
+
+var setValue = (e, t, n, s) => {
+  const r = getHostRef(e);
+  if (!r) {
+    throw new Error(`Couldn't find host element for "${s._$$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/ionic-team/stencil/issues/5457).`);
+  }
+  const l = r.$hostElement$;
+  const o = r._$$instanceValues$$_.get(t);
+  const i = r._$$flags$$_;
+  const a = r._$$lazyInstance$$_;
+  n = parsePropertyValue(n, s._$$members$$_[t][0]);
+  const f = Number.isNaN(o) && Number.isNaN(n);
+  const c = n !== o && !f;
+  if ((!(i & 8 /* isConstructingInstance */) || o === void 0) && c) {
+    r._$$instanceValues$$_.set(t, n);
+    if (a) {
+      if (s._$$watchers$$_ && i & 128 /* isWatchReady */) {
+        const e = s._$$watchers$$_[t];
+        if (e) {
+          e.map((e => {
+            try {
+              a[e](n, o, t);
+            } catch (e) {
+              consoleError(e, l);
+            }
+          }));
+        }
+      }
+      if ((i & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+        scheduleUpdate(r, false);
+      }
+    }
+  }
+};
+
+// src/runtime/proxy-component.ts
+var proxyComponent = (e, t, n) => {
+  var s, r;
+  const l = e.prototype;
+  if (t._$$flags$$_ & 64 /* formAssociated */ && n & 1 /* isElementConstructor */) {
+    y.forEach((e => {
+      Object.defineProperty(l, e, {
+        value(...t) {
+          const n = getHostRef(this);
+          const s = n._$$lazyInstance$$_;
+          if (!s) {
+            n._$$onReadyPromise$$_.then((n => {
+              const s = n[e];
+              typeof s === "function" && s.call(n, ...t);
+            }));
+          } else {
+            const n = s[e];
+            typeof n === "function" && n.call(s, ...t);
+          }
+        }
+      });
+    }));
+  }
+  if (t._$$members$$_ || (t._$$watchers$$_ || e.watchers)) {
+    if (e.watchers && !t._$$watchers$$_) {
+      t._$$watchers$$_ = e.watchers;
+    }
+    const o = Object.entries((s = t._$$members$$_) != null ? s : {});
+    o.map((([e, [s]]) => {
+      if (s & 31 /* Prop */ || n & 2 /* proxyState */ && s & 32 /* State */) {
+        if ((s & 2048 /* Getter */) === 0) {
+          Object.defineProperty(l, e, {
+            get() {
+              return getValue(this, e);
+            },
+            set(n) {
+              setValue(this, e, n, t);
+            },
+            configurable: true,
+            enumerable: true
+          });
+        } else if (n & 1 /* isElementConstructor */ && s & 2048 /* Getter */) {
+          {
+            Object.defineProperty(l, e, {
+              get() {
+                const t = getHostRef(this);
+                const n = t ? t._$$lazyInstance$$_ : l;
+                if (!n) return;
+                return n[e];
+              },
+              configurable: true,
+              enumerable: true
+            });
+          }
+          if (s & 4096 /* Setter */) {
+            const n = Object.getOwnPropertyDescriptor(l, e).set;
+            Object.defineProperty(l, e, {
+              set(s) {
+                const r = getHostRef(this);
+                if (n) {
+                  const l = r.$hostElement$[e];
+                  if (!r._$$instanceValues$$_.get(e) && l) {
+                    r._$$instanceValues$$_.set(e, l);
+                  }
+                  n.apply(this, [ parsePropertyValue(s, t._$$members$$_[e][0]) ]);
+                  setValue(this, e, r.$hostElement$[e], t);
+                  return;
+                }
+                if (!r) return;
+                const setterSetVal = () => {
+                  const n = r._$$lazyInstance$$_[e];
+                  if (!r._$$instanceValues$$_.get(e) && n) {
+                    r._$$instanceValues$$_.set(e, n);
+                  }
+                  r._$$lazyInstance$$_[e] = parsePropertyValue(s, t._$$members$$_[e][0]);
+                  setValue(this, e, r._$$lazyInstance$$_[e], t);
+                };
+                if (r._$$lazyInstance$$_) {
+                  setterSetVal();
+                } else {
+                  r._$$onReadyPromise$$_.then((() => setterSetVal()));
+                }
+              }
+            });
+          }
+        }
+      } else if (n & 1 /* isElementConstructor */ && s & 64 /* Method */) {
+        Object.defineProperty(l, e, {
+          value(...t) {
+            var n;
+            const s = getHostRef(this);
+            return (n = s == null ? void 0 : s._$$onInstancePromise$$_) == null ? void 0 : n.then((() => {
+              var n;
+              return (n = s._$$lazyInstance$$_) == null ? void 0 : n[e](...t);
+            }));
+          }
+        });
+      }
+    }));
+    if (n & 1 /* isElementConstructor */) {
+      const n =  new Map;
+      l.attributeChangedCallback = function(e, s, r) {
+        S.jmp((() => {
+          var o;
+          const i = n.get(e);
+          if (this.hasOwnProperty(i)) {
+            r = this[i];
+            delete this[i];
+          } else if (l.hasOwnProperty(i) && typeof this[i] === "number" && // cast type to number to avoid TS compiler issues
+          this[i] == r) {
+            return;
+          } else if (i == null) {
+            const n = getHostRef(this);
+            const l = n == null ? void 0 : n._$$flags$$_;
+            if (l && !(l & 8 /* isConstructingInstance */) && l & 128 /* isWatchReady */ && r !== s) {
+              const l = n._$$lazyInstance$$_;
+              const i = (o = t._$$watchers$$_) == null ? void 0 : o[e];
+              i == null ? void 0 : i.forEach((t => {
+                if (l[t] != null) {
+                  l[t].call(l, r, s, e);
+                }
+              }));
+            }
+            return;
+          }
+          const a = Object.getOwnPropertyDescriptor(l, i);
+          if (!a.get || !!a.set) {
+            this[i] = r === null && typeof this[i] === "boolean" ? false : r;
+          }
+        }));
+      };
+      e.observedAttributes = Array.from(
+       new Set([ ...Object.keys((r = t._$$watchers$$_) != null ? r : {}), ...o.filter((([e, t]) => t[0] & 15 /* HasAttribute */)).map((([e, s]) => {
+        var r;
+        const l = s[1] || e;
+        n.set(l, e);
+        if (s[0] & 512 /* ReflectAttr */) {
+          (r = t._$$attrsToReflect$$_) == null ? void 0 : r.push([ e, l ]);
+        }
+        return l;
+      })) ]));
+    }
+  }
+  return e;
+};
+
+// src/runtime/initialize-component.ts
+var initializeComponent = async (e, t, n, s) => {
+  let r;
+  if ((t._$$flags$$_ & 32 /* hasInitializedComponent */) === 0) {
+    t._$$flags$$_ |= 32 /* hasInitializedComponent */;
+    const s = n._$$lazyBundleId$$_;
+    if (s) {
+      const e = loadModule(n);
+      if (e && "then" in e) {
+        const t = uniqueTime();
+        r = await e;
+        t();
+      } else {
+        r = e;
+      }
+      if (!r) {
+        throw new Error(`Constructor for "${n._$$tagName$$_}#${t._$$modeName$$_}" was not found`);
+      }
+      if (!r.isProxied) {
+        {
+          n._$$watchers$$_ = r.watchers;
+        }
+        proxyComponent(r, n, 2 /* proxyState */);
+        r.isProxied = true;
+      }
+      const s = createTime("createInstance", n._$$tagName$$_);
+      {
+        t._$$flags$$_ |= 8 /* isConstructingInstance */;
+      }
+      try {
+        new r(t);
+      } catch (e) {
+        consoleError(e);
+      }
+      {
+        t._$$flags$$_ &= ~8 /* isConstructingInstance */;
+      }
+      {
+        t._$$flags$$_ |= 128 /* isWatchReady */;
+      }
+      s();
+      fireConnectedCallback(t._$$lazyInstance$$_);
+    } else {
+      r = e.constructor;
+      const n = e.localName;
+      customElements.whenDefined(n).then((() => t._$$flags$$_ |= 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 s = createTime("registerStyles", n._$$tagName$$_);
+        registerStyle(t, e, !!(n._$$flags$$_ & 1 /* shadowDomEncapsulation */));
+        s();
+      }
+    }
+  }
+  const o = t._$$ancestorComponent$$_;
+  const schedule = () => scheduleUpdate(t, true);
+  if (o && o["s-rc"]) {
+    o["s-rc"].push(schedule);
+  } else {
+    schedule();
+  }
+};
+
+var fireConnectedCallback = e => {
+  {
+    safeCall(e, "connectedCallback");
+  }
+};
+
+// src/runtime/connected-callback.ts
+var connectedCallback = e => {
+  if ((S._$$flags$$_ & 1 /* isTmpDisconnected */) === 0) {
+    const t = getHostRef(e);
+    const n = t._$$cmpMeta$$_;
+    const s = createTime("connectedCallback", n._$$tagName$$_);
+    if (!(t._$$flags$$_ & 1 /* hasConnected */)) {
+      t._$$flags$$_ |= 1 /* hasConnected */;
+      let s;
+      {
+        s = e.getAttribute(u);
+        if (s) {
+          if (n._$$flags$$_ & 1 /* shadowDomEncapsulation */) {
+            const t = addStyle(e.shadowRoot, n);
+            e.classList.remove(t + "-h", t + "-s");
+          }
+          initializeClientHydrate(e, n._$$tagName$$_, s, t);
+        }
+      }
+      {
+        let n = e;
+        while (n = n.parentNode || n.host) {
+          if (n.nodeType === 1 /* ElementNode */ && n.hasAttribute("s-id") && n["s-p"] || n["s-p"]) {
+            attachToAncestor(t, t._$$ancestorComponent$$_ = n);
+            break;
+          }
+        }
+      }
+      if (n._$$members$$_) {
+        Object.entries(n._$$members$$_).map((([t, [n]]) => {
+          if (n & 31 /* Prop */ && e.hasOwnProperty(t)) {
+            const n = e[t];
+            delete e[t];
+            e[t] = n;
+          }
+        }));
+      }
+      {
+        initializeComponent(e, t, n);
+      }
+    } else {
+      addHostEventListeners(e, t, n._$$listeners$$_);
+      if (t == null ? void 0 : t._$$lazyInstance$$_) {
+        fireConnectedCallback(t._$$lazyInstance$$_);
+      } else if (t == null ? void 0 : t._$$onReadyPromise$$_) {
+        t._$$onReadyPromise$$_.then((() => fireConnectedCallback(t._$$lazyInstance$$_)));
+      }
+    }
+    s();
+  }
+};
+
+var disconnectInstance = e => {
+  {
+    safeCall(e, "disconnectedCallback");
+  }
+};
+
+var disconnectedCallback = async e => {
+  if ((S._$$flags$$_ & 1 /* isTmpDisconnected */) === 0) {
+    const t = getHostRef(e);
+    {
+      if (t._$$rmListeners$$_) {
+        t._$$rmListeners$$_.map((e => e()));
+        t._$$rmListeners$$_ = void 0;
+      }
+    }
+    if (t == null ? void 0 : t._$$lazyInstance$$_) {
+      disconnectInstance(t._$$lazyInstance$$_);
+    } else if (t == null ? void 0 : t._$$onReadyPromise$$_) {
+      t._$$onReadyPromise$$_.then((() => disconnectInstance(t._$$lazyInstance$$_)));
+    }
+  }
+};
+
+// src/runtime/bootstrap-lazy.ts
+var bootstrapLazy = (e, t = {}) => {
+  var n;
+  const s = createTime();
+  const r = [];
+  const l = t.exclude || [];
+  const o = b.customElements;
+  const i = w.head;
+  const a =  i.querySelector("meta[charset]");
+  const f =  w.createElement("style");
+  const c = [];
+  let u;
+  let d = true;
+  Object.assign(S, t);
+  S._$$resourcesUrl$$_ = new URL(t.resourcesUrl || "./", w.baseURI).href;
+  {
+    S._$$flags$$_ |= 2 /* appLoaded */;
+  }
+  let v = false;
+  e.map((e => {
+    e[1].map((t => {
+      var n;
+      const s = {
+        _$$flags$$_: t[0],
+        _$$tagName$$_: t[1],
+        _$$members$$_: t[2],
+        _$$listeners$$_: t[3]
+      };
+      if (s._$$flags$$_ & 4 /* hasSlotRelocation */) {
+        v = true;
+      }
+      {
+        s._$$members$$_ = t[2];
+      }
+      {
+        s._$$listeners$$_ = t[3];
+      }
+      {
+        s._$$attrsToReflect$$_ = [];
+      }
+      {
+        s._$$watchers$$_ = (n = t[4]) != null ? n : {};
+      }
+      const i = s._$$tagName$$_;
+      const a = class extends HTMLElement {
+        // StencilLazyHost
+        constructor(e) {
+          super(e);
+          this.hasRegisteredEventListeners = false;
+          e = this;
+          registerHost(e, s);
+          if (s._$$flags$$_ & 1 /* shadowDomEncapsulation */) {
+            {
+              if (!e.shadowRoot) {
+                {
+                  e.attachShadow({
+                    mode: "open"
+                  });
+                }
+              } else {
+                if (e.shadowRoot.mode !== "open") {
+                  throw new Error(`Unable to re-use existing shadow root for ${s._$$tagName$$_}! Mode is set to ${e.shadowRoot.mode} but Stencil only supports open shadow roots.`);
+                }
+              }
+            }
+          }
+        }
+        connectedCallback() {
+          const e = getHostRef(this);
+          if (!this.hasRegisteredEventListeners) {
+            this.hasRegisteredEventListeners = true;
+            addHostEventListeners(this, e, s._$$listeners$$_);
+          }
+          if (u) {
+            clearTimeout(u);
+            u = null;
+          }
+          if (d) {
+            c.push(this);
+          } else {
+            S.jmp((() => connectedCallback(this)));
+          }
+        }
+        disconnectedCallback() {
+          S.jmp((() => disconnectedCallback(this)));
+        }
+        componentOnReady() {
+          return getHostRef(this)._$$onReadyPromise$$_;
+        }
+      };
+      {
+        {
+          patchCloneNode(a.prototype);
+        }
+        {
+          patchSlotAppendChild(a.prototype);
+        }
+      }
+      if (s._$$flags$$_ & 64 /* formAssociated */) {
+        a.formAssociated = true;
+      }
+      s._$$lazyBundleId$$_ = e[0];
+      if (!l.includes(i) && !o.get(i)) {
+        r.push(i);
+        o.define(i, proxyComponent(a, s, 1 /* isElementConstructor */));
+      }
+    }));
+  }));
+  if (r.length > 0) {
+    if (v) {
+      f.textContent += m;
+    }
+    {
+      f.textContent += r.sort() + p;
+    }
+    if (f.innerHTML.length) {
+      f.setAttribute("data-styles", "");
+      const e = (n = S._$$nonce$$_) != null ? n : queryNonceMetaTagContent(w);
+      if (e != null) {
+        f.setAttribute("nonce", e);
+      }
+      i.insertBefore(f, a ? a.nextSibling : i.firstChild);
+    }
+  }
+  d = false;
+  if (c.length) {
+    c.map((e => e.connectedCallback()));
+  } else {
+    {
+      S.jmp((() => u = setTimeout(appDidLoad, 30)));
+    }
+  }
+  s();
+};
+
+var addHostEventListeners = (e, t, n, s) => {
+  if (n) {
+    n.map((([n, s, r]) => {
+      const l = getHostListenerTarget(e, n);
+      const o = hostListenerProxy(t, r);
+      const i = hostListenerOpts(n);
+      S.ael(l, s, o, i);
+      (t._$$rmListeners$$_ = t._$$rmListeners$$_ || []).push((() => S.rel(l, s, o, i)));
+    }));
+  }
+};
+
+var hostListenerProxy = (e, t) => n => {
+  var s;
+  try {
+    {
+      if (e._$$flags$$_ & 256 /* isListenReady */) {
+        (s = e._$$lazyInstance$$_) == null ? void 0 : s[t](n);
+      } else {
+        (e._$$queuedListeners$$_ = e._$$queuedListeners$$_ || []).push([ t, n ]);
+      }
+    }
+  } catch (e) {
+    consoleError(e);
+  }
+};
+
+var getHostListenerTarget = (e, t) => {
+  if (t & 4 /* TargetDocument */) return w;
+  if (t & 8 /* TargetWindow */) return b;
+  return e;
+};
+
+var hostListenerOpts = e => C ? {
+  passive: (e & 1 /* Passive */) !== 0,
+  capture: (e & 2 /* Capture */) !== 0
+} : (e & 2 /* Capture */) !== 0
+// src/runtime/nonce.ts
+;
+
+var setNonce = e => S._$$nonce$$_ = e;
+
+export { g as H, A as a, bootstrapLazy as b, createEvent as c, getElement as g, h, promiseResolve as p, registerInstance as r, setNonce as s };
+//# sourceMappingURL=p-bde61e4e.js.map