@clevertask/react-sortable-tree 0.0.1

package/dist/react-sortable-tree.js

@@ -0,0 +1,3789 @@
+import { jsx as _, jsxs as fn } from "react/jsx-runtime";
+import j, { useMemo as T, useLayoutEffect as Qn, useEffect as k, useRef as z, useCallback as $, useState as V, createContext as Ke, memo as ut, useReducer as Nt, useContext as we, cloneElement as er, forwardRef as dt } from "react";
+import { unstable_batchedUpdates as je, createPortal as gn } from "react-dom";
+function tr() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return T(
+    () => (r) => {
+      t.forEach((o) => o(r));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const ft = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function Ne(e) {
+  const t = Object.prototype.toString.call(e);
+  return t === "[object Window]" || // In Electron context the Window object serializes to [object global]
+  t === "[object global]";
+}
+function Lt(e) {
+  return "nodeType" in e;
+}
+function G(e) {
+  var t, n;
+  return e ? Ne(e) ? e : Lt(e) && (t = (n = e.ownerDocument) == null ? void 0 : n.defaultView) != null ? t : window : window;
+}
+function Pt(e) {
+  const {
+    Document: t
+  } = G(e);
+  return e instanceof t;
+}
+function Ue(e) {
+  return Ne(e) ? !1 : e instanceof G(e).HTMLElement;
+}
+function hn(e) {
+  return e instanceof G(e).SVGElement;
+}
+function Le(e) {
+  return e ? Ne(e) ? e.document : Lt(e) ? Pt(e) ? e : Ue(e) || hn(e) ? e.ownerDocument : document : document : document;
+}
+const ie = ft ? Qn : k;
+function gt(e) {
+  const t = z(e);
+  return ie(() => {
+    t.current = e;
+  }), $(function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    return t.current == null ? void 0 : t.current(...r);
+  }, []);
+}
+function nr() {
+  const e = z(null), t = $((r, o) => {
+    e.current = setInterval(r, o);
+  }, []), n = $(() => {
+    e.current !== null && (clearInterval(e.current), e.current = null);
+  }, []);
+  return [t, n];
+}
+function Ye(e, t) {
+  t === void 0 && (t = [e]);
+  const n = z(e);
+  return ie(() => {
+    n.current !== e && (n.current = e);
+  }, t), n;
+}
+function We(e, t) {
+  const n = z();
+  return T(
+    () => {
+      const r = e(n.current);
+      return n.current = r, r;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function ot(e) {
+  const t = gt(e), n = z(null), r = $(
+    (o) => {
+      o !== n.current && (t == null || t(o, n.current)), n.current = o;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [n, r];
+}
+function it(e) {
+  const t = z();
+  return k(() => {
+    t.current = e;
+  }, [e]), t.current;
+}
+let wt = {};
+function Je(e, t) {
+  return T(() => {
+    if (t)
+      return t;
+    const n = wt[e] == null ? 0 : wt[e] + 1;
+    return wt[e] = n, e + "-" + n;
+  }, [e, t]);
+}
+function pn(e) {
+  return function(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    return r.reduce((i, s) => {
+      const a = Object.entries(s);
+      for (const [l, c] of a) {
+        const u = i[l];
+        u != null && (i[l] = u + e * c);
+      }
+      return i;
+    }, {
+      ...t
+    });
+  };
+}
+const Ae = /* @__PURE__ */ pn(1), st = /* @__PURE__ */ pn(-1);
+function rr(e) {
+  return "clientX" in e && "clientY" in e;
+}
+function ht(e) {
+  if (!e)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = G(e.target);
+  return t && e instanceof t;
+}
+function or(e) {
+  if (!e)
+    return !1;
+  const {
+    TouchEvent: t
+  } = G(e.target);
+  return t && e instanceof t;
+}
+function at(e) {
+  if (or(e)) {
+    if (e.touches && e.touches.length) {
+      const {
+        clientX: t,
+        clientY: n
+      } = e.touches[0];
+      return {
+        x: t,
+        y: n
+      };
+    } else if (e.changedTouches && e.changedTouches.length) {
+      const {
+        clientX: t,
+        clientY: n
+      } = e.changedTouches[0];
+      return {
+        x: t,
+        y: n
+      };
+    }
+  }
+  return rr(e) ? {
+    x: e.clientX,
+    y: e.clientY
+  } : null;
+}
+const ge = /* @__PURE__ */ Object.freeze({
+  Translate: {
+    toString(e) {
+      if (!e)
+        return;
+      const {
+        x: t,
+        y: n
+      } = e;
+      return "translate3d(" + (t ? Math.round(t) : 0) + "px, " + (n ? Math.round(n) : 0) + "px, 0)";
+    }
+  },
+  Scale: {
+    toString(e) {
+      if (!e)
+        return;
+      const {
+        scaleX: t,
+        scaleY: n
+      } = e;
+      return "scaleX(" + t + ") scaleY(" + n + ")";
+    }
+  },
+  Transform: {
+    toString(e) {
+      if (e)
+        return [ge.Translate.toString(e), ge.Scale.toString(e)].join(" ");
+    }
+  },
+  Transition: {
+    toString(e) {
+      let {
+        property: t,
+        duration: n,
+        easing: r
+      } = e;
+      return t + " " + n + "ms " + r;
+    }
+  }
+}), qt = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function ir(e) {
+  return e.matches(qt) ? e : e.querySelector(qt);
+}
+const sr = {
+  display: "none"
+};
+function ar(e) {
+  let {
+    id: t,
+    value: n
+  } = e;
+  return j.createElement("div", {
+    id: t,
+    style: sr
+  }, n);
+}
+function lr(e) {
+  let {
+    id: t,
+    announcement: n,
+    ariaLiveType: r = "assertive"
+  } = e;
+  const o = {
+    position: "fixed",
+    width: 1,
+    height: 1,
+    margin: -1,
+    border: 0,
+    padding: 0,
+    overflow: "hidden",
+    clip: "rect(0 0 0 0)",
+    clipPath: "inset(100%)",
+    whiteSpace: "nowrap"
+  };
+  return j.createElement("div", {
+    id: t,
+    style: o,
+    role: "status",
+    "aria-live": r,
+    "aria-atomic": !0
+  }, n);
+}
+function cr() {
+  const [e, t] = V("");
+  return {
+    announce: $((r) => {
+      r != null && t(r);
+    }, []),
+    announcement: e
+  };
+}
+const vn = /* @__PURE__ */ Ke(null);
+function ur(e) {
+  const t = we(vn);
+  k(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function dr() {
+  const [e] = V(() => /* @__PURE__ */ new Set()), t = $((r) => (e.add(r), () => e.delete(r)), [e]);
+  return [$((r) => {
+    let {
+      type: o,
+      event: i
+    } = r;
+    e.forEach((s) => {
+      var a;
+      return (a = s[o]) == null ? void 0 : a.call(s, i);
+    });
+  }, [e]), t];
+}
+const fr = {
+  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.
+  `
+}, gr = {
+  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 hr(e) {
+  let {
+    announcements: t = gr,
+    container: n,
+    hiddenTextDescribedById: r,
+    screenReaderInstructions: o = fr
+  } = e;
+  const {
+    announce: i,
+    announcement: s
+  } = cr(), a = Je("DndLiveRegion"), [l, c] = V(!1);
+  if (k(() => {
+    c(!0);
+  }, []), ur(T(() => ({
+    onDragStart(d) {
+      let {
+        active: f
+      } = d;
+      i(t.onDragStart({
+        active: f
+      }));
+    },
+    onDragMove(d) {
+      let {
+        active: f,
+        over: h
+      } = d;
+      t.onDragMove && i(t.onDragMove({
+        active: f,
+        over: h
+      }));
+    },
+    onDragOver(d) {
+      let {
+        active: f,
+        over: h
+      } = d;
+      i(t.onDragOver({
+        active: f,
+        over: h
+      }));
+    },
+    onDragEnd(d) {
+      let {
+        active: f,
+        over: h
+      } = d;
+      i(t.onDragEnd({
+        active: f,
+        over: h
+      }));
+    },
+    onDragCancel(d) {
+      let {
+        active: f,
+        over: h
+      } = d;
+      i(t.onDragCancel({
+        active: f,
+        over: h
+      }));
+    }
+  }), [i, t])), !l)
+    return null;
+  const u = j.createElement(j.Fragment, null, j.createElement(ar, {
+    id: r,
+    value: o.draggable
+  }), j.createElement(lr, {
+    id: a,
+    announcement: s
+  }));
+  return n ? gn(u, n) : u;
+}
+var X;
+(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";
+})(X || (X = {}));
+function lt() {
+}
+function Gt(e, t) {
+  return T(
+    () => ({
+      sensor: e,
+      options: t ?? {}
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  );
+}
+function pr() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return T(
+    () => [...t].filter((r) => r != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const de = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function bn(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function vr(e, t) {
+  const n = at(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 mn(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return n - r;
+}
+function br(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return r - n;
+}
+function Zt(e) {
+  let {
+    left: t,
+    top: n,
+    height: r,
+    width: o
+  } = e;
+  return [{
+    x: t,
+    y: n
+  }, {
+    x: t + o,
+    y: n
+  }, {
+    x: t,
+    y: n + r
+  }, {
+    x: t + o,
+    y: n + r
+  }];
+}
+function yn(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return n[t];
+}
+function Qt(e, t, n) {
+  return t === void 0 && (t = e.left), n === void 0 && (n = e.top), {
+    x: t + e.width * 0.5,
+    y: n + e.height * 0.5
+  };
+}
+const mr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Qt(t, t.left, t.top), i = [];
+  for (const s of r) {
+    const {
+      id: a
+    } = s, l = n.get(a);
+    if (l) {
+      const c = bn(Qt(l), o);
+      i.push({
+        id: a,
+        data: {
+          droppableContainer: s,
+          value: c
+        }
+      });
+    }
+  }
+  return i.sort(mn);
+}, yr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Zt(t), i = [];
+  for (const s of r) {
+    const {
+      id: a
+    } = s, l = n.get(a);
+    if (l) {
+      const c = Zt(l), u = o.reduce((f, h, b) => f + bn(c[b], h), 0), d = Number((u / 4).toFixed(4));
+      i.push({
+        id: a,
+        data: {
+          droppableContainer: s,
+          value: d
+        }
+      });
+    }
+  }
+  return i.sort(mn);
+};
+function wr(e, t) {
+  const n = Math.max(t.top, e.top), r = Math.max(t.left, e.left), o = Math.min(t.left + t.width, e.left + e.width), i = Math.min(t.top + t.height, e.top + e.height), s = o - r, a = i - n;
+  if (r < o && n < i) {
+    const l = t.width * t.height, c = e.width * e.height, u = s * a, d = u / (l + c - u);
+    return Number(d.toFixed(4));
+  }
+  return 0;
+}
+const xr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = [];
+  for (const i of r) {
+    const {
+      id: s
+    } = i, a = n.get(s);
+    if (a) {
+      const l = wr(a, t);
+      l > 0 && o.push({
+        id: s,
+        data: {
+          droppableContainer: i,
+          value: l
+        }
+      });
+    }
+  }
+  return o.sort(br);
+};
+function Dr(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function wn(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : de;
+}
+function Cr(e) {
+  return function(n) {
+    for (var r = arguments.length, o = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++)
+      o[i - 1] = arguments[i];
+    return o.reduce((s, a) => ({
+      ...s,
+      top: s.top + e * a.y,
+      bottom: s.bottom + e * a.y,
+      left: s.left + e * a.x,
+      right: s.right + e * a.x
+    }), {
+      ...n
+    });
+  };
+}
+const Sr = /* @__PURE__ */ Cr(1);
+function xn(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 Ir(e, t, n) {
+  const r = xn(t);
+  if (!r)
+    return e;
+  const {
+    scaleX: o,
+    scaleY: i,
+    x: s,
+    y: a
+  } = r, l = e.left - s - (1 - o) * parseFloat(n), c = e.top - a - (1 - i) * parseFloat(n.slice(n.indexOf(" ") + 1)), u = o ? e.width / o : e.width, d = i ? e.height / i : e.height;
+  return {
+    width: u,
+    height: d,
+    top: c,
+    right: l + u,
+    bottom: c + d,
+    left: l
+  };
+}
+const Rr = {
+  ignoreTransform: !1
+};
+function Pe(e, t) {
+  t === void 0 && (t = Rr);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: c,
+      transformOrigin: u
+    } = G(e).getComputedStyle(e);
+    c && (n = Ir(n, c, u));
+  }
+  const {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: l
+  } = n;
+  return {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: l
+  };
+}
+function en(e) {
+  return Pe(e, {
+    ignoreTransform: !0
+  });
+}
+function Er(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function Or(e, t) {
+  return t === void 0 && (t = G(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Tr(e, t) {
+  t === void 0 && (t = G(e).getComputedStyle(e));
+  const n = /(auto|scroll|overlay)/;
+  return ["overflow", "overflowX", "overflowY"].some((o) => {
+    const i = t[o];
+    return typeof i == "string" ? n.test(i) : !1;
+  });
+}
+function kt(e, t) {
+  const n = [];
+  function r(o) {
+    if (t != null && n.length >= t || !o)
+      return n;
+    if (Pt(o) && o.scrollingElement != null && !n.includes(o.scrollingElement))
+      return n.push(o.scrollingElement), n;
+    if (!Ue(o) || hn(o) || n.includes(o))
+      return n;
+    const i = G(e).getComputedStyle(o);
+    return o !== e && Tr(o, i) && n.push(o), Or(o, i) ? n : r(o.parentNode);
+  }
+  return e ? r(e) : n;
+}
+function Dn(e) {
+  const [t] = kt(e, 1);
+  return t ?? null;
+}
+function xt(e) {
+  return !ft || !e ? null : Ne(e) ? e : Lt(e) ? Pt(e) || e === Le(e).scrollingElement ? window : Ue(e) ? e : null : null;
+}
+function Cn(e) {
+  return Ne(e) ? e.scrollX : e.scrollLeft;
+}
+function Sn(e) {
+  return Ne(e) ? e.scrollY : e.scrollTop;
+}
+function Rt(e) {
+  return {
+    x: Cn(e),
+    y: Sn(e)
+  };
+}
+var Y;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(Y || (Y = {}));
+function In(e) {
+  return !ft || !e ? !1 : e === document.scrollingElement;
+}
+function Rn(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = In(e) ? {
+    height: window.innerHeight,
+    width: window.innerWidth
+  } : {
+    height: e.clientHeight,
+    width: e.clientWidth
+  }, r = {
+    x: e.scrollWidth - n.width,
+    y: e.scrollHeight - n.height
+  }, o = e.scrollTop <= t.y, i = e.scrollLeft <= t.x, s = e.scrollTop >= r.y, a = e.scrollLeft >= r.x;
+  return {
+    isTop: o,
+    isLeft: i,
+    isBottom: s,
+    isRight: a,
+    maxScroll: r,
+    minScroll: t
+  };
+}
+const Ar = {
+  x: 0.2,
+  y: 0.2
+};
+function Mr(e, t, n, r, o) {
+  let {
+    top: i,
+    left: s,
+    right: a,
+    bottom: l
+  } = n;
+  r === void 0 && (r = 10), o === void 0 && (o = Ar);
+  const {
+    isTop: c,
+    isBottom: u,
+    isLeft: d,
+    isRight: f
+  } = Rn(e), h = {
+    x: 0,
+    y: 0
+  }, b = {
+    x: 0,
+    y: 0
+  }, g = {
+    height: t.height * o.y,
+    width: t.width * o.x
+  };
+  return !c && i <= t.top + g.height ? (h.y = Y.Backward, b.y = r * Math.abs((t.top + g.height - i) / g.height)) : !u && l >= t.bottom - g.height && (h.y = Y.Forward, b.y = r * Math.abs((t.bottom - g.height - l) / g.height)), !f && a >= t.right - g.width ? (h.x = Y.Forward, b.x = r * Math.abs((t.right - g.width - a) / g.width)) : !d && s <= t.left + g.width && (h.x = Y.Backward, b.x = r * Math.abs((t.left + g.width - s) / g.width)), {
+    direction: h,
+    speed: b
+  };
+}
+function Nr(e) {
+  if (e === document.scrollingElement) {
+    const {
+      innerWidth: i,
+      innerHeight: s
+    } = window;
+    return {
+      top: 0,
+      left: 0,
+      right: i,
+      bottom: s,
+      width: i,
+      height: s
+    };
+  }
+  const {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o
+  } = e.getBoundingClientRect();
+  return {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o,
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+}
+function En(e) {
+  return e.reduce((t, n) => Ae(t, Rt(n)), de);
+}
+function Lr(e) {
+  return e.reduce((t, n) => t + Cn(n), 0);
+}
+function Pr(e) {
+  return e.reduce((t, n) => t + Sn(n), 0);
+}
+function On(e, t) {
+  if (t === void 0 && (t = Pe), !e)
+    return;
+  const {
+    top: n,
+    left: r,
+    bottom: o,
+    right: i
+  } = t(e);
+  Dn(e) && (o <= 0 || i <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const kr = [["x", ["left", "right"], Lr], ["y", ["top", "bottom"], Pr]];
+class zt {
+  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 = kt(n), o = En(r);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [i, s, a] of kr)
+      for (const l of s)
+        Object.defineProperty(this, l, {
+          get: () => {
+            const c = a(r), u = o[i] - c;
+            return this.rect[l] + u;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class Fe {
+  constructor(t) {
+    this.target = void 0, this.listeners = [], this.removeAll = () => {
+      this.listeners.forEach((n) => {
+        var r;
+        return (r = this.target) == null ? void 0 : r.removeEventListener(...n);
+      });
+    }, this.target = t;
+  }
+  add(t, n, r) {
+    var o;
+    (o = this.target) == null || o.addEventListener(t, n, r), this.listeners.push([t, n, r]);
+  }
+}
+function zr(e) {
+  const {
+    EventTarget: t
+  } = G(e);
+  return e instanceof t ? e : Le(e);
+}
+function Dt(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 oe;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(oe || (oe = {}));
+function tn(e) {
+  e.preventDefault();
+}
+function Br(e) {
+  e.stopPropagation();
+}
+var S;
+(function(e) {
+  e.Space = "Space", e.Down = "ArrowDown", e.Right = "ArrowRight", e.Left = "ArrowLeft", e.Up = "ArrowUp", e.Esc = "Escape", e.Enter = "Enter";
+})(S || (S = {}));
+const Tn = {
+  start: [S.Space, S.Enter],
+  cancel: [S.Esc],
+  end: [S.Space, S.Enter]
+}, $r = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case S.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case S.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case S.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case S.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class Bt {
+  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 Fe(Le(n)), this.windowListeners = new Fe(G(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(oe.Resize, this.handleCancel), this.windowListeners.add(oe.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(oe.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, r = t.node.current;
+    r && On(r), n(de);
+  }
+  handleKeyDown(t) {
+    if (ht(t)) {
+      const {
+        active: n,
+        context: r,
+        options: o
+      } = this.props, {
+        keyboardCodes: i = Tn,
+        coordinateGetter: s = $r,
+        scrollBehavior: a = "smooth"
+      } = o, {
+        code: l
+      } = t;
+      if (i.end.includes(l)) {
+        this.handleEnd(t);
+        return;
+      }
+      if (i.cancel.includes(l)) {
+        this.handleCancel(t);
+        return;
+      }
+      const {
+        collisionRect: c
+      } = r.current, u = c ? {
+        x: c.left,
+        y: c.top
+      } : de;
+      this.referenceCoordinates || (this.referenceCoordinates = u);
+      const d = s(t, {
+        active: n,
+        context: r.current,
+        currentCoordinates: u
+      });
+      if (d) {
+        const f = st(d, u), h = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: b
+        } = r.current;
+        for (const g of b) {
+          const p = t.code, {
+            isTop: m,
+            isRight: w,
+            isLeft: y,
+            isBottom: C,
+            maxScroll: x,
+            minScroll: I
+          } = Rn(g), R = Nr(g), E = {
+            x: Math.min(p === S.Right ? R.right - R.width / 2 : R.right, Math.max(p === S.Right ? R.left : R.left + R.width / 2, d.x)),
+            y: Math.min(p === S.Down ? R.bottom - R.height / 2 : R.bottom, Math.max(p === S.Down ? R.top : R.top + R.height / 2, d.y))
+          }, N = p === S.Right && !w || p === S.Left && !y, B = p === S.Down && !C || p === S.Up && !m;
+          if (N && E.x !== d.x) {
+            const A = g.scrollLeft + f.x, Z = p === S.Right && A <= x.x || p === S.Left && A >= I.x;
+            if (Z && !f.y) {
+              g.scrollTo({
+                left: A,
+                behavior: a
+              });
+              return;
+            }
+            Z ? h.x = g.scrollLeft - A : h.x = p === S.Right ? g.scrollLeft - x.x : g.scrollLeft - I.x, h.x && g.scrollBy({
+              left: -h.x,
+              behavior: a
+            });
+            break;
+          } else if (B && E.y !== d.y) {
+            const A = g.scrollTop + f.y, Z = p === S.Down && A <= x.y || p === S.Up && A >= I.y;
+            if (Z && !f.x) {
+              g.scrollTo({
+                top: A,
+                behavior: a
+              });
+              return;
+            }
+            Z ? h.y = g.scrollTop - A : h.y = p === S.Down ? g.scrollTop - x.y : g.scrollTop - I.y, h.y && g.scrollBy({
+              top: -h.y,
+              behavior: a
+            });
+            break;
+          }
+        }
+        this.handleMove(t, Ae(st(d, this.referenceCoordinates), h));
+      }
+    }
+  }
+  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();
+  }
+}
+Bt.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: r = Tn,
+      onActivation: o
+    } = t, {
+      active: i
+    } = n;
+    const {
+      code: s
+    } = e.nativeEvent;
+    if (r.start.includes(s)) {
+      const a = i.activatorNode.current;
+      return a && e.target !== a ? !1 : (e.preventDefault(), o == null || o({
+        event: e.nativeEvent
+      }), !0);
+    }
+    return !1;
+  }
+}];
+function nn(e) {
+  return !!(e && "distance" in e);
+}
+function rn(e) {
+  return !!(e && "delay" in e);
+}
+class $t {
+  constructor(t, n, r) {
+    var o;
+    r === void 0 && (r = zr(t.event.target)), this.props = void 0, this.events = void 0, this.autoScrollEnabled = !0, this.document = void 0, this.activated = !1, this.initialCoordinates = void 0, this.timeoutId = null, this.listeners = void 0, this.documentListeners = void 0, this.windowListeners = void 0, this.props = t, this.events = n;
+    const {
+      event: i
+    } = t, {
+      target: s
+    } = i;
+    this.props = t, this.events = n, this.document = Le(s), this.documentListeners = new Fe(this.document), this.listeners = new Fe(r), this.windowListeners = new Fe(G(s)), this.initialCoordinates = (o = at(i)) != null ? o : de, 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(oe.Resize, this.handleCancel), this.windowListeners.add(oe.DragStart, tn), this.windowListeners.add(oe.VisibilityChange, this.handleCancel), this.windowListeners.add(oe.ContextMenu, tn), this.documentListeners.add(oe.Keydown, this.handleKeydown), n) {
+      if (r != null && r({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (rn(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay);
+        return;
+      }
+      if (nn(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(oe.Click, Br, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(oe.SelectionChange, this.removeTextSelection), n(t));
+  }
+  handleMove(t) {
+    var n;
+    const {
+      activated: r,
+      initialCoordinates: o,
+      props: i
+    } = this, {
+      onMove: s,
+      options: {
+        activationConstraint: a
+      }
+    } = i;
+    if (!o)
+      return;
+    const l = (n = at(t)) != null ? n : de, c = st(o, l);
+    if (!r && a) {
+      if (nn(a)) {
+        if (a.tolerance != null && Dt(c, a.tolerance))
+          return this.handleCancel();
+        if (Dt(c, a.distance))
+          return this.handleStart();
+      }
+      return rn(a) && Dt(c, a.tolerance) ? this.handleCancel() : void 0;
+    }
+    t.cancelable && t.preventDefault(), s(l);
+  }
+  handleEnd() {
+    const {
+      onEnd: t
+    } = this.props;
+    this.detach(), t();
+  }
+  handleCancel() {
+    const {
+      onCancel: t
+    } = this.props;
+    this.detach(), t();
+  }
+  handleKeydown(t) {
+    t.code === S.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const _r = {
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class _t extends $t {
+  constructor(t) {
+    const {
+      event: n
+    } = t, r = Le(n.target);
+    super(t, _r, r);
+  }
+}
+_t.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 jr = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var Et;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(Et || (Et = {}));
+class Fr extends $t {
+  constructor(t) {
+    super(t, jr, Le(t.event.target));
+  }
+}
+Fr.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return n.button === Et.RightClick ? !1 : (r == null || r({
+      event: n
+    }), !0);
+  }
+}];
+const Ct = {
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class Hr extends $t {
+  constructor(t) {
+    super(t, Ct);
+  }
+  static setup() {
+    return window.addEventListener(Ct.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(Ct.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+Hr.activators = [{
+  eventName: "onTouchStart",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    const {
+      touches: o
+    } = n;
+    return o.length > 1 ? !1 : (r == null || r({
+      event: n
+    }), !0);
+  }
+}];
+var He;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(He || (He = {}));
+var ct;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(ct || (ct = {}));
+function Xr(e) {
+  let {
+    acceleration: t,
+    activator: n = He.Pointer,
+    canScroll: r,
+    draggingRect: o,
+    enabled: i,
+    interval: s = 5,
+    order: a = ct.TreeOrder,
+    pointerCoordinates: l,
+    scrollableAncestors: c,
+    scrollableAncestorRects: u,
+    delta: d,
+    threshold: f
+  } = e;
+  const h = Vr({
+    delta: d,
+    disabled: !i
+  }), [b, g] = nr(), p = z({
+    x: 0,
+    y: 0
+  }), m = z({
+    x: 0,
+    y: 0
+  }), w = T(() => {
+    switch (n) {
+      case He.Pointer:
+        return l ? {
+          top: l.y,
+          bottom: l.y,
+          left: l.x,
+          right: l.x
+        } : null;
+      case He.DraggableRect:
+        return o;
+    }
+  }, [n, o, l]), y = z(null), C = $(() => {
+    const I = y.current;
+    if (!I)
+      return;
+    const R = p.current.x * m.current.x, E = p.current.y * m.current.y;
+    I.scrollBy(R, E);
+  }, []), x = T(() => a === ct.TreeOrder ? [...c].reverse() : c, [a, c]);
+  k(
+    () => {
+      if (!i || !c.length || !w) {
+        g();
+        return;
+      }
+      for (const I of x) {
+        if ((r == null ? void 0 : r(I)) === !1)
+          continue;
+        const R = c.indexOf(I), E = u[R];
+        if (!E)
+          continue;
+        const {
+          direction: N,
+          speed: B
+        } = Mr(I, E, w, t, f);
+        for (const A of ["x", "y"])
+          h[A][N[A]] || (B[A] = 0, N[A] = 0);
+        if (B.x > 0 || B.y > 0) {
+          g(), y.current = I, b(C, s), p.current = B, m.current = N;
+          return;
+        }
+      }
+      p.current = {
+        x: 0,
+        y: 0
+      }, m.current = {
+        x: 0,
+        y: 0
+      }, g();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      C,
+      r,
+      g,
+      i,
+      s,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(w),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(h),
+      b,
+      c,
+      x,
+      u,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(f)
+    ]
+  );
+}
+const Yr = {
+  x: {
+    [Y.Backward]: !1,
+    [Y.Forward]: !1
+  },
+  y: {
+    [Y.Backward]: !1,
+    [Y.Forward]: !1
+  }
+};
+function Vr(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const r = it(t);
+  return We((o) => {
+    if (n || !r || !o)
+      return Yr;
+    const i = {
+      x: Math.sign(t.x - r.x),
+      y: Math.sign(t.y - r.y)
+    };
+    return {
+      x: {
+        [Y.Backward]: o.x[Y.Backward] || i.x === -1,
+        [Y.Forward]: o.x[Y.Forward] || i.x === 1
+      },
+      y: {
+        [Y.Backward]: o.y[Y.Backward] || i.y === -1,
+        [Y.Forward]: o.y[Y.Forward] || i.y === 1
+      }
+    };
+  }, [n, t, r]);
+}
+function Kr(e, t) {
+  const n = t !== null ? e.get(t) : void 0, r = n ? n.node.current : null;
+  return We((o) => {
+    var i;
+    return t === null ? null : (i = r ?? o) != null ? i : null;
+  }, [r, t]);
+}
+function Ur(e, t) {
+  return T(() => e.reduce((n, r) => {
+    const {
+      sensor: o
+    } = r, i = o.activators.map((s) => ({
+      eventName: s.eventName,
+      handler: t(s.handler, r)
+    }));
+    return [...n, ...i];
+  }, []), [e, t]);
+}
+var Me;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Me || (Me = {}));
+var Ot;
+(function(e) {
+  e.Optimized = "optimized";
+})(Ot || (Ot = {}));
+const on = /* @__PURE__ */ new Map();
+function Wr(e, t) {
+  let {
+    dragging: n,
+    dependencies: r,
+    config: o
+  } = t;
+  const [i, s] = V(null), {
+    frequency: a,
+    measure: l,
+    strategy: c
+  } = o, u = z(e), d = p(), f = Ye(d), h = $(function(m) {
+    m === void 0 && (m = []), !f.current && s((w) => w === null ? m : w.concat(m.filter((y) => !w.includes(y))));
+  }, [f]), b = z(null), g = We((m) => {
+    if (d && !n)
+      return on;
+    if (!m || m === on || u.current !== e || i != null) {
+      const w = /* @__PURE__ */ new Map();
+      for (let y of e) {
+        if (!y)
+          continue;
+        if (i && i.length > 0 && !i.includes(y.id) && y.rect.current) {
+          w.set(y.id, y.rect.current);
+          continue;
+        }
+        const C = y.node.current, x = C ? new zt(l(C), C) : null;
+        y.rect.current = x, x && w.set(y.id, x);
+      }
+      return w;
+    }
+    return m;
+  }, [e, i, n, d, l]);
+  return k(() => {
+    u.current = e;
+  }, [e]), k(
+    () => {
+      d || h();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, d]
+  ), k(
+    () => {
+      i && i.length > 0 && s(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(i)]
+  ), k(
+    () => {
+      d || typeof a != "number" || b.current !== null || (b.current = setTimeout(() => {
+        h(), b.current = null;
+      }, a));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [a, d, h, ...r]
+  ), {
+    droppableRects: g,
+    measureDroppableContainers: h,
+    measuringScheduled: i != null
+  };
+  function p() {
+    switch (c) {
+      case Me.Always:
+        return !1;
+      case Me.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function jt(e, t) {
+  return We((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function Jr(e, t) {
+  return jt(e, t);
+}
+function qr(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = gt(t), o = T(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: i
+    } = window;
+    return new i(r);
+  }, [r, n]);
+  return k(() => () => o == null ? void 0 : o.disconnect(), [o]), o;
+}
+function pt(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = gt(t), o = T(
+    () => {
+      if (n || typeof window > "u" || typeof window.ResizeObserver > "u")
+        return;
+      const {
+        ResizeObserver: i
+      } = window;
+      return new i(r);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n]
+  );
+  return k(() => () => o == null ? void 0 : o.disconnect(), [o]), o;
+}
+function Gr(e) {
+  return new zt(Pe(e), e);
+}
+function sn(e, t, n) {
+  t === void 0 && (t = Gr);
+  const [r, o] = Nt(a, null), i = qr({
+    callback(l) {
+      if (e)
+        for (const c of l) {
+          const {
+            type: u,
+            target: d
+          } = c;
+          if (u === "childList" && d instanceof HTMLElement && d.contains(e)) {
+            o();
+            break;
+          }
+        }
+    }
+  }), s = pt({
+    callback: o
+  });
+  return ie(() => {
+    o(), e ? (s == null || s.observe(e), i == null || i.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (s == null || s.disconnect(), i == null || i.disconnect());
+  }, [e]), r;
+  function a(l) {
+    if (!e)
+      return null;
+    if (e.isConnected === !1) {
+      var c;
+      return (c = l ?? n) != null ? c : null;
+    }
+    const u = t(e);
+    return JSON.stringify(l) === JSON.stringify(u) ? l : u;
+  }
+}
+function Zr(e) {
+  const t = jt(e);
+  return wn(e, t);
+}
+const an = [];
+function Qr(e) {
+  const t = z(e), n = We((r) => e ? r && r !== an && e && t.current && e.parentNode === t.current.parentNode ? r : kt(e) : an, [e]);
+  return k(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function eo(e) {
+  const [t, n] = V(null), r = z(e), o = $((i) => {
+    const s = xt(i.target);
+    s && n((a) => a ? (a.set(s, Rt(s)), new Map(a)) : null);
+  }, []);
+  return k(() => {
+    const i = r.current;
+    if (e !== i) {
+      s(i);
+      const a = e.map((l) => {
+        const c = xt(l);
+        return c ? (c.addEventListener("scroll", o, {
+          passive: !0
+        }), [c, Rt(c)]) : null;
+      }).filter((l) => l != null);
+      n(a.length ? new Map(a) : null), r.current = e;
+    }
+    return () => {
+      s(e), s(i);
+    };
+    function s(a) {
+      a.forEach((l) => {
+        const c = xt(l);
+        c == null || c.removeEventListener("scroll", o);
+      });
+    }
+  }, [o, e]), T(() => e.length ? t ? Array.from(t.values()).reduce((i, s) => Ae(i, s), de) : En(e) : de, [e, t]);
+}
+function ln(e, t) {
+  t === void 0 && (t = []);
+  const n = z(null);
+  return k(
+    () => {
+      n.current = null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), k(() => {
+    const r = e !== de;
+    r && !n.current && (n.current = e), !r && n.current && (n.current = null);
+  }, [e]), n.current ? st(e, n.current) : de;
+}
+function to(e) {
+  k(
+    () => {
+      if (!ft)
+        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 no(e, t) {
+  return T(() => e.reduce((n, r) => {
+    let {
+      eventName: o,
+      handler: i
+    } = r;
+    return n[o] = (s) => {
+      i(s, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function An(e) {
+  return T(() => e ? Er(e) : null, [e]);
+}
+const St = [];
+function ro(e, t) {
+  t === void 0 && (t = Pe);
+  const [n] = e, r = An(n ? G(n) : null), [o, i] = Nt(a, St), s = pt({
+    callback: i
+  });
+  return e.length > 0 && o === St && i(), ie(() => {
+    e.length ? e.forEach((l) => s == null ? void 0 : s.observe(l)) : (s == null || s.disconnect(), i());
+  }, [e]), o;
+  function a() {
+    return e.length ? e.map((l) => In(l) ? r : new zt(t(l), l)) : St;
+  }
+}
+function Mn(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return Ue(t) ? t : e;
+}
+function oo(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, r] = V(null), o = $((c) => {
+    for (const {
+      target: u
+    } of c)
+      if (Ue(u)) {
+        r((d) => {
+          const f = t(u);
+          return d ? {
+            ...d,
+            width: f.width,
+            height: f.height
+          } : f;
+        });
+        break;
+      }
+  }, [t]), i = pt({
+    callback: o
+  }), s = $((c) => {
+    const u = Mn(c);
+    i == null || i.disconnect(), u && (i == null || i.observe(u)), r(u ? t(u) : null);
+  }, [t, i]), [a, l] = ot(s);
+  return T(() => ({
+    nodeRef: a,
+    rect: n,
+    setRef: l
+  }), [n, a, l]);
+}
+const io = [{
+  sensor: _t,
+  options: {}
+}, {
+  sensor: Bt,
+  options: {}
+}], so = {
+  current: {}
+}, rt = {
+  draggable: {
+    measure: en
+  },
+  droppable: {
+    measure: en,
+    strategy: Me.WhileDragging,
+    frequency: Ot.Optimized
+  },
+  dragOverlay: {
+    measure: Pe
+  }
+};
+class Xe 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 ao = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new Xe(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: lt
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: rt,
+  measureDroppableContainers: lt,
+  windowRect: null,
+  measuringScheduled: !1
+}, Nn = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: lt,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: lt
+}, qe = /* @__PURE__ */ Ke(Nn), Ln = /* @__PURE__ */ Ke(ao);
+function lo() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new Xe()
+    }
+  };
+}
+function co(e, t) {
+  switch (t.type) {
+    case X.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case X.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 X.DragEnd:
+    case X.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case X.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: r
+      } = n, o = new Xe(e.droppable.containers);
+      return o.set(r, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: o
+        }
+      };
+    }
+    case X.SetDroppableDisabled: {
+      const {
+        id: n,
+        key: r,
+        disabled: o
+      } = t, i = e.droppable.containers.get(n);
+      if (!i || r !== i.key)
+        return e;
+      const s = new Xe(e.droppable.containers);
+      return s.set(n, {
+        ...i,
+        disabled: o
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: s
+        }
+      };
+    }
+    case X.UnregisterDroppable: {
+      const {
+        id: n,
+        key: r
+      } = t, o = e.droppable.containers.get(n);
+      if (!o || r !== o.key)
+        return e;
+      const i = new Xe(e.droppable.containers);
+      return i.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function uo(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: r,
+    draggableNodes: o
+  } = we(qe), i = it(r), s = it(n == null ? void 0 : n.id);
+  return k(() => {
+    if (!t && !r && i && s != null) {
+      if (!ht(i) || document.activeElement === i.target)
+        return;
+      const a = o.get(s);
+      if (!a)
+        return;
+      const {
+        activatorNode: l,
+        node: c
+      } = a;
+      if (!l.current && !c.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const u of [l.current, c.current]) {
+          if (!u)
+            continue;
+          const d = ir(u);
+          if (d) {
+            d.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [r, t, o, s, i]), null;
+}
+function Pn(e, t) {
+  let {
+    transform: n,
+    ...r
+  } = t;
+  return e != null && e.length ? e.reduce((o, i) => i({
+    transform: o,
+    ...r
+  }), n) : n;
+}
+function fo(e) {
+  return T(
+    () => ({
+      draggable: {
+        ...rt.draggable,
+        ...e == null ? void 0 : e.draggable
+      },
+      droppable: {
+        ...rt.droppable,
+        ...e == null ? void 0 : e.droppable
+      },
+      dragOverlay: {
+        ...rt.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 go(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: r,
+    config: o = !0
+  } = e;
+  const i = z(!1), {
+    x: s,
+    y: a
+  } = typeof o == "boolean" ? {
+    x: o,
+    y: o
+  } : o;
+  ie(() => {
+    if (!s && !a || !t) {
+      i.current = !1;
+      return;
+    }
+    if (i.current || !r)
+      return;
+    const c = t == null ? void 0 : t.node.current;
+    if (!c || c.isConnected === !1)
+      return;
+    const u = n(c), d = wn(u, r);
+    if (s || (d.x = 0), a || (d.y = 0), i.current = !0, Math.abs(d.x) > 0 || Math.abs(d.y) > 0) {
+      const f = Dn(c);
+      f && f.scrollBy({
+        top: d.y,
+        left: d.x
+      });
+    }
+  }, [t, s, a, r, n]);
+}
+const vt = /* @__PURE__ */ Ke({
+  ...de,
+  scaleX: 1,
+  scaleY: 1
+});
+var ye;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(ye || (ye = {}));
+const ho = /* @__PURE__ */ ut(function(t) {
+  var n, r, o, i;
+  let {
+    id: s,
+    accessibility: a,
+    autoScroll: l = !0,
+    children: c,
+    sensors: u = io,
+    collisionDetection: d = xr,
+    measuring: f,
+    modifiers: h,
+    ...b
+  } = t;
+  const g = Nt(co, void 0, lo), [p, m] = g, [w, y] = dr(), [C, x] = V(ye.Uninitialized), I = C === ye.Initialized, {
+    draggable: {
+      active: R,
+      nodes: E,
+      translate: N
+    },
+    droppable: {
+      containers: B
+    }
+  } = p, A = R ? E.get(R) : null, Z = z({
+    initial: null,
+    translated: null
+  }), Q = T(() => {
+    var U;
+    return R != null ? {
+      id: R,
+      // It's possible for the active node to unmount while dragging
+      data: (U = A == null ? void 0 : A.data) != null ? U : so,
+      rect: Z
+    } : null;
+  }, [R, A]), ne = z(null), [xe, De] = V(null), [J, Ce] = V(null), se = Ye(b, Object.values(b)), Se = Je("DndDescribedBy", s), v = T(() => B.getEnabled(), [B]), D = fo(f), {
+    droppableRects: P,
+    measureDroppableContainers: M,
+    measuringScheduled: F
+  } = Wr(v, {
+    dragging: I,
+    dependencies: [N.x, N.y],
+    config: D.droppable
+  }), H = Kr(E, R), K = T(() => J ? at(J) : null, [J]), q = Zn(), W = Jr(H, D.draggable.measure);
+  go({
+    activeNode: R ? E.get(R) : null,
+    config: q.layoutShiftCompensation,
+    initialRect: W,
+    measure: D.draggable.measure
+  });
+  const O = sn(H, D.draggable.measure, W), he = sn(H ? H.parentElement : null), L = z({
+    activatorEvent: null,
+    active: null,
+    activeNode: H,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: P,
+    draggableNodes: E,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: B,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), pe = B.getNodeFor((n = L.current.over) == null ? void 0 : n.id), ae = oo({
+    measure: D.dragOverlay.measure
+  }), Ie = (r = ae.nodeRef.current) != null ? r : H, Re = I ? (o = ae.rect) != null ? o : O : null, Ft = !!(ae.nodeRef.current && ae.rect), Ht = Zr(Ft ? null : O), mt = An(Ie ? G(Ie) : null), ve = Qr(I ? pe ?? H : null), Ge = ro(ve), Ze = Pn(h, {
+    transform: {
+      x: N.x - Ht.x,
+      y: N.y - Ht.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: J,
+    active: Q,
+    activeNodeRect: O,
+    containerNodeRect: he,
+    draggingNodeRect: Re,
+    over: L.current.over,
+    overlayNodeRect: ae.rect,
+    scrollableAncestors: ve,
+    scrollableAncestorRects: Ge,
+    windowRect: mt
+  }), Xt = K ? Ae(K, N) : null, Yt = eo(ve), Vn = ln(Yt), Kn = ln(Yt, [O]), Ee = Ae(Ze, Vn), Oe = Re ? Sr(Re, Ze) : null, ke = Q && Oe ? d({
+    active: Q,
+    collisionRect: Oe,
+    droppableRects: P,
+    droppableContainers: v,
+    pointerCoordinates: Xt
+  }) : null, Vt = yn(ke, "id"), [be, Kt] = V(null), Un = Ft ? Ze : Ae(Ze, Kn), Wn = Dr(Un, (i = be == null ? void 0 : be.rect) != null ? i : null, O), Ut = $(
+    (U, ee) => {
+      let {
+        sensor: te,
+        options: me
+      } = ee;
+      if (ne.current == null)
+        return;
+      const re = E.get(ne.current);
+      if (!re)
+        return;
+      const le = U.nativeEvent, fe = new te({
+        active: ne.current,
+        activeNode: re,
+        event: le,
+        options: me,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: L,
+        onStart(ce) {
+          const ze = ne.current;
+          if (ze == null)
+            return;
+          const Be = E.get(ze);
+          if (!Be)
+            return;
+          const {
+            onDragStart: Qe
+          } = se.current, et = {
+            active: {
+              id: ze,
+              data: Be.data,
+              rect: Z
+            }
+          };
+          je(() => {
+            Qe == null || Qe(et), x(ye.Initializing), m({
+              type: X.DragStart,
+              initialCoordinates: ce,
+              active: ze
+            }), w({
+              type: "onDragStart",
+              event: et
+            });
+          });
+        },
+        onMove(ce) {
+          m({
+            type: X.DragMove,
+            coordinates: ce
+          });
+        },
+        onEnd: Te(X.DragEnd),
+        onCancel: Te(X.DragCancel)
+      });
+      je(() => {
+        De(fe), Ce(U.nativeEvent);
+      });
+      function Te(ce) {
+        return async function() {
+          const {
+            active: Be,
+            collisions: Qe,
+            over: et,
+            scrollAdjustedTranslate: Jt
+          } = L.current;
+          let $e = null;
+          if (Be && Jt) {
+            const {
+              cancelDrop: _e
+            } = se.current;
+            $e = {
+              activatorEvent: le,
+              active: Be,
+              collisions: Qe,
+              delta: Jt,
+              over: et
+            }, ce === X.DragEnd && typeof _e == "function" && await Promise.resolve(_e($e)) && (ce = X.DragCancel);
+          }
+          ne.current = null, je(() => {
+            m({
+              type: ce
+            }), x(ye.Uninitialized), Kt(null), De(null), Ce(null);
+            const _e = ce === X.DragEnd ? "onDragEnd" : "onDragCancel";
+            if ($e) {
+              const yt = se.current[_e];
+              yt == null || yt($e), w({
+                type: _e,
+                event: $e
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [E]
+  ), Jn = $((U, ee) => (te, me) => {
+    const re = te.nativeEvent, le = E.get(me);
+    if (
+      // Another sensor is already instantiating
+      ne.current !== null || // No active draggable
+      !le || // Event has already been captured
+      re.dndKit || re.defaultPrevented
+    )
+      return;
+    const fe = {
+      active: le
+    };
+    U(te, ee.options, fe) === !0 && (re.dndKit = {
+      capturedBy: ee.sensor
+    }, ne.current = me, Ut(te, ee));
+  }, [E, Ut]), Wt = Ur(u, Jn);
+  to(u), ie(() => {
+    O && C === ye.Initializing && x(ye.Initialized);
+  }, [O, C]), k(
+    () => {
+      const {
+        onDragMove: U
+      } = se.current, {
+        active: ee,
+        activatorEvent: te,
+        collisions: me,
+        over: re
+      } = L.current;
+      if (!ee || !te)
+        return;
+      const le = {
+        active: ee,
+        activatorEvent: te,
+        collisions: me,
+        delta: {
+          x: Ee.x,
+          y: Ee.y
+        },
+        over: re
+      };
+      je(() => {
+        U == null || U(le), w({
+          type: "onDragMove",
+          event: le
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [Ee.x, Ee.y]
+  ), k(
+    () => {
+      const {
+        active: U,
+        activatorEvent: ee,
+        collisions: te,
+        droppableContainers: me,
+        scrollAdjustedTranslate: re
+      } = L.current;
+      if (!U || ne.current == null || !ee || !re)
+        return;
+      const {
+        onDragOver: le
+      } = se.current, fe = me.get(Vt), Te = fe && fe.rect.current ? {
+        id: fe.id,
+        rect: fe.rect.current,
+        data: fe.data,
+        disabled: fe.disabled
+      } : null, ce = {
+        active: U,
+        activatorEvent: ee,
+        collisions: te,
+        delta: {
+          x: re.x,
+          y: re.y
+        },
+        over: Te
+      };
+      je(() => {
+        Kt(Te), le == null || le(ce), w({
+          type: "onDragOver",
+          event: ce
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [Vt]
+  ), ie(() => {
+    L.current = {
+      activatorEvent: J,
+      active: Q,
+      activeNode: H,
+      collisionRect: Oe,
+      collisions: ke,
+      droppableRects: P,
+      draggableNodes: E,
+      draggingNode: Ie,
+      draggingNodeRect: Re,
+      droppableContainers: B,
+      over: be,
+      scrollableAncestors: ve,
+      scrollAdjustedTranslate: Ee
+    }, Z.current = {
+      initial: Re,
+      translated: Oe
+    };
+  }, [Q, H, ke, Oe, E, Ie, Re, P, B, be, ve, Ee]), Xr({
+    ...q,
+    delta: N,
+    draggingRect: Oe,
+    pointerCoordinates: Xt,
+    scrollableAncestors: ve,
+    scrollableAncestorRects: Ge
+  });
+  const qn = T(() => ({
+    active: Q,
+    activeNode: H,
+    activeNodeRect: O,
+    activatorEvent: J,
+    collisions: ke,
+    containerNodeRect: he,
+    dragOverlay: ae,
+    draggableNodes: E,
+    droppableContainers: B,
+    droppableRects: P,
+    over: be,
+    measureDroppableContainers: M,
+    scrollableAncestors: ve,
+    scrollableAncestorRects: Ge,
+    measuringConfiguration: D,
+    measuringScheduled: F,
+    windowRect: mt
+  }), [Q, H, O, J, ke, he, ae, E, B, P, be, M, ve, Ge, D, F, mt]), Gn = T(() => ({
+    activatorEvent: J,
+    activators: Wt,
+    active: Q,
+    activeNodeRect: O,
+    ariaDescribedById: {
+      draggable: Se
+    },
+    dispatch: m,
+    draggableNodes: E,
+    over: be,
+    measureDroppableContainers: M
+  }), [J, Wt, Q, O, m, Se, E, be, M]);
+  return j.createElement(vn.Provider, {
+    value: y
+  }, j.createElement(qe.Provider, {
+    value: Gn
+  }, j.createElement(Ln.Provider, {
+    value: qn
+  }, j.createElement(vt.Provider, {
+    value: Wn
+  }, c)), j.createElement(uo, {
+    disabled: (a == null ? void 0 : a.restoreFocus) === !1
+  })), j.createElement(hr, {
+    ...a,
+    hiddenTextDescribedById: Se
+  }));
+  function Zn() {
+    const U = (xe == null ? void 0 : xe.autoScrollEnabled) === !1, ee = typeof l == "object" ? l.enabled === !1 : l === !1, te = I && !U && !ee;
+    return typeof l == "object" ? {
+      ...l,
+      enabled: te
+    } : {
+      enabled: te
+    };
+  }
+}), po = /* @__PURE__ */ Ke(null), cn = "button", vo = "Droppable";
+function bo(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: r = !1,
+    attributes: o
+  } = e;
+  const i = Je(vo), {
+    activators: s,
+    activatorEvent: a,
+    active: l,
+    activeNodeRect: c,
+    ariaDescribedById: u,
+    draggableNodes: d,
+    over: f
+  } = we(qe), {
+    role: h = cn,
+    roleDescription: b = "draggable",
+    tabIndex: g = 0
+  } = o ?? {}, p = (l == null ? void 0 : l.id) === t, m = we(p ? vt : po), [w, y] = ot(), [C, x] = ot(), I = no(s, t), R = Ye(n);
+  ie(
+    () => (d.set(t, {
+      id: t,
+      key: i,
+      node: w,
+      activatorNode: C,
+      data: R
+    }), () => {
+      const N = d.get(t);
+      N && N.key === i && d.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [d, t]
+  );
+  const E = T(() => ({
+    role: h,
+    tabIndex: g,
+    "aria-disabled": r,
+    "aria-pressed": p && h === cn ? !0 : void 0,
+    "aria-roledescription": b,
+    "aria-describedby": u.draggable
+  }), [r, h, g, p, b, u.draggable]);
+  return {
+    active: l,
+    activatorEvent: a,
+    activeNodeRect: c,
+    attributes: E,
+    isDragging: p,
+    listeners: r ? void 0 : I,
+    node: w,
+    over: f,
+    setNodeRef: y,
+    setActivatorNodeRef: x,
+    transform: m
+  };
+}
+function kn() {
+  return we(Ln);
+}
+const mo = "Droppable", yo = {
+  timeout: 25
+};
+function wo(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: r,
+    resizeObserverConfig: o
+  } = e;
+  const i = Je(mo), {
+    active: s,
+    dispatch: a,
+    over: l,
+    measureDroppableContainers: c
+  } = we(qe), u = z({
+    disabled: n
+  }), d = z(!1), f = z(null), h = z(null), {
+    disabled: b,
+    updateMeasurementsFor: g,
+    timeout: p
+  } = {
+    ...yo,
+    ...o
+  }, m = Ye(g ?? r), w = $(
+    () => {
+      if (!d.current) {
+        d.current = !0;
+        return;
+      }
+      h.current != null && clearTimeout(h.current), h.current = setTimeout(() => {
+        c(Array.isArray(m.current) ? m.current : [m.current]), h.current = null;
+      }, p);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [p]
+  ), y = pt({
+    callback: w,
+    disabled: b || !s
+  }), C = $((E, N) => {
+    y && (N && (y.unobserve(N), d.current = !1), E && y.observe(E));
+  }, [y]), [x, I] = ot(C), R = Ye(t);
+  return k(() => {
+    !y || !x.current || (y.disconnect(), d.current = !1, y.observe(x.current));
+  }, [x, y]), ie(
+    () => (a({
+      type: X.RegisterDroppable,
+      element: {
+        id: r,
+        key: i,
+        disabled: n,
+        node: x,
+        rect: f,
+        data: R
+      }
+    }), () => a({
+      type: X.UnregisterDroppable,
+      key: i,
+      id: r
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), k(() => {
+    n !== u.current.disabled && (a({
+      type: X.SetDroppableDisabled,
+      id: r,
+      key: i,
+      disabled: n
+    }), u.current.disabled = n);
+  }, [r, i, n, a]), {
+    active: s,
+    rect: f,
+    isOver: (l == null ? void 0 : l.id) === r,
+    node: x,
+    over: l,
+    setNodeRef: I
+  };
+}
+function xo(e) {
+  let {
+    animation: t,
+    children: n
+  } = e;
+  const [r, o] = V(null), [i, s] = V(null), a = it(n);
+  return !n && !r && a && o(a), ie(() => {
+    if (!i)
+      return;
+    const l = r == null ? void 0 : r.key, c = r == null ? void 0 : r.props.id;
+    if (l == null || c == null) {
+      o(null);
+      return;
+    }
+    Promise.resolve(t(c, i)).then(() => {
+      o(null);
+    });
+  }, [t, r, i]), j.createElement(j.Fragment, null, n, r ? er(r, {
+    ref: s
+  }) : null);
+}
+const Do = {
+  x: 0,
+  y: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+function Co(e) {
+  let {
+    children: t
+  } = e;
+  return j.createElement(qe.Provider, {
+    value: Nn
+  }, j.createElement(vt.Provider, {
+    value: Do
+  }, t));
+}
+const So = {
+  position: "fixed",
+  touchAction: "none"
+}, Io = (e) => ht(e) ? "transform 250ms ease" : void 0, Ro = /* @__PURE__ */ dt((e, t) => {
+  let {
+    as: n,
+    activatorEvent: r,
+    adjustScale: o,
+    children: i,
+    className: s,
+    rect: a,
+    style: l,
+    transform: c,
+    transition: u = Io
+  } = e;
+  if (!a)
+    return null;
+  const d = o ? c : {
+    ...c,
+    scaleX: 1,
+    scaleY: 1
+  }, f = {
+    ...So,
+    width: a.width,
+    height: a.height,
+    top: a.top,
+    left: a.left,
+    transform: ge.Transform.toString(d),
+    transformOrigin: o && r ? vr(r, a) : void 0,
+    transition: typeof u == "function" ? u(r) : u,
+    ...l
+  };
+  return j.createElement(n, {
+    className: s,
+    style: f,
+    ref: t
+  }, i);
+}), Eo = (e) => (t) => {
+  let {
+    active: n,
+    dragOverlay: r
+  } = t;
+  const o = {}, {
+    styles: i,
+    className: s
+  } = e;
+  if (i != null && i.active)
+    for (const [a, l] of Object.entries(i.active))
+      l !== void 0 && (o[a] = n.node.style.getPropertyValue(a), n.node.style.setProperty(a, l));
+  if (i != null && i.dragOverlay)
+    for (const [a, l] of Object.entries(i.dragOverlay))
+      l !== void 0 && r.node.style.setProperty(a, l);
+  return s != null && s.active && n.node.classList.add(s.active), s != null && s.dragOverlay && r.node.classList.add(s.dragOverlay), function() {
+    for (const [l, c] of Object.entries(o))
+      n.node.style.setProperty(l, c);
+    s != null && s.active && n.node.classList.remove(s.active);
+  };
+}, Oo = (e) => {
+  let {
+    transform: {
+      initial: t,
+      final: n
+    }
+  } = e;
+  return [{
+    transform: ge.Transform.toString(t)
+  }, {
+    transform: ge.Transform.toString(n)
+  }];
+}, Tt = {
+  duration: 250,
+  easing: "ease",
+  keyframes: Oo,
+  sideEffects: /* @__PURE__ */ Eo({
+    styles: {
+      active: {
+        opacity: "0"
+      }
+    }
+  })
+};
+function To(e) {
+  let {
+    config: t,
+    draggableNodes: n,
+    droppableContainers: r,
+    measuringConfiguration: o
+  } = e;
+  return gt((i, s) => {
+    if (t === null)
+      return;
+    const a = n.get(i);
+    if (!a)
+      return;
+    const l = a.node.current;
+    if (!l)
+      return;
+    const c = Mn(s);
+    if (!c)
+      return;
+    const {
+      transform: u
+    } = G(s).getComputedStyle(s), d = xn(u);
+    if (!d)
+      return;
+    const f = typeof t == "function" ? t : Ao(t);
+    return On(l, o.draggable.measure), f({
+      active: {
+        id: i,
+        data: a.data,
+        node: l,
+        rect: o.draggable.measure(l)
+      },
+      draggableNodes: n,
+      dragOverlay: {
+        node: s,
+        rect: o.dragOverlay.measure(c)
+      },
+      droppableContainers: r,
+      measuringConfiguration: o,
+      transform: d
+    });
+  });
+}
+function Ao(e) {
+  const {
+    duration: t,
+    easing: n,
+    sideEffects: r,
+    keyframes: o
+  } = {
+    ...Tt,
+    ...e
+  };
+  return (i) => {
+    let {
+      active: s,
+      dragOverlay: a,
+      transform: l,
+      ...c
+    } = i;
+    if (!t)
+      return;
+    const u = {
+      x: a.rect.left - s.rect.left,
+      y: a.rect.top - s.rect.top
+    }, d = {
+      scaleX: l.scaleX !== 1 ? s.rect.width * l.scaleX / a.rect.width : 1,
+      scaleY: l.scaleY !== 1 ? s.rect.height * l.scaleY / a.rect.height : 1
+    }, f = {
+      x: l.x - u.x,
+      y: l.y - u.y,
+      ...d
+    }, h = o({
+      ...c,
+      active: s,
+      dragOverlay: a,
+      transform: {
+        initial: l,
+        final: f
+      }
+    }), [b] = h, g = h[h.length - 1];
+    if (JSON.stringify(b) === JSON.stringify(g))
+      return;
+    const p = r == null ? void 0 : r({
+      active: s,
+      dragOverlay: a,
+      ...c
+    }), m = a.node.animate(h, {
+      duration: t,
+      easing: n,
+      fill: "forwards"
+    });
+    return new Promise((w) => {
+      m.onfinish = () => {
+        p == null || p(), w();
+      };
+    });
+  };
+}
+let un = 0;
+function Mo(e) {
+  return T(() => {
+    if (e != null)
+      return un++, un;
+  }, [e]);
+}
+const No = /* @__PURE__ */ j.memo((e) => {
+  let {
+    adjustScale: t = !1,
+    children: n,
+    dropAnimation: r,
+    style: o,
+    transition: i,
+    modifiers: s,
+    wrapperElement: a = "div",
+    className: l,
+    zIndex: c = 999
+  } = e;
+  const {
+    activatorEvent: u,
+    active: d,
+    activeNodeRect: f,
+    containerNodeRect: h,
+    draggableNodes: b,
+    droppableContainers: g,
+    dragOverlay: p,
+    over: m,
+    measuringConfiguration: w,
+    scrollableAncestors: y,
+    scrollableAncestorRects: C,
+    windowRect: x
+  } = kn(), I = we(vt), R = Mo(d == null ? void 0 : d.id), E = Pn(s, {
+    activatorEvent: u,
+    active: d,
+    activeNodeRect: f,
+    containerNodeRect: h,
+    draggingNodeRect: p.rect,
+    over: m,
+    overlayNodeRect: p.rect,
+    scrollableAncestors: y,
+    scrollableAncestorRects: C,
+    transform: I,
+    windowRect: x
+  }), N = jt(f), B = To({
+    config: r,
+    draggableNodes: b,
+    droppableContainers: g,
+    measuringConfiguration: w
+  }), A = N ? p.setRef : void 0;
+  return j.createElement(Co, null, j.createElement(xo, {
+    animation: B
+  }, d && R ? j.createElement(Ro, {
+    key: R,
+    id: d.id,
+    ref: A,
+    as: a,
+    activatorEvent: u,
+    adjustScale: t,
+    className: l,
+    transition: i,
+    rect: N,
+    style: {
+      zIndex: c,
+      ...o
+    },
+    transform: E
+  }, n) : null));
+});
+function Ve(e, t, n) {
+  const r = e.slice();
+  return r.splice(n < 0 ? r.length + n : n, 0, r.splice(t, 1)[0]), r;
+}
+function Lo(e, t) {
+  return e.reduce((n, r, o) => {
+    const i = t.get(r);
+    return i && (n[o] = i), n;
+  }, Array(e.length));
+}
+function tt(e) {
+  return e !== null && e >= 0;
+}
+function Po(e, t) {
+  if (e === t)
+    return !0;
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+function ko(e) {
+  return typeof e == "boolean" ? {
+    draggable: e,
+    droppable: e
+  } : e;
+}
+const zn = (e) => {
+  let {
+    rects: t,
+    activeIndex: n,
+    overIndex: r,
+    index: o
+  } = e;
+  const i = Ve(t, r, n), s = t[o], a = i[o];
+  return !a || !s ? null : {
+    x: a.left - s.left,
+    y: a.top - s.top,
+    scaleX: a.width / s.width,
+    scaleY: a.height / s.height
+  };
+}, nt = {
+  scaleX: 1,
+  scaleY: 1
+}, zo = (e) => {
+  var t;
+  let {
+    activeIndex: n,
+    activeNodeRect: r,
+    index: o,
+    rects: i,
+    overIndex: s
+  } = e;
+  const a = (t = i[n]) != null ? t : r;
+  if (!a)
+    return null;
+  if (o === n) {
+    const c = i[s];
+    return c ? {
+      x: 0,
+      y: n < s ? c.top + c.height - (a.top + a.height) : c.top - a.top,
+      ...nt
+    } : null;
+  }
+  const l = Bo(i, o, n);
+  return o > n && o <= s ? {
+    x: 0,
+    y: -a.height - l,
+    ...nt
+  } : o < n && o >= s ? {
+    x: 0,
+    y: a.height + l,
+    ...nt
+  } : {
+    x: 0,
+    y: 0,
+    ...nt
+  };
+};
+function Bo(e, t, n) {
+  const r = e[t], o = e[t - 1], i = e[t + 1];
+  return r ? n < t ? o ? r.top - (o.top + o.height) : i ? i.top - (r.top + r.height) : 0 : i ? i.top - (r.top + r.height) : o ? r.top - (o.top + o.height) : 0 : 0;
+}
+const Bn = "Sortable", $n = /* @__PURE__ */ j.createContext({
+  activeIndex: -1,
+  containerId: Bn,
+  disableTransforms: !1,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: !1,
+  sortedRects: [],
+  strategy: zn,
+  disabled: {
+    draggable: !1,
+    droppable: !1
+  }
+});
+function $o(e) {
+  let {
+    children: t,
+    id: n,
+    items: r,
+    strategy: o = zn,
+    disabled: i = !1
+  } = e;
+  const {
+    active: s,
+    dragOverlay: a,
+    droppableRects: l,
+    over: c,
+    measureDroppableContainers: u
+  } = kn(), d = Je(Bn, n), f = a.rect !== null, h = T(() => r.map((I) => typeof I == "object" && "id" in I ? I.id : I), [r]), b = s != null, g = s ? h.indexOf(s.id) : -1, p = c ? h.indexOf(c.id) : -1, m = z(h), w = !Po(h, m.current), y = p !== -1 && g === -1 || w, C = ko(i);
+  ie(() => {
+    w && b && u(h);
+  }, [w, h, b, u]), k(() => {
+    m.current = h;
+  }, [h]);
+  const x = T(
+    () => ({
+      activeIndex: g,
+      containerId: d,
+      disabled: C,
+      disableTransforms: y,
+      items: h,
+      overIndex: p,
+      useDragOverlay: f,
+      sortedRects: Lo(h, l),
+      strategy: o
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [g, d, C.draggable, C.droppable, y, h, p, l, f, o]
+  );
+  return j.createElement($n.Provider, {
+    value: x
+  }, t);
+}
+const _o = (e) => {
+  let {
+    id: t,
+    items: n,
+    activeIndex: r,
+    overIndex: o
+  } = e;
+  return Ve(n, r, o).indexOf(t);
+}, jo = (e) => {
+  let {
+    containerId: t,
+    isSorting: n,
+    wasDragging: r,
+    index: o,
+    items: i,
+    newIndex: s,
+    previousItems: a,
+    previousContainerId: l,
+    transition: c
+  } = e;
+  return !c || !r || a !== i && o === s ? !1 : n ? !0 : s !== o && t === l;
+}, Fo = {
+  duration: 200,
+  easing: "ease"
+}, _n = "transform", Ho = /* @__PURE__ */ ge.Transition.toString({
+  property: _n,
+  duration: 0,
+  easing: "linear"
+}), Xo = {
+  roleDescription: "sortable"
+};
+function Yo(e) {
+  let {
+    disabled: t,
+    index: n,
+    node: r,
+    rect: o
+  } = e;
+  const [i, s] = V(null), a = z(n);
+  return ie(() => {
+    if (!t && n !== a.current && r.current) {
+      const l = o.current;
+      if (l) {
+        const c = Pe(r.current, {
+          ignoreTransform: !0
+        }), u = {
+          x: l.left - c.left,
+          y: l.top - c.top,
+          scaleX: l.width / c.width,
+          scaleY: l.height / c.height
+        };
+        (u.x || u.y) && s(u);
+      }
+    }
+    n !== a.current && (a.current = n);
+  }, [t, n, r, o]), k(() => {
+    i && s(null);
+  }, [i]), i;
+}
+function Vo(e) {
+  let {
+    animateLayoutChanges: t = jo,
+    attributes: n,
+    disabled: r,
+    data: o,
+    getNewIndex: i = _o,
+    id: s,
+    strategy: a,
+    resizeObserverConfig: l,
+    transition: c = Fo
+  } = e;
+  const {
+    items: u,
+    containerId: d,
+    activeIndex: f,
+    disabled: h,
+    disableTransforms: b,
+    sortedRects: g,
+    overIndex: p,
+    useDragOverlay: m,
+    strategy: w
+  } = we($n), y = Ko(r, h), C = u.indexOf(s), x = T(() => ({
+    sortable: {
+      containerId: d,
+      index: C,
+      items: u
+    },
+    ...o
+  }), [d, o, C, u]), I = T(() => u.slice(u.indexOf(s)), [u, s]), {
+    rect: R,
+    node: E,
+    isOver: N,
+    setNodeRef: B
+  } = wo({
+    id: s,
+    data: x,
+    disabled: y.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: I,
+      ...l
+    }
+  }), {
+    active: A,
+    activatorEvent: Z,
+    activeNodeRect: Q,
+    attributes: ne,
+    setNodeRef: xe,
+    listeners: De,
+    isDragging: J,
+    over: Ce,
+    setActivatorNodeRef: se,
+    transform: Se
+  } = bo({
+    id: s,
+    data: x,
+    attributes: {
+      ...Xo,
+      ...n
+    },
+    disabled: y.draggable
+  }), v = tr(B, xe), D = !!A, P = D && !b && tt(f) && tt(p), M = !m && J, F = M && P ? Se : null, K = P ? F ?? (a ?? w)({
+    rects: g,
+    activeNodeRect: Q,
+    activeIndex: f,
+    overIndex: p,
+    index: C
+  }) : null, q = tt(f) && tt(p) ? i({
+    id: s,
+    items: u,
+    activeIndex: f,
+    overIndex: p
+  }) : C, W = A == null ? void 0 : A.id, O = z({
+    activeId: W,
+    items: u,
+    newIndex: q,
+    containerId: d
+  }), he = u !== O.current.items, L = t({
+    active: A,
+    containerId: d,
+    isDragging: J,
+    isSorting: D,
+    id: s,
+    index: C,
+    items: u,
+    newIndex: O.current.newIndex,
+    previousItems: O.current.items,
+    previousContainerId: O.current.containerId,
+    transition: c,
+    wasDragging: O.current.activeId != null
+  }), pe = Yo({
+    disabled: !L,
+    index: C,
+    node: E,
+    rect: R
+  });
+  return k(() => {
+    D && O.current.newIndex !== q && (O.current.newIndex = q), d !== O.current.containerId && (O.current.containerId = d), u !== O.current.items && (O.current.items = u);
+  }, [D, q, d, u]), k(() => {
+    if (W === O.current.activeId)
+      return;
+    if (W && !O.current.activeId) {
+      O.current.activeId = W;
+      return;
+    }
+    const Ie = setTimeout(() => {
+      O.current.activeId = W;
+    }, 50);
+    return () => clearTimeout(Ie);
+  }, [W]), {
+    active: A,
+    activeIndex: f,
+    attributes: ne,
+    data: x,
+    rect: R,
+    index: C,
+    newIndex: q,
+    items: u,
+    isOver: N,
+    isSorting: D,
+    isDragging: J,
+    listeners: De,
+    node: E,
+    overIndex: p,
+    over: Ce,
+    setNodeRef: v,
+    setActivatorNodeRef: se,
+    setDroppableNodeRef: B,
+    setDraggableNodeRef: xe,
+    transform: pe ?? K,
+    transition: ae()
+  };
+  function ae() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      pe || // Or to prevent items jumping to back to their "new" position when items change
+      he && O.current.newIndex === C
+    )
+      return Ho;
+    if (!(M && !ht(Z) || !c) && (D || L))
+      return ge.Transition.toString({
+        ...c,
+        property: _n
+      });
+  }
+}
+function Ko(e, t) {
+  var n, r;
+  return typeof e == "boolean" ? {
+    draggable: e,
+    // Backwards compatibility
+    droppable: !1
+  } : {
+    draggable: (n = e == null ? void 0 : e.draggable) != null ? n : t.draggable,
+    droppable: (r = e == null ? void 0 : e.droppable) != null ? r : t.droppable
+  };
+}
+S.Down, S.Right, S.Up, S.Left;
+const Uo = /iPad|iPhone|iPod/.test(navigator.platform);
+function Wo(e, t) {
+  return Math.round(e / t);
+}
+function At(e, t, n, r, o) {
+  const i = e.findIndex(({ id: m }) => m === n), s = e.findIndex(({ id: m }) => m === t), a = e[s], l = Ve(e, s, i), c = l[i - 1], u = l[i + 1], d = Wo(r, o), f = a.depth + d, h = Jo({
+    previousItem: c
+  }), b = qo({ nextItem: u });
+  let g = f;
+  return f >= h ? g = h : f < b && (g = b), { depth: g, maxDepth: h, minDepth: b, parentId: p() };
+  function p() {
+    var w;
+    return g === 0 || !c ? null : g === c.depth ? c.parentId : g > c.depth ? c.id : ((w = l.slice(0, i).reverse().find((y) => y.depth === g)) == null ? void 0 : w.parentId) ?? null;
+  }
+}
+function Jo({ previousItem: e }) {
+  return e ? e.depth + 1 : 0;
+}
+function qo({ nextItem: e }) {
+  return e ? e.depth : 0;
+}
+function jn(e, t = null, n = 0) {
+  return e.reduce((r, o, i) => (r.push({ ...o, parentId: t, depth: n, index: i }), r.push(...jn(o.children, o.id, n + 1)), r), []);
+}
+function It(e) {
+  return jn(e);
+}
+function Go(e) {
+  const t = { id: "root", label: "", children: [] }, n = { [t.id]: t }, r = e.map((o) => ({ ...o, children: [] }));
+  for (const o of r) {
+    const { id: i, children: s, label: a } = o, l = o.parentId ?? t.id, c = n[l] ?? Zo(r, l);
+    n[i] = { id: i, label: a, children: s }, c.children.push(o);
+  }
+  return t.children;
+}
+function Zo(e, t) {
+  return e.find(({ id: n }) => n === t);
+}
+function Fn(e, t) {
+  for (const n of e) {
+    const { id: r, children: o } = n;
+    if (r === t)
+      return n;
+    if (o.length) {
+      const i = Fn(o, t);
+      if (i)
+        return i;
+    }
+  }
+}
+function Qo(e, t) {
+  const { items: n, itemMap: r } = e, o = new Map(r);
+  function i(a) {
+    return a.filter((l) => l.id === t ? (o.delete(t), !1) : (l.children.length && (l.children = i(l.children)), !0));
+  }
+  return { items: i(n), itemMap: o };
+}
+function ei(e, t, n) {
+  const { items: r, itemMap: o } = e, i = o.get(t);
+  if (!i) return e;
+  const s = { ...i, ...n(i) }, a = new Map(o);
+  a.set(t, s);
+  function l(u) {
+    return u.map((d) => d.id === t ? (s.children && s.children.forEach((f) => {
+      a.set(f.id, f);
+    }), s) : d.children.length ? { ...d, children: l(d.children) } : d);
+  }
+  return { items: l(r), itemMap: a };
+}
+function ti(e) {
+  const t = /* @__PURE__ */ new Map();
+  function n(r) {
+    t.set(r.id, r), r.children.forEach(n);
+  }
+  return e.forEach(n), { items: e, itemMap: t };
+}
+function Hn(e, t = 0) {
+  return e.reduce((n, { children: r }) => r.length ? Hn(r, n + 1) : n + 1, t);
+}
+function ni(e, t) {
+  const n = Fn(e, t);
+  return n ? Hn(n.children) : 0;
+}
+function ri(e, t) {
+  const n = [...t];
+  return e.filter((r) => r.parentId && n.includes(r.parentId) ? (r.children.length && n.push(r.id), !1) : !0);
+}
+const oi = [
+  S.Down,
+  S.Right,
+  S.Up,
+  S.Left
+], ii = [S.Left, S.Right], si = (e, t, n) => (r, {
+  currentCoordinates: o,
+  context: { active: i, over: s, collisionRect: a, droppableRects: l, droppableContainers: c }
+}) => {
+  if (oi.includes(r.code)) {
+    if (!i || !a)
+      return;
+    r.preventDefault();
+    const {
+      current: { items: u, offset: d }
+    } = e;
+    if (ii.includes(r.code) && (s != null && s.id)) {
+      const { depth: g, maxDepth: p, minDepth: m } = At(
+        u,
+        i.id,
+        s.id,
+        d,
+        n
+      );
+      switch (r.code) {
+        case S.Left:
+          if (g > m)
+            return {
+              ...o,
+              x: o.x - n
+            };
+          break;
+        case S.Right:
+          if (g < p)
+            return {
+              ...o,
+              x: o.x + n
+            };
+          break;
+      }
+      return;
+    }
+    const f = [];
+    c.forEach((g) => {
+      if (g != null && g.disabled || g.id === (s == null ? void 0 : s.id))
+        return;
+      const p = l.get(g.id);
+      if (p)
+        switch (r.code) {
+          case S.Down:
+            a.top < p.top && f.push(g);
+            break;
+          case S.Up:
+            a.top > p.top && f.push(g);
+            break;
+        }
+    });
+    const h = yr({
+      active: i,
+      collisionRect: a,
+      pointerCoordinates: null,
+      droppableRects: l,
+      droppableContainers: f
+    });
+    let b = yn(h, "id");
+    if (b === (s == null ? void 0 : s.id) && h.length > 1 && (b = h[1].id), b && (s != null && s.id)) {
+      const g = l.get(i.id), p = l.get(b), m = c.get(b);
+      if (g && p && m) {
+        const w = u.findIndex(({ id: I }) => I === b), y = u[w], C = u.findIndex(({ id: I }) => I === i.id), x = u[C];
+        if (y && x) {
+          const { depth: I } = At(
+            u,
+            i.id,
+            b,
+            (y.depth - x.depth) * n,
+            n
+          ), E = w > C ? 1 : -1, N = t ? (a.height - g.height) / 2 : 0;
+          return {
+            x: p.left + I * n,
+            y: p.top + E * N
+          };
+        }
+      }
+    }
+  }
+}, ai = "_Wrapper_1ewsl_1", li = "_clone_1ewsl_8", ci = "_TreeItem_1ewsl_16", ui = "_ghost_1ewsl_23", di = "_indicator_1ewsl_23", fi = "_Text_1ewsl_78", gi = "_Count_1ewsl_90", hi = "_disableInteraction_1ewsl_106", pi = "_disableSelection_1ewsl_110", vi = "_Collapse_1ewsl_118", bi = "_collapsed_1ewsl_122", ue = {
+  Wrapper: ai,
+  clone: li,
+  TreeItem: ci,
+  ghost: ui,
+  indicator: di,
+  Text: fi,
+  Count: gi,
+  disableInteraction: hi,
+  disableSelection: pi,
+  Collapse: vi,
+  collapsed: bi
+};
+function mi(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var Xn = { exports: {} };
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+(function(e) {
+  (function() {
+    var t = {}.hasOwnProperty;
+    function n() {
+      for (var i = "", s = 0; s < arguments.length; s++) {
+        var a = arguments[s];
+        a && (i = o(i, r(a)));
+      }
+      return i;
+    }
+    function r(i) {
+      if (typeof i == "string" || typeof i == "number")
+        return i;
+      if (typeof i != "object")
+        return "";
+      if (Array.isArray(i))
+        return n.apply(null, i);
+      if (i.toString !== Object.prototype.toString && !i.toString.toString().includes("[native code]"))
+        return i.toString();
+      var s = "";
+      for (var a in i)
+        t.call(i, a) && i[a] && (s = o(s, a));
+      return s;
+    }
+    function o(i, s) {
+      return s ? i ? i + " " + s : i + s : i;
+    }
+    e.exports ? (n.default = n, e.exports = n) : window.classNames = n;
+  })();
+})(Xn);
+var yi = Xn.exports;
+const Mt = /* @__PURE__ */ mi(yi), wi = "_Action_1vzup_1", xi = {
+  Action: wi
+}, bt = dt(
+  ({ active: e, className: t, cursor: n, style: r, ...o }, i) => /* @__PURE__ */ _(
+    "button",
+    {
+      ref: i,
+      ...o,
+      className: Mt(xi.Action, t),
+      tabIndex: 0,
+      style: {
+        ...r,
+        cursor: n,
+        "--fill": e == null ? void 0 : e.fill,
+        "--background": e == null ? void 0 : e.background
+      }
+    }
+  )
+), Di = dt(
+  (e, t) => /* @__PURE__ */ _(
+    bt,
+    {
+      ref: t,
+      cursor: "grab",
+      "data-cypress": "draggable-handle",
+      ...e,
+      children: /* @__PURE__ */ _("svg", { viewBox: "0 0 20 20", width: "12", children: /* @__PURE__ */ _("path", { d: "M7 2a2 2 0 1 0 .001 4.001A2 2 0 0 0 7 2zm0 6a2 2 0 1 0 .001 4.001A2 2 0 0 0 7 8zm0 6a2 2 0 1 0 .001 4.001A2 2 0 0 0 7 14zm6-8a2 2 0 1 0-.001-4.001A2 2 0 0 0 13 6zm0 2a2 2 0 1 0 .001 4.001A2 2 0 0 0 13 8zm0 6a2 2 0 1 0 .001 4.001A2 2 0 0 0 13 14z" }) })
+    }
+  )
+);
+function Ci(e) {
+  return /* @__PURE__ */ _(
+    bt,
+    {
+      ...e,
+      active: {
+        fill: "rgba(255, 70, 70, 0.95)",
+        background: "rgba(255, 70, 70, 0.1)"
+      },
+      children: /* @__PURE__ */ _(
+        "svg",
+        {
+          width: "18",
+          height: "18",
+          viewBox: "0 0 18 18",
+          fill: "none",
+          xmlns: "http://www.w3.org/2000/svg",
+          children: /* @__PURE__ */ _("path", { d: "M5.5 1C5.22386 1 5 1.22386 5 1.5C5 1.77614 5.22386 2 5.5 2H9.5C9.77614 2 10 1.77614 10 1.5C10 1.22386 9.77614 1 9.5 1H5.5ZM3 3.5C3 3.22386 3.22386 3 3.5 3H5H10H11.5C11.7761 3 12 3.22386 12 3.5C12 3.77614 11.7761 4 11.5 4H11V12C11 12.5523 10.5523 13 10 13H5C4.44772 13 4 12.5523 4 12V4L3.5 4C3.22386 4 3 3.77614 3 3.5ZM5 4H10V12H5V4Z" })
+        }
+      )
+    }
+  );
+}
+function Si(e) {
+  return /* @__PURE__ */ _(
+    bt,
+    {
+      ...e,
+      active: {
+        fill: "rgba(255, 70, 70, 0.95)",
+        background: "rgba(255, 70, 70, 0.1)"
+      },
+      children: /* @__PURE__ */ _(
+        "svg",
+        {
+          width: "18",
+          height: "18",
+          viewBox: "0 0 18 18",
+          fill: "none",
+          xmlns: "http://www.w3.org/2000/svg",
+          children: /* @__PURE__ */ _("path", { d: "M8 2.75C8 2.47386 7.77614 2.25 7.5 2.25C7.22386 2.25 7 2.47386 7 2.75V7H2.75C2.47386 7 2.25 7.22386 2.25 7.5C2.25 7.77614 2.47386 8 2.75 8H7V12.25C7 12.5261 7.22386 12.75 7.5 12.75C7.77614 12.75 8 12.5261 8 12.25V8H12.25C12.5261 8 12.75 7.77614 12.75 7.5C12.75 7.22386 12.5261 7 12.25 7H8V2.75Z" })
+        }
+      )
+    }
+  );
+}
+const Ii = dt(
+  ({
+    childCount: e,
+    clone: t,
+    depth: n,
+    disableSelection: r,
+    disableInteraction: o,
+    disableDragging: i,
+    ghost: s,
+    handleProps: a,
+    indentationWidth: l,
+    indicator: c,
+    collapsed: u,
+    onCollapse: d,
+    onRemove: f,
+    onAdd: h,
+    onLabelClick: b,
+    style: g,
+    value: p,
+    wrapperRef: m,
+    ...w
+  }, y) => /* @__PURE__ */ _(
+    "li",
+    {
+      className: Mt(
+        ue.Wrapper,
+        t && ue.clone,
+        s && ue.ghost,
+        c && ue.indicator,
+        r && ue.disableSelection,
+        o && ue.disableInteraction
+      ),
+      ref: m,
+      style: {
+        "--spacing": `${l * n}px`
+      },
+      ...w,
+      children: /* @__PURE__ */ fn("div", { className: ue.TreeItem, ref: y, style: g, children: [
+        !i && /* @__PURE__ */ _(Di, { ...a }),
+        d && /* @__PURE__ */ _(bt, { onClick: d, className: Mt(ue.Collapse, u && ue.collapsed), children: Ri }),
+        /* @__PURE__ */ _("span", { onClick: b, className: ue.Text, children: p }),
+        !t && f && /* @__PURE__ */ _(Ci, { onClick: f }),
+        !t && h && /* @__PURE__ */ _(Si, { onClick: h }),
+        t && e && e > 1 ? /* @__PURE__ */ _("span", { className: ue.Count, children: e }) : null
+      ] })
+    }
+  )
+), Ri = /* @__PURE__ */ _("svg", { width: "10", xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 70 41", children: /* @__PURE__ */ _("path", { d: "M30.76 39.2402C31.885 40.3638 33.41 40.995 35 40.995C36.59 40.995 38.115 40.3638 39.24 39.2402L68.24 10.2402C69.2998 9.10284 69.8768 7.59846 69.8494 6.04406C69.822 4.48965 69.1923 3.00657 68.093 1.90726C66.9937 0.807959 65.5106 0.178263 63.9562 0.150837C62.4018 0.123411 60.8974 0.700397 59.76 1.76024L35 26.5102L10.24 1.76024C9.10259 0.700397 7.59822 0.123411 6.04381 0.150837C4.4894 0.178263 3.00632 0.807959 1.90702 1.90726C0.807714 3.00657 0.178019 4.48965 0.150593 6.04406C0.123167 7.59846 0.700153 9.10284 1.75999 10.2402L30.76 39.2402Z" }) }), Ei = ut(Ii), Oi = ({ isSorting: e, wasDragging: t }) => !(e || t);
+function Ti({ id: e, depth: t, ...n }) {
+  const {
+    attributes: r,
+    isDragging: o,
+    isSorting: i,
+    listeners: s,
+    setDraggableNodeRef: a,
+    setDroppableNodeRef: l,
+    transform: c,
+    transition: u
+  } = Vo({
+    id: e,
+    animateLayoutChanges: Oi
+  }), d = {
+    transform: ge.Translate.toString(c),
+    transition: u
+  };
+  return /* @__PURE__ */ _(
+    Ei,
+    {
+      ref: a,
+      wrapperRef: l,
+      style: d,
+      depth: t,
+      ghost: o,
+      disableSelection: Uo,
+      disableInteraction: i,
+      handleProps: n.disableDragging ? null : {
+        ...r,
+        ...s
+      },
+      ...n
+    }
+  );
+}
+const dn = ut(Ti), Ai = {
+  droppable: {
+    strategy: Me.Always
+  }
+}, Mi = {
+  keyframes({ transform: e }) {
+    return [
+      { opacity: 1, transform: ge.Transform.toString(e.initial) },
+      {
+        opacity: 0,
+        transform: ge.Transform.toString({
+          ...e.final,
+          x: e.final.x + 5,
+          y: e.final.y + 5
+        })
+      }
+    ];
+  },
+  easing: "ease-out",
+  sideEffects({ active: e }) {
+    e.node.animate([{ opacity: 0 }, { opacity: 1 }], {
+      duration: Tt.duration,
+      easing: Tt.easing
+    });
+  }
+};
+function Ni({
+  items: e,
+  onItemsChange: t,
+  isCollapsible: n,
+  onLazyLoadChildren: r,
+  showDropIndicator: o = !1,
+  indentationWidth: i = 50,
+  isRemovable: s,
+  onRemoveItem: a,
+  allowNestedItemAddition: l,
+  onAddItem: c,
+  onDragEnd: u,
+  onItemClick: d
+}) {
+  const [f, h] = V(null), [b, g] = V(null), [p, m] = V(0), [w, y] = V(null), C = T(() => {
+    let v = It(e);
+    const D = v.filter(({ parentId: M }) => !M);
+    D.length === 1 && (v = v.map(
+      (M) => M.id === D[0].id ? {
+        ...M,
+        disableDragging: !0
+      } : M
+    ));
+    const P = v.reduce((M, { children: F, collapsed: H, id: K }) => (H && F.length && M.push(K), M), []);
+    return ri(v, f ? [f, ...P] : P);
+  }, [f, e]), x = f && b ? At(C, f, b, p, i) : null, I = z({
+    items: C,
+    offset: p
+  }), [R] = V(
+    () => si(I, o, i)
+  ), E = pr(
+    Gt(_t),
+    Gt(Bt, {
+      coordinateGetter: R
+    })
+  ), N = T(() => C.map(({ id: v }) => v), [C]), B = f ? C.find(({ id: v }) => v === f) : null;
+  k(() => {
+    I.current = {
+      items: C,
+      offset: p
+    };
+  }, [C, p]);
+  const A = $(
+    ({ active: { id: v } }) => {
+      h(v), g(v);
+      const D = C.find(({ id: P }) => P === v);
+      D && y({
+        parentId: D.parentId,
+        overId: v
+      }), document.body.style.setProperty("cursor", "grabbing");
+    },
+    [C]
+  ), Z = $(({ delta: v }) => {
+    m(v.x);
+  }, []), Q = $(({ over: v }) => {
+    g((v == null ? void 0 : v.id) ?? null);
+  }, []), ne = $(
+    ({ active: v, over: D }) => {
+      if (De(), x && D) {
+        const { depth: P, parentId: M } = x, F = JSON.parse(JSON.stringify(It(e))), H = F.findIndex(({ id: L }) => L === D.id), K = F.findIndex(({ id: L }) => L === v.id), q = F[K];
+        F[K] = { ...q, depth: P, parentId: M };
+        const W = Ve(F, K, H), O = Go(W), he = Yn(O, F[K].id, M);
+        t(ti(O)), u == null || u(he);
+      }
+    },
+    [e, x]
+  ), xe = $(() => {
+    De();
+  }, []), De = $(() => {
+    g(null), h(null), m(0), y(null), document.body.style.setProperty("cursor", "");
+  }, []), J = $((v) => {
+    t((D) => Qo(D, v));
+  }, []), Ce = $(
+    ({
+      id: v,
+      canFetchChildren: D,
+      collapsed: P
+    }) => D ? r == null ? void 0 : r(v, !!P) : t(
+      (M) => ei(M, v, (F) => ({ collapsed: !F.collapsed }))
+    ),
+    []
+  ), se = $(
+    (v, D, P) => {
+      if (P && x) {
+        if (v !== "onDragEnd") {
+          if (w && x.parentId === w.parentId && P === w.overId)
+            return;
+          y({
+            parentId: x.parentId,
+            overId: P
+          });
+        }
+        const M = JSON.parse(JSON.stringify(It(e))), F = M.findIndex(({ id: L }) => L === P), H = M.findIndex(({ id: L }) => L === D), K = Ve(M, H, F), q = K[F - 1];
+        let W;
+        const O = v === "onDragEnd" ? "dropped" : "moved", he = v === "onDragEnd" ? "dropped" : "nested";
+        if (q)
+          if (x.depth > q.depth)
+            W = `${D} was ${he} under ${q.id}.`;
+          else {
+            let L = q;
+            for (; L && x.depth < L.depth; ) {
+              const pe = L.parentId;
+              L = K.find(({ id: ae }) => ae === pe);
+            }
+            L && (W = `${D} was ${O} after ${L.id}.`);
+          }
+        else {
+          const L = K[F + 1];
+          W = `${D} was ${O} before ${L.id}.`;
+        }
+        return W;
+      }
+    },
+    [w, e, x]
+  );
+  return /* @__PURE__ */ _(
+    ho,
+    {
+      accessibility: { announcements: {
+        onDragStart({ active: v }) {
+          return `Picked up ${v.id}.`;
+        },
+        onDragMove({ active: v, over: D }) {
+          return se("onDragMove", v.id, D == null ? void 0 : D.id);
+        },
+        onDragOver({ active: v, over: D }) {
+          return se("onDragOver", v.id, D == null ? void 0 : D.id);
+        },
+        onDragEnd({ active: v, over: D }) {
+          return se("onDragEnd", v.id, D == null ? void 0 : D.id);
+        },
+        onDragCancel({ active: v }) {
+          return `Moving was cancelled. ${v.id} was dropped in its original position.`;
+        }
+      } },
+      sensors: E,
+      collisionDetection: mr,
+      measuring: Ai,
+      onDragStart: A,
+      onDragMove: Z,
+      onDragOver: Q,
+      onDragEnd: ne,
+      onDragCancel: xe,
+      children: /* @__PURE__ */ fn($o, { items: N, strategy: zo, children: [
+        C.map(({ id: v, label: D, children: P, collapsed: M, depth: F, canFetchChildren: H, disableDragging: K }) => /* @__PURE__ */ _(
+          dn,
+          {
+            id: v,
+            value: D,
+            disableDragging: !!K,
+            depth: v === f && x ? x.depth : F,
+            indentationWidth: i,
+            indicator: o,
+            collapsed: !!(M && (P.length || H)),
+            onCollapse: n && (P.length || H) ? () => Ce({ id: v, canFetchChildren: H, collapsed: M }) : void 0,
+            onRemove: s ? () => a ? a(v) : J(v) : void 0,
+            onAdd: l ? () => c == null ? void 0 : c(v) : void 0,
+            onLabelClick: d ? () => d(v) : void 0
+          },
+          v
+        )),
+        gn(
+          /* @__PURE__ */ _(
+            No,
+            {
+              dropAnimation: Mi,
+              modifiers: o ? [Li] : void 0,
+              children: f && B ? /* @__PURE__ */ _(
+                dn,
+                {
+                  id: f,
+                  depth: B.depth,
+                  clone: !0,
+                  childCount: ni(e, f) + 1,
+                  value: B.label,
+                  indentationWidth: i
+                }
+              ) : null
+            }
+          ),
+          document.body
+        )
+      ] })
+    }
+  );
+}
+const Li = ({ transform: e }) => ({
+  ...e,
+  y: e.y - 25
+});
+function Yn(e, t, n = null) {
+  for (let r = 0; r < e.length; r++) {
+    const o = e[r];
+    if (o.id === t)
+      return { index: r, parent: n, movedItem: o };
+    if (o.children && o.children.length > 0) {
+      const i = Yn(o.children, t, o.id);
+      if (i)
+        return i;
+    }
+  }
+  return null;
+}
+const Bi = ut(Ni);
+export {
+  Bi as SortableTree,
+  ti as createOptimizedTreeStructure,
+  Qo as removeItemById,
+  ei as setTreeItemProperties
+};
+//# sourceMappingURL=react-sortable-tree.js.map