@viasat/beam-web-components 2.0.0

package/Tooltip/Tooltip.js

@@ -0,0 +1,1827 @@
+import { unsafeCSS as xt, css as he, html as Yt, LitElement as qt } from "lit";
+import { property as v, state as ge } from "lit/decorators.js";
+import { createRef as zt, ref as Tt } from "lit/directives/ref.js";
+import bt from "clsx";
+import { h as ve, g as Gt, j as kt, k as be } from "../chunks/classNames.Cq_tbDRp.js";
+import { p as ye, t as we } from "../chunks/constants.jOWREYQE.js";
+import { e as xe, f as Ce } from "../chunks/tokens.CTW8Tt94.js";
+import { c as Zt } from "../chunks/register-custom-element.DHGKOhmA.js";
+import { c as Oe, d as Dt, m as Bt, r as Ae, h as Ee, e as Jt, f as $t } from "../chunks/helpers.AwJwaZvv.js";
+const Qt = `:root,:host,.bm-light,.bm-dark .bm-inverse,[data-bm-theme~=bm-light]{--bm-comp-tooltip-color-bg: var(--bm-sem-color-surface-inverse, #202e39);--bm-comp-tooltip-color-text: var( --bm-sem-color-text-primary-inverse, #ffffff );--bm-comp-tooltip-color-icon-trigger: var( --bm-sem-color-icon-secondary, #576775 );--bm-comp-tooltip-radius: var(--bm-sem-radius-sm, .25rem);--bm-comp-tooltip-space-x: var(--bm-sem-space-75, .75rem);--bm-comp-tooltip-space-y: var(--bm-sem-space-50, .5rem);--bm-comp-tooltip-space-arrow: var(--bm-sem-space-75, .75rem);--bm-comp-tooltip-space-offset: var(--bm-sem-space-25, .25rem);--bm-comp-tooltip-size-arrow-width: .625rem;--bm-comp-tooltip-size-arrow-height: var( --bm-primitive-dimension-25, .25rem );--bm-comp-tooltip-size-width: var(--bm-primitive-dimension-1500, 15rem);--bm-comp-tooltip-size-icon-trigger-xs: var(--bm-sem-size-icon-xs, .75rem);--bm-comp-tooltip-size-icon-trigger-sm: var(--bm-sem-size-icon-sm, 1rem);--bm-comp-tooltip-size-icon-trigger-md: var(--bm-sem-size-icon-md, 1.25rem);--bm-comp-tooltip-size-icon-trigger-lg: var(--bm-sem-size-icon-lg, 1.5rem);--bm-comp-tooltip-size-icon-trigger-xl: var(--bm-sem-size-icon-xl, 1.75rem);--bm-comp-tooltip-typo-body: var( --bm-sem-typo-compact-body-sm, 400 .875rem/1rem "Source Sans Pro" )}:host,.bm-dark,.bm-light .bm-inverse,[data-bm-theme~=bm-dark]{--bm-comp-tooltip-color-bg: var(--bm-sem-color-surface-inverse, #ffffff);--bm-comp-tooltip-color-text: var( --bm-sem-color-text-primary-inverse, #141d24 );--bm-comp-tooltip-color-icon-trigger: var( --bm-sem-color-icon-secondary, #c3cdd5 );--bm-comp-tooltip-radius: var(--bm-sem-radius-sm, .25rem);--bm-comp-tooltip-space-x: var(--bm-sem-space-75, .75rem);--bm-comp-tooltip-space-y: var(--bm-sem-space-50, .5rem);--bm-comp-tooltip-space-arrow: var(--bm-sem-space-75, .75rem);--bm-comp-tooltip-space-offset: var(--bm-sem-space-25, .25rem);--bm-comp-tooltip-size-arrow-width: .625rem;--bm-comp-tooltip-size-arrow-height: var( --bm-primitive-dimension-25, .25rem );--bm-comp-tooltip-size-width: var(--bm-primitive-dimension-1500, 15rem);--bm-comp-tooltip-size-icon-trigger-xs: var(--bm-sem-size-icon-xs, .75rem);--bm-comp-tooltip-size-icon-trigger-sm: var(--bm-sem-size-icon-sm, 1rem);--bm-comp-tooltip-size-icon-trigger-md: var(--bm-sem-size-icon-md, 1.25rem);--bm-comp-tooltip-size-icon-trigger-lg: var(--bm-sem-size-icon-lg, 1.5rem);--bm-comp-tooltip-size-icon-trigger-xl: var(--bm-sem-size-icon-xl, 1.75rem);--bm-comp-tooltip-typo-body: var( --bm-sem-typo-compact-body-sm, 400 .875rem/1rem "Source Sans Pro" )}.bm-tooltip__icon-trigger{border:none;background:none;padding:0;margin:0;display:flex;cursor:pointer;color:var(--bm-comp-tooltip-color-icon-trigger)}.bm-tooltip{z-index:999;background-color:var(--bm-comp-tooltip-color-bg);border-radius:var(--bm-comp-tooltip-radius);max-width:var(--bm-comp-tooltip-size-width);padding:var(--bm-comp-tooltip-space-y) var(--bm-comp-tooltip-space-x);color:var(--bm-comp-tooltip-color-text);font:var(--bm-comp-tooltip-typo-body);offset:var(--bm-comp-tooltip-space-offset);transition-property:opacity}.bm-tooltip[data-status=open]{transition-duration:0s}.bm-tooltip[data-status=close]{transition-duration:.2s}.bm-tooltip[data-status=initial],.bm-tooltip[data-status=close]{opacity:0}.bm-tooltip__arrow{offset:var(--bm-comp-tooltip-space-arrow);-webkit-mask-image:url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="10" height="4" fill="none"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.75 3.515c.69.647 1.81.647 2.5 0L10 0H0l3.75 3.515Z" fill="%23202E39"/></svg>');-webkit-mask-size:cover;-webkit-mask-position:center;-webkit-mask-repeat:no-repeat;mask-image:url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="10" height="4" fill="none"><path fill-rule="evenodd" clip-rule="evenodd" d="M3.75 3.515c.69.647 1.81.647 2.5 0L10 0H0l3.75 3.515Z" fill="%23202E39"/></svg>');mask-size:cover;mask-position:center;mask-repeat:no-repeat;scale:1.05;width:var(--bm-comp-tooltip-size-arrow-width);height:var(--bm-comp-tooltip-size-arrow-height);background-color:var(--bm-comp-tooltip-color-bg)}.bm-tooltip__icon-trigger svg{background:none;border:none}.bm-tooltip__icon-trigger:focus-visible{border-radius:var(--bm-sem-radius-round);outline-offset:0px;outline:var(--bm-sem-border-width-focus) solid var(--bm-sem-color-border-focus)}.bm-tooltip__icon-trigger--disabled{opacity:var(--bm-sem-opacity-disabled);cursor:inherit}.bm-tooltip__icon-trigger--xs{border-radius:100%;height:var(--bm-comp-tooltip-size-icon-trigger-xs);width:var(--bm-comp-tooltip-size-icon-trigger-xs)}.bm-tooltip__icon-trigger--xs svg{height:var(--bm-comp-tooltip-size-icon-trigger-xs);width:var(--bm-comp-tooltip-size-icon-trigger-xs)}.bm-tooltip__icon-trigger--sm{border-radius:100%;height:var(--bm-comp-tooltip-size-icon-trigger-sm);width:var(--bm-comp-tooltip-size-icon-trigger-sm)}.bm-tooltip__icon-trigger--sm svg{height:var(--bm-comp-tooltip-size-icon-trigger-sm);width:var(--bm-comp-tooltip-size-icon-trigger-sm)}.bm-tooltip__icon-trigger--md{border-radius:100%;height:var(--bm-comp-tooltip-size-icon-trigger-md);width:var(--bm-comp-tooltip-size-icon-trigger-md)}.bm-tooltip__icon-trigger--md svg{height:var(--bm-comp-tooltip-size-icon-trigger-md);width:var(--bm-comp-tooltip-size-icon-trigger-md)}.bm-tooltip__icon-trigger--lg{border-radius:100%;height:var(--bm-comp-tooltip-size-icon-trigger-lg);width:var(--bm-comp-tooltip-size-icon-trigger-lg)}.bm-tooltip__icon-trigger--lg svg{height:var(--bm-comp-tooltip-size-icon-trigger-lg);width:var(--bm-comp-tooltip-size-icon-trigger-lg)}.bm-tooltip__icon-trigger--xl{border-radius:100%;height:var(--bm-comp-tooltip-size-icon-trigger-xl);width:var(--bm-comp-tooltip-size-icon-trigger-xl)}.bm-tooltip__icon-trigger--xl svg{height:var(--bm-comp-tooltip-size-icon-trigger-xl);width:var(--bm-comp-tooltip-size-icon-trigger-xl)}`, te = ["top", "right", "bottom", "left"], Ht = ["start", "end"], Ft = /* @__PURE__ */ te.reduce((t, e) => t.concat(e, e + "-" + Ht[0], e + "-" + Ht[1]), []), tt = Math.min, q = Math.max, ft = Math.round, ct = Math.floor, F = (t) => ({
+  x: t,
+  y: t
+}), Pe = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Re = {
+  start: "end",
+  end: "start"
+};
+function yt(t, e, n) {
+  return q(t, tt(e, n));
+}
+function J(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function z(t) {
+  return t.split("-")[0];
+}
+function M(t) {
+  return t.split("-")[1];
+}
+function Ct(t) {
+  return t === "x" ? "y" : "x";
+}
+function Ot(t) {
+  return t === "y" ? "height" : "width";
+}
+function et(t) {
+  return ["top", "bottom"].includes(z(t)) ? "y" : "x";
+}
+function At(t) {
+  return Ct(et(t));
+}
+function ee(t, e, n) {
+  n === void 0 && (n = !1);
+  const i = M(t), o = At(t), r = Ot(o);
+  let s = o === "x" ? i === (n ? "end" : "start") ? "right" : "left" : i === "start" ? "bottom" : "top";
+  return e.reference[r] > e.floating[r] && (s = it(s)), [s, it(s)];
+}
+function Le(t) {
+  const e = it(t);
+  return [pt(t), e, pt(e)];
+}
+function pt(t) {
+  return t.replace(/start|end/g, (e) => Re[e]);
+}
+function Se(t, e, n) {
+  const i = ["left", "right"], o = ["right", "left"], r = ["top", "bottom"], s = ["bottom", "top"];
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? o : i : e ? i : o;
+    case "left":
+    case "right":
+      return e ? r : s;
+    default:
+      return [];
+  }
+}
+function _e(t, e, n, i) {
+  const o = M(t);
+  let r = Se(z(t), n === "start", i);
+  return o && (r = r.map((s) => s + "-" + o), e && (r = r.concat(r.map(pt)))), r;
+}
+function it(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => Pe[e]);
+}
+function ze(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function oe(t) {
+  return typeof t != "number" ? ze(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function mt(t) {
+  const {
+    x: e,
+    y: n,
+    width: i,
+    height: o
+  } = t;
+  return {
+    width: i,
+    height: o,
+    top: n,
+    left: e,
+    right: e + i,
+    bottom: n + o,
+    x: e,
+    y: n
+  };
+}
+function Mt(t, e, n) {
+  let {
+    reference: i,
+    floating: o
+  } = t;
+  const r = et(e), s = At(e), l = Ot(s), c = z(e), a = r === "y", m = i.x + i.width / 2 - o.width / 2, f = i.y + i.height / 2 - o.height / 2, d = i[l] / 2 - o[l] / 2;
+  let p;
+  switch (c) {
+    case "top":
+      p = {
+        x: m,
+        y: i.y - o.height
+      };
+      break;
+    case "bottom":
+      p = {
+        x: m,
+        y: i.y + i.height
+      };
+      break;
+    case "right":
+      p = {
+        x: i.x + i.width,
+        y: f
+      };
+      break;
+    case "left":
+      p = {
+        x: i.x - o.width,
+        y: f
+      };
+      break;
+    default:
+      p = {
+        x: i.x,
+        y: i.y
+      };
+  }
+  switch (M(e)) {
+    case "start":
+      p[s] -= d * (n && a ? -1 : 1);
+      break;
+    case "end":
+      p[s] += d * (n && a ? -1 : 1);
+      break;
+  }
+  return p;
+}
+const Te = async (t, e, n) => {
+  const {
+    placement: i = "bottom",
+    strategy: o = "absolute",
+    middleware: r = [],
+    platform: s
+  } = n, l = r.filter(Boolean), c = await (s.isRTL == null ? void 0 : s.isRTL(e));
+  let a = await s.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: o
+  }), {
+    x: m,
+    y: f
+  } = Mt(a, i, c), d = i, p = {}, b = 0;
+  for (let g = 0; g < l.length; g++) {
+    const {
+      name: h,
+      fn: u
+    } = l[g], {
+      x: y,
+      y: w,
+      data: A,
+      reset: x
+    } = await u({
+      x: m,
+      y: f,
+      initialPlacement: i,
+      placement: d,
+      strategy: o,
+      middlewareData: p,
+      rects: a,
+      platform: s,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    m = y ?? m, f = w ?? f, p = {
+      ...p,
+      [h]: {
+        ...p[h],
+        ...A
+      }
+    }, x && b <= 50 && (b++, typeof x == "object" && (x.placement && (d = x.placement), x.rects && (a = x.rects === !0 ? await s.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: o
+    }) : x.rects), {
+      x: m,
+      y: f
+    } = Mt(a, d, c)), g = -1);
+  }
+  return {
+    x: m,
+    y: f,
+    placement: d,
+    strategy: o,
+    middlewareData: p
+  };
+};
+async function st(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const {
+    x: i,
+    y: o,
+    platform: r,
+    rects: s,
+    elements: l,
+    strategy: c
+  } = t, {
+    boundary: a = "clippingAncestors",
+    rootBoundary: m = "viewport",
+    elementContext: f = "floating",
+    altBoundary: d = !1,
+    padding: p = 0
+  } = J(e, t), b = oe(p), h = l[d ? f === "floating" ? "reference" : "floating" : f], u = mt(await r.getClippingRect({
+    element: (n = await (r.isElement == null ? void 0 : r.isElement(h))) == null || n ? h : h.contextElement || await (r.getDocumentElement == null ? void 0 : r.getDocumentElement(l.floating)),
+    boundary: a,
+    rootBoundary: m,
+    strategy: c
+  })), y = f === "floating" ? {
+    x: i,
+    y: o,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, w = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(l.floating)), A = await (r.isElement == null ? void 0 : r.isElement(w)) ? await (r.getScale == null ? void 0 : r.getScale(w)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, x = mt(r.convertOffsetParentRelativeRectToViewportRelativeRect ? await r.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: y,
+    offsetParent: w,
+    strategy: c
+  }) : y);
+  return {
+    top: (u.top - x.top + b.top) / A.y,
+    bottom: (x.bottom - u.bottom + b.bottom) / A.y,
+    left: (u.left - x.left + b.left) / A.x,
+    right: (x.right - u.right + b.right) / A.x
+  };
+}
+function ke(t, e, n) {
+  return (t ? [...n.filter((o) => M(o) === t), ...n.filter((o) => M(o) !== t)] : n.filter((o) => z(o) === o)).filter((o) => t ? M(o) === t || (e ? pt(o) !== o : !1) : !0);
+}
+const De = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(e) {
+      var n, i, o;
+      const {
+        rects: r,
+        middlewareData: s,
+        placement: l,
+        platform: c,
+        elements: a
+      } = e, {
+        crossAxis: m = !1,
+        alignment: f,
+        allowedPlacements: d = Ft,
+        autoAlignment: p = !0,
+        ...b
+      } = J(t, e), g = f !== void 0 || d === Ft ? ke(f || null, p, d) : d, h = await st(e, b), u = ((n = s.autoPlacement) == null ? void 0 : n.index) || 0, y = g[u];
+      if (y == null)
+        return {};
+      const w = ee(y, r, await (c.isRTL == null ? void 0 : c.isRTL(a.floating)));
+      if (l !== y)
+        return {
+          reset: {
+            placement: g[0]
+          }
+        };
+      const A = [h[z(y)], h[w[0]], h[w[1]]], x = [...((i = s.autoPlacement) == null ? void 0 : i.overflows) || [], {
+        placement: y,
+        overflows: A
+      }], D = g[u + 1];
+      if (D)
+        return {
+          data: {
+            index: u + 1,
+            overflows: x
+          },
+          reset: {
+            placement: D
+          }
+        };
+      const R = x.map((E) => {
+        const S = M(E.placement);
+        return [E.placement, S && m ? (
+          // Check along the mainAxis and main crossAxis side.
+          E.overflows.slice(0, 2).reduce((Y, W) => Y + W, 0)
+        ) : (
+          // Check only the mainAxis.
+          E.overflows[0]
+        ), E.overflows];
+      }).sort((E, S) => E[1] - S[1]), N = ((o = R.filter((E) => E[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        M(E[0]) ? 2 : 3
+      ).every((S) => S <= 0))[0]) == null ? void 0 : o[0]) || R[0][0];
+      return N !== l ? {
+        data: {
+          index: u + 1,
+          overflows: x
+        },
+        reset: {
+          placement: N
+        }
+      } : {};
+    }
+  };
+}, Be = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n, i;
+      const {
+        placement: o,
+        middlewareData: r,
+        rects: s,
+        initialPlacement: l,
+        platform: c,
+        elements: a
+      } = e, {
+        mainAxis: m = !0,
+        crossAxis: f = !0,
+        fallbackPlacements: d,
+        fallbackStrategy: p = "bestFit",
+        fallbackAxisSideDirection: b = "none",
+        flipAlignment: g = !0,
+        ...h
+      } = J(t, e);
+      if ((n = r.arrow) != null && n.alignmentOffset)
+        return {};
+      const u = z(o), y = et(l), w = z(l) === l, A = await (c.isRTL == null ? void 0 : c.isRTL(a.floating)), x = d || (w || !g ? [it(l)] : Le(l)), D = b !== "none";
+      !d && D && x.push(..._e(l, g, b, A));
+      const R = [l, ...x], B = await st(e, h), N = [];
+      let E = ((i = r.flip) == null ? void 0 : i.overflows) || [];
+      if (m && N.push(B[u]), f) {
+        const $ = ee(o, s, A);
+        N.push(B[$[0]], B[$[1]]);
+      }
+      if (E = [...E, {
+        placement: o,
+        overflows: N
+      }], !N.every(($) => $ <= 0)) {
+        var S, Y;
+        const $ = (((S = r.flip) == null ? void 0 : S.index) || 0) + 1, U = R[$];
+        if (U)
+          return {
+            data: {
+              index: $,
+              overflows: E
+            },
+            reset: {
+              placement: U
+            }
+          };
+        let K = (Y = E.filter((V) => V.overflows[0] <= 0).sort((V, H) => V.overflows[1] - H.overflows[1])[0]) == null ? void 0 : Y.placement;
+        if (!K)
+          switch (p) {
+            case "bestFit": {
+              var W;
+              const V = (W = E.filter((H) => {
+                if (D) {
+                  const _ = et(H.placement);
+                  return _ === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  _ === "y";
+                }
+                return !0;
+              }).map((H) => [H.placement, H.overflows.filter((_) => _ > 0).reduce((_, gt) => _ + gt, 0)]).sort((H, _) => H[1] - _[1])[0]) == null ? void 0 : W[0];
+              V && (K = V);
+              break;
+            }
+            case "initialPlacement":
+              K = l;
+              break;
+          }
+        if (o !== K)
+          return {
+            reset: {
+              placement: K
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function jt(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function It(t) {
+  return te.some((e) => t[e] >= 0);
+}
+const $e = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const {
+        rects: n
+      } = e, {
+        strategy: i = "referenceHidden",
+        ...o
+      } = J(t, e);
+      switch (i) {
+        case "referenceHidden": {
+          const r = await st(e, {
+            ...o,
+            elementContext: "reference"
+          }), s = jt(r, n.reference);
+          return {
+            data: {
+              referenceHiddenOffsets: s,
+              referenceHidden: It(s)
+            }
+          };
+        }
+        case "escaped": {
+          const r = await st(e, {
+            ...o,
+            altBoundary: !0
+          }), s = jt(r, n.floating);
+          return {
+            data: {
+              escapedOffsets: s,
+              escaped: It(s)
+            }
+          };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+};
+async function He(t, e) {
+  const {
+    placement: n,
+    platform: i,
+    elements: o
+  } = t, r = await (i.isRTL == null ? void 0 : i.isRTL(o.floating)), s = z(n), l = M(n), c = et(n) === "y", a = ["left", "top"].includes(s) ? -1 : 1, m = r && c ? -1 : 1, f = J(e, t);
+  let {
+    mainAxis: d,
+    crossAxis: p,
+    alignmentAxis: b
+  } = typeof f == "number" ? {
+    mainAxis: f,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: f.mainAxis || 0,
+    crossAxis: f.crossAxis || 0,
+    alignmentAxis: f.alignmentAxis
+  };
+  return l && typeof b == "number" && (p = l === "end" ? b * -1 : b), c ? {
+    x: p * m,
+    y: d * a
+  } : {
+    x: d * a,
+    y: p * m
+  };
+}
+const Fe = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, i;
+      const {
+        x: o,
+        y: r,
+        placement: s,
+        middlewareData: l
+      } = e, c = await He(e, t);
+      return s === ((n = l.offset) == null ? void 0 : n.placement) && (i = l.arrow) != null && i.alignmentOffset ? {} : {
+        x: o + c.x,
+        y: r + c.y,
+        data: {
+          ...c,
+          placement: s
+        }
+      };
+    }
+  };
+}, Me = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: n,
+        y: i,
+        placement: o
+      } = e, {
+        mainAxis: r = !0,
+        crossAxis: s = !1,
+        limiter: l = {
+          fn: (h) => {
+            let {
+              x: u,
+              y
+            } = h;
+            return {
+              x: u,
+              y
+            };
+          }
+        },
+        ...c
+      } = J(t, e), a = {
+        x: n,
+        y: i
+      }, m = await st(e, c), f = et(z(o)), d = Ct(f);
+      let p = a[d], b = a[f];
+      if (r) {
+        const h = d === "y" ? "top" : "left", u = d === "y" ? "bottom" : "right", y = p + m[h], w = p - m[u];
+        p = yt(y, p, w);
+      }
+      if (s) {
+        const h = f === "y" ? "top" : "left", u = f === "y" ? "bottom" : "right", y = b + m[h], w = b - m[u];
+        b = yt(y, b, w);
+      }
+      const g = l.fn({
+        ...e,
+        [d]: p,
+        [f]: b
+      });
+      return {
+        ...g,
+        data: {
+          x: g.x - n,
+          y: g.y - i,
+          enabled: {
+            [d]: r,
+            [f]: s
+          }
+        }
+      };
+    }
+  };
+};
+function dt() {
+  return typeof window < "u";
+}
+function nt(t) {
+  return ne(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function L(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function I(t) {
+  var e;
+  return (e = (ne(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function ne(t) {
+  return dt() ? t instanceof Node || t instanceof L(t).Node : !1;
+}
+function T(t) {
+  return dt() ? t instanceof Element || t instanceof L(t).Element : !1;
+}
+function j(t) {
+  return dt() ? t instanceof HTMLElement || t instanceof L(t).HTMLElement : !1;
+}
+function Nt(t) {
+  return !dt() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof L(t).ShadowRoot;
+}
+function lt(t) {
+  const {
+    overflow: e,
+    overflowX: n,
+    overflowY: i,
+    display: o
+  } = k(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + i + n) && !["inline", "contents"].includes(o);
+}
+function je(t) {
+  return ["table", "td", "th"].includes(nt(t));
+}
+function ut(t) {
+  return [":popover-open", ":modal"].some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+function Et(t) {
+  const e = Pt(), n = T(t) ? k(t) : t;
+  return ["transform", "translate", "scale", "rotate", "perspective"].some((i) => n[i] ? n[i] !== "none" : !1) || (n.containerType ? n.containerType !== "normal" : !1) || !e && (n.backdropFilter ? n.backdropFilter !== "none" : !1) || !e && (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 Ie(t) {
+  let e = X(t);
+  for (; j(e) && !ot(e); ) {
+    if (Et(e))
+      return e;
+    if (ut(e))
+      return null;
+    e = X(e);
+  }
+  return null;
+}
+function Pt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function ot(t) {
+  return ["html", "body", "#document"].includes(nt(t));
+}
+function k(t) {
+  return L(t).getComputedStyle(t);
+}
+function ht(t) {
+  return T(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function X(t) {
+  if (nt(t) === "html")
+    return t;
+  const e = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    Nt(t) && t.host || // Fallback.
+    I(t)
+  );
+  return Nt(e) ? e.host : e;
+}
+function ie(t) {
+  const e = X(t);
+  return ot(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : j(e) && lt(e) ? e : ie(e);
+}
+function rt(t, e, n) {
+  var i;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const o = ie(t), r = o === ((i = t.ownerDocument) == null ? void 0 : i.body), s = L(o);
+  if (r) {
+    const l = wt(s);
+    return e.concat(s, s.visualViewport || [], lt(o) ? o : [], l && n ? rt(l) : []);
+  }
+  return e.concat(o, rt(o, [], n));
+}
+function wt(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function se(t) {
+  const e = k(t);
+  let n = parseFloat(e.width) || 0, i = parseFloat(e.height) || 0;
+  const o = j(t), r = o ? t.offsetWidth : n, s = o ? t.offsetHeight : i, l = ft(n) !== r || ft(i) !== s;
+  return l && (n = r, i = s), {
+    width: n,
+    height: i,
+    $: l
+  };
+}
+function Rt(t) {
+  return T(t) ? t : t.contextElement;
+}
+function Q(t) {
+  const e = Rt(t);
+  if (!j(e))
+    return F(1);
+  const n = e.getBoundingClientRect(), {
+    width: i,
+    height: o,
+    $: r
+  } = se(e);
+  let s = (r ? ft(n.width) : n.width) / i, l = (r ? ft(n.height) : n.height) / o;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: s,
+    y: l
+  };
+}
+const Ne = /* @__PURE__ */ F(0);
+function re(t) {
+  const e = L(t);
+  return !Pt() || !e.visualViewport ? Ne : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function We(t, e, n) {
+  return e === void 0 && (e = !1), !n || e && n !== L(t) ? !1 : e;
+}
+function Z(t, e, n, i) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const o = t.getBoundingClientRect(), r = Rt(t);
+  let s = F(1);
+  e && (i ? T(i) && (s = Q(i)) : s = Q(t));
+  const l = We(r, n, i) ? re(r) : F(0);
+  let c = (o.left + l.x) / s.x, a = (o.top + l.y) / s.y, m = o.width / s.x, f = o.height / s.y;
+  if (r) {
+    const d = L(r), p = i && T(i) ? L(i) : i;
+    let b = d, g = wt(b);
+    for (; g && i && p !== b; ) {
+      const h = Q(g), u = g.getBoundingClientRect(), y = k(g), w = u.left + (g.clientLeft + parseFloat(y.paddingLeft)) * h.x, A = u.top + (g.clientTop + parseFloat(y.paddingTop)) * h.y;
+      c *= h.x, a *= h.y, m *= h.x, f *= h.y, c += w, a += A, b = L(g), g = wt(b);
+    }
+  }
+  return mt({
+    width: m,
+    height: f,
+    x: c,
+    y: a
+  });
+}
+function Lt(t, e) {
+  const n = ht(t).scrollLeft;
+  return e ? e.left + n : Z(I(t)).left + n;
+}
+function le(t, e, n) {
+  n === void 0 && (n = !1);
+  const i = t.getBoundingClientRect(), o = i.left + e.scrollLeft - (n ? 0 : (
+    // RTL <body> scrollbar.
+    Lt(t, i)
+  )), r = i.top + e.scrollTop;
+  return {
+    x: o,
+    y: r
+  };
+}
+function Ue(t) {
+  let {
+    elements: e,
+    rect: n,
+    offsetParent: i,
+    strategy: o
+  } = t;
+  const r = o === "fixed", s = I(i), l = e ? ut(e.floating) : !1;
+  if (i === s || l && r)
+    return n;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = F(1);
+  const m = F(0), f = j(i);
+  if ((f || !f && !r) && ((nt(i) !== "body" || lt(s)) && (c = ht(i)), j(i))) {
+    const p = Z(i);
+    a = Q(i), m.x = p.x + i.clientLeft, m.y = p.y + i.clientTop;
+  }
+  const d = s && !f && !r ? le(s, c, !0) : F(0);
+  return {
+    width: n.width * a.x,
+    height: n.height * a.y,
+    x: n.x * a.x - c.scrollLeft * a.x + m.x + d.x,
+    y: n.y * a.y - c.scrollTop * a.y + m.y + d.y
+  };
+}
+function Ve(t) {
+  return Array.from(t.getClientRects());
+}
+function Ke(t) {
+  const e = I(t), n = ht(t), i = t.ownerDocument.body, o = q(e.scrollWidth, e.clientWidth, i.scrollWidth, i.clientWidth), r = q(e.scrollHeight, e.clientHeight, i.scrollHeight, i.clientHeight);
+  let s = -n.scrollLeft + Lt(t);
+  const l = -n.scrollTop;
+  return k(i).direction === "rtl" && (s += q(e.clientWidth, i.clientWidth) - o), {
+    width: o,
+    height: r,
+    x: s,
+    y: l
+  };
+}
+function Xe(t, e) {
+  const n = L(t), i = I(t), o = n.visualViewport;
+  let r = i.clientWidth, s = i.clientHeight, l = 0, c = 0;
+  if (o) {
+    r = o.width, s = o.height;
+    const a = Pt();
+    (!a || a && e === "fixed") && (l = o.offsetLeft, c = o.offsetTop);
+  }
+  return {
+    width: r,
+    height: s,
+    x: l,
+    y: c
+  };
+}
+function Ye(t, e) {
+  const n = Z(t, !0, e === "fixed"), i = n.top + t.clientTop, o = n.left + t.clientLeft, r = j(t) ? Q(t) : F(1), s = t.clientWidth * r.x, l = t.clientHeight * r.y, c = o * r.x, a = i * r.y;
+  return {
+    width: s,
+    height: l,
+    x: c,
+    y: a
+  };
+}
+function Wt(t, e, n) {
+  let i;
+  if (e === "viewport")
+    i = Xe(t, n);
+  else if (e === "document")
+    i = Ke(I(t));
+  else if (T(e))
+    i = Ye(e, n);
+  else {
+    const o = re(t);
+    i = {
+      x: e.x - o.x,
+      y: e.y - o.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return mt(i);
+}
+function ce(t, e) {
+  const n = X(t);
+  return n === e || !T(n) || ot(n) ? !1 : k(n).position === "fixed" || ce(n, e);
+}
+function qe(t, e) {
+  const n = e.get(t);
+  if (n)
+    return n;
+  let i = rt(t, [], !1).filter((l) => T(l) && nt(l) !== "body"), o = null;
+  const r = k(t).position === "fixed";
+  let s = r ? X(t) : t;
+  for (; T(s) && !ot(s); ) {
+    const l = k(s), c = Et(s);
+    !c && l.position === "fixed" && (o = null), (r ? !c && !o : !c && l.position === "static" && !!o && ["absolute", "fixed"].includes(o.position) || lt(s) && !c && ce(t, s)) ? i = i.filter((m) => m !== s) : o = l, s = X(s);
+  }
+  return e.set(t, i), i;
+}
+function Ge(t) {
+  let {
+    element: e,
+    boundary: n,
+    rootBoundary: i,
+    strategy: o
+  } = t;
+  const s = [...n === "clippingAncestors" ? ut(e) ? [] : qe(e, this._c) : [].concat(n), i], l = s[0], c = s.reduce((a, m) => {
+    const f = Wt(e, m, o);
+    return a.top = q(f.top, a.top), a.right = tt(f.right, a.right), a.bottom = tt(f.bottom, a.bottom), a.left = q(f.left, a.left), a;
+  }, Wt(e, l, o));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function Ze(t) {
+  const {
+    width: e,
+    height: n
+  } = se(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function Je(t, e, n) {
+  const i = j(e), o = I(e), r = n === "fixed", s = Z(t, !0, r, e);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = F(0);
+  if (i || !i && !r)
+    if ((nt(e) !== "body" || lt(o)) && (l = ht(e)), i) {
+      const d = Z(e, !0, r, e);
+      c.x = d.x + e.clientLeft, c.y = d.y + e.clientTop;
+    } else o && (c.x = Lt(o));
+  const a = o && !i && !r ? le(o, l) : F(0), m = s.left + l.scrollLeft - c.x - a.x, f = s.top + l.scrollTop - c.y - a.y;
+  return {
+    x: m,
+    y: f,
+    width: s.width,
+    height: s.height
+  };
+}
+function vt(t) {
+  return k(t).position === "static";
+}
+function Ut(t, e) {
+  if (!j(t) || k(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let n = t.offsetParent;
+  return I(t) === n && (n = n.ownerDocument.body), n;
+}
+function ae(t, e) {
+  const n = L(t);
+  if (ut(t))
+    return n;
+  if (!j(t)) {
+    let o = X(t);
+    for (; o && !ot(o); ) {
+      if (T(o) && !vt(o))
+        return o;
+      o = X(o);
+    }
+    return n;
+  }
+  let i = Ut(t, e);
+  for (; i && je(i) && vt(i); )
+    i = Ut(i, e);
+  return i && ot(i) && vt(i) && !Et(i) ? n : i || Ie(t) || n;
+}
+const Qe = async function(t) {
+  const e = this.getOffsetParent || ae, n = this.getDimensions, i = await n(t.floating);
+  return {
+    reference: Je(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: i.width,
+      height: i.height
+    }
+  };
+};
+function to(t) {
+  return k(t).direction === "rtl";
+}
+const eo = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ue,
+  getDocumentElement: I,
+  getClippingRect: Ge,
+  getOffsetParent: ae,
+  getElementRects: Qe,
+  getClientRects: Ve,
+  getDimensions: Ze,
+  getScale: Q,
+  isElement: T,
+  isRTL: to
+};
+function fe(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function oo(t, e) {
+  let n = null, i;
+  const o = I(t);
+  function r() {
+    var l;
+    clearTimeout(i), (l = n) == null || l.disconnect(), n = null;
+  }
+  function s(l, c) {
+    l === void 0 && (l = !1), c === void 0 && (c = 1), r();
+    const a = t.getBoundingClientRect(), {
+      left: m,
+      top: f,
+      width: d,
+      height: p
+    } = a;
+    if (l || e(), !d || !p)
+      return;
+    const b = ct(f), g = ct(o.clientWidth - (m + d)), h = ct(o.clientHeight - (f + p)), u = ct(m), w = {
+      rootMargin: -b + "px " + -g + "px " + -h + "px " + -u + "px",
+      threshold: q(0, tt(1, c)) || 1
+    };
+    let A = !0;
+    function x(D) {
+      const R = D[0].intersectionRatio;
+      if (R !== c) {
+        if (!A)
+          return s();
+        R ? s(!1, R) : i = setTimeout(() => {
+          s(!1, 1e-7);
+        }, 1e3);
+      }
+      R === 1 && !fe(a, t.getBoundingClientRect()) && s(), A = !1;
+    }
+    try {
+      n = new IntersectionObserver(x, {
+        ...w,
+        // Handle <iframe>s
+        root: o.ownerDocument
+      });
+    } catch {
+      n = new IntersectionObserver(x, w);
+    }
+    n.observe(t);
+  }
+  return s(!0), r;
+}
+function no(t, e, n, i) {
+  i === void 0 && (i = {});
+  const {
+    ancestorScroll: o = !0,
+    ancestorResize: r = !0,
+    elementResize: s = typeof ResizeObserver == "function",
+    layoutShift: l = typeof IntersectionObserver == "function",
+    animationFrame: c = !1
+  } = i, a = Rt(t), m = o || r ? [...a ? rt(a) : [], ...rt(e)] : [];
+  m.forEach((u) => {
+    o && u.addEventListener("scroll", n, {
+      passive: !0
+    }), r && u.addEventListener("resize", n);
+  });
+  const f = a && l ? oo(a, n) : null;
+  let d = -1, p = null;
+  s && (p = new ResizeObserver((u) => {
+    let [y] = u;
+    y && y.target === a && p && (p.unobserve(e), cancelAnimationFrame(d), d = requestAnimationFrame(() => {
+      var w;
+      (w = p) == null || w.observe(e);
+    })), n();
+  }), a && !c && p.observe(a), p.observe(e));
+  let b, g = c ? Z(t) : null;
+  c && h();
+  function h() {
+    const u = Z(t);
+    g && !fe(g, u) && n(), g = u, b = requestAnimationFrame(h);
+  }
+  return n(), () => {
+    var u;
+    m.forEach((y) => {
+      o && y.removeEventListener("scroll", n), r && y.removeEventListener("resize", n);
+    }), f == null || f(), (u = p) == null || u.disconnect(), p = null, c && cancelAnimationFrame(b);
+  };
+}
+const io = Fe, so = De, ro = Me, lo = Be, co = $e, ao = (t, e, n) => {
+  const i = /* @__PURE__ */ new Map(), o = {
+    platform: eo,
+    ...n
+  }, r = {
+    ...o.platform,
+    _c: i
+  };
+  return Te(t, e, {
+    ...o,
+    platform: r
+  });
+}, fo = (t) => {
+  var e;
+  return {
+    visibility: (e = t.hide) != null && e.referenceHidden ? "hidden" : "visible"
+  };
+}, po = (t) => ({
+  name: "arrowStyles",
+  options: t,
+  async fn(e) {
+    var St, _t;
+    const { x: n, y: i, placement: o, rects: r, platform: s, elements: l, middlewareData: c } = e, { element: a, padding: m = 0 } = J(t, e) || {};
+    if (a == null)
+      return {};
+    const f = oe(m), d = { x: n, y: i }, p = At(o), b = Ct(p), g = Ot(p), h = await s.getDimensions(a), u = p === "y", y = u ? "top" : "left", w = u ? "bottom" : "right", A = u ? "clientHeight" : "clientWidth", x = r.reference[g] + r.reference[p] - d[p] - r.floating[g], D = d[p] - r.reference[p], R = await ((St = s.getOffsetParent) == null ? void 0 : St.call(s, a));
+    let B = R ? R[A] : 0;
+    (!B || !await ((_t = s.isElement) == null ? void 0 : _t.call(s, R))) && (B = l.floating[A] || r.floating[g]);
+    const N = x / 2 - D / 2, E = B / 2 - h.width / 2 - 1, S = tt(f[y], E), Y = tt(f[w], E), W = S, $ = B - h.width - Y, U = B / 2 - h.width / 2 + N, K = yt(W, U, $), V = !c.arrow && M(o) != null && U !== K && r.reference[g] / 2 - (U < W ? S : Y) - h.width / 2 < 0, H = V ? U < W ? U - W : U - $ : 0, _ = z(o), gt = ["top", "left"].includes(_) ? -1 : 1, de = h.height * gt, ue = uo({
+      placement: _,
+      arrowHeight: h.height,
+      arrowWidth: h.width,
+      // pass arrow middleware
+      [p]: K
+      // for posterity, this is what the floating-ui arrow middleware returns
+      // centerOffset: center - offset - alignmentOffset,
+      // ...(shouldAddOffset && { alignmentOffset }),
+    });
+    return {
+      [p]: d[p] + H,
+      [b]: d[b] + de,
+      data: ue,
+      reset: V
+    };
+  }
+}), at = (t, e, n, i) => {
+  if (i) {
+    const o = i === !0 ? n() : n(i);
+    t[e](o);
+  }
+}, mo = ({
+  baseConfig: t,
+  middleware: e,
+  offset: n,
+  arrow: i,
+  placement: o = "top"
+}) => {
+  const r = { ...t, placement: o };
+  let s = [];
+  if (typeof e.overrides != "object") {
+    s.push(io(n));
+    let l = e.flip ?? !0;
+    e.autoPlacement && (l = !1), at(
+      s,
+      "unshift",
+      so,
+      e.autoPlacement
+    ), at(s, "push", ro, e.shift ?? !0), at(s, "unshift", lo, l), at(s, "push", co, e.hide ?? !0);
+  } else
+    s.push(...e.overrides);
+  return i.hide || s.push(po(i.options)), typeof e.overrides == "function" && (s = e.overrides(s)), r.middleware = s, r;
+}, uo = ({
+  placement: t,
+  arrowHeight: e,
+  arrowWidth: n,
+  x: i,
+  y: o
+}) => {
+  const r = z(t), s = n / 2 - e, l = {
+    /* since the default orientation is pointing down, we don't need to rotate the arrow
+    if the tooltip is on top of the reference element
+     */
+    top: "rotate(0deg)",
+    // since the default orientation is pointing down, we don't need to translate the arrow
+    bottom: "rotate(180deg)",
+    /* For an arrow with non-equal width and height, once we rotate the arrow 90 degrees
+        for left and right positions, the top-left corner of the arrow will not be the same
+        as the top-left corner of the original downward-pointing arrow. Thus, top:0 for
+        example will not place the arrow at the top of the tooltip.
+    
+        To fix this, we need to translate the arrow along the x-axis by the difference between
+        the arrow's width and height.
+    
+         * Example: note that the transformation origin is always bottom-center
+         *
+         * default, downward pointing position    rotated 90 degrees, offset from edge
+         * |________  =>                         |     |\  <- the top is slightly higher!
+         * |   ..                                |     | *
+         * |                                     |     |/
+    
+        We use translate X to move it along vertical axis as translations are applied before
+        rotation transformations. In both situations, the overall effect is sliding the
+        arrow downwards.
+         */
+    left: `rotate(-90deg) translateX(${-s}px)`,
+    right: `rotate(90deg) translateX(${s}px)`
+  }[r], c = -n / 2 - e, a = {
+    /*
+     * If the tooltip is at the top of the anchor, place the arrow at the bottom of
+     * the tooltip with bottom: 0. The bottom of the arrow will be flush with the bottom
+     * of the tooltip. Result:
+     * v   (arrow)
+     * --- (bottom of tooltip)
+     *
+     * Then, shift it down by its height so the flat, top side of the arrow is
+     * flush with the bottom of the tooltip.
+     *
+     * --- (bottom of tooltip)
+     * v   (arrow)
+     */
+    top: `${-e}px`,
+    /*
+     * Place the arrow at the top of the tooltip with top: 0. The arrow will be rotated
+     * to point downwards by default. When it's then rotated by 180 deg with
+     * transform-origin as bottom center, we need to shift the arrow up by its height
+     * so it's still flush with the top.
+     *
+     * Then, we need to shift the arrow up by its height again so its bottom edge is
+     * flush with the top of the tooltip.
+     *
+     * In summary the arrow is shifted up by 2 * arrowHeight, or top: -2 * arrowHeight
+     */
+    bottom: `${-e * 2}px`,
+    /*
+     * Place the arrow at the right of the tooltip with right: 0. When we rotate
+     * the arrow 90 degrees clockwise about the bottom center, there will now be
+     * space between the right edge of the tooltip and the arrow. To fix this, we
+     * need to shift the arrow left by the difference between half of the
+     * arrow's width and the arrow's height (the two lengths on the horizontal axis)
+     *
+     * Example: note that the transformation origin is always bottom-center
+     *
+     * default, downward pointing position       rotated 90 degrees, offset from edge
+     * |                                        |
+     * |--------  =>                            |     |\
+     * |   ..                                   |     | *
+     * |                                        |     |/
+     */
+    left: `${c}px`,
+    // similarly for the right side
+    right: `${c}px`
+  }[r], m = {
+    transform: l
+  };
+  m.left = i != null ? `${i}px` : "", m.top = o != null ? `${o}px` : "";
+  const f = it(r);
+  return m[f] = a, m;
+}, ho = ".bm-floatingui{z-index:999;position:absolute;inset:unset;top:0;left:0;width:max-content;overflow:unset;border:unset}.bm-floatingui__arrow{position:absolute;transform-origin:bottom center}.bm-floatingui__overlay{background:var(--bm-comp-dialog-color-overlay);padding:var(--bm-comp-dialog-space-viewport-offset);display:flex;justify-content:center;align-items:center;z-index:1}.bm-floatingui__overlay--transparent{background:transparent}";
+class go {
+  constructor(e) {
+    this.eventMap = /* @__PURE__ */ new Map(), this.elements = /* @__PURE__ */ new Map(), e.addController(this);
+  }
+  /**
+   * Registers an element to be managed by the controller. Adds previously
+   * registered event listeners if specified by assignListeners
+   *
+   * Removes registered event listeners on previous element with id, if it exists
+   *
+   * @param elementId - element id used as reference to this element controller
+   * @param eventTarget - element to assign to id
+   * @param assignListeners - a map of categories to booleans to dynamically add the
+   * category listeners to the element. Or pass in true to add them all.
+   */
+  registerElement(e, n, i = !1) {
+    if (this.elements.has(e) && this.removeAllEventListeners(), this.elements.set(e, n), i) {
+      const o = typeof i == "object" ? (r) => i[r] : void 0;
+      this.assignEventListeners(e, o);
+    }
+  }
+  /**
+   * Registers event listeners for a singular element under a category name
+   *
+   * @param categoryName - name of category
+   * @param elementId - id representing element. Matches arg in `registerElement`
+   * @param handlers - key/value pair(s) of event listeners and their
+   *
+   * @example
+   * this.registerEventListeners('hover', element, [
+   *   {
+   *     event: 'mouseenter',
+   *     handler: mouseenter,
+   *   },
+   *   {
+   *     event: 'mouseleave',
+   *     handler: mouseleave,
+   *   },
+   * ]);
+   */
+  registerEventListeners(e, n, i) {
+    this.eventMap.has(e) || this.eventMap.set(e, /* @__PURE__ */ new Map());
+    const o = this.eventMap.get(e);
+    if (typeof i == "function")
+      o && o.set(n, [i]);
+    else {
+      const r = i.filter(
+        (s) => !!s
+      );
+      o && o.set(n, r);
+    }
+  }
+  /**
+   * Registers hover event listeners
+   *
+   * @param elementId
+   * @param mouseenter
+   * @param mouseleave
+   */
+  registerHoverListener(e, n, i) {
+    this.registerEventListeners("hover", e, [
+      {
+        event: "mouseenter",
+        handler: n
+      },
+      i && {
+        event: "mouseleave",
+        handler: i
+      }
+    ]);
+  }
+  /**
+   * Registers click event listeners
+   *
+   * @param elementId
+   * @param click
+   */
+  registerClickListener(e, n) {
+    this.registerEventListeners("click", e, [
+      { event: "click", handler: n }
+    ]);
+  }
+  /**
+   * Registers focus and blur event listeners
+   *
+   * @param elementId
+   * @param focus
+   * @param blur
+   */
+  registerFocusListener(e, n, i) {
+    this.registerEventListeners("focus", e, [
+      { event: "focus", handler: n },
+      i && { event: "blur", handler: i }
+    ]);
+  }
+  /**
+   * Removes all event listeners
+   */
+  removeAllEventListeners() {
+    this.eventMap.forEach((e, n) => {
+      this.removeEventListeners(n);
+    });
+  }
+  hostDisconnected() {
+    this.removeAllEventListeners();
+  }
+  /**
+   * Adds event listeners for a specific category
+   *
+   * @param category
+   */
+  addEventListeners(e) {
+    this.setEventListeners(e, "addEventListener");
+  }
+  /**
+   * Removes event listeners for a specific category
+   *
+   * @param category
+   */
+  removeEventListeners(e) {
+    this.setEventListeners(e, "removeEventListener");
+  }
+  /**
+   * Assigns event listeners to an element based on the category
+   *
+   * @param elementId
+   * @param categoryFilter - Optional filter to only assign event listeners for a specific category
+   * @private
+   */
+  assignEventListeners(e, n) {
+    const i = this.elements.get(e);
+    return i ? (this.eventMap.forEach((o, r) => {
+      (n === void 0 || n(r)) && o.forEach((s, l) => {
+        l === e && s.forEach(({ event: c, handler: a }) => {
+          i.addEventListener(c, a);
+        });
+      });
+    }), !0) : (console.warn(`Element ${e} not found`), !1);
+  }
+  /**
+   * Perform action with handler  on all elements in category
+   *
+   * @param category
+   * @param action
+   * @private
+   */
+  setEventListeners(e, n) {
+    var i;
+    if (!this.eventMap.has(e)) {
+      console.warn(`No event listeners registered for ${e}`);
+      return;
+    }
+    (i = this.eventMap.get(e)) == null || i.forEach((o, r) => {
+      const s = this.elements.get(r);
+      if (!s) {
+        console.warn(
+          `Cannot ${n} to ${r} for event category ${e}`
+        );
+        return;
+      }
+      o.forEach(({ event: l, handler: c }) => {
+        s[n](l, c);
+      });
+    });
+  }
+}
+class Vt {
+  constructor(e) {
+    e.addController(this);
+  }
+  hostDisconnected() {
+    this.cancelSchedule();
+  }
+  /**
+   * Schedule a function to run after a delay.
+   *
+   * @param callback - The function to run.
+   * @param delay - The delay in milliseconds.
+   */
+  schedule(e, n) {
+    this.timer || (this.timer = setTimeout(e, n));
+  }
+  /**
+   * Cancel the scheduled function.
+   */
+  cancelSchedule() {
+    clearTimeout(this.timer), this.timer = void 0;
+  }
+}
+var vo = Object.defineProperty, Kt = (t, e, n, i) => {
+  for (var o = void 0, r = t.length - 1, s; r >= 0; r--)
+    (s = t[r]) && (o = s(e, n, o) || o);
+  return o && vo(e, n, o), o;
+};
+const bo = (t) => {
+  class e extends t {
+    shouldToggle(i, o) {
+      i && this.fireChange(o);
+      const r = this._isOpen === o, s = this.open === !o;
+      return !(r || s);
+    }
+    /**
+     * Fire a custom event when the floating event is triggered
+     * with an internal event
+     *
+     * @param change - whether the floating content is open or closed
+     */
+    fireChange(i) {
+      const o = `${ye}toggle`;
+      this.dispatchEvent(
+        new CustomEvent(o, {
+          detail: { open: i },
+          bubbles: !0,
+          composed: !0
+        })
+      );
+    }
+  }
+  return Kt([
+    v({ type: Boolean })
+  ], e.prototype, "open"), Kt([
+    ge()
+  ], e.prototype, "_isOpen"), e;
+};
+var yo = Object.defineProperty, P = (t, e, n, i) => {
+  for (var o = void 0, r = t.length - 1, s; r >= 0; r--)
+    (s = t[r]) && (o = s(e, n, o) || o);
+  return o && yo(e, n, o), o;
+};
+const {
+  subElementClassPrefix: wo,
+  baseClassNamePrefix: xo
+} = Gt("floatingui"), Xt = {
+  content: xo,
+  arrow: `${wo}arrow`
+}, Co = ve("popover"), Oo = (t) => {
+  const n = class n extends bo(t) {
+    constructor() {
+      super(), this.hideArrow = !1, this.shift = !0, this.autoHiding = !0, this.defaultOpen = !1, this.showDelay = 0, this.hideDelay = 0, this.popoverAPI = !0, this.disableAutoAria = !1, this.autoDescribedById = Oe(), this.openOnClick = !1, this.openOnHover = !1, this.openOnFocus = !1, this.initialRender = !0, this.contentRef = zt(), this.edgePadding = 0, this.shouldReturnFocus = !1, this.eventPrefix = "bm-floatingui", this.arrowRef = zt(), this.shouldUsePopoverAPI = !1, this.anchor = null, this.eventController = new go(this), this.autoUpdateCleanup = null, this.closeController = new Vt(this), this.openController = new Vt(this), this.openContent = this.openContent.bind(this), this.mouseEnterHandler = this.mouseEnterHandler.bind(this), this.mouseLeaveHandler = this.mouseLeaveHandler.bind(this), this.closeContent = this.closeContent.bind(this), this.toggleContent = this.toggleContent.bind(this), this.contentSlotHandler = this.contentSlotHandler.bind(this), this.environmentClickListener = this.environmentClickListener.bind(this), this.handleKeydown = this.handleKeydown.bind(this), this.eventController.registerClickListener("anchor", this.toggleContent), this.eventController.registerHoverListener(
+        "anchor",
+        this.mouseEnterHandler,
+        this.mouseLeaveHandler
+      ), this.eventController.registerFocusListener(
+        "anchor",
+        this.openContent,
+        this.closeContent
+      ), this.eventController.registerHoverListener(
+        "content",
+        this.openContent,
+        this.closeContent
+      ), this.eventController.registerElement("document", document), this.eventController.registerEventListeners("open", "document", [
+        {
+          event: "mousedown",
+          handler: this.environmentClickListener
+        }
+      ]), this.eventController.registerElement("window", window), this.eventController.registerEventListeners("open", "window", [
+        {
+          event: "keydown",
+          handler: this.handleKeydown
+        }
+      ]);
+    }
+    disconnectedCallback() {
+      var o;
+      (o = this.autoUpdateCleanup) == null || o.call(this), this._isOpen = !1, super.disconnectedCallback();
+    }
+    /**
+     * Close the floating content.
+     *
+     * Focus will be returned to the anchor element if
+     * the open state was triggered by a click or focus event.
+     *
+     * @param internal - whether the close was triggered internally;
+     * if true, the change event will be fired
+     */
+    closeContent(o) {
+      if (!this.shouldToggle(!!o, !1))
+        return;
+      this.contentRef.value.setAttribute("data-status", "close");
+      const s = () => {
+        var l, c;
+        this.shouldUsePopoverAPI && this.contentRef.value.hidePopover(), this._isOpen = !1, (l = this.autoUpdateCleanup) == null || l.call(this), this.eventController.removeEventListeners("open"), this.shouldReturnFocus && ((c = this.anchor) == null || c.focus(), this.shouldReturnFocus = !1);
+      };
+      this.closeController.schedule(s, this.hideDelay);
+    }
+    /**
+     * Open the floating content. `open` attribute overrides this method call.
+     *
+     * @param internal - whether the close was triggered internally;
+     * if true, the change event will be fired
+     */
+    openContent(o) {
+      this.contentRef.value.setAttribute("data-status", "open"), this.closeController.cancelSchedule(), this.shouldUsePopoverAPI && this.contentRef.value.showPopover(), this.shouldToggle(!!o, !0) && (this._isOpen = !0, this.eventController.addEventListeners("open"), this.positionFloatingContent());
+    }
+    /**
+     * Toggle the visibility of the floating content.
+     *
+     * @param internal - whether the close was triggered internally;
+     * if true, the change event will be fired
+     */
+    toggleContent(o) {
+      this._isOpen ? this.closeContent(o) : (this.shouldReturnFocus = !0, this.openContent(o));
+    }
+    positionFloatingContent() {
+      var s;
+      (s = this.autoUpdateCleanup) == null || s.call(this);
+      let o = {};
+      o = mo({
+        baseConfig: o,
+        middleware: {
+          autoPlacement: this.autoPlacement,
+          flip: this.flip,
+          hide: this.autoHiding,
+          shift: this.shift,
+          overrides: this.middleware
+        },
+        offset: this.offset || 0,
+        arrow: {
+          options: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            element: this.arrowRef.value,
+            padding: this.edgePadding
+          },
+          hide: this.hideArrow
+        },
+        placement: this.placement
+      });
+      const r = () => (
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        ao(this.anchor, this.contentRef.value, o).then(
+          (l) => {
+            const { x: c, y: a, middlewareData: m } = l;
+            Object.assign(this.contentRef.value.style, {
+              ...fo(m),
+              // translation more performant than top left
+              transform: `translate(${c}px, ${a}px)`
+            }), this.arrowRef.value && m.arrowStyles && Object.assign(this.arrowRef.value.style, m.arrowStyles);
+          }
+        )
+      );
+      this.autoUpdateCleanup = no(
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.anchor,
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.contentRef.value,
+        r
+      );
+    }
+    shouldUpdate(o) {
+      if (this.initialRender)
+        return !0;
+      if (o.has("open")) {
+        if (this._isOpen === this.open)
+          return !1;
+        const s = this._isOpen;
+        return this.open ? this.openContent() : this.closeContent(), s !== this._isOpen;
+      }
+      return super.shouldUpdate(o);
+    }
+    /**
+     * Lifecycle method called when the element is first updated
+     *
+     * Sets the initialRender flag to false only if additional operations on the initial render
+     * are not required. For example, if the floating content should be open by default, the
+     * initialRender flag should not be set to false.
+     *
+     * @param changedProperties
+     * @protected
+     */
+    firstUpdated(o) {
+      super.firstUpdated(o), this.defaultOpen || (this.initialRender = !1), this.eventController.registerElement("content", this.contentRef.value, {
+        hover: this.openOnHover
+      });
+    }
+    /**
+     * Handle slotchange event on the body slot. Currently just
+     * sets the id on the light dom ƒor aria purposes
+     *
+     * @param e
+     * @protected
+     */
+    contentSlotHandler(o) {
+      if (this.disableAutoAria)
+        return;
+      const { child: r } = Dt("bm-floatingui", "content", o);
+      r.setAttribute("id", this.autoDescribedById);
+    }
+    environmentClickListener(o) {
+      if (!this._isOpen || this.open)
+        return;
+      const r = kt(o, this.anchor), s = kt(o, this.contentRef.value);
+      r || s || this.closeContent(!0);
+    }
+    willUpdate(o) {
+      super.willUpdate(o), o.has("popoverAPI") && (this.shouldUsePopoverAPI = this.popoverAPI && Co);
+    }
+    updated(o) {
+      if (super.updated(o), this.anchor && ["click", "hover", "focus"].forEach((m) => {
+        const f = `openOn${be(m)}`;
+        o.has(f) && (this[f] ? this.eventController.addEventListeners(m) : this.eventController.removeEventListeners(m));
+      }), o.has("autoDescribedById") && !this.disableAutoAria && this.anchor)
+        if (this.autoDescribedById)
+          Bt(this.anchor, "aria-describedby", this.autoDescribedById);
+        else {
+          const a = o.get("autoDescribedById");
+          if (!a)
+            return;
+          Ae(this.anchor, "aria-describedby", a);
+        }
+      const l = Ee(
+        o,
+        [
+          "placement",
+          "autoPlacement",
+          "flip",
+          "shift",
+          "autoHiding",
+          "middleware"
+        ]
+      ) && this._isOpen, c = o.has("_isOpen");
+      l && !c && this.positionFloatingContent();
+    }
+    mouseEnterHandler() {
+      const o = () => {
+        this.openContent(!0);
+      };
+      this.openController.schedule(o, this.showDelay);
+    }
+    mouseLeaveHandler() {
+      this.openController.cancelSchedule(), this.closeContent(!0);
+    }
+    anchorSlotHandler(o) {
+      const { child: r } = Dt("bm-floatingui", "anchor", o);
+      this.anchor = r, this.eventController.registerElement("anchor", r, {
+        hover: this.openOnHover,
+        click: this.openOnClick,
+        focus: this.openOnFocus
+      }), this.disableAutoAria || Bt(r, "aria-describedby", this.autoDescribedById), this.open ? this.openContent() : this.defaultOpen && this.initialRender && (this.openContent(), this.initialRender = !1);
+    }
+    handleKeydown(o) {
+      o.key === "Escape" && this.closeContent(!0);
+    }
+  };
+  n.styles = [
+    xt(ho),
+    he`
+        :host {
+          display: contents;
+        }
+      `
+  ];
+  let e = n;
+  return P([
+    v({ type: Boolean })
+  ], e.prototype, "hideArrow"), P([
+    v({ type: String })
+  ], e.prototype, "placement"), P([
+    v({ type: Object })
+  ], e.prototype, "autoPlacement"), P([
+    v({ type: Object })
+  ], e.prototype, "flip"), P([
+    v({ type: Object })
+  ], e.prototype, "shift"), P([
+    v({ type: Object })
+  ], e.prototype, "autoHiding"), P([
+    v({ type: Object })
+  ], e.prototype, "middleware"), P([
+    v({ type: Boolean })
+  ], e.prototype, "defaultOpen"), P([
+    v({ type: Number })
+  ], e.prototype, "showDelay"), P([
+    v({ type: Number })
+  ], e.prototype, "hideDelay"), P([
+    v({ type: Boolean, converter: Jt })
+  ], e.prototype, "popoverAPI"), P([
+    v({ type: Boolean })
+  ], e.prototype, "disableAutoAria"), P([
+    v({ type: String })
+  ], e.prototype, "autoDescribedById"), P([
+    v()
+  ], e.prototype, "offset"), P([
+    v({ type: Boolean })
+  ], e.prototype, "openOnClick"), P([
+    v({ type: Boolean })
+  ], e.prototype, "openOnHover"), P([
+    v({ type: Boolean })
+  ], e.prototype, "openOnFocus"), e;
+};
+var Ao = Object.defineProperty, Eo = Object.getOwnPropertyDescriptor, Po = Object.getPrototypeOf, Ro = Reflect.get, O = (t, e, n, i) => {
+  for (var o = i > 1 ? void 0 : i ? Eo(e, n) : e, r = t.length - 1, s; r >= 0; r--)
+    (s = t[r]) && (o = (i ? s(e, n, o) : s(o)) || o);
+  return i && o && Ao(e, n, o), o;
+}, pe = (t, e, n) => Ro(Po(t), n, e);
+const { subElementClassPrefix: me, baseClassNamePrefix: Lo } = Gt("tooltip");
+let C = class extends Oo(qt) {
+  constructor() {
+    super(), this.disabled = !1, this.triggerSize = "md", this.eventPrefix = "tooltip", this.hideDelay = 200, $t(xe, this, "edgePadding"), $t(Ce, this, "offset");
+  }
+  willUpdate(t) {
+    super.willUpdate(t);
+    const e = (n) => {
+      this.openOnHover = n, this.openOnFocus = n;
+    };
+    t.has("disabled") && e(!this.disabled);
+  }
+  render() {
+    return Yt` <slot name="trigger" @slotchange=${this.anchorSlotHandler}></slot>
+      <div
+        role="tooltip"
+        @slotchange=${this.contentSlotHandler}
+        aria-hidden=${!this._isOpen}
+        ${Tt(this.contentRef)}
+        class=${bt(
+      this.theme && we(this.theme),
+      Xt.content,
+      Lo
+    )}
+        popover="manual"
+        style="display: ${this._isOpen ? "block" : "none"}"
+      >
+        <slot name="text"></slot>
+        <span
+          class=${bt(Xt.arrow, `${me}arrow`)}
+          ${Tt(this.arrowRef)}
+        >
+        </span>
+      </div>`;
+  }
+};
+C.styles = [
+  xt(Qt),
+  pe(C, C, "styles") ?? []
+];
+O([
+  v({ type: String })
+], C.prototype, "theme", 2);
+O([
+  v({ type: Boolean })
+], C.prototype, "open", 2);
+O([
+  v({ type: Boolean })
+], C.prototype, "hideArrow", 2);
+O([
+  v({ type: String })
+], C.prototype, "placement", 2);
+O([
+  v({ type: Object })
+], C.prototype, "autoPlacement", 2);
+O([
+  v({ type: Object })
+], C.prototype, "flip", 2);
+O([
+  v({ type: Object })
+], C.prototype, "shift", 2);
+O([
+  v({ type: Object })
+], C.prototype, "autoHiding", 2);
+O([
+  v({ type: Object })
+], C.prototype, "middleware", 2);
+O([
+  v({ type: Boolean })
+], C.prototype, "defaultOpen", 2);
+O([
+  v({ type: Number })
+], C.prototype, "showDelay", 2);
+O([
+  v({ type: Boolean, converter: Jt })
+], C.prototype, "popoverAPI", 2);
+O([
+  v({ type: Boolean })
+], C.prototype, "disableAutoAria", 2);
+O([
+  v({ type: String })
+], C.prototype, "autoDescribedById", 2);
+O([
+  v({ type: Boolean })
+], C.prototype, "disabled", 2);
+O([
+  v({ type: String })
+], C.prototype, "triggerSize", 2);
+C = O([
+  Zt("bm-tooltip")
+], C);
+let G = class extends qt {
+  constructor() {
+    super(...arguments), this.size = "md", this.disabled = !1;
+  }
+  render() {
+    const t = `${me}icon-trigger`, e = bt(
+      t,
+      this.size !== "none" && `${t}--${this.size}`,
+      this.disabled && `${t}--disabled`
+    );
+    return Yt`<button class=${e} aria-label="tooltip trigger">
+      <slot></slot>
+    </button>`;
+  }
+};
+G.styles = [
+  xt(Qt),
+  pe(G, G, "styles") ?? []
+];
+O([
+  v({ type: String })
+], G.prototype, "size", 2);
+O([
+  v({ type: Boolean })
+], G.prototype, "disabled", 2);
+G = O([
+  Zt("bm-tooltip-icon-trigger")
+], G);
+export {
+  C as BmTooltip,
+  G as BmTooltipIconTrigger
+};