@blofin/blofin-ui 0.7.45 → 0.7.46-beta.0

package/dist/ProTable-beea76d7.js

@@ -0,0 +1,3393 @@
+import { j as A } from "./jsx-runtime-82a9ddf6.js";
+import * as Se from "react";
+import U, { useLayoutEffect as $n, useEffect as O, useRef as M, useMemo as N, useCallback as W, useState as Q, createContext as qe, memo as Hn, useReducer as Xn, useContext as Ce } from "react";
+import { c as $, a as st } from "./index-f20f14ba.js";
+import { unstable_batchedUpdates as nt, createPortal as Wn } from "react-dom";
+var oe = /* @__PURE__ */ ((e) => (e.default = "default", e.desc = "desc", e.asc = "asc", e))(oe || {});
+const Yn = $("bu-w-full bu-overflow-auto bu-rounded-lg", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background",
+      dark: "bu-bg-dark-background"
+    }
+  }
+}), Kn = $("bu-w-full bu-border-collapse"), Un = $("bu-sticky bu-top-0 bu-z-[100]", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background",
+      dark: "bu-bg-dark-background"
+    }
+  }
+}), rn = $(
+  "bu-relative bu-z-[999] bu-h-[25px] bu-select-none bu-border-b bu-px-[4px] bu-text-left bu-text-[12px] bu-font-medium bu-transition-all bu-duration-300",
+  {
+    variants: {
+      theme: {
+        light: "bu-border-light-line-primary bu-text-light-label-40",
+        dark: "bu-border-dark-line-primary bu-text-dark-label-40"
+      },
+      draggable: {
+        true: "bu-cursor-grab hover:bu-cursor-grab",
+        false: ""
+      }
+    }
+  }
+), on = $("bu-sticky bu-left-0 bu-top-0 bu-z-[1000]", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background",
+      dark: "bu-bg-dark-background"
+    }
+  }
+}), sn = $("bu-sticky bu-right-0 bu-top-0 bu-z-[1000]", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background",
+      dark: "bu-bg-dark-background"
+    }
+  }
+}), an = $("bu-cursor-pointer", {
+  variants: {
+    theme: {
+      light: "hover:bu-bg-light-hover-fill-primary",
+      dark: "hover:bu-bg-dark-hover-fill-primary"
+    }
+  }
+}), Vn = $(
+  "bu-pointer-events-auto bu-opacity-0 bu-transition-opacity bu-duration-200 group-hover:bu-opacity-100",
+  {
+    variants: {
+      theme: {
+        light: "bu-text-light-label-60 hover:bu-text-light-primary",
+        dark: "bu-text-dark-label-60 hover:bu-text-dark-primary"
+      }
+    }
+  }
+), ln = $("bu-z-[1002] !bu-cursor-grabbing bu-opacity-60 bu-shadow-lg", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background",
+      dark: "bu-bg-dark-background"
+    }
+  }
+}), qn = $("bu-ml-2 bu-inline-flex bu-flex-col bu-align-middle"), Gn = $(
+  "bu-h-0 bu-w-0 bu-border-l-4 bu-border-r-4 bu-border-transparent",
+  {
+    variants: {
+      direction: {
+        asc: "bu-mb-0.5 bu-border-b-[5px]",
+        desc: "bu-border-t-[5px]"
+      },
+      theme: {
+        light: "bu-border-b-light-line-secondary bu-border-t-light-line-secondary",
+        dark: "bu-border-b-dark-line-secondary bu-border-t-dark-line-secondary"
+      },
+      active: {
+        true: "!bu-border-b-light-primary !bu-border-t-light-primary",
+        false: ""
+      }
+    }
+  }
+), Jn = $("", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background",
+      dark: "bu-bg-dark-background"
+    }
+  }
+}), _n = $("bu-group bu-border-b bu-transition-colors bu-duration-200", {
+  variants: {
+    theme: {
+      light: "bu-hover:bu-bg-light-fill-primary bu-border-light-line-primary",
+      dark: "bu-hover:bu-bg-dark-fill-primary bu-border-dark-line-primary"
+    }
+  }
+}), cn = $("bu-h-[60px] bu-border-b bu-px-[4px] bu-text-[12px]", {
+  variants: {
+    theme: {
+      light: "bu-border-light-line-primary bu-text-light-label group-hover:bu-bg-light-fill-primary",
+      dark: "bu-border-dark-line-primary bu-text-dark-label group-hover:bu-bg-dark-fill-primary"
+    }
+  }
+}), un = $("bu-sticky bu-left-0", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background group-hover:bu-bg-light-fill-primary",
+      dark: "bu-bg-dark-background group-hover:bu-bg-dark-fill-primary"
+    }
+  }
+}), dn = $("bu-sticky bu-right-0", {
+  variants: {
+    theme: {
+      light: "bu-bg-light-background group-hover:bu-bg-light-fill-primary",
+      dark: "bu-bg-dark-background group-hover:bu-bg-dark-fill-primary"
+    }
+  }
+}), Qn = $("bu-px-5 bu-py-10 bu-text-center", {
+  variants: {
+    theme: {
+      light: "bu-text-light-label-60",
+      dark: "bu-text-dark-label-60"
+    }
+  }
+}), Zn = (e) => ({
+  "flex-start": "left",
+  center: "center",
+  "flex-end": "right"
+})[e || "center"], er = (e) => {
+  const { theme: t, fixed: n, sortable: r, isDragging: o, draggable: i, customClass: s } = e, l = [rn({ theme: t, draggable: i && !n })];
+  return n === "left" ? l.push(on({ theme: t })) : n === "right" && l.push(sn({ theme: t })), r && l.push(an({ theme: t })), o && l.push(ln({ theme: t })), s && l.push(s), l.join(" ");
+}, tr = (e) => {
+  const { theme: t, fixed: n, customClass: r } = e, o = [cn({ theme: t })];
+  return n === "left" ? o.push(un({ theme: t })) : n === "right" && o.push(dn({ theme: t })), r && o.push(r), o.join(" ");
+}, V = {
+  container: Yn,
+  table: Kn,
+  thead: Un,
+  th: rn,
+  thFixedLeft: on,
+  thFixedRight: sn,
+  thSortable: an,
+  dragHandle: Vn,
+  dragging: ln,
+  sortIcon: qn,
+  sortArrow: Gn,
+  tbody: Jn,
+  tr: _n,
+  td: cn,
+  tdFixedLeft: un,
+  tdFixedRight: dn,
+  empty: Qn,
+  getThClasses: er,
+  getTdClasses: tr,
+  getTextAlign: Zn
+};
+function nr() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return N(
+    () => (r) => {
+      t.forEach((o) => o(r));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const dt = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function Oe(e) {
+  const t = Object.prototype.toString.call(e);
+  return t === "[object Window]" || // In Electron context the Window object serializes to [object global]
+  t === "[object global]";
+}
+function It(e) {
+  return "nodeType" in e;
+}
+function q(e) {
+  var t, n;
+  return e ? Oe(e) ? e : It(e) && (t = (n = e.ownerDocument) == null ? void 0 : n.defaultView) != null ? t : window : window;
+}
+function Et(e) {
+  const {
+    Document: t
+  } = q(e);
+  return e instanceof t;
+}
+function Ge(e) {
+  return Oe(e) ? !1 : e instanceof q(e).HTMLElement;
+}
+function fn(e) {
+  return e instanceof q(e).SVGElement;
+}
+function Me(e) {
+  return e ? Oe(e) ? e.document : It(e) ? Et(e) ? e : Ge(e) || fn(e) ? e.ownerDocument : document : document : document;
+}
+const ue = dt ? $n : O;
+function kt(e) {
+  const t = M(e);
+  return ue(() => {
+    t.current = e;
+  }), W(function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    return t.current == null ? void 0 : t.current(...r);
+  }, []);
+}
+function rr() {
+  const e = M(null), t = W((r, o) => {
+    e.current = setInterval(r, o);
+  }, []), n = W(() => {
+    e.current !== null && (clearInterval(e.current), e.current = null);
+  }, []);
+  return [t, n];
+}
+function Ke(e, t) {
+  t === void 0 && (t = [e]);
+  const n = M(e);
+  return ue(() => {
+    n.current !== e && (n.current = e);
+  }, t), n;
+}
+function Je(e, t) {
+  const n = M();
+  return N(
+    () => {
+      const r = e(n.current);
+      return n.current = r, r;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function at(e) {
+  const t = kt(e), n = M(null), r = W(
+    (o) => {
+      o !== n.current && (t == null || t(o, n.current)), n.current = o;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [n, r];
+}
+function mt(e) {
+  const t = M();
+  return O(() => {
+    t.current = e;
+  }, [e]), t.current;
+}
+let pt = {};
+function _e(e, t) {
+  return N(() => {
+    if (t)
+      return t;
+    const n = pt[e] == null ? 0 : pt[e] + 1;
+    return pt[e] = n, e + "-" + n;
+  }, [e, t]);
+}
+function gn(e) {
+  return function(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    return r.reduce((i, s) => {
+      const a = Object.entries(s);
+      for (const [l, d] of a) {
+        const u = i[l];
+        u != null && (i[l] = u + e * d);
+      }
+      return i;
+    }, {
+      ...t
+    });
+  };
+}
+const Ne = /* @__PURE__ */ gn(1), lt = /* @__PURE__ */ gn(-1);
+function or(e) {
+  return "clientX" in e && "clientY" in e;
+}
+function At(e) {
+  if (!e)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = q(e.target);
+  return t && e instanceof t;
+}
+function ir(e) {
+  if (!e)
+    return !1;
+  const {
+    TouchEvent: t
+  } = q(e.target);
+  return t && e instanceof t;
+}
+function St(e) {
+  if (ir(e)) {
+    if (e.touches && e.touches.length) {
+      const {
+        clientX: t,
+        clientY: n
+      } = e.touches[0];
+      return {
+        x: t,
+        y: n
+      };
+    } else if (e.changedTouches && e.changedTouches.length) {
+      const {
+        clientX: t,
+        clientY: n
+      } = e.changedTouches[0];
+      return {
+        x: t,
+        y: n
+      };
+    }
+  }
+  return or(e) ? {
+    x: e.clientX,
+    y: e.clientY
+  } : null;
+}
+const Ue = /* @__PURE__ */ Object.freeze({
+  Translate: {
+    toString(e) {
+      if (!e)
+        return;
+      const {
+        x: t,
+        y: n
+      } = e;
+      return "translate3d(" + (t ? Math.round(t) : 0) + "px, " + (n ? Math.round(n) : 0) + "px, 0)";
+    }
+  },
+  Scale: {
+    toString(e) {
+      if (!e)
+        return;
+      const {
+        scaleX: t,
+        scaleY: n
+      } = e;
+      return "scaleX(" + t + ") scaleY(" + n + ")";
+    }
+  },
+  Transform: {
+    toString(e) {
+      if (e)
+        return [Ue.Translate.toString(e), Ue.Scale.toString(e)].join(" ");
+    }
+  },
+  Transition: {
+    toString(e) {
+      let {
+        property: t,
+        duration: n,
+        easing: r
+      } = e;
+      return t + " " + n + "ms " + r;
+    }
+  }
+}), Yt = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function sr(e) {
+  return e.matches(Yt) ? e : e.querySelector(Yt);
+}
+const ar = {
+  display: "none"
+};
+function lr(e) {
+  let {
+    id: t,
+    value: n
+  } = e;
+  return U.createElement("div", {
+    id: t,
+    style: ar
+  }, n);
+}
+function cr(e) {
+  let {
+    id: t,
+    announcement: n,
+    ariaLiveType: r = "assertive"
+  } = e;
+  const o = {
+    position: "fixed",
+    top: 0,
+    left: 0,
+    width: 1,
+    height: 1,
+    margin: -1,
+    border: 0,
+    padding: 0,
+    overflow: "hidden",
+    clip: "rect(0 0 0 0)",
+    clipPath: "inset(100%)",
+    whiteSpace: "nowrap"
+  };
+  return U.createElement("div", {
+    id: t,
+    style: o,
+    role: "status",
+    "aria-live": r,
+    "aria-atomic": !0
+  }, n);
+}
+function ur() {
+  const [e, t] = Q("");
+  return {
+    announce: W((r) => {
+      r != null && t(r);
+    }, []),
+    announcement: e
+  };
+}
+const hn = /* @__PURE__ */ qe(null);
+function dr(e) {
+  const t = Ce(hn);
+  O(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function fr() {
+  const [e] = Q(() => /* @__PURE__ */ new Set()), t = W((r) => (e.add(r), () => e.delete(r)), [e]);
+  return [W((r) => {
+    let {
+      type: o,
+      event: i
+    } = r;
+    e.forEach((s) => {
+      var a;
+      return (a = s[o]) == null ? void 0 : a.call(s, i);
+    });
+  }, [e]), t];
+}
+const gr = {
+  draggable: `
+    To pick up a draggable item, press the space bar.
+    While dragging, use the arrow keys to move the item.
+    Press space again to drop the item in its new position, or press escape to cancel.
+  `
+}, hr = {
+  onDragStart(e) {
+    let {
+      active: t
+    } = e;
+    return "Picked up draggable item " + t.id + ".";
+  },
+  onDragOver(e) {
+    let {
+      active: t,
+      over: n
+    } = e;
+    return n ? "Draggable item " + t.id + " was moved over droppable area " + n.id + "." : "Draggable item " + t.id + " is no longer over a droppable area.";
+  },
+  onDragEnd(e) {
+    let {
+      active: t,
+      over: n
+    } = e;
+    return n ? "Draggable item " + t.id + " was dropped over droppable area " + n.id : "Draggable item " + t.id + " was dropped.";
+  },
+  onDragCancel(e) {
+    let {
+      active: t
+    } = e;
+    return "Dragging was cancelled. Draggable item " + t.id + " was dropped.";
+  }
+};
+function br(e) {
+  let {
+    announcements: t = hr,
+    container: n,
+    hiddenTextDescribedById: r,
+    screenReaderInstructions: o = gr
+  } = e;
+  const {
+    announce: i,
+    announcement: s
+  } = ur(), a = _e("DndLiveRegion"), [l, d] = Q(!1);
+  if (O(() => {
+    d(!0);
+  }, []), dr(N(() => ({
+    onDragStart(c) {
+      let {
+        active: f
+      } = c;
+      i(t.onDragStart({
+        active: f
+      }));
+    },
+    onDragMove(c) {
+      let {
+        active: f,
+        over: g
+      } = c;
+      t.onDragMove && i(t.onDragMove({
+        active: f,
+        over: g
+      }));
+    },
+    onDragOver(c) {
+      let {
+        active: f,
+        over: g
+      } = c;
+      i(t.onDragOver({
+        active: f,
+        over: g
+      }));
+    },
+    onDragEnd(c) {
+      let {
+        active: f,
+        over: g
+      } = c;
+      i(t.onDragEnd({
+        active: f,
+        over: g
+      }));
+    },
+    onDragCancel(c) {
+      let {
+        active: f,
+        over: g
+      } = c;
+      i(t.onDragCancel({
+        active: f,
+        over: g
+      }));
+    }
+  }), [i, t])), !l)
+    return null;
+  const u = U.createElement(U.Fragment, null, U.createElement(lr, {
+    id: r,
+    value: o.draggable
+  }), U.createElement(cr, {
+    id: a,
+    announcement: s
+  }));
+  return n ? Wn(u, n) : u;
+}
+var z;
+(function(e) {
+  e.DragStart = "dragStart", e.DragMove = "dragMove", e.DragEnd = "dragEnd", e.DragCancel = "dragCancel", e.DragOver = "dragOver", e.RegisterDroppable = "registerDroppable", e.SetDroppableDisabled = "setDroppableDisabled", e.UnregisterDroppable = "unregisterDroppable";
+})(z || (z = {}));
+function ct() {
+}
+function Kt(e, t) {
+  return N(
+    () => ({
+      sensor: e,
+      options: t ?? {}
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  );
+}
+function vr() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return N(
+    () => [...t].filter((r) => r != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const ie = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function pr(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function yr(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return n - r;
+}
+function xr(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return r - n;
+}
+function wr(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return t ? n[t] : n;
+}
+function Ut(e, t, n) {
+  return t === void 0 && (t = e.left), n === void 0 && (n = e.top), {
+    x: t + e.width * 0.5,
+    y: n + e.height * 0.5
+  };
+}
+const mr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Ut(t, t.left, t.top), i = [];
+  for (const s of r) {
+    const {
+      id: a
+    } = s, l = n.get(a);
+    if (l) {
+      const d = pr(Ut(l), o);
+      i.push({
+        id: a,
+        data: {
+          droppableContainer: s,
+          value: d
+        }
+      });
+    }
+  }
+  return i.sort(yr);
+};
+function Sr(e, t) {
+  const n = Math.max(t.top, e.top), r = Math.max(t.left, e.left), o = Math.min(t.left + t.width, e.left + e.width), i = Math.min(t.top + t.height, e.top + e.height), s = o - r, a = i - n;
+  if (r < o && n < i) {
+    const l = t.width * t.height, d = e.width * e.height, u = s * a, c = u / (l + d - u);
+    return Number(c.toFixed(4));
+  }
+  return 0;
+}
+const Dr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = [];
+  for (const i of r) {
+    const {
+      id: s
+    } = i, a = n.get(s);
+    if (a) {
+      const l = Sr(a, t);
+      l > 0 && o.push({
+        id: s,
+        data: {
+          droppableContainer: i,
+          value: l
+        }
+      });
+    }
+  }
+  return o.sort(xr);
+};
+function Cr(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function bn(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : ie;
+}
+function Rr(e) {
+  return function(n) {
+    for (var r = arguments.length, o = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++)
+      o[i - 1] = arguments[i];
+    return o.reduce((s, a) => ({
+      ...s,
+      top: s.top + e * a.y,
+      bottom: s.bottom + e * a.y,
+      left: s.left + e * a.x,
+      right: s.right + e * a.x
+    }), {
+      ...n
+    });
+  };
+}
+const Ir = /* @__PURE__ */ Rr(1);
+function Er(e) {
+  if (e.startsWith("matrix3d(")) {
+    const t = e.slice(9, -1).split(/, /);
+    return {
+      x: +t[12],
+      y: +t[13],
+      scaleX: +t[0],
+      scaleY: +t[5]
+    };
+  } else if (e.startsWith("matrix(")) {
+    const t = e.slice(7, -1).split(/, /);
+    return {
+      x: +t[4],
+      y: +t[5],
+      scaleX: +t[0],
+      scaleY: +t[3]
+    };
+  }
+  return null;
+}
+function kr(e, t, n) {
+  const r = Er(t);
+  if (!r)
+    return e;
+  const {
+    scaleX: o,
+    scaleY: i,
+    x: s,
+    y: a
+  } = r, l = e.left - s - (1 - o) * parseFloat(n), d = e.top - a - (1 - i) * parseFloat(n.slice(n.indexOf(" ") + 1)), u = o ? e.width / o : e.width, c = i ? e.height / i : e.height;
+  return {
+    width: u,
+    height: c,
+    top: d,
+    right: l + u,
+    bottom: d + c,
+    left: l
+  };
+}
+const Ar = {
+  ignoreTransform: !1
+};
+function Le(e, t) {
+  t === void 0 && (t = Ar);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: d,
+      transformOrigin: u
+    } = q(e).getComputedStyle(e);
+    d && (n = kr(n, d, u));
+  }
+  const {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: l
+  } = n;
+  return {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: l
+  };
+}
+function Vt(e) {
+  return Le(e, {
+    ignoreTransform: !0
+  });
+}
+function Tr(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function Nr(e, t) {
+  return t === void 0 && (t = q(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Or(e, t) {
+  t === void 0 && (t = q(e).getComputedStyle(e));
+  const n = /(auto|scroll|overlay)/;
+  return ["overflow", "overflowX", "overflowY"].some((o) => {
+    const i = t[o];
+    return typeof i == "string" ? n.test(i) : !1;
+  });
+}
+function Tt(e, t) {
+  const n = [];
+  function r(o) {
+    if (t != null && n.length >= t || !o)
+      return n;
+    if (Et(o) && o.scrollingElement != null && !n.includes(o.scrollingElement))
+      return n.push(o.scrollingElement), n;
+    if (!Ge(o) || fn(o) || n.includes(o))
+      return n;
+    const i = q(e).getComputedStyle(o);
+    return o !== e && Or(o, i) && n.push(o), Nr(o, i) ? n : r(o.parentNode);
+  }
+  return e ? r(e) : n;
+}
+function vn(e) {
+  const [t] = Tt(e, 1);
+  return t ?? null;
+}
+function yt(e) {
+  return !dt || !e ? null : Oe(e) ? e : It(e) ? Et(e) || e === Me(e).scrollingElement ? window : Ge(e) ? e : null : null;
+}
+function pn(e) {
+  return Oe(e) ? e.scrollX : e.scrollLeft;
+}
+function yn(e) {
+  return Oe(e) ? e.scrollY : e.scrollTop;
+}
+function Dt(e) {
+  return {
+    x: pn(e),
+    y: yn(e)
+  };
+}
+var B;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(B || (B = {}));
+function xn(e) {
+  return !dt || !e ? !1 : e === document.scrollingElement;
+}
+function wn(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = xn(e) ? {
+    height: window.innerHeight,
+    width: window.innerWidth
+  } : {
+    height: e.clientHeight,
+    width: e.clientWidth
+  }, r = {
+    x: e.scrollWidth - n.width,
+    y: e.scrollHeight - n.height
+  }, o = e.scrollTop <= t.y, i = e.scrollLeft <= t.x, s = e.scrollTop >= r.y, a = e.scrollLeft >= r.x;
+  return {
+    isTop: o,
+    isLeft: i,
+    isBottom: s,
+    isRight: a,
+    maxScroll: r,
+    minScroll: t
+  };
+}
+const Mr = {
+  x: 0.2,
+  y: 0.2
+};
+function Lr(e, t, n, r, o) {
+  let {
+    top: i,
+    left: s,
+    right: a,
+    bottom: l
+  } = n;
+  r === void 0 && (r = 10), o === void 0 && (o = Mr);
+  const {
+    isTop: d,
+    isBottom: u,
+    isLeft: c,
+    isRight: f
+  } = wn(e), g = {
+    x: 0,
+    y: 0
+  }, p = {
+    x: 0,
+    y: 0
+  }, h = {
+    height: t.height * o.y,
+    width: t.width * o.x
+  };
+  return !d && i <= t.top + h.height ? (g.y = B.Backward, p.y = r * Math.abs((t.top + h.height - i) / h.height)) : !u && l >= t.bottom - h.height && (g.y = B.Forward, p.y = r * Math.abs((t.bottom - h.height - l) / h.height)), !f && a >= t.right - h.width ? (g.x = B.Forward, p.x = r * Math.abs((t.right - h.width - a) / h.width)) : !c && s <= t.left + h.width && (g.x = B.Backward, p.x = r * Math.abs((t.left + h.width - s) / h.width)), {
+    direction: g,
+    speed: p
+  };
+}
+function zr(e) {
+  if (e === document.scrollingElement) {
+    const {
+      innerWidth: i,
+      innerHeight: s
+    } = window;
+    return {
+      top: 0,
+      left: 0,
+      right: i,
+      bottom: s,
+      width: i,
+      height: s
+    };
+  }
+  const {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o
+  } = e.getBoundingClientRect();
+  return {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o,
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+}
+function mn(e) {
+  return e.reduce((t, n) => Ne(t, Dt(n)), ie);
+}
+function jr(e) {
+  return e.reduce((t, n) => t + pn(n), 0);
+}
+function Pr(e) {
+  return e.reduce((t, n) => t + yn(n), 0);
+}
+function Br(e, t) {
+  if (t === void 0 && (t = Le), !e)
+    return;
+  const {
+    top: n,
+    left: r,
+    bottom: o,
+    right: i
+  } = t(e);
+  vn(e) && (o <= 0 || i <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const Fr = [["x", ["left", "right"], jr], ["y", ["top", "bottom"], Pr]];
+class Nt {
+  constructor(t, n) {
+    this.rect = void 0, this.width = void 0, this.height = void 0, this.top = void 0, this.bottom = void 0, this.right = void 0, this.left = void 0;
+    const r = Tt(n), o = mn(r);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [i, s, a] of Fr)
+      for (const l of s)
+        Object.defineProperty(this, l, {
+          get: () => {
+            const d = a(r), u = o[i] - d;
+            return this.rect[l] + u;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class Xe {
+  constructor(t) {
+    this.target = void 0, this.listeners = [], this.removeAll = () => {
+      this.listeners.forEach((n) => {
+        var r;
+        return (r = this.target) == null ? void 0 : r.removeEventListener(...n);
+      });
+    }, this.target = t;
+  }
+  add(t, n, r) {
+    var o;
+    (o = this.target) == null || o.addEventListener(t, n, r), this.listeners.push([t, n, r]);
+  }
+}
+function $r(e) {
+  const {
+    EventTarget: t
+  } = q(e);
+  return e instanceof t ? e : Me(e);
+}
+function xt(e, t) {
+  const n = Math.abs(e.x), r = Math.abs(e.y);
+  return typeof t == "number" ? Math.sqrt(n ** 2 + r ** 2) > t : "x" in t && "y" in t ? n > t.x && r > t.y : "x" in t ? n > t.x : "y" in t ? r > t.y : !1;
+}
+var te;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(te || (te = {}));
+function qt(e) {
+  e.preventDefault();
+}
+function Hr(e) {
+  e.stopPropagation();
+}
+var I;
+(function(e) {
+  e.Space = "Space", e.Down = "ArrowDown", e.Right = "ArrowRight", e.Left = "ArrowLeft", e.Up = "ArrowUp", e.Esc = "Escape", e.Enter = "Enter", e.Tab = "Tab";
+})(I || (I = {}));
+const Sn = {
+  start: [I.Space, I.Enter],
+  cancel: [I.Esc],
+  end: [I.Space, I.Enter, I.Tab]
+}, Xr = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case I.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case I.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case I.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case I.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class Ot {
+  constructor(t) {
+    this.props = void 0, this.autoScrollEnabled = !1, this.referenceCoordinates = void 0, this.listeners = void 0, this.windowListeners = void 0, this.props = t;
+    const {
+      event: {
+        target: n
+      }
+    } = t;
+    this.props = t, this.listeners = new Xe(Me(n)), this.windowListeners = new Xe(q(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(te.Resize, this.handleCancel), this.windowListeners.add(te.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(te.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, r = t.node.current;
+    r && Br(r), n(ie);
+  }
+  handleKeyDown(t) {
+    if (At(t)) {
+      const {
+        active: n,
+        context: r,
+        options: o
+      } = this.props, {
+        keyboardCodes: i = Sn,
+        coordinateGetter: s = Xr,
+        scrollBehavior: a = "smooth"
+      } = o, {
+        code: l
+      } = t;
+      if (i.end.includes(l)) {
+        this.handleEnd(t);
+        return;
+      }
+      if (i.cancel.includes(l)) {
+        this.handleCancel(t);
+        return;
+      }
+      const {
+        collisionRect: d
+      } = r.current, u = d ? {
+        x: d.left,
+        y: d.top
+      } : ie;
+      this.referenceCoordinates || (this.referenceCoordinates = u);
+      const c = s(t, {
+        active: n,
+        context: r.current,
+        currentCoordinates: u
+      });
+      if (c) {
+        const f = lt(c, u), g = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: p
+        } = r.current;
+        for (const h of p) {
+          const v = t.code, {
+            isTop: m,
+            isRight: x,
+            isLeft: S,
+            isBottom: D,
+            maxScroll: C,
+            minScroll: R
+          } = wn(h), y = zr(h), w = {
+            x: Math.min(v === I.Right ? y.right - y.width / 2 : y.right, Math.max(v === I.Right ? y.left : y.left + y.width / 2, c.x)),
+            y: Math.min(v === I.Down ? y.bottom - y.height / 2 : y.bottom, Math.max(v === I.Down ? y.top : y.top + y.height / 2, c.y))
+          }, E = v === I.Right && !x || v === I.Left && !S, T = v === I.Down && !D || v === I.Up && !m;
+          if (E && w.x !== c.x) {
+            const b = h.scrollLeft + f.x, H = v === I.Right && b <= C.x || v === I.Left && b >= R.x;
+            if (H && !f.y) {
+              h.scrollTo({
+                left: b,
+                behavior: a
+              });
+              return;
+            }
+            H ? g.x = h.scrollLeft - b : g.x = v === I.Right ? h.scrollLeft - C.x : h.scrollLeft - R.x, g.x && h.scrollBy({
+              left: -g.x,
+              behavior: a
+            });
+            break;
+          } else if (T && w.y !== c.y) {
+            const b = h.scrollTop + f.y, H = v === I.Down && b <= C.y || v === I.Up && b >= R.y;
+            if (H && !f.x) {
+              h.scrollTo({
+                top: b,
+                behavior: a
+              });
+              return;
+            }
+            H ? g.y = h.scrollTop - b : g.y = v === I.Down ? h.scrollTop - C.y : h.scrollTop - R.y, g.y && h.scrollBy({
+              top: -g.y,
+              behavior: a
+            });
+            break;
+          }
+        }
+        this.handleMove(t, Ne(lt(c, this.referenceCoordinates), g));
+      }
+    }
+  }
+  handleMove(t, n) {
+    const {
+      onMove: r
+    } = this.props;
+    t.preventDefault(), r(n);
+  }
+  handleEnd(t) {
+    const {
+      onEnd: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  handleCancel(t) {
+    const {
+      onCancel: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll();
+  }
+}
+Ot.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: r = Sn,
+      onActivation: o
+    } = t, {
+      active: i
+    } = n;
+    const {
+      code: s
+    } = e.nativeEvent;
+    if (r.start.includes(s)) {
+      const a = i.activatorNode.current;
+      return a && e.target !== a ? !1 : (e.preventDefault(), o == null || o({
+        event: e.nativeEvent
+      }), !0);
+    }
+    return !1;
+  }
+}];
+function Gt(e) {
+  return !!(e && "distance" in e);
+}
+function Jt(e) {
+  return !!(e && "delay" in e);
+}
+class Mt {
+  constructor(t, n, r) {
+    var o;
+    r === void 0 && (r = $r(t.event.target)), this.props = void 0, this.events = void 0, this.autoScrollEnabled = !0, this.document = void 0, this.activated = !1, this.initialCoordinates = void 0, this.timeoutId = null, this.listeners = void 0, this.documentListeners = void 0, this.windowListeners = void 0, this.props = t, this.events = n;
+    const {
+      event: i
+    } = t, {
+      target: s
+    } = i;
+    this.props = t, this.events = n, this.document = Me(s), this.documentListeners = new Xe(this.document), this.listeners = new Xe(r), this.windowListeners = new Xe(q(s)), this.initialCoordinates = (o = St(i)) != null ? o : ie, this.handleStart = this.handleStart.bind(this), this.handleMove = this.handleMove.bind(this), this.handleEnd = this.handleEnd.bind(this), this.handleCancel = this.handleCancel.bind(this), this.handleKeydown = this.handleKeydown.bind(this), this.removeTextSelection = this.removeTextSelection.bind(this), this.attach();
+  }
+  attach() {
+    const {
+      events: t,
+      props: {
+        options: {
+          activationConstraint: n,
+          bypassActivationConstraint: r
+        }
+      }
+    } = this;
+    if (this.listeners.add(t.move.name, this.handleMove, {
+      passive: !1
+    }), this.listeners.add(t.end.name, this.handleEnd), t.cancel && this.listeners.add(t.cancel.name, this.handleCancel), this.windowListeners.add(te.Resize, this.handleCancel), this.windowListeners.add(te.DragStart, qt), this.windowListeners.add(te.VisibilityChange, this.handleCancel), this.windowListeners.add(te.ContextMenu, qt), this.documentListeners.add(te.Keydown, this.handleKeydown), n) {
+      if (r != null && r({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (Jt(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay), this.handlePending(n);
+        return;
+      }
+      if (Gt(n)) {
+        this.handlePending(n);
+        return;
+      }
+    }
+    this.handleStart();
+  }
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll(), setTimeout(this.documentListeners.removeAll, 50), this.timeoutId !== null && (clearTimeout(this.timeoutId), this.timeoutId = null);
+  }
+  handlePending(t, n) {
+    const {
+      active: r,
+      onPending: o
+    } = this.props;
+    o(r, t, this.initialCoordinates, n);
+  }
+  handleStart() {
+    const {
+      initialCoordinates: t
+    } = this, {
+      onStart: n
+    } = this.props;
+    t && (this.activated = !0, this.documentListeners.add(te.Click, Hr, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(te.SelectionChange, this.removeTextSelection), n(t));
+  }
+  handleMove(t) {
+    var n;
+    const {
+      activated: r,
+      initialCoordinates: o,
+      props: i
+    } = this, {
+      onMove: s,
+      options: {
+        activationConstraint: a
+      }
+    } = i;
+    if (!o)
+      return;
+    const l = (n = St(t)) != null ? n : ie, d = lt(o, l);
+    if (!r && a) {
+      if (Gt(a)) {
+        if (a.tolerance != null && xt(d, a.tolerance))
+          return this.handleCancel();
+        if (xt(d, a.distance))
+          return this.handleStart();
+      }
+      if (Jt(a) && xt(d, a.tolerance))
+        return this.handleCancel();
+      this.handlePending(a, d);
+      return;
+    }
+    t.cancelable && t.preventDefault(), s(l);
+  }
+  handleEnd() {
+    const {
+      onAbort: t,
+      onEnd: n
+    } = this.props;
+    this.detach(), this.activated || t(this.props.active), n();
+  }
+  handleCancel() {
+    const {
+      onAbort: t,
+      onCancel: n
+    } = this.props;
+    this.detach(), this.activated || t(this.props.active), n();
+  }
+  handleKeydown(t) {
+    t.code === I.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const Wr = {
+  cancel: {
+    name: "pointercancel"
+  },
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class Lt extends Mt {
+  constructor(t) {
+    const {
+      event: n
+    } = t, r = Me(n.target);
+    super(t, Wr, r);
+  }
+}
+Lt.activators = [{
+  eventName: "onPointerDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return !n.isPrimary || n.button !== 0 ? !1 : (r == null || r({
+      event: n
+    }), !0);
+  }
+}];
+const Yr = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var Ct;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(Ct || (Ct = {}));
+class Kr extends Mt {
+  constructor(t) {
+    super(t, Yr, Me(t.event.target));
+  }
+}
+Kr.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return n.button === Ct.RightClick ? !1 : (r == null || r({
+      event: n
+    }), !0);
+  }
+}];
+const wt = {
+  cancel: {
+    name: "touchcancel"
+  },
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class Ur extends Mt {
+  constructor(t) {
+    super(t, wt);
+  }
+  static setup() {
+    return window.addEventListener(wt.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(wt.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+Ur.activators = [{
+  eventName: "onTouchStart",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    const {
+      touches: o
+    } = n;
+    return o.length > 1 ? !1 : (r == null || r({
+      event: n
+    }), !0);
+  }
+}];
+var We;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(We || (We = {}));
+var ut;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(ut || (ut = {}));
+function Vr(e) {
+  let {
+    acceleration: t,
+    activator: n = We.Pointer,
+    canScroll: r,
+    draggingRect: o,
+    enabled: i,
+    interval: s = 5,
+    order: a = ut.TreeOrder,
+    pointerCoordinates: l,
+    scrollableAncestors: d,
+    scrollableAncestorRects: u,
+    delta: c,
+    threshold: f
+  } = e;
+  const g = Gr({
+    delta: c,
+    disabled: !i
+  }), [p, h] = rr(), v = M({
+    x: 0,
+    y: 0
+  }), m = M({
+    x: 0,
+    y: 0
+  }), x = N(() => {
+    switch (n) {
+      case We.Pointer:
+        return l ? {
+          top: l.y,
+          bottom: l.y,
+          left: l.x,
+          right: l.x
+        } : null;
+      case We.DraggableRect:
+        return o;
+    }
+  }, [n, o, l]), S = M(null), D = W(() => {
+    const R = S.current;
+    if (!R)
+      return;
+    const y = v.current.x * m.current.x, w = v.current.y * m.current.y;
+    R.scrollBy(y, w);
+  }, []), C = N(() => a === ut.TreeOrder ? [...d].reverse() : d, [a, d]);
+  O(
+    () => {
+      if (!i || !d.length || !x) {
+        h();
+        return;
+      }
+      for (const R of C) {
+        if ((r == null ? void 0 : r(R)) === !1)
+          continue;
+        const y = d.indexOf(R), w = u[y];
+        if (!w)
+          continue;
+        const {
+          direction: E,
+          speed: T
+        } = Lr(R, w, x, t, f);
+        for (const b of ["x", "y"])
+          g[b][E[b]] || (T[b] = 0, E[b] = 0);
+        if (T.x > 0 || T.y > 0) {
+          h(), S.current = R, p(D, s), v.current = T, m.current = E;
+          return;
+        }
+      }
+      v.current = {
+        x: 0,
+        y: 0
+      }, m.current = {
+        x: 0,
+        y: 0
+      }, h();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      D,
+      r,
+      h,
+      i,
+      s,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(x),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(g),
+      p,
+      d,
+      C,
+      u,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(f)
+    ]
+  );
+}
+const qr = {
+  x: {
+    [B.Backward]: !1,
+    [B.Forward]: !1
+  },
+  y: {
+    [B.Backward]: !1,
+    [B.Forward]: !1
+  }
+};
+function Gr(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const r = mt(t);
+  return Je((o) => {
+    if (n || !r || !o)
+      return qr;
+    const i = {
+      x: Math.sign(t.x - r.x),
+      y: Math.sign(t.y - r.y)
+    };
+    return {
+      x: {
+        [B.Backward]: o.x[B.Backward] || i.x === -1,
+        [B.Forward]: o.x[B.Forward] || i.x === 1
+      },
+      y: {
+        [B.Backward]: o.y[B.Backward] || i.y === -1,
+        [B.Forward]: o.y[B.Forward] || i.y === 1
+      }
+    };
+  }, [n, t, r]);
+}
+function Jr(e, t) {
+  const n = t != null ? e.get(t) : void 0, r = n ? n.node.current : null;
+  return Je((o) => {
+    var i;
+    return t == null ? null : (i = r ?? o) != null ? i : null;
+  }, [r, t]);
+}
+function _r(e, t) {
+  return N(() => e.reduce((n, r) => {
+    const {
+      sensor: o
+    } = r, i = o.activators.map((s) => ({
+      eventName: s.eventName,
+      handler: t(s.handler, r)
+    }));
+    return [...n, ...i];
+  }, []), [e, t]);
+}
+var Ve;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Ve || (Ve = {}));
+var Rt;
+(function(e) {
+  e.Optimized = "optimized";
+})(Rt || (Rt = {}));
+const _t = /* @__PURE__ */ new Map();
+function Qr(e, t) {
+  let {
+    dragging: n,
+    dependencies: r,
+    config: o
+  } = t;
+  const [i, s] = Q(null), {
+    frequency: a,
+    measure: l,
+    strategy: d
+  } = o, u = M(e), c = v(), f = Ke(c), g = W(function(m) {
+    m === void 0 && (m = []), !f.current && s((x) => x === null ? m : x.concat(m.filter((S) => !x.includes(S))));
+  }, [f]), p = M(null), h = Je((m) => {
+    if (c && !n)
+      return _t;
+    if (!m || m === _t || u.current !== e || i != null) {
+      const x = /* @__PURE__ */ new Map();
+      for (let S of e) {
+        if (!S)
+          continue;
+        if (i && i.length > 0 && !i.includes(S.id) && S.rect.current) {
+          x.set(S.id, S.rect.current);
+          continue;
+        }
+        const D = S.node.current, C = D ? new Nt(l(D), D) : null;
+        S.rect.current = C, C && x.set(S.id, C);
+      }
+      return x;
+    }
+    return m;
+  }, [e, i, n, c, l]);
+  return O(() => {
+    u.current = e;
+  }, [e]), O(
+    () => {
+      c || g();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, c]
+  ), O(
+    () => {
+      i && i.length > 0 && s(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(i)]
+  ), O(
+    () => {
+      c || typeof a != "number" || p.current !== null || (p.current = setTimeout(() => {
+        g(), p.current = null;
+      }, a));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [a, c, g, ...r]
+  ), {
+    droppableRects: h,
+    measureDroppableContainers: g,
+    measuringScheduled: i != null
+  };
+  function v() {
+    switch (d) {
+      case Ve.Always:
+        return !1;
+      case Ve.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function Dn(e, t) {
+  return Je((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function Zr(e, t) {
+  return Dn(e, t);
+}
+function eo(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = kt(t), o = N(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: i
+    } = window;
+    return new i(r);
+  }, [r, n]);
+  return O(() => () => o == null ? void 0 : o.disconnect(), [o]), o;
+}
+function ft(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = kt(t), o = N(
+    () => {
+      if (n || typeof window > "u" || typeof window.ResizeObserver > "u")
+        return;
+      const {
+        ResizeObserver: i
+      } = window;
+      return new i(r);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n]
+  );
+  return O(() => () => o == null ? void 0 : o.disconnect(), [o]), o;
+}
+function to(e) {
+  return new Nt(Le(e), e);
+}
+function Qt(e, t, n) {
+  t === void 0 && (t = to);
+  const [r, o] = Q(null);
+  function i() {
+    o((l) => {
+      if (!e)
+        return null;
+      if (e.isConnected === !1) {
+        var d;
+        return (d = l ?? n) != null ? d : null;
+      }
+      const u = t(e);
+      return JSON.stringify(l) === JSON.stringify(u) ? l : u;
+    });
+  }
+  const s = eo({
+    callback(l) {
+      if (e)
+        for (const d of l) {
+          const {
+            type: u,
+            target: c
+          } = d;
+          if (u === "childList" && c instanceof HTMLElement && c.contains(e)) {
+            i();
+            break;
+          }
+        }
+    }
+  }), a = ft({
+    callback: i
+  });
+  return ue(() => {
+    i(), e ? (a == null || a.observe(e), s == null || s.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (a == null || a.disconnect(), s == null || s.disconnect());
+  }, [e]), r;
+}
+function no(e) {
+  const t = Dn(e);
+  return bn(e, t);
+}
+const Zt = [];
+function ro(e) {
+  const t = M(e), n = Je((r) => e ? r && r !== Zt && e && t.current && e.parentNode === t.current.parentNode ? r : Tt(e) : Zt, [e]);
+  return O(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function oo(e) {
+  const [t, n] = Q(null), r = M(e), o = W((i) => {
+    const s = yt(i.target);
+    s && n((a) => a ? (a.set(s, Dt(s)), new Map(a)) : null);
+  }, []);
+  return O(() => {
+    const i = r.current;
+    if (e !== i) {
+      s(i);
+      const a = e.map((l) => {
+        const d = yt(l);
+        return d ? (d.addEventListener("scroll", o, {
+          passive: !0
+        }), [d, Dt(d)]) : null;
+      }).filter((l) => l != null);
+      n(a.length ? new Map(a) : null), r.current = e;
+    }
+    return () => {
+      s(e), s(i);
+    };
+    function s(a) {
+      a.forEach((l) => {
+        const d = yt(l);
+        d == null || d.removeEventListener("scroll", o);
+      });
+    }
+  }, [o, e]), N(() => e.length ? t ? Array.from(t.values()).reduce((i, s) => Ne(i, s), ie) : mn(e) : ie, [e, t]);
+}
+function en(e, t) {
+  t === void 0 && (t = []);
+  const n = M(null);
+  return O(
+    () => {
+      n.current = null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), O(() => {
+    const r = e !== ie;
+    r && !n.current && (n.current = e), !r && n.current && (n.current = null);
+  }, [e]), n.current ? lt(e, n.current) : ie;
+}
+function io(e) {
+  O(
+    () => {
+      if (!dt)
+        return;
+      const t = e.map((n) => {
+        let {
+          sensor: r
+        } = n;
+        return r.setup == null ? void 0 : r.setup();
+      });
+      return () => {
+        for (const n of t)
+          n == null || n();
+      };
+    },
+    // TO-DO: Sensors length could theoretically change which would not be a valid dependency
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    e.map((t) => {
+      let {
+        sensor: n
+      } = t;
+      return n;
+    })
+  );
+}
+function so(e, t) {
+  return N(() => e.reduce((n, r) => {
+    let {
+      eventName: o,
+      handler: i
+    } = r;
+    return n[o] = (s) => {
+      i(s, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function Cn(e) {
+  return N(() => e ? Tr(e) : null, [e]);
+}
+const tn = [];
+function ao(e, t) {
+  t === void 0 && (t = Le);
+  const [n] = e, r = Cn(n ? q(n) : null), [o, i] = Q(tn);
+  function s() {
+    i(() => e.length ? e.map((l) => xn(l) ? r : new Nt(t(l), l)) : tn);
+  }
+  const a = ft({
+    callback: s
+  });
+  return ue(() => {
+    a == null || a.disconnect(), s(), e.forEach((l) => a == null ? void 0 : a.observe(l));
+  }, [e]), o;
+}
+function lo(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return Ge(t) ? t : e;
+}
+function co(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, r] = Q(null), o = W((d) => {
+    for (const {
+      target: u
+    } of d)
+      if (Ge(u)) {
+        r((c) => {
+          const f = t(u);
+          return c ? {
+            ...c,
+            width: f.width,
+            height: f.height
+          } : f;
+        });
+        break;
+      }
+  }, [t]), i = ft({
+    callback: o
+  }), s = W((d) => {
+    const u = lo(d);
+    i == null || i.disconnect(), u && (i == null || i.observe(u)), r(u ? t(u) : null);
+  }, [t, i]), [a, l] = at(s);
+  return N(() => ({
+    nodeRef: a,
+    rect: n,
+    setRef: l
+  }), [n, a, l]);
+}
+const uo = [{
+  sensor: Lt,
+  options: {}
+}, {
+  sensor: Ot,
+  options: {}
+}], fo = {
+  current: {}
+}, it = {
+  draggable: {
+    measure: Vt
+  },
+  droppable: {
+    measure: Vt,
+    strategy: Ve.WhileDragging,
+    frequency: Rt.Optimized
+  },
+  dragOverlay: {
+    measure: Le
+  }
+};
+class Ye extends Map {
+  get(t) {
+    var n;
+    return t != null && (n = super.get(t)) != null ? n : void 0;
+  }
+  toArray() {
+    return Array.from(this.values());
+  }
+  getEnabled() {
+    return this.toArray().filter((t) => {
+      let {
+        disabled: n
+      } = t;
+      return !n;
+    });
+  }
+  getNodeFor(t) {
+    var n, r;
+    return (n = (r = this.get(t)) == null ? void 0 : r.node.current) != null ? n : void 0;
+  }
+}
+const go = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new Ye(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: ct
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: it,
+  measureDroppableContainers: ct,
+  windowRect: null,
+  measuringScheduled: !1
+}, ho = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: ct,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: ct
+}, gt = /* @__PURE__ */ qe(ho), Rn = /* @__PURE__ */ qe(go);
+function bo() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new Ye()
+    }
+  };
+}
+function vo(e, t) {
+  switch (t.type) {
+    case z.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case z.DragMove:
+      return e.draggable.active == null ? e : {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          translate: {
+            x: t.coordinates.x - e.draggable.initialCoordinates.x,
+            y: t.coordinates.y - e.draggable.initialCoordinates.y
+          }
+        }
+      };
+    case z.DragEnd:
+    case z.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case z.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: r
+      } = n, o = new Ye(e.droppable.containers);
+      return o.set(r, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: o
+        }
+      };
+    }
+    case z.SetDroppableDisabled: {
+      const {
+        id: n,
+        key: r,
+        disabled: o
+      } = t, i = e.droppable.containers.get(n);
+      if (!i || r !== i.key)
+        return e;
+      const s = new Ye(e.droppable.containers);
+      return s.set(n, {
+        ...i,
+        disabled: o
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: s
+        }
+      };
+    }
+    case z.UnregisterDroppable: {
+      const {
+        id: n,
+        key: r
+      } = t, o = e.droppable.containers.get(n);
+      if (!o || r !== o.key)
+        return e;
+      const i = new Ye(e.droppable.containers);
+      return i.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function po(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: r,
+    draggableNodes: o
+  } = Ce(gt), i = mt(r), s = mt(n == null ? void 0 : n.id);
+  return O(() => {
+    if (!t && !r && i && s != null) {
+      if (!At(i) || document.activeElement === i.target)
+        return;
+      const a = o.get(s);
+      if (!a)
+        return;
+      const {
+        activatorNode: l,
+        node: d
+      } = a;
+      if (!l.current && !d.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const u of [l.current, d.current]) {
+          if (!u)
+            continue;
+          const c = sr(u);
+          if (c) {
+            c.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [r, t, o, s, i]), null;
+}
+function yo(e, t) {
+  let {
+    transform: n,
+    ...r
+  } = t;
+  return e != null && e.length ? e.reduce((o, i) => i({
+    transform: o,
+    ...r
+  }), n) : n;
+}
+function xo(e) {
+  return N(
+    () => ({
+      draggable: {
+        ...it.draggable,
+        ...e == null ? void 0 : e.draggable
+      },
+      droppable: {
+        ...it.droppable,
+        ...e == null ? void 0 : e.droppable
+      },
+      dragOverlay: {
+        ...it.dragOverlay,
+        ...e == null ? void 0 : e.dragOverlay
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e == null ? void 0 : e.draggable, e == null ? void 0 : e.droppable, e == null ? void 0 : e.dragOverlay]
+  );
+}
+function wo(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: r,
+    config: o = !0
+  } = e;
+  const i = M(!1), {
+    x: s,
+    y: a
+  } = typeof o == "boolean" ? {
+    x: o,
+    y: o
+  } : o;
+  ue(() => {
+    if (!s && !a || !t) {
+      i.current = !1;
+      return;
+    }
+    if (i.current || !r)
+      return;
+    const d = t == null ? void 0 : t.node.current;
+    if (!d || d.isConnected === !1)
+      return;
+    const u = n(d), c = bn(u, r);
+    if (s || (c.x = 0), a || (c.y = 0), i.current = !0, Math.abs(c.x) > 0 || Math.abs(c.y) > 0) {
+      const f = vn(d);
+      f && f.scrollBy({
+        top: c.y,
+        left: c.x
+      });
+    }
+  }, [t, s, a, r, n]);
+}
+const In = /* @__PURE__ */ qe({
+  ...ie,
+  scaleX: 1,
+  scaleY: 1
+});
+var me;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(me || (me = {}));
+const mo = /* @__PURE__ */ Hn(function(t) {
+  var n, r, o, i;
+  let {
+    id: s,
+    accessibility: a,
+    autoScroll: l = !0,
+    children: d,
+    sensors: u = uo,
+    collisionDetection: c = Dr,
+    measuring: f,
+    modifiers: g,
+    ...p
+  } = t;
+  const h = Xn(vo, void 0, bo), [v, m] = h, [x, S] = fr(), [D, C] = Q(me.Uninitialized), R = D === me.Initialized, {
+    draggable: {
+      active: y,
+      nodes: w,
+      translate: E
+    },
+    droppable: {
+      containers: T
+    }
+  } = v, b = y != null ? w.get(y) : null, H = M({
+    initial: null,
+    translated: null
+  }), j = N(() => {
+    var X;
+    return y != null ? {
+      id: y,
+      // It's possible for the active node to unmount while dragging
+      data: (X = b == null ? void 0 : b.data) != null ? X : fo,
+      rect: H
+    } : null;
+  }, [y, b]), L = M(null), [ne, Y] = Q(null), [P, se] = Q(null), re = Ke(p, Object.values(p)), ze = _e("DndDescribedBy", s), Qe = N(() => T.getEnabled(), [T]), K = xo(f), {
+    droppableRects: de,
+    measureDroppableContainers: De,
+    measuringScheduled: je
+  } = Qr(Qe, {
+    dragging: R,
+    dependencies: [E.x, E.y],
+    config: K.droppable
+  }), Z = Jr(w, y), Ze = N(() => P ? St(P) : null, [P]), be = Fn(), fe = Zr(Z, K.draggable.measure);
+  wo({
+    activeNode: y != null ? w.get(y) : null,
+    config: be.layoutShiftCompensation,
+    initialRect: fe,
+    measure: K.draggable.measure
+  });
+  const k = Qt(Z, K.draggable.measure, fe), Pe = Qt(Z ? Z.parentElement : null), ae = M({
+    activatorEvent: null,
+    active: null,
+    activeNode: Z,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: de,
+    draggableNodes: w,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: T,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), Re = T.getNodeFor((n = ae.current.over) == null ? void 0 : n.id), ge = co({
+    measure: K.dragOverlay.measure
+  }), Ie = (r = ge.nodeRef.current) != null ? r : Z, Ee = R ? (o = ge.rect) != null ? o : k : null, jt = !!(ge.nodeRef.current && ge.rect), Pt = no(jt ? null : k), ht = Cn(Ie ? q(Ie) : null), ve = ro(R ? Re ?? Z : null), et = ao(ve), tt = yo(g, {
+    transform: {
+      x: E.x - Pt.x,
+      y: E.y - Pt.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: P,
+    active: j,
+    activeNodeRect: k,
+    containerNodeRect: Pe,
+    draggingNodeRect: Ee,
+    over: ae.current.over,
+    overlayNodeRect: ge.rect,
+    scrollableAncestors: ve,
+    scrollableAncestorRects: et,
+    windowRect: ht
+  }), Bt = Ze ? Ne(Ze, E) : null, Ft = oo(ve), On = en(Ft), Mn = en(Ft, [k]), ke = Ne(tt, On), Ae = Ee ? Ir(Ee, tt) : null, Be = j && Ae ? c({
+    active: j,
+    collisionRect: Ae,
+    droppableRects: de,
+    droppableContainers: Qe,
+    pointerCoordinates: Bt
+  }) : null, $t = wr(Be, "id"), [pe, Ht] = Q(null), Ln = jt ? tt : Ne(tt, Mn), zn = Cr(Ln, (i = pe == null ? void 0 : pe.rect) != null ? i : null, k), bt = M(null), Xt = W(
+    (X, G) => {
+      let {
+        sensor: J,
+        options: ye
+      } = G;
+      if (L.current == null)
+        return;
+      const ee = w.get(L.current);
+      if (!ee)
+        return;
+      const _ = X.nativeEvent, le = new J({
+        active: L.current,
+        activeNode: ee,
+        event: _,
+        options: ye,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: ae,
+        onAbort(F) {
+          if (!w.get(F))
+            return;
+          const {
+            onDragAbort: ce
+          } = re.current, he = {
+            id: F
+          };
+          ce == null || ce(he), x({
+            type: "onDragAbort",
+            event: he
+          });
+        },
+        onPending(F, xe, ce, he) {
+          if (!w.get(F))
+            return;
+          const {
+            onDragPending: $e
+          } = re.current, we = {
+            id: F,
+            constraint: xe,
+            initialCoordinates: ce,
+            offset: he
+          };
+          $e == null || $e(we), x({
+            type: "onDragPending",
+            event: we
+          });
+        },
+        onStart(F) {
+          const xe = L.current;
+          if (xe == null)
+            return;
+          const ce = w.get(xe);
+          if (!ce)
+            return;
+          const {
+            onDragStart: he
+          } = re.current, Fe = {
+            activatorEvent: _,
+            active: {
+              id: xe,
+              data: ce.data,
+              rect: H
+            }
+          };
+          nt(() => {
+            he == null || he(Fe), C(me.Initializing), m({
+              type: z.DragStart,
+              initialCoordinates: F,
+              active: xe
+            }), x({
+              type: "onDragStart",
+              event: Fe
+            }), Y(bt.current), se(_);
+          });
+        },
+        onMove(F) {
+          m({
+            type: z.DragMove,
+            coordinates: F
+          });
+        },
+        onEnd: Te(z.DragEnd),
+        onCancel: Te(z.DragCancel)
+      });
+      bt.current = le;
+      function Te(F) {
+        return async function() {
+          const {
+            active: ce,
+            collisions: he,
+            over: Fe,
+            scrollAdjustedTranslate: $e
+          } = ae.current;
+          let we = null;
+          if (ce && $e) {
+            const {
+              cancelDrop: He
+            } = re.current;
+            we = {
+              activatorEvent: _,
+              active: ce,
+              collisions: he,
+              delta: $e,
+              over: Fe
+            }, F === z.DragEnd && typeof He == "function" && await Promise.resolve(He(we)) && (F = z.DragCancel);
+          }
+          L.current = null, nt(() => {
+            m({
+              type: F
+            }), C(me.Uninitialized), Ht(null), Y(null), se(null), bt.current = null;
+            const He = F === z.DragEnd ? "onDragEnd" : "onDragCancel";
+            if (we) {
+              const vt = re.current[He];
+              vt == null || vt(we), x({
+                type: He,
+                event: we
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [w]
+  ), jn = W((X, G) => (J, ye) => {
+    const ee = J.nativeEvent, _ = w.get(ye);
+    if (
+      // Another sensor is already instantiating
+      L.current !== null || // No active draggable
+      !_ || // Event has already been captured
+      ee.dndKit || ee.defaultPrevented
+    )
+      return;
+    const le = {
+      active: _
+    };
+    X(J, G.options, le) === !0 && (ee.dndKit = {
+      capturedBy: G.sensor
+    }, L.current = ye, Xt(J, G));
+  }, [w, Xt]), Wt = _r(u, jn);
+  io(u), ue(() => {
+    k && D === me.Initializing && C(me.Initialized);
+  }, [k, D]), O(
+    () => {
+      const {
+        onDragMove: X
+      } = re.current, {
+        active: G,
+        activatorEvent: J,
+        collisions: ye,
+        over: ee
+      } = ae.current;
+      if (!G || !J)
+        return;
+      const _ = {
+        active: G,
+        activatorEvent: J,
+        collisions: ye,
+        delta: {
+          x: ke.x,
+          y: ke.y
+        },
+        over: ee
+      };
+      nt(() => {
+        X == null || X(_), x({
+          type: "onDragMove",
+          event: _
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [ke.x, ke.y]
+  ), O(
+    () => {
+      const {
+        active: X,
+        activatorEvent: G,
+        collisions: J,
+        droppableContainers: ye,
+        scrollAdjustedTranslate: ee
+      } = ae.current;
+      if (!X || L.current == null || !G || !ee)
+        return;
+      const {
+        onDragOver: _
+      } = re.current, le = ye.get($t), Te = le && le.rect.current ? {
+        id: le.id,
+        rect: le.rect.current,
+        data: le.data,
+        disabled: le.disabled
+      } : null, F = {
+        active: X,
+        activatorEvent: G,
+        collisions: J,
+        delta: {
+          x: ee.x,
+          y: ee.y
+        },
+        over: Te
+      };
+      nt(() => {
+        Ht(Te), _ == null || _(F), x({
+          type: "onDragOver",
+          event: F
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [$t]
+  ), ue(() => {
+    ae.current = {
+      activatorEvent: P,
+      active: j,
+      activeNode: Z,
+      collisionRect: Ae,
+      collisions: Be,
+      droppableRects: de,
+      draggableNodes: w,
+      draggingNode: Ie,
+      draggingNodeRect: Ee,
+      droppableContainers: T,
+      over: pe,
+      scrollableAncestors: ve,
+      scrollAdjustedTranslate: ke
+    }, H.current = {
+      initial: Ee,
+      translated: Ae
+    };
+  }, [j, Z, Be, Ae, w, Ie, Ee, de, T, pe, ve, ke]), Vr({
+    ...be,
+    delta: E,
+    draggingRect: Ae,
+    pointerCoordinates: Bt,
+    scrollableAncestors: ve,
+    scrollableAncestorRects: et
+  });
+  const Pn = N(() => ({
+    active: j,
+    activeNode: Z,
+    activeNodeRect: k,
+    activatorEvent: P,
+    collisions: Be,
+    containerNodeRect: Pe,
+    dragOverlay: ge,
+    draggableNodes: w,
+    droppableContainers: T,
+    droppableRects: de,
+    over: pe,
+    measureDroppableContainers: De,
+    scrollableAncestors: ve,
+    scrollableAncestorRects: et,
+    measuringConfiguration: K,
+    measuringScheduled: je,
+    windowRect: ht
+  }), [j, Z, k, P, Be, Pe, ge, w, T, de, pe, De, ve, et, K, je, ht]), Bn = N(() => ({
+    activatorEvent: P,
+    activators: Wt,
+    active: j,
+    activeNodeRect: k,
+    ariaDescribedById: {
+      draggable: ze
+    },
+    dispatch: m,
+    draggableNodes: w,
+    over: pe,
+    measureDroppableContainers: De
+  }), [P, Wt, j, k, m, ze, w, pe, De]);
+  return U.createElement(hn.Provider, {
+    value: S
+  }, U.createElement(gt.Provider, {
+    value: Bn
+  }, U.createElement(Rn.Provider, {
+    value: Pn
+  }, U.createElement(In.Provider, {
+    value: zn
+  }, d)), U.createElement(po, {
+    disabled: (a == null ? void 0 : a.restoreFocus) === !1
+  })), U.createElement(br, {
+    ...a,
+    hiddenTextDescribedById: ze
+  }));
+  function Fn() {
+    const X = (ne == null ? void 0 : ne.autoScrollEnabled) === !1, G = typeof l == "object" ? l.enabled === !1 : l === !1, J = R && !X && !G;
+    return typeof l == "object" ? {
+      ...l,
+      enabled: J
+    } : {
+      enabled: J
+    };
+  }
+}), So = /* @__PURE__ */ qe(null), nn = "button", Do = "Draggable";
+function Co(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: r = !1,
+    attributes: o
+  } = e;
+  const i = _e(Do), {
+    activators: s,
+    activatorEvent: a,
+    active: l,
+    activeNodeRect: d,
+    ariaDescribedById: u,
+    draggableNodes: c,
+    over: f
+  } = Ce(gt), {
+    role: g = nn,
+    roleDescription: p = "draggable",
+    tabIndex: h = 0
+  } = o ?? {}, v = (l == null ? void 0 : l.id) === t, m = Ce(v ? In : So), [x, S] = at(), [D, C] = at(), R = so(s, t), y = Ke(n);
+  ue(
+    () => (c.set(t, {
+      id: t,
+      key: i,
+      node: x,
+      activatorNode: D,
+      data: y
+    }), () => {
+      const E = c.get(t);
+      E && E.key === i && c.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [c, t]
+  );
+  const w = N(() => ({
+    role: g,
+    tabIndex: h,
+    "aria-disabled": r,
+    "aria-pressed": v && g === nn ? !0 : void 0,
+    "aria-roledescription": p,
+    "aria-describedby": u.draggable
+  }), [r, g, h, v, p, u.draggable]);
+  return {
+    active: l,
+    activatorEvent: a,
+    activeNodeRect: d,
+    attributes: w,
+    isDragging: v,
+    listeners: r ? void 0 : R,
+    node: x,
+    over: f,
+    setNodeRef: S,
+    setActivatorNodeRef: C,
+    transform: m
+  };
+}
+function Ro() {
+  return Ce(Rn);
+}
+const Io = "Droppable", Eo = {
+  timeout: 25
+};
+function ko(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: r,
+    resizeObserverConfig: o
+  } = e;
+  const i = _e(Io), {
+    active: s,
+    dispatch: a,
+    over: l,
+    measureDroppableContainers: d
+  } = Ce(gt), u = M({
+    disabled: n
+  }), c = M(!1), f = M(null), g = M(null), {
+    disabled: p,
+    updateMeasurementsFor: h,
+    timeout: v
+  } = {
+    ...Eo,
+    ...o
+  }, m = Ke(h ?? r), x = W(
+    () => {
+      if (!c.current) {
+        c.current = !0;
+        return;
+      }
+      g.current != null && clearTimeout(g.current), g.current = setTimeout(() => {
+        d(Array.isArray(m.current) ? m.current : [m.current]), g.current = null;
+      }, v);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [v]
+  ), S = ft({
+    callback: x,
+    disabled: p || !s
+  }), D = W((w, E) => {
+    S && (E && (S.unobserve(E), c.current = !1), w && S.observe(w));
+  }, [S]), [C, R] = at(D), y = Ke(t);
+  return O(() => {
+    !S || !C.current || (S.disconnect(), c.current = !1, S.observe(C.current));
+  }, [C, S]), O(
+    () => (a({
+      type: z.RegisterDroppable,
+      element: {
+        id: r,
+        key: i,
+        disabled: n,
+        node: C,
+        rect: f,
+        data: y
+      }
+    }), () => a({
+      type: z.UnregisterDroppable,
+      key: i,
+      id: r
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), O(() => {
+    n !== u.current.disabled && (a({
+      type: z.SetDroppableDisabled,
+      id: r,
+      key: i,
+      disabled: n
+    }), u.current.disabled = n);
+  }, [r, i, n, a]), {
+    active: s,
+    rect: f,
+    isOver: (l == null ? void 0 : l.id) === r,
+    node: C,
+    over: l,
+    setNodeRef: R
+  };
+}
+function zt(e, t, n) {
+  const r = e.slice();
+  return r.splice(n < 0 ? r.length + n : n, 0, r.splice(t, 1)[0]), r;
+}
+function Ao(e, t) {
+  return e.reduce((n, r, o) => {
+    const i = t.get(r);
+    return i && (n[o] = i), n;
+  }, Array(e.length));
+}
+function rt(e) {
+  return e !== null && e >= 0;
+}
+function To(e, t) {
+  if (e === t)
+    return !0;
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+function No(e) {
+  return typeof e == "boolean" ? {
+    draggable: e,
+    droppable: e
+  } : e;
+}
+const ot = {
+  scaleX: 1,
+  scaleY: 1
+}, Oo = (e) => {
+  var t;
+  let {
+    rects: n,
+    activeNodeRect: r,
+    activeIndex: o,
+    overIndex: i,
+    index: s
+  } = e;
+  const a = (t = n[o]) != null ? t : r;
+  if (!a)
+    return null;
+  const l = Mo(n, s, o);
+  if (s === o) {
+    const d = n[i];
+    return d ? {
+      x: o < i ? d.left + d.width - (a.left + a.width) : d.left - a.left,
+      y: 0,
+      ...ot
+    } : null;
+  }
+  return s > o && s <= i ? {
+    x: -a.width - l,
+    y: 0,
+    ...ot
+  } : s < o && s >= i ? {
+    x: a.width + l,
+    y: 0,
+    ...ot
+  } : {
+    x: 0,
+    y: 0,
+    ...ot
+  };
+};
+function Mo(e, t, n) {
+  const r = e[t], o = e[t - 1], i = e[t + 1];
+  return !r || !o && !i ? 0 : n < t ? o ? r.left - (o.left + o.width) : i.left - (r.left + r.width) : i ? i.left - (r.left + r.width) : r.left - (o.left + o.width);
+}
+const En = (e) => {
+  let {
+    rects: t,
+    activeIndex: n,
+    overIndex: r,
+    index: o
+  } = e;
+  const i = zt(t, r, n), s = t[o], a = i[o];
+  return !a || !s ? null : {
+    x: a.left - s.left,
+    y: a.top - s.top,
+    scaleX: a.width / s.width,
+    scaleY: a.height / s.height
+  };
+}, kn = "Sortable", An = /* @__PURE__ */ U.createContext({
+  activeIndex: -1,
+  containerId: kn,
+  disableTransforms: !1,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: !1,
+  sortedRects: [],
+  strategy: En,
+  disabled: {
+    draggable: !1,
+    droppable: !1
+  }
+});
+function Lo(e) {
+  let {
+    children: t,
+    id: n,
+    items: r,
+    strategy: o = En,
+    disabled: i = !1
+  } = e;
+  const {
+    active: s,
+    dragOverlay: a,
+    droppableRects: l,
+    over: d,
+    measureDroppableContainers: u
+  } = Ro(), c = _e(kn, n), f = a.rect !== null, g = N(() => r.map((R) => typeof R == "object" && "id" in R ? R.id : R), [r]), p = s != null, h = s ? g.indexOf(s.id) : -1, v = d ? g.indexOf(d.id) : -1, m = M(g), x = !To(g, m.current), S = v !== -1 && h === -1 || x, D = No(i);
+  ue(() => {
+    x && p && u(g);
+  }, [x, g, p, u]), O(() => {
+    m.current = g;
+  }, [g]);
+  const C = N(
+    () => ({
+      activeIndex: h,
+      containerId: c,
+      disabled: D,
+      disableTransforms: S,
+      items: g,
+      overIndex: v,
+      useDragOverlay: f,
+      sortedRects: Ao(g, l),
+      strategy: o
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [h, c, D.draggable, D.droppable, S, g, v, l, f, o]
+  );
+  return U.createElement(An.Provider, {
+    value: C
+  }, t);
+}
+const zo = (e) => {
+  let {
+    id: t,
+    items: n,
+    activeIndex: r,
+    overIndex: o
+  } = e;
+  return zt(n, r, o).indexOf(t);
+}, Tn = (e) => {
+  let {
+    containerId: t,
+    isSorting: n,
+    wasDragging: r,
+    index: o,
+    items: i,
+    newIndex: s,
+    previousItems: a,
+    previousContainerId: l,
+    transition: d
+  } = e;
+  return !d || !r || a !== i && o === s ? !1 : n ? !0 : s !== o && t === l;
+}, jo = {
+  duration: 200,
+  easing: "ease"
+}, Nn = "transform", Po = /* @__PURE__ */ Ue.Transition.toString({
+  property: Nn,
+  duration: 0,
+  easing: "linear"
+}), Bo = {
+  roleDescription: "sortable"
+};
+function Fo(e) {
+  let {
+    disabled: t,
+    index: n,
+    node: r,
+    rect: o
+  } = e;
+  const [i, s] = Q(null), a = M(n);
+  return ue(() => {
+    if (!t && n !== a.current && r.current) {
+      const l = o.current;
+      if (l) {
+        const d = Le(r.current, {
+          ignoreTransform: !0
+        }), u = {
+          x: l.left - d.left,
+          y: l.top - d.top,
+          scaleX: l.width / d.width,
+          scaleY: l.height / d.height
+        };
+        (u.x || u.y) && s(u);
+      }
+    }
+    n !== a.current && (a.current = n);
+  }, [t, n, r, o]), O(() => {
+    i && s(null);
+  }, [i]), i;
+}
+function $o(e) {
+  let {
+    animateLayoutChanges: t = Tn,
+    attributes: n,
+    disabled: r,
+    data: o,
+    getNewIndex: i = zo,
+    id: s,
+    strategy: a,
+    resizeObserverConfig: l,
+    transition: d = jo
+  } = e;
+  const {
+    items: u,
+    containerId: c,
+    activeIndex: f,
+    disabled: g,
+    disableTransforms: p,
+    sortedRects: h,
+    overIndex: v,
+    useDragOverlay: m,
+    strategy: x
+  } = Ce(An), S = Ho(r, g), D = u.indexOf(s), C = N(() => ({
+    sortable: {
+      containerId: c,
+      index: D,
+      items: u
+    },
+    ...o
+  }), [c, o, D, u]), R = N(() => u.slice(u.indexOf(s)), [u, s]), {
+    rect: y,
+    node: w,
+    isOver: E,
+    setNodeRef: T
+  } = ko({
+    id: s,
+    data: C,
+    disabled: S.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: R,
+      ...l
+    }
+  }), {
+    active: b,
+    activatorEvent: H,
+    activeNodeRect: j,
+    attributes: L,
+    setNodeRef: ne,
+    listeners: Y,
+    isDragging: P,
+    over: se,
+    setActivatorNodeRef: re,
+    transform: ze
+  } = Co({
+    id: s,
+    data: C,
+    attributes: {
+      ...Bo,
+      ...n
+    },
+    disabled: S.draggable
+  }), Qe = nr(T, ne), K = !!b, de = K && !p && rt(f) && rt(v), De = !m && P, je = De && de ? ze : null, Ze = de ? je ?? (a ?? x)({
+    rects: h,
+    activeNodeRect: j,
+    activeIndex: f,
+    overIndex: v,
+    index: D
+  }) : null, be = rt(f) && rt(v) ? i({
+    id: s,
+    items: u,
+    activeIndex: f,
+    overIndex: v
+  }) : D, fe = b == null ? void 0 : b.id, k = M({
+    activeId: fe,
+    items: u,
+    newIndex: be,
+    containerId: c
+  }), Pe = u !== k.current.items, ae = t({
+    active: b,
+    containerId: c,
+    isDragging: P,
+    isSorting: K,
+    id: s,
+    index: D,
+    items: u,
+    newIndex: k.current.newIndex,
+    previousItems: k.current.items,
+    previousContainerId: k.current.containerId,
+    transition: d,
+    wasDragging: k.current.activeId != null
+  }), Re = Fo({
+    disabled: !ae,
+    index: D,
+    node: w,
+    rect: y
+  });
+  return O(() => {
+    K && k.current.newIndex !== be && (k.current.newIndex = be), c !== k.current.containerId && (k.current.containerId = c), u !== k.current.items && (k.current.items = u);
+  }, [K, be, c, u]), O(() => {
+    if (fe === k.current.activeId)
+      return;
+    if (fe != null && k.current.activeId == null) {
+      k.current.activeId = fe;
+      return;
+    }
+    const Ie = setTimeout(() => {
+      k.current.activeId = fe;
+    }, 50);
+    return () => clearTimeout(Ie);
+  }, [fe]), {
+    active: b,
+    activeIndex: f,
+    attributes: L,
+    data: C,
+    rect: y,
+    index: D,
+    newIndex: be,
+    items: u,
+    isOver: E,
+    isSorting: K,
+    isDragging: P,
+    listeners: Y,
+    node: w,
+    overIndex: v,
+    over: se,
+    setNodeRef: Qe,
+    setActivatorNodeRef: re,
+    setDroppableNodeRef: T,
+    setDraggableNodeRef: ne,
+    transform: Re ?? Ze,
+    transition: ge()
+  };
+  function ge() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      Re || // Or to prevent items jumping to back to their "new" position when items change
+      Pe && k.current.newIndex === D
+    )
+      return Po;
+    if (!(De && !At(H) || !d) && (K || ae))
+      return Ue.Transition.toString({
+        ...d,
+        property: Nn
+      });
+  }
+}
+function Ho(e, t) {
+  var n, r;
+  return typeof e == "boolean" ? {
+    draggable: e,
+    // Backwards compatibility
+    droppable: !1
+  } : {
+    draggable: (n = e == null ? void 0 : e.draggable) != null ? n : t.draggable,
+    droppable: (r = e == null ? void 0 : e.droppable) != null ? r : t.droppable
+  };
+}
+I.Down, I.Right, I.Up, I.Left;
+const Xo = ({ className: e }) => /* @__PURE__ */ A.jsxs(
+  "svg",
+  {
+    width: "16",
+    height: "16",
+    viewBox: "0 0 16 16",
+    fill: "currentColor",
+    className: e,
+    style: { flexShrink: 0 },
+    children: [
+      /* @__PURE__ */ A.jsx("circle", { cx: "6", cy: "4", r: "1.5" }),
+      /* @__PURE__ */ A.jsx("circle", { cx: "10", cy: "4", r: "1.5" }),
+      /* @__PURE__ */ A.jsx("circle", { cx: "6", cy: "8", r: "1.5" }),
+      /* @__PURE__ */ A.jsx("circle", { cx: "10", cy: "8", r: "1.5" }),
+      /* @__PURE__ */ A.jsx("circle", { cx: "6", cy: "12", r: "1.5" }),
+      /* @__PURE__ */ A.jsx("circle", { cx: "10", cy: "12", r: "1.5" })
+    ]
+  }
+), Wo = ({
+  column: e,
+  index: t,
+  columns: n,
+  sortState: r,
+  onSort: o,
+  renderSortIcon: i,
+  draggable: s = !1,
+  dragHandleIcon: a,
+  theme: l = "light"
+}) => {
+  const d = Se.useRef(null), [u, c] = Se.useState(null), f = (y) => {
+    const { isSorting: w, wasDragging: E } = y;
+    return w || E ? Tn(y) : !0;
+  }, {
+    attributes: g,
+    listeners: p,
+    setNodeRef: h,
+    transform: v,
+    transition: m,
+    isDragging: x
+  } = $o({
+    id: e.key || `col-${t}`,
+    disabled: !s || !!e.fixed,
+    animateLayoutChanges: f,
+    transition: {
+      duration: 250,
+      easing: "cubic-bezier(0.25, 1, 0.5, 1)"
+    }
+  }), S = Se.useCallback((y) => {
+    d.current = y, h(y);
+  }, [h]);
+  Se.useEffect(() => {
+    if (x && d.current) {
+      const y = d.current.getBoundingClientRect().width;
+      c(y);
+    } else
+      x || c(null);
+  }, [x]);
+  const D = () => {
+    const y = x && u ? `${u}px` : e.width || "auto";
+    let w = "auto";
+    e.fixed ? w = x ? 1001 : 1e3 : x && (w = 100);
+    const E = {
+      transform: v ? Ue.Translate.toString(v) : void 0,
+      transition: m || "transform 250ms cubic-bezier(0.25, 1, 0.5, 1)",
+      willChange: "transform",
+      width: y,
+      textAlign: V.getTextAlign(e.align),
+      opacity: x ? 0.5 : 1,
+      // cursor 由 className 控制，不在 inline style 中设置
+      zIndex: w,
+      whiteSpace: "nowrap",
+      overflow: "hidden",
+      textOverflow: "ellipsis"
+    };
+    if (x && u && (E.minWidth = `${u}px`, E.maxWidth = `${u}px`), e.fixed === "left") {
+      let T = 0;
+      for (let b = 0; b < t; b++)
+        n[b].fixed === "left" && (T += parseInt(n[b].width || "150"));
+      E.left = `${T}px`;
+    } else if (e.fixed === "right") {
+      let T = 0;
+      for (let b = t + 1; b < n.length; b++)
+        n[b].fixed === "right" && (T += parseInt(n[b].width || "150"));
+      E.right = `${T}px`;
+    }
+    return E;
+  }, C = st(
+    "bu-group",
+    V.getThClasses({
+      theme: l,
+      fixed: e.fixed,
+      sortable: e.filter,
+      isDragging: x,
+      draggable: s
+    })
+  ), R = s && !e.fixed;
+  return /* @__PURE__ */ A.jsx(
+    "th",
+    {
+      ref: S,
+      className: C,
+      style: D(),
+      ...g,
+      ...p,
+      onClick: () => o(e),
+      children: /* @__PURE__ */ A.jsxs("div", { className: "bu-flex bu-items-center bu-gap-2 bu-relative", style: { justifyContent: e.align || "center" }, children: [
+        /* @__PURE__ */ A.jsxs("div", { className: "bu-flex", children: [
+          e.renderHeader ? e.renderHeader([]) : e.title,
+          i(e)
+        ] }),
+        R && /* @__PURE__ */ A.jsx(
+          "span",
+          {
+            className: st(V.dragHandle({
+              theme: l
+            }), "group-hover:bu-opacity-100"),
+            style: {
+              display: "flex",
+              alignItems: "center",
+              marginLeft: "4px"
+            },
+            children: a || /* @__PURE__ */ A.jsx(Xo, {})
+          }
+        )
+      ] })
+    }
+  );
+}, Yo = (e) => {
+  const {
+    columns: t,
+    sortStates: n,
+    onSort: r,
+    activeId: o,
+    theadClass: i,
+    draggable: s = !1,
+    dragHandleIcon: a,
+    theme: l = "light"
+  } = e, d = (c) => {
+    c.filter && c.key && r(c.key, c.type);
+  }, u = (c) => {
+    if (!c.filter || !c.key)
+      return null;
+    const f = n[c.key] || oe.default;
+    return /* @__PURE__ */ A.jsxs("span", { className: V.sortIcon(), children: [
+      /* @__PURE__ */ A.jsx(
+        "span",
+        {
+          className: V.sortArrow({
+            direction: "asc",
+            theme: l,
+            active: f === oe.asc
+          })
+        }
+      ),
+      /* @__PURE__ */ A.jsx(
+        "span",
+        {
+          className: V.sortArrow({
+            direction: "desc",
+            theme: l,
+            active: f === oe.desc
+          })
+        }
+      )
+    ] });
+  };
+  return /* @__PURE__ */ A.jsx("thead", { className: st(V.thead({ theme: l }), i), children: /* @__PURE__ */ A.jsx("tr", { children: t.map((c, f) => /* @__PURE__ */ A.jsx(
+    Wo,
+    {
+      column: c,
+      index: f,
+      columns: t,
+      sortState: c.key ? n[c.key] : void 0,
+      onSort: d,
+      renderSortIcon: u,
+      isDragging: c.key === o,
+      draggable: s,
+      dragHandleIcon: a,
+      theme: l
+    },
+    c.key || f
+  )) }) });
+}, Ko = (e) => {
+  const { columns: t, data: n, rowKey: r, tdClass: o, tbodyClass: i, theme: s = "light" } = e, a = (u, c) => {
+    const f = {
+      textAlign: V.getTextAlign(u.align)
+    };
+    if (u.fixed === "left") {
+      let g = 0;
+      for (let p = 0; p < c; p++)
+        t[p].fixed === "left" && (g += parseInt(t[p].width || "150"));
+      f.left = `${g}px`;
+    } else if (u.fixed === "right") {
+      let g = 0;
+      for (let p = c + 1; p < t.length; p++)
+        t[p].fixed === "right" && (g += parseInt(t[p].width || "150"));
+      f.right = `${g}px`;
+    }
+    return f;
+  }, l = (u, c, f) => u.render ? u.render(c, f) : u.key ? c[u.key] : null, d = (u, c, f) => {
+    if (u.onCell)
+      return u.onCell(c, f);
+  };
+  return /* @__PURE__ */ A.jsx("tbody", { className: st(V.tbody({ theme: s }), i), children: n.map((u, c) => /* @__PURE__ */ A.jsx(
+    "tr",
+    {
+      className: V.tr({ theme: s }),
+      children: t.map((f, g) => {
+        const p = d(f, u, c);
+        return p === 0 ? null : /* @__PURE__ */ A.jsx(
+          "td",
+          {
+            className: V.getTdClasses({
+              theme: s,
+              fixed: f.fixed,
+              customClass: o
+            }),
+            style: a(f, g),
+            colSpan: p,
+            children: l(f, u, c)
+          },
+          f.key || g
+        );
+      })
+    },
+    u[r] || c
+  )) });
+}, Uo = (e) => {
+  let {
+    transform: t
+  } = e;
+  return {
+    ...t,
+    y: 0
+  };
+}, _o = (e) => {
+  const {
+    columns: t,
+    data: n,
+    rowKey: r = "id",
+    theadClass: o,
+    tdClass: i,
+    tbodyClass: s,
+    renderEmpty: a,
+    theme: l = "light",
+    onSortChange: d,
+    tableLayout: u = "auto",
+    draggable: c = !1,
+    // 默认不启用拖拽
+    onColumnsChange: f,
+    dragHandleIcon: g,
+    maxHeight: p
+  } = e, [h, v] = Se.useState(t), [m, x] = Se.useState({}), [S, D] = Se.useState(null), C = vr(
+    Kt(Lt, {
+      activationConstraint: {
+        distance: 8
+        // 8px 移动后才激活拖拽
+      }
+    }),
+    Kt(Ot)
+  );
+  Se.useEffect(() => {
+    v(t);
+  }, []);
+  const R = (b, H) => {
+    const j = m[b] || oe.default;
+    let L;
+    j === oe.default ? L = oe.desc : j === oe.desc ? L = oe.asc : L = oe.default;
+    const ne = H || "single";
+    let Y;
+    if (ne === "single" ? Y = { [b]: L } : (Y = { ...m, [b]: L }, L === oe.default && delete Y[b]), x(Y), d)
+      if (ne === "single")
+        d({ sortKey: b, sort: L });
+      else {
+        const P = Object.entries(Y).map(([se, re]) => ({
+          sortKey: se,
+          sort: re
+        }));
+        d(P);
+      }
+  }, y = (b) => {
+    D(b.active.id);
+  }, w = (b) => {
+    const { active: H, over: j } = b;
+    D(null), !(!j || H.id === j.id) && v((L) => {
+      const ne = L.findIndex((se) => se.key === H.id), Y = L.findIndex((se) => se.key === j.id);
+      if (ne === -1 || Y === -1 || L[Y].fixed)
+        return L;
+      const P = zt(L, ne, Y);
+      return f && f(P), P;
+    });
+  }, E = h.filter((b) => !b.fixed && b.key).map((b) => b.key), T = () => /* @__PURE__ */ A.jsxs(
+    "div",
+    {
+      className: V.container({ theme: l }),
+      style: p ? { maxHeight: p, overflow: "auto" } : void 0,
+      children: [
+        /* @__PURE__ */ A.jsxs("table", { className: V.table(), style: { tableLayout: u }, children: [
+          /* @__PURE__ */ A.jsx(
+            Yo,
+            {
+              columns: h,
+              sortStates: m,
+              onSort: R,
+              activeId: c ? S : null,
+              theadClass: o,
+              draggable: c,
+              dragHandleIcon: g,
+              theme: l
+            }
+          ),
+          /* @__PURE__ */ A.jsx(
+            Ko,
+            {
+              columns: h,
+              data: n,
+              rowKey: r,
+              tdClass: i,
+              tbodyClass: s,
+              theme: l
+            }
+          )
+        ] }),
+        n.length === 0 && /* @__PURE__ */ A.jsx("div", { className: V.empty({ theme: l }), children: a || "No Data" })
+      ]
+    }
+  );
+  return c ? /* @__PURE__ */ A.jsx(
+    mo,
+    {
+      sensors: C,
+      collisionDetection: mr,
+      onDragStart: y,
+      onDragEnd: w,
+      modifiers: [Uo],
+      children: /* @__PURE__ */ A.jsx(
+        Lo,
+        {
+          items: E,
+          strategy: Oo,
+          children: T()
+        }
+      )
+    }
+  ) : T();
+};
+export {
+  _o as P,
+  oe as S
+};