@konstructio/ui 0.1.2-alpha.10 → 0.1.2-alpha.103

package/dist/dist-C2aTw0m62.js

@@ -0,0 +1,1320 @@
+import { a as Xt } from "./dist-DqKFpce5.js";
+import { t as Ot } from "./dist-CVy-ulDZ.js";
+import { i as ve, n as xt } from "./dist-D4FePjTS.js";
+import { t as xe } from "./dist-ppXKUlVt.js";
+import { t as ye } from "./dist-C2s4VX-42.js";
+import * as O from "react";
+import { useLayoutEffect as be } from "react";
+import * as Ae from "react-dom";
+import { jsx as V } from "react/jsx-runtime";
+var Re = [
+  "top",
+  "right",
+  "bottom",
+  "left"
+], K = Math.min, I = Math.max, lt = Math.round, st = Math.floor, j = (t) => ({
+  x: t,
+  y: t
+}), Pe = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+};
+function Yt(t, e, n) {
+  return I(t, K(e, n));
+}
+function Y(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function U(t) {
+  return t.split("-")[0];
+}
+function et(t) {
+  return t.split("-")[1];
+}
+function Ct(t) {
+  return t === "x" ? "y" : "x";
+}
+function St(t) {
+  return t === "y" ? "height" : "width";
+}
+function N(t) {
+  const e = t[0];
+  return e === "t" || e === "b" ? "y" : "x";
+}
+function Et(t) {
+  return Ct(N(t));
+}
+function Oe(t, e, n) {
+  n === void 0 && (n = !1);
+  const r = et(t), i = Et(t), o = St(i);
+  let s = i === "x" ? r === (n ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return e.reference[o] > e.floating[o] && (s = at(s)), [s, at(s)];
+}
+function Ce(t) {
+  const e = at(t);
+  return [
+    Rt(t),
+    e,
+    Rt(e)
+  ];
+}
+function Rt(t) {
+  return t.includes("start") ? t.replace("start", "end") : t.replace("end", "start");
+}
+var Ft = ["left", "right"], Wt = ["right", "left"], Se = ["top", "bottom"], Ee = ["bottom", "top"];
+function Le(t, e, n) {
+  switch (t) {
+    case "top":
+    case "bottom":
+      return n ? e ? Wt : Ft : e ? Ft : Wt;
+    case "left":
+    case "right":
+      return e ? Se : Ee;
+    default:
+      return [];
+  }
+}
+function Te(t, e, n, r) {
+  const i = et(t);
+  let o = Le(U(t), n === "start", r);
+  return i && (o = o.map((s) => s + "-" + i), e && (o = o.concat(o.map(Rt)))), o;
+}
+function at(t) {
+  const e = U(t);
+  return Pe[e] + t.slice(e.length);
+}
+function $e(t) {
+  var e, n, r, i;
+  return {
+    top: (e = t.top) != null ? e : 0,
+    right: (n = t.right) != null ? n : 0,
+    bottom: (r = t.bottom) != null ? r : 0,
+    left: (i = t.left) != null ? i : 0
+  };
+}
+function qt(t) {
+  return typeof t != "number" ? $e(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function ft(t) {
+  const { x: e, y: n, width: r, height: i } = t;
+  return {
+    width: r,
+    height: i,
+    top: n,
+    left: e,
+    right: e + r,
+    bottom: n + i,
+    x: e,
+    y: n
+  };
+}
+function kt(t, e, n) {
+  let { reference: r, floating: i } = t;
+  const o = N(e), s = Et(e), c = St(s), l = U(e), u = o === "y", a = r.x + r.width / 2 - i.width / 2, m = r.y + r.height / 2 - i.height / 2, p = r[c] / 2 - i[c] / 2;
+  let f;
+  switch (l) {
+    case "top":
+      f = {
+        x: a,
+        y: r.y - i.height
+      };
+      break;
+    case "bottom":
+      f = {
+        x: a,
+        y: r.y + r.height
+      };
+      break;
+    case "right":
+      f = {
+        x: r.x + r.width,
+        y: m
+      };
+      break;
+    case "left":
+      f = {
+        x: r.x - i.width,
+        y: m
+      };
+      break;
+    default:
+      f = {
+        x: r.x,
+        y: r.y
+      };
+  }
+  const d = et(e);
+  return d && (f[s] += p * (d === "end" ? 1 : -1) * (n && u ? -1 : 1)), f;
+}
+async function De(t, e) {
+  var n;
+  e === void 0 && (e = {});
+  const { x: r, y: i, platform: o, rects: s, elements: c, strategy: l } = t, { boundary: u = "clippingAncestors", rootBoundary: a = "viewport", elementContext: m = "floating", altBoundary: p = !1, padding: f = 0 } = Y(e, t), d = qt(f), h = c[p ? m === "floating" ? "reference" : "floating" : m], g = ft(await o.getClippingRect({
+    element: (n = await (o.isElement == null ? void 0 : o.isElement(h))) == null || n ? h : h.contextElement || await (o.getDocumentElement == null ? void 0 : o.getDocumentElement(c.floating)),
+    boundary: u,
+    rootBoundary: a,
+    strategy: l
+  })), w = m === "floating" ? {
+    x: r,
+    y: i,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, v = await (o.getOffsetParent == null ? void 0 : o.getOffsetParent(c.floating)), b = await (o.isElement == null ? void 0 : o.isElement(v)) && await (o.getScale == null ? void 0 : o.getScale(v)) || {
+    x: 1,
+    y: 1
+  }, y = ft(o.convertOffsetParentRelativeRectToViewportRelativeRect ? await o.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: c,
+    rect: w,
+    offsetParent: v,
+    strategy: l
+  }) : w);
+  return {
+    top: (g.top - y.top + d.top) / b.y,
+    bottom: (y.bottom - g.bottom + d.bottom) / b.y,
+    left: (g.left - y.left + d.left) / b.x,
+    right: (y.right - g.right + d.right) / b.x
+  };
+}
+var Me = 50, _e = async (t, e, n) => {
+  const { placement: r = "bottom", strategy: i = "absolute", middleware: o = [], platform: s } = n, c = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: De
+  }, l = await (s.isRTL == null ? void 0 : s.isRTL(e));
+  let u = await s.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), { x: a, y: m } = kt(u, r, l), p = r, f = 0;
+  const d = {};
+  for (let h = 0; h < o.length; h++) {
+    const g = o[h];
+    if (!g) continue;
+    const { name: w, fn: v } = g, { x: b, y, data: R, reset: x } = await v({
+      x: a,
+      y: m,
+      initialPlacement: r,
+      placement: p,
+      strategy: i,
+      middlewareData: d,
+      rects: u,
+      platform: c,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    a = b ?? a, m = y ?? m, d[w] = {
+      ...d[w],
+      ...R
+    }, x && f < Me && (f++, typeof x == "object" && (x.placement && (p = x.placement), x.rects && (u = x.rects === !0 ? await s.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: i
+    }) : x.rects), { x: a, y: m } = kt(u, p, l)), h = -1);
+  }
+  return {
+    x: a,
+    y: m,
+    placement: p,
+    strategy: i,
+    middlewareData: d
+  };
+}, Fe = (t) => ({
+  name: "arrow",
+  options: t,
+  async fn(e) {
+    const { x: n, y: r, placement: i, rects: o, platform: s, elements: c, middlewareData: l } = e, { element: u, padding: a = 0 } = Y(t, e) || {};
+    if (u == null) return {};
+    const m = qt(a), p = {
+      x: n,
+      y: r
+    }, f = Et(i), d = St(f), h = await s.getDimensions(u), g = f === "y", w = g ? "top" : "left", v = g ? "bottom" : "right", b = g ? "clientHeight" : "clientWidth", y = o.reference[d] + o.reference[f] - p[f] - o.floating[d], R = p[f] - o.reference[f], x = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
+    let A = x ? x[b] : 0;
+    (!A || !await (s.isElement == null ? void 0 : s.isElement(x))) && (A = c.floating[b] || o.floating[d]);
+    const C = y / 2 - R / 2, D = A / 2 - h[d] / 2 - 1, $ = K(m[w], D), k = K(m[v], D), H = A - h[d] - k, T = A / 2 - h[d] / 2 + C, S = Yt($, T, H), F = !l.arrow && et(i) != null && T !== S && o.reference[d] / 2 - (T < $ ? $ : k) - h[d] / 2 < 0, E = F ? T < $ ? T - $ : T - H : 0;
+    return {
+      [f]: p[f] + E,
+      data: {
+        [f]: S,
+        centerOffset: T - S - E,
+        ...F && { alignmentOffset: E }
+      },
+      reset: F
+    };
+  }
+}), We = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var n, r;
+      const { placement: i, middlewareData: o, rects: s, initialPlacement: c, platform: l, elements: u } = e, { mainAxis: a = !0, crossAxis: m = !0, fallbackPlacements: p, fallbackStrategy: f = "bestFit", fallbackAxisSideDirection: d = "none", flipAlignment: h = !0, ...g } = Y(t, e);
+      if ((n = o.arrow) != null && n.alignmentOffset) return {};
+      const w = U(i), v = N(c), b = U(c) === c, y = await (l.isRTL == null ? void 0 : l.isRTL(u.floating)), R = p || (b || !h ? [at(c)] : Ce(c)), x = d !== "none";
+      !p && x && R.push(...Te(c, h, d, y));
+      const A = [c, ...R], C = await l.detectOverflow(e, g), D = [];
+      let $ = ((r = o.flip) == null ? void 0 : r.overflows) || [];
+      if (a && D.push(C[w]), m) {
+        const S = Oe(i, s, y);
+        D.push(C[S[0]], C[S[1]]);
+      }
+      if ($ = [...$, {
+        placement: i,
+        overflows: D
+      }], !D.every((S) => S <= 0)) {
+        var k, H;
+        const S = (((k = o.flip) == null ? void 0 : k.index) || 0) + 1, F = A[S];
+        if (F && (!(m === "alignment" && v !== N(F)) || $.every((M) => N(M.placement) === v ? M.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: S,
+              overflows: $
+            },
+            reset: { placement: F }
+          };
+        let E = (H = $.filter((M) => M.overflows[0] <= 0).sort((M, P) => M.overflows[1] - P.overflows[1])[0]) == null ? void 0 : H.placement;
+        if (!E) switch (f) {
+          case "bestFit": {
+            var T;
+            const M = (T = $.filter((P) => {
+              if (x) {
+                const L = N(P.placement);
+                return L === v || L === "y";
+              }
+              return !0;
+            }).map((P) => [P.placement, P.overflows.filter((L) => L > 0).reduce((L, W) => L + W, 0)]).sort((P, L) => P[1] - L[1])[0]) == null ? void 0 : T[0];
+            M && (E = M);
+            break;
+          }
+          case "initialPlacement":
+            E = c;
+            break;
+        }
+        if (i !== E) return { reset: { placement: E } };
+      }
+      return {};
+    }
+  };
+};
+function Ht(t, e) {
+  return {
+    top: t.top - e.height,
+    right: t.right - e.width,
+    bottom: t.bottom - e.height,
+    left: t.left - e.width
+  };
+}
+function Nt(t) {
+  return Re.some((e) => t[e] >= 0);
+}
+var ke = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "hide",
+    options: t,
+    async fn(e) {
+      const { rects: n, platform: r } = e, { strategy: i = "referenceHidden", ...o } = Y(t, e);
+      switch (i) {
+        case "referenceHidden": {
+          const s = Ht(await r.detectOverflow(e, {
+            ...o,
+            elementContext: "reference"
+          }), n.reference);
+          return { data: {
+            referenceHiddenOffsets: s,
+            referenceHidden: Nt(s)
+          } };
+        }
+        case "escaped": {
+          const s = Ht(await r.detectOverflow(e, {
+            ...o,
+            altBoundary: !0
+          }), n.floating);
+          return { data: {
+            escapedOffsets: s,
+            escaped: Nt(s)
+          } };
+        }
+        default:
+          return {};
+      }
+    }
+  };
+}, Kt = /* @__PURE__ */ new Set(["left", "top"]);
+async function He(t, e) {
+  const { placement: n, platform: r, elements: i } = t, o = await (r.isRTL == null ? void 0 : r.isRTL(i.floating)), s = U(n), c = et(n), l = N(n) === "y", u = Kt.has(s) ? -1 : 1, a = o && l ? -1 : 1, m = Y(e, t);
+  let { mainAxis: p, crossAxis: f, alignmentAxis: d } = typeof m == "number" ? {
+    mainAxis: m,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: m.mainAxis || 0,
+    crossAxis: m.crossAxis || 0,
+    alignmentAxis: m.alignmentAxis
+  };
+  return c && typeof d == "number" && (f = c === "end" ? d * -1 : d), l ? {
+    x: f * a,
+    y: p * u
+  } : {
+    x: p * u,
+    y: f * a
+  };
+}
+var Ne = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var n, r;
+      const { x: i, y: o, placement: s, middlewareData: c } = e, l = await He(e, t);
+      return s === ((n = c.offset) == null ? void 0 : n.placement) && (r = c.arrow) != null && r.alignmentOffset ? {} : {
+        x: i + l.x,
+        y: o + l.y,
+        data: {
+          ...l,
+          placement: s
+        }
+      };
+    }
+  };
+}, ze = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const { x: n, y: r, placement: i, platform: o } = e, { mainAxis: s = !0, crossAxis: c = !1, limiter: l = { fn: (v) => {
+        let { x: b, y } = v;
+        return {
+          x: b,
+          y
+        };
+      } }, ...u } = Y(t, e), a = {
+        x: n,
+        y: r
+      }, m = await o.detectOverflow(e, u), p = N(i), f = Ct(p);
+      let d = a[f], h = a[p];
+      const g = (v, b) => Yt(b + m[v === "y" ? "top" : "left"], b, b - m[v === "y" ? "bottom" : "right"]);
+      s && (d = g(f, d)), c && (h = g(p, h));
+      const w = l.fn({
+        ...e,
+        [f]: d,
+        [p]: h
+      });
+      return {
+        ...w,
+        data: {
+          x: w.x - n,
+          y: w.y - r,
+          enabled: {
+            [f]: s,
+            [p]: c
+          }
+        }
+      };
+    }
+  };
+}, Be = function(t) {
+  return t === void 0 && (t = {}), {
+    options: t,
+    fn(e) {
+      var n, r;
+      const { x: i, y: o, placement: s, rects: c, middlewareData: l } = e, { offset: u = 0, mainAxis: a = !0, crossAxis: m = !0 } = Y(t, e), p = {
+        x: i,
+        y: o
+      }, f = N(s), d = Ct(f);
+      let h = p[d], g = p[f];
+      const w = Y(u, e), v = typeof w == "number" ? {
+        mainAxis: w,
+        crossAxis: 0
+      } : {
+        mainAxis: (n = w.mainAxis) != null ? n : 0,
+        crossAxis: (r = w.crossAxis) != null ? r : 0
+      };
+      if (a) {
+        const R = d === "y" ? "height" : "width", x = c.reference[d] - c.floating[R] + v.mainAxis, A = c.reference[d] + c.reference[R] - v.mainAxis;
+        h < x ? h = x : h > A && (h = A);
+      }
+      if (m) {
+        var b, y;
+        const R = d === "y" ? "width" : "height", x = Kt.has(U(s)), A = c.reference[f] - c.floating[R] + (x && ((b = l.offset) == null ? void 0 : b[f]) || 0) + (x ? 0 : v.crossAxis), C = c.reference[f] + c.reference[R] + (x ? 0 : ((y = l.offset) == null ? void 0 : y[f]) || 0) - (x ? v.crossAxis : 0);
+        g < A ? g = A : g > C && (g = C);
+      }
+      return {
+        [d]: h,
+        [f]: g
+      };
+    }
+  };
+}, Ve = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      const { placement: n, rects: r, platform: i, elements: o } = e, { apply: s = () => {
+      }, ...c } = Y(t, e), l = await i.detectOverflow(e, c), u = U(n), a = et(n), m = N(n) === "y", { width: p, height: f } = r.floating;
+      let d, h;
+      u === "top" || u === "bottom" ? (d = u, h = a === (await (i.isRTL == null ? void 0 : i.isRTL(o.floating)) ? "start" : "end") ? "left" : "right") : (h = u, d = a === "end" ? "top" : "bottom");
+      const g = f - l.top - l.bottom, w = p - l.left - l.right, v = K(f - l[d], g), b = K(p - l[h], w), y = e.middlewareData.shift, R = !y;
+      let x = v, A = b;
+      y != null && y.enabled.x && (A = w), y != null && y.enabled.y && (x = g), R && !a && (m ? A = p - 2 * I(l.left, l.right) : x = f - 2 * I(l.top, l.bottom)), await s({
+        ...e,
+        availableWidth: A,
+        availableHeight: x
+      });
+      const C = await i.getDimensions(o.floating);
+      return p !== C.width || f !== C.height ? { reset: { rects: !0 } } : {};
+    }
+  };
+};
+function dt() {
+  return typeof window < "u";
+}
+function nt(t) {
+  return Ut(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function _(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function q(t) {
+  var e;
+  return (e = (Ut(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function Ut(t) {
+  return dt() ? t instanceof Node || t instanceof _(t).Node : !1;
+}
+function z(t) {
+  return dt() ? t instanceof Element || t instanceof _(t).Element : !1;
+}
+function Z(t) {
+  return dt() ? t instanceof HTMLElement || t instanceof _(t).HTMLElement : !1;
+}
+function zt(t) {
+  return !dt() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof _(t).ShadowRoot;
+}
+function mt(t) {
+  const { overflow: e, overflowX: n, overflowY: r, display: i } = B(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + r + n) && i !== "inline" && i !== "contents";
+}
+function Ie(t) {
+  return /^(table|td|th)$/.test(nt(t));
+}
+function pt(t) {
+  try {
+    if (t.matches(":popover-open")) return !0;
+  } catch {
+  }
+  try {
+    return t.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+var je = /transform|translate|scale|rotate|perspective|filter/, Xe = /paint|layout|strict|content/, G = (t) => !!t && t !== "none", yt;
+function Lt(t) {
+  const e = z(t) ? B(t) : t;
+  return G(e.transform) || G(e.translate) || G(e.scale) || G(e.rotate) || G(e.perspective) || !Tt() && (G(e.backdropFilter) || G(e.filter)) || je.test(e.willChange || "") || Xe.test(e.contain || "");
+}
+function Ye(t) {
+  let e = J(t);
+  for (; Z(e) && !rt(e); ) {
+    if (Lt(e)) return e;
+    if (pt(e)) return null;
+    e = J(e);
+  }
+  return null;
+}
+function Tt() {
+  return yt == null && (yt = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), yt;
+}
+function rt(t) {
+  return /^(html|body|#document)$/.test(nt(t));
+}
+function B(t) {
+  return _(t).getComputedStyle(t);
+}
+function ht(t) {
+  return z(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function J(t) {
+  if (nt(t) === "html") return t;
+  const e = t.assignedSlot || t.parentNode || zt(t) && t.host || q(t);
+  return zt(e) ? e.host : e;
+}
+function Zt(t) {
+  const e = J(t);
+  return rt(e) ? (t.ownerDocument || t).body : Z(e) && mt(e) ? e : Zt(e);
+}
+function ot(t, e, n) {
+  var r;
+  e === void 0 && (e = []), n === void 0 && (n = !0);
+  const i = Zt(t), o = i === ((r = t.ownerDocument) == null ? void 0 : r.body), s = _(i);
+  if (o) {
+    const c = Pt(s);
+    return e.concat(s, s.visualViewport || [], mt(i) ? i : [], c && n ? ot(c) : []);
+  } else return e.concat(i, ot(i, [], n));
+}
+function Pt(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function Gt(t) {
+  const e = B(t);
+  let n = parseFloat(e.width) || 0, r = parseFloat(e.height) || 0;
+  const i = Z(t), o = i ? t.offsetWidth : n, s = i ? t.offsetHeight : r, c = lt(n) !== o || lt(r) !== s;
+  return c && (n = o, r = s), {
+    width: n,
+    height: r,
+    $: c
+  };
+}
+function $t(t) {
+  return z(t) ? t : t.contextElement;
+}
+function tt(t) {
+  const e = $t(t);
+  if (!Z(e)) return j(1);
+  const n = e.getBoundingClientRect(), { width: r, height: i, $: o } = Gt(e);
+  let s = (o ? lt(n.width) : n.width) / r, c = (o ? lt(n.height) : n.height) / i;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!c || !Number.isFinite(c)) && (c = 1), {
+    x: s,
+    y: c
+  };
+}
+var qe = /* @__PURE__ */ j(0);
+function Jt(t) {
+  const e = _(t);
+  return !Tt() || !e.visualViewport ? qe : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function Ke(t, e, n) {
+  return e === void 0 && (e = !1), !!n && e && n === _(t);
+}
+function Q(t, e, n, r) {
+  e === void 0 && (e = !1), n === void 0 && (n = !1);
+  const i = t.getBoundingClientRect(), o = $t(t);
+  let s = j(1);
+  e && (r ? z(r) && (s = tt(r)) : s = tt(t));
+  const c = Ke(o, n, r) ? Jt(o) : j(0);
+  let l = (i.left + c.x) / s.x, u = (i.top + c.y) / s.y, a = i.width / s.x, m = i.height / s.y;
+  if (o && r) {
+    const p = _(o), f = z(r) ? _(r) : r;
+    let d = p, h = Pt(d);
+    for (; h && f !== d; ) {
+      const g = tt(h), w = h.getBoundingClientRect(), v = B(h), b = w.left + (h.clientLeft + parseFloat(v.paddingLeft)) * g.x, y = w.top + (h.clientTop + parseFloat(v.paddingTop)) * g.y;
+      l *= g.x, u *= g.y, a *= g.x, m *= g.y, l += b, u += y, d = _(h), h = Pt(d);
+    }
+  }
+  return ft({
+    width: a,
+    height: m,
+    x: l,
+    y: u
+  });
+}
+function gt(t, e) {
+  const n = ht(t).scrollLeft;
+  return e ? e.left + n : Q(q(t)).left + n;
+}
+function Qt(t, e) {
+  const n = t.getBoundingClientRect();
+  return {
+    x: n.left + e.scrollLeft - gt(t, n),
+    y: n.top + e.scrollTop
+  };
+}
+function Ue(t) {
+  let { elements: e, rect: n, offsetParent: r, strategy: i } = t;
+  const o = i === "fixed", s = q(r), c = e ? pt(e.floating) : !1;
+  if (r === s || c && o) return n;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, u = j(1);
+  const a = j(0), m = Z(r);
+  if ((m || !o) && ((nt(r) !== "body" || mt(s)) && (l = ht(r)), m)) {
+    const f = Q(r);
+    u = tt(r), a.x = f.x + r.clientLeft, a.y = f.y + r.clientTop;
+  }
+  const p = s && !m && !o ? Qt(s, l) : j(0);
+  return {
+    width: n.width * u.x,
+    height: n.height * u.y,
+    x: n.x * u.x - l.scrollLeft * u.x + a.x + p.x,
+    y: n.y * u.y - l.scrollTop * u.y + a.y + p.y
+  };
+}
+function Ze(t) {
+  return t.getClientRects ? Array.from(t.getClientRects()) : [];
+}
+function Ge(t) {
+  const e = ht(t), n = t.ownerDocument.body, r = I(t.scrollWidth, t.clientWidth, n.scrollWidth, n.clientWidth), i = I(t.scrollHeight, t.clientHeight, n.scrollHeight, n.clientHeight);
+  let o = -e.scrollLeft + gt(t);
+  const s = -e.scrollTop;
+  return B(n).direction === "rtl" && (o += I(t.clientWidth, n.clientWidth) - r), {
+    width: r,
+    height: i,
+    x: o,
+    y: s
+  };
+}
+var Je = 25;
+function Qe(t, e, n) {
+  n === void 0 && (n = "viewport");
+  const r = n === "layoutViewport", i = _(t), o = q(t), s = i.visualViewport;
+  let c = o.clientWidth, l = o.clientHeight, u = 0, a = 0;
+  if (s) {
+    const m = !Tt() || e === "fixed";
+    r ? m || (u = -s.offsetLeft, a = -s.offsetTop) : (c = s.width, l = s.height, m && (u = s.offsetLeft, a = s.offsetTop));
+  }
+  if (gt(o) <= 0) {
+    const m = o.ownerDocument, p = m.body, f = getComputedStyle(p), d = m.compatMode === "CSS1Compat" && parseFloat(f.marginLeft) + parseFloat(f.marginRight) || 0, h = Math.abs(o.clientWidth - p.clientWidth - d), g = getComputedStyle(o).scrollbarGutter === "stable both-edges" ? h / 2 : h;
+    g <= Je && (c -= g);
+  }
+  return {
+    width: c,
+    height: l,
+    x: u,
+    y: a
+  };
+}
+function tn(t, e) {
+  const n = Q(t, !0, e === "fixed"), r = n.top + t.clientTop, i = n.left + t.clientLeft, o = tt(t);
+  return {
+    width: t.clientWidth * o.x,
+    height: t.clientHeight * o.y,
+    x: i * o.x,
+    y: r * o.y
+  };
+}
+function Bt(t, e, n) {
+  let r;
+  if (e === "viewport" || e === "layoutViewport") r = Qe(t, n, e);
+  else if (e === "document") r = Ge(q(t));
+  else if (z(e)) r = tn(e, n);
+  else {
+    const i = Jt(t);
+    r = {
+      x: e.x - i.x,
+      y: e.y - i.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return ft(r);
+}
+function en(t, e) {
+  const n = e.get(t);
+  if (n) return n;
+  let r = ot(t, [], !1).filter((c) => z(c) && nt(c) !== "body"), i = null;
+  const o = B(t).position === "fixed";
+  let s = o ? J(t) : t;
+  for (; z(s) && !rt(s); ) {
+    const c = B(s), l = Lt(s), u = i ? i.position : o ? "fixed" : "";
+    !l && (u === "fixed" || u === "absolute" && c.position === "static") ? r = r.filter((a) => a !== s) : i = c, s = J(s);
+  }
+  return e.set(t, r), r;
+}
+function nn(t) {
+  let { element: e, boundary: n, rootBoundary: r, strategy: i } = t;
+  const o = [...n === "clippingAncestors" ? pt(e) ? [] : en(e, this._c) : [].concat(n), r], s = Bt(e, o[0], i);
+  let c = s.top, l = s.right, u = s.bottom, a = s.left;
+  for (let m = 1; m < o.length; m++) {
+    const p = Bt(e, o[m], i);
+    c = I(p.top, c), l = K(p.right, l), u = K(p.bottom, u), a = I(p.left, a);
+  }
+  return {
+    width: l - a,
+    height: u - c,
+    x: a,
+    y: c
+  };
+}
+function rn(t) {
+  const { width: e, height: n } = Gt(t);
+  return {
+    width: e,
+    height: n
+  };
+}
+function on(t, e, n) {
+  const r = Z(e), i = q(e), o = n === "fixed", s = Q(t, !0, o, e);
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = j(0);
+  if ((r || !o) && ((nt(e) !== "body" || mt(i)) && (c = ht(e)), r)) {
+    const a = Q(e, !0, o, e);
+    l.x = a.x + e.clientLeft, l.y = a.y + e.clientTop;
+  }
+  !r && i && (l.x = gt(i));
+  const u = i && !r && !o ? Qt(i, c) : j(0);
+  return {
+    x: s.left + c.scrollLeft - l.x - u.x,
+    y: s.top + c.scrollTop - l.y - u.y,
+    width: s.width,
+    height: s.height
+  };
+}
+function bt(t) {
+  return B(t).position === "static";
+}
+function Vt(t, e) {
+  if (!Z(t) || B(t).position === "fixed") return null;
+  if (e) return e(t);
+  let n = t.offsetParent;
+  return q(t) === n && (n = n.ownerDocument.body), n;
+}
+function te(t, e) {
+  const n = _(t);
+  if (pt(t)) return n;
+  if (!Z(t)) {
+    let i = J(t);
+    for (; i && !rt(i); ) {
+      if (z(i) && !bt(i)) return i;
+      i = J(i);
+    }
+    return n;
+  }
+  let r = Vt(t, e);
+  for (; r && Ie(r) && bt(r); ) r = Vt(r, e);
+  return r && rt(r) && bt(r) && !Lt(r) ? n : r || Ye(t) || n;
+}
+var sn = async function(t) {
+  const e = this.getOffsetParent || te, n = this.getDimensions, r = await n(t.floating);
+  return {
+    reference: on(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: r.width,
+      height: r.height
+    }
+  };
+};
+function cn(t) {
+  return B(t).direction === "rtl";
+}
+var ln = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: Ue,
+  getDocumentElement: q,
+  getClippingRect: nn,
+  getOffsetParent: te,
+  getElementRects: sn,
+  getClientRects: Ze,
+  getDimensions: rn,
+  getScale: tt,
+  isElement: z,
+  isRTL: cn
+};
+function ee(t, e) {
+  return t.x === e.x && t.y === e.y && t.width === e.width && t.height === e.height;
+}
+function an(t, e, n) {
+  let r = null, i;
+  const o = q(t);
+  function s() {
+    var a;
+    clearTimeout(i), (a = r) == null || a.disconnect(), r = null;
+  }
+  function c(a, m) {
+    a === void 0 && (a = !1), m === void 0 && (m = 1), s();
+    const p = t.getBoundingClientRect(), { left: f, top: d, width: h, height: g } = p;
+    if (a || e(), !h || !g) return;
+    const w = st(d), v = st(o.clientWidth - (f + h)), b = st(o.clientHeight - (d + g)), y = st(f), R = {
+      rootMargin: -w + "px " + -v + "px " + -b + "px " + -y + "px",
+      threshold: I(0, K(1, m)) || 1
+    };
+    let x = !0;
+    function A(C) {
+      const D = C[0].intersectionRatio;
+      if (!ee(p, t.getBoundingClientRect())) return c();
+      if (D !== m) {
+        if (!x) return c();
+        D ? c(!1, D) : i = setTimeout(() => {
+          c(!1, 1e-7);
+        }, 1e3);
+      }
+      x = !1;
+    }
+    try {
+      r = new IntersectionObserver(A, {
+        ...R,
+        root: o.ownerDocument
+      });
+    } catch {
+      r = new IntersectionObserver(A, R);
+    }
+    r.observe(t);
+  }
+  const l = _(t), u = () => c(n);
+  return l.addEventListener("resize", u), c(!0), () => {
+    l.removeEventListener("resize", u), s();
+  };
+}
+function fn(t, e, n, r) {
+  r === void 0 && (r = {});
+  const { ancestorScroll: i = !0, ancestorResize: o = !0, elementResize: s = typeof ResizeObserver == "function", layoutShift: c = typeof IntersectionObserver == "function", animationFrame: l = !1 } = r, u = $t(t), a = i || o ? [...u ? ot(u) : [], ...e ? ot(e) : []] : [];
+  a.forEach((w) => {
+    i && w.addEventListener("scroll", n), o && w.addEventListener("resize", n);
+  });
+  const m = u && c ? an(u, n, o) : null;
+  let p = -1, f = null;
+  s && (f = new ResizeObserver((w) => {
+    let [v] = w;
+    v && v.target === u && f && e && (f.unobserve(e), cancelAnimationFrame(p), p = requestAnimationFrame(() => {
+      var b;
+      (b = f) == null || b.observe(e);
+    })), n();
+  }), u && !l && f.observe(u), e && f.observe(e));
+  let d, h = l ? Q(t) : null;
+  l && g();
+  function g() {
+    const w = Q(t);
+    h && !ee(h, w) && n(), h = w, d = requestAnimationFrame(g);
+  }
+  return n(), () => {
+    var w;
+    a.forEach((v) => {
+      i && v.removeEventListener("scroll", n), o && v.removeEventListener("resize", n);
+    }), m?.(), (w = f) == null || w.disconnect(), f = null, l && cancelAnimationFrame(d);
+  };
+}
+var un = Ne, dn = ze, mn = We, pn = Ve, hn = ke, It = Fe, gn = Be, wn = (t, e, n) => {
+  const r = /* @__PURE__ */ new Map(), i = n ?? {}, o = {
+    ...ln,
+    ...i.platform,
+    _c: r
+  };
+  return _e(t, e, {
+    ...i,
+    platform: o
+  });
+}, ct = typeof document < "u" ? be : function() {
+};
+function ut(t, e) {
+  if (t === e) return !0;
+  if (typeof t != typeof e) return !1;
+  if (typeof t == "function" && t.toString() === e.toString()) return !0;
+  let n, r, i;
+  if (t && e && typeof t == "object") {
+    if (Array.isArray(t)) {
+      if (n = t.length, n !== e.length) return !1;
+      for (r = n; r-- !== 0; ) if (!ut(t[r], e[r])) return !1;
+      return !0;
+    }
+    if (i = Object.keys(t), n = i.length, n !== Object.keys(e).length) return !1;
+    for (r = n; r-- !== 0; ) if (!{}.hasOwnProperty.call(e, i[r])) return !1;
+    for (r = n; r-- !== 0; ) {
+      const o = i[r];
+      if (!(o === "_owner" && t.$$typeof) && !ut(t[o], e[o]))
+        return !1;
+    }
+    return !0;
+  }
+  return t !== t && e !== e;
+}
+function ne(t) {
+  return typeof window > "u" ? 1 : (t.ownerDocument.defaultView || window).devicePixelRatio || 1;
+}
+function jt(t, e) {
+  const n = ne(t);
+  return Math.round(e * n) / n;
+}
+function At(t) {
+  const e = O.useRef(t);
+  return ct(() => {
+    e.current = t;
+  }), e;
+}
+function vn(t) {
+  t === void 0 && (t = {});
+  const { placement: e = "bottom", strategy: n = "absolute", middleware: r = [], platform: i, elements: { reference: o, floating: s } = {}, transform: c = !0, whileElementsMounted: l, open: u } = t, [a, m] = O.useState({
+    x: 0,
+    y: 0,
+    strategy: n,
+    placement: e,
+    middlewareData: {},
+    isPositioned: !1
+  }), [p, f] = O.useState(r);
+  ut(p, r) || f(r);
+  const [d, h] = O.useState(null), [g, w] = O.useState(null), v = O.useCallback((P) => {
+    P !== x.current && (x.current = P, h(P));
+  }, []), b = O.useCallback((P) => {
+    P !== A.current && (A.current = P, w(P));
+  }, []), y = o || d, R = s || g, x = O.useRef(null), A = O.useRef(null), C = O.useRef(a), D = l != null, $ = At(l), k = At(i), H = At(u), T = O.useCallback(() => {
+    if (!x.current || !A.current) return;
+    const P = {
+      placement: e,
+      strategy: n,
+      middleware: p
+    };
+    k.current && (P.platform = k.current), wn(x.current, A.current, P).then((L) => {
+      const W = {
+        ...L,
+        isPositioned: H.current !== !1
+      };
+      S.current && !ut(C.current, W) && (C.current = W, Ae.flushSync(() => {
+        m(W);
+      }));
+    });
+  }, [
+    p,
+    e,
+    n,
+    k,
+    H
+  ]);
+  ct(() => {
+    u === !1 && C.current.isPositioned && (C.current.isPositioned = !1, m((P) => ({
+      ...P,
+      isPositioned: !1
+    })));
+  }, [u]);
+  const S = O.useRef(!1);
+  ct(() => (S.current = !0, () => {
+    S.current = !1;
+  }), []), ct(() => {
+    if (y && (x.current = y), R && (A.current = R), y && R) {
+      if ($.current) return $.current(y, R, T);
+      T();
+    }
+  }, [
+    y,
+    R,
+    T,
+    $,
+    D
+  ]);
+  const F = O.useMemo(() => ({
+    reference: x,
+    floating: A,
+    setReference: v,
+    setFloating: b
+  }), [v, b]), E = O.useMemo(() => ({
+    reference: y,
+    floating: R
+  }), [y, R]), M = O.useMemo(() => {
+    const P = {
+      position: n,
+      left: 0,
+      top: 0
+    };
+    if (!E.floating) return P;
+    const L = jt(E.floating, a.x), W = jt(E.floating, a.y);
+    return c ? {
+      ...P,
+      transform: "translate(" + L + "px, " + W + "px)",
+      ...ne(E.floating) >= 1.5 && { willChange: "transform" }
+    } : {
+      position: n,
+      left: L,
+      top: W
+    };
+  }, [
+    n,
+    c,
+    E.floating,
+    a.x,
+    a.y
+  ]);
+  return O.useMemo(() => ({
+    ...a,
+    update: T,
+    refs: F,
+    elements: E,
+    floatingStyles: M
+  }), [
+    a,
+    T,
+    F,
+    E,
+    M
+  ]);
+}
+var xn = (t) => {
+  function e(n) {
+    return {}.hasOwnProperty.call(n, "current");
+  }
+  return {
+    name: "arrow",
+    options: t,
+    fn(n) {
+      const { element: r, padding: i } = typeof t == "function" ? t(n) : t;
+      return r && e(r) ? r.current != null ? It({
+        element: r.current,
+        padding: i
+      }).fn(n) : {} : r ? It({
+        element: r,
+        padding: i
+      }).fn(n) : {};
+    }
+  };
+}, yn = (t, e) => {
+  const n = un(t);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [t, e]
+  };
+}, bn = (t, e) => {
+  const n = dn(t);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [t, e]
+  };
+}, An = (t, e) => ({
+  fn: gn(t).fn,
+  options: [t, e]
+}), Rn = (t, e) => {
+  const n = mn(t);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [t, e]
+  };
+}, Pn = (t, e) => {
+  const n = pn(t);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [t, e]
+  };
+}, On = (t, e) => {
+  const n = hn(t);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [t, e]
+  };
+}, Cn = (t, e) => {
+  const n = xn(t);
+  return {
+    name: n.name,
+    fn: n.fn,
+    options: [t, e]
+  };
+}, Sn = Object.defineProperty, En = (t, e) => Sn(t, "name", {
+  value: e,
+  configurable: !0
+}), Ln = /* @__PURE__ */ O.forwardRef(/* @__PURE__ */ En(function(e, n) {
+  const { children: r, width: i = 10, height: o = 5, ...s } = e;
+  return /* @__PURE__ */ V(Ot.svg, {
+    ...s,
+    ref: n,
+    width: i,
+    height: o,
+    viewBox: "0 0 30 10",
+    preserveAspectRatio: "none",
+    children: e.asChild ? r : /* @__PURE__ */ V("polygon", { points: "0,0 30,0 15,10" })
+  });
+}, "Arrow")), Tn = Ln, $n = Object.defineProperty, X = (t, e) => $n(t, "name", {
+  value: e,
+  configurable: !0
+}), re = "Popper", [oe, Zn] = ve(re), [Dn, ie] = oe(re), Mn = /* @__PURE__ */ X((t) => {
+  const { __scopePopper: e, children: n } = t, [r, i] = O.useState(null), [o, s] = O.useState(void 0);
+  return /* @__PURE__ */ V(Dn, {
+    scope: e,
+    anchor: r,
+    onAnchorChange: i,
+    placementState: o,
+    setPlacementState: s,
+    children: n
+  });
+}, "Popper"), _n = "PopperAnchor", Fn = /* @__PURE__ */ O.forwardRef(/* @__PURE__ */ X(function(e, n) {
+  const { __scopePopper: r, virtualRef: i, ...o } = e, s = ie(_n, r), c = O.useRef(null), l = s.onAnchorChange, u = Xt(n, O.useCallback((d) => {
+    c.current = d, d && l(d);
+  }, [l])), a = O.useRef(null);
+  O.useEffect(() => {
+    if (!i) return;
+    const d = a.current;
+    a.current = i.current, d !== a.current && l(a.current);
+  });
+  const m = s.placementState && wt(s.placementState), p = m?.[0], f = m?.[1];
+  return i ? null : /* @__PURE__ */ V(Ot.div, {
+    "data-radix-popper-side": p,
+    "data-radix-popper-align": f,
+    ...o,
+    ref: u
+  });
+}, "PopperAnchor")), se = "PopperContent", [Wn, kn] = oe(se), Hn = /* @__PURE__ */ O.forwardRef(/* @__PURE__ */ X(function(e, n) {
+  const { __scopePopper: r, side: i = "bottom", sideOffset: o = 0, align: s = "center", alignOffset: c = 0, arrowPadding: l = 0, avoidCollisions: u = !0, collisionBoundary: a = [], collisionPadding: m = 0, sticky: p = "partial", hideWhenDetached: f = !1, updatePositionStrategy: d = "optimized", onPlaced: h, ...g } = e, w = ie(se, r), [v, b] = O.useState(null), y = Xt(n, b), [R, x] = O.useState(null), A = ye(R), C = A?.width ?? 0, D = A?.height ?? 0, $ = i + (s !== "center" ? "-" + s : ""), k = typeof m == "number" ? m : {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...m
+  }, H = Array.isArray(a) ? a : [a], T = H.length > 0, S = {
+    padding: k,
+    boundary: H.filter(ce),
+    altBoundary: T
+  }, { refs: F, floatingStyles: E, placement: M, isPositioned: P, middlewareData: L } = vn({
+    strategy: "fixed",
+    placement: $,
+    whileElementsMounted: /* @__PURE__ */ X((...vt) => fn(...vt, { animationFrame: d === "always" }), "whileElementsMounted"),
+    elements: { reference: w.anchor },
+    middleware: [
+      yn({
+        mainAxis: o + D,
+        alignmentAxis: c
+      }),
+      u && bn({
+        mainAxis: !0,
+        crossAxis: !1,
+        limiter: p === "partial" ? An() : void 0,
+        ...S
+      }),
+      u && Rn({ ...S }),
+      Pn({
+        ...S,
+        apply: /* @__PURE__ */ X(({ elements: vt, rects: me, availableWidth: pe, availableHeight: he }) => {
+          const { width: ge, height: we } = me.reference, it = vt.floating.style;
+          it.setProperty("--radix-popper-available-width", `${pe}px`), it.setProperty("--radix-popper-available-height", `${he}px`), it.setProperty("--radix-popper-anchor-width", `${ge}px`), it.setProperty("--radix-popper-anchor-height", `${we}px`);
+        }, "apply")
+      }),
+      R && Cn({
+        element: R,
+        padding: l
+      }),
+      Vn({
+        arrowWidth: C,
+        arrowHeight: D
+      }),
+      f && On({
+        strategy: "referenceHidden",
+        ...S,
+        boundary: T ? S.boundary : void 0
+      })
+    ]
+  }), W = w.setPlacementState;
+  xt(() => (W(M), () => {
+    W(void 0);
+  }), [M, W]);
+  const [Dt, Mt] = wt(M), _t = xe(h);
+  xt(() => {
+    P && _t?.();
+  }, [P, _t]);
+  const le = L.arrow?.x, ae = L.arrow?.y, fe = L.arrow?.centerOffset !== 0, [ue, de] = O.useState();
+  return xt(() => {
+    v && de(window.getComputedStyle(v).zIndex);
+  }, [v]), /* @__PURE__ */ V("div", {
+    ref: F.setFloating,
+    "data-radix-popper-content-wrapper": "",
+    style: {
+      ...E,
+      transform: P ? E.transform : "translate(0, -200%)",
+      minWidth: "max-content",
+      zIndex: ue,
+      "--radix-popper-transform-origin": [L.transformOrigin?.x, L.transformOrigin?.y].join(" "),
+      ...L.hide?.referenceHidden && {
+        visibility: "hidden",
+        pointerEvents: "none"
+      }
+    },
+    dir: e.dir,
+    children: /* @__PURE__ */ V(Wn, {
+      scope: r,
+      placedSide: Dt,
+      placedAlign: Mt,
+      onArrowChange: x,
+      arrowX: le,
+      arrowY: ae,
+      shouldHideArrow: fe,
+      children: /* @__PURE__ */ V(Ot.div, {
+        "data-side": Dt,
+        "data-align": Mt,
+        ...g,
+        ref: y,
+        style: {
+          ...g.style,
+          animation: P ? g.style?.animation : "none"
+        }
+      })
+    })
+  });
+}, "PopperContent")), Nn = "PopperArrow", zn = {
+  top: "bottom",
+  right: "left",
+  bottom: "top",
+  left: "right"
+}, Bn = /* @__PURE__ */ O.forwardRef(/* @__PURE__ */ X(function(e, n) {
+  const { __scopePopper: r, ...i } = e, o = kn(Nn, r), s = zn[o.placedSide];
+  return /* @__PURE__ */ V("span", {
+    ref: o.onArrowChange,
+    style: {
+      position: "absolute",
+      left: o.arrowX,
+      top: o.arrowY,
+      [s]: 0,
+      transformOrigin: {
+        top: "",
+        right: "0 0",
+        bottom: "center 0",
+        left: "100% 0"
+      }[o.placedSide],
+      transform: {
+        top: "translateY(100%)",
+        right: "translateY(50%) rotate(90deg) translateX(-50%)",
+        bottom: "rotate(180deg)",
+        left: "translateY(50%) rotate(-90deg) translateX(50%)"
+      }[o.placedSide],
+      visibility: o.shouldHideArrow ? "hidden" : void 0
+    },
+    children: /* @__PURE__ */ V(Tn, {
+      ...i,
+      ref: n,
+      style: {
+        ...i.style,
+        display: "block"
+      }
+    })
+  });
+}, "PopperArrow"));
+function ce(t) {
+  return t !== null;
+}
+X(ce, "isNotNull");
+var Vn = /* @__PURE__ */ X((t) => ({
+  name: "transformOrigin",
+  options: t,
+  fn(e) {
+    const { placement: n, rects: r, middlewareData: i } = e, o = i.arrow?.centerOffset !== 0, s = o ? 0 : t.arrowWidth, c = o ? 0 : t.arrowHeight, [l, u] = wt(n), a = {
+      start: "0%",
+      center: "50%",
+      end: "100%"
+    }[u], m = (i.arrow?.x ?? 0) + s / 2, p = (i.arrow?.y ?? 0) + c / 2;
+    let f = "", d = "";
+    return l === "bottom" ? (f = o ? a : `${m}px`, d = `${-c}px`) : l === "top" ? (f = o ? a : `${m}px`, d = `${r.floating.height + c}px`) : l === "right" ? (f = `${-c}px`, d = o ? a : `${p}px`) : l === "left" && (f = `${r.floating.width + c}px`, d = o ? a : `${p}px`), { data: {
+      x: f,
+      y: d
+    } };
+  }
+}), "transformOrigin");
+function wt(t) {
+  const [e, n = "center"] = t.split("-");
+  return [e, n];
+}
+X(wt, "getSideAndAlignFromPlacement");
+var Gn = Mn, Jn = Fn, Qn = Hn, tr = Bn;
+export {
+  Zn as a,
+  Gn as i,
+  tr as n,
+  Qn as r,
+  Jn as t
+};