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

package/dist/webcomponents/p-CMdFJ4qj.system.js

@@ -0,0 +1,2512 @@
+var __extends = this && this.__extends || function() {
+  var extendStatics = function(r, n) {
+    extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function(r, n) {
+      r.__proto__ = n;
+    } || function(r, n) {
+      for (var e in n) if (Object.prototype.hasOwnProperty.call(n, e)) r[e] = n[e];
+    };
+    return extendStatics(r, n);
+  };
+  return function(r, n) {
+    if (typeof n !== "function" && n !== null) throw new TypeError("Class extends value " + String(n) + " is not a constructor or null");
+    extendStatics(r, n);
+    function __() {
+      this.constructor = r;
+    }
+    r.prototype = n === null ? Object.create(n) : (__.prototype = n.prototype, new __);
+  };
+}();
+
+var __assign = this && this.__assign || function() {
+  __assign = Object.assign || function(r) {
+    for (var n, e = 1, t = arguments.length; e < t; e++) {
+      n = arguments[e];
+      for (var i in n) if (Object.prototype.hasOwnProperty.call(n, i)) r[i] = n[i];
+    }
+    return r;
+  };
+  return __assign.apply(this, arguments);
+};
+
+var __awaiter = this && this.__awaiter || function(r, n, e, t) {
+  function adopt(r) {
+    return r instanceof e ? r : new e((function(n) {
+      n(r);
+    }));
+  }
+  return new (e || (e = Promise))((function(e, 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 ? e(r.value) : adopt(r.value).then(fulfilled, rejected);
+    }
+    step((t = t.apply(r, n || [])).next());
+  }));
+};
+
+var __generator = this && this.__generator || function(r, n) {
+  var e = {
+    label: 0,
+    sent: function() {
+      if (a[0] & 1) throw a[1];
+      return a[1];
+    },
+    trys: [],
+    ops: []
+  }, t, i, a, o;
+  return o = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol === "function" && (o[Symbol.iterator] = function() {
+    return this;
+  }), o;
+  function verb(r) {
+    return function(n) {
+      return step([ r, n ]);
+    };
+  }
+  function step(f) {
+    if (t) throw new TypeError("Generator is already executing.");
+    while (o && (o = 0, f[0] && (e = 0)), e) try {
+      if (t = 1, i && (a = f[0] & 2 ? i["return"] : f[0] ? i["throw"] || ((a = i["return"]) && a.call(i), 
+      0) : i.next) && !(a = a.call(i, f[1])).done) return a;
+      if (i = 0, a) f = [ f[0] & 2, a.value ];
+      switch (f[0]) {
+       case 0:
+       case 1:
+        a = f;
+        break;
+
+       case 4:
+        e.label++;
+        return {
+          value: f[1],
+          done: false
+        };
+
+       case 5:
+        e.label++;
+        i = f[1];
+        f = [ 0 ];
+        continue;
+
+       case 7:
+        f = e.ops.pop();
+        e.trys.pop();
+        continue;
+
+       default:
+        if (!(a = e.trys, a = a.length > 0 && a[a.length - 1]) && (f[0] === 6 || f[0] === 2)) {
+          e = 0;
+          continue;
+        }
+        if (f[0] === 3 && (!a || f[1] > a[0] && f[1] < a[3])) {
+          e.label = f[1];
+          break;
+        }
+        if (f[0] === 6 && e.label < a[1]) {
+          e.label = a[1];
+          a = f;
+          break;
+        }
+        if (a && e.label < a[2]) {
+          e.label = a[2];
+          e.ops.push(f);
+          break;
+        }
+        if (a[2]) e.ops.pop();
+        e.trys.pop();
+        continue;
+      }
+      f = n.call(r, e);
+    } catch (r) {
+      f = [ 6, r ];
+      i = 0;
+    } finally {
+      t = a = 0;
+    }
+    if (f[0] & 5) throw f[1];
+    return {
+      value: f[0] ? f[1] : void 0,
+      done: true
+    };
+  }
+};
+
+var __spreadArray = this && this.__spreadArray || function(r, n, e) {
+  if (e || arguments.length === 2) for (var t = 0, i = n.length, a; t < i; t++) {
+    if (a || !(t in n)) {
+      if (!a) a = Array.prototype.slice.call(n, 0, t);
+      a[t] = n[t];
+    }
+  }
+  return r.concat(a || Array.prototype.slice.call(n));
+};
+
+/*!
+ * Construído com @govbr-ds/webcomponents
+ */ System.register([], (function(r, n) {
+  "use strict";
+  return {
+    execute: function() {
+      var e = this;
+      var t = "webcomponents";
+      var i = /* webcomponents */ {
+        hydratedSelectorName: "hydrated",
+        lazyLoad: true,
+        updatable: true
+      };
+      /*
+             Stencil Client Platform v4.28.2 | MIT Licensed | https://stenciljs.com
+             */      var a = Object.defineProperty;
+      var __export = function(r, n) {
+        for (var e in n) a(r, e, {
+          get: n[e],
+          enumerable: true
+        });
+      };
+      // src/utils/es2022-rewire-class-members.ts
+            var reWireGetterSetter = function(r, n) {
+        var e;
+        var t = n.t;
+        var i = Object.entries((e = t.i) != null ? e : {});
+        i.map((function(e) {
+          var t = e[0], i = e[1][0];
+          if (i & 31 /* Prop */ || i & 32 /* State */) {
+            var a = r[t];
+            var o = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(r), t);
+            Object.defineProperty(r, t, {
+              get: function() {
+                return o.get.call(this);
+              },
+              set: function(r) {
+                o.set.call(this, r);
+              },
+              configurable: true,
+              enumerable: true
+            });
+            r[t] = n.o.has(t) ? n.o.get(t) : a;
+          }
+        }));
+      };
+      // src/client/client-host-ref.ts
+            var getHostRef = function(r) {
+        if (r.__stencil__getHostRef) {
+          return r.__stencil__getHostRef();
+        }
+        return void 0;
+      };
+      var o = r("r", (function(r, n) {
+        r.__stencil__getHostRef = function() {
+          return n;
+        };
+        n.u = r;
+        {
+          reWireGetterSetter(r, n);
+        }
+      }));
+      var registerHost = function(r, n) {
+        var e = {
+          l: 0,
+          $hostElement$: r,
+          t: n,
+          o:  new Map
+        };
+        {
+          e.v = new Promise((function(r) {
+            return e.h = r;
+          }));
+        }
+        {
+          e.p = new Promise((function(r) {
+            return e.m = r;
+          }));
+          r["s-p"] = [];
+          r["s-rc"] = [];
+        }
+        var t = e;
+        r.__stencil__getHostRef = function() {
+          return t;
+        };
+        return t;
+      };
+      var isMemberInElement = function(r, n) {
+        return n in r;
+      };
+      var consoleError = function(r, n) {
+        return (0, console.error)(r, n);
+      };
+      // src/client/client-load-module.ts
+            var f =  new Map;
+      var loadModule = function(r, e, t) {
+        var i = r.$.replace(/-/g, "_");
+        var a = r._;
+        if (!a) {
+          return void 0;
+        }
+        var o = f.get(a);
+        if (o) {
+          return o[i];
+        }
+        /*!__STENCIL_STATIC_IMPORT_SWITCH__*/        return n.import(
+        /* @vite-ignore */
+        /* webpackInclude: /\.entry\.js$/ */
+        /* webpackExclude: /\.system\.entry\.js$/ */
+        /* webpackMode: "lazy" */
+        "./".concat(a, ".entry.js").concat("")).then((function(r) {
+          {
+            f.set(a, r);
+          }
+          return r[i];
+        }), (function(r) {
+          consoleError(r, e.$hostElement$);
+        }));
+      };
+      // src/client/client-style.ts
+            var u =  new Map;
+      // src/runtime/runtime-constants.ts
+            var l = "r";
+      var v = "o";
+      var s = "s";
+      var c = "t";
+      var d = "c";
+      var h = "s-id";
+      var p = "sty-id";
+      var m = "c-id";
+      var y = "{visibility:hidden}.hydrated{visibility:inherit}";
+      var b = "slot-fb{display:contents}slot-fb[hidden]{display:none}";
+      var $ = "http://www.w3.org/1999/xlink";
+      var g = [ "formAssociatedCallback", "formResetCallback", "formDisabledCallback", "formStateRestoreCallback" ];
+      var w = typeof window !== "undefined" ? window : {};
+      var _ = r("H", w.HTMLElement || /** @class */ function() {
+        function HTMLElement() {}
+        return HTMLElement;
+      }());
+      var S = {
+        l: 0,
+        S: "",
+        jmp: function(r) {
+          return r();
+        },
+        raf: function(r) {
+          return requestAnimationFrame(r);
+        },
+        ael: function(r, n, e, t) {
+          return r.addEventListener(n, e, t);
+        },
+        rel: function(r, n, e, t) {
+          return r.removeEventListener(n, e, t);
+        },
+        ce: function(r, n) {
+          return new CustomEvent(r, n);
+        }
+      };
+      var j =  function() {
+        var r;
+        var n = false;
+        try {
+          (r = w.document) == null ? void 0 : r.addEventListener("e", null, Object.defineProperty({}, "passive", {
+            get: function() {
+              n = true;
+            }
+          }));
+        } catch (r) {}
+        return n;
+      }();
+      var O = r("p", (function(r) {
+        return Promise.resolve(r);
+      }));
+      var A =  function() {
+        try {
+          new CSSStyleSheet;
+          return typeof (new CSSStyleSheet).replaceSync === "function";
+        } catch (r) {}
+        return false;
+      }();
+      var E = false;
+      var C = [];
+      var N = [];
+      var queueTask = function(r, n) {
+        return function(e) {
+          r.push(e);
+          if (!E) {
+            E = true;
+            if (n && S.l & 4 /* queueSync */) {
+              nextTick(flush);
+            } else {
+              S.raf(flush);
+            }
+          }
+        };
+      };
+      var consume = function(r) {
+        for (var n = 0; n < r.length; n++) {
+          try {
+            r[n](performance.now());
+          } catch (r) {
+            consoleError(r);
+          }
+        }
+        r.length = 0;
+      };
+      var flush = function() {
+        consume(C);
+        {
+          consume(N);
+          if (E = C.length > 0) {
+            S.raf(flush);
+          }
+        }
+      };
+      var nextTick = function(r) {
+        return O().then(r);
+      };
+      var k =  queueTask(N, true);
+      var isComplexType = function(r) {
+        r = typeof r;
+        return r === "object" || r === "function";
+      };
+      // src/utils/query-nonce-meta-tag-content.ts
+            function queryNonceMetaTagContent(r) {
+        var n, e, t;
+        return (t = (e = (n = r.head) == null ? void 0 : n.querySelector('meta[name="csp-nonce"]')) == null ? void 0 : e.getAttribute("content")) != null ? t : void 0;
+      }
+      // src/utils/result.ts
+            var x = {};
+      __export(x, {
+        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, n) {
+        if (r.isOk) {
+          var e = n(r.value);
+          if (e instanceof Promise) {
+            return e.then((function(r) {
+              return ok(r);
+            }));
+          } else {
+            return ok(e);
+          }
+        }
+        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 getSlottedChildNodes = function(r) {
+        var n = [];
+        for (var e = 0; e < r.length; e++) {
+          var t = r[e]["s-nr"] || void 0;
+          if (t && t.isConnected) {
+            n.push(t);
+          }
+        }
+        return n;
+      };
+      function getHostSlotNodes(r, n, e) {
+        var t = 0;
+        var i = [];
+        var a;
+        for (;t < r.length; t++) {
+          a = r[t];
+          if (a["s-sr"] && (!n || a["s-hn"] === n) && (e === void 0 || getSlotName(a) === e)) {
+            i.push(a);
+            if (typeof e !== "undefined") return i;
+          }
+          i = __spreadArray(__spreadArray([], i, true), getHostSlotNodes(a.childNodes, n, e), true);
+        }
+        return i;
+      }
+      var addSlotRelocateNode = function(r, n, e, t) {
+        if (r["s-ol"] && r["s-ol"].isConnected) {
+          return;
+        }
+        var i = document.createTextNode("");
+        i["s-nr"] = r;
+        if (!n["s-cr"] || !n["s-cr"].parentNode) return;
+        var a = n["s-cr"].parentNode;
+        var o = internalCall(a, "appendChild");
+        if (typeof t !== "undefined") {
+          i["s-oo"] = t;
+          var f = internalCall(a, "childNodes");
+          var u = [ i ];
+          f.forEach((function(r) {
+            if (r["s-nr"]) u.push(r);
+          }));
+          u.sort((function(r, n) {
+            if (!r["s-oo"] || r["s-oo"] < (n["s-oo"] || 0)) return -1; else if (!n["s-oo"] || n["s-oo"] < r["s-oo"]) return 1;
+            return 0;
+          }));
+          u.forEach((function(r) {
+            return o.call(a, r);
+          }));
+        } else {
+          o.call(a, i);
+        }
+        r["s-ol"] = i;
+        r["s-sh"] = n["s-hn"];
+      };
+      var getSlotName = function(r) {
+        return typeof r["s-sn"] === "string" ? r["s-sn"] : r.nodeType === 1 && r.getAttribute("slot") || void 0;
+      };
+      function patchSlotNode(r) {
+        if (r.assignedElements || r.assignedNodes || !r["s-sr"]) return;
+        var assignedFactory = function(n) {
+          return function(r) {
+            var e = [];
+            var t = this["s-sn"];
+            if (r == null ? void 0 : r.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        ");
+            }
+            var i = this["s-cr"].parentElement;
+            var a = i.__childNodes ? i.childNodes : getSlottedChildNodes(i.childNodes);
+            a.forEach((function(r) {
+              if (t === getSlotName(r)) {
+                e.push(r);
+              }
+            }));
+            if (n) {
+              return e.filter((function(r) {
+                return r.nodeType === 1;
+              } /* ElementNode */));
+            }
+            return e;
+          }.bind(r);
+        };
+        r.assignedElements = assignedFactory(true);
+        r.assignedNodes = assignedFactory(false);
+      }
+      function dispatchSlotChangeEvent(r) {
+        r.dispatchEvent(new CustomEvent("slotchange", {
+          bubbles: false,
+          cancelable: false,
+          composed: false
+        }));
+      }
+      function findSlotFromSlottedNode(r, n) {
+        var e;
+        n = n || ((e = r["s-ol"]) == null ? void 0 : e.parentElement);
+        if (!n) return {
+          slotNode: null,
+          slotName: ""
+        };
+        var t = r["s-sn"] = getSlotName(r) || "";
+        var i = internalCall(n, "childNodes");
+        var a = getHostSlotNodes(i, n.tagName, t)[0];
+        return {
+          slotNode: a,
+          slotName: t
+        };
+      }
+      var patchSlottedNode = function(r) {
+        if (!r || r.__nextSibling !== void 0 || !globalThis.Node) return;
+        patchNextSibling(r);
+        patchPreviousSibling(r);
+        patchParentNode(r);
+        if (r.nodeType === Node.ELEMENT_NODE) {
+          patchNextElementSibling(r);
+          patchPreviousElementSibling(r);
+        }
+      };
+      var patchNextSibling = function(r) {
+        if (!r || r.__nextSibling) return;
+        patchHostOriginalAccessor("nextSibling", r);
+        Object.defineProperty(r, "nextSibling", {
+          get: function() {
+            var r;
+            var n = (r = this["s-ol"]) == null ? void 0 : r.parentNode.childNodes;
+            var e = n == null ? void 0 : n.indexOf(this);
+            if (n && e > -1) {
+              return n[e + 1];
+            }
+            return this.__nextSibling;
+          }
+        });
+      };
+      var patchNextElementSibling = function(r) {
+        if (!r || r.__nextElementSibling) return;
+        patchHostOriginalAccessor("nextElementSibling", r);
+        Object.defineProperty(r, "nextElementSibling", {
+          get: function() {
+            var r;
+            var n = (r = this["s-ol"]) == null ? void 0 : r.parentNode.children;
+            var e = n == null ? void 0 : n.indexOf(this);
+            if (n && e > -1) {
+              return n[e + 1];
+            }
+            return this.__nextElementSibling;
+          }
+        });
+      };
+      var patchPreviousSibling = function(r) {
+        if (!r || r.__previousSibling) return;
+        patchHostOriginalAccessor("previousSibling", r);
+        Object.defineProperty(r, "previousSibling", {
+          get: function() {
+            var r;
+            var n = (r = this["s-ol"]) == null ? void 0 : r.parentNode.childNodes;
+            var e = n == null ? void 0 : n.indexOf(this);
+            if (n && e > -1) {
+              return n[e - 1];
+            }
+            return this.__previousSibling;
+          }
+        });
+      };
+      var patchPreviousElementSibling = function(r) {
+        if (!r || r.__previousElementSibling) return;
+        patchHostOriginalAccessor("previousElementSibling", r);
+        Object.defineProperty(r, "previousElementSibling", {
+          get: function() {
+            var r;
+            var n = (r = this["s-ol"]) == null ? void 0 : r.parentNode.children;
+            var e = n == null ? void 0 : n.indexOf(this);
+            if (n && e > -1) {
+              return n[e - 1];
+            }
+            return this.__previousElementSibling;
+          }
+        });
+      };
+      var patchParentNode = function(r) {
+        if (!r || r.__parentNode) return;
+        patchHostOriginalAccessor("parentNode", r);
+        Object.defineProperty(r, "parentNode", {
+          get: function() {
+            var r;
+            return ((r = this["s-ol"]) == null ? void 0 : r.parentNode) || this.__parentNode;
+          },
+          set: function(r) {
+            this.__parentNode = r;
+          }
+        });
+      };
+      var H = [ "children", "nextElementSibling", "previousElementSibling" ];
+      var M = [ "childNodes", "firstChild", "lastChild", "nextSibling", "previousSibling", "textContent", "parentNode" ];
+      function patchHostOriginalAccessor(r, n) {
+        var e;
+        if (H.includes(r)) {
+          e = Object.getOwnPropertyDescriptor(Element.prototype, r);
+        } else if (M.includes(r)) {
+          e = Object.getOwnPropertyDescriptor(Node.prototype, r);
+        }
+        if (!e) {
+          e = Object.getOwnPropertyDescriptor(n, r);
+        }
+        if (e) Object.defineProperty(n, "__" + r, e);
+      }
+      function internalCall(r, n) {
+        if ("__" + n in r) {
+          var e = r["__" + n];
+          if (typeof e !== "function") return e;
+          return e.bind(r);
+        } else {
+          if (typeof r[n] !== "function") return r[n];
+          return r[n].bind(r);
+        }
+      }
+      var createTime = function(r, n) {
+        if (n === void 0) {
+          n = "";
+        }
+        {
+          return function() {
+            return;
+          };
+        }
+      };
+      var uniqueTime = function(r, n) {
+        {
+          return function() {
+            return;
+          };
+        }
+      };
+      var T = r("h", (function(r, n) {
+        var e = [];
+        for (var t = 2; t < arguments.length; t++) {
+          e[t - 2] = arguments[t];
+        }
+        var i = null;
+        var a = null;
+        var o = false;
+        var f = false;
+        var u = [];
+        var walk = function(n) {
+          for (var e = 0; e < n.length; e++) {
+            i = n[e];
+            if (Array.isArray(i)) {
+              walk(i);
+            } else if (i != null && typeof i !== "boolean") {
+              if (o = typeof r !== "function" && !isComplexType(i)) {
+                i = String(i);
+              }
+              if (o && f) {
+                u[u.length - 1].j += i;
+              } else {
+                u.push(o ? newVNode(null, i) : i);
+              }
+              f = o;
+            }
+          }
+        };
+        walk(e);
+        if (n) {
+          if (n.key) {
+            a = n.key;
+          }
+          {
+            var l = n.className || n.class;
+            if (l) {
+              n.class = typeof l !== "object" ? l : Object.keys(l).filter((function(r) {
+                return l[r];
+              })).join(" ");
+            }
+          }
+        }
+        if (typeof r === "function") {
+          return r(n === null ? {} : n, u, D);
+        }
+        var v = newVNode(r, null);
+        v.O = n;
+        if (u.length > 0) {
+          v.A = u;
+        }
+        {
+          v.C = a;
+        }
+        return v;
+      }));
+      var newVNode = function(r, n) {
+        var e = {
+          l: 0,
+          N: r,
+          j: n,
+          k: null,
+          A: null
+        };
+        {
+          e.O = null;
+        }
+        {
+          e.C = null;
+        }
+        return e;
+      };
+      var I = r("a", {});
+      var isHost = function(r) {
+        return r && r.N === I;
+      };
+      var D = {
+        forEach: function(r, n) {
+          return r.map(convertToPublic).forEach(n);
+        },
+        map: function(r, n) {
+          return r.map(convertToPublic).map(n).map(convertToPrivate);
+        }
+      };
+      var convertToPublic = function(r) {
+        return {
+          vattrs: r.O,
+          vchildren: r.A,
+          vkey: r.C,
+          vname: r.H,
+          vtag: r.N,
+          vtext: r.j
+        };
+      };
+      var convertToPrivate = function(r) {
+        if (typeof r.vtag === "function") {
+          var n = __assign({}, r.vattrs);
+          if (r.vkey) {
+            n.key = r.vkey;
+          }
+          if (r.vname) {
+            n.name = r.vname;
+          }
+          return T.apply(void 0, __spreadArray([ r.vtag, n ], r.vchildren || [], false));
+        }
+        var e = newVNode(r.vtag, r.vtext);
+        e.O = r.vattrs;
+        e.A = r.vchildren;
+        e.C = r.vkey;
+        e.H = r.vname;
+        return e;
+      };
+      // src/runtime/client-hydrate.ts
+            var initializeClientHydrate = function(r, n, e, t) {
+        var i = createTime("hydrateClient", n);
+        var a = r.shadowRoot;
+        var o = [];
+        var f = [];
+        var u = [];
+        var l = a ? [] : null;
+        var v = newVNode(n, null);
+        v.k = r;
+        if (w.document && (!S.M || !S.M.size)) {
+          initializeDocumentHydrate(w.document.body, S.M =  new Map);
+        }
+        r[h] = e;
+        r.removeAttribute(h);
+        t.T = clientHydrate(v, o, f, l, r, r, e, u);
+        var s = 0;
+        var c = o.length;
+        var d;
+        for (s; s < c; s++) {
+          d = o[s];
+          var p = d.I + "." + d.D;
+          var m = S.M.get(p);
+          var y = d.k;
+          if (!a) {
+            y["s-hn"] = n.toUpperCase();
+            if (d.N === "slot") {
+              y["s-cr"] = r["s-cr"];
+            }
+          }
+          if (d.N === "slot") {
+            d.H = d.k["s-sn"] || d.k["name"] || null;
+            if (d.A) {
+              d.l |= 2 /* isSlotFallback */;
+              if (!d.k.childNodes.length) {
+                d.A.forEach((function(r) {
+                  d.k.appendChild(r.k);
+                }));
+              }
+            } else {
+              d.l |= 1 /* isSlotReference */;
+            }
+          }
+          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.D);
+            }
+          }
+          S.M.delete(p);
+        }
+        var b = [];
+        var $ = u.length;
+        var g = 0;
+        var _;
+        var j;
+        var O;
+        var A;
+        for (g; g < $; g++) {
+          _ = u[g];
+          if (!_ || !_.length) continue;
+          O = _.length;
+          j = 0;
+          for (j; j < O; j++) {
+            A = _[j];
+            if (!b[A.hostId]) {
+              b[A.hostId] = S.M.get(A.hostId);
+            }
+            if (!b[A.hostId]) continue;
+            var E = b[A.hostId];
+            if (!E.shadowRoot || !a) {
+              A.slot["s-cr"] = E["s-cr"];
+              if (!A.slot["s-cr"] && E.shadowRoot) {
+                A.slot["s-cr"] = E;
+              } else {
+                A.slot["s-cr"] = (E.__childNodes || E.childNodes)[0];
+              }
+              addSlotRelocateNode(A.node, A.slot, false, A.node["s-oo"]);
+              {
+                patchSlottedNode(A.node);
+              }
+            }
+            if (E.shadowRoot && A.node.parentElement !== E) {
+              E.appendChild(A.node);
+            }
+          }
+        }
+        if (a && !a.childNodes.length) {
+          var C = 0;
+          var N = l.length;
+          if (N) {
+            for (C; C < N; C++) {
+              a.appendChild(l[C]);
+            }
+            Array.from(r.childNodes).forEach((function(r) {
+              if (typeof r["s-sn"] !== "string") {
+                if (r.nodeType === 1 /* ElementNode */ && r.slot && r.hidden) {
+                  r.removeAttribute("hidden");
+                } else if (r.nodeType === 8 /* CommentNode */ || r.nodeType === 3 /* TextNode */ && !r.wholeText.trim()) {
+                  r.parentNode.removeChild(r);
+                }
+              }
+            }));
+          }
+        }
+        S.M.delete(r["s-id"]);
+        t.$hostElement$ = r;
+        i();
+      };
+      var clientHydrate = function(r, n, e, t, i, a, o, f) {
+        if (f === void 0) {
+          f = [];
+        }
+        var u;
+        var v;
+        var h;
+        var p;
+        if (a.nodeType === 1 /* ElementNode */) {
+          u = a.getAttribute(m);
+          if (u) {
+            v = u.split(".");
+            if (v[0] === o || v[0] === "0") {
+              h = createSimpleVNode({
+                l: 0,
+                I: v[0],
+                D: v[1],
+                P: v[2],
+                U: v[3],
+                N: a.tagName.toLowerCase(),
+                k: a,
+                // If we don't add the initial classes to the VNode, the first `vdom-render.ts` patch
+                // won't try to reconcile them. Classes set on the node will be blown away.
+                O: {
+                  class: a.className || ""
+                }
+              });
+              n.push(h);
+              a.removeAttribute(m);
+              if (!r.A) {
+                r.A = [];
+              }
+              var y = h.k.getAttribute("s-sn");
+              if (typeof y === "string") {
+                if (h.N === "slot-fb") {
+                  addSlot(y, v[2], h, a, r, n, e, t, f);
+                }
+                h.k["s-sn"] = y;
+                h.k.removeAttribute("s-sn");
+              }
+              if (h.U !== void 0) {
+                r.A[h.U] = h;
+              }
+              r = h;
+              if (t && h.P === "0") {
+                t[h.U] = h.k;
+              }
+            }
+          }
+          if (a.shadowRoot) {
+            for (p = a.shadowRoot.childNodes.length - 1; p >= 0; p--) {
+              clientHydrate(r, n, e, t, i, a.shadowRoot.childNodes[p], o, f);
+            }
+          }
+          var b = a.__childNodes || a.childNodes;
+          for (p = b.length - 1; p >= 0; p--) {
+            clientHydrate(r, n, e, t, i, b[p], o, f);
+          }
+        } else if (a.nodeType === 8 /* CommentNode */) {
+          v = a.nodeValue.split(".");
+          if (v[1] === o || v[1] === "0") {
+            u = v[0];
+            h = createSimpleVNode({
+              I: v[1],
+              D: v[2],
+              P: v[3],
+              U: v[4] || "0",
+              k: a,
+              O: null,
+              A: null,
+              C: null,
+              H: null,
+              N: null,
+              j: null
+            });
+            if (u === c) {
+              h.k = findCorrespondingNode(a, 3 /* TextNode */);
+              if (h.k && h.k.nodeType === 3 /* TextNode */) {
+                h.j = h.k.textContent;
+                n.push(h);
+                a.remove();
+                if (o === h.I) {
+                  if (!r.A) {
+                    r.A = [];
+                  }
+                  r.A[h.U] = h;
+                }
+                if (t && h.P === "0") {
+                  t[h.U] = h.k;
+                }
+              }
+            } else if (u === d) {
+              h.k = findCorrespondingNode(a, 8 /* CommentNode */);
+              if (h.k && h.k.nodeType === 8 /* CommentNode */) {
+                n.push(h);
+                a.remove();
+              }
+            } else if (h.I === o) {
+              if (u === s) {
+                var y = a["s-sn"] = v[5] || "";
+                addSlot(y, v[2], h, a, r, n, e, t, f);
+              } else if (u === l) {
+                if (t) {
+                  a.remove();
+                }
+              }
+            }
+          }
+        } else if (r && r.N === "style") {
+          var $ = newVNode(null, a.textContent);
+          $.k = a;
+          $.U = "0";
+          r.A = [ $ ];
+        } else {
+          if (a.nodeType === 3 /* TextNode */ && !a.wholeText.trim()) {
+            a.remove();
+          }
+        }
+        return r;
+      };
+      var initializeDocumentHydrate = function(r, n) {
+        if (r.nodeType === 1 /* ElementNode */) {
+          var e = r[h] || r.getAttribute(h);
+          if (e) {
+            n.set(e, r);
+          }
+          var t = 0;
+          if (r.shadowRoot) {
+            for (;t < r.shadowRoot.childNodes.length; t++) {
+              initializeDocumentHydrate(r.shadowRoot.childNodes[t], n);
+            }
+          }
+          var i = r.__childNodes || r.childNodes;
+          for (t = 0; t < i.length; t++) {
+            initializeDocumentHydrate(i[t], n);
+          }
+        } else if (r.nodeType === 8 /* CommentNode */) {
+          var a = r.nodeValue.split(".");
+          if (a[0] === v) {
+            n.set(a[1] + "." + a[2], r);
+            r.nodeValue = "";
+            r["s-en"] = a[3];
+          }
+        }
+      };
+      var createSimpleVNode = function(r) {
+        var n = {
+          l: 0,
+          I: null,
+          D: null,
+          P: null,
+          U: "0",
+          k: null,
+          O: null,
+          A: null,
+          C: null,
+          H: null,
+          N: null,
+          j: null
+        };
+        return __assign(__assign({}, n), r);
+      };
+      function addSlot(r, n, e, t, i, a, o, f, u) {
+        t["s-sr"] = true;
+        e.H = r || null;
+        e.N = "slot";
+        var l = (i == null ? void 0 : i.k) ? i.k["s-id"] || i.k.getAttribute("s-id") : "";
+        if (f && w.document) {
+          var v = e.k = w.document.createElement(e.N);
+          if (e.H) {
+            e.k.setAttribute("name", r);
+          }
+          if (l && l !== e.I) {
+            i.k.insertBefore(v, i.k.children[0]);
+          } else {
+            t.parentNode.insertBefore(e.k, t);
+          }
+          addSlottedNodes(u, n, r, t, e.I);
+          t.remove();
+          if (e.P === "0") {
+            f[e.U] = e.k;
+          }
+        } else {
+          var v = e.k;
+          var s = l && l !== e.I && i.k.shadowRoot;
+          addSlottedNodes(u, n, r, t, s ? l : e.I);
+          patchSlotNode(t);
+          if (s) {
+            i.k.insertBefore(v, i.k.children[0]);
+          }
+          a.push(e);
+        }
+        o.push(e);
+        if (!i.A) {
+          i.A = [];
+        }
+        i.A[e.U] = e;
+      }
+      var addSlottedNodes = function(r, n, e, t, i) {
+        var a = t.nextSibling;
+        r[n] = r[n] || [];
+        while (a && ((a["getAttribute"] && a.getAttribute("slot") || a["s-sn"]) === e || e === "" && !a["s-sn"] && (a.nodeType === 8 /* CommentNode */ && a.nodeValue.indexOf(".") !== 1 || a.nodeType === 3 /* TextNode */))) {
+          a["s-sn"] = e;
+          r[n].push({
+            slot: t,
+            node: a,
+            hostId: i
+          });
+          a = a.nextSibling;
+        }
+      };
+      var findCorrespondingNode = function(r, n) {
+        var e = r;
+        do {
+          e = e.nextSibling;
+        } while (e && (e.nodeType !== n || !e.nodeValue));
+        return e;
+      };
+      var parsePropertyValue = function(r, n) {
+        if (r != null && !isComplexType(r)) {
+          if (n & 4 /* Boolean */) {
+            return r === "false" ? false : r === "" || !!r;
+          }
+          if (n & 2 /* Number */) {
+            return parseFloat(r);
+          }
+          if (n & 1 /* String */) {
+            return String(r);
+          }
+          return r;
+        }
+        return r;
+      };
+      var P = r("g", (function(r) {
+        return getHostRef(r).$hostElement$;
+      }));
+      // src/runtime/event-emitter.ts
+            var U = r("c", (function(r, n, e) {
+        var t = P(r);
+        return {
+          emit: function(r) {
+            return emitEvent(t, n, {
+              bubbles: true,
+              composed: true,
+              cancelable: true,
+              detail: r
+            });
+          }
+        };
+      }));
+      var emitEvent = function(r, n, e) {
+        var t = S.ce(n, e);
+        r.dispatchEvent(t);
+        return t;
+      };
+      var L =  new WeakMap;
+      var registerStyle = function(r, n, e) {
+        var t = u.get(r);
+        if (A && e) {
+          t = t || new CSSStyleSheet;
+          if (typeof t === "string") {
+            t = n;
+          } else {
+            t.replaceSync(n);
+          }
+        } else {
+          t = n;
+        }
+        u.set(r, t);
+      };
+      var addStyle = function(r, n, e) {
+        var t;
+        var i = getScopeId(n);
+        var a = u.get(i);
+        if (!w.document) {
+          return i;
+        }
+        r = r.nodeType === 11 /* DocumentFragment */ ? r : w.document;
+        if (a) {
+          if (typeof a === "string") {
+            r = r.head || r;
+            var o = L.get(r);
+            var f = void 0;
+            if (!o) {
+              L.set(r, o =  new Set);
+            }
+            if (!o.has(i)) {
+              if (r.host && (f = r.querySelector("[".concat(p, '="').concat(i, '"]')))) {
+                f.innerHTML = a;
+              } else {
+                f = document.querySelector("[".concat(p, '="').concat(i, '"]')) || w.document.createElement("style");
+                f.innerHTML = a;
+                var l = (t = S.L) != null ? t : queryNonceMetaTagContent(w.document);
+                if (l != null) {
+                  f.setAttribute("nonce", l);
+                }
+                if (!(n.l & 1 /* shadowDomEncapsulation */)) {
+                  if (r.nodeName === "HEAD") {
+                    var v = r.querySelectorAll("link[rel=preconnect]");
+                    var s = v.length > 0 ? v[v.length - 1].nextSibling : r.querySelector("style");
+                    r.insertBefore(f, (s == null ? void 0 : s.parentNode) === r ? s : null);
+                  } else if ("host" in r) {
+                    if (A) {
+                      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(f);
+                      }
+                    }
+                  } else {
+                    r.append(f);
+                  }
+                }
+                if (n.l & 1 /* shadowDomEncapsulation */) {
+                  r.insertBefore(f, null);
+                }
+              }
+              if (n.l & 4 /* hasSlotRelocation */) {
+                f.innerHTML += b;
+              }
+              if (o) {
+                o.add(i);
+              }
+            }
+          } else if (!r.adoptedStyleSheets.includes(a)) {
+            r.adoptedStyleSheets = __spreadArray(__spreadArray([], r.adoptedStyleSheets, true), [ a ], false);
+          }
+        }
+        return i;
+      };
+      var attachStyles = function(r) {
+        var n = r.t;
+        var e = r.$hostElement$;
+        var t = n.l;
+        var i = createTime("attachStyles", n.$);
+        var a = addStyle(e.shadowRoot ? e.shadowRoot : e.getRootNode(), n);
+        if (t & 10 /* needsScopedEncapsulation */ && t & 2 /* scopedCssEncapsulation */ || t & 128 /* shadowNeedsScopedCss */) {
+          e["s-sc"] = a;
+          e.classList.add(a + "-h");
+        }
+        i();
+      };
+      var getScopeId = function(r, n) {
+        return "sc-" + r.$;
+      };
+      var convertScopedToShadow = function(r) {
+        return r.replace(/\/\*!@([^\/]+)\*\/[^\{]+\{/g, "$1{");
+      };
+      var hydrateScopedToShadow = function() {
+        if (!w.document) {
+          return;
+        }
+        var r = w.document.querySelectorAll("[".concat(p, "]"));
+        var n = 0;
+        for (;n < r.length; n++) {
+          registerStyle(r[n].getAttribute(p), convertScopedToShadow(r[n].innerHTML), true);
+        }
+      };
+      var setAccessor = function(r, n, e, t, i, a, o) {
+        if (e === t) {
+          return;
+        }
+        var f = isMemberInElement(r, n);
+        var u = n.toLowerCase();
+        if (n === "class") {
+          var l = r.classList;
+          var v = parseClassList(e);
+          var s = parseClassList(t);
+          if (r["s-si"] && o) {
+            s.push(r["s-si"]);
+            v.forEach((function(n) {
+              if (n.startsWith(r["s-si"])) s.push(n);
+            }));
+            s = __spreadArray([], new Set(s), true);
+            l.add.apply(l, s);
+          } else {
+            l.remove.apply(l, v.filter((function(r) {
+              return r && !s.includes(r);
+            })));
+            l.add.apply(l, s.filter((function(r) {
+              return r && !v.includes(r);
+            })));
+          }
+        } else if (n === "style") {
+          {
+            for (var c in e) {
+              if (!t || t[c] == null) {
+                if (c.includes("-")) {
+                  r.style.removeProperty(c);
+                } else {
+                  r.style[c] = "";
+                }
+              }
+            }
+          }
+          for (var c in t) {
+            if (!e || t[c] !== e[c]) {
+              if (c.includes("-")) {
+                r.style.setProperty(c, t[c]);
+              } else {
+                r.style[c] = t[c];
+              }
+            }
+          }
+        } else if (n === "key") ; else if (n === "ref") {
+          if (t) {
+            t(r);
+          }
+        } else if (!f && n[0] === "o" && n[1] === "n") {
+          if (n[2] === "-") {
+            n = n.slice(3);
+          } else if (isMemberInElement(w, u)) {
+            n = u.slice(2);
+          } else {
+            n = u[2] + n.slice(3);
+          }
+          if (e || t) {
+            var d = n.endsWith(W);
+            n = n.replace(F, "");
+            if (e) {
+              S.rel(r, n, e, d);
+            }
+            if (t) {
+              S.ael(r, n, t, d);
+            }
+          }
+        } else {
+          var h = isComplexType(t);
+          if ((f || h && t !== null) && true) {
+            try {
+              if (!r.tagName.includes("-")) {
+                var p = t == null ? "" : t;
+                if (n === "list") {
+                  f = false;
+                } else if (e == null || r[n] != p) {
+                  if (typeof r.__lookupSetter__(n) === "function") {
+                    r[n] = p;
+                  } else {
+                    r.setAttribute(n, p);
+                  }
+                }
+              } else if (r[n] !== t) {
+                r[n] = t;
+              }
+            } catch (r) {}
+          }
+          var m = false;
+          {
+            if (u !== (u = u.replace(/^xlink\:?/, ""))) {
+              n = u;
+              m = true;
+            }
+          }
+          if (t == null || t === false) {
+            if (t !== false || r.getAttribute(n) === "") {
+              if (m) {
+                r.removeAttributeNS($, n);
+              } else {
+                r.removeAttribute(n);
+              }
+            }
+          } else if ((!f || a & 4 /* isHost */ || i) && !h && r.nodeType === 1 /* ElementNode */) {
+            t = t === true ? "" : t;
+            if (m) {
+              r.setAttributeNS($, n, t);
+            } else {
+              r.setAttribute(n, t);
+            }
+          }
+        }
+      };
+      var R = /\s/;
+      var parseClassList = function(r) {
+        if (typeof r === "object" && r && "baseVal" in r) {
+          r = r.baseVal;
+        }
+        if (!r || typeof r !== "string") {
+          return [];
+        }
+        return r.split(R);
+      };
+      var W = "Capture";
+      var F = new RegExp(W + "$");
+      // src/runtime/vdom/update-element.ts
+            var updateElement = function(r, n, e, t) {
+        var i = n.k.nodeType === 11 /* DocumentFragment */ && n.k.host ? n.k.host : n.k;
+        var a = r && r.O || {};
+        var o = n.O || {};
+        {
+          for (var f = 0, u = sortedAttrNames(Object.keys(a)); f < u.length; f++) {
+            var l = u[f];
+            if (!(l in o)) {
+              setAccessor(i, l, a[l], void 0, e, n.l, t);
+            }
+          }
+        }
+        for (var v = 0, s = sortedAttrNames(Object.keys(o)); v < s.length; v++) {
+          var l = s[v];
+          setAccessor(i, l, a[l], o[l], e, n.l, t);
+        }
+      };
+      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;
+      }
+      var q;
+      var z = false;
+      var G = false;
+      var createElm = function(r, n, e) {
+        var t = n.A[e];
+        var i = 0;
+        var a;
+        var o;
+        if (t.j !== null) {
+          a = t.k = w.document.createTextNode(t.j);
+        } else {
+          if (!w.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.");
+          }
+          a = t.k = w.document.createElement(t.N);
+          {
+            updateElement(null, t, G);
+          }
+          if (t.A) {
+            for (i = 0; i < t.A.length; ++i) {
+              o = createElm(r, t, i);
+              if (o) {
+                a.appendChild(o);
+              }
+            }
+          }
+        }
+        a["s-hn"] = q;
+        return a;
+      };
+      var relocateToHostRoot = function(r) {
+        S.l |= 1 /* isTmpDisconnected */;
+        var n = r.closest(q.toLowerCase());
+        if (n != null) {
+          var e = Array.from(n.__childNodes || n.childNodes).find((function(r) {
+            return r["s-cr"];
+          }));
+          var t = Array.from(r.__childNodes || r.childNodes);
+          for (var i = 0, a = e ? t.reverse() : t; i < a.length; i++) {
+            var o = a[i];
+            if (o["s-sh"] != null) {
+              insertBefore(n, o, e != null ? e : null);
+              o["s-sh"] = void 0;
+            }
+          }
+        }
+        S.l &= -2 /* isTmpDisconnected */;
+      };
+      var addVnodes = function(r, n, e, t, i, a) {
+        var o = r;
+        var f;
+        if (o.shadowRoot && o.tagName === q) {
+          o = o.shadowRoot;
+        }
+        for (;i <= a; ++i) {
+          if (t[i]) {
+            f = createElm(null, e, i);
+            if (f) {
+              t[i].k = f;
+              insertBefore(o, f, n);
+            }
+          }
+        }
+      };
+      var removeVnodes = function(r, n, e) {
+        for (var t = n; t <= e; ++t) {
+          var i = r[t];
+          if (i) {
+            var a = i.k;
+            nullifyVNodeRefs(i);
+            if (a) {
+              a.remove();
+            }
+          }
+        }
+      };
+      var updateChildren = function(r, n, e, t, i) {
+        if (i === void 0) {
+          i = false;
+        }
+        var a = 0;
+        var o = 0;
+        var f = 0;
+        var u = 0;
+        var l = n.length - 1;
+        var v = n[0];
+        var s = n[l];
+        var c = t.length - 1;
+        var d = t[0];
+        var h = t[c];
+        var p;
+        var m;
+        while (a <= l && o <= c) {
+          if (v == null) {
+            v = n[++a];
+          } else if (s == null) {
+            s = n[--l];
+          } else if (d == null) {
+            d = t[++o];
+          } else if (h == null) {
+            h = t[--c];
+          } else if (isSameVnode(v, d, i)) {
+            patch(v, d, i);
+            v = n[++a];
+            d = t[++o];
+          } else if (isSameVnode(s, h, i)) {
+            patch(s, h, i);
+            s = n[--l];
+            h = t[--c];
+          } else if (isSameVnode(v, h, i)) {
+            patch(v, h, i);
+            insertBefore(r, v.k, s.k.nextSibling);
+            v = n[++a];
+            h = t[--c];
+          } else if (isSameVnode(s, d, i)) {
+            patch(s, d, i);
+            insertBefore(r, s.k, v.k);
+            s = n[--l];
+            d = t[++o];
+          } else {
+            f = -1;
+            {
+              for (u = a; u <= l; ++u) {
+                if (n[u] && n[u].C !== null && n[u].C === d.C) {
+                  f = u;
+                  break;
+                }
+              }
+            }
+            if (f >= 0) {
+              m = n[f];
+              if (m.N !== d.N) {
+                p = createElm(n && n[o], e, f);
+              } else {
+                patch(m, d, i);
+                n[f] = void 0;
+                p = m.k;
+              }
+              d = t[++o];
+            } else {
+              p = createElm(n && n[o], e, o);
+              d = t[++o];
+            }
+            if (p) {
+              {
+                insertBefore(v.k.parentNode, p, v.k);
+              }
+            }
+          }
+        }
+        if (a > l) {
+          addVnodes(r, t[c + 1] == null ? null : t[c + 1].k, e, t, o, c);
+        } else if (o > c) {
+          removeVnodes(n, a, l);
+        }
+      };
+      var isSameVnode = function(r, n, e) {
+        if (e === void 0) {
+          e = false;
+        }
+        if (r.N === n.N) {
+          if (!e) {
+            return r.C === n.C;
+          }
+          if (e && !r.C && n.C) {
+            r.C = n.C;
+          }
+          return true;
+        }
+        return false;
+      };
+      var patch = function(r, n, e) {
+        if (e === void 0) {
+          e = false;
+        }
+        var t = n.k = r.k;
+        var a = r.A;
+        var o = n.A;
+        var f = n.N;
+        var u = n.j;
+        if (u === null) {
+          {
+            if (f === "slot" && !z) {
+              if (r.H !== n.H) {
+                n.k["s-sn"] = n.H || "";
+                relocateToHostRoot(n.k.parentElement);
+              }
+            }
+            updateElement(r, n, G, e);
+          }
+          if (a !== null && o !== null) {
+            updateChildren(t, a, n, o, e);
+          } else if (o !== null) {
+            if (r.j !== null) {
+              t.textContent = "";
+            }
+            addVnodes(t, null, n, o, 0, o.length - 1);
+          } else if (
+          // don't do this on initial render as it can cause non-hydrated content to be removed
+          !e && i.updatable && a !== null) {
+            removeVnodes(a, 0, a.length - 1);
+          }
+        } else if (r.j !== u) {
+          t.data = u;
+        }
+      };
+      var nullifyVNodeRefs = function(r) {
+        {
+          r.O && r.O.ref && r.O.ref(null);
+          r.A && r.A.map(nullifyVNodeRefs);
+        }
+      };
+      var insertBefore = function(r, n, e) {
+        if (typeof n["s-sn"] === "string") {
+          if (r.getRootNode().nodeType !== 11 /* DOCUMENT_FRAGMENT_NODE */) {
+            patchParentNode(n);
+          }
+          r.insertBefore(n, e);
+          var t = findSlotFromSlottedNode(n).slotNode;
+          if (t) dispatchSlotChangeEvent(t);
+          return n;
+        }
+        if (r.__insertBefore) {
+          return r.__insertBefore(n, e);
+        } else {
+          return r == null ? void 0 : r.insertBefore(n, e);
+        }
+      };
+      var renderVdom = function(r, n, e) {
+        if (e === void 0) {
+          e = false;
+        }
+        var t;
+        var i = r.$hostElement$;
+        var a = r.t;
+        var o = r.T || newVNode(null, null);
+        var f = isHost(n) ? n : T(null, null, n);
+        q = i.tagName;
+        if (a.R) {
+          f.O = f.O || {};
+          a.R.map((function(r) {
+            var n = r[0], e = r[1];
+            return f.O[e] = i[n];
+          }));
+        }
+        if (e && f.O) {
+          for (var u = 0, l = Object.keys(f.O); u < l.length; u++) {
+            var v = l[u];
+            if (i.hasAttribute(v) && ![ "key", "ref", "style", "class" ].includes(v)) {
+              f.O[v] = i[v];
+            }
+          }
+        }
+        f.N = null;
+        f.l |= 4 /* isHost */;
+        r.T = f;
+        f.k = o.k = i.shadowRoot || i;
+        z = !!(a.l & 1 /* shadowDomEncapsulation */) && !(a.l & 128 /* shadowNeedsScopedCss */);
+        patch(o, f, e);
+        if (a.l & 2 /* scopedCssEncapsulation */) {
+          var s = f.k.__childNodes || f.k.childNodes;
+          for (var c = 0, d = s; c < d.length; c++) {
+            var h = d[c];
+            if (h["s-hn"] !== q && !h["s-sh"]) {
+              if (e && h["s-ih"] == null) {
+                h["s-ih"] = (t = h.hidden) != null ? t : false;
+              }
+              h.hidden = true;
+            }
+          }
+        }
+      };
+      // src/runtime/update-component.ts
+            var attachToAncestor = function(r, n) {
+        if (n && !r.W && n["s-p"]) {
+          var e = n["s-p"].push(new Promise((function(t) {
+            return r.W = function() {
+              n["s-p"].splice(e - 1, 1);
+              t();
+            };
+          })));
+        }
+      };
+      var scheduleUpdate = function(r, n) {
+        {
+          r.l |= 16 /* isQueuedForUpdate */;
+        }
+        if (r.l & 4 /* isWaitingForChildren */) {
+          r.l |= 512 /* needsRerender */;
+          return;
+        }
+        attachToAncestor(r, r.F);
+        var dispatch = function() {
+          return dispatchHooks(r, n);
+        };
+        return k(dispatch);
+      };
+      var dispatchHooks = function(r, n) {
+        var e = r.$hostElement$;
+        var t = createTime("scheduleUpdate", r.t.$);
+        var i = r.u;
+        if (!i) {
+          throw new Error("Can't render component <".concat(e.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 (n) {
+          {
+            r.l |= 256 /* isListenReady */;
+            if (r.q) {
+              r.q.map((function(r) {
+                var n = r[0], t = r[1];
+                return safeCall(i, n, t, e);
+              }));
+              r.q = void 0;
+            }
+          }
+          emitLifecycleEvent(e, "componentWillLoad");
+          a = safeCall(i, "componentWillLoad", void 0, e);
+        } else {
+          emitLifecycleEvent(e, "componentWillUpdate");
+          a = safeCall(i, "componentWillUpdate", void 0, e);
+        }
+        emitLifecycleEvent(e, "componentWillRender");
+        a = enqueue(a, (function() {
+          return safeCall(i, "componentWillRender", void 0, e);
+        }));
+        t();
+        return enqueue(a, (function() {
+          return updateComponent(r, i, n);
+        }));
+      };
+      var enqueue = function(r, n) {
+        return isPromisey(r) ? r.then(n).catch((function(r) {
+          console.error(r);
+          n();
+        })) : n();
+      };
+      var isPromisey = function(r) {
+        return r instanceof Promise || r && r.then && typeof r.then === "function";
+      };
+      var updateComponent = function(r, n, t) {
+        return __awaiter(e, void 0, void 0, (function() {
+          var e, i, a, o, f, u, l;
+          return __generator(this, (function(v) {
+            i = r.$hostElement$;
+            a = createTime("update", r.t.$);
+            o = i["s-rc"];
+            if (t) {
+              attachStyles(r);
+            }
+            f = createTime("render", r.t.$);
+            {
+              callRender(r, n, i, t);
+            }
+            if (o) {
+              o.map((function(r) {
+                return r();
+              }));
+              i["s-rc"] = void 0;
+            }
+            f();
+            a();
+            {
+              u = (e = i["s-p"]) != null ? e : [];
+              l = function() {
+                return postUpdateComponent(r);
+              };
+              if (u.length === 0) {
+                l();
+              } else {
+                Promise.all(u).then(l);
+                r.l |= 4 /* isWaitingForChildren */;
+                u.length = 0;
+              }
+            }
+            return [ 2 /*return*/ ];
+          }));
+        }));
+      };
+      var callRender = function(r, n, e, t) {
+        try {
+          n = n.render();
+          {
+            r.l &= -17 /* isQueuedForUpdate */;
+          }
+          {
+            r.l |= 2 /* hasRendered */;
+          }
+          {
+            {
+              {
+                renderVdom(r, n, t);
+              }
+            }
+          }
+        } catch (n) {
+          consoleError(n, r.$hostElement$);
+        }
+        return null;
+      };
+      var postUpdateComponent = function(r) {
+        var n = r.t.$;
+        var e = r.$hostElement$;
+        var t = createTime("postUpdate", n);
+        var i = r.u;
+        var a = r.F;
+        safeCall(i, "componentDidRender", void 0, e);
+        emitLifecycleEvent(e, "componentDidRender");
+        if (!(r.l & 64 /* hasLoadedComponent */)) {
+          r.l |= 64 /* hasLoadedComponent */;
+          {
+            addHydratedFlag(e);
+          }
+          safeCall(i, "componentDidLoad", void 0, e);
+          emitLifecycleEvent(e, "componentDidLoad");
+          t();
+          {
+            r.m(e);
+            if (!a) {
+              appDidLoad();
+            }
+          }
+        } else {
+          safeCall(i, "componentDidUpdate", void 0, e);
+          emitLifecycleEvent(e, "componentDidUpdate");
+          t();
+        }
+        {
+          r.h(e);
+        }
+        {
+          if (r.W) {
+            r.W();
+            r.W = void 0;
+          }
+          if (r.l & 512 /* needsRerender */) {
+            nextTick((function() {
+              return scheduleUpdate(r, false);
+            }));
+          }
+          r.l &= -517;
+        }
+      };
+      var appDidLoad = function(r) {
+        nextTick((function() {
+          return emitEvent(w, "appload", {
+            detail: {
+              namespace: t
+            }
+          });
+        }));
+      };
+      var safeCall = function(r, n, e, t) {
+        if (r && r[n]) {
+          try {
+            return r[n](e);
+          } catch (r) {
+            consoleError(r, t);
+          }
+        }
+        return void 0;
+      };
+      var emitLifecycleEvent = function(r, n) {
+        {
+          emitEvent(r, "stencil_" + n, {
+            bubbles: true,
+            composed: true,
+            detail: {
+              namespace: t
+            }
+          });
+        }
+      };
+      var addHydratedFlag = function(r) {
+        var n;
+        return r.classList.add((n = i.hydratedSelectorName) != null ? n : "hydrated");
+      };
+      // src/runtime/set-value.ts
+            var getValue = function(r, n) {
+        return getHostRef(r).o.get(n);
+      };
+      var setValue = function(r, n, e, t) {
+        var i = getHostRef(r);
+        if (!i) {
+          throw new Error("Couldn't find host element for \"".concat(t.$, '" 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).'));
+        }
+        var a = i.$hostElement$;
+        var o = i.o.get(n);
+        var f = i.l;
+        var u = i.u;
+        e = parsePropertyValue(e, t.i[n][0]);
+        var l = Number.isNaN(o) && Number.isNaN(e);
+        var v = e !== o && !l;
+        if ((!(f & 8 /* isConstructingInstance */) || o === void 0) && v) {
+          i.o.set(n, e);
+          if (u) {
+            if (t.G && f & 128 /* isWatchReady */) {
+              var s = t.G[n];
+              if (s) {
+                s.map((function(r) {
+                  try {
+                    u[r](e, o, n);
+                  } catch (r) {
+                    consoleError(r, a);
+                  }
+                }));
+              }
+            }
+            if ((f & (2 /* hasRendered */ | 16 /* isQueuedForUpdate */)) === 2 /* hasRendered */) {
+              if (u.componentShouldUpdate) {
+                if (u.componentShouldUpdate(e, o, n) === false) {
+                  return;
+                }
+              }
+              scheduleUpdate(i, false);
+            }
+          }
+        }
+      };
+      // src/runtime/proxy-component.ts
+            var proxyComponent = function(r, n, e) {
+        var t, a;
+        var o = r.prototype;
+        if (n.l & 64 /* formAssociated */ && e & 1 /* isElementConstructor */) {
+          g.forEach((function(r) {
+            Object.defineProperty(o, r, {
+              value: function() {
+                var n = [];
+                for (var e = 0; e < arguments.length; e++) {
+                  n[e] = arguments[e];
+                }
+                var t = getHostRef(this);
+                var i = t.u;
+                if (!i) {
+                  t.p.then((function(e) {
+                    var t = e[r];
+                    typeof t === "function" && t.call.apply(t, __spreadArray([ e ], n, false));
+                  }));
+                } else {
+                  var a = i[r];
+                  typeof a === "function" && a.call.apply(a, __spreadArray([ i ], n, false));
+                }
+              }
+            });
+          }));
+        }
+        if (n.i || (n.G || r.watchers)) {
+          if (r.watchers && !n.G) {
+            n.G = r.watchers;
+          }
+          var f = Object.entries((t = n.i) != null ? t : {});
+          f.map((function(r) {
+            var t = r[0], i = r[1][0];
+            if (i & 31 /* Prop */ || e & 2 /* proxyState */ && i & 32 /* State */) {
+              var a = Object.getOwnPropertyDescriptor(o, t) || {}, f = a.get, u = a.set;
+              if (f) n.i[t][0] |= 2048 /* Getter */;
+              if (u) n.i[t][0] |= 4096 /* Setter */;
+              if (e & 1 /* isElementConstructor */ || !f) {
+                Object.defineProperty(o, t, {
+                  get: function() {
+                    {
+                      if ((n.i[t][0] & 2048 /* Getter */) === 0) {
+                        return getValue(this, t);
+                      }
+                      var r = getHostRef(this);
+                      var e = r ? r.u : o;
+                      if (!e) return;
+                      return e[t];
+                    }
+                  },
+                  configurable: true,
+                  enumerable: true
+                });
+              }
+              Object.defineProperty(o, t, {
+                set: function(r) {
+                  var a = this;
+                  var o = getHostRef(this);
+                  if (u) {
+                    var f = i & 32 /* State */ ? this[t] : o.$hostElement$[t];
+                    if (typeof f === "undefined" && o.o.get(t)) {
+                      r = o.o.get(t);
+                    } else if (!o.o.get(t) && f) {
+                      o.o.set(t, f);
+                    }
+                    u.apply(this, [ parsePropertyValue(r, i) ]);
+                    r = i & 32 /* State */ ? this[t] : o.$hostElement$[t];
+                    setValue(this, t, r, n);
+                    return;
+                  }
+                  {
+                    if ((e & 1 /* isElementConstructor */) === 0 || (n.i[t][0] & 4096 /* Setter */) === 0) {
+                      setValue(this, t, r, n);
+                      if (e & 1 /* isElementConstructor */ && !o.u) {
+                        o.p.then((function() {
+                          if (n.i[t][0] & 4096 /* Setter */ && o.u[t] !== o.o.get(t)) {
+                            o.u[t] = r;
+                          }
+                        }));
+                      }
+                      return;
+                    }
+                    var setterSetVal_1 = function() {
+                      var e = o.u[t];
+                      if (!o.o.get(t) && e) {
+                        o.o.set(t, e);
+                      }
+                      o.u[t] = parsePropertyValue(r, i);
+                      setValue(a, t, o.u[t], n);
+                    };
+                    if (o.u) {
+                      setterSetVal_1();
+                    } else {
+                      o.p.then((function() {
+                        return setterSetVal_1();
+                      }));
+                    }
+                  }
+                }
+              });
+            } else if (e & 1 /* isElementConstructor */ && i & 64 /* Method */) {
+              Object.defineProperty(o, t, {
+                value: function() {
+                  var r = [];
+                  for (var n = 0; n < arguments.length; n++) {
+                    r[n] = arguments[n];
+                  }
+                  var e;
+                  var i = getHostRef(this);
+                  return (e = i == null ? void 0 : i.v) == null ? void 0 : e.then((function() {
+                    var n;
+                    return (n = i.u) == null ? void 0 : n[t].apply(n, r);
+                  }));
+                }
+              });
+            }
+          }));
+          if (e & 1 /* isElementConstructor */) {
+            var u =  new Map;
+            o.attributeChangedCallback = function(r, e, t) {
+              var a = this;
+              S.jmp((function() {
+                var f;
+                var l = u.get(r);
+                if (a.hasOwnProperty(l) && i.lazyLoad) {
+                  t = a[l];
+                  delete a[l];
+                } else if (o.hasOwnProperty(l) && typeof a[l] === "number" && // cast type to number to avoid TS compiler issues
+                a[l] == t) {
+                  return;
+                } else if (l == null) {
+                  var v = getHostRef(a);
+                  var s = v == null ? void 0 : v.l;
+                  if (s && !(s & 8 /* isConstructingInstance */) && s & 128 /* isWatchReady */ && t !== e) {
+                    var c = v.u;
+                    var d = (f = n.G) == null ? void 0 : f[r];
+                    d == null ? void 0 : d.forEach((function(n) {
+                      if (c[n] != null) {
+                        c[n].call(c, t, e, r);
+                      }
+                    }));
+                  }
+                  return;
+                }
+                var h = Object.getOwnPropertyDescriptor(o, l);
+                t = t === null && typeof a[l] === "boolean" ? false : t;
+                if (t !== a[l] && (!h.get || !!h.set)) {
+                  a[l] = t;
+                }
+              }));
+            };
+            r.observedAttributes = Array.from(
+             new Set(__spreadArray(__spreadArray([], Object.keys((a = n.G) != null ? a : {}), true), f.filter((function(r) {
+              var n = r[0], e = r[1];
+              return e[0] & 15;
+            } /* HasAttribute */)).map((function(r) {
+              var e = r[0], t = r[1];
+              var i;
+              var a = t[1] || e;
+              u.set(a, e);
+              if (t[0] & 512 /* ReflectAttr */) {
+                (i = n.R) == null ? void 0 : i.push([ e, a ]);
+              }
+              return a;
+            })), true)));
+          }
+        }
+        return r;
+      };
+      // src/runtime/initialize-component.ts
+            var initializeComponent = function(r, n, t, i) {
+        return __awaiter(e, void 0, void 0, (function() {
+          var e, i, a, o, f, l, v, s, c, d, h;
+          return __generator(this, (function(p) {
+            switch (p.label) {
+             case 0:
+              if (!((n.l & 32 /* hasInitializedComponent */) === 0)) return [ 3 /*break*/ , 6 ];
+              n.l |= 32 /* hasInitializedComponent */;
+              i = t._;
+              if (!i) return [ 3 /*break*/ , 4 ];
+              a = loadModule(t, n);
+              if (!(a && "then" in a)) return [ 3 /*break*/ , 2 ];
+              o = uniqueTime();
+              return [ 4 /*yield*/ , a ];
+
+             case 1:
+              e = p.sent();
+              o();
+              return [ 3 /*break*/ , 3 ];
+
+             case 2:
+              e = a;
+              p.label = 3;
+
+             case 3:
+              if (!e) {
+                throw new Error('Constructor for "'.concat(t.$, "#").concat(n.V, '" was not found'));
+              }
+              if (!e.isProxied) {
+                {
+                  t.G = e.watchers;
+                }
+                proxyComponent(e, t, 2 /* proxyState */);
+                e.isProxied = true;
+              }
+              f = createTime("createInstance", t.$);
+              {
+                n.l |= 8 /* isConstructingInstance */;
+              }
+              try {
+                new e(n);
+              } catch (n) {
+                consoleError(n, r);
+              }
+              {
+                n.l &= -9 /* isConstructingInstance */;
+              }
+              {
+                n.l |= 128 /* isWatchReady */;
+              }
+              f();
+              fireConnectedCallback(n.u, r);
+              return [ 3 /*break*/ , 5 ];
+
+             case 4:
+              e = r.constructor;
+              l = r.localName;
+              customElements.whenDefined(l).then((function() {
+                return n.l |= 128;
+              } /* isWatchReady */));
+              p.label = 5;
+
+             case 5:
+              if (e && e.style) {
+                v = void 0;
+                if (typeof e.style === "string") {
+                  v = e.style;
+                }
+                s = getScopeId(t);
+                if (!u.has(s)) {
+                  c = createTime("registerStyles", t.$);
+                  registerStyle(s, v, !!(t.l & 1 /* shadowDomEncapsulation */));
+                  c();
+                }
+              }
+              p.label = 6;
+
+             case 6:
+              d = n.F;
+              h = function() {
+                return scheduleUpdate(n, true);
+              };
+              if (d && d["s-rc"]) {
+                d["s-rc"].push(h);
+              } else {
+                h();
+              }
+              return [ 2 /*return*/ ];
+            }
+          }));
+        }));
+      };
+      var fireConnectedCallback = function(r, n) {
+        {
+          safeCall(r, "connectedCallback", void 0, n);
+        }
+      };
+      // src/runtime/connected-callback.ts
+            var connectedCallback = function(r) {
+        if ((S.l & 1 /* isTmpDisconnected */) === 0) {
+          var n = getHostRef(r);
+          var e = n.t;
+          var t = createTime("connectedCallback", e.$);
+          if (!(n.l & 1 /* hasConnected */)) {
+            n.l |= 1 /* hasConnected */;
+            var i = void 0;
+            {
+              i = r.getAttribute(h);
+              if (i) {
+                if (e.l & 1 /* shadowDomEncapsulation */) {
+                  var a = addStyle(r.shadowRoot, e);
+                  r.classList.remove(a + "-h", a + "-s");
+                }
+                initializeClientHydrate(r, e.$, i, n);
+              }
+            }
+            {
+              var o = r;
+              while (o = o.parentNode || o.host) {
+                if (o.nodeType === 1 /* ElementNode */ && o.hasAttribute("s-id") && o["s-p"] || o["s-p"]) {
+                  attachToAncestor(n, n.F = o);
+                  break;
+                }
+              }
+            }
+            if (e.i) {
+              Object.entries(e.i).map((function(n) {
+                var e = n[0], t = n[1][0];
+                if (t & 31 /* Prop */ && r.hasOwnProperty(e)) {
+                  var i = r[e];
+                  delete r[e];
+                  r[e] = i;
+                }
+              }));
+            }
+            {
+              initializeComponent(r, n, e);
+            }
+          } else {
+            addHostEventListeners(r, n, e.Y);
+            if (n == null ? void 0 : n.u) {
+              fireConnectedCallback(n.u, r);
+            } else if (n == null ? void 0 : n.p) {
+              n.p.then((function() {
+                return fireConnectedCallback(n.u, r);
+              }));
+            }
+          }
+          t();
+        }
+      };
+      var disconnectInstance = function(r, n) {
+        {
+          safeCall(r, "disconnectedCallback", void 0, n || r);
+        }
+      };
+      var disconnectedCallback = function(r) {
+        return __awaiter(e, void 0, void 0, (function() {
+          var n;
+          return __generator(this, (function(e) {
+            if ((S.l & 1 /* isTmpDisconnected */) === 0) {
+              n = getHostRef(r);
+              {
+                if (n.B) {
+                  n.B.map((function(r) {
+                    return r();
+                  }));
+                  n.B = void 0;
+                }
+              }
+              if (n == null ? void 0 : n.u) {
+                disconnectInstance(n.u, r);
+              } else if (n == null ? void 0 : n.p) {
+                n.p.then((function() {
+                  return disconnectInstance(n.u, r);
+                }));
+              }
+            }
+            if (L.has(r)) {
+              L.delete(r);
+            }
+            if (r.shadowRoot && L.has(r.shadowRoot)) {
+              L.delete(r.shadowRoot);
+            }
+            return [ 2 /*return*/ ];
+          }));
+        }));
+      };
+      // src/runtime/bootstrap-lazy.ts
+            var V = r("b", (function(r, n) {
+        if (n === void 0) {
+          n = {};
+        }
+        var e;
+        if (!w.document) {
+          console.warn("Stencil: No document found. Skipping bootstrapping lazy components.");
+          return;
+        }
+        var t = createTime();
+        var i = [];
+        var a = n.exclude || [];
+        var o = w.customElements;
+        var f = w.document.head;
+        var u =  f.querySelector("meta[charset]");
+        var l =  w.document.createElement("style");
+        var v = [];
+        var s;
+        var c = true;
+        Object.assign(S, n);
+        S.S = new URL(n.resourcesUrl || "./", w.document.baseURI).href;
+        {
+          S.l |= 2 /* appLoaded */;
+        }
+        {
+          hydrateScopedToShadow();
+        }
+        var d = false;
+        r.map((function(r) {
+          r[1].map((function(n) {
+            var e;
+            var t = {
+              l: n[0],
+              $: n[1],
+              i: n[2],
+              Y: n[3]
+            };
+            if (t.l & 4 /* hasSlotRelocation */) {
+              d = true;
+            }
+            {
+              t.i = n[2];
+            }
+            {
+              t.Y = n[3];
+            }
+            {
+              t.R = [];
+            }
+            {
+              t.G = (e = n[4]) != null ? e : {};
+            }
+            var f = t.$;
+            var u = /** @class */ function(r) {
+              __extends(HostElement, r);
+              // StencilLazyHost
+                            function HostElement(n) {
+                var e = r.call(this, n) || this;
+                e.hasRegisteredEventListeners = false;
+                n = e;
+                registerHost(n, t);
+                if (t.l & 1 /* shadowDomEncapsulation */) {
+                  {
+                    if (!n.shadowRoot) {
+                      {
+                        n.attachShadow({
+                          mode: "open"
+                        });
+                      }
+                    } else {
+                      if (n.shadowRoot.mode !== "open") {
+                        throw new Error("Unable to re-use existing shadow root for ".concat(t.$, "! Mode is set to ").concat(n.shadowRoot.mode, " but Stencil only supports open shadow roots."));
+                      }
+                    }
+                  }
+                }
+                return e;
+              }
+              HostElement.prototype.connectedCallback = function() {
+                var r = this;
+                var n = getHostRef(this);
+                if (!this.hasRegisteredEventListeners) {
+                  this.hasRegisteredEventListeners = true;
+                  addHostEventListeners(this, n, t.Y);
+                }
+                if (s) {
+                  clearTimeout(s);
+                  s = null;
+                }
+                if (c) {
+                  v.push(this);
+                } else {
+                  S.jmp((function() {
+                    return connectedCallback(r);
+                  }));
+                }
+              };
+              HostElement.prototype.disconnectedCallback = function() {
+                var r = this;
+                S.jmp((function() {
+                  return disconnectedCallback(r);
+                }));
+                S.raf((function() {
+                  var n;
+                  var e = getHostRef(r);
+                  var t = v.findIndex((function(n) {
+                    return n === r;
+                  }));
+                  if (t > -1) {
+                    v.splice(t, 1);
+                  }
+                  if (((n = e == null ? void 0 : e.T) == null ? void 0 : n.k) instanceof Node && !e.T.k.isConnected) {
+                    delete e.T.k;
+                  }
+                }));
+              };
+              HostElement.prototype.componentOnReady = function() {
+                return getHostRef(this).p;
+              };
+              return HostElement;
+            }(HTMLElement);
+            if (t.l & 64 /* formAssociated */) {
+              u.formAssociated = true;
+            }
+            t._ = r[0];
+            if (!a.includes(f) && !o.get(f)) {
+              i.push(f);
+              o.define(f, proxyComponent(u, t, 1 /* isElementConstructor */));
+            }
+          }));
+        }));
+        if (i.length > 0) {
+          if (d) {
+            l.textContent += b;
+          }
+          {
+            l.textContent += i.sort() + y;
+          }
+          if (l.innerHTML.length) {
+            l.setAttribute("data-styles", "");
+            var h = (e = S.L) != null ? e : queryNonceMetaTagContent(w.document);
+            if (h != null) {
+              l.setAttribute("nonce", h);
+            }
+            f.insertBefore(l, u ? u.nextSibling : f.firstChild);
+          }
+        }
+        c = false;
+        if (v.length) {
+          v.map((function(r) {
+            return r.connectedCallback();
+          }));
+        } else {
+          {
+            S.jmp((function() {
+              return s = setTimeout(appDidLoad, 30);
+            }));
+          }
+        }
+        t();
+      }));
+      var addHostEventListeners = function(r, n, e, t) {
+        if (e && w.document) {
+          e.map((function(e) {
+            var t = e[0], i = e[1], a = e[2];
+            var o = getHostListenerTarget(w.document, r, t);
+            var f = hostListenerProxy(n, a);
+            var u = hostListenerOpts(t);
+            S.ael(o, i, f, u);
+            (n.B = n.B || []).push((function() {
+              return S.rel(o, i, f, u);
+            }));
+          }));
+        }
+      };
+      var hostListenerProxy = function(r, n) {
+        return function(e) {
+          var t;
+          try {
+            {
+              if (r.l & 256 /* isListenReady */) {
+                (t = r.u) == null ? void 0 : t[n](e);
+              } else {
+                (r.q = r.q || []).push([ n, e ]);
+              }
+            }
+          } catch (n) {
+            consoleError(n, r.$hostElement$);
+          }
+        };
+      };
+      var getHostListenerTarget = function(r, n, e) {
+        if (e & 4 /* TargetDocument */) {
+          return r;
+        }
+        if (e & 8 /* TargetWindow */) {
+          return w;
+        }
+        return n;
+      };
+      var hostListenerOpts = function(r) {
+        return j ? {
+          passive: (r & 1 /* Passive */) !== 0,
+          capture: (r & 2 /* Capture */) !== 0
+        } : (r & 2 /* Capture */) !== 0;
+      };
+      // src/runtime/nonce.ts
+            var Y = r("s", (function(r) {
+        return S.L = r;
+      }));
+    }
+  };
+}));
+//# sourceMappingURL=p-CMdFJ4qj.system.js.map
+//# sourceMappingURL=module.js.map
+//# sourceMappingURL=p-CMdFJ4qj.system.js.map