@govbr-ds/webcomponents/dist/webcomponents/p-ClsF4De3.js

Biblioteca de Web Components baseado no GovBR-DS

/*!
 * Construído por SERPRO
 * © https://serpro.gov.br/ - MIT License.
 */
const e = "webcomponents";

const t = /* webcomponents */ {
  hydratedSelectorName: "hydrated",
  lazyLoad: true,
  updatable: true
};

/*
 Stencil Client Platform v4.28.2 | MIT Licensed | https://stenciljs.com
 */ var n = Object.defineProperty;

var __export = (e, t) => {
  for (var i in t) n(e, i, {
    get: t[i],
    enumerable: true
  });
};

// src/utils/es2022-rewire-class-members.ts
var reWireGetterSetter = (e, t) => {
  var n;
  const i = t._$$cmpMeta$$_;
  const o = Object.entries((n = i._$$members$$_) != null ? n : {});
  o.map((([n, [i]]) => {
    if (i & 31 /* Prop */ || i & 32 /* State */) {
      const i = e[n];
      const o = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(e), n);
      Object.defineProperty(e, n, {
        get() {
          return o.get.call(this);
        },
        set(e) {
          o.set.call(this, e);
        },
        configurable: true,
        enumerable: true
      });
      e[n] = t._$$instanceValues$$_.has(n) ? t._$$instanceValues$$_.get(n) : i;
    }
  }));
};

// src/client/client-host-ref.ts
var getHostRef = e => {
  if (e.__stencil__getHostRef) {
    return e.__stencil__getHostRef();
  }
  return void 0;
};

