@pibit.ai/cure-design-system 0.3.15 → 0.3.16

package/dist/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -0,0 +1,387 @@
+import { getSideAxis as $, getAlignmentAxis as j, getSide as D, getAlignment as S, evaluate as E, getPaddingObject as H, rectToClientRect as k, getAxisLength as X, placements as V, getAlignmentSides as Y, min as B, max as C, clamp as F, getOppositeAlignmentPlacement as z, getOppositeAxis as I } from "../../utils/dist/floating-ui.utils.js";
+function W(t, e, c) {
+  let {
+    reference: i,
+    floating: n
+  } = t;
+  const s = $(e), a = j(e), d = X(a), u = D(e), h = s === "y", o = i.x + i.width / 2 - n.width / 2, l = i.y + i.height / 2 - n.height / 2, r = i[d] / 2 - n[d] / 2;
+  let m;
+  switch (u) {
+    case "top":
+      m = {
+        x: o,
+        y: i.y - n.height
+      };
+      break;
+    case "bottom":
+      m = {
+        x: o,
+        y: i.y + i.height
+      };
+      break;
+    case "right":
+      m = {
+        x: i.x + i.width,
+        y: l
+      };
+      break;
+    case "left":
+      m = {
+        x: i.x - n.width,
+        y: l
+      };
+      break;
+    default:
+      m = {
+        x: i.x,
+        y: i.y
+      };
+  }
+  switch (S(e)) {
+    case "start":
+      m[a] -= r * (c && h ? -1 : 1);
+      break;
+    case "end":
+      m[a] += r * (c && h ? -1 : 1);
+      break;
+  }
+  return m;
+}
+async function N(t, e) {
+  var c;
+  e === void 0 && (e = {});
+  const {
+    x: i,
+    y: n,
+    platform: s,
+    rects: a,
+    elements: d,
+    strategy: u
+  } = t, {
+    boundary: h = "clippingAncestors",
+    rootBoundary: o = "viewport",
+    elementContext: l = "floating",
+    altBoundary: r = !1,
+    padding: m = 0
+  } = E(e, t), f = H(m), p = d[r ? l === "floating" ? "reference" : "floating" : l], g = k(await s.getClippingRect({
+    element: (c = await (s.isElement == null ? void 0 : s.isElement(p))) == null || c ? p : p.contextElement || await (s.getDocumentElement == null ? void 0 : s.getDocumentElement(d.floating)),
+    boundary: h,
+    rootBoundary: o,
+    strategy: u
+  })), w = l === "floating" ? {
+    x: i,
+    y: n,
+    width: a.floating.width,
+    height: a.floating.height
+  } : a.reference, v = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(d.floating)), y = await (s.isElement == null ? void 0 : s.isElement(v)) ? await (s.getScale == null ? void 0 : s.getScale(v)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, b = k(s.convertOffsetParentRelativeRectToViewportRelativeRect ? await s.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: d,
+    rect: w,
+    offsetParent: v,
+    strategy: u
+  }) : w);
+  return {
+    top: (g.top - b.top + f.top) / y.y,
+    bottom: (b.bottom - g.bottom + f.bottom) / y.y,
+    left: (g.left - b.left + f.left) / y.x,
+    right: (b.right - g.right + f.right) / y.x
+  };
+}
+const U = 50, Q = async (t, e, c) => {
+  const {
+    placement: i = "bottom",
+    strategy: n = "absolute",
+    middleware: s = [],
+    platform: a
+  } = c, d = a.detectOverflow ? a : {
+    ...a,
+    detectOverflow: N
+  }, u = await (a.isRTL == null ? void 0 : a.isRTL(e));
+  let h = await a.getElementRects({
+    reference: t,
+    floating: e,
+    strategy: n
+  }), {
+    x: o,
+    y: l
+  } = W(h, i, u), r = i, m = 0;
+  const f = {};
+  for (let x = 0; x < s.length; x++) {
+    const p = s[x];
+    if (!p)
+      continue;
+    const {
+      name: g,
+      fn: w
+    } = p, {
+      x: v,
+      y,
+      data: b,
+      reset: O
+    } = await w({
+      x: o,
+      y: l,
+      initialPlacement: i,
+      placement: r,
+      strategy: n,
+      middlewareData: f,
+      rects: h,
+      platform: d,
+      elements: {
+        reference: t,
+        floating: e
+      }
+    });
+    o = v ?? o, l = y ?? l, f[g] = {
+      ...f[g],
+      ...b
+    }, O && m < U && (m++, typeof O == "object" && (O.placement && (r = O.placement), O.rects && (h = O.rects === !0 ? await a.getElementRects({
+      reference: t,
+      floating: e,
+      strategy: n
+    }) : O.rects), {
+      x: o,
+      y: l
+    } = W(h, r, u)), x = -1);
+  }
+  return {
+    x: o,
+    y: l,
+    placement: r,
+    strategy: n,
+    middlewareData: f
+  };
+};
+function q(t, e, c) {
+  return (t ? [...c.filter((n) => S(n) === t), ...c.filter((n) => S(n) !== t)] : c.filter((n) => D(n) === n)).filter((n) => t ? S(n) === t || (e ? z(n) !== n : !1) : !0);
+}
+const Z = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "autoPlacement",
+    options: t,
+    async fn(e) {
+      var c, i, n;
+      const {
+        rects: s,
+        middlewareData: a,
+        placement: d,
+        platform: u,
+        elements: h
+      } = e, {
+        crossAxis: o = !1,
+        alignment: l,
+        allowedPlacements: r = V,
+        autoAlignment: m = !0,
+        ...f
+      } = E(t, e), x = l !== void 0 || r === V ? q(l || null, m, r) : r, p = await u.detectOverflow(e, f), g = ((c = a.autoPlacement) == null ? void 0 : c.index) || 0, w = x[g];
+      if (w == null)
+        return {};
+      const v = Y(w, s, await (u.isRTL == null ? void 0 : u.isRTL(h.floating)));
+      if (d !== w)
+        return {
+          reset: {
+            placement: x[0]
+          }
+        };
+      const y = [p[D(w)], p[v[0]], p[v[1]]], b = [...((i = a.autoPlacement) == null ? void 0 : i.overflows) || [], {
+        placement: w,
+        overflows: y
+      }], O = x[g + 1];
+      if (O)
+        return {
+          data: {
+            index: g + 1,
+            overflows: b
+          },
+          reset: {
+            placement: O
+          }
+        };
+      const P = b.map((A) => {
+        const R = S(A.placement);
+        return [A.placement, R && o ? (
+          // Check along the mainAxis and main crossAxis side.
+          A.overflows.slice(0, 2).reduce((M, _) => M + _, 0)
+        ) : (
+          // Check only the mainAxis.
+          A.overflows[0]
+        ), A.overflows];
+      }).sort((A, R) => A[1] - R[1]), T = ((n = P.filter((A) => A[2].slice(
+        0,
+        // Aligned placements should not check their opposite crossAxis
+        // side.
+        S(A[0]) ? 2 : 3
+      ).every((R) => R <= 0))[0]) == null ? void 0 : n[0]) || P[0][0];
+      return T !== d ? {
+        data: {
+          index: g + 1,
+          overflows: b
+        },
+        reset: {
+          placement: T
+        }
+      } : {};
+    }
+  };
+}, G = /* @__PURE__ */ new Set(["left", "top"]);
+async function J(t, e) {
+  const {
+    placement: c,
+    platform: i,
+    elements: n
+  } = t, s = await (i.isRTL == null ? void 0 : i.isRTL(n.floating)), a = D(c), d = S(c), u = $(c) === "y", h = G.has(a) ? -1 : 1, o = s && u ? -1 : 1, l = E(e, t);
+  let {
+    mainAxis: r,
+    crossAxis: m,
+    alignmentAxis: f
+  } = typeof l == "number" ? {
+    mainAxis: l,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: l.mainAxis || 0,
+    crossAxis: l.crossAxis || 0,
+    alignmentAxis: l.alignmentAxis
+  };
+  return d && typeof f == "number" && (m = d === "end" ? f * -1 : f), u ? {
+    x: m * o,
+    y: r * h
+  } : {
+    x: r * h,
+    y: m * o
+  };
+}
+const tt = function(t) {
+  return t === void 0 && (t = 0), {
+    name: "offset",
+    options: t,
+    async fn(e) {
+      var c, i;
+      const {
+        x: n,
+        y: s,
+        placement: a,
+        middlewareData: d
+      } = e, u = await J(e, t);
+      return a === ((c = d.offset) == null ? void 0 : c.placement) && (i = d.arrow) != null && i.alignmentOffset ? {} : {
+        x: n + u.x,
+        y: s + u.y,
+        data: {
+          ...u,
+          placement: a
+        }
+      };
+    }
+  };
+}, et = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "shift",
+    options: t,
+    async fn(e) {
+      const {
+        x: c,
+        y: i,
+        placement: n,
+        platform: s
+      } = e, {
+        mainAxis: a = !0,
+        crossAxis: d = !1,
+        limiter: u = {
+          fn: (g) => {
+            let {
+              x: w,
+              y: v
+            } = g;
+            return {
+              x: w,
+              y: v
+            };
+          }
+        },
+        ...h
+      } = E(t, e), o = {
+        x: c,
+        y: i
+      }, l = await s.detectOverflow(e, h), r = $(D(n)), m = I(r);
+      let f = o[m], x = o[r];
+      if (a) {
+        const g = m === "y" ? "top" : "left", w = m === "y" ? "bottom" : "right", v = f + l[g], y = f - l[w];
+        f = F(v, f, y);
+      }
+      if (d) {
+        const g = r === "y" ? "top" : "left", w = r === "y" ? "bottom" : "right", v = x + l[g], y = x - l[w];
+        x = F(v, x, y);
+      }
+      const p = u.fn({
+        ...e,
+        [m]: f,
+        [r]: x
+      });
+      return {
+        ...p,
+        data: {
+          x: p.x - c,
+          y: p.y - i,
+          enabled: {
+            [m]: a,
+            [r]: d
+          }
+        }
+      };
+    }
+  };
+}, nt = function(t) {
+  return t === void 0 && (t = {}), {
+    name: "size",
+    options: t,
+    async fn(e) {
+      var c, i;
+      const {
+        placement: n,
+        rects: s,
+        platform: a,
+        elements: d
+      } = e, {
+        apply: u = () => {
+        },
+        ...h
+      } = E(t, e), o = await a.detectOverflow(e, h), l = D(n), r = S(n), m = $(n) === "y", {
+        width: f,
+        height: x
+      } = s.floating;
+      let p, g;
+      l === "top" || l === "bottom" ? (p = l, g = r === (await (a.isRTL == null ? void 0 : a.isRTL(d.floating)) ? "start" : "end") ? "left" : "right") : (g = l, p = r === "end" ? "top" : "bottom");
+      const w = x - o.top - o.bottom, v = f - o.left - o.right, y = B(x - o[p], w), b = B(f - o[g], v), O = !e.middlewareData.shift;
+      let P = y, L = b;
+      if ((c = e.middlewareData.shift) != null && c.enabled.x && (L = v), (i = e.middlewareData.shift) != null && i.enabled.y && (P = w), O && !r) {
+        const A = C(o.left, 0), R = C(o.right, 0), M = C(o.top, 0), _ = C(o.bottom, 0);
+        m ? L = f - 2 * (A !== 0 || R !== 0 ? A + R : C(o.left, o.right)) : P = x - 2 * (M !== 0 || _ !== 0 ? M + _ : C(o.top, o.bottom));
+      }
+      await u({
+        ...e,
+        availableWidth: L,
+        availableHeight: P
+      });
+      const T = await a.getDimensions(d.floating);
+      return f !== T.width || x !== T.height ? {
+        reset: {
+          rects: !0
+        }
+      } : {};
+    }
+  };
+};
+export {
+  Z as autoPlacement,
+  Q as computePosition,
+  N as detectOverflow,
+  tt as offset,
+  k as rectToClientRect,
+  et as shift,
+  nt as size
+};

