@luzmo/analytics-components-kit 1.0.1-alpha.2 → 1.0.1-alpha.4

package/lib/index-B9h2L_hV.js

@@ -0,0 +1,3048 @@
+/*! * A kit of modern Luzmo Web Components for analytics in your web application.
+ * 
+ * Copyright © 2024 Luzmo
+ * All rights reserved.
+ * Luzmo web components (“Luzmo Web Components”)
+ * must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account
+ * to use the Luzmo Web Components. 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 { e as re, i as Oe, t as Ae, c as Lt, a as _t, E as Te, b as Re, r as ut } from "./directive-helpers-eY1rHtyn.js";
+import { b as De, T as Se, L as le, r as ae, x as k, o as St, n as x, e as pt, E as ce, B as he } from "./if-defined-BbzmSG-O.js";
+import { v as ft } from "./index-DdtjeKYI.js";
+import { i as ke, b as Le, f as $e } from "./async-directive-SCUUQ3Mh.js";
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+function Fe(e) {
+  return (t, n) => {
+    const { slot: i, selector: o } = e ?? {}, s = "slot" + (i ? `[name=${i}]` : ":not([name])");
+    return De(t, n, { get() {
+      var a;
+      const r = (a = this.renderRoot) == null ? void 0 : a.querySelector(s), l = (r == null ? void 0 : r.assignedElements(e)) ?? [];
+      return o === void 0 ? l : l.filter((c) => c.matches(o));
+    } });
+  };
+}
+class ze extends Event {
+  constructor(t, n, i) {
+    super("slottable-request", {
+      bubbles: !1,
+      cancelable: !0,
+      composed: !1
+    }), this.name = t, this.data = n, this.slotName = i === void 0 ? t : `${t}.${i}`;
+  }
+}
+const Nt = Symbol("remove-slottable-request");
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+const de = "important", _e = " !" + de, Jt = re(class extends Oe {
+  constructor(e) {
+    var t;
+    if (super(e), e.type !== Ae.ATTRIBUTE || e.name !== "style" || ((t = e.strings) == null ? void 0 : t.length) > 2) throw Error("The `styleMap` directive must be used in the `style` attribute and must be the only part in the attribute.");
+  }
+  render(e) {
+    return Object.keys(e).reduce((t, n) => {
+      const i = e[n];
+      return i == null ? t : t + `${n = n.includes("-") ? n : n.replace(/(?:^(webkit|moz|ms|o)|)(?=[A-Z])/g, "-$&").toLowerCase()}:${i};`;
+    }, "");
+  }
+  update(e, [t]) {
+    const { style: n } = e.element;
+    if (this.ft === void 0) return this.ft = new Set(Object.keys(t)), this.render(t);
+    for (const i of this.ft) t[i] == null && (this.ft.delete(i), i.includes("-") ? n.removeProperty(i) : n[i] = null);
+    for (const i in t) {
+      const o = t[i];
+      if (o != null) {
+        this.ft.add(i);
+        const s = typeof o == "string" && o.endsWith(_e);
+        i.includes("-") || s ? n.setProperty(i, s ? o.slice(0, -11) : o, s ? de : "") : n[i] = o;
+      }
+    }
+    return Se;
+  }
+});
+function Ne(e, t, n = []) {
+  for (const [i, o] of t.entries()) {
+    const s = e[i], r = s.parentElement || s.getRootNode();
+    n[i] && n[i](o), r && r !== s && s.replaceWith(o), delete e[i];
+  }
+  return t;
+}
+const Be = (e, t, {
+  position: n,
+  prepareCallback: i
+} = { position: "beforeend" }) => {
+  let { length: o } = e;
+  if (o === 0)
+    return () => e;
+  let s = 1, r = 0;
+  (n === "afterbegin" || n === "afterend") && (s = -1, r = o - 1);
+  const l = new Array(o), a = new Array(o), c = document.createComment(
+    "placeholder for reparented element"
+  );
+  do {
+    const h = e[r];
+    i && (a[r] = i(h)), l[r] = c.cloneNode();
+    const d = h.parentElement || h.getRootNode();
+    d && d !== h && d.replaceChild(l[r], h), t.insertAdjacentElement(n, h), r += s;
+  } while (--o > 0);
+  return function() {
+    return Ne(
+      l,
+      e,
+      a
+    );
+  };
+}, Me = 1e3, He = 1e3;
+class qe {
+  constructor(t = {}) {
+    this.warmUpDelay = Me, this.coolDownDelay = He, 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((n) => {
+        this.resolve = n, 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 xt = new qe(), tt = () => {
+}, Bt = (e, t, n) => {
+  const i = new AbortController(), o = /* @__PURE__ */ new Map(), s = () => {
+    i.abort(), n();
+  };
+  let r, l;
+  const a = requestAnimationFrame(() => {
+    r = requestAnimationFrame(() => {
+      l = requestAnimationFrame(() => {
+        s();
+      });
+    });
+  }), c = (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());
+  }, h = (d) => {
+    d.target === e && (o.has(d.propertyName) || o.set(d.propertyName, 0), o.set(
+      d.propertyName,
+      o.get(d.propertyName) + 1
+    ), cancelAnimationFrame(a), cancelAnimationFrame(r), cancelAnimationFrame(l));
+  };
+  e.addEventListener("transitionrun", h, {
+    signal: i.signal
+  }), e.addEventListener("transitionend", c, {
+    signal: i.signal
+  }), e.addEventListener("transitioncancel", c, {
+    signal: i.signal
+  }), t();
+};
+function L() {
+  return new Promise((e) => requestAnimationFrame(() => e()));
+}
+class rt extends le {
+  constructor() {
+    super(...arguments), this.dispose = tt, this.offset = 0, this.willPreventClose = !1;
+  }
+  applyFocus(t, n) {
+  }
+  /* 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, n, i, o) {
+    await Promise.resolve().then(() => st);
+    const s = arguments.length === 2, r = i || t, l = new this();
+    let a = !1;
+    const c = Be([r], l, {
+      position: "beforeend",
+      prepareCallback: (f) => {
+        const u = f.slot;
+        return f.removeAttribute("slot"), () => {
+          f.slot = u;
+        };
+      }
+    });
+    if (l.dispose = () => {
+      l.addEventListener("luzmo-closed", () => {
+        a || (c(), a = !0), requestAnimationFrame(() => {
+          l.remove();
+        });
+      }), l.open = !1, l.dispose = tt;
+    }, !s && r && o) {
+      const f = t, u = n, p = o;
+      return rt.applyOptions(l, {
+        ...p,
+        delayed: p.delayed || r.hasAttribute("delayed"),
+        trigger: p.virtualTrigger || f,
+        type: u === "modal" ? "modal" : u === "hover" ? "hint" : "auto"
+      }), f.after(l), await l.updateComplete, l.open = !0, l.dispose;
+    }
+    const d = n;
+    return l.append(r), rt.applyOptions(l, {
+      ...d,
+      delayed: d.delayed || r.hasAttribute("delayed")
+    }), l.updateComplete.then(() => {
+      l.open = !0;
+    }), l;
+  }
+  static applyOptions(t, n) {
+    t.delayed = !!n.delayed, t.receivesFocus = n.receivesFocus ?? "auto", t.triggerElement = n.trigger || null, t.type = n.type || "modal", t.offset = n.offset ?? 0, t.placement = n.placement, t.willPreventClose = !!n.notImmediatelyClosable;
+  }
+}
+const Mt = (e) => e.querySelector(
+  ft
+), Ht = (e) => e.assignedElements().find(
+  (n) => n.matches(ft)
+);
+class qt extends Event {
+  constructor() {
+    super("beforetoggle", {
+      bubbles: !1,
+      composed: !1
+    }), this.currentState = "open", this.newState = "closed";
+  }
+}
+class It extends Event {
+  constructor() {
+    super("beforetoggle", {
+      bubbles: !1,
+      composed: !1
+    }), this.currentState = "closed", this.newState = "open";
+  }
+}
+class z extends Event {
+  constructor(t, n, {
+    publish: i,
+    interaction: o,
+    reason: s
+  }) {
+    super(t, {
+      bubbles: i,
+      composed: i
+    }), this.overlay = n, this.detail = {
+      interaction: o,
+      reason: s
+    };
+  }
+}
+class mt {
+  constructor(t, n) {
+    this.x = 0, this.y = 0, this.x = t, this.y = n;
+  }
+  updateBoundingClientRect(t, n) {
+    this.x = t, this.y = n, 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 Ie(e) {
+  class t extends e {
+    async manageDialogOpen() {
+      const i = this.open;
+      if (await L(), await this.managePosition(), this.open !== i)
+        return;
+      const o = await this.dialogMakeTransition(i);
+      this.open === i && await this.dialogApplyFocus(i, o);
+    }
+    dialogMakeTransition(i) {
+      let o = null;
+      const s = (l, a) => () => {
+        if (l.open = i, !i) {
+          const h = () => {
+            l.removeEventListener("close", h);
+          };
+          l.addEventListener("close", h);
+        }
+        if (a > 0)
+          return;
+        const c = i ? It : qt;
+        this.dispatchEvent(new c()), i && (l.matches(ft) && (o = l), o = o || Mt(l), o || l.querySelectorAll("slot").forEach((d) => {
+          o || (o = Ht(d));
+        }), !(!this.isConnected || this.dialogEl.open) && this.dialogEl.showModal());
+      }, r = (l, a) => () => {
+        if (this.open !== i)
+          return;
+        const c = i ? "luzmo-opened" : "luzmo-closed";
+        if (a > 0) {
+          l.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          );
+          return;
+        }
+        if (!this.isConnected || i !== this.open)
+          return;
+        const h = async () => {
+          const d = this.triggerElement instanceof mt;
+          this.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: d
+            })
+          ), l.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          ), this.triggerElement && !d && this.triggerElement.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: !0
+            })
+          ), this.state = i ? "opened" : "closed", this.returnFocus(), await L(), await L(), i === this.open && i === !1 && this.requestSlottable();
+        };
+        !i && this.dialogEl.open ? (this.dialogEl.addEventListener(
+          "close",
+          () => {
+            h();
+          },
+          { once: !0 }
+        ), this.dialogEl.close()) : h();
+      };
+      return this.elements.forEach((l, a) => {
+        Bt(l, s(l, a), r(l, a));
+      }), o;
+    }
+    dialogApplyFocus(i, o) {
+      this.applyFocus(i, o);
+    }
+  }
+  return t;
+}
+function We(e) {
+  class t extends e {
+    async managePopoverOpen() {
+      await this.managePosition();
+    }
+    async manageDelay(i) {
+      if (i === !1 || i !== this.open) {
+        xt.close(this);
+        return;
+      }
+      this.delayed && await xt.openTimer(this) && (this.open = !i);
+    }
+    ensureOnDOM(i) {
+      document.body.offsetHeight;
+    }
+    makeTransition(i) {
+      if (this.open !== i)
+        return null;
+      let o = null;
+      const s = (l, a) => () => {
+        if (i !== this.open)
+          return;
+        if (l.open = i, a === 0) {
+          const h = i ? It : qt;
+          this.dispatchEvent(new h());
+        }
+        if (i !== !0 || (l.matches(ft) && (o = l), o = o || Mt(l), o))
+          return;
+        l.querySelectorAll("slot").forEach((h) => {
+          o || (o = Ht(h));
+        });
+      }, r = (l, a) => async () => {
+        if (this.open !== i)
+          return;
+        const c = i ? "luzmo-opened" : "luzmo-closed";
+        if (l.dispatchEvent(
+          new z(c, this, {
+            interaction: this.type
+          })
+        ), a > 0)
+          return;
+        const h = this.triggerElement instanceof mt;
+        this.dispatchEvent(
+          new z(c, this, {
+            interaction: this.type,
+            publish: h
+          })
+        ), this.triggerElement && !h && this.triggerElement.dispatchEvent(
+          new z(c, this, {
+            interaction: this.type,
+            publish: !0
+          })
+        ), this.state = i ? "opened" : "closed", this.returnFocus(), await L(), await L(), i === this.open && i === !1 && this.requestSlottable();
+      };
+      return this.elements.forEach((l, a) => {
+        Bt(l, s(l, a), r(l, a));
+      }), o;
+    }
+  }
+  return t;
+}
+const Ve = CSS.supports("(overlay: auto)");
+function Qt(e) {
+  let t = !1;
+  try {
+    t = e.matches(":popover-open");
+  } catch {
+  }
+  let n = !1;
+  try {
+    n = e.matches(":open");
+  } catch {
+  }
+  return t || n;
+}
+function Ue(e) {
+  class t extends e {
+    async manageDelay(i) {
+      if (i === !1 || i !== this.open) {
+        xt.close(this);
+        return;
+      }
+      this.delayed && await xt.openTimer(this) && (this.open = !i);
+    }
+    /**
+     * 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(i) {
+      if (i && this.open !== i)
+        return;
+      const o = async ({
+        newState: s
+      } = {}) => {
+        s !== "open" && await this.placementController.resetOverlayPosition();
+      };
+      if (!Qt(this.dialogEl)) {
+        o();
+        return;
+      }
+      this.dialogEl.addEventListener("toggle", o, {
+        once: !0
+      });
+    }
+    shouldShowPopover(i) {
+      let o = !1;
+      try {
+        o = this.dialogEl.matches(":popover-open");
+      } catch {
+      }
+      let s = !1;
+      try {
+        s = this.dialogEl.matches(":open");
+      } catch {
+      }
+      i && this.open === i && !o && !s && this.isConnected && (this.dialogEl.showPopover(), this.managePosition());
+    }
+    async ensureOnDOM(i) {
+      await L(), Ve || await this.shouldHidePopover(i), this.shouldShowPopover(i), await L();
+    }
+    makeTransition(i) {
+      if (this.open !== i)
+        return null;
+      let o = null;
+      const s = (l, a) => () => {
+        if (l.open = i, a === 0) {
+          const h = i ? It : qt;
+          this.dispatchEvent(new h());
+        }
+        if (!i || (l.matches(ft) && (o = l), o = o || Mt(l), o))
+          return;
+        l.querySelectorAll("slot").forEach((h) => {
+          o || (o = Ht(h));
+        });
+      }, r = (l, a) => () => {
+        if (this.open !== i)
+          return;
+        const c = i ? "luzmo-opened" : "luzmo-closed";
+        if (a > 0) {
+          l.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          );
+          return;
+        }
+        const h = async () => {
+          if (this.open !== i)
+            return;
+          await L();
+          const f = this.triggerElement instanceof mt;
+          this.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: f
+            })
+          ), l.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: !1
+            })
+          ), this.triggerElement && !f && this.triggerElement.dispatchEvent(
+            new z(c, this, {
+              interaction: this.type,
+              publish: !0
+            })
+          ), this.state = i ? "opened" : "closed", this.returnFocus(), await L(), await L(), i === this.open && i === !1 && this.requestSlottable();
+        };
+        if (this.open !== i)
+          return;
+        const d = Qt(this.dialogEl);
+        i !== !0 && d && this.isConnected ? (this.dialogEl.addEventListener(
+          "beforetoggle",
+          () => {
+            h();
+          },
+          { once: !0 }
+        ), this.dialogEl.hidePopover()) : h();
+      };
+      return this.elements.forEach((l, a) => {
+        Bt(l, s(l, a), r(l, a));
+      }), o;
+    }
+  }
+  return t;
+}
+const je = "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 n = this.lastOverlay;
+      this.lastOverlay = void 0;
+      const i = this.stack.length - 1, o = this.stack.filter((s, r) => !t.find(
+        (a) => (
+          // The Overlay is in the stack
+          a === s || a === (s == null ? void 0 : s.triggerElement) && (s == null ? void 0 : s.type) === "hint" || r === i && s !== n && s.triggerInteraction === "longpress"
+        )
+      ) && !s.shouldPreventClose() && s.type !== "manual" && !(s.type === "modal" && n !== 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: n, newState: i } = t;
+      i !== "open" && this.closeOverlay(n);
+    }, this.handleKeydown = (t) => {
+      if (t.code !== "Escape" || this.stack.length === 0)
+        return;
+      const n = this.stack.at(-1);
+      if ((n == null ? void 0 : n.type) === "page") {
+        t.preventDefault();
+        return;
+      }
+      je || (n == null ? void 0 : n.type) !== "manual" && n && this.closeOverlay(n);
+    }, 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 n = this.stack.indexOf(t);
+    n !== -1 && this.stack.splice(n, 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(
+      (n) => n.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 n = this.stack.indexOf(t);
+      n !== -1 && (this.stack.splice(n, 1), this.stack.push(t));
+      return;
+    }
+    if (t.type === "auto" || t.type === "modal" || t.type === "page") {
+      const n = "luzmo-overlay-query-path", i = new Event(n, {
+        composed: !0,
+        bubbles: !0
+      });
+      t.addEventListener(
+        n,
+        (o) => {
+          const s = o.composedPath();
+          this.stack.forEach((r) => {
+            !s.find((a) => a === r) && r.type !== "manual" && r.type !== "modal" && this.closeOverlay(r);
+          });
+        },
+        { once: !0 }
+      ), t.dispatchEvent(i);
+    } else if (t.type === "hint") {
+      if (this.stack.some((i) => i.type !== "manual" && i.triggerElement && i.triggerElement === t.triggerElement)) {
+        t.open = !1;
+        return;
+      }
+      this.stack.forEach((i) => {
+        i.type === "hint" && this.closeOverlay(i);
+      });
+    }
+    requestAnimationFrame(() => {
+      this.stack.push(t), t.addEventListener("beforetoggle", this.handleBeforetoggle, {
+        once: !0
+      });
+    });
+  }
+  remove(t) {
+    this.closeOverlay(t);
+  }
+}
+const Zt = new Ke(), Ye = ':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))}}', J = Math.min, D = Math.max, Ct = Math.round, yt = Math.floor, q = (e) => ({
+  x: e,
+  y: e
+}), Ge = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Xe = {
+  start: "end",
+  end: "start"
+};
+function $t(e, t, n) {
+  return D(e, J(t, n));
+}
+function at(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Q(e) {
+  return e.split("-")[0];
+}
+function ct(e) {
+  return e.split("-")[1];
+}
+function ue(e) {
+  return e === "x" ? "y" : "x";
+}
+function Wt(e) {
+  return e === "y" ? "height" : "width";
+}
+function et(e) {
+  return ["top", "bottom"].includes(Q(e)) ? "y" : "x";
+}
+function Vt(e) {
+  return ue(et(e));
+}
+function Je(e, t, n) {
+  n === void 0 && (n = !1);
+  const i = ct(e), o = Vt(e), s = Wt(o);
+  let r = o === "x" ? i === (n ? "end" : "start") ? "right" : "left" : i === "start" ? "bottom" : "top";
+  return t.reference[s] > t.floating[s] && (r = Pt(r)), [r, Pt(r)];
+}
+function Qe(e) {
+  const t = Pt(e);
+  return [Ft(e), t, Ft(t)];
+}
+function Ft(e) {
+  return e.replace(/start|end/g, (t) => Xe[t]);
+}
+function Ze(e, t, n) {
+  const i = ["left", "right"], o = ["right", "left"], s = ["top", "bottom"], r = ["bottom", "top"];
+  switch (e) {
+    case "top":
+    case "bottom":
+      return n ? t ? o : i : t ? i : o;
+    case "left":
+    case "right":
+      return t ? s : r;
+    default:
+      return [];
+  }
+}
+function tn(e, t, n, i) {
+  const o = ct(e);
+  let s = Ze(Q(e), n === "start", i);
+  return o && (s = s.map((r) => r + "-" + o), t && (s = s.concat(s.map(Ft)))), s;
+}
+function Pt(e) {
+  return e.replace(/left|right|bottom|top/g, (t) => Ge[t]);
+}
+function en(e) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...e
+  };
+}
+function pe(e) {
+  return typeof e != "number" ? en(e) : {
+    top: e,
+    right: e,
+    bottom: e,
+    left: e
+  };
+}
+function Ot(e) {
+  const {
+    x: t,
+    y: n,
+    width: i,
+    height: o
+  } = e;
+  return {
+    width: i,
+    height: o,
+    top: n,
+    left: t,
+    right: t + i,
+    bottom: n + o,
+    x: t,
+    y: n
+  };
+}
+function te(e, t, n) {
+  let {
+    reference: i,
+    floating: o
+  } = e;
+  const s = et(t), r = Vt(t), l = Wt(r), a = Q(t), c = s === "y", h = i.x + i.width / 2 - o.width / 2, d = i.y + i.height / 2 - o.height / 2, f = i[l] / 2 - o[l] / 2;
+  let u;
+  switch (a) {
+    case "top":
+      u = {
+        x: h,
+        y: i.y - o.height
+      };
+      break;
+    case "bottom":
+      u = {
+        x: h,
+        y: i.y + i.height
+      };
+      break;
+    case "right":
+      u = {
+        x: i.x + i.width,
+        y: d
+      };
+      break;
+    case "left":
+      u = {
+        x: i.x - o.width,
+        y: d
+      };
+      break;
+    default:
+      u = {
+        x: i.x,
+        y: i.y
+      };
+  }
+  switch (ct(t)) {
+    case "start":
+      u[r] -= f * (n && c ? -1 : 1);
+      break;
+    case "end":
+      u[r] += f * (n && c ? -1 : 1);
+      break;
+  }
+  return u;
+}
+const nn = async (e, t, n) => {
+  const {
+    placement: i = "bottom",
+    strategy: o = "absolute",
+    middleware: s = [],
+    platform: r
+  } = n, l = s.filter(Boolean), a = await (r.isRTL == null ? void 0 : r.isRTL(t));
+  let c = await r.getElementRects({
+    reference: e,
+    floating: t,
+    strategy: o
+  }), {
+    x: h,
+    y: d
+  } = te(c, i, a), f = i, u = {}, p = 0;
+  for (let m = 0; m < l.length; m++) {
+    const {
+      name: v,
+      fn: g
+    } = l[m], {
+      x: y,
+      y: b,
+      data: E,
+      reset: w
+    } = await g({
+      x: h,
+      y: d,
+      initialPlacement: i,
+      placement: f,
+      strategy: o,
+      middlewareData: u,
+      rects: c,
+      platform: r,
+      elements: {
+        reference: e,
+        floating: t
+      }
+    });
+    h = y ?? h, d = b ?? d, u = {
+      ...u,
+      [v]: {
+        ...u[v],
+        ...E
+      }
+    }, w && p <= 50 && (p++, typeof w == "object" && (w.placement && (f = w.placement), w.rects && (c = w.rects === !0 ? await r.getElementRects({
+      reference: e,
+      floating: t,
+      strategy: o
+    }) : w.rects), {
+      x: h,
+      y: d
+    } = te(c, f, a)), m = -1);
+  }
+  return {
+    x: h,
+    y: d,
+    placement: f,
+    strategy: o,
+    middlewareData: u
+  };
+};
+async function Ut(e, t) {
+  var n;
+  t === void 0 && (t = {});
+  const {
+    x: i,
+    y: o,
+    platform: s,
+    rects: r,
+    elements: l,
+    strategy: a
+  } = e, {
+    boundary: c = "clippingAncestors",
+    rootBoundary: h = "viewport",
+    elementContext: d = "floating",
+    altBoundary: f = !1,
+    padding: u = 0
+  } = at(t, e), p = pe(u), v = l[f ? d === "floating" ? "reference" : "floating" : d], g = Ot(await s.getClippingRect({
+    element: (n = await (s.isElement == null ? void 0 : s.isElement(v))) == null || n ? v : v.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(l.floating)),
+    boundary: c,
+    rootBoundary: h,
+    strategy: a
+  })), y = d === "floating" ? {
+    x: i,
+    y: o,
+    width: r.floating.width,
+    height: r.floating.height
+  } : r.reference, b = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(l.floating)), E = await (s.isElement == null ? void 0 : s.isElement(b)) ? await (s.getScale == null ? void 0 : s.getScale(b)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, w = Ot(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: y,
+    offsetParent: b,
+    strategy: a
+  }) : y);
+  return {
+    top: (g.top - w.top + p.top) / E.y,
+    bottom: (w.bottom - g.bottom + p.bottom) / E.y,
+    left: (g.left - w.left + p.left) / E.x,
+    right: (w.right - g.right + p.right) / E.x
+  };
+}
+const on = (e) => ({
+  name: "arrow",
+  options: e,
+  async fn(t) {
+    const {
+      x: n,
+      y: i,
+      placement: o,
+      rects: s,
+      platform: r,
+      elements: l,
+      middlewareData: a
+    } = t, {
+      element: c,
+      padding: h = 0
+    } = at(e, t) || {};
+    if (c == null)
+      return {};
+    const d = pe(h), f = {
+      x: n,
+      y: i
+    }, u = Vt(o), p = Wt(u), m = await r.getDimensions(c), v = u === "y", g = v ? "top" : "left", y = v ? "bottom" : "right", b = v ? "clientHeight" : "clientWidth", E = s.reference[p] + s.reference[u] - f[u] - s.floating[p], w = f[u] - s.reference[u], $ = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(c));
+    let C = $ ? $[b] : 0;
+    (!C || !await (r.isElement == null ? void 0 : r.isElement($))) && (C = l.floating[b] || s.floating[p]);
+    const V = E / 2 - w / 2, B = C / 2 - m[p] / 2 - 1, F = J(d[g], B), K = J(d[y], B), M = F, Y = C - m[p] - K, A = C / 2 - m[p] / 2 + V, it = $t(M, A, Y), U = !a.arrow && ct(o) != null && A !== it && s.reference[p] / 2 - (A < M ? F : K) - m[p] / 2 < 0, H = U ? A < M ? A - M : A - Y : 0;
+    return {
+      [u]: f[u] + H,
+      data: {
+        [u]: it,
+        centerOffset: A - it - H,
+        ...U && {
+          alignmentOffset: H
+        }
+      },
+      reset: U
+    };
+  }
+}), sn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "flip",
+    options: e,
+    async fn(t) {
+      var n, i;
+      const {
+        placement: o,
+        middlewareData: s,
+        rects: r,
+        initialPlacement: l,
+        platform: a,
+        elements: c
+      } = t, {
+        mainAxis: h = !0,
+        crossAxis: d = !0,
+        fallbackPlacements: f,
+        fallbackStrategy: u = "bestFit",
+        fallbackAxisSideDirection: p = "none",
+        flipAlignment: m = !0,
+        ...v
+      } = at(e, t);
+      if ((n = s.arrow) != null && n.alignmentOffset)
+        return {};
+      const g = Q(o), y = et(l), b = Q(l) === l, E = await (a.isRTL == null ? void 0 : a.isRTL(c.floating)), w = f || (b || !m ? [Pt(l)] : Qe(l)), $ = p !== "none";
+      !f && $ && w.push(...tn(l, m, p, E));
+      const C = [l, ...w], V = await Ut(t, v), B = [];
+      let F = ((i = s.flip) == null ? void 0 : i.overflows) || [];
+      if (h && B.push(V[g]), d) {
+        const A = Je(o, r, E);
+        B.push(V[A[0]], V[A[1]]);
+      }
+      if (F = [...F, {
+        placement: o,
+        overflows: B
+      }], !B.every((A) => A <= 0)) {
+        var K, M;
+        const A = (((K = s.flip) == null ? void 0 : K.index) || 0) + 1, it = C[A];
+        if (it)
+          return {
+            data: {
+              index: A,
+              overflows: F
+            },
+            reset: {
+              placement: it
+            }
+          };
+        let U = (M = F.filter((H) => H.overflows[0] <= 0).sort((H, G) => H.overflows[1] - G.overflows[1])[0]) == null ? void 0 : M.placement;
+        if (!U)
+          switch (u) {
+            case "bestFit": {
+              var Y;
+              const H = (Y = F.filter((G) => {
+                if ($) {
+                  const X = et(G.placement);
+                  return X === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  X === "y";
+                }
+                return !0;
+              }).map((G) => [G.placement, G.overflows.filter((X) => X > 0).reduce((X, Pe) => X + Pe, 0)]).sort((G, X) => G[1] - X[1])[0]) == null ? void 0 : Y[0];
+              H && (U = H);
+              break;
+            }
+            case "initialPlacement":
+              U = l;
+              break;
+          }
+        if (o !== U)
+          return {
+            reset: {
+              placement: U
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function rn(e, t) {
+  const {
+    placement: n,
+    platform: i,
+    elements: o
+  } = e, s = await (i.isRTL == null ? void 0 : i.isRTL(o.floating)), r = Q(n), l = ct(n), a = et(n) === "y", c = ["left", "top"].includes(r) ? -1 : 1, h = s && a ? -1 : 1, d = at(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 l && typeof p == "number" && (u = l === "end" ? p * -1 : p), a ? {
+    x: u * h,
+    y: f * c
+  } : {
+    x: f * c,
+    y: u * h
+  };
+}
+const ln = function(e) {
+  return e === void 0 && (e = 0), {
+    name: "offset",
+    options: e,
+    async fn(t) {
+      var n, i;
+      const {
+        x: o,
+        y: s,
+        placement: r,
+        middlewareData: l
+      } = t, a = await rn(t, e);
+      return r === ((n = l.offset) == null ? void 0 : n.placement) && (i = l.arrow) != null && i.alignmentOffset ? {} : {
+        x: o + a.x,
+        y: s + a.y,
+        data: {
+          ...a,
+          placement: r
+        }
+      };
+    }
+  };
+}, an = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "shift",
+    options: e,
+    async fn(t) {
+      const {
+        x: n,
+        y: i,
+        placement: o
+      } = t, {
+        mainAxis: s = !0,
+        crossAxis: r = !1,
+        limiter: l = {
+          fn: (v) => {
+            let {
+              x: g,
+              y
+            } = v;
+            return {
+              x: g,
+              y
+            };
+          }
+        },
+        ...a
+      } = at(e, t), c = {
+        x: n,
+        y: i
+      }, h = await Ut(t, a), d = et(Q(o)), f = ue(d);
+      let u = c[f], p = c[d];
+      if (s) {
+        const v = f === "y" ? "top" : "left", g = f === "y" ? "bottom" : "right", y = u + h[v], b = u - h[g];
+        u = $t(y, u, b);
+      }
+      if (r) {
+        const v = d === "y" ? "top" : "left", g = d === "y" ? "bottom" : "right", y = p + h[v], b = p - h[g];
+        p = $t(y, p, b);
+      }
+      const m = l.fn({
+        ...t,
+        [f]: u,
+        [d]: p
+      });
+      return {
+        ...m,
+        data: {
+          x: m.x - n,
+          y: m.y - i,
+          enabled: {
+            [f]: s,
+            [d]: r
+          }
+        }
+      };
+    }
+  };
+}, cn = function(e) {
+  return e === void 0 && (e = {}), {
+    name: "size",
+    options: e,
+    async fn(t) {
+      var n, i;
+      const {
+        placement: o,
+        rects: s,
+        platform: r,
+        elements: l
+      } = t, {
+        apply: a = () => {
+        },
+        ...c
+      } = at(e, t), h = await Ut(t, c), d = Q(o), f = ct(o), u = et(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(l.floating)) ? "start" : "end") ? "left" : "right") : (g = d, v = f === "end" ? "top" : "bottom");
+      const y = m - h.top - h.bottom, b = p - h.left - h.right, E = J(m - h[v], y), w = J(p - h[g], b), $ = !t.middlewareData.shift;
+      let C = E, V = w;
+      if ((n = t.middlewareData.shift) != null && n.enabled.x && (V = b), (i = t.middlewareData.shift) != null && i.enabled.y && (C = y), $ && !f) {
+        const F = D(h.left, 0), K = D(h.right, 0), M = D(h.top, 0), Y = D(h.bottom, 0);
+        u ? V = p - 2 * (F !== 0 || K !== 0 ? F + K : D(h.left, h.right)) : C = m - 2 * (M !== 0 || Y !== 0 ? M + Y : D(h.top, h.bottom));
+      }
+      await a({
+        ...t,
+        availableWidth: V,
+        availableHeight: C
+      });
+      const B = await r.getDimensions(l.floating);
+      return p !== B.width || m !== B.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function At() {
+  return typeof window < "u";
+}
+function ht(e) {
+  return fe(e) ? (e.nodeName || "").toLowerCase() : "#document";
+}
+function S(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function W(e) {
+  var t;
+  return (t = (fe(e) ? e.ownerDocument : e.document) || window.document) == null ? void 0 : t.documentElement;
+}
+function fe(e) {
+  return At() ? e instanceof Node || e instanceof S(e).Node : !1;
+}
+function _(e) {
+  return At() ? e instanceof Element || e instanceof S(e).Element : !1;
+}
+function I(e) {
+  return At() ? e instanceof HTMLElement || e instanceof S(e).HTMLElement : !1;
+}
+function ee(e) {
+  return !At() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof S(e).ShadowRoot;
+}
+function gt(e) {
+  const {
+    overflow: t,
+    overflowX: n,
+    overflowY: i,
+    display: o
+  } = N(e);
+  return /auto|scroll|overlay|hidden|clip/.test(t + i + n) && !["inline", "contents"].includes(o);
+}
+function hn(e) {
+  return ["table", "td", "th"].includes(ht(e));
+}
+function Tt(e) {
+  return [":popover-open", ":modal"].some((t) => {
+    try {
+      return e.matches(t);
+    } catch {
+      return !1;
+    }
+  });
+}
+function jt(e) {
+  const t = Kt(), n = _(e) ? N(e) : e;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((i) => n[i] ? n[i] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !t && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !t && (n.filter ? n.filter !== "none" : !1) || ["transform", "translate", "scale", "rotate", "perspective", "filter"].some((i) => (n.willChange || "").includes(i)) || ["paint", "layout", "strict", "content"].some((i) => (n.contain || "").includes(i));
+}
+function dn(e) {
+  let t = Z(e);
+  for (; I(t) && !lt(t); ) {
+    if (jt(t))
+      return t;
+    if (Tt(t))
+      return null;
+    t = Z(t);
+  }
+  return null;
+}
+function Kt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function lt(e) {
+  return ["html", "body", "#document"].includes(ht(e));
+}
+function N(e) {
+  return S(e).getComputedStyle(e);
+}
+function Rt(e) {
+  return _(e) ? {
+    scrollLeft: e.scrollLeft,
+    scrollTop: e.scrollTop
+  } : {
+    scrollLeft: e.scrollX,
+    scrollTop: e.scrollY
+  };
+}
+function Z(e) {
+  if (ht(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.
+    ee(e) && e.host || // Fallback.
+    W(e)
+  );
+  return ee(t) ? t.host : t;
+}
+function me(e) {
+  const t = Z(e);
+  return lt(t) ? e.ownerDocument ? e.ownerDocument.body : e.body : I(t) && gt(t) ? t : me(t);
+}
+function dt(e, t, n) {
+  var i;
+  t === void 0 && (t = []), n === void 0 && (n = !0);
+  const o = me(e), s = o === ((i = e.ownerDocument) == null ? void 0 : i.body), r = S(o);
+  if (s) {
+    const l = zt(r);
+    return t.concat(r, r.visualViewport || [], gt(o) ? o : [], l && n ? dt(l) : []);
+  }
+  return t.concat(o, dt(o, [], n));
+}
+function zt(e) {
+  return e.parent && Object.getPrototypeOf(e.parent) ? e.frameElement : null;
+}
+function ge(e) {
+  const t = N(e);
+  let n = parseFloat(t.width) || 0, i = parseFloat(t.height) || 0;
+  const o = I(e), s = o ? e.offsetWidth : n, r = o ? e.offsetHeight : i, l = Ct(n) !== s || Ct(i) !== r;
+  return l && (n = s, i = r), {
+    width: n,
+    height: i,
+    $: l
+  };
+}
+function Yt(e) {
+  return _(e) ? e : e.contextElement;
+}
+function ot(e) {
+  const t = Yt(e);
+  if (!I(t))
+    return q(1);
+  const n = t.getBoundingClientRect(), {
+    width: i,
+    height: o,
+    $: s
+  } = ge(t);
+  let r = (s ? Ct(n.width) : n.width) / i, l = (s ? Ct(n.height) : n.height) / o;
+  return (!r || !Number.isFinite(r)) && (r = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: r,
+    y: l
+  };
+}
+const un = /* @__PURE__ */ q(0);
+function ve(e) {
+  const t = S(e);
+  return !Kt() || !t.visualViewport ? un : {
+    x: t.visualViewport.offsetLeft,
+    y: t.visualViewport.offsetTop
+  };
+}
+function pn(e, t, n) {
+  return t === void 0 && (t = !1), !n || t && n !== S(e) ? !1 : t;
+}
+function nt(e, t, n, i) {
+  t === void 0 && (t = !1), n === void 0 && (n = !1);
+  const o = e.getBoundingClientRect(), s = Yt(e);
+  let r = q(1);
+  t && (i ? _(i) && (r = ot(i)) : r = ot(e));
+  const l = pn(s, n, i) ? ve(s) : q(0);
+  let a = (o.left + l.x) / r.x, c = (o.top + l.y) / r.y, h = o.width / r.x, d = o.height / r.y;
+  if (s) {
+    const f = S(s), u = i && _(i) ? S(i) : i;
+    let p = f, m = zt(p);
+    for (; m && i && u !== p; ) {
+      const v = ot(m), g = m.getBoundingClientRect(), y = N(m), b = g.left + (m.clientLeft + parseFloat(y.paddingLeft)) * v.x, E = g.top + (m.clientTop + parseFloat(y.paddingTop)) * v.y;
+      a *= v.x, c *= v.y, h *= v.x, d *= v.y, a += b, c += E, p = S(m), m = zt(p);
+    }
+  }
+  return Ot({
+    width: h,
+    height: d,
+    x: a,
+    y: c
+  });
+}
+function Gt(e, t) {
+  const n = Rt(e).scrollLeft;
+  return t ? t.left + n : nt(W(e)).left + n;
+}
+function ye(e, t, n) {
+  n === void 0 && (n = !1);
+  const i = e.getBoundingClientRect(), o = i.left + t.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    Gt(e, i)
+  )), s = i.top + t.scrollTop;
+  return {
+    x: o,
+    y: s
+  };
+}
+function fn(e) {
+  let {
+    elements: t,
+    rect: n,
+    offsetParent: i,
+    strategy: o
+  } = e;
+  const s = o === "fixed", r = W(i), l = t ? Tt(t.floating) : !1;
+  if (i === r || l && s)
+    return n;
+  let a = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, c = q(1);
+  const h = q(0), d = I(i);
+  if ((d || !d && !s) && ((ht(i) !== "body" || gt(r)) && (a = Rt(i)), I(i))) {
+    const u = nt(i);
+    c = ot(i), h.x = u.x + i.clientLeft, h.y = u.y + i.clientTop;
+  }
+  const f = r && !d && !s ? ye(r, a, !0) : q(0);
+  return {
+    width: n.width * c.x,
+    height: n.height * c.y,
+    x: n.x * c.x - a.scrollLeft * c.x + h.x + f.x,
+    y: n.y * c.y - a.scrollTop * c.y + h.y + f.y
+  };
+}
+function mn(e) {
+  return Array.from(e.getClientRects());
+}
+function gn(e) {
+  const t = W(e), n = Rt(e), i = e.ownerDocument.body, o = D(t.scrollWidth, t.clientWidth, i.scrollWidth, i.clientWidth), s = D(t.scrollHeight, t.clientHeight, i.scrollHeight, i.clientHeight);
+  let r = -n.scrollLeft + Gt(e);
+  const l = -n.scrollTop;
+  return N(i).direction === "rtl" && (r += D(t.clientWidth, i.clientWidth) - o), {
+    width: o,
+    height: s,
+    x: r,
+    y: l
+  };
+}
+function vn(e, t) {
+  const n = S(e), i = W(e), o = n.visualViewport;
+  let s = i.clientWidth, r = i.clientHeight, l = 0, a = 0;
+  if (o) {
+    s = o.width, r = o.height;
+    const c = Kt();
+    (!c || c && t === "fixed") && (l = o.offsetLeft, a = o.offsetTop);
+  }
+  return {
+    width: s,
+    height: r,
+    x: l,
+    y: a
+  };
+}
+function yn(e, t) {
+  const n = nt(e, !0, t === "fixed"), i = n.top + e.clientTop, o = n.left + e.clientLeft, s = I(e) ? ot(e) : q(1), r = e.clientWidth * s.x, l = e.clientHeight * s.y, a = o * s.x, c = i * s.y;
+  return {
+    width: r,
+    height: l,
+    x: a,
+    y: c
+  };
+}
+function ne(e, t, n) {
+  let i;
+  if (t === "viewport")
+    i = vn(e, n);
+  else if (t === "document")
+    i = gn(W(e));
+  else if (_(t))
+    i = yn(t, n);
+  else {
+    const o = ve(e);
+    i = {
+      x: t.x - o.x,
+      y: t.y - o.y,
+      width: t.width,
+      height: t.height
+    };
+  }
+  return Ot(i);
+}
+function be(e, t) {
+  const n = Z(e);
+  return n === t || !_(n) || lt(n) ? !1 : N(n).position === "fixed" || be(n, t);
+}
+function bn(e, t) {
+  const n = t.get(e);
+  if (n)
+    return n;
+  let i = dt(e, [], !1).filter((l) => _(l) && ht(l) !== "body"), o = null;
+  const s = N(e).position === "fixed";
+  let r = s ? Z(e) : e;
+  for (; _(r) && !lt(r); ) {
+    const l = N(r), a = jt(r);
+    !a && l.position === "fixed" && (o = null), (s ? !a && !o : !a && l.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || gt(r) && !a && be(e, r)) ? i = i.filter((h) => h !== r) : o = l, r = Z(r);
+  }
+  return t.set(e, i), i;
+}
+function wn(e) {
+  let {
+    element: t,
+    boundary: n,
+    rootBoundary: i,
+    strategy: o
+  } = e;
+  const r = [...n === "clippingAncestors" ? Tt(t) ? [] : bn(t, this._c) : [].concat(n), i], l = r[0], a = r.reduce((c, h) => {
+    const d = ne(t, h, o);
+    return c.top = D(d.top, c.top), c.right = J(d.right, c.right), c.bottom = J(d.bottom, c.bottom), c.left = D(d.left, c.left), c;
+  }, ne(t, l, o));
+  return {
+    width: a.right - a.left,
+    height: a.bottom - a.top,
+    x: a.left,
+    y: a.top
+  };
+}
+function En(e) {
+  const {
+    width: t,
+    height: n
+  } = ge(e);
+  return {
+    width: t,
+    height: n
+  };
+}
+function xn(e, t, n) {
+  const i = I(t), o = W(t), s = n === "fixed", r = nt(e, !0, s, t);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const a = q(0);
+  if (i || !i && !s)
+    if ((ht(t) !== "body" || gt(o)) && (l = Rt(t)), i) {
+      const f = nt(t, !0, s, t);
+      a.x = f.x + t.clientLeft, a.y = f.y + t.clientTop;
+    } else o && (a.x = Gt(o));
+  const c = o && !i && !s ? ye(o, l) : q(0), h = r.left + l.scrollLeft - a.x - c.x, d = r.top + l.scrollTop - a.y - c.y;
+  return {
+    x: h,
+    y: d,
+    width: r.width,
+    height: r.height
+  };
+}
+function kt(e) {
+  return N(e).position === "static";
+}
+function ie(e, t) {
+  if (!I(e) || N(e).position === "fixed")
+    return null;
+  if (t)
+    return t(e);
+  let n = e.offsetParent;
+  return W(e) === n && (n = n.ownerDocument.body), n;
+}
+function we(e, t) {
+  const n = S(e);
+  if (Tt(e))
+    return n;
+  if (!I(e)) {
+    let o = Z(e);
+    for (; o && !lt(o); ) {
+      if (_(o) && !kt(o))
+        return o;
+      o = Z(o);
+    }
+    return n;
+  }
+  let i = ie(e, t);
+  for (; i && hn(i) && kt(i); )
+    i = ie(i, t);
+  return i && lt(i) && kt(i) && !jt(i) ? n : i || dn(e) || n;
+}
+const Cn = async function(e) {
+  const t = this.getOffsetParent || we, n = this.getDimensions, i = await n(e.floating);
+  return {
+    reference: xn(e.reference, await t(e.floating), e.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: i.width,
+      height: i.height
+    }
+  };
+};
+function Pn(e) {
+  return N(e).direction === "rtl";
+}
+const On = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: fn,
+  getDocumentElement: W,
+  getClippingRect: wn,
+  getOffsetParent: we,
+  getElementRects: Cn,
+  getClientRects: mn,
+  getDimensions: En,
+  getScale: ot,
+  isElement: _,
+  isRTL: Pn
+};
+function Ee(e, t) {
+  return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height;
+}
+function An(e, t) {
+  let n = null, i;
+  const o = W(e);
+  function s() {
+    var l;
+    clearTimeout(i), (l = n) == null || l.disconnect(), n = null;
+  }
+  function r(l, a) {
+    l === void 0 && (l = !1), a === void 0 && (a = 1), s();
+    const c = e.getBoundingClientRect(), {
+      left: h,
+      top: d,
+      width: f,
+      height: u
+    } = c;
+    if (l || t(), !f || !u)
+      return;
+    const p = yt(d), m = yt(o.clientWidth - (h + f)), v = yt(o.clientHeight - (d + u)), g = yt(h), b = {
+      rootMargin: -p + "px " + -m + "px " + -v + "px " + -g + "px",
+      threshold: D(0, J(1, a)) || 1
+    };
+    let E = !0;
+    function w($) {
+      const C = $[0].intersectionRatio;
+      if (C !== a) {
+        if (!E)
+          return r();
+        C ? r(!1, C) : i = setTimeout(() => {
+          r(!1, 1e-7);
+        }, 1e3);
+      }
+      C === 1 && !Ee(c, e.getBoundingClientRect()) && r(), E = !1;
+    }
+    try {
+      n = new IntersectionObserver(w, {
+        ...b,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(w, b);
+    }
+    n.observe(e);
+  }
+  return r(!0), s;
+}
+function oe(e, t, n, i) {
+  i === void 0 && (i = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: s = !0,
+    elementResize: r = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: a = !1
+  } = i, c = Yt(e), h = o || s ? [...c ? dt(c) : [], ...dt(t)] : [];
+  h.forEach((g) => {
+    o && g.addEventListener("scroll", n, {
+      passive: !0
+    }), s && g.addEventListener("resize", n);
+  });
+  const d = c && l ? An(c, n) : null;
+  let f = -1, u = null;
+  r && (u = new ResizeObserver((g) => {
+    let [y] = g;
+    y && y.target === c && u && (u.unobserve(t), cancelAnimationFrame(f), f = requestAnimationFrame(() => {
+      var b;
+      (b = u) == null || b.observe(t);
+    })), n();
+  }), c && !a && u.observe(c), u.observe(t));
+  let p, m = a ? nt(e) : null;
+  a && v();
+  function v() {
+    const g = nt(e);
+    m && !Ee(m, g) && n(), m = g, p = requestAnimationFrame(v);
+  }
+  return n(), () => {
+    var g;
+    h.forEach((y) => {
+      o && y.removeEventListener("scroll", n), s && y.removeEventListener("resize", n);
+    }), d == null || d(), (g = u) == null || g.disconnect(), u = null, a && cancelAnimationFrame(p);
+  };
+}
+const Tn = ln, Rn = an, se = sn, Dn = cn, Sn = on, kn = (e, t, n) => {
+  const i = /* @__PURE__ */ new Map(), o = {
+    platform: On,
+    ...n
+  }, s = {
+    ...o.platform,
+    _c: i
+  };
+  return nn(e, t, {
+    ...o,
+    platform: s
+  });
+};
+function bt(e) {
+  if (e === void 0)
+    return 0;
+  const t = window.devicePixelRatio || 1;
+  return Math.round(e * t) / t;
+}
+const wt = 8, Ln = 100, $n = (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 Fn {
+  /**
+   * 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, n = this.options) {
+    if (this.target = t, this.options = n, !t || !n)
+      return;
+    const i = oe(
+      n.trigger,
+      t,
+      this.closeForAncestorUpdate,
+      {
+        ancestorResize: !1,
+        elementResize: !1,
+        layoutShift: !1
+      }
+    ), o = oe(
+      n.trigger,
+      t,
+      this.updatePlacement,
+      {
+        ancestorScroll: !1
+      }
+    );
+    this.cleanup = () => {
+      var s;
+      (s = this.host.elements) == null || s.forEach((r) => {
+        r.addEventListener(
+          "luzmo-closed",
+          () => {
+            const l = this.originalPlacements.get(r);
+            l && r.setAttribute("placement", l), this.originalPlacements.delete(r);
+          },
+          { once: !0 }
+        );
+      }), i(), 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: n } = this;
+    await (document.fonts ? document.fonts.ready : Promise.resolve());
+    const i = t.trigger instanceof HTMLElement ? se() : se({
+      padding: wt,
+      fallbackPlacements: $n(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, l = [
+      Tn({
+        mainAxis: o,
+        crossAxis: s
+      }),
+      Rn({ padding: wt }),
+      i,
+      Dn({
+        padding: wt,
+        apply: ({ availableWidth: p, availableHeight: m, rects: { floating: v } }) => {
+          const g = Math.max(
+            Ln,
+            Math.floor(m)
+          ), y = v.height;
+          this.initialHeight = this.isConstrained && this.initialHeight || y, this.isConstrained = y < this.initialHeight || g <= y;
+          const b = this.isConstrained ? `${g}px` : "";
+          Object.assign(n.style, {
+            maxWidth: `${Math.floor(p)}px`,
+            maxHeight: b
+          });
+        }
+      }),
+      ...r ? [
+        Sn({
+          element: r,
+          padding: t.tipPadding || wt
+        })
+      ] : []
+    ], { x: a, y: c, placement: h, middlewareData: d } = await kn(
+      t.trigger,
+      n,
+      {
+        placement: t.placement,
+        middleware: l,
+        strategy: "fixed"
+      }
+    );
+    if (Object.assign(n.style, {
+      top: "0px",
+      left: "0px",
+      translate: `${bt(a)}px ${bt(c)}px`
+    }), n.setAttribute("actual-placement", h), (u = this.host.elements) == null || u.forEach((p) => {
+      this.originalPlacements.has(p) || this.originalPlacements.set(
+        p,
+        p.getAttribute("placement")
+      ), p.setAttribute("placement", h);
+    }), r && d.arrow) {
+      const { x: p, y: m } = d.arrow;
+      Object.assign(r.style, {
+        top: h.startsWith("right") || h.startsWith("left") ? "0px" : "",
+        left: h.startsWith("bottom") || h.startsWith("top") ? "0px" : "",
+        translate: `${bt(p)}px ${bt(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 vt = /* @__PURE__ */ ((e) => (e[e.click = 0] = "click", e[e.hover = 1] = "hover", e[e.longpress = 2] = "longpress", e))(vt || {});
+class Xt {
+  constructor(t, { overlay: n, isPersistent: i, handleOverlayReady: o }) {
+    this.target = t, this.isLazilyOpen = !1, this.isPersistent = !1, this.isPersistent = !!i, this.handleOverlayReady = o, this.isPersistent && this.init(), this.overlay = n;
+  }
+  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: n } = await Promise.resolve().then(() => st);
+        this.overlay = new n(), this.overlay.open = !0;
+      }), Promise.resolve().then(() => st));
+    }
+  }
+  get overlay() {
+    return this._overlay;
+  }
+  set overlay(t) {
+    var n;
+    t && this.overlay !== t && (this.overlay && this.overlay.removeController(this), this._overlay = t, this.overlay.addController(this), this.initOverlay(), this.prepareDescription(this.target), (n = this.handleOverlayReady) == null || n.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 zn extends Xt {
+  constructor() {
+    super(...arguments), this.type = vt.click, this.preventNextToggle = !1;
+  }
+  handleClick() {
+    this.preventNextToggle || (this.open = !this.open), this.preventNextToggle = !1;
+  }
+  handlePointerdown() {
+    this.preventNextToggle = this.open;
+  }
+  init() {
+    var n;
+    (n = this.abortController) == null || n.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 _n = 300;
+class Nn extends Xt {
+  constructor() {
+    super(...arguments), this.type = vt.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(), n = this.overlay.elements[0].getRootNode(), i = this.overlay.getRootNode();
+    t === i ? this.prepareOverlayRelativeDescription() : t === n && this.prepareContentRelativeDescription();
+  }
+  prepareOverlayRelativeDescription() {
+    const t = Lt(
+      this.target,
+      "aria-describedby",
+      [this.overlay.id]
+    );
+    this.releaseDescription = () => {
+      t(), this.releaseDescription = tt;
+    };
+  }
+  prepareContentRelativeDescription() {
+    const t = [], n = this.overlay.elements.map((o) => (t.push(o.id), o.id || (o.id = `${this.overlay.tagName.toLowerCase()}-helper-${_t()}`), o.id));
+    this.elementIds = t;
+    const i = Lt(
+      this.target,
+      "aria-describedby",
+      n
+    );
+    this.releaseDescription = () => {
+      i(), this.overlay.elements.map((o, s) => {
+        o.id = this.elementIds[s];
+      }), this.releaseDescription = tt;
+    };
+  }
+  doPointerleave() {
+    this.pointerentered = !1;
+    const t = this.target;
+    this.focusedin && t.matches(":focus-visible") || (this.hoverTimeout = setTimeout(() => {
+      this.open = !1;
+    }, _n));
+  }
+  init() {
+    var n;
+    (n = this.abortController) == null || n.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 Bn = 300, Mn = {
+  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 Hn extends Xt {
+  constructor() {
+    super(...arguments), this.type = vt.longpress, this.longpressState = null, this.releaseDescription = tt, 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"
+          }
+        })
+      );
+    }, Bn));
+  }
+  handleKeydown(t) {
+    const { code: n, altKey: i } = t;
+    i && n === "ArrowDown" && (t.stopPropagation(), t.stopImmediatePropagation());
+  }
+  handleKeyup(t) {
+    const { code: n, altKey: i } = t;
+    if (n === "Space" || i && n === "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 !== tt || // require "longpress content" to apply relationship
+      this.overlay.elements.length === 0
+    )
+      return;
+    const n = document.createElement("div");
+    n.id = `longpress-describedby-descriptor-${_t()}`;
+    const i = ke() || Le() ? "touch" : "keyboard";
+    n.textContent = Mn[i], n.slot = "longpress-describedby-descriptor";
+    const o = t.getRootNode(), s = this.overlay.getRootNode();
+    o === s ? this.overlay.append(n) : (n.hidden = !("host" in o), t.after(n));
+    const r = Lt(
+      t,
+      "aria-describedby",
+      [n.id]
+    );
+    this.releaseDescription = () => {
+      r(), n.remove(), this.releaseDescription = tt;
+    };
+  }
+  shouldCompleteOpen() {
+    this.longpressState = this.longpressState === "pressed" ? null : this.longpressState;
+  }
+  init() {
+    var n;
+    (n = this.abortController) == null || n.abort(), this.abortController = new AbortController();
+    const { signal: t } = this.abortController;
+    this.target.addEventListener("longpress", () => this.handleLongpress(), {
+      signal: t
+    }), this.target.addEventListener(
+      "pointerdown",
+      (i) => this.handlePointerdown(i),
+      { signal: t }
+    ), this.prepareDescription(this.target), !this.target.holdAffordance && (this.target.addEventListener(
+      "keydown",
+      (i) => this.handleKeydown(i),
+      { signal: t }
+    ), this.target.addEventListener(
+      "keyup",
+      (i) => this.handleKeyup(i),
+      { signal: t }
+    ));
+  }
+}
+const xe = {
+  click: zn,
+  longpress: Hn,
+  hover: Nn
+};
+var qn = Object.defineProperty, In = Object.getOwnPropertyDescriptor, T = (e, t, n, i) => {
+  for (var o = i > 1 ? void 0 : i ? In(t, n) : t, s = e.length - 1, r; s >= 0; s--)
+    (r = e[s]) && (o = (i ? r(t, n, o) : r(o)) || o);
+  return i && o && qn(t, n, o), o;
+};
+const Wn = "showPopover" in document.createElement("div");
+let Et = Ie(rt);
+Et = Wn ? Ue(Et) : We(Et);
+var j;
+const P = (j = class extends Et {
+  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 n = new Event("overlay-relation-query", {
+        bubbles: !0,
+        composed: !0
+      });
+      t.relatedTarget.addEventListener(n.type, (i) => {
+        i.composedPath().includes(this) || (this.open = !1);
+      }), t.relatedTarget.dispatchEvent(n);
+    };
+  }
+  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 n;
+    this._disabled = t, t ? ((n = this.strategy) == null || n.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 mt);
+  }
+  /**
+   * 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 Fn(this)), this._placementController;
+  }
+  get open() {
+    return this._open;
+  }
+  set open(t) {
+    var n;
+    t && this.disabled || t !== this.open && ((n = this.strategy) != null && n.activelyOpening && !t || (this._open = t, this.open && (j.openCount += 1), this.requestUpdate("open", !this.open), this.open && this.requestSlottable()));
+  }
+  get state() {
+    return this._state;
+  }
+  set state(t) {
+    var i;
+    if (t === this.state)
+      return;
+    const n = this.state;
+    this._state = t, (this.state === "opened" || this.state === "closed") && ((i = this.strategy) == null || i.shouldCompleteOpen()), this.requestUpdate("state", n);
+  }
+  /**
+   * 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 Te(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, n = this.triggerElement, i = this.placement || "right", o = this.tipPadding;
+    this.placementController.placeOverlay(this.dialogEl, {
+      offset: t,
+      placement: i,
+      tipPadding: o,
+      trigger: n,
+      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 n = await this.makeTransition(t);
+    this.open === t && await this.applyFocus(t, n);
+  }
+  /**
+   * 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, n) {
+    if (!(this.receivesFocus === "false" || this.type === "hint")) {
+      if (await L(), await L(), t === this.open && !this.open) {
+        this.hasNonVirtualTrigger && this.contains(this.getRootNode().activeElement) && this.triggerElement.focus();
+        return;
+      }
+      n == null || n.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 n;
+    if (this.open || this.type === "hint")
+      return;
+    const t = () => {
+      var s, r;
+      const i = [];
+      let o = document.activeElement;
+      for (; (s = o == null ? void 0 : o.shadowRoot) != null && s.activeElement; )
+        o = o.shadowRoot.activeElement;
+      for (; o; ) {
+        const l = o.assignedSlot || o.parentElement || ((r = o.getRootNode()) == null ? void 0 : r.host);
+        l && i.push(l), o = l;
+      }
+      return i;
+    };
+    this.receivesFocus !== "false" && ((n = this.triggerElement) != null && n.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 ? (Zt.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(), Zt.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 n = this.getRootNode();
+      this.open ? n.addEventListener("focusout", this.closeOnFocusOut, {
+        capture: !0
+      }) : n.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 xe[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 n;
+    if (t.stopPropagation(), !((n = this.strategy) != null && n.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, n;
+    this.elements.length === 0 ? (t = this.strategy) == null || t.releaseDescription() : this.hasNonVirtualTrigger && ((n = this.strategy) == null || n.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 ze(
+        "overlay-content",
+        this.open ? {} : Nt
+      )
+    ), 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 i;
+    if (this.hasAttribute("id") || this.setAttribute("id", `${this.tagName.toLowerCase()}-${_t()}`), t.has("open") && (this.hasUpdated || this.open) && this.manageOpen(t.get("open")), t.has("trigger")) {
+      const [o, s] = ((i = this.trigger) == null ? void 0 : i.split("@")) || [];
+      this.elementResolver.selector = o ? `#${o}` : "", this.triggerInteraction = s;
+    }
+    let n = !1;
+    t.has(Re) && (n = this.triggerElement, this.triggerElement = this.elementResolver.element), t.has("triggerElement") && (n = t.get("triggerElement")), n !== !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 k` <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": j.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 k`
+      <dialog
+        class="dialog"
+        part="dialog"
+        placement=${St(
+      this.requiresPositioning ? this.placement || "right" : void 0
+    )}
+        style=${Jt(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 k`
+      <div
+        class="dialog"
+        part="dialog"
+        placement=${St(
+      this.requiresPositioning ? this.placement || "right" : void 0
+    )}
+        popover=${St(this.popoverValue)}
+        style=${Jt(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 k`
+      ${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();
+  }
+}, j.styles = [ae(Ye)], j.openCount = 1, j);
+T([
+  x({ type: Boolean })
+], P.prototype, "delayed", 1);
+T([
+  pt(".dialog")
+], P.prototype, "dialogEl", 2);
+T([
+  x({ type: Boolean })
+], P.prototype, "disabled", 1);
+T([
+  Fe({
+    flatten: !0,
+    selector: ':not([slot="longpress-describedby-descriptor"], slot)'
+  })
+], P.prototype, "elements", 2);
+T([
+  x({ type: Number })
+], P.prototype, "offset", 2);
+T([
+  x({ type: Boolean, reflect: !0 })
+], P.prototype, "open", 1);
+T([
+  x()
+], P.prototype, "placement", 2);
+T([
+  x({ attribute: "receives-focus" })
+], P.prototype, "receivesFocus", 2);
+T([
+  pt("slot")
+], P.prototype, "slotEl", 2);
+T([
+  ut()
+], P.prototype, "state", 1);
+T([
+  x({ type: Number, attribute: "tip-padding" })
+], P.prototype, "tipPadding", 2);
+T([
+  x()
+], P.prototype, "trigger", 2);
+T([
+  x({ attribute: !1 })
+], P.prototype, "triggerElement", 2);
+T([
+  x({ attribute: !1 })
+], P.prototype, "triggerInteraction", 2);
+T([
+  x()
+], P.prototype, "type", 2);
+let Dt = P;
+const st = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Overlay: Dt
+}, Symbol.toStringTag, { value: "Module" })), Vn = ":host([disabled]) ::slotted([slot=trigger]){pointer-events:none}slot[name=longpress-describedby-descriptor]{display:none}";
+var Un = Object.defineProperty, R = (e, t, n, i) => {
+  for (var o = void 0, s = e.length - 1, r; s >= 0; s--)
+    (r = e[s]) && (o = r(t, n, o) || o);
+  return o && Un(t, n, o), o;
+};
+class O extends le {
+  constructor() {
+    super(...arguments), this.content = "click hover longpress", this.offset = 6, this.disabled = !1, this.receivesFocus = "auto", this.clickContent = [], this.longpressContent = [], this.hoverContent = [], this.targetContent = [];
+  }
+  static get styles() {
+    return [ae(Vn)];
+  }
+  getAssignedElementsFromSlot(t) {
+    return t.assignedElements({ flatten: !0 });
+  }
+  handleTriggerContent(t) {
+    this.targetContent = this.getAssignedElementsFromSlot(t.target);
+  }
+  handleSlotContent(t) {
+    switch (t.target.name) {
+      case "click-content": {
+        this.clickContent = this.getAssignedElementsFromSlot(t.target);
+        break;
+      }
+      case "longpress-content": {
+        this.longpressContent = this.getAssignedElementsFromSlot(t.target);
+        break;
+      }
+      case "hover-content": {
+        this.hoverContent = this.getAssignedElementsFromSlot(t.target);
+        break;
+      }
+    }
+  }
+  handleBeforetoggle(t) {
+    const { target: n } = t;
+    let i;
+    if (n === this.clickOverlayElement)
+      i = "click";
+    else if (n === this.longpressOverlayElement)
+      i = "longpress";
+    else if (n === this.hoverOverlayElement)
+      i = "hover";
+    else
+      return;
+    t.newState === "open" ? this.open = i : this.open === i && (this.open = void 0);
+  }
+  update(t) {
+    var n, i, o, s, r, l;
+    t.has("clickContent") && (this.clickPlacement = ((n = this.clickContent[0]) == null ? void 0 : n.getAttribute("placement")) || ((i = this.clickContent[0]) == null ? void 0 : i.getAttribute("direction")) || void 0), t.has("hoverContent") && (this.hoverPlacement = ((o = this.hoverContent[0]) == null ? void 0 : o.getAttribute("placement")) || ((s = this.hoverContent[0]) == null ? void 0 : s.getAttribute("direction")) || void 0), t.has("longpressContent") && (this.longpressPlacement = ((r = this.longpressContent[0]) == null ? void 0 : r.getAttribute("placement")) || ((l = this.longpressContent[0]) == null ? void 0 : l.getAttribute("direction")) || void 0), super.update(t);
+  }
+  renderSlot(t) {
+    return k`
+      <slot name=${t} @slotchange=${this.handleSlotContent}></slot>
+    `;
+  }
+  renderClickOverlay() {
+    Promise.resolve().then(() => st);
+    const t = this.renderSlot("click-content");
+    return this.clickContent.length === 0 ? t : k`
+      <luzmo-overlay
+        id="click-overlay"
+        ?disabled=${this.disabled || this.clickContent.length === 0}
+        ?open=${this.open === "click" && this.clickContent.length > 0}
+        .offset=${this.offset}
+        .placement=${this.clickPlacement || this.placement}
+        .triggerElement=${this.targetContent[0]}
+        .triggerInteraction=${"click"}
+        .type=${this.type === "modal" ? "modal" : "auto"}
+        @beforetoggle=${this.handleBeforetoggle}
+        .receivesFocus=${this.receivesFocus}
+      >
+        ${t}
+      </luzmo-overlay>
+    `;
+  }
+  renderHoverOverlay() {
+    Promise.resolve().then(() => st);
+    const t = this.renderSlot("hover-content");
+    return this.hoverContent.length === 0 ? t : k`
+      <luzmo-overlay
+        id="hover-overlay"
+        ?open=${this.open === "hover" && this.hoverContent.length > 0}
+        ?disabled=${this.disabled || this.hoverContent.length === 0 || !!this.open && this.open !== "hover"}
+        .offset=${this.offset}
+        .placement=${this.hoverPlacement || this.placement}
+        .triggerElement=${this.targetContent[0]}
+        .triggerInteraction=${"hover"}
+        .type=${"hint"}
+        @beforetoggle=${this.handleBeforetoggle}
+        .receivesFocus=${this.receivesFocus}
+      >
+        ${t}
+      </luzmo-overlay>
+    `;
+  }
+  renderLongpressOverlay() {
+    Promise.resolve().then(() => st);
+    const t = this.renderSlot("longpress-content");
+    return this.longpressContent.length === 0 ? t : k`
+      <luzmo-overlay
+        id="longpress-overlay"
+        ?disabled=${this.disabled || this.longpressContent.length === 0}
+        ?open=${this.open === "longpress" && this.longpressContent.length > 0}
+        .offset=${this.offset}
+        .placement=${this.longpressPlacement || this.placement}
+        .triggerElement=${this.targetContent[0]}
+        .triggerInteraction=${"longpress"}
+        .type=${"auto"}
+        @beforetoggle=${this.handleBeforetoggle}
+        .receivesFocus=${this.receivesFocus}
+      >
+        ${t}
+      </luzmo-overlay>
+      <slot name="longpress-describedby-descriptor"></slot>
+    `;
+  }
+  render() {
+    const t = this.content.split(" ");
+    return k`
+      <slot
+        id="trigger"
+        name="trigger"
+        @slotchange=${this.handleTriggerContent}
+      ></slot>
+      ${[
+      t.includes("click") ? this.renderClickOverlay() : k``,
+      t.includes("hover") ? this.renderHoverOverlay() : k``,
+      t.includes("longpress") ? this.renderLongpressOverlay() : k``
+    ]}
+    `;
+  }
+  updated(t) {
+    if (super.updated(t), this.disabled && t.has("disabled")) {
+      this.open = void 0;
+      return;
+    }
+  }
+  async getUpdateComplete() {
+    return await super.getUpdateComplete();
+  }
+}
+R([
+  x()
+], O.prototype, "content");
+R([
+  x({ reflect: !0 })
+], O.prototype, "placement");
+R([
+  x()
+], O.prototype, "type");
+R([
+  x({ type: Number })
+], O.prototype, "offset");
+R([
+  x({ reflect: !0 })
+], O.prototype, "open");
+R([
+  x({ type: Boolean, reflect: !0 })
+], O.prototype, "disabled");
+R([
+  x({ attribute: "receives-focus" })
+], O.prototype, "receivesFocus");
+R([
+  ut()
+], O.prototype, "clickContent");
+R([
+  ut()
+], O.prototype, "longpressContent");
+R([
+  ut()
+], O.prototype, "hoverContent");
+R([
+  ut()
+], O.prototype, "targetContent");
+R([
+  pt("#click-overlay", !0)
+], O.prototype, "clickOverlayElement");
+R([
+  pt("#longpress-overlay", !0)
+], O.prototype, "longpressOverlayElement");
+R([
+  pt("#hover-overlay", !0)
+], O.prototype, "hoverOverlayElement");
+function jn(e, t, n, i) {
+  return Dt.open(
+    e,
+    t,
+    n,
+    i
+  );
+}
+class Kn extends $e {
+  /* c8 ignore next 9 */
+  render(t) {
+    return ce;
+  }
+  update(t, [n]) {
+    this.template = n, this.target !== t.element && (this.target = t.element, this.renderBefore = this.target.children[0]), this.listenerHost = this.target, this.init();
+  }
+  handleSlottableRequest(t) {
+    if (t.target !== t.currentTarget)
+      return;
+    const n = t.data === Nt;
+    he(n ? void 0 : this.template(), this.target, {
+      renderBefore: this.renderBefore
+    });
+  }
+  init() {
+    var n;
+    (n = this.listeners) == null || n.abort(), this.listeners = new AbortController();
+    const { signal: t } = this.listeners;
+    this.listenerHost.addEventListener(
+      "slottable-request",
+      (i) => this.handleSlottableRequest(i),
+      { signal: t }
+    );
+  }
+  disconnected() {
+    var t;
+    (t = this.listeners) == null || t.abort();
+  }
+  /* c8 ignore next 3 */
+  reconnected() {
+    this.init();
+  }
+}
+class Ce extends Kn {
+  constructor() {
+    super(...arguments), this.defaultOptions = {
+      triggerInteraction: "click",
+      overlayOptions: {
+        type: "auto",
+        offset: 0
+      }
+    }, this.options = {
+      ...this.defaultOptions.overlayOptions
+    };
+  }
+  /* c8 ignore next 9 */
+  render(t, n) {
+    return ce;
+  }
+  update(t, [n, i]) {
+    var l, a, c;
+    this.options = {
+      ...this.defaultOptions.overlayOptions,
+      ...i == null ? void 0 : i.overlayOptions
+    }, this.insertionOptions = i == null ? void 0 : i.insertionOptions, this.template = n, this.host = (l = t.options) == null ? void 0 : l.host;
+    let o = !1;
+    const s = (i == null ? void 0 : i.triggerInteraction) || this.defaultOptions.triggerInteraction, r = vt[(a = this.strategy) == null ? void 0 : a.type] !== s;
+    this.target !== t.element && (this.target = t.element, o = !0), (o || r) && ((c = this.strategy) == null || c.abort(), this.strategy = new xe[s](this.target, {
+      isPersistent: !0,
+      handleOverlayReady: (h) => {
+        this.listenerHost = this.overlay = h, this.init();
+      }
+    })), this.strategy.open = (i == null ? void 0 : i.open) ?? !1;
+  }
+  handleSlottableRequest(t) {
+    var o, s;
+    if (t.target !== t.currentTarget)
+      return;
+    const n = t.data === Nt, i = {};
+    if (this.host && (i.host = this.host), he(
+      n ? void 0 : this.template(),
+      this.overlay,
+      i
+    ), n)
+      this.overlay.remove();
+    else {
+      rt.applyOptions(this.overlay, {
+        ...this.options,
+        trigger: this.target
+      });
+      const r = typeof ((o = this.insertionOptions) == null ? void 0 : o.el) == "function" ? this.insertionOptions.el() : ((s = this.insertionOptions) == null ? void 0 : s.el) || this.target, { where: l = "afterend" } = this.insertionOptions || {};
+      r.insertAdjacentElement(l, this.overlay);
+    }
+  }
+}
+const Yn = re(Ce);
+customElements.get("luzmo-overlay") || customElements.define("luzmo-overlay", Dt);
+customElements.get("luzmo-overlay-trigger") || customElements.define("luzmo-overlay-trigger", O);
+const Zn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Overlay: Dt,
+  OverlayTrigger: O,
+  OverlayTriggerDirective: Ce,
+  VirtualTrigger: mt,
+  openOverlay: jn,
+  trigger: Yn
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Dt as O,
+  ze as S,
+  mt as V,
+  Fe as a,
+  jn as b,
+  O as c,
+  Ce as d,
+  st as e,
+  Zn as i,
+  Jt as o,
+  Nt as r,
+  Yn as t
+};