@lanaco/lnc-react-ui 3.11.35 → 4.0.2

package/dist/Kanban.js

@@ -0,0 +1,4793 @@
+import { jsx as ae, jsxs as pn } from "react/jsx-runtime";
+import k, { useEffect as K, useLayoutEffect as hi, useRef as Y, useMemo as j, useCallback as be, useState as he, createContext as kt, memo as pi, useReducer as Yn, useContext as vt, cloneElement as vi, forwardRef as Nr } from "react";
+import { r as At } from "./index-CZJEA84h.js";
+import { c as un, g as bi, P as W } from "./index-Ds9PUTwb.js";
+import { b as Mt, r as Ot, j as Tt } from "./utils-DEke8iwo.js";
+import { c as pr } from "./index-BklgDeu4.js";
+import { n as Pt } from "./emotion-styled.browser.esm-BZSYYThs.js";
+import { u as kn } from "./emotion-element-5486c51c.browser.esm-CSejtOeT.js";
+import { H as yi, K as mi } from "./KanbanCard-D9OhU8C6.js";
+import { c as wi } from "./index-B_da1uvD.js";
+import xi from "./KanbanHeader.js";
+import { u as Ci } from "./useUpdateEffect-CuYWz7EA.js";
+var Di = function(e) {
+  K(e, []);
+};
+function Si() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return j(
+    () => (o) => {
+      t.forEach((i) => i(o));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const Dn = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function $t(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 Gn(e) {
+  return "nodeType" in e;
+}
+function Se(e) {
+  var t, n;
+  return e ? $t(e) ? e : Gn(e) && (t = (n = e.ownerDocument) == null ? void 0 : n.defaultView) != null ? t : window : window;
+}
+function Wn(e) {
+  const {
+    Document: t
+  } = Se(e);
+  return e instanceof t;
+}
+function Gt(e) {
+  return $t(e) ? !1 : e instanceof Se(e).HTMLElement;
+}
+function Mr(e) {
+  return e instanceof Se(e).SVGElement;
+}
+function Bt(e) {
+  return e ? $t(e) ? e.document : Gn(e) ? Wn(e) ? e : Gt(e) || Mr(e) ? e.ownerDocument : document : document : document;
+}
+const Ue = Dn ? hi : K;
+function Sn(e) {
+  const t = Y(e);
+  return Ue(() => {
+    t.current = e;
+  }), be(function() {
+    for (var n = arguments.length, o = new Array(n), i = 0; i < n; i++)
+      o[i] = arguments[i];
+    return t.current == null ? void 0 : t.current(...o);
+  }, []);
+}
+function Ri() {
+  const e = Y(null), t = be((o, i) => {
+    e.current = setInterval(o, i);
+  }, []), n = be(() => {
+    e.current !== null && (clearInterval(e.current), e.current = null);
+  }, []);
+  return [t, n];
+}
+function Yt(e, t) {
+  t === void 0 && (t = [e]);
+  const n = Y(e);
+  return Ue(() => {
+    n.current !== e && (n.current = e);
+  }, t), n;
+}
+function Wt(e, t) {
+  const n = Y();
+  return j(
+    () => {
+      const o = e(n.current);
+      return n.current = o, o;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function vn(e) {
+  const t = Sn(e), n = Y(null), o = be(
+    (i) => {
+      i !== n.current && (t == null || t(i, n.current)), n.current = i;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [n, o];
+}
+function bn(e) {
+  const t = Y();
+  return K(() => {
+    t.current = e;
+  }, [e]), t.current;
+}
+let Mn = {};
+function qt(e, t) {
+  return j(() => {
+    if (t)
+      return t;
+    const n = Mn[e] == null ? 0 : Mn[e] + 1;
+    return Mn[e] = n, e + "-" + n;
+  }, [e, t]);
+}
+function Lr(e) {
+  return function(t) {
+    for (var n = arguments.length, o = new Array(n > 1 ? n - 1 : 0), i = 1; i < n; i++)
+      o[i - 1] = arguments[i];
+    return o.reduce((a, l) => {
+      const c = Object.entries(l);
+      for (const [d, u] of c) {
+        const h = a[d];
+        h != null && (a[d] = h + e * u);
+      }
+      return a;
+    }, {
+      ...t
+    });
+  };
+}
+const Nt = /* @__PURE__ */ Lr(1), yn = /* @__PURE__ */ Lr(-1);
+function Ai(e) {
+  return "clientX" in e && "clientY" in e;
+}
+function Rn(e) {
+  if (!e)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = Se(e.target);
+  return t && e instanceof t;
+}
+function Ei(e) {
+  if (!e)
+    return !1;
+  const {
+    TouchEvent: t
+  } = Se(e.target);
+  return t && e instanceof t;
+}
+function mn(e) {
+  if (Ei(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 Ai(e) ? {
+    x: e.clientX,
+    y: e.clientY
+  } : null;
+}
+const bt = /* @__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 [bt.Translate.toString(e), bt.Scale.toString(e)].join(" ");
+    }
+  },
+  Transition: {
+    toString(e) {
+      let {
+        property: t,
+        duration: n,
+        easing: o
+      } = e;
+      return t + " " + n + "ms " + o;
+    }
+  }
+}), vr = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function _i(e) {
+  return e.matches(vr) ? e : e.querySelector(vr);
+}
+const Ii = {
+  display: "none"
+};
+function Oi(e) {
+  let {
+    id: t,
+    value: n
+  } = e;
+  return k.createElement("div", {
+    id: t,
+    style: Ii
+  }, n);
+}
+function Ti(e) {
+  let {
+    id: t,
+    announcement: n,
+    ariaLiveType: o = "assertive"
+  } = e;
+  const i = {
+    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 k.createElement("div", {
+    id: t,
+    style: i,
+    role: "status",
+    "aria-live": o,
+    "aria-atomic": !0
+  }, n);
+}
+function Ni() {
+  const [e, t] = he("");
+  return {
+    announce: be((o) => {
+      o != null && t(o);
+    }, []),
+    announcement: e
+  };
+}
+const Pr = /* @__PURE__ */ kt(null);
+function Mi(e) {
+  const t = vt(Pr);
+  K(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function Li() {
+  const [e] = he(() => /* @__PURE__ */ new Set()), t = be((o) => (e.add(o), () => e.delete(o)), [e]);
+  return [be((o) => {
+    let {
+      type: i,
+      event: a
+    } = o;
+    e.forEach((l) => {
+      var c;
+      return (c = l[i]) == null ? void 0 : c.call(l, a);
+    });
+  }, [e]), t];
+}
+const Pi = {
+  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.
+  `
+}, $i = {
+  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 Bi(e) {
+  let {
+    announcements: t = $i,
+    container: n,
+    hiddenTextDescribedById: o,
+    screenReaderInstructions: i = Pi
+  } = e;
+  const {
+    announce: a,
+    announcement: l
+  } = Ni(), c = qt("DndLiveRegion"), [d, u] = he(!1);
+  if (K(() => {
+    u(!0);
+  }, []), Mi(j(() => ({
+    onDragStart(g) {
+      let {
+        active: w
+      } = g;
+      a(t.onDragStart({
+        active: w
+      }));
+    },
+    onDragMove(g) {
+      let {
+        active: w,
+        over: b
+      } = g;
+      t.onDragMove && a(t.onDragMove({
+        active: w,
+        over: b
+      }));
+    },
+    onDragOver(g) {
+      let {
+        active: w,
+        over: b
+      } = g;
+      a(t.onDragOver({
+        active: w,
+        over: b
+      }));
+    },
+    onDragEnd(g) {
+      let {
+        active: w,
+        over: b
+      } = g;
+      a(t.onDragEnd({
+        active: w,
+        over: b
+      }));
+    },
+    onDragCancel(g) {
+      let {
+        active: w,
+        over: b
+      } = g;
+      a(t.onDragCancel({
+        active: w,
+        over: b
+      }));
+    }
+  }), [a, t])), !d)
+    return null;
+  const h = k.createElement(k.Fragment, null, k.createElement(Oi, {
+    id: o,
+    value: i.draggable
+  }), k.createElement(Ti, {
+    id: c,
+    announcement: l
+  }));
+  return n ? At.createPortal(h, n) : h;
+}
+var le;
+(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";
+})(le || (le = {}));
+function wn() {
+}
+function Ln(e, t) {
+  return j(
+    () => ({
+      sensor: e,
+      options: t ?? {}
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  );
+}
+function zi() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return j(
+    () => [...t].filter((o) => o != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const Je = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function qn(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function Fi(e, t) {
+  const n = mn(e);
+  if (!n)
+    return "0 0";
+  const o = {
+    x: (n.x - t.left) / t.width * 100,
+    y: (n.y - t.top) / t.height * 100
+  };
+  return o.x + "% " + o.y + "%";
+}
+function Jn(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: o
+    }
+  } = t;
+  return n - o;
+}
+function Ki(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: o
+    }
+  } = t;
+  return o - n;
+}
+function Fn(e) {
+  let {
+    left: t,
+    top: n,
+    height: o,
+    width: i
+  } = e;
+  return [{
+    x: t,
+    y: n
+  }, {
+    x: t + i,
+    y: n
+  }, {
+    x: t,
+    y: n + o
+  }, {
+    x: t + i,
+    y: n + o
+  }];
+}
+function Vn(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return t ? n[t] : n;
+}
+function br(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 yr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: o
+  } = e;
+  const i = br(t, t.left, t.top), a = [];
+  for (const l of o) {
+    const {
+      id: c
+    } = l, d = n.get(c);
+    if (d) {
+      const u = qn(br(d), i);
+      a.push({
+        id: c,
+        data: {
+          droppableContainer: l,
+          value: u
+        }
+      });
+    }
+  }
+  return a.sort(Jn);
+}, Hi = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: o
+  } = e;
+  const i = Fn(t), a = [];
+  for (const l of o) {
+    const {
+      id: c
+    } = l, d = n.get(c);
+    if (d) {
+      const u = Fn(d), h = i.reduce((w, b, A) => w + qn(u[A], b), 0), g = Number((h / 4).toFixed(4));
+      a.push({
+        id: c,
+        data: {
+          droppableContainer: l,
+          value: g
+        }
+      });
+    }
+  }
+  return a.sort(Jn);
+};
+function Ui(e, t) {
+  const n = Math.max(t.top, e.top), o = Math.max(t.left, e.left), i = Math.min(t.left + t.width, e.left + e.width), a = Math.min(t.top + t.height, e.top + e.height), l = i - o, c = a - n;
+  if (o < i && n < a) {
+    const d = t.width * t.height, u = e.width * e.height, h = l * c, g = h / (d + u - h);
+    return Number(g.toFixed(4));
+  }
+  return 0;
+}
+const $r = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: o
+  } = e;
+  const i = [];
+  for (const a of o) {
+    const {
+      id: l
+    } = a, c = n.get(l);
+    if (c) {
+      const d = Ui(c, t);
+      d > 0 && i.push({
+        id: l,
+        data: {
+          droppableContainer: a,
+          value: d
+        }
+      });
+    }
+  }
+  return i.sort(Ki);
+};
+function Xi(e, t) {
+  const {
+    top: n,
+    left: o,
+    bottom: i,
+    right: a
+  } = t;
+  return n <= e.y && e.y <= i && o <= e.x && e.x <= a;
+}
+const ji = (e) => {
+  let {
+    droppableContainers: t,
+    droppableRects: n,
+    pointerCoordinates: o
+  } = e;
+  if (!o)
+    return [];
+  const i = [];
+  for (const a of t) {
+    const {
+      id: l
+    } = a, c = n.get(l);
+    if (c && Xi(o, c)) {
+      const u = Fn(c).reduce((g, w) => g + qn(o, w), 0), h = Number((u / 4).toFixed(4));
+      i.push({
+        id: l,
+        data: {
+          droppableContainer: a,
+          value: h
+        }
+      });
+    }
+  }
+  return i.sort(Jn);
+};
+function Yi(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function Br(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : Je;
+}
+function ki(e) {
+  return function(n) {
+    for (var o = arguments.length, i = new Array(o > 1 ? o - 1 : 0), a = 1; a < o; a++)
+      i[a - 1] = arguments[a];
+    return i.reduce((l, c) => ({
+      ...l,
+      top: l.top + e * c.y,
+      bottom: l.bottom + e * c.y,
+      left: l.left + e * c.x,
+      right: l.right + e * c.x
+    }), {
+      ...n
+    });
+  };
+}
+const Gi = /* @__PURE__ */ ki(1);
+function zr(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 Wi(e, t, n) {
+  const o = zr(t);
+  if (!o)
+    return e;
+  const {
+    scaleX: i,
+    scaleY: a,
+    x: l,
+    y: c
+  } = o, d = e.left - l - (1 - i) * parseFloat(n), u = e.top - c - (1 - a) * parseFloat(n.slice(n.indexOf(" ") + 1)), h = i ? e.width / i : e.width, g = a ? e.height / a : e.height;
+  return {
+    width: h,
+    height: g,
+    top: u,
+    right: d + h,
+    bottom: u + g,
+    left: d
+  };
+}
+const qi = {
+  ignoreTransform: !1
+};
+function zt(e, t) {
+  t === void 0 && (t = qi);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: u,
+      transformOrigin: h
+    } = Se(e).getComputedStyle(e);
+    u && (n = Wi(n, u, h));
+  }
+  const {
+    top: o,
+    left: i,
+    width: a,
+    height: l,
+    bottom: c,
+    right: d
+  } = n;
+  return {
+    top: o,
+    left: i,
+    width: a,
+    height: l,
+    bottom: c,
+    right: d
+  };
+}
+function mr(e) {
+  return zt(e, {
+    ignoreTransform: !0
+  });
+}
+function Ji(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function Vi(e, t) {
+  return t === void 0 && (t = Se(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Qi(e, t) {
+  t === void 0 && (t = Se(e).getComputedStyle(e));
+  const n = /(auto|scroll|overlay)/;
+  return ["overflow", "overflowX", "overflowY"].some((i) => {
+    const a = t[i];
+    return typeof a == "string" ? n.test(a) : !1;
+  });
+}
+function Qn(e, t) {
+  const n = [];
+  function o(i) {
+    if (t != null && n.length >= t || !i)
+      return n;
+    if (Wn(i) && i.scrollingElement != null && !n.includes(i.scrollingElement))
+      return n.push(i.scrollingElement), n;
+    if (!Gt(i) || Mr(i) || n.includes(i))
+      return n;
+    const a = Se(e).getComputedStyle(i);
+    return i !== e && Qi(i, a) && n.push(i), Vi(i, a) ? n : o(i.parentNode);
+  }
+  return e ? o(e) : n;
+}
+function Fr(e) {
+  const [t] = Qn(e, 1);
+  return t ?? null;
+}
+function Pn(e) {
+  return !Dn || !e ? null : $t(e) ? e : Gn(e) ? Wn(e) || e === Bt(e).scrollingElement ? window : Gt(e) ? e : null : null;
+}
+function Kr(e) {
+  return $t(e) ? e.scrollX : e.scrollLeft;
+}
+function Hr(e) {
+  return $t(e) ? e.scrollY : e.scrollTop;
+}
+function Kn(e) {
+  return {
+    x: Kr(e),
+    y: Hr(e)
+  };
+}
+var ge;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(ge || (ge = {}));
+function Ur(e) {
+  return !Dn || !e ? !1 : e === document.scrollingElement;
+}
+function Xr(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = Ur(e) ? {
+    height: window.innerHeight,
+    width: window.innerWidth
+  } : {
+    height: e.clientHeight,
+    width: e.clientWidth
+  }, o = {
+    x: e.scrollWidth - n.width,
+    y: e.scrollHeight - n.height
+  }, i = e.scrollTop <= t.y, a = e.scrollLeft <= t.x, l = e.scrollTop >= o.y, c = e.scrollLeft >= o.x;
+  return {
+    isTop: i,
+    isLeft: a,
+    isBottom: l,
+    isRight: c,
+    maxScroll: o,
+    minScroll: t
+  };
+}
+const Zi = {
+  x: 0.2,
+  y: 0.2
+};
+function es(e, t, n, o, i) {
+  let {
+    top: a,
+    left: l,
+    right: c,
+    bottom: d
+  } = n;
+  o === void 0 && (o = 10), i === void 0 && (i = Zi);
+  const {
+    isTop: u,
+    isBottom: h,
+    isLeft: g,
+    isRight: w
+  } = Xr(e), b = {
+    x: 0,
+    y: 0
+  }, A = {
+    x: 0,
+    y: 0
+  }, v = {
+    height: t.height * i.y,
+    width: t.width * i.x
+  };
+  return !u && a <= t.top + v.height ? (b.y = ge.Backward, A.y = o * Math.abs((t.top + v.height - a) / v.height)) : !h && d >= t.bottom - v.height && (b.y = ge.Forward, A.y = o * Math.abs((t.bottom - v.height - d) / v.height)), !w && c >= t.right - v.width ? (b.x = ge.Forward, A.x = o * Math.abs((t.right - v.width - c) / v.width)) : !g && l <= t.left + v.width && (b.x = ge.Backward, A.x = o * Math.abs((t.left + v.width - l) / v.width)), {
+    direction: b,
+    speed: A
+  };
+}
+function ts(e) {
+  if (e === document.scrollingElement) {
+    const {
+      innerWidth: a,
+      innerHeight: l
+    } = window;
+    return {
+      top: 0,
+      left: 0,
+      right: a,
+      bottom: l,
+      width: a,
+      height: l
+    };
+  }
+  const {
+    top: t,
+    left: n,
+    right: o,
+    bottom: i
+  } = e.getBoundingClientRect();
+  return {
+    top: t,
+    left: n,
+    right: o,
+    bottom: i,
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+}
+function jr(e) {
+  return e.reduce((t, n) => Nt(t, Kn(n)), Je);
+}
+function ns(e) {
+  return e.reduce((t, n) => t + Kr(n), 0);
+}
+function rs(e) {
+  return e.reduce((t, n) => t + Hr(n), 0);
+}
+function Yr(e, t) {
+  if (t === void 0 && (t = zt), !e)
+    return;
+  const {
+    top: n,
+    left: o,
+    bottom: i,
+    right: a
+  } = t(e);
+  Fr(e) && (i <= 0 || a <= 0 || n >= window.innerHeight || o >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const os = [["x", ["left", "right"], ns], ["y", ["top", "bottom"], rs]];
+class Zn {
+  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 o = Qn(n), i = jr(o);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [a, l, c] of os)
+      for (const d of l)
+        Object.defineProperty(this, d, {
+          get: () => {
+            const u = c(o), h = i[a] - u;
+            return this.rect[d] + h;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class Ht {
+  constructor(t) {
+    this.target = void 0, this.listeners = [], this.removeAll = () => {
+      this.listeners.forEach((n) => {
+        var o;
+        return (o = this.target) == null ? void 0 : o.removeEventListener(...n);
+      });
+    }, this.target = t;
+  }
+  add(t, n, o) {
+    var i;
+    (i = this.target) == null || i.addEventListener(t, n, o), this.listeners.push([t, n, o]);
+  }
+}
+function is(e) {
+  const {
+    EventTarget: t
+  } = Se(e);
+  return e instanceof t ? e : Bt(e);
+}
+function $n(e, t) {
+  const n = Math.abs(e.x), o = Math.abs(e.y);
+  return typeof t == "number" ? Math.sqrt(n ** 2 + o ** 2) > t : "x" in t && "y" in t ? n > t.x && o > t.y : "x" in t ? n > t.x : "y" in t ? o > t.y : !1;
+}
+var He;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(He || (He = {}));
+function wr(e) {
+  e.preventDefault();
+}
+function ss(e) {
+  e.stopPropagation();
+}
+var L;
+(function(e) {
+  e.Space = "Space", e.Down = "ArrowDown", e.Right = "ArrowRight", e.Left = "ArrowLeft", e.Up = "ArrowUp", e.Esc = "Escape", e.Enter = "Enter";
+})(L || (L = {}));
+const kr = {
+  start: [L.Space, L.Enter],
+  cancel: [L.Esc],
+  end: [L.Space, L.Enter]
+}, as = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case L.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case L.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case L.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case L.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class er {
+  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 Ht(Bt(n)), this.windowListeners = new Ht(Se(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(He.Resize, this.handleCancel), this.windowListeners.add(He.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(He.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, o = t.node.current;
+    o && Yr(o), n(Je);
+  }
+  handleKeyDown(t) {
+    if (Rn(t)) {
+      const {
+        active: n,
+        context: o,
+        options: i
+      } = this.props, {
+        keyboardCodes: a = kr,
+        coordinateGetter: l = as,
+        scrollBehavior: c = "smooth"
+      } = i, {
+        code: d
+      } = t;
+      if (a.end.includes(d)) {
+        this.handleEnd(t);
+        return;
+      }
+      if (a.cancel.includes(d)) {
+        this.handleCancel(t);
+        return;
+      }
+      const {
+        collisionRect: u
+      } = o.current, h = u ? {
+        x: u.left,
+        y: u.top
+      } : Je;
+      this.referenceCoordinates || (this.referenceCoordinates = h);
+      const g = l(t, {
+        active: n,
+        context: o.current,
+        currentCoordinates: h
+      });
+      if (g) {
+        const w = yn(g, h), b = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: A
+        } = o.current;
+        for (const v of A) {
+          const x = t.code, {
+            isTop: S,
+            isRight: E,
+            isLeft: D,
+            isBottom: R,
+            maxScroll: T,
+            minScroll: _
+          } = Xr(v), O = ts(v), M = {
+            x: Math.min(x === L.Right ? O.right - O.width / 2 : O.right, Math.max(x === L.Right ? O.left : O.left + O.width / 2, g.x)),
+            y: Math.min(x === L.Down ? O.bottom - O.height / 2 : O.bottom, Math.max(x === L.Down ? O.top : O.top + O.height / 2, g.y))
+          }, H = x === L.Right && !E || x === L.Left && !D, U = x === L.Down && !R || x === L.Up && !S;
+          if (H && M.x !== g.x) {
+            const B = v.scrollLeft + w.x, re = x === L.Right && B <= T.x || x === L.Left && B >= _.x;
+            if (re && !w.y) {
+              v.scrollTo({
+                left: B,
+                behavior: c
+              });
+              return;
+            }
+            re ? b.x = v.scrollLeft - B : b.x = x === L.Right ? v.scrollLeft - T.x : v.scrollLeft - _.x, b.x && v.scrollBy({
+              left: -b.x,
+              behavior: c
+            });
+            break;
+          } else if (U && M.y !== g.y) {
+            const B = v.scrollTop + w.y, re = x === L.Down && B <= T.y || x === L.Up && B >= _.y;
+            if (re && !w.x) {
+              v.scrollTo({
+                top: B,
+                behavior: c
+              });
+              return;
+            }
+            re ? b.y = v.scrollTop - B : b.y = x === L.Down ? v.scrollTop - T.y : v.scrollTop - _.y, b.y && v.scrollBy({
+              top: -b.y,
+              behavior: c
+            });
+            break;
+          }
+        }
+        this.handleMove(t, Nt(yn(g, this.referenceCoordinates), b));
+      }
+    }
+  }
+  handleMove(t, n) {
+    const {
+      onMove: o
+    } = this.props;
+    t.preventDefault(), o(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();
+  }
+}
+er.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: o = kr,
+      onActivation: i
+    } = t, {
+      active: a
+    } = n;
+    const {
+      code: l
+    } = e.nativeEvent;
+    if (o.start.includes(l)) {
+      const c = a.activatorNode.current;
+      return c && e.target !== c ? !1 : (e.preventDefault(), i == null || i({
+        event: e.nativeEvent
+      }), !0);
+    }
+    return !1;
+  }
+}];
+function xr(e) {
+  return !!(e && "distance" in e);
+}
+function Cr(e) {
+  return !!(e && "delay" in e);
+}
+class tr {
+  constructor(t, n, o) {
+    var i;
+    o === void 0 && (o = is(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: a
+    } = t, {
+      target: l
+    } = a;
+    this.props = t, this.events = n, this.document = Bt(l), this.documentListeners = new Ht(this.document), this.listeners = new Ht(o), this.windowListeners = new Ht(Se(l)), this.initialCoordinates = (i = mn(a)) != null ? i : Je, 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: o
+        }
+      }
+    } = this;
+    if (this.listeners.add(t.move.name, this.handleMove, {
+      passive: !1
+    }), this.listeners.add(t.end.name, this.handleEnd), this.windowListeners.add(He.Resize, this.handleCancel), this.windowListeners.add(He.DragStart, wr), this.windowListeners.add(He.VisibilityChange, this.handleCancel), this.windowListeners.add(He.ContextMenu, wr), this.documentListeners.add(He.Keydown, this.handleKeydown), n) {
+      if (o != null && o({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (Cr(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay);
+        return;
+      }
+      if (xr(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(He.Click, ss, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(He.SelectionChange, this.removeTextSelection), n(t));
+  }
+  handleMove(t) {
+    var n;
+    const {
+      activated: o,
+      initialCoordinates: i,
+      props: a
+    } = this, {
+      onMove: l,
+      options: {
+        activationConstraint: c
+      }
+    } = a;
+    if (!i)
+      return;
+    const d = (n = mn(t)) != null ? n : Je, u = yn(i, d);
+    if (!o && c) {
+      if (xr(c)) {
+        if (c.tolerance != null && $n(u, c.tolerance))
+          return this.handleCancel();
+        if ($n(u, c.distance))
+          return this.handleStart();
+      }
+      return Cr(c) && $n(u, c.tolerance) ? this.handleCancel() : void 0;
+    }
+    t.cancelable && t.preventDefault(), l(d);
+  }
+  handleEnd() {
+    const {
+      onEnd: t
+    } = this.props;
+    this.detach(), t();
+  }
+  handleCancel() {
+    const {
+      onCancel: t
+    } = this.props;
+    this.detach(), t();
+  }
+  handleKeydown(t) {
+    t.code === L.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const ls = {
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class Gr extends tr {
+  constructor(t) {
+    const {
+      event: n
+    } = t, o = Bt(n.target);
+    super(t, ls, o);
+  }
+}
+Gr.activators = [{
+  eventName: "onPointerDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: o
+    } = t;
+    return !n.isPrimary || n.button !== 0 ? !1 : (o == null || o({
+      event: n
+    }), !0);
+  }
+}];
+const cs = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var Hn;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(Hn || (Hn = {}));
+class Wr extends tr {
+  constructor(t) {
+    super(t, cs, Bt(t.event.target));
+  }
+}
+Wr.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: o
+    } = t;
+    return n.button === Hn.RightClick ? !1 : (o == null || o({
+      event: n
+    }), !0);
+  }
+}];
+const Bn = {
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class qr extends tr {
+  constructor(t) {
+    super(t, Bn);
+  }
+  static setup() {
+    return window.addEventListener(Bn.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(Bn.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+qr.activators = [{
+  eventName: "onTouchStart",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: o
+    } = t;
+    const {
+      touches: i
+    } = n;
+    return i.length > 1 ? !1 : (o == null || o({
+      event: n
+    }), !0);
+  }
+}];
+var Ut;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(Ut || (Ut = {}));
+var xn;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(xn || (xn = {}));
+function us(e) {
+  let {
+    acceleration: t,
+    activator: n = Ut.Pointer,
+    canScroll: o,
+    draggingRect: i,
+    enabled: a,
+    interval: l = 5,
+    order: c = xn.TreeOrder,
+    pointerCoordinates: d,
+    scrollableAncestors: u,
+    scrollableAncestorRects: h,
+    delta: g,
+    threshold: w
+  } = e;
+  const b = fs({
+    delta: g,
+    disabled: !a
+  }), [A, v] = Ri(), x = Y({
+    x: 0,
+    y: 0
+  }), S = Y({
+    x: 0,
+    y: 0
+  }), E = j(() => {
+    switch (n) {
+      case Ut.Pointer:
+        return d ? {
+          top: d.y,
+          bottom: d.y,
+          left: d.x,
+          right: d.x
+        } : null;
+      case Ut.DraggableRect:
+        return i;
+    }
+  }, [n, i, d]), D = Y(null), R = be(() => {
+    const _ = D.current;
+    if (!_)
+      return;
+    const O = x.current.x * S.current.x, M = x.current.y * S.current.y;
+    _.scrollBy(O, M);
+  }, []), T = j(() => c === xn.TreeOrder ? [...u].reverse() : u, [c, u]);
+  K(
+    () => {
+      if (!a || !u.length || !E) {
+        v();
+        return;
+      }
+      for (const _ of T) {
+        if ((o == null ? void 0 : o(_)) === !1)
+          continue;
+        const O = u.indexOf(_), M = h[O];
+        if (!M)
+          continue;
+        const {
+          direction: H,
+          speed: U
+        } = es(_, M, E, t, w);
+        for (const B of ["x", "y"])
+          b[B][H[B]] || (U[B] = 0, H[B] = 0);
+        if (U.x > 0 || U.y > 0) {
+          v(), D.current = _, A(R, l), x.current = U, S.current = H;
+          return;
+        }
+      }
+      x.current = {
+        x: 0,
+        y: 0
+      }, S.current = {
+        x: 0,
+        y: 0
+      }, v();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      R,
+      o,
+      v,
+      a,
+      l,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(E),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(b),
+      A,
+      u,
+      T,
+      h,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(w)
+    ]
+  );
+}
+const ds = {
+  x: {
+    [ge.Backward]: !1,
+    [ge.Forward]: !1
+  },
+  y: {
+    [ge.Backward]: !1,
+    [ge.Forward]: !1
+  }
+};
+function fs(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const o = bn(t);
+  return Wt((i) => {
+    if (n || !o || !i)
+      return ds;
+    const a = {
+      x: Math.sign(t.x - o.x),
+      y: Math.sign(t.y - o.y)
+    };
+    return {
+      x: {
+        [ge.Backward]: i.x[ge.Backward] || a.x === -1,
+        [ge.Forward]: i.x[ge.Forward] || a.x === 1
+      },
+      y: {
+        [ge.Backward]: i.y[ge.Backward] || a.y === -1,
+        [ge.Forward]: i.y[ge.Forward] || a.y === 1
+      }
+    };
+  }, [n, t, o]);
+}
+function gs(e, t) {
+  const n = t !== null ? e.get(t) : void 0, o = n ? n.node.current : null;
+  return Wt((i) => {
+    var a;
+    return t === null ? null : (a = o ?? i) != null ? a : null;
+  }, [o, t]);
+}
+function hs(e, t) {
+  return j(() => e.reduce((n, o) => {
+    const {
+      sensor: i
+    } = o, a = i.activators.map((l) => ({
+      eventName: l.eventName,
+      handler: t(l.handler, o)
+    }));
+    return [...n, ...a];
+  }, []), [e, t]);
+}
+var Lt;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Lt || (Lt = {}));
+var Un;
+(function(e) {
+  e.Optimized = "optimized";
+})(Un || (Un = {}));
+const Dr = /* @__PURE__ */ new Map();
+function ps(e, t) {
+  let {
+    dragging: n,
+    dependencies: o,
+    config: i
+  } = t;
+  const [a, l] = he(null), {
+    frequency: c,
+    measure: d,
+    strategy: u
+  } = i, h = Y(e), g = x(), w = Yt(g), b = be(function(S) {
+    S === void 0 && (S = []), !w.current && l((E) => E === null ? S : E.concat(S.filter((D) => !E.includes(D))));
+  }, [w]), A = Y(null), v = Wt((S) => {
+    if (g && !n)
+      return Dr;
+    if (!S || S === Dr || h.current !== e || a != null) {
+      const E = /* @__PURE__ */ new Map();
+      for (let D of e) {
+        if (!D)
+          continue;
+        if (a && a.length > 0 && !a.includes(D.id) && D.rect.current) {
+          E.set(D.id, D.rect.current);
+          continue;
+        }
+        const R = D.node.current, T = R ? new Zn(d(R), R) : null;
+        D.rect.current = T, T && E.set(D.id, T);
+      }
+      return E;
+    }
+    return S;
+  }, [e, a, n, g, d]);
+  return K(() => {
+    h.current = e;
+  }, [e]), K(
+    () => {
+      g || b();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, g]
+  ), K(
+    () => {
+      a && a.length > 0 && l(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(a)]
+  ), K(
+    () => {
+      g || typeof c != "number" || A.current !== null || (A.current = setTimeout(() => {
+        b(), A.current = null;
+      }, c));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [c, g, b, ...o]
+  ), {
+    droppableRects: v,
+    measureDroppableContainers: b,
+    measuringScheduled: a != null
+  };
+  function x() {
+    switch (u) {
+      case Lt.Always:
+        return !1;
+      case Lt.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function nr(e, t) {
+  return Wt((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function vs(e, t) {
+  return nr(e, t);
+}
+function bs(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const o = Sn(t), i = j(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: a
+    } = window;
+    return new a(o);
+  }, [o, n]);
+  return K(() => () => i == null ? void 0 : i.disconnect(), [i]), i;
+}
+function An(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const o = Sn(t), i = j(
+    () => {
+      if (n || typeof window > "u" || typeof window.ResizeObserver > "u")
+        return;
+      const {
+        ResizeObserver: a
+      } = window;
+      return new a(o);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n]
+  );
+  return K(() => () => i == null ? void 0 : i.disconnect(), [i]), i;
+}
+function ys(e) {
+  return new Zn(zt(e), e);
+}
+function Sr(e, t, n) {
+  t === void 0 && (t = ys);
+  const [o, i] = Yn(c, null), a = bs({
+    callback(d) {
+      if (e)
+        for (const u of d) {
+          const {
+            type: h,
+            target: g
+          } = u;
+          if (h === "childList" && g instanceof HTMLElement && g.contains(e)) {
+            i();
+            break;
+          }
+        }
+    }
+  }), l = An({
+    callback: i
+  });
+  return Ue(() => {
+    i(), e ? (l == null || l.observe(e), a == null || a.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (l == null || l.disconnect(), a == null || a.disconnect());
+  }, [e]), o;
+  function c(d) {
+    if (!e)
+      return null;
+    if (e.isConnected === !1) {
+      var u;
+      return (u = d ?? n) != null ? u : null;
+    }
+    const h = t(e);
+    return JSON.stringify(d) === JSON.stringify(h) ? d : h;
+  }
+}
+function ms(e) {
+  const t = nr(e);
+  return Br(e, t);
+}
+const Rr = [];
+function ws(e) {
+  const t = Y(e), n = Wt((o) => e ? o && o !== Rr && e && t.current && e.parentNode === t.current.parentNode ? o : Qn(e) : Rr, [e]);
+  return K(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function xs(e) {
+  const [t, n] = he(null), o = Y(e), i = be((a) => {
+    const l = Pn(a.target);
+    l && n((c) => c ? (c.set(l, Kn(l)), new Map(c)) : null);
+  }, []);
+  return K(() => {
+    const a = o.current;
+    if (e !== a) {
+      l(a);
+      const c = e.map((d) => {
+        const u = Pn(d);
+        return u ? (u.addEventListener("scroll", i, {
+          passive: !0
+        }), [u, Kn(u)]) : null;
+      }).filter((d) => d != null);
+      n(c.length ? new Map(c) : null), o.current = e;
+    }
+    return () => {
+      l(e), l(a);
+    };
+    function l(c) {
+      c.forEach((d) => {
+        const u = Pn(d);
+        u == null || u.removeEventListener("scroll", i);
+      });
+    }
+  }, [i, e]), j(() => e.length ? t ? Array.from(t.values()).reduce((a, l) => Nt(a, l), Je) : jr(e) : Je, [e, t]);
+}
+function Ar(e, t) {
+  t === void 0 && (t = []);
+  const n = Y(null);
+  return K(
+    () => {
+      n.current = null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), K(() => {
+    const o = e !== Je;
+    o && !n.current && (n.current = e), !o && n.current && (n.current = null);
+  }, [e]), n.current ? yn(e, n.current) : Je;
+}
+function Cs(e) {
+  K(
+    () => {
+      if (!Dn)
+        return;
+      const t = e.map((n) => {
+        let {
+          sensor: o
+        } = n;
+        return o.setup == null ? void 0 : o.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 Ds(e, t) {
+  return j(() => e.reduce((n, o) => {
+    let {
+      eventName: i,
+      handler: a
+    } = o;
+    return n[i] = (l) => {
+      a(l, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function Jr(e) {
+  return j(() => e ? Ji(e) : null, [e]);
+}
+const zn = [];
+function Ss(e, t) {
+  t === void 0 && (t = zt);
+  const [n] = e, o = Jr(n ? Se(n) : null), [i, a] = Yn(c, zn), l = An({
+    callback: a
+  });
+  return e.length > 0 && i === zn && a(), Ue(() => {
+    e.length ? e.forEach((d) => l == null ? void 0 : l.observe(d)) : (l == null || l.disconnect(), a());
+  }, [e]), i;
+  function c() {
+    return e.length ? e.map((d) => Ur(d) ? o : new Zn(t(d), d)) : zn;
+  }
+}
+function Vr(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return Gt(t) ? t : e;
+}
+function Rs(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, o] = he(null), i = be((u) => {
+    for (const {
+      target: h
+    } of u)
+      if (Gt(h)) {
+        o((g) => {
+          const w = t(h);
+          return g ? {
+            ...g,
+            width: w.width,
+            height: w.height
+          } : w;
+        });
+        break;
+      }
+  }, [t]), a = An({
+    callback: i
+  }), l = be((u) => {
+    const h = Vr(u);
+    a == null || a.disconnect(), h && (a == null || a.observe(h)), o(h ? t(h) : null);
+  }, [t, a]), [c, d] = vn(l);
+  return j(() => ({
+    nodeRef: c,
+    rect: n,
+    setRef: d
+  }), [n, c, d]);
+}
+const As = [{
+  sensor: Gr,
+  options: {}
+}, {
+  sensor: er,
+  options: {}
+}], Es = {
+  current: {}
+}, hn = {
+  draggable: {
+    measure: mr
+  },
+  droppable: {
+    measure: mr,
+    strategy: Lt.WhileDragging,
+    frequency: Un.Optimized
+  },
+  dragOverlay: {
+    measure: zt
+  }
+};
+class Xt 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, o;
+    return (n = (o = this.get(t)) == null ? void 0 : o.node.current) != null ? n : void 0;
+  }
+}
+const _s = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new Xt(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: wn
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: hn,
+  measureDroppableContainers: wn,
+  windowRect: null,
+  measuringScheduled: !1
+}, Qr = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: wn,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: wn
+}, Jt = /* @__PURE__ */ kt(Qr), Zr = /* @__PURE__ */ kt(_s);
+function Is() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new Xt()
+    }
+  };
+}
+function Os(e, t) {
+  switch (t.type) {
+    case le.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case le.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 le.DragEnd:
+    case le.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case le.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: o
+      } = n, i = new Xt(e.droppable.containers);
+      return i.set(o, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    case le.SetDroppableDisabled: {
+      const {
+        id: n,
+        key: o,
+        disabled: i
+      } = t, a = e.droppable.containers.get(n);
+      if (!a || o !== a.key)
+        return e;
+      const l = new Xt(e.droppable.containers);
+      return l.set(n, {
+        ...a,
+        disabled: i
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: l
+        }
+      };
+    }
+    case le.UnregisterDroppable: {
+      const {
+        id: n,
+        key: o
+      } = t, i = e.droppable.containers.get(n);
+      if (!i || o !== i.key)
+        return e;
+      const a = new Xt(e.droppable.containers);
+      return a.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: a
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function Ts(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: o,
+    draggableNodes: i
+  } = vt(Jt), a = bn(o), l = bn(n == null ? void 0 : n.id);
+  return K(() => {
+    if (!t && !o && a && l != null) {
+      if (!Rn(a) || document.activeElement === a.target)
+        return;
+      const c = i.get(l);
+      if (!c)
+        return;
+      const {
+        activatorNode: d,
+        node: u
+      } = c;
+      if (!d.current && !u.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const h of [d.current, u.current]) {
+          if (!h)
+            continue;
+          const g = _i(h);
+          if (g) {
+            g.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [o, t, i, l, a]), null;
+}
+function eo(e, t) {
+  let {
+    transform: n,
+    ...o
+  } = t;
+  return e != null && e.length ? e.reduce((i, a) => a({
+    transform: i,
+    ...o
+  }), n) : n;
+}
+function Ns(e) {
+  return j(
+    () => ({
+      draggable: {
+        ...hn.draggable,
+        ...e == null ? void 0 : e.draggable
+      },
+      droppable: {
+        ...hn.droppable,
+        ...e == null ? void 0 : e.droppable
+      },
+      dragOverlay: {
+        ...hn.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 Ms(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: o,
+    config: i = !0
+  } = e;
+  const a = Y(!1), {
+    x: l,
+    y: c
+  } = typeof i == "boolean" ? {
+    x: i,
+    y: i
+  } : i;
+  Ue(() => {
+    if (!l && !c || !t) {
+      a.current = !1;
+      return;
+    }
+    if (a.current || !o)
+      return;
+    const u = t == null ? void 0 : t.node.current;
+    if (!u || u.isConnected === !1)
+      return;
+    const h = n(u), g = Br(h, o);
+    if (l || (g.x = 0), c || (g.y = 0), a.current = !0, Math.abs(g.x) > 0 || Math.abs(g.y) > 0) {
+      const w = Fr(u);
+      w && w.scrollBy({
+        top: g.y,
+        left: g.x
+      });
+    }
+  }, [t, l, c, o, n]);
+}
+const En = /* @__PURE__ */ kt({
+  ...Je,
+  scaleX: 1,
+  scaleY: 1
+});
+var pt;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(pt || (pt = {}));
+const Ls = /* @__PURE__ */ pi(function(t) {
+  var n, o, i, a;
+  let {
+    id: l,
+    accessibility: c,
+    autoScroll: d = !0,
+    children: u,
+    sensors: h = As,
+    collisionDetection: g = $r,
+    measuring: w,
+    modifiers: b,
+    ...A
+  } = t;
+  const v = Yn(Os, void 0, Is), [x, S] = v, [E, D] = Li(), [R, T] = he(pt.Uninitialized), _ = R === pt.Initialized, {
+    draggable: {
+      active: O,
+      nodes: M,
+      translate: H
+    },
+    droppable: {
+      containers: U
+    }
+  } = x, B = O ? M.get(O) : null, re = Y({
+    initial: null,
+    translated: null
+  }), Q = j(() => {
+    var X;
+    return O != null ? {
+      id: O,
+      // It's possible for the active node to unmount while dragging
+      data: (X = B == null ? void 0 : B.data) != null ? X : Es,
+      rect: re
+    } : null;
+  }, [O, B]), Re = Y(null), [Xe, F] = he(null), [J, Le] = he(null), Oe = Yt(A, Object.values(A)), ce = qt("DndDescribedBy", l), Pe = j(() => U.getEnabled(), [U]), V = Ns(w), {
+    droppableRects: we,
+    measureDroppableContainers: je,
+    measuringScheduled: tt
+  } = ps(Pe, {
+    dragging: _,
+    dependencies: [H.x, H.y],
+    config: V.droppable
+  }), Z = gs(M, O), nt = j(() => J ? mn(J) : null, [J]), $e = Qt(), ue = vs(Z, V.draggable.measure);
+  Ms({
+    activeNode: O ? M.get(O) : null,
+    config: $e.layoutShiftCompensation,
+    initialRect: ue,
+    measure: V.draggable.measure
+  });
+  const $ = Sr(Z, V.draggable.measure, ue), rt = Sr(Z ? Z.parentElement : null), Ae = Y({
+    activatorEvent: null,
+    active: null,
+    activeNode: Z,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: we,
+    draggableNodes: M,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: U,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), Ve = U.getNodeFor((n = Ae.current.over) == null ? void 0 : n.id), P = Rs({
+    measure: V.dragOverlay.measure
+  }), Qe = (o = P.nodeRef.current) != null ? o : Z, Ye = _ ? (i = P.rect) != null ? i : $ : null, yt = !!(P.nodeRef.current && P.rect), Ee = ms(yt ? null : $), Ze = Jr(Qe ? Se(Qe) : null), p = ws(_ ? Ve ?? Z : null), m = Ss(p), N = eo(b, {
+    transform: {
+      x: H.x - Ee.x,
+      y: H.y - Ee.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: J,
+    active: Q,
+    activeNodeRect: $,
+    containerNodeRect: rt,
+    draggingNodeRect: Ye,
+    over: Ae.current.over,
+    overlayNodeRect: P.rect,
+    scrollableAncestors: p,
+    scrollableAncestorRects: m,
+    windowRect: Ze
+  }), q = nt ? Nt(nt, H) : null, G = xs(p), de = Ar(G), ee = Ar(G, [$]), oe = Nt(N, de), pe = Ye ? Gi(Ye, N) : null, ye = Q && pe ? g({
+    active: Q,
+    collisionRect: pe,
+    droppableRects: we,
+    droppableContainers: Pe,
+    pointerCoordinates: q
+  }) : null, ot = Vn(ye, "id"), [te, Te] = he(null), mt = yt ? N : Nt(N, ee), ie = Yi(mt, (a = te == null ? void 0 : te.rect) != null ? a : null, $), fe = be(
+    (X, ne) => {
+      let {
+        sensor: xe,
+        options: ke
+      } = ne;
+      if (Re.current == null)
+        return;
+      const Ce = M.get(Re.current);
+      if (!Ce)
+        return;
+      const Ne = X.nativeEvent, ze = new xe({
+        active: Re.current,
+        activeNode: Ce,
+        event: Ne,
+        options: ke,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: Ae,
+        onStart(Me) {
+          const it = Re.current;
+          if (it == null)
+            return;
+          const Ge = M.get(it);
+          if (!Ge)
+            return;
+          const {
+            onDragStart: dt
+          } = Oe.current, ft = {
+            active: {
+              id: it,
+              data: Ge.data,
+              rect: re
+            }
+          };
+          At.unstable_batchedUpdates(() => {
+            dt == null || dt(ft), T(pt.Initializing), S({
+              type: le.DragStart,
+              initialCoordinates: Me,
+              active: it
+            }), E({
+              type: "onDragStart",
+              event: ft
+            });
+          });
+        },
+        onMove(Me) {
+          S({
+            type: le.DragMove,
+            coordinates: Me
+          });
+        },
+        onEnd: ut(le.DragEnd),
+        onCancel: ut(le.DragCancel)
+      });
+      At.unstable_batchedUpdates(() => {
+        F(ze), Le(X.nativeEvent);
+      });
+      function ut(Me) {
+        return async function() {
+          const {
+            active: Ge,
+            collisions: dt,
+            over: ft,
+            scrollAdjustedTranslate: Et
+          } = Ae.current;
+          let We = null;
+          if (Ge && Et) {
+            const {
+              cancelDrop: wt
+            } = Oe.current;
+            We = {
+              activatorEvent: Ne,
+              active: Ge,
+              collisions: dt,
+              delta: Et,
+              over: ft
+            }, Me === le.DragEnd && typeof wt == "function" && await Promise.resolve(wt(We)) && (Me = le.DragCancel);
+          }
+          Re.current = null, At.unstable_batchedUpdates(() => {
+            S({
+              type: Me
+            }), T(pt.Uninitialized), Te(null), F(null), Le(null);
+            const wt = Me === le.DragEnd ? "onDragEnd" : "onDragCancel";
+            if (We) {
+              const Kt = Oe.current[wt];
+              Kt == null || Kt(We), E({
+                type: wt,
+                event: We
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [M]
+  ), Be = be((X, ne) => (xe, ke) => {
+    const Ce = xe.nativeEvent, Ne = M.get(ke);
+    if (
+      // Another sensor is already instantiating
+      Re.current !== null || // No active draggable
+      !Ne || // Event has already been captured
+      Ce.dndKit || Ce.defaultPrevented
+    )
+      return;
+    const ze = {
+      active: Ne
+    };
+    X(xe, ne.options, ze) === !0 && (Ce.dndKit = {
+      capturedBy: ne.sensor
+    }, Re.current = ke, fe(xe, ne));
+  }, [M, fe]), et = hs(h, Be);
+  Cs(h), Ue(() => {
+    $ && R === pt.Initializing && T(pt.Initialized);
+  }, [$, R]), K(
+    () => {
+      const {
+        onDragMove: X
+      } = Oe.current, {
+        active: ne,
+        activatorEvent: xe,
+        collisions: ke,
+        over: Ce
+      } = Ae.current;
+      if (!ne || !xe)
+        return;
+      const Ne = {
+        active: ne,
+        activatorEvent: xe,
+        collisions: ke,
+        delta: {
+          x: oe.x,
+          y: oe.y
+        },
+        over: Ce
+      };
+      At.unstable_batchedUpdates(() => {
+        X == null || X(Ne), E({
+          type: "onDragMove",
+          event: Ne
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [oe.x, oe.y]
+  ), K(
+    () => {
+      const {
+        active: X,
+        activatorEvent: ne,
+        collisions: xe,
+        droppableContainers: ke,
+        scrollAdjustedTranslate: Ce
+      } = Ae.current;
+      if (!X || Re.current == null || !ne || !Ce)
+        return;
+      const {
+        onDragOver: Ne
+      } = Oe.current, ze = ke.get(ot), ut = ze && ze.rect.current ? {
+        id: ze.id,
+        rect: ze.rect.current,
+        data: ze.data,
+        disabled: ze.disabled
+      } : null, Me = {
+        active: X,
+        activatorEvent: ne,
+        collisions: xe,
+        delta: {
+          x: Ce.x,
+          y: Ce.y
+        },
+        over: ut
+      };
+      At.unstable_batchedUpdates(() => {
+        Te(ut), Ne == null || Ne(Me), E({
+          type: "onDragOver",
+          event: Me
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [ot]
+  ), Ue(() => {
+    Ae.current = {
+      activatorEvent: J,
+      active: Q,
+      activeNode: Z,
+      collisionRect: pe,
+      collisions: ye,
+      droppableRects: we,
+      draggableNodes: M,
+      draggingNode: Qe,
+      draggingNodeRect: Ye,
+      droppableContainers: U,
+      over: te,
+      scrollableAncestors: p,
+      scrollAdjustedTranslate: oe
+    }, re.current = {
+      initial: Ye,
+      translated: pe
+    };
+  }, [Q, Z, ye, pe, M, Qe, Ye, we, U, te, p, oe]), us({
+    ...$e,
+    delta: H,
+    draggingRect: pe,
+    pointerCoordinates: q,
+    scrollableAncestors: p,
+    scrollableAncestorRects: m
+  });
+  const Ft = j(() => ({
+    active: Q,
+    activeNode: Z,
+    activeNodeRect: $,
+    activatorEvent: J,
+    collisions: ye,
+    containerNodeRect: rt,
+    dragOverlay: P,
+    draggableNodes: M,
+    droppableContainers: U,
+    droppableRects: we,
+    over: te,
+    measureDroppableContainers: je,
+    scrollableAncestors: p,
+    scrollableAncestorRects: m,
+    measuringConfiguration: V,
+    measuringScheduled: tt,
+    windowRect: Ze
+  }), [Q, Z, $, J, ye, rt, P, M, U, we, te, je, p, m, V, tt, Ze]), Vt = j(() => ({
+    activatorEvent: J,
+    activators: et,
+    active: Q,
+    activeNodeRect: $,
+    ariaDescribedById: {
+      draggable: ce
+    },
+    dispatch: S,
+    draggableNodes: M,
+    over: te,
+    measureDroppableContainers: je
+  }), [J, et, Q, $, S, ce, M, te, je]);
+  return k.createElement(Pr.Provider, {
+    value: D
+  }, k.createElement(Jt.Provider, {
+    value: Vt
+  }, k.createElement(Zr.Provider, {
+    value: Ft
+  }, k.createElement(En.Provider, {
+    value: ie
+  }, u)), k.createElement(Ts, {
+    disabled: (c == null ? void 0 : c.restoreFocus) === !1
+  })), k.createElement(Bi, {
+    ...c,
+    hiddenTextDescribedById: ce
+  }));
+  function Qt() {
+    const X = (Xe == null ? void 0 : Xe.autoScrollEnabled) === !1, ne = typeof d == "object" ? d.enabled === !1 : d === !1, xe = _ && !X && !ne;
+    return typeof d == "object" ? {
+      ...d,
+      enabled: xe
+    } : {
+      enabled: xe
+    };
+  }
+}), Ps = /* @__PURE__ */ kt(null), Er = "button", $s = "Droppable";
+function Bs(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: o = !1,
+    attributes: i
+  } = e;
+  const a = qt($s), {
+    activators: l,
+    activatorEvent: c,
+    active: d,
+    activeNodeRect: u,
+    ariaDescribedById: h,
+    draggableNodes: g,
+    over: w
+  } = vt(Jt), {
+    role: b = Er,
+    roleDescription: A = "draggable",
+    tabIndex: v = 0
+  } = i ?? {}, x = (d == null ? void 0 : d.id) === t, S = vt(x ? En : Ps), [E, D] = vn(), [R, T] = vn(), _ = Ds(l, t), O = Yt(n);
+  Ue(
+    () => (g.set(t, {
+      id: t,
+      key: a,
+      node: E,
+      activatorNode: R,
+      data: O
+    }), () => {
+      const H = g.get(t);
+      H && H.key === a && g.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [g, t]
+  );
+  const M = j(() => ({
+    role: b,
+    tabIndex: v,
+    "aria-disabled": o,
+    "aria-pressed": x && b === Er ? !0 : void 0,
+    "aria-roledescription": A,
+    "aria-describedby": h.draggable
+  }), [o, b, v, x, A, h.draggable]);
+  return {
+    active: d,
+    activatorEvent: c,
+    activeNodeRect: u,
+    attributes: M,
+    isDragging: x,
+    listeners: o ? void 0 : _,
+    node: E,
+    over: w,
+    setNodeRef: D,
+    setActivatorNodeRef: T,
+    transform: S
+  };
+}
+function to() {
+  return vt(Zr);
+}
+const zs = "Droppable", Fs = {
+  timeout: 25
+};
+function Ks(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: o,
+    resizeObserverConfig: i
+  } = e;
+  const a = qt(zs), {
+    active: l,
+    dispatch: c,
+    over: d,
+    measureDroppableContainers: u
+  } = vt(Jt), h = Y({
+    disabled: n
+  }), g = Y(!1), w = Y(null), b = Y(null), {
+    disabled: A,
+    updateMeasurementsFor: v,
+    timeout: x
+  } = {
+    ...Fs,
+    ...i
+  }, S = Yt(v ?? o), E = be(
+    () => {
+      if (!g.current) {
+        g.current = !0;
+        return;
+      }
+      b.current != null && clearTimeout(b.current), b.current = setTimeout(() => {
+        u(Array.isArray(S.current) ? S.current : [S.current]), b.current = null;
+      }, x);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [x]
+  ), D = An({
+    callback: E,
+    disabled: A || !l
+  }), R = be((M, H) => {
+    D && (H && (D.unobserve(H), g.current = !1), M && D.observe(M));
+  }, [D]), [T, _] = vn(R), O = Yt(t);
+  return K(() => {
+    !D || !T.current || (D.disconnect(), g.current = !1, D.observe(T.current));
+  }, [T, D]), Ue(
+    () => (c({
+      type: le.RegisterDroppable,
+      element: {
+        id: o,
+        key: a,
+        disabled: n,
+        node: T,
+        rect: w,
+        data: O
+      }
+    }), () => c({
+      type: le.UnregisterDroppable,
+      key: a,
+      id: o
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [o]
+  ), K(() => {
+    n !== h.current.disabled && (c({
+      type: le.SetDroppableDisabled,
+      id: o,
+      key: a,
+      disabled: n
+    }), h.current.disabled = n);
+  }, [o, a, n, c]), {
+    active: l,
+    rect: w,
+    isOver: (d == null ? void 0 : d.id) === o,
+    node: T,
+    over: d,
+    setNodeRef: _
+  };
+}
+function Hs(e) {
+  let {
+    animation: t,
+    children: n
+  } = e;
+  const [o, i] = he(null), [a, l] = he(null), c = bn(n);
+  return !n && !o && c && i(c), Ue(() => {
+    if (!a)
+      return;
+    const d = o == null ? void 0 : o.key, u = o == null ? void 0 : o.props.id;
+    if (d == null || u == null) {
+      i(null);
+      return;
+    }
+    Promise.resolve(t(u, a)).then(() => {
+      i(null);
+    });
+  }, [t, o, a]), k.createElement(k.Fragment, null, n, o ? vi(o, {
+    ref: l
+  }) : null);
+}
+const Us = {
+  x: 0,
+  y: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+function Xs(e) {
+  let {
+    children: t
+  } = e;
+  return k.createElement(Jt.Provider, {
+    value: Qr
+  }, k.createElement(En.Provider, {
+    value: Us
+  }, t));
+}
+const js = {
+  position: "fixed",
+  touchAction: "none"
+}, Ys = (e) => Rn(e) ? "transform 250ms ease" : void 0, ks = /* @__PURE__ */ Nr((e, t) => {
+  let {
+    as: n,
+    activatorEvent: o,
+    adjustScale: i,
+    children: a,
+    className: l,
+    rect: c,
+    style: d,
+    transform: u,
+    transition: h = Ys
+  } = e;
+  if (!c)
+    return null;
+  const g = i ? u : {
+    ...u,
+    scaleX: 1,
+    scaleY: 1
+  }, w = {
+    ...js,
+    width: c.width,
+    height: c.height,
+    top: c.top,
+    left: c.left,
+    transform: bt.Transform.toString(g),
+    transformOrigin: i && o ? Fi(o, c) : void 0,
+    transition: typeof h == "function" ? h(o) : h,
+    ...d
+  };
+  return k.createElement(n, {
+    className: l,
+    style: w,
+    ref: t
+  }, a);
+}), no = (e) => (t) => {
+  let {
+    active: n,
+    dragOverlay: o
+  } = t;
+  const i = {}, {
+    styles: a,
+    className: l
+  } = e;
+  if (a != null && a.active)
+    for (const [c, d] of Object.entries(a.active))
+      d !== void 0 && (i[c] = n.node.style.getPropertyValue(c), n.node.style.setProperty(c, d));
+  if (a != null && a.dragOverlay)
+    for (const [c, d] of Object.entries(a.dragOverlay))
+      d !== void 0 && o.node.style.setProperty(c, d);
+  return l != null && l.active && n.node.classList.add(l.active), l != null && l.dragOverlay && o.node.classList.add(l.dragOverlay), function() {
+    for (const [d, u] of Object.entries(i))
+      n.node.style.setProperty(d, u);
+    l != null && l.active && n.node.classList.remove(l.active);
+  };
+}, Gs = (e) => {
+  let {
+    transform: {
+      initial: t,
+      final: n
+    }
+  } = e;
+  return [{
+    transform: bt.Transform.toString(t)
+  }, {
+    transform: bt.Transform.toString(n)
+  }];
+}, Ws = {
+  duration: 250,
+  easing: "ease",
+  keyframes: Gs,
+  sideEffects: /* @__PURE__ */ no({
+    styles: {
+      active: {
+        opacity: "0"
+      }
+    }
+  })
+};
+function qs(e) {
+  let {
+    config: t,
+    draggableNodes: n,
+    droppableContainers: o,
+    measuringConfiguration: i
+  } = e;
+  return Sn((a, l) => {
+    if (t === null)
+      return;
+    const c = n.get(a);
+    if (!c)
+      return;
+    const d = c.node.current;
+    if (!d)
+      return;
+    const u = Vr(l);
+    if (!u)
+      return;
+    const {
+      transform: h
+    } = Se(l).getComputedStyle(l), g = zr(h);
+    if (!g)
+      return;
+    const w = typeof t == "function" ? t : Js(t);
+    return Yr(d, i.draggable.measure), w({
+      active: {
+        id: a,
+        data: c.data,
+        node: d,
+        rect: i.draggable.measure(d)
+      },
+      draggableNodes: n,
+      dragOverlay: {
+        node: l,
+        rect: i.dragOverlay.measure(u)
+      },
+      droppableContainers: o,
+      measuringConfiguration: i,
+      transform: g
+    });
+  });
+}
+function Js(e) {
+  const {
+    duration: t,
+    easing: n,
+    sideEffects: o,
+    keyframes: i
+  } = {
+    ...Ws,
+    ...e
+  };
+  return (a) => {
+    let {
+      active: l,
+      dragOverlay: c,
+      transform: d,
+      ...u
+    } = a;
+    if (!t)
+      return;
+    const h = {
+      x: c.rect.left - l.rect.left,
+      y: c.rect.top - l.rect.top
+    }, g = {
+      scaleX: d.scaleX !== 1 ? l.rect.width * d.scaleX / c.rect.width : 1,
+      scaleY: d.scaleY !== 1 ? l.rect.height * d.scaleY / c.rect.height : 1
+    }, w = {
+      x: d.x - h.x,
+      y: d.y - h.y,
+      ...g
+    }, b = i({
+      ...u,
+      active: l,
+      dragOverlay: c,
+      transform: {
+        initial: d,
+        final: w
+      }
+    }), [A] = b, v = b[b.length - 1];
+    if (JSON.stringify(A) === JSON.stringify(v))
+      return;
+    const x = o == null ? void 0 : o({
+      active: l,
+      dragOverlay: c,
+      ...u
+    }), S = c.node.animate(b, {
+      duration: t,
+      easing: n,
+      fill: "forwards"
+    });
+    return new Promise((E) => {
+      S.onfinish = () => {
+        x == null || x(), E();
+      };
+    });
+  };
+}
+let _r = 0;
+function Vs(e) {
+  return j(() => {
+    if (e != null)
+      return _r++, _r;
+  }, [e]);
+}
+const Qs = /* @__PURE__ */ k.memo((e) => {
+  let {
+    adjustScale: t = !1,
+    children: n,
+    dropAnimation: o,
+    style: i,
+    transition: a,
+    modifiers: l,
+    wrapperElement: c = "div",
+    className: d,
+    zIndex: u = 999
+  } = e;
+  const {
+    activatorEvent: h,
+    active: g,
+    activeNodeRect: w,
+    containerNodeRect: b,
+    draggableNodes: A,
+    droppableContainers: v,
+    dragOverlay: x,
+    over: S,
+    measuringConfiguration: E,
+    scrollableAncestors: D,
+    scrollableAncestorRects: R,
+    windowRect: T
+  } = to(), _ = vt(En), O = Vs(g == null ? void 0 : g.id), M = eo(l, {
+    activatorEvent: h,
+    active: g,
+    activeNodeRect: w,
+    containerNodeRect: b,
+    draggingNodeRect: x.rect,
+    over: S,
+    overlayNodeRect: x.rect,
+    scrollableAncestors: D,
+    scrollableAncestorRects: R,
+    transform: _,
+    windowRect: T
+  }), H = nr(w), U = qs({
+    config: o,
+    draggableNodes: A,
+    droppableContainers: v,
+    measuringConfiguration: E
+  }), B = H ? x.setRef : void 0;
+  return k.createElement(Xs, null, k.createElement(Hs, {
+    animation: U
+  }, g && O ? k.createElement(ks, {
+    key: O,
+    id: g.id,
+    ref: B,
+    as: c,
+    activatorEvent: h,
+    adjustScale: t,
+    className: d,
+    transition: a,
+    rect: H,
+    style: {
+      zIndex: u,
+      ...i
+    },
+    transform: M
+  }, n) : null));
+});
+function jt(e, t, n) {
+  const o = e.slice();
+  return o.splice(n < 0 ? o.length + n : n, 0, o.splice(t, 1)[0]), o;
+}
+function Zs(e, t) {
+  return e.reduce((n, o, i) => {
+    const a = t.get(o);
+    return a && (n[i] = a), n;
+  }, Array(e.length));
+}
+function dn(e) {
+  return e !== null && e >= 0;
+}
+function ea(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 ta(e) {
+  return typeof e == "boolean" ? {
+    draggable: e,
+    droppable: e
+  } : e;
+}
+const fn = {
+  scaleX: 1,
+  scaleY: 1
+}, na = (e) => {
+  var t;
+  let {
+    rects: n,
+    activeNodeRect: o,
+    activeIndex: i,
+    overIndex: a,
+    index: l
+  } = e;
+  const c = (t = n[i]) != null ? t : o;
+  if (!c)
+    return null;
+  const d = ra(n, l, i);
+  if (l === i) {
+    const u = n[a];
+    return u ? {
+      x: i < a ? u.left + u.width - (c.left + c.width) : u.left - c.left,
+      y: 0,
+      ...fn
+    } : null;
+  }
+  return l > i && l <= a ? {
+    x: -c.width - d,
+    y: 0,
+    ...fn
+  } : l < i && l >= a ? {
+    x: c.width + d,
+    y: 0,
+    ...fn
+  } : {
+    x: 0,
+    y: 0,
+    ...fn
+  };
+};
+function ra(e, t, n) {
+  const o = e[t], i = e[t - 1], a = e[t + 1];
+  return !o || !i && !a ? 0 : n < t ? i ? o.left - (i.left + i.width) : a.left - (o.left + o.width) : a ? a.left - (o.left + o.width) : o.left - (i.left + i.width);
+}
+const ro = (e) => {
+  let {
+    rects: t,
+    activeIndex: n,
+    overIndex: o,
+    index: i
+  } = e;
+  const a = jt(t, o, n), l = t[i], c = a[i];
+  return !c || !l ? null : {
+    x: c.left - l.left,
+    y: c.top - l.top,
+    scaleX: c.width / l.width,
+    scaleY: c.height / l.height
+  };
+}, gn = {
+  scaleX: 1,
+  scaleY: 1
+}, Ir = (e) => {
+  var t;
+  let {
+    activeIndex: n,
+    activeNodeRect: o,
+    index: i,
+    rects: a,
+    overIndex: l
+  } = e;
+  const c = (t = a[n]) != null ? t : o;
+  if (!c)
+    return null;
+  if (i === n) {
+    const u = a[l];
+    return u ? {
+      x: 0,
+      y: n < l ? u.top + u.height - (c.top + c.height) : u.top - c.top,
+      ...gn
+    } : null;
+  }
+  const d = oa(a, i, n);
+  return i > n && i <= l ? {
+    x: 0,
+    y: -c.height - d,
+    ...gn
+  } : i < n && i >= l ? {
+    x: 0,
+    y: c.height + d,
+    ...gn
+  } : {
+    x: 0,
+    y: 0,
+    ...gn
+  };
+};
+function oa(e, t, n) {
+  const o = e[t], i = e[t - 1], a = e[t + 1];
+  return o ? n < t ? i ? o.top - (i.top + i.height) : a ? a.top - (o.top + o.height) : 0 : a ? a.top - (o.top + o.height) : i ? o.top - (i.top + i.height) : 0 : 0;
+}
+const oo = "Sortable", io = /* @__PURE__ */ k.createContext({
+  activeIndex: -1,
+  containerId: oo,
+  disableTransforms: !1,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: !1,
+  sortedRects: [],
+  strategy: ro,
+  disabled: {
+    draggable: !1,
+    droppable: !1
+  }
+});
+function Or(e) {
+  let {
+    children: t,
+    id: n,
+    items: o,
+    strategy: i = ro,
+    disabled: a = !1
+  } = e;
+  const {
+    active: l,
+    dragOverlay: c,
+    droppableRects: d,
+    over: u,
+    measureDroppableContainers: h
+  } = to(), g = qt(oo, n), w = c.rect !== null, b = j(() => o.map((_) => typeof _ == "object" && "id" in _ ? _.id : _), [o]), A = l != null, v = l ? b.indexOf(l.id) : -1, x = u ? b.indexOf(u.id) : -1, S = Y(b), E = !ea(b, S.current), D = x !== -1 && v === -1 || E, R = ta(a);
+  Ue(() => {
+    E && A && h(b);
+  }, [E, b, A, h]), K(() => {
+    S.current = b;
+  }, [b]);
+  const T = j(
+    () => ({
+      activeIndex: v,
+      containerId: g,
+      disabled: R,
+      disableTransforms: D,
+      items: b,
+      overIndex: x,
+      useDragOverlay: w,
+      sortedRects: Zs(b, d),
+      strategy: i
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [v, g, R.draggable, R.droppable, D, b, x, d, w, i]
+  );
+  return k.createElement(io.Provider, {
+    value: T
+  }, t);
+}
+const ia = (e) => {
+  let {
+    id: t,
+    items: n,
+    activeIndex: o,
+    overIndex: i
+  } = e;
+  return jt(n, o, i).indexOf(t);
+}, so = (e) => {
+  let {
+    containerId: t,
+    isSorting: n,
+    wasDragging: o,
+    index: i,
+    items: a,
+    newIndex: l,
+    previousItems: c,
+    previousContainerId: d,
+    transition: u
+  } = e;
+  return !u || !o || c !== a && i === l ? !1 : n ? !0 : l !== i && t === d;
+}, sa = {
+  duration: 200,
+  easing: "ease"
+}, ao = "transform", aa = /* @__PURE__ */ bt.Transition.toString({
+  property: ao,
+  duration: 0,
+  easing: "linear"
+}), la = {
+  roleDescription: "sortable"
+};
+function ca(e) {
+  let {
+    disabled: t,
+    index: n,
+    node: o,
+    rect: i
+  } = e;
+  const [a, l] = he(null), c = Y(n);
+  return Ue(() => {
+    if (!t && n !== c.current && o.current) {
+      const d = i.current;
+      if (d) {
+        const u = zt(o.current, {
+          ignoreTransform: !0
+        }), h = {
+          x: d.left - u.left,
+          y: d.top - u.top,
+          scaleX: d.width / u.width,
+          scaleY: d.height / u.height
+        };
+        (h.x || h.y) && l(h);
+      }
+    }
+    n !== c.current && (c.current = n);
+  }, [t, n, o, i]), K(() => {
+    a && l(null);
+  }, [a]), a;
+}
+function lo(e) {
+  let {
+    animateLayoutChanges: t = so,
+    attributes: n,
+    disabled: o,
+    data: i,
+    getNewIndex: a = ia,
+    id: l,
+    strategy: c,
+    resizeObserverConfig: d,
+    transition: u = sa
+  } = e;
+  const {
+    items: h,
+    containerId: g,
+    activeIndex: w,
+    disabled: b,
+    disableTransforms: A,
+    sortedRects: v,
+    overIndex: x,
+    useDragOverlay: S,
+    strategy: E
+  } = vt(io), D = ua(o, b), R = h.indexOf(l), T = j(() => ({
+    sortable: {
+      containerId: g,
+      index: R,
+      items: h
+    },
+    ...i
+  }), [g, i, R, h]), _ = j(() => h.slice(h.indexOf(l)), [h, l]), {
+    rect: O,
+    node: M,
+    isOver: H,
+    setNodeRef: U
+  } = Ks({
+    id: l,
+    data: T,
+    disabled: D.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: _,
+      ...d
+    }
+  }), {
+    active: B,
+    activatorEvent: re,
+    activeNodeRect: Q,
+    attributes: Re,
+    setNodeRef: Xe,
+    listeners: F,
+    isDragging: J,
+    over: Le,
+    setActivatorNodeRef: Oe,
+    transform: ce
+  } = Bs({
+    id: l,
+    data: T,
+    attributes: {
+      ...la,
+      ...n
+    },
+    disabled: D.draggable
+  }), Pe = Si(U, Xe), V = !!B, we = V && !A && dn(w) && dn(x), je = !S && J, tt = je && we ? ce : null, nt = we ? tt ?? (c ?? E)({
+    rects: v,
+    activeNodeRect: Q,
+    activeIndex: w,
+    overIndex: x,
+    index: R
+  }) : null, $e = dn(w) && dn(x) ? a({
+    id: l,
+    items: h,
+    activeIndex: w,
+    overIndex: x
+  }) : R, ue = B == null ? void 0 : B.id, $ = Y({
+    activeId: ue,
+    items: h,
+    newIndex: $e,
+    containerId: g
+  }), rt = h !== $.current.items, Ae = t({
+    active: B,
+    containerId: g,
+    isDragging: J,
+    isSorting: V,
+    id: l,
+    index: R,
+    items: h,
+    newIndex: $.current.newIndex,
+    previousItems: $.current.items,
+    previousContainerId: $.current.containerId,
+    transition: u,
+    wasDragging: $.current.activeId != null
+  }), Ve = ca({
+    disabled: !Ae,
+    index: R,
+    node: M,
+    rect: O
+  });
+  return K(() => {
+    V && $.current.newIndex !== $e && ($.current.newIndex = $e), g !== $.current.containerId && ($.current.containerId = g), h !== $.current.items && ($.current.items = h);
+  }, [V, $e, g, h]), K(() => {
+    if (ue === $.current.activeId)
+      return;
+    if (ue && !$.current.activeId) {
+      $.current.activeId = ue;
+      return;
+    }
+    const Qe = setTimeout(() => {
+      $.current.activeId = ue;
+    }, 50);
+    return () => clearTimeout(Qe);
+  }, [ue]), {
+    active: B,
+    activeIndex: w,
+    attributes: Re,
+    data: T,
+    rect: O,
+    index: R,
+    newIndex: $e,
+    items: h,
+    isOver: H,
+    isSorting: V,
+    isDragging: J,
+    listeners: F,
+    node: M,
+    overIndex: x,
+    over: Le,
+    setNodeRef: Pe,
+    setActivatorNodeRef: Oe,
+    setDroppableNodeRef: U,
+    setDraggableNodeRef: Xe,
+    transform: Ve ?? nt,
+    transition: P()
+  };
+  function P() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      Ve || // Or to prevent items jumping to back to their "new" position when items change
+      rt && $.current.newIndex === R
+    )
+      return aa;
+    if (!(je && !Rn(re) || !u) && (V || Ae))
+      return bt.Transition.toString({
+        ...u,
+        property: ao
+      });
+  }
+}
+function ua(e, t) {
+  var n, o;
+  return typeof e == "boolean" ? {
+    draggable: e,
+    // Backwards compatibility
+    droppable: !1
+  } : {
+    draggable: (n = e == null ? void 0 : e.draggable) != null ? n : t.draggable,
+    droppable: (o = e == null ? void 0 : e.droppable) != null ? o : t.droppable
+  };
+}
+L.Down, L.Right, L.Up, L.Left;
+const da = (e) => e;
+function Tr(e, t = da) {
+  return [...new Array(e)].map((n, o) => t(o));
+}
+const fa = [
+  L.Down,
+  L.Right,
+  L.Up,
+  L.Left
+], ga = (e, { context: { active: t, droppableRects: n, droppableContainers: o, collisionRect: i } }) => {
+  var a;
+  if (fa.includes(e.code)) {
+    if (e.preventDefault(), !t || !i)
+      return;
+    const l = [];
+    o.getEnabled().forEach((u) => {
+      var w;
+      if (!u || u != null && u.disabled)
+        return;
+      const h = n.get(u.id);
+      if (!h)
+        return;
+      const g = u.data.current;
+      if (g) {
+        const { type: b, children: A } = g;
+        if (b === "container" && (A == null ? void 0 : A.length) > 0 && ((w = t.data.current) == null ? void 0 : w.type) !== "container")
+          return;
+      }
+      switch (e.code) {
+        case L.Down:
+          i.top < h.top && l.push(u);
+          break;
+        case L.Up:
+          i.top > h.top && l.push(u);
+          break;
+        case L.Left:
+          i.left >= h.left + h.width && l.push(u);
+          break;
+        case L.Right:
+          i.left + i.width <= h.left && l.push(u);
+          break;
+      }
+    });
+    const c = Hi({
+      active: t,
+      collisionRect: i,
+      droppableRects: n,
+      droppableContainers: l,
+      pointerCoordinates: null
+    }), d = Vn(c, "id");
+    if (d != null) {
+      const u = o.get(d), h = u == null ? void 0 : u.node.current, g = u == null ? void 0 : u.rect.current;
+      if (h && g)
+        return u.id === "placeholder" ? {
+          x: g.left + (g.width - i.width) / 2,
+          y: g.top + (g.height - i.height) / 2
+        } : ((a = u.data.current) == null ? void 0 : a.type) === "container" ? {
+          x: g.left + 20,
+          y: g.top + 74
+        } : {
+          x: g.left,
+          y: g.top
+        };
+    }
+  }
+}, ha = "_Wrapper_37o6x_33", pa = "_fadeIn_37o6x_41", va = "_dragOverlay_37o6x_44", ba = "_Item_37o6x_53", ya = "_withHandle_37o6x_79", ma = "_dragging_37o6x_83", wa = "_disabled_37o6x_91", xa = "_pop_37o6x_1", Ca = "_color_37o6x_110", Da = "_Remove_37o6x_123", Sa = "_Actions_37o6x_129", qe = {
+  Wrapper: ha,
+  fadeIn: pa,
+  dragOverlay: va,
+  Item: ba,
+  withHandle: ya,
+  dragging: ma,
+  disabled: wa,
+  pop: xa,
+  color: Ca,
+  Remove: Da,
+  Actions: Sa
+}, Ra = Pt.div`
+  font-family: ${(e) => {
+  var t, n;
+  return (n = (t = e.theme) == null ? void 0 : t.typography) == null ? void 0 : n.fontFamily;
+}};
+  background-color: ${(e) => Mt(
+  e.theme,
+  "KanbanCard",
+  e.color ? "primary" : e.color,
+  "enabled",
+  "background"
+)};
+  color: ${(e) => Mt(
+  e.theme,
+  "KanbanCard",
+  e.color ? "primary" : e.color,
+  "enabled",
+  "text"
+)};
+  &:hover .Actions > * {
+    opacity: 1 !important;
+  }
+`, Xn = k.memo(
+  k.forwardRef(
+    ({
+      cardProps: e,
+      color: t,
+      dragOverlay: n,
+      dragging: o,
+      disabled: i,
+      fadeIn: a,
+      handle: l,
+      handleProps: c,
+      height: d,
+      index: u,
+      listeners: h,
+      onRemove: g,
+      renderItem: w,
+      sorting: b,
+      transition: A,
+      transform: v,
+      value: x,
+      wrapperStyle: S,
+      className: E,
+      style: D,
+      children: R,
+      ...T
+    }, _) => {
+      const O = kn();
+      return K(() => {
+        if (n)
+          return document.body.style.cursor = "grabbing", () => {
+            document.body.style.cursor = "";
+          };
+      }, [n]), w ? w({
+        dragOverlay: !!n,
+        dragging: !!o,
+        sorting: !!b,
+        index: u,
+        fadeIn: !!a,
+        listeners: h,
+        ref: _,
+        style: D,
+        transform: v,
+        transition: A,
+        value: x
+      }) : /* @__PURE__ */ ae(
+        "li",
+        {
+          className: pr(
+            qe.Wrapper,
+            a && qe.fadeIn,
+            b && qe.sorting,
+            n && qe.dragOverlay
+          ),
+          style: {
+            ...S,
+            transition: [A, S == null ? void 0 : S.transition].filter(Boolean).join(", "),
+            "--translate-x": v ? `${Math.round(v.x)}px` : void 0,
+            "--translate-y": v ? `${Math.round(v.y)}px` : void 0,
+            "--scale-x": v != null && v.scaleX ? `${v.scaleX}` : void 0,
+            "--scale-y": v != null && v.scaleY ? `${v.scaleY}` : void 0,
+            "--index": u,
+            "--color": t
+          },
+          ref: _,
+          children: /* @__PURE__ */ pn(
+            Ra,
+            {
+              theme: O,
+              color: t,
+              className: pr(
+                qe.Item,
+                o && qe.dragging,
+                l && qe.withHandle,
+                n && qe.dragOverlay,
+                i && qe.disabled,
+                t && qe.color
+              ) + " " + E,
+              style: e == null ? void 0 : e.style,
+              "data-cypress": "draggable-item",
+              ...l ? void 0 : h,
+              ...T,
+              tabIndex: l ? void 0 : 0,
+              children: [
+                R,
+                /* @__PURE__ */ ae("span", { className: qe.Actions })
+              ]
+            }
+          )
+        }
+      );
+    }
+  )
+), Aa = Pt.div`
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  grid-auto-rows: max-content;
+  overflow: hidden;
+  box-sizing: border-box;
+  appearance: none;
+  outline: none;
+  min-width: 350px;
+  margin: 10px;
+  border-radius: 5px;
+  min-height: 200px;
+  transition: background-color 350ms ease;
+  background-color: rgba(246, 246, 246, 1);
+  border: 1px solid rgba(0, 0, 0, 0.05);
+  font-size: 1em;
+
+  ${(e) => e.horizontal ? "width: 100%;" : ""}
+  ${(e) => e.shadow ? "box-shadow: 0 1px 10px 0 rgba(34, 33, 81, 0.1);" : ""}
+
+  & ul {
+    display: grid;
+    grid-gap: 10px;
+    grid-template-columns: repeat(var(--columns, 1), 1fr);
+    list-style: none;
+    padding: 20px;
+    margin: 0;
+    ${(e) => e.scrollable ? "overflow-y: auto;" : ""}
+    ${(e) => e.horizontal ? "grid-auto-flow: column;" : ""}
+    ${(e) => e.maxContainerHeight && `max-height: ${e.maxContainerHeight};`}
+    overflow: auto;
+  }
+
+  ${(e) => e.hover ? " background-color: #ebebeb;" : ""}
+
+  &:focus-visible {
+    border-color: transparent;
+    box-shadow: 0 0 0 2px rgba(255, 255, 255, 0), 0 0px 0px 2px #4c9ffe;
+  }
+
+  background-color: ${(e) => Mt(
+  e.theme,
+  "Kanban",
+  e.color,
+  "enabled",
+  "background"
+)};
+`, Ea = Pt.div`
+  display: flex;
+  padding: 5px 20px;
+  padding-left: 8px;
+  gap: 12px;
+  align-items: center;
+  background-color: #fff;
+  border-top-left-radius: 5px;
+  border-top-right-radius: 5px;
+  border-bottom: 1px solid rgba(0, 0, 0, 0.08);
+  background-color: ${(e) => Mt(
+  e.theme,
+  "KanbanHeader",
+  e.color,
+  "enabled",
+  "background"
+)};
+  color: ${(e) => Mt(
+  e.theme,
+  "KanbanHeader",
+  e.color ? "primary" : e.color,
+  "enabled",
+  "text"
+)};
+  &:hover .Actions > * {
+    opacity: 1 !important;
+  }
+`, _a = Pt.div`
+  display: flex;
+
+  & > *:first-of-type:not(:last-of-type) {
+    opacity: 0;
+  }
+
+  & > *:first-of-type:not(:last-of-type):focus-visible {
+    opacity: 1;
+  }
+`, co = Nr((e, t) => {
+  const {
+    children: n,
+    containerId: o,
+    renderFooterContent: i,
+    columns: a = 1,
+    handleProps: l,
+    horizontal: c,
+    hover: d,
+    onClick: u,
+    onRemove: h,
+    label: g,
+    placeholder: w,
+    maxContainerHeight: b,
+    style: A,
+    scrollable: v,
+    shadow: x,
+    unstyled: S,
+    size: E,
+    color: D,
+    ...R
+  } = e, T = kn();
+  return /* @__PURE__ */ pn(
+    Aa,
+    {
+      ...R,
+      ref: t,
+      style: {
+        ...A,
+        "--columns": a
+      },
+      unstyled: S,
+      horizontal: c,
+      hover: d,
+      scrollable: v,
+      shadow: x,
+      onClick: u,
+      tabIndex: u ? 0 : void 0,
+      maxContainerHeight: b,
+      color: D,
+      theme: T,
+      children: [
+        g ? /* @__PURE__ */ pn(Ea, { theme: T, color: D, children: [
+          /* @__PURE__ */ ae(_a, { className: "Actions", children: /* @__PURE__ */ ae(yi, { ...l }) }),
+          g
+        ] }) : null,
+        /* @__PURE__ */ ae("ul", { children: n }),
+        i(o)
+      ]
+    }
+  );
+});
+var Cn = { exports: {} };
+Cn.exports;
+(function(e, t) {
+  var n = 200, o = "Expected a function", i = "__lodash_hash_undefined__", a = 1, l = 2, c = 1 / 0, d = 9007199254740991, u = 17976931348623157e292, h = NaN, g = "[object Arguments]", w = "[object Array]", b = "[object Boolean]", A = "[object Date]", v = "[object Error]", x = "[object Function]", S = "[object GeneratorFunction]", E = "[object Map]", D = "[object Number]", R = "[object Object]", T = "[object Promise]", _ = "[object RegExp]", O = "[object Set]", M = "[object String]", H = "[object Symbol]", U = "[object WeakMap]", B = "[object ArrayBuffer]", re = "[object DataView]", Q = "[object Float32Array]", Re = "[object Float64Array]", Xe = "[object Int8Array]", F = "[object Int16Array]", J = "[object Int32Array]", Le = "[object Uint8Array]", Oe = "[object Uint8ClampedArray]", ce = "[object Uint16Array]", Pe = "[object Uint32Array]", V = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, we = /^\w*$/, je = /^\./, tt = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, Z = /[\\^$.*+?()[\]{}|]/g, nt = /^\s+|\s+$/g, $e = /\\(\\)?/g, ue = /^[-+]0x[0-9a-f]+$/i, $ = /^0b[01]+$/i, rt = /^\[object .+?Constructor\]$/, Ae = /^0o[0-7]+$/i, Ve = /^(?:0|[1-9]\d*)$/, P = {};
+  P[Q] = P[Re] = P[Xe] = P[F] = P[J] = P[Le] = P[Oe] = P[ce] = P[Pe] = !0, P[g] = P[w] = P[B] = P[b] = P[re] = P[A] = P[v] = P[x] = P[E] = P[D] = P[R] = P[_] = P[O] = P[M] = P[U] = !1;
+  var Qe = parseInt, Ye = typeof un == "object" && un && un.Object === Object && un, yt = typeof self == "object" && self && self.Object === Object && self, Ee = Ye || yt || Function("return this")(), Ze = t && !t.nodeType && t, p = Ze && !0 && e && !e.nodeType && e, m = p && p.exports === Ze, N = m && Ye.process, q = function() {
+    try {
+      return N && N.binding("util");
+    } catch {
+    }
+  }(), G = q && q.isTypedArray;
+  function de(r, s) {
+    for (var f = -1, y = r ? r.length : 0; ++f < y; )
+      if (s(r[f], f, r))
+        return !0;
+    return !1;
+  }
+  function ee(r, s, f, y) {
+    for (var I = r.length, C = f + -1; ++C < I; )
+      if (s(r[C], C, r))
+        return C;
+    return -1;
+  }
+  function oe(r) {
+    return function(s) {
+      return s == null ? void 0 : s[r];
+    };
+  }
+  function pe(r, s) {
+    for (var f = -1, y = Array(r); ++f < r; )
+      y[f] = s(f);
+    return y;
+  }
+  function ye(r) {
+    return function(s) {
+      return r(s);
+    };
+  }
+  function ot(r, s) {
+    return r == null ? void 0 : r[s];
+  }
+  function te(r) {
+    var s = !1;
+    if (r != null && typeof r.toString != "function")
+      try {
+        s = !!(r + "");
+      } catch {
+      }
+    return s;
+  }
+  function Te(r) {
+    var s = -1, f = Array(r.size);
+    return r.forEach(function(y, I) {
+      f[++s] = [I, y];
+    }), f;
+  }
+  function mt(r, s) {
+    return function(f) {
+      return r(s(f));
+    };
+  }
+  function ie(r) {
+    var s = -1, f = Array(r.size);
+    return r.forEach(function(y) {
+      f[++s] = y;
+    }), f;
+  }
+  var fe = Array.prototype, Be = Function.prototype, et = Object.prototype, Ft = Ee["__core-js_shared__"], Vt = function() {
+    var r = /[^.]+$/.exec(Ft && Ft.keys && Ft.keys.IE_PROTO || "");
+    return r ? "Symbol(src)_1." + r : "";
+  }(), Qt = Be.toString, X = et.hasOwnProperty, ne = et.toString, xe = RegExp(
+    "^" + Qt.call(X).replace(Z, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+  ), ke = Ee.Symbol, Ce = Ee.Uint8Array, Ne = et.propertyIsEnumerable, ze = fe.splice, ut = mt(Object.keys, Object), Me = Math.max, it = _t(Ee, "DataView"), Ge = _t(Ee, "Map"), dt = _t(Ee, "Promise"), ft = _t(Ee, "Set"), Et = _t(Ee, "WeakMap"), We = _t(Object, "create"), wt = Ct(it), Kt = Ct(Ge), uo = Ct(dt), fo = Ct(ft), go = Ct(Et), Zt = ke ? ke.prototype : void 0, _n = Zt ? Zt.valueOf : void 0, rr = Zt ? Zt.toString : void 0;
+  function xt(r) {
+    var s = -1, f = r ? r.length : 0;
+    for (this.clear(); ++s < f; ) {
+      var y = r[s];
+      this.set(y[0], y[1]);
+    }
+  }
+  function ho() {
+    this.__data__ = We ? We(null) : {};
+  }
+  function po(r) {
+    return this.has(r) && delete this.__data__[r];
+  }
+  function vo(r) {
+    var s = this.__data__;
+    if (We) {
+      var f = s[r];
+      return f === i ? void 0 : f;
+    }
+    return X.call(s, r) ? s[r] : void 0;
+  }
+  function bo(r) {
+    var s = this.__data__;
+    return We ? s[r] !== void 0 : X.call(s, r);
+  }
+  function yo(r, s) {
+    var f = this.__data__;
+    return f[r] = We && s === void 0 ? i : s, this;
+  }
+  xt.prototype.clear = ho, xt.prototype.delete = po, xt.prototype.get = vo, xt.prototype.has = bo, xt.prototype.set = yo;
+  function st(r) {
+    var s = -1, f = r ? r.length : 0;
+    for (this.clear(); ++s < f; ) {
+      var y = r[s];
+      this.set(y[0], y[1]);
+    }
+  }
+  function mo() {
+    this.__data__ = [];
+  }
+  function wo(r) {
+    var s = this.__data__, f = tn(s, r);
+    if (f < 0)
+      return !1;
+    var y = s.length - 1;
+    return f == y ? s.pop() : ze.call(s, f, 1), !0;
+  }
+  function xo(r) {
+    var s = this.__data__, f = tn(s, r);
+    return f < 0 ? void 0 : s[f][1];
+  }
+  function Co(r) {
+    return tn(this.__data__, r) > -1;
+  }
+  function Do(r, s) {
+    var f = this.__data__, y = tn(f, r);
+    return y < 0 ? f.push([r, s]) : f[y][1] = s, this;
+  }
+  st.prototype.clear = mo, st.prototype.delete = wo, st.prototype.get = xo, st.prototype.has = Co, st.prototype.set = Do;
+  function at(r) {
+    var s = -1, f = r ? r.length : 0;
+    for (this.clear(); ++s < f; ) {
+      var y = r[s];
+      this.set(y[0], y[1]);
+    }
+  }
+  function So() {
+    this.__data__ = {
+      hash: new xt(),
+      map: new (Ge || st)(),
+      string: new xt()
+    };
+  }
+  function Ro(r) {
+    return nn(this, r).delete(r);
+  }
+  function Ao(r) {
+    return nn(this, r).get(r);
+  }
+  function Eo(r) {
+    return nn(this, r).has(r);
+  }
+  function _o(r, s) {
+    return nn(this, r).set(r, s), this;
+  }
+  at.prototype.clear = So, at.prototype.delete = Ro, at.prototype.get = Ao, at.prototype.has = Eo, at.prototype.set = _o;
+  function en(r) {
+    var s = -1, f = r ? r.length : 0;
+    for (this.__data__ = new at(); ++s < f; )
+      this.add(r[s]);
+  }
+  function Io(r) {
+    return this.__data__.set(r, i), this;
+  }
+  function Oo(r) {
+    return this.__data__.has(r);
+  }
+  en.prototype.add = en.prototype.push = Io, en.prototype.has = Oo;
+  function lt(r) {
+    this.__data__ = new st(r);
+  }
+  function To() {
+    this.__data__ = new st();
+  }
+  function No(r) {
+    return this.__data__.delete(r);
+  }
+  function Mo(r) {
+    return this.__data__.get(r);
+  }
+  function Lo(r) {
+    return this.__data__.has(r);
+  }
+  function Po(r, s) {
+    var f = this.__data__;
+    if (f instanceof st) {
+      var y = f.__data__;
+      if (!Ge || y.length < n - 1)
+        return y.push([r, s]), this;
+      f = this.__data__ = new at(y);
+    }
+    return f.set(r, s), this;
+  }
+  lt.prototype.clear = To, lt.prototype.delete = No, lt.prototype.get = Mo, lt.prototype.has = Lo, lt.prototype.set = Po;
+  function $o(r, s) {
+    var f = Dt(r) || dr(r) ? pe(r.length, String) : [], y = f.length, I = !!y;
+    for (var C in r)
+      X.call(r, C) && !(I && (C == "length" || ar(C, y))) && f.push(C);
+    return f;
+  }
+  function tn(r, s) {
+    for (var f = r.length; f--; )
+      if (ur(r[f][0], s))
+        return f;
+    return -1;
+  }
+  function or(r, s) {
+    s = rn(s, r) ? [s] : ir(s);
+    for (var f = 0, y = s.length; r != null && f < y; )
+      r = r[on(s[f++])];
+    return f && f == y ? r : void 0;
+  }
+  function Bo(r) {
+    return ne.call(r);
+  }
+  function zo(r, s) {
+    return r != null && s in Object(r);
+  }
+  function In(r, s, f, y, I) {
+    return r === s ? !0 : r == null || s == null || !It(r) && !sn(s) ? r !== r && s !== s : Fo(r, s, In, f, y, I);
+  }
+  function Fo(r, s, f, y, I, C) {
+    var z = Dt(r), ve = Dt(s), se = w, me = w;
+    z || (se = gt(r), se = se == g ? R : se), ve || (me = gt(s), me = me == g ? R : me);
+    var _e = se == R && !te(r), Ie = me == R && !te(s), De = se == me;
+    if (De && !_e)
+      return C || (C = new lt()), z || ii(r) ? sr(r, s, f, y, I, C) : qo(r, s, se, f, y, I, C);
+    if (!(I & l)) {
+      var Fe = _e && X.call(r, "__wrapped__"), Ke = Ie && X.call(s, "__wrapped__");
+      if (Fe || Ke) {
+        var ht = Fe ? r.value() : r, ct = Ke ? s.value() : s;
+        return C || (C = new lt()), f(ht, ct, y, I, C);
+      }
+    }
+    return De ? (C || (C = new lt()), Jo(r, s, f, y, I, C)) : !1;
+  }
+  function Ko(r, s, f, y) {
+    var I = f.length, C = I;
+    if (r == null)
+      return !C;
+    for (r = Object(r); I--; ) {
+      var z = f[I];
+      if (z[2] ? z[1] !== r[z[0]] : !(z[0] in r))
+        return !1;
+    }
+    for (; ++I < C; ) {
+      z = f[I];
+      var ve = z[0], se = r[ve], me = z[1];
+      if (z[2]) {
+        if (se === void 0 && !(ve in r))
+          return !1;
+      } else {
+        var _e = new lt(), Ie;
+        if (!(Ie === void 0 ? In(me, se, y, a | l, _e) : Ie))
+          return !1;
+      }
+    }
+    return !0;
+  }
+  function Ho(r) {
+    if (!It(r) || ei(r))
+      return !1;
+    var s = gr(r) || te(r) ? xe : rt;
+    return s.test(Ct(r));
+  }
+  function Uo(r) {
+    return sn(r) && Tn(r.length) && !!P[ne.call(r)];
+  }
+  function Xo(r) {
+    return typeof r == "function" ? r : r == null ? fi : typeof r == "object" ? Dt(r) ? ko(r[0], r[1]) : Yo(r) : gi(r);
+  }
+  function jo(r) {
+    if (!ti(r))
+      return ut(r);
+    var s = [];
+    for (var f in Object(r))
+      X.call(r, f) && f != "constructor" && s.push(f);
+    return s;
+  }
+  function Yo(r) {
+    var s = Vo(r);
+    return s.length == 1 && s[0][2] ? cr(s[0][0], s[0][1]) : function(f) {
+      return f === r || Ko(f, r, s);
+    };
+  }
+  function ko(r, s) {
+    return rn(r) && lr(s) ? cr(on(r), s) : function(f) {
+      var y = ui(f, r);
+      return y === void 0 && y === s ? di(f, r) : In(s, y, void 0, a | l);
+    };
+  }
+  function Go(r) {
+    return function(s) {
+      return or(s, r);
+    };
+  }
+  function Wo(r) {
+    if (typeof r == "string")
+      return r;
+    if (an(r))
+      return rr ? rr.call(r) : "";
+    var s = r + "";
+    return s == "0" && 1 / r == -c ? "-0" : s;
+  }
+  function ir(r) {
+    return Dt(r) ? r : ni(r);
+  }
+  function sr(r, s, f, y, I, C) {
+    var z = I & l, ve = r.length, se = s.length;
+    if (ve != se && !(z && se > ve))
+      return !1;
+    var me = C.get(r);
+    if (me && C.get(s))
+      return me == s;
+    var _e = -1, Ie = !0, De = I & a ? new en() : void 0;
+    for (C.set(r, s), C.set(s, r); ++_e < ve; ) {
+      var Fe = r[_e], Ke = s[_e];
+      if (y)
+        var ht = z ? y(Ke, Fe, _e, s, r, C) : y(Fe, Ke, _e, r, s, C);
+      if (ht !== void 0) {
+        if (ht)
+          continue;
+        Ie = !1;
+        break;
+      }
+      if (De) {
+        if (!de(s, function(ct, St) {
+          if (!De.has(St) && (Fe === ct || f(Fe, ct, y, I, C)))
+            return De.add(St);
+        })) {
+          Ie = !1;
+          break;
+        }
+      } else if (!(Fe === Ke || f(Fe, Ke, y, I, C))) {
+        Ie = !1;
+        break;
+      }
+    }
+    return C.delete(r), C.delete(s), Ie;
+  }
+  function qo(r, s, f, y, I, C, z) {
+    switch (f) {
+      case re:
+        if (r.byteLength != s.byteLength || r.byteOffset != s.byteOffset)
+          return !1;
+        r = r.buffer, s = s.buffer;
+      case B:
+        return !(r.byteLength != s.byteLength || !y(new Ce(r), new Ce(s)));
+      case b:
+      case A:
+      case D:
+        return ur(+r, +s);
+      case v:
+        return r.name == s.name && r.message == s.message;
+      case _:
+      case M:
+        return r == s + "";
+      case E:
+        var ve = Te;
+      case O:
+        var se = C & l;
+        if (ve || (ve = ie), r.size != s.size && !se)
+          return !1;
+        var me = z.get(r);
+        if (me)
+          return me == s;
+        C |= a, z.set(r, s);
+        var _e = sr(ve(r), ve(s), y, I, C, z);
+        return z.delete(r), _e;
+      case H:
+        if (_n)
+          return _n.call(r) == _n.call(s);
+    }
+    return !1;
+  }
+  function Jo(r, s, f, y, I, C) {
+    var z = I & l, ve = Nn(r), se = ve.length, me = Nn(s), _e = me.length;
+    if (se != _e && !z)
+      return !1;
+    for (var Ie = se; Ie--; ) {
+      var De = ve[Ie];
+      if (!(z ? De in s : X.call(s, De)))
+        return !1;
+    }
+    var Fe = C.get(r);
+    if (Fe && C.get(s))
+      return Fe == s;
+    var Ke = !0;
+    C.set(r, s), C.set(s, r);
+    for (var ht = z; ++Ie < se; ) {
+      De = ve[Ie];
+      var ct = r[De], St = s[De];
+      if (y)
+        var hr = z ? y(St, ct, De, s, r, C) : y(ct, St, De, r, s, C);
+      if (!(hr === void 0 ? ct === St || f(ct, St, y, I, C) : hr)) {
+        Ke = !1;
+        break;
+      }
+      ht || (ht = De == "constructor");
+    }
+    if (Ke && !ht) {
+      var ln = r.constructor, cn = s.constructor;
+      ln != cn && "constructor" in r && "constructor" in s && !(typeof ln == "function" && ln instanceof ln && typeof cn == "function" && cn instanceof cn) && (Ke = !1);
+    }
+    return C.delete(r), C.delete(s), Ke;
+  }
+  function nn(r, s) {
+    var f = r.__data__;
+    return Zo(s) ? f[typeof s == "string" ? "string" : "hash"] : f.map;
+  }
+  function Vo(r) {
+    for (var s = Nn(r), f = s.length; f--; ) {
+      var y = s[f], I = r[y];
+      s[f] = [y, I, lr(I)];
+    }
+    return s;
+  }
+  function _t(r, s) {
+    var f = ot(r, s);
+    return Ho(f) ? f : void 0;
+  }
+  var gt = Bo;
+  (it && gt(new it(new ArrayBuffer(1))) != re || Ge && gt(new Ge()) != E || dt && gt(dt.resolve()) != T || ft && gt(new ft()) != O || Et && gt(new Et()) != U) && (gt = function(r) {
+    var s = ne.call(r), f = s == R ? r.constructor : void 0, y = f ? Ct(f) : void 0;
+    if (y)
+      switch (y) {
+        case wt:
+          return re;
+        case Kt:
+          return E;
+        case uo:
+          return T;
+        case fo:
+          return O;
+        case go:
+          return U;
+      }
+    return s;
+  });
+  function Qo(r, s, f) {
+    s = rn(s, r) ? [s] : ir(s);
+    for (var y, I = -1, z = s.length; ++I < z; ) {
+      var C = on(s[I]);
+      if (!(y = r != null && f(r, C)))
+        break;
+      r = r[C];
+    }
+    if (y)
+      return y;
+    var z = r ? r.length : 0;
+    return !!z && Tn(z) && ar(C, z) && (Dt(r) || dr(r));
+  }
+  function ar(r, s) {
+    return s = s ?? d, !!s && (typeof r == "number" || Ve.test(r)) && r > -1 && r % 1 == 0 && r < s;
+  }
+  function rn(r, s) {
+    if (Dt(r))
+      return !1;
+    var f = typeof r;
+    return f == "number" || f == "symbol" || f == "boolean" || r == null || an(r) ? !0 : we.test(r) || !V.test(r) || s != null && r in Object(s);
+  }
+  function Zo(r) {
+    var s = typeof r;
+    return s == "string" || s == "number" || s == "symbol" || s == "boolean" ? r !== "__proto__" : r === null;
+  }
+  function ei(r) {
+    return !!Vt && Vt in r;
+  }
+  function ti(r) {
+    var s = r && r.constructor, f = typeof s == "function" && s.prototype || et;
+    return r === f;
+  }
+  function lr(r) {
+    return r === r && !It(r);
+  }
+  function cr(r, s) {
+    return function(f) {
+      return f == null ? !1 : f[r] === s && (s !== void 0 || r in Object(f));
+    };
+  }
+  var ni = On(function(r) {
+    r = ci(r);
+    var s = [];
+    return je.test(r) && s.push(""), r.replace(tt, function(f, y, I, C) {
+      s.push(I ? C.replace($e, "$1") : y || f);
+    }), s;
+  });
+  function on(r) {
+    if (typeof r == "string" || an(r))
+      return r;
+    var s = r + "";
+    return s == "0" && 1 / r == -c ? "-0" : s;
+  }
+  function Ct(r) {
+    if (r != null) {
+      try {
+        return Qt.call(r);
+      } catch {
+      }
+      try {
+        return r + "";
+      } catch {
+      }
+    }
+    return "";
+  }
+  function ri(r, s, f) {
+    var y = r ? r.length : 0;
+    if (!y)
+      return -1;
+    var I = f == null ? 0 : ai(f);
+    return I < 0 && (I = Me(y + I, 0)), ee(r, Xo(s), I);
+  }
+  function On(r, s) {
+    if (typeof r != "function" || s && typeof s != "function")
+      throw new TypeError(o);
+    var f = function() {
+      var y = arguments, I = s ? s.apply(this, y) : y[0], C = f.cache;
+      if (C.has(I))
+        return C.get(I);
+      var z = r.apply(this, y);
+      return f.cache = C.set(I, z), z;
+    };
+    return f.cache = new (On.Cache || at)(), f;
+  }
+  On.Cache = at;
+  function ur(r, s) {
+    return r === s || r !== r && s !== s;
+  }
+  function dr(r) {
+    return oi(r) && X.call(r, "callee") && (!Ne.call(r, "callee") || ne.call(r) == g);
+  }
+  var Dt = Array.isArray;
+  function fr(r) {
+    return r != null && Tn(r.length) && !gr(r);
+  }
+  function oi(r) {
+    return sn(r) && fr(r);
+  }
+  function gr(r) {
+    var s = It(r) ? ne.call(r) : "";
+    return s == x || s == S;
+  }
+  function Tn(r) {
+    return typeof r == "number" && r > -1 && r % 1 == 0 && r <= d;
+  }
+  function It(r) {
+    var s = typeof r;
+    return !!r && (s == "object" || s == "function");
+  }
+  function sn(r) {
+    return !!r && typeof r == "object";
+  }
+  function an(r) {
+    return typeof r == "symbol" || sn(r) && ne.call(r) == H;
+  }
+  var ii = G ? ye(G) : Uo;
+  function si(r) {
+    if (!r)
+      return r === 0 ? r : 0;
+    if (r = li(r), r === c || r === -c) {
+      var s = r < 0 ? -1 : 1;
+      return s * u;
+    }
+    return r === r ? r : 0;
+  }
+  function ai(r) {
+    var s = si(r), f = s % 1;
+    return s === s ? f ? s - f : s : 0;
+  }
+  function li(r) {
+    if (typeof r == "number")
+      return r;
+    if (an(r))
+      return h;
+    if (It(r)) {
+      var s = typeof r.valueOf == "function" ? r.valueOf() : r;
+      r = It(s) ? s + "" : s;
+    }
+    if (typeof r != "string")
+      return r === 0 ? r : +r;
+    r = r.replace(nt, "");
+    var f = $.test(r);
+    return f || Ae.test(r) ? Qe(r.slice(2), f ? 2 : 8) : ue.test(r) ? h : +r;
+  }
+  function ci(r) {
+    return r == null ? "" : Wo(r);
+  }
+  function ui(r, s, f) {
+    var y = r == null ? void 0 : or(r, s);
+    return y === void 0 ? f : y;
+  }
+  function di(r, s) {
+    return r != null && Qo(r, s, zo);
+  }
+  function Nn(r) {
+    return fr(r) ? $o(r) : jo(r);
+  }
+  function fi(r) {
+    return r;
+  }
+  function gi(r) {
+    return rn(r) ? oe(on(r)) : Go(r);
+  }
+  e.exports = ri;
+})(Cn, Cn.exports);
+var Ia = Cn.exports;
+const Rt = /* @__PURE__ */ bi(Ia), Oa = Pt.div``, Ta = Pt.div`
+  box-sizing: border-box;
+  display: flex;
+  flex-direction: ${(e) => e.verticalDisplay ? "column" : "row"};
+  ${(e) => e.horizontalDisplay == !1 && "flex-wrap: wrap;"}
+  overflow: auto;
+`, Na = (e) => so({ ...e, wasDragging: !0 }), Ma = {
+  sideEffects: no({
+    styles: {
+      active: {
+        opacity: "0.5"
+      }
+    }
+  })
+}, La = () => {
+  const [e, t] = he(!1);
+  return K(() => {
+    const n = setTimeout(() => t(!0), 500);
+    return () => clearTimeout(n);
+  }, []), e;
+}, jn = (e, t) => {
+  if (e)
+    return Mt(
+      t,
+      "KanbanCard",
+      e,
+      "enabled",
+      "highlight"
+    );
+}, Pa = ({
+  children: e,
+  containerId: t,
+  columns: n = 1,
+  disabled: o,
+  id: i,
+  items: a,
+  className: l,
+  renderFooterContent: c,
+  maxContainerHeight: d,
+  style: u,
+  ...h
+}) => {
+  var R;
+  const {
+    active: g,
+    attributes: w,
+    isDragging: b,
+    listeners: A,
+    over: v,
+    setNodeRef: x,
+    transition: S,
+    transform: E
+  } = lo({
+    id: i,
+    data: {
+      type: "container",
+      children: a
+    },
+    animateLayoutChanges: Na
+  }), D = v ? i === v.id && ((R = g == null ? void 0 : g.data.current) == null ? void 0 : R.type) !== "container" || a.includes(v.id) : !1;
+  return /* @__PURE__ */ ae(
+    co,
+    {
+      ref: o ? void 0 : x,
+      style: {
+        ...u,
+        transition: S,
+        transform: bt.Translate.toString(E),
+        opacity: b ? 0.5 : void 0
+      },
+      className: l,
+      hover: D,
+      handleProps: {
+        ...w,
+        ...A
+      },
+      containerId: t,
+      renderFooterContent: c,
+      maxContainerHeight: d,
+      ...h,
+      children: e
+    }
+  );
+}, $a = ({
+  disabled: e,
+  id: t,
+  item: n,
+  index: o,
+  renderItem: i,
+  style: a = {},
+  containerId: l,
+  getIndex: c,
+  wrapperStyle: d,
+  cardProps: u,
+  theme: h,
+  renderContent: g,
+  color: w
+}) => {
+  const {
+    setNodeRef: b,
+    setActivatorNodeRef: A,
+    listeners: v,
+    isDragging: x,
+    isSorting: S,
+    over: E,
+    overIndex: D,
+    transform: R,
+    transition: T,
+    attributes: _
+  } = lo({
+    id: t
+  }), O = La(), M = x && !O;
+  return /* @__PURE__ */ ae(
+    Xn,
+    {
+      ref: e ? void 0 : b,
+      cardProps: u,
+      value: t,
+      dragging: x,
+      sorting: S,
+      handle: (u == null ? void 0 : u.handle) !== !1,
+      handleProps: {
+        ..._,
+        ...v
+      },
+      index: o,
+      wrapperStyle: d({ index: o }),
+      style: {
+        ...a,
+        index: o,
+        value: t,
+        isDragging: x,
+        isSorting: S,
+        overIndex: E ? c(E.id) : D,
+        containerId: l
+      },
+      color: jn(n == null ? void 0 : n.color, h),
+      transition: T,
+      transform: R,
+      fadeIn: M,
+      listeners: v,
+      renderItem: i,
+      children: g(n == null ? void 0 : n.content, t, {
+        ...u,
+        handleProps: { ..._, ...v },
+        item: n,
+        containerId: l
+      })
+    }
+  );
+}, Ba = k.forwardRef((e, t) => {
+  const {
+    horizontalDisplay: n = !1,
+    verticalDisplay: o = !1,
+    adjustScale: i = !1,
+    itemCount: a = 5,
+    cancelDrop: l,
+    columns: c,
+    handle: d = !1,
+    containerStyle: u,
+    coordinateGetter: h = ga,
+    getItemStyles: g = (p) => ({ ...p }),
+    wrapperStyle: w = (p) => ({ ...p }),
+    minimal: b = !1,
+    modifiers: A,
+    renderItem: v,
+    strategy: x = Ir,
+    scrollable: S,
+    maxContainerHeight: E,
+    cardProps: D,
+    headerProps: R,
+    footerProps: T,
+    //---------------------------
+    data: _ = [],
+    columnInfo: O = {},
+    onColumnMoved: M = () => {
+    },
+    onCardMoved: H = () => {
+    },
+    onCardChangedColumns: U = () => {
+    },
+    //---------------------------
+    color: B = "primary",
+    size: re = "small",
+    children: Q,
+    ...Re
+  } = e, Xe = kn(), [F, J] = he(
+    () => _ ?? {
+      A: Tr(a, (p) => `A${p + 1}`),
+      B: Tr(a, (p) => `B${p + 1}`)
+    }
+  ), [Le, Oe] = he(Object.keys(_)), [ce, Pe] = he(null), V = Y(null), we = Y(!1), je = ce ? Le.includes(ce) : !1, tt = be(
+    (p) => {
+      var G;
+      if (ce && ce in F)
+        return yr({
+          ...p,
+          droppableContainers: p.droppableContainers.filter(
+            (de) => de.id in F
+          )
+        });
+      const m = ji(p), N = m.length > 0 ? (
+        // If there are droppables intersecting with the pointer, return those
+        m
+      ) : $r(p);
+      let q = Vn(N, "id");
+      if (q != null) {
+        if (q in F) {
+          const de = F[q];
+          de.length > 0 && (q = (G = yr({
+            ...p,
+            droppableContainers: p.droppableContainers.filter(
+              (ee) => ee.id !== q && de.map((oe) => oe.id).includes(ee.id)
+            )
+          })[0]) == null ? void 0 : G.id);
+        }
+        return V.current = q, [{ id: q }];
+      }
+      return we.current && (V.current = ce), V.current ? [{ id: V.current }] : [];
+    },
+    [ce, F]
+  ), [Z, nt] = he([]), $e = zi(
+    Ln(Wr),
+    Ln(qr),
+    Ln(er, {
+      coordinateGetter: h
+    })
+  );
+  Di(() => {
+    J(_), Oe(Object.keys(_));
+  }), Ci(() => {
+    J(_), Oe(Object.keys(_));
+  }, [_]), K(() => {
+    requestAnimationFrame(() => {
+      we.current = !1;
+    });
+  }, [F]);
+  const ue = (p) => p in F ? p : Object.keys(F).find(
+    (m) => F[m].map((N) => N.id).includes(p)
+  ), $ = (p) => {
+    const m = ue(p);
+    return m ? Rt(F[m], (N) => N.id == p) : -1;
+  }, rt = () => {
+    Z && J(Z), Pe(null), nt(null);
+  }, Ae = (p) => {
+    Pe(p.active.id), nt(F);
+  }, Ve = (p) => {
+    const { active: m, over: N } = p, q = N == null ? void 0 : N.id;
+    if (q == null || m.id in F)
+      return;
+    const G = ue(q), de = ue(m.id);
+    !G || !de || de !== G && J((ee) => {
+      const oe = ee[de], pe = ee[G], ye = Rt(pe, (Te) => Te.id == q), ot = Rt(oe, (Te) => Te.id == m.id);
+      let te;
+      if (q in ee)
+        te = pe.length + 1;
+      else {
+        const mt = N && m.rect.current.translated && m.rect.current.translated.top > N.rect.top + N.rect.height ? 1 : 0;
+        te = ye >= 0 ? ye + mt : pe.length + 1;
+      }
+      return U(m.id), we.current = !0, {
+        ...ee,
+        [de]: ee[de].filter(
+          (Te) => Te.id != m.id
+        ),
+        [G]: [
+          ...ee[G].slice(0, te),
+          ee[de][ot],
+          ...ee[G].slice(
+            te,
+            ee[G].length
+          )
+        ]
+      };
+    });
+  }, P = (p) => {
+    const { active: m, over: N } = p;
+    var q = !1, G = wi(F);
+    m.id in F && (N != null && N.id) && Oe((ie) => {
+      q = !0;
+      const fe = ie.indexOf(m.id), Be = ie.indexOf(N.id);
+      var et = jt(ie, fe, Be);
+      return m.id !== N.id && M(p, et), et;
+    });
+    const de = ue(m.id);
+    if (!de) {
+      Pe(null);
+      return;
+    }
+    const ee = N == null ? void 0 : N.id;
+    if (ee == null) {
+      Pe(null);
+      return;
+    }
+    const oe = ue(ee);
+    if (oe) {
+      const ie = Rt(
+        F[de],
+        (Be) => Be.id == m.id
+      ), fe = Rt(F[oe], (Be) => Be.id == ee);
+      ie !== fe && (G = {
+        ...G,
+        [oe]: jt(
+          G[oe],
+          ie,
+          fe
+        )
+      }, J((Be) => ({
+        ...Be,
+        [oe]: jt(
+          Be[oe],
+          ie,
+          fe
+        )
+      })));
+    }
+    if (!q) {
+      var pe, ye = null, ot, te = -1, Te = Object.keys(Z), mt = Object.keys(G);
+      Te.forEach((ie) => {
+        if (Z[ie].map((fe) => fe.id.toString()).includes(m.id.toString())) {
+          pe = ie, ot = Rt(Z[ie], (fe) => fe.id == m.id);
+          return;
+        }
+      }), mt.forEach((ie) => {
+        if (G[ie].map((fe) => fe.id.toString()).includes(m.id.toString())) {
+          ye = ie, te = Rt(G[ie], (fe) => fe.id == m.id);
+          return;
+        }
+      }), pe === ye && ot !== te && H(p, G, ye), pe !== ye && U(p, G, ye, pe);
+    }
+    Pe(null);
+  }, Qe = (p) => {
+    var m = null;
+    return Le.forEach((N) => {
+      F[N].forEach((q) => {
+        if (q.id == p) {
+          m = q;
+          return;
+        }
+      });
+    }), /* @__PURE__ */ ae(
+      Xn,
+      {
+        value: p,
+        handle: d,
+        cardProps: D,
+        style: g({
+          containerId: ue(p),
+          overIndex: -1,
+          index: $(p),
+          value: p,
+          isSorting: !0,
+          isDragging: !0,
+          isDragOverlay: !0
+        }),
+        color: jn(m == null ? void 0 : m.color, Xe),
+        wrapperStyle: w({ index: 0 }),
+        renderItem: v,
+        dragOverlay: !0,
+        children: Ze(m == null ? void 0 : m.content, p, { ...D, item: m }) || {
+          name: p
+        }
+      }
+    );
+  }, Ye = (p) => /* @__PURE__ */ ae(
+    co,
+    {
+      label: yt(p),
+      columns: c,
+      style: {
+        height: "100%"
+      },
+      shadow: !0,
+      unstyled: !1,
+      containerId: p,
+      renderFooterContent: Ee,
+      children: F[p].map((m, N) => /* @__PURE__ */ ae(
+        Xn,
+        {
+          cardProps: D,
+          value: m.id,
+          handle: d,
+          style: g({
+            containerId: p,
+            overIndex: -1,
+            index: $(m),
+            value: m,
+            isDragging: !1,
+            isSorting: !1,
+            isDragOverlay: !1
+          }),
+          color: jn(m == null ? void 0 : m.color, Xe),
+          wrapperStyle: w({ index: N }),
+          renderItem: v,
+          children: Ze(m == null ? void 0 : m.content, m == null ? void 0 : m.id, {
+            ...D,
+            item: m,
+            containerId: p
+          })
+        },
+        m.id
+      ))
+    }
+  ), yt = (p) => {
+    let m = c == null ? void 0 : c.find((N) => N.id == (p == null ? void 0 : p.toString()));
+    return Ot(
+      Tt("KANBAN_HEADER", p, Q),
+      {
+        ...R,
+        item: { [p]: F[p] },
+        column: m
+      },
+      m == null ? void 0 : m.header,
+      !0
+    ) || Ot(
+      Tt("KANBAN_HEADER", null, Q),
+      {
+        ...R,
+        item: { [p]: F[p] },
+        column: m
+      },
+      m == null ? void 0 : m.header,
+      !0
+    ) || /* @__PURE__ */ ae(
+      xi,
+      {
+        id: p,
+        color: B,
+        size: re,
+        item: { [p]: F[p] },
+        column: m,
+        ...R,
+        children: m == null ? void 0 : m.header
+      }
+    );
+  }, Ee = (p) => Ot(
+    Tt("KANBAN_FOOTER", p, Q),
+    {
+      ...T,
+      id: p
+    },
+    null
+  ) || Ot(
+    Tt("KANBAN_FOOTER", null, Q),
+    {
+      ...T,
+      id: p
+    },
+    null
+  ), Ze = (p, m, N) => Ot(
+    Tt("KANBAN_CARD", m, Q),
+    {
+      ...N
+    },
+    p,
+    !0
+  ) || Ot(
+    Tt("KANBAN_CARD", null, Q),
+    {
+      ...N
+    },
+    p,
+    !0
+  ) || /* @__PURE__ */ ae(mi, { color: B, size: re, ...N, children: p });
+  return /* @__PURE__ */ ae(Oa, { ref: t, ...Re, children: /* @__PURE__ */ pn(
+    Ls,
+    {
+      measuring: {
+        droppable: {
+          strategy: Lt.Always
+        }
+      },
+      sensors: $e,
+      collisionDetection: tt,
+      modifiers: A,
+      cancelDrop: l,
+      onDragCancel: rt,
+      onDragStart: Ae,
+      onDragOver: Ve,
+      onDragEnd: P,
+      children: [
+        /* @__PURE__ */ ae(
+          Ta,
+          {
+            horizontalDisplay: n,
+            verticalDisplay: o,
+            children: /* @__PURE__ */ ae(
+              Or,
+              {
+                items: [...Le],
+                strategy: o ? Ir : na,
+                children: Le.map((p) => /* @__PURE__ */ ae(
+                  Pa,
+                  {
+                    id: p,
+                    label: b ? void 0 : yt(p),
+                    items: F[p],
+                    color: B,
+                    scrollable: S,
+                    style: u,
+                    unstyled: b,
+                    containerId: p,
+                    renderFooterContent: Ee,
+                    maxContainerHeight: E,
+                    ...R,
+                    children: /* @__PURE__ */ ae(Or, { items: F[p], strategy: x, children: F[p].map((m, N) => /* @__PURE__ */ ae(
+                      $a,
+                      {
+                        disabled: je || (m == null ? void 0 : m.disabled),
+                        id: m.id,
+                        item: m,
+                        index: N,
+                        style: g,
+                        wrapperStyle: w,
+                        renderItem: v,
+                        containerId: p,
+                        getIndex: $,
+                        cardProps: D,
+                        theme: Xe,
+                        renderContent: Ze
+                      },
+                      m.id
+                    )) })
+                  },
+                  p
+                ))
+              }
+            )
+          }
+        ),
+        At.createPortal(
+          /* @__PURE__ */ ae(Qs, { adjustScale: i, dropAnimation: Ma, children: ce ? Le.includes(ce) ? Ye(ce) : Qe(ce) : null }),
+          document.body
+        )
+      ]
+    }
+  ) });
+});
+Ba.propTypes = {
+  horizontalDisplay: W.bool,
+  verticalDisplay: W.bool,
+  adjustScale: W.bool,
+  //Number of items in container
+  itemCount: W.bool,
+  cancelDrop: W.func,
+  /**
+   * type of: [{id: `<string | number>`, content: `<string | element>`}, ...]
+   */
+  columns: W.array,
+  handle: W.bool,
+  // containerStyle,
+  // coordinateGetter = multipleContainersCoordinateGetter,
+  getItemStyles: W.func,
+  wrapperStyle: W.func,
+  minimal: W.bool,
+  // modifiers,
+  renderItem: W.func,
+  // strategy = verticalListSortingStrategy,
+  scrollable: W.bool,
+  cardProps: W.any,
+  headerProps: W.any,
+  footerProps: W.any,
+  //---------------------------
+  /**
+   * Type of:
+   * { < string | number >:
+   * array[{ id< string | number >,
+   * name< string >,
+   *  content< element >,
+   * color< "primary" | "secondary" | "danger" | "warning" | "information" | "neutral" >]}] }
+   */
+  data: W.object,
+  columnInfo: W.object,
+  onColumnMoved: W.func,
+  onCardMoved: W.func,
+  onCardChangedColumns: W.func,
+  /**
+   * Max height of column container (cards list) before scroll appears.
+   */
+  maxContainerHeight: W.string,
+  //----------------
+  className: W.string,
+  style: W.object,
+  color: W.oneOf([
+    "primary",
+    "secondary",
+    "success",
+    "warning",
+    "danger",
+    "information",
+    "neutral",
+    "gray"
+  ]),
+  size: W.oneOf(["small", "medium", "large"])
+};
+export {
+  Ba as default
+};