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

package/dist/webcomponents/p-3303bca8.system.js

@@ -0,0 +1,2340 @@
+var __extends = this && this.__extends || function() {
+  var extendStatics = function(r, e) {
+    extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function(r, e) {
+      r.__proto__ = e;
+    } || function(r, e) {
+      for (var n in e) if (Object.prototype.hasOwnProperty.call(e, n)) r[n] = e[n];
+    };
+    return extendStatics(r, e);
+  };
+  return function(r, e) {
+    if (typeof e !== "function" && e !== null) throw new TypeError("Class extends value " + String(e) + " is not a constructor or null");
+    extendStatics(r, e);
+    function __() {
+      this.constructor = r;
+    }
+    r.prototype = e === null ? Object.create(e) : (__.prototype = e.prototype, new __);
+  };
+}();
+
+var __assign = this && this.__assign || function() {
+  __assign = Object.assign || function(r) {
+    for (var e, n = 1, t = arguments.length; n < t; n++) {
+      e = arguments[n];
+      for (var i in e) if (Object.prototype.hasOwnProperty.call(e, i)) r[i] = e[i];
+    }
+    return r;
+  };
+  return __assign.apply(this, arguments);
+};
+
+var __awaiter = this && this.__awaiter || function(r, e, n, t) {
+  function adopt(r) {
+    return r instanceof n ? r : new n((function(e) {
+      e(r);
+    }));
+  }
+  return new (n || (n = Promise))((function(n, i) {
+    function fulfilled(r) {
+      try {
+        step(t.next(r));
+      } catch (r) {
+        i(r);
+      }
+    }
+    function rejected(r) {
+      try {
+        step(t["throw"](r));
+      } catch (r) {
+        i(r);
+      }
+    }
+    function step(r) {
+      r.done ? n(r.value) : adopt(r.value).then(fulfilled, rejected);
+    }
+    step((t = t.apply(r, e || [])).next());
+  }));
+};
+
+var __generator = this && this.__generator || function(r, e) {
+  var n = {
+    label: 0,
+    sent: function() {
+      if (a[0] & 1) throw a[1];
+      return a[1];
+    },
+    trys: [],
+    ops: []
+  }, t, i, a, f;
+  return f = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol === "function" && (f[Symbol.iterator] = function() {
+    return this;
+  }), f;
+  function verb(r) {
+    return function(e) {
+      return step([ r, e ]);
+    };
+  }
+  function step(u) {
+    if (t) throw new TypeError("Generator is already executing.");
+    while (f && (f = 0, u[0] && (n = 0)), n) try {
+      if (t = 1, i && (a = u[0] & 2 ? i["return"] : u[0] ? i["throw"] || ((a = i["return"]) && a.call(i), 
+      0) : i.next) && !(a = a.call(i, u[1])).done) return a;
+      if (i = 0, a) u = [ u[0] & 2, a.value ];
+      switch (u[0]) {
+       case 0:
+       case 1:
+        a = u;
+        break;
+
+       case 4:
+        n.label++;
+        return {
+          value: u[1],
+          done: false
+        };
+
+       case 5:
+        n.label++;
+        i = u[1];
+        u = [ 0 ];
+        continue;
+
+       case 7:
+        u = n.ops.pop();
+        n.trys.pop();
+        continue;
+
+       default:
+        if (!(a = n.trys, a = a.length > 0 && a[a.length - 1]) && (u[0] === 6 || u[0] === 2)) {
+          n = 0;
+          continue;
+        }
+        if (u[0] === 3 && (!a || u[1] > a[0] && u[1] < a[3])) {
+          n.label = u[1];
+          break;
+        }
+        if (u[0] === 6 && n.label < a[1]) {
+          n.label = a[1];
+          a = u;
+          break;
+        }
+        if (a && n.label < a[2]) {
+          n.label = a[2];
+          n.ops.push(u);
+          break;
+        }
+        if (a[2]) n.ops.pop();
+        n.trys.pop();
+        continue;
+      }
+      u = e.call(r, n);
+    } catch (r) {
+      u = [ 6, r ];
+      i = 0;
+    } finally {
+      t = a = 0;
+    }
+    if (u[0] & 5) throw u[1];
+    return {
+      value: u[0] ? u[1] : void 0,
+      done: true
+    };
+  }
+};
+
+var __spreadArray = this && this.__spreadArray || function(r, e, n) {
+  if (n || arguments.length === 2) for (var t = 0, i = e.length, a; t < i; t++) {
+    if (a || !(t in e)) {
+      if (!a) a = Array.prototype.slice.call(e, 0, t);
+      a[t] = e[t];
+    }
+  }
+  return r.concat(a || Array.prototype.slice.call(e));
+};
+
+/*!
+ * Construído com @govbr-ds/webcomponents
+ */ System.register([], (function(r, e) {
+  "use strict";
+  return {
+    execute: function() {
+      var n = this;
+      var t = "webcomponents";
+      var i = /* webcomponents */ {
+        allRenderFn: true,
+        appendChildSlotFix: true,
+        asyncLoading: true,
+        asyncQueue: false,
+        attachStyles: true,
+        cloneNodeFix: true,
+        cmpDidLoad: true,
+        cmpDidRender: false,
+        cmpDidUnload: false,
+        cmpDidUpdate: false,
+        cmpShouldUpdate: false,
+        cmpWillLoad: true,
+        cmpWillRender: false,
+        cmpWillUpdate: false,
+        connectedCallback: true,
+        constructableCSS: true,
+        cssAnnotations: true,
+        devTools: false,
+        disconnectedCallback: true,
+        element: false,
+        event: true,
+        experimentalScopedSlotChanges: false,
+        experimentalSlotFixes: false,
+        formAssociated: true,
+        hasRenderFn: true,
+        hostListener: true,
+        hostListenerTarget: true,
+        hostListenerTargetBody: false,
+        hostListenerTargetDocument: true,
+        hostListenerTargetParent: false,
+        hostListenerTargetWindow: true,
+        hotModuleReplacement: false,
+        hydrateClientSide: true,
+        hydrateServerSide: false,
+        hydratedAttribute: false,
+        hydratedClass: true,
+        hydratedSelectorName: "hydrated",
+        initializeNextTick: false,
+        invisiblePrehydration: true,
+        isDebug: true,
+        isDev: false,
+        isTesting: false,
+        lazyLoad: true,
+        lifecycle: true,
+        lifecycleDOMEvents: true,
+        member: true,
+        method: true,
+        mode: false,
+        observeAttribute: true,
+        profile: false,
+        prop: true,
+        propBoolean: true,
+        propMutable: true,
+        propNumber: true,
+        propString: true,
+        reflect: true,
+        scoped: false,
+        scopedSlotTextContentFix: false,
+        scriptDataOpts: false,
+        shadowDelegatesFocus: false,
+        shadowDom: true,
+        slot: true,
+        slotChildNodesFix: false,
+        slotRelocation: false,
+        state: true,
+        style: true,
+        svg: false,
+        taskQueue: true,
+        transformTagName: false,
+        updatable: true,
+        vdomAttribute: true,
+        vdomClass: true,
+        vdomFunctional: true,
+        vdomKey: true,
+        vdomListener: true,
+        vdomPropOrAttr: true,
+        vdomRef: true,
+        vdomRender: true,
+        vdomStyle: true,
+        vdomText: true,
+        vdomXlink: true,
+        watchCallback: true
+      };
+      /*
+             Stencil Client Platform v4.23.0 | MIT Licensed | https://stenciljs.com
+             */      var a = Object.defineProperty;
+      var __export = function(r, e) {
+        for (var n in e) a(r, n, {
+          get: e[n],
+          enumerable: true
+        });
+      };
+      var f =  new WeakMap;
+      var getHostRef = function(r) {
+        return f.get(r);
+      };
+      var u = r("r", (function(r, e) {
+        return f.set(e.t = r, e);
+      }));
+      var registerHost = function(r, e) {
+        var n = {
+          i: 0,
+          $hostElement$: r,
+          u: e,
+          o:  new Map
+        };
+        {
+          n.l = new Promise((function(r) {
+            return n.v = r;
+          }));
+        }
+        {
+          n.h = new Promise((function(r) {
+            return n.p = r;
+          }));
+          r["s-p"] = [];
+          r["s-rc"] = [];
+        }
+        return f.set(r, n);
+      };
+      var isMemberInElement = function(r, e) {
+        return e in r;
+      };
+      var consoleError = function(r, e) {
+        return (0, console.error)(r, e);
+      };
+      // src/client/client-load-module.ts
+            var o =  new Map;
+      var loadModule = function(r, n, t) {
+        var i = r.m.replace(/-/g, "_");
+        var a = r.$;
+        if (!a) {
+          return void 0;
+        }
+        var f = o.get(a);
+        if (f) {
+          return f[i];
+        }
+        /*!__STENCIL_STATIC_IMPORT_SWITCH__*/        return e.import(
+        /* @vite-ignore */
+        /* webpackInclude: /\.entry\.js$/ */
+        /* webpackExclude: /\.system\.entry\.js$/ */
+        /* webpackMode: "lazy" */
+        "./".concat(a, ".entry.js").concat("")).then((function(r) {
+          {
+            o.set(a, r);
+          }
+          return r[i];
+        }), consoleError);
+      };
+      // src/client/client-style.ts
+            var l =  new Map;
+      // src/runtime/runtime-constants.ts
+            var s = "r";
+      var v = "o";
+      var c = "s";
+      var d = "t";
+      var h = "c";
+      var p = "s-id";
+      var m = "sty-id";
+      var y = "c-id";
+      var $ = "{visibility:hidden}.hydrated{visibility:inherit}";
+      var b = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+      var w = "http://www.w3.org/1999/xlink";
+      var _ = [ "formAssociatedCallback", "formResetCallback", "formDisabledCallback", "formStateRestoreCallback" ];
+      var g = typeof window !== "undefined" ? window : {};
+      var S = g.document || {
+        head: {}
+      };
+      var k = r("H", g.HTMLElement || /** @class */ function() {
+        function HTMLElement() {}
+        return HTMLElement;
+      }());
+      var C = {
+        i: 0,
+        _: "",
+        jmp: function(r) {
+          return r();
+        },
+        raf: function(r) {
+          return requestAnimationFrame(r);
+        },
+        ael: function(r, e, n, t) {
+          return r.addEventListener(e, n, t);
+        },
+        rel: function(r, e, n, t) {
+          return r.removeEventListener(e, n, t);
+        },
+        ce: function(r, e) {
+          return new CustomEvent(r, e);
+        }
+      };
+      var j = i.shadowDom;
+      var A =  function() {
+        var r = false;
+        try {
+          S.addEventListener("e", null, Object.defineProperty({}, "passive", {
+            get: function() {
+              r = true;
+            }
+          }));
+        } catch (r) {}
+        return r;
+      }();
+      var x = r("p", (function(r) {
+        return Promise.resolve(r);
+      }));
+      var O =  function() {
+        try {
+          new CSSStyleSheet;
+          return typeof (new CSSStyleSheet).replaceSync === "function";
+        } catch (r) {}
+        return false;
+      }();
+      var E = false;
+      var T = [];
+      var D = [];
+      var queueTask = function(r, e) {
+        return function(n) {
+          r.push(n);
+          if (!E) {
+            E = true;
+            if (e && C.i & 4 /* queueSync */) {
+              nextTick(flush);
+            } else {
+              C.raf(flush);
+            }
+          }
+        };
+      };
+      var consume = function(r) {
+        for (var e = 0; e < r.length; e++) {
+          try {
+            r[e](performance.now());
+          } catch (r) {
+            consoleError(r);
+          }
+        }
+        r.length = 0;
+      };
+      var flush = function() {
+        consume(T);
+        {
+          consume(D);
+          if (E = T.length > 0) {
+            C.raf(flush);
+          }
+        }
+      };
+      var nextTick = function(r) {
+        return x().then(r);
+      };
+      var L =  queueTask(D, true);
+      // src/utils/constants.ts
+            var M = {};
+      // src/utils/helpers.ts
+            var isDef = function(r) {
+        return r != null;
+      };
+      var isComplexType = function(r) {
+        r = typeof r;
+        return r === "object" || r === "function";
+      };
+      // src/utils/query-nonce-meta-tag-content.ts
+            function queryNonceMetaTagContent(r) {
+        var e, n, t;
+        return (t = (n = (e = r.head) == null ? void 0 : e.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : n.getAttribute("content")) != null ? t : void 0;
+      }
+      // src/utils/result.ts
+            var N = {};
+      __export(N, {
+        err: function() {
+          return err;
+        },
+        map: function() {
+          return map;
+        },
+        ok: function() {
+          return ok;
+        },
+        unwrap: function() {
+          return unwrap;
+        },
+        unwrapErr: function() {
+          return unwrapErr;
+        }
+      });
+      var ok = function(r) {
+        return {
+          isOk: true,
+          isErr: false,
+          value: r
+        };
+      };
+      var err = function(r) {
+        return {
+          isOk: false,
+          isErr: true,
+          value: r
+        };
+      };
+      function map(r, e) {
+        if (r.isOk) {
+          var n = e(r.value);
+          if (n instanceof Promise) {
+            return n.then((function(r) {
+              return ok(r);
+            }));
+          } else {
+            return ok(n);
+          }
+        }
+        if (r.isErr) {
+          var t = r.value;
+          return err(t);
+        }
+        throw "should never get here";
+      }
+      var unwrap = function(r) {
+        if (r.isOk) {
+          return r.value;
+        } else {
+          throw r.value;
+        }
+      };
+      var unwrapErr = function(r) {
+        if (r.isErr) {
+          return r.value;
+        } else {
+          throw r.value;
+        }
+      };
+      var R = r("h", (function(r, e) {
+        var n = [];
+        for (var t = 2; t < arguments.length; t++) {
+          n[t - 2] = arguments[t];
+        }
+        var i = null;
+        var a = null;
+        var f = false;
+        var u = false;
+        var o = [];
+        var walk = function(e) {
+          for (var n = 0; n < e.length; n++) {
+            i = e[n];
+            if (Array.isArray(i)) {
+              walk(i);
+            } else if (i != null && typeof i !== "boolean") {
+              if (f = typeof r !== "function" && !isComplexType(i)) {
+                i = String(i);
+              }
+              if (f && u) {
+                o[o.length - 1].S += i;
+              } else {
+                o.push(f ? newVNode(null, i) : i);
+              }
+              u = f;
+            }
+          }
+        };
+        walk(n);
+        if (e) {
+          if (e.key) {
+            a = e.key;
+          }
+          {
+            var l = e.className || e.class;
+            if (l) {
+              e.class = typeof l !== "object" ? l : Object.keys(l).filter((function(r) {
+                return l[r];
+              })).join(" ");
+            }
+          }
+        }
+        if (typeof r === "function") {
+          return r(e === null ? {} : e, o, F);
+        }
+        var s = newVNode(r, null);
+        s.k = e;
+        if (o.length > 0) {
+          s.C = o;
+        }
+        {
+          s.j = a;
+        }
+        return s;
+      }));
+      var newVNode = function(r, e) {
+        var n = {
+          i: 0,
+          A: r,
+          S: e,
+          O: null,
+          C: null
+        };
+        {
+          n.k = null;
+        }
+        {
+          n.j = null;
+        }
+        return n;
+      };
+      var H = r("a", {});
+      var isHost = function(r) {
+        return r && r.A === H;
+      };
+      var F = {
+        forEach: function(r, e) {
+          return r.map(convertToPublic).forEach(e);
+        },
+        map: function(r, e) {
+          return r.map(convertToPublic).map(e).map(convertToPrivate);
+        }
+      };
+      var convertToPublic = function(r) {
+        return {
+          vattrs: r.k,
+          vchildren: r.C,
+          vkey: r.j,
+          vname: r.T,
+          vtag: r.A,
+          vtext: r.S
+        };
+      };
+      var convertToPrivate = function(r) {
+        if (typeof r.vtag === "function") {
+          var e = __assign({}, r.vattrs);
+          if (r.vkey) {
+            e.key = r.vkey;
+          }
+          if (r.vname) {
+            e.name = r.vname;
+          }
+          return R.apply(void 0, __spreadArray([ r.vtag, e ], r.vchildren || [], false));
+        }
+        var n = newVNode(r.vtag, r.vtext);
+        n.k = r.vattrs;
+        n.C = r.vchildren;
+        n.j = r.vkey;
+        n.T = r.vname;
+        return n;
+      };
+      var setAccessor = function(r, e, n, t, i, a) {
+        if (n !== t) {
+          var f = isMemberInElement(r, e);
+          var u = e.toLowerCase();
+          if (e === "class") {
+            var o = r.classList;
+            var l = parseClassList(n);
+            var s = parseClassList(t);
+            if (r["s-si"] && s.indexOf(r["s-si"]) < 0) {
+              s.push(r["s-si"]);
+            }
+            o.remove.apply(o, l.filter((function(r) {
+              return r && !s.includes(r);
+            })));
+            o.add.apply(o, s.filter((function(r) {
+              return r && !l.includes(r);
+            })));
+          } else if (e === "style") {
+            {
+              for (var v in n) {
+                if (!t || t[v] == null) {
+                  if (v.includes("-")) {
+                    r.style.removeProperty(v);
+                  } else {
+                    r.style[v] = "";
+                  }
+                }
+              }
+            }
+            for (var v in t) {
+              if (!n || t[v] !== n[v]) {
+                if (v.includes("-")) {
+                  r.style.setProperty(v, t[v]);
+                } else {
+                  r.style[v] = t[v];
+                }
+              }
+            }
+          } else if (e === "key") ; else if (e === "ref") {
+            if (t) {
+              t(r);
+            }
+          } else if (!f && e[0] === "o" && e[1] === "n") {
+            if (e[2] === "-") {
+              e = e.slice(3);
+            } else if (isMemberInElement(g, u)) {
+              e = u.slice(2);
+            } else {
+              e = u[2] + e.slice(3);
+            }
+            if (n || t) {
+              var c = e.endsWith(U);
+              e = e.replace(W, "");
+              if (n) {
+                C.rel(r, e, n, c);
+              }
+              if (t) {
+                C.ael(r, e, t, c);
+              }
+            }
+          } else {
+            var d = isComplexType(t);
+            if ((f || d && t !== null) && !i) {
+              try {
+                if (!r.tagName.includes("-")) {
+                  var h = t == null ? "" : t;
+                  if (e === "list") {
+                    f = false;
+                  } else if (n == null || r[e] != h) {
+                    if (typeof r.__lookupSetter__(e) === "function") {
+                      r[e] = h;
+                    } else {
+                      r.setAttribute(e, h);
+                    }
+                  }
+                } else {
+                  r[e] = t;
+                }
+              } catch (r) {}
+            }
+            var p = false;
+            {
+              if (u !== (u = u.replace(/^xlink\:?/, ""))) {
+                e = u;
+                p = true;
+              }
+            }
+            if (t == null || t === false) {
+              if (t !== false || r.getAttribute(e) === "") {
+                if (p) {
+                  r.removeAttributeNS(w, e);
+                } else {
+                  r.removeAttribute(e);
+                }
+              }
+            } else if ((!f || a & 4 /* isHost */ || i) && !d) {
+              t = t === true ? "" : t;
+              if (p) {
+                r.setAttributeNS(w, e, t);
+              } else {
+                r.setAttribute(e, t);
+              }
+            }
+          }
+        }
+      };
+      var P = /\s/;
+      var parseClassList = function(r) {
+        return !r ? [] : r.split(P);
+      };
+      var U = "Capture";
+      var W = new RegExp(U + "$");
+      // src/runtime/vdom/update-element.ts
+            var updateElement = function(r, e, n) {
+        var t = e.O.nodeType === 11 /* DocumentFragment */ && e.O.host ? e.O.host : e.O;
+        var i = r && r.k || M;
+        var a = e.k || M;
+        {
+          for (var f = 0, u = sortedAttrNames(Object.keys(i)); f < u.length; f++) {
+            var o = u[f];
+            if (!(o in a)) {
+              setAccessor(t, o, i[o], void 0, n, e.i);
+            }
+          }
+        }
+        for (var l = 0, s = sortedAttrNames(Object.keys(a)); l < s.length; l++) {
+          var o = s[l];
+          setAccessor(t, o, i[o], a[o], n, e.i);
+        }
+      };
+      function sortedAttrNames(r) {
+        return r.includes("ref") ? __spreadArray(__spreadArray([], r.filter((function(r) {
+          return r !== "ref";
+        })), true), [ "ref" ], false) : 
+        // no need to sort, return the original array
+        r;
+      }
+      // src/runtime/vdom/vdom-render.ts
+            var I;
+      var q;
+      var z = false;
+      var B = false;
+      var createElm = function(r, e, n, t) {
+        var a = e.C[n];
+        var f = 0;
+        var u;
+        var o;
+        if (a.S !== null) {
+          u = a.O = S.createTextNode(a.S);
+        } else {
+          u = a.O = S.createElement(!z && i.slotRelocation && a.i & 2 /* isSlotFallback */ ? "slot-fb" : a.A);
+          {
+            updateElement(null, a, B);
+          }
+          var l = u.getRootNode();
+          var s = !l.querySelector("body");
+          if (!s && i.scoped && isDef(I) && u["s-si"] !== I) {
+            u.classList.add(u["s-si"] = I);
+          }
+          if (a.C) {
+            for (f = 0; f < a.C.length; ++f) {
+              o = createElm(r, a, f);
+              if (o) {
+                u.appendChild(o);
+              }
+            }
+          }
+        }
+        u["s-hn"] = q;
+        return u;
+      };
+      var addVnodes = function(r, e, n, t, i, a) {
+        var f = r;
+        var u;
+        if (f.shadowRoot && f.tagName === q) {
+          f = f.shadowRoot;
+        }
+        for (;i <= a; ++i) {
+          if (t[i]) {
+            u = createElm(null, n, i);
+            if (u) {
+              t[i].O = u;
+              insertBefore(f, u, e);
+            }
+          }
+        }
+      };
+      var removeVnodes = function(r, e, n) {
+        for (var t = e; t <= n; ++t) {
+          var i = r[t];
+          if (i) {
+            var a = i.O;
+            nullifyVNodeRefs(i);
+            if (a) {
+              a.remove();
+            }
+          }
+        }
+      };
+      var updateChildren = function(r, e, n, t, i) {
+        if (i === void 0) {
+          i = false;
+        }
+        var a = 0;
+        var f = 0;
+        var u = 0;
+        var o = 0;
+        var l = e.length - 1;
+        var s = e[0];
+        var v = e[l];
+        var c = t.length - 1;
+        var d = t[0];
+        var h = t[c];
+        var p;
+        var m;
+        while (a <= l && f <= c) {
+          if (s == null) {
+            s = e[++a];
+          } else if (v == null) {
+            v = e[--l];
+          } else if (d == null) {
+            d = t[++f];
+          } else if (h == null) {
+            h = t[--c];
+          } else if (isSameVnode(s, d, i)) {
+            patch(s, d, i);
+            s = e[++a];
+            d = t[++f];
+          } else if (isSameVnode(v, h, i)) {
+            patch(v, h, i);
+            v = e[--l];
+            h = t[--c];
+          } else if (isSameVnode(s, h, i)) {
+            patch(s, h, i);
+            insertBefore(r, s.O, v.O.nextSibling);
+            s = e[++a];
+            h = t[--c];
+          } else if (isSameVnode(v, d, i)) {
+            patch(v, d, i);
+            insertBefore(r, v.O, s.O);
+            v = e[--l];
+            d = t[++f];
+          } else {
+            u = -1;
+            {
+              for (o = a; o <= l; ++o) {
+                if (e[o] && e[o].j !== null && e[o].j === d.j) {
+                  u = o;
+                  break;
+                }
+              }
+            }
+            if (u >= 0) {
+              m = e[u];
+              if (m.A !== d.A) {
+                p = createElm(e && e[f], n, u);
+              } else {
+                patch(m, d, i);
+                e[u] = void 0;
+                p = m.O;
+              }
+              d = t[++f];
+            } else {
+              p = createElm(e && e[f], n, f);
+              d = t[++f];
+            }
+            if (p) {
+              {
+                insertBefore(s.O.parentNode, p, s.O);
+              }
+            }
+          }
+        }
+        if (a > l) {
+          addVnodes(r, t[c + 1] == null ? null : t[c + 1].O, n, t, f, c);
+        } else if (f > c) {
+          removeVnodes(e, a, l);
+        }
+      };
+      var isSameVnode = function(r, e, n) {
+        if (n === void 0) {
+          n = false;
+        }
+        if (r.A === e.A) {
+          if (!n) {
+            return r.j === e.j;
+          }
+          return true;
+        }
+        return false;
+      };
+      var patch = function(r, e, n) {
+        if (n === void 0) {
+          n = false;
+        }
+        var t = e.O = r.O;
+        var a = r.C;
+        var f = e.C;
+        var u = e.A;
+        var o = e.S;
+        if (o === null) {
+          {
+            if (u === "slot" && !z) ; else {
+              updateElement(r, e, B);
+            }
+          }
+          if (a !== null && f !== null) {
+            updateChildren(t, a, e, f, n);
+          } else if (f !== null) {
+            if (r.S !== null) {
+              t.textContent = "";
+            }
+            addVnodes(t, null, e, f, 0, f.length - 1);
+          } else if (
+          // don't do this on initial render as it can cause non-hydrated content to be removed
+          !n && i.updatable && a !== null) {
+            removeVnodes(a, 0, a.length - 1);
+          }
+        } else if (r.S !== o) {
+          t.data = o;
+        }
+      };
+      var updateFallbackSlotVisibility = function(r) {
+        var e = r.__childNodes || r.childNodes;
+        for (var n = 0, t = e; n < t.length; n++) {
+          var i = t[n];
+          if (i.nodeType === 1 /* ElementNode */) {
+            if (i["s-sr"]) {
+              var a = i["s-sn"];
+              i.hidden = false;
+              for (var f = 0, u = e; f < u.length; f++) {
+                var o = u[f];
+                if (o !== i) {
+                  if (o["s-hn"] !== i["s-hn"] || a !== "") {
+                    if (o.nodeType === 1 /* ElementNode */ && (a === o.getAttribute("slot") || a === o["s-sn"]) || o.nodeType === 3 /* TextNode */ && a === o["s-sn"]) {
+                      i.hidden = true;
+                      break;
+                    }
+                  } else if (a === o["s-sn"]) {
+                    if (o.nodeType === 1 /* ElementNode */ || o.nodeType === 3 /* TextNode */ && o.textContent.trim() !== "") {
+                      i.hidden = true;
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            updateFallbackSlotVisibility(i);
+          }
+        }
+      };
+      var nullifyVNodeRefs = function(r) {
+        {
+          r.k && r.k.ref && r.k.ref(null);
+          r.C && r.C.map(nullifyVNodeRefs);
+        }
+      };
+      var insertBefore = function(r, e, n) {
+        var t = r == null ? void 0 : r.insertBefore(e, n);
+        return t;
+      };
+      var renderVdom = function(r, e, n) {
+        if (n === void 0) {
+          n = false;
+        }
+        var t = r.$hostElement$;
+        var i = r.u;
+        var a = r.D || newVNode(null, null);
+        var f = isHost(e) ? e : R(null, null, e);
+        q = t.tagName;
+        if (i.L) {
+          f.k = f.k || {};
+          i.L.map((function(r) {
+            var e = r[0], n = r[1];
+            return f.k[n] = t[e];
+          }));
+        }
+        if (n && f.k) {
+          for (var u = 0, o = Object.keys(f.k); u < o.length; u++) {
+            var l = o[u];
+            if (t.hasAttribute(l) && ![ "key", "ref", "style", "class" ].includes(l)) {
+              f.k[l] = t[l];
+            }
+          }
+        }
+        f.A = null;
+        f.i |= 4 /* isHost */;
+        r.D = f;
+        f.O = a.O = t.shadowRoot || t;
+        {
+          I = t["s-sc"];
+        }
+        z = (i.i & 1 /* shadowDomEncapsulation */) !== 0;
+        patch(a, f, n);
+      };
+      var patchCloneNode = function(r) {
+        var e = r.cloneNode;
+        r.cloneNode = function(r) {
+          var n = this;
+          var t = n.shadowRoot && j;
+          var i = e.call(n, t ? r : false);
+          if (!t && r) {
+            var a = 0;
+            var f = void 0, u = void 0;
+            var o = [ "s-id", "s-cr", "s-lr", "s-rc", "s-sc", "s-p", "s-cn", "s-sr", "s-sn", "s-hn", "s-ol", "s-nr", "s-si", "s-rf", "s-scs" ];
+            var l = this.__childNodes || this.childNodes;
+            for (;a < l.length; a++) {
+              f = l[a]["s-nr"];
+              u = o.every((function(r) {
+                return !l[a][r];
+              }));
+              if (f) {
+                if (i.__appendChild) {
+                  i.__appendChild(f.cloneNode(true));
+                } else {
+                  i.appendChild(f.cloneNode(true));
+                }
+              }
+              if (u) {
+                i.appendChild(l[a].cloneNode(true));
+              }
+            }
+          }
+          return i;
+        };
+      };
+      var patchSlotAppendChild = function(r) {
+        r.__appendChild = r.appendChild;
+        r.appendChild = function(r) {
+          var e = r["s-sn"] = getSlotName(r);
+          var n = getHostSlotNode(this.__childNodes || this.childNodes, e, this.tagName);
+          if (n) {
+            addSlotRelocateNode(r, n);
+            var t = getHostSlotChildNodes(n, e);
+            var i = t[t.length - 1];
+            var a = insertBefore(i.parentNode, r, i.nextSibling);
+            updateFallbackSlotVisibility(this);
+            return a;
+          }
+          return this.__appendChild(r);
+        };
+      };
+      var addSlotRelocateNode = function(r, e, n, t) {
+        var i;
+        if (r["s-ol"] && r["s-ol"].isConnected) {
+          i = r["s-ol"];
+        } else {
+          i = document.createTextNode("");
+          i["s-nr"] = r;
+        }
+        if (!e["s-cr"] || !e["s-cr"].parentNode) return;
+        var a = e["s-cr"].parentNode;
+        var f = n ? a.__prepend || a.prepend : a.__appendChild || a.appendChild;
+        if (typeof t !== "undefined") {
+          {
+            i["s-oo"] = t;
+            var u = a.__childNodes || a.childNodes;
+            var o = [ i ];
+            u.forEach((function(r) {
+              if (r["s-nr"]) o.push(r);
+            }));
+            o.sort((function(r, e) {
+              if (!r["s-oo"] || r["s-oo"] < e["s-oo"]) return -1; else if (!e["s-oo"] || e["s-oo"] < r["s-oo"]) return 1;
+              return 0;
+            }));
+            o.forEach((function(r) {
+              return f.call(a, r);
+            }));
+          }
+        } else {
+          f.call(a, i);
+        }
+        r["s-ol"] = i;
+        r["s-sh"] = e["s-hn"];
+      };
+      var getSlotName = function(r) {
+        return r["s-sn"] || r.nodeType === 1 && r.getAttribute("slot") || "";
+      };
+      var getHostSlotNode = function(r, e, n) {
+        var t = 0;
+        var i;
+        for (;t < r.length; t++) {
+          i = r[t];
+          if (i["s-sr"] && i["s-sn"] === e && i["s-hn"] === n) {
+            return i;
+          }
+          i = getHostSlotNode(i.childNodes, e, n);
+          if (i) {
+            return i;
+          }
+        }
+        return null;
+      };
+      var getHostSlotChildNodes = function(r, e) {
+        var n = [ r ];
+        while ((r = r.nextSibling) && r["s-sn"] === e) {
+          n.push(r);
+        }
+        return n;
+      };
+      var createTime = function(r, e) {
+        if (e === void 0) {
+          e = "";
+        }
+        {
+          return function() {
+            return;
+          };
+        }
+      };
+      var uniqueTime = function(r, e) {
+        {
+          return function() {
+            return;
+          };
+        }
+      };
+      // src/runtime/client-hydrate.ts
+            var initializeClientHydrate = function(r, e, n, t) {
+        var i = createTime("hydrateClient", e);
+        var a = r.shadowRoot;
+        var f = [];
+        var u = [];
+        var o = [];
+        var l = a ? [] : null;
+        var s = newVNode(e, null);
+        s.O = r;
+        if (!C.M) {
+          initializeDocumentHydrate(S.body, C.M =  new Map);
+        }
+        r[p] = n;
+        r.removeAttribute(p);
+        t.D = clientHydrate(s, f, u, l, r, r, n, o);
+        var v = 0;
+        var c = f.length;
+        var d;
+        for (v; v < c; v++) {
+          d = f[v];
+          var h = d.N + "." + d.R;
+          var m = C.M.get(h);
+          var y = d.O;
+          if (!a) {
+            y["s-hn"] = e.toUpperCase();
+            if (d.A === "slot") {
+              y["s-cr"] = r["s-cr"];
+            }
+          }
+          if (m && m.isConnected) {
+            if (a && m["s-en"] === "") {
+              m.parentNode.insertBefore(y, m.nextSibling);
+            }
+            m.parentNode.removeChild(m);
+            if (!a) {
+              y["s-oo"] = parseInt(d.R);
+            }
+          }
+          C.M.delete(h);
+        }
+        var $ = [];
+        var b = 0;
+        var w = o.length;
+        var _;
+        var g;
+        var k;
+        var j;
+        for (b; b < w; b++) {
+          _ = o[b];
+          if (!_ || !_.length) continue;
+          k = _.length;
+          g = 0;
+          for (g; g < k; g++) {
+            j = _[g];
+            if (!$[j.hostId]) {
+              $[j.hostId] = C.M.get(j.hostId);
+            }
+            if (!$[j.hostId]) continue;
+            var A = $[j.hostId];
+            if (!A.shadowRoot || !a) {
+              j.slot["s-cr"] = A["s-cr"];
+              if (!j.slot["s-cr"] && A.shadowRoot) {
+                j.slot["s-cr"] = A;
+              } else {
+                var x = A.__childNodes || A.childNodes;
+                j.slot["s-cr"] = x[0];
+              }
+              addSlotRelocateNode(j.node, j.slot, false, j.node["s-oo"]);
+            }
+            if (A.shadowRoot && j.node.parentElement !== A) {
+              A.appendChild(j.node);
+            }
+          }
+        }
+        if (a) {
+          var O = 0;
+          var E = l.length;
+          for (O; O < E; O++) {
+            a.appendChild(l[O]);
+          }
+          Array.from(r.childNodes).forEach((function(r) {
+            if (r.nodeType === 8 /* CommentNode */ && typeof r["s-sn"] !== "string") {
+              r.parentNode.removeChild(r);
+            }
+          }));
+        }
+        t.$hostElement$ = r;
+        i();
+      };
+      var clientHydrate = function(r, e, n, t, i, a, f, u) {
+        if (u === void 0) {
+          u = [];
+        }
+        var o;
+        var l;
+        var v;
+        var p;
+        var m = i["s-sc"];
+        if (a.nodeType === 1 /* ElementNode */) {
+          o = a.getAttribute(y);
+          if (o) {
+            l = o.split(".");
+            if (l[0] === f || l[0] === "0") {
+              v = createSimpleVNode({
+                i: 0,
+                N: l[0],
+                R: l[1],
+                H: l[2],
+                F: l[3],
+                A: a.tagName.toLowerCase(),
+                O: a,
+                // If we don't add the initial classes to the VNode, the first `vdom-render.ts` reconciliation will fail:
+                // client side changes before componentDidLoad will be ignored, `set-accessor.ts` will just take the element's initial classes
+                k: {
+                  class: a.className
+                }
+              });
+              e.push(v);
+              a.removeAttribute(y);
+              if (!r.C) {
+                r.C = [];
+              }
+              var $ = v.O.getAttribute("s-sn");
+              if (typeof $ === "string") {
+                if (v.A === "slot-fb") {
+                  addSlot($, l[2], v, a, r, e, n, t, u);
+                }
+                v.O["s-sn"] = $;
+                v.O.removeAttribute("s-sn");
+              }
+              if (v.F !== void 0) {
+                r.C[v.F] = v;
+              }
+              if (m) a["s-si"] = m;
+              r = v;
+              if (t && v.H === "0") {
+                t[v.F] = v.O;
+              }
+            }
+          }
+          if (a.shadowRoot) {
+            for (p = a.shadowRoot.childNodes.length - 1; p >= 0; p--) {
+              clientHydrate(r, e, n, t, i, a.shadowRoot.childNodes[p], f, u);
+            }
+          }
+          var b = a.__childNodes || a.childNodes;
+          for (p = b.length - 1; p >= 0; p--) {
+            clientHydrate(r, e, n, t, i, b[p], f, u);
+          }
+        } else if (a.nodeType === 8 /* CommentNode */) {
+          l = a.nodeValue.split(".");
+          if (l[1] === f || l[1] === "0") {
+            o = l[0];
+            v = createSimpleVNode({
+              N: l[1],
+              R: l[2],
+              H: l[3],
+              F: l[4] || "0",
+              O: a,
+              k: null,
+              C: null,
+              j: null,
+              T: null,
+              A: null,
+              S: null
+            });
+            if (o === d) {
+              v.O = a.nextSibling;
+              if (v.O && v.O.nodeType === 3 /* TextNode */) {
+                v.S = v.O.textContent;
+                e.push(v);
+                a.remove();
+                if (f === v.N) {
+                  if (!r.C) {
+                    r.C = [];
+                  }
+                  r.C[v.F] = v;
+                }
+                if (t && v.H === "0") {
+                  t[v.F] = v.O;
+                }
+              }
+            } else if (o === h) {
+              v.O = a.nextSibling;
+              if (v.O && v.O.nodeType === 8 /* CommentNode */) {
+                e.push(v);
+                a.remove();
+              }
+            } else if (v.N === f) {
+              if (o === c) {
+                v.A = "slot";
+                var $ = a["s-sn"] = v.T = l[5] || "";
+                addSlot($, l[2], v, a, r, e, n, t, u);
+              } else if (o === s) {
+                if (t) {
+                  a.remove();
+                }
+              }
+            }
+          }
+        } else if (r && r.A === "style") {
+          var w = newVNode(null, a.textContent);
+          w.O = a;
+          w.F = "0";
+          r.C = [ w ];
+        }
+        return r;
+      };
+      var initializeDocumentHydrate = function(r, e) {
+        if (r.nodeType === 1 /* ElementNode */) {
+          var n = r[p] || r.getAttribute(p);
+          if (n) {
+            e.set(n, r);
+          }
+          var t = 0;
+          if (r.shadowRoot) {
+            for (;t < r.shadowRoot.childNodes.length; t++) {
+              initializeDocumentHydrate(r.shadowRoot.childNodes[t], e);
+            }
+          }
+          var i = r.__childNodes || r.childNodes;
+          for (t = 0; t < i.length; t++) {
+            initializeDocumentHydrate(i[t], e);
+          }
+        } else if (r.nodeType === 8 /* CommentNode */) {
+          var a = r.nodeValue.split(".");
+          if (a[0] === v) {
+            e.set(a[1] + "." + a[2], r);
+            r.nodeValue = "";
+            r["s-en"] = a[3];
+          }
+        }
+      };
+      var createSimpleVNode = function(r) {
+        var e = {
+          i: 0,
+          N: null,
+          R: null,
+          H: null,
+          F: "0",
+          O: null,
+          k: null,
+          C: null,
+          j: null,
+          T: null,
+          A: null,
+          S: null
+        };
+        return __assign(__assign({}, e), r);
+      };
+      function addSlot(r, e, n, t, i, a, f, u, o) {
+        t["s-sr"] = true;
+        var l = (i == null ? void 0 : i.O) ? i.O["s-id"] || i.O.getAttribute("s-id") : "";
+        if (u) {
+          var s = n.O = S.createElement(n.A);
+          if (n.T) {
+            n.O.setAttribute("name", r);
+          }
+          if (l && l !== n.N) {
+            i.O.insertBefore(s, i.O.children[0]);
+          } else {
+            t.parentNode.insertBefore(n.O, t);
+          }
+          addSlottedNodes(o, e, r, t, n.N);
+          t.remove();
+          if (n.H === "0") {
+            u[n.F] = n.O;
+          }
+        } else {
+          var s = n.O;
+          var v = l && l !== n.N && i.O.shadowRoot;
+          addSlottedNodes(o, e, r, t, v ? l : n.N);
+          if (v) {
+            i.O.insertBefore(s, i.O.children[0]);
+          }
+          a.push(n);
+        }
+        f.push(n);
+        if (!i.C) {
+          i.C = [];
+        }
+        i.C[n.F] = n;
+      }
+      var addSlottedNodes = function(r, e, n, t, i) {
+        var a = t.nextSibling;
+        r[e] = r[e] || [];
+        while (a && ((a["getAttribute"] && a.getAttribute("slot") || a["s-sn"]) === n || n === "" && !a["s-sn"] && (a.nodeType === 8 /* CommentNode */ && a.nodeValue.indexOf(".") !== 1 || a.nodeType === 3 /* TextNode */))) {
+          a["s-sn"] = n;
+          r[e].push({
+            slot: t,
+            node: a,
+            hostId: i
+          });
+          a = a.nextSibling;
+        }
+      };
+      var parsePropertyValue = function(r, e) {
+        if (r != null && !isComplexType(r)) {
+          if (e & 4 /* Boolean */) {
+            return r === "false" ? false : r === "" || !!r;
+          }
+          if (e & 2 /* Number */) {
+            return parseFloat(r);
+          }
+          if (e & 1 /* String */) {
+            return String(r);
+          }
+          return r;
+        }
+        return r;
+      };
+      var G = r("g", (function(r) {
+        return getHostRef(r).$hostElement$;
+      }));
+      // src/runtime/event-emitter.ts
+            var Q = r("c", (function(r, e, n) {
+        var t = G(r);
+        return {
+          emit: function(r) {
+            return emitEvent(t, e, {
+              bubbles: !!(n & 4 /* Bubbles */),
+              composed: !!(n & 2 /* Composed */),
+              cancelable: !!(n & 1 /* Cancellable */),
+              detail: r
+            });
+          }
+        };
+      }));
+      var emitEvent = function(r, e, n) {
+        var t = C.ce(e, n);
+        r.dispatchEvent(t);
+        return t;
+      };
+      var K =  new WeakMap;
+      var registerStyle = function(r, e, n) {
+        var t = l.get(r);
+        if (O && n) {
+          t = t || new CSSStyleSheet;
+          if (typeof t === "string") {
+            t = e;
+          } else {
+            t.replaceSync(e);
+          }
+        } else {
+          t = e;
+        }
+        l.set(r, t);
+      };
+      var addStyle = function(r, e, n) {
+        var t;
+        var i = getScopeId(e);
+        var a = l.get(i);
+        r = r.nodeType === 11 /* DocumentFragment */ ? r : S;
+        if (a) {
+          if (typeof a === "string") {
+            r = r.head || r;
+            var f = K.get(r);
+            var u = void 0;
+            if (!f) {
+              K.set(r, f =  new Set);
+            }
+            if (!f.has(i)) {
+              if (r.host && (u = r.querySelector("[".concat(m, '="').concat(i, '"]')))) {
+                u.innerHTML = a;
+              } else {
+                u = S.createElement("style");
+                u.innerHTML = a;
+                var o = (t = C.P) != null ? t : queryNonceMetaTagContent(S);
+                if (o != null) {
+                  u.setAttribute("nonce", o);
+                }
+                if (!(e.i & 1 /* shadowDomEncapsulation */)) {
+                  if (r.nodeName === "HEAD") {
+                    var s = r.querySelectorAll("link[rel=preconnect]");
+                    var v = s.length > 0 ? s[s.length - 1].nextSibling : r.querySelector("style");
+                    r.insertBefore(u, v);
+                  } else if ("host" in r) {
+                    if (O) {
+                      var c = new CSSStyleSheet;
+                      c.replaceSync(a);
+                      r.adoptedStyleSheets = __spreadArray([ c ], r.adoptedStyleSheets, true);
+                    } else {
+                      var d = r.querySelector("style");
+                      if (d) {
+                        d.innerHTML = a + d.innerHTML;
+                      } else {
+                        r.prepend(u);
+                      }
+                    }
+                  } else {
+                    r.append(u);
+                  }
+                }
+                if (e.i & 1 /* shadowDomEncapsulation */ && r.nodeName !== "HEAD") {
+                  r.insertBefore(u, null);
+                }
+              }
+              if (e.i & 4 /* hasSlotRelocation */) {
+                u.innerHTML += b;
+              }
+              if (f) {
+                f.add(i);
+              }
+            }
+          } else if (!r.adoptedStyleSheets.includes(a)) {
+            r.adoptedStyleSheets = __spreadArray(__spreadArray([], r.adoptedStyleSheets, true), [ a ], false);
+          }
+        }
+        return i;
+      };
+      var attachStyles = function(r) {
+        var e = r.u;
+        var n = r.$hostElement$;
+        var t = e.i;
+        var i = createTime("attachStyles", e.m);
+        var a = addStyle(n.shadowRoot ? n.shadowRoot : n.getRootNode(), e);
+        if (t & 10 /* needsScopedEncapsulation */ && t & 2 /* scopedCssEncapsulation */) {
+          n["s-sc"] = a;
+          n.classList.add(a + "-h");
+        }
+        i();
+      };
+      var getScopeId = function(r, e) {
+        return "sc-" + r.m;
+      };
+      // src/runtime/update-component.ts
+            var attachToAncestor = function(r, e) {
+        if (e && !r.U && e["s-p"]) {
+          e["s-p"].push(new Promise((function(e) {
+            return r.U = e;
+          })));
+        }
+      };
+      var scheduleUpdate = function(r, e) {
+        {
+          r.i |= 16 /* isQueuedForUpdate */;
+        }
+        if (r.i & 4 /* isWaitingForChildren */) {
+          r.i |= 512 /* needsRerender */;
+          return;
+        }
+        attachToAncestor(r, r.W);
+        var dispatch = function() {
+          return dispatchHooks(r, e);
+        };
+        return L(dispatch);
+      };
+      var dispatchHooks = function(r, e) {
+        var n = r.$hostElement$;
+        var t = createTime("scheduleUpdate", r.u.m);
+        var i = r.t;
+        if (!i) {
+          throw new Error("Can't render component <".concat(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"));
+        }
+        var a;
+        if (e) {
+          {
+            r.i |= 256 /* isListenReady */;
+            if (r.I) {
+              r.I.map((function(r) {
+                var e = r[0], n = r[1];
+                return safeCall(i, e, n);
+              }));
+              r.I = void 0;
+            }
+          }
+          emitLifecycleEvent(n, "componentWillLoad");
+          {
+            a = safeCall(i, "componentWillLoad");
+          }
+        } else {
+          emitLifecycleEvent(n, "componentWillUpdate");
+        }
+        emitLifecycleEvent(n, "componentWillRender");
+        t();
+        return enqueue(a, (function() {
+          return updateComponent(r, i, e);
+        }));
+      };
+      var enqueue = function(r, e) {
+        return isPromisey(r) ? r.then(e).catch((function(r) {
+          console.error(r);
+          e();
+        })) : e();
+      };
+      var isPromisey = function(r) {
+        return r instanceof Promise || r && r.then && typeof r.then === "function";
+      };
+      var updateComponent = function(r, e, t) {
+        return __awaiter(n, void 0, void 0, (function() {
+          var n, i, a, f, u, o, l;
+          return __generator(this, (function(s) {
+            i = r.$hostElement$;
+            a = createTime("update", r.u.m);
+            f = i["s-rc"];
+            if (t) {
+              attachStyles(r);
+            }
+            u = createTime("render", r.u.m);
+            {
+              callRender(r, e, i, t);
+            }
+            if (f) {
+              f.map((function(r) {
+                return r();
+              }));
+              i["s-rc"] = void 0;
+            }
+            u();
+            a();
+            {
+              o = (n = i["s-p"]) != null ? n : [];
+              l = function() {
+                return postUpdateComponent(r);
+              };
+              if (o.length === 0) {
+                l();
+              } else {
+                Promise.all(o).then(l);
+                r.i |= 4 /* isWaitingForChildren */;
+                o.length = 0;
+              }
+            }
+            return [ 2 /*return*/ ];
+          }));
+        }));
+      };
+      var callRender = function(r, e, n, t) {
+        try {
+          e = e.render();
+          {
+            r.i &= ~16 /* isQueuedForUpdate */;
+          }
+          {
+            r.i |= 2 /* hasRendered */;
+          }
+          {
+            {
+              {
+                renderVdom(r, e, t);
+              }
+            }
+          }
+        } catch (e) {
+          consoleError(e, r.$hostElement$);
+        }
+        return null;
+      };
+      var postUpdateComponent = function(r) {
+        var e = r.u.m;
+        var n = r.$hostElement$;
+        var t = createTime("postUpdate", e);
+        var i = r.t;
+        var a = r.W;
+        emitLifecycleEvent(n, "componentDidRender");
+        if (!(r.i & 64 /* hasLoadedComponent */)) {
+          r.i |= 64 /* hasLoadedComponent */;
+          {
+            addHydratedFlag(n);
+          }
+          {
+            safeCall(i, "componentDidLoad");
+          }
+          emitLifecycleEvent(n, "componentDidLoad");
+          t();
+          {
+            r.p(n);
+            if (!a) {
+              appDidLoad();
+            }
+          }
+        } else {
+          emitLifecycleEvent(n, "componentDidUpdate");
+          t();
+        }
+        {
+          r.v(n);
+        }
+        {
+          if (r.U) {
+            r.U();
+            r.U = void 0;
+          }
+          if (r.i & 512 /* needsRerender */) {
+            nextTick((function() {
+              return scheduleUpdate(r, false);
+            }));
+          }
+          r.i &= ~(4 /* isWaitingForChildren */ | 512 /* needsRerender */);
+        }
+      };
+      var appDidLoad = function(r) {
+        {
+          addHydratedFlag(S.documentElement);
+        }
+        nextTick((function() {
+          return emitEvent(g, "appload", {
+            detail: {
+              namespace: t
+            }
+          });
+        }));
+      };
+      var safeCall = function(r, e, n) {
+        if (r && r[e]) {
+          try {
+            return r[e](n);
+          } catch (r) {
+            consoleError(r);
+          }
+        }
+        return void 0;
+      };
+      var emitLifecycleEvent = function(r, e) {
+        {
+          emitEvent(r, "stencil_" + e, {
+            bubbles: true,
+            composed: true,
+            detail: {
+              namespace: t
+            }
+          });
+        }
+      };
+      var addHydratedFlag = function(r) {
+        var e;
+        return r.classList.add((e = i.hydratedSelectorName) != null ? e : "hydrated");
+      };
+      // src/runtime/set-value.ts
+            var getValue = function(r, e) {
+        return getHostRef(r).o.get(e);
+      };
+      var setValue = function(r, e, n, t) {
+        var i = getHostRef(r);
+        if (!i) {
+          throw new Error("Couldn't find host element for \"".concat(t.m, '" as it is unknown to this Stencil runtime. This usually happens when integrating a 3rd party Stencil component with another Stencil component or application. Please reach out to the maintainers of the 3rd party Stencil component or report this on the Stencil Discord server (https://chat.stenciljs.com) or comment on this similar [GitHub issue](https://github.com/ionic-team/stencil/issues/5457).'));
+        }
+        var a = i.$hostElement$;
+        var f = i.o.get(e);
+        var u = i.i;
+        var o = i.t;
+        n = parsePropertyValue(n, t.q[e][0]);
+        var l = Number.isNaN(f) && Number.isNaN(n);
+        var s = n !== f && !l;
+        if ((!(u & 8 /* isConstructingInstance */) || f === void 0) && s) {
+          i.o.set(e, n);
+          if (o) {
+            if (t.B && u & 128 /* isWatchReady */) {
+              var v = t.B[e];
+              if (v) {
+                v.map((function(r) {
+                  try {
+                    o[r](n, f, e);
+                  } catch (r) {
+                    consoleError(r, a);
+                  }
+                }));
+              }
+            }
+            if ((u & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+              scheduleUpdate(i, false);
+            }
+          }
+        }
+      };
+      // src/runtime/proxy-component.ts
+            var proxyComponent = function(r, e, n) {
+        var t, i;
+        var a = r.prototype;
+        if (e.i & 64 /* formAssociated */ && n & 1 /* isElementConstructor */) {
+          _.forEach((function(r) {
+            Object.defineProperty(a, r, {
+              value: function() {
+                var e = [];
+                for (var n = 0; n < arguments.length; n++) {
+                  e[n] = arguments[n];
+                }
+                var t = getHostRef(this);
+                var i = t.t;
+                if (!i) {
+                  t.h.then((function(n) {
+                    var t = n[r];
+                    typeof t === "function" && t.call.apply(t, __spreadArray([ n ], e, false));
+                  }));
+                } else {
+                  var a = i[r];
+                  typeof a === "function" && a.call.apply(a, __spreadArray([ i ], e, false));
+                }
+              }
+            });
+          }));
+        }
+        if (e.q || (e.B || r.watchers)) {
+          if (r.watchers && !e.B) {
+            e.B = r.watchers;
+          }
+          var f = Object.entries((t = e.q) != null ? t : {});
+          f.map((function(r) {
+            var t = r[0], i = r[1][0];
+            if (i & 31 /* Prop */ || n & 2 /* proxyState */ && i & 32 /* State */) {
+              if ((i & 2048 /* Getter */) === 0) {
+                Object.defineProperty(a, t, {
+                  get: function() {
+                    return getValue(this, t);
+                  },
+                  set: function(r) {
+                    setValue(this, t, r, e);
+                  },
+                  configurable: true,
+                  enumerable: true
+                });
+              } else if (n & 1 /* isElementConstructor */ && i & 2048 /* Getter */) {
+                {
+                  Object.defineProperty(a, t, {
+                    get: function() {
+                      var r = getHostRef(this);
+                      var e = r ? r.t : a;
+                      if (!e) return;
+                      return e[t];
+                    },
+                    configurable: true,
+                    enumerable: true
+                  });
+                }
+                if (i & 4096 /* Setter */) {
+                  var f = Object.getOwnPropertyDescriptor(a, t).set;
+                  Object.defineProperty(a, t, {
+                    set: function(r) {
+                      var n = this;
+                      var i = getHostRef(this);
+                      if (f) {
+                        var a = i.$hostElement$[t];
+                        if (!i.o.get(t) && a) {
+                          i.o.set(t, a);
+                        }
+                        f.apply(this, [ parsePropertyValue(r, e.q[t][0]) ]);
+                        setValue(this, t, i.$hostElement$[t], e);
+                        return;
+                      }
+                      if (!i) return;
+                      var setterSetVal = function() {
+                        var a = i.t[t];
+                        if (!i.o.get(t) && a) {
+                          i.o.set(t, a);
+                        }
+                        i.t[t] = parsePropertyValue(r, e.q[t][0]);
+                        setValue(n, t, i.t[t], e);
+                      };
+                      if (i.t) {
+                        setterSetVal();
+                      } else {
+                        i.h.then((function() {
+                          return setterSetVal();
+                        }));
+                      }
+                    }
+                  });
+                }
+              }
+            } else if (n & 1 /* isElementConstructor */ && i & 64 /* Method */) {
+              Object.defineProperty(a, t, {
+                value: function() {
+                  var r = [];
+                  for (var e = 0; e < arguments.length; e++) {
+                    r[e] = arguments[e];
+                  }
+                  var n;
+                  var i = getHostRef(this);
+                  return (n = i == null ? void 0 : i.l) == null ? void 0 : n.then((function() {
+                    var e;
+                    return (e = i.t) == null ? void 0 : e[t].apply(e, r);
+                  }));
+                }
+              });
+            }
+          }));
+          if (n & 1 /* isElementConstructor */) {
+            var u =  new Map;
+            a.attributeChangedCallback = function(r, n, t) {
+              var i = this;
+              C.jmp((function() {
+                var f;
+                var o = u.get(r);
+                if (i.hasOwnProperty(o)) {
+                  t = i[o];
+                  delete i[o];
+                } else if (a.hasOwnProperty(o) && typeof i[o] === "number" && // cast type to number to avoid TS compiler issues
+                i[o] == t) {
+                  return;
+                } else if (o == null) {
+                  var l = getHostRef(i);
+                  var s = l == null ? void 0 : l.i;
+                  if (s && !(s & 8 /* isConstructingInstance */) && s & 128 /* isWatchReady */ && t !== n) {
+                    var v = l.t;
+                    var c = (f = e.B) == null ? void 0 : f[r];
+                    c == null ? void 0 : c.forEach((function(e) {
+                      if (v[e] != null) {
+                        v[e].call(v, t, n, r);
+                      }
+                    }));
+                  }
+                  return;
+                }
+                var d = Object.getOwnPropertyDescriptor(a, o);
+                if (!d.get || !!d.set) {
+                  i[o] = t === null && typeof i[o] === "boolean" ? false : t;
+                }
+              }));
+            };
+            r.observedAttributes = Array.from(
+             new Set(__spreadArray(__spreadArray([], Object.keys((i = e.B) != null ? i : {}), true), f.filter((function(r) {
+              var e = r[0], n = r[1];
+              return n[0] & 15;
+            } /* HasAttribute */)).map((function(r) {
+              var n = r[0], t = r[1];
+              var i;
+              var a = t[1] || n;
+              u.set(a, n);
+              if (t[0] & 512 /* ReflectAttr */) {
+                (i = e.L) == null ? void 0 : i.push([ n, a ]);
+              }
+              return a;
+            })), true)));
+          }
+        }
+        return r;
+      };
+      // src/runtime/initialize-component.ts
+            var initializeComponent = function(r, e, t, i) {
+        return __awaiter(n, void 0, void 0, (function() {
+          var n, i, a, f, u, o, s, v, c, d, h;
+          return __generator(this, (function(p) {
+            switch (p.label) {
+             case 0:
+              if (!((e.i & 32 /* hasInitializedComponent */) === 0)) return [ 3 /*break*/ , 6 ];
+              e.i |= 32 /* hasInitializedComponent */;
+              i = t.$;
+              if (!i) return [ 3 /*break*/ , 4 ];
+              a = loadModule(t);
+              if (!(a && "then" in a)) return [ 3 /*break*/ , 2 ];
+              f = uniqueTime();
+              return [ 4 /*yield*/ , a ];
+
+             case 1:
+              n = p.sent();
+              f();
+              return [ 3 /*break*/ , 3 ];
+
+             case 2:
+              n = a;
+              p.label = 3;
+
+             case 3:
+              if (!n) {
+                throw new Error('Constructor for "'.concat(t.m, "#").concat(e.G, '" was not found'));
+              }
+              if (!n.isProxied) {
+                {
+                  t.B = n.watchers;
+                }
+                proxyComponent(n, t, 2 /* proxyState */);
+                n.isProxied = true;
+              }
+              u = createTime("createInstance", t.m);
+              {
+                e.i |= 8 /* isConstructingInstance */;
+              }
+              try {
+                new n(e);
+              } catch (r) {
+                consoleError(r);
+              }
+              {
+                e.i &= ~8 /* isConstructingInstance */;
+              }
+              {
+                e.i |= 128 /* isWatchReady */;
+              }
+              u();
+              fireConnectedCallback(e.t);
+              return [ 3 /*break*/ , 5 ];
+
+             case 4:
+              n = r.constructor;
+              o = r.localName;
+              customElements.whenDefined(o).then((function() {
+                return e.i |= 128;
+              } /* isWatchReady */));
+              p.label = 5;
+
+             case 5:
+              if (n && n.style) {
+                s = void 0;
+                if (typeof n.style === "string") {
+                  s = n.style;
+                }
+                v = getScopeId(t);
+                if (!l.has(v)) {
+                  c = createTime("registerStyles", t.m);
+                  registerStyle(v, s, !!(t.i & 1 /* shadowDomEncapsulation */));
+                  c();
+                }
+              }
+              p.label = 6;
+
+             case 6:
+              d = e.W;
+              h = function() {
+                return scheduleUpdate(e, true);
+              };
+              if (d && d["s-rc"]) {
+                d["s-rc"].push(h);
+              } else {
+                h();
+              }
+              return [ 2 /*return*/ ];
+            }
+          }));
+        }));
+      };
+      var fireConnectedCallback = function(r) {
+        {
+          safeCall(r, "connectedCallback");
+        }
+      };
+      // src/runtime/connected-callback.ts
+            var connectedCallback = function(r) {
+        if ((C.i & 1 /* isTmpDisconnected */) === 0) {
+          var e = getHostRef(r);
+          var n = e.u;
+          var t = createTime("connectedCallback", n.m);
+          if (!(e.i & 1 /* hasConnected */)) {
+            e.i |= 1 /* hasConnected */;
+            var i = void 0;
+            {
+              i = r.getAttribute(p);
+              if (i) {
+                if (n.i & 1 /* shadowDomEncapsulation */) {
+                  var a = addStyle(r.shadowRoot, n);
+                  r.classList.remove(a + "-h", a + "-s");
+                }
+                initializeClientHydrate(r, n.m, i, e);
+              }
+            }
+            {
+              var f = r;
+              while (f = f.parentNode || f.host) {
+                if (f.nodeType === 1 /* ElementNode */ && f.hasAttribute("s-id") && f["s-p"] || f["s-p"]) {
+                  attachToAncestor(e, e.W = f);
+                  break;
+                }
+              }
+            }
+            if (n.q) {
+              Object.entries(n.q).map((function(e) {
+                var n = e[0], t = e[1][0];
+                if (t & 31 /* Prop */ && r.hasOwnProperty(n)) {
+                  var i = r[n];
+                  delete r[n];
+                  r[n] = i;
+                }
+              }));
+            }
+            {
+              initializeComponent(r, e, n);
+            }
+          } else {
+            addHostEventListeners(r, e, n.K);
+            if (e == null ? void 0 : e.t) {
+              fireConnectedCallback(e.t);
+            } else if (e == null ? void 0 : e.h) {
+              e.h.then((function() {
+                return fireConnectedCallback(e.t);
+              }));
+            }
+          }
+          t();
+        }
+      };
+      var disconnectInstance = function(r) {
+        {
+          safeCall(r, "disconnectedCallback");
+        }
+      };
+      var disconnectedCallback = function(r) {
+        return __awaiter(n, void 0, void 0, (function() {
+          var e;
+          return __generator(this, (function(n) {
+            if ((C.i & 1 /* isTmpDisconnected */) === 0) {
+              e = getHostRef(r);
+              {
+                if (e.V) {
+                  e.V.map((function(r) {
+                    return r();
+                  }));
+                  e.V = void 0;
+                }
+              }
+              if (e == null ? void 0 : e.t) {
+                disconnectInstance(e.t);
+              } else if (e == null ? void 0 : e.h) {
+                e.h.then((function() {
+                  return disconnectInstance(e.t);
+                }));
+              }
+            }
+            return [ 2 /*return*/ ];
+          }));
+        }));
+      };
+      // src/runtime/bootstrap-lazy.ts
+            var V = r("b", (function(r, e) {
+        if (e === void 0) {
+          e = {};
+        }
+        var n;
+        var t = createTime();
+        var i = [];
+        var a = e.exclude || [];
+        var f = g.customElements;
+        var u = S.head;
+        var o =  u.querySelector("meta[charset]");
+        var l =  S.createElement("style");
+        var s = [];
+        var v;
+        var c = true;
+        Object.assign(C, e);
+        C._ = new URL(e.resourcesUrl || "./", S.baseURI).href;
+        {
+          C.i |= 2 /* appLoaded */;
+        }
+        var d = false;
+        r.map((function(r) {
+          r[1].map((function(e) {
+            var n;
+            var t = {
+              i: e[0],
+              m: e[1],
+              q: e[2],
+              K: e[3]
+            };
+            if (t.i & 4 /* hasSlotRelocation */) {
+              d = true;
+            }
+            {
+              t.q = e[2];
+            }
+            {
+              t.K = e[3];
+            }
+            {
+              t.L = [];
+            }
+            {
+              t.B = (n = e[4]) != null ? n : {};
+            }
+            var u = t.m;
+            var o = /** @class */ function(r) {
+              __extends(HostElement, r);
+              // StencilLazyHost
+                            function HostElement(e) {
+                var n = r.call(this, e) || this;
+                n.hasRegisteredEventListeners = false;
+                e = n;
+                registerHost(e, t);
+                if (t.i & 1 /* shadowDomEncapsulation */) {
+                  {
+                    if (!e.shadowRoot) {
+                      {
+                        e.attachShadow({
+                          mode: "open"
+                        });
+                      }
+                    } else {
+                      if (e.shadowRoot.mode !== "open") {
+                        throw new Error("Unable to re-use existing shadow root for ".concat(t.m, "! Mode is set to ").concat(e.shadowRoot.mode, " but Stencil only supports open shadow roots."));
+                      }
+                    }
+                  }
+                }
+                return n;
+              }
+              HostElement.prototype.connectedCallback = function() {
+                var r = this;
+                var e = getHostRef(this);
+                if (!this.hasRegisteredEventListeners) {
+                  this.hasRegisteredEventListeners = true;
+                  addHostEventListeners(this, e, t.K);
+                }
+                if (v) {
+                  clearTimeout(v);
+                  v = null;
+                }
+                if (c) {
+                  s.push(this);
+                } else {
+                  C.jmp((function() {
+                    return connectedCallback(r);
+                  }));
+                }
+              };
+              HostElement.prototype.disconnectedCallback = function() {
+                var r = this;
+                C.jmp((function() {
+                  return disconnectedCallback(r);
+                }));
+              };
+              HostElement.prototype.componentOnReady = function() {
+                return getHostRef(this).h;
+              };
+              return HostElement;
+            }(HTMLElement);
+            {
+              {
+                patchCloneNode(o.prototype);
+              }
+              {
+                patchSlotAppendChild(o.prototype);
+              }
+            }
+            if (t.i & 64 /* formAssociated */) {
+              o.formAssociated = true;
+            }
+            t.$ = r[0];
+            if (!a.includes(u) && !f.get(u)) {
+              i.push(u);
+              f.define(u, proxyComponent(o, t, 1 /* isElementConstructor */));
+            }
+          }));
+        }));
+        if (i.length > 0) {
+          if (d) {
+            l.textContent += b;
+          }
+          {
+            l.textContent += i.sort() + $;
+          }
+          if (l.innerHTML.length) {
+            l.setAttribute("data-styles", "");
+            var h = (n = C.P) != null ? n : queryNonceMetaTagContent(S);
+            if (h != null) {
+              l.setAttribute("nonce", h);
+            }
+            u.insertBefore(l, o ? o.nextSibling : u.firstChild);
+          }
+        }
+        c = false;
+        if (s.length) {
+          s.map((function(r) {
+            return r.connectedCallback();
+          }));
+        } else {
+          {
+            C.jmp((function() {
+              return v = setTimeout(appDidLoad, 30);
+            }));
+          }
+        }
+        t();
+      }));
+      var addHostEventListeners = function(r, e, n, t) {
+        if (n) {
+          n.map((function(n) {
+            var t = n[0], i = n[1], a = n[2];
+            var f = getHostListenerTarget(r, t);
+            var u = hostListenerProxy(e, a);
+            var o = hostListenerOpts(t);
+            C.ael(f, i, u, o);
+            (e.V = e.V || []).push((function() {
+              return C.rel(f, i, u, o);
+            }));
+          }));
+        }
+      };
+      var hostListenerProxy = function(r, e) {
+        return function(n) {
+          var t;
+          try {
+            {
+              if (r.i & 256 /* isListenReady */) {
+                (t = r.t) == null ? void 0 : t[e](n);
+              } else {
+                (r.I = r.I || []).push([ e, n ]);
+              }
+            }
+          } catch (r) {
+            consoleError(r);
+          }
+        };
+      };
+      var getHostListenerTarget = function(r, e) {
+        if (e & 4 /* TargetDocument */) return S;
+        if (e & 8 /* TargetWindow */) return g;
+        return r;
+      };
+      var hostListenerOpts = function(r) {
+        return A ? {
+          passive: (r & 1 /* Passive */) !== 0,
+          capture: (r & 2 /* Capture */) !== 0
+        } : (r & 2 /* Capture */) !== 0;
+      };
+      // src/runtime/nonce.ts
+            var X = r("s", (function(r) {
+        return C.P = r;
+      }));
+    }
+  };
+}));
+//# sourceMappingURL=module.js.map
+//# sourceMappingURL=p-3303bca8.system.js.map