@xuda.io/xuda-widget-plugin-xuda-drive 1.0.63 → 1.0.65

package/floating-ui/core@1.1.1.js

@@ -0,0 +1,763 @@
+!(function (t, e) {
+  "object" == typeof exports && "undefined" != typeof module
+    ? e(exports)
+    : "function" == typeof define && define.amd
+    ? define(["exports"], e)
+    : e(
+        ((t =
+          "undefined" != typeof globalThis
+            ? globalThis
+            : t || self).FloatingUICore = {})
+      );
+})(this, function (t) {
+  "use strict";
+  function e(t) {
+    return t.split("-")[1];
+  }
+  function n(t) {
+    return "y" === t ? "height" : "width";
+  }
+  function i(t) {
+    return t.split("-")[0];
+  }
+  function o(t) {
+    return ["top", "bottom"].includes(i(t)) ? "x" : "y";
+  }
+  function r(t, r, a) {
+    let { reference: l, floating: s } = t;
+    const f = l.x + l.width / 2 - s.width / 2,
+      c = l.y + l.height / 2 - s.height / 2,
+      u = o(r),
+      m = n(u),
+      d = l[m] / 2 - s[m] / 2,
+      g = "x" === u;
+    let p;
+    switch (i(r)) {
+      case "top":
+        p = { x: f, y: l.y - s.height };
+        break;
+      case "bottom":
+        p = { x: f, y: l.y + l.height };
+        break;
+      case "right":
+        p = { x: l.x + l.width, y: c };
+        break;
+      case "left":
+        p = { x: l.x - s.width, y: c };
+        break;
+      default:
+        p = { x: l.x, y: l.y };
+    }
+    switch (e(r)) {
+      case "start":
+        p[u] -= d * (a && g ? -1 : 1);
+        break;
+      case "end":
+        p[u] += d * (a && g ? -1 : 1);
+    }
+    return p;
+  }
+  function a(t) {
+    return "number" != typeof t
+      ? (function (t) {
+          return { top: 0, right: 0, bottom: 0, left: 0, ...t };
+        })(t)
+      : { top: t, right: t, bottom: t, left: t };
+  }
+  function l(t) {
+    return {
+      ...t,
+      top: t.y,
+      left: t.x,
+      right: t.x + t.width,
+      bottom: t.y + t.height,
+    };
+  }
+  async function s(t, e) {
+    var n;
+    void 0 === e && (e = {});
+    const { x: i, y: o, platform: r, rects: s, elements: f, strategy: c } = t,
+      {
+        boundary: u = "clippingAncestors",
+        rootBoundary: m = "viewport",
+        elementContext: d = "floating",
+        altBoundary: g = !1,
+        padding: p = 0,
+      } = e,
+      h = a(p),
+      y = f[g ? ("floating" === d ? "reference" : "floating") : d],
+      x = l(
+        await r.getClippingRect({
+          element:
+            null ==
+              (n = await (null == r.isElement ? void 0 : r.isElement(y))) || n
+              ? y
+              : y.contextElement ||
+                (await (null == r.getDocumentElement
+                  ? void 0
+                  : r.getDocumentElement(f.floating))),
+          boundary: u,
+          rootBoundary: m,
+          strategy: c,
+        })
+      ),
+      w = "floating" === d ? { ...s.floating, x: i, y: o } : s.reference,
+      v = await (null == r.getOffsetParent
+        ? void 0
+        : r.getOffsetParent(f.floating)),
+      b = ((await (null == r.isElement ? void 0 : r.isElement(v))) &&
+        (await (null == r.getScale ? void 0 : r.getScale(v)))) || {
+        x: 1,
+        y: 1,
+      },
+      R = l(
+        r.convertOffsetParentRelativeRectToViewportRelativeRect
+          ? await r.convertOffsetParentRelativeRectToViewportRelativeRect({
+              rect: w,
+              offsetParent: v,
+              strategy: c,
+            })
+          : w
+      );
+    return {
+      top: (x.top - R.top + h.top) / b.y,
+      bottom: (R.bottom - x.bottom + h.bottom) / b.y,
+      left: (x.left - R.left + h.left) / b.x,
+      right: (R.right - x.right + h.right) / b.x,
+    };
+  }
+  const f = Math.min,
+    c = Math.max;
+  function u(t, e, n) {
+    return c(t, f(e, n));
+  }
+  const m = ["top", "right", "bottom", "left"],
+    d = m.reduce((t, e) => t.concat(e, e + "-start", e + "-end"), []),
+    g = { left: "right", right: "left", bottom: "top", top: "bottom" };
+  function p(t) {
+    return t.replace(/left|right|bottom|top/g, (t) => g[t]);
+  }
+  function h(t, i, r) {
+    void 0 === r && (r = !1);
+    const a = e(t),
+      l = o(t),
+      s = n(l);
+    let f =
+      "x" === l
+        ? a === (r ? "end" : "start")
+          ? "right"
+          : "left"
+        : "start" === a
+        ? "bottom"
+        : "top";
+    return (
+      i.reference[s] > i.floating[s] && (f = p(f)), { main: f, cross: p(f) }
+    );
+  }
+  const y = { start: "end", end: "start" };
+  function x(t) {
+    return t.replace(/start|end/g, (t) => y[t]);
+  }
+  function w(t, e) {
+    return {
+      top: t.top - e.height,
+      right: t.right - e.width,
+      bottom: t.bottom - e.height,
+      left: t.left - e.width,
+    };
+  }
+  function v(t) {
+    return m.some((e) => t[e] >= 0);
+  }
+  function b(t) {
+    return "x" === t ? "y" : "x";
+  }
+  (t.arrow = (t) => ({
+    name: "arrow",
+    options: t,
+    async fn(i) {
+      const { element: r, padding: l = 0 } = t || {},
+        { x: s, y: f, placement: c, rects: m, platform: d } = i;
+      if (null == r) return {};
+      const g = a(l),
+        p = { x: s, y: f },
+        h = o(c),
+        y = n(h),
+        x = await d.getDimensions(r),
+        w = "y" === h ? "top" : "left",
+        v = "y" === h ? "bottom" : "right",
+        b = m.reference[y] + m.reference[h] - p[h] - m.floating[y],
+        R = p[h] - m.reference[h],
+        A = await (null == d.getOffsetParent ? void 0 : d.getOffsetParent(r));
+      let P = A ? ("y" === h ? A.clientHeight || 0 : A.clientWidth || 0) : 0;
+      0 === P && (P = m.floating[y]);
+      const T = b / 2 - R / 2,
+        O = g[w],
+        D = P - x[y] - g[v],
+        E = P / 2 - x[y] / 2 + T,
+        L = u(O, E, D),
+        k =
+          null != e(c) &&
+          E != L &&
+          m.reference[y] / 2 - (E < O ? g[w] : g[v]) - x[y] / 2 < 0;
+      return {
+        [h]: p[h] - (k ? (E < O ? O - E : D - E) : 0),
+        data: { [h]: L, centerOffset: E - L },
+      };
+    },
+  })),
+    (t.autoPlacement = function (t) {
+      return (
+        void 0 === t && (t = {}),
+        {
+          name: "autoPlacement",
+          options: t,
+          async fn(n) {
+            var o, r, a;
+            const {
+                rects: l,
+                middlewareData: f,
+                placement: c,
+                platform: u,
+                elements: m,
+              } = n,
+              {
+                alignment: g,
+                allowedPlacements: p = d,
+                autoAlignment: y = !0,
+                ...w
+              } = t,
+              v =
+                void 0 !== g || p === d
+                  ? (function (t, n, o) {
+                      return (
+                        t
+                          ? [
+                              ...o.filter((n) => e(n) === t),
+                              ...o.filter((n) => e(n) !== t),
+                            ]
+                          : o.filter((t) => i(t) === t)
+                      ).filter((i) => !t || e(i) === t || (!!n && x(i) !== i));
+                    })(g || null, y, p)
+                  : p,
+              b = await s(n, w),
+              R = (null == (o = f.autoPlacement) ? void 0 : o.index) || 0,
+              A = v[R];
+            if (null == A) return {};
+            const { main: P, cross: T } = h(
+              A,
+              l,
+              await (null == u.isRTL ? void 0 : u.isRTL(m.floating))
+            );
+            if (c !== A) return { reset: { placement: v[0] } };
+            const O = [b[i(A)], b[P], b[T]],
+              D = [
+                ...((null == (r = f.autoPlacement) ? void 0 : r.overflows) ||
+                  []),
+                { placement: A, overflows: O },
+              ],
+              E = v[R + 1];
+            if (E)
+              return {
+                data: { index: R + 1, overflows: D },
+                reset: { placement: E },
+              };
+            const L = D.slice().sort((t, e) => t.overflows[0] - e.overflows[0]),
+              k =
+                null ==
+                (a = L.find((t) => {
+                  let { overflows: e } = t;
+                  return e.every((t) => t <= 0);
+                }))
+                  ? void 0
+                  : a.placement,
+              C = k || L[0].placement;
+            return C !== c
+              ? {
+                  data: { index: R + 1, overflows: D },
+                  reset: { placement: C },
+                }
+              : {};
+          },
+        }
+      );
+    }),
+    (t.computePosition = async (t, e, n) => {
+      const {
+          placement: i = "bottom",
+          strategy: o = "absolute",
+          middleware: a = [],
+          platform: l,
+        } = n,
+        s = a.filter(Boolean),
+        f = await (null == l.isRTL ? void 0 : l.isRTL(e));
+      let c = await l.getElementRects({
+          reference: t,
+          floating: e,
+          strategy: o,
+        }),
+        { x: u, y: m } = r(c, i, f),
+        d = i,
+        g = {},
+        p = 0;
+      for (let n = 0; n < s.length; n++) {
+        const { name: a, fn: h } = s[n],
+          {
+            x: y,
+            y: x,
+            data: w,
+            reset: v,
+          } = await h({
+            x: u,
+            y: m,
+            initialPlacement: i,
+            placement: d,
+            strategy: o,
+            middlewareData: g,
+            rects: c,
+            platform: l,
+            elements: { reference: t, floating: e },
+          });
+        (u = null != y ? y : u),
+          (m = null != x ? x : m),
+          (g = { ...g, [a]: { ...g[a], ...w } }),
+          v &&
+            p <= 50 &&
+            (p++,
+            "object" == typeof v &&
+              (v.placement && (d = v.placement),
+              v.rects &&
+                (c =
+                  !0 === v.rects
+                    ? await l.getElementRects({
+                        reference: t,
+                        floating: e,
+                        strategy: o,
+                      })
+                    : v.rects),
+              ({ x: u, y: m } = r(c, d, f))),
+            (n = -1));
+      }
+      return { x: u, y: m, placement: d, strategy: o, middlewareData: g };
+    }),
+    (t.detectOverflow = s),
+    (t.flip = function (t) {
+      return (
+        void 0 === t && (t = {}),
+        {
+          name: "flip",
+          options: t,
+          async fn(n) {
+            var o;
+            const {
+                placement: r,
+                middlewareData: a,
+                rects: l,
+                initialPlacement: f,
+                platform: c,
+                elements: u,
+              } = n,
+              {
+                mainAxis: m = !0,
+                crossAxis: d = !0,
+                fallbackPlacements: g,
+                fallbackStrategy: y = "bestFit",
+                fallbackAxisSideDirection: w = "none",
+                flipAlignment: v = !0,
+                ...b
+              } = t,
+              R = i(r),
+              A = i(f) === f,
+              P = await (null == c.isRTL ? void 0 : c.isRTL(u.floating)),
+              T =
+                g ||
+                (A || !v
+                  ? [p(f)]
+                  : (function (t) {
+                      const e = p(t);
+                      return [x(t), e, x(e)];
+                    })(f));
+            g ||
+              "none" === w ||
+              T.push(
+                ...(function (t, n, o, r) {
+                  const a = e(t);
+                  let l = (function (t, e, n) {
+                    const i = ["left", "right"],
+                      o = ["right", "left"],
+                      r = ["top", "bottom"],
+                      a = ["bottom", "top"];
+                    switch (t) {
+                      case "top":
+                      case "bottom":
+                        return n ? (e ? o : i) : e ? i : o;
+                      case "left":
+                      case "right":
+                        return e ? r : a;
+                      default:
+                        return [];
+                    }
+                  })(i(t), "start" === o, r);
+                  return (
+                    a &&
+                      ((l = l.map((t) => t + "-" + a)),
+                      n && (l = l.concat(l.map(x)))),
+                    l
+                  );
+                })(f, v, w, P)
+              );
+            const O = [f, ...T],
+              D = await s(n, b),
+              E = [];
+            let L = (null == (o = a.flip) ? void 0 : o.overflows) || [];
+            if ((m && E.push(D[R]), d)) {
+              const { main: t, cross: e } = h(r, l, P);
+              E.push(D[t], D[e]);
+            }
+            if (
+              ((L = [...L, { placement: r, overflows: E }]),
+              !E.every((t) => t <= 0))
+            ) {
+              var k, C;
+              const t = ((null == (k = a.flip) ? void 0 : k.index) || 0) + 1,
+                e = O[t];
+              if (e)
+                return {
+                  data: { index: t, overflows: L },
+                  reset: { placement: e },
+                };
+              let n =
+                null == (C = L.find((t) => t.overflows[0] <= 0))
+                  ? void 0
+                  : C.placement;
+              if (!n)
+                switch (y) {
+                  case "bestFit": {
+                    var B;
+                    const t =
+                      null ==
+                      (B = L.map((t) => [
+                        t.placement,
+                        t.overflows
+                          .filter((t) => t > 0)
+                          .reduce((t, e) => t + e, 0),
+                      ]).sort((t, e) => t[1] - e[1])[0])
+                        ? void 0
+                        : B[0];
+                    t && (n = t);
+                    break;
+                  }
+                  case "initialPlacement":
+                    n = f;
+                }
+              if (r !== n) return { reset: { placement: n } };
+            }
+            return {};
+          },
+        }
+      );
+    }),
+    (t.hide = function (t) {
+      return (
+        void 0 === t && (t = {}),
+        {
+          name: "hide",
+          options: t,
+          async fn(e) {
+            const { strategy: n = "referenceHidden", ...i } = t,
+              { rects: o } = e;
+            switch (n) {
+              case "referenceHidden": {
+                const t = w(
+                  await s(e, { ...i, elementContext: "reference" }),
+                  o.reference
+                );
+                return {
+                  data: { referenceHiddenOffsets: t, referenceHidden: v(t) },
+                };
+              }
+              case "escaped": {
+                const t = w(await s(e, { ...i, altBoundary: !0 }), o.floating);
+                return { data: { escapedOffsets: t, escaped: v(t) } };
+              }
+              default:
+                return {};
+            }
+          },
+        }
+      );
+    }),
+    (t.inline = function (t) {
+      return (
+        void 0 === t && (t = {}),
+        {
+          name: "inline",
+          options: t,
+          async fn(e) {
+            const {
+                placement: n,
+                elements: r,
+                rects: s,
+                platform: u,
+                strategy: m,
+              } = e,
+              { padding: d = 2, x: g, y: p } = t,
+              h = l(
+                u.convertOffsetParentRelativeRectToViewportRelativeRect
+                  ? await u.convertOffsetParentRelativeRectToViewportRelativeRect(
+                      {
+                        rect: s.reference,
+                        offsetParent: await (null == u.getOffsetParent
+                          ? void 0
+                          : u.getOffsetParent(r.floating)),
+                        strategy: m,
+                      }
+                    )
+                  : s.reference
+              ),
+              y =
+                (await (null == u.getClientRects
+                  ? void 0
+                  : u.getClientRects(r.reference))) || [],
+              x = a(d);
+            const w = await u.getElementRects({
+              reference: {
+                getBoundingClientRect: function () {
+                  if (
+                    2 === y.length &&
+                    y[0].left > y[1].right &&
+                    null != g &&
+                    null != p
+                  )
+                    return (
+                      y.find(
+                        (t) =>
+                          g > t.left - x.left &&
+                          g < t.right + x.right &&
+                          p > t.top - x.top &&
+                          p < t.bottom + x.bottom
+                      ) || h
+                    );
+                  if (y.length >= 2) {
+                    if ("x" === o(n)) {
+                      const t = y[0],
+                        e = y[y.length - 1],
+                        o = "top" === i(n),
+                        r = t.top,
+                        a = e.bottom,
+                        l = o ? t.left : e.left,
+                        s = o ? t.right : e.right;
+                      return {
+                        top: r,
+                        bottom: a,
+                        left: l,
+                        right: s,
+                        width: s - l,
+                        height: a - r,
+                        x: l,
+                        y: r,
+                      };
+                    }
+                    const t = "left" === i(n),
+                      e = c(...y.map((t) => t.right)),
+                      r = f(...y.map((t) => t.left)),
+                      a = y.filter((n) => (t ? n.left === r : n.right === e)),
+                      l = a[0].top,
+                      s = a[a.length - 1].bottom;
+                    return {
+                      top: l,
+                      bottom: s,
+                      left: r,
+                      right: e,
+                      width: e - r,
+                      height: s - l,
+                      x: r,
+                      y: l,
+                    };
+                  }
+                  return h;
+                },
+              },
+              floating: r.floating,
+              strategy: m,
+            });
+            return s.reference.x !== w.reference.x ||
+              s.reference.y !== w.reference.y ||
+              s.reference.width !== w.reference.width ||
+              s.reference.height !== w.reference.height
+              ? { reset: { rects: w } }
+              : {};
+          },
+        }
+      );
+    }),
+    (t.limitShift = function (t) {
+      return (
+        void 0 === t && (t = {}),
+        {
+          options: t,
+          fn(e) {
+            const { x: n, y: r, placement: a, rects: l, middlewareData: s } = e,
+              { offset: f = 0, mainAxis: c = !0, crossAxis: u = !0 } = t,
+              m = { x: n, y: r },
+              d = o(a),
+              g = b(d);
+            let p = m[d],
+              h = m[g];
+            const y = "function" == typeof f ? f(e) : f,
+              x =
+                "number" == typeof y
+                  ? { mainAxis: y, crossAxis: 0 }
+                  : { mainAxis: 0, crossAxis: 0, ...y };
+            if (c) {
+              const t = "y" === d ? "height" : "width",
+                e = l.reference[d] - l.floating[t] + x.mainAxis,
+                n = l.reference[d] + l.reference[t] - x.mainAxis;
+              p < e ? (p = e) : p > n && (p = n);
+            }
+            if (u) {
+              var w, v;
+              const t = "y" === d ? "width" : "height",
+                e = ["top", "left"].includes(i(a)),
+                n =
+                  l.reference[g] -
+                  l.floating[t] +
+                  ((e && (null == (w = s.offset) ? void 0 : w[g])) || 0) +
+                  (e ? 0 : x.crossAxis),
+                o =
+                  l.reference[g] +
+                  l.reference[t] +
+                  (e ? 0 : (null == (v = s.offset) ? void 0 : v[g]) || 0) -
+                  (e ? x.crossAxis : 0);
+              h < n ? (h = n) : h > o && (h = o);
+            }
+            return { [d]: p, [g]: h };
+          },
+        }
+      );
+    }),
+    (t.offset = function (t) {
+      return (
+        void 0 === t && (t = 0),
+        {
+          name: "offset",
+          options: t,
+          async fn(n) {
+            const { x: r, y: a } = n,
+              l = await (async function (t, n) {
+                const { placement: r, platform: a, elements: l } = t,
+                  s = await (null == a.isRTL ? void 0 : a.isRTL(l.floating)),
+                  f = i(r),
+                  c = e(r),
+                  u = "x" === o(r),
+                  m = ["left", "top"].includes(f) ? -1 : 1,
+                  d = s && u ? -1 : 1,
+                  g = "function" == typeof n ? n(t) : n;
+                let {
+                  mainAxis: p,
+                  crossAxis: h,
+                  alignmentAxis: y,
+                } = "number" == typeof g
+                  ? { mainAxis: g, crossAxis: 0, alignmentAxis: null }
+                  : { mainAxis: 0, crossAxis: 0, alignmentAxis: null, ...g };
+                return (
+                  c && "number" == typeof y && (h = "end" === c ? -1 * y : y),
+                  u ? { x: h * d, y: p * m } : { x: p * m, y: h * d }
+                );
+              })(n, t);
+            return { x: r + l.x, y: a + l.y, data: l };
+          },
+        }
+      );
+    }),
+    (t.rectToClientRect = l),
+    (t.shift = function (t) {
+      return (
+        void 0 === t && (t = {}),
+        {
+          name: "shift",
+          options: t,
+          async fn(e) {
+            const { x: n, y: r, placement: a } = e,
+              {
+                mainAxis: l = !0,
+                crossAxis: f = !1,
+                limiter: c = {
+                  fn: (t) => {
+                    let { x: e, y: n } = t;
+                    return { x: e, y: n };
+                  },
+                },
+                ...m
+              } = t,
+              d = { x: n, y: r },
+              g = await s(e, m),
+              p = o(i(a)),
+              h = b(p);
+            let y = d[p],
+              x = d[h];
+            if (l) {
+              const t = "y" === p ? "bottom" : "right";
+              y = u(y + g["y" === p ? "top" : "left"], y, y - g[t]);
+            }
+            if (f) {
+              const t = "y" === h ? "bottom" : "right";
+              x = u(x + g["y" === h ? "top" : "left"], x, x - g[t]);
+            }
+            const w = c.fn({ ...e, [p]: y, [h]: x });
+            return { ...w, data: { x: w.x - n, y: w.y - r } };
+          },
+        }
+      );
+    }),
+    (t.size = function (t) {
+      return (
+        void 0 === t && (t = {}),
+        {
+          name: "size",
+          options: t,
+          async fn(n) {
+            const { placement: o, rects: r, platform: a, elements: l } = n,
+              { apply: f = () => {}, ...u } = t,
+              m = await s(n, u),
+              d = i(o),
+              g = e(o);
+            let p, h;
+            "top" === d || "bottom" === d
+              ? ((p = d),
+                (h =
+                  g ===
+                  ((await (null == a.isRTL ? void 0 : a.isRTL(l.floating)))
+                    ? "start"
+                    : "end")
+                    ? "left"
+                    : "right"))
+              : ((h = d), (p = "end" === g ? "top" : "bottom"));
+            const y = c(m.left, 0),
+              x = c(m.right, 0),
+              w = c(m.top, 0),
+              v = c(m.bottom, 0),
+              b = {
+                availableHeight:
+                  r.floating.height -
+                  (["left", "right"].includes(o)
+                    ? 2 * (0 !== w || 0 !== v ? w + v : c(m.top, m.bottom))
+                    : m[p]),
+                availableWidth:
+                  r.floating.width -
+                  (["top", "bottom"].includes(o)
+                    ? 2 * (0 !== y || 0 !== x ? y + x : c(m.left, m.right))
+                    : m[h]),
+              };
+            await f({ ...n, ...b });
+            const R = await a.getDimensions(l.floating);
+            return r.floating.width !== R.width ||
+              r.floating.height !== R.height
+              ? { reset: { rects: !0 } }
+              : {};
+          },
+        }
+      );
+    }),
+    Object.defineProperty(t, "__esModule", { value: !0 });
+});