ep-craft 0.1.21 → 0.1.22

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

@@ -1,377 +0,0 @@
-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
-};