laif-ds 0.2.10 → 0.2.12

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

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