energy-components 1.0.2

package/dist/components/tooltip.es.js

@@ -0,0 +1,1082 @@
+import { unref as at, defineComponent as Vt, toRefs as Mt, ref as U, computed as Ft, openBlock as bt, createElementBlock as At, createElementVNode as Z, renderSlot as Ht, normalizeClass as Rt, toDisplayString as Ct, createVNode as jt, createCommentVNode as Yt } from "vue";
+import { R as Xt } from "./icon-svg-Cpx09myr.js";
+import { _ as zt } from "./_plugin-vue_export-helper-CHgC5LLL.js";
+import './style/tooltip.css';const X = Math.min, O = Math.max, nt = Math.round, H = (t) => ({
+  x: t,
+  y: t
+}), It = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, Kt = {
+  start: "end",
+  end: "start"
+};
+function ft(t, e, o) {
+  return O(t, X(e, o));
+}
+function J(t, e) {
+  return typeof t == "function" ? t(e) : t;
+}
+function j(t) {
+  return t.split("-")[0];
+}
+function Q(t) {
+  return t.split("-")[1];
+}
+function Tt(t) {
+  return t === "x" ? "y" : "x";
+}
+function gt(t) {
+  return t === "y" ? "height" : "width";
+}
+function z(t) {
+  return ["top", "bottom"].includes(j(t)) ? "y" : "x";
+}
+function ht(t) {
+  return Tt(z(t));
+}
+function qt(t, e, o) {
+  o === void 0 && (o = !1);
+  const n = Q(t), i = ht(t), r = gt(i);
+  let s = i === "x" ? n === (o ? "end" : "start") ? "right" : "left" : n === "start" ? "bottom" : "top";
+  return e.reference[r] > e.floating[r] && (s = ot(s)), [s, ot(s)];
+}
+function Gt(t) {
+  const e = ot(t);
+  return [ut(t), e, ut(e)];
+}
+function ut(t) {
+  return t.replace(/start|end/g, (e) => Kt[e]);
+}
+function Jt(t, e, o) {
+  const n = ["left", "right"], i = ["right", "left"], r = ["top", "bottom"], s = ["bottom", "top"];
+  switch (t) {
+    case "top":
+    case "bottom":
+      return o ? e ? i : n : e ? n : i;
+    case "left":
+    case "right":
+      return e ? r : s;
+    default:
+      return [];
+  }
+}
+function Qt(t, e, o, n) {
+  const i = Q(t);
+  let r = Jt(j(t), o === "start", n);
+  return i && (r = r.map((s) => s + "-" + i), e && (r = r.concat(r.map(ut)))), r;
+}
+function ot(t) {
+  return t.replace(/left|right|bottom|top/g, (e) => It[e]);
+}
+function Ut(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function Et(t) {
+  return typeof t != "number" ? Ut(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function it(t) {
+  const {
+    x: e,
+    y: o,
+    width: n,
+    height: i
+  } = t;
+  return {
+    width: n,
+    height: i,
+    top: o,
+    left: e,
+    right: e + n,
+    bottom: o + i,
+    x: e,
+    y: o
+  };
+}
+function Ot(t, e, o) {
+  let {
+    reference: n,
+    floating: i
+  } = t;
+  const r = z(e), s = ht(e), l = gt(s), c = j(e), a = r === "y", f = n.x + n.width / 2 - i.width / 2, u = n.y + n.height / 2 - i.height / 2, p = n[l] / 2 - i[l] / 2;
+  let d;
+  switch (c) {
+    case "top":
+      d = {
+        x: f,
+        y: n.y - i.height
+      };
+      break;
+    case "bottom":
+      d = {
+        x: f,
+        y: n.y + n.height
+      };
+      break;
+    case "right":
+      d = {
+        x: n.x + n.width,
+        y: u
+      };
+      break;
+    case "left":
+      d = {
+        x: n.x - i.width,
+        y: u
+      };
+      break;
+    default:
+      d = {
+        x: n.x,
+        y: n.y
+      };
+  }
+  switch (Q(e)) {
+    case "start":
+      d[s] -= p * (o && a ? -1 : 1);
+      break;
+    case "end":
+      d[s] += p * (o && a ? -1 : 1);
+      break;
+  }
+  return d;
+}
+const Zt = async (t, e, o) => {
+  const {
+    placement: n = "bottom",
+    strategy: i = "absolute",
+    middleware: r = [],
+    platform: s
+  } = o, l = r.filter(Boolean), c = await (s.isRTL == null ? void 0 : s.isRTL(e));
+  let a = await s.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: i
+  }), {
+    x: f,
+    y: u
+  } = Ot(a, n, c), p = n, d = {}, m = 0;
+  for (let g = 0; g < l.length; g++) {
+    const {
+      name: h,
+      fn: w
+    } = l[g], {
+      x,
+      y,
+      data: b,
+      reset: v
+    } = await w({
+      x: f,
+      y: u,
+      initialPlacement: n,
+      placement: p,
+      strategy: i,
+      middlewareData: d,
+      rects: a,
+      platform: s,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    f = x ?? f, u = y ?? u, d = {
+      ...d,
+      [h]: {
+        ...d[h],
+        ...b
+      }
+    }, v && m <= 50 && (m++, typeof v == "object" && (v.placement && (p = v.placement), v.rects && (a = v.rects === !0 ? await s.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: i
+    }) : v.rects), {
+      x: f,
+      y: u
+    } = Ot(a, p, c)), g = -1);
+  }
+  return {
+    x: f,
+    y: u,
+    placement: p,
+    strategy: i,
+    middlewareData: d
+  };
+};
+async function wt(t, e) {
+  var o;
+  e === void 0 && (e = {});
+  const {
+    x: n,
+    y: i,
+    platform: r,
+    rects: s,
+    elements: l,
+    strategy: c
+  } = t, {
+    boundary: a = "clippingAncestors",
+    rootBoundary: f = "viewport",
+    elementContext: u = "floating",
+    altBoundary: p = !1,
+    padding: d = 0
+  } = J(e, t), m = Et(d), h = l[p ? u === "floating" ? "reference" : "floating" : u], w = it(await r.getClippingRect({
+    element: (o = await (r.isElement == null ? void 0 : r.isElement(h))) == null || o ? h : h.contextElement || await (r.getDocumentElement == null ? void 0 : r.getDocumentElement(l.floating)),
+    boundary: a,
+    rootBoundary: f,
+    strategy: c
+  })), x = u === "floating" ? {
+    x: n,
+    y: i,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, y = await (r.getOffsetParent == null ? void 0 : r.getOffsetParent(l.floating)), b = await (r.isElement == null ? void 0 : r.isElement(y)) ? await (r.getScale == null ? void 0 : r.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, v = it(r.convertOffsetParentRelativeRectToViewportRelativeRect ? await r.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: l,
+    rect: x,
+    offsetParent: y,
+    strategy: c
+  }) : x);
+  return {
+    top: (w.top - v.top + m.top) / b.y,
+    bottom: (v.bottom - w.bottom + m.bottom) / b.y,
+    left: (w.left - v.left + m.left) / b.x,
+    right: (v.right - w.right + m.right) / b.x
+  };
+}
+const te = (t) => ({
+  name: "arrow",
+  options: t,
+  async fn(e) {
+    const {
+      x: o,
+      y: n,
+      placement: i,
+      rects: r,
+      platform: s,
+      elements: l,
+      middlewareData: c
+    } = e, {
+      element: a,
+      padding: f = 0
+    } = J(t, e) || {};
+    if (a == null)
+      return {};
+    const u = Et(f), p = {
+      x: o,
+      y: n
+    }, d = ht(i), m = gt(d), g = await s.getDimensions(a), h = d === "y", w = h ? "top" : "left", x = h ? "bottom" : "right", y = h ? "clientHeight" : "clientWidth", b = r.reference[m] + r.reference[d] - p[d] - r.floating[m], v = p[d] - r.reference[d], T = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(a));
+    let R = T ? T[y] : 0;
+    (!R || !await (s.isElement == null ? void 0 : s.isElement(T))) && (R = l.floating[y] || r.floating[m]);
+    const $ = b / 2 - v / 2, E = R / 2 - g[m] / 2 - 1, _ = X(u[w], E), B = X(u[x], E), P = _, V = R - g[m] - B, A = R / 2 - g[m] / 2 + $, K = ft(P, A, V), W = !c.arrow && Q(i) != null && A !== K && r.reference[m] / 2 - (A < P ? _ : B) - g[m] / 2 < 0, L = W ? A < P ? A - P : A - V : 0;
+    return {
+      [d]: p[d] + L,
+      data: {
+        [d]: K,
+        centerOffset: A - K - L,
+        ...W && {
+          alignmentOffset: L
+        }
+      },
+      reset: W
+    };
+  }
+}), ee = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "flip",
+    options: t,
+    async fn(e) {
+      var o, n;
+      const {
+        placement: i,
+        middlewareData: r,
+        rects: s,
+        initialPlacement: l,
+        platform: c,
+        elements: a
+      } = e, {
+        mainAxis: f = !0,
+        crossAxis: u = !0,
+        fallbackPlacements: p,
+        fallbackStrategy: d = "bestFit",
+        fallbackAxisSideDirection: m = "none",
+        flipAlignment: g = !0,
+        ...h
+      } = J(t, e);
+      if ((o = r.arrow) != null && o.alignmentOffset)
+        return {};
+      const w = j(i), x = z(l), y = j(l) === l, b = await (c.isRTL == null ? void 0 : c.isRTL(a.floating)), v = p || (y || !g ? [ot(l)] : Gt(l)), T = m !== "none";
+      !p && T && v.push(...Qt(l, g, m, b));
+      const R = [l, ...v], $ = await wt(e, h), E = [];
+      let _ = ((n = r.flip) == null ? void 0 : n.overflows) || [];
+      if (f && E.push($[w]), u) {
+        const A = qt(i, s, b);
+        E.push($[A[0]], $[A[1]]);
+      }
+      if (_ = [..._, {
+        placement: i,
+        overflows: E
+      }], !E.every((A) => A <= 0)) {
+        var B, P;
+        const A = (((B = r.flip) == null ? void 0 : B.index) || 0) + 1, K = R[A];
+        if (K)
+          return {
+            data: {
+              index: A,
+              overflows: _
+            },
+            reset: {
+              placement: K
+            }
+          };
+        let W = (P = _.filter((L) => L.overflows[0] <= 0).sort((L, M) => L.overflows[1] - M.overflows[1])[0]) == null ? void 0 : P.placement;
+        if (!W)
+          switch (d) {
+            case "bestFit": {
+              var V;
+              const L = (V = _.filter((M) => {
+                if (T) {
+                  const F = z(M.placement);
+                  return F === x || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  F === "y";
+                }
+                return !0;
+              }).map((M) => [M.placement, M.overflows.filter((F) => F > 0).reduce((F, Bt) => F + Bt, 0)]).sort((M, F) => M[1] - F[1])[0]) == null ? void 0 : V[0];
+              L && (W = L);
+              break;
+            }
+            case "initialPlacement":
+              W = l;
+              break;
+          }
+        if (i !== W)
+          return {
+            reset: {
+              placement: W
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+async function ne(t, e) {
+  const {
+    placement: o,
+    platform: n,
+    elements: i
+  } = t, r = await (n.isRTL == null ? void 0 : n.isRTL(i.floating)), s = j(o), l = Q(o), c = z(o) === "y", a = ["left", "top"].includes(s) ? -1 : 1, f = r && c ? -1 : 1, u = J(e, t);
+  let {
+    mainAxis: p,
+    crossAxis: d,
+    alignmentAxis: m
+  } = typeof u == "number" ? {
+    mainAxis: u,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: u.mainAxis || 0,
+    crossAxis: u.crossAxis || 0,
+    alignmentAxis: u.alignmentAxis
+  };
+  return l && typeof m == "number" && (d = l === "end" ? m * -1 : m), c ? {
+    x: d * f,
+    y: p * a
+  } : {
+    x: p * a,
+    y: d * f
+  };
+}
+const oe = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var o, n;
+      const {
+        x: i,
+        y: r,
+        placement: s,
+        middlewareData: l
+      } = e, c = await ne(e, t);
+      return s === ((o = l.offset) == null ? void 0 : o.placement) && (n = l.arrow) != null && n.alignmentOffset ? {} : {
+        x: i + c.x,
+        y: r + c.y,
+        data: {
+          ...c,
+          placement: s
+        }
+      };
+    }
+  };
+}, ie = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: o,
+        y: n,
+        placement: i
+      } = e, {
+        mainAxis: r = !0,
+        crossAxis: s = !1,
+        limiter: l = {
+          fn: (h) => {
+            let {
+              x: w,
+              y: x
+            } = h;
+            return {
+              x: w,
+              y: x
+            };
+          }
+        },
+        ...c
+      } = J(t, e), a = {
+        x: o,
+        y: n
+      }, f = await wt(e, c), u = z(j(i)), p = Tt(u);
+      let d = a[p], m = a[u];
+      if (r) {
+        const h = p === "y" ? "top" : "left", w = p === "y" ? "bottom" : "right", x = d + f[h], y = d - f[w];
+        d = ft(x, d, y);
+      }
+      if (s) {
+        const h = u === "y" ? "top" : "left", w = u === "y" ? "bottom" : "right", x = m + f[h], y = m - f[w];
+        m = ft(x, m, y);
+      }
+      const g = l.fn({
+        ...e,
+        [p]: d,
+        [u]: m
+      });
+      return {
+        ...g,
+        data: {
+          x: g.x - o,
+          y: g.y - n,
+          enabled: {
+            [p]: r,
+            [u]: s
+          }
+        }
+      };
+    }
+  };
+}, se = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      var o, n;
+      const {
+        placement: i,
+        rects: r,
+        platform: s,
+        elements: l
+      } = e, {
+        apply: c = () => {
+        },
+        ...a
+      } = J(t, e), f = await wt(e, a), u = j(i), p = Q(i), d = z(i) === "y", {
+        width: m,
+        height: g
+      } = r.floating;
+      let h, w;
+      u === "top" || u === "bottom" ? (h = u, w = p === (await (s.isRTL == null ? void 0 : s.isRTL(l.floating)) ? "start" : "end") ? "left" : "right") : (w = u, h = p === "end" ? "top" : "bottom");
+      const x = g - f.top - f.bottom, y = m - f.left - f.right, b = X(g - f[h], x), v = X(m - f[w], y), T = !e.middlewareData.shift;
+      let R = b, $ = v;
+      if ((o = e.middlewareData.shift) != null && o.enabled.x && ($ = y), (n = e.middlewareData.shift) != null && n.enabled.y && (R = x), T && !p) {
+        const _ = O(f.left, 0), B = O(f.right, 0), P = O(f.top, 0), V = O(f.bottom, 0);
+        d ? $ = m - 2 * (_ !== 0 || B !== 0 ? _ + B : O(f.left, f.right)) : R = g - 2 * (P !== 0 || V !== 0 ? P + V : O(f.top, f.bottom));
+      }
+      await c({
+        ...e,
+        availableWidth: $,
+        availableHeight: R
+      });
+      const E = await s.getDimensions(l.floating);
+      return m !== E.width || g !== E.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+function st() {
+  return typeof window < "u";
+}
+function I(t) {
+  return xt(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function C(t) {
+  var e;
+  return (t == null || (e = t.ownerDocument) == null ? void 0 : e.defaultView) || window;
+}
+function N(t) {
+  var e;
+  return (e = (xt(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : e.documentElement;
+}
+function xt(t) {
+  return st() ? t instanceof Node || t instanceof C(t).Node : !1;
+}
+function S(t) {
+  return st() ? t instanceof Element || t instanceof C(t).Element : !1;
+}
+function k(t) {
+  return st() ? t instanceof HTMLElement || t instanceof C(t).HTMLElement : !1;
+}
+function _t(t) {
+  return !st() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof C(t).ShadowRoot;
+}
+function et(t) {
+  const {
+    overflow: e,
+    overflowX: o,
+    overflowY: n,
+    display: i
+  } = D(t);
+  return /auto|scroll|overlay|hidden|clip/.test(e + n + o) && !["inline", "contents"].includes(i);
+}
+function re(t) {
+  return ["table", "td", "th"].includes(I(t));
+}
+function rt(t) {
+  return [":popover-open", ":modal"].some((e) => {
+    try {
+      return t.matches(e);
+    } catch {
+      return !1;
+    }
+  });
+}
+function yt(t) {
+  const e = vt(), o = S(t) ? D(t) : t;
+  return o.transform !== "none" || o.perspective !== "none" || (o.containerType ? o.containerType !== "normal" : !1) || !e && (o.backdropFilter ? o.backdropFilter !== "none" : !1) || !e && (o.filter ? o.filter !== "none" : !1) || ["transform", "perspective", "filter"].some((n) => (o.willChange || "").includes(n)) || ["paint", "layout", "strict", "content"].some((n) => (o.contain || "").includes(n));
+}
+function le(t) {
+  let e = Y(t);
+  for (; k(e) && !G(e); ) {
+    if (yt(e))
+      return e;
+    if (rt(e))
+      return null;
+    e = Y(e);
+  }
+  return null;
+}
+function vt() {
+  return typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter", "none");
+}
+function G(t) {
+  return ["html", "body", "#document"].includes(I(t));
+}
+function D(t) {
+  return C(t).getComputedStyle(t);
+}
+function lt(t) {
+  return S(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function Y(t) {
+  if (I(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.
+    _t(t) && t.host || // Fallback.
+    N(t)
+  );
+  return _t(e) ? e.host : e;
+}
+function Pt(t) {
+  const e = Y(t);
+  return G(e) ? t.ownerDocument ? t.ownerDocument.body : t.body : k(e) && et(e) ? e : Pt(e);
+}
+function dt(t, e, o) {
+  var n;
+  e === void 0 && (e = []), o === void 0 && (o = !0);
+  const i = Pt(t), r = i === ((n = t.ownerDocument) == null ? void 0 : n.body), s = C(i);
+  if (r) {
+    const l = mt(s);
+    return e.concat(s, s.visualViewport || [], et(i) ? i : [], l && o ? dt(l) : []);
+  }
+  return e.concat(i, dt(i, [], o));
+}
+function mt(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+function Lt(t) {
+  const e = D(t);
+  let o = parseFloat(e.width) || 0, n = parseFloat(e.height) || 0;
+  const i = k(t), r = i ? t.offsetWidth : o, s = i ? t.offsetHeight : n, l = nt(o) !== r || nt(n) !== s;
+  return l && (o = r, n = s), {
+    width: o,
+    height: n,
+    $: l
+  };
+}
+function kt(t) {
+  return S(t) ? t : t.contextElement;
+}
+function q(t) {
+  const e = kt(t);
+  if (!k(e))
+    return H(1);
+  const o = e.getBoundingClientRect(), {
+    width: n,
+    height: i,
+    $: r
+  } = Lt(e);
+  let s = (r ? nt(o.width) : o.width) / n, l = (r ? nt(o.height) : o.height) / i;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!l || !Number.isFinite(l)) && (l = 1), {
+    x: s,
+    y: l
+  };
+}
+const ce = /* @__PURE__ */ H(0);
+function $t(t) {
+  const e = C(t);
+  return !vt() || !e.visualViewport ? ce : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function ae(t, e, o) {
+  return e === void 0 && (e = !1), !o || e && o !== C(t) ? !1 : e;
+}
+function tt(t, e, o, n) {
+  e === void 0 && (e = !1), o === void 0 && (o = !1);
+  const i = t.getBoundingClientRect(), r = kt(t);
+  let s = H(1);
+  e && (n ? S(n) && (s = q(n)) : s = q(t));
+  const l = ae(r, o, n) ? $t(r) : H(0);
+  let c = (i.left + l.x) / s.x, a = (i.top + l.y) / s.y, f = i.width / s.x, u = i.height / s.y;
+  if (r) {
+    const p = C(r), d = n && S(n) ? C(n) : n;
+    let m = p, g = mt(m);
+    for (; g && n && d !== m; ) {
+      const h = q(g), w = g.getBoundingClientRect(), x = D(g), y = w.left + (g.clientLeft + parseFloat(x.paddingLeft)) * h.x, b = w.top + (g.clientTop + parseFloat(x.paddingTop)) * h.y;
+      c *= h.x, a *= h.y, f *= h.x, u *= h.y, c += y, a += b, m = C(g), g = mt(m);
+    }
+  }
+  return it({
+    width: f,
+    height: u,
+    x: c,
+    y: a
+  });
+}
+function fe(t) {
+  let {
+    elements: e,
+    rect: o,
+    offsetParent: n,
+    strategy: i
+  } = t;
+  const r = i === "fixed", s = N(n), l = e ? rt(e.floating) : !1;
+  if (n === s || l && r)
+    return o;
+  let c = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, a = H(1);
+  const f = H(0), u = k(n);
+  if ((u || !u && !r) && ((I(n) !== "body" || et(s)) && (c = lt(n)), k(n))) {
+    const p = tt(n);
+    a = q(n), f.x = p.x + n.clientLeft, f.y = p.y + n.clientTop;
+  }
+  return {
+    width: o.width * a.x,
+    height: o.height * a.y,
+    x: o.x * a.x - c.scrollLeft * a.x + f.x,
+    y: o.y * a.y - c.scrollTop * a.y + f.y
+  };
+}
+function ue(t) {
+  return Array.from(t.getClientRects());
+}
+function pt(t, e) {
+  const o = lt(t).scrollLeft;
+  return e ? e.left + o : tt(N(t)).left + o;
+}
+function de(t) {
+  const e = N(t), o = lt(t), n = t.ownerDocument.body, i = O(e.scrollWidth, e.clientWidth, n.scrollWidth, n.clientWidth), r = O(e.scrollHeight, e.clientHeight, n.scrollHeight, n.clientHeight);
+  let s = -o.scrollLeft + pt(t);
+  const l = -o.scrollTop;
+  return D(n).direction === "rtl" && (s += O(e.clientWidth, n.clientWidth) - i), {
+    width: i,
+    height: r,
+    x: s,
+    y: l
+  };
+}
+function me(t, e) {
+  const o = C(t), n = N(t), i = o.visualViewport;
+  let r = n.clientWidth, s = n.clientHeight, l = 0, c = 0;
+  if (i) {
+    r = i.width, s = i.height;
+    const a = vt();
+    (!a || a && e === "fixed") && (l = i.offsetLeft, c = i.offsetTop);
+  }
+  return {
+    width: r,
+    height: s,
+    x: l,
+    y: c
+  };
+}
+function pe(t, e) {
+  const o = tt(t, !0, e === "fixed"), n = o.top + t.clientTop, i = o.left + t.clientLeft, r = k(t) ? q(t) : H(1), s = t.clientWidth * r.x, l = t.clientHeight * r.y, c = i * r.x, a = n * r.y;
+  return {
+    width: s,
+    height: l,
+    x: c,
+    y: a
+  };
+}
+function St(t, e, o) {
+  let n;
+  if (e === "viewport")
+    n = me(t, o);
+  else if (e === "document")
+    n = de(N(t));
+  else if (S(e))
+    n = pe(e, o);
+  else {
+    const i = $t(t);
+    n = {
+      ...e,
+      x: e.x - i.x,
+      y: e.y - i.y
+    };
+  }
+  return it(n);
+}
+function Wt(t, e) {
+  const o = Y(t);
+  return o === e || !S(o) || G(o) ? !1 : D(o).position === "fixed" || Wt(o, e);
+}
+function ge(t, e) {
+  const o = e.get(t);
+  if (o)
+    return o;
+  let n = dt(t, [], !1).filter((l) => S(l) && I(l) !== "body"), i = null;
+  const r = D(t).position === "fixed";
+  let s = r ? Y(t) : t;
+  for (; S(s) && !G(s); ) {
+    const l = D(s), c = yt(s);
+    !c && l.position === "fixed" && (i = null), (r ? !c && !i : !c && l.position === "static" && !!i && ["absolute", "fixed"].includes(i.position) || et(s) && !c && Wt(t, s)) ? n = n.filter((f) => f !== s) : i = l, s = Y(s);
+  }
+  return e.set(t, n), n;
+}
+function he(t) {
+  let {
+    element: e,
+    boundary: o,
+    rootBoundary: n,
+    strategy: i
+  } = t;
+  const s = [...o === "clippingAncestors" ? rt(e) ? [] : ge(e, this._c) : [].concat(o), n], l = s[0], c = s.reduce((a, f) => {
+    const u = St(e, f, i);
+    return a.top = O(u.top, a.top), a.right = X(u.right, a.right), a.bottom = X(u.bottom, a.bottom), a.left = O(u.left, a.left), a;
+  }, St(e, l, i));
+  return {
+    width: c.right - c.left,
+    height: c.bottom - c.top,
+    x: c.left,
+    y: c.top
+  };
+}
+function we(t) {
+  const {
+    width: e,
+    height: o
+  } = Lt(t);
+  return {
+    width: e,
+    height: o
+  };
+}
+function xe(t, e, o) {
+  const n = k(e), i = N(e), r = o === "fixed", s = tt(t, !0, r, e);
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const c = H(0);
+  if (n || !n && !r)
+    if ((I(e) !== "body" || et(i)) && (l = lt(e)), n) {
+      const d = tt(e, !0, r, e);
+      c.x = d.x + e.clientLeft, c.y = d.y + e.clientTop;
+    } else i && (c.x = pt(i));
+  let a = 0, f = 0;
+  if (i && !n && !r) {
+    const d = i.getBoundingClientRect();
+    f = d.top + l.scrollTop, a = d.left + l.scrollLeft - // RTL <body> scrollbar.
+    pt(i, d);
+  }
+  const u = s.left + l.scrollLeft - c.x - a, p = s.top + l.scrollTop - c.y - f;
+  return {
+    x: u,
+    y: p,
+    width: s.width,
+    height: s.height
+  };
+}
+function ct(t) {
+  return D(t).position === "static";
+}
+function Dt(t, e) {
+  if (!k(t) || D(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let o = t.offsetParent;
+  return N(t) === o && (o = o.ownerDocument.body), o;
+}
+function Nt(t, e) {
+  const o = C(t);
+  if (rt(t))
+    return o;
+  if (!k(t)) {
+    let i = Y(t);
+    for (; i && !G(i); ) {
+      if (S(i) && !ct(i))
+        return i;
+      i = Y(i);
+    }
+    return o;
+  }
+  let n = Dt(t, e);
+  for (; n && re(n) && ct(n); )
+    n = Dt(n, e);
+  return n && G(n) && ct(n) && !yt(n) ? o : n || le(t) || o;
+}
+const ye = async function(t) {
+  const e = this.getOffsetParent || Nt, o = this.getDimensions, n = await o(t.floating);
+  return {
+    reference: xe(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: n.width,
+      height: n.height
+    }
+  };
+};
+function ve(t) {
+  return D(t).direction === "rtl";
+}
+const be = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: fe,
+  getDocumentElement: N,
+  getClippingRect: he,
+  getOffsetParent: Nt,
+  getElementRects: ye,
+  getClientRects: ue,
+  getDimensions: we,
+  getScale: q,
+  isElement: S,
+  isRTL: ve
+}, Ae = oe, Re = ie, Ce = ee, Oe = se, _e = te, Se = (t, e, o) => {
+  const n = /* @__PURE__ */ new Map(), i = {
+    platform: be,
+    ...o
+  }, r = {
+    ...i.platform,
+    _c: n
+  };
+  return Zt(t, e, {
+    ...i,
+    platform: r
+  });
+};
+function De(t) {
+  return t != null && typeof t == "object" && "$el" in t;
+}
+function Te(t) {
+  if (De(t)) {
+    const e = t.$el;
+    return xt(e) && I(e) === "#comment" ? null : e;
+  }
+  return t;
+}
+function Ee(t) {
+  return typeof t == "function" ? t() : at(t);
+}
+function Pe(t) {
+  return {
+    name: "arrow",
+    options: t,
+    fn(e) {
+      const o = Te(Ee(t.element));
+      return o == null ? {} : _e({
+        element: o,
+        padding: t.padding
+      }).fn(e);
+    }
+  };
+}
+const Le = { class: "rds-tooltip" }, ke = {
+  key: 0,
+  class: "rds-tooltip__header"
+}, $e = { class: "rds-tooltip__title" }, We = { class: "rds-tooltip__content" }, Ne = /* @__PURE__ */ Vt({
+  __name: "tooltip",
+  props: {
+    /**
+     * <span>Título del tooltip</span>
+     */
+    title: {
+      type: String,
+      default: ""
+    },
+    /**
+     * <span>Contenido del tooltip</span>
+     */
+    content: {
+      type: String,
+      default: ""
+    },
+    /**
+     * <span>Posición del tooltip</span>
+     */
+    placement: {
+      type: String
+    },
+    /**
+     * <span>Espacio de desplazamiento para el tooltip</span>
+     */
+    offsetSpace: {
+      type: Number,
+      default: 8
+    },
+    /**
+     * <span>Especifica si el tooltip es grande</span>
+     */
+    large: {
+      type: Boolean,
+      default: !1
+      // Aquí se necesita aclaración, ya que en el original se menciona 'size: 'large'', pero no se define un default para 'large'
+    },
+    /**
+     * <span>Especifica si el tooltip debe ocupar el ancho completo</span>
+     */
+    fullWidth: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  setup(t) {
+    const e = t, { large: o, fullWidth: n, title: i } = Mt(e), r = U(), s = U(), l = U(), c = U(!0), a = U(""), f = async () => {
+      const { x: m, y: g, middlewareData: h, placement: w } = await Se(
+        r.value,
+        s.value,
+        {
+          placement: e.placement,
+          middleware: [
+            Ae(e.offsetSpace),
+            Ce(),
+            Re(),
+            Oe({
+              apply({ availableWidth: v, availableHeight: T, elements: R }) {
+                Object.assign(R.floating.style, {
+                  maxWidth: n.value ? `${v}px` : "380px",
+                  maxHeight: `${Math.max(0, T)}px`
+                });
+              }
+            }),
+            Pe({
+              element: l.value,
+              padding: o.value ? 16 : 8
+            })
+          ]
+        }
+      );
+      Object.assign(s.value.style, {
+        left: `${m}px`,
+        top: `${g}px`
+      });
+      const { x, y } = h.arrow, b = {
+        left: "right",
+        right: "left",
+        bottom: "top",
+        top: "bottom"
+      };
+      a.value = `rds-tooltip__tooltip-arrow--${w}`, Object.assign(l.value.style, {
+        left: x != null ? `${x}px` : "",
+        top: y != null ? `${y}px` : "",
+        bottom: "",
+        right: "",
+        [b[w.split("-")[0]]]: "-4px"
+      });
+    }, u = () => {
+      i != null && i.value || (c.value = !0);
+    }, p = () => {
+      c.value = !1, f();
+    }, d = Ft(() => `rds-tooltip__tooltip ${c.value ? "rds-tooltip__tooltip-hidden " : ""}${o.value || i != null && i.value ? "rds-tooltip__tooltip--large " : ""}${n.value ? "rds-tooltip__tooltip--full-width " : ""}`);
+    return (m, g) => (bt(), At("div", Le, [
+      Z("div", {
+        ref_key: "referenceRef",
+        ref: r,
+        class: "rds-tooltip__trigger",
+        onBlur: u,
+        onFocus: p,
+        onMouseenter: p,
+        onMouseleave: u
+      }, [
+        Ht(m.$slots, "default", {}, void 0, !0)
+      ], 544),
+      Z("div", {
+        ref_key: "floatingRef",
+        ref: s,
+        class: Rt(d.value)
+      }, [
+        at(i) ? (bt(), At("div", ke, [
+          Z("h3", $e, Ct(at(i)), 1),
+          jt(Xt, {
+            name: "close",
+            "aria-hidden": "true",
+            class: "rds-tooltip__icon",
+            onClick: g[0] || (g[0] = (h) => c.value = !c.value)
+          })
+        ])) : Yt("", !0),
+        Z("div", We, Ct(t.content), 1),
+        Z("div", {
+          ref_key: "arrowRef",
+          ref: l,
+          class: Rt(["rds-tooltip__tooltip-arrow", a.value])
+        }, null, 2)
+      ], 2)
+    ]));
+  }
+}), Fe = /* @__PURE__ */ zt(Ne, [["__scopeId", "data-v-e5e6156d"]]);
+export {
+  Fe as default
+};