var registerInstance = (e, t) => {
  e.__stencil__getHostRef = () => t;
  t._$$lazyInstance$$_ = e;
  {
    reWireGetterSetter(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"] = [];
  }
  const i = n;
  e.__stencil__getHostRef = () => i;
  return i;
};

var isMemberInElement = (e, t) => t in e;

var consoleError = (e, t) => (0, console.error)(e, t)
// src/client/client-load-module.ts
;

var i =  new Map;

var loadModule = (e, t, n) => {
  const o = e._$$tagName$$_.replace(/-/g, "_");
  const r = e._$$lazyBundleId$$_;
  if (!r) {
    return void 0;
  }
  const l = i.get(r);
  if (l) {
    return l[o];
  }
  /*!__STENCIL_STATIC_IMPORT_SWITCH__*/  return import(
  /* @vite-ignore */
  /* webpackInclude: /\.entry\.js$/ */
  /* webpackExclude: /\.system\.entry\.js$/ */
  /* webpackMode: "lazy" */
  `./${r}.entry.js${""}`).then((e => {
    {
      i.set(r, e);
    }
    return e[o];
  }), (e => {
    consoleError(e, t.$hostElement$);
  }));
};

// src/client/client-style.ts
var o =  new Map;

// src/runtime/runtime-constants.ts
var r = "r";

var l = "o";

var s = "s";

var f = "t";

var a = "c";

var c = "s-id";

var u = "sty-id";

var v = "c-id";

var d = "{visibility:hidden}.hydrated{visibility:inherit}";

var p = "slot-fb{display:contents}slot-fb[hidden]{display:none}";

var m = "http://www.w3.org/1999/xlink";

var $ = [ "formAssociatedCallback", "formResetCallback", "formDisabledCallback", "formStateRestoreCallback" ];

var b = typeof window !== "undefined" ? window : {};

var y = b.HTMLElement || class {};

var g = {
  _$$flags$$_: 0,
  _$$resourcesUrl$$_: "",
  jmp: e => e(),
  raf: e => requestAnimationFrame(e),
  ael: (e, t, n, i) => e.addEventListener(t, n, i),
  rel: (e, t, n, i) => e.removeEventListener(t, n, i),
  ce: (e, t) => new CustomEvent(e, t)
};

var w =  (() => {
  var e;
  let t = false;
  try {
    (e = b.document) == null ? void 0 : e.addEventListener("e", null, Object.defineProperty({}, "passive", {
      get() {
        t = true;
      }
    }));
  } catch (e) {}
  return t;
})();

var promiseResolve = e => Promise.resolve(e);

var S =  (() => {
  try {
    new CSSStyleSheet;
    return typeof (new CSSStyleSheet).replaceSync === "function";
  } catch (e) {}
  return false;
})();

var O = false;

var j = [];

var C = [];

var queueTask = (e, t) => n => {
  e.push(n);
  if (!O) {
    O = true;
    if (t && g._$$flags$$_ & 4 /* queueSync */) {
      nextTick(flush);
    } else {
      g.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(j);
  {
    consume(C);
    if (O = j.length > 0) {
      g.raf(flush);
    }
  }
};

var nextTick = e => promiseResolve().then(e);

var N =  queueTask(C, true);

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, i;
  return (i = (n = (t = e.head) == null ? void 0 : t.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : n.getAttribute("content")) != null ? i : void 0;
}

// src/utils/result.ts
var k = {};

__export(k, {
  err: () => err,
  map: () => map,
  ok: () => ok,
  unwrap: () => unwrap,
  unwrapErr: () => unwrapErr
});

var ok = e => ({
  isOk: true,
  isErr: false,
  value: e
});

var err = e => ({
  isOk: false,
  isErr: true,
  value: e
});

function map(e, t) {
  if (e.isOk) {
    const n = t(e.value);
    if (n instanceof Promise) {
      return n.then((e => ok(e)));
    } else {
      return ok(n);
    }
  }
  if (e.isErr) {
    const t = e.value;
    return err(t);
  }
  throw "should never get here";
}

var unwrap = e => {
  if (e.isOk) {
    return e.value;
  } else {
    throw e.value;
  }
};

var unwrapErr = e => {
  if (e.isErr) {
    return e.value;
  } else {
    throw e.value;
  }
};

var getSlottedChildNodes = e => {
  const t = [];
  for (let n = 0; n < e.length; n++) {
    const i = e[n]["s-nr"] || void 0;
    if (i && i.isConnected) {
      t.push(i);
    }
  }
  return t;
};

function getHostSlotNodes(e, t, n) {
  let i = 0;
  let o = [];
  let r;
  for (;i < e.length; i++) {
    r = e[i];
    if (r["s-sr"] && (!t || r["s-hn"] === t) && (n === void 0 || getSlotName(r) === n)) {
      o.push(r);
      if (typeof n !== "undefined") return o;
    }
    o = [ ...o, ...getHostSlotNodes(r.childNodes, t, n) ];
  }
  return o;
}

var addSlotRelocateNode = (e, t, n, i) => {
  if (e["s-ol"] && e["s-ol"].isConnected) {
    return;
  }
  const o = document.createTextNode("");
  o["s-nr"] = e;
  if (!t["s-cr"] || !t["s-cr"].parentNode) return;
  const r = t["s-cr"].parentNode;
  const l = internalCall(r, "appendChild");
  if (typeof i !== "undefined") {
    o["s-oo"] = i;
    const e = internalCall(r, "childNodes");
    const t = [ o ];
    e.forEach((e => {
      if (e["s-nr"]) t.push(e);
    }));
    t.sort(((e, t) => {
      if (!e["s-oo"] || e["s-oo"] < (t["s-oo"] || 0)) return -1; else if (!t["s-oo"] || t["s-oo"] < e["s-oo"]) return 1;
      return 0;
    }));
    t.forEach((e => l.call(r, e)));
  } else {
    l.call(r, o);
  }
  e["s-ol"] = o;
  e["s-sh"] = t["s-hn"];
};

var getSlotName = e => typeof e["s-sn"] === "string" ? e["s-sn"] : e.nodeType === 1 && e.getAttribute("slot") || void 0;

function patchSlotNode(e) {
  if (e.assignedElements || e.assignedNodes || !e["s-sr"]) return;
  const assignedFactory = t => function(e) {
    const n = [];
    const i = this["s-sn"];
    if (e == null ? void 0 : e.flatten) {
      console.error(`\n          Flattening is not supported for Stencil non-shadow slots. \n          You can use \`.childNodes\` to nested slot fallback content.\n          If you have a particular use case, please open an issue on the Stencil repo.\n        `);
    }
    const o = this["s-cr"].parentElement;
    const r = o.__childNodes ? o.childNodes : getSlottedChildNodes(o.childNodes);
    r.forEach((e => {
      if (i === getSlotName(e)) {
        n.push(e);
      }
    }));
    if (t) {
      return n.filter((e => e.nodeType === 1 /* ElementNode */));
    }
    return n;
  }.bind(e);
  e.assignedElements = assignedFactory(true);
  e.assignedNodes = assignedFactory(false);
}

function dispatchSlotChangeEvent(e) {
  e.dispatchEvent(new CustomEvent("slotchange", {
    bubbles: false,
    cancelable: false,
    composed: false
  }));
}

function findSlotFromSlottedNode(e, t) {
  var n;
  t = t || ((n = e["s-ol"]) == null ? void 0 : n.parentElement);
  if (!t) return {
    slotNode: null,
    slotName: ""
  };
  const i = e["s-sn"] = getSlotName(e) || "";
  const o = internalCall(t, "childNodes");
  const r = getHostSlotNodes(o, t.tagName, i)[0];
  return {
    slotNode: r,
    slotName: i
  };
}

var patchSlottedNode = e => {
  if (!e || e.__nextSibling !== void 0 || !globalThis.Node) return;
  patchNextSibling(e);
  patchPreviousSibling(e);
  patchParentNode(e);
  if (e.nodeType === Node.ELEMENT_NODE) {
    patchNextElementSibling(e);
    patchPreviousElementSibling(e);
  }
};

var patchNextSibling = e => {
  if (!e || e.__nextSibling) return;
  patchHostOriginalAccessor("nextSibling", e);
  Object.defineProperty(e, "nextSibling", {
    get: function() {
      var e;
      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.childNodes;
      const n = t == null ? void 0 : t.indexOf(this);
      if (t && n > -1) {
        return t[n + 1];
      }
      return this.__nextSibling;
    }
  });
};

var patchNextElementSibling = e => {
  if (!e || e.__nextElementSibling) return;
  patchHostOriginalAccessor("nextElementSibling", e);
  Object.defineProperty(e, "nextElementSibling", {
    get: function() {
      var e;
      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.children;
      const n = t == null ? void 0 : t.indexOf(this);
      if (t && n > -1) {
        return t[n + 1];
      }
      return this.__nextElementSibling;
    }
  });
};

var patchPreviousSibling = e => {
  if (!e || e.__previousSibling) return;
  patchHostOriginalAccessor("previousSibling", e);
  Object.defineProperty(e, "previousSibling", {
    get: function() {
      var e;
      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.childNodes;
      const n = t == null ? void 0 : t.indexOf(this);
      if (t && n > -1) {
        return t[n - 1];
      }
      return this.__previousSibling;
    }
  });
};

var patchPreviousElementSibling = e => {
  if (!e || e.__previousElementSibling) return;
  patchHostOriginalAccessor("previousElementSibling", e);
  Object.defineProperty(e, "previousElementSibling", {
    get: function() {
      var e;
      const t = (e = this["s-ol"]) == null ? void 0 : e.parentNode.children;
      const n = t == null ? void 0 : t.indexOf(this);
      if (t && n > -1) {
        return t[n - 1];
      }
      return this.__previousElementSibling;
    }
  });
};

var patchParentNode = e => {
  if (!e || e.__parentNode) return;
  patchHostOriginalAccessor("parentNode", e);
  Object.defineProperty(e, "parentNode", {
    get: function() {
      var e;
      return ((e = this["s-ol"]) == null ? void 0 : e.parentNode) || this.__parentNode;
    },
    set: function(e) {
      this.__parentNode = e;
    }
  });
};

var E = [ "children", "nextElementSibling", "previousElementSibling" ];

var x = [ "childNodes", "firstChild", "lastChild", "nextSibling", "previousSibling", "textContent", "parentNode" ];

function patchHostOriginalAccessor(e, t) {
  let n;
  if (E.includes(e)) {
    n = Object.getOwnPropertyDescriptor(Element.prototype, e);
  } else if (x.includes(e)) {
    n = Object.getOwnPropertyDescriptor(Node.prototype, e);
  }
  if (!n) {
    n = Object.getOwnPropertyDescriptor(t, e);
  }
  if (n) Object.defineProperty(t, "__" + e, n);
}

function internalCall(e, t) {
  if ("__" + t in e) {
    const n = e["__" + t];
    if (typeof n !== "function") return n;
    return n.bind(e);
  } else {
    if (typeof e[t] !== "function") return e[t];
    return e[t].bind(e);
  }
}

var createTime = (e, t = "") => {
  {
    return () => {};
  }
};

var uniqueTime = (e, t) => {
  {
    return () => {};
  }
};

var h = (e, t, ...n) => {
  let i = null;
  let o = null;
  let r = false;
  let l = false;
  const s = [];
  const walk = t => {
    for (let n = 0; n < t.length; n++) {
      i = t[n];
      if (Array.isArray(i)) {
        walk(i);
      } else if (i != null && typeof i !== "boolean") {
        if (r = typeof e !== "function" && !isComplexType(i)) {
          i = String(i);
        }
        if (r && l) {
          s[s.length - 1]._$$text$$_ += i;
        } else {
          s.push(r ? newVNode(null, i) : i);
        }
        l = r;
      }
    }
  };
  walk(n);
  if (t) {
    if (t.key) {
      o = t.key;
    }
    {
      const e = t.className || t.class;
      if (e) {
        t.class = typeof e !== "object" ? e : Object.keys(e).filter((t => e[t])).join(" ");
      }
    }
  }
  if (typeof e === "function") {
    return e(t === null ? {} : t, s, M);
  }
  const f = newVNode(e, null);
  f._$$attrs$$_ = t;
  if (s.length > 0) {
    f._$$children$$_ = s;
  }
  {
    f._$$key$$_ = o;
  }
  return f;
};

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 M = {
  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;
};

// src/runtime/client-hydrate.ts
var initializeClientHydrate = (e, t, n, i) => {
  const o = createTime("hydrateClient", t);
  const r = e.shadowRoot;
  const l = [];
  const s = [];
  const f = [];
  const a = r ? [] : null;
  const u = newVNode(t, null);
  u._$$elm$$_ = e;
  if (b.document && (!g._$$orgLocNodes$$_ || !g._$$orgLocNodes$$_.size)) {
    initializeDocumentHydrate(b.document.body, g._$$orgLocNodes$$_ =  new Map);
  }
  e[c] = n;
  e.removeAttribute(c);
  i._$$vnode$$_ = clientHydrate(u, l, s, a, e, e, n, f);
  let v = 0;
  const d = l.length;
  let p;
  for (v; v < d; v++) {
    p = l[v];
    const n = p._$$hostId$$_ + "." + p._$$nodeId$$_;
    const i = g._$$orgLocNodes$$_.get(n);
    const o = p._$$elm$$_;
    if (!r) {
      o["s-hn"] = t.toUpperCase();
      if (p._$$tag$$_ === "slot") {
        o["s-cr"] = e["s-cr"];
      }
    }
    if (p._$$tag$$_ === "slot") {
      p._$$name$$_ = p._$$elm$$_["s-sn"] || p._$$elm$$_["name"] || null;
      if (p._$$children$$_) {
        p._$$flags$$_ |= 2 /* isSlotFallback */;
        if (!p._$$elm$$_.childNodes.length) {
          p._$$children$$_.forEach((e => {
            p._$$elm$$_.appendChild(e._$$elm$$_);
          }));
        }
      } else {
        p._$$flags$$_ |= 1 /* isSlotReference */;
      }
    }
    if (i && i.isConnected) {
      if (r && i["s-en"] === "") {
        i.parentNode.insertBefore(o, i.nextSibling);
      }
      i.parentNode.removeChild(i);
      if (!r) {
        o["s-oo"] = parseInt(p._$$nodeId$$_);
      }
    }
    g._$$orgLocNodes$$_.delete(n);
  }
  const m = [];
  const $ = f.length;
  let y = 0;
  let w;
  let S;
  let O;
  let j;
  for (y; y < $; y++) {
    w = f[y];
    if (!w || !w.length) continue;
    O = w.length;
    S = 0;
    for (S; S < O; S++) {
      j = w[S];
      if (!m[j.hostId]) {
        m[j.hostId] = g._$$orgLocNodes$$_.get(j.hostId);
      }
      if (!m[j.hostId]) continue;
      const e = m[j.hostId];
      if (!e.shadowRoot || !r) {
        j.slot["s-cr"] = e["s-cr"];
        if (!j.slot["s-cr"] && e.shadowRoot) {
          j.slot["s-cr"] = e;
        } else {
          j.slot["s-cr"] = (e.__childNodes || e.childNodes)[0];
        }
        addSlotRelocateNode(j.node, j.slot, false, j.node["s-oo"]);
        {
          patchSlottedNode(j.node);
        }
      }
      if (e.shadowRoot && j.node.parentElement !== e) {
        e.appendChild(j.node);
      }
    }
  }
  if (r && !r.childNodes.length) {
    let t = 0;
    const n = a.length;
    if (n) {
      for (t; t < n; t++) {
        r.appendChild(a[t]);
      }
      Array.from(e.childNodes).forEach((e => {
        if (typeof e["s-sn"] !== "string") {
          if (e.nodeType === 1 /* ElementNode */ && e.slot && e.hidden) {
            e.removeAttribute("hidden");
          } else if (e.nodeType === 8 /* CommentNode */ || e.nodeType === 3 /* TextNode */ && !e.wholeText.trim()) {
            e.parentNode.removeChild(e);
          }
        }
      }));
    }
  }
  g._$$orgLocNodes$$_.delete(e["s-id"]);
  i.$hostElement$ = e;
  o();
};

var clientHydrate = (e, t, n, i, o, l, c, u = []) => {
  let d;
  let p;
  let m;
  let $;
  if (l.nodeType === 1 /* ElementNode */) {
    d = l.getAttribute(v);
    if (d) {
      p = d.split(".");
      if (p[0] === c || 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` patch
          // won't try to reconcile them. Classes set on the node will be blown away.
          _$$attrs$$_: {
            class: l.className || ""
          }
        });
        t.push(m);
        l.removeAttribute(v);
        if (!e._$$children$$_) {
          e._$$children$$_ = [];
        }
        const o = m._$$elm$$_.getAttribute("s-sn");
        if (typeof o === "string") {
          if (m._$$tag$$_ === "slot-fb") {
            addSlot(o, p[2], m, l, e, t, n, i, u);
          }
          m._$$elm$$_["s-sn"] = o;
          m._$$elm$$_.removeAttribute("s-sn");
        }
        if (m._$$index$$_ !== void 0) {
          e._$$children$$_[m._$$index$$_] = m;
        }
        e = m;
        if (i && m._$$depth$$_ === "0") {
          i[m._$$index$$_] = m._$$elm$$_;
        }
      }
    }
    if (l.shadowRoot) {
      for ($ = l.shadowRoot.childNodes.length - 1; $ >= 0; $--) {
        clientHydrate(e, t, n, i, o, l.shadowRoot.childNodes[$], c, u);
      }
    }
    const r = l.__childNodes || l.childNodes;
    for ($ = r.length - 1; $ >= 0; $--) {
      clientHydrate(e, t, n, i, o, r[$], c, u);
    }
  } else if (l.nodeType === 8 /* CommentNode */) {
    p = l.nodeValue.split(".");
    if (p[1] === c || 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$$_ = findCorrespondingNode(l, 3 /* TextNode */);
        if (m._$$elm$$_ && m._$$elm$$_.nodeType === 3 /* TextNode */) {
          m._$$text$$_ = m._$$elm$$_.textContent;
          t.push(m);
          l.remove();
          if (c === m._$$hostId$$_) {
            if (!e._$$children$$_) {
              e._$$children$$_ = [];
            }
            e._$$children$$_[m._$$index$$_] = m;
          }
          if (i && m._$$depth$$_ === "0") {
            i[m._$$index$$_] = m._$$elm$$_;
          }
        }
      } else if (d === a) {
        m._$$elm$$_ = findCorrespondingNode(l, 8 /* CommentNode */);
        if (m._$$elm$$_ && m._$$elm$$_.nodeType === 8 /* CommentNode */) {
          t.push(m);
          l.remove();
        }
      } else if (m._$$hostId$$_ === c) {
        if (d === s) {
          const o = l["s-sn"] = p[5] || "";
          addSlot(o, p[2], m, l, e, t, n, i, u);
        } else if (d === r) {
          if (i) {
            l.remove();
          }
        }
      }
    }
  } else if (e && e._$$tag$$_ === "style") {
    const t = newVNode(null, l.textContent);
    t._$$elm$$_ = l;
    t._$$index$$_ = "0";
    e._$$children$$_ = [ t ];
  } else {
    if (l.nodeType === 3 /* TextNode */ && !l.wholeText.trim()) {
      l.remove();
    }
  }
  return e;
};

var initializeDocumentHydrate = (e, t) => {
  if (e.nodeType === 1 /* ElementNode */) {
    const n = e[c] || e.getAttribute(c);
    if (n) {
      t.set(n, e);
    }
    let i = 0;
    if (e.shadowRoot) {
      for (;i < e.shadowRoot.childNodes.length; i++) {
        initializeDocumentHydrate(e.shadowRoot.childNodes[i], t);
      }
    }
    const o = e.__childNodes || e.childNodes;
    for (i = 0; i < o.length; i++) {
      initializeDocumentHydrate(o[i], t);
    }
  } else if (e.nodeType === 8 /* CommentNode */) {
    const n = e.nodeValue.split(".");
    if (n[0] === l) {
      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, i, o, r, l, s, f) {
  i["s-sr"] = true;
  n._$$name$$_ = e || null;
  n._$$tag$$_ = "slot";
  const a = (o == null ? void 0 : o._$$elm$$_) ? o._$$elm$$_["s-id"] || o._$$elm$$_.getAttribute("s-id") : "";
  if (s && b.document) {
    const r = n._$$elm$$_ = b.document.createElement(n._$$tag$$_);
    if (n._$$name$$_) {
      n._$$elm$$_.setAttribute("name", e);
    }
    if (a && a !== n._$$hostId$$_) {
      o._$$elm$$_.insertBefore(r, o._$$elm$$_.children[0]);
    } else {
      i.parentNode.insertBefore(n._$$elm$$_, i);
    }
    addSlottedNodes(f, t, e, i, n._$$hostId$$_);
    i.remove();
    if (n._$$depth$$_ === "0") {
      s[n._$$index$$_] = n._$$elm$$_;
    }
  } else {
    const l = n._$$elm$$_;
    const s = a && a !== n._$$hostId$$_ && o._$$elm$$_.shadowRoot;
    addSlottedNodes(f, t, e, i, s ? a : n._$$hostId$$_);
    patchSlotNode(i);
    if (s) {
      o._$$elm$$_.insertBefore(l, o._$$elm$$_.children[0]);
    }
    r.push(n);
  }
  l.push(n);
  if (!o._$$children$$_) {
    o._$$children$$_ = [];
  }
  o._$$children$$_[n._$$index$$_] = n;
}

var addSlottedNodes = (e, t, n, i, o) => {
  let r = i.nextSibling;
  e[t] = e[t] || [];
  while (r && ((r["getAttribute"] && r.getAttribute("slot") || r["s-sn"]) === n || n === "" && !r["s-sn"] && (r.nodeType === 8 /* CommentNode */ && r.nodeValue.indexOf(".") !== 1 || r.nodeType === 3 /* TextNode */))) {
    r["s-sn"] = n;
    e[t].push({
      slot: i,
      node: r,
      hostId: o
    });
    r = r.nextSibling;
  }
};

var findCorrespondingNode = (e, t) => {
  let n = e;
  do {
    n = n.nextSibling;
  } while (n && (n.nodeType !== t || !n.nodeValue));
  return n;
};

var parsePropertyValue = (e, t) => {
  if (e != null && !isComplexType(e)) {
    if (t & 4 /* Boolean */) {
      return e === "false" ? false : e === "" || !!e;
    }
    if (t & 2 /* Number */) {
      return parseFloat(e);
    }
    if (t & 1 /* String */) {
      return String(e);
    }
    return e;
  }
  return e;
};

var getElement = e => getHostRef(e).$hostElement$
// src/runtime/event-emitter.ts
;

var createEvent = (e, t, n) => {
  const i = getElement(e);
  return {
    emit: e => emitEvent(i, t, {
      bubbles: true,
      composed: true,
      cancelable: true,
      detail: e
    })
  };
};

var emitEvent = (e, t, n) => {
  const i = g.ce(t, n);
  e.dispatchEvent(i);
  return i;
};

var H =  new WeakMap;

var registerStyle = (e, t, n) => {
  let i = o.get(e);
  if (S && n) {
    i = i || new CSSStyleSheet;
    if (typeof i === "string") {
      i = t;
    } else {
      i.replaceSync(t);
    }
  } else {
    i = t;
  }
  o.set(e, i);
};

var addStyle = (e, t, n) => {
  var i;
  const r = getScopeId(t);
  const l = o.get(r);
  if (!b.document) {
    return r;
  }
  e = e.nodeType === 11 /* DocumentFragment */ ? e : b.document;
  if (l) {
    if (typeof l === "string") {
      e = e.head || e;
      let n = H.get(e);
      let o;
      if (!n) {
        H.set(e, n =  new Set);
      }
      if (!n.has(r)) {
        if (e.host && (o = e.querySelector(`[${u}="${r}"]`))) {
          o.innerHTML = l;
        } else {
          o = document.querySelector(`[${u}="${r}"]`) || b.document.createElement("style");
          o.innerHTML = l;
          const n = (i = g._$$nonce$$_) != null ? i : queryNonceMetaTagContent(b.document);
          if (n != null) {
            o.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(o, (n == null ? void 0 : n.parentNode) === e ? n : null);
            } else if ("host" in e) {
              if (S) {
                const t = new CSSStyleSheet;
                t.replaceSync(l);
                e.adoptedStyleSheets = [ t, ...e.adoptedStyleSheets ];
              } else {
                const t = e.querySelector("style");
                if (t) {
                  t.innerHTML = l + t.innerHTML;
                } else {
                  e.prepend(o);
                }
              }
            } else {
              e.append(o);
            }
          }
          if (t._$$flags$$_ & 1 /* shadowDomEncapsulation */) {
            e.insertBefore(o, null);
          }
        }
        if (t._$$flags$$_ & 4 /* hasSlotRelocation */) {
          o.innerHTML += p;
        }
        if (n) {
          n.add(r);
        }
      }
    } else if (!e.adoptedStyleSheets.includes(l)) {
      e.adoptedStyleSheets = [ ...e.adoptedStyleSheets, l ];
    }
  }
  return r;
};

var attachStyles = e => {
  const t = e._$$cmpMeta$$_;
  const n = e.$hostElement$;
  const i = t._$$flags$$_;
  const o = createTime("attachStyles", t._$$tagName$$_);
  const r = addStyle(n.shadowRoot ? n.shadowRoot : n.getRootNode(), t);
  if (i & 10 /* needsScopedEncapsulation */ && i & 2 /* scopedCssEncapsulation */ || i & 128 /* shadowNeedsScopedCss */) {
    n["s-sc"] = r;
    n.classList.add(r + "-h");
  }
  o();
};

var getScopeId = (e, t) => "sc-" + e._$$tagName$$_;

var convertScopedToShadow = e => e.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, "$1{");

var hydrateScopedToShadow = () => {
  if (!b.document) {
    return;
  }
  const e = b.document.querySelectorAll(`[${u}]`);
  let t = 0;
  for (;t < e.length; t++) {
    registerStyle(e[t].getAttribute(u), convertScopedToShadow(e[t].innerHTML), true);
  }
};

var setAccessor = (e, t, n, i, o, r, l) => {
  if (n === i) {
    return;
  }
  let s = isMemberInElement(e, t);
  let f = t.toLowerCase();
  if (t === "class") {
    const t = e.classList;
    const o = parseClassList(n);
    let r = parseClassList(i);
    if (e["s-si"] && l) {
      r.push(e["s-si"]);
      o.forEach((t => {
        if (t.startsWith(e["s-si"])) r.push(t);
      }));
      r = [ ...new Set(r) ];
      t.add(...r);
    } else {
      t.remove(...o.filter((e => e && !r.includes(e))));
      t.add(...r.filter((e => e && !o.includes(e))));
    }
  } else if (t === "style") {
    {
      for (const t in n) {
        if (!i || i[t] == null) {
          if (t.includes("-")) {
            e.style.removeProperty(t);
          } else {
            e.style[t] = "";
          }
        }
      }
    }
    for (const t in i) {
      if (!n || i[t] !== n[t]) {
        if (t.includes("-")) {
          e.style.setProperty(t, i[t]);
        } else {
          e.style[t] = i[t];
        }
      }
    }
  } else if (t === "key") ; else if (t === "ref") {
    if (i) {
      i(e);
    }
  } else if (!s && t[0] === "o" && t[1] === "n") {
    if (t[2] === "-") {
      t = t.slice(3);
    } else if (isMemberInElement(b, f)) {
      t = f.slice(2);
    } else {
      t = f[2] + t.slice(3);
    }
    if (n || i) {
      const o = t.endsWith(D);
      t = t.replace(R, "");
      if (n) {
        g.rel(e, t, n, o);
      }
      if (i) {
        g.ael(e, t, i, o);
      }
    }
  } else {
    const l = isComplexType(i);
    if ((s || l && i !== null) && true) {
      try {
        if (!e.tagName.includes("-")) {
          const o = i == null ? "" : i;
          if (t === "list") {
            s = false;
          } else if (n == null || e[t] != o) {
            if (typeof e.__lookupSetter__(t) === "function") {
              e[t] = o;
            } else {
              e.setAttribute(t, o);
            }
          }
        } else if (e[t] !== i) {
          e[t] = i;
        }
      } catch (e) {}
    }
    let a = false;
    {
      if (f !== (f = f.replace(/^xlink\:?/, ""))) {
        t = f;
        a = true;
      }
    }
    if (i == null || i === false) {
      if (i !== false || e.getAttribute(t) === "") {
        if (a) {
          e.removeAttributeNS(m, t);
        } else {
          e.removeAttribute(t);
        }
      }
    } else if ((!s || r & 4 /* isHost */ || o) && !l && e.nodeType === 1 /* ElementNode */) {
      i = i === true ? "" : i;
      if (a) {
        e.setAttributeNS(m, t, i);
      } else {
        e.setAttribute(t, i);
      }
    }
  }
};

var I = /\s/;

var parseClassList = e => {
  if (typeof e === "object" && e && "baseVal" in e) {
    e = e.baseVal;
  }
  if (!e || typeof e !== "string") {
    return [];
  }
  return e.split(I);
};

var D = "Capture";

var R = new RegExp(D + "$");

// src/runtime/vdom/update-element.ts
var updateElement = (e, t, n, i) => {
  const o = t._$$elm$$_.nodeType === 11 /* DocumentFragment */ && t._$$elm$$_.host ? t._$$elm$$_.host : t._$$elm$$_;
  const r = e && e._$$attrs$$_ || {};
  const l = t._$$attrs$$_ || {};
  {
    for (const e of sortedAttrNames(Object.keys(r))) {
      if (!(e in l)) {
        setAccessor(o, e, r[e], void 0, n, t._$$flags$$_, i);
      }
    }
  }
  for (const e of sortedAttrNames(Object.keys(l))) {
    setAccessor(o, e, r[e], l[e], n, t._$$flags$$_, i);
  }
};

function sortedAttrNames(e) {
  return e.includes("ref") ? 
  // we need to sort these to ensure that `'ref'` is the last attr
  [ ...e.filter((e => e !== "ref")), "ref" ] : 
  // no need to sort, return the original array
  e;
}

var U;

var P = false;

var W = false;

var createElm = (e, t, n) => {
  const i = t._$$children$$_[n];
  let o = 0;
  let r;
  let l;
  if (i._$$text$$_ !== null) {
    r = i._$$elm$$_ = b.document.createTextNode(i._$$text$$_);
  } else {
    if (!b.document) {
      throw new Error("You are trying to render a Stencil component in an environment that doesn't support the DOM. Make sure to populate the [`window`](https://developer.mozilla.org/en-US/docs/Web/API/Window/window) object before rendering a component.");
    }
    r = i._$$elm$$_ = b.document.createElement(i._$$tag$$_);
    {
      updateElement(null, i, W);
    }
    if (i._$$children$$_) {
      for (o = 0; o < i._$$children$$_.length; ++o) {
        l = createElm(e, i, o);
        if (l) {
          r.appendChild(l);
        }
      }
    }
  }
  r["s-hn"] = U;
  return r;
};

var relocateToHostRoot = e => {
  g._$$flags$$_ |= 1 /* isTmpDisconnected */;
  const t = e.closest(U.toLowerCase());
  if (t != null) {
    const n = Array.from(t.__childNodes || t.childNodes).find((e => e["s-cr"]));
    const i = Array.from(e.__childNodes || e.childNodes);
    for (const e of n ? i.reverse() : i) {
      if (e["s-sh"] != null) {
        insertBefore(t, e, n != null ? n : null);
        e["s-sh"] = void 0;
      }
    }
  }
  g._$$flags$$_ &= -2 /* isTmpDisconnected */;
};

var addVnodes = (e, t, n, i, o, r) => {
  let l = e;
  let s;
  if (l.shadowRoot && l.tagName === U) {
    l = l.shadowRoot;
  }
  for (;o <= r; ++o) {
    if (i[o]) {
      s = createElm(null, n, o);
      if (s) {
        i[o]._$$elm$$_ = s;
        insertBefore(l, s, t);
      }
    }
  }
};

var removeVnodes = (e, t, n) => {
  for (let i = t; i <= n; ++i) {
    const t = e[i];
    if (t) {
      const e = t._$$elm$$_;
      nullifyVNodeRefs(t);
      if (e) {
        e.remove();
      }
    }
  }
};

var updateChildren = (e, t, n, i, o = false) => {
  let r = 0;
  let l = 0;
  let s = 0;
  let f = 0;
  let a = t.length - 1;
  let c = t[0];
  let u = t[a];
  let v = i.length - 1;
  let d = i[0];
  let p = i[v];
  let m;
  let $;
  while (r <= a && l <= v) {
    if (c == null) {
      c = t[++r];
    } else if (u == null) {
      u = t[--a];
    } else if (d == null) {
      d = i[++l];
    } else if (p == null) {
      p = i[--v];
    } else if (isSameVnode(c, d, o)) {
      patch(c, d, o);
      c = t[++r];
      d = i[++l];
    } else if (isSameVnode(u, p, o)) {
      patch(u, p, o);
      u = t[--a];
      p = i[--v];
    } else if (isSameVnode(c, p, o)) {
      patch(c, p, o);
      insertBefore(e, c._$$elm$$_, u._$$elm$$_.nextSibling);
      c = t[++r];
      p = i[--v];
    } else if (isSameVnode(u, d, o)) {
      patch(u, d, o);
      insertBefore(e, u._$$elm$$_, c._$$elm$$_);
      u = t[--a];
      d = i[++l];
    } else {
      s = -1;
      {
        for (f = r; f <= a; ++f) {
          if (t[f] && t[f]._$$key$$_ !== null && t[f]._$$key$$_ === d._$$key$$_) {
            s = f;
            break;
          }
        }
      }
      if (s >= 0) {
        $ = t[s];
        if ($._$$tag$$_ !== d._$$tag$$_) {
          m = createElm(t && t[l], n, s);
        } else {
          patch($, d, o);
          t[s] = void 0;
          m = $._$$elm$$_;
        }
        d = i[++l];
      } else {
        m = createElm(t && t[l], n, l);
        d = i[++l];
      }
      if (m) {
        {
          insertBefore(c._$$elm$$_.parentNode, m, c._$$elm$$_);
        }
      }
    }
  }
  if (r > a) {
    addVnodes(e, i[v + 1] == null ? null : i[v + 1]._$$elm$$_, n, i, l, v);
  } else if (l > v) {
    removeVnodes(t, r, a);
  }
};

var isSameVnode = (e, t, n = false) => {
  if (e._$$tag$$_ === t._$$tag$$_) {
    if (!n) {
      return e._$$key$$_ === t._$$key$$_;
    }
    if (n && !e._$$key$$_ && t._$$key$$_) {
      e._$$key$$_ = t._$$key$$_;
    }
    return true;
  }
  return false;
};

var patch = (e, n, i = false) => {
  const o = n._$$elm$$_ = e._$$elm$$_;
  const r = e._$$children$$_;
  const l = n._$$children$$_;
  const s = n._$$tag$$_;
  const f = n._$$text$$_;
  if (f === null) {
    {
      if (s === "slot" && !P) {
        if (e._$$name$$_ !== n._$$name$$_) {
          n._$$elm$$_["s-sn"] = n._$$name$$_ || "";
          relocateToHostRoot(n._$$elm$$_.parentElement);
        }
      }
      updateElement(e, n, W, i);
    }
    if (r !== null && l !== null) {
      updateChildren(o, r, n, l, i);
    } else if (l !== null) {
      if (e._$$text$$_ !== null) {
        o.textContent = "";
      }
      addVnodes(o, null, n, l, 0, l.length - 1);
    } else if (
    // don't do this on initial render as it can cause non-hydrated content to be removed
    !i && t.updatable && r !== null) {
      removeVnodes(r, 0, r.length - 1);
    }
  } else if (e._$$text$$_ !== f) {
    o.data = f;
  }
};

var nullifyVNodeRefs = e => {
  {
    e._$$attrs$$_ && e._$$attrs$$_.ref && e._$$attrs$$_.ref(null);
    e._$$children$$_ && e._$$children$$_.map(nullifyVNodeRefs);
  }
};

var insertBefore = (e, t, n) => {
  if (typeof t["s-sn"] === "string") {
    if (e.getRootNode().nodeType !== 11 /* DOCUMENT_FRAGMENT_NODE */) {
      patchParentNode(t);
    }
    e.insertBefore(t, n);
    const {slotNode: i} = findSlotFromSlottedNode(t);
    if (i) dispatchSlotChangeEvent(i);
    return t;
  }
  if (e.__insertBefore) {
    return e.__insertBefore(t, n);
  } else {
    return e == null ? void 0 : e.insertBefore(t, n);
  }
};

var renderVdom = (e, t, n = false) => {
  var i;
  const o = e.$hostElement$;
  const r = e._$$cmpMeta$$_;
  const l = e._$$vnode$$_ || newVNode(null, null);
  const s = isHost(t) ? t : h(null, null, t);
  U = o.tagName;
  if (r._$$attrsToReflect$$_) {
    s._$$attrs$$_ = s._$$attrs$$_ || {};
    r._$$attrsToReflect$$_.map((([e, t]) => s._$$attrs$$_[t] = o[e]));
  }
  if (n && s._$$attrs$$_) {
    for (const e of Object.keys(s._$$attrs$$_)) {
      if (o.hasAttribute(e) && ![ "key", "ref", "style", "class" ].includes(e)) {
        s._$$attrs$$_[e] = o[e];
      }
    }
  }
  s._$$tag$$_ = null;
  s._$$flags$$_ |= 4 /* isHost */;
  e._$$vnode$$_ = s;
  s._$$elm$$_ = l._$$elm$$_ = o.shadowRoot || o;
  P = !!(r._$$flags$$_ & 1 /* shadowDomEncapsulation */) && !(r._$$flags$$_ & 128 /* shadowNeedsScopedCss */);
  patch(l, s, n);
  if (r._$$flags$$_ & 2 /* scopedCssEncapsulation */) {
    const e = s._$$elm$$_.__childNodes || s._$$elm$$_.childNodes;
    for (const t of e) {
      if (t["s-hn"] !== U && !t["s-sh"]) {
        if (n && t["s-ih"] == null) {
          t["s-ih"] = (i = t.hidden) != null ? i : false;
        }
        t.hidden = true;
      }
    }
  }
};

// src/runtime/update-component.ts
var attachToAncestor = (e, t) => {
  if (t && !e._$$onRenderResolve$$_ && t["s-p"]) {
    const n = t["s-p"].push(new Promise((i => e._$$onRenderResolve$$_ = () => {
      t["s-p"].splice(n - 1, 1);
      i();
    })));
  }
};

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 N(dispatch);
};

var dispatchHooks = (e, t) => {
  const n = e.$hostElement$;
  const i = createTime("scheduleUpdate", e._$$cmpMeta$$_._$$tagName$$_);
  const o = e._$$lazyInstance$$_;
  if (!o) {
    throw new Error(`Can't render component <${n.tagName.toLowerCase()} /> with invalid Stencil runtime! Make sure this imported component is compiled with a \`externalRuntime: true\` flag. For more information, please refer to https://stenciljs.com/docs/custom-elements#externalruntime`);
  }
  let r;
  if (t) {
    {
      e._$$flags$$_ |= 256 /* isListenReady */;
      if (e._$$queuedListeners$$_) {
        e._$$queuedListeners$$_.map((([e, t]) => safeCall(o, e, t, n)));
        e._$$queuedListeners$$_ = void 0;
      }
    }
    emitLifecycleEvent(n, "componentWillLoad");
    r = safeCall(o, "componentWillLoad", void 0, n);
  } else {
    emitLifecycleEvent(n, "componentWillUpdate");
    r = safeCall(o, "componentWillUpdate", void 0, n);
  }
  emitLifecycleEvent(n, "componentWillRender");
  r = enqueue(r, (() => safeCall(o, "componentWillRender", void 0, n)));
  i();
  return enqueue(r, (() => updateComponent(e, o, 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 i;
  const o = e.$hostElement$;
  const r = createTime("update", e._$$cmpMeta$$_._$$tagName$$_);
  const l = o["s-rc"];
  if (n) {
    attachStyles(e);
  }
  const s = createTime("render", e._$$cmpMeta$$_._$$tagName$$_);
  {
    callRender(e, t, o, n);
  }
  if (l) {
    l.map((e => e()));
    o["s-rc"] = void 0;
  }
  s();
  r();
  {
    const t = (i = o["s-p"]) != null ? i : [];
    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, i) => {
  try {
    t = t.render();
    {
      e._$$flags$$_ &= -17 /* isQueuedForUpdate */;
    }
    {
      e._$$flags$$_ |= 2 /* hasRendered */;
    }
    {
      {
        {
          renderVdom(e, t, i);
        }
      }
    }
  } catch (t) {
    consoleError(t, e.$hostElement$);
  }
  return null;
};

var postUpdateComponent = e => {
  const t = e._$$cmpMeta$$_._$$tagName$$_;
  const n = e.$hostElement$;
  const i = createTime("postUpdate", t);
  const o = e._$$lazyInstance$$_;
  const r = e._$$ancestorComponent$$_;
  safeCall(o, "componentDidRender", void 0, n);
  emitLifecycleEvent(n, "componentDidRender");
  if (!(e._$$flags$$_ & 64 /* hasLoadedComponent */)) {
    e._$$flags$$_ |= 64 /* hasLoadedComponent */;
    {
      addHydratedFlag(n);
    }
    safeCall(o, "componentDidLoad", void 0, n);
    emitLifecycleEvent(n, "componentDidLoad");
    i();
    {
      e._$$onReadyResolve$$_(n);
      if (!r) {
        appDidLoad();
      }
    }
  } else {
    safeCall(o, "componentDidUpdate", void 0, n);
    emitLifecycleEvent(n, "componentDidUpdate");
    i();
  }
  {
    e._$$onInstanceResolve$$_(n);
  }
  {
    if (e._$$onRenderResolve$$_) {
      e._$$onRenderResolve$$_();
      e._$$onRenderResolve$$_ = void 0;
    }
    if (e._$$flags$$_ & 512 /* needsRerender */) {
      nextTick((() => scheduleUpdate(e, false)));
    }
    e._$$flags$$_ &= -517;
  }
};

var appDidLoad = t => {
  nextTick((() => emitEvent(b, "appload", {
    detail: {
      namespace: e
    }
  })));
};

var safeCall = (e, t, n, i) => {
  if (e && e[t]) {
    try {
      return e[t](n);
    } catch (e) {
      consoleError(e, i);
    }
  }
  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, i) => {
  const o = getHostRef(e);
  if (!o) {
    throw new Error(`Couldn't find host element for "${i._$$tagName$$_}" as it is unknown to this Stencil runtime. This usually happens when integrating a 3rd party Stencil component with another Stencil component or application. Please reach out to the maintainers of the 3rd party Stencil component or report this on the Stencil Discord server (https://chat.stenciljs.com) or comment on this similar [GitHub issue](https://github.com/stenciljs/core/issues/5457).`);
  }
  const r = o.$hostElement$;
  const l = o._$$instanceValues$$_.get(t);
  const s = o._$$flags$$_;
  const f = o._$$lazyInstance$$_;
  n = parsePropertyValue(n, i._$$members$$_[t][0]);
  const a = Number.isNaN(l) && Number.isNaN(n);
  const c = n !== l && !a;
  if ((!(s & 8 /* isConstructingInstance */) || l === void 0) && c) {
    o._$$instanceValues$$_.set(t, n);
    if (f) {
      if (i._$$watchers$$_ && s & 128 /* isWatchReady */) {
        const e = i._$$watchers$$_[t];
        if (e) {
          e.map((e => {
            try {
              f[e](n, l, t);
            } catch (e) {
              consoleError(e, r);
            }
          }));
        }
      }
      if ((s & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
        if (f.componentShouldUpdate) {
          if (f.componentShouldUpdate(n, l, t) === false) {
            return;
          }
        }
        scheduleUpdate(o, false);
      }
    }
  }
};

// src/runtime/proxy-component.ts
var proxyComponent = (e, n, i) => {
  var o, r;
  const l = e.prototype;
  if (n._$$flags$$_ & 64 /* formAssociated */ && i & 1 /* isElementConstructor */) {
    $.forEach((e => {
      Object.defineProperty(l, e, {
        value(...t) {
          const n = getHostRef(this);
          const i = n._$$lazyInstance$$_;
          if (!i) {
            n._$$onReadyPromise$$_.then((n => {
              const i = n[e];
              typeof i === "function" && i.call(n, ...t);
            }));
          } else {
            const n = i[e];
            typeof n === "function" && n.call(i, ...t);
          }
        }
      });
    }));
  }
  if (n._$$members$$_ || (n._$$watchers$$_ || e.watchers)) {
    if (e.watchers && !n._$$watchers$$_) {
      n._$$watchers$$_ = e.watchers;
    }
    const s = Object.entries((o = n._$$members$$_) != null ? o : {});
    s.map((([e, [t]]) => {
      if (t & 31 /* Prop */ || i & 2 /* proxyState */ && t & 32 /* State */) {
        const {get: o, set: r} = Object.getOwnPropertyDescriptor(l, e) || {};
        if (o) n._$$members$$_[e][0] |= 2048 /* Getter */;
        if (r) n._$$members$$_[e][0] |= 4096 /* Setter */;
        if (i & 1 /* isElementConstructor */ || !o) {
          Object.defineProperty(l, e, {
            get() {
              {
                if ((n._$$members$$_[e][0] & 2048 /* Getter */) === 0) {
                  return getValue(this, e);
                }
                const t = getHostRef(this);
                const i = t ? t._$$lazyInstance$$_ : l;
                if (!i) return;
                return i[e];
              }
            },
            configurable: true,
            enumerable: true
          });
        }
        Object.defineProperty(l, e, {
          set(o) {
            const l = getHostRef(this);
            if (r) {
              const i = t & 32 /* State */ ? this[e] : l.$hostElement$[e];
              if (typeof i === "undefined" && l._$$instanceValues$$_.get(e)) {
                o = l._$$instanceValues$$_.get(e);
              } else if (!l._$$instanceValues$$_.get(e) && i) {
                l._$$instanceValues$$_.set(e, i);
              }
              r.apply(this, [ parsePropertyValue(o, t) ]);
              o = t & 32 /* State */ ? this[e] : l.$hostElement$[e];
              setValue(this, e, o, n);
              return;
            }
            {
              if ((i & 1 /* isElementConstructor */) === 0 || (n._$$members$$_[e][0] & 4096 /* Setter */) === 0) {
                setValue(this, e, o, n);
                if (i & 1 /* isElementConstructor */ && !l._$$lazyInstance$$_) {
                  l._$$onReadyPromise$$_.then((() => {
                    if (n._$$members$$_[e][0] & 4096 /* Setter */ && l._$$lazyInstance$$_[e] !== l._$$instanceValues$$_.get(e)) {
                      l._$$lazyInstance$$_[e] = o;
                    }
                  }));
                }
                return;
              }
              const setterSetVal = () => {
                const i = l._$$lazyInstance$$_[e];
                if (!l._$$instanceValues$$_.get(e) && i) {
                  l._$$instanceValues$$_.set(e, i);
                }
                l._$$lazyInstance$$_[e] = parsePropertyValue(o, t);
                setValue(this, e, l._$$lazyInstance$$_[e], n);
              };
              if (l._$$lazyInstance$$_) {
                setterSetVal();
              } else {
                l._$$onReadyPromise$$_.then((() => setterSetVal()));
              }
            }
          }
        });
      } else if (i & 1 /* isElementConstructor */ && t & 64 /* Method */) {
        Object.defineProperty(l, e, {
          value(...t) {
            var n;
            const i = getHostRef(this);
            return (n = i == null ? void 0 : i._$$onInstancePromise$$_) == null ? void 0 : n.then((() => {
              var n;
              return (n = i._$$lazyInstance$$_) == null ? void 0 : n[e](...t);
            }));
          }
        });
      }
    }));
    if (i & 1 /* isElementConstructor */) {
      const i =  new Map;
      l.attributeChangedCallback = function(e, o, r) {
        g.jmp((() => {
          var s;
          const f = i.get(e);
          if (this.hasOwnProperty(f) && t.lazyLoad) {
            r = this[f];
            delete this[f];
          } else if (l.hasOwnProperty(f) && typeof this[f] === "number" && // cast type to number to avoid TS compiler issues
          this[f] == r) {
            return;
          } else if (f == null) {
            const t = getHostRef(this);
            const i = t == null ? void 0 : t._$$flags$$_;
            if (i && !(i & 8 /* isConstructingInstance */) && i & 128 /* isWatchReady */ && r !== o) {
              const i = t._$$lazyInstance$$_;
              const l = (s = n._$$watchers$$_) == null ? void 0 : s[e];
              l == null ? void 0 : l.forEach((t => {
                if (i[t] != null) {
                  i[t].call(i, r, o, e);
                }
              }));
            }
            return;
          }
          const a = Object.getOwnPropertyDescriptor(l, f);
          r = r === null && typeof this[f] === "boolean" ? false : r;
          if (r !== this[f] && (!a.get || !!a.set)) {
            this[f] = r;
          }
        }));
      };
      e.observedAttributes = Array.from(
       new Set([ ...Object.keys((r = n._$$watchers$$_) != null ? r : {}), ...s.filter((([e, t]) => t[0] & 15 /* HasAttribute */)).map((([e, t]) => {
        var o;
        const r = t[1] || e;
        i.set(r, e);
        if (t[0] & 512 /* ReflectAttr */) {
          (o = n._$$attrsToReflect$$_) == null ? void 0 : o.push([ e, r ]);
        }
        return r;
      })) ]));
    }
  }
  return e;
};

// src/runtime/initialize-component.ts
var initializeComponent = async (e, t, n, i) => {
  let r;
  if ((t._$$flags$$_ & 32 /* hasInitializedComponent */) === 0) {
    t._$$flags$$_ |= 32 /* hasInitializedComponent */;
    const i = n._$$lazyBundleId$$_;
    if (i) {
      const i = loadModule(n, t);
      if (i && "then" in i) {
        const e = uniqueTime();
        r = await i;
        e();
      } else {
        r = i;
      }
      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 o = createTime("createInstance", n._$$tagName$$_);
      {
        t._$$flags$$_ |= 8 /* isConstructingInstance */