ep-craft 0.1.13 → 0.1.15

package/dist/node_modules/.pnpm/@floating-ui_core@1.8.0/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -0,0 +1,377 @@
+import { evaluate as _, getSide as B, getSideAxis as M, getOppositePlacement as q, getExpandedPlacements as G, getOppositeAxisPlacements as J, getAlignmentSides as K, getPaddingObject as z, getAlignmentAxis as H, getAlignment as X, clamp as I, getOppositeAxis as Q, rectToClientRect as Y, getAxisLength as N, min as $ } from "../../../../../@floating-ui_utils@0.2.12/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
+function W(l, o, d) {
+  let {
+    reference: t,
+    floating: r
+  } = l;
+  const e = M(o), s = H(o), a = N(s), m = B(o), u = e === "y", g = t.x + t.width / 2 - r.width / 2, c = t.y + t.height / 2 - r.height / 2, f = t[a] / 2 - r[a] / 2;
+  let n;
+  switch (m) {
+    case "top":
+      n = {
+        x: g,
+        y: t.y - r.height
+      };
+      break;
+    case "bottom":
+      n = {
+        x: g,
+        y: t.y + t.height
+      };
+      break;
+    case "right":
+      n = {
+        x: t.x + t.width,
+        y: c
+      };
+      break;
+    case "left":
+      n = {
+        x: t.x - r.width,
+        y: c
+      };
+      break;
+    default:
+      n = {
+        x: t.x,
+        y: t.y
+      };
+  }
+  const i = X(o);
+  return i && (n[s] += f * (i === "end" ? 1 : -1) * (d && u ? -1 : 1)), n;
+}
+async function Z(l, o) {
+  var d;
+  o === void 0 && (o = {});
+  const {
+    x: t,
+    y: r,
+    platform: e,
+    rects: s,
+    elements: a,
+    strategy: m
+  } = l, {
+    boundary: u = "clippingAncestors",
+    rootBoundary: g = "viewport",
+    elementContext: c = "floating",
+    altBoundary: f = !1,
+    padding: n = 0
+  } = _(o, l), i = z(n), p = a[f ? c === "floating" ? "reference" : "floating" : c], v = Y(await e.getClippingRect({
+    element: (d = await (e.isElement == null ? void 0 : e.isElement(p))) == null || d ? p : p.contextElement || await (e.getDocumentElement == null ? void 0 : e.getDocumentElement(a.floating)),
+    boundary: u,
+    rootBoundary: g,
+    strategy: m
+  })), y = c === "floating" ? {
+    x: t,
+    y: r,
+    width: s.floating.width,
+    height: s.floating.height
+  } : s.reference, w = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(a.floating)), A = await (e.isElement == null ? void 0 : e.isElement(w)) && await (e.getScale == null ? void 0 : e.getScale(w)) || {
+    x: 1,
+    y: 1
+  }, P = Y(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: y,
+    offsetParent: w,
+    strategy: m
+  }) : y);
+  return {
+    top: (v.top - P.top + i.top) / A.y,
+    bottom: (P.bottom - v.bottom + i.bottom) / A.y,
+    left: (v.left - P.left + i.left) / A.x,
+    right: (P.right - v.right + i.right) / A.x
+  };
+}
+const ee = 50, oe = async (l, o, d) => {
+  const {
+    placement: t = "bottom",
+    strategy: r = "absolute",
+    middleware: e = [],
+    platform: s
+  } = d, a = s.detectOverflow ? s : {
+    ...s,
+    detectOverflow: Z
+  }, m = await (s.isRTL == null ? void 0 : s.isRTL(o));
+  let u = await s.getElementRects({
+    reference: l,
+    floating: o,
+    strategy: r
+  }), {
+    x: g,
+    y: c
+  } = W(u, t, m), f = t, n = 0;
+  const i = {};
+  for (let x = 0; x < e.length; x++) {
+    const p = e[x];
+    if (!p)
+      continue;
+    const {
+      name: v,
+      fn: y
+    } = p, {
+      x: w,
+      y: A,
+      data: P,
+      reset: h
+    } = await y({
+      x: g,
+      y: c,
+      initialPlacement: t,
+      placement: f,
+      strategy: r,
+      middlewareData: i,
+      rects: u,
+      platform: a,
+      elements: {
+        reference: l,
+        floating: o
+      }
+    });
+    g = w ?? g, c = A ?? c, i[v] = {
+      ...i[v],
+      ...P
+    }, h && n < ee && (n++, typeof h == "object" && (h.placement && (f = h.placement), h.rects && (u = h.rects === !0 ? await s.getElementRects({
+      reference: l,
+      floating: o,
+      strategy: r
+    }) : h.rects), {
+      x: g,
+      y: c
+    } = W(u, f, m)), x = -1);
+  }
+  return {
+    x: g,
+    y: c,
+    placement: f,
+    strategy: r,
+    middlewareData: i
+  };
+}, se = (l) => ({
+  name: "arrow",
+  options: l,
+  async fn(o) {
+    const {
+      x: d,
+      y: t,
+      placement: r,
+      rects: e,
+      platform: s,
+      elements: a,
+      middlewareData: m
+    } = o, {
+      element: u,
+      padding: g = 0
+    } = _(l, o) || {};
+    if (u == null)
+      return {};
+    const c = z(g), f = {
+      x: d,
+      y: t
+    }, n = H(r), i = N(n), x = await s.getDimensions(u), p = n === "y", v = p ? "top" : "left", y = p ? "bottom" : "right", w = p ? "clientHeight" : "clientWidth", A = e.reference[i] + e.reference[n] - f[n] - e.floating[i], P = f[n] - e.reference[n], h = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
+    let E = h ? h[w] : 0;
+    (!E || !await (s.isElement == null ? void 0 : s.isElement(h))) && (E = a.floating[w] || e.floating[i]);
+    const V = A / 2 - P / 2, S = E / 2 - x[i] / 2 - 1, b = $(c[v], S), F = $(c[y], S), j = E - x[i] - F, C = E / 2 - x[i] / 2 + V, O = I(b, C, j), T = !m.arrow && X(r) != null && C !== O && e.reference[i] / 2 - (C < b ? b : F) - x[i] / 2 < 0, k = T ? C < b ? C - b : C - j : 0;
+    return {
+      [n]: f[n] + k,
+      data: {
+        [n]: O,
+        centerOffset: C - O - k,
+        ...T && {
+          alignmentOffset: k
+        }
+      },
+      reset: T
+    };
+  }
+}), le = function(l) {
+  return l === void 0 && (l = {}), {
+    name: "flip",
+    options: l,
+    async fn(o) {
+      var d, t;
+      const {
+        placement: r,
+        middlewareData: e,
+        rects: s,
+        initialPlacement: a,
+        platform: m,
+        elements: u
+      } = o, {
+        mainAxis: g = !0,
+        crossAxis: c = !0,
+        fallbackPlacements: f,
+        fallbackStrategy: n = "bestFit",
+        fallbackAxisSideDirection: i = "none",
+        flipAlignment: x = !0,
+        ...p
+      } = _(l, o);
+      if ((d = e.arrow) != null && d.alignmentOffset)
+        return {};
+      const v = B(r), y = M(a), w = B(a) === a, A = await (m.isRTL == null ? void 0 : m.isRTL(u.floating)), P = f || (w || !x ? [q(a)] : G(a)), h = i !== "none";
+      !f && h && P.push(...J(a, x, i, A));
+      const E = [a, ...P], V = await m.detectOverflow(o, p), S = [];
+      let b = ((t = e.flip) == null ? void 0 : t.overflows) || [];
+      if (g && S.push(V[v]), c) {
+        const O = K(r, s, A);
+        S.push(V[O[0]], V[O[1]]);
+      }
+      if (b = [...b, {
+        placement: r,
+        overflows: S
+      }], !S.every((O) => O <= 0)) {
+        var F, j;
+        const O = (((F = e.flip) == null ? void 0 : F.index) || 0) + 1, T = E[O];
+        if (T && (!(c === "alignment" ? y !== M(T) : !1) || // We leave the current main axis only if every placement on that axis
+        // overflows the main axis.
+        b.every((R) => M(R.placement) === y ? R.overflows[0] > 0 : !0)))
+          return {
+            data: {
+              index: O,
+              overflows: b
+            },
+            reset: {
+              placement: T
+            }
+          };
+        let k = (j = b.filter((L) => L.overflows[0] <= 0).sort((L, R) => L.overflows[1] - R.overflows[1])[0]) == null ? void 0 : j.placement;
+        if (!k)
+          switch (n) {
+            case "bestFit": {
+              var C;
+              const L = (C = b.filter((R) => {
+                if (h) {
+                  const D = M(R.placement);
+                  return D === y || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  D === "y";
+                }
+                return !0;
+              }).map((R) => [R.placement, R.overflows.filter((D) => D > 0).reduce((D, U) => D + U, 0)]).sort((R, D) => R[1] - D[1])[0]) == null ? void 0 : C[0];
+              L && (k = L);
+              break;
+            }
+            case "initialPlacement":
+              k = a;
+              break;
+          }
+        if (r !== k)
+          return {
+            reset: {
+              placement: k
+            }
+          };
+      }
+      return {};
+    }
+  };
+}, te = /* @__PURE__ */ new Set(["left", "top"]);
+async function ne(l, o) {
+  const {
+    placement: d,
+    platform: t,
+    elements: r
+  } = l, e = await (t.isRTL == null ? void 0 : t.isRTL(r.floating)), s = B(d), a = X(d), m = M(d) === "y", u = te.has(s) ? -1 : 1, g = e && m ? -1 : 1, c = _(o, l);
+  let {
+    mainAxis: f,
+    crossAxis: n,
+    alignmentAxis: i
+  } = typeof c == "number" ? {
+    mainAxis: c,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: c.mainAxis || 0,
+    crossAxis: c.crossAxis || 0,
+    alignmentAxis: c.alignmentAxis
+  };
+  return a && typeof i == "number" && (n = a === "end" ? i * -1 : i), m ? {
+    x: n * g,
+    y: f * u
+  } : {
+    x: f * u,
+    y: n * g
+  };
+}
+const ae = function(l) {
+  return l === void 0 && (l = 0), {
+    name: "offset",
+    options: l,
+    async fn(o) {
+      var d, t;
+      const {
+        x: r,
+        y: e,
+        placement: s,
+        middlewareData: a
+      } = o, m = await ne(o, l);
+      return s === ((d = a.offset) == null ? void 0 : d.placement) && (t = a.arrow) != null && t.alignmentOffset ? {} : {
+        x: r + m.x,
+        y: e + m.y,
+        data: {
+          ...m,
+          placement: s
+        }
+      };
+    }
+  };
+}, ce = function(l) {
+  return l === void 0 && (l = {}), {
+    name: "shift",
+    options: l,
+    async fn(o) {
+      const {
+        x: d,
+        y: t,
+        placement: r,
+        platform: e
+      } = o, {
+        mainAxis: s = !0,
+        crossAxis: a = !1,
+        limiter: m = {
+          fn: (y) => {
+            let {
+              x: w,
+              y: A
+            } = y;
+            return {
+              x: w,
+              y: A
+            };
+          }
+        },
+        ...u
+      } = _(l, o), g = {
+        x: d,
+        y: t
+      }, c = await e.detectOverflow(o, u), f = M(r), n = Q(f);
+      let i = g[n], x = g[f];
+      const p = (y, w) => I(w + c[y === "y" ? "top" : "left"], w, w - c[y === "y" ? "bottom" : "right"]);
+      s && (i = p(n, i)), a && (x = p(f, x));
+      const v = m.fn({
+        ...o,
+        [n]: i,
+        [f]: x
+      });
+      return {
+        ...v,
+        data: {
+          x: v.x - d,
+          y: v.y - t,
+          enabled: {
+            [n]: s,
+            [f]: a
+          }
+        }
+      };
+    }
+  };
+};
+export {
+  se as arrow,
+  oe as computePosition,
+  Z as detectOverflow,
+  le as flip,
+  ae as offset,
+  Y as rectToClientRect,
+  ce as shift
+};