mada-design-system 0.1.1 → 0.2.1

package/index.es100.js

@@ -1,324 +1,2598 @@
-import U, { useMemo as A, useRef as z, useEffect as E, useContext as le, useState as ue } from "react";
-import { KeyboardCode as O, useDndContext as fe, useDroppable as ge, useDraggable as pe, getClientRect as be } from "./index.es99.js";
-import { useUniqueId as ve, useIsomorphicLayoutEffect as V, useCombinedRefs as me, isKeyboardEvent as Ie, CSS as Y } from "./index.es169.js";
-function $(e, r, t) {
-  const n = e.slice();
-  return n.splice(t < 0 ? n.length + t : t, 0, n.splice(r, 1)[0]), n;
-}
-function xe(e, r) {
-  return e.reduce((t, n, i) => {
-    const c = r.get(n);
-    return c && (t[i] = c), t;
-  }, Array(e.length));
-}
-function N(e) {
-  return e !== null && e >= 0;
-}
-function ye(e, r) {
-  if (e === r)
-    return !0;
-  if (e.length !== r.length)
-    return !1;
-  for (let t = 0; t < e.length; t++)
-    if (e[t] !== r[t])
-      return !1;
-  return !0;
-}
-function he(e) {
-  return typeof e == "boolean" ? {
-    draggable: e,
-    droppable: e
-  } : e;
-}
-const j = (e) => {
-  let {
-    rects: r,
-    activeIndex: t,
-    overIndex: n,
-    index: i
-  } = e;
-  const c = $(r, n, t), o = r[i], a = c[i];
-  return !a || !o ? null : {
-    x: a.left - o.left,
-    y: a.top - o.top,
-    scaleX: a.width / o.width,
-    scaleY: a.height / o.height
-  };
-}, G = "Sortable", k = /* @__PURE__ */ U.createContext({
-  activeIndex: -1,
-  containerId: G,
-  disableTransforms: !1,
-  items: [],
-  overIndex: -1,
-  useDragOverlay: !1,
-  sortedRects: [],
-  strategy: j,
-  disabled: {
-    draggable: !1,
-    droppable: !1
+import M, { createContext as Ne, useMemo as A, memo as yn, useReducer as mn, useState as K, useRef as P, useCallback as U, useEffect as O, useContext as de, cloneElement as wn, forwardRef as Dn } from "react";
+import { unstable_batchedUpdates as Be, createPortal as xn } from "react-dom";
+import { getWindow as J, useLatestValue as Ae, useUniqueId as Ue, getEventCoordinates as $e, add as ye, useIsomorphicLayoutEffect as fe, getOwnerDocument as me, useInterval as Cn, usePrevious as Ke, useLazyMemo as Me, subtract as Xe, canUseDOM as at, isHTMLElement as He, useNodeRef as je, isKeyboardEvent as lt, findFirstFocusableNode as Sn, CSS as rt, useEvent as ct, isWindow as ut, isNode as Rn, isDocument as Yt, isSVGElement as En } from "./index.es171.js";
+import { useAnnouncement as An, HiddenText as On, LiveRegion as Nn } from "./index.es172.js";
+const Ut = /* @__PURE__ */ Ne(null);
+function Mn(e) {
+  const t = de(Ut);
+  O(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function Tn() {
+  const [e] = K(() => /* @__PURE__ */ new Set()), t = U((r) => (e.add(r), () => e.delete(r)), [e]);
+  return [U((r) => {
+    let {
+      type: i,
+      event: o
+    } = r;
+    e.forEach((a) => {
+      var s;
+      return (s = a[i]) == null ? void 0 : s.call(a, o);
+    });
+  }, [e]), t];
+}
+const Ln = {
+  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.
+  `
+}, kn = {
+  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 _e(e) {
+};
+function In(e) {
   let {
-    children: r,
-    id: t,
-    items: n,
-    strategy: i = j,
-    disabled: c = !1
+    announcements: t = kn,
+    container: n,
+    hiddenTextDescribedById: r,
+    screenReaderInstructions: i = Ln
   } = e;
   const {
-    active: o,
-    dragOverlay: a,
-    droppableRects: f,
-    over: l,
-    measureDroppableContainers: s
-  } = fe(), p = ve(G, t), v = a.rect !== null, u = A(() => n.map((m) => typeof m == "object" && "id" in m ? m.id : m), [n]), S = o != null, y = o ? u.indexOf(o.id) : -1, b = l ? u.indexOf(l.id) : -1, T = z(u), h = !ye(u, T.current), D = b !== -1 && y === -1 || h, g = he(c);
-  V(() => {
-    h && S && s(u);
-  }, [h, u, S, s]), E(() => {
-    T.current = u;
-  }, [u]);
-  const R = A(
+    announce: o,
+    announcement: a
+  } = An(), s = Ue("DndLiveRegion"), [l, c] = K(!1);
+  if (O(() => {
+    c(!0);
+  }, []), Mn(A(() => ({
+    onDragStart(u) {
+      let {
+        active: g
+      } = u;
+      o(t.onDragStart({
+        active: g
+      }));
+    },
+    onDragMove(u) {
+      let {
+        active: g,
+        over: f
+      } = u;
+      t.onDragMove && o(t.onDragMove({
+        active: g,
+        over: f
+      }));
+    },
+    onDragOver(u) {
+      let {
+        active: g,
+        over: f
+      } = u;
+      o(t.onDragOver({
+        active: g,
+        over: f
+      }));
+    },
+    onDragEnd(u) {
+      let {
+        active: g,
+        over: f
+      } = u;
+      o(t.onDragEnd({
+        active: g,
+        over: f
+      }));
+    },
+    onDragCancel(u) {
+      let {
+        active: g,
+        over: f
+      } = u;
+      o(t.onDragCancel({
+        active: g,
+        over: f
+      }));
+    }
+  }), [o, t])), !l)
+    return null;
+  const d = M.createElement(M.Fragment, null, M.createElement(On, {
+    id: r,
+    value: i.draggable
+  }), M.createElement(Nn, {
+    id: s,
+    announcement: a
+  }));
+  return n ? xn(d, n) : d;
+}
+var N;
+(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";
+})(N || (N = {}));
+function We() {
+}
+function eo(e, t) {
+  return A(
     () => ({
-      activeIndex: y,
-      containerId: p,
-      disabled: g,
-      disableTransforms: D,
-      items: u,
-      overIndex: b,
-      useDragOverlay: v,
-      sortedRects: xe(u, f),
-      strategy: i
+      sensor: e,
+      options: t ?? {}
     }),
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [y, p, g.draggable, g.droppable, D, u, b, f, v, i]
+    [e, t]
   );
-  return U.createElement(k.Provider, {
-    value: R
-  }, r);
 }
-const De = (e) => {
+function to() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return A(
+    () => [...t].filter((r) => r != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const H = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function Pn(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function zn(e, t) {
+  const n = $e(e);
+  if (!n)
+    return "0 0";
+  const r = {
+    x: (n.x - t.left) / t.width * 100,
+    y: (n.y - t.top) / t.height * 100
+  };
+  return r.x + "% " + r.y + "%";
+}
+function Bn(e, t) {
   let {
-    id: r,
-    items: t,
-    activeIndex: n,
-    overIndex: i
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return n - r;
+}
+function Fn(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return r - n;
+}
+function $n(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return t ? n[t] : n;
+}
+function Lt(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 no = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
   } = e;
-  return $(t, n, i).indexOf(r);
-}, Re = (e) => {
+  const i = Lt(t, t.left, t.top), o = [];
+  for (const a of r) {
+    const {
+      id: s
+    } = a, l = n.get(s);
+    if (l) {
+      const c = Pn(Lt(l), i);
+      o.push({
+        id: s,
+        data: {
+          droppableContainer: a,
+          value: c
+        }
+      });
+    }
+  }
+  return o.sort(Bn);
+};
+function Kn(e, t) {
+  const n = Math.max(t.top, e.top), r = Math.max(t.left, e.left), i = Math.min(t.left + t.width, e.left + e.width), o = Math.min(t.top + t.height, e.top + e.height), a = i - r, s = o - n;
+  if (r < i && n < o) {
+    const l = t.width * t.height, c = e.width * e.height, d = a * s, u = d / (l + c - d);
+    return Number(u.toFixed(4));
+  }
+  return 0;
+}
+const Xn = (e) => {
   let {
-    containerId: r,
-    isSorting: t,
-    wasDragging: n,
-    index: i,
-    items: c,
-    newIndex: o,
-    previousItems: a,
-    previousContainerId: f,
-    transition: l
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
   } = e;
-  return !l || !n || a !== c && i === o ? !1 : t ? !0 : o !== i && r === f;
-}, Ce = {
-  duration: 200,
-  easing: "ease"
-}, J = "transform", we = /* @__PURE__ */ Y.Transition.toString({
-  property: J,
-  duration: 0,
-  easing: "linear"
-}), Se = {
-  roleDescription: "sortable"
+  const i = [];
+  for (const o of r) {
+    const {
+      id: a
+    } = o, s = n.get(a);
+    if (s) {
+      const l = Kn(s, t);
+      l > 0 && i.push({
+        id: a,
+        data: {
+          droppableContainer: o,
+          value: l
+        }
+      });
+    }
+  }
+  return i.sort(Fn);
 };
-function Te(e) {
+function jn(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function Ht(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : H;
+}
+function Wn(e) {
+  return function(n) {
+    for (var r = arguments.length, i = new Array(r > 1 ? r - 1 : 0), o = 1; o < r; o++)
+      i[o - 1] = arguments[o];
+    return i.reduce((a, s) => ({
+      ...a,
+      top: a.top + e * s.y,
+      bottom: a.bottom + e * s.y,
+      left: a.left + e * s.x,
+      right: a.right + e * s.x
+    }), {
+      ...n
+    });
+  };
+}
+const Yn = /* @__PURE__ */ Wn(1);
+function _t(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 Un(e, t, n) {
+  const r = _t(t);
+  if (!r)
+    return e;
+  const {
+    scaleX: i,
+    scaleY: o,
+    x: a,
+    y: s
+  } = r, l = e.left - a - (1 - i) * parseFloat(n), c = e.top - s - (1 - o) * parseFloat(n.slice(n.indexOf(" ") + 1)), d = i ? e.width / i : e.width, u = o ? e.height / o : e.height;
+  return {
+    width: d,
+    height: u,
+    top: c,
+    right: l + d,
+    bottom: c + u,
+    left: l
+  };
+}
+const Hn = {
+  ignoreTransform: !1
+};
+function Te(e, t) {
+  t === void 0 && (t = Hn);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: c,
+      transformOrigin: d
+    } = J(e).getComputedStyle(e);
+    c && (n = Un(n, c, d));
+  }
+  const {
+    top: r,
+    left: i,
+    width: o,
+    height: a,
+    bottom: s,
+    right: l
+  } = n;
+  return {
+    top: r,
+    left: i,
+    width: o,
+    height: a,
+    bottom: s,
+    right: l
+  };
+}
+function kt(e) {
+  return Te(e, {
+    ignoreTransform: !0
+  });
+}
+function _n(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function qn(e, t) {
+  return t === void 0 && (t = J(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Jn(e, t) {
+  t === void 0 && (t = J(e).getComputedStyle(e));
+  const n = /(auto|scroll|overlay)/;
+  return ["overflow", "overflowX", "overflowY"].some((i) => {
+    const o = t[i];
+    return typeof o == "string" ? n.test(o) : !1;
+  });
+}
+function dt(e, t) {
+  const n = [];
+  function r(i) {
+    if (t != null && n.length >= t || !i)
+      return n;
+    if (Yt(i) && i.scrollingElement != null && !n.includes(i.scrollingElement))
+      return n.push(i.scrollingElement), n;
+    if (!He(i) || En(i) || n.includes(i))
+      return n;
+    const o = J(e).getComputedStyle(i);
+    return i !== e && Jn(i, o) && n.push(i), qn(i, o) ? n : r(i.parentNode);
+  }
+  return e ? r(e) : n;
+}
+function qt(e) {
+  const [t] = dt(e, 1);
+  return t ?? null;
+}
+function et(e) {
+  return !at || !e ? null : ut(e) ? e : Rn(e) ? Yt(e) || e === me(e).scrollingElement ? window : He(e) ? e : null : null;
+}
+function Jt(e) {
+  return ut(e) ? e.scrollX : e.scrollLeft;
+}
+function Vt(e) {
+  return ut(e) ? e.scrollY : e.scrollTop;
+}
+function ot(e) {
+  return {
+    x: Jt(e),
+    y: Vt(e)
+  };
+}
+var L;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(L || (L = {}));
+function Gt(e) {
+  return !at || !e ? !1 : e === document.scrollingElement;
+}
+function Qt(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = Gt(e) ? {
+    height: window.innerHeight,
+    width: window.innerWidth
+  } : {
+    height: e.clientHeight,
+    width: e.clientWidth
+  }, r = {
+    x: e.scrollWidth - n.width,
+    y: e.scrollHeight - n.height
+  }, i = e.scrollTop <= t.y, o = e.scrollLeft <= t.x, a = e.scrollTop >= r.y, s = e.scrollLeft >= r.x;
+  return {
+    isTop: i,
+    isLeft: o,
+    isBottom: a,
+    isRight: s,
+    maxScroll: r,
+    minScroll: t
+  };
+}
+const Vn = {
+  x: 0.2,
+  y: 0.2
+};
+function Gn(e, t, n, r, i) {
   let {
-    disabled: r,
-    index: t,
-    node: n,
-    rect: i
+    top: o,
+    left: a,
+    right: s,
+    bottom: l
+  } = n;
+  r === void 0 && (r = 10), i === void 0 && (i = Vn);
+  const {
+    isTop: c,
+    isBottom: d,
+    isLeft: u,
+    isRight: g
+  } = Qt(e), f = {
+    x: 0,
+    y: 0
+  }, x = {
+    x: 0,
+    y: 0
+  }, h = {
+    height: t.height * i.y,
+    width: t.width * i.x
+  };
+  return !c && o <= t.top + h.height ? (f.y = L.Backward, x.y = r * Math.abs((t.top + h.height - o) / h.height)) : !d && l >= t.bottom - h.height && (f.y = L.Forward, x.y = r * Math.abs((t.bottom - h.height - l) / h.height)), !g && s >= t.right - h.width ? (f.x = L.Forward, x.x = r * Math.abs((t.right - h.width - s) / h.width)) : !u && a <= t.left + h.width && (f.x = L.Backward, x.x = r * Math.abs((t.left + h.width - a) / h.width)), {
+    direction: f,
+    speed: x
+  };
+}
+function Qn(e) {
+  if (e === document.scrollingElement) {
+    const {
+      innerWidth: o,
+      innerHeight: a
+    } = window;
+    return {
+      top: 0,
+      left: 0,
+      right: o,
+      bottom: a,
+      width: o,
+      height: a
+    };
+  }
+  const {
+    top: t,
+    left: n,
+    right: r,
+    bottom: i
+  } = e.getBoundingClientRect();
+  return {
+    top: t,
+    left: n,
+    right: r,
+    bottom: i,
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+}
+function Zt(e) {
+  return e.reduce((t, n) => ye(t, ot(n)), H);
+}
+function Zn(e) {
+  return e.reduce((t, n) => t + Jt(n), 0);
+}
+function er(e) {
+  return e.reduce((t, n) => t + Vt(n), 0);
+}
+function en(e, t) {
+  if (t === void 0 && (t = Te), !e)
+    return;
+  const {
+    top: n,
+    left: r,
+    bottom: i,
+    right: o
+  } = t(e);
+  qt(e) && (i <= 0 || o <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const tr = [["x", ["left", "right"], Zn], ["y", ["top", "bottom"], er]];
+class ft {
+  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 = dt(n), i = Zt(r);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [o, a, s] of tr)
+      for (const l of a)
+        Object.defineProperty(this, l, {
+          get: () => {
+            const c = s(r), d = i[o] - c;
+            return this.rect[l] + d;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class Se {
+  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 i;
+    (i = this.target) == null || i.addEventListener(t, n, r), this.listeners.push([t, n, r]);
+  }
+}
+function nr(e) {
+  const {
+    EventTarget: t
+  } = J(e);
+  return e instanceof t ? e : me(e);
+}
+function tt(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 j;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(j || (j = {}));
+function It(e) {
+  e.preventDefault();
+}
+function rr(e) {
+  e.stopPropagation();
+}
+var D;
+(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";
+})(D || (D = {}));
+const tn = {
+  start: [D.Space, D.Enter],
+  cancel: [D.Esc],
+  end: [D.Space, D.Enter, D.Tab]
+}, or = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case D.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case D.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case D.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case D.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class nn {
+  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 Se(me(n)), this.windowListeners = new Se(J(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(j.Resize, this.handleCancel), this.windowListeners.add(j.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(j.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, r = t.node.current;
+    r && en(r), n(H);
+  }
+  handleKeyDown(t) {
+    if (lt(t)) {
+      const {
+        active: n,
+        context: r,
+        options: i
+      } = this.props, {
+        keyboardCodes: o = tn,
+        coordinateGetter: a = or,
+        scrollBehavior: s = "smooth"
+      } = i, {
+        code: l
+      } = t;
+      if (o.end.includes(l)) {
+        this.handleEnd(t);
+        return;
+      }
+      if (o.cancel.includes(l)) {
+        this.handleCancel(t);
+        return;
+      }
+      const {
+        collisionRect: c
+      } = r.current, d = c ? {
+        x: c.left,
+        y: c.top
+      } : H;
+      this.referenceCoordinates || (this.referenceCoordinates = d);
+      const u = a(t, {
+        active: n,
+        context: r.current,
+        currentCoordinates: d
+      });
+      if (u) {
+        const g = Xe(u, d), f = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: x
+        } = r.current;
+        for (const h of x) {
+          const v = t.code, {
+            isTop: y,
+            isRight: w,
+            isLeft: m,
+            isBottom: T,
+            maxScroll: C,
+            minScroll: S
+          } = Qt(h), p = Qn(h), b = {
+            x: Math.min(v === D.Right ? p.right - p.width / 2 : p.right, Math.max(v === D.Right ? p.left : p.left + p.width / 2, u.x)),
+            y: Math.min(v === D.Down ? p.bottom - p.height / 2 : p.bottom, Math.max(v === D.Down ? p.top : p.top + p.height / 2, u.y))
+          }, R = v === D.Right && !w || v === D.Left && !m, k = v === D.Down && !T || v === D.Up && !y;
+          if (R && b.x !== u.x) {
+            const E = h.scrollLeft + g.x, V = v === D.Right && E <= C.x || v === D.Left && E >= S.x;
+            if (V && !g.y) {
+              h.scrollTo({
+                left: E,
+                behavior: s
+              });
+              return;
+            }
+            V ? f.x = h.scrollLeft - E : f.x = v === D.Right ? h.scrollLeft - C.x : h.scrollLeft - S.x, f.x && h.scrollBy({
+              left: -f.x,
+              behavior: s
+            });
+            break;
+          } else if (k && b.y !== u.y) {
+            const E = h.scrollTop + g.y, V = v === D.Down && E <= C.y || v === D.Up && E >= S.y;
+            if (V && !g.x) {
+              h.scrollTo({
+                top: E,
+                behavior: s
+              });
+              return;
+            }
+            V ? f.y = h.scrollTop - E : f.y = v === D.Down ? h.scrollTop - C.y : h.scrollTop - S.y, f.y && h.scrollBy({
+              top: -f.y,
+              behavior: s
+            });
+            break;
+          }
+        }
+        this.handleMove(t, ye(Xe(u, this.referenceCoordinates), f));
+      }
+    }
+  }
+  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();
+  }
+}
+nn.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: r = tn,
+      onActivation: i
+    } = t, {
+      active: o
+    } = n;
+    const {
+      code: a
+    } = e.nativeEvent;
+    if (r.start.includes(a)) {
+      const s = o.activatorNode.current;
+      return s && e.target !== s ? !1 : (e.preventDefault(), i == null || i({
+        event: e.nativeEvent
+      }), !0);
+    }
+    return !1;
+  }
+}];
+function Pt(e) {
+  return !!(e && "distance" in e);
+}
+function zt(e) {
+  return !!(e && "delay" in e);
+}
+class ht {
+  constructor(t, n, r) {
+    var i;
+    r === void 0 && (r = nr(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: o
+    } = t, {
+      target: a
+    } = o;
+    this.props = t, this.events = n, this.document = me(a), this.documentListeners = new Se(this.document), this.listeners = new Se(r), this.windowListeners = new Se(J(a)), this.initialCoordinates = (i = $e(o)) != null ? i : H, 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(j.Resize, this.handleCancel), this.windowListeners.add(j.DragStart, It), this.windowListeners.add(j.VisibilityChange, this.handleCancel), this.windowListeners.add(j.ContextMenu, It), this.documentListeners.add(j.Keydown, this.handleKeydown), n) {
+      if (r != null && r({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (zt(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay), this.handlePending(n);
+        return;
+      }
+      if (Pt(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: i
+    } = this.props;
+    i(r, t, this.initialCoordinates, n);
+  }
+  handleStart() {
+    const {
+      initialCoordinates: t
+    } = this, {
+      onStart: n
+    } = this.props;
+    t && (this.activated = !0, this.documentListeners.add(j.Click, rr, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(j.SelectionChange, this.removeTextSelection), n(t));
+  }
+  handleMove(t) {
+    var n;
+    const {
+      activated: r,
+      initialCoordinates: i,
+      props: o
+    } = this, {
+      onMove: a,
+      options: {
+        activationConstraint: s
+      }
+    } = o;
+    if (!i)
+      return;
+    const l = (n = $e(t)) != null ? n : H, c = Xe(i, l);
+    if (!r && s) {
+      if (Pt(s)) {
+        if (s.tolerance != null && tt(c, s.tolerance))
+          return this.handleCancel();
+        if (tt(c, s.distance))
+          return this.handleStart();
+      }
+      if (zt(s) && tt(c, s.tolerance))
+        return this.handleCancel();
+      this.handlePending(s, c);
+      return;
+    }
+    t.cancelable && t.preventDefault(), a(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 === D.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const ir = {
+  cancel: {
+    name: "pointercancel"
+  },
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class rn extends ht {
+  constructor(t) {
+    const {
+      event: n
+    } = t, r = me(n.target);
+    super(t, ir, r);
+  }
+}
+rn.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 sr = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var it;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(it || (it = {}));
+class ar extends ht {
+  constructor(t) {
+    super(t, sr, me(t.event.target));
+  }
+}
+ar.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return n.button === it.RightClick ? !1 : (r == null || r({
+      event: n
+    }), !0);
+  }
+}];
+const nt = {
+  cancel: {
+    name: "touchcancel"
+  },
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class lr extends ht {
+  constructor(t) {
+    super(t, nt);
+  }
+  static setup() {
+    return window.addEventListener(nt.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(nt.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+lr.activators = [{
+  eventName: "onTouchStart",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    const {
+      touches: i
+    } = n;
+    return i.length > 1 ? !1 : (r == null || r({
+      event: n
+    }), !0);
+  }
+}];
+var Re;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(Re || (Re = {}));
+var Ye;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(Ye || (Ye = {}));
+function cr(e) {
+  let {
+    acceleration: t,
+    activator: n = Re.Pointer,
+    canScroll: r,
+    draggingRect: i,
+    enabled: o,
+    interval: a = 5,
+    order: s = Ye.TreeOrder,
+    pointerCoordinates: l,
+    scrollableAncestors: c,
+    scrollableAncestorRects: d,
+    delta: u,
+    threshold: g
   } = e;
-  const [c, o] = ue(null), a = z(t);
-  return V(() => {
-    if (!r && t !== a.current && n.current) {
-      const f = i.current;
-      if (f) {
-        const l = be(n.current, {
-          ignoreTransform: !0
-        }), s = {
-          x: f.left - l.left,
-          y: f.top - l.top,
-          scaleX: f.width / l.width,
-          scaleY: f.height / l.height
-        };
-        (s.x || s.y) && o(s);
+  const f = dr({
+    delta: u,
+    disabled: !o
+  }), [x, h] = Cn(), v = P({
+    x: 0,
+    y: 0
+  }), y = P({
+    x: 0,
+    y: 0
+  }), w = A(() => {
+    switch (n) {
+      case Re.Pointer:
+        return l ? {
+          top: l.y,
+          bottom: l.y,
+          left: l.x,
+          right: l.x
+        } : null;
+      case Re.DraggableRect:
+        return i;
+    }
+  }, [n, i, l]), m = P(null), T = U(() => {
+    const S = m.current;
+    if (!S)
+      return;
+    const p = v.current.x * y.current.x, b = v.current.y * y.current.y;
+    S.scrollBy(p, b);
+  }, []), C = A(() => s === Ye.TreeOrder ? [...c].reverse() : c, [s, c]);
+  O(
+    () => {
+      if (!o || !c.length || !w) {
+        h();
+        return;
+      }
+      for (const S of C) {
+        if ((r == null ? void 0 : r(S)) === !1)
+          continue;
+        const p = c.indexOf(S), b = d[p];
+        if (!b)
+          continue;
+        const {
+          direction: R,
+          speed: k
+        } = Gn(S, b, w, t, g);
+        for (const E of ["x", "y"])
+          f[E][R[E]] || (k[E] = 0, R[E] = 0);
+        if (k.x > 0 || k.y > 0) {
+          h(), m.current = S, x(T, a), v.current = k, y.current = R;
+          return;
+        }
       }
+      v.current = {
+        x: 0,
+        y: 0
+      }, y.current = {
+        x: 0,
+        y: 0
+      }, h();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      T,
+      r,
+      h,
+      o,
+      a,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(w),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(f),
+      x,
+      c,
+      C,
+      d,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(g)
+    ]
+  );
+}
+const ur = {
+  x: {
+    [L.Backward]: !1,
+    [L.Forward]: !1
+  },
+  y: {
+    [L.Backward]: !1,
+    [L.Forward]: !1
+  }
+};
+function dr(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const r = Ke(t);
+  return Me((i) => {
+    if (n || !r || !i)
+      return ur;
+    const o = {
+      x: Math.sign(t.x - r.x),
+      y: Math.sign(t.y - r.y)
+    };
+    return {
+      x: {
+        [L.Backward]: i.x[L.Backward] || o.x === -1,
+        [L.Forward]: i.x[L.Forward] || o.x === 1
+      },
+      y: {
+        [L.Backward]: i.y[L.Backward] || o.y === -1,
+        [L.Forward]: i.y[L.Forward] || o.y === 1
+      }
+    };
+  }, [n, t, r]);
+}
+function fr(e, t) {
+  const n = t != null ? e.get(t) : void 0, r = n ? n.node.current : null;
+  return Me((i) => {
+    var o;
+    return t == null ? null : (o = r ?? i) != null ? o : null;
+  }, [r, t]);
+}
+function hr(e, t) {
+  return A(() => e.reduce((n, r) => {
+    const {
+      sensor: i
+    } = r, o = i.activators.map((a) => ({
+      eventName: a.eventName,
+      handler: t(a.handler, r)
+    }));
+    return [...n, ...o];
+  }, []), [e, t]);
+}
+var Oe;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Oe || (Oe = {}));
+var st;
+(function(e) {
+  e.Optimized = "optimized";
+})(st || (st = {}));
+const Bt = /* @__PURE__ */ new Map();
+function gr(e, t) {
+  let {
+    dragging: n,
+    dependencies: r,
+    config: i
+  } = t;
+  const [o, a] = K(null), {
+    frequency: s,
+    measure: l,
+    strategy: c
+  } = i, d = P(e), u = v(), g = Ae(u), f = U(function(y) {
+    y === void 0 && (y = []), !g.current && a((w) => w === null ? y : w.concat(y.filter((m) => !w.includes(m))));
+  }, [g]), x = P(null), h = Me((y) => {
+    if (u && !n)
+      return Bt;
+    if (!y || y === Bt || d.current !== e || o != null) {
+      const w = /* @__PURE__ */ new Map();
+      for (let m of e) {
+        if (!m)
+          continue;
+        if (o && o.length > 0 && !o.includes(m.id) && m.rect.current) {
+          w.set(m.id, m.rect.current);
+          continue;
+        }
+        const T = m.node.current, C = T ? new ft(l(T), T) : null;
+        m.rect.current = C, C && w.set(m.id, C);
+      }
+      return w;
     }
-    t !== a.current && (a.current = t);
-  }, [r, t, n, i]), E(() => {
-    c && o(null);
-  }, [c]), c;
+    return y;
+  }, [e, o, n, u, l]);
+  return O(() => {
+    d.current = e;
+  }, [e]), O(
+    () => {
+      u || f();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, u]
+  ), O(
+    () => {
+      o && o.length > 0 && a(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(o)]
+  ), O(
+    () => {
+      u || typeof s != "number" || x.current !== null || (x.current = setTimeout(() => {
+        f(), x.current = null;
+      }, s));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [s, u, f, ...r]
+  ), {
+    droppableRects: h,
+    measureDroppableContainers: f,
+    measuringScheduled: o != null
+  };
+  function v() {
+    switch (c) {
+      case Oe.Always:
+        return !1;
+      case Oe.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function gt(e, t) {
+  return Me((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function vr(e, t) {
+  return gt(e, t);
 }
-function ze(e) {
+function pr(e) {
   let {
-    animateLayoutChanges: r = Re,
-    attributes: t,
-    disabled: n,
-    data: i,
-    getNewIndex: c = De,
-    id: o,
-    strategy: a,
-    resizeObserverConfig: f,
-    transition: l = Ce
+    callback: t,
+    disabled: n
   } = e;
-  const {
-    items: s,
-    containerId: p,
-    activeIndex: v,
-    disabled: u,
-    disableTransforms: S,
-    sortedRects: y,
-    overIndex: b,
-    useDragOverlay: T,
-    strategy: h
-  } = le(k), D = Oe(n, u), g = s.indexOf(o), R = A(() => ({
-    sortable: {
-      containerId: p,
-      index: g,
-      items: s
+  const r = ct(t), i = A(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: o
+    } = window;
+    return new o(r);
+  }, [r, n]);
+  return O(() => () => i == null ? void 0 : i.disconnect(), [i]), i;
+}
+function _e(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = ct(t), i = A(
+    () => {
+      if (n || typeof window > "u" || typeof window.ResizeObserver > "u")
+        return;
+      const {
+        ResizeObserver: o
+      } = window;
+      return new o(r);
     },
-    ...i
-  }), [p, i, g, s]), m = A(() => s.slice(s.indexOf(o)), [s, o]), {
-    rect: P,
-    node: M,
-    isOver: Q,
-    setNodeRef: X
-  } = ge({
-    id: o,
-    data: R,
-    disabled: D.droppable,
-    resizeObserverConfig: {
-      updateMeasurementsFor: m,
-      ...f
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n]
+  );
+  return O(() => () => i == null ? void 0 : i.disconnect(), [i]), i;
+}
+function br(e) {
+  return new ft(Te(e), e);
+}
+function Ft(e, t, n) {
+  t === void 0 && (t = br);
+  const [r, i] = K(null);
+  function o() {
+    i((l) => {
+      if (!e)
+        return null;
+      if (e.isConnected === !1) {
+        var c;
+        return (c = l ?? n) != null ? c : null;
+      }
+      const d = t(e);
+      return JSON.stringify(l) === JSON.stringify(d) ? l : d;
+    });
+  }
+  const a = pr({
+    callback(l) {
+      if (e)
+        for (const c of l) {
+          const {
+            type: d,
+            target: u
+          } = c;
+          if (d === "childList" && u instanceof HTMLElement && u.contains(e)) {
+            o();
+            break;
+          }
+        }
     }
-  }), {
-    active: C,
-    activatorEvent: W,
-    activeNodeRect: Z,
-    attributes: ee,
-    setNodeRef: q,
-    listeners: te,
-    isDragging: L,
-    over: re,
-    setActivatorNodeRef: ne,
-    transform: oe
-  } = pe({
-    id: o,
-    data: R,
-    attributes: {
-      ...Se,
-      ...t
+  }), s = _e({
+    callback: o
+  });
+  return fe(() => {
+    o(), e ? (s == null || s.observe(e), a == null || a.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (s == null || s.disconnect(), a == null || a.disconnect());
+  }, [e]), r;
+}
+function yr(e) {
+  const t = gt(e);
+  return Ht(e, t);
+}
+const $t = [];
+function mr(e) {
+  const t = P(e), n = Me((r) => e ? r && r !== $t && e && t.current && e.parentNode === t.current.parentNode ? r : dt(e) : $t, [e]);
+  return O(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function wr(e) {
+  const [t, n] = K(null), r = P(e), i = U((o) => {
+    const a = et(o.target);
+    a && n((s) => s ? (s.set(a, ot(a)), new Map(s)) : null);
+  }, []);
+  return O(() => {
+    const o = r.current;
+    if (e !== o) {
+      a(o);
+      const s = e.map((l) => {
+        const c = et(l);
+        return c ? (c.addEventListener("scroll", i, {
+          passive: !0
+        }), [c, ot(c)]) : null;
+      }).filter((l) => l != null);
+      n(s.length ? new Map(s) : null), r.current = e;
+    }
+    return () => {
+      a(e), a(o);
+    };
+    function a(s) {
+      s.forEach((l) => {
+        const c = et(l);
+        c == null || c.removeEventListener("scroll", i);
+      });
+    }
+  }, [i, e]), A(() => e.length ? t ? Array.from(t.values()).reduce((o, a) => ye(o, a), H) : Zt(e) : H, [e, t]);
+}
+function Kt(e, t) {
+  t === void 0 && (t = []);
+  const n = P(null);
+  return O(
+    () => {
+      n.current = null;
     },
-    disabled: D.draggable
-  }), se = me(X, q), I = !!C, B = I && !S && N(v) && N(b), F = !T && L, H = F && B ? oe : null, ie = B ? H ?? (a ?? h)({
-    rects: y,
-    activeNodeRect: Z,
-    activeIndex: v,
-    overIndex: b,
-    index: g
-  }) : null, w = N(v) && N(b) ? c({
-    id: o,
-    items: s,
-    activeIndex: v,
-    overIndex: b
-  }) : g, x = C == null ? void 0 : C.id, d = z({
-    activeId: x,
-    items: s,
-    newIndex: w,
-    containerId: p
-  }), ae = s !== d.current.items, K = r({
-    active: C,
-    containerId: p,
-    isDragging: L,
-    isSorting: I,
-    id: o,
-    index: g,
-    items: s,
-    newIndex: d.current.newIndex,
-    previousItems: d.current.items,
-    previousContainerId: d.current.containerId,
-    transition: l,
-    wasDragging: d.current.activeId != null
-  }), _ = Te({
-    disabled: !K,
-    index: g,
-    node: M,
-    rect: P
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), O(() => {
+    const r = e !== H;
+    r && !n.current && (n.current = e), !r && n.current && (n.current = null);
+  }, [e]), n.current ? Xe(e, n.current) : H;
+}
+function Dr(e) {
+  O(
+    () => {
+      if (!at)
+        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 xr(e, t) {
+  return A(() => e.reduce((n, r) => {
+    let {
+      eventName: i,
+      handler: o
+    } = r;
+    return n[i] = (a) => {
+      o(a, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function on(e) {
+  return A(() => e ? _n(e) : null, [e]);
+}
+const Xt = [];
+function Cr(e, t) {
+  t === void 0 && (t = Te);
+  const [n] = e, r = on(n ? J(n) : null), [i, o] = K(Xt);
+  function a() {
+    o(() => e.length ? e.map((l) => Gt(l) ? r : new ft(t(l), l)) : Xt);
+  }
+  const s = _e({
+    callback: a
   });
-  return E(() => {
-    I && d.current.newIndex !== w && (d.current.newIndex = w), p !== d.current.containerId && (d.current.containerId = p), s !== d.current.items && (d.current.items = s);
-  }, [I, w, p, s]), E(() => {
-    if (x === d.current.activeId)
+  return fe(() => {
+    s == null || s.disconnect(), a(), e.forEach((l) => s == null ? void 0 : s.observe(l));
+  }, [e]), i;
+}
+function sn(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return He(t) ? t : e;
+}
+function Sr(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, r] = K(null), i = U((c) => {
+    for (const {
+      target: d
+    } of c)
+      if (He(d)) {
+        r((u) => {
+          const g = t(d);
+          return u ? {
+            ...u,
+            width: g.width,
+            height: g.height
+          } : g;
+        });
+        break;
+      }
+  }, [t]), o = _e({
+    callback: i
+  }), a = U((c) => {
+    const d = sn(c);
+    o == null || o.disconnect(), d && (o == null || o.observe(d)), r(d ? t(d) : null);
+  }, [t, o]), [s, l] = je(a);
+  return A(() => ({
+    nodeRef: s,
+    rect: n,
+    setRef: l
+  }), [n, s, l]);
+}
+const Rr = [{
+  sensor: rn,
+  options: {}
+}, {
+  sensor: nn,
+  options: {}
+}], Er = {
+  current: {}
+}, Fe = {
+  draggable: {
+    measure: kt
+  },
+  droppable: {
+    measure: kt,
+    strategy: Oe.WhileDragging,
+    frequency: st.Optimized
+  },
+  dragOverlay: {
+    measure: Te
+  }
+};
+class Ee 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 Ar = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new Ee(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: We
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: Fe,
+  measureDroppableContainers: We,
+  windowRect: null,
+  measuringScheduled: !1
+}, an = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: We,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: We
+}, Le = /* @__PURE__ */ Ne(an), ln = /* @__PURE__ */ Ne(Ar);
+function Or() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new Ee()
+    }
+  };
+}
+function Nr(e, t) {
+  switch (t.type) {
+    case N.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case N.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 N.DragEnd:
+    case N.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case N.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: r
+      } = n, i = new Ee(e.droppable.containers);
+      return i.set(r, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    case N.SetDroppableDisabled: {
+      const {
+        id: n,
+        key: r,
+        disabled: i
+      } = t, o = e.droppable.containers.get(n);
+      if (!o || r !== o.key)
+        return e;
+      const a = new Ee(e.droppable.containers);
+      return a.set(n, {
+        ...o,
+        disabled: i
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: a
+        }
+      };
+    }
+    case N.UnregisterDroppable: {
+      const {
+        id: n,
+        key: r
+      } = t, i = e.droppable.containers.get(n);
+      if (!i || r !== i.key)
+        return e;
+      const o = new Ee(e.droppable.containers);
+      return o.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: o
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function Mr(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: r,
+    draggableNodes: i
+  } = de(Le), o = Ke(r), a = Ke(n == null ? void 0 : n.id);
+  return O(() => {
+    if (!t && !r && o && a != null) {
+      if (!lt(o) || document.activeElement === o.target)
+        return;
+      const s = i.get(a);
+      if (!s)
+        return;
+      const {
+        activatorNode: l,
+        node: c
+      } = s;
+      if (!l.current && !c.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const d of [l.current, c.current]) {
+          if (!d)
+            continue;
+          const u = Sn(d);
+          if (u) {
+            u.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [r, t, i, a, o]), null;
+}
+function cn(e, t) {
+  let {
+    transform: n,
+    ...r
+  } = t;
+  return e != null && e.length ? e.reduce((i, o) => o({
+    transform: i,
+    ...r
+  }), n) : n;
+}
+function Tr(e) {
+  return A(
+    () => ({
+      draggable: {
+        ...Fe.draggable,
+        ...e == null ? void 0 : e.draggable
+      },
+      droppable: {
+        ...Fe.droppable,
+        ...e == null ? void 0 : e.droppable
+      },
+      dragOverlay: {
+        ...Fe.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 Lr(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: r,
+    config: i = !0
+  } = e;
+  const o = P(!1), {
+    x: a,
+    y: s
+  } = typeof i == "boolean" ? {
+    x: i,
+    y: i
+  } : i;
+  fe(() => {
+    if (!a && !s || !t) {
+      o.current = !1;
+      return;
+    }
+    if (o.current || !r)
       return;
-    if (x != null && d.current.activeId == null) {
-      d.current.activeId = x;
+    const c = t == null ? void 0 : t.node.current;
+    if (!c || c.isConnected === !1)
       return;
+    const d = n(c), u = Ht(d, r);
+    if (a || (u.x = 0), s || (u.y = 0), o.current = !0, Math.abs(u.x) > 0 || Math.abs(u.y) > 0) {
+      const g = qt(c);
+      g && g.scrollBy({
+        top: u.y,
+        left: u.x
+      });
     }
-    const ce = setTimeout(() => {
-      d.current.activeId = x;
-    }, 50);
-    return () => clearTimeout(ce);
-  }, [x]), {
-    active: C,
-    activeIndex: v,
-    attributes: ee,
-    data: R,
-    rect: P,
-    index: g,
-    newIndex: w,
-    items: s,
-    isOver: Q,
-    isSorting: I,
-    isDragging: L,
-    listeners: te,
-    node: M,
-    overIndex: b,
-    over: re,
-    setNodeRef: se,
-    setActivatorNodeRef: ne,
-    setDroppableNodeRef: X,
-    setDraggableNodeRef: q,
-    transform: _ ?? ie,
-    transition: de()
-  };
-  function de() {
+  }, [t, a, s, r, n]);
+}
+const qe = /* @__PURE__ */ Ne({
+  ...H,
+  scaleX: 1,
+  scaleY: 1
+});
+var se;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(se || (se = {}));
+const ro = /* @__PURE__ */ yn(function(t) {
+  var n, r, i, o;
+  let {
+    id: a,
+    accessibility: s,
+    autoScroll: l = !0,
+    children: c,
+    sensors: d = Rr,
+    collisionDetection: u = Xn,
+    measuring: g,
+    modifiers: f,
+    ...x
+  } = t;
+  const h = mn(Nr, void 0, Or), [v, y] = h, [w, m] = Tn(), [T, C] = K(se.Uninitialized), S = T === se.Initialized, {
+    draggable: {
+      active: p,
+      nodes: b,
+      translate: R
+    },
+    droppable: {
+      containers: k
+    }
+  } = v, E = p != null ? b.get(p) : null, V = P({
+    initial: null,
+    translated: null
+  }), G = A(() => {
+    var z;
+    return p != null ? {
+      id: p,
+      // It's possible for the active node to unmount while dragging
+      data: (z = E == null ? void 0 : E.data) != null ? z : Er,
+      rect: V
+    } : null;
+  }, [p, E]), ee = P(null), [vt, pt] = K(null), [Q, bt] = K(null), ae = Ae(x, Object.values(x)), Je = Ue("DndDescribedBy", a), yt = A(() => k.getEnabled(), [k]), le = Tr(g), {
+    droppableRects: he,
+    measureDroppableContainers: ke,
+    measuringScheduled: mt
+  } = gr(yt, {
+    dragging: S,
+    dependencies: [R.x, R.y],
+    config: le.droppable
+  }), W = fr(b, p), wt = A(() => Q ? $e(Q) : null, [Q]), Dt = bn(), xt = vr(W, le.draggable.measure);
+  Lr({
+    activeNode: p != null ? b.get(p) : null,
+    config: Dt.layoutShiftCompensation,
+    initialRect: xt,
+    measure: le.draggable.measure
+  });
+  const Y = Ft(W, le.draggable.measure, xt), Ve = Ft(W ? W.parentElement : null), ce = P({
+    activatorEvent: null,
+    active: null,
+    activeNode: W,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: he,
+    draggableNodes: b,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: k,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), Ct = k.getNodeFor((n = ce.current.over) == null ? void 0 : n.id), ue = Sr({
+    measure: le.dragOverlay.measure
+  }), Ie = (r = ue.nodeRef.current) != null ? r : W, ge = S ? (i = ue.rect) != null ? i : Y : null, St = !!(ue.nodeRef.current && ue.rect), Rt = yr(St ? null : Y), Ge = on(Ie ? J(Ie) : null), te = mr(S ? Ct ?? W : null), Pe = Cr(te), ze = cn(f, {
+    transform: {
+      x: R.x - Rt.x,
+      y: R.y - Rt.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: Q,
+    active: G,
+    activeNodeRect: Y,
+    containerNodeRect: Ve,
+    draggingNodeRect: ge,
+    over: ce.current.over,
+    overlayNodeRect: ue.rect,
+    scrollableAncestors: te,
+    scrollableAncestorRects: Pe,
+    windowRect: Ge
+  }), Et = wt ? ye(wt, R) : null, At = wr(te), un = Kt(At), dn = Kt(At, [Y]), ve = ye(ze, un), pe = ge ? Yn(ge, ze) : null, we = G && pe ? u({
+    active: G,
+    collisionRect: pe,
+    droppableRects: he,
+    droppableContainers: yt,
+    pointerCoordinates: Et
+  }) : null, Ot = $n(we, "id"), [ne, Nt] = K(null), fn = St ? ze : ye(ze, dn), hn = jn(fn, (o = ne == null ? void 0 : ne.rect) != null ? o : null, Y), Qe = P(null), Mt = U(
+    (z, B) => {
+      let {
+        sensor: F,
+        options: re
+      } = B;
+      if (ee.current == null)
+        return;
+      const X = b.get(ee.current);
+      if (!X)
+        return;
+      const $ = z.nativeEvent, _ = new F({
+        active: ee.current,
+        activeNode: X,
+        event: $,
+        options: re,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: ce,
+        onAbort(I) {
+          if (!b.get(I))
+            return;
+          const {
+            onDragAbort: q
+          } = ae.current, Z = {
+            id: I
+          };
+          q == null || q(Z), w({
+            type: "onDragAbort",
+            event: Z
+          });
+        },
+        onPending(I, oe, q, Z) {
+          if (!b.get(I))
+            return;
+          const {
+            onDragPending: xe
+          } = ae.current, ie = {
+            id: I,
+            constraint: oe,
+            initialCoordinates: q,
+            offset: Z
+          };
+          xe == null || xe(ie), w({
+            type: "onDragPending",
+            event: ie
+          });
+        },
+        onStart(I) {
+          const oe = ee.current;
+          if (oe == null)
+            return;
+          const q = b.get(oe);
+          if (!q)
+            return;
+          const {
+            onDragStart: Z
+          } = ae.current, De = {
+            activatorEvent: $,
+            active: {
+              id: oe,
+              data: q.data,
+              rect: V
+            }
+          };
+          Be(() => {
+            Z == null || Z(De), C(se.Initializing), y({
+              type: N.DragStart,
+              initialCoordinates: I,
+              active: oe
+            }), w({
+              type: "onDragStart",
+              event: De
+            }), pt(Qe.current), bt($);
+          });
+        },
+        onMove(I) {
+          y({
+            type: N.DragMove,
+            coordinates: I
+          });
+        },
+        onEnd: be(N.DragEnd),
+        onCancel: be(N.DragCancel)
+      });
+      Qe.current = _;
+      function be(I) {
+        return async function() {
+          const {
+            active: q,
+            collisions: Z,
+            over: De,
+            scrollAdjustedTranslate: xe
+          } = ce.current;
+          let ie = null;
+          if (q && xe) {
+            const {
+              cancelDrop: Ce
+            } = ae.current;
+            ie = {
+              activatorEvent: $,
+              active: q,
+              collisions: Z,
+              delta: xe,
+              over: De
+            }, I === N.DragEnd && typeof Ce == "function" && await Promise.resolve(Ce(ie)) && (I = N.DragCancel);
+          }
+          ee.current = null, Be(() => {
+            y({
+              type: I
+            }), C(se.Uninitialized), Nt(null), pt(null), bt(null), Qe.current = null;
+            const Ce = I === N.DragEnd ? "onDragEnd" : "onDragCancel";
+            if (ie) {
+              const Ze = ae.current[Ce];
+              Ze == null || Ze(ie), w({
+                type: Ce,
+                event: ie
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [b]
+  ), gn = U((z, B) => (F, re) => {
+    const X = F.nativeEvent, $ = b.get(re);
     if (
-      // Temporarily disable transitions for a single frame to set up derived transforms
-      _ || // Or to prevent items jumping to back to their "new" position when items change
-      ae && d.current.newIndex === g
+      // Another sensor is already instantiating
+      ee.current !== null || // No active draggable
+      !$ || // Event has already been captured
+      X.dndKit || X.defaultPrevented
     )
-      return we;
-    if (!(F && !Ie(W) || !l) && (I || K))
-      return Y.Transition.toString({
-        ...l,
-        property: J
+      return;
+    const _ = {
+      active: $
+    };
+    z(F, B.options, _) === !0 && (X.dndKit = {
+      capturedBy: B.sensor
+    }, ee.current = re, Mt(F, B));
+  }, [b, Mt]), Tt = hr(d, gn);
+  Dr(d), fe(() => {
+    Y && T === se.Initializing && C(se.Initialized);
+  }, [Y, T]), O(
+    () => {
+      const {
+        onDragMove: z
+      } = ae.current, {
+        active: B,
+        activatorEvent: F,
+        collisions: re,
+        over: X
+      } = ce.current;
+      if (!B || !F)
+        return;
+      const $ = {
+        active: B,
+        activatorEvent: F,
+        collisions: re,
+        delta: {
+          x: ve.x,
+          y: ve.y
+        },
+        over: X
+      };
+      Be(() => {
+        z == null || z($), w({
+          type: "onDragMove",
+          event: $
+        });
       });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [ve.x, ve.y]
+  ), O(
+    () => {
+      const {
+        active: z,
+        activatorEvent: B,
+        collisions: F,
+        droppableContainers: re,
+        scrollAdjustedTranslate: X
+      } = ce.current;
+      if (!z || ee.current == null || !B || !X)
+        return;
+      const {
+        onDragOver: $
+      } = ae.current, _ = re.get(Ot), be = _ && _.rect.current ? {
+        id: _.id,
+        rect: _.rect.current,
+        data: _.data,
+        disabled: _.disabled
+      } : null, I = {
+        active: z,
+        activatorEvent: B,
+        collisions: F,
+        delta: {
+          x: X.x,
+          y: X.y
+        },
+        over: be
+      };
+      Be(() => {
+        Nt(be), $ == null || $(I), w({
+          type: "onDragOver",
+          event: I
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [Ot]
+  ), fe(() => {
+    ce.current = {
+      activatorEvent: Q,
+      active: G,
+      activeNode: W,
+      collisionRect: pe,
+      collisions: we,
+      droppableRects: he,
+      draggableNodes: b,
+      draggingNode: Ie,
+      draggingNodeRect: ge,
+      droppableContainers: k,
+      over: ne,
+      scrollableAncestors: te,
+      scrollAdjustedTranslate: ve
+    }, V.current = {
+      initial: ge,
+      translated: pe
+    };
+  }, [G, W, we, pe, b, Ie, ge, he, k, ne, te, ve]), cr({
+    ...Dt,
+    delta: R,
+    draggingRect: pe,
+    pointerCoordinates: Et,
+    scrollableAncestors: te,
+    scrollableAncestorRects: Pe
+  });
+  const vn = A(() => ({
+    active: G,
+    activeNode: W,
+    activeNodeRect: Y,
+    activatorEvent: Q,
+    collisions: we,
+    containerNodeRect: Ve,
+    dragOverlay: ue,
+    draggableNodes: b,
+    droppableContainers: k,
+    droppableRects: he,
+    over: ne,
+    measureDroppableContainers: ke,
+    scrollableAncestors: te,
+    scrollableAncestorRects: Pe,
+    measuringConfiguration: le,
+    measuringScheduled: mt,
+    windowRect: Ge
+  }), [G, W, Y, Q, we, Ve, ue, b, k, he, ne, ke, te, Pe, le, mt, Ge]), pn = A(() => ({
+    activatorEvent: Q,
+    activators: Tt,
+    active: G,
+    activeNodeRect: Y,
+    ariaDescribedById: {
+      draggable: Je
+    },
+    dispatch: y,
+    draggableNodes: b,
+    over: ne,
+    measureDroppableContainers: ke
+  }), [Q, Tt, G, Y, y, Je, b, ne, ke]);
+  return M.createElement(Ut.Provider, {
+    value: m
+  }, M.createElement(Le.Provider, {
+    value: pn
+  }, M.createElement(ln.Provider, {
+    value: vn
+  }, M.createElement(qe.Provider, {
+    value: hn
+  }, c)), M.createElement(Mr, {
+    disabled: (s == null ? void 0 : s.restoreFocus) === !1
+  })), M.createElement(In, {
+    ...s,
+    hiddenTextDescribedById: Je
+  }));
+  function bn() {
+    const z = (vt == null ? void 0 : vt.autoScrollEnabled) === !1, B = typeof l == "object" ? l.enabled === !1 : l === !1, F = S && !z && !B;
+    return typeof l == "object" ? {
+      ...l,
+      enabled: F
+    } : {
+      enabled: F
+    };
   }
+}), kr = /* @__PURE__ */ Ne(null), jt = "button", Ir = "Draggable";
+function oo(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: r = !1,
+    attributes: i
+  } = e;
+  const o = Ue(Ir), {
+    activators: a,
+    activatorEvent: s,
+    active: l,
+    activeNodeRect: c,
+    ariaDescribedById: d,
+    draggableNodes: u,
+    over: g
+  } = de(Le), {
+    role: f = jt,
+    roleDescription: x = "draggable",
+    tabIndex: h = 0
+  } = i ?? {}, v = (l == null ? void 0 : l.id) === t, y = de(v ? qe : kr), [w, m] = je(), [T, C] = je(), S = xr(a, t), p = Ae(n);
+  fe(
+    () => (u.set(t, {
+      id: t,
+      key: o,
+      node: w,
+      activatorNode: T,
+      data: p
+    }), () => {
+      const R = u.get(t);
+      R && R.key === o && u.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [u, t]
+  );
+  const b = A(() => ({
+    role: f,
+    tabIndex: h,
+    "aria-disabled": r,
+    "aria-pressed": v && f === jt ? !0 : void 0,
+    "aria-roledescription": x,
+    "aria-describedby": d.draggable
+  }), [r, f, h, v, x, d.draggable]);
+  return {
+    active: l,
+    activatorEvent: s,
+    activeNodeRect: c,
+    attributes: b,
+    isDragging: v,
+    listeners: r ? void 0 : S,
+    node: w,
+    over: g,
+    setNodeRef: m,
+    setActivatorNodeRef: C,
+    transform: y
+  };
 }
-function Oe(e, r) {
-  var t, n;
-  return typeof e == "boolean" ? {
-    draggable: e,
-    // Backwards compatibility
-    droppable: !1
-  } : {
-    draggable: (t = e == null ? void 0 : e.draggable) != null ? t : r.draggable,
-    droppable: (n = e == null ? void 0 : e.droppable) != null ? n : r.droppable
+function Pr() {
+  return de(ln);
+}
+const zr = "Droppable", Br = {
+  timeout: 25
+};
+function io(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: r,
+    resizeObserverConfig: i
+  } = e;
+  const o = Ue(zr), {
+    active: a,
+    dispatch: s,
+    over: l,
+    measureDroppableContainers: c
+  } = de(Le), d = P({
+    disabled: n
+  }), u = P(!1), g = P(null), f = P(null), {
+    disabled: x,
+    updateMeasurementsFor: h,
+    timeout: v
+  } = {
+    ...Br,
+    ...i
+  }, y = Ae(h ?? r), w = U(
+    () => {
+      if (!u.current) {
+        u.current = !0;
+        return;
+      }
+      f.current != null && clearTimeout(f.current), f.current = setTimeout(() => {
+        c(Array.isArray(y.current) ? y.current : [y.current]), f.current = null;
+      }, v);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [v]
+  ), m = _e({
+    callback: w,
+    disabled: x || !a
+  }), T = U((b, R) => {
+    m && (R && (m.unobserve(R), u.current = !1), b && m.observe(b));
+  }, [m]), [C, S] = je(T), p = Ae(t);
+  return O(() => {
+    !m || !C.current || (m.disconnect(), u.current = !1, m.observe(C.current));
+  }, [C, m]), O(
+    () => (s({
+      type: N.RegisterDroppable,
+      element: {
+        id: r,
+        key: o,
+        disabled: n,
+        node: C,
+        rect: g,
+        data: p
+      }
+    }), () => s({
+      type: N.UnregisterDroppable,
+      key: o,
+      id: r
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), O(() => {
+    n !== d.current.disabled && (s({
+      type: N.SetDroppableDisabled,
+      id: r,
+      key: o,
+      disabled: n
+    }), d.current.disabled = n);
+  }, [r, o, n, s]), {
+    active: a,
+    rect: g,
+    isOver: (l == null ? void 0 : l.id) === r,
+    node: C,
+    over: l,
+    setNodeRef: S
   };
 }
-O.Down, O.Right, O.Up, O.Left;
+function Fr(e) {
+  let {
+    animation: t,
+    children: n
+  } = e;
+  const [r, i] = K(null), [o, a] = K(null), s = Ke(n);
+  return !n && !r && s && i(s), fe(() => {
+    if (!o)
+      return;
+    const l = r == null ? void 0 : r.key, c = r == null ? void 0 : r.props.id;
+    if (l == null || c == null) {
+      i(null);
+      return;
+    }
+    Promise.resolve(t(c, o)).then(() => {
+      i(null);
+    });
+  }, [t, r, o]), M.createElement(M.Fragment, null, n, r ? wn(r, {
+    ref: a
+  }) : null);
+}
+const $r = {
+  x: 0,
+  y: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+function Kr(e) {
+  let {
+    children: t
+  } = e;
+  return M.createElement(Le.Provider, {
+    value: an
+  }, M.createElement(qe.Provider, {
+    value: $r
+  }, t));
+}
+const Xr = {
+  position: "fixed",
+  touchAction: "none"
+}, jr = (e) => lt(e) ? "transform 250ms ease" : void 0, Wr = /* @__PURE__ */ Dn((e, t) => {
+  let {
+    as: n,
+    activatorEvent: r,
+    adjustScale: i,
+    children: o,
+    className: a,
+    rect: s,
+    style: l,
+    transform: c,
+    transition: d = jr
+  } = e;
+  if (!s)
+    return null;
+  const u = i ? c : {
+    ...c,
+    scaleX: 1,
+    scaleY: 1
+  }, g = {
+    ...Xr,
+    width: s.width,
+    height: s.height,
+    top: s.top,
+    left: s.left,
+    transform: rt.Transform.toString(u),
+    transformOrigin: i && r ? zn(r, s) : void 0,
+    transition: typeof d == "function" ? d(r) : d,
+    ...l
+  };
+  return M.createElement(n, {
+    className: a,
+    style: g,
+    ref: t
+  }, o);
+}), Yr = (e) => (t) => {
+  let {
+    active: n,
+    dragOverlay: r
+  } = t;
+  const i = {}, {
+    styles: o,
+    className: a
+  } = e;
+  if (o != null && o.active)
+    for (const [s, l] of Object.entries(o.active))
+      l !== void 0 && (i[s] = n.node.style.getPropertyValue(s), n.node.style.setProperty(s, l));
+  if (o != null && o.dragOverlay)
+    for (const [s, l] of Object.entries(o.dragOverlay))
+      l !== void 0 && r.node.style.setProperty(s, l);
+  return a != null && a.active && n.node.classList.add(a.active), a != null && a.dragOverlay && r.node.classList.add(a.dragOverlay), function() {
+    for (const [l, c] of Object.entries(i))
+      n.node.style.setProperty(l, c);
+    a != null && a.active && n.node.classList.remove(a.active);
+  };
+}, Ur = (e) => {
+  let {
+    transform: {
+      initial: t,
+      final: n
+    }
+  } = e;
+  return [{
+    transform: rt.Transform.toString(t)
+  }, {
+    transform: rt.Transform.toString(n)
+  }];
+}, Hr = {
+  duration: 250,
+  easing: "ease",
+  keyframes: Ur,
+  sideEffects: /* @__PURE__ */ Yr({
+    styles: {
+      active: {
+        opacity: "0"
+      }
+    }
+  })
+};
+function _r(e) {
+  let {
+    config: t,
+    draggableNodes: n,
+    droppableContainers: r,
+    measuringConfiguration: i
+  } = e;
+  return ct((o, a) => {
+    if (t === null)
+      return;
+    const s = n.get(o);
+    if (!s)
+      return;
+    const l = s.node.current;
+    if (!l)
+      return;
+    const c = sn(a);
+    if (!c)
+      return;
+    const {
+      transform: d
+    } = J(a).getComputedStyle(a), u = _t(d);
+    if (!u)
+      return;
+    const g = typeof t == "function" ? t : qr(t);
+    return en(l, i.draggable.measure), g({
+      active: {
+        id: o,
+        data: s.data,
+        node: l,
+        rect: i.draggable.measure(l)
+      },
+      draggableNodes: n,
+      dragOverlay: {
+        node: a,
+        rect: i.dragOverlay.measure(c)
+      },
+      droppableContainers: r,
+      measuringConfiguration: i,
+      transform: u
+    });
+  });
+}
+function qr(e) {
+  const {
+    duration: t,
+    easing: n,
+    sideEffects: r,
+    keyframes: i
+  } = {
+    ...Hr,
+    ...e
+  };
+  return (o) => {
+    let {
+      active: a,
+      dragOverlay: s,
+      transform: l,
+      ...c
+    } = o;
+    if (!t)
+      return;
+    const d = {
+      x: s.rect.left - a.rect.left,
+      y: s.rect.top - a.rect.top
+    }, u = {
+      scaleX: l.scaleX !== 1 ? a.rect.width * l.scaleX / s.rect.width : 1,
+      scaleY: l.scaleY !== 1 ? a.rect.height * l.scaleY / s.rect.height : 1
+    }, g = {
+      x: l.x - d.x,
+      y: l.y - d.y,
+      ...u
+    }, f = i({
+      ...c,
+      active: a,
+      dragOverlay: s,
+      transform: {
+        initial: l,
+        final: g
+      }
+    }), [x] = f, h = f[f.length - 1];
+    if (JSON.stringify(x) === JSON.stringify(h))
+      return;
+    const v = r == null ? void 0 : r({
+      active: a,
+      dragOverlay: s,
+      ...c
+    }), y = s.node.animate(f, {
+      duration: t,
+      easing: n,
+      fill: "forwards"
+    });
+    return new Promise((w) => {
+      y.onfinish = () => {
+        v == null || v(), w();
+      };
+    });
+  };
+}
+let Wt = 0;
+function Jr(e) {
+  return A(() => {
+    if (e != null)
+      return Wt++, Wt;
+  }, [e]);
+}
+const so = /* @__PURE__ */ M.memo((e) => {
+  let {
+    adjustScale: t = !1,
+    children: n,
+    dropAnimation: r,
+    style: i,
+    transition: o,
+    modifiers: a,
+    wrapperElement: s = "div",
+    className: l,
+    zIndex: c = 999
+  } = e;
+  const {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: g,
+    containerNodeRect: f,
+    draggableNodes: x,
+    droppableContainers: h,
+    dragOverlay: v,
+    over: y,
+    measuringConfiguration: w,
+    scrollableAncestors: m,
+    scrollableAncestorRects: T,
+    windowRect: C
+  } = Pr(), S = de(qe), p = Jr(u == null ? void 0 : u.id), b = cn(a, {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: g,
+    containerNodeRect: f,
+    draggingNodeRect: v.rect,
+    over: y,
+    overlayNodeRect: v.rect,
+    scrollableAncestors: m,
+    scrollableAncestorRects: T,
+    transform: S,
+    windowRect: C
+  }), R = gt(g), k = _r({
+    config: r,
+    draggableNodes: x,
+    droppableContainers: h,
+    measuringConfiguration: w
+  }), E = R ? v.setRef : void 0;
+  return M.createElement(Kr, null, M.createElement(Fr, {
+    animation: k
+  }, u && p ? M.createElement(Wr, {
+    key: p,
+    id: u.id,
+    ref: E,
+    as: s,
+    activatorEvent: d,
+    adjustScale: t,
+    className: l,
+    transition: o,
+    rect: R,
+    style: {
+      zIndex: c,
+      ...i
+    },
+    transform: b
+  }, n) : null));
+});
 export {
-  _e as SortableContext,
-  $ as arrayMove,
-  Re as defaultAnimateLayoutChanges,
-  De as defaultNewIndexGetter,
-  j as rectSortingStrategy,
-  ze as useSortable
+  Re as AutoScrollActivator,
+  ro as DndContext,
+  so as DragOverlay,
+  D as KeyboardCode,
+  nn as KeyboardSensor,
+  st as MeasuringFrequency,
+  Oe as MeasuringStrategy,
+  ar as MouseSensor,
+  rn as PointerSensor,
+  lr as TouchSensor,
+  Ye as TraversalOrder,
+  cn as applyModifiers,
+  no as closestCenter,
+  kn as defaultAnnouncements,
+  H as defaultCoordinates,
+  Hr as defaultDropAnimation,
+  Yr as defaultDropAnimationSideEffects,
+  or as defaultKeyboardCoordinateGetter,
+  Ln as defaultScreenReaderInstructions,
+  Te as getClientRect,
+  $n as getFirstCollision,
+  dt as getScrollableAncestors,
+  Xn as rectIntersection,
+  Pr as useDndContext,
+  Mn as useDndMonitor,
+  oo as useDraggable,
+  io as useDroppable,
+  eo as useSensor,
+  to as useSensors
 };