package/dist/node_modules/@floating-ui/dom/dist/floating-ui.dom.js

@@ -0,0 +1,313 @@
+import { computePosition as Z, offset as tt, autoPlacement as et, size as ot, shift as it } from "../../core/dist/floating-ui.core.js";
+import { createCoords as g, round as W, rectToClientRect as z, max as T, min as A } from "../../utils/dist/floating-ui.utils.js";
+import { isElement as p, getDocumentElement as x, getComputedStyle as y, isHTMLElement as C, getWindow as R, isTopLayer as D, getParentNode as O, isLastTraversableNode as E, isTableElement as nt, isContainingBlock as X, getContainingBlock as st, getNodeName as N, isOverflowElement as H, getNodeScroll as S, getOverflowAncestors as ct, getFrameElement as M, isWebKit as _ } from "../../utils/dist/floating-ui.utils.dom.js";
+function K(t) {
+  const e = y(t);
+  let i = parseFloat(e.width) || 0, o = parseFloat(e.height) || 0;
+  const n = C(t), c = n ? t.offsetWidth : i, s = n ? t.offsetHeight : o, r = W(i) !== c || W(o) !== s;
+  return r && (i = c, o = s), {
+    width: i,
+    height: o,
+    $: r
+  };
+}
+function j(t) {
+  return p(t) ? t : t.contextElement;
+}
+function L(t) {
+  const e = j(t);
+  if (!C(e))
+    return g(1);
+  const i = e.getBoundingClientRect(), {
+    width: o,
+    height: n,
+    $: c
+  } = K(e);
+  let s = (c ? W(i.width) : i.width) / o, r = (c ? W(i.height) : i.height) / n;
+  return (!s || !Number.isFinite(s)) && (s = 1), (!r || !Number.isFinite(r)) && (r = 1), {
+    x: s,
+    y: r
+  };
+}
+const rt = /* @__PURE__ */ g(0);
+function q(t) {
+  const e = R(t);
+  return !_() || !e.visualViewport ? rt : {
+    x: e.visualViewport.offsetLeft,
+    y: e.visualViewport.offsetTop
+  };
+}
+function lt(t, e, i) {
+  return e === void 0 && (e = !1), !i || e && i !== R(t) ? !1 : e;
+}
+function v(t, e, i, o) {
+  e === void 0 && (e = !1), i === void 0 && (i = !1);
+  const n = t.getBoundingClientRect(), c = j(t);
+  let s = g(1);
+  e && (o ? p(o) && (s = L(o)) : s = L(t));
+  const r = lt(c, i, o) ? q(c) : g(0);
+  let l = (n.left + r.x) / s.x, f = (n.top + r.y) / s.y, u = n.width / s.x, h = n.height / s.y;
+  if (c) {
+    const d = R(c), a = o && p(o) ? R(o) : o;
+    let m = d, w = M(m);
+    for (; w && o && a !== m; ) {
+      const b = L(w), V = w.getBoundingClientRect(), $ = y(w), U = V.left + (w.clientLeft + parseFloat($.paddingLeft)) * b.x, Y = V.top + (w.clientTop + parseFloat($.paddingTop)) * b.y;
+      l *= b.x, f *= b.y, u *= b.x, h *= b.y, l += U, f += Y, m = R(w), w = M(m);
+    }
+  }
+  return z({
+    width: u,
+    height: h,
+    x: l,
+    y: f
+  });
+}
+function B(t, e) {
+  const i = S(t).scrollLeft;
+  return e ? e.left + i : v(x(t)).left + i;
+}
+function G(t, e) {
+  const i = t.getBoundingClientRect(), o = i.left + e.scrollLeft - B(t, i), n = i.top + e.scrollTop;
+  return {
+    x: o,
+    y: n
+  };
+}
+function ft(t) {
+  let {
+    elements: e,
+    rect: i,
+    offsetParent: o,
+    strategy: n
+  } = t;
+  const c = n === "fixed", s = x(o), r = e ? D(e.floating) : !1;
+  if (o === s || r && c)
+    return i;
+  let l = {
+    scrollLeft: 0,
+    scrollTop: 0
+  }, f = g(1);
+  const u = g(0), h = C(o);
+  if ((h || !h && !c) && ((N(o) !== "body" || H(s)) && (l = S(o)), h)) {
+    const a = v(o);
+    f = L(o), u.x = a.x + o.clientLeft, u.y = a.y + o.clientTop;
+  }
+  const d = s && !h && !c ? G(s, l) : g(0);
+  return {
+    width: i.width * f.x,
+    height: i.height * f.y,
+    x: i.x * f.x - l.scrollLeft * f.x + u.x + d.x,
+    y: i.y * f.y - l.scrollTop * f.y + u.y + d.y
+  };
+}
+function ut(t) {
+  return Array.from(t.getClientRects());
+}
+function ht(t) {
+  const e = x(t), i = S(t), o = t.ownerDocument.body, n = T(e.scrollWidth, e.clientWidth, o.scrollWidth, o.clientWidth), c = T(e.scrollHeight, e.clientHeight, o.scrollHeight, o.clientHeight);
+  let s = -i.scrollLeft + B(t);
+  const r = -i.scrollTop;
+  return y(o).direction === "rtl" && (s += T(e.clientWidth, o.clientWidth) - n), {
+    width: n,
+    height: c,
+    x: s,
+    y: r
+  };
+}
+const I = 25;
+function at(t, e) {
+  const i = R(t), o = x(t), n = i.visualViewport;
+  let c = o.clientWidth, s = o.clientHeight, r = 0, l = 0;
+  if (n) {
+    c = n.width, s = n.height;
+    const u = _();
+    (!u || u && e === "fixed") && (r = n.offsetLeft, l = n.offsetTop);
+  }
+  const f = B(o);
+  if (f <= 0) {
+    const u = o.ownerDocument, h = u.body, d = getComputedStyle(h), a = u.compatMode === "CSS1Compat" && parseFloat(d.marginLeft) + parseFloat(d.marginRight) || 0, m = Math.abs(o.clientWidth - h.clientWidth - a);
+    m <= I && (c -= m);
+  } else f <= I && (c += f);
+  return {
+    width: c,
+    height: s,
+    x: r,
+    y: l
+  };
+}
+function dt(t, e) {
+  const i = v(t, !0, e === "fixed"), o = i.top + t.clientTop, n = i.left + t.clientLeft, c = C(t) ? L(t) : g(1), s = t.clientWidth * c.x, r = t.clientHeight * c.y, l = n * c.x, f = o * c.y;
+  return {
+    width: s,
+    height: r,
+    x: l,
+    y: f
+  };
+}
+function P(t, e, i) {
+  let o;
+  if (e === "viewport")
+    o = at(t, i);
+  else if (e === "document")
+    o = ht(x(t));
+  else if (p(e))
+    o = dt(e, i);
+  else {
+    const n = q(t);
+    o = {
+      x: e.x - n.x,
+      y: e.y - n.y,
+      width: e.width,
+      height: e.height
+    };
+  }
+  return z(o);
+}
+function J(t, e) {
+  const i = O(t);
+  return i === e || !p(i) || E(i) ? !1 : y(i).position === "fixed" || J(i, e);
+}
+function gt(t, e) {
+  const i = e.get(t);
+  if (i)
+    return i;
+  let o = ct(t, []).filter((r) => p(r) && N(r) !== "body"), n = null;
+  const c = y(t).position === "fixed";
+  let s = c ? O(t) : t;
+  for (; p(s) && !E(s); ) {
+    const r = y(s), l = X(s);
+    !l && r.position === "fixed" && (n = null), (c ? !l && !n : !l && r.position === "static" && !!n && (n.position === "absolute" || n.position === "fixed") || H(s) && !l && J(t, s)) ? o = o.filter((u) => u !== s) : n = r, s = O(s);
+  }
+  return e.set(t, o), o;
+}
+function pt(t) {
+  let {
+    element: e,
+    boundary: i,
+    rootBoundary: o,
+    strategy: n
+  } = t;
+  const s = [...i === "clippingAncestors" ? D(e) ? [] : gt(e, this._c) : [].concat(i), o], r = P(e, s[0], n);
+  let l = r.top, f = r.right, u = r.bottom, h = r.left;
+  for (let d = 1; d < s.length; d++) {
+    const a = P(e, s[d], n);
+    l = T(a.top, l), f = A(a.right, f), u = A(a.bottom, u), h = T(a.left, h);
+  }
+  return {
+    width: f - h,
+    height: u - l,
+    x: h,
+    y: l
+  };
+}
+function yt(t) {
+  const {
+    width: e,
+    height: i
+  } = K(t);
+  return {
+    width: e,
+    height: i
+  };
+}
+function wt(t, e, i) {
+  const o = C(e), n = x(e), c = i === "fixed", s = v(t, !0, c, e);
+  let r = {
+    scrollLeft: 0,
+    scrollTop: 0
+  };
+  const l = g(0);
+  function f() {
+    l.x = B(n);
+  }
+  if (o || !o && !c)
+    if ((N(e) !== "body" || H(n)) && (r = S(e)), o) {
+      const a = v(e, !0, c, e);
+      l.x = a.x + e.clientLeft, l.y = a.y + e.clientTop;
+    } else n && f();
+  c && !o && n && f();
+  const u = n && !o && !c ? G(n, r) : g(0), h = s.left + r.scrollLeft - l.x - u.x, d = s.top + r.scrollTop - l.y - u.y;
+  return {
+    x: h,
+    y: d,
+    width: s.width,
+    height: s.height
+  };
+}
+function F(t) {
+  return y(t).position === "static";
+}
+function k(t, e) {
+  if (!C(t) || y(t).position === "fixed")
+    return null;
+  if (e)
+    return e(t);
+  let i = t.offsetParent;
+  return x(t) === i && (i = i.ownerDocument.body), i;
+}
+function Q(t, e) {
+  const i = R(t);
+  if (D(t))
+    return i;
+  if (!C(t)) {
+    let n = O(t);
+    for (; n && !E(n); ) {
+      if (p(n) && !F(n))
+        return n;
+      n = O(n);
+    }
+    return i;
+  }
+  let o = k(t, e);
+  for (; o && nt(o) && F(o); )
+    o = k(o, e);
+  return o && E(o) && F(o) && !X(o) ? i : o || st(t) || i;
+}
+const xt = async function(t) {
+  const e = this.getOffsetParent || Q, i = this.getDimensions, o = await i(t.floating);
+  return {
+    reference: wt(t.reference, await e(t.floating), t.strategy),
+    floating: {
+      x: 0,
+      y: 0,
+      width: o.width,
+      height: o.height
+    }
+  };
+};
+function mt(t) {
+  return y(t).direction === "rtl";
+}
+const Rt = {
+  convertOffsetParentRelativeRectToViewportRelativeRect: ft,
+  getDocumentElement: x,
+  getClippingRect: pt,
+  getOffsetParent: Q,
+  getElementRects: xt,
+  getClientRects: ut,
+  getDimensions: yt,
+  getScale: L,
+  isElement: p,
+  isRTL: mt
+}, Tt = tt, Ot = et, vt = it, Wt = ot, Et = (t, e, i) => {
+  const o = /* @__PURE__ */ new Map(), n = {
+    platform: Rt,
+    ...i
+  }, c = {
+    ...n.platform,
+    _c: o
+  };
+  return Z(t, e, {
+    ...n,
+    platform: c
+  });
+};
+export {
+  Ot as autoPlacement,
+  Et as computePosition,
+  ct as getOverflowAncestors,
+  Tt as offset,
+  Rt as platform,
+  vt as shift,
+  Wt as size
+};