q2-tecton-elements 1.51.1 → 1.52.1

package/dist/q2-tecton-elements/index-7a5365e2.js

@@ -0,0 +1,1792 @@
+const e = "q2-tecton-elements";
+
+const t = /* q2-tecton-elements */ {
+  allRenderFn: false,
+  appendChildSlotFix: false,
+  asyncLoading: true,
+  asyncQueue: false,
+  attachStyles: true,
+  cloneNodeFix: false,
+  cmpDidLoad: true,
+  cmpDidRender: true,
+  cmpDidUnload: false,
+  cmpDidUpdate: true,
+  cmpShouldUpdate: true,
+  cmpWillLoad: true,
+  cmpWillRender: true,
+  cmpWillUpdate: true,
+  connectedCallback: true,
+  constructableCSS: true,
+  cssAnnotations: true,
+  devTools: false,
+  disconnectedCallback: true,
+  element: false,
+  event: true,
+  experimentalScopedSlotChanges: false,
+  experimentalSlotFixes: false,
+  formAssociated: false,
+  hasRenderFn: true,
+  hostListener: true,
+  hostListenerTarget: true,
+  hostListenerTargetBody: false,
+  hostListenerTargetDocument: false,
+  hostListenerTargetParent: false,
+  hostListenerTargetWindow: true,
+  hotModuleReplacement: false,
+  hydrateClientSide: false,
+  hydrateServerSide: false,
+  hydratedAttribute: true,
+  hydratedClass: false,
+  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: true,
+  state: true,
+  style: true,
+  svg: true,
+  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.18.0 | MIT Licensed | https://stenciljs.com
+ */ var r = Object.defineProperty;
+
+var __export = (e, t) => {
+  for (var l in t) r(e, l, {
+    get: t[l],
+    enumerable: true
+  });
+};
+
+// src/runtime/asset-path.ts
+var getAssetPath = e => {
+  const t = new URL(e, L._$$resourcesUrl$$_);
+  return t.origin !== T.location.origin ? t.href : t.pathname;
+};
+
+// src/utils/constants.ts
+var l = {};
+
+var n = "http://www.w3.org/2000/svg";
+
+var s = "http://www.w3.org/1999/xhtml";
+
+// 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, r, l;
+  return (l = (r = (t = e.head) == null ? void 0 : t.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : r.getAttribute("content")) != null ? l : void 0;
+}
+
+// src/utils/result.ts
+var o = {};
+
+__export(o, {
+  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 r = t(e.value);
+    if (r instanceof Promise) {
+      return r.then((e => ok(e)));
+    } else {
+      return ok(r);
+    }
+  }
+  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 createTime = (e, t = "") => {
+  {
+    return () => {};
+  }
+};
+
+var uniqueTime = (e, t) => {
+  {
+    return () => {};
+  }
+};
+
+var i = "{visibility:hidden}[stencil-hydrated]{visibility:inherit}";
+
+var a = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+
+var f = "http://www.w3.org/1999/xlink";
+
+var h = (e, t, ...r) => {
+  let l = null;
+  let n = null;
+  let s = null;
+  let o = false;
+  let i = false;
+  const a = [];
+  const walk = t => {
+    for (let r = 0; r < t.length; r++) {
+      l = t[r];
+      if (Array.isArray(l)) {
+        walk(l);
+      } else if (l != null && typeof l !== "boolean") {
+        if (o = typeof e !== "function" && !isComplexType(l)) {
+          l = String(l);
+        }
+        if (o && i) {
+          a[a.length - 1]._$$text$$_ += l;
+        } else {
+          a.push(o ? newVNode(null, l) : l);
+        }
+        i = o;
+      }
+    }
+  };
+  walk(r);
+  if (t) {
+    if (t.key) {
+      n = t.key;
+    }
+    if (t.name) {
+      s = t.name;
+    }
+    {
+      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, a, u);
+  }
+  const f = newVNode(e, null);
+  f._$$attrs$$_ = t;
+  if (a.length > 0) {
+    f._$$children$$_ = a;
+  }
+  {
+    f._$$key$$_ = n;
+  }
+  {
+    f._$$name$$_ = s;
+  }
+  return f;
+};
+
+var newVNode = (e, t) => {
+  const r = {
+    _$$flags$$_: 0,
+    _$$tag$$_: e,
+    _$$text$$_: t,
+    _$$elm$$_: null,
+    _$$children$$_: null
+  };
+  {
+    r._$$attrs$$_ = null;
+  }
+  {
+    r._$$key$$_ = null;
+  }
+  {
+    r._$$name$$_ = null;
+  }
+  return r;
+};
+
+var c = {};
+
+var isHost = e => e && e._$$tag$$_ === c;
+
+var u = {
+  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 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, r) => {
+  const l = getElement(e);
+  return {
+    emit: e => emitEvent(l, t, {
+      bubbles: !!(r & 4 /* Bubbles */),
+      composed: !!(r & 2 /* Composed */),
+      cancelable: !!(r & 1 /* Cancellable */),
+      detail: e
+    })
+  };
+};
+
+var emitEvent = (e, t, r) => {
+  const l = L.ce(t, r);
+  e.dispatchEvent(l);
+  return l;
+};
+
+var v =  new WeakMap;
+
+var registerStyle = (e, t, r) => {
+  let l = R.get(e);
+  if (N && r) {
+    l = l || new CSSStyleSheet;
+    if (typeof l === "string") {
+      l = t;
+    } else {
+      l.replaceSync(t);
+    }
+  } else {
+    l = t;
+  }
+  R.set(e, l);
+};
+
+var addStyle = (e, t, r) => {
+  var l;
+  const n = getScopeId(t);
+  const s = R.get(n);
+  e = e.nodeType === 11 /* DocumentFragment */ ? e : x;
+  if (s) {
+    if (typeof s === "string") {
+      e = e.head || e;
+      let r = v.get(e);
+      let o;
+      if (!r) {
+        v.set(e, r =  new Set);
+      }
+      if (!r.has(n)) {
+        {
+          o = x.createElement("style");
+          o.innerHTML = s;
+          const t = (l = L._$$nonce$$_) != null ? l : queryNonceMetaTagContent(x);
+          if (t != null) {
+            o.setAttribute("nonce", t);
+          }
+          e.insertBefore(o, e.querySelector("link"));
+        }
+        if (t._$$flags$$_ & 4 /* hasSlotRelocation */) {
+          o.innerHTML += a;
+        }
+        if (r) {
+          r.add(n);
+        }
+      }
+    } else if (!e.adoptedStyleSheets.includes(s)) {
+      e.adoptedStyleSheets = [ ...e.adoptedStyleSheets, s ];
+    }
+  }
+  return n;
+};
+
+var attachStyles = e => {
+  const t = e._$$cmpMeta$$_;
+  const r = e.$hostElement$;
+  const l = t._$$flags$$_;
+  const n = createTime("attachStyles", t._$$tagName$$_);
+  const s = addStyle(r.shadowRoot ? r.shadowRoot : r.getRootNode(), t);
+  if (l & 10 /* needsScopedEncapsulation */) {
+    r["s-sc"] = s;
+    r.classList.add(s + "-h");
+  }
+  n();
+};
+
+var getScopeId = (e, t) => "sc-" + e._$$tagName$$_;
+
+var setAccessor = (e, t, r, l, n, s) => {
+  if (r !== l) {
+    let o = isMemberInElement(e, t);
+    let i = t.toLowerCase();
+    if (t === "class") {
+      const t = e.classList;
+      const n = parseClassList(r);
+      const s = parseClassList(l);
+      t.remove(...n.filter((e => e && !s.includes(e))));
+      t.add(...s.filter((e => e && !n.includes(e))));
+    } else if (t === "style") {
+      {
+        for (const t in r) {
+          if (!l || l[t] == null) {
+            if (t.includes("-")) {
+              e.style.removeProperty(t);
+            } else {
+              e.style[t] = "";
+            }
+          }
+        }
+      }
+      for (const t in l) {
+        if (!r || l[t] !== r[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 (!o && t[0] === "o" && t[1] === "n") {
+      if (t[2] === "-") {
+        t = t.slice(3);
+      } else if (isMemberInElement(T, i)) {
+        t = i.slice(2);
+      } else {
+        t = i[2] + t.slice(3);
+      }
+      if (r || l) {
+        const n = t.endsWith(p);
+        t = t.replace(m, "");
+        if (r) {
+          L.rel(e, t, r, n);
+        }
+        if (l) {
+          L.ael(e, t, l, n);
+        }
+      }
+    } else {
+      const a = isComplexType(l);
+      if ((o || a && l !== null) && !n) {
+        try {
+          if (!e.tagName.includes("-")) {
+            const n = l == null ? "" : l;
+            if (t === "list") {
+              o = false;
+            } else if (r == null || e[t] != n) {
+              e[t] = n;
+            }
+          } else {
+            e[t] = l;
+          }
+        } catch (e) {}
+      }
+      let c = false;
+      {
+        if (i !== (i = i.replace(/^xlink\:?/, ""))) {
+          t = i;
+          c = true;
+        }
+      }
+      if (l == null || l === false) {
+        if (l !== false || e.getAttribute(t) === "") {
+          if (c) {
+            e.removeAttributeNS(f, t);
+          } else {
+            e.removeAttribute(t);
+          }
+        }
+      } else if ((!o || s & 4 /* isHost */ || n) && !a) {
+        l = l === true ? "" : l;
+        if (c) {
+          e.setAttributeNS(f, t, l);
+        } else {
+          e.setAttribute(t, l);
+        }
+      }
+    }
+  }
+};
+
+var d = /\s/;
+
+var parseClassList = e => !e ? [] : e.split(d);
+
+var p = "Capture";
+
+var m = new RegExp(p + "$");
+
+// src/runtime/vdom/update-element.ts
+var updateElement = (e, t, r) => {
+  const n = t._$$elm$$_.nodeType === 11 /* DocumentFragment */ && t._$$elm$$_.host ? t._$$elm$$_.host : t._$$elm$$_;
+  const s = e && e._$$attrs$$_ || l;
+  const o = t._$$attrs$$_ || l;
+  {
+    for (const e of sortedAttrNames(Object.keys(s))) {
+      if (!(e in o)) {
+        setAccessor(n, e, s[e], void 0, r, t._$$flags$$_);
+      }
+    }
+  }
+  for (const e of sortedAttrNames(Object.keys(o))) {
+    setAccessor(n, e, s[e], o[e], r, 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 y;
+
+var b;
+
+var w;
+
+var g = false;
+
+var $ = false;
+
+var S = false;
+
+var k = false;
+
+var createElm = (e, t, r, l) => {
+  var o;
+  const i = t._$$children$$_[r];
+  let a = 0;
+  let f;
+  let c;
+  let u;
+  if (!g) {
+    S = true;
+    if (i._$$tag$$_ === "slot") {
+      if (y) {
+        l.classList.add(y + "-s");
+      }
+      i._$$flags$$_ |= i._$$children$$_ ? 
+      // slot element has fallback content
+      // still create an element that "mocks" the slot element
+      2 /* isSlotFallback */ : 
+      // slot element does not have fallback content
+      // create an html comment we'll use to always reference
+      // where actual slot content should sit next to
+      1 /* isSlotReference */;
+    }
+  }
+  if (i._$$text$$_ !== null) {
+    f = i._$$elm$$_ = x.createTextNode(i._$$text$$_);
+  } else if (i._$$flags$$_ & 1 /* isSlotReference */) {
+    f = i._$$elm$$_ = slotReferenceDebugNode(i);
+  } else {
+    if (!k) {
+      k = i._$$tag$$_ === "svg";
+    }
+    f = i._$$elm$$_ = x.createElementNS(k ? n : s, i._$$flags$$_ & 2 /* isSlotFallback */ ? "slot-fb" : i._$$tag$$_);
+    if (k && i._$$tag$$_ === "foreignObject") {
+      k = false;
+    }
+    {
+      updateElement(null, i, k);
+    }
+    if (isDef(y) && f["s-si"] !== y) {
+      f.classList.add(f["s-si"] = y);
+    }
+    if (i._$$children$$_) {
+      for (a = 0; a < i._$$children$$_.length; ++a) {
+        c = createElm(e, i, a, f);
+        if (c) {
+          f.appendChild(c);
+        }
+      }
+    }
+    {
+      if (i._$$tag$$_ === "svg") {
+        k = false;
+      } else if (f.tagName === "foreignObject") {
+        k = true;
+      }
+    }
+  }
+  f["s-hn"] = w;
+  {
+    if (i._$$flags$$_ & (2 /* isSlotFallback */ | 1 /* isSlotReference */)) {
+      f["s-sr"] = true;
+      f["s-cr"] = b;
+      f["s-sn"] = i._$$name$$_ || "";
+      f["s-rf"] = (o = i._$$attrs$$_) == null ? void 0 : o.ref;
+      u = e && e._$$children$$_ && e._$$children$$_[r];
+      if (u && u._$$tag$$_ === i._$$tag$$_ && e._$$elm$$_) {
+        {
+          putBackInOriginalLocation(e._$$elm$$_, false);
+        }
+      }
+    }
+  }
+  return f;
+};
+
+var putBackInOriginalLocation = (e, r) => {
+  L._$$flags$$_ |= 1 /* isTmpDisconnected */;
+  const l = Array.from(e.childNodes);
+  if (e["s-sr"] && t.experimentalSlotFixes) {
+    let t = e;
+    while (t = t.nextSibling) {
+      if (t && t["s-sn"] === e["s-sn"] && t["s-sh"] === w) {
+        l.push(t);
+      }
+    }
+  }
+  for (let e = l.length - 1; e >= 0; e--) {
+    const t = l[e];
+    if (t["s-hn"] !== w && t["s-ol"]) {
+      parentReferenceNode(t).insertBefore(t, referenceNode(t));
+      t["s-ol"].remove();
+      t["s-ol"] = void 0;
+      t["s-sh"] = void 0;
+      S = true;
+    }
+    if (r) {
+      putBackInOriginalLocation(t, r);
+    }
+  }
+  L._$$flags$$_ &= ~1 /* isTmpDisconnected */;
+};
+
+var addVnodes = (e, t, r, l, n, s) => {
+  let o = e["s-cr"] && e["s-cr"].parentNode || e;
+  let i;
+  if (o.shadowRoot && o.tagName === w) {
+    o = o.shadowRoot;
+  }
+  for (;n <= s; ++n) {
+    if (l[n]) {
+      i = createElm(null, r, n, e);
+      if (i) {
+        l[n]._$$elm$$_ = i;
+        o.insertBefore(i, referenceNode(t));
+      }
+    }
+  }
+};
+
+var removeVnodes = (e, t, r) => {
+  for (let l = t; l <= r; ++l) {
+    const t = e[l];
+    if (t) {
+      const e = t._$$elm$$_;
+      nullifyVNodeRefs(t);
+      if (e) {
+        {
+          $ = true;
+          if (e["s-ol"]) {
+            e["s-ol"].remove();
+          } else {
+            putBackInOriginalLocation(e, true);
+          }
+        }
+        e.remove();
+      }
+    }
+  }
+};
+
+var updateChildren = (e, t, r, l, n = false) => {
+  let s = 0;
+  let o = 0;
+  let i = 0;
+  let a = 0;
+  let f = t.length - 1;
+  let c = t[0];
+  let u = t[f];
+  let v = l.length - 1;
+  let d = l[0];
+  let p = l[v];
+  let m;
+  let y;
+  while (s <= f && o <= v) {
+    if (c == null) {
+      c = t[++s];
+    } else if (u == null) {
+      u = t[--f];
+    } else if (d == null) {
+      d = l[++o];
+    } else if (p == null) {
+      p = l[--v];
+    } else if (isSameVnode(c, d, n)) {
+      patch(c, d, n);
+      c = t[++s];
+      d = l[++o];
+    } else if (isSameVnode(u, p, n)) {
+      patch(u, p, n);
+      u = t[--f];
+      p = l[--v];
+    } else if (isSameVnode(c, p, n)) {
+      if (c._$$tag$$_ === "slot" || p._$$tag$$_ === "slot") {
+        putBackInOriginalLocation(c._$$elm$$_.parentNode, false);
+      }
+      patch(c, p, n);
+      e.insertBefore(c._$$elm$$_, u._$$elm$$_.nextSibling);
+      c = t[++s];
+      p = l[--v];
+    } else if (isSameVnode(u, d, n)) {
+      if (c._$$tag$$_ === "slot" || p._$$tag$$_ === "slot") {
+        putBackInOriginalLocation(u._$$elm$$_.parentNode, false);
+      }
+      patch(u, d, n);
+      e.insertBefore(u._$$elm$$_, c._$$elm$$_);
+      u = t[--f];
+      d = l[++o];
+    } else {
+      i = -1;
+      {
+        for (a = s; a <= f; ++a) {
+          if (t[a] && t[a]._$$key$$_ !== null && t[a]._$$key$$_ === d._$$key$$_) {
+            i = a;
+            break;
+          }
+        }
+      }
+      if (i >= 0) {
+        y = t[i];
+        if (y._$$tag$$_ !== d._$$tag$$_) {
+          m = createElm(t && t[o], r, i, e);
+        } else {
+          patch(y, d, n);
+          t[i] = void 0;
+          m = y._$$elm$$_;
+        }
+        d = l[++o];
+      } else {
+        m = createElm(t && t[o], r, o, e);
+        d = l[++o];
+      }
+      if (m) {
+        {
+          parentReferenceNode(c._$$elm$$_).insertBefore(m, referenceNode(c._$$elm$$_));
+        }
+      }
+    }
+  }
+  if (s > f) {
+    addVnodes(e, l[v + 1] == null ? null : l[v + 1]._$$elm$$_, r, l, o, v);
+  } else if (o > v) {
+    removeVnodes(t, s, f);
+  }
+};
+
+var isSameVnode = (e, t, r = false) => {
+  if (e._$$tag$$_ === t._$$tag$$_) {
+    if (e._$$tag$$_ === "slot") {
+      return e._$$name$$_ === t._$$name$$_;
+    }
+    if (!r) {
+      return e._$$key$$_ === t._$$key$$_;
+    }
+    return true;
+  }
+  return false;
+};
+
+var referenceNode = e => e && e["s-ol"] || e;
+
+var parentReferenceNode = e => (e["s-ol"] ? e["s-ol"] : e).parentNode;
+
+var patch = (e, t, r = false) => {
+  const l = t._$$elm$$_ = e._$$elm$$_;
+  const n = e._$$children$$_;
+  const s = t._$$children$$_;
+  const o = t._$$tag$$_;
+  const i = t._$$text$$_;
+  let a;
+  if (i === null) {
+    {
+      k = o === "svg" ? true : o === "foreignObject" ? false : k;
+    }
+    {
+      if (o === "slot" && !g) ; else {
+        updateElement(e, t, k);
+      }
+    }
+    if (n !== null && s !== null) {
+      updateChildren(l, n, t, s, r);
+    } else if (s !== null) {
+      if (e._$$text$$_ !== null) {
+        l.textContent = "";
+      }
+      addVnodes(l, null, t, s, 0, s.length - 1);
+    } else if (n !== null) {
+      removeVnodes(n, 0, n.length - 1);
+    }
+    if (k && o === "svg") {
+      k = false;
+    }
+  } else if (a = l["s-cr"]) {
+    a.parentNode.textContent = i;
+  } else if (e._$$text$$_ !== i) {
+    l.data = i;
+  }
+};
+
+var updateFallbackSlotVisibility = e => {
+  const t = e.childNodes;
+  for (const e of t) {
+    if (e.nodeType === 1 /* ElementNode */) {
+      if (e["s-sr"]) {
+        const r = e["s-sn"];
+        e.hidden = false;
+        for (const l of t) {
+          if (l !== e) {
+            if (l["s-hn"] !== e["s-hn"] || r !== "") {
+              if (l.nodeType === 1 /* ElementNode */ && (r === l.getAttribute("slot") || r === l["s-sn"]) || l.nodeType === 3 /* TextNode */ && r === l["s-sn"]) {
+                e.hidden = true;
+                break;
+              }
+            } else {
+              if (l.nodeType === 1 /* ElementNode */ || l.nodeType === 3 /* TextNode */ && l.textContent.trim() !== "") {
+                e.hidden = true;
+                break;
+              }
+            }
+          }
+        }
+      }
+      updateFallbackSlotVisibility(e);
+    }
+  }
+};
+
+var C = [];
+
+var markSlotContentForRelocation = e => {
+  let r;
+  let l;
+  let n;
+  for (const s of e.childNodes) {
+    if (s["s-sr"] && (r = s["s-cr"]) && r.parentNode) {
+      l = r.parentNode.childNodes;
+      const e = s["s-sn"];
+      for (n = l.length - 1; n >= 0; n--) {
+        r = l[n];
+        if (!r["s-cn"] && !r["s-nr"] && r["s-hn"] !== s["s-hn"] && !t.experimentalSlotFixes) {
+          if (isNodeLocatedInSlot(r, e)) {
+            let t = C.find((e => e._$$nodeToRelocate$$_ === r));
+            $ = true;
+            r["s-sn"] = r["s-sn"] || e;
+            if (t) {
+              t._$$nodeToRelocate$$_["s-sh"] = s["s-hn"];
+              t._$$slotRefNode$$_ = s;
+            } else {
+              r["s-sh"] = s["s-hn"];
+              C.push({
+                _$$slotRefNode$$_: s,
+                _$$nodeToRelocate$$_: r
+              });
+            }
+            if (r["s-sr"]) {
+              C.map((e => {
+                if (isNodeLocatedInSlot(e._$$nodeToRelocate$$_, r["s-sn"])) {
+                  t = C.find((e => e._$$nodeToRelocate$$_ === r));
+                  if (t && !e._$$slotRefNode$$_) {
+                    e._$$slotRefNode$$_ = t._$$slotRefNode$$_;
+                  }
+                }
+              }));
+            }
+          } else if (!C.some((e => e._$$nodeToRelocate$$_ === r))) {
+            C.push({
+              _$$nodeToRelocate$$_: r
+            });
+          }
+        }
+      }
+    }
+    if (s.nodeType === 1 /* ElementNode */) {
+      markSlotContentForRelocation(s);
+    }
+  }
+};
+
+var isNodeLocatedInSlot = (e, t) => {
+  if (e.nodeType === 1 /* ElementNode */) {
+    if (e.getAttribute("slot") === null && t === "") {
+      return true;
+    }
+    if (e.getAttribute("slot") === t) {
+      return true;
+    }
+    return false;
+  }
+  if (e["s-sn"] === t) {
+    return true;
+  }
+  return t === "";
+};
+
+var nullifyVNodeRefs = e => {
+  {
+    e._$$attrs$$_ && e._$$attrs$$_.ref && e._$$attrs$$_.ref(null);
+    e._$$children$$_ && e._$$children$$_.map(nullifyVNodeRefs);
+  }
+};
+
+var renderVdom = (e, t, r = false) => {
+  var l, n, s, o;
+  const i = e.$hostElement$;
+  const a = e._$$cmpMeta$$_;
+  const f = e._$$vnode$$_ || newVNode(null, null);
+  const c = isHost(t) ? t : h(null, null, t);
+  w = i.tagName;
+  if (a._$$attrsToReflect$$_) {
+    c._$$attrs$$_ = c._$$attrs$$_ || {};
+    a._$$attrsToReflect$$_.map((([e, t]) => c._$$attrs$$_[t] = i[e]));
+  }
+  if (r && c._$$attrs$$_) {
+    for (const e of Object.keys(c._$$attrs$$_)) {
+      if (i.hasAttribute(e) && ![ "key", "ref", "style", "class" ].includes(e)) {
+        c._$$attrs$$_[e] = i[e];
+      }
+    }
+  }
+  c._$$tag$$_ = null;
+  c._$$flags$$_ |= 4 /* isHost */;
+  e._$$vnode$$_ = c;
+  c._$$elm$$_ = f._$$elm$$_ = i.shadowRoot || i;
+  {
+    y = i["s-sc"];
+  }
+  g = (a._$$flags$$_ & 1 /* shadowDomEncapsulation */) !== 0;
+  {
+    b = i["s-cr"];
+    $ = false;
+  }
+  patch(f, c, r);
+  {
+    L._$$flags$$_ |= 1 /* isTmpDisconnected */;
+    if (S) {
+      markSlotContentForRelocation(c._$$elm$$_);
+      for (const e of C) {
+        const t = e._$$nodeToRelocate$$_;
+        if (!t["s-ol"]) {
+          const e = originalLocationDebugNode(t);
+          e["s-nr"] = t;
+          t.parentNode.insertBefore(t["s-ol"] = e, t);
+        }
+      }
+      for (const e of C) {
+        const t = e._$$nodeToRelocate$$_;
+        const i = e._$$slotRefNode$$_;
+        if (i) {
+          const e = i.parentNode;
+          let r = i.nextSibling;
+          {
+            let s = (l = t["s-ol"]) == null ? void 0 : l.previousSibling;
+            while (s) {
+              let l = (n = s["s-nr"]) != null ? n : null;
+              if (l && l["s-sn"] === t["s-sn"] && e === l.parentNode) {
+                l = l.nextSibling;
+                while (l === t || (l == null ? void 0 : l["s-sr"])) {
+                  l = l == null ? void 0 : l.nextSibling;
+                }
+                if (!l || !l["s-nr"]) {
+                  r = l;
+                  break;
+                }
+              }
+              s = s.previousSibling;
+            }
+          }
+          if (!r && e !== t.parentNode || t.nextSibling !== r) {
+            if (t !== r) {
+              if (!t["s-hn"] && t["s-ol"]) {
+                t["s-hn"] = t["s-ol"].parentNode.nodeName;
+              }
+              e.insertBefore(t, r);
+              if (t.nodeType === 1 /* ElementNode */) {
+                t.hidden = (s = t["s-ih"]) != null ? s : false;
+              }
+            }
+          }
+          t && typeof i["s-rf"] === "function" && i["s-rf"](t);
+        } else {
+          if (t.nodeType === 1 /* ElementNode */) {
+            if (r) {
+              t["s-ih"] = (o = t.hidden) != null ? o : false;
+            }
+            t.hidden = true;
+          }
+        }
+      }
+    }
+    if ($) {
+      updateFallbackSlotVisibility(c._$$elm$$_);
+    }
+    L._$$flags$$_ &= ~1 /* isTmpDisconnected */;
+    C.length = 0;
+  }
+  b = void 0;
+};
+
+var slotReferenceDebugNode = e => x.createComment(`<slot${e._$$name$$_ ? ' name="' + e._$$name$$_ + '"' : ""}> (host=${w.toLowerCase()})`);
+
+var originalLocationDebugNode = e => x.createComment(`org-location for ` + (e.localName ? `<${e.localName}> (host=${e["s-hn"]})` : `[${e.textContent}]`))
+// 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 F(dispatch);
+};
+
+var dispatchHooks = (e, t) => {
+  const r = e.$hostElement$;
+  const l = createTime("scheduleUpdate", e._$$cmpMeta$$_._$$tagName$$_);
+  const n = e._$$lazyInstance$$_;
+  let s;
+  if (t) {
+    {
+      e._$$flags$$_ |= 256 /* isListenReady */;
+      if (e._$$queuedListeners$$_) {
+        e._$$queuedListeners$$_.map((([e, t]) => safeCall(n, e, t)));
+        e._$$queuedListeners$$_ = void 0;
+      }
+    }
+    emitLifecycleEvent(r, "componentWillLoad");
+    {
+      s = safeCall(n, "componentWillLoad");
+    }
+  } else {
+    emitLifecycleEvent(r, "componentWillUpdate");
+    {
+      s = safeCall(n, "componentWillUpdate");
+    }
+  }
+  emitLifecycleEvent(r, "componentWillRender");
+  {
+    s = enqueue(s, (() => safeCall(n, "componentWillRender")));
+  }
+  l();
+  return enqueue(s, (() => updateComponent(e, n, t)));
+};
+
+var enqueue = (e, t) => isPromisey(e) ? e.then(t) : t();
+
+var isPromisey = e => e instanceof Promise || e && e.then && typeof e.then === "function";
+
+var updateComponent = async (e, t, r) => {
+  var l;
+  const n = e.$hostElement$;
+  const s = createTime("update", e._$$cmpMeta$$_._$$tagName$$_);
+  const o = n["s-rc"];
+  if (r) {
+    attachStyles(e);
+  }
+  const i = createTime("render", e._$$cmpMeta$$_._$$tagName$$_);
+  {
+    callRender(e, t, n, r);
+  }
+  if (o) {
+    o.map((e => e()));
+    n["s-rc"] = void 0;
+  }
+  i();
+  s();
+  {
+    const t = (l = n["s-p"]) != null ? l : [];
+    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, r, l) => {
+  try {
+    t = t.render && t.render();
+    {
+      e._$$flags$$_ &= ~16 /* isQueuedForUpdate */;
+    }
+    {
+      e._$$flags$$_ |= 2 /* hasRendered */;
+    }
+    {
+      {
+        {
+          renderVdom(e, t, l);
+        }
+      }
+    }
+  } catch (t) {
+    consoleError(t, e.$hostElement$);
+  }
+  return null;
+};
+
+var postUpdateComponent = e => {
+  const t = e._$$cmpMeta$$_._$$tagName$$_;
+  const r = e.$hostElement$;
+  const l = createTime("postUpdate", t);
+  const n = e._$$lazyInstance$$_;
+  const s = e._$$ancestorComponent$$_;
+  {
+    safeCall(n, "componentDidRender");
+  }
+  emitLifecycleEvent(r, "componentDidRender");
+  if (!(e._$$flags$$_ & 64 /* hasLoadedComponent */)) {
+    e._$$flags$$_ |= 64 /* hasLoadedComponent */;
+    {
+      addHydratedFlag(r);
+    }
+    {
+      safeCall(n, "componentDidLoad");
+    }
+    emitLifecycleEvent(r, "componentDidLoad");
+    l();
+    {
+      e._$$onReadyResolve$$_(r);
+      if (!s) {
+        appDidLoad();
+      }
+    }
+  } else {
+    {
+      safeCall(n, "componentDidUpdate");
+    }
+    emitLifecycleEvent(r, "componentDidUpdate");
+    l();
+  }
+  {
+    e._$$onInstanceResolve$$_(r);
+  }
+  {
+    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(x.documentElement);
+  }
+  nextTick((() => emitEvent(T, "appload", {
+    detail: {
+      namespace: e
+    }
+  })));
+};
+
+var safeCall = (e, t, r) => {
+  if (e && e[t]) {
+    try {
+      return e[t](r);
+    } catch (e) {
+      consoleError(e);
+    }
+  }
+  return void 0;
+};
+
+var emitLifecycleEvent = (t, r) => {
+  {
+    emitEvent(t, "stencil_" + r, {
+      bubbles: true,
+      composed: true,
+      detail: {
+        namespace: e
+      }
+    });
+  }
+};
+
+var addHydratedFlag = e => e.setAttribute("stencil-hydrated", "")
+// src/runtime/set-value.ts
+;
+
+var getValue = (e, t) => getHostRef(e)._$$instanceValues$$_.get(t);
+
+var setValue = (e, t, r, l) => {
+  const n = getHostRef(e);
+  const s = n.$hostElement$;
+  const o = n._$$instanceValues$$_.get(t);
+  const i = n._$$flags$$_;
+  const a = n._$$lazyInstance$$_;
+  r = parsePropertyValue(r, l._$$members$$_[t][0]);
+  const f = Number.isNaN(o) && Number.isNaN(r);
+  const c = r !== o && !f;
+  if ((!(i & 8 /* isConstructingInstance */) || o === void 0) && c) {
+    n._$$instanceValues$$_.set(t, r);
+    if (a) {
+      if (l._$$watchers$$_ && i & 128 /* isWatchReady */) {
+        const e = l._$$watchers$$_[t];
+        if (e) {
+          e.map((e => {
+            try {
+              a[e](r, o, t);
+            } catch (e) {
+              consoleError(e, s);
+            }
+          }));
+        }
+      }
+      if ((i & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+        if (a.componentShouldUpdate) {
+          if (a.componentShouldUpdate(r, o, t) === false) {
+            return;
+          }
+        }
+        scheduleUpdate(n, false);
+      }
+    }
+  }
+};
+
+// src/runtime/proxy-component.ts
+var proxyComponent = (e, t, r) => {
+  var l;
+  const n = e.prototype;
+  if (t._$$members$$_) {
+    if (e.watchers) {
+      t._$$watchers$$_ = e.watchers;
+    }
+    const s = Object.entries(t._$$members$$_);
+    s.map((([e, [l]]) => {
+      if (l & 31 /* Prop */ || r & 2 /* proxyState */ && l & 32 /* State */) {
+        Object.defineProperty(n, e, {
+          get() {
+            return getValue(this, e);
+          },
+          set(r) {
+            setValue(this, e, r, t);
+          },
+          configurable: true,
+          enumerable: true
+        });
+      } else if (r & 1 /* isElementConstructor */ && l & 64 /* Method */) {
+        Object.defineProperty(n, e, {
+          value(...t) {
+            var r;
+            const l = getHostRef(this);
+            return (r = l == null ? void 0 : l._$$onInstancePromise$$_) == null ? void 0 : r.then((() => {
+              var r;
+              return (r = l._$$lazyInstance$$_) == null ? void 0 : r[e](...t);
+            }));
+          }
+        });
+      }
+    }));
+    if (r & 1 /* isElementConstructor */) {
+      const r =  new Map;
+      n.attributeChangedCallback = function(e, l, s) {
+        L.jmp((() => {
+          var o;
+          const i = r.get(e);
+          if (this.hasOwnProperty(i)) {
+            s = this[i];
+            delete this[i];
+          } else if (n.hasOwnProperty(i) && typeof this[i] === "number" && this[i] == s) {
+            return;
+          } else if (i == null) {
+            const r = getHostRef(this);
+            const n = r == null ? void 0 : r._$$flags$$_;
+            if (n && !(n & 8 /* isConstructingInstance */) && n & 128 /* isWatchReady */ && s !== l) {
+              const n = r._$$lazyInstance$$_;
+              const i = (o = t._$$watchers$$_) == null ? void 0 : o[e];
+              i == null ? void 0 : i.forEach((t => {
+                if (n[t] != null) {
+                  n[t].call(n, s, l, e);
+                }
+              }));
+            }
+            return;
+          }
+          this[i] = s === null && typeof this[i] === "boolean" ? false : s;
+        }));
+      };
+      e.observedAttributes = Array.from(
+       new Set([ ...Object.keys((l = t._$$watchers$$_) != null ? l : {}), ...s.filter((([e, t]) => t[0] & 15 /* HasAttribute */)).map((([e, l]) => {
+        var n;
+        const s = l[1] || e;
+        r.set(s, e);
+        if (l[0] & 512 /* ReflectAttr */) {
+          (n = t._$$attrsToReflect$$_) == null ? void 0 : n.push([ e, s ]);
+        }
+        return s;
+      })) ]));
+    }
+  }
+  return e;
+};
+
+// src/runtime/initialize-component.ts
+var initializeComponent = async (e, t, r, l) => {
+  let n;
+  if ((t._$$flags$$_ & 32 /* hasInitializedComponent */) === 0) {
+    t._$$flags$$_ |= 32 /* hasInitializedComponent */;
+    const l = r._$$lazyBundleId$$_;
+    if (l) {
+      n = loadModule(r);
+      if (n.then) {
+        const e = uniqueTime();
+        n = await n;
+        e();
+      }
+      if (!n) {
+        throw new Error(`Constructor for "${r._$$tagName$$_}#${t._$$modeName$$_}" was not found`);
+      }
+      if (!n.isProxied) {
+        {
+          r._$$watchers$$_ = n.watchers;
+        }
+        proxyComponent(n, r, 2 /* proxyState */);
+        n.isProxied = true;
+      }
+      const e = createTime("createInstance", r._$$tagName$$_);
+      {
+        t._$$flags$$_ |= 8 /* isConstructingInstance */;
+      }
+      try {
+        new n(t);
+      } catch (e) {
+        consoleError(e);
+      }
+      {
+        t._$$flags$$_ &= ~8 /* isConstructingInstance */;
+      }
+      {
+        t._$$flags$$_ |= 128 /* isWatchReady */;
+      }
+      e();
+      fireConnectedCallback(t._$$lazyInstance$$_);
+    } else {
+      n = e.constructor;
+      customElements.whenDefined(r._$$tagName$$_).then((() => t._$$flags$$_ |= 128 /* isWatchReady */));
+    }
+    if (n.style) {
+      let e = n.style;
+      const t = getScopeId(r);
+      if (!R.has(t)) {
+        const l = createTime("registerStyles", r._$$tagName$$_);
+        registerStyle(t, e, !!(r._$$flags$$_ & 1 /* shadowDomEncapsulation */));
+        l();
+      }
+    }
+  }
+  const s = t._$$ancestorComponent$$_;
+  const schedule = () => scheduleUpdate(t, true);
+  if (s && s["s-rc"]) {
+    s["s-rc"].push(schedule);
+  } else {
+    schedule();
+  }
+};
+
+var fireConnectedCallback = e => {
+  {
+    safeCall(e, "connectedCallback");
+  }
+};
+
+// src/runtime/connected-callback.ts
+var connectedCallback = e => {
+  if ((L._$$flags$$_ & 1 /* isTmpDisconnected */) === 0) {
+    const t = getHostRef(e);
+    const r = t._$$cmpMeta$$_;
+    const l = createTime("connectedCallback", r._$$tagName$$_);
+    if (!(t._$$flags$$_ & 1 /* hasConnected */)) {
+      t._$$flags$$_ |= 1 /* hasConnected */;
+      {
+        if (// TODO(STENCIL-854): Remove code related to legacy shadowDomShim field
+        r._$$flags$$_ & (4 /* hasSlotRelocation */ | 8 /* needsShadowDomShim */)) {
+          setContentReference(e);
+        }
+      }
+      {
+        let r = e;
+        while (r = r.parentNode || r.host) {
+          if (r["s-p"]) {
+            attachToAncestor(t, t._$$ancestorComponent$$_ = r);
+            break;
+          }
+        }
+      }
+      if (r._$$members$$_) {
+        Object.entries(r._$$members$$_).map((([t, [r]]) => {
+          if (r & 31 /* Prop */ && e.hasOwnProperty(t)) {
+            const r = e[t];
+            delete e[t];
+            e[t] = r;
+          }
+        }));
+      }
+      {
+        initializeComponent(e, t, r);
+      }
+    } else {
+      addHostEventListeners(e, t, r._$$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$$_)));
+      }
+    }
+    l();
+  }
+};
+
+var setContentReference = e => {
+  const t = e["s-cr"] = x.createComment(`content-ref (host=${e.localName})`);
+  t["s-cn"] = true;
+  e.insertBefore(t, e.firstChild);
+};
+
+var disconnectInstance = e => {
+  {
+    safeCall(e, "disconnectedCallback");
+  }
+};
+
+var disconnectedCallback = async e => {
+  if ((L._$$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 r;
+  const l = createTime();
+  const n = [];
+  const s = t.exclude || [];
+  const o = T.customElements;
+  const f = x.head;
+  const c =  f.querySelector("meta[charset]");
+  const u =  x.createElement("style");
+  const v = [];
+  let d;
+  let p = true;
+  Object.assign(L, t);
+  L._$$resourcesUrl$$_ = new URL(t.resourcesUrl || "./", x.baseURI).href;
+  let m = false;
+  e.map((e => {
+    e[1].map((t => {
+      var r;
+      const l = {
+        _$$flags$$_: t[0],
+        _$$tagName$$_: t[1],
+        _$$members$$_: t[2],
+        _$$listeners$$_: t[3]
+      };
+      if (l._$$flags$$_ & 4 /* hasSlotRelocation */) {
+        m = true;
+      }
+      {
+        l._$$members$$_ = t[2];
+      }
+      {
+        l._$$listeners$$_ = t[3];
+      }
+      {
+        l._$$attrsToReflect$$_ = [];
+      }
+      {
+        l._$$watchers$$_ = (r = t[4]) != null ? r : {};
+      }
+      const i = l._$$tagName$$_;
+      const a = class extends HTMLElement {
+        // StencilLazyHost
+        constructor(e) {
+          super(e);
+          e = this;
+          registerHost(e, l);
+          if (l._$$flags$$_ & 1 /* shadowDomEncapsulation */) {
+            {
+              {
+                e.attachShadow({
+                  mode: "open"
+                });
+              }
+            }
+          }
+        }
+        connectedCallback() {
+          if (d) {
+            clearTimeout(d);
+            d = null;
+          }
+          if (p) {
+            v.push(this);
+          } else {
+            L.jmp((() => connectedCallback(this)));
+          }
+        }
+        disconnectedCallback() {
+          L.jmp((() => disconnectedCallback(this)));
+        }
+        componentOnReady() {
+          return getHostRef(this)._$$onReadyPromise$$_;
+        }
+      };
+      l._$$lazyBundleId$$_ = e[0];
+      if (!s.includes(i) && !o.get(i)) {
+        n.push(i);
+        o.define(i, proxyComponent(a, l, 1 /* isElementConstructor */));
+      }
+    }));
+  }));
+  if (n.length > 0) {
+    if (m) {
+      u.textContent += a;
+    }
+    {
+      u.textContent += n + i;
+    }
+    if (u.innerHTML.length) {
+      u.setAttribute("data-styles", "");
+      const e = (r = L._$$nonce$$_) != null ? r : queryNonceMetaTagContent(x);
+      if (e != null) {
+        u.setAttribute("nonce", e);
+      }
+      f.insertBefore(u, c ? c.nextSibling : f.firstChild);
+    }
+  }
+  p = false;
+  if (v.length) {
+    v.map((e => e.connectedCallback()));
+  } else {
+    {
+      L.jmp((() => d = setTimeout(appDidLoad, 30)));
+    }
+  }
+  l();
+};
+
+// src/runtime/fragment.ts
+var Fragment = (e, t) => t;
+
+var addHostEventListeners = (e, t, r, l) => {
+  if (r) {
+    r.map((([r, l, n]) => {
+      const s = getHostListenerTarget(e, r);
+      const o = hostListenerProxy(t, n);
+      const i = hostListenerOpts(r);
+      L.ael(s, l, o, i);
+      (t._$$rmListeners$$_ = t._$$rmListeners$$_ || []).push((() => L.rel(s, l, o, i)));
+    }));
+  }
+};
+
+var hostListenerProxy = (e, t) => r => {
+  try {
+    {
+      if (e._$$flags$$_ & 256 /* isListenReady */) {
+        e._$$lazyInstance$$_[t](r);
+      } else {
+        (e._$$queuedListeners$$_ = e._$$queuedListeners$$_ || []).push([ t, r ]);
+      }
+    }
+  } catch (e) {
+    consoleError(e);
+  }
+};
+
+var getHostListenerTarget = (e, t) => {
+  if (t & 8 /* TargetWindow */) return T;
+  return e;
+};
+
+var hostListenerOpts = e => D ? {
+  passive: (e & 1 /* Passive */) !== 0,
+  capture: (e & 2 /* Capture */) !== 0
+} : (e & 2 /* Capture */) !== 0
+// src/runtime/nonce.ts
+;
+
+var setNonce = e => L._$$nonce$$_ = e
+// src/client/client-host-ref.ts
+;
+
+var O =  new WeakMap;
+
+var getHostRef = e => O.get(e);
+
+var registerInstance = (e, t) => O.set(t._$$lazyInstance$$_ = e, t);
+
+var registerHost = (e, t) => {
+  const r = {
+    _$$flags$$_: 0,
+    $hostElement$: e,
+    _$$cmpMeta$$_: t,
+    _$$instanceValues$$_:  new Map
+  };
+  {
+    r._$$onInstancePromise$$_ = new Promise((e => r._$$onInstanceResolve$$_ = e));
+  }
+  {
+    r._$$onReadyPromise$$_ = new Promise((e => r._$$onReadyResolve$$_ = e));
+    e["s-p"] = [];
+    e["s-rc"] = [];
+  }
+  addHostEventListeners(e, r, t._$$listeners$$_);
+  return O.set(e, r);
+};
+
+var isMemberInElement = (e, t) => t in e;
+
+var consoleError = (e, t) => (0, console.error)(e, t)
+// src/client/client-load-module.ts
+;
+
+var j =  new Map;
+
+var loadModule = (e, t, r) => {
+  const l = e._$$tagName$$_.replace(/-/g, "_");
+  const n = e._$$lazyBundleId$$_;
+  const s = j.get(n);
+  if (s) {
+    return s[l];
+  }
+  /*!__STENCIL_STATIC_IMPORT_SWITCH__*/  return import(
+  /* @vite-ignore */
+  /* webpackInclude: /\.entry\.js$/ */
+  /* webpackExclude: /\.system\.entry\.js$/ */
+  /* webpackMode: "lazy" */
+  `./${n}.entry.js${""}`).then((e => {
+    {
+      j.set(n, e);
+    }
+    return e[l];
+  }), consoleError);
+};
+
+// src/client/client-style.ts
+var R =  new Map;
+
+var T = typeof window !== "undefined" ? window : {};
+
+var x = T.document || {
+  head: {}
+};
+
+var L = {
+  _$$flags$$_: 0,
+  _$$resourcesUrl$$_: "",
+  jmp: e => e(),
+  raf: e => requestAnimationFrame(e),
+  ael: (e, t, r, l) => e.addEventListener(t, r, l),
+  rel: (e, t, r, l) => e.removeEventListener(t, r, l),
+  ce: (e, t) => new CustomEvent(e, t)
+};
+
+var D =  (() => {
+  let e = false;
+  try {
+    x.addEventListener("e", null, Object.defineProperty({}, "passive", {
+      get() {
+        e = true;
+      }
+    }));
+  } catch (e) {}
+  return e;
+})();
+
+var promiseResolve = e => Promise.resolve(e);
+
+var N =  (() => {
+  try {
+    new CSSStyleSheet;
+    return typeof (new CSSStyleSheet).replaceSync === "function";
+  } catch (e) {}
+  return false;
+})();
+
+var M = false;
+
+var A = [];
+
+var U = [];
+
+var queueTask = (e, t) => r => {
+  e.push(r);
+  if (!M) {
+    M = true;
+    if (t && L._$$flags$$_ & 4 /* queueSync */) {
+      nextTick(flush);
+    } else {
+      L.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(A);
+  {
+    consume(U);
+    if (M = A.length > 0) {
+      L.raf(flush);
+    }
+  }
+};
+
+var nextTick = e => promiseResolve().then(e);
+
+var F =  queueTask(U, true);
+
+export { Fragment as F, c as H, getAssetPath as a, bootstrapLazy as b, createEvent as c, getElement as g, h, promiseResolve as p, registerInstance as r, setNonce as s };
+//# sourceMappingURL=index-7a5365e2.js.map