@cloudraker/reki 2.6.1 → 2.7.1

package/dist/chunks/record-board-iapx3cw5rusehrta.js

@@ -0,0 +1,3395 @@
+"use client";
+import { jsxs as St, jsx as q, Fragment as jn } from "react/jsx-runtime";
+import L, { useRef as O, useMemo as A, useLayoutEffect as Yn, useEffect as T, useCallback as $, useState as F, memo as Kn, useReducer as Un, useContext as pe, createContext as Ke, cloneElement as Wn, forwardRef as Vn } from "react";
+import { unstable_batchedUpdates as et, createPortal as Hn } from "react-dom";
+import { C as _n } from "./color-sample-h7hspma3rb91go3z.js";
+import { c as rn } from "./cn-ct4n7r74mh8y0f48.js";
+function qn() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return A(
+    () => (r) => {
+      t.forEach((o) => o(r));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const ut = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function Ee(e) {
+  const t = Object.prototype.toString.call(e);
+  return t === "[object Window]" || // In Electron context the Window object serializes to [object global]
+  t === "[object global]";
+}
+function It(e) {
+  return "nodeType" in e;
+}
+function X(e) {
+  var t, n;
+  return e ? Ee(e) ? e : It(e) && (t = (n = e.ownerDocument) == null ? void 0 : n.defaultView) != null ? t : window : window;
+}
+function Nt(e) {
+  const {
+    Document: t
+  } = X(e);
+  return e instanceof t;
+}
+function Ue(e) {
+  return Ee(e) ? !1 : e instanceof X(e).HTMLElement;
+}
+function on(e) {
+  return e instanceof X(e).SVGElement;
+}
+function Ae(e) {
+  return e ? Ee(e) ? e.document : It(e) ? Nt(e) ? e : Ue(e) || on(e) ? e.ownerDocument : document : document : document;
+}
+const Q = ut ? Yn : T;
+function dt(e) {
+  const t = O(e);
+  return Q(() => {
+    t.current = e;
+  }), $(function() {
+    for (var n = arguments.length, r = new Array(n), o = 0; o < n; o++)
+      r[o] = arguments[o];
+    return t.current == null ? void 0 : t.current(...r);
+  }, []);
+}
+function Gn() {
+  const e = O(null), t = $((r, o) => {
+    e.current = setInterval(r, o);
+  }, []), n = $(() => {
+    e.current !== null && (clearInterval(e.current), e.current = null);
+  }, []);
+  return [t, n];
+}
+function Xe(e, t) {
+  t === void 0 && (t = [e]);
+  const n = O(e);
+  return Q(() => {
+    n.current !== e && (n.current = e);
+  }, t), n;
+}
+function We(e, t) {
+  const n = O();
+  return A(
+    () => {
+      const r = e(n.current);
+      return n.current = r, r;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function ot(e) {
+  const t = dt(e), n = O(null), r = $(
+    (o) => {
+      o !== n.current && t?.(o, n.current), n.current = o;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [n, r];
+}
+function it(e) {
+  const t = O();
+  return T(() => {
+    t.current = e;
+  }, [e]), t.current;
+}
+let yt = {};
+function Ve(e, t) {
+  return A(() => {
+    if (t)
+      return t;
+    const n = yt[e] == null ? 0 : yt[e] + 1;
+    return yt[e] = n, e + "-" + n;
+  }, [e, t]);
+}
+function sn(e) {
+  return function(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    return r.reduce((i, s) => {
+      const a = Object.entries(s);
+      for (const [l, c] of a) {
+        const d = i[l];
+        d != null && (i[l] = d + e * c);
+      }
+      return i;
+    }, {
+      ...t
+    });
+  };
+}
+const Re = /* @__PURE__ */ sn(1), je = /* @__PURE__ */ sn(-1);
+function Jn(e) {
+  return "clientX" in e && "clientY" in e;
+}
+function ft(e) {
+  if (!e)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = X(e.target);
+  return t && e instanceof t;
+}
+function Qn(e) {
+  if (!e)
+    return !1;
+  const {
+    TouchEvent: t
+  } = X(e.target);
+  return t && e instanceof t;
+}
+function st(e) {
+  if (Qn(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 Jn(e) ? {
+    x: e.clientX,
+    y: e.clientY
+  } : null;
+}
+const be = /* @__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 [be.Translate.toString(e), be.Scale.toString(e)].join(" ");
+    }
+  },
+  Transition: {
+    toString(e) {
+      let {
+        property: t,
+        duration: n,
+        easing: r
+      } = e;
+      return t + " " + n + "ms " + r;
+    }
+  }
+}), Kt = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function Zn(e) {
+  return e.matches(Kt) ? e : e.querySelector(Kt);
+}
+const er = {
+  display: "none"
+};
+function tr(e) {
+  let {
+    id: t,
+    value: n
+  } = e;
+  return L.createElement("div", {
+    id: t,
+    style: er
+  }, n);
+}
+function nr(e) {
+  let {
+    id: t,
+    announcement: n,
+    ariaLiveType: r = "assertive"
+  } = e;
+  const o = {
+    position: "fixed",
+    top: 0,
+    left: 0,
+    width: 1,
+    height: 1,
+    margin: -1,
+    border: 0,
+    padding: 0,
+    overflow: "hidden",
+    clip: "rect(0 0 0 0)",
+    clipPath: "inset(100%)",
+    whiteSpace: "nowrap"
+  };
+  return L.createElement("div", {
+    id: t,
+    style: o,
+    role: "status",
+    "aria-live": r,
+    "aria-atomic": !0
+  }, n);
+}
+function rr() {
+  const [e, t] = F("");
+  return {
+    announce: $((r) => {
+      r != null && t(r);
+    }, []),
+    announcement: e
+  };
+}
+const an = /* @__PURE__ */ Ke(null);
+function or(e) {
+  const t = pe(an);
+  T(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function ir() {
+  const [e] = F(() => /* @__PURE__ */ new Set()), t = $((r) => (e.add(r), () => e.delete(r)), [e]);
+  return [$((r) => {
+    let {
+      type: o,
+      event: i
+    } = r;
+    e.forEach((s) => {
+      var a;
+      return (a = s[o]) == null ? void 0 : a.call(s, i);
+    });
+  }, [e]), t];
+}
+const sr = {
+  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.
+  `
+}, ar = {
+  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 lr(e) {
+  let {
+    announcements: t = ar,
+    container: n,
+    hiddenTextDescribedById: r,
+    screenReaderInstructions: o = sr
+  } = e;
+  const {
+    announce: i,
+    announcement: s
+  } = rr(), a = Ve("DndLiveRegion"), [l, c] = F(!1);
+  if (T(() => {
+    c(!0);
+  }, []), or(A(() => ({
+    onDragStart(u) {
+      let {
+        active: f
+      } = u;
+      i(t.onDragStart({
+        active: f
+      }));
+    },
+    onDragMove(u) {
+      let {
+        active: f,
+        over: g
+      } = u;
+      t.onDragMove && i(t.onDragMove({
+        active: f,
+        over: g
+      }));
+    },
+    onDragOver(u) {
+      let {
+        active: f,
+        over: g
+      } = u;
+      i(t.onDragOver({
+        active: f,
+        over: g
+      }));
+    },
+    onDragEnd(u) {
+      let {
+        active: f,
+        over: g
+      } = u;
+      i(t.onDragEnd({
+        active: f,
+        over: g
+      }));
+    },
+    onDragCancel(u) {
+      let {
+        active: f,
+        over: g
+      } = u;
+      i(t.onDragCancel({
+        active: f,
+        over: g
+      }));
+    }
+  }), [i, t])), !l)
+    return null;
+  const d = L.createElement(L.Fragment, null, L.createElement(tr, {
+    id: r,
+    value: o.draggable
+  }), L.createElement(nr, {
+    id: a,
+    announcement: s
+  }));
+  return n ? Hn(d, n) : d;
+}
+var k;
+(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";
+})(k || (k = {}));
+function at() {
+}
+function Ut(e, t) {
+  return A(
+    () => ({
+      sensor: e,
+      options: t ?? {}
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  );
+}
+function cr() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return A(
+    () => [...t].filter((r) => r != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const Z = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function ur(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function dr(e, t) {
+  const n = st(e);
+  if (!n)
+    return "0 0";
+  const r = {
+    x: (n.x - t.left) / t.width * 100,
+    y: (n.y - t.top) / t.height * 100
+  };
+  return r.x + "% " + r.y + "%";
+}
+function fr(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return n - r;
+}
+function gr(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return r - n;
+}
+function Wt(e) {
+  let {
+    left: t,
+    top: n,
+    height: r,
+    width: o
+  } = e;
+  return [{
+    x: t,
+    y: n
+  }, {
+    x: t + o,
+    y: n
+  }, {
+    x: t,
+    y: n + r
+  }, {
+    x: t + o,
+    y: n + r
+  }];
+}
+function ln(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return n[t];
+}
+const cn = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Wt(t), i = [];
+  for (const s of r) {
+    const {
+      id: a
+    } = s, l = n.get(a);
+    if (l) {
+      const c = Wt(l), d = o.reduce((f, g, x) => f + ur(c[x], g), 0), u = Number((d / 4).toFixed(4));
+      i.push({
+        id: a,
+        data: {
+          droppableContainer: s,
+          value: u
+        }
+      });
+    }
+  }
+  return i.sort(fr);
+};
+function hr(e, t) {
+  const n = Math.max(t.top, e.top), r = Math.max(t.left, e.left), o = Math.min(t.left + t.width, e.left + e.width), i = Math.min(t.top + t.height, e.top + e.height), s = o - r, a = i - n;
+  if (r < o && n < i) {
+    const l = t.width * t.height, c = e.width * e.height, d = s * a, u = d / (l + c - d);
+    return Number(u.toFixed(4));
+  }
+  return 0;
+}
+const vr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = [];
+  for (const i of r) {
+    const {
+      id: s
+    } = i, a = n.get(s);
+    if (a) {
+      const l = hr(a, t);
+      l > 0 && o.push({
+        id: s,
+        data: {
+          droppableContainer: i,
+          value: l
+        }
+      });
+    }
+  }
+  return o.sort(gr);
+};
+function pr(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function un(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : Z;
+}
+function br(e) {
+  return function(n) {
+    for (var r = arguments.length, o = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++)
+      o[i - 1] = arguments[i];
+    return o.reduce((s, a) => ({
+      ...s,
+      top: s.top + e * a.y,
+      bottom: s.bottom + e * a.y,
+      left: s.left + e * a.x,
+      right: s.right + e * a.x
+    }), {
+      ...n
+    });
+  };
+}
+const mr = /* @__PURE__ */ br(1);
+function dn(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 yr(e, t, n) {
+  const r = dn(t);
+  if (!r)
+    return e;
+  const {
+    scaleX: o,
+    scaleY: i,
+    x: s,
+    y: a
+  } = r, l = e.left - s - (1 - o) * parseFloat(n), c = e.top - a - (1 - i) * parseFloat(n.slice(n.indexOf(" ") + 1)), d = o ? e.width / o : e.width, u = i ? e.height / i : e.height;
+  return {
+    width: d,
+    height: u,
+    top: c,
+    right: l + d,
+    bottom: c + u,
+    left: l
+  };
+}
+const wr = {
+  ignoreTransform: !1
+};
+function Ie(e, t) {
+  t === void 0 && (t = wr);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: c,
+      transformOrigin: d
+    } = X(e).getComputedStyle(e);
+    c && (n = yr(n, c, d));
+  }
+  const {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: l
+  } = n;
+  return {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: l
+  };
+}
+function Vt(e) {
+  return Ie(e, {
+    ignoreTransform: !0
+  });
+}
+function xr(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function Dr(e, t) {
+  return t === void 0 && (t = X(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Sr(e, t) {
+  t === void 0 && (t = X(e).getComputedStyle(e));
+  const n = /(auto|scroll|overlay)/;
+  return ["overflow", "overflowX", "overflowY"].some((o) => {
+    const i = t[o];
+    return typeof i == "string" ? n.test(i) : !1;
+  });
+}
+function gt(e, t) {
+  const n = [];
+  function r(o) {
+    if (t != null && n.length >= t || !o)
+      return n;
+    if (Nt(o) && o.scrollingElement != null && !n.includes(o.scrollingElement))
+      return n.push(o.scrollingElement), n;
+    if (!Ue(o) || on(o) || n.includes(o))
+      return n;
+    const i = X(e).getComputedStyle(o);
+    return o !== e && Sr(o, i) && n.push(o), Dr(o, i) ? n : r(o.parentNode);
+  }
+  return e ? r(e) : n;
+}
+function fn(e) {
+  const [t] = gt(e, 1);
+  return t ?? null;
+}
+function wt(e) {
+  return !ut || !e ? null : Ee(e) ? e : It(e) ? Nt(e) || e === Ae(e).scrollingElement ? window : Ue(e) ? e : null : null;
+}
+function gn(e) {
+  return Ee(e) ? e.scrollX : e.scrollLeft;
+}
+function hn(e) {
+  return Ee(e) ? e.scrollY : e.scrollTop;
+}
+function Ct(e) {
+  return {
+    x: gn(e),
+    y: hn(e)
+  };
+}
+var P;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(P || (P = {}));
+function vn(e) {
+  return !ut || !e ? !1 : e === document.scrollingElement;
+}
+function pn(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = vn(e) ? {
+    height: window.innerHeight,
+    width: window.innerWidth
+  } : {
+    height: e.clientHeight,
+    width: e.clientWidth
+  }, r = {
+    x: e.scrollWidth - n.width,
+    y: e.scrollHeight - n.height
+  }, o = e.scrollTop <= t.y, i = e.scrollLeft <= t.x, s = e.scrollTop >= r.y, a = e.scrollLeft >= r.x;
+  return {
+    isTop: o,
+    isLeft: i,
+    isBottom: s,
+    isRight: a,
+    maxScroll: r,
+    minScroll: t
+  };
+}
+const Cr = {
+  x: 0.2,
+  y: 0.2
+};
+function Rr(e, t, n, r, o) {
+  let {
+    top: i,
+    left: s,
+    right: a,
+    bottom: l
+  } = n;
+  r === void 0 && (r = 10), o === void 0 && (o = Cr);
+  const {
+    isTop: c,
+    isBottom: d,
+    isLeft: u,
+    isRight: f
+  } = pn(e), g = {
+    x: 0,
+    y: 0
+  }, x = {
+    x: 0,
+    y: 0
+  }, v = {
+    height: t.height * o.y,
+    width: t.width * o.x
+  };
+  return !c && i <= t.top + v.height ? (g.y = P.Backward, x.y = r * Math.abs((t.top + v.height - i) / v.height)) : !d && l >= t.bottom - v.height && (g.y = P.Forward, x.y = r * Math.abs((t.bottom - v.height - l) / v.height)), !f && a >= t.right - v.width ? (g.x = P.Forward, x.x = r * Math.abs((t.right - v.width - a) / v.width)) : !u && s <= t.left + v.width && (g.x = P.Backward, x.x = r * Math.abs((t.left + v.width - s) / v.width)), {
+    direction: g,
+    speed: x
+  };
+}
+function Er(e) {
+  if (e === document.scrollingElement) {
+    const {
+      innerWidth: i,
+      innerHeight: s
+    } = window;
+    return {
+      top: 0,
+      left: 0,
+      right: i,
+      bottom: s,
+      width: i,
+      height: s
+    };
+  }
+  const {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o
+  } = e.getBoundingClientRect();
+  return {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o,
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+}
+function bn(e) {
+  return e.reduce((t, n) => Re(t, Ct(n)), Z);
+}
+function Ar(e) {
+  return e.reduce((t, n) => t + gn(n), 0);
+}
+function Ir(e) {
+  return e.reduce((t, n) => t + hn(n), 0);
+}
+function mn(e, t) {
+  if (t === void 0 && (t = Ie), !e)
+    return;
+  const {
+    top: n,
+    left: r,
+    bottom: o,
+    right: i
+  } = t(e);
+  fn(e) && (o <= 0 || i <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const Nr = [["x", ["left", "right"], Ar], ["y", ["top", "bottom"], Ir]];
+class Ot {
+  constructor(t, n) {
+    this.rect = void 0, this.width = void 0, this.height = void 0, this.top = void 0, this.bottom = void 0, this.right = void 0, this.left = void 0;
+    const r = gt(n), o = bn(r);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [i, s, a] of Nr)
+      for (const l of s)
+        Object.defineProperty(this, l, {
+          get: () => {
+            const c = a(r), d = o[i] - c;
+            return this.rect[l] + d;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class Be {
+  constructor(t) {
+    this.target = void 0, this.listeners = [], this.removeAll = () => {
+      this.listeners.forEach((n) => {
+        var r;
+        return (r = this.target) == null ? void 0 : r.removeEventListener(...n);
+      });
+    }, this.target = t;
+  }
+  add(t, n, r) {
+    var o;
+    (o = this.target) == null || o.addEventListener(t, n, r), this.listeners.push([t, n, r]);
+  }
+}
+function Or(e) {
+  const {
+    EventTarget: t
+  } = X(e);
+  return e instanceof t ? e : Ae(e);
+}
+function xt(e, t) {
+  const n = Math.abs(e.x), r = Math.abs(e.y);
+  return typeof t == "number" ? Math.sqrt(n ** 2 + r ** 2) > t : "x" in t && "y" in t ? n > t.x && r > t.y : "x" in t ? n > t.x : "y" in t ? r > t.y : !1;
+}
+var G;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(G || (G = {}));
+function Ht(e) {
+  e.preventDefault();
+}
+function Tr(e) {
+  e.stopPropagation();
+}
+var C;
+(function(e) {
+  e.Space = "Space", e.Down = "ArrowDown", e.Right = "ArrowRight", e.Left = "ArrowLeft", e.Up = "ArrowUp", e.Esc = "Escape", e.Enter = "Enter", e.Tab = "Tab";
+})(C || (C = {}));
+const yn = {
+  start: [C.Space, C.Enter],
+  cancel: [C.Esc],
+  end: [C.Space, C.Enter, C.Tab]
+}, Mr = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case C.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case C.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case C.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case C.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class Tt {
+  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 Be(Ae(n)), this.windowListeners = new Be(X(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(G.Resize, this.handleCancel), this.windowListeners.add(G.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(G.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, r = t.node.current;
+    r && mn(r), n(Z);
+  }
+  handleKeyDown(t) {
+    if (ft(t)) {
+      const {
+        active: n,
+        context: r,
+        options: o
+      } = this.props, {
+        keyboardCodes: i = yn,
+        coordinateGetter: s = Mr,
+        scrollBehavior: a = "smooth"
+      } = o, {
+        code: l
+      } = t;
+      if (i.end.includes(l)) {
+        this.handleEnd(t);
+        return;
+      }
+      if (i.cancel.includes(l)) {
+        this.handleCancel(t);
+        return;
+      }
+      const {
+        collisionRect: c
+      } = r.current, d = c ? {
+        x: c.left,
+        y: c.top
+      } : Z;
+      this.referenceCoordinates || (this.referenceCoordinates = d);
+      const u = s(t, {
+        active: n,
+        context: r.current,
+        currentCoordinates: d
+      });
+      if (u) {
+        const f = je(u, d), g = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: x
+        } = r.current;
+        for (const v of x) {
+          const h = t.code, {
+            isTop: p,
+            isRight: m,
+            isLeft: b,
+            isBottom: S,
+            maxScroll: R,
+            minScroll: D
+          } = pn(v), y = Er(v), w = {
+            x: Math.min(h === C.Right ? y.right - y.width / 2 : y.right, Math.max(h === C.Right ? y.left : y.left + y.width / 2, u.x)),
+            y: Math.min(h === C.Down ? y.bottom - y.height / 2 : y.bottom, Math.max(h === C.Down ? y.top : y.top + y.height / 2, u.y))
+          }, N = h === C.Right && !m || h === C.Left && !b, M = h === C.Down && !S || h === C.Up && !p;
+          if (N && w.x !== u.x) {
+            const E = v.scrollLeft + f.x, Y = h === C.Right && E <= R.x || h === C.Left && E >= D.x;
+            if (Y && !f.y) {
+              v.scrollTo({
+                left: E,
+                behavior: a
+              });
+              return;
+            }
+            Y ? g.x = v.scrollLeft - E : g.x = h === C.Right ? v.scrollLeft - R.x : v.scrollLeft - D.x, g.x && v.scrollBy({
+              left: -g.x,
+              behavior: a
+            });
+            break;
+          } else if (M && w.y !== u.y) {
+            const E = v.scrollTop + f.y, Y = h === C.Down && E <= R.y || h === C.Up && E >= D.y;
+            if (Y && !f.x) {
+              v.scrollTo({
+                top: E,
+                behavior: a
+              });
+              return;
+            }
+            Y ? g.y = v.scrollTop - E : g.y = h === C.Down ? v.scrollTop - R.y : v.scrollTop - D.y, g.y && v.scrollBy({
+              top: -g.y,
+              behavior: a
+            });
+            break;
+          }
+        }
+        this.handleMove(t, Re(je(u, this.referenceCoordinates), g));
+      }
+    }
+  }
+  handleMove(t, n) {
+    const {
+      onMove: r
+    } = this.props;
+    t.preventDefault(), r(n);
+  }
+  handleEnd(t) {
+    const {
+      onEnd: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  handleCancel(t) {
+    const {
+      onCancel: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll();
+  }
+}
+Tt.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: r = yn,
+      onActivation: o
+    } = t, {
+      active: i
+    } = n;
+    const {
+      code: s
+    } = e.nativeEvent;
+    if (r.start.includes(s)) {
+      const a = i.activatorNode.current;
+      return a && e.target !== a ? !1 : (e.preventDefault(), o?.({
+        event: e.nativeEvent
+      }), !0);
+    }
+    return !1;
+  }
+}];
+function _t(e) {
+  return !!(e && "distance" in e);
+}
+function qt(e) {
+  return !!(e && "delay" in e);
+}
+class Mt {
+  constructor(t, n, r) {
+    var o;
+    r === void 0 && (r = Or(t.event.target)), this.props = void 0, this.events = void 0, this.autoScrollEnabled = !0, this.document = void 0, this.activated = !1, this.initialCoordinates = void 0, this.timeoutId = null, this.listeners = void 0, this.documentListeners = void 0, this.windowListeners = void 0, this.props = t, this.events = n;
+    const {
+      event: i
+    } = t, {
+      target: s
+    } = i;
+    this.props = t, this.events = n, this.document = Ae(s), this.documentListeners = new Be(this.document), this.listeners = new Be(r), this.windowListeners = new Be(X(s)), this.initialCoordinates = (o = st(i)) != null ? o : Z, this.handleStart = this.handleStart.bind(this), this.handleMove = this.handleMove.bind(this), this.handleEnd = this.handleEnd.bind(this), this.handleCancel = this.handleCancel.bind(this), this.handleKeydown = this.handleKeydown.bind(this), this.removeTextSelection = this.removeTextSelection.bind(this), this.attach();
+  }
+  attach() {
+    const {
+      events: t,
+      props: {
+        options: {
+          activationConstraint: n,
+          bypassActivationConstraint: r
+        }
+      }
+    } = this;
+    if (this.listeners.add(t.move.name, this.handleMove, {
+      passive: !1
+    }), this.listeners.add(t.end.name, this.handleEnd), t.cancel && this.listeners.add(t.cancel.name, this.handleCancel), this.windowListeners.add(G.Resize, this.handleCancel), this.windowListeners.add(G.DragStart, Ht), this.windowListeners.add(G.VisibilityChange, this.handleCancel), this.windowListeners.add(G.ContextMenu, Ht), this.documentListeners.add(G.Keydown, this.handleKeydown), n) {
+      if (r != null && r({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (qt(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay), this.handlePending(n);
+        return;
+      }
+      if (_t(n)) {
+        this.handlePending(n);
+        return;
+      }
+    }
+    this.handleStart();
+  }
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll(), setTimeout(this.documentListeners.removeAll, 50), this.timeoutId !== null && (clearTimeout(this.timeoutId), this.timeoutId = null);
+  }
+  handlePending(t, n) {
+    const {
+      active: r,
+      onPending: o
+    } = this.props;
+    o(r, t, this.initialCoordinates, n);
+  }
+  handleStart() {
+    const {
+      initialCoordinates: t
+    } = this, {
+      onStart: n
+    } = this.props;
+    t && (this.activated = !0, this.documentListeners.add(G.Click, Tr, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(G.SelectionChange, this.removeTextSelection), n(t));
+  }
+  handleMove(t) {
+    var n;
+    const {
+      activated: r,
+      initialCoordinates: o,
+      props: i
+    } = this, {
+      onMove: s,
+      options: {
+        activationConstraint: a
+      }
+    } = i;
+    if (!o)
+      return;
+    const l = (n = st(t)) != null ? n : Z, c = je(o, l);
+    if (!r && a) {
+      if (_t(a)) {
+        if (a.tolerance != null && xt(c, a.tolerance))
+          return this.handleCancel();
+        if (xt(c, a.distance))
+          return this.handleStart();
+      }
+      if (qt(a) && xt(c, a.tolerance))
+        return this.handleCancel();
+      this.handlePending(a, c);
+      return;
+    }
+    t.cancelable && t.preventDefault(), s(l);
+  }
+  handleEnd() {
+    const {
+      onAbort: t,
+      onEnd: n
+    } = this.props;
+    this.detach(), this.activated || t(this.props.active), n();
+  }
+  handleCancel() {
+    const {
+      onAbort: t,
+      onCancel: n
+    } = this.props;
+    this.detach(), this.activated || t(this.props.active), n();
+  }
+  handleKeydown(t) {
+    t.code === C.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const Lr = {
+  cancel: {
+    name: "pointercancel"
+  },
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class Lt extends Mt {
+  constructor(t) {
+    const {
+      event: n
+    } = t, r = Ae(n.target);
+    super(t, Lr, r);
+  }
+}
+Lt.activators = [{
+  eventName: "onPointerDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return !n.isPrimary || n.button !== 0 ? !1 : (r?.({
+      event: n
+    }), !0);
+  }
+}];
+const kr = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var Rt;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(Rt || (Rt = {}));
+class Pr extends Mt {
+  constructor(t) {
+    super(t, kr, Ae(t.event.target));
+  }
+}
+Pr.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return n.button === Rt.RightClick ? !1 : (r?.({
+      event: n
+    }), !0);
+  }
+}];
+const Dt = {
+  cancel: {
+    name: "touchcancel"
+  },
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class zr extends Mt {
+  constructor(t) {
+    super(t, Dt);
+  }
+  static setup() {
+    return window.addEventListener(Dt.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(Dt.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+zr.activators = [{
+  eventName: "onTouchStart",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    const {
+      touches: o
+    } = n;
+    return o.length > 1 ? !1 : (r?.({
+      event: n
+    }), !0);
+  }
+}];
+var Fe;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(Fe || (Fe = {}));
+var lt;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(lt || (lt = {}));
+function Br(e) {
+  let {
+    acceleration: t,
+    activator: n = Fe.Pointer,
+    canScroll: r,
+    draggingRect: o,
+    enabled: i,
+    interval: s = 5,
+    order: a = lt.TreeOrder,
+    pointerCoordinates: l,
+    scrollableAncestors: c,
+    scrollableAncestorRects: d,
+    delta: u,
+    threshold: f
+  } = e;
+  const g = $r({
+    delta: u,
+    disabled: !i
+  }), [x, v] = Gn(), h = O({
+    x: 0,
+    y: 0
+  }), p = O({
+    x: 0,
+    y: 0
+  }), m = A(() => {
+    switch (n) {
+      case Fe.Pointer:
+        return l ? {
+          top: l.y,
+          bottom: l.y,
+          left: l.x,
+          right: l.x
+        } : null;
+      case Fe.DraggableRect:
+        return o;
+    }
+  }, [n, o, l]), b = O(null), S = $(() => {
+    const D = b.current;
+    if (!D)
+      return;
+    const y = h.current.x * p.current.x, w = h.current.y * p.current.y;
+    D.scrollBy(y, w);
+  }, []), R = A(() => a === lt.TreeOrder ? [...c].reverse() : c, [a, c]);
+  T(
+    () => {
+      if (!i || !c.length || !m) {
+        v();
+        return;
+      }
+      for (const D of R) {
+        if (r?.(D) === !1)
+          continue;
+        const y = c.indexOf(D), w = d[y];
+        if (!w)
+          continue;
+        const {
+          direction: N,
+          speed: M
+        } = Rr(D, w, m, t, f);
+        for (const E of ["x", "y"])
+          g[E][N[E]] || (M[E] = 0, N[E] = 0);
+        if (M.x > 0 || M.y > 0) {
+          v(), b.current = D, x(S, s), h.current = M, p.current = N;
+          return;
+        }
+      }
+      h.current = {
+        x: 0,
+        y: 0
+      }, p.current = {
+        x: 0,
+        y: 0
+      }, v();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      S,
+      r,
+      v,
+      i,
+      s,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(m),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(g),
+      x,
+      c,
+      R,
+      d,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(f)
+    ]
+  );
+}
+const Fr = {
+  x: {
+    [P.Backward]: !1,
+    [P.Forward]: !1
+  },
+  y: {
+    [P.Backward]: !1,
+    [P.Forward]: !1
+  }
+};
+function $r(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const r = it(t);
+  return We((o) => {
+    if (n || !r || !o)
+      return Fr;
+    const i = {
+      x: Math.sign(t.x - r.x),
+      y: Math.sign(t.y - r.y)
+    };
+    return {
+      x: {
+        [P.Backward]: o.x[P.Backward] || i.x === -1,
+        [P.Forward]: o.x[P.Forward] || i.x === 1
+      },
+      y: {
+        [P.Backward]: o.y[P.Backward] || i.y === -1,
+        [P.Forward]: o.y[P.Forward] || i.y === 1
+      }
+    };
+  }, [n, t, r]);
+}
+function Xr(e, t) {
+  const n = t != null ? e.get(t) : void 0, r = n ? n.node.current : null;
+  return We((o) => {
+    var i;
+    return t == null ? null : (i = r ?? o) != null ? i : null;
+  }, [r, t]);
+}
+function jr(e, t) {
+  return A(() => e.reduce((n, r) => {
+    const {
+      sensor: o
+    } = r, i = o.activators.map((s) => ({
+      eventName: s.eventName,
+      handler: t(s.handler, r)
+    }));
+    return [...n, ...i];
+  }, []), [e, t]);
+}
+var Ye;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Ye || (Ye = {}));
+var Et;
+(function(e) {
+  e.Optimized = "optimized";
+})(Et || (Et = {}));
+const Gt = /* @__PURE__ */ new Map();
+function Yr(e, t) {
+  let {
+    dragging: n,
+    dependencies: r,
+    config: o
+  } = t;
+  const [i, s] = F(null), {
+    frequency: a,
+    measure: l,
+    strategy: c
+  } = o, d = O(e), u = h(), f = Xe(u), g = $(function(p) {
+    p === void 0 && (p = []), !f.current && s((m) => m === null ? p : m.concat(p.filter((b) => !m.includes(b))));
+  }, [f]), x = O(null), v = We((p) => {
+    if (u && !n)
+      return Gt;
+    if (!p || p === Gt || d.current !== e || i != null) {
+      const m = /* @__PURE__ */ new Map();
+      for (let b of e) {
+        if (!b)
+          continue;
+        if (i && i.length > 0 && !i.includes(b.id) && b.rect.current) {
+          m.set(b.id, b.rect.current);
+          continue;
+        }
+        const S = b.node.current, R = S ? new Ot(l(S), S) : null;
+        b.rect.current = R, R && m.set(b.id, R);
+      }
+      return m;
+    }
+    return p;
+  }, [e, i, n, u, l]);
+  return T(() => {
+    d.current = e;
+  }, [e]), T(
+    () => {
+      u || g();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, u]
+  ), T(
+    () => {
+      i && i.length > 0 && s(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(i)]
+  ), T(
+    () => {
+      u || typeof a != "number" || x.current !== null || (x.current = setTimeout(() => {
+        g(), x.current = null;
+      }, a));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [a, u, g, ...r]
+  ), {
+    droppableRects: v,
+    measureDroppableContainers: g,
+    measuringScheduled: i != null
+  };
+  function h() {
+    switch (c) {
+      case Ye.Always:
+        return !1;
+      case Ye.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function kt(e, t) {
+  return We((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function Kr(e, t) {
+  return kt(e, t);
+}
+function Ur(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = dt(t), o = A(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: i
+    } = window;
+    return new i(r);
+  }, [r, n]);
+  return T(() => () => o?.disconnect(), [o]), o;
+}
+function ht(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = dt(t), o = A(
+    () => {
+      if (n || typeof window > "u" || typeof window.ResizeObserver > "u")
+        return;
+      const {
+        ResizeObserver: i
+      } = window;
+      return new i(r);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n]
+  );
+  return T(() => () => o?.disconnect(), [o]), o;
+}
+function Wr(e) {
+  return new Ot(Ie(e), e);
+}
+function Jt(e, t, n) {
+  t === void 0 && (t = Wr);
+  const [r, o] = F(null);
+  function i() {
+    o((l) => {
+      if (!e)
+        return null;
+      if (e.isConnected === !1) {
+        var c;
+        return (c = l ?? n) != null ? c : null;
+      }
+      const d = t(e);
+      return JSON.stringify(l) === JSON.stringify(d) ? l : d;
+    });
+  }
+  const s = Ur({
+    callback(l) {
+      if (e)
+        for (const c of l) {
+          const {
+            type: d,
+            target: u
+          } = c;
+          if (d === "childList" && u instanceof HTMLElement && u.contains(e)) {
+            i();
+            break;
+          }
+        }
+    }
+  }), a = ht({
+    callback: i
+  });
+  return Q(() => {
+    i(), e ? (a?.observe(e), s?.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (a?.disconnect(), s?.disconnect());
+  }, [e]), r;
+}
+function Vr(e) {
+  const t = kt(e);
+  return un(e, t);
+}
+const Qt = [];
+function Hr(e) {
+  const t = O(e), n = We((r) => e ? r && r !== Qt && e && t.current && e.parentNode === t.current.parentNode ? r : gt(e) : Qt, [e]);
+  return T(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function _r(e) {
+  const [t, n] = F(null), r = O(e), o = $((i) => {
+    const s = wt(i.target);
+    s && n((a) => a ? (a.set(s, Ct(s)), new Map(a)) : null);
+  }, []);
+  return T(() => {
+    const i = r.current;
+    if (e !== i) {
+      s(i);
+      const a = e.map((l) => {
+        const c = wt(l);
+        return c ? (c.addEventListener("scroll", o, {
+          passive: !0
+        }), [c, Ct(c)]) : null;
+      }).filter((l) => l != null);
+      n(a.length ? new Map(a) : null), r.current = e;
+    }
+    return () => {
+      s(e), s(i);
+    };
+    function s(a) {
+      a.forEach((l) => {
+        const c = wt(l);
+        c?.removeEventListener("scroll", o);
+      });
+    }
+  }, [o, e]), A(() => e.length ? t ? Array.from(t.values()).reduce((i, s) => Re(i, s), Z) : bn(e) : Z, [e, t]);
+}
+function Zt(e, t) {
+  t === void 0 && (t = []);
+  const n = O(null);
+  return T(
+    () => {
+      n.current = null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), T(() => {
+    const r = e !== Z;
+    r && !n.current && (n.current = e), !r && n.current && (n.current = null);
+  }, [e]), n.current ? je(e, n.current) : Z;
+}
+function qr(e) {
+  T(
+    () => {
+      if (!ut)
+        return;
+      const t = e.map((n) => {
+        let {
+          sensor: r
+        } = n;
+        return r.setup == null ? void 0 : r.setup();
+      });
+      return () => {
+        for (const n of t)
+          n?.();
+      };
+    },
+    // 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 Gr(e, t) {
+  return A(() => e.reduce((n, r) => {
+    let {
+      eventName: o,
+      handler: i
+    } = r;
+    return n[o] = (s) => {
+      i(s, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function wn(e) {
+  return A(() => e ? xr(e) : null, [e]);
+}
+const en = [];
+function Jr(e, t) {
+  t === void 0 && (t = Ie);
+  const [n] = e, r = wn(n ? X(n) : null), [o, i] = F(en);
+  function s() {
+    i(() => e.length ? e.map((l) => vn(l) ? r : new Ot(t(l), l)) : en);
+  }
+  const a = ht({
+    callback: s
+  });
+  return Q(() => {
+    a?.disconnect(), s(), e.forEach((l) => a?.observe(l));
+  }, [e]), o;
+}
+function xn(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return Ue(t) ? t : e;
+}
+function Qr(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, r] = F(null), o = $((c) => {
+    for (const {
+      target: d
+    } of c)
+      if (Ue(d)) {
+        r((u) => {
+          const f = t(d);
+          return u ? {
+            ...u,
+            width: f.width,
+            height: f.height
+          } : f;
+        });
+        break;
+      }
+  }, [t]), i = ht({
+    callback: o
+  }), s = $((c) => {
+    const d = xn(c);
+    i?.disconnect(), d && i?.observe(d), r(d ? t(d) : null);
+  }, [t, i]), [a, l] = ot(s);
+  return A(() => ({
+    nodeRef: a,
+    rect: n,
+    setRef: l
+  }), [n, a, l]);
+}
+const Zr = [{
+  sensor: Lt,
+  options: {}
+}, {
+  sensor: Tt,
+  options: {}
+}], eo = {
+  current: {}
+}, rt = {
+  draggable: {
+    measure: Vt
+  },
+  droppable: {
+    measure: Vt,
+    strategy: Ye.WhileDragging,
+    frequency: Et.Optimized
+  },
+  dragOverlay: {
+    measure: Ie
+  }
+};
+class $e extends Map {
+  get(t) {
+    var n;
+    return t != null && (n = super.get(t)) != null ? n : void 0;
+  }
+  toArray() {
+    return Array.from(this.values());
+  }
+  getEnabled() {
+    return this.toArray().filter((t) => {
+      let {
+        disabled: n
+      } = t;
+      return !n;
+    });
+  }
+  getNodeFor(t) {
+    var n, r;
+    return (n = (r = this.get(t)) == null ? void 0 : r.node.current) != null ? n : void 0;
+  }
+}
+const to = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new $e(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: at
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: rt,
+  measureDroppableContainers: at,
+  windowRect: null,
+  measuringScheduled: !1
+}, Dn = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: at,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: at
+}, He = /* @__PURE__ */ Ke(Dn), Sn = /* @__PURE__ */ Ke(to);
+function no() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new $e()
+    }
+  };
+}
+function ro(e, t) {
+  switch (t.type) {
+    case k.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case k.DragMove:
+      return e.draggable.active == null ? e : {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          translate: {
+            x: t.coordinates.x - e.draggable.initialCoordinates.x,
+            y: t.coordinates.y - e.draggable.initialCoordinates.y
+          }
+        }
+      };
+    case k.DragEnd:
+    case k.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case k.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: r
+      } = n, o = new $e(e.droppable.containers);
+      return o.set(r, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: o
+        }
+      };
+    }
+    case k.SetDroppableDisabled: {
+      const {
+        id: n,
+        key: r,
+        disabled: o
+      } = t, i = e.droppable.containers.get(n);
+      if (!i || r !== i.key)
+        return e;
+      const s = new $e(e.droppable.containers);
+      return s.set(n, {
+        ...i,
+        disabled: o
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: s
+        }
+      };
+    }
+    case k.UnregisterDroppable: {
+      const {
+        id: n,
+        key: r
+      } = t, o = e.droppable.containers.get(n);
+      if (!o || r !== o.key)
+        return e;
+      const i = new $e(e.droppable.containers);
+      return i.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function oo(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: r,
+    draggableNodes: o
+  } = pe(He), i = it(r), s = it(n?.id);
+  return T(() => {
+    if (!t && !r && i && s != null) {
+      if (!ft(i) || document.activeElement === i.target)
+        return;
+      const a = o.get(s);
+      if (!a)
+        return;
+      const {
+        activatorNode: l,
+        node: c
+      } = a;
+      if (!l.current && !c.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const d of [l.current, c.current]) {
+          if (!d)
+            continue;
+          const u = Zn(d);
+          if (u) {
+            u.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [r, t, o, s, i]), null;
+}
+function Cn(e, t) {
+  let {
+    transform: n,
+    ...r
+  } = t;
+  return e != null && e.length ? e.reduce((o, i) => i({
+    transform: o,
+    ...r
+  }), n) : n;
+}
+function io(e) {
+  return A(
+    () => ({
+      draggable: {
+        ...rt.draggable,
+        ...e?.draggable
+      },
+      droppable: {
+        ...rt.droppable,
+        ...e?.droppable
+      },
+      dragOverlay: {
+        ...rt.dragOverlay,
+        ...e?.dragOverlay
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e?.draggable, e?.droppable, e?.dragOverlay]
+  );
+}
+function so(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: r,
+    config: o = !0
+  } = e;
+  const i = O(!1), {
+    x: s,
+    y: a
+  } = typeof o == "boolean" ? {
+    x: o,
+    y: o
+  } : o;
+  Q(() => {
+    if (!s && !a || !t) {
+      i.current = !1;
+      return;
+    }
+    if (i.current || !r)
+      return;
+    const c = t?.node.current;
+    if (!c || c.isConnected === !1)
+      return;
+    const d = n(c), u = un(d, r);
+    if (s || (u.x = 0), a || (u.y = 0), i.current = !0, Math.abs(u.x) > 0 || Math.abs(u.y) > 0) {
+      const f = fn(c);
+      f && f.scrollBy({
+        top: u.y,
+        left: u.x
+      });
+    }
+  }, [t, s, a, r, n]);
+}
+const vt = /* @__PURE__ */ Ke({
+  ...Z,
+  scaleX: 1,
+  scaleY: 1
+});
+var ve;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(ve || (ve = {}));
+const ao = /* @__PURE__ */ Kn(function(t) {
+  var n, r, o, i;
+  let {
+    id: s,
+    accessibility: a,
+    autoScroll: l = !0,
+    children: c,
+    sensors: d = Zr,
+    collisionDetection: u = vr,
+    measuring: f,
+    modifiers: g,
+    ...x
+  } = t;
+  const v = Un(ro, void 0, no), [h, p] = v, [m, b] = ir(), [S, R] = F(ve.Uninitialized), D = S === ve.Initialized, {
+    draggable: {
+      active: y,
+      nodes: w,
+      translate: N
+    },
+    droppable: {
+      containers: M
+    }
+  } = h, E = y != null ? w.get(y) : null, Y = O({
+    initial: null,
+    translated: null
+  }), J = A(() => {
+    var B;
+    return y != null ? {
+      id: y,
+      // It's possible for the active node to unmount while dragging
+      data: (B = E?.data) != null ? B : eo,
+      rect: Y
+    } : null;
+  }, [y, E]), ee = O(null), [Ne, _e] = F(null), [K, qe] = F(null), oe = Xe(x, Object.values(x)), Oe = Ve("DndDescribedBy", s), Ge = A(() => M.getEnabled(), [M]), j = io(f), {
+    droppableRects: ie,
+    measureDroppableContainers: me,
+    measuringScheduled: Te
+  } = Yr(Ge, {
+    dragging: D,
+    dependencies: [N.x, N.y],
+    config: j.droppable
+  }), H = Xr(w, y), Je = A(() => K ? st(K) : null, [K]), ce = Xn(), se = Kr(H, j.draggable.measure);
+  so({
+    activeNode: y != null ? w.get(y) : null,
+    config: ce.layoutShiftCompensation,
+    initialRect: se,
+    measure: j.draggable.measure
+  });
+  const I = Jt(H, j.draggable.measure, se), Me = Jt(H ? H.parentElement : null), te = O({
+    activatorEvent: null,
+    active: null,
+    activeNode: H,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: ie,
+    draggableNodes: w,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: M,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), ye = M.getNodeFor((n = te.current.over) == null ? void 0 : n.id), ae = Qr({
+    measure: j.dragOverlay.measure
+  }), we = (r = ae.nodeRef.current) != null ? r : H, xe = D ? (o = ae.rect) != null ? o : I : null, Pt = !!(ae.nodeRef.current && ae.rect), zt = Vr(Pt ? null : I), pt = wn(we ? X(we) : null), ue = Hr(D ? ye ?? H : null), Qe = Jr(ue), Ze = Cn(g, {
+    transform: {
+      x: N.x - zt.x,
+      y: N.y - zt.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: K,
+    active: J,
+    activeNodeRect: I,
+    containerNodeRect: Me,
+    draggingNodeRect: xe,
+    over: te.current.over,
+    overlayNodeRect: ae.rect,
+    scrollableAncestors: ue,
+    scrollableAncestorRects: Qe,
+    windowRect: pt
+  }), Bt = Je ? Re(Je, N) : null, Ft = _r(ue), Ln = Zt(Ft), kn = Zt(Ft, [I]), De = Re(Ze, Ln), Se = xe ? mr(xe, Ze) : null, Le = J && Se ? u({
+    active: J,
+    collisionRect: Se,
+    droppableRects: ie,
+    droppableContainers: Ge,
+    pointerCoordinates: Bt
+  }) : null, $t = ln(Le, "id"), [de, Xt] = F(null), Pn = Pt ? Ze : Re(Ze, kn), zn = pr(Pn, (i = de?.rect) != null ? i : null, I), bt = O(null), jt = $(
+    (B, U) => {
+      let {
+        sensor: W,
+        options: fe
+      } = U;
+      if (ee.current == null)
+        return;
+      const _ = w.get(ee.current);
+      if (!_)
+        return;
+      const V = B.nativeEvent, ne = new W({
+        active: ee.current,
+        activeNode: _,
+        event: V,
+        options: fe,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: te,
+        onAbort(z) {
+          if (!w.get(z))
+            return;
+          const {
+            onDragAbort: re
+          } = oe.current, le = {
+            id: z
+          };
+          re?.(le), m({
+            type: "onDragAbort",
+            event: le
+          });
+        },
+        onPending(z, ge, re, le) {
+          if (!w.get(z))
+            return;
+          const {
+            onDragPending: Pe
+          } = oe.current, he = {
+            id: z,
+            constraint: ge,
+            initialCoordinates: re,
+            offset: le
+          };
+          Pe?.(he), m({
+            type: "onDragPending",
+            event: he
+          });
+        },
+        onStart(z) {
+          const ge = ee.current;
+          if (ge == null)
+            return;
+          const re = w.get(ge);
+          if (!re)
+            return;
+          const {
+            onDragStart: le
+          } = oe.current, ke = {
+            activatorEvent: V,
+            active: {
+              id: ge,
+              data: re.data,
+              rect: Y
+            }
+          };
+          et(() => {
+            le?.(ke), R(ve.Initializing), p({
+              type: k.DragStart,
+              initialCoordinates: z,
+              active: ge
+            }), m({
+              type: "onDragStart",
+              event: ke
+            }), _e(bt.current), qe(V);
+          });
+        },
+        onMove(z) {
+          p({
+            type: k.DragMove,
+            coordinates: z
+          });
+        },
+        onEnd: Ce(k.DragEnd),
+        onCancel: Ce(k.DragCancel)
+      });
+      bt.current = ne;
+      function Ce(z) {
+        return async function() {
+          const {
+            active: re,
+            collisions: le,
+            over: ke,
+            scrollAdjustedTranslate: Pe
+          } = te.current;
+          let he = null;
+          if (re && Pe) {
+            const {
+              cancelDrop: ze
+            } = oe.current;
+            he = {
+              activatorEvent: V,
+              active: re,
+              collisions: le,
+              delta: Pe,
+              over: ke
+            }, z === k.DragEnd && typeof ze == "function" && await Promise.resolve(ze(he)) && (z = k.DragCancel);
+          }
+          ee.current = null, et(() => {
+            p({
+              type: z
+            }), R(ve.Uninitialized), Xt(null), _e(null), qe(null), bt.current = null;
+            const ze = z === k.DragEnd ? "onDragEnd" : "onDragCancel";
+            if (he) {
+              const mt = oe.current[ze];
+              mt?.(he), m({
+                type: ze,
+                event: he
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [w]
+  ), Bn = $((B, U) => (W, fe) => {
+    const _ = W.nativeEvent, V = w.get(fe);
+    if (
+      // Another sensor is already instantiating
+      ee.current !== null || // No active draggable
+      !V || // Event has already been captured
+      _.dndKit || _.defaultPrevented
+    )
+      return;
+    const ne = {
+      active: V
+    };
+    B(W, U.options, ne) === !0 && (_.dndKit = {
+      capturedBy: U.sensor
+    }, ee.current = fe, jt(W, U));
+  }, [w, jt]), Yt = jr(d, Bn);
+  qr(d), Q(() => {
+    I && S === ve.Initializing && R(ve.Initialized);
+  }, [I, S]), T(
+    () => {
+      const {
+        onDragMove: B
+      } = oe.current, {
+        active: U,
+        activatorEvent: W,
+        collisions: fe,
+        over: _
+      } = te.current;
+      if (!U || !W)
+        return;
+      const V = {
+        active: U,
+        activatorEvent: W,
+        collisions: fe,
+        delta: {
+          x: De.x,
+          y: De.y
+        },
+        over: _
+      };
+      et(() => {
+        B?.(V), m({
+          type: "onDragMove",
+          event: V
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [De.x, De.y]
+  ), T(
+    () => {
+      const {
+        active: B,
+        activatorEvent: U,
+        collisions: W,
+        droppableContainers: fe,
+        scrollAdjustedTranslate: _
+      } = te.current;
+      if (!B || ee.current == null || !U || !_)
+        return;
+      const {
+        onDragOver: V
+      } = oe.current, ne = fe.get($t), Ce = ne && ne.rect.current ? {
+        id: ne.id,
+        rect: ne.rect.current,
+        data: ne.data,
+        disabled: ne.disabled
+      } : null, z = {
+        active: B,
+        activatorEvent: U,
+        collisions: W,
+        delta: {
+          x: _.x,
+          y: _.y
+        },
+        over: Ce
+      };
+      et(() => {
+        Xt(Ce), V?.(z), m({
+          type: "onDragOver",
+          event: z
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [$t]
+  ), Q(() => {
+    te.current = {
+      activatorEvent: K,
+      active: J,
+      activeNode: H,
+      collisionRect: Se,
+      collisions: Le,
+      droppableRects: ie,
+      draggableNodes: w,
+      draggingNode: we,
+      draggingNodeRect: xe,
+      droppableContainers: M,
+      over: de,
+      scrollableAncestors: ue,
+      scrollAdjustedTranslate: De
+    }, Y.current = {
+      initial: xe,
+      translated: Se
+    };
+  }, [J, H, Le, Se, w, we, xe, ie, M, de, ue, De]), Br({
+    ...ce,
+    delta: N,
+    draggingRect: Se,
+    pointerCoordinates: Bt,
+    scrollableAncestors: ue,
+    scrollableAncestorRects: Qe
+  });
+  const Fn = A(() => ({
+    active: J,
+    activeNode: H,
+    activeNodeRect: I,
+    activatorEvent: K,
+    collisions: Le,
+    containerNodeRect: Me,
+    dragOverlay: ae,
+    draggableNodes: w,
+    droppableContainers: M,
+    droppableRects: ie,
+    over: de,
+    measureDroppableContainers: me,
+    scrollableAncestors: ue,
+    scrollableAncestorRects: Qe,
+    measuringConfiguration: j,
+    measuringScheduled: Te,
+    windowRect: pt
+  }), [J, H, I, K, Le, Me, ae, w, M, ie, de, me, ue, Qe, j, Te, pt]), $n = A(() => ({
+    activatorEvent: K,
+    activators: Yt,
+    active: J,
+    activeNodeRect: I,
+    ariaDescribedById: {
+      draggable: Oe
+    },
+    dispatch: p,
+    draggableNodes: w,
+    over: de,
+    measureDroppableContainers: me
+  }), [K, Yt, J, I, p, Oe, w, de, me]);
+  return L.createElement(an.Provider, {
+    value: b
+  }, L.createElement(He.Provider, {
+    value: $n
+  }, L.createElement(Sn.Provider, {
+    value: Fn
+  }, L.createElement(vt.Provider, {
+    value: zn
+  }, c)), L.createElement(oo, {
+    disabled: a?.restoreFocus === !1
+  })), L.createElement(lr, {
+    ...a,
+    hiddenTextDescribedById: Oe
+  }));
+  function Xn() {
+    const B = Ne?.autoScrollEnabled === !1, U = typeof l == "object" ? l.enabled === !1 : l === !1, W = D && !B && !U;
+    return typeof l == "object" ? {
+      ...l,
+      enabled: W
+    } : {
+      enabled: W
+    };
+  }
+}), lo = /* @__PURE__ */ Ke(null), tn = "button", co = "Draggable";
+function uo(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: r = !1,
+    attributes: o
+  } = e;
+  const i = Ve(co), {
+    activators: s,
+    activatorEvent: a,
+    active: l,
+    activeNodeRect: c,
+    ariaDescribedById: d,
+    draggableNodes: u,
+    over: f
+  } = pe(He), {
+    role: g = tn,
+    roleDescription: x = "draggable",
+    tabIndex: v = 0
+  } = o ?? {}, h = l?.id === t, p = pe(h ? vt : lo), [m, b] = ot(), [S, R] = ot(), D = Gr(s, t), y = Xe(n);
+  Q(
+    () => (u.set(t, {
+      id: t,
+      key: i,
+      node: m,
+      activatorNode: S,
+      data: y
+    }), () => {
+      const N = u.get(t);
+      N && N.key === i && u.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [u, t]
+  );
+  const w = A(() => ({
+    role: g,
+    tabIndex: v,
+    "aria-disabled": r,
+    "aria-pressed": h && g === tn ? !0 : void 0,
+    "aria-roledescription": x,
+    "aria-describedby": d.draggable
+  }), [r, g, v, h, x, d.draggable]);
+  return {
+    active: l,
+    activatorEvent: a,
+    activeNodeRect: c,
+    attributes: w,
+    isDragging: h,
+    listeners: r ? void 0 : D,
+    node: m,
+    over: f,
+    setNodeRef: b,
+    setActivatorNodeRef: R,
+    transform: p
+  };
+}
+function Rn() {
+  return pe(Sn);
+}
+const fo = "Droppable", go = {
+  timeout: 25
+};
+function En(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: r,
+    resizeObserverConfig: o
+  } = e;
+  const i = Ve(fo), {
+    active: s,
+    dispatch: a,
+    over: l,
+    measureDroppableContainers: c
+  } = pe(He), d = O({
+    disabled: n
+  }), u = O(!1), f = O(null), g = O(null), {
+    disabled: x,
+    updateMeasurementsFor: v,
+    timeout: h
+  } = {
+    ...go,
+    ...o
+  }, p = Xe(v ?? r), m = $(
+    () => {
+      if (!u.current) {
+        u.current = !0;
+        return;
+      }
+      g.current != null && clearTimeout(g.current), g.current = setTimeout(() => {
+        c(Array.isArray(p.current) ? p.current : [p.current]), g.current = null;
+      }, h);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [h]
+  ), b = ht({
+    callback: m,
+    disabled: x || !s
+  }), S = $((w, N) => {
+    b && (N && (b.unobserve(N), u.current = !1), w && b.observe(w));
+  }, [b]), [R, D] = ot(S), y = Xe(t);
+  return T(() => {
+    !b || !R.current || (b.disconnect(), u.current = !1, b.observe(R.current));
+  }, [R, b]), T(
+    () => (a({
+      type: k.RegisterDroppable,
+      element: {
+        id: r,
+        key: i,
+        disabled: n,
+        node: R,
+        rect: f,
+        data: y
+      }
+    }), () => a({
+      type: k.UnregisterDroppable,
+      key: i,
+      id: r
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), T(() => {
+    n !== d.current.disabled && (a({
+      type: k.SetDroppableDisabled,
+      id: r,
+      key: i,
+      disabled: n
+    }), d.current.disabled = n);
+  }, [r, i, n, a]), {
+    active: s,
+    rect: f,
+    isOver: l?.id === r,
+    node: R,
+    over: l,
+    setNodeRef: D
+  };
+}
+function ho(e) {
+  let {
+    animation: t,
+    children: n
+  } = e;
+  const [r, o] = F(null), [i, s] = F(null), a = it(n);
+  return !n && !r && a && o(a), Q(() => {
+    if (!i)
+      return;
+    const l = r?.key, c = r?.props.id;
+    if (l == null || c == null) {
+      o(null);
+      return;
+    }
+    Promise.resolve(t(c, i)).then(() => {
+      o(null);
+    });
+  }, [t, r, i]), L.createElement(L.Fragment, null, n, r ? Wn(r, {
+    ref: s
+  }) : null);
+}
+const vo = {
+  x: 0,
+  y: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+function po(e) {
+  let {
+    children: t
+  } = e;
+  return L.createElement(He.Provider, {
+    value: Dn
+  }, L.createElement(vt.Provider, {
+    value: vo
+  }, t));
+}
+const bo = {
+  position: "fixed",
+  touchAction: "none"
+}, mo = (e) => ft(e) ? "transform 250ms ease" : void 0, yo = /* @__PURE__ */ Vn((e, t) => {
+  let {
+    as: n,
+    activatorEvent: r,
+    adjustScale: o,
+    children: i,
+    className: s,
+    rect: a,
+    style: l,
+    transform: c,
+    transition: d = mo
+  } = e;
+  if (!a)
+    return null;
+  const u = o ? c : {
+    ...c,
+    scaleX: 1,
+    scaleY: 1
+  }, f = {
+    ...bo,
+    width: a.width,
+    height: a.height,
+    top: a.top,
+    left: a.left,
+    transform: be.Transform.toString(u),
+    transformOrigin: o && r ? dr(r, a) : void 0,
+    transition: typeof d == "function" ? d(r) : d,
+    ...l
+  };
+  return L.createElement(n, {
+    className: s,
+    style: f,
+    ref: t
+  }, i);
+}), wo = (e) => (t) => {
+  let {
+    active: n,
+    dragOverlay: r
+  } = t;
+  const o = {}, {
+    styles: i,
+    className: s
+  } = e;
+  if (i != null && i.active)
+    for (const [a, l] of Object.entries(i.active))
+      l !== void 0 && (o[a] = n.node.style.getPropertyValue(a), n.node.style.setProperty(a, l));
+  if (i != null && i.dragOverlay)
+    for (const [a, l] of Object.entries(i.dragOverlay))
+      l !== void 0 && r.node.style.setProperty(a, l);
+  return s != null && s.active && n.node.classList.add(s.active), s != null && s.dragOverlay && r.node.classList.add(s.dragOverlay), function() {
+    for (const [l, c] of Object.entries(o))
+      n.node.style.setProperty(l, c);
+    s != null && s.active && n.node.classList.remove(s.active);
+  };
+}, xo = (e) => {
+  let {
+    transform: {
+      initial: t,
+      final: n
+    }
+  } = e;
+  return [{
+    transform: be.Transform.toString(t)
+  }, {
+    transform: be.Transform.toString(n)
+  }];
+}, Do = {
+  duration: 250,
+  easing: "ease",
+  keyframes: xo,
+  sideEffects: /* @__PURE__ */ wo({
+    styles: {
+      active: {
+        opacity: "0"
+      }
+    }
+  })
+};
+function So(e) {
+  let {
+    config: t,
+    draggableNodes: n,
+    droppableContainers: r,
+    measuringConfiguration: o
+  } = e;
+  return dt((i, s) => {
+    if (t === null)
+      return;
+    const a = n.get(i);
+    if (!a)
+      return;
+    const l = a.node.current;
+    if (!l)
+      return;
+    const c = xn(s);
+    if (!c)
+      return;
+    const {
+      transform: d
+    } = X(s).getComputedStyle(s), u = dn(d);
+    if (!u)
+      return;
+    const f = typeof t == "function" ? t : Co(t);
+    return mn(l, o.draggable.measure), f({
+      active: {
+        id: i,
+        data: a.data,
+        node: l,
+        rect: o.draggable.measure(l)
+      },
+      draggableNodes: n,
+      dragOverlay: {
+        node: s,
+        rect: o.dragOverlay.measure(c)
+      },
+      droppableContainers: r,
+      measuringConfiguration: o,
+      transform: u
+    });
+  });
+}
+function Co(e) {
+  const {
+    duration: t,
+    easing: n,
+    sideEffects: r,
+    keyframes: o
+  } = {
+    ...Do,
+    ...e
+  };
+  return (i) => {
+    let {
+      active: s,
+      dragOverlay: a,
+      transform: l,
+      ...c
+    } = i;
+    if (!t)
+      return;
+    const d = {
+      x: a.rect.left - s.rect.left,
+      y: a.rect.top - s.rect.top
+    }, u = {
+      scaleX: l.scaleX !== 1 ? s.rect.width * l.scaleX / a.rect.width : 1,
+      scaleY: l.scaleY !== 1 ? s.rect.height * l.scaleY / a.rect.height : 1
+    }, f = {
+      x: l.x - d.x,
+      y: l.y - d.y,
+      ...u
+    }, g = o({
+      ...c,
+      active: s,
+      dragOverlay: a,
+      transform: {
+        initial: l,
+        final: f
+      }
+    }), [x] = g, v = g[g.length - 1];
+    if (JSON.stringify(x) === JSON.stringify(v))
+      return;
+    const h = r?.({
+      active: s,
+      dragOverlay: a,
+      ...c
+    }), p = a.node.animate(g, {
+      duration: t,
+      easing: n,
+      fill: "forwards"
+    });
+    return new Promise((m) => {
+      p.onfinish = () => {
+        h?.(), m();
+      };
+    });
+  };
+}
+let nn = 0;
+function Ro(e) {
+  return A(() => {
+    if (e != null)
+      return nn++, nn;
+  }, [e]);
+}
+const Eo = /* @__PURE__ */ L.memo((e) => {
+  let {
+    adjustScale: t = !1,
+    children: n,
+    dropAnimation: r,
+    style: o,
+    transition: i,
+    modifiers: s,
+    wrapperElement: a = "div",
+    className: l,
+    zIndex: c = 999
+  } = e;
+  const {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: f,
+    containerNodeRect: g,
+    draggableNodes: x,
+    droppableContainers: v,
+    dragOverlay: h,
+    over: p,
+    measuringConfiguration: m,
+    scrollableAncestors: b,
+    scrollableAncestorRects: S,
+    windowRect: R
+  } = Rn(), D = pe(vt), y = Ro(u?.id), w = Cn(s, {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: f,
+    containerNodeRect: g,
+    draggingNodeRect: h.rect,
+    over: p,
+    overlayNodeRect: h.rect,
+    scrollableAncestors: b,
+    scrollableAncestorRects: S,
+    transform: D,
+    windowRect: R
+  }), N = kt(f), M = So({
+    config: r,
+    draggableNodes: x,
+    droppableContainers: v,
+    measuringConfiguration: m
+  }), E = N ? h.setRef : void 0;
+  return L.createElement(po, null, L.createElement(ho, {
+    animation: M
+  }, u && y ? L.createElement(yo, {
+    key: y,
+    id: u.id,
+    ref: E,
+    as: a,
+    activatorEvent: d,
+    adjustScale: t,
+    className: l,
+    transition: i,
+    rect: N,
+    style: {
+      zIndex: c,
+      ...o
+    },
+    transform: w
+  }, n) : null));
+});
+function An(e, t, n) {
+  const r = e.slice();
+  return r.splice(n < 0 ? r.length + n : n, 0, r.splice(t, 1)[0]), r;
+}
+function Ao(e, t) {
+  return e.reduce((n, r, o) => {
+    const i = t.get(r);
+    return i && (n[o] = i), n;
+  }, Array(e.length));
+}
+function tt(e) {
+  return e !== null && e >= 0;
+}
+function Io(e, t) {
+  if (e === t)
+    return !0;
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+function No(e) {
+  return typeof e == "boolean" ? {
+    draggable: e,
+    droppable: e
+  } : e;
+}
+const In = (e) => {
+  let {
+    rects: t,
+    activeIndex: n,
+    overIndex: r,
+    index: o
+  } = e;
+  const i = An(t, r, n), s = t[o], a = i[o];
+  return !a || !s ? null : {
+    x: a.left - s.left,
+    y: a.top - s.top,
+    scaleX: a.width / s.width,
+    scaleY: a.height / s.height
+  };
+}, nt = {
+  scaleX: 1,
+  scaleY: 1
+}, Oo = (e) => {
+  var t;
+  let {
+    activeIndex: n,
+    activeNodeRect: r,
+    index: o,
+    rects: i,
+    overIndex: s
+  } = e;
+  const a = (t = i[n]) != null ? t : r;
+  if (!a)
+    return null;
+  if (o === n) {
+    const c = i[s];
+    return c ? {
+      x: 0,
+      y: n < s ? c.top + c.height - (a.top + a.height) : c.top - a.top,
+      ...nt
+    } : null;
+  }
+  const l = To(i, o, n);
+  return o > n && o <= s ? {
+    x: 0,
+    y: -a.height - l,
+    ...nt
+  } : o < n && o >= s ? {
+    x: 0,
+    y: a.height + l,
+    ...nt
+  } : {
+    x: 0,
+    y: 0,
+    ...nt
+  };
+};
+function To(e, t, n) {
+  const r = e[t], o = e[t - 1], i = e[t + 1];
+  return r ? n < t ? o ? r.top - (o.top + o.height) : i ? i.top - (r.top + r.height) : 0 : i ? i.top - (r.top + r.height) : o ? r.top - (o.top + o.height) : 0 : 0;
+}
+const Nn = "Sortable", On = /* @__PURE__ */ L.createContext({
+  activeIndex: -1,
+  containerId: Nn,
+  disableTransforms: !1,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: !1,
+  sortedRects: [],
+  strategy: In,
+  disabled: {
+    draggable: !1,
+    droppable: !1
+  }
+});
+function Mo(e) {
+  let {
+    children: t,
+    id: n,
+    items: r,
+    strategy: o = In,
+    disabled: i = !1
+  } = e;
+  const {
+    active: s,
+    dragOverlay: a,
+    droppableRects: l,
+    over: c,
+    measureDroppableContainers: d
+  } = Rn(), u = Ve(Nn, n), f = a.rect !== null, g = A(() => r.map((D) => typeof D == "object" && "id" in D ? D.id : D), [r]), x = s != null, v = s ? g.indexOf(s.id) : -1, h = c ? g.indexOf(c.id) : -1, p = O(g), m = !Io(g, p.current), b = h !== -1 && v === -1 || m, S = No(i);
+  Q(() => {
+    m && x && d(g);
+  }, [m, g, x, d]), T(() => {
+    p.current = g;
+  }, [g]);
+  const R = A(
+    () => ({
+      activeIndex: v,
+      containerId: u,
+      disabled: S,
+      disableTransforms: b,
+      items: g,
+      overIndex: h,
+      useDragOverlay: f,
+      sortedRects: Ao(g, l),
+      strategy: o
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [v, u, S.draggable, S.droppable, b, g, h, l, f, o]
+  );
+  return L.createElement(On.Provider, {
+    value: R
+  }, t);
+}
+const Lo = (e) => {
+  let {
+    id: t,
+    items: n,
+    activeIndex: r,
+    overIndex: o
+  } = e;
+  return An(n, r, o).indexOf(t);
+}, ko = (e) => {
+  let {
+    containerId: t,
+    isSorting: n,
+    wasDragging: r,
+    index: o,
+    items: i,
+    newIndex: s,
+    previousItems: a,
+    previousContainerId: l,
+    transition: c
+  } = e;
+  return !c || !r || a !== i && o === s ? !1 : n ? !0 : s !== o && t === l;
+}, Po = {
+  duration: 200,
+  easing: "ease"
+}, Tn = "transform", zo = /* @__PURE__ */ be.Transition.toString({
+  property: Tn,
+  duration: 0,
+  easing: "linear"
+}), Bo = {
+  roleDescription: "sortable"
+};
+function Fo(e) {
+  let {
+    disabled: t,
+    index: n,
+    node: r,
+    rect: o
+  } = e;
+  const [i, s] = F(null), a = O(n);
+  return Q(() => {
+    if (!t && n !== a.current && r.current) {
+      const l = o.current;
+      if (l) {
+        const c = Ie(r.current, {
+          ignoreTransform: !0
+        }), d = {
+          x: l.left - c.left,
+          y: l.top - c.top,
+          scaleX: l.width / c.width,
+          scaleY: l.height / c.height
+        };
+        (d.x || d.y) && s(d);
+      }
+    }
+    n !== a.current && (a.current = n);
+  }, [t, n, r, o]), T(() => {
+    i && s(null);
+  }, [i]), i;
+}
+function $o(e) {
+  let {
+    animateLayoutChanges: t = ko,
+    attributes: n,
+    disabled: r,
+    data: o,
+    getNewIndex: i = Lo,
+    id: s,
+    strategy: a,
+    resizeObserverConfig: l,
+    transition: c = Po
+  } = e;
+  const {
+    items: d,
+    containerId: u,
+    activeIndex: f,
+    disabled: g,
+    disableTransforms: x,
+    sortedRects: v,
+    overIndex: h,
+    useDragOverlay: p,
+    strategy: m
+  } = pe(On), b = Xo(r, g), S = d.indexOf(s), R = A(() => ({
+    sortable: {
+      containerId: u,
+      index: S,
+      items: d
+    },
+    ...o
+  }), [u, o, S, d]), D = A(() => d.slice(d.indexOf(s)), [d, s]), {
+    rect: y,
+    node: w,
+    isOver: N,
+    setNodeRef: M
+  } = En({
+    id: s,
+    data: R,
+    disabled: b.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: D,
+      ...l
+    }
+  }), {
+    active: E,
+    activatorEvent: Y,
+    activeNodeRect: J,
+    attributes: ee,
+    setNodeRef: Ne,
+    listeners: _e,
+    isDragging: K,
+    over: qe,
+    setActivatorNodeRef: oe,
+    transform: Oe
+  } = uo({
+    id: s,
+    data: R,
+    attributes: {
+      ...Bo,
+      ...n
+    },
+    disabled: b.draggable
+  }), Ge = qn(M, Ne), j = !!E, ie = j && !x && tt(f) && tt(h), me = !p && K, Te = me && ie ? Oe : null, Je = ie ? Te ?? (a ?? m)({
+    rects: v,
+    activeNodeRect: J,
+    activeIndex: f,
+    overIndex: h,
+    index: S
+  }) : null, ce = tt(f) && tt(h) ? i({
+    id: s,
+    items: d,
+    activeIndex: f,
+    overIndex: h
+  }) : S, se = E?.id, I = O({
+    activeId: se,
+    items: d,
+    newIndex: ce,
+    containerId: u
+  }), Me = d !== I.current.items, te = t({
+    active: E,
+    containerId: u,
+    isDragging: K,
+    isSorting: j,
+    id: s,
+    index: S,
+    items: d,
+    newIndex: I.current.newIndex,
+    previousItems: I.current.items,
+    previousContainerId: I.current.containerId,
+    transition: c,
+    wasDragging: I.current.activeId != null
+  }), ye = Fo({
+    disabled: !te,
+    index: S,
+    node: w,
+    rect: y
+  });
+  return T(() => {
+    j && I.current.newIndex !== ce && (I.current.newIndex = ce), u !== I.current.containerId && (I.current.containerId = u), d !== I.current.items && (I.current.items = d);
+  }, [j, ce, u, d]), T(() => {
+    if (se === I.current.activeId)
+      return;
+    if (se != null && I.current.activeId == null) {
+      I.current.activeId = se;
+      return;
+    }
+    const we = setTimeout(() => {
+      I.current.activeId = se;
+    }, 50);
+    return () => clearTimeout(we);
+  }, [se]), {
+    active: E,
+    activeIndex: f,
+    attributes: ee,
+    data: R,
+    rect: y,
+    index: S,
+    newIndex: ce,
+    items: d,
+    isOver: N,
+    isSorting: j,
+    isDragging: K,
+    listeners: _e,
+    node: w,
+    overIndex: h,
+    over: qe,
+    setNodeRef: Ge,
+    setActivatorNodeRef: oe,
+    setDroppableNodeRef: M,
+    setDraggableNodeRef: Ne,
+    transform: ye ?? Je,
+    transition: ae()
+  };
+  function ae() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      ye || // Or to prevent items jumping to back to their "new" position when items change
+      Me && I.current.newIndex === S
+    )
+      return zo;
+    if (!(me && !ft(Y) || !c) && (j || te))
+      return be.Transition.toString({
+        ...c,
+        property: Tn
+      });
+  }
+}
+function Xo(e, t) {
+  var n, r;
+  return typeof e == "boolean" ? {
+    draggable: e,
+    // Backwards compatibility
+    droppable: !1
+  } : {
+    draggable: (n = e?.draggable) != null ? n : t.draggable,
+    droppable: (r = e?.droppable) != null ? r : t.droppable
+  };
+}
+function ct(e) {
+  if (!e)
+    return !1;
+  const t = e.data.current;
+  return !!(t && "sortable" in t && typeof t.sortable == "object" && "containerId" in t.sortable && "items" in t.sortable && "index" in t.sortable);
+}
+const jo = [C.Down, C.Right, C.Up, C.Left], Yo = (e, t) => {
+  let {
+    context: {
+      active: n,
+      collisionRect: r,
+      droppableRects: o,
+      droppableContainers: i,
+      over: s,
+      scrollableAncestors: a
+    }
+  } = t;
+  if (jo.includes(e.code)) {
+    if (e.preventDefault(), !n || !r)
+      return;
+    const l = [];
+    i.getEnabled().forEach((u) => {
+      if (!u || u != null && u.disabled)
+        return;
+      const f = o.get(u.id);
+      if (f)
+        switch (e.code) {
+          case C.Down:
+            r.top < f.top && l.push(u);
+            break;
+          case C.Up:
+            r.top > f.top && l.push(u);
+            break;
+          case C.Left:
+            r.left > f.left && l.push(u);
+            break;
+          case C.Right:
+            r.left < f.left && l.push(u);
+            break;
+        }
+    });
+    const c = cn({
+      collisionRect: r,
+      droppableRects: o,
+      droppableContainers: l
+    });
+    let d = ln(c, "id");
+    if (d === s?.id && c.length > 1 && (d = c[1].id), d != null) {
+      const u = i.get(n.id), f = i.get(d), g = f ? o.get(f.id) : null, x = f?.node.current;
+      if (x && g && u && f) {
+        const h = gt(x).some((D, y) => a[y] !== D), p = Mn(u, f), m = Ko(u, f), b = h || !p ? {
+          x: 0,
+          y: 0
+        } : {
+          x: m ? r.width - g.width : 0,
+          y: m ? r.height - g.height : 0
+        }, S = {
+          x: g.left,
+          y: g.top
+        };
+        return b.x && b.y ? S : je(S, b);
+      }
+    }
+  }
+};
+function Mn(e, t) {
+  return !ct(e) || !ct(t) ? !1 : e.data.current.sortable.containerId === t.data.current.sortable.containerId;
+}
+function Ko(e, t) {
+  return !ct(e) || !ct(t) || !Mn(e, t) ? !1 : e.data.current.sortable.index < t.data.current.sortable.index;
+}
+const Jo = {}, Qo = {}, At = "column:";
+function Uo({ id: e, children: t }) {
+  const { attributes: n, listeners: r, setNodeRef: o, transform: i, transition: s, isDragging: a } = $o({ id: e });
+  return /* @__PURE__ */ q(
+    "div",
+    {
+      ref: o,
+      style: { transform: be.Transform.toString(i), transition: s },
+      ...n,
+      ...r,
+      className: rn(
+        "cursor-grab rounded-md bg-reki-base p-2 ring ring-reki-hairline",
+        "active:cursor-grabbing",
+        a && "opacity-50"
+      ),
+      children: t
+    }
+  );
+}
+function Wo({
+  column: e,
+  records: t,
+  getRecordId: n,
+  renderCard: r,
+  renderColumnHeader: o
+}) {
+  const { setNodeRef: i } = En({ id: `${At}${e.id}` }), s = t.map(n);
+  return /* @__PURE__ */ St("section", { className: "flex w-72 shrink-0 flex-col gap-2", children: [
+    /* @__PURE__ */ q("header", { className: "flex items-center gap-2 px-1 text-sm font-medium text-reki-default", children: o ? o(e, t.length) : /* @__PURE__ */ St(jn, { children: [
+      e.color ? /* @__PURE__ */ q(_n, { colorName: e.color, variant: "circle" }) : null,
+      /* @__PURE__ */ q("span", { className: "min-w-0 truncate", children: e.title }),
+      /* @__PURE__ */ q("span", { className: "ml-auto text-xs text-reki-subtle tabular-nums", children: t.length })
+    ] }) }),
+    /* @__PURE__ */ q(Mo, { items: s, strategy: Oo, children: /* @__PURE__ */ q(
+      "div",
+      {
+        ref: i,
+        className: "flex min-h-16 flex-col gap-2 rounded-md bg-reki-recessed p-2",
+        children: t.map((a) => /* @__PURE__ */ q(Uo, { id: n(a), children: r(a) }, n(a)))
+      }
+    ) })
+  ] });
+}
+function Zo({
+  columns: e,
+  records: t,
+  getRecordId: n,
+  getColumnId: r,
+  renderCard: o,
+  onMove: i,
+  renderColumnHeader: s,
+  className: a
+}) {
+  const [l, c] = F(null), d = cr(
+    Ut(Lt, {
+      activationConstraint: { distance: 4 }
+    }),
+    Ut(Tt, {
+      coordinateGetter: Yo
+    })
+  ), u = A(() => {
+    const h = /* @__PURE__ */ new Map();
+    for (const p of e)
+      h.set(p.id, []);
+    for (const p of t) {
+      const m = r(p), b = h.get(m);
+      b && b.push(p);
+    }
+    return h;
+  }, [e, t, r]), f = A(() => {
+    const h = /* @__PURE__ */ new Map();
+    for (const p of t)
+      h.set(n(p), p);
+    return h;
+  }, [t, n]), g = (h) => {
+    c(String(h.active.id));
+  }, x = (h) => {
+    c(null);
+    const { active: p, over: m } = h;
+    if (!m)
+      return;
+    const b = String(p.id), S = f.get(b);
+    if (!S)
+      return;
+    const R = r(S), D = String(m.id);
+    let y, w;
+    if (D.startsWith(At))
+      y = D.slice(At.length), w = u.get(y)?.length ?? 0;
+    else {
+      const N = f.get(D);
+      if (!N)
+        return;
+      y = r(N);
+      const M = u.get(y) ?? [], E = M.findIndex((Y) => n(Y) === D);
+      w = E < 0 ? M.length : E;
+    }
+    D !== b && i?.({ recordId: b, fromColumnId: R, toColumnId: y, toIndex: w });
+  }, v = l ? f.get(l) : void 0;
+  return /* @__PURE__ */ St(
+    ao,
+    {
+      sensors: d,
+      collisionDetection: cn,
+      onDragStart: g,
+      onDragEnd: x,
+      onDragCancel: () => c(null),
+      children: [
+        /* @__PURE__ */ q("div", { className: rn("flex h-full gap-3 overflow-x-auto p-1", a), children: e.map((h) => /* @__PURE__ */ q(
+          Wo,
+          {
+            column: h,
+            records: u.get(h.id) ?? [],
+            getRecordId: n,
+            renderCard: o,
+            renderColumnHeader: s
+          },
+          h.id
+        )) }),
+        /* @__PURE__ */ q(Eo, { children: v ? /* @__PURE__ */ q("div", { className: "cursor-grabbing rounded-md bg-reki-base p-2 shadow-lg shadow-reki-tip-shadow ring ring-reki-hairline", children: o(v) }) : null })
+      ]
+    }
+  );
+}
+export {
+  Qo as R,
+  Jo as a,
+  Zo as b
+};
+//# sourceMappingURL=record-board-iapx3cw5rusehrta.js.map