@luzmo/lucero 0.0.3 → 0.0.4

package/lib/overlay-C7QKFqRc.js

@@ -0,0 +1,2702 @@
+/*! * Lucero - The design system for Luzmo.
+ * 
+ * Copyright © 2025 Luzmo
+ * All rights reserved.
+ * Lucero (“Luzmo Design System”) must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account to use Lucero.
+ * This license terminates automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+import { r as St } from "./random-id-ByCz1xaq.js";
+import { E as ue, e as pe } from "./element-resolution-FCUT-wql.js";
+import { unsafeCSS as fe, html as ht } from "lit";
+import { L as me, n as z } from "./base-nYalvNMy.js";
+import { r as ge } from "./state-BAO-13Bs.js";
+import { e as te } from "./query-D_KR_GUc.js";
+import { o as ve } from "./query-assigned-elements-DjfhL1cl.js";
+import { o as Ct } from "./if-defined-CYpcjGCb.js";
+import { o as Ut } from "./style-map-BqvQDFJt.js";
+import { u as lt } from "./focusable-selectors-B4YgbghQ.js";
+import { S as ye, r as we } from "./slottable-request-event-DggLA4Rx.js";
+import { c as At } from "./condition-attribute-with-id-Dv4lSRbe.js";
+import { a as be, i as xe } from "./platform-DQYMG7JI.js";
+function Ee(e, t, i = []) {
+  for (const [n, o] of t.entries()) {
+    const s = e[n], r = s.parentElement || s.getRootNode();
+    i[n] && i[n](o), r && r !== s && s.replaceWith(o), delete e[n];
+  }
+  return t;
+}
+const Pe = (e, t, {
+  position: i,
+  prepareCallback: n
+} = { position: "beforeend" }) => {
+  let { length: o } = e;
+  if (o === 0)
+    return () => e;
+  let s = 1, r = 0;
+  (i === "afterbegin" || i === "afterend") && (s = -1, r = o - 1);
+  const a = new Array(o), l = new Array(o), h = document.createComment(
+    "placeholder for reparented element"
+  );
+  do {
+    const c = e[r];
+    n && (l[r] = n(c)), a[r] = h.cloneNode();
+    const d = c.parentElement || c.getRootNode();
+    d && d !== c && d.replaceChild(a[r], c), t.insertAdjacentElement(i, c), r += s;
+  } while (--o > 0);
+  return function() {
+    return Ee(a, e, l);
+  };
+}, Ce = 1e3, Oe = 1e3;
+class Ae {
+  constructor(t = {}) {
+    this.warmUpDelay = Ce, this.coolDownDelay = Oe, this.isWarm = !1, this.timeout = 0, Object.assign(this, t);
+  }
+  openTimer(t) {
+    if (this.cancelCooldownTimer(), !this.component || t !== this.component)
+      return this.component && (this.close(this.component), this.cancelCooldownTimer()), this.component = t, this.isWarm ? Promise.resolve(!1) : (this.promise = new Promise((i) => {
+        this.resolve = i, this.timeout = window.setTimeout(() => {
+          this.resolve && (this.resolve(!1), this.isWarm = !0);
+        }, this.warmUpDelay);
+      }), this.promise);
+    if (this.promise)
+      return this.promise;
+    throw new Error("Inconsistent state");
+  }
+  close(t) {
+    this.component && this.component === t && (this.resetCooldownTimer(), this.timeout > 0 && (clearTimeout(this.timeout), this.timeout = 0), this.resolve && (this.resolve(!0), delete this.resolve), delete this.promise, delete this.component);
+  }
+  resetCooldownTimer() {
+    this.isWarm && (this.cooldownTimeout && window.clearTimeout(this.cooldownTimeout), this.cooldownTimeout = window.setTimeout(() => {
+      this.isWarm = !1, delete this.cooldownTimeout;
+    }, this.coolDownDelay));
+  }
+  cancelCooldownTimer() {
+    this.cooldownTimeout && window.clearTimeout(this.cooldownTimeout), delete this.cooldownTimeout;
+  }
+}
+const mt = new Ae(), J = () => {
+}, kt = (e, t, i) => {
+  const n = new AbortController(), o = /* @__PURE__ */ new Map(), s = () => {
+    n.abort(), i();
+  };
+  let r, a;
+  const l = requestAnimationFrame(() => {
+    r = requestAnimationFrame(() => {
+      a = requestAnimationFrame(() => {
+        s();
+      });
+    });
+  }), h = (d) => {
+    d.target === e && (o.set(
+      d.propertyName,
+      o.get(d.propertyName) - 1
+    ), o.get(d.propertyName) || o.delete(d.propertyName), o.size === 0 && s());
+  }, c = (d) => {
+    d.target === e && (o.has(d.propertyName) || o.set(d.propertyName, 0), o.set(
+      d.propertyName,
+      o.get(d.propertyName) + 1
+    ), cancelAnimationFrame(l), cancelAnimationFrame(r), cancelAnimationFrame(a));
+  };
+  e.addEventListener("transitionrun", c, {
+    signal: n.signal
+  }), e.addEventListener("transitionend", h, {
+    signal: n.signal
+  }), e.addEventListener("transitioncancel", h, {
+    signal: n.signal
+  }), t();
+};
+function R() {
+  return new Promise((e) => requestAnimationFrame(() => e()));
+}
+class rt extends me {
+  constructor() {
+    super(...arguments), this.dispose = J, this.offset = 0, this.willPreventClose = !1;
+  }
+  applyFocus(t, i) {
+  }
+  /* c8 ignore next 6 */
+  get delayed() {
+    return !1;
+  }
+  set delayed(t) {
+  }
+  /* c8 ignore next 6 */
+  get disabled() {
+    return !1;
+  }
+  set disabled(t) {
+  }
+  get elementResolver() {
+    return this._elementResolver;
+  }
+  set elementResolver(t) {
+    this._elementResolver = t;
+  }
+  /* c8 ignore next 3 */
+  ensureOnDOM(t) {
+  }
+  /* c8 ignore next 5 */
+  makeTransition(t) {
+    return null;
+  }
+  manageDelay(t) {
+  }
+  /* c8 ignore next 3 */
+  manageDialogOpen() {
+  }
+  /* c8 ignore next 3 */
+  managePopoverOpen() {
+  }
+  /* c8 ignore next 3 */
+  managePosition() {
+  }
+  /* c8 ignore next 6 */
+  get open() {
+    return !1;
+  }
+  set open(t) {
+  }
+  get placementController() {
+    return this._placementController;
+  }
+  set placementController(t) {
+    this._placementController = t;
+  }
+  requestSlottable() {
+  }
+  returnFocus() {
+  }
+  /* c8 ignore next 6 */
+  get state() {
+    return "closed";
+  }
+  set state(t) {
+  }
+  /* c8 ignore next 3 */
+  manuallyKeepOpen() {
+  }
+  static update() {
+    const t = new CustomEvent("luzmo-update-overlays", {
+      bubbles: !0,
+      composed: !0,
+      cancelable: !0
+    });
+    document.dispatchEvent(t);
+  }
+  static async open(t, i, n, o) {
+    await Promise.resolve().then(() => Lt);
+    const s = arguments.length === 2, r = n || t, a = new this();
+    let l = !1;
+    const h = Pe([r], a, {
+      position: "beforeend",
+      prepareCallback: (f) => {
+        const u = f.slot;
+        return f.removeAttribute("slot"), () => {
+          f.slot = u;
+        };
+      }
+    });
+    if (a.dispose = () => {
+      a.addEventListener("luzmo-closed", () => {
+        l || (h(), l = !0), requestAnimationFrame(() => {
+          a.remove();
+        });
+      }), a.open = !1, a.dispose = J;
+    }, !s && r && o) {
+      const f = t, u = i, p = o;
+      return rt.applyOptions(a, {
+        ...p,
+        delayed: p.delayed || r.hasAttribute("delayed"),
+        trigger: p.virtualTrigger || f,
+        type: u === "modal" ? "modal" : u === "hover" ? "hint" : "auto"
+      }), f.after(a), await a.updateComplete, a.open = !0, a.dispose;
+    }
+    const d = i;
+    return a.append(r), rt.applyOptions(a, {
+      ...d,
+      delayed: d.delayed || r.hasAttribute("delayed")
+    }), a.updateComplete.then(() => {
+      a.open = !0;
+    }), a;
+  }
+  static applyOptions(t, i) {
+    t.delayed = !!i.delayed, t.receivesFocus = i.receivesFocus ?? "auto", t.triggerElement = i.trigger || null, t.type = i.type || "modal", t.offset = i.offset ?? 0, t.placement = i.placement, t.willPreventClose = !!i.notImmediatelyClosable;
+  }
+}
+const Ft = (e) => e.querySelector(
+  lt
+), zt = (e) => e.assignedElements().find((i) => i.matches(lt));
+class Nt extends Event {
+  constructor() {
+    super("beforetoggle", {
+      bubbles: !1,
+      composed: !1
+    }), this.currentState = "open", this.newState = "closed";
+  }
+}
+class _t extends Event {
+  constructor() {
+    super("beforetoggle", {
+      bubbles: !1,
+      composed: !1
+    }), this.currentState = "closed", this.newState = "open";
+  }
+}
+class S extends Event {
+  constructor(t, i, {
+    publish: n,
+    interaction: o,
+    reason: s
+  }) {
+    super(t, {
+      bubbles: n,
+      composed: n
+    }), this.overlay = i, this.detail = {
+      interaction: o,
+      reason: s
+    };
+  }
+}
+class wt {
+  constructor(t, i) {
+    this.x = 0, this.y = 0, this.x = t, this.y = i;
+  }
+  updateBoundingClientRect(t, i) {
+    this.x = t, this.y = i, rt.update();
+  }
+  getBoundingClientRect() {
+    return {
+      width: 0,
+      height: 0,
+      top: this.y,
+      right: this.x,
+      y: this.y,
+      x: this.x,
+      bottom: this.y,
+      left: this.x,
+      /* c8 ignore next 3 */
+      toJSON() {
+      }
+    };
+  }
+}
+function Te(e) {
+  class t extends e {
+    async manageDialogOpen() {
+      const n = this.open;
+      if (await R(), await this.managePosition(), this.open !== n)
+        return;
+      const o = await this.dialogMakeTransition(n);
+      this.open === n && await this.dialogApplyFocus(n, o);
+    }
+    dialogMakeTransition(n) {
+      let o = null;
+      const s = (a, l) => () => {
+        if (a.open = n, !n) {
+          const c = () => {
+            a.removeEventListener("close", c);
+          };
+          a.addEventListener("close", c);
+        }
+        if (l > 0)
+          return;
+        const h = n ? _t : Nt;
+        this.dispatchEvent(new h()), n && (a.matches(lt) && (o = a), o = o || Ft(a), o || a.querySelectorAll("slot").forEach((d) => {
+          o || (o = zt(d));
+        }), !(!this.isConnected || this.dialogEl.open) && this.dialogEl.showModal());
+      }, r = (a, l) => () => {
+        if (this.open !== n)
+          return;
+        const h = n ? "luzmo-opened" : "luzmo-closed";
+        if (l > 0) {
+          a.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          );
+          return;
+        }
+        if (!this.isConnected || n !== this.open)
+          return;
+        const c = async () => {
+          const d = this.triggerElement instanceof wt;
+          this.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: d
+            })
+          ), a.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          ), this.triggerElement && !d && this.triggerElement.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: !0
+            })
+          ), this.state = n ? "opened" : "closed", this.returnFocus(), await R(), await R(), n === this.open && n === !1 && this.requestSlottable();
+        };
+        !n && this.dialogEl.open ? (this.dialogEl.addEventListener(
+          "close",
+          () => {
+            c();
+          },
+          { once: !0 }
+        ), this.dialogEl.close()) : c();
+      };
+      return this.elements.forEach((a, l) => {
+        kt(a, s(a, l), r(a, l));
+      }), o;
+    }
+    dialogApplyFocus(n, o) {
+      this.applyFocus(n, o);
+    }
+  }
+  return t;
+}
+function Re(e) {
+  class t extends e {
+    async managePopoverOpen() {
+      await this.managePosition();
+    }
+    async manageDelay(n) {
+      if (n === !1 || n !== this.open) {
+        mt.close(this);
+        return;
+      }
+      this.delayed && await mt.openTimer(this) && (this.open = !n);
+    }
+    ensureOnDOM(n) {
+      document.body.offsetHeight;
+    }
+    makeTransition(n) {
+      if (this.open !== n)
+        return null;
+      let o = null;
+      const s = (a, l) => () => {
+        if (n !== this.open)
+          return;
+        if (a.open = n, l === 0) {
+          const c = n ? _t : Nt;
+          this.dispatchEvent(new c());
+        }
+        if (n !== !0 || (a.matches(lt) && (o = a), o = o || Ft(a), o))
+          return;
+        a.querySelectorAll("slot").forEach((c) => {
+          o || (o = zt(c));
+        });
+      }, r = (a, l) => async () => {
+        if (this.open !== n)
+          return;
+        const h = n ? "luzmo-opened" : "luzmo-closed";
+        if (a.dispatchEvent(
+          new S(h, this, {
+            interaction: this.type
+          })
+        ), l > 0)
+          return;
+        const c = this.triggerElement instanceof wt;
+        this.dispatchEvent(
+          new S(h, this, {
+            interaction: this.type,
+            publish: c
+          })
+        ), this.triggerElement && !c && this.triggerElement.dispatchEvent(
+          new S(h, this, {
+            interaction: this.type,
+            publish: !0
+          })
+        ), this.state = n ? "opened" : "closed", this.returnFocus(), await R(), await R(), n === this.open && n === !1 && this.requestSlottable();
+      };
+      return this.elements.forEach((a, l) => {
+        kt(a, s(a, l), r(a, l));
+      }), o;
+    }
+  }
+  return t;
+}
+const De = CSS.supports("(overlay: auto)");
+function jt(e) {
+  let t = !1;
+  try {
+    t = e.matches(":popover-open");
+  } catch {
+  }
+  let i = !1;
+  try {
+    i = e.matches(":open");
+  } catch {
+  }
+  return t || i;
+}
+function Le(e) {
+  class t extends e {
+    async manageDelay(n) {
+      if (n === !1 || n !== this.open) {
+        mt.close(this);
+        return;
+      }
+      this.delayed && await mt.openTimer(this) && (this.open = !n);
+    }
+    /**
+     * A popover should be hidden _after_ it is no longer on top-layer because
+     * the position metrics will have changed from when it was originally positioned.
+     */
+    shouldHidePopover(n) {
+      if (n && this.open !== n)
+        return;
+      const o = async ({
+        newState: s
+      } = {}) => {
+        s !== "open" && await this.placementController.resetOverlayPosition();
+      };
+      if (!jt(this.dialogEl)) {
+        o();
+        return;
+      }
+      this.dialogEl.addEventListener("toggle", o, {
+        once: !0
+      });
+    }
+    shouldShowPopover(n) {
+      let o = !1;
+      try {
+        o = this.dialogEl.matches(":popover-open");
+      } catch {
+      }
+      let s = !1;
+      try {
+        s = this.dialogEl.matches(":open");
+      } catch {
+      }
+      n && this.open === n && !o && !s && this.isConnected && (this.dialogEl.showPopover(), this.managePosition());
+    }
+    async ensureOnDOM(n) {
+      await R(), De || await this.shouldHidePopover(n), this.shouldShowPopover(n), await R();
+    }
+    makeTransition(n) {
+      if (this.open !== n)
+        return null;
+      let o = null;
+      const s = (a, l) => () => {
+        if (a.open = n, l === 0) {
+          const c = n ? _t : Nt;
+          this.dispatchEvent(new c());
+        }
+        if (!n || (a.matches(lt) && (o = a), o = o || Ft(a), o))
+          return;
+        a.querySelectorAll("slot").forEach((c) => {
+          o || (o = zt(c));
+        });
+      }, r = (a, l) => () => {
+        if (this.open !== n)
+          return;
+        const h = n ? "luzmo-opened" : "luzmo-closed";
+        if (l > 0) {
+          a.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          );
+          return;
+        }
+        const c = async () => {
+          if (this.open !== n)
+            return;
+          await R();
+          const f = this.triggerElement instanceof wt;
+          this.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: f
+            })
+          ), a.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          ), this.triggerElement && !f && this.triggerElement.dispatchEvent(
+            new S(h, this, {
+              interaction: this.type,
+              publish: !0
+            })
+          ), this.state = n ? "opened" : "closed", this.returnFocus(), await R(), await R(), n === this.open && n === !1 && this.requestSlottable();
+        };
+        if (this.open !== n)
+          return;
+        const d = jt(this.dialogEl);
+        n !== !0 && d && this.isConnected ? (this.dialogEl.addEventListener(
+          "beforetoggle",
+          () => {
+            c();
+          },
+          { once: !0 }
+        ), this.dialogEl.hidePopover()) : c();
+      };
+      return this.elements.forEach((a, l) => {
+        kt(a, s(a, l), r(a, l));
+      }), o;
+    }
+  }
+  return t;
+}
+const Se = "showPopover" in document.createElement("div");
+class ke {
+  constructor() {
+    this.root = document.body, this.stack = [], this.handlePointerdown = (t) => {
+      this.pointerdownPath = t.composedPath(), this.lastOverlay = this.stack.at(-1);
+    }, this.handlePointerup = () => {
+      const t = this.pointerdownPath;
+      if (this.pointerdownPath = void 0, this.stack.length === 0 || !(t != null && t.length))
+        return;
+      const i = this.lastOverlay;
+      this.lastOverlay = void 0;
+      const n = this.stack.length - 1, o = this.stack.filter((s, r) => !t.find(
+        (l) => (
+          // The Overlay is in the stack
+          l === s || // The Overlay trigger is in the stack and the Overlay is a "hint"
+          l === (s == null ? void 0 : s.triggerElement) && (s == null ? void 0 : s.type) === "hint" || // The last Overlay in the stack is not the last Overlay at `pointerdown` time and has a
+          // `triggerInteraction` of "longpress", meaning it was opened by this poitner interaction
+          r === n && s !== i && s.triggerInteraction === "longpress"
+        )
+      ) && !s.shouldPreventClose() && s.type !== "manual" && // Don't close if this overlay is modal and not on top of the overlay stack.
+      !(s.type === "modal" && i !== s));
+      o.reverse(), o.forEach((s) => {
+        this.closeOverlay(s);
+        let r = s.parentOverlayToForceClose;
+        for (; r; )
+          this.closeOverlay(r), r = r.parentOverlayToForceClose;
+      });
+    }, this.handleBeforetoggle = (t) => {
+      const { target: i, newState: n } = t;
+      n !== "open" && this.closeOverlay(i);
+    }, this.handleKeydown = (t) => {
+      if (t.code !== "Escape" || this.stack.length === 0)
+        return;
+      const i = this.stack.at(-1);
+      if ((i == null ? void 0 : i.type) === "page") {
+        t.preventDefault();
+        return;
+      }
+      Se || (i == null ? void 0 : i.type) !== "manual" && i && this.closeOverlay(i);
+    }, this.bindEvents();
+  }
+  get document() {
+    return this.root.ownerDocument || document;
+  }
+  bindEvents() {
+    this.document.addEventListener("pointerdown", this.handlePointerdown), this.document.addEventListener("pointerup", this.handlePointerup), this.document.addEventListener("keydown", this.handleKeydown);
+  }
+  closeOverlay(t) {
+    const i = this.stack.indexOf(t);
+    i !== -1 && this.stack.splice(i, 1), t.open = !1;
+  }
+  /**
+   * Get an array of Overlays that all share the same trigger element.
+   *
+   * @param triggerElement {HTMLELement}
+   * @returns
+   */
+  overlaysByTriggerElement(t) {
+    return this.stack.filter(
+      (i) => i.triggerElement === t
+    );
+  }
+  /**
+   * When overlays are added manage the open state of exisiting overlays appropriately:
+   * - 'modal': should close other non-'modal' and non-'manual' overlays
+   * - 'page': should close other non-'modal' and non-'manual' overlays
+   * - 'auto': should close other 'auto' overlays and other 'hint' overlays, but not 'manual' overlays
+   * - 'manual': shouldn't close other overlays
+   * - 'hint': shouldn't close other overlays and give way to all other overlays on a trigger
+   */
+  add(t) {
+    if (this.stack.includes(t)) {
+      const i = this.stack.indexOf(t);
+      i !== -1 && (this.stack.splice(i, 1), this.stack.push(t));
+      return;
+    }
+    if (t.type === "auto" || t.type === "modal" || t.type === "page") {
+      const i = "luzmo-overlay-query-path", n = new Event(i, {
+        composed: !0,
+        bubbles: !0
+      });
+      t.addEventListener(
+        i,
+        (o) => {
+          const s = o.composedPath();
+          this.stack.forEach((r) => {
+            !s.find((l) => l === r) && r.type !== "manual" && r.type !== "modal" && this.closeOverlay(r);
+          });
+        },
+        { once: !0 }
+      ), t.dispatchEvent(n);
+    } else if (t.type === "hint") {
+      if (this.stack.some(
+        (n) => n.type !== "manual" && n.triggerElement && n.triggerElement === t.triggerElement
+      )) {
+        t.open = !1;
+        return;
+      }
+      this.stack.forEach((n) => {
+        n.type === "hint" && this.closeOverlay(n);
+      });
+    }
+    requestAnimationFrame(() => {
+      this.stack.push(t), t.addEventListener("beforetoggle", this.handleBeforetoggle, {
+        once: !0
+      });
+    });
+  }
+  remove(t) {
+    this.closeOverlay(t);
+  }
+}
+const Kt = new ke(), Fe = ':host{display:contents;pointer-events:none;--luzmo-overlay-animation-distance: .5rem}:host(:has(> luzmo-tooltip)){--luzmo-overlay-animation-distance: var( --luzmo-tooltip-animation-distance, 4px )}.dialog{margin:0;border:0;background:none;padding:0;position:fixed;overflow:visible;opacity:1!important;box-sizing:border-box;max-height:calc(100vh - 16px);max-height:calc(100dvh - 16px);max-width:calc(100vw - 16px);height:auto;inset:auto;top:0;left:0;display:flex;--luzmo-overlay-open: true}.dialog:not([is-visible]){display:none}.dialog:focus{outline:none}dialog:modal{--luzmo-popover-filter: drop-shadow(0px 2px 6px rgba(0, 0, 0, .15))}:host(:not([open])) .dialog{--luzmo-overlay-open: false}.dialog::backdrop{display:none}.dialog:before{position:absolute;top:-999em;right:-999em;bottom:-999em;left:-999em;content:"";pointer-events:auto!important}.dialog:not(.not-immediately-closable):before{display:none}.dialog>div{width:100%}::slotted(*){pointer-events:auto;visibility:visible!important}::slotted(luzmo-popover){position:static}.dialog:not([actual-placement])[placement*=top]{padding-block:var(--luzmo-overlay-animation-distance);margin-top:var(--luzmo-overlay-animation-distance)}.dialog:not([actual-placement])[placement*=right]{padding-inline:var(--luzmo-overlay-animation-distance);margin-left:calc(-1 * var(--luzmo-overlay-animation-distance))}.dialog:not([actual-placement])[placement*=bottom]{padding-block:var(--luzmo-overlay-animation-distance);margin-top:calc(-1 * var(--luzmo-overlay-animation-distance))}.dialog:not([actual-placement])[placement*=left]{padding-inline:var(--luzmo-overlay-animation-distance);margin-left:var(--luzmo-overlay-animation-distance)}.dialog[actual-placement*=top]{padding-block:var(--luzmo-overlay-animation-distance);margin-top:var(--luzmo-overlay-animation-distance)}.dialog[actual-placement*=right]{padding-inline:var(--luzmo-overlay-animation-distance);margin-left:calc(-1 * var(--luzmo-overlay-animation-distance))}.dialog[actual-placement*=bottom]{padding-block:var(--luzmo-overlay-animation-distance);margin-top:calc(-1 * var(--luzmo-overlay-animation-distance))}.dialog[actual-placement*=left]{padding-inline:var(--luzmo-overlay-animation-distance);margin-left:var(--luzmo-overlay-animation-distance)}slot[name=longpress-describedby-descriptor]{display:none}@supports selector(:open){.dialog{opacity:0}.dialog:open{opacity:1;--luzmo-popover-filter: drop-shadow(0px 2px 6px rgba(0, 0, 0, .15))}}@supports selector(:popover-open){.dialog{opacity:0}.dialog:popover-open{opacity:1;--luzmo-popover-filter: drop-shadow(0px 2px 6px rgba(0, 0, 0, .15))}}@supports (overlay: auto){.dialog{display:none;transition:all var(--luzmo-overlay-animation-duration, .13s),translate 0s,display var(--luzmo-overlay-animation-duration, .13s);transition-behavior:allow-discrete}.dialog:popover-open,.dialog:modal{display:flex}}@supports (not selector(:open)) and (not selector(:popover-open)){:host:not([open]) .dialog{pointer-events:none}.dialog[actual-placement]{z-index:calc(var(--luzmo-overlay-z-index-base, 1000) + var(--luzmo-overlay-open-count))}}', Y = Math.min, A = Math.max, gt = Math.round, dt = Math.floor, M = (e) => ({
+  x: e,
+  y: e
+}), ze = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Ne = {
+  start: "end",
+  end: "start"
+};
+function Tt(e, t, i) {
+  return A(e, Y(t, i));
+}
+function nt(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function G(e) {
+  return e.split("-")[0];
+}
+function ot(e) {
+  return e.split("-")[1];
+}
+function ee(e) {
+  return e === "x" ? "y" : "x";
+}
+function $t(e) {
+  return e === "y" ? "height" : "width";
+}
+function Q(e) {
+  return ["top", "bottom"].includes(G(e)) ? "y" : "x";
+}
+function Mt(e) {
+  return ee(Q(e));
+}
+function _e(e, t, i) {
+  i === void 0 && (i = !1);
+  const n = ot(e), o = Mt(e), s = $t(o);
+  let r = o === "x" ? n === (i ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return t.reference[s] > t.floating[s] && (r = vt(r)), [r, vt(r)];
+}
+function $e(e) {
+  const t = vt(e);
+  return [Rt(e), t, Rt(t)];
+}
+function Rt(e) {
+  return e.replace(/start|end/g, (t) => Ne[t]);
+}
+function Me(e, t, i) {
+  const n = ["left", "right"], o = ["right", "left"], s = ["top", "bottom"], r = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return i ? t ? o : n : t ? n : o;
+    case "left":
+    case "right":
+      return t ? s : r;
+    default:
+      return [];
+  }
+}
+function He(e, t, i, n) {
+  const o = ot(e);
+  let s = Me(G(e), i === "start", n);
+  return o && (s = s.map((r) => r + "-" + o), t && (s = s.concat(s.map(Rt)))), s;
+}
+function vt(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => ze[t]);
+}
+function Be(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function ie(e) {
+  return typeof e != "number" ? Be(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function yt(e) {
+  const {
+    x: t,
+    y: i,
+    width: n,
+    height: o
+  } = e;
+  return {
+    width: n,
+    height: o,
+    top: i,
+    left: t,
+    right: t + n,
+    bottom: i + o,
+    x: t,
+    y: i
+  };
+}
+function Yt(e, t, i) {
+  let {
+    reference: n,
+    floating: o
+  } = e;
+  const s = Q(t), r = Mt(t), a = $t(r), l = G(t), h = s === "y", c = n.x + n.width / 2 - o.width / 2, d = n.y + n.height / 2 - o.height / 2, f = n[a] / 2 - o[a] / 2;
+  let u;
+  switch (l) {
+    case "top":
+      u = {
+        x: c,
+        y: n.y - o.height
+      };
+      break;
+    case "bottom":
+      u = {
+        x: c,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      u = {
+        x: n.x + n.width,
+        y: d
+      };
+      break;
+    case "left":
+      u = {
+        x: n.x - o.width,
+        y: d
+      };
+      break;
+    default:
+      u = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (ot(t)) {
+    case "start":
+      u[r] -= f * (i && h ? -1 : 1);
+      break;
+    case "end":
+      u[r] += f * (i && h ? -1 : 1);
+      break;
+  }
+  return u;
+}
+const We = async (e, t, i) => {
+  const {
+    placement: n = "bottom",
+    strategy: o = "absolute",
+    middleware: s = [],
+    platform: r
+  } = i, a = s.filter(Boolean), l = await (r.isRTL == null ? void 0 : r.isRTL(t));
+  let h = await r.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: c,
+    y: d
+  } = Yt(h, n, l), f = n, u = {}, p = 0;
+  for (let m = 0; m < a.length; m++) {
+    const {
+      name: v,
+      fn: g
+    } = a[m], {
+      x: y,
+      y: w,
+      data: x,
+      reset: b
+    } = await g({
+      x: c,
+      y: d,
+      initialPlacement: n,
+      placement: f,
+      strategy: o,
+      middlewareData: u,
+      rects: h,
+      platform: r,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    c = y ?? c, d = w ?? d, u = {
+      ...u,
+      [v]: {
+        ...u[v],
+        ...x
+      }
+    }, b && p <= 50 && (p++, typeof b == "object" && (b.placement && (f = b.placement), b.rects && (h = b.rects === !0 ? await r.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : b.rects), {
+      x: c,
+      y: d
+    } = Yt(h, f, l)), m = -1);
+  }
+  return {
+    x: c,
+    y: d,
+    placement: f,
+    strategy: o,
+    middlewareData: u
+  };
+};
+async function Ht(e, t) {
+  var i;
+  t === void 0 && (t = {});
+  const {
+    x: n,
+    y: o,
+    platform: s,
+    rects: r,
+    elements: a,
+    strategy: l
+  } = e, {
+    boundary: h = "clippingAncestors",
+    rootBoundary: c = "viewport",
+    elementContext: d = "floating",
+    altBoundary: f = !1,
+    padding: u = 0
+  } = nt(t, e), p = ie(u), v = a[f ? d === "floating" ? "reference" : "floating" : d], g = yt(await s.getClippingRect({
+    element: (i = await (s.isElement == null ? void 0 : s.isElement(v))) == null || i ? v : v.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(a.floating)),
+    boundary: h,
+    rootBoundary: c,
+    strategy: l
+  })), y = d === "floating" ? {
+    x: n,
+    y: o,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, w = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(a.floating)), x = await (s.isElement == null ? void 0 : s.isElement(w)) ? await (s.getScale == null ? void 0 : s.getScale(w)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, b = yt(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: y,
+    offsetParent: w,
+    strategy: l
+  }) : y);
+  return {
+    top: (g.top - b.top + p.top) / x.y,
+    bottom: (b.bottom - g.bottom + p.bottom) / x.y,
+    left: (g.left - b.left + p.left) / x.x,
+    right: (b.right - g.right + p.right) / x.x
+  };
+}
+const qe = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: i,
+      y: n,
+      placement: o,
+      rects: s,
+      platform: r,
+      elements: a,
+      middlewareData: l
+    } = t, {
+      element: h,
+      padding: c = 0
+    } = nt(e, t) || {};
+    if (h == null)
+      return {};
+    const d = ie(c), f = {
+      x: i,
+      y: n
+    }, u = Mt(o), p = $t(u), m = await r.getDimensions(h), v = u === "y", g = v ? "top" : "left", y = v ? "bottom" : "right", w = v ? "clientHeight" : "clientWidth", x = s.reference[p] + s.reference[u] - f[u] - s.floating[p], b = f[u] - s.reference[u], D = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(h));
+    let E = D ? D[w] : 0;
+    (!E || !await (r.isElement == null ? void 0 : r.isElement(D))) && (E = a.floating[w] || s.floating[p]);
+    const W = x / 2 - b / 2, N = E / 2 - m[p] / 2 - 1, L = Y(d[g], N), V = Y(d[y], N), _ = L, U = E - m[p] - V, C = E / 2 - m[p] / 2 + W, tt = Tt(_, C, U), q = !l.arrow && ot(o) != null && C !== tt && s.reference[p] / 2 - (C < _ ? L : V) - m[p] / 2 < 0, $ = q ? C < _ ? C - _ : C - U : 0;
+    return {
+      [u]: f[u] + $,
+      data: {
+        [u]: tt,
+        centerOffset: C - tt - $,
+        ...q && {
+          alignmentOffset: $
+        }
+      },
+      reset: q
+    };
+  }
+}), Ie = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var i, n;
+      const {
+        placement: o,
+        middlewareData: s,
+        rects: r,
+        initialPlacement: a,
+        platform: l,
+        elements: h
+      } = t, {
+        mainAxis: c = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: f,
+        fallbackStrategy: u = "bestFit",
+        fallbackAxisSideDirection: p = "none",
+        flipAlignment: m = !0,
+        ...v
+      } = nt(e, t);
+      if ((i = s.arrow) != null && i.alignmentOffset)
+        return {};
+      const g = G(o), y = Q(a), w = G(a) === a, x = await (l.isRTL == null ? void 0 : l.isRTL(h.floating)), b = f || (w || !m ? [vt(a)] : $e(a)), D = p !== "none";
+      !f && D && b.push(...He(a, m, p, x));
+      const E = [a, ...b], W = await Ht(t, v), N = [];
+      let L = ((n = s.flip) == null ? void 0 : n.overflows) || [];
+      if (c && N.push(W[g]), d) {
+        const C = _e(o, r, x);
+        N.push(W[C[0]], W[C[1]]);
+      }
+      if (L = [...L, {
+        placement: o,
+        overflows: N
+      }], !N.every((C) => C <= 0)) {
+        var V, _;
+        const C = (((V = s.flip) == null ? void 0 : V.index) || 0) + 1, tt = E[C];
+        if (tt)
+          return {
+            data: {
+              index: C,
+              overflows: L
+            },
+            reset: {
+              placement: tt
+            }
+          };
+        let q = (_ = L.filter(($) => $.overflows[0] <= 0).sort(($, j) => $.overflows[1] - j.overflows[1])[0]) == null ? void 0 : _.placement;
+        if (!q)
+          switch (u) {
+            case "bestFit": {
+              var U;
+              const $ = (U = L.filter((j) => {
+                if (D) {
+                  const K = Q(j.placement);
+                  return K === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  K === "y";
+                }
+                return !0;
+              }).map((j) => [j.placement, j.overflows.filter((K) => K > 0).reduce((K, de) => K + de, 0)]).sort((j, K) => j[1] - K[1])[0]) == null ? void 0 : U[0];
+              $ && (q = $);
+              break;
+            }
+            case "initialPlacement":
+              q = a;
+              break;
+          }
+        if (o !== q)
+          return {
+            reset: {
+              placement: q
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function Ve(e, t) {
+  const {
+    placement: i,
+    platform: n,
+    elements: o
+  } = e, s = await (n.isRTL == null ? void 0 : n.isRTL(o.floating)), r = G(i), a = ot(i), l = Q(i) === "y", h = ["left", "top"].includes(r) ? -1 : 1, c = s && l ? -1 : 1, d = nt(t, e);
+  let {
+    mainAxis: f,
+    crossAxis: u,
+    alignmentAxis: p
+  } = typeof d == "number" ? {
+    mainAxis: d,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: d.mainAxis || 0,
+    crossAxis: d.crossAxis || 0,
+    alignmentAxis: d.alignmentAxis
+  };
+  return a && typeof p == "number" && (u = a === "end" ? p * -1 : p), l ? {
+    x: u * c,
+    y: f * h
+  } : {
+    x: f * h,
+    y: u * c
+  };
+}
+const Ue = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var i, n;
+      const {
+        x: o,
+        y: s,
+        placement: r,
+        middlewareData: a
+      } = t, l = await Ve(t, e);
+      return r === ((i = a.offset) == null ? void 0 : i.placement) && (n = a.arrow) != null && n.alignmentOffset ? {} : {
+        x: o + l.x,
+        y: s + l.y,
+        data: {
+          ...l,
+          placement: r
+        }
+      };
+    }
+  };
+}, je = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: i,
+        y: n,
+        placement: o
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: r = !1,
+        limiter: a = {
+          fn: (v) => {
+            let {
+              x: g,
+              y
+            } = v;
+            return {
+              x: g,
+              y
+            };
+          }
+        },
+        ...l
+      } = nt(e, t), h = {
+        x: i,
+        y: n
+      }, c = await Ht(t, l), d = Q(G(o)), f = ee(d);
+      let u = h[f], p = h[d];
+      if (s) {
+        const v = f === "y" ? "top" : "left", g = f === "y" ? "bottom" : "right", y = u + c[v], w = u - c[g];
+        u = Tt(y, u, w);
+      }
+      if (r) {
+        const v = d === "y" ? "top" : "left", g = d === "y" ? "bottom" : "right", y = p + c[v], w = p - c[g];
+        p = Tt(y, p, w);
+      }
+      const m = a.fn({
+        ...t,
+        [f]: u,
+        [d]: p
+      });
+      return {
+        ...m,
+        data: {
+          x: m.x - i,
+          y: m.y - n,
+          enabled: {
+            [f]: s,
+            [d]: r
+          }
+        }
+      };
+    }
+  };
+}, Ke = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var i, n;
+      const {
+        placement: o,
+        rects: s,
+        platform: r,
+        elements: a
+      } = t, {
+        apply: l = () => {
+        },
+        ...h
+      } = nt(e, t), c = await Ht(t, h), d = G(o), f = ot(o), u = Q(o) === "y", {
+        width: p,
+        height: m
+      } = s.floating;
+      let v, g;
+      d === "top" || d === "bottom" ? (v = d, g = f === (await (r.isRTL == null ? void 0 : r.isRTL(a.floating)) ? "start" : "end") ? "left" : "right") : (g = d, v = f === "end" ? "top" : "bottom");
+      const y = m - c.top - c.bottom, w = p - c.left - c.right, x = Y(m - c[v], y), b = Y(p - c[g], w), D = !t.middlewareData.shift;
+      let E = x, W = b;
+      if ((i = t.middlewareData.shift) != null && i.enabled.x && (W = w), (n = t.middlewareData.shift) != null && n.enabled.y && (E = y), D && !f) {
+        const L = A(c.left, 0), V = A(c.right, 0), _ = A(c.top, 0), U = A(c.bottom, 0);
+        u ? W = p - 2 * (L !== 0 || V !== 0 ? L + V : A(c.left, c.right)) : E = m - 2 * (_ !== 0 || U !== 0 ? _ + U : A(c.top, c.bottom));
+      }
+      await l({
+        ...t,
+        availableWidth: W,
+        availableHeight: E
+      });
+      const N = await r.getDimensions(a.floating);
+      return p !== N.width || m !== N.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function bt() {
+  return typeof window < "u";
+}
+function st(e) {
+  return ne(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function T(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function B(e) {
+  var t;
+  return (t = (ne(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function ne(e) {
+  return bt() ? e instanceof Node || e instanceof T(e).Node : !1;
+}
+function k(e) {
+  return bt() ? e instanceof Element || e instanceof T(e).Element : !1;
+}
+function H(e) {
+  return bt() ? e instanceof HTMLElement || e instanceof T(e).HTMLElement : !1;
+}
+function Gt(e) {
+  return !bt() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof T(e).ShadowRoot;
+}
+function ct(e) {
+  const {
+    overflow: t,
+    overflowX: i,
+    overflowY: n,
+    display: o
+  } = F(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + n + i) && !["inline", "contents"].includes(o);
+}
+function Ye(e) {
+  return ["table", "td", "th"].includes(st(e));
+}
+function xt(e) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Bt(e) {
+  const t = Wt(), i = k(e) ? F(e) : e;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((n) => i[n] ? i[n] !== "none" : !1) || (i.containerType ? i.containerType !== "normal" : !1) || !t && (i.backdropFilter ? i.backdropFilter !== "none" : !1) || !t && (i.filter ? i.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((n) => (i.willChange || "").includes(n)) || ["paint", "layout", "strict", "content"].some((n) => (i.contain || "").includes(n));
+}
+function Ge(e) {
+  let t = X(e);
+  for (; H(t) && !it(t); ) {
+    if (Bt(t))
+      return t;
+    if (xt(t))
+      return null;
+    t = X(t);
+  }
+  return null;
+}
+function Wt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function it(e) {
+  return ["html", "body", "#document"].includes(st(e));
+}
+function F(e) {
+  return T(e).getComputedStyle(e);
+}
+function Et(e) {
+  return k(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function X(e) {
+  if (st(e) === "html")
+    return e;
+  const t = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    e.assignedSlot || // DOM Element detected.
+    e.parentNode || // ShadowRoot detected.
+    Gt(e) && e.host || // Fallback.
+    B(e)
+  );
+  return Gt(t) ? t.host : t;
+}
+function oe(e) {
+  const t = X(e);
+  return it(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : H(t) && ct(t) ? t : oe(t);
+}
+function at(e, t, i) {
+  var n;
+  t === void 0 && (t = []), i === void 0 && (i = !0);
+  const o = oe(e), s = o === ((n = e.ownerDocument) == null ? void 0 : n.body), r = T(o);
+  if (s) {
+    const a = Dt(r);
+    return t.concat(r, r.visualViewport || [], ct(o) ? o : [], a && i ? at(a) : []);
+  }
+  return t.concat(o, at(o, [], i));
+}
+function Dt(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function se(e) {
+  const t = F(e);
+  let i = parseFloat(t.width) || 0, n = parseFloat(t.height) || 0;
+  const o = H(e), s = o ? e.offsetWidth : i, r = o ? e.offsetHeight : n, a = gt(i) !== s || gt(n) !== r;
+  return a && (i = s, n = r), {
+    width: i,
+    height: n,
+    $: a
+  };
+}
+function qt(e) {
+  return k(e) ? e : e.contextElement;
+}
+function et(e) {
+  const t = qt(e);
+  if (!H(t))
+    return M(1);
+  const i = t.getBoundingClientRect(), {
+    width: n,
+    height: o,
+    $: s
+  } = se(t);
+  let r = (s ? gt(i.width) : i.width) / n, a = (s ? gt(i.height) : i.height) / o;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!a || !Number.isFinite(a)) && (a = 1), {
+    x: r,
+    y: a
+  };
+}
+const Xe = /* @__PURE__ */ M(0);
+function re(e) {
+  const t = T(e);
+  return !Wt() || !t.visualViewport ? Xe : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function Je(e, t, i) {
+  return t === void 0 && (t = !1), !i || t && i !== T(e) ? !1 : t;
+}
+function Z(e, t, i, n) {
+  t === void 0 && (t = !1), i === void 0 && (i = !1);
+  const o = e.getBoundingClientRect(), s = qt(e);
+  let r = M(1);
+  t && (n ? k(n) && (r = et(n)) : r = et(e));
+  const a = Je(s, i, n) ? re(s) : M(0);
+  let l = (o.left + a.x) / r.x, h = (o.top + a.y) / r.y, c = o.width / r.x, d = o.height / r.y;
+  if (s) {
+    const f = T(s), u = n && k(n) ? T(n) : n;
+    let p = f, m = Dt(p);
+    for (; m && n && u !== p; ) {
+      const v = et(m), g = m.getBoundingClientRect(), y = F(m), w = g.left + (m.clientLeft + parseFloat(y.paddingLeft)) * v.x, x = g.top + (m.clientTop + parseFloat(y.paddingTop)) * v.y;
+      l *= v.x, h *= v.y, c *= v.x, d *= v.y, l += w, h += x, p = T(m), m = Dt(p);
+    }
+  }
+  return yt({
+    width: c,
+    height: d,
+    x: l,
+    y: h
+  });
+}
+function It(e, t) {
+  const i = Et(e).scrollLeft;
+  return t ? t.left + i : Z(B(e)).left + i;
+}
+function ae(e, t, i) {
+  i === void 0 && (i = !1);
+  const n = e.getBoundingClientRect(), o = n.left + t.scrollLeft - (i ? 0 : (
+    // RTL <body> scrollbar.
+    It(e, n)
+  )), s = n.top + t.scrollTop;
+  return {
+    x: o,
+    y: s
+  };
+}
+function Qe(e) {
+  let {
+    elements: t,
+    rect: i,
+    offsetParent: n,
+    strategy: o
+  } = e;
+  const s = o === "fixed", r = B(n), a = t ? xt(t.floating) : !1;
+  if (n === r || a && s)
+    return i;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, h = M(1);
+  const c = M(0), d = H(n);
+  if ((d || !d && !s) && ((st(n) !== "body" || ct(r)) && (l = Et(n)), H(n))) {
+    const u = Z(n);
+    h = et(n), c.x = u.x + n.clientLeft, c.y = u.y + n.clientTop;
+  }
+  const f = r && !d && !s ? ae(r, l, !0) : M(0);
+  return {
+    width: i.width * h.x,
+    height: i.height * h.y,
+    x: i.x * h.x - l.scrollLeft * h.x + c.x + f.x,
+    y: i.y * h.y - l.scrollTop * h.y + c.y + f.y
+  };
+}
+function Ze(e) {
+  return Array.from(e.getClientRects());
+}
+function ti(e) {
+  const t = B(e), i = Et(e), n = e.ownerDocument.body, o = A(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), s = A(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let r = -i.scrollLeft + It(e);
+  const a = -i.scrollTop;
+  return F(n).direction === "rtl" && (r += A(t.clientWidth, n.clientWidth) - o), {
+    width: o,
+    height: s,
+    x: r,
+    y: a
+  };
+}
+function ei(e, t) {
+  const i = T(e), n = B(e), o = i.visualViewport;
+  let s = n.clientWidth, r = n.clientHeight, a = 0, l = 0;
+  if (o) {
+    s = o.width, r = o.height;
+    const h = Wt();
+    (!h || h && t === "fixed") && (a = o.offsetLeft, l = o.offsetTop);
+  }
+  return {
+    width: s,
+    height: r,
+    x: a,
+    y: l
+  };
+}
+function ii(e, t) {
+  const i = Z(e, !0, t === "fixed"), n = i.top + e.clientTop, o = i.left + e.clientLeft, s = H(e) ? et(e) : M(1), r = e.clientWidth * s.x, a = e.clientHeight * s.y, l = o * s.x, h = n * s.y;
+  return {
+    width: r,
+    height: a,
+    x: l,
+    y: h
+  };
+}
+function Xt(e, t, i) {
+  let n;
+  if (t === "viewport")
+    n = ei(e, i);
+  else if (t === "document")
+    n = ti(B(e));
+  else if (k(t))
+    n = ii(t, i);
+  else {
+    const o = re(e);
+    n = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return yt(n);
+}
+function le(e, t) {
+  const i = X(e);
+  return i === t || !k(i) || it(i) ? !1 : F(i).position === "fixed" || le(i, t);
+}
+function ni(e, t) {
+  const i = t.get(e);
+  if (i)
+    return i;
+  let n = at(e, [], !1).filter((a) => k(a) && st(a) !== "body"), o = null;
+  const s = F(e).position === "fixed";
+  let r = s ? X(e) : e;
+  for (; k(r) && !it(r); ) {
+    const a = F(r), l = Bt(r);
+    !l && a.position === "fixed" && (o = null), (s ? !l && !o : !l && a.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || ct(r) && !l && le(e, r)) ? n = n.filter((c) => c !== r) : o = a, r = X(r);
+  }
+  return t.set(e, n), n;
+}
+function oi(e) {
+  let {
+    element: t,
+    boundary: i,
+    rootBoundary: n,
+    strategy: o
+  } = e;
+  const r = [...i === "clippingAncestors" ? xt(t) ? [] : ni(t, this._c) : [].concat(i), n], a = r[0], l = r.reduce((h, c) => {
+    const d = Xt(t, c, o);
+    return h.top = A(d.top, h.top), h.right = Y(d.right, h.right), h.bottom = Y(d.bottom, h.bottom), h.left = A(d.left, h.left), h;
+  }, Xt(t, a, o));
+  return {
+    width: l.right - l.left,
+    height: l.bottom - l.top,
+    x: l.left,
+    y: l.top
+  };
+}
+function si(e) {
+  const {
+    width: t,
+    height: i
+  } = se(e);
+  return {
+    width: t,
+    height: i
+  };
+}
+function ri(e, t, i) {
+  const n = H(t), o = B(t), s = i === "fixed", r = Z(e, !0, s, t);
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = M(0);
+  if (n || !n && !s)
+    if ((st(t) !== "body" || ct(o)) && (a = Et(t)), n) {
+      const f = Z(t, !0, s, t);
+      l.x = f.x + t.clientLeft, l.y = f.y + t.clientTop;
+    } else o && (l.x = It(o));
+  const h = o && !n && !s ? ae(o, a) : M(0), c = r.left + a.scrollLeft - l.x - h.x, d = r.top + a.scrollTop - l.y - h.y;
+  return {
+    x: c,
+    y: d,
+    width: r.width,
+    height: r.height
+  };
+}
+function Ot(e) {
+  return F(e).position === "static";
+}
+function Jt(e, t) {
+  if (!H(e) || F(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let i = e.offsetParent;
+  return B(e) === i && (i = i.ownerDocument.body), i;
+}
+function ce(e, t) {
+  const i = T(e);
+  if (xt(e))
+    return i;
+  if (!H(e)) {
+    let o = X(e);
+    for (; o && !it(o); ) {
+      if (k(o) && !Ot(o))
+        return o;
+      o = X(o);
+    }
+    return i;
+  }
+  let n = Jt(e, t);
+  for (; n && Ye(n) && Ot(n); )
+    n = Jt(n, t);
+  return n && it(n) && Ot(n) && !Bt(n) ? i : n || Ge(e) || i;
+}
+const ai = async function(e) {
+  const t = this.getOffsetParent || ce, i = this.getDimensions, n = await i(e.floating);
+  return {
+    reference: ri(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function li(e) {
+  return F(e).direction === "rtl";
+}
+const ci = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Qe,
+  getDocumentElement: B,
+  getClippingRect: oi,
+  getOffsetParent: ce,
+  getElementRects: ai,
+  getClientRects: Ze,
+  getDimensions: si,
+  getScale: et,
+  isElement: k,
+  isRTL: li
+};
+function he(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function hi(e, t) {
+  let i = null, n;
+  const o = B(e);
+  function s() {
+    var a;
+    clearTimeout(n), (a = i) == null || a.disconnect(), i = null;
+  }
+  function r(a, l) {
+    a === void 0 && (a = !1), l === void 0 && (l = 1), s();
+    const h = e.getBoundingClientRect(), {
+      left: c,
+      top: d,
+      width: f,
+      height: u
+    } = h;
+    if (a || t(), !f || !u)
+      return;
+    const p = dt(d), m = dt(o.clientWidth - (c + f)), v = dt(o.clientHeight - (d + u)), g = dt(c), w = {
+      rootMargin: -p + "px " + -m + "px " + -v + "px " + -g + "px",
+      threshold: A(0, Y(1, l)) || 1
+    };
+    let x = !0;
+    function b(D) {
+      const E = D[0].intersectionRatio;
+      if (E !== l) {
+        if (!x)
+          return r();
+        E ? r(!1, E) : n = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      E === 1 && !he(h, e.getBoundingClientRect()) && r(), x = !1;
+    }
+    try {
+      i = new IntersectionObserver(b, {
+        ...w,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      i = new IntersectionObserver(b, w);
+    }
+    i.observe(e);
+  }
+  return r(!0), s;
+}
+function Qt(e, t, i, n) {
+  n === void 0 && (n = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: s = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: a = typeof IntersectionObserver == "function",
+    animationFrame: l = !1
+  } = n, h = qt(e), c = o || s ? [...h ? at(h) : [], ...at(t)] : [];
+  c.forEach((g) => {
+    o && g.addEventListener("scroll", i, {
+      passive: !0
+    }), s && g.addEventListener("resize", i);
+  });
+  const d = h && a ? hi(h, i) : null;
+  let f = -1, u = null;
+  r && (u = new ResizeObserver((g) => {
+    let [y] = g;
+    y && y.target === h && u && (u.unobserve(t), cancelAnimationFrame(f), f = requestAnimationFrame(() => {
+      var w;
+      (w = u) == null || w.observe(t);
+    })), i();
+  }), h && !l && u.observe(h), u.observe(t));
+  let p, m = l ? Z(e) : null;
+  l && v();
+  function v() {
+    const g = Z(e);
+    m && !he(m, g) && i(), m = g, p = requestAnimationFrame(v);
+  }
+  return i(), () => {
+    var g;
+    c.forEach((y) => {
+      o && y.removeEventListener("scroll", i), s && y.removeEventListener("resize", i);
+    }), d == null || d(), (g = u) == null || g.disconnect(), u = null, l && cancelAnimationFrame(p);
+  };
+}
+const di = Ue, ui = je, Zt = Ie, pi = Ke, fi = qe, mi = (e, t, i) => {
+  const n = /* @__PURE__ */ new Map(), o = {
+    platform: ci,
+    ...i
+  }, s = {
+    ...o.platform,
+    _c: n
+  };
+  return We(e, t, {
+    ...o,
+    platform: s
+  });
+};
+function ut(e) {
+  if (e === void 0)
+    return 0;
+  const t = window.devicePixelRatio || 1;
+  return Math.round(e * t) / t;
+}
+const pt = 8, gi = 100, vi = (e) => ({
+  left: ["right", "bottom", "top"],
+  "left-start": ["right-start", "bottom", "top"],
+  "left-end": ["right-end", "bottom", "top"],
+  right: ["left", "bottom", "top"],
+  "right-start": ["left-start", "bottom", "top"],
+  "right-end": ["left-end", "bottom", "top"],
+  top: ["bottom", "left", "right"],
+  "top-start": ["bottom-start", "left", "right"],
+  "top-end": ["bottom-end", "left", "right"],
+  bottom: ["top", "left", "right"],
+  "bottom-start": ["top-start", "left", "right"],
+  "bottom-end": ["top-end", "left", "right"]
+})[e] ?? [e];
+class yi {
+  /**
+   * Creates an instance of the PlacementController.
+   *
+   * @param host - The host element that uses this controller.
+   */
+  constructor(t) {
+    this.originalPlacements = /* @__PURE__ */ new WeakMap(), this.allowPlacementUpdate = !1, this.closeForAncestorUpdate = () => {
+      !this.allowPlacementUpdate && this.options.type !== "modal" && this.cleanup && this.target.dispatchEvent(new Event("close", { bubbles: !0 })), this.allowPlacementUpdate = !1;
+    }, this.updatePlacement = () => {
+      this.computePlacement();
+    }, this.resetOverlayPosition = () => {
+      !this.target || !this.options || (this.clearOverlayPosition(), this.host.offsetHeight, this.computePlacement());
+    }, this.host = t, this.host.addController(this);
+  }
+  /**
+   * Places the overlay relative to the target element.
+   *
+   * This method sets up the necessary configurations and event listeners to manage the
+   * positioning and constraints of the overlay element.
+   *
+   * @param [target=this.target] - The target element for the overlay.
+   * @param [options=this.options] - The options for configuring the overlay placement.
+   * @returns A promise that resolves when the overlay has been placed.
+   */
+  placeOverlay(t = this.target, i = this.options) {
+    if (this.target = t, this.options = i, !t || !i)
+      return;
+    const n = Qt(
+      i.trigger,
+      t,
+      this.closeForAncestorUpdate,
+      {
+        ancestorResize: !1,
+        elementResize: !1,
+        layoutShift: !1
+      }
+    ), o = Qt(
+      i.trigger,
+      t,
+      this.updatePlacement,
+      {
+        ancestorScroll: !1
+      }
+    );
+    this.cleanup = () => {
+      var s;
+      (s = this.host.elements) == null || s.forEach((r) => {
+        r.addEventListener(
+          "luzmo-closed",
+          () => {
+            const a = this.originalPlacements.get(r);
+            a && r.setAttribute("placement", a), this.originalPlacements.delete(r);
+          },
+          { once: !0 }
+        );
+      }), n(), o();
+    };
+  }
+  /**
+   * Computes the placement of the overlay relative to the target element.
+   *
+   * This method calculates the necessary positioning and constraints for the overlay element
+   * using various middleware functions. It updates the overlay's style and attributes based
+   * on the computed position.
+   *
+   * @returns A promise that resolves when the placement has been computed.
+   */
+  async computePlacement() {
+    var f, u;
+    const { options: t, target: i } = this;
+    await (document.fonts ? document.fonts.ready : Promise.resolve());
+    const n = t.trigger instanceof HTMLElement ? Zt() : Zt({
+      padding: pt,
+      fallbackPlacements: vi(t.placement)
+    }), [o = 0, s = 0] = Array.isArray(t == null ? void 0 : t.offset) ? t.offset : [t.offset, 0], r = (f = this.host.elements.find(
+      (p) => p.tipElement
+    )) == null ? void 0 : f.tipElement, a = [
+      di({
+        mainAxis: o,
+        crossAxis: s
+      }),
+      ui({ padding: pt }),
+      n,
+      pi({
+        padding: pt,
+        apply: ({ availableWidth: p, availableHeight: m, rects: { floating: v } }) => {
+          const g = Math.max(
+            gi,
+            Math.floor(m)
+          ), y = v.height;
+          this.initialHeight = this.isConstrained && this.initialHeight || y, this.isConstrained = y < this.initialHeight || g <= y;
+          const w = this.isConstrained ? `${g}px` : "";
+          Object.assign(i.style, {
+            maxWidth: `${Math.floor(p)}px`,
+            maxHeight: w
+          });
+        }
+      }),
+      ...r ? [
+        fi({
+          element: r,
+          padding: t.tipPadding || pt
+        })
+      ] : []
+    ], { x: l, y: h, placement: c, middlewareData: d } = await mi(
+      t.trigger,
+      i,
+      {
+        placement: t.placement,
+        middleware: a,
+        strategy: "fixed"
+      }
+    );
+    if (Object.assign(i.style, {
+      top: "0px",
+      left: "0px",
+      translate: `${ut(l)}px ${ut(h)}px`
+    }), i.setAttribute("actual-placement", c), (u = this.host.elements) == null || u.forEach((p) => {
+      this.originalPlacements.has(p) || this.originalPlacements.set(
+        p,
+        p.getAttribute("placement")
+      ), p.setAttribute("placement", c);
+    }), r && d.arrow) {
+      const { x: p, y: m } = d.arrow;
+      Object.assign(r.style, {
+        top: c.startsWith("right") || c.startsWith("left") ? "0px" : "",
+        left: c.startsWith("bottom") || c.startsWith("top") ? "0px" : "",
+        translate: `${ut(p)}px ${ut(m)}px`
+      });
+    }
+  }
+  /**
+   * Clears the overlay's position styles.
+   *
+   * This method removes the max-height and max-width styles from the target element,
+   * and resets the initial height and constrained state of the overlay.
+   */
+  clearOverlayPosition() {
+    this.target && (this.target.style.removeProperty("max-height"), this.target.style.removeProperty("max-width"), this.initialHeight = void 0, this.isConstrained = !1);
+  }
+  /**
+   * Lifecycle method called when the host element is connected to the DOM.
+   *
+   * This method sets up an event listener to reset the overlay's position when the 'luzmo-update-overlays' event is dispatched.
+   */
+  hostConnected() {
+    document.addEventListener(
+      "luzmo-update-overlays",
+      this.resetOverlayPosition
+    );
+  }
+  /**
+   * Lifecycle method called when the host element is updated.
+   *
+   * This method cleans up resources if the overlay is not open.
+   */
+  hostUpdated() {
+    var t;
+    this.host.open || ((t = this.cleanup) == null || t.call(this), this.cleanup = void 0);
+  }
+  /**
+   * Lifecycle method called when the host element is disconnected from the DOM.
+   *
+   * This method removes the event listener and cleans up resources.
+   */
+  hostDisconnected() {
+    var t;
+    (t = this.cleanup) == null || t.call(this), this.cleanup = void 0, document.removeEventListener(
+      "luzmo-update-overlays",
+      this.resetOverlayPosition
+    );
+  }
+}
+var Pt = /* @__PURE__ */ ((e) => (e[e.click = 0] = "click", e[e.hover = 1] = "hover", e[e.longpress = 2] = "longpress", e))(Pt || {});
+class Vt {
+  constructor(t, { overlay: i, isPersistent: n, handleOverlayReady: o }) {
+    this.target = t, this.isLazilyOpen = !1, this.isPersistent = !1, this.isPersistent = !!n, this.handleOverlayReady = o, this.isPersistent && this.init(), this.overlay = i;
+  }
+  get activelyOpening() {
+    return !1;
+  }
+  get open() {
+    var t;
+    return ((t = this.overlay) == null ? void 0 : t.open) ?? this.isLazilyOpen;
+  }
+  /**
+   * Set `open` against the associated Overlay lazily.
+   */
+  set open(t) {
+    if (t !== this.open) {
+      if (this.isLazilyOpen = t, this.overlay) {
+        this.overlay.open = t;
+        return;
+      }
+      t && (customElements.whenDefined("luzmo-overlay").then(async () => {
+        const { Overlay: i } = await Promise.resolve().then(() => Lt);
+        this.overlay = new i(), this.overlay.open = !0;
+      }), Promise.resolve().then(() => Lt));
+    }
+  }
+  get overlay() {
+    return this._overlay;
+  }
+  set overlay(t) {
+    var i;
+    t && this.overlay !== t && (this.overlay && this.overlay.removeController(this), this._overlay = t, this.overlay.addController(this), this.initOverlay(), this.prepareDescription(this.target), (i = this.handleOverlayReady) == null || i.call(this, this.overlay));
+  }
+  prepareDescription(t) {
+  }
+  releaseDescription() {
+  }
+  shouldCompleteOpen() {
+  }
+  /* c8 ignore next 3 */
+  init() {
+  }
+  /* c8 ignore next 3 */
+  initOverlay() {
+  }
+  abort() {
+    var t;
+    this.releaseDescription(), (t = this.abortController) == null || t.abort();
+  }
+  hostConnected() {
+    this.init();
+  }
+  hostDisconnected() {
+    this.isPersistent || this.abort();
+  }
+}
+class wi extends Vt {
+  constructor() {
+    super(...arguments), this.type = Pt.click, this.preventNextToggle = !1;
+  }
+  handleClick() {
+    this.preventNextToggle || (this.open = !this.open), this.preventNextToggle = !1;
+  }
+  handlePointerdown() {
+    this.preventNextToggle = this.open;
+  }
+  init() {
+    var i;
+    (i = this.abortController) == null || i.abort(), this.abortController = new AbortController();
+    const { signal: t } = this.abortController;
+    this.target.addEventListener("click", () => this.handleClick(), {
+      signal: t
+    }), this.target.addEventListener(
+      "pointerdown",
+      () => this.handlePointerdown(),
+      { signal: t }
+    );
+  }
+}
+const bi = 300;
+class xi extends Vt {
+  constructor() {
+    super(...arguments), this.type = Pt.hover, this.elementIds = [], this.focusedin = !1, this.pointerentered = !1;
+  }
+  handleTargetFocusin() {
+    this.target.matches(":focus-visible") && (this.open = !0, this.focusedin = !0);
+  }
+  handleTargetFocusout() {
+    this.focusedin = !1, !this.pointerentered && (this.open = !1);
+  }
+  handleTargetPointerenter() {
+    var t;
+    this.hoverTimeout && (clearTimeout(this.hoverTimeout), this.hoverTimeout = void 0), !((t = this.overlay) != null && t.disabled) && (this.open = !0, this.pointerentered = !0);
+  }
+  handleTargetPointerleave() {
+    this.doPointerleave();
+  }
+  // set a timeout once the pointer enters and the overlay is shown
+  // give the user time to enter the overlay
+  handleHostPointerenter() {
+    this.hoverTimeout && (clearTimeout(this.hoverTimeout), this.hoverTimeout = void 0);
+  }
+  handleHostPointerleave() {
+    this.doPointerleave();
+  }
+  prepareDescription() {
+    if (this.overlay.elements.length === 0)
+      return;
+    const t = this.target.getRootNode(), i = this.overlay.elements[0].getRootNode(), n = this.overlay.getRootNode();
+    t === n ? this.prepareOverlayRelativeDescription() : t === i && this.prepareContentRelativeDescription();
+  }
+  prepareOverlayRelativeDescription() {
+    const t = At(
+      this.target,
+      "aria-describedby",
+      [this.overlay.id]
+    );
+    this.releaseDescription = () => {
+      t(), this.releaseDescription = J;
+    };
+  }
+  prepareContentRelativeDescription() {
+    const t = [], i = this.overlay.elements.map((o) => (t.push(o.id), o.id || (o.id = `${this.overlay.tagName.toLowerCase()}-helper-${St()}`), o.id));
+    this.elementIds = t;
+    const n = At(
+      this.target,
+      "aria-describedby",
+      i
+    );
+    this.releaseDescription = () => {
+      n(), this.overlay.elements.map((o, s) => {
+        o.id = this.elementIds[s];
+      }), this.releaseDescription = J;
+    };
+  }
+  doPointerleave() {
+    this.pointerentered = !1;
+    const t = this.target;
+    this.focusedin && t.matches(":focus-visible") || (this.hoverTimeout = setTimeout(() => {
+      this.open = !1;
+    }, bi));
+  }
+  init() {
+    var i;
+    (i = this.abortController) == null || i.abort(), this.abortController = new AbortController();
+    const { signal: t } = this.abortController;
+    this.target.addEventListener("focusin", () => this.handleTargetFocusin(), {
+      signal: t
+    }), this.target.addEventListener(
+      "focusout",
+      () => this.handleTargetFocusout(),
+      { signal: t }
+    ), this.target.addEventListener(
+      "pointerenter",
+      () => this.handleTargetPointerenter(),
+      { signal: t }
+    ), this.target.addEventListener(
+      "pointerleave",
+      () => this.handleTargetPointerleave(),
+      { signal: t }
+    ), this.overlay && this.initOverlay();
+  }
+  initOverlay() {
+    if (!this.abortController)
+      return;
+    const { signal: t } = this.abortController;
+    this.overlay.addEventListener(
+      "pointerenter",
+      () => this.handleHostPointerenter(),
+      { signal: t }
+    ), this.overlay.addEventListener(
+      "pointerleave",
+      () => this.handleHostPointerleave(),
+      { signal: t }
+    );
+  }
+}
+const Ei = 300, Pi = {
+  touch: "Double tap and long press for additional options",
+  keyboard: "Press Space or Alt+Down Arrow for additional options",
+  mouse: "Click and hold for additional options"
+};
+class Ci extends Vt {
+  constructor() {
+    super(...arguments), this.type = Pt.longpress, this.longpressState = null, this.releaseDescription = J, this.handlePointerup = () => {
+      var t;
+      clearTimeout(this.timeout), this.target && (this.longpressState = ((t = this.overlay) == null ? void 0 : t.state) === "opening" ? "pressed" : null, document.removeEventListener("pointerup", this.handlePointerup), document.removeEventListener("pointercancel", this.handlePointerup));
+    };
+  }
+  get activelyOpening() {
+    return this.longpressState === "opening" || this.longpressState === "pressed";
+  }
+  handleLongpress() {
+    this.open = !0, this.longpressState = this.longpressState === "potential" ? "opening" : "pressed";
+  }
+  handlePointerdown(t) {
+    !this.target || t.button !== 0 || (this.longpressState = "potential", document.addEventListener("pointerup", this.handlePointerup), document.addEventListener("pointercancel", this.handlePointerup), "holdAffordance" in this.target) || (this.timeout = setTimeout(() => {
+      this.target && this.target.dispatchEvent(
+        new CustomEvent("longpress", {
+          bubbles: !0,
+          composed: !0,
+          detail: {
+            source: "pointer"
+          }
+        })
+      );
+    }, Ei));
+  }
+  handleKeydown(t) {
+    const { code: i, altKey: n } = t;
+    n && i === "ArrowDown" && (t.stopPropagation(), t.stopImmediatePropagation());
+  }
+  handleKeyup(t) {
+    const { code: i, altKey: n } = t;
+    if (i === "Space" || n && i === "ArrowDown") {
+      if (!this.target)
+        return;
+      t.stopPropagation(), this.target.dispatchEvent(
+        new CustomEvent("longpress", {
+          bubbles: !0,
+          composed: !0,
+          detail: {
+            source: "keyboard"
+          }
+        })
+      ), setTimeout(() => {
+        this.longpressState = null;
+      });
+    }
+  }
+  prepareDescription(t) {
+    if (
+      // do not reapply until target is recycled
+      this.releaseDescription !== J || // require "longpress content" to apply relationship
+      this.overlay.elements.length === 0
+    )
+      return;
+    const i = document.createElement("div");
+    i.id = `longpress-describedby-descriptor-${St()}`;
+    const n = be() || xe() ? "touch" : "keyboard";
+    i.textContent = Pi[n], i.slot = "longpress-describedby-descriptor";
+    const o = t.getRootNode(), s = this.overlay.getRootNode();
+    o === s ? this.overlay.append(i) : (i.hidden = !("host" in o), t.after(i));
+    const r = At(
+      t,
+      "aria-describedby",
+      [i.id]
+    );
+    this.releaseDescription = () => {
+      r(), i.remove(), this.releaseDescription = J;
+    };
+  }
+  shouldCompleteOpen() {
+    this.longpressState = this.longpressState === "pressed" ? null : this.longpressState;
+  }
+  init() {
+    var i;
+    (i = this.abortController) == null || i.abort(), this.abortController = new AbortController();
+    const { signal: t } = this.abortController;
+    this.target.addEventListener("longpress", () => this.handleLongpress(), {
+      signal: t
+    }), this.target.addEventListener(
+      "pointerdown",
+      (n) => this.handlePointerdown(n),
+      { signal: t }
+    ), this.prepareDescription(this.target), !this.target.holdAffordance && (this.target.addEventListener(
+      "keydown",
+      (n) => this.handleKeydown(n),
+      { signal: t }
+    ), this.target.addEventListener(
+      "keyup",
+      (n) => this.handleKeyup(n),
+      { signal: t }
+    ));
+  }
+}
+const Oi = {
+  click: wi,
+  longpress: Ci,
+  hover: xi
+};
+var Ai = Object.defineProperty, Ti = Object.getOwnPropertyDescriptor, O = (e, t, i, n) => {
+  for (var o = n > 1 ? void 0 : n ? Ti(t, i) : t, s = e.length - 1, r; s >= 0; s--)
+    (r = e[s]) && (o = (n ? r(t, i, o) : r(o)) || o);
+  return n && o && Ai(t, i, o), o;
+};
+const Ri = "showPopover" in document.createElement("div");
+let ft = Te(rt);
+ft = Ri ? Le(ft) : Re(ft);
+var I;
+const P = (I = class extends ft {
+  constructor() {
+    super(...arguments), this._delayed = !1, this._disabled = !1, this.offset = 0, this._open = !1, this.lastRequestSlottableState = !1, this.receivesFocus = "auto", this._state = "closed", this.triggerElement = null, this.type = "auto", this.wasOpen = !1, this.closeOnFocusOut = (t) => {
+      if (!t.relatedTarget)
+        return;
+      const i = new Event("overlay-relation-query", {
+        bubbles: !0,
+        composed: !0
+      });
+      t.relatedTarget.addEventListener(i.type, (n) => {
+        n.composedPath().includes(this) || (this.open = !1);
+      }), t.relatedTarget.dispatchEvent(i);
+    };
+  }
+  get delayed() {
+    var t;
+    return ((t = this.elements.at(-1)) == null ? void 0 : t.hasAttribute("delayed")) || this._delayed;
+  }
+  set delayed(t) {
+    this._delayed = t;
+  }
+  get disabled() {
+    return this._disabled;
+  }
+  set disabled(t) {
+    var i;
+    this._disabled = t, t ? ((i = this.strategy) == null || i.abort(), this.wasOpen = this.open, this.open = !1) : (this.bindEvents(), this.open = this.open || this.wasOpen, this.wasOpen = !1);
+  }
+  /**
+   * Determines if the overlay has a non-virtual trigger element.
+   *
+   * @returns `true` if the trigger element is not a virtual trigger, otherwise `false`.
+   */
+  get hasNonVirtualTrigger() {
+    return !!this.triggerElement && !(this.triggerElement instanceof wt);
+  }
+  /**
+   * Provides an instance of the `PlacementController` for managing the positioning
+   * of the overlay relative to its trigger element.
+   *
+   * If the `PlacementController` instance does not already exist, it is created and
+   * assigned to the `_placementController` property.
+   *
+   * @protected
+   * @returns The `PlacementController` instance.
+   */
+  get placementController() {
+    return this._placementController || (this._placementController = new yi(this)), this._placementController;
+  }
+  get open() {
+    return this._open;
+  }
+  set open(t) {
+    var i;
+    t && this.disabled || t !== this.open && ((i = this.strategy) != null && i.activelyOpening && !t || (this._open = t, this.open && (I.openCount += 1), this.requestUpdate("open", !this.open), this.open && this.requestSlottable()));
+  }
+  get state() {
+    return this._state;
+  }
+  set state(t) {
+    var n;
+    if (t === this.state)
+      return;
+    const i = this.state;
+    this._state = t, (this.state === "opened" || this.state === "closed") && ((n = this.strategy) == null || n.shouldCompleteOpen()), this.requestUpdate("state", i);
+  }
+  /**
+   * Provides an instance of the `ElementResolutionController` for managing the element
+   * that the overlay should be associated with. If the instance does not already exist,
+   * it is created and assigned to the `_elementResolver` property.
+   *
+   * @protected
+   * @returns The `ElementResolutionController` instance.
+   */
+  get elementResolver() {
+    return this._elementResolver || (this._elementResolver = new ue(this)), this._elementResolver;
+  }
+  /**
+   * Determines if the overlay uses a dialog.
+   * Returns `true` if the overlay type is "modal" or "page".
+   *
+   * @private
+   * @returns `true` if the overlay uses a dialog, otherwise `false`.
+   */
+  get usesDialog() {
+    return this.type === "modal" || this.type === "page";
+  }
+  /**
+   * Determines the value for the popover attribute based on the overlay type.
+   *
+   * @private
+   * @returns The popover value or undefined if not applicable.
+   */
+  get popoverValue() {
+    if ("popover" in this)
+      switch (this.type) {
+        case "modal":
+        case "page":
+          return;
+        case "hint":
+          return "manual";
+        default:
+          return this.type;
+      }
+  }
+  /**
+   * Determines if the overlay requires positioning based on its type and state.
+   *
+   * @protected
+   * @returns True if the overlay requires positioning, otherwise false.
+   */
+  get requiresPositioning() {
+    return !(this.type === "page" || !this.open || !this.triggerElement || !this.placement && this.type !== "hint");
+  }
+  /**
+   * Manages the positioning of the overlay relative to its trigger element.
+   *
+   * This method calculates the necessary parameters for positioning the overlay,
+   * such as offset, placement, and tip padding, and then delegates the actual
+   * positioning to the `PlacementController`.
+   *
+   * @protected
+   * @override
+   */
+  managePosition() {
+    if (!this.requiresPositioning || !this.open)
+      return;
+    const t = this.offset || 0, i = this.triggerElement, n = this.placement || "right", o = this.tipPadding;
+    this.placementController.placeOverlay(this.dialogEl, {
+      offset: t,
+      placement: n,
+      tipPadding: o,
+      trigger: i,
+      type: this.type
+    });
+  }
+  /**
+   * Manages the process of opening the popover.
+   *
+   * This method handles the necessary steps to open the popover, including managing delays,
+   * ensuring the popover is in the DOM, making transitions, and applying focus.
+   *
+   * @protected
+   * @override
+   * @returns A promise that resolves when the popover has been fully opened.
+   */
+  async managePopoverOpen() {
+    super.managePopoverOpen();
+    const t = this.open;
+    if (this.open !== t || (await this.manageDelay(t), this.open !== t) || (await this.ensureOnDOM(t), this.open !== t))
+      return;
+    const i = await this.makeTransition(t);
+    this.open === t && await this.applyFocus(t, i);
+  }
+  /**
+   * Applies focus to the appropriate element after the popover has been opened.
+   *
+   * This method handles the focus management for the overlay, ensuring that the correct
+   * element receives focus based on the overlay's type and state.
+   *
+   * @protected
+   * @override
+   * @param targetOpenState - The target open state of the overlay.
+   * @param focusEl - The element to focus after opening the popover.
+   * @returns A promise that resolves when the focus has been applied.
+   */
+  async applyFocus(t, i) {
+    if (!(this.receivesFocus === "false" || this.type === "hint")) {
+      if (await R(), await R(), t === this.open && !this.open) {
+        this.hasNonVirtualTrigger && this.contains(this.getRootNode().activeElement) && this.triggerElement.focus();
+        return;
+      }
+      i == null || i.focus();
+    }
+  }
+  /**
+   * Returns focus to the trigger element if the overlay is closed.
+   *
+   * This method ensures that focus is returned to the trigger element when the overlay is closed,
+   * unless the overlay is of type "hint" or the focus is already outside the overlay.
+   *
+   * @protected
+   * @override
+   */
+  returnFocus() {
+    var i;
+    if (this.open || this.type === "hint")
+      return;
+    const t = () => {
+      var s, r;
+      const n = [];
+      let o = document.activeElement;
+      for (; (s = o == null ? void 0 : o.shadowRoot) != null && s.activeElement; )
+        o = o.shadowRoot.activeElement;
+      for (; o; ) {
+        const a = o.assignedSlot || o.parentElement || ((r = o.getRootNode()) == null ? void 0 : r.host);
+        a && n.push(a), o = a;
+      }
+      return n;
+    };
+    this.receivesFocus !== "false" && ((i = this.triggerElement) != null && i.focus) && (this.contains(this.getRootNode().activeElement) || t().includes(this) || document.activeElement === document.body) && this.triggerElement.focus();
+  }
+  /**
+   * Manages the process of opening or closing the overlay.
+   *
+   * This method handles the necessary steps to open or close the overlay, including updating the state,
+   * managing the overlay stack, and handling focus events.
+   *
+   * @protected
+   * @param oldOpen - The previous open state of the overlay.
+   * @returns A promise that resolves when the overlay has been fully managed.
+   */
+  async manageOpen(t) {
+    if (!(!this.isConnected && this.open) && (this.hasUpdated || await this.updateComplete, this.open ? (Kt.add(this), this.willPreventClose && (document.addEventListener(
+      "pointerup",
+      () => {
+        this.dialogEl.classList.toggle("not-immediately-closable", !1), this.willPreventClose = !1;
+      },
+      { once: !0 }
+    ), this.dialogEl.classList.toggle("not-immediately-closable", !0))) : (t && this.dispose(), Kt.remove(this)), this.open && this.state !== "opened" ? this.state = "opening" : !this.open && this.state !== "closed" && (this.state = "closing"), this.usesDialog ? this.manageDialogOpen() : this.managePopoverOpen(), this.type === "auto")) {
+      const i = this.getRootNode();
+      this.open ? i.addEventListener("focusout", this.closeOnFocusOut, {
+        capture: !0
+      }) : i.removeEventListener("focusout", this.closeOnFocusOut, {
+        capture: !0
+      });
+    }
+  }
+  /**
+   * Binds event handling strategies to the overlay based on the specified trigger interaction.
+   *
+   * This method sets up the appropriate event handling strategy for the overlay, ensuring that
+   * it responds correctly to user interactions such as clicks, hovers, or long presses.
+   *
+   * @protected
+   */
+  bindEvents() {
+    var t;
+    (t = this.strategy) == null || t.abort(), this.strategy = void 0, this.hasNonVirtualTrigger && this.triggerInteraction && (this.strategy = new Oi[this.triggerInteraction](
+      this.triggerElement,
+      {
+        overlay: this
+      }
+    ));
+  }
+  /**
+   * Handles the `beforetoggle` event to manage the overlay's state.
+   *
+   * This method checks the new state of the event and calls `handleBrowserClose`
+   * if the new state is not 'open'.
+   *
+   * @protected
+   * @param event - The `beforetoggle` event with the new state.
+   */
+  handleBeforetoggle(t) {
+    t.newState !== "open" && this.handleBrowserClose(t);
+  }
+  /**
+   * Handles the browser's close event to manage the overlay's state.
+   *
+   * This method stops the propagation of the event and closes the overlay if it is not
+   * actively opening. If the overlay is actively opening, it calls `manuallyKeepOpen`.
+   *
+   * @protected
+   * @param event - The browser's close event.
+   */
+  handleBrowserClose(t) {
+    var i;
+    if (t.stopPropagation(), !((i = this.strategy) != null && i.activelyOpening)) {
+      this.open = !1;
+      return;
+    }
+    this.manuallyKeepOpen();
+  }
+  /**
+   * Manually keeps the overlay open.
+   *
+   * This method sets the overlay to open, allows placement updates, and manages the open state.
+   *
+   * @public
+   * @override
+   */
+  manuallyKeepOpen() {
+    this.open = !0, this.placementController.allowPlacementUpdate = !0, this.manageOpen(!1);
+  }
+  /**
+   * Handles the `slotchange` event to manage the overlay's state.
+   *
+   * This method checks if there are any elements in the slot. If there are no elements,
+   * it releases the description from the strategy. If there are elements and the trigger
+   * is non-virtual, it prepares the description for the trigger element.
+   *
+   * @protected
+   */
+  handleSlotchange() {
+    var t, i;
+    this.elements.length === 0 ? (t = this.strategy) == null || t.releaseDescription() : this.hasNonVirtualTrigger && ((i = this.strategy) == null || i.prepareDescription(this.triggerElement));
+  }
+  /**
+   * Determines whether the overlay should prevent closing.
+   *
+   * This method checks the `willPreventClose` flag and resets it to `false`.
+   * It returns the value of the `willPreventClose` flag.
+   *
+   * @public
+   * @returns `true` if the overlay should prevent closing, otherwise `false`.
+   */
+  shouldPreventClose() {
+    const t = this.willPreventClose;
+    return this.willPreventClose = !1, t;
+  }
+  /**
+   * Requests slottable content for the overlay.
+   *
+   * This method dispatches a `SlottableRequestEvent` to request or remove slottable content
+   * based on the current open state of the overlay. It ensures that the same state is not
+   * dispatched twice in a row.
+   *
+   * @protected
+   * @override
+   */
+  requestSlottable() {
+    this.lastRequestSlottableState !== this.open && (this.open || document.body.offsetHeight, this.dispatchEvent(
+      new ye(
+        "overlay-content",
+        this.open ? {} : we
+      )
+    ), this.lastRequestSlottableState = this.open);
+  }
+  /**
+   * Lifecycle method called before the component updates.
+   *
+   * This method handles various tasks before the component updates, such as setting an ID,
+   * managing the open state, resolving the trigger element, and binding events.
+   *
+   * @override
+   * @param changes - The properties that have changed.
+   */
+  willUpdate(t) {
+    var n;
+    if (this.hasAttribute("id") || this.setAttribute("id", `${this.tagName.toLowerCase()}-${St()}`), t.has("open") && (this.hasUpdated || this.open) && this.manageOpen(t.get("open")), t.has("trigger")) {
+      const [o, s] = ((n = this.trigger) == null ? void 0 : n.split("@")) || [];
+      this.elementResolver.selector = o ? `#${o}` : "", this.triggerInteraction = s;
+    }
+    let i = !1;
+    t.has(pe) && (i = this.triggerElement, this.triggerElement = this.elementResolver.element), t.has("triggerElement") && (i = t.get("triggerElement")), i !== !1 && this.bindEvents();
+  }
+  /**
+   * Lifecycle method called after the component updates.
+   *
+   * This method handles various tasks after the component updates, such as updating the placement
+   * attribute, resetting the overlay position, and clearing the overlay position based on the state.
+   *
+   * @override
+   * @param changes - The properties that have changed.
+   */
+  updated(t) {
+    super.updated(t), t.has("placement") && (this.placement ? this.dialogEl.setAttribute("actual-placement", this.placement) : this.dialogEl.removeAttribute("actual-placement"), this.open && t.get("placement") !== void 0 && this.placementController.resetOverlayPosition()), t.has("state") && this.state === "closed" && t.get("state") !== void 0 && this.placementController.clearOverlayPosition();
+  }
+  /**
+   * Renders the content of the overlay.
+   *
+   * This method returns a template result containing a slot element. The slot element
+   * listens for the `slotchange` event to manage the overlay's state.
+   *
+   * @protected
+   * @returns The template result containing the slot element.
+   */
+  renderContent() {
+    return ht` <slot @slotchange=${this.handleSlotchange}></slot> `;
+  }
+  /**
+   * Generates a style map for the dialog element.
+   *
+   * This method returns an object containing CSS custom properties for the dialog element.
+   * The `--luzmo-overlay-open-count` custom property is set to the current open count of overlays.
+   *
+   * @private
+   * @returns The style map for the dialog element.
+   */
+  get dialogStyleMap() {
+    return {
+      "--luzmo-overlay-open-count": I.openCount.toString()
+    };
+  }
+  /**
+   * Renders the dialog element for the overlay.
+   *
+   * This method returns a template result containing a dialog element. The dialog element
+   * includes various attributes and event listeners to manage the overlay's state and behavior.
+   *
+   * @protected
+   * @returns The template result containing the dialog element.
+   */
+  renderDialog() {
+    return ht`
+      <dialog
+        class="dialog"
+        part="dialog"
+        placement=${Ct(
+      this.requiresPositioning ? this.placement || "right" : void 0
+    )}
+        style=${Ut(this.dialogStyleMap)}
+        @close=${this.handleBrowserClose}
+        @cancel=${this.handleBrowserClose}
+        @beforetoggle=${this.handleBeforetoggle}
+        ?is-visible=${this.state !== "closed"}
+      >
+        ${this.renderContent()}
+      </dialog>
+    `;
+  }
+  /**
+   * Renders the popover element for the overlay.
+   *
+   * This method returns a template result containing a div element styled as a popover.
+   * The popover element includes various attributes and event listeners to manage the overlay's state and behavior.
+   *
+   * @protected
+   * @returns The template result containing the popover element.
+   */
+  renderPopover() {
+    return ht`
+      <div
+        class="dialog"
+        part="dialog"
+        placement=${Ct(
+      this.requiresPositioning ? this.placement || "right" : void 0
+    )}
+        popover=${Ct(this.popoverValue)}
+        style=${Ut(this.dialogStyleMap)}
+        @beforetoggle=${this.handleBeforetoggle}
+        @close=${this.handleBrowserClose}
+        ?is-visible=${this.state !== "closed"}
+      >
+        ${this.renderContent()}
+      </div>
+    `;
+  }
+  /**
+   * Renders the overlay component.
+   *
+   * This method returns a template result containing either a dialog or popover element
+   * based on the overlay type. It also includes a slot for longpress descriptors.
+   *
+   * @override
+   * @returns The template result containing the overlay content.
+   */
+  render() {
+    const t = this.type === "modal" || this.type === "page";
+    return ht`
+      ${t ? this.renderDialog() : this.renderPopover()}
+      <slot name="longpress-describedby-descriptor"></slot>
+    `;
+  }
+  /**
+   * Lifecycle method called when the component is added to the DOM.
+   *
+   * This method sets up event listeners and binds events if the component has already updated.
+   *
+   * @override
+   */
+  connectedCallback() {
+    super.connectedCallback(), this.addEventListener("close", () => {
+      this.open = !1;
+    }), this.hasUpdated && this.bindEvents();
+  }
+  /**
+   * Lifecycle method called when the component is removed from the DOM.
+   *
+   * This method releases the description from the strategy and updates the 'open' property.
+   *
+   * @override
+   */
+  disconnectedCallback() {
+    var t;
+    (t = this.strategy) == null || t.releaseDescription(), this.open = !1, super.disconnectedCallback();
+  }
+}, I.styles = [fe(Fe)], I.openCount = 1, I);
+O([
+  z({ type: Boolean })
+], P.prototype, "delayed", 1);
+O([
+  te(".dialog")
+], P.prototype, "dialogEl", 2);
+O([
+  z({ type: Boolean })
+], P.prototype, "disabled", 1);
+O([
+  ve({
+    flatten: !0,
+    selector: ':not([slot="longpress-describedby-descriptor"], slot)'
+  })
+], P.prototype, "elements", 2);
+O([
+  z({ type: Number })
+], P.prototype, "offset", 2);
+O([
+  z({ type: Boolean, reflect: !0 })
+], P.prototype, "open", 1);
+O([
+  z()
+], P.prototype, "placement", 2);
+O([
+  z({ attribute: "receives-focus" })
+], P.prototype, "receivesFocus", 2);
+O([
+  te("slot")
+], P.prototype, "slotEl", 2);
+O([
+  ge()
+], P.prototype, "state", 1);
+O([
+  z({ type: Number, attribute: "tip-padding" })
+], P.prototype, "tipPadding", 2);
+O([
+  z()
+], P.prototype, "trigger", 2);
+O([
+  z({ attribute: !1 })
+], P.prototype, "triggerElement", 2);
+O([
+  z({ attribute: !1 })
+], P.prototype, "triggerInteraction", 2);
+O([
+  z()
+], P.prototype, "type", 2);
+let Di = P;
+const Lt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Overlay: Di
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  rt as A,
+  Pt as I,
+  Di as O,
+  wt as V,
+  Lt as o,
+  Oi as s
+};