@ubloimmo/uikit 0.31.2 → 0.32.0

package/dist/node_modules/@dnd-kit/core/dist/core.esm.js

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