vrembem 4.0.0-next.3 → 4.0.0-next.30

package/dev/index.js

@@ -1,290 +1,338 @@
-var b$2 = (t, e, n) => {
-  if (!e.has(t))
-    throw TypeError("Cannot " + n);
+var __typeError = (msg) => {
+  throw TypeError(msg);
 };
-var o$1 = (t, e, n) => (b$2(t, e, "read from private field"), n ? n.call(t) : e.get(t)), h$2 = (t, e, n) => {
-  if (e.has(t))
-    throw TypeError("Cannot add the same private member more than once");
-  e instanceof WeakSet ? e.add(t) : e.set(t, n);
-}, a = (t, e, n, i) => (b$2(t, e, "write to private field"), i ? i.call(t, n) : e.set(t, n), n);
-var l$1;
-let $$2 = class $ {
-  constructor(e, n) {
-    h$2(this, l$1, void 0);
-    this.value = e, a(this, l$1, n), this.mql = null;
-  }
-  get handler() {
-    return o$1(this, l$1);
-  }
-  // Unmount existing handler before setting a new one.
-  set handler(e) {
-    this.mql && (typeof this.mql.removeEventListener == "function" ? this.mql.removeEventListener("change", o$1(this, l$1)) : this.mql.removeListener(o$1(this, l$1))), a(this, l$1, e);
-  }
-  mount(e, n) {
-    return e && (this.value = e), n && a(this, l$1, n), this.value ? (this.mql = window.matchMedia(`(min-width: ${this.value})`), typeof this.mql.addEventListener == "function" ? this.mql.addEventListener("change", o$1(this, l$1)) : this.mql.addListener(o$1(this, l$1)), o$1(this, l$1).call(this, this.mql), this) : this;
-  }
-  unmount() {
-    return this.mql ? (typeof this.mql.removeEventListener == "function" ? this.mql.removeEventListener("change", o$1(this, l$1)) : this.mql.removeListener(o$1(this, l$1)), this.value = null, a(this, l$1, null), this.mql = null, this) : this;
-  }
-};
-l$1 = /* @__PURE__ */ new WeakMap();
-let T$2 = class T {
-  constructor() {
-    this.collection = [];
-  }
-  async register(e) {
-    return await this.deregister(e), this.collection.push(e), this.collection;
-  }
-  async deregister(e) {
-    const n = this.collection.findIndex((i) => i === e);
-    if (n >= 0) {
-      const i = this.collection[n];
-      Object.getOwnPropertyNames(i).forEach((r2) => {
-        delete i[r2];
-      }), this.collection.splice(n, 1);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _handler, _focusable, _handleFocusTrap, _handleFocusLock, _mode, _state, _breakpoint, _handleClick, _handleKeydown, _handleClick2, _handleKeydown2, _eventListeners, _isHovered, _handleKeydown3;
+function toCamel(value) {
+  return value.split("-").map((word, index2) => index2 === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toKebab(value) {
+  return value.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toMilliseconds(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const parsed = parseFloat(value);
+  if (!Number.isNaN(parsed)) {
+    const isMilliseconds = value.includes("ms");
+    return parsed * (isMilliseconds ? 1 : 1e3);
+  }
+  throw new Error(`Could not convert value to milliseconds: ${value}`);
+}
+function getPrefix() {
+  return getComputedStyle(document.body).getPropertyValue("--vb-prefix").trim();
+}
+function cssVar(property, options) {
+  const settings = {
+    fallback: null,
+    element: document.body,
+    ...options
+  };
+  if (property.slice(0, 2) !== "--") {
+    const prefixValue = getPrefix();
+    if (prefixValue) {
+      property = `${prefixValue}${property}`;
+    }
+    property = `--${property}`;
+  }
+  const cssValue = getComputedStyle(settings.element).getPropertyValue(property).trim();
+  if (cssValue) {
+    return cssValue;
+  } else {
+    if (settings.fallback) {
+      return settings.fallback;
+    } else {
+      throw new Error(`CSS variable "${property}" was not found!`);
     }
-    return this.collection;
-  }
-  async registerCollection(e) {
-    return await Promise.all(Array.from(e, (n) => {
-      this.register(n);
-    })), this.collection;
-  }
-  async deregisterCollection() {
-    for (; this.collection.length > 0; )
-      await this.deregister(this.collection[0]);
-    return this.collection;
-  }
-  get(e, n = "id") {
-    return this.collection.find((i) => i[n] === e);
-  }
-};
-const s = {
-  inert: ":not([inert]):not([inert] *)",
-  negTabIndex: ':not([tabindex^="-"])',
-  disabled: ":not(:disabled)"
-}, v$2 = [
-  `a[href]${s.inert}${s.negTabIndex}`,
-  `area[href]${s.inert}${s.negTabIndex}`,
-  `input:not([type="hidden"]):not([type="radio"])${s.inert}${s.negTabIndex}${s.disabled}`,
-  `input[type="radio"]${s.inert}${s.negTabIndex}${s.disabled}`,
-  `select${s.inert}${s.negTabIndex}${s.disabled}`,
-  `textarea${s.inert}${s.negTabIndex}${s.disabled}`,
-  `button${s.inert}${s.negTabIndex}${s.disabled}`,
-  `details${s.inert} > summary:first-of-type${s.negTabIndex}`,
-  // Discard until Firefox supports `:has()`
-  // See: https://github.com/KittyGiraudel/focusable-selectors/issues/12
-  // `details:not(:has(> summary))${not.inert}${not.negTabIndex}`,
-  `iframe${s.inert}${s.negTabIndex}`,
-  `audio[controls]${s.inert}${s.negTabIndex}`,
-  `video[controls]${s.inert}${s.negTabIndex}`,
-  `[contenteditable]${s.inert}${s.negTabIndex}`,
-  `[tabindex]${s.inert}${s.negTabIndex}`
-];
-var f$2, d$1, u$2;
-let x$1 = class x {
-  constructor(e = null, n = "[data-focus]") {
-    h$2(this, f$2, void 0);
-    h$2(this, d$1, void 0);
-    h$2(this, u$2, void 0);
-    this.el = e, this.selectorFocus = n, a(this, d$1, g$2.bind(this)), a(this, u$2, p$2.bind(this));
-  }
-  get focusable() {
-    return o$1(this, f$2);
-  }
-  set focusable(e) {
-    a(this, f$2, e), o$1(this, f$2).length ? (document.removeEventListener("keydown", o$1(this, u$2)), document.addEventListener("keydown", o$1(this, d$1))) : (document.removeEventListener("keydown", o$1(this, d$1)), document.addEventListener("keydown", o$1(this, u$2)));
-  }
-  get focusableFirst() {
-    return this.focusable[0];
-  }
-  get focusableLast() {
-    return this.focusable[this.focusable.length - 1];
-  }
-  mount(e, n) {
-    e && (this.el = e), n && (this.selectorFocus = n), this.focusable = this.getFocusable(), this.focus();
   }
-  unmount() {
-    this.el = null, this.focusable = [], document.removeEventListener("keydown", o$1(this, d$1)), document.removeEventListener("keydown", o$1(this, u$2));
+}
+function getConfig(el, dataConfig = "config") {
+  const string = el.getAttribute(`data-${dataConfig}`) || "";
+  const json = string.replace(/'/g, '"');
+  return json ? JSON.parse(json) : {};
+}
+function getCustomProps(entry) {
+  const styles = getComputedStyle(entry.el);
+  const result = {};
+  const keys = entry.getSetting("customProps");
+  for (let i = 0; i < keys.length; i++) {
+    const prefix = getPrefix();
+    const module = entry.context.module.toLowerCase();
+    const key = toKebab(keys[i]);
+    const value = styles.getPropertyValue(`--${prefix}${module}-${key}`).trim();
+    if (value) {
+      result[key] = value;
+    }
   }
-  focus(e = this.el, n = this.selectorFocus) {
-    (e.querySelector(n) || e).focus();
+  return result;
+}
+function getElement(query) {
+  if (typeof query === "string") {
+    return document.getElementById(query);
+  } else if (query instanceof HTMLElement) {
+    return query;
+  } else {
+    return null;
+  }
+}
+function maybeReturnSetting(prop, key, type = "camel") {
+  key = type === "camel" ? toCamel(key) : toKebab(key);
+  return prop.split(".").concat(key).reduce((obj, key2) => obj == null ? void 0 : obj[key2], this);
+}
+function getSetting(key, options = {}) {
+  const {
+    fallback,
+    props = ["dataConfig", "customProps", "settings", "context.settings"]
+  } = options;
+  for (const prop of props) {
+    const type = prop !== "customProps" ? "camel" : "kebab";
+    const result = maybeReturnSetting.call(this, prop, key, type);
+    if (result !== void 0) {
+      return result;
+    }
   }
-  getFocusable(e = this.el) {
-    const n = [], i = document.activeElement, r2 = e.scrollTop;
-    return e.querySelectorAll(v$2.join(",")).forEach((m2) => {
-      m2.focus(), document.activeElement === m2 && n.push(m2);
-    }), e.scrollTop = r2, i.focus(), n;
+  if (fallback !== void 0) {
+    return fallback;
   }
-};
-f$2 = /* @__PURE__ */ new WeakMap(), d$1 = /* @__PURE__ */ new WeakMap(), u$2 = /* @__PURE__ */ new WeakMap();
-function g$2(t) {
-  (t.key === "Tab" || t.keyCode === 9) && (t.shiftKey ? (document.activeElement === this.focusableFirst || document.activeElement === this.el) && (t.preventDefault(), this.focusableLast.focus()) : (document.activeElement === this.focusableLast || document.activeElement === this.el) && (t.preventDefault(), this.focusableFirst.focus()));
-}
-function p$2(t) {
-  (t.key === "Tab" || t.keyCode === 9) && t.preventDefault();
-}
-function q$2(t, e) {
-  const i = (t.getAttribute(`data-${e}`) || "").replace(/'/g, '"');
-  return i ? JSON.parse(i) : {};
-}
-function I$3() {
-  return getComputedStyle(document.body).getPropertyValue("--vrembem-variable-prefix").trim();
+  throw new Error(`${this.context.module} setting does not exist: ${key}`);
 }
-function C$2(t, e = true) {
-  const n = localStorage.getItem(t), i = n ? JSON.parse(n) : {};
-  return {
-    get(r2) {
-      return r2 ? i[r2] : i;
-    },
-    set(r2, c2) {
-      return c2 ? i[r2] = c2 : delete i[r2], e && localStorage.setItem(t, JSON.stringify(i)), i;
-    }
-  };
+async function lifecycleHook(name, ...args) {
+  if (name in this && typeof this[name] === "function") {
+    await this[name](...args);
+  }
 }
-function O$2(t, e, n) {
-  const i = e.nodeType === Node.COMMENT_NODE, r2 = e.nodeType === Node.ELEMENT_NODE;
-  if (e = i || r2 ? e : document.querySelector(e), i && (n = "after"), !e)
-    throw new Error(`Not a valid teleport reference: '${e}'`);
-  if (typeof e[n] != "function")
-    throw new Error(`Not a valid teleport method: '${n}'`);
-  let c2 = null;
-  return i || (c2 = document.createComment("teleported #" + t.id), t.before(c2)), e[n](t), i && e.remove(), c2;
-}
-const S$3 = (t, e) => new Promise((n) => {
-  e.transition ? (t.classList.remove(e.stateClosed), t.classList.add(e.stateOpening), t.addEventListener("transitionend", function i(r2) {
-    r2.target == t && (t.classList.add(e.stateOpened), t.classList.remove(e.stateOpening), n(t), this.removeEventListener("transitionend", i));
-  })) : (t.classList.add(e.stateOpened), t.classList.remove(e.stateClosed), n(t));
-}), F$3 = (t, e) => new Promise((n) => {
-  e.transition ? (t.classList.add(e.stateClosing), t.classList.remove(e.stateOpened), t.addEventListener("transitionend", function i(r2) {
-    r2.target == t && (t.classList.remove(e.stateClosing), t.classList.add(e.stateClosed), n(t), this.removeEventListener("transitionend", i));
-  })) : (t.classList.add(e.stateClosed), t.classList.remove(e.stateOpened), n(t));
-});
-function y$2(t, e) {
-  e && document.querySelectorAll(e).forEach((i) => {
-    t ? i.style.overflow = "hidden" : i.style.removeProperty("overflow");
+function transition(el, init, interim, final, duration = 0) {
+  return new Promise((resolve) => {
+    el.classList.remove(init);
+    el.classList.add(interim);
+    setTimeout(() => {
+      el.classList.add(final);
+      el.classList.remove(interim);
+      resolve(el);
+    }, toMilliseconds(duration));
   });
 }
-function L$2(t, e) {
-  e && document.querySelectorAll(e).forEach((i) => {
-    t ? (i.inert = true, i.setAttribute("aria-hidden", true)) : (i.inert = null, i.removeAttribute("aria-hidden"));
-  });
+function setOverflowHidden(state, selector) {
+  if (selector) {
+    const els = document.querySelectorAll(selector);
+    els.forEach((el) => {
+      if (state) {
+        el.style.overflow = "hidden";
+      } else {
+        el.style.removeProperty("overflow");
+      }
+    });
+  }
 }
-function k$3(t, e) {
-  L$2(!!t, e.selectorInert), y$2(!!t, e.selectorOverflow);
+function setInert(state, selector) {
+  if (selector) {
+    const els = document.querySelectorAll(selector);
+    els.forEach((el) => {
+      if (state) {
+        el.inert = true;
+        el.setAttribute("aria-hidden", true);
+      } else {
+        el.inert = null;
+        el.removeAttribute("aria-hidden");
+      }
+    });
+  }
 }
-const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  Breakpoint: $$2,
-  Collection: T$2,
-  FocusTrap: x$1,
-  closeTransition: F$3,
-  getConfig: q$2,
-  getPrefix: I$3,
-  localStore: C$2,
-  openTransition: S$3,
-  teleport: O$2,
-  updateGlobalState: k$3
-}, Symbol.toStringTag, { value: "Module" }));
-var S$2 = (t, e, s2) => {
-  if (!e.has(t))
-    throw TypeError("Cannot " + s2);
-};
-var p$1 = (t, e, s2) => (S$2(t, e, "read from private field"), s2 ? s2.call(t) : e.get(t)), E$1 = (t, e, s2) => {
-  if (e.has(t))
-    throw TypeError("Cannot add the same private member more than once");
-  e instanceof WeakSet ? e.add(t) : e.set(t, s2);
-}, $$1 = (t, e, s2, i) => (S$2(t, e, "write to private field"), i ? i.call(t, s2) : e.set(t, s2), s2);
-var I$2 = (t, e, s2) => {
-  if (!e.has(t))
-    throw TypeError("Cannot " + s2);
-}, l = (t, e, s2) => (I$2(t, e, "read from private field"), s2 ? s2.call(t) : e.get(t)), w$1 = (t, e, s2) => {
-  if (e.has(t))
-    throw TypeError("Cannot add the same private member more than once");
-  e instanceof WeakSet ? e.add(t) : e.set(t, s2);
-}, h$1 = (t, e, s2, i) => (I$2(t, e, "write to private field"), i ? i.call(t, s2) : e.set(t, s2), s2), c$1;
-let M$2 = class M {
-  constructor(e, s2) {
-    w$1(this, c$1, void 0), this.value = e, h$1(this, c$1, s2), this.mql = null;
+function setGlobalState(state, selectorInert, selectorOverflow) {
+  setInert(!!state, selectorInert);
+  setOverflowHidden(!!state, selectorOverflow);
+}
+class Breakpoint {
+  constructor(value, handler) {
+    __privateAdd(this, _handler);
+    this.value = value;
+    __privateSet(this, _handler, handler);
+    this.mql = null;
   }
   get handler() {
-    return l(this, c$1);
+    return __privateGet(this, _handler);
   }
   // Unmount existing handler before setting a new one.
-  set handler(e) {
-    this.mql && (typeof this.mql.removeEventListener == "function" ? this.mql.removeEventListener("change", l(this, c$1)) : this.mql.removeListener(l(this, c$1))), h$1(this, c$1, e);
+  set handler(func) {
+    if (this.mql) {
+      this.mql.removeEventListener("change", __privateGet(this, _handler));
+    }
+    __privateSet(this, _handler, func);
   }
-  mount(e, s2) {
-    return e && (this.value = e), s2 && h$1(this, c$1, s2), this.value ? (this.mql = window.matchMedia(`(min-width: ${this.value})`), typeof this.mql.addEventListener == "function" ? this.mql.addEventListener("change", l(this, c$1)) : this.mql.addListener(l(this, c$1)), l(this, c$1).call(this, this.mql), this) : this;
+  mount(value, handler) {
+    if (value) this.value = value;
+    if (handler) __privateSet(this, _handler, handler);
+    if (!this.value) return this;
+    this.mql = window.matchMedia(`(min-width: ${this.value})`);
+    this.mql.addEventListener("change", __privateGet(this, _handler));
+    __privateGet(this, _handler).call(this, this.mql);
+    return this;
   }
   unmount() {
-    return this.mql ? (typeof this.mql.removeEventListener == "function" ? this.mql.removeEventListener("change", l(this, c$1)) : this.mql.removeListener(l(this, c$1)), this.value = null, h$1(this, c$1, null), this.mql = null, this) : this;
-  }
-};
-c$1 = /* @__PURE__ */ new WeakMap();
-let P$1 = class P {
-  constructor() {
+    if (!this.mql) return this;
+    this.mql.removeEventListener("change", __privateGet(this, _handler));
+    this.value = null;
+    __privateSet(this, _handler, null);
+    this.mql = null;
+    return this;
+  }
+}
+_handler = new WeakMap();
+class Collection {
+  constructor(options = {}) {
+    this.module = this.constructor.name;
     this.collection = [];
+    this.settings = Object.assign({
+      dataConfig: "config",
+      customProps: [],
+      teleport: null,
+      teleportMethod: "append"
+    }, options);
+  }
+  get(value, key = "id") {
+    return this.collection.find((entry) => entry[key] === value);
+  }
+  applySettings(obj) {
+    return Object.assign(this.settings, obj);
+  }
+  async createEntry(query, config) {
+    return new CollectionEntry(this, query, config);
+  }
+  async register(query, config = {}) {
+    await this.deregister((query == null ? void 0 : query.id) || query, true);
+    const entry = await this.createEntry(query, config);
+    await entry.mount();
+    await lifecycleHook.call(this, "beforeRegister", entry);
+    await lifecycleHook.call(entry, "beforeRegister");
+    this.collection.push(entry);
+    await lifecycleHook.call(entry, "afterRegister");
+    await lifecycleHook.call(this, "afterRegister", entry);
+    return entry;
+  }
+  async deregister(id, reReg = false) {
+    const index2 = this.collection.findIndex((entry) => entry.id === id);
+    if (~index2) {
+      const entry = this.collection[index2];
+      await entry.unmount(reReg);
+      await lifecycleHook.call(this, "beforeDeregister", entry);
+      await lifecycleHook.call(entry, "beforeDeregister", reReg);
+      Object.getOwnPropertyNames(entry).forEach((prop) => {
+        if (prop != "beforeDeregister" && prop != "afterDeregister") {
+          delete entry[prop];
+        }
+      });
+      this.collection.splice(index2, 1);
+      await lifecycleHook.call(entry, "afterDeregister", reReg);
+      await lifecycleHook.call(this, "afterDeregister", entry);
+    }
+    return this.collection;
   }
-  async register(e) {
-    return await this.deregister(e), this.collection.push(e), this.collection;
+  async mount(options = {}) {
+    this.applySettings(options);
+    await lifecycleHook.call(this, "beforeMount");
+    const els = document.querySelectorAll(this.settings.selector);
+    for (const el of els) {
+      await this.register(el);
+    }
+    await lifecycleHook.call(this, "afterMount");
+    return this;
   }
-  async deregister(e) {
-    const s2 = this.collection.findIndex((i) => i === e);
-    if (s2 >= 0) {
-      const i = this.collection[s2];
-      Object.getOwnPropertyNames(i).forEach((n) => {
-        delete i[n];
-      }), this.collection.splice(s2, 1);
+  async unmount() {
+    await lifecycleHook.call(this, "beforeUnmount");
+    while (this.collection.length > 0) {
+      await this.deregister(this.collection[0].id);
     }
-    return this.collection;
+    await lifecycleHook.call(this, "afterUnmount");
+    return this;
   }
-  async registerCollection(e) {
-    return await Promise.all(Array.from(e, (s2) => {
-      this.register(s2);
-    })), this.collection;
+}
+class CollectionEntry {
+  constructor(context, query, options = {}) {
+    this.context = context;
+    this.id = (query == null ? void 0 : query.id) || query;
+    this.el = getElement(query);
+    this.settings = Object.assign({}, options);
+    this.dataConfig = {};
+    this.customProps = {};
+    this.returnRef = null;
   }
-  async deregisterCollection() {
-    for (; this.collection.length > 0; )
-      await this.deregister(this.collection[0]);
-    return this.collection;
+  applySettings(obj) {
+    return Object.assign(this.settings, obj);
   }
-  get(e, s2 = "id") {
-    return this.collection.find((i) => i[s2] === e);
+  getDataConfig() {
+    return Object.assign(this.dataConfig, getConfig(this.el, this.getSetting("dataConfig")));
   }
-};
-const r$1 = {
-  inert: ":not([inert]):not([inert] *)",
-  negTabIndex: ':not([tabindex^="-"])',
-  disabled: ":not(:disabled)"
-}, F$2 = [
-  `a[href]${r$1.inert}${r$1.negTabIndex}`,
-  `area[href]${r$1.inert}${r$1.negTabIndex}`,
-  `input:not([type="hidden"]):not([type="radio"])${r$1.inert}${r$1.negTabIndex}${r$1.disabled}`,
-  `input[type="radio"]${r$1.inert}${r$1.negTabIndex}${r$1.disabled}`,
-  `select${r$1.inert}${r$1.negTabIndex}${r$1.disabled}`,
-  `textarea${r$1.inert}${r$1.negTabIndex}${r$1.disabled}`,
-  `button${r$1.inert}${r$1.negTabIndex}${r$1.disabled}`,
-  `details${r$1.inert} > summary:first-of-type${r$1.negTabIndex}`,
-  // Discard until Firefox supports `:has()`
-  // See: https://github.com/KittyGiraudel/focusable-selectors/issues/12
-  // `details:not(:has(> summary))${not.inert}${not.negTabIndex}`,
-  `iframe${r$1.inert}${r$1.negTabIndex}`,
-  `audio[controls]${r$1.inert}${r$1.negTabIndex}`,
-  `video[controls]${r$1.inert}${r$1.negTabIndex}`,
-  `[contenteditable]${r$1.inert}${r$1.negTabIndex}`,
-  `[tabindex]${r$1.inert}${r$1.negTabIndex}`
-];
-var v$1, u$1, g$1;
-let B$2 = class B {
-  constructor(e = null, s2 = "[data-focus]") {
-    w$1(this, v$1, void 0), w$1(this, u$1, void 0), w$1(this, g$1, void 0), this.el = e, this.selectorFocus = s2, h$1(this, u$1, _$2.bind(this)), h$1(this, g$1, N$2.bind(this));
+  getCustomProps() {
+    return Object.assign(this.customProps, getCustomProps(this));
   }
-  get focusable() {
-    return l(this, v$1);
+  getSetting(key, options = {}) {
+    return getSetting.call(this, key, options);
+  }
+  async mount(options = {}) {
+    if (this.el === null) {
+      throw new Error(`${this.context.module} element was not found with ID: "${this.id}"`);
+    }
+    this.applySettings(options);
+    this.getDataConfig();
+    this.getCustomProps();
+    await lifecycleHook.call(this, "beforeMount");
+    if (this.getSetting("teleport")) {
+      this.teleport();
+    }
+    await lifecycleHook.call(this, "afterMount");
+  }
+  async unmount(reMount = false) {
+    await lifecycleHook.call(this, "beforeUnmount", reMount);
+    if (this.getSetting("teleport")) {
+      this.teleportReturn();
+    }
+    await lifecycleHook.call(this, "afterUnmount", reMount);
+  }
+  teleport(ref = this.getSetting("teleport"), method = this.getSetting("teleportMethod")) {
+    if (!this.returnRef) {
+      this.returnRef = teleport(this.el, ref, method);
+      return this.el;
+    } else {
+      console.error("Element has already been teleported:", this.el);
+      return false;
+    }
   }
-  set focusable(e) {
-    h$1(this, v$1, e), l(this, v$1).length ? (document.removeEventListener("keydown", l(this, g$1)), document.addEventListener("keydown", l(this, u$1))) : (document.removeEventListener("keydown", l(this, u$1)), document.addEventListener("keydown", l(this, g$1)));
+  teleportReturn() {
+    if (this.returnRef) {
+      this.returnRef = teleport(this.el, this.returnRef);
+      return this.el;
+    } else {
+      console.error("No return reference found:", this.el);
+      return false;
+    }
+  }
+}
+class FocusTrap {
+  constructor(el = null, selectorFocus = "[data-focus]") {
+    __privateAdd(this, _focusable);
+    __privateAdd(this, _handleFocusTrap);
+    __privateAdd(this, _handleFocusLock);
+    this.el = el;
+    this.selectorFocus = selectorFocus;
+    __privateSet(this, _handleFocusTrap, handleFocusTrap.bind(this));
+    __privateSet(this, _handleFocusLock, handleFocusLock.bind(this));
+  }
+  get focusable() {
+    return __privateGet(this, _focusable);
+  }
+  set focusable(value) {
+    __privateSet(this, _focusable, value);
+    if (__privateGet(this, _focusable).length) {
+      document.removeEventListener("keydown", __privateGet(this, _handleFocusLock));
+      document.addEventListener("keydown", __privateGet(this, _handleFocusTrap));
+    } else {
+      document.removeEventListener("keydown", __privateGet(this, _handleFocusTrap));
+      document.addEventListener("keydown", __privateGet(this, _handleFocusLock));
+    }
   }
   get focusableFirst() {
     return this.focusable[0];
@@ -292,80 +340,214 @@ let B$2 = class B {
   get focusableLast() {
     return this.focusable[this.focusable.length - 1];
   }
-  mount(e, s2) {
-    e && (this.el = e), s2 && (this.selectorFocus = s2), this.focusable = this.getFocusable(), this.focus();
+  mount(el, selectorFocus) {
+    if (el) this.el = el;
+    if (selectorFocus) this.selectorFocus = selectorFocus;
+    this.focusable = this.getFocusable();
+    this.focus();
   }
   unmount() {
-    this.el = null, this.focusable = [], document.removeEventListener("keydown", l(this, u$1)), document.removeEventListener("keydown", l(this, g$1));
-  }
-  focus(e = this.el, s2 = this.selectorFocus) {
-    (e.querySelector(s2) || e).focus();
-  }
-  getFocusable(e = this.el) {
-    const s2 = [], i = document.activeElement, n = e.scrollTop;
-    return e.querySelectorAll(F$2.join(",")).forEach((a2) => {
-      a2.focus(), document.activeElement === a2 && s2.push(a2);
-    }), e.scrollTop = n, i.focus(), s2;
+    this.el = null;
+    this.focusable = [];
+    document.removeEventListener("keydown", __privateGet(this, _handleFocusTrap));
+    document.removeEventListener("keydown", __privateGet(this, _handleFocusLock));
+  }
+  focus(el = this.el, selectorFocus = this.selectorFocus) {
+    const result = el.querySelector(selectorFocus) || el;
+    result.focus();
+  }
+  getFocusable(el = this.el) {
+    const focusable = [];
+    const initFocus = document.activeElement;
+    const initScrollTop = el.scrollTop;
+    const selector = focusableSelectors.join(",");
+    const els = el.querySelectorAll(selector);
+    els.forEach((el2) => {
+      el2.focus();
+      if (document.activeElement === el2) {
+        focusable.push(el2);
+      }
+    });
+    el.scrollTop = initScrollTop;
+    initFocus.focus();
+    return focusable;
+  }
+}
+_focusable = new WeakMap();
+_handleFocusTrap = new WeakMap();
+_handleFocusLock = new WeakMap();
+const notInert = ":not([inert])";
+const notNegTabIndex = ':not([tabindex^="-"])';
+const notDisabled = ":not(:disabled)";
+const focusableSelectors = [
+  `a[href]${notInert}${notNegTabIndex}`,
+  `area[href]${notInert}${notNegTabIndex}`,
+  `input:not([type="hidden"]):not([type="radio"])${notInert}${notNegTabIndex}${notDisabled}`,
+  `input[type="radio"]${notInert}${notNegTabIndex}${notDisabled}`,
+  `select${notInert}${notNegTabIndex}${notDisabled}`,
+  `textarea${notInert}${notNegTabIndex}${notDisabled}`,
+  `button${notInert}${notNegTabIndex}${notDisabled}`,
+  `details${notInert} > summary:first-of-type${notNegTabIndex}`,
+  `iframe${notInert}${notNegTabIndex}`,
+  `audio[controls]${notInert}${notNegTabIndex}`,
+  `video[controls]${notInert}${notNegTabIndex}`,
+  `[contenteditable]${notInert}${notNegTabIndex}`,
+  `[tabindex]${notInert}${notNegTabIndex}`
+];
+function handleFocusTrap(event) {
+  const isTab = event.key === "Tab" || event.keyCode === 9;
+  if (!isTab) return;
+  if (event.shiftKey) {
+    if (document.activeElement === this.focusableFirst || document.activeElement === this.el) {
+      event.preventDefault();
+      this.focusableLast.focus();
+    }
+  } else {
+    if (document.activeElement === this.focusableLast || document.activeElement === this.el) {
+      event.preventDefault();
+      this.focusableFirst.focus();
+    }
   }
-};
-v$1 = /* @__PURE__ */ new WeakMap(), u$1 = /* @__PURE__ */ new WeakMap(), g$1 = /* @__PURE__ */ new WeakMap();
-function _$2(t) {
-  (t.key === "Tab" || t.keyCode === 9) && (t.shiftKey ? (document.activeElement === this.focusableFirst || document.activeElement === this.el) && (t.preventDefault(), this.focusableLast.focus()) : (document.activeElement === this.focusableLast || document.activeElement === this.el) && (t.preventDefault(), this.focusableFirst.focus()));
-}
-function N$2(t) {
-  (t.key === "Tab" || t.keyCode === 9) && t.preventDefault();
-}
-function K$2(t, e) {
-  const s2 = (t.getAttribute(`data-${e}`) || "").replace(/'/g, '"');
-  return s2 ? JSON.parse(s2) : {};
 }
-function W$1() {
-  return getComputedStyle(document.body).getPropertyValue("--vrembem-variable-prefix").trim();
+function handleFocusLock(event) {
+  const isTab = event.key === "Tab" || event.keyCode === 9;
+  if (isTab) event.preventDefault();
 }
-function V(t, e = true) {
-  const s2 = localStorage.getItem(t), i = s2 ? JSON.parse(s2) : {};
+function localStore(key, enable = true) {
+  const local = localStorage.getItem(key);
+  const store = local ? JSON.parse(local) : {};
   return {
-    get(n) {
-      return n ? i[n] : i;
+    get(prop) {
+      return prop ? store[prop] : store;
     },
-    set(n, a2) {
-      return a2 ? i[n] = a2 : delete i[n], e && localStorage.setItem(t, JSON.stringify(i)), i;
+    set(prop, value) {
+      if (value) {
+        store[prop] = value;
+      } else {
+        delete store[prop];
+      }
+      if (enable) localStorage.setItem(key, JSON.stringify(store));
+      return store;
     }
   };
 }
-const J$2 = (t, e) => new Promise((s2) => {
-  e.transition ? (t.classList.remove(e.stateClosed), t.classList.add(e.stateOpening), t.addEventListener("transitionend", function i(n) {
-    n.target == t && (t.classList.add(e.stateOpened), t.classList.remove(e.stateOpening), s2(t), this.removeEventListener("transitionend", i));
-  })) : (t.classList.add(e.stateOpened), t.classList.remove(e.stateClosed), s2(t));
-}), z$1 = (t, e) => new Promise((s2) => {
-  e.transition ? (t.classList.add(e.stateClosing), t.classList.remove(e.stateOpened), t.addEventListener("transitionend", function i(n) {
-    n.target == t && (t.classList.remove(e.stateClosing), t.classList.add(e.stateClosed), s2(t), this.removeEventListener("transitionend", i));
-  })) : (t.classList.add(e.stateClosed), t.classList.remove(e.stateOpened), s2(t));
-});
-function G$1(t, e) {
-  e && document.querySelectorAll(e).forEach((s2) => {
-    t ? s2.style.overflow = "hidden" : s2.style.removeProperty("overflow");
-  });
-}
-function H$2(t, e) {
-  e && document.querySelectorAll(e).forEach((s2) => {
-    t ? (s2.inert = true, s2.setAttribute("aria-hidden", true)) : (s2.inert = null, s2.removeAttribute("aria-hidden"));
-  });
-}
-function k$2(t, e) {
-  H$2(!!t, e.selectorInert), G$1(!!t, e.selectorOverflow);
+function teleport(what, where, how) {
+  const isComment = where.nodeType === Node.COMMENT_NODE;
+  const isElement2 = where.nodeType === Node.ELEMENT_NODE;
+  where = isComment || isElement2 ? where : document.querySelector(where);
+  if (isComment) how = "after";
+  if (!where) throw new Error(`Not a valid teleport reference: '${where}'`);
+  if (typeof where[how] != "function") throw new Error(`Not a valid teleport method: '${how}'`);
+  let returnRef = null;
+  if (!isComment) {
+    returnRef = document.createComment("teleported #" + what.id);
+    what.before(returnRef);
+  }
+  where[how](what);
+  if (isComment) {
+    where.remove();
+  }
+  return returnRef;
+}
+function themeStore(options) {
+  const settings = {
+    prefix: cssVar("prefix-themes", { fallback: "vb-theme-" }),
+    themes: ["root", "light", "dark"],
+    storeKey: "VB:Profile"
+  };
+  for (const [key] of Object.entries(settings)) {
+    if (options && options[key]) {
+      settings[key] = options[key];
+    }
+  }
+  const callbacks = {
+    onInit() {
+    },
+    onChange() {
+    }
+  };
+  for (const [key] of Object.entries(callbacks)) {
+    if (options && options[key]) {
+      callbacks[key] = options[key];
+    }
+  }
+  const profile = localStore(settings.storeKey);
+  const api = {
+    // Store our settings in the API.
+    settings,
+    // Actions.
+    add(value) {
+      settings.themes.push(value);
+    },
+    remove(value) {
+      const index2 = settings.themes.indexOf(value);
+      ~index2 && settings.themes.splice(index2, 1);
+    },
+    callback(name) {
+      callbacks[name].call(this);
+    },
+    // Getters.
+    get class() {
+      return `${settings.prefix}${this.theme}`;
+    },
+    get classes() {
+      return settings.themes.map((theme) => `${settings.prefix}${theme}`);
+    },
+    get themes() {
+      return settings.themes;
+    },
+    // Setup the theme get and set methods.
+    get theme() {
+      return profile.get("theme") || "root";
+    },
+    set theme(value) {
+      if (settings.themes.includes(value)) {
+        if (this.theme != value) {
+          profile.set("theme", value);
+          document.documentElement.classList.remove(...this.classes);
+          document.documentElement.classList.add(`${settings.prefix}${value}`);
+          this.callback("onChange");
+        }
+      } else {
+        console.error(`Not a valid theme value: "${value}"`);
+      }
+    }
+  };
+  api.callback("onInit");
+  return api;
 }
-const Q$1 = {
-  autoInit: false,
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Breakpoint,
+  Collection,
+  CollectionEntry,
+  FocusTrap,
+  cssVar,
+  getConfig,
+  getCustomProps,
+  getElement,
+  getPrefix,
+  getSetting,
+  lifecycleHook,
+  localStore,
+  setGlobalState,
+  teleport,
+  themeStore,
+  toCamel,
+  toKebab,
+  toMilliseconds,
+  transition
+}, Symbol.toStringTag, { value: "Module" }));
+const defaults$2 = {
   // Data attributes
   dataOpen: "drawer-open",
   dataClose: "drawer-close",
   dataToggle: "drawer-toggle",
   dataBreakpoint: "drawer-breakpoint",
-  dataConfig: "drawer-config",
   // Selectors
-  selectorDrawer: ".drawer",
+  selector: ".drawer",
   selectorDialog: ".drawer__dialog",
+  selectorScreen: ".drawer",
   selectorFocus: "[data-focus]",
   selectorInert: null,
   selectorOverflow: "body",
@@ -377,378 +559,379 @@ const Q$1 = {
   // Classes
   classModal: "drawer_modal",
   // Feature toggles
+  customProps: [
+    "transition-duration"
+  ],
   breakpoints: null,
   customEventPrefix: "drawer:",
-  eventListeners: true,
   store: true,
   storeKey: "VB:DrawerState",
   setTabindex: true,
-  transition: true
+  teleport: null,
+  teleportMethod: "prepend",
+  transition: true,
+  transitionDuration: 300
 };
-function R$1(t) {
-  const e = t.target.closest(`
-    [data-${this.settings.dataOpen}],
-    [data-${this.settings.dataToggle}],
-    [data-${this.settings.dataClose}]
-  `);
-  if (e) {
-    t.preventDefault(), e.matches(`[data-${this.settings.dataToggle}]`) && e.getAttribute(`data-${this.settings.dataToggle}`).trim().split(" ").forEach((i) => {
-      const n = this.get(i);
-      n.trigger = e, n.toggle();
-    }), e.matches(`[data-${this.settings.dataOpen}]`) && e.getAttribute(`data-${this.settings.dataOpen}`).trim().split(" ").forEach((i) => {
-      const n = this.get(i);
-      n.trigger = e, n.open();
-    }), e.matches(`[data-${this.settings.dataClose}]`) && e.getAttribute(`data-${this.settings.dataClose}`).trim().split(" ").forEach((i) => {
-      if (i) {
-        const n = this.get(i);
-        n.trigger = e, n.close();
-      } else {
-        const n = t.target.closest(this.settings.selectorDrawer);
-        n && this.close(n);
-      }
-    });
-    return;
+function applyInitialState(entry) {
+  if (entry.store === "opened") {
+    entry.open(false, false);
+  } else if (entry.store === "closed") {
+    entry.close(false, false);
+  } else if (entry.store === "indeterminate") {
+    entry.state = "indeterminate";
+  } else {
+    if (entry.el.classList.contains(entry.getSetting("stateOpened"))) {
+      entry.open(false, false);
+    } else if (entry.el.classList.contains(entry.getSetting("stateClosed"))) {
+      entry.close(false, false);
+    } else {
+      entry.state = "indeterminate";
+    }
   }
-  t.target.matches(this.settings.selectorDrawer) && this.close(t.target.id);
 }
-function U$1(t) {
-  if (t.key === "Escape") {
-    const e = this.activeModal;
-    e && this.close(e);
+async function applyInlineState(entry) {
+  if (entry.store === "opened") {
+    await entry.open(false, false);
+  } else if (entry.store === "closed") {
+    await entry.close(false, false);
+  } else if (entry.store === "indeterminate") {
+    if (entry.state != "indeterminate") {
+      entry.state = "indeterminate";
+    }
+  } else {
+    if (entry.state != entry.inlineState) {
+      entry.state = entry.inlineState;
+    }
+    if (entry.inlineState === "opened") {
+      await entry.open(false, false);
+    } else if (entry.inlineState === "closed") {
+      await entry.close(false, false);
+    }
   }
 }
-async function L$1(t, e = true) {
-  if (!t)
-    return this.collection;
-  const s2 = this.collection.findIndex((i) => i.id === t.id);
-  if (s2 >= 0) {
-    const i = this.collection[s2];
-    e && i.state === "opened" && await i.close(false), this.store.set(i.id), i.unmountBreakpoint(), Object.getOwnPropertyNames(i).forEach((n) => {
-      delete i[n];
-    }), this.collection.splice(s2, 1);
-  }
-  return this.collection;
-}
-function X(t) {
-  const e = W$1(), s2 = t.getAttribute(`data-${this.settings.dataBreakpoint}`);
-  return this.settings.breakpoints && this.settings.breakpoints[s2] ? this.settings.breakpoints[s2] : getComputedStyle(document.body).getPropertyValue(`--${e}breakpoint-${s2}`).trim() ? getComputedStyle(document.body).getPropertyValue(`--${e}breakpoint-${s2}`).trim() : s2;
-}
-function y$1(t) {
-  const e = typeof t == "string" ? this.get(t) : this.get(t.id);
-  if (e)
-    return e;
-  throw new Error(`Drawer not found in collection with id of "${t.id || t}".`);
-}
-function O$1(t) {
-  return typeof t == "string" ? t : typeof t.hasAttribute == "function" ? t.hasAttribute(`data-${this.settings.dataOpen}`) ? t.getAttribute(`data-${this.settings.dataOpen}`) : t.hasAttribute(`data-${this.settings.dataClose}`) ? t.getAttribute(`data-${this.settings.dataClose}`) || false : t.hasAttribute(`data-${this.settings.dataToggle}`) ? t.getAttribute(`data-${this.settings.dataToggle}`) : t.closest(this.settings.selectorDrawer) ? (t = t.closest(this.settings.selectorDrawer), t.id || false) : false : t.id ? t.id : false;
-}
-function Y(t) {
-  const e = O$1.call(this, t);
-  if (e) {
-    const s2 = document.querySelector(`#${e}`), i = s2 ? s2.querySelector(this.settings.selectorDialog) : null;
-    return !s2 && !i ? { error: new Error(`No drawer elements found using the ID: "${e}".`) } : i ? { drawer: s2, dialog: i } : { error: new Error("Drawer is missing dialog element.") };
-  } else
-    return { error: new Error("Could not resolve the drawer ID.") };
-}
-async function A$1(t) {
-  this.store.get(t.id) ? this.store.get(t.id) === "opened" ? await t.open(false, false) : await t.close(false, false) : t.el.classList.contains(this.settings.stateOpened) ? t.state = "opened" : (t.el.classList.remove(this.settings.stateOpening), t.el.classList.remove(this.settings.stateClosing), t.el.classList.add(this.settings.stateClosed));
-}
-function D$2(t) {
-  t.state === "opened" ? t.mode === "modal" ? this.focusTrap.mount(t.dialog, this.settings.selectorFocus) : this.focusTrap.focus(t.dialog, this.settings.selectorFocus) : (t.trigger && (t.trigger.focus(), t.trigger = null), this.focusTrap.unmount());
-}
-async function C$1(t, e, s2 = true) {
-  const i = y$1.call(this, t), n = { ...this.settings, ...i.settings };
-  return e !== void 0 && (n.transition = e), i.state === "closed" && (i.state = "opening", await J$2(i.el, n), i.mode === "modal" && k$2(true, n), i.state = "opened"), s2 && D$2.call(this, i), i.el.dispatchEvent(new CustomEvent(n.customEventPrefix + "opened", {
-    detail: this,
-    bubbles: true
-  })), i;
+function getBreakpoint(drawer) {
+  const prefix = getPrefix();
+  const bp = drawer.getAttribute(`data-${this.settings.dataBreakpoint}`);
+  if (this.settings.breakpoints && this.settings.breakpoints[bp]) {
+    return this.settings.breakpoints[bp];
+  } else if (getComputedStyle(document.body).getPropertyValue(`--${prefix}breakpoint-${bp}`).trim()) {
+    return getComputedStyle(document.body).getPropertyValue(`--${prefix}breakpoint-${bp}`).trim();
+  } else {
+    return bp;
+  }
 }
-async function b$1(t, e, s2 = true) {
-  const i = y$1.call(this, t), n = { ...this.settings, ...i.settings };
-  return e !== void 0 && (n.transition = e), i.state === "opened" && (i.state = "closing", document.activeElement.blur(), await z$1(i.el, n), i.mode === "modal" && k$2(false, n), s2 && D$2.call(this, i), i.state = "closed", i.el.dispatchEvent(new CustomEvent(n.customEventPrefix + "closed", {
-    detail: this,
-    bubbles: true
-  }))), i;
+function getDrawer(query) {
+  const entry = typeof query === "string" ? this.get(query) : query;
+  if (entry) {
+    return entry;
+  } else {
+    throw new Error(`Drawer not found in collection with id of "${query.id || query}".`);
+  }
 }
-async function q$1(t, e, s2) {
-  const i = y$1.call(this, t);
-  return i.state === "closed" ? C$1.call(this, i, e, s2) : b$1.call(this, i, e, s2);
+function updateFocusState$1(entry) {
+  if (entry.state === "opened") {
+    if (entry.mode === "modal") {
+      this.focusTrap.mount(entry.dialog, this.settings.selectorFocus);
+    } else {
+      this.focusTrap.focus(entry.dialog, this.settings.selectorFocus);
+    }
+  } else {
+    if (entry.trigger) {
+      entry.trigger.focus();
+      entry.trigger = null;
+    }
+    this.focusTrap.unmount();
+  }
 }
-function Z$1(t) {
-  switch (t.mode) {
+function switchMode(entry) {
+  switch (entry.mode) {
     case "inline":
-      return j.call(this, t);
+      return toInline.call(this, entry);
     case "modal":
-      return tt$1.call(this, t);
+      return toModal.call(this, entry);
     default:
-      throw new Error(`"${t.mode}" is not a valid drawer mode.`);
+      throw new Error(`"${entry.mode}" is not a valid drawer mode.`);
   }
 }
-async function j(t) {
-  return t.el.classList.remove(t.getSetting("classModal")), t.dialog.removeAttribute("aria-modal"), k$2(false, { ...this.settings, ...t.settings }), this.focusTrap.unmount(), await A$1.call(this, t), t.el.dispatchEvent(new CustomEvent(t.getSetting("customEventPrefix") + "switchMode", {
+async function toInline(entry) {
+  entry.el.classList.remove(entry.getSetting("classModal"));
+  entry.dialog.removeAttribute("aria-modal");
+  setGlobalState(false, entry.getSetting("selectorInert"), entry.getSetting("selectorOverflow"));
+  this.focusTrap.unmount();
+  await applyInlineState(entry);
+  entry.el.dispatchEvent(new CustomEvent(entry.getSetting("customEventPrefix") + "switchMode", {
     detail: this,
     bubbles: true
-  })), t;
-}
-async function tt$1(t) {
-  return t.el.classList.add(t.getSetting("classModal")), t.dialog.setAttribute("aria-modal", "true"), !this.store.get(t.id) && t.el.classList.contains(t.getSetting("stateOpened")) && this.store.set(t.id, "opened"), await b$1.call(this, t, false, false), t.el.dispatchEvent(new CustomEvent(t.getSetting("customEventPrefix") + "switchMode", {
+  }));
+  return entry;
+}
+async function toModal(entry) {
+  entry.el.classList.add(entry.getSetting("classModal"));
+  entry.dialog.setAttribute("aria-modal", "true");
+  await entry.close(false, false);
+  entry.el.dispatchEvent(new CustomEvent(entry.getSetting("customEventPrefix") + "switchMode", {
     detail: this,
     bubbles: true
-  })), t;
-}
-async function et$1(t, e) {
-  await L$1.call(this, t, false);
-  const s2 = this, i = new M$2(), n = {
-    open(o2, d2) {
-      return C$1.call(s2, this, o2, d2);
-    },
-    close(o2, d2) {
-      return b$1.call(s2, this, o2, d2);
-    },
-    toggle(o2, d2) {
-      return q$1.call(s2, this, o2, d2);
-    },
-    deregister() {
-      return L$1.call(s2, this);
-    },
-    mountBreakpoint() {
-      const o2 = this.breakpoint, d2 = this.handleBreakpoint.bind(this);
-      return i.mount(o2, d2), this;
-    },
-    unmountBreakpoint() {
-      return i.unmount(), this;
-    },
-    handleBreakpoint(o2) {
-      return this.mode = o2.matches ? "inline" : "modal", this;
-    },
-    getSetting(o2) {
-      return o2 in this.settings ? this.settings[o2] : s2.settings[o2];
-    }
-  }, a2 = {
-    id: t.id,
-    el: t,
-    dialog: e,
-    trigger: null,
-    settings: K$2(t, this.settings.dataConfig),
-    get breakpoint() {
-      return X.call(s2, t);
-    },
-    get state() {
-      return T3;
-    },
-    set state(o2) {
-      T3 = o2, (o2 === "opened" || o2 === "closed") && this.mode === "inline" && s2.store.set(this.id, this.state);
-    },
-    get mode() {
-      return x3;
-    },
-    set mode(o2) {
-      x3 = o2, Z$1.call(s2, this);
-    },
-    ...n
-  };
-  let T3 = t.classList.contains(a2.getSetting("stateOpened")) ? "opened" : "closed", x3 = t.classList.contains(a2.getSetting("classModal")) ? "modal" : "inline";
-  return a2.mode === "modal" ? a2.dialog.setAttribute("aria-modal", "true") : a2.dialog.removeAttribute("aria-modal"), a2.getSetting("setTabindex") && a2.dialog.setAttribute("tabindex", "-1"), this.collection.push(a2), a2.breakpoint ? a2.mountBreakpoint() : await A$1.call(this, a2), a2;
-}
-var f$1, m$1;
-let it$1 = class it extends P$1 {
-  constructor(s2) {
-    super();
-    E$1(this, f$1, void 0);
-    E$1(this, m$1, void 0);
-    this.defaults = Q$1, this.settings = { ...this.defaults, ...s2 }, this.focusTrap = new B$2(), this.store = V(this.settings.storeKey, this.settings.store), $$1(this, f$1, R$1.bind(this)), $$1(this, m$1, U$1.bind(this)), this.settings.autoInit && this.init();
+  }));
+  return entry;
+}
+class DrawerEntry extends CollectionEntry {
+  constructor(context, query, options = {}) {
+    super(context, query, options);
+    __privateAdd(this, _mode);
+    __privateAdd(this, _state);
+    __privateAdd(this, _breakpoint);
+    this.dialog = null;
+    this.trigger = null;
+    __privateSet(this, _breakpoint, new Breakpoint());
+    __privateSet(this, _mode, "indeterminate");
+    __privateSet(this, _state, "indeterminate");
+    this.inlineState = "indeterminate";
+  }
+  get breakpoint() {
+    return getBreakpoint.call(this.context, this.el);
+  }
+  get store() {
+    return this.context.store.get(this.id);
+  }
+  get mode() {
+    return __privateGet(this, _mode);
+  }
+  set mode(value) {
+    __privateSet(this, _mode, value);
+    switchMode.call(this.context, this);
+  }
+  get state() {
+    return __privateGet(this, _state);
+  }
+  set state(value) {
+    __privateSet(this, _state, value);
+    if (this.mode === "inline" && value != "opening" && value != "closing") {
+      this.inlineState = value;
+      if (this.getSetting("store")) {
+        this.context.store.set(this.id, value);
+      }
+    }
+    if (value === "indeterminate") {
+      this.el.classList.remove(this.getSetting("stateOpened"));
+      this.el.classList.remove(this.getSetting("stateOpening"));
+      this.el.classList.remove(this.getSetting("stateClosed"));
+      this.el.classList.remove(this.getSetting("stateClosing"));
+    }
   }
-  get activeModal() {
-    return this.collection.find((s2) => s2.state === "opened" && s2.mode === "modal");
+  async open(transition2, focus) {
+    return this.context.open(this, transition2, focus);
   }
-  async init(s2 = null) {
-    s2 && (this.settings = { ...this.settings, ...s2 });
-    const i = document.querySelectorAll(this.settings.selectorDrawer);
-    return await this.registerCollection(i), this.settings.eventListeners && this.initEventListeners(), this;
+  async close(transition2, focus) {
+    return this.context.close(this, transition2, focus);
   }
-  async destroy() {
-    return await this.deregisterCollection(), this.settings.eventListeners && this.destroyEventListeners(), this;
+  async toggle(transition2, focus) {
+    return this.context.toggle(this, transition2, focus);
   }
-  initEventListeners() {
-    document.addEventListener("click", p$1(this, f$1), false), document.addEventListener("keydown", p$1(this, m$1), false);
+  async deregister() {
+    return this.context.deregister(this.id);
   }
-  destroyEventListeners() {
-    document.removeEventListener("click", p$1(this, f$1), false), document.removeEventListener("keydown", p$1(this, m$1), false);
+  mountBreakpoint() {
+    const value = this.breakpoint;
+    const handler = this.handleBreakpoint.bind(this);
+    __privateGet(this, _breakpoint).mount(value, handler);
   }
-  register(s2) {
-    const i = Y.call(this, s2);
-    return i.error ? Promise.reject(i.error) : et$1.call(this, i.drawer, i.dialog);
+  unmountBreakpoint() {
+    __privateGet(this, _breakpoint).unmount();
   }
-  deregister(s2) {
-    const i = this.get(O$1.call(this, s2));
-    return L$1.call(this, i);
+  handleBreakpoint(event) {
+    const bpMode = event.matches ? "inline" : "modal";
+    if (this.mode != bpMode) {
+      this.mode = bpMode;
+    }
   }
-  open(s2, i, n) {
-    return C$1.call(this, s2, i, n);
+  async beforeMount() {
+    const dialog = this.el.querySelector(this.getSetting("selectorDialog"));
+    this.dialog = dialog ? dialog : this.el;
+    if (this.getSetting("setTabindex")) {
+      this.dialog.setAttribute("tabindex", "-1");
+    }
+    applyInitialState(this);
+    this.inlineState = this.state;
+    this.mode = this.el.classList.contains(this.getSetting("classModal")) ? "modal" : "inline";
+    if (this.breakpoint) {
+      this.mountBreakpoint();
+    }
   }
-  close(s2, i, n) {
-    return b$1.call(this, s2, i, n);
+  async beforeUnmount(close2 = true) {
+    if (close2 && this.state === "opened") {
+      await this.close(false);
+    }
+    this.context.store.set(this.id);
+    this.unmountBreakpoint();
   }
-  toggle(s2, i, n) {
-    return q$1.call(this, s2, i, n);
+}
+_mode = new WeakMap();
+_state = new WeakMap();
+_breakpoint = new WeakMap();
+async function handleClick$2(event) {
+  const trigger = event.target.closest(`
+    [data-${this.settings.dataOpen}],
+    [data-${this.settings.dataToggle}],
+    [data-${this.settings.dataClose}]
+  `);
+  if (trigger) {
+    event.preventDefault();
+    if (trigger.matches(`[data-${this.settings.dataToggle}]`)) {
+      const selectors = trigger.getAttribute(`data-${this.settings.dataToggle}`).trim().split(" ");
+      selectors.forEach((selector) => {
+        const entry = getDrawer.call(this, selector);
+        entry.trigger = trigger;
+        return entry.toggle();
+      });
+    }
+    if (trigger.matches(`[data-${this.settings.dataOpen}]`)) {
+      const selectors = trigger.getAttribute(`data-${this.settings.dataOpen}`).trim().split(" ");
+      selectors.forEach((selector) => {
+        const entry = getDrawer.call(this, selector);
+        entry.trigger = trigger;
+        return entry.open();
+      });
+    }
+    if (trigger.matches(`[data-${this.settings.dataClose}]`)) {
+      const selectors = trigger.getAttribute(`data-${this.settings.dataClose}`).trim().split(" ");
+      selectors.forEach((selector) => {
+        if (selector) {
+          const entry = getDrawer.call(this, selector);
+          entry.trigger = trigger;
+          return entry.close();
+        } else {
+          const parent = event.target.closest(this.settings.selector);
+          if (parent) return this.close(parent.id);
+        }
+      });
+    }
+    return;
   }
-};
-f$1 = /* @__PURE__ */ new WeakMap(), m$1 = /* @__PURE__ */ new WeakMap();
-var I$1 = (e, t, s2) => {
-  if (!t.has(e))
-    throw TypeError("Cannot " + s2);
-};
-var f = (e, t, s2) => (I$1(e, t, "read from private field"), s2 ? s2.call(e) : t.get(e)), v = (e, t, s2) => {
-  if (t.has(e))
-    throw TypeError("Cannot add the same private member more than once");
-  t instanceof WeakSet ? t.add(e) : t.set(e, s2);
-}, b = (e, t, s2, i) => (I$1(e, t, "write to private field"), i ? i.call(e, s2) : t.set(e, s2), s2);
-var k$1 = (e, t, s2) => {
-  if (!t.has(e))
-    throw TypeError("Cannot " + s2);
-}, o = (e, t, s2) => (k$1(e, t, "read from private field"), s2 ? s2.call(e) : t.get(e)), y = (e, t, s2) => {
-  if (t.has(e))
-    throw TypeError("Cannot add the same private member more than once");
-  t instanceof WeakSet ? t.add(e) : t.set(e, s2);
-}, E = (e, t, s2, i) => (k$1(e, t, "write to private field"), i ? i.call(e, s2) : t.set(e, s2), s2);
-class A {
-  constructor() {
-    this.collection = [];
+  if (this.activeModal && event.target.matches(this.settings.selectorScreen)) {
+    return this.close(this.activeModal.id);
   }
-  async register(t) {
-    return await this.deregister(t), this.collection.push(t), this.collection;
+}
+function handleKeydown$2(event) {
+  if (event.key === "Escape") {
+    if (this.activeModal) return this.close(this.activeModal.id);
   }
-  async deregister(t) {
-    const s2 = this.collection.findIndex((i) => i === t);
-    if (s2 >= 0) {
-      const i = this.collection[s2];
-      Object.getOwnPropertyNames(i).forEach((n) => {
-        delete i[n];
-      }), this.collection.splice(s2, 1);
+}
+async function open$2(query, transitionOverride, focus = true) {
+  const entry = getDrawer.call(this, query);
+  if (entry.state === "closed" || entry.state === "indeterminate") {
+    entry.state = "opening";
+    if (transitionOverride != void 0 ? transitionOverride : entry.getSetting("transition")) {
+      await transition(
+        entry.el,
+        entry.getSetting("stateClosed"),
+        entry.getSetting("stateOpening"),
+        entry.getSetting("stateOpened"),
+        entry.getSetting("transitionDuration")
+      );
+    } else {
+      entry.el.classList.add(entry.getSetting("stateOpened"));
+      entry.el.classList.remove(entry.getSetting("stateClosed"));
     }
-    return this.collection;
+    entry.state = "opened";
+    if (entry.mode === "modal") setGlobalState(true, entry.getSetting("selectorInert"), entry.getSetting("selectorOverflow"));
+    if (focus) {
+      updateFocusState$1.call(this, entry);
+    }
+    entry.el.dispatchEvent(new CustomEvent(entry.getSetting("customEventPrefix") + "opened", {
+      detail: this,
+      bubbles: true
+    }));
   }
-  async registerCollection(t) {
-    return await Promise.all(Array.from(t, (s2) => {
-      this.register(s2);
-    })), this.collection;
+  return entry;
+}
+async function close$2(query, transitionOverride, focus = true) {
+  const entry = getDrawer.call(this, query);
+  if (entry.state === "opened" || entry.state === "indeterminate") {
+    entry.state = "closing";
+    document.activeElement.blur();
+    if (transitionOverride != void 0 ? transitionOverride : entry.getSetting("transition")) {
+      await transition(
+        entry.el,
+        entry.getSetting("stateOpened"),
+        entry.getSetting("stateClosing"),
+        entry.getSetting("stateClosed"),
+        entry.getSetting("transitionDuration")
+      );
+    } else {
+      entry.el.classList.add(entry.getSetting("stateClosed"));
+      entry.el.classList.remove(entry.getSetting("stateOpened"));
+    }
+    entry.state = "closed";
+    if (entry.mode === "modal") setGlobalState(false, entry.getSetting("selectorInert"), entry.getSetting("selectorOverflow"));
+    if (focus) {
+      updateFocusState$1.call(this, entry);
+    }
+    entry.el.dispatchEvent(new CustomEvent(entry.getSetting("customEventPrefix") + "closed", {
+      detail: this,
+      bubbles: true
+    }));
   }
-  async deregisterCollection() {
-    for (; this.collection.length > 0; )
-      await this.deregister(this.collection[0]);
-    return this.collection;
+  return entry;
+}
+async function toggle(query, transition2, focus) {
+  const entry = getDrawer.call(this, query);
+  if (entry.state === "closed") {
+    return open$2.call(this, entry, transition2, focus);
+  } else {
+    return close$2.call(this, entry, transition2, focus);
   }
-  get(t, s2 = "id") {
-    return this.collection.find((i) => i[s2] === t);
-  }
-}
-const r = {
-  inert: ":not([inert]):not([inert] *)",
-  negTabIndex: ':not([tabindex^="-"])',
-  disabled: ":not(:disabled)"
-}, S$1 = [
-  `a[href]${r.inert}${r.negTabIndex}`,
-  `area[href]${r.inert}${r.negTabIndex}`,
-  `input:not([type="hidden"]):not([type="radio"])${r.inert}${r.negTabIndex}${r.disabled}`,
-  `input[type="radio"]${r.inert}${r.negTabIndex}${r.disabled}`,
-  `select${r.inert}${r.negTabIndex}${r.disabled}`,
-  `textarea${r.inert}${r.negTabIndex}${r.disabled}`,
-  `button${r.inert}${r.negTabIndex}${r.disabled}`,
-  `details${r.inert} > summary:first-of-type${r.negTabIndex}`,
-  // Discard until Firefox supports `:has()`
-  // See: https://github.com/KittyGiraudel/focusable-selectors/issues/12
-  // `details:not(:has(> summary))${not.inert}${not.negTabIndex}`,
-  `iframe${r.inert}${r.negTabIndex}`,
-  `audio[controls]${r.inert}${r.negTabIndex}`,
-  `video[controls]${r.inert}${r.negTabIndex}`,
-  `[contenteditable]${r.inert}${r.negTabIndex}`,
-  `[tabindex]${r.inert}${r.negTabIndex}`
-];
-var g, c, d;
-let M$1 = class M2 {
-  constructor(t = null, s2 = "[data-focus]") {
-    y(this, g, void 0), y(this, c, void 0), y(this, d, void 0), this.el = t, this.selectorFocus = s2, E(this, c, R.bind(this)), E(this, d, N$1.bind(this));
+}
+class Drawer extends Collection {
+  constructor(options) {
+    super({ ...defaults$2, ...options });
+    __privateAdd(this, _handleClick);
+    __privateAdd(this, _handleKeydown);
+    this.focusTrap = new FocusTrap();
+    __privateSet(this, _handleClick, handleClick$2.bind(this));
+    __privateSet(this, _handleKeydown, handleKeydown$2.bind(this));
+    this.store = localStore(this.settings.storeKey, this.settings.store);
   }
-  get focusable() {
-    return o(this, g);
+  get activeModal() {
+    return this.collection.find((entry) => {
+      return entry.state === "opened" && entry.mode === "modal";
+    });
   }
-  set focusable(t) {
-    E(this, g, t), o(this, g).length ? (document.removeEventListener("keydown", o(this, d)), document.addEventListener("keydown", o(this, c))) : (document.removeEventListener("keydown", o(this, c)), document.addEventListener("keydown", o(this, d)));
+  async createEntry(query, config) {
+    return new DrawerEntry(this, query, config);
   }
-  get focusableFirst() {
-    return this.focusable[0];
+  async open(id, transition2, focus) {
+    return open$2.call(this, id, transition2, focus);
   }
-  get focusableLast() {
-    return this.focusable[this.focusable.length - 1];
+  async close(id, transition2, focus) {
+    return close$2.call(this, id, transition2, focus);
   }
-  mount(t, s2) {
-    t && (this.el = t), s2 && (this.selectorFocus = s2), this.focusable = this.getFocusable(), this.focus();
+  async toggle(id, transition2, focus) {
+    return toggle.call(this, id, transition2, focus);
   }
-  unmount() {
-    this.el = null, this.focusable = [], document.removeEventListener("keydown", o(this, c)), document.removeEventListener("keydown", o(this, d));
+  async afterMount() {
+    document.addEventListener("click", __privateGet(this, _handleClick), false);
+    document.addEventListener("keydown", __privateGet(this, _handleKeydown), false);
   }
-  focus(t = this.el, s2 = this.selectorFocus) {
-    (t.querySelector(s2) || t).focus();
+  async beforeUnmount() {
+    this.trigger = null;
   }
-  getFocusable(t = this.el) {
-    const s2 = [], i = document.activeElement, n = t.scrollTop;
-    return t.querySelectorAll(S$1.join(",")).forEach((l2) => {
-      l2.focus(), document.activeElement === l2 && s2.push(l2);
-    }), t.scrollTop = n, i.focus(), s2;
+  async afterUnmount() {
+    document.removeEventListener("click", __privateGet(this, _handleClick), false);
+    document.removeEventListener("keydown", __privateGet(this, _handleKeydown), false);
   }
-};
-g = /* @__PURE__ */ new WeakMap(), c = /* @__PURE__ */ new WeakMap(), d = /* @__PURE__ */ new WeakMap();
-function R(e) {
-  (e.key === "Tab" || e.keyCode === 9) && (e.shiftKey ? (document.activeElement === this.focusableFirst || document.activeElement === this.el) && (e.preventDefault(), this.focusableLast.focus()) : (document.activeElement === this.focusableLast || document.activeElement === this.el) && (e.preventDefault(), this.focusableFirst.focus()));
-}
-function N$1(e) {
-  (e.key === "Tab" || e.keyCode === 9) && e.preventDefault();
-}
-function P2(e, t) {
-  const s2 = (e.getAttribute(`data-${t}`) || "").replace(/'/g, '"');
-  return s2 ? JSON.parse(s2) : {};
-}
-function T$1(e, t, s2) {
-  const i = t.nodeType === Node.COMMENT_NODE, n = t.nodeType === Node.ELEMENT_NODE;
-  if (t = i || n ? t : document.querySelector(t), i && (s2 = "after"), !t)
-    throw new Error(`Not a valid teleport reference: '${t}'`);
-  if (typeof t[s2] != "function")
-    throw new Error(`Not a valid teleport method: '${s2}'`);
-  let l2 = null;
-  return i || (l2 = document.createComment("teleported #" + e.id), e.before(l2)), t[s2](e), i && t.remove(), l2;
-}
-const D$1 = (e, t) => new Promise((s2) => {
-  t.transition ? (e.classList.remove(t.stateClosed), e.classList.add(t.stateOpening), e.addEventListener("transitionend", function i(n) {
-    n.target == e && (e.classList.add(t.stateOpened), e.classList.remove(t.stateOpening), s2(e), this.removeEventListener("transitionend", i));
-  })) : (e.classList.add(t.stateOpened), e.classList.remove(t.stateClosed), s2(e));
-}), F$1 = (e, t) => new Promise((s2) => {
-  t.transition ? (e.classList.add(t.stateClosing), e.classList.remove(t.stateOpened), e.addEventListener("transitionend", function i(n) {
-    n.target == e && (e.classList.remove(t.stateClosing), e.classList.add(t.stateClosed), s2(e), this.removeEventListener("transitionend", i));
-  })) : (e.classList.add(t.stateClosed), e.classList.remove(t.stateOpened), s2(e));
-});
-function q(e, t) {
-  t && document.querySelectorAll(t).forEach((s2) => {
-    e ? s2.style.overflow = "hidden" : s2.style.removeProperty("overflow");
-  });
-}
-function z(e, t) {
-  t && document.querySelectorAll(t).forEach((s2) => {
-    e ? (s2.inert = true, s2.setAttribute("aria-hidden", true)) : (s2.inert = null, s2.removeAttribute("aria-hidden"));
-  });
 }
-function W(e, t) {
-  z(!!e, t.selectorInert), q(!!e, t.selectorOverflow);
-}
-const _$1 = {
-  autoInit: false,
+_handleClick = new WeakMap();
+_handleKeydown = new WeakMap();
+const defaults$1 = {
   // Data attributes
   dataOpen: "modal-open",
   dataClose: "modal-close",
   dataReplace: "modal-replace",
-  dataConfig: "modal-config",
   // Selectors
-  selectorModal: ".modal",
+  selector: ".modal",
   selectorDialog: ".modal__dialog",
+  selectorScreen: ".modal",
   selectorRequired: '[role="alertdialog"]',
   selectorFocus: "[data-focus]",
   selectorInert: null,
@@ -759,1439 +942,2151 @@ const _$1 = {
   stateClosing: "is-closing",
   stateClosed: "is-closed",
   // Feature settings
+  customProps: [
+    "transition-duration"
+  ],
   customEventPrefix: "modal:",
-  eventListeners: true,
+  setTabindex: true,
   teleport: null,
   teleportMethod: "append",
-  setTabindex: true,
-  transition: true
+  transition: true,
+  transitionDuration: 300
 };
-function L(e) {
-  const t = typeof e == "string" ? this.get(e) : this.get(e.id);
-  if (t)
-    return t;
-  throw new Error(`Modal not found in collection with id of "${e.id || e}".`);
-}
-function p(e) {
-  return typeof e == "string" ? e : typeof e.hasAttribute == "function" ? e.hasAttribute(`data-${this.settings.dataOpen}`) ? e.getAttribute(`data-${this.settings.dataOpen}`) : e.hasAttribute(`data-${this.settings.dataClose}`) ? e.getAttribute(`data-${this.settings.dataClose}`) || false : e.hasAttribute(`data-${this.settings.dataReplace}`) ? e.getAttribute(`data-${this.settings.dataReplace}`) : e.closest(this.settings.selectorModal) ? (e = e.closest(this.settings.selectorModal), e.id || false) : false : e.id ? e.id : false;
-}
-function G(e) {
-  const t = p.call(this, e);
-  if (t) {
-    const s2 = document.querySelector(`#${t}`), i = s2 ? s2.querySelector(this.settings.selectorDialog) : null;
-    return !s2 && !i ? { error: new Error(`No modal elements found using the ID: "${t}".`) } : i ? { modal: s2, dialog: i } : { error: new Error("Modal is missing dialog element.") };
-  } else
-    return { error: new Error("Could not resolve the modal ID.") };
-}
-function m() {
-  this.active ? this.focusTrap.mount(this.active.dialog, this.settings.selectorFocus) : (this.trigger && (this.trigger.focus(), this.trigger = null), this.focusTrap.unmount());
-}
-async function K$1(e) {
-  let t = e.target.closest(
-    `[data-${this.settings.dataOpen}], [data-${this.settings.dataReplace}]`
-  );
-  if (t) {
-    e.preventDefault(), e.target.closest(this.settings.selectorModal) || (this.trigger = t);
-    const i = this.get(p.call(this, t));
-    return t.matches(`[data-${this.settings.dataOpen}]`) ? i.open() : i.replace();
+class ModalEntry extends CollectionEntry {
+  constructor(context, query, options = {}) {
+    super(context, query, options);
+    this.state = "closed";
+    this.dialog = null;
   }
-  if (t = e.target.closest(`[data-${this.settings.dataClose}]`), t) {
-    e.preventDefault();
-    const s2 = t.getAttribute(`data-${this.settings.dataClose}`);
-    return s2 === "*" ? this.closeAll() : this.close(s2);
+  get isRequired() {
+    return this.dialog.matches(this.getSetting("selectorRequired"));
+  }
+  async open(transition2, focus) {
+    return this.context.open(this, transition2, focus);
+  }
+  async close(transition2, focus) {
+    return this.context.close(this, transition2, focus);
+  }
+  async replace(transition2, focus) {
+    return this.context.replace(this, transition2, focus);
+  }
+  async deregister() {
+    return this.context.deregister(this.id);
+  }
+  async beforeMount() {
+    const dialog = this.el.querySelector(this.getSetting("selectorDialog"));
+    this.dialog = dialog ? dialog : this.el;
+    this.dialog.setAttribute("aria-modal", "true");
+    if (!this.dialog.hasAttribute("role")) {
+      this.dialog.setAttribute("role", "dialog");
+    }
+    if (this.getSetting("setTabindex")) {
+      this.dialog.setAttribute("tabindex", "-1");
+    }
+  }
+  async afterRegister() {
+    if (this.el.classList.contains(this.getSetting("stateOpened"))) {
+      await this.open(false);
+    } else {
+      this.el.classList.remove(this.getSetting("stateOpening"));
+      this.el.classList.remove(this.getSetting("stateClosing"));
+      this.el.classList.add(this.getSetting("stateClosed"));
+    }
+  }
+  async beforeUnmount(reMount = false) {
+    if (!reMount && this.state === "opened") {
+      await this.close(false);
+    } else {
+      this.context.stack.remove(this);
+    }
   }
-  if (e.target.matches(this.settings.selectorModal) && !e.target.querySelector(this.settings.selectorRequired))
-    return this.close(p.call(this, e.target));
 }
-function J$1(e) {
-  if (e.key === "Escape" && this.active && !this.active.dialog.matches(this.settings.selectorRequired))
-    return this.close();
+function getModal(query) {
+  const entry = typeof query === "string" ? this.get(query) : this.get(query.id);
+  if (entry) {
+    return entry;
+  } else {
+    throw new Error(`Modal not found in collection with id of "${query.id || query}".`);
+  }
 }
-async function w(e, t = true) {
-  if (!e)
-    return this.collection;
-  const s2 = this.collection.findIndex((i) => i.id === e.id);
-  if (s2 >= 0) {
-    const i = this.collection[s2];
-    t && i.state === "opened" ? await i.close(false) : this.stack.remove(i), i.getSetting("teleport") && i.teleportReturn(), Object.getOwnPropertyNames(i).forEach((n) => {
-      delete i[n];
-    }), this.collection.splice(s2, 1);
-  }
-  return this.collection;
-}
-async function x2(e, t, s2 = true) {
-  const i = L.call(this, e), n = { ...this.settings, ...i.settings };
-  return t !== void 0 && (n.transition = t), this.stack.moveToTop(i), i.state === "closed" && (i.state = "opening", this.stack.add(i), await D$1(i.el, n), i.state = "opened"), s2 && m.call(this), i.el.dispatchEvent(new CustomEvent(n.customEventPrefix + "opened", {
-    detail: this,
-    bubbles: true
-  })), i;
-}
-async function C(e, t, s2 = true) {
-  const i = e ? L.call(this, e) : this.active;
-  if (i && i.state === "opened") {
-    i.state = "closing";
-    const n = { ...this.settings, ...i.settings };
-    t !== void 0 && (n.transition = t), document.activeElement.blur(), await F$1(i.el, n), this.stack.remove(i), s2 && m.call(this), i.state = "closed", i.el.dispatchEvent(new CustomEvent(n.customEventPrefix + "closed", {
-      detail: this,
-      bubbles: true
-    }));
+function updateFocusState() {
+  if (this.active) {
+    this.focusTrap.mount(this.active.dialog, this.settings.selectorFocus);
+  } else {
+    if (this.trigger) {
+      this.trigger.focus();
+      this.trigger = null;
+    }
+    this.focusTrap.unmount();
   }
-  return i;
 }
-async function $2(e, t) {
-  const s2 = [];
-  return await Promise.all(this.stack.value.map(async (i) => {
-    e && e === i.id ? Promise.resolve() : s2.push(await C.call(this, i, t, false)), i.trigger = null;
-  })), s2;
+async function handleClick$1(event) {
+  const trigger = event.target.closest(`
+    [data-${this.settings.dataOpen}],
+    [data-${this.settings.dataReplace}],
+    [data-${this.settings.dataClose}]
+  `);
+  if (trigger) {
+    event.preventDefault();
+    if (trigger.matches(`[data-${this.settings.dataOpen}]`)) {
+      const selector = trigger.getAttribute(`data-${this.settings.dataOpen}`).trim();
+      const entry = getModal.call(this, selector);
+      const fromModal = event.target.closest(this.settings.selector);
+      if (!fromModal) this.trigger = trigger;
+      return entry.open();
+    }
+    if (trigger.matches(`[data-${this.settings.dataReplace}]`)) {
+      const selector = trigger.getAttribute(`data-${this.settings.dataReplace}`).trim();
+      const entry = getModal.call(this, selector);
+      const fromModal = event.target.closest(this.settings.selector);
+      if (!fromModal) this.trigger = trigger;
+      return entry.replace();
+    }
+    if (trigger.matches(`[data-${this.settings.dataClose}]`)) {
+      const selector = trigger.getAttribute(`data-${this.settings.dataClose}`).trim();
+      return selector === "*" ? this.closeAll() : this.close(selector);
+    }
+  }
+  if (this.active && event.target.matches(this.settings.selectorScreen) && !this.active.isRequired) {
+    return this.close(this.active.id);
+  }
 }
-async function O(e, t, s2 = true) {
-  const i = L.call(this, e);
-  let n, l2;
-  return i.state === "opened" ? (n = i, l2 = await $2.call(this, i.id, t)) : (n = x2.call(this, i, t, false), l2 = $2.call(this, false, t), await Promise.all([n, l2])), s2 && m.call(this), { opened: n, closed: l2 };
+function handleKeydown$1(event) {
+  if (event.key === "Escape") {
+    if (this.active && !this.active.dialog.matches(this.settings.selectorRequired)) {
+      return this.close();
+    }
+  }
 }
-async function B$1(e, t) {
-  await w.call(this, e, false);
-  const s2 = this, i = {
-    open(l2, a2) {
-      return x2.call(s2, this, l2, a2);
-    },
-    close(l2, a2) {
-      return C.call(s2, this, l2, a2);
-    },
-    replace(l2, a2) {
-      return O.call(s2, this, l2, a2);
-    },
-    deregister() {
-      return w.call(s2, this);
-    },
-    teleport(l2 = this.getSetting("teleport"), a2 = this.getSetting("teleportMethod")) {
-      return this.returnRef ? (console.error("Element has already been teleported:", this.el), false) : (this.returnRef = T$1(this.el, l2, a2), this.el);
-    },
-    teleportReturn() {
-      return this.returnRef ? (this.returnRef = T$1(this.el, this.returnRef), this.el) : (console.error("No return reference found:", this.el), false);
-    },
-    getSetting(l2) {
-      return l2 in this.settings ? this.settings[l2] : s2.settings[l2];
-    }
-  }, n = {
-    id: e.id,
-    state: "closed",
-    el: e,
-    dialog: t,
-    returnRef: null,
-    settings: P2(e, this.settings.dataConfig),
-    ...i
-  };
-  return n.dialog.setAttribute("aria-modal", "true"), n.dialog.hasAttribute("role") || n.dialog.setAttribute("role", "dialog"), n.getSetting("setTabindex") && n.dialog.setAttribute("tabindex", "-1"), n.getSetting("teleport") && n.teleport(), this.collection.push(n), n.el.classList.contains(this.settings.stateOpened) ? await n.open(false) : (n.el.classList.remove(this.settings.stateOpening), n.el.classList.remove(this.settings.stateClosing), n.el.classList.add(this.settings.stateClosed)), n;
+async function open$1(query, transitionOverride = void 0, focus = true) {
+  const entry = getModal.call(this, query);
+  this.stack.moveToTop(entry);
+  if (entry.state === "closed") {
+    entry.state = "opening";
+    this.stack.add(entry);
+    if (transitionOverride != void 0 ? transitionOverride : entry.getSetting("transition")) {
+      await transition(
+        entry.el,
+        entry.getSetting("stateClosed"),
+        entry.getSetting("stateOpening"),
+        entry.getSetting("stateOpened"),
+        entry.getSetting("transitionDuration")
+      );
+    } else {
+      entry.el.classList.add(entry.getSetting("stateOpened"));
+      entry.el.classList.remove(entry.getSetting("stateClosed"));
+    }
+    entry.state = "opened";
+  }
+  if (focus) {
+    updateFocusState.call(this);
+  }
+  entry.el.dispatchEvent(new CustomEvent(entry.getSetting("customEventPrefix") + "opened", {
+    detail: this,
+    bubbles: true
+  }));
+  return entry;
+}
+async function close$1(query, transitionOverride, focus = true) {
+  const entry = query ? getModal.call(this, query) : this.active;
+  if (entry && entry.state === "opened") {
+    entry.state = "closing";
+    document.activeElement.blur();
+    if (transitionOverride != void 0 ? transitionOverride : entry.getSetting("transition")) {
+      await transition(
+        entry.el,
+        entry.getSetting("stateOpened"),
+        entry.getSetting("stateClosing"),
+        entry.getSetting("stateClosed"),
+        entry.getSetting("transitionDuration")
+      );
+    } else {
+      entry.el.classList.add(entry.getSetting("stateClosed"));
+      entry.el.classList.remove(entry.getSetting("stateOpened"));
+    }
+    this.stack.remove(entry);
+    entry.state = "closed";
+    if (focus) {
+      updateFocusState.call(this);
+    }
+    entry.el.dispatchEvent(new CustomEvent(entry.getSetting("customEventPrefix") + "closed", {
+      detail: this,
+      bubbles: true
+    }));
+  }
+  return entry;
 }
-function H$1(e) {
-  const t = [];
+async function closeAll$1(exclude, transition2) {
+  const result = [];
+  await Promise.all(this.stack.value.map(async (modal) => {
+    if (exclude && exclude === modal.id) {
+      Promise.resolve();
+    } else {
+      result.push(await close$1.call(this, modal, transition2, false));
+    }
+    modal.trigger = null;
+  }));
+  return result;
+}
+async function replace(query, transition2, focus = true) {
+  const entry = getModal.call(this, query);
+  let resultOpened, resultClosed;
+  if (entry.state === "opened") {
+    resultOpened = entry;
+    resultClosed = await closeAll$1.call(this, entry.id, transition2);
+  } else {
+    resultClosed = closeAll$1.call(this, false, transition2);
+    resultOpened = open$1.call(this, entry, transition2, false);
+    await Promise.all([resultOpened, resultClosed]);
+  }
+  if (focus) {
+    updateFocusState.call(this);
+  }
+  return { opened: resultOpened, closed: resultClosed };
+}
+function stack(settings) {
+  const stackArray = [];
   return {
     get value() {
-      return [...t];
+      return [...stackArray];
     },
     get top() {
-      return t[t.length - 1];
+      const result = stackArray[stackArray.length - 1];
+      return result ? result : null;
     },
     updateIndex() {
-      t.forEach((s2, i) => {
-        s2.el.style.zIndex = null;
-        const n = getComputedStyle(s2.el)["z-index"];
-        s2.el.style.zIndex = parseInt(n) + i + 1;
+      stackArray.forEach((entry, index2) => {
+        entry.el.style.zIndex = null;
+        const value = getComputedStyle(entry.el)["z-index"];
+        entry.el.style.zIndex = parseInt(value) + index2 + 1;
       });
     },
-    updateGlobalState() {
-      W(this.top, e), this.updateIndex();
+    setGlobalState() {
+      setGlobalState(this.top, settings.selectorInert, settings.selectorOverflow);
+      this.updateIndex();
     },
-    add(s2) {
-      s2.el.style.zIndex = null;
-      const i = getComputedStyle(s2.el)["z-index"];
-      s2.el.style.zIndex = parseInt(i) + t.length + 1, t.push(s2), this.updateGlobalState();
+    add(entry) {
+      entry.el.style.zIndex = null;
+      const value = getComputedStyle(entry.el)["z-index"];
+      entry.el.style.zIndex = parseInt(value) + stackArray.length + 1;
+      stackArray.push(entry);
+      this.setGlobalState();
     },
-    remove(s2) {
-      const i = t.findIndex((n) => n.id === s2.id);
-      i >= 0 && (s2.el.style.zIndex = null, t.splice(i, 1), this.updateGlobalState());
+    remove(entry) {
+      const index2 = stackArray.findIndex((item) => {
+        return item.id === entry.id;
+      });
+      if (index2 >= 0) {
+        entry.el.style.zIndex = null;
+        stackArray.splice(index2, 1);
+        this.setGlobalState();
+      }
     },
-    moveToTop(s2) {
-      const i = t.findIndex((n) => n.id === s2.id);
-      i >= 0 && (t.splice(i, 1), this.add(s2));
+    moveToTop(entry) {
+      const index2 = stackArray.findIndex((item) => {
+        return item.id === entry.id;
+      });
+      if (index2 >= 0) {
+        stackArray.splice(index2, 1);
+        this.add(entry);
+      }
     }
   };
 }
-var u, h;
-class U extends A {
-  constructor(s2) {
-    super();
-    v(this, u, void 0);
-    v(this, h, void 0);
-    this.defaults = _$1, this.settings = { ...this.defaults, ...s2 }, this.trigger = null, this.focusTrap = new M$1(), this.stack = H$1(this.settings), b(this, u, K$1.bind(this)), b(this, h, J$1.bind(this)), this.settings.autoInit && this.init();
+class Modal extends Collection {
+  constructor(options) {
+    super({ ...defaults$1, ...options });
+    __privateAdd(this, _handleClick2);
+    __privateAdd(this, _handleKeydown2);
+    this.trigger = null;
+    this.focusTrap = new FocusTrap();
+    __privateSet(this, _handleClick2, handleClick$1.bind(this));
+    __privateSet(this, _handleKeydown2, handleKeydown$1.bind(this));
+    this.stack = stack(this.settings);
   }
   get active() {
     return this.stack.top;
   }
-  async init(s2) {
-    s2 && (this.settings = { ...this.settings, ...s2 });
-    const i = document.querySelectorAll(this.settings.selectorModal);
-    return await this.registerCollection(i), this.settings.eventListeners && this.initEventListeners(), this;
-  }
-  async destroy() {
-    return this.trigger = null, await this.deregisterCollection(), this.settings.eventListeners && this.destroyEventListeners(), this;
-  }
-  initEventListeners() {
-    document.addEventListener("click", f(this, u), false), document.addEventListener("keydown", f(this, h), false);
-  }
-  destroyEventListeners() {
-    document.removeEventListener("click", f(this, u), false), document.removeEventListener("keydown", f(this, h), false);
-  }
-  register(s2) {
-    const i = G.call(this, s2);
-    return i.error ? Promise.reject(i.error) : B$1.call(this, i.modal, i.dialog);
-  }
-  deregister(s2) {
-    const i = this.get(p.call(this, s2));
-    return w.call(this, i);
+  async createEntry(query, config) {
+    return new ModalEntry(this, query, config);
   }
-  open(s2, i, n) {
-    return x2.call(this, s2, i, n);
+  async open(id, transition2, focus) {
+    return open$1.call(this, id, transition2, focus);
   }
-  close(s2, i, n) {
-    return C.call(this, s2, i, n);
+  async close(id, transition2, focus) {
+    return close$1.call(this, id, transition2, focus);
   }
-  replace(s2, i, n) {
-    return O.call(this, s2, i, n);
+  async replace(id, transition2, focus) {
+    return replace.call(this, id, transition2, focus);
   }
-  async closeAll(s2 = false, i, n = true) {
-    const l2 = await $2.call(this, s2, i);
-    return n && m.call(this), l2;
-  }
-}
-u = /* @__PURE__ */ new WeakMap(), h = /* @__PURE__ */ new WeakMap();
-var Ue = (e, t, r2) => {
-  if (!t.has(e))
-    throw TypeError("Cannot " + r2);
-};
-var Ae = (e, t, r2) => (Ue(e, t, "read from private field"), r2 ? r2.call(e) : t.get(e)), _e = (e, t, r2) => {
-  if (t.has(e))
-    throw TypeError("Cannot add the same private member more than once");
-  t instanceof WeakSet ? t.add(e) : t.set(e, r2);
-}, Ke = (e, t, r2, i) => (Ue(e, t, "write to private field"), i ? i.call(e, r2) : t.set(e, r2), r2);
-class Ct {
-  constructor() {
-    this.collection = [];
-  }
-  async register(t) {
-    return await this.deregister(t), this.collection.push(t), this.collection;
-  }
-  async deregister(t) {
-    const r2 = this.collection.findIndex((i) => i === t);
-    if (r2 >= 0) {
-      const i = this.collection[r2];
-      Object.getOwnPropertyNames(i).forEach((n) => {
-        delete i[n];
-      }), this.collection.splice(r2, 1);
+  async closeAll(exclude = false, transition2, focus = true) {
+    const result = await closeAll$1.call(this, exclude, transition2);
+    if (focus) {
+      updateFocusState.call(this);
     }
-    return this.collection;
+    return result;
   }
-  async registerCollection(t) {
-    return await Promise.all(Array.from(t, (r2) => {
-      this.register(r2);
-    })), this.collection;
+  async afterMount() {
+    document.addEventListener("click", __privateGet(this, _handleClick2), false);
+    document.addEventListener("keydown", __privateGet(this, _handleKeydown2), false);
   }
-  async deregisterCollection() {
-    for (; this.collection.length > 0; )
-      await this.deregister(this.collection[0]);
-    return this.collection;
+  async beforeUnmount() {
+    this.trigger = null;
   }
-  get(t, r2 = "id") {
-    return this.collection.find((i) => i[r2] === t);
+  async afterUnmount() {
+    document.removeEventListener("click", __privateGet(this, _handleClick2), false);
+    document.removeEventListener("keydown", __privateGet(this, _handleKeydown2), false);
   }
 }
-function kt() {
-  return getComputedStyle(document.body).getPropertyValue("--vrembem-variable-prefix").trim();
-}
-const Dt = {
-  autoInit: false,
+_handleClick2 = new WeakMap();
+_handleKeydown2 = new WeakMap();
+const defaults = {
   // Selectors
-  selectorPopover: ".popover",
+  selector: ".popover",
+  selectorTooltip: ".popover_tooltip",
   selectorArrow: ".popover__arrow",
   // State classes
   stateActive: "is-active",
+  // Custom properties and their defaults
+  customProps: [
+    "placement",
+    "event",
+    "offset",
+    "flip-padding",
+    "shift-padding",
+    "arrow-padding",
+    "toggle-delay"
+  ],
+  placement: "bottom",
+  event: "click",
+  offset: 0,
+  flipPadding: 0,
+  shiftPadding: 0,
+  arrowPadding: 0,
+  toggleDelay: 0,
   // Feature settings
-  eventListeners: true,
-  eventType: "click",
-  placement: "bottom"
+  teleport: null,
+  teleportMethod: "append"
 };
-function ot(e, t) {
-  const r2 = getComputedStyle(e), i = {
-    placement: t.placement,
-    event: t.eventType,
-    offset: 0,
-    "overflow-padding": 0,
-    "flip-padding": 0,
-    "arrow-element": t.selectorArrow,
-    "arrow-padding": 0
-  };
-  for (const n in i) {
-    const o2 = kt(), l2 = r2.getPropertyValue(`--${o2}popover-${n}`).trim();
-    l2 && (i[n] = l2);
-  }
-  return i;
-}
-function Pe(e) {
-  let t;
-  const r2 = typeof e == "string" ? e.trim().split(" ") : [e];
-  switch (r2.forEach(function(i, n) {
-    r2[n] = parseInt(i, 10);
-  }), r2.length) {
+function applyPositionStyle(el, x, y) {
+  Object.assign(el.style, {
+    left: x != null ? `${x}px` : "",
+    top: y != null ? `${y}px` : ""
+  });
+}
+function getDelay(popover, index2) {
+  let value = popover.getSetting("toggle-delay");
+  if (typeof value == "string") {
+    if (value.indexOf(",") > -1) {
+      value = value.split(",");
+    }
+    if (value.indexOf(" ") > -1) {
+      value = value.split(" ");
+    }
+  }
+  if (Array.isArray(value)) {
+    value = value[index2];
+  }
+  const number = Number(value);
+  if (!Number.isNaN(number)) {
+    return number;
+  } else {
+    throw new Error(`Provided delay value is not a number: "${value}"`);
+  }
+}
+function getPadding(value) {
+  let padding;
+  const array = typeof value === "string" ? value.trim().split(" ") : [value];
+  for (let index2 = 0; index2 < array.length; index2++) {
+    array[index2] = Number(array[index2]);
+  }
+  switch (array.length) {
     case 1:
-      t = r2[0];
+      padding = array[0];
       break;
     case 2:
-      t = {
-        top: r2[0],
-        right: r2[1],
-        bottom: r2[0],
-        left: r2[1]
+      padding = {
+        top: array[0],
+        right: array[1],
+        bottom: array[0],
+        left: array[1]
       };
       break;
     case 3:
-      t = {
-        top: r2[0],
-        right: r2[1],
-        bottom: r2[2],
-        left: r2[1]
+      padding = {
+        top: array[0],
+        right: array[1],
+        bottom: array[2],
+        left: array[1]
       };
       break;
     case 4:
-      t = {
-        top: r2[0],
-        right: r2[1],
-        bottom: r2[2],
-        left: r2[3]
+      padding = {
+        top: array[0],
+        right: array[1],
+        bottom: array[2],
+        left: array[3]
       };
       break;
     default:
-      t = false;
+      padding = false;
       break;
   }
-  return t;
+  return padding;
 }
-function Rt(e) {
-  return [{
-    name: "offset",
-    options: {
-      offset: [0, parseInt(e.offset, 10)]
+function getMiddlewareOptions(popover) {
+  return {
+    offset: Number(popover.getSetting("offset")),
+    flip: {
+      padding: getPadding(popover.getSetting("flip-padding"))
+    },
+    shift: {
+      padding: getPadding(popover.getSetting("shift-padding"))
+    },
+    arrow: {
+      element: popover.getSetting("selectorArrow"),
+      padding: getPadding(popover.getSetting("arrow-padding"))
     }
-  }, {
-    name: "preventOverflow",
-    options: {
-      padding: Pe(e["overflow-padding"])
+  };
+}
+function getPopover(query) {
+  const entry = typeof query === "string" ? this.get(query) : this.get(query.id);
+  if (entry) {
+    return entry;
+  } else {
+    throw new Error(`Popover not found in collection with id of "${query}".`);
+  }
+}
+async function close(query) {
+  const popover = query ? getPopover.call(this, query) : await closeAll.call(this);
+  if (popover && popover.state === "opened") {
+    popover.el.inert = true;
+    popover.el.classList.remove(this.settings.stateActive);
+    if (!popover.isTooltip) {
+      popover.trigger.setAttribute("aria-expanded", "false");
     }
-  }, {
-    name: "flip",
-    options: {
-      padding: Pe(e["flip-padding"])
-    }
-  }, {
-    name: "arrow",
-    options: {
-      element: e["arrow-element"],
-      padding: Pe(e["arrow-padding"])
-    }
-  }];
-}
-function at(e) {
-  const t = typeof e == "string" ? this.get(e) : this.get(e.id);
-  if (t)
-    return t;
-  throw new Error(`Popover not found in collection with id of "${e}".`);
-}
-function st(e) {
-  return typeof e == "string" ? e : typeof e.hasAttribute == "function" ? e.closest(this.settings.selectorPopover) ? (e = e.closest(this.settings.selectorPopover), e.id) : e.hasAttribute("aria-controls") ? e.getAttribute("aria-controls") : e.hasAttribute("aria-describedby") ? e.getAttribute("aria-describedby") : false : e.id ? e.id : false;
-}
-function Bt(e) {
-  const t = st.call(this, e);
-  if (t) {
-    const r2 = document.querySelector(`#${t}`), i = document.querySelector(`[aria-controls="${t}"]`) || document.querySelector(`[aria-describedby="${t}"]`);
-    return !i && !r2 ? { error: new Error(`No popover elements found using the ID: "${t}".`) } : i ? r2 ? { popover: r2, trigger: i } : { error: new Error("No popover associated with the provided popover trigger.") } : { error: new Error("No popover trigger associated with the provided popover.") };
-  } else
-    return { error: new Error("Could not resolve the popover ID.") };
-}
-async function ke(e) {
-  const t = e ? at.call(this, e) : await ct.call(this);
-  return t && t.state === "opened" && (t.el.classList.remove(this.settings.stateActive), t.trigger.hasAttribute("aria-controls") && t.trigger.setAttribute("aria-expanded", "false"), t.popper.setOptions({
-    modifiers: [{ name: "eventListeners", enabled: false }]
-  }), t.state = "closed", t.trigger === this.trigger && (this.trigger = null)), t;
-}
-async function ct() {
-  const e = [];
-  return await Promise.all(this.collection.map(async (t) => {
-    t.state === "opened" && e.push(await ke.call(this, t));
-  })), e;
-}
-function lt(e) {
-  e.state == "opened" && setTimeout(() => {
-    const t = e.el.closest(":hover") === e.el || e.trigger.closest(":hover") === e.trigger, r2 = document.activeElement.closest(
-      `#${e.id}, [aria-controls="${e.id}"], [aria-describedby="${e.id}"]`
+    popover.floatingCleanup();
+    popover.state = "closed";
+    if (popover.trigger === this.trigger) {
+      this.trigger = null;
+    }
+  }
+  return popover;
+}
+async function closeAll() {
+  const result = [];
+  await Promise.all(this.collection.map(async (popover) => {
+    if (popover.state === "opened") {
+      result.push(await close.call(this, popover));
+    }
+  }));
+  return result;
+}
+function closeCheck(popover) {
+  if (popover.state != "opened") return;
+  setTimeout(() => {
+    const isHovered = popover.el.matches(":hover") === popover.el || popover.trigger.matches(":hover") === popover.trigger;
+    let isFocused = document.activeElement.closest(
+      `#${popover.id}, [aria-controls="${popover.id}"], [aria-describedby="${popover.id}"]`
     );
-    return !t && !r2 && e.close(), e;
+    isFocused = isFocused ? isFocused.matches(":focus-visible") : false;
+    if (!isHovered && !isFocused) {
+      popover.close();
+    }
+    return popover;
   }, 1);
 }
-function Tt(e) {
-  e.state === "opened" ? e.close() : (this.trigger = e.trigger, e.open(), ft.call(this, e));
+function handleClick(popover) {
+  if (popover.state === "opened") {
+    popover.close();
+  } else {
+    this.trigger = popover.trigger;
+    popover.open();
+  }
+}
+function handleTooltipClick(popover) {
+  if (popover.isTooltip) {
+    if (popover.toggleDelayId) {
+      clearTimeout(popover.toggleDelayId);
+    }
+    popover.close();
+  }
+}
+function handleMouseEnter(popover, event) {
+  popover.isHovered = event;
+  if (event.type == "focus" && !popover.trigger.matches(":focus-visible")) {
+    return;
+  }
+  if (popover.toggleDelayId) {
+    clearTimeout(popover.toggleDelayId);
+  }
+  const isExpanded = popover.trigger.getAttribute("aria-expanded");
+  if (isExpanded && isExpanded == "true") return;
+  const delay = this.activeHover ? 0 : getDelay(popover, 0);
+  if (this.activeHover) this.activeHover.close();
+  popover.toggleDelayId = setTimeout(() => {
+    if (popover.id) popover.open();
+  }, delay);
+}
+function handleMouseLeave(popover, event) {
+  setTimeout(() => {
+    popover.isHovered = event;
+    if (popover.isHovered) return;
+    if (popover.toggleDelayId) {
+      clearTimeout(popover.toggleDelayId);
+    }
+    popover.toggleDelayId = setTimeout(() => {
+      closeCheck.call(this, popover);
+    }, getDelay(popover, 1));
+  }, 1);
 }
-function St(e) {
-  switch (e.key) {
+function handleKeydown(event) {
+  switch (event.key) {
     case "Escape":
-      this.trigger && this.trigger.focus(), ct.call(this);
+      if (this.trigger) {
+        this.trigger.focus();
+      }
+      closeAll.call(this);
       return;
     case "Tab":
-      this.collection.forEach((t) => {
-        lt.call(this, t);
+      this.collection.forEach((popover) => {
+        closeCheck.call(this, popover);
       });
       return;
     default:
       return;
   }
 }
-function ft(e) {
-  const t = this;
-  document.addEventListener("click", function r2(i) {
-    i.target.closest(
-      `#${e.id}, [aria-controls="${e.id}"], [aria-describedby="${e.id}"]`
-    ) ? e.el && !e.el.classList.contains(t.settings.stateActive) && this.removeEventListener("click", r2) : (e.el && e.el.classList.contains(t.settings.stateActive) && e.close(), this.removeEventListener("click", r2));
-  });
-}
-var k = "top", S = "bottom", M3 = "right", D = "left", De = "auto", le = [k, S, M3, D], Q = "start", se = "end", Mt = "clippingParents", ut = "viewport", ne = "popper", Wt = "reference", Ge = /* @__PURE__ */ le.reduce(function(e, t) {
-  return e.concat([t + "-" + Q, t + "-" + se]);
-}, []), pt = /* @__PURE__ */ [].concat(le, [De]).reduce(function(e, t) {
-  return e.concat([t, t + "-" + Q, t + "-" + se]);
-}, []), jt = "beforeRead", Ht = "read", Nt = "afterRead", It = "beforeMain", Vt = "main", Ft = "afterMain", qt = "beforeWrite", Xt = "write", Yt = "afterWrite", zt = [jt, Ht, Nt, It, Vt, Ft, qt, Xt, Yt];
-function N(e) {
-  return e ? (e.nodeName || "").toLowerCase() : null;
-}
-function B2(e) {
-  if (e == null)
-    return window;
-  if (e.toString() !== "[object Window]") {
-    var t = e.ownerDocument;
-    return t && t.defaultView || window;
-  }
-  return e;
-}
-function K(e) {
-  var t = B2(e).Element;
-  return e instanceof t || e instanceof Element;
-}
-function T2(e) {
-  var t = B2(e).HTMLElement;
-  return e instanceof t || e instanceof HTMLElement;
-}
-function Re(e) {
-  if (typeof ShadowRoot > "u")
-    return false;
-  var t = B2(e).ShadowRoot;
-  return e instanceof t || e instanceof ShadowRoot;
-}
-function Ut(e) {
-  var t = e.state;
-  Object.keys(t.elements).forEach(function(r2) {
-    var i = t.styles[r2] || {}, n = t.attributes[r2] || {}, o2 = t.elements[r2];
-    !T2(o2) || !N(o2) || (Object.assign(o2.style, i), Object.keys(n).forEach(function(l2) {
-      var s2 = n[l2];
-      s2 === false ? o2.removeAttribute(l2) : o2.setAttribute(l2, s2 === true ? "" : s2);
-    }));
+function handleDocumentClick(popover) {
+  const root = this;
+  document.addEventListener("click", function _f(event) {
+    const wasClicked = event.target.closest(
+      `#${popover.id}, [aria-controls="${popover.id}"], [aria-describedby="${popover.id}"]`
+    );
+    if (wasClicked) {
+      if (popover.el && !popover.el.classList.contains(root.settings.stateActive)) {
+        this.removeEventListener("click", _f);
+      }
+    } else {
+      if (popover.el && popover.el.classList.contains(root.settings.stateActive)) {
+        popover.close();
+      }
+      this.removeEventListener("click", _f);
+    }
   });
 }
-function _t(e) {
-  var t = e.state, r2 = {
-    popper: {
-      position: t.options.strategy,
-      left: "0",
-      top: "0",
-      margin: "0"
-    },
-    arrow: {
-      position: "absolute"
-    },
-    reference: {}
-  };
-  return Object.assign(t.elements.popper.style, r2.popper), t.styles = r2, t.elements.arrow && Object.assign(t.elements.arrow.style, r2.arrow), function() {
-    Object.keys(t.elements).forEach(function(i) {
-      var n = t.elements[i], o2 = t.attributes[i] || {}, l2 = Object.keys(t.styles.hasOwnProperty(i) ? t.styles[i] : r2[i]), s2 = l2.reduce(function(a2, f2) {
-        return a2[f2] = "", a2;
-      }, {});
-      !T2(n) || !N(n) || (Object.assign(n.style, s2), Object.keys(o2).forEach(function(a2) {
-        n.removeAttribute(a2);
-      }));
+class PopoverEntry extends CollectionEntry {
+  constructor(context, query, options = {}) {
+    super(context, query, options);
+    __privateAdd(this, _eventListeners);
+    __privateAdd(this, _isHovered);
+    this.state = "closed";
+    this.toggleDelayId = null;
+    this.trigger = null;
+    __privateSet(this, _eventListeners, null);
+    __privateSet(this, _isHovered, {
+      el: false,
+      trigger: false
     });
-  };
-}
-const Kt = {
-  name: "applyStyles",
-  enabled: true,
-  phase: "write",
-  fn: Ut,
-  effect: _t,
-  requires: ["computeStyles"]
-};
-function H(e) {
-  return e.split("-")[0];
-}
-var _ = Math.max, ye = Math.min, Z = Math.round;
-function Le() {
-  var e = navigator.userAgentData;
-  return e != null && e.brands && Array.isArray(e.brands) ? e.brands.map(function(t) {
-    return t.brand + "/" + t.version;
-  }).join(" ") : navigator.userAgent;
-}
-function dt() {
-  return !/^((?!chrome|android).)*safari/i.test(Le());
-}
-function ee(e, t, r2) {
-  t === void 0 && (t = false), r2 === void 0 && (r2 = false);
-  var i = e.getBoundingClientRect(), n = 1, o2 = 1;
-  t && T2(e) && (n = e.offsetWidth > 0 && Z(i.width) / e.offsetWidth || 1, o2 = e.offsetHeight > 0 && Z(i.height) / e.offsetHeight || 1);
-  var l2 = K(e) ? B2(e) : window, s2 = l2.visualViewport, a2 = !dt() && r2, f2 = (i.left + (a2 && s2 ? s2.offsetLeft : 0)) / n, c2 = (i.top + (a2 && s2 ? s2.offsetTop : 0)) / o2, h2 = i.width / n, y2 = i.height / o2;
-  return {
-    width: h2,
-    height: y2,
-    top: c2,
-    right: f2 + h2,
-    bottom: c2 + y2,
-    left: f2,
-    x: f2,
-    y: c2
-  };
-}
-function Be(e) {
-  var t = ee(e), r2 = e.offsetWidth, i = e.offsetHeight;
-  return Math.abs(t.width - r2) <= 1 && (r2 = t.width), Math.abs(t.height - i) <= 1 && (i = t.height), {
-    x: e.offsetLeft,
-    y: e.offsetTop,
-    width: r2,
-    height: i
-  };
-}
-function vt(e, t) {
-  var r2 = t.getRootNode && t.getRootNode();
-  if (e.contains(t))
-    return true;
-  if (r2 && Re(r2)) {
-    var i = t;
-    do {
-      if (i && e.isSameNode(i))
-        return true;
-      i = i.parentNode || i.host;
-    } while (i);
-  }
-  return false;
-}
-function I(e) {
-  return B2(e).getComputedStyle(e);
-}
-function Gt(e) {
-  return ["table", "td", "th"].indexOf(N(e)) >= 0;
-}
-function F(e) {
-  return ((K(e) ? e.ownerDocument : (
-    // $FlowFixMe[prop-missing]
-    e.document
-  )) || window.document).documentElement;
-}
-function we(e) {
-  return N(e) === "html" ? e : (
-    // this is a quicker (but less type safe) way to save quite some bytes from the bundle
-    // $FlowFixMe[incompatible-return]
-    // $FlowFixMe[prop-missing]
-    e.assignedSlot || // step into the shadow DOM of the parent of a slotted node
-    e.parentNode || // DOM Element detected
-    (Re(e) ? e.host : null) || // ShadowRoot detected
-    // $FlowFixMe[incompatible-call]: HTMLElement is a Node
-    F(e)
-  );
-}
-function Je(e) {
-  return !T2(e) || // https://github.com/popperjs/popper-core/issues/837
-  I(e).position === "fixed" ? null : e.offsetParent;
-}
-function Jt(e) {
-  var t = /firefox/i.test(Le()), r2 = /Trident/i.test(Le());
-  if (r2 && T2(e)) {
-    var i = I(e);
-    if (i.position === "fixed")
-      return null;
+    this.floatingCleanup = () => {
+    };
   }
-  var n = we(e);
-  for (Re(n) && (n = n.host); T2(n) && ["html", "body"].indexOf(N(n)) < 0; ) {
-    var o2 = I(n);
-    if (o2.transform !== "none" || o2.perspective !== "none" || o2.contain === "paint" || ["transform", "perspective"].indexOf(o2.willChange) !== -1 || t && o2.willChange === "filter" || t && o2.filter && o2.filter !== "none")
-      return n;
-    n = n.parentNode;
+  get isTooltip() {
+    return !!this.el.closest(this.getSetting("selectorTooltip")) || this.el.getAttribute("role") == "tooltip";
+  }
+  get isHovered() {
+    return __privateGet(this, _isHovered).el || __privateGet(this, _isHovered).trigger;
+  }
+  set isHovered(event) {
+    const state = event.type == "mouseenter" ? true : event.type == "mouseleave" ? false : void 0;
+    if (state == void 0) return;
+    switch (event.target) {
+      case this.el:
+        __privateGet(this, _isHovered).el = state;
+        break;
+      case this.trigger:
+        __privateGet(this, _isHovered).trigger = state;
+        break;
+    }
+  }
+  async open() {
+    return this.context.open(this);
+  }
+  async close() {
+    return this.context.close(this);
+  }
+  async deregister() {
+    return this.context.deregister(this.id);
+  }
+  registerEventListeners() {
+    if (!__privateGet(this, _eventListeners)) {
+      const eventType = this.getSetting("event");
+      if (eventType === "hover") {
+        __privateSet(this, _eventListeners, [{
+          el: ["el", "trigger"],
+          type: ["mouseenter", "focus"],
+          listener: handleMouseEnter.bind(this.context, this)
+        }, {
+          el: ["el", "trigger"],
+          type: ["mouseleave", "focusout"],
+          listener: handleMouseLeave.bind(this.context, this)
+        }, {
+          el: ["trigger"],
+          type: ["click"],
+          listener: handleTooltipClick.bind(this.context, this)
+        }]);
+        __privateGet(this, _eventListeners).forEach((evObj) => {
+          evObj.el.forEach((el) => {
+            evObj.type.forEach((type) => {
+              this[el].addEventListener(type, evObj.listener, false);
+            });
+          });
+        });
+      } else {
+        __privateSet(this, _eventListeners, [{
+          el: ["trigger"],
+          type: ["click"],
+          listener: handleClick.bind(this.context, this)
+        }]);
+        __privateGet(this, _eventListeners).forEach((evObj) => {
+          evObj.el.forEach((el) => {
+            evObj.type.forEach((type) => {
+              this[el].addEventListener(type, evObj.listener, false);
+            });
+          });
+        });
+      }
+    }
+  }
+  deregisterEventListeners() {
+    if (__privateGet(this, _eventListeners)) {
+      __privateGet(this, _eventListeners).forEach((evObj) => {
+        evObj.el.forEach((el) => {
+          evObj.type.forEach((type) => {
+            this[el].removeEventListener(type, evObj.listener, false);
+          });
+        });
+      });
+      __privateSet(this, _eventListeners, null);
+    }
+  }
+  async beforeMount() {
+    this.trigger = document.querySelector(
+      `[aria-controls="${this.id}"], [aria-describedby="${this.id}"]`
+    );
+    if (this.isTooltip) {
+      this.settings.event = "hover";
+      this.el.setAttribute("role", "tooltip");
+    } else {
+      this.trigger.setAttribute("aria-expanded", "false");
+    }
+    this.registerEventListeners();
+  }
+  async afterRegister() {
+    if (this.el.classList.contains(this.getSetting("stateActive"))) {
+      await this.open();
+    } else {
+      this.el.inert = true;
+    }
+  }
+  async beforeUnmount() {
+    if (this.state === "opened") {
+      await this.close();
+    }
+    this.floatingCleanup();
+    this.deregisterEventListeners();
+  }
+}
+_eventListeners = new WeakMap();
+_isHovered = new WeakMap();
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = (v) => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+const oppositeAlignmentMap = {
+  start: "end",
+  end: "start"
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === "function" ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split("-")[0];
+}
+function getAlignment(placement) {
+  return placement.split("-")[1];
+}
+function getOppositeAxis(axis) {
+  return axis === "x" ? "y" : "x";
+}
+function getAxisLength(axis) {
+  return axis === "y" ? "height" : "width";
+}
+function getSideAxis(placement) {
+  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
+}
+function getSideList(side, isStart, rtl) {
+  const lr = ["left", "right"];
+  const rl = ["right", "left"];
+  const tb = ["top", "bottom"];
+  const bt = ["bottom", "top"];
+  switch (side) {
+    case "top":
+    case "bottom":
+      if (rtl) return isStart ? rl : lr;
+      return isStart ? lr : rl;
+    case "left":
+    case "right":
+      return isStart ? tb : bt;
+    default:
+      return [];
   }
-  return null;
-}
-function fe(e) {
-  for (var t = B2(e), r2 = Je(e); r2 && Gt(r2) && I(r2).position === "static"; )
-    r2 = Je(r2);
-  return r2 && (N(r2) === "html" || N(r2) === "body" && I(r2).position === "static") ? t : r2 || Jt(e) || t;
-}
-function Te(e) {
-  return ["top", "bottom"].indexOf(e) >= 0 ? "x" : "y";
 }
-function oe(e, t, r2) {
-  return _(e, ye(t, r2));
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === "start", rtl);
+  if (alignment) {
+    list = list.map((side) => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
 }
-function Qt(e, t, r2) {
-  var i = oe(e, t, r2);
-  return i > r2 ? r2 : i;
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
 }
-function ht() {
+function expandPaddingObject(padding) {
   return {
     top: 0,
     right: 0,
     bottom: 0,
-    left: 0
+    left: 0,
+    ...padding
   };
 }
-function gt(e) {
-  return Object.assign({}, ht(), e);
+function getPaddingObject(padding) {
+  return typeof padding !== "number" ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
 }
-function mt(e, t) {
-  return t.reduce(function(r2, i) {
-    return r2[i] = e, r2;
-  }, {});
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
 }
-var Zt = function(t, r2) {
-  return t = typeof t == "function" ? t(Object.assign({}, r2.rects, {
-    placement: r2.placement
-  })) : t, gt(typeof t != "number" ? t : mt(t, le));
-};
-function er(e) {
-  var t, r2 = e.state, i = e.name, n = e.options, o2 = r2.elements.arrow, l2 = r2.modifiersData.popperOffsets, s2 = H(r2.placement), a2 = Te(s2), f2 = [D, M3].indexOf(s2) >= 0, c2 = f2 ? "height" : "width";
-  if (!(!o2 || !l2)) {
-    var h2 = Zt(n.padding, r2), y2 = Be(o2), u2 = a2 === "y" ? k : D, b2 = a2 === "y" ? S : M3, v2 = r2.rects.reference[c2] + r2.rects.reference[a2] - l2[a2] - r2.rects.popper[c2], d2 = l2[a2] - r2.rects.reference[a2], w2 = fe(o2), O2 = w2 ? a2 === "y" ? w2.clientHeight || 0 : w2.clientWidth || 0 : 0, E2 = v2 / 2 - d2 / 2, p2 = h2[u2], g2 = O2 - y2[c2] - h2[b2], m2 = O2 / 2 - y2[c2] / 2 + E2, x3 = oe(p2, m2, g2), L2 = a2;
-    r2.modifiersData[i] = (t = {}, t[L2] = x3, t.centerOffset = x3 - m2, t);
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  let {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === "y";
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
+    case "top":
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case "bottom":
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case "right":
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case "left":
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
   }
-}
-function tr(e) {
-  var t = e.state, r2 = e.options, i = r2.element, n = i === void 0 ? "[data-popper-arrow]" : i;
-  n != null && (typeof n == "string" && (n = t.elements.popper.querySelector(n), !n) || vt(t.elements.popper, n) && (t.elements.arrow = n));
-}
-const rr = {
-  name: "arrow",
-  enabled: true,
-  phase: "main",
-  fn: er,
-  effect: tr,
-  requires: ["popperOffsets"],
-  requiresIfExists: ["preventOverflow"]
-};
-function te(e) {
-  return e.split("-")[1];
-}
-var ir = {
-  top: "auto",
-  right: "auto",
-  bottom: "auto",
-  left: "auto"
+  switch (getAlignment(placement)) {
+    case "start":
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+    case "end":
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+  }
+  return coords;
+}
+const computePosition$1 = async (reference, floating, config) => {
+  const {
+    placement = "bottom",
+    strategy = "absolute",
+    middleware = [],
+    platform: platform2
+  } = config;
+  const validMiddleware = middleware.filter(Boolean);
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
+  let rects = await platform2.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let middlewareData = {};
+  let resetCount = 0;
+  for (let i = 0; i < validMiddleware.length; i++) {
+    const {
+      name,
+      fn
+    } = validMiddleware[i];
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platform2,
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData = {
+      ...middlewareData,
+      [name]: {
+        ...middlewareData[name],
+        ...data
+      }
+    };
+    if (reset && resetCount <= 50) {
+      resetCount++;
+      if (typeof reset === "object") {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform2.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i = -1;
+    }
+  }
+  return {
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
 };
-function nr(e, t) {
-  var r2 = e.x, i = e.y, n = t.devicePixelRatio || 1;
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform: platform2,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = "clippingAncestors",
+    rootBoundary = "viewport",
+    elementContext = "floating",
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === "floating" ? "reference" : "floating";
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
+    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === "floating" ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
+  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
   return {
-    x: Z(r2 * n) / n || 0,
-    y: Z(i * n) / n || 0
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
   };
 }
-function Qe(e) {
-  var t, r2 = e.popper, i = e.popperRect, n = e.placement, o2 = e.variation, l2 = e.offsets, s2 = e.position, a2 = e.gpuAcceleration, f2 = e.adaptive, c2 = e.roundOffsets, h2 = e.isFixed, y2 = l2.x, u2 = y2 === void 0 ? 0 : y2, b2 = l2.y, v2 = b2 === void 0 ? 0 : b2, d2 = typeof c2 == "function" ? c2({
-    x: u2,
-    y: v2
-  }) : {
-    x: u2,
-    y: v2
-  };
-  u2 = d2.x, v2 = d2.y;
-  var w2 = l2.hasOwnProperty("x"), O2 = l2.hasOwnProperty("y"), E2 = D, p2 = k, g2 = window;
-  if (f2) {
-    var m2 = fe(r2), x3 = "clientHeight", L2 = "clientWidth";
-    if (m2 === B2(r2) && (m2 = F(r2), I(m2).position !== "static" && s2 === "absolute" && (x3 = "scrollHeight", L2 = "scrollWidth")), m2 = m2, n === k || (n === D || n === M3) && o2 === se) {
-      p2 = S;
-      var P3 = h2 && m2 === g2 && g2.visualViewport ? g2.visualViewport.height : (
-        // $FlowFixMe[prop-missing]
-        m2[x3]
-      );
-      v2 -= P3 - i.height, v2 *= a2 ? 1 : -1;
+const arrow$1 = (options) => ({
+  name: "arrow",
+  options,
+  async fn(state) {
+    const {
+      x,
+      y,
+      placement,
+      rects,
+      platform: platform2,
+      elements,
+      middlewareData
+    } = state;
+    const {
+      element,
+      padding = 0
+    } = evaluate(options, state) || {};
+    if (element == null) {
+      return {};
     }
-    if (n === D || (n === k || n === S) && o2 === se) {
-      E2 = M3;
-      var A2 = h2 && m2 === g2 && g2.visualViewport ? g2.visualViewport.width : (
-        // $FlowFixMe[prop-missing]
-        m2[L2]
-      );
-      u2 -= A2 - i.width, u2 *= a2 ? 1 : -1;
+    const paddingObject = getPaddingObject(padding);
+    const coords = {
+      x,
+      y
+    };
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
+    const arrowDimensions = await platform2.getDimensions(element);
+    const isYAxis = axis === "y";
+    const minProp = isYAxis ? "top" : "left";
+    const maxProp = isYAxis ? "bottom" : "right";
+    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
+    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
+    const startDiff = coords[axis] - rects.reference[axis];
+    const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
+    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
+    if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
+      clientSize = elements.floating[clientProp] || rects.floating[length];
     }
+    const centerToReference = endDiff / 2 - startDiff / 2;
+    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+    const min$1 = minPadding;
+    const max2 = clientSize - arrowDimensions[length] - maxPadding;
+    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
+    const offset2 = clamp(min$1, center, max2);
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
+    return {
+      [axis]: coords[axis] + alignmentOffset,
+      data: {
+        [axis]: offset2,
+        centerOffset: center - offset2 - alignmentOffset,
+        ...shouldAddOffset && {
+          alignmentOffset
+        }
+      },
+      reset: shouldAddOffset
+    };
+  }
+});
+const flip$1 = function(options) {
+  if (options === void 0) {
+    options = {};
   }
-  var $3 = Object.assign({
-    position: s2
-  }, f2 && ir), W2 = c2 === true ? nr({
-    x: u2,
-    y: v2
-  }, B2(r2)) : {
-    x: u2,
-    y: v2
+  return {
+    name: "flip",
+    options,
+    async fn(state) {
+      var _middlewareData$arrow, _middlewareData$flip;
+      const {
+        placement,
+        middlewareData,
+        rects,
+        initialPlacement,
+        platform: platform2,
+        elements
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true,
+        fallbackPlacements: specifiedFallbackPlacements,
+        fallbackStrategy = "bestFit",
+        fallbackAxisSideDirection = "none",
+        flipAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
+      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+      }
+      const placements = [initialPlacement, ...fallbackPlacements];
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const overflows = [];
+      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
+      if (checkMainAxis) {
+        overflows.push(overflow[side]);
+      }
+      if (checkCrossAxis) {
+        const sides = getAlignmentSides(placement, rects, rtl);
+        overflows.push(overflow[sides[0]], overflow[sides[1]]);
+      }
+      overflowsData = [...overflowsData, {
+        placement,
+        overflows
+      }];
+      if (!overflows.every((side2) => side2 <= 0)) {
+        var _middlewareData$flip2, _overflowsData$filter;
+        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
+        const nextPlacement = placements[nextIndex];
+        if (nextPlacement) {
+          return {
+            data: {
+              index: nextIndex,
+              overflows: overflowsData
+            },
+            reset: {
+              placement: nextPlacement
+            }
+          };
+        }
+        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
+        if (!resetPlacement) {
+          switch (fallbackStrategy) {
+            case "bestFit": {
+              var _overflowsData$filter2;
+              const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
+                if (hasFallbackAxisSideDirection) {
+                  const currentSideAxis = getSideAxis(d.placement);
+                  return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  currentSideAxis === "y";
+                }
+                return true;
+              }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
+              if (placement2) {
+                resetPlacement = placement2;
+              }
+              break;
+            }
+            case "initialPlacement":
+              resetPlacement = initialPlacement;
+              break;
+          }
+        }
+        if (placement !== resetPlacement) {
+          return {
+            reset: {
+              placement: resetPlacement
+            }
+          };
+        }
+      }
+      return {};
+    }
   };
-  if (u2 = W2.x, v2 = W2.y, a2) {
-    var C2;
-    return Object.assign({}, $3, (C2 = {}, C2[p2] = O2 ? "0" : "", C2[E2] = w2 ? "0" : "", C2.transform = (g2.devicePixelRatio || 1) <= 1 ? "translate(" + u2 + "px, " + v2 + "px)" : "translate3d(" + u2 + "px, " + v2 + "px, 0)", C2));
-  }
-  return Object.assign({}, $3, (t = {}, t[p2] = O2 ? v2 + "px" : "", t[E2] = w2 ? u2 + "px" : "", t.transform = "", t));
-}
-function or(e) {
-  var t = e.state, r2 = e.options, i = r2.gpuAcceleration, n = i === void 0 ? true : i, o2 = r2.adaptive, l2 = o2 === void 0 ? true : o2, s2 = r2.roundOffsets, a2 = s2 === void 0 ? true : s2, f2 = {
-    placement: H(t.placement),
-    variation: te(t.placement),
-    popper: t.elements.popper,
-    popperRect: t.rects.popper,
-    gpuAcceleration: n,
-    isFixed: t.options.strategy === "fixed"
+};
+async function convertValueToCoords(state, options) {
+  const {
+    placement,
+    platform: platform2,
+    elements
+  } = state;
+  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === "y";
+  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
+  let {
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === "number" ? {
+    mainAxis: rawValue,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
+  };
+  if (alignment && typeof alignmentAxis === "number") {
+    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
   };
-  t.modifiersData.popperOffsets != null && (t.styles.popper = Object.assign({}, t.styles.popper, Qe(Object.assign({}, f2, {
-    offsets: t.modifiersData.popperOffsets,
-    position: t.options.strategy,
-    adaptive: l2,
-    roundOffsets: a2
-  })))), t.modifiersData.arrow != null && (t.styles.arrow = Object.assign({}, t.styles.arrow, Qe(Object.assign({}, f2, {
-    offsets: t.modifiersData.arrow,
-    position: "absolute",
-    adaptive: false,
-    roundOffsets: a2
-  })))), t.attributes.popper = Object.assign({}, t.attributes.popper, {
-    "data-popper-placement": t.placement
-  });
 }
-const ar = {
-  name: "computeStyles",
-  enabled: true,
-  phase: "beforeWrite",
-  fn: or,
-  data: {}
-};
-var ge = {
-  passive: true
+const offset$1 = function(options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
+    name: "offset",
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
+      const {
+        x,
+        y,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: {
+          ...diffCoords,
+          placement
+        }
+      };
+    }
+  };
 };
-function sr(e) {
-  var t = e.state, r2 = e.instance, i = e.options, n = i.scroll, o2 = n === void 0 ? true : n, l2 = i.resize, s2 = l2 === void 0 ? true : l2, a2 = B2(t.elements.popper), f2 = [].concat(t.scrollParents.reference, t.scrollParents.popper);
-  return o2 && f2.forEach(function(c2) {
-    c2.addEventListener("scroll", r2.update, ge);
-  }), s2 && a2.addEventListener("resize", r2.update, ge), function() {
-    o2 && f2.forEach(function(c2) {
-      c2.removeEventListener("scroll", r2.update, ge);
-    }), s2 && a2.removeEventListener("resize", r2.update, ge);
+const shift$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: "shift",
+    options,
+    async fn(state) {
+      const {
+        x,
+        y,
+        placement
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: (_ref) => {
+            let {
+              x: x2,
+              y: y2
+            } = _ref;
+            return {
+              x: x2,
+              y: y2
+            };
+          }
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await detectOverflow(state, detectOverflowOptions);
+      const crossAxis = getSideAxis(getSide(placement));
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      if (checkMainAxis) {
+        const minSide = mainAxis === "y" ? "top" : "left";
+        const maxSide = mainAxis === "y" ? "bottom" : "right";
+        const min2 = mainAxisCoord + overflow[minSide];
+        const max2 = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = clamp(min2, mainAxisCoord, max2);
+      }
+      if (checkCrossAxis) {
+        const minSide = crossAxis === "y" ? "top" : "left";
+        const maxSide = crossAxis === "y" ? "bottom" : "right";
+        const min2 = crossAxisCoord + overflow[minSide];
+        const max2 = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = clamp(min2, crossAxisCoord, max2);
+      }
+      const limitedCoords = limiter.fn({
+        ...state,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      });
+      return {
+        ...limitedCoords,
+        data: {
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y,
+          enabled: {
+            [mainAxis]: checkMainAxis,
+            [crossAxis]: checkCrossAxis
+          }
+        }
+      };
+    }
   };
-}
-const cr = {
-  name: "eventListeners",
-  enabled: true,
-  phase: "write",
-  fn: function() {
-  },
-  effect: sr,
-  data: {}
 };
-var lr = {
-  left: "right",
-  right: "left",
-  bottom: "top",
-  top: "bottom"
+const limitShift$1 = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    options,
+    fn(state) {
+      const {
+        x,
+        y,
+        placement,
+        rects,
+        middlewareData
+      } = state;
+      const {
+        offset: offset2 = 0,
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = true
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const crossAxis = getSideAxis(placement);
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      const rawOffset = evaluate(offset2, state);
+      const computedOffset = typeof rawOffset === "number" ? {
+        mainAxis: rawOffset,
+        crossAxis: 0
+      } : {
+        mainAxis: 0,
+        crossAxis: 0,
+        ...rawOffset
+      };
+      if (checkMainAxis) {
+        const len = mainAxis === "y" ? "height" : "width";
+        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
+        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
+        if (mainAxisCoord < limitMin) {
+          mainAxisCoord = limitMin;
+        } else if (mainAxisCoord > limitMax) {
+          mainAxisCoord = limitMax;
+        }
+      }
+      if (checkCrossAxis) {
+        var _middlewareData$offse, _middlewareData$offse2;
+        const len = mainAxis === "y" ? "width" : "height";
+        const isOriginSide = ["top", "left"].includes(getSide(placement));
+        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
+        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
+        if (crossAxisCoord < limitMin) {
+          crossAxisCoord = limitMin;
+        } else if (crossAxisCoord > limitMax) {
+          crossAxisCoord = limitMax;
+        }
+      }
+      return {
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      };
+    }
+  };
 };
-function me(e) {
-  return e.replace(/left|right|bottom|top/g, function(t) {
-    return lr[t];
-  });
+function hasWindow() {
+  return typeof window !== "undefined";
 }
-var fr = {
-  start: "end",
-  end: "start"
-};
-function Ze(e) {
-  return e.replace(/start|end/g, function(t) {
-    return fr[t];
+function getNodeName(node) {
+  if (isNode(node)) {
+    return (node.nodeName || "").toLowerCase();
+  }
+  return "#document";
+}
+function getWindow(node) {
+  var _node$ownerDocument;
+  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+}
+function getDocumentElement(node) {
+  var _ref;
+  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
+}
+function isNode(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Node || value instanceof getWindow(value).Node;
+}
+function isElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof Element || value instanceof getWindow(value).Element;
+}
+function isHTMLElement(value) {
+  if (!hasWindow()) {
+    return false;
+  }
+  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+}
+function isShadowRoot(value) {
+  if (!hasWindow() || typeof ShadowRoot === "undefined") {
+    return false;
+  }
+  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
+}
+function isOverflowElement(element) {
+  const {
+    overflow,
+    overflowX,
+    overflowY,
+    display
+  } = getComputedStyle$1(element);
+  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
+}
+function isTableElement(element) {
+  return ["table", "td", "th"].includes(getNodeName(element));
+}
+function isTopLayer(element) {
+  return [":popover-open", ":modal"].some((selector) => {
+    try {
+      return element.matches(selector);
+    } catch (e) {
+      return false;
+    }
   });
 }
-function Se(e) {
-  var t = B2(e), r2 = t.pageXOffset, i = t.pageYOffset;
-  return {
-    scrollLeft: r2,
-    scrollTop: i
-  };
+function isContainingBlock(elementOrCss) {
+  const webkit = isWebKit();
+  const css = isElement(elementOrCss) ? getComputedStyle$1(elementOrCss) : elementOrCss;
+  return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
+}
+function getContainingBlock(element) {
+  let currentNode = getParentNode(element);
+  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    if (isContainingBlock(currentNode)) {
+      return currentNode;
+    } else if (isTopLayer(currentNode)) {
+      return null;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  return null;
 }
-function Me(e) {
-  return ee(F(e)).left + Se(e).scrollLeft;
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) return false;
+  return CSS.supports("-webkit-backdrop-filter", "none");
 }
-function ur(e, t) {
-  var r2 = B2(e), i = F(e), n = r2.visualViewport, o2 = i.clientWidth, l2 = i.clientHeight, s2 = 0, a2 = 0;
-  if (n) {
-    o2 = n.width, l2 = n.height;
-    var f2 = dt();
-    (f2 || !f2 && t === "fixed") && (s2 = n.offsetLeft, a2 = n.offsetTop);
+function isLastTraversableNode(node) {
+  return ["html", "body", "#document"].includes(getNodeName(node));
+}
+function getComputedStyle$1(element) {
+  return getWindow(element).getComputedStyle(element);
+}
+function getNodeScroll(element) {
+  if (isElement(element)) {
+    return {
+      scrollLeft: element.scrollLeft,
+      scrollTop: element.scrollTop
+    };
   }
   return {
-    width: o2,
-    height: l2,
-    x: s2 + Me(e),
-    y: a2
+    scrollLeft: element.scrollX,
+    scrollTop: element.scrollY
   };
 }
-function pr(e) {
-  var t, r2 = F(e), i = Se(e), n = (t = e.ownerDocument) == null ? void 0 : t.body, o2 = _(r2.scrollWidth, r2.clientWidth, n ? n.scrollWidth : 0, n ? n.clientWidth : 0), l2 = _(r2.scrollHeight, r2.clientHeight, n ? n.scrollHeight : 0, n ? n.clientHeight : 0), s2 = -i.scrollLeft + Me(e), a2 = -i.scrollTop;
-  return I(n || r2).direction === "rtl" && (s2 += _(r2.clientWidth, n ? n.clientWidth : 0) - o2), {
-    width: o2,
-    height: l2,
-    x: s2,
-    y: a2
+function getParentNode(node) {
+  if (getNodeName(node) === "html") {
+    return node;
+  }
+  const result = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    node.assignedSlot || // DOM Element detected.
+    node.parentNode || // ShadowRoot detected.
+    isShadowRoot(node) && node.host || // Fallback.
+    getDocumentElement(node)
+  );
+  return isShadowRoot(result) ? result.host : result;
+}
+function getNearestOverflowAncestor(node) {
+  const parentNode = getParentNode(node);
+  if (isLastTraversableNode(parentNode)) {
+    return node.ownerDocument ? node.ownerDocument.body : node.body;
+  }
+  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
+    return parentNode;
+  }
+  return getNearestOverflowAncestor(parentNode);
+}
+function getOverflowAncestors(node, list, traverseIframes) {
+  var _node$ownerDocument2;
+  if (list === void 0) {
+    list = [];
+  }
+  if (traverseIframes === void 0) {
+    traverseIframes = true;
+  }
+  const scrollableAncestor = getNearestOverflowAncestor(node);
+  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
+  const win = getWindow(scrollableAncestor);
+  if (isBody) {
+    const frameElement = getFrameElement(win);
+    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
+  }
+  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
+}
+function getFrameElement(win) {
+  return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
+}
+function getCssDimensions(element) {
+  const css = getComputedStyle$1(element);
+  let width = parseFloat(css.width) || 0;
+  let height = parseFloat(css.height) || 0;
+  const hasOffset = isHTMLElement(element);
+  const offsetWidth = hasOffset ? element.offsetWidth : width;
+  const offsetHeight = hasOffset ? element.offsetHeight : height;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  if (shouldFallback) {
+    width = offsetWidth;
+    height = offsetHeight;
+  }
+  return {
+    width,
+    height,
+    $: shouldFallback
   };
 }
-function We(e) {
-  var t = I(e), r2 = t.overflow, i = t.overflowX, n = t.overflowY;
-  return /auto|scroll|overlay|hidden/.test(r2 + n + i);
+function unwrapElement(element) {
+  return !isElement(element) ? element.contextElement : element;
 }
-function yt(e) {
-  return ["html", "body", "#document"].indexOf(N(e)) >= 0 ? e.ownerDocument.body : T2(e) && We(e) ? e : yt(we(e));
+function getScale(element) {
+  const domElement = unwrapElement(element);
+  if (!isHTMLElement(domElement)) {
+    return createCoords(1);
+  }
+  const rect = domElement.getBoundingClientRect();
+  const {
+    width,
+    height,
+    $
+  } = getCssDimensions(domElement);
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
+  if (!x || !Number.isFinite(x)) {
+    x = 1;
+  }
+  if (!y || !Number.isFinite(y)) {
+    y = 1;
+  }
+  return {
+    x,
+    y
+  };
 }
-function ae(e, t) {
-  var r2;
-  t === void 0 && (t = []);
-  var i = yt(e), n = i === ((r2 = e.ownerDocument) == null ? void 0 : r2.body), o2 = B2(i), l2 = n ? [o2].concat(o2.visualViewport || [], We(i) ? i : []) : i, s2 = t.concat(l2);
-  return n ? s2 : (
-    // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here
-    s2.concat(ae(we(l2)))
-  );
+const noOffsets = /* @__PURE__ */ createCoords(0);
+function getVisualOffsets(element) {
+  const win = getWindow(element);
+  if (!isWebKit() || !win.visualViewport) {
+    return noOffsets;
+  }
+  return {
+    x: win.visualViewport.offsetLeft,
+    y: win.visualViewport.offsetTop
+  };
 }
-function $e(e) {
-  return Object.assign({}, e, {
-    left: e.x,
-    top: e.y,
-    right: e.x + e.width,
-    bottom: e.y + e.height
-  });
+function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
+  if (isFixed === void 0) {
+    isFixed = false;
+  }
+  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
+    return false;
+  }
+  return isFixed;
 }
-function dr(e, t) {
-  var r2 = ee(e, false, t === "fixed");
-  return r2.top = r2.top + e.clientTop, r2.left = r2.left + e.clientLeft, r2.bottom = r2.top + e.clientHeight, r2.right = r2.left + e.clientWidth, r2.width = e.clientWidth, r2.height = e.clientHeight, r2.x = r2.left, r2.y = r2.top, r2;
-}
-function et(e, t, r2) {
-  return t === ut ? $e(ur(e, r2)) : K(t) ? dr(t, r2) : $e(pr(F(e)));
-}
-function vr(e) {
-  var t = ae(we(e)), r2 = ["absolute", "fixed"].indexOf(I(e).position) >= 0, i = r2 && T2(e) ? fe(e) : e;
-  return K(i) ? t.filter(function(n) {
-    return K(n) && vt(n, i) && N(n) !== "body";
-  }) : [];
-}
-function hr(e, t, r2, i) {
-  var n = t === "clippingParents" ? vr(e) : [].concat(t), o2 = [].concat(n, [r2]), l2 = o2[0], s2 = o2.reduce(function(a2, f2) {
-    var c2 = et(e, f2, i);
-    return a2.top = _(c2.top, a2.top), a2.right = ye(c2.right, a2.right), a2.bottom = ye(c2.bottom, a2.bottom), a2.left = _(c2.left, a2.left), a2;
-  }, et(e, l2, i));
-  return s2.width = s2.right - s2.left, s2.height = s2.bottom - s2.top, s2.x = s2.left, s2.y = s2.top, s2;
-}
-function wt(e) {
-  var t = e.reference, r2 = e.element, i = e.placement, n = i ? H(i) : null, o2 = i ? te(i) : null, l2 = t.x + t.width / 2 - r2.width / 2, s2 = t.y + t.height / 2 - r2.height / 2, a2;
-  switch (n) {
-    case k:
-      a2 = {
-        x: l2,
-        y: t.y - r2.height
-      };
-      break;
-    case S:
-      a2 = {
-        x: l2,
-        y: t.y + t.height
-      };
-      break;
-    case M3:
-      a2 = {
-        x: t.x + t.width,
-        y: s2
-      };
-      break;
-    case D:
-      a2 = {
-        x: t.x - r2.width,
-        y: s2
-      };
-      break;
-    default:
-      a2 = {
-        x: t.x,
-        y: t.y
-      };
+function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
+  if (includeScale === void 0) {
+    includeScale = false;
   }
-  var f2 = n ? Te(n) : null;
-  if (f2 != null) {
-    var c2 = f2 === "y" ? "height" : "width";
-    switch (o2) {
-      case Q:
-        a2[f2] = a2[f2] - (t[c2] / 2 - r2[c2] / 2);
-        break;
-      case se:
-        a2[f2] = a2[f2] + (t[c2] / 2 - r2[c2] / 2);
-        break;
+  if (isFixedStrategy === void 0) {
+    isFixedStrategy = false;
+  }
+  const clientRect = element.getBoundingClientRect();
+  const domElement = unwrapElement(element);
+  let scale = createCoords(1);
+  if (includeScale) {
+    if (offsetParent) {
+      if (isElement(offsetParent)) {
+        scale = getScale(offsetParent);
+      }
+    } else {
+      scale = getScale(element);
     }
   }
-  return a2;
-}
-function ce(e, t) {
-  t === void 0 && (t = {});
-  var r2 = t, i = r2.placement, n = i === void 0 ? e.placement : i, o2 = r2.strategy, l2 = o2 === void 0 ? e.strategy : o2, s2 = r2.boundary, a2 = s2 === void 0 ? Mt : s2, f2 = r2.rootBoundary, c2 = f2 === void 0 ? ut : f2, h2 = r2.elementContext, y2 = h2 === void 0 ? ne : h2, u2 = r2.altBoundary, b2 = u2 === void 0 ? false : u2, v2 = r2.padding, d2 = v2 === void 0 ? 0 : v2, w2 = gt(typeof d2 != "number" ? d2 : mt(d2, le)), O2 = y2 === ne ? Wt : ne, E2 = e.rects.popper, p2 = e.elements[b2 ? O2 : y2], g2 = hr(K(p2) ? p2 : p2.contextElement || F(e.elements.popper), a2, c2, l2), m2 = ee(e.elements.reference), x3 = wt({
-    reference: m2,
-    element: E2,
-    strategy: "absolute",
-    placement: n
-  }), L2 = $e(Object.assign({}, E2, x3)), P3 = y2 === ne ? L2 : m2, A2 = {
-    top: g2.top - P3.top + w2.top,
-    bottom: P3.bottom - g2.bottom + w2.bottom,
-    left: g2.left - P3.left + w2.left,
-    right: P3.right - g2.right + w2.right
-  }, $3 = e.modifiersData.offset;
-  if (y2 === ne && $3) {
-    var W2 = $3[n];
-    Object.keys(A2).forEach(function(C2) {
-      var q2 = [M3, S].indexOf(C2) >= 0 ? 1 : -1, X2 = [k, S].indexOf(C2) >= 0 ? "y" : "x";
-      A2[C2] += W2[X2] * q2;
-    });
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  let x = (clientRect.left + visualOffsets.x) / scale.x;
+  let y = (clientRect.top + visualOffsets.y) / scale.y;
+  let width = clientRect.width / scale.x;
+  let height = clientRect.height / scale.y;
+  if (domElement) {
+    const win = getWindow(domElement);
+    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
+    let currentWin = win;
+    let currentIFrame = getFrameElement(currentWin);
+    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
+      const iframeScale = getScale(currentIFrame);
+      const iframeRect = currentIFrame.getBoundingClientRect();
+      const css = getComputedStyle$1(currentIFrame);
+      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
+      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
+      x *= iframeScale.x;
+      y *= iframeScale.y;
+      width *= iframeScale.x;
+      height *= iframeScale.y;
+      x += left;
+      y += top;
+      currentWin = getWindow(currentIFrame);
+      currentIFrame = getFrameElement(currentWin);
+    }
   }
-  return A2;
-}
-function gr(e, t) {
-  t === void 0 && (t = {});
-  var r2 = t, i = r2.placement, n = r2.boundary, o2 = r2.rootBoundary, l2 = r2.padding, s2 = r2.flipVariations, a2 = r2.allowedAutoPlacements, f2 = a2 === void 0 ? pt : a2, c2 = te(i), h2 = c2 ? s2 ? Ge : Ge.filter(function(b2) {
-    return te(b2) === c2;
-  }) : le, y2 = h2.filter(function(b2) {
-    return f2.indexOf(b2) >= 0;
-  });
-  y2.length === 0 && (y2 = h2);
-  var u2 = y2.reduce(function(b2, v2) {
-    return b2[v2] = ce(e, {
-      placement: v2,
-      boundary: n,
-      rootBoundary: o2,
-      padding: l2
-    })[H(v2)], b2;
-  }, {});
-  return Object.keys(u2).sort(function(b2, v2) {
-    return u2[b2] - u2[v2];
+  return rectToClientRect({
+    width,
+    height,
+    x,
+    y
   });
 }
-function mr(e) {
-  if (H(e) === De)
-    return [];
-  var t = me(e);
-  return [Ze(e), t, Ze(t)];
-}
-function yr(e) {
-  var t = e.state, r2 = e.options, i = e.name;
-  if (!t.modifiersData[i]._skip) {
-    for (var n = r2.mainAxis, o2 = n === void 0 ? true : n, l2 = r2.altAxis, s2 = l2 === void 0 ? true : l2, a2 = r2.fallbackPlacements, f2 = r2.padding, c2 = r2.boundary, h2 = r2.rootBoundary, y2 = r2.altBoundary, u2 = r2.flipVariations, b2 = u2 === void 0 ? true : u2, v2 = r2.allowedAutoPlacements, d2 = t.options.placement, w2 = H(d2), O2 = w2 === d2, E2 = a2 || (O2 || !b2 ? [me(d2)] : mr(d2)), p2 = [d2].concat(E2).reduce(function(G2, V2) {
-      return G2.concat(H(V2) === De ? gr(t, {
-        placement: V2,
-        boundary: c2,
-        rootBoundary: h2,
-        padding: f2,
-        flipVariations: b2,
-        allowedAutoPlacements: v2
-      }) : V2);
-    }, []), g2 = t.rects.reference, m2 = t.rects.popper, x3 = /* @__PURE__ */ new Map(), L2 = true, P3 = p2[0], A2 = 0; A2 < p2.length; A2++) {
-      var $3 = p2[A2], W2 = H($3), C2 = te($3) === Q, q2 = [k, S].indexOf(W2) >= 0, X2 = q2 ? "width" : "height", R2 = ce(t, {
-        placement: $3,
-        boundary: c2,
-        rootBoundary: h2,
-        altBoundary: y2,
-        padding: f2
-      }), j2 = q2 ? C2 ? M3 : D : C2 ? S : k;
-      g2[X2] > m2[X2] && (j2 = me(j2));
-      var ue = me(j2), Y2 = [];
-      if (o2 && Y2.push(R2[W2] <= 0), s2 && Y2.push(R2[j2] <= 0, R2[ue] <= 0), Y2.every(function(G2) {
-        return G2;
-      })) {
-        P3 = $3, L2 = false;
-        break;
-      }
-      x3.set($3, Y2);
-    }
-    if (L2)
-      for (var pe = b2 ? 3 : 1, be = function(V2) {
-        var ie = p2.find(function(ve) {
-          var z2 = x3.get(ve);
-          if (z2)
-            return z2.slice(0, V2).every(function(xe) {
-              return xe;
-            });
-        });
-        if (ie)
-          return P3 = ie, "break";
-      }, re = pe; re > 0; re--) {
-        var de = be(re);
-        if (de === "break")
-          break;
-      }
-    t.placement !== P3 && (t.modifiersData[i]._skip = true, t.placement = P3, t.reset = true);
-  }
-}
-const wr = {
-  name: "flip",
-  enabled: true,
-  phase: "main",
-  fn: yr,
-  requiresIfExists: ["offset"],
-  data: {
-    _skip: false
+function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
+  let {
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  } = _ref;
+  const isFixed = strategy === "fixed";
+  const documentElement = getDocumentElement(offsetParent);
+  const topLayer = elements ? isTopLayer(elements.floating) : false;
+  if (offsetParent === documentElement || topLayer && isFixed) {
+    return rect;
+  }
+  let scroll = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isHTMLElement(offsetParent)) {
+      const offsetRect = getBoundingClientRect(offsetParent);
+      scale = getScale(offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    }
   }
-};
-function tt(e, t, r2) {
-  return r2 === void 0 && (r2 = {
-    x: 0,
-    y: 0
-  }), {
-    top: e.top - t.height - r2.y,
-    right: e.right - t.width + r2.x,
-    bottom: e.bottom - t.height + r2.y,
-    left: e.left - t.width - r2.x
+  return {
+    width: rect.width * scale.x,
+    height: rect.height * scale.y,
+    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
+    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
   };
 }
-function rt(e) {
-  return [k, M3, S, D].some(function(t) {
-    return e[t] >= 0;
-  });
+function getClientRects(element) {
+  return Array.from(element.getClientRects());
 }
-function br(e) {
-  var t = e.state, r2 = e.name, i = t.rects.reference, n = t.rects.popper, o2 = t.modifiersData.preventOverflow, l2 = ce(t, {
-    elementContext: "reference"
-  }), s2 = ce(t, {
-    altBoundary: true
-  }), a2 = tt(l2, i), f2 = tt(s2, n, o2), c2 = rt(a2), h2 = rt(f2);
-  t.modifiersData[r2] = {
-    referenceClippingOffsets: a2,
-    popperEscapeOffsets: f2,
-    isReferenceHidden: c2,
-    hasPopperEscaped: h2
-  }, t.attributes.popper = Object.assign({}, t.attributes.popper, {
-    "data-popper-reference-hidden": c2,
-    "data-popper-escaped": h2
-  });
+function getWindowScrollBarX(element, rect) {
+  const leftScroll = getNodeScroll(element).scrollLeft;
+  if (!rect) {
+    return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
+  }
+  return rect.left + leftScroll;
 }
-const xr = {
-  name: "hide",
-  enabled: true,
-  phase: "main",
-  requiresIfExists: ["preventOverflow"],
-  fn: br
-};
-function Or(e, t, r2) {
-  var i = H(e), n = [D, k].indexOf(i) >= 0 ? -1 : 1, o2 = typeof r2 == "function" ? r2(Object.assign({}, t, {
-    placement: e
-  })) : r2, l2 = o2[0], s2 = o2[1];
-  return l2 = l2 || 0, s2 = (s2 || 0) * n, [D, M3].indexOf(i) >= 0 ? {
-    x: s2,
-    y: l2
-  } : {
-    x: l2,
-    y: s2
+function getDocumentRect(element) {
+  const html = getDocumentElement(element);
+  const scroll = getNodeScroll(element);
+  const body = element.ownerDocument.body;
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  let x = -scroll.scrollLeft + getWindowScrollBarX(element);
+  const y = -scroll.scrollTop;
+  if (getComputedStyle$1(body).direction === "rtl") {
+    x += max(html.clientWidth, body.clientWidth) - width;
+  }
+  return {
+    width,
+    height,
+    x,
+    y
   };
 }
-function Er(e) {
-  var t = e.state, r2 = e.options, i = e.name, n = r2.offset, o2 = n === void 0 ? [0, 0] : n, l2 = pt.reduce(function(c2, h2) {
-    return c2[h2] = Or(h2, t.rects, o2), c2;
-  }, {}), s2 = l2[t.placement], a2 = s2.x, f2 = s2.y;
-  t.modifiersData.popperOffsets != null && (t.modifiersData.popperOffsets.x += a2, t.modifiersData.popperOffsets.y += f2), t.modifiersData[i] = l2;
-}
-const Ar = {
-  name: "offset",
-  enabled: true,
-  phase: "main",
-  requires: ["popperOffsets"],
-  fn: Er
-};
-function Pr(e) {
-  var t = e.state, r2 = e.name;
-  t.modifiersData[r2] = wt({
-    reference: t.rects.reference,
-    element: t.rects.popper,
-    strategy: "absolute",
-    placement: t.placement
-  });
-}
-const Lr = {
-  name: "popperOffsets",
-  enabled: true,
-  phase: "read",
-  fn: Pr,
-  data: {}
-};
-function $r(e) {
-  return e === "x" ? "y" : "x";
-}
-function Cr(e) {
-  var t = e.state, r2 = e.options, i = e.name, n = r2.mainAxis, o2 = n === void 0 ? true : n, l2 = r2.altAxis, s2 = l2 === void 0 ? false : l2, a2 = r2.boundary, f2 = r2.rootBoundary, c2 = r2.altBoundary, h2 = r2.padding, y2 = r2.tether, u2 = y2 === void 0 ? true : y2, b2 = r2.tetherOffset, v2 = b2 === void 0 ? 0 : b2, d2 = ce(t, {
-    boundary: a2,
-    rootBoundary: f2,
-    padding: h2,
-    altBoundary: c2
-  }), w2 = H(t.placement), O2 = te(t.placement), E2 = !O2, p2 = Te(w2), g2 = $r(p2), m2 = t.modifiersData.popperOffsets, x3 = t.rects.reference, L2 = t.rects.popper, P3 = typeof v2 == "function" ? v2(Object.assign({}, t.rects, {
-    placement: t.placement
-  })) : v2, A2 = typeof P3 == "number" ? {
-    mainAxis: P3,
-    altAxis: P3
-  } : Object.assign({
-    mainAxis: 0,
-    altAxis: 0
-  }, P3), $3 = t.modifiersData.offset ? t.modifiersData.offset[t.placement] : null, W2 = {
-    x: 0,
-    y: 0
+function getViewportRect(element, strategy) {
+  const win = getWindow(element);
+  const html = getDocumentElement(element);
+  const visualViewport = win.visualViewport;
+  let width = html.clientWidth;
+  let height = html.clientHeight;
+  let x = 0;
+  let y = 0;
+  if (visualViewport) {
+    width = visualViewport.width;
+    height = visualViewport.height;
+    const visualViewportBased = isWebKit();
+    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
+      x = visualViewport.offsetLeft;
+      y = visualViewport.offsetTop;
+    }
+  }
+  return {
+    width,
+    height,
+    x,
+    y
   };
-  if (m2) {
-    if (o2) {
-      var C2, q2 = p2 === "y" ? k : D, X2 = p2 === "y" ? S : M3, R2 = p2 === "y" ? "height" : "width", j2 = m2[p2], ue = j2 + d2[q2], Y2 = j2 - d2[X2], pe = u2 ? -L2[R2] / 2 : 0, be = O2 === Q ? x3[R2] : L2[R2], re = O2 === Q ? -L2[R2] : -x3[R2], de = t.elements.arrow, G2 = u2 && de ? Be(de) : {
-        width: 0,
-        height: 0
-      }, V2 = t.modifiersData["arrow#persistent"] ? t.modifiersData["arrow#persistent"].padding : ht(), ie = V2[q2], ve = V2[X2], z2 = oe(0, x3[R2], G2[R2]), xe = E2 ? x3[R2] / 2 - pe - z2 - ie - A2.mainAxis : be - z2 - ie - A2.mainAxis, Ot = E2 ? -x3[R2] / 2 + pe + z2 + ve + A2.mainAxis : re + z2 + ve + A2.mainAxis, Oe = t.elements.arrow && fe(t.elements.arrow), Et = Oe ? p2 === "y" ? Oe.clientTop || 0 : Oe.clientLeft || 0 : 0, He = (C2 = $3 == null ? void 0 : $3[p2]) != null ? C2 : 0, At = j2 + xe - He - Et, Pt = j2 + Ot - He, Ne = oe(u2 ? ye(ue, At) : ue, j2, u2 ? _(Y2, Pt) : Y2);
-      m2[p2] = Ne, W2[p2] = Ne - j2;
-    }
-    if (s2) {
-      var Ie, Lt = p2 === "x" ? k : D, $t = p2 === "x" ? S : M3, U2 = m2[g2], he = g2 === "y" ? "height" : "width", Ve = U2 + d2[Lt], Fe = U2 - d2[$t], Ee = [k, D].indexOf(w2) !== -1, qe = (Ie = $3 == null ? void 0 : $3[g2]) != null ? Ie : 0, Xe = Ee ? Ve : U2 - x3[he] - L2[he] - qe + A2.altAxis, Ye = Ee ? U2 + x3[he] + L2[he] - qe - A2.altAxis : Fe, ze = u2 && Ee ? Qt(Xe, U2, Ye) : oe(u2 ? Xe : Ve, U2, u2 ? Ye : Fe);
-      m2[g2] = ze, W2[g2] = ze - U2;
-    }
-    t.modifiersData[i] = W2;
-  }
-}
-const kr = {
-  name: "preventOverflow",
-  enabled: true,
-  phase: "main",
-  fn: Cr,
-  requiresIfExists: ["offset"]
-};
-function Dr(e) {
+}
+function getInnerBoundingClientRect(element, strategy) {
+  const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
+  const top = clientRect.top + element.clientTop;
+  const left = clientRect.left + element.clientLeft;
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
+  const width = element.clientWidth * scale.x;
+  const height = element.clientHeight * scale.y;
+  const x = left * scale.x;
+  const y = top * scale.y;
   return {
-    scrollLeft: e.scrollLeft,
-    scrollTop: e.scrollTop
+    width,
+    height,
+    x,
+    y
   };
 }
-function Rr(e) {
-  return e === B2(e) || !T2(e) ? Se(e) : Dr(e);
+function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
+  let rect;
+  if (clippingAncestor === "viewport") {
+    rect = getViewportRect(element, strategy);
+  } else if (clippingAncestor === "document") {
+    rect = getDocumentRect(getDocumentElement(element));
+  } else if (isElement(clippingAncestor)) {
+    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
+  } else {
+    const visualOffsets = getVisualOffsets(element);
+    rect = {
+      ...clippingAncestor,
+      x: clippingAncestor.x - visualOffsets.x,
+      y: clippingAncestor.y - visualOffsets.y
+    };
+  }
+  return rectToClientRect(rect);
+}
+function hasFixedPositionAncestor(element, stopNode) {
+  const parentNode = getParentNode(element);
+  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
+    return false;
+  }
+  return getComputedStyle$1(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
+}
+function getClippingElementAncestors(element, cache) {
+  const cachedResult = cache.get(element);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
+  let currentContainingBlockComputedStyle = null;
+  const elementIsFixed = getComputedStyle$1(element).position === "fixed";
+  let currentNode = elementIsFixed ? getParentNode(element) : element;
+  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
+    const computedStyle = getComputedStyle$1(currentNode);
+    const currentNodeIsContaining = isContainingBlock(currentNode);
+    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
+      currentContainingBlockComputedStyle = null;
+    }
+    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
+    if (shouldDropCurrentNode) {
+      result = result.filter((ancestor) => ancestor !== currentNode);
+    } else {
+      currentContainingBlockComputedStyle = computedStyle;
+    }
+    currentNode = getParentNode(currentNode);
+  }
+  cache.set(element, result);
+  return result;
+}
+function getClippingRect(_ref) {
+  let {
+    element,
+    boundary,
+    rootBoundary,
+    strategy
+  } = _ref;
+  const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
+  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
+  const firstClippingAncestor = clippingAncestors[0];
+  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
+    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
+    return accRect;
+  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
+  return {
+    width: clippingRect.right - clippingRect.left,
+    height: clippingRect.bottom - clippingRect.top,
+    x: clippingRect.left,
+    y: clippingRect.top
+  };
 }
-function Br(e) {
-  var t = e.getBoundingClientRect(), r2 = Z(t.width) / e.offsetWidth || 1, i = Z(t.height) / e.offsetHeight || 1;
-  return r2 !== 1 || i !== 1;
+function getDimensions(element) {
+  const {
+    width,
+    height
+  } = getCssDimensions(element);
+  return {
+    width,
+    height
+  };
 }
-function Tr(e, t, r2) {
-  r2 === void 0 && (r2 = false);
-  var i = T2(t), n = T2(t) && Br(t), o2 = F(t), l2 = ee(e, n, r2), s2 = {
+function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
+  const isOffsetParentAnElement = isHTMLElement(offsetParent);
+  const documentElement = getDocumentElement(offsetParent);
+  const isFixed = strategy === "fixed";
+  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
+  let scroll = {
     scrollLeft: 0,
     scrollTop: 0
-  }, a2 = {
-    x: 0,
-    y: 0
   };
-  return (i || !i && !r2) && ((N(t) !== "body" || // https://github.com/popperjs/popper-core/issues/1078
-  We(o2)) && (s2 = Rr(t)), T2(t) ? (a2 = ee(t, true), a2.x += t.clientLeft, a2.y += t.clientTop) : o2 && (a2.x = Me(o2))), {
-    x: l2.left + s2.scrollLeft - a2.x,
-    y: l2.top + s2.scrollTop - a2.y,
-    width: l2.width,
-    height: l2.height
+  const offsets = createCoords(0);
+  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
+    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
+      scroll = getNodeScroll(offsetParent);
+    }
+    if (isOffsetParentAnElement) {
+      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
+      offsets.x = offsetRect.x + offsetParent.clientLeft;
+      offsets.y = offsetRect.y + offsetParent.clientTop;
+    } else if (documentElement) {
+      offsets.x = getWindowScrollBarX(documentElement);
+    }
+  }
+  let htmlX = 0;
+  let htmlY = 0;
+  if (documentElement && !isOffsetParentAnElement && !isFixed) {
+    const htmlRect = documentElement.getBoundingClientRect();
+    htmlY = htmlRect.top + scroll.scrollTop;
+    htmlX = htmlRect.left + scroll.scrollLeft - // RTL <body> scrollbar.
+    getWindowScrollBarX(documentElement, htmlRect);
+  }
+  const x = rect.left + scroll.scrollLeft - offsets.x - htmlX;
+  const y = rect.top + scroll.scrollTop - offsets.y - htmlY;
+  return {
+    x,
+    y,
+    width: rect.width,
+    height: rect.height
   };
 }
-function Sr(e) {
-  var t = /* @__PURE__ */ new Map(), r2 = /* @__PURE__ */ new Set(), i = [];
-  e.forEach(function(o2) {
-    t.set(o2.name, o2);
-  });
-  function n(o2) {
-    r2.add(o2.name);
-    var l2 = [].concat(o2.requires || [], o2.requiresIfExists || []);
-    l2.forEach(function(s2) {
-      if (!r2.has(s2)) {
-        var a2 = t.get(s2);
-        a2 && n(a2);
+function isStaticPositioned(element) {
+  return getComputedStyle$1(element).position === "static";
+}
+function getTrueOffsetParent(element, polyfill) {
+  if (!isHTMLElement(element) || getComputedStyle$1(element).position === "fixed") {
+    return null;
+  }
+  if (polyfill) {
+    return polyfill(element);
+  }
+  let rawOffsetParent = element.offsetParent;
+  if (getDocumentElement(element) === rawOffsetParent) {
+    rawOffsetParent = rawOffsetParent.ownerDocument.body;
+  }
+  return rawOffsetParent;
+}
+function getOffsetParent(element, polyfill) {
+  const win = getWindow(element);
+  if (isTopLayer(element)) {
+    return win;
+  }
+  if (!isHTMLElement(element)) {
+    let svgOffsetParent = getParentNode(element);
+    while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
+      if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
+        return svgOffsetParent;
       }
-    }), i.push(o2);
+      svgOffsetParent = getParentNode(svgOffsetParent);
+    }
+    return win;
+  }
+  let offsetParent = getTrueOffsetParent(element, polyfill);
+  while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
+    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
+  }
+  if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
+    return win;
   }
-  return e.forEach(function(o2) {
-    r2.has(o2.name) || n(o2);
-  }), i;
+  return offsetParent || getContainingBlock(element) || win;
 }
-function Mr(e) {
-  var t = Sr(e);
-  return zt.reduce(function(r2, i) {
-    return r2.concat(t.filter(function(n) {
-      return n.phase === i;
-    }));
-  }, []);
-}
-function Wr(e) {
-  var t;
-  return function() {
-    return t || (t = new Promise(function(r2) {
-      Promise.resolve().then(function() {
-        t = void 0, r2(e());
-      });
-    })), t;
+const getElementRects = async function(data) {
+  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
+  const getDimensionsFn = this.getDimensions;
+  const floatingDimensions = await getDimensionsFn(data.floating);
+  return {
+    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: floatingDimensions.width,
+      height: floatingDimensions.height
+    }
   };
-}
-function jr(e) {
-  var t = e.reduce(function(r2, i) {
-    var n = r2[i.name];
-    return r2[i.name] = n ? Object.assign({}, n, i, {
-      options: Object.assign({}, n.options, i.options),
-      data: Object.assign({}, n.data, i.data)
-    }) : i, r2;
-  }, {});
-  return Object.keys(t).map(function(r2) {
-    return t[r2];
-  });
-}
-var it2 = {
-  placement: "bottom",
-  modifiers: [],
-  strategy: "absolute"
 };
-function nt() {
-  for (var e = arguments.length, t = new Array(e), r2 = 0; r2 < e; r2++)
-    t[r2] = arguments[r2];
-  return !t.some(function(i) {
-    return !(i && typeof i.getBoundingClientRect == "function");
-  });
-}
-function Hr(e) {
-  e === void 0 && (e = {});
-  var t = e, r2 = t.defaultModifiers, i = r2 === void 0 ? [] : r2, n = t.defaultOptions, o2 = n === void 0 ? it2 : n;
-  return function(s2, a2, f2) {
-    f2 === void 0 && (f2 = o2);
-    var c2 = {
-      placement: "bottom",
-      orderedModifiers: [],
-      options: Object.assign({}, it2, o2),
-      modifiersData: {},
-      elements: {
-        reference: s2,
-        popper: a2
-      },
-      attributes: {},
-      styles: {}
-    }, h2 = [], y2 = false, u2 = {
-      state: c2,
-      setOptions: function(w2) {
-        var O2 = typeof w2 == "function" ? w2(c2.options) : w2;
-        v2(), c2.options = Object.assign({}, o2, c2.options, O2), c2.scrollParents = {
-          reference: K(s2) ? ae(s2) : s2.contextElement ? ae(s2.contextElement) : [],
-          popper: ae(a2)
-        };
-        var E2 = Mr(jr([].concat(i, c2.options.modifiers)));
-        return c2.orderedModifiers = E2.filter(function(p2) {
-          return p2.enabled;
-        }), b2(), u2.update();
-      },
-      // Sync update – it will always be executed, even if not necessary. This
-      // is useful for low frequency updates where sync behavior simplifies the
-      // logic.
-      // For high frequency updates (e.g. `resize` and `scroll` events), always
-      // prefer the async Popper#update method
-      forceUpdate: function() {
-        if (!y2) {
-          var w2 = c2.elements, O2 = w2.reference, E2 = w2.popper;
-          if (nt(O2, E2)) {
-            c2.rects = {
-              reference: Tr(O2, fe(E2), c2.options.strategy === "fixed"),
-              popper: Be(E2)
-            }, c2.reset = false, c2.placement = c2.options.placement, c2.orderedModifiers.forEach(function(A2) {
-              return c2.modifiersData[A2.name] = Object.assign({}, A2.data);
-            });
-            for (var p2 = 0; p2 < c2.orderedModifiers.length; p2++) {
-              if (c2.reset === true) {
-                c2.reset = false, p2 = -1;
-                continue;
-              }
-              var g2 = c2.orderedModifiers[p2], m2 = g2.fn, x3 = g2.options, L2 = x3 === void 0 ? {} : x3, P3 = g2.name;
-              typeof m2 == "function" && (c2 = m2({
-                state: c2,
-                options: L2,
-                name: P3,
-                instance: u2
-              }) || c2);
-            }
-          }
+function isRTL(element) {
+  return getComputedStyle$1(element).direction === "rtl";
+}
+const platform = {
+  convertOffsetParentRelativeRectToViewportRelativeRect,
+  getDocumentElement,
+  getClippingRect,
+  getOffsetParent,
+  getElementRects,
+  getClientRects,
+  getDimensions,
+  getScale,
+  isElement,
+  isRTL
+};
+function observeMove(element, onMove) {
+  let io = null;
+  let timeoutId;
+  const root = getDocumentElement(element);
+  function cleanup() {
+    var _io;
+    clearTimeout(timeoutId);
+    (_io = io) == null || _io.disconnect();
+    io = null;
+  }
+  function refresh(skip, threshold) {
+    if (skip === void 0) {
+      skip = false;
+    }
+    if (threshold === void 0) {
+      threshold = 1;
+    }
+    cleanup();
+    const {
+      left,
+      top,
+      width,
+      height
+    } = element.getBoundingClientRect();
+    if (!skip) {
+      onMove();
+    }
+    if (!width || !height) {
+      return;
+    }
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
+    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
+    const options = {
+      rootMargin,
+      threshold: max(0, min(1, threshold)) || 1
+    };
+    let isFirstUpdate = true;
+    function handleObserve(entries) {
+      const ratio = entries[0].intersectionRatio;
+      if (ratio !== threshold) {
+        if (!isFirstUpdate) {
+          return refresh();
         }
-      },
-      // Async and optimistically optimized update – it will not be executed if
-      // not necessary (debounced to run at most once-per-tick)
-      update: Wr(function() {
-        return new Promise(function(d2) {
-          u2.forceUpdate(), d2(c2);
+        if (!ratio) {
+          timeoutId = setTimeout(() => {
+            refresh(false, 1e-7);
+          }, 1e3);
+        } else {
+          refresh(false, ratio);
+        }
+      }
+      isFirstUpdate = false;
+    }
+    try {
+      io = new IntersectionObserver(handleObserve, {
+        ...options,
+        // Handle <iframe>s
+        root: root.ownerDocument
+      });
+    } catch (e) {
+      io = new IntersectionObserver(handleObserve, options);
+    }
+    io.observe(element);
+  }
+  refresh(true);
+  return cleanup;
+}
+function autoUpdate(reference, floating, update, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    ancestorScroll = true,
+    ancestorResize = true,
+    elementResize = typeof ResizeObserver === "function",
+    layoutShift = typeof IntersectionObserver === "function",
+    animationFrame = false
+  } = options;
+  const referenceEl = unwrapElement(reference);
+  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
+  ancestors.forEach((ancestor) => {
+    ancestorScroll && ancestor.addEventListener("scroll", update, {
+      passive: true
+    });
+    ancestorResize && ancestor.addEventListener("resize", update);
+  });
+  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
+  let reobserveFrame = -1;
+  let resizeObserver = null;
+  if (elementResize) {
+    resizeObserver = new ResizeObserver((_ref) => {
+      let [firstEntry] = _ref;
+      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
+        resizeObserver.unobserve(floating);
+        cancelAnimationFrame(reobserveFrame);
+        reobserveFrame = requestAnimationFrame(() => {
+          var _resizeObserver;
+          (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
         });
-      }),
-      destroy: function() {
-        v2(), y2 = true;
       }
-    };
-    if (!nt(s2, a2))
-      return u2;
-    u2.setOptions(f2).then(function(d2) {
-      !y2 && f2.onFirstUpdate && f2.onFirstUpdate(d2);
+      update();
     });
-    function b2() {
-      c2.orderedModifiers.forEach(function(d2) {
-        var w2 = d2.name, O2 = d2.options, E2 = O2 === void 0 ? {} : O2, p2 = d2.effect;
-        if (typeof p2 == "function") {
-          var g2 = p2({
-            state: c2,
-            name: w2,
-            instance: u2,
-            options: E2
-          }), m2 = function() {
-          };
-          h2.push(g2 || m2);
-        }
-      });
+    if (referenceEl && !animationFrame) {
+      resizeObserver.observe(referenceEl);
     }
-    function v2() {
-      h2.forEach(function(d2) {
-        return d2();
-      }), h2 = [];
+    resizeObserver.observe(floating);
+  }
+  let frameId;
+  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
+  if (animationFrame) {
+    frameLoop();
+  }
+  function frameLoop() {
+    const nextRefRect = getBoundingClientRect(reference);
+    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
+      update();
+    }
+    prevRefRect = nextRefRect;
+    frameId = requestAnimationFrame(frameLoop);
+  }
+  update();
+  return () => {
+    var _resizeObserver2;
+    ancestors.forEach((ancestor) => {
+      ancestorScroll && ancestor.removeEventListener("scroll", update);
+      ancestorResize && ancestor.removeEventListener("resize", update);
+    });
+    cleanupIo == null || cleanupIo();
+    (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
+    resizeObserver = null;
+    if (animationFrame) {
+      cancelAnimationFrame(frameId);
     }
-    return u2;
   };
 }
-var Nr = [cr, Lr, ar, Kt, Ar, wr, kr, rr, xr], Ir = /* @__PURE__ */ Hr({
-  defaultModifiers: Nr
-});
-async function Ce(e) {
-  if (!e)
-    return this.collection;
-  const t = this.collection.findIndex((r2) => r2.id === e.id);
-  if (t >= 0) {
-    const r2 = this.collection[t];
-    r2.state === "opened" && r2.close(), r2.popper.destroy(), bt(r2), Object.getOwnPropertyNames(r2).forEach((i) => {
-      delete r2[i];
-    }), this.collection.splice(t, 1);
-  }
-  return this.collection;
-}
-function bt(e) {
-  return e.__eventListeners && (e.__eventListeners.forEach((t) => {
-    t.el.forEach((r2) => {
-      t.type.forEach((i) => {
-        e[r2].removeEventListener(i, t.listener, false);
-      });
-    });
-  }), delete e.__eventListeners), e;
-}
-async function je(e) {
-  const t = at.call(this, e);
-  return t.el.classList.add(this.settings.stateActive), t.trigger.hasAttribute("aria-controls") && t.trigger.setAttribute("aria-expanded", "true"), t.config = ot(t.el, this.settings), t.popper.setOptions({
-    placement: t.config.placement,
-    modifiers: [
-      { name: "eventListeners", enabled: true },
-      ...Rt(t.config)
-    ]
-  }), t.popper.update(), t.state = "opened", t;
-}
-async function Vr(e, t) {
-  Ce.call(this, e);
-  const r2 = this, i = {
-    open() {
-      return je.call(r2, this);
-    },
-    close() {
-      return ke.call(r2, this);
-    },
-    deregister() {
-      return Ce.call(r2, this);
-    }
-  }, n = {
-    id: e.id,
-    state: "closed",
-    el: e,
-    trigger: t,
-    popper: Ir(t, e),
-    config: ot(e, this.settings),
-    ...i
+const offset = offset$1;
+const shift = shift$1;
+const flip = flip$1;
+const arrow = arrow$1;
+const limitShift = limitShift$1;
+const computePosition = (reference, floating, options) => {
+  const cache = /* @__PURE__ */ new Map();
+  const mergedOptions = {
+    platform,
+    ...options
   };
-  return n.trigger.hasAttribute("aria-controls") && n.trigger.setAttribute("aria-expanded", "false"), xt.call(this, n), this.collection.push(n), n.el.classList.contains(this.settings.stateActive) && (await n.open(), ft.call(this, n)), n;
-}
-function xt(e) {
-  return e.__eventListeners || (e.config.event === "hover" ? (e.__eventListeners = [{
-    el: ["trigger"],
-    type: ["mouseenter", "focus"],
-    listener: je.bind(this, e)
-  }, {
-    el: ["el", "trigger"],
-    type: ["mouseleave", "focusout"],
-    listener: lt.bind(this, e)
-  }], e.__eventListeners.forEach((r2) => {
-    r2.el.forEach((i) => {
-      r2.type.forEach((n) => {
-        e[i].addEventListener(n, r2.listener, false);
-      });
-    });
-  })) : (e.__eventListeners = [{
-    el: ["trigger"],
-    type: ["click"],
-    listener: Tt.bind(this, e)
-  }], e.__eventListeners.forEach((r2) => {
-    r2.el.forEach((i) => {
-      r2.type.forEach((n) => {
-        e[i].addEventListener(n, r2.listener, false);
-      });
+  const platformWithCache = {
+    ...mergedOptions.platform,
+    _c: cache
+  };
+  return computePosition$1(reference, floating, {
+    ...mergedOptions,
+    platform: platformWithCache
+  });
+};
+async function open(query) {
+  const popover = getPopover.call(this, query);
+  popover.el.inert = false;
+  popover.el.classList.add(this.settings.stateActive);
+  if (!popover.isTooltip) {
+    popover.trigger.setAttribute("aria-expanded", "true");
+  }
+  popover.getCustomProps();
+  const middlewareOptions = getMiddlewareOptions(popover);
+  const arrowEl = popover.el.querySelector(middlewareOptions.arrow.element);
+  middlewareOptions.arrow.element = arrowEl ? arrowEl : void 0;
+  popover.floatingCleanup = autoUpdate(popover.trigger, popover.el, () => {
+    computePosition(popover.trigger, popover.el, {
+      placement: popover.getSetting("placement"),
+      middleware: [
+        flip(middlewareOptions.flip),
+        shift({ ...middlewareOptions.shift, limiter: limitShift() }),
+        offset(middlewareOptions.offset),
+        arrow(middlewareOptions.arrow)
+      ]
+    }).then(({ x, y, placement, middlewareData }) => {
+      if (!popover.el) {
+        return;
+      }
+      applyPositionStyle(popover.el, x, y);
+      if (middlewareOptions.arrow.element && middlewareData.arrow) {
+        const { x: x2, y: y2 } = middlewareData.arrow;
+        applyPositionStyle(middlewareOptions.arrow.element, x2, y2);
+      }
+      popover.el.setAttribute("data-floating-placement", placement);
     });
-  }))), e;
+  });
+  popover.state = "opened";
+  if (popover.getSetting("event") === "click") {
+    handleDocumentClick.call(this, popover);
+  }
+  return popover;
 }
-var J;
-class qr extends Ct {
-  constructor(r2) {
-    super();
-    _e(this, J, void 0);
-    this.defaults = Dt, this.settings = { ...this.defaults, ...r2 }, this.trigger = null, Ke(this, J, St.bind(this)), this.settings.autoInit && this.init();
+class Popover extends Collection {
+  constructor(options = {}) {
+    super({ ...defaults, ...options });
+    __privateAdd(this, _handleKeydown3);
+    this.trigger = null;
+    __privateSet(this, _handleKeydown3, handleKeydown.bind(this));
   }
-  async init(r2) {
-    r2 && (this.settings = { ...this.settings, ...r2 });
-    const i = document.querySelectorAll(this.settings.selectorPopover);
-    return await this.registerCollection(i), this.settings.eventListeners && this.initEventListeners(false), this;
+  get active() {
+    return this.get("opened", "state");
   }
-  async destroy() {
-    return this.trigger = null, await this.deregisterCollection(), this.settings.eventListeners && this.destroyEventListeners(false), this;
+  get activeHover() {
+    return this.collection.find((popover) => {
+      return popover.state == "opened" && popover.getSetting("event") == "hover";
+    });
   }
-  initEventListeners(r2 = true) {
-    r2 && this.collection.forEach((i) => {
-      xt.call(this, i);
-    }), document.addEventListener("keydown", Ae(this, J), false);
+  async createEntry(query, config) {
+    return new PopoverEntry(this, query, config);
   }
-  destroyEventListeners(r2 = true) {
-    r2 && this.collection.forEach((i) => {
-      bt(i);
-    }), document.removeEventListener("keydown", Ae(this, J), false);
+  async open(id) {
+    return open.call(this, id);
   }
-  register(r2) {
-    const i = Bt.call(this, r2);
-    return i.error ? Promise.reject(i.error) : Vr.call(this, i.popover, i.trigger);
+  async close(id) {
+    return close.call(this, id);
   }
-  deregister(r2) {
-    const i = this.get(st.call(this, r2));
-    return Ce.call(this, i);
+  async afterMount() {
+    document.addEventListener("keydown", __privateGet(this, _handleKeydown3), false);
   }
-  open(r2) {
-    return je.call(this, r2);
+  async beforeUnmount() {
+    this.trigger = null;
   }
-  close(r2) {
-    return ke.call(this, r2);
+  async afterUnmount() {
+    document.removeEventListener("keydown", __privateGet(this, _handleKeydown3), false);
   }
 }
-J = /* @__PURE__ */ new WeakMap();
+_handleKeydown3 = new WeakMap();
 export {
-  it$1 as Drawer,
-  U as Modal,
-  qr as Popover,
+  Drawer,
+  Modal,
+  Popover,
   index as core
 };
 //# sourceMappingURL=index.js.map