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

package/dist/esm-es5/index-CAyrQrUt.js

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