@vc-shell/framework 2.0.0-alpha.1 → 2.0.0-alpha.2

package/dist/vendor-floating-ui-core-BoHdh92a.js

@@ -1,432 +0,0 @@
-import { e as W, g as F, a as _, b as G, c as J, d as K, f as Q, h as z, i as Y, j as Z, k as I, l as N, m as U, n as H, r as B, o as j } from "./vendor-floating-ui-utils-CidJRIm2.js";
-function X(l, t, d) {
-  let {
-    reference: i,
-    floating: f
-  } = l;
-  const e = _(t), s = N(t), r = U(s), g = F(t), u = e === "y", a = i.x + i.width / 2 - f.width / 2, c = i.y + i.height / 2 - f.height / 2, m = i[r] / 2 - f[r] / 2;
-  let n;
-  switch (g) {
-    case "top":
-      n = {
-        x: a,
-        y: i.y - f.height
-      };
-      break;
-    case "bottom":
-      n = {
-        x: a,
-        y: i.y + i.height
-      };
-      break;
-    case "right":
-      n = {
-        x: i.x + i.width,
-        y: c
-      };
-      break;
-    case "left":
-      n = {
-        x: i.x - f.width,
-        y: c
-      };
-      break;
-    default:
-      n = {
-        x: i.x,
-        y: i.y
-      };
-  }
-  switch (Y(t)) {
-    case "start":
-      n[s] -= m * (d && u ? -1 : 1);
-      break;
-    case "end":
-      n[s] += m * (d && u ? -1 : 1);
-      break;
-  }
-  return n;
-}
-async function tt(l, t) {
-  var d;
-  t === void 0 && (t = {});
-  const {
-    x: i,
-    y: f,
-    platform: e,
-    rects: s,
-    elements: r,
-    strategy: g
-  } = l, {
-    boundary: u = "clippingAncestors",
-    rootBoundary: a = "viewport",
-    elementContext: c = "floating",
-    altBoundary: m = !1,
-    padding: n = 0
-  } = W(t, l), o = I(n), p = r[m ? c === "floating" ? "reference" : "floating" : c], w = B(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(r.floating)),
-    boundary: u,
-    rootBoundary: a,
-    strategy: g
-  })), v = c === "floating" ? {
-    x: i,
-    y: f,
-    width: s.floating.width,
-    height: s.floating.height
-  } : s.reference, h = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(r.floating)), y = await (e.isElement == null ? void 0 : e.isElement(h)) ? await (e.getScale == null ? void 0 : e.getScale(h)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, O = B(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: r,
-    rect: v,
-    offsetParent: h,
-    strategy: g
-  }) : v);
-  return {
-    top: (w.top - O.top + o.top) / y.y,
-    bottom: (O.bottom - w.bottom + o.bottom) / y.y,
-    left: (w.left - O.left + o.left) / y.x,
-    right: (O.right - w.right + o.right) / y.x
-  };
-}
-const et = 50, ot = async (l, t, d) => {
-  const {
-    placement: i = "bottom",
-    strategy: f = "absolute",
-    middleware: e = [],
-    platform: s
-  } = d, r = s.detectOverflow ? s : {
-    ...s,
-    detectOverflow: tt
-  }, g = await (s.isRTL == null ? void 0 : s.isRTL(t));
-  let u = await s.getElementRects({
-    reference: l,
-    floating: t,
-    strategy: f
-  }), {
-    x: a,
-    y: c
-  } = X(u, i, g), m = i, n = 0;
-  const o = {};
-  for (let x = 0; x < e.length; x++) {
-    const p = e[x];
-    if (!p)
-      continue;
-    const {
-      name: w,
-      fn: v
-    } = p, {
-      x: h,
-      y,
-      data: O,
-      reset: A
-    } = await v({
-      x: a,
-      y: c,
-      initialPlacement: i,
-      placement: m,
-      strategy: f,
-      middlewareData: o,
-      rects: u,
-      platform: r,
-      elements: {
-        reference: l,
-        floating: t
-      }
-    });
-    a = h ?? a, c = y ?? c, o[w] = {
-      ...o[w],
-      ...O
-    }, A && n < et && (n++, typeof A == "object" && (A.placement && (m = A.placement), A.rects && (u = A.rects === !0 ? await s.getElementRects({
-      reference: l,
-      floating: t,
-      strategy: f
-    }) : A.rects), {
-      x: a,
-      y: c
-    } = X(u, m, g)), x = -1);
-  }
-  return {
-    x: a,
-    y: c,
-    placement: m,
-    strategy: f,
-    middlewareData: o
-  };
-}, at = (l) => ({
-  name: "arrow",
-  options: l,
-  async fn(t) {
-    const {
-      x: d,
-      y: i,
-      placement: f,
-      rects: e,
-      platform: s,
-      elements: r,
-      middlewareData: g
-    } = t, {
-      element: u,
-      padding: a = 0
-    } = W(l, t) || {};
-    if (u == null)
-      return {};
-    const c = I(a), m = {
-      x: d,
-      y: i
-    }, n = N(f), o = U(n), x = await s.getDimensions(u), p = n === "y", w = p ? "top" : "left", v = p ? "bottom" : "right", h = p ? "clientHeight" : "clientWidth", y = e.reference[o] + e.reference[n] - m[n] - e.floating[o], O = m[n] - e.reference[n], A = await (s.getOffsetParent == null ? void 0 : s.getOffsetParent(u));
-    let R = A ? A[h] : 0;
-    (!R || !await (s.isElement == null ? void 0 : s.isElement(A))) && (R = r.floating[h] || e.floating[o]);
-    const E = y / 2 - O / 2, C = R / 2 - x[o] / 2 - 1, P = H(c[w], C), L = H(c[v], C), k = P, M = R - x[o] - L, b = R / 2 - x[o] / 2 + E, $ = z(k, b, M), T = !g.arrow && Y(f) != null && b !== $ && e.reference[o] / 2 - (b < k ? P : L) - x[o] / 2 < 0, D = T ? b < k ? b - k : b - M : 0;
-    return {
-      [n]: m[n] + D,
-      data: {
-        [n]: $,
-        centerOffset: b - $ - D,
-        ...T && {
-          alignmentOffset: D
-        }
-      },
-      reset: T
-    };
-  }
-}), lt = function(l) {
-  return l === void 0 && (l = {}), {
-    name: "flip",
-    options: l,
-    async fn(t) {
-      var d, i;
-      const {
-        placement: f,
-        middlewareData: e,
-        rects: s,
-        initialPlacement: r,
-        platform: g,
-        elements: u
-      } = t, {
-        mainAxis: a = !0,
-        crossAxis: c = !0,
-        fallbackPlacements: m,
-        fallbackStrategy: n = "bestFit",
-        fallbackAxisSideDirection: o = "none",
-        flipAlignment: x = !0,
-        ...p
-      } = W(l, t);
-      if ((d = e.arrow) != null && d.alignmentOffset)
-        return {};
-      const w = F(f), v = _(r), h = F(r) === r, y = await (g.isRTL == null ? void 0 : g.isRTL(u.floating)), O = m || (h || !x ? [G(r)] : J(r)), A = o !== "none";
-      !m && A && O.push(...K(r, x, o, y));
-      const R = [r, ...O], E = await g.detectOverflow(t, p), C = [];
-      let P = ((i = e.flip) == null ? void 0 : i.overflows) || [];
-      if (a && C.push(E[w]), c) {
-        const b = Q(f, s, y);
-        C.push(E[b[0]], E[b[1]]);
-      }
-      if (P = [...P, {
-        placement: f,
-        overflows: C
-      }], !C.every((b) => b <= 0)) {
-        var L, k;
-        const b = (((L = e.flip) == null ? void 0 : L.index) || 0) + 1, $ = R[b];
-        if ($ && (!(c === "alignment" ? v !== _($) : !1) || // We leave the current main axis only if every placement on that axis
-        // overflows the main axis.
-        P.every((S) => _(S.placement) === v ? S.overflows[0] > 0 : !0)))
-          return {
-            data: {
-              index: b,
-              overflows: P
-            },
-            reset: {
-              placement: $
-            }
-          };
-        let T = (k = P.filter((D) => D.overflows[0] <= 0).sort((D, S) => D.overflows[1] - S.overflows[1])[0]) == null ? void 0 : k.placement;
-        if (!T)
-          switch (n) {
-            case "bestFit": {
-              var M;
-              const D = (M = P.filter((S) => {
-                if (A) {
-                  const V = _(S.placement);
-                  return V === v || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  V === "y";
-                }
-                return !0;
-              }).map((S) => [S.placement, S.overflows.filter((V) => V > 0).reduce((V, q) => V + q, 0)]).sort((S, V) => S[1] - V[1])[0]) == null ? void 0 : M[0];
-              D && (T = D);
-              break;
-            }
-            case "initialPlacement":
-              T = r;
-              break;
-          }
-        if (f !== T)
-          return {
-            reset: {
-              placement: T
-            }
-          };
-      }
-      return {};
-    }
-  };
-}, nt = /* @__PURE__ */ new Set(["left", "top"]);
-async function it(l, t) {
-  const {
-    placement: d,
-    platform: i,
-    elements: f
-  } = l, e = await (i.isRTL == null ? void 0 : i.isRTL(f.floating)), s = F(d), r = Y(d), g = _(d) === "y", u = nt.has(s) ? -1 : 1, a = e && g ? -1 : 1, c = W(t, l);
-  let {
-    mainAxis: m,
-    crossAxis: n,
-    alignmentAxis: o
-  } = typeof c == "number" ? {
-    mainAxis: c,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: c.mainAxis || 0,
-    crossAxis: c.crossAxis || 0,
-    alignmentAxis: c.alignmentAxis
-  };
-  return r && typeof o == "number" && (n = r === "end" ? o * -1 : o), g ? {
-    x: n * a,
-    y: m * u
-  } : {
-    x: m * u,
-    y: n * a
-  };
-}
-const ct = function(l) {
-  return l === void 0 && (l = 0), {
-    name: "offset",
-    options: l,
-    async fn(t) {
-      var d, i;
-      const {
-        x: f,
-        y: e,
-        placement: s,
-        middlewareData: r
-      } = t, g = await it(t, l);
-      return s === ((d = r.offset) == null ? void 0 : d.placement) && (i = r.arrow) != null && i.alignmentOffset ? {} : {
-        x: f + g.x,
-        y: e + g.y,
-        data: {
-          ...g,
-          placement: s
-        }
-      };
-    }
-  };
-}, rt = function(l) {
-  return l === void 0 && (l = {}), {
-    name: "shift",
-    options: l,
-    async fn(t) {
-      const {
-        x: d,
-        y: i,
-        placement: f,
-        platform: e
-      } = t, {
-        mainAxis: s = !0,
-        crossAxis: r = !1,
-        limiter: g = {
-          fn: (w) => {
-            let {
-              x: v,
-              y: h
-            } = w;
-            return {
-              x: v,
-              y: h
-            };
-          }
-        },
-        ...u
-      } = W(l, t), a = {
-        x: d,
-        y: i
-      }, c = await e.detectOverflow(t, u), m = _(F(f)), n = Z(m);
-      let o = a[n], x = a[m];
-      if (s) {
-        const w = n === "y" ? "top" : "left", v = n === "y" ? "bottom" : "right", h = o + c[w], y = o - c[v];
-        o = z(h, o, y);
-      }
-      if (r) {
-        const w = m === "y" ? "top" : "left", v = m === "y" ? "bottom" : "right", h = x + c[w], y = x - c[v];
-        x = z(h, x, y);
-      }
-      const p = g.fn({
-        ...t,
-        [n]: o,
-        [m]: x
-      });
-      return {
-        ...p,
-        data: {
-          x: p.x - d,
-          y: p.y - i,
-          enabled: {
-            [n]: s,
-            [m]: r
-          }
-        }
-      };
-    }
-  };
-}, ft = function(l) {
-  return l === void 0 && (l = {}), {
-    name: "size",
-    options: l,
-    async fn(t) {
-      var d, i;
-      const {
-        placement: f,
-        rects: e,
-        platform: s,
-        elements: r
-      } = t, {
-        apply: g = () => {
-        },
-        ...u
-      } = W(l, t), a = await s.detectOverflow(t, u), c = F(f), m = Y(f), n = _(f) === "y", {
-        width: o,
-        height: x
-      } = e.floating;
-      let p, w;
-      c === "top" || c === "bottom" ? (p = c, w = m === (await (s.isRTL == null ? void 0 : s.isRTL(r.floating)) ? "start" : "end") ? "left" : "right") : (w = c, p = m === "end" ? "top" : "bottom");
-      const v = x - a.top - a.bottom, h = o - a.left - a.right, y = H(x - a[p], v), O = H(o - a[w], h), A = !t.middlewareData.shift;
-      let R = y, E = O;
-      if ((d = t.middlewareData.shift) != null && d.enabled.x && (E = h), (i = t.middlewareData.shift) != null && i.enabled.y && (R = v), A && !m) {
-        const P = j(a.left, 0), L = j(a.right, 0), k = j(a.top, 0), M = j(a.bottom, 0);
-        n ? E = o - 2 * (P !== 0 || L !== 0 ? P + L : j(a.left, a.right)) : R = x - 2 * (k !== 0 || M !== 0 ? k + M : j(a.top, a.bottom));
-      }
-      await g({
-        ...t,
-        availableWidth: E,
-        availableHeight: R
-      });
-      const C = await s.getDimensions(r.floating);
-      return o !== C.width || x !== C.height ? {
-        reset: {
-          rects: !0
-        }
-      } : {};
-    }
-  };
-};
-export {
-  at as a,
-  ft as b,
-  ot as c,
-  lt as f,
-  ct as o,
-  rt as s
-};