@purpur/library 9.10.0 → 10.0.0

package/dist/core.esm-CKGHpLM_.mjs

@@ -0,0 +1,2892 @@
+import N, { useMemo as R, useRef as E, useCallback as B, useLayoutEffect as En, useEffect as A, useState as j, createContext as Me, useContext as fe, memo as An, useReducer as On, cloneElement as Nn, forwardRef as Tn } from "react";
+import { unstable_batchedUpdates as Xe, createPortal as Mn } from "react-dom";
+function so() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return R(
+    () => (r) => {
+      t.forEach((o) => o(r));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const qe = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function me(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 dt(e) {
+  return "nodeType" in e;
+}
+function F(e) {
+  var t, n;
+  return e ? me(e) ? e : dt(e) && (t = (n = e.ownerDocument) == null ? void 0 : n.defaultView) != null ? t : window : window;
+}
+function ft(e) {
+  const {
+    Document: t
+  } = F(e);
+  return e instanceof t;
+}
+function Le(e) {
+  return me(e) ? !1 : e instanceof F(e).HTMLElement;
+}
+function Jt(e) {
+  return e instanceof F(e).SVGElement;
+}
+function we(e) {
+  return e ? me(e) ? e.document : dt(e) ? ft(e) ? e : Le(e) || Jt(e) ? e.ownerDocument : document : document : document;
+}
+const ee = qe ? En : A;
+function Je(e) {
+  const t = E(e);
+  return ee(() => {
+    t.current = e;
+  }), B(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 Ln() {
+  const e = E(null), t = B((r, o) => {
+    e.current = setInterval(r, o);
+  }, []), n = B(() => {
+    e.current !== null && (clearInterval(e.current), e.current = null);
+  }, []);
+  return [t, n];
+}
+function Oe(e, t) {
+  t === void 0 && (t = [e]);
+  const n = E(e);
+  return ee(() => {
+    n.current !== e && (n.current = e);
+  }, t), n;
+}
+function Ie(e, t) {
+  const n = E();
+  return R(
+    () => {
+      const r = e(n.current);
+      return n.current = r, r;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function $e(e) {
+  const t = Je(e), n = E(null), r = B(
+    (o) => {
+      o !== n.current && t?.(o, n.current), n.current = o;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [n, r];
+}
+function Ke(e) {
+  const t = E();
+  return A(() => {
+    t.current = e;
+  }, [e]), t.current;
+}
+let ot = {};
+function Ge(e, t) {
+  return R(() => {
+    if (t)
+      return t;
+    const n = ot[e] == null ? 0 : ot[e] + 1;
+    return ot[e] = n, e + "-" + n;
+  }, [e, t]);
+}
+function Gt(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, a) => {
+      const s = Object.entries(a);
+      for (const [l, c] of s) {
+        const d = i[l];
+        d != null && (i[l] = d + e * c);
+      }
+      return i;
+    }, {
+      ...t
+    });
+  };
+}
+const ye = /* @__PURE__ */ Gt(1), We = /* @__PURE__ */ Gt(-1);
+function In(e) {
+  return "clientX" in e && "clientY" in e;
+}
+function ht(e) {
+  if (!e)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = F(e.target);
+  return t && e instanceof t;
+}
+function Pn(e) {
+  if (!e)
+    return !1;
+  const {
+    TouchEvent: t
+  } = F(e.target);
+  return t && e instanceof t;
+}
+function Ue(e) {
+  if (Pn(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 In(e) ? {
+    x: e.clientX,
+    y: e.clientY
+  } : null;
+}
+const Ne = /* @__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 [Ne.Translate.toString(e), Ne.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 kn(e) {
+  return e.matches(kt) ? e : e.querySelector(kt);
+}
+const zn = {
+  display: "none"
+};
+function Bn(e) {
+  let {
+    id: t,
+    value: n
+  } = e;
+  return N.createElement("div", {
+    id: t,
+    style: zn
+  }, n);
+}
+function Fn(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 N.createElement("div", {
+    id: t,
+    style: o,
+    role: "status",
+    "aria-live": r,
+    "aria-atomic": !0
+  }, n);
+}
+function jn() {
+  const [e, t] = j("");
+  return {
+    announce: B((r) => {
+      r != null && t(r);
+    }, []),
+    announcement: e
+  };
+}
+const Qt = /* @__PURE__ */ Me(null);
+function Xn(e) {
+  const t = fe(Qt);
+  A(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function Yn() {
+  const [e] = j(() => /* @__PURE__ */ new Set()), t = B((r) => (e.add(r), () => e.delete(r)), [e]);
+  return [B((r) => {
+    let {
+      type: o,
+      event: i
+    } = r;
+    e.forEach((a) => {
+      var s;
+      return (s = a[o]) == null ? void 0 : s.call(a, i);
+    });
+  }, [e]), t];
+}
+const $n = {
+  draggable: `
+    To pick up a draggable item, press the space bar.
+    While dragging, use the arrow keys to move the item.
+    Press space again to drop the item in its new position, or press escape to cancel.
+  `
+}, Kn = {
+  onDragStart(e) {
+    let {
+      active: t
+    } = e;
+    return "Picked up draggable item " + t.id + ".";
+  },
+  onDragOver(e) {
+    let {
+      active: t,
+      over: n
+    } = e;
+    return n ? "Draggable item " + t.id + " was moved over droppable area " + n.id + "." : "Draggable item " + t.id + " is no longer over a droppable area.";
+  },
+  onDragEnd(e) {
+    let {
+      active: t,
+      over: n
+    } = e;
+    return n ? "Draggable item " + t.id + " was dropped over droppable area " + n.id : "Draggable item " + t.id + " was dropped.";
+  },
+  onDragCancel(e) {
+    let {
+      active: t
+    } = e;
+    return "Dragging was cancelled. Draggable item " + t.id + " was dropped.";
+  }
+};
+function Wn(e) {
+  let {
+    announcements: t = Kn,
+    container: n,
+    hiddenTextDescribedById: r,
+    screenReaderInstructions: o = $n
+  } = e;
+  const {
+    announce: i,
+    announcement: a
+  } = jn(), s = Ge("DndLiveRegion"), [l, c] = j(!1);
+  if (A(() => {
+    c(!0);
+  }, []), Xn(R(() => ({
+    onDragStart(u) {
+      let {
+        active: h
+      } = u;
+      i(t.onDragStart({
+        active: h
+      }));
+    },
+    onDragMove(u) {
+      let {
+        active: h,
+        over: f
+      } = u;
+      t.onDragMove && i(t.onDragMove({
+        active: h,
+        over: f
+      }));
+    },
+    onDragOver(u) {
+      let {
+        active: h,
+        over: f
+      } = u;
+      i(t.onDragOver({
+        active: h,
+        over: f
+      }));
+    },
+    onDragEnd(u) {
+      let {
+        active: h,
+        over: f
+      } = u;
+      i(t.onDragEnd({
+        active: h,
+        over: f
+      }));
+    },
+    onDragCancel(u) {
+      let {
+        active: h,
+        over: f
+      } = u;
+      i(t.onDragCancel({
+        active: h,
+        over: f
+      }));
+    }
+  }), [i, t])), !l)
+    return null;
+  const d = N.createElement(N.Fragment, null, N.createElement(Bn, {
+    id: r,
+    value: o.draggable
+  }), N.createElement(Fn, {
+    id: s,
+    announcement: a
+  }));
+  return n ? Mn(d, n) : d;
+}
+var M;
+(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";
+})(M || (M = {}));
+function He() {
+}
+function ao(e, t) {
+  return R(
+    () => ({
+      sensor: e,
+      options: t ?? {}
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  );
+}
+function lo() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return R(
+    () => [...t].filter((r) => r != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const V = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function Zt(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function Un(e, t) {
+  const n = Ue(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 _t(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return n - r;
+}
+function Hn(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return r - n;
+}
+function zt(e) {
+  let {
+    left: t,
+    top: n,
+    height: r,
+    width: o
+  } = e;
+  return [{
+    x: t,
+    y: n
+  }, {
+    x: t + o,
+    y: n
+  }, {
+    x: t,
+    y: n + r
+  }, {
+    x: t + o,
+    y: n + r
+  }];
+}
+function Vn(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return n[t];
+}
+function Bt(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 co = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Bt(t, t.left, t.top), i = [];
+  for (const a of r) {
+    const {
+      id: s
+    } = a, l = n.get(s);
+    if (l) {
+      const c = Zt(Bt(l), o);
+      i.push({
+        id: s,
+        data: {
+          droppableContainer: a,
+          value: c
+        }
+      });
+    }
+  }
+  return i.sort(_t);
+}, uo = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = zt(t), i = [];
+  for (const a of r) {
+    const {
+      id: s
+    } = a, l = n.get(s);
+    if (l) {
+      const c = zt(l), d = o.reduce((h, f, D) => h + Zt(c[D], f), 0), u = Number((d / 4).toFixed(4));
+      i.push({
+        id: s,
+        data: {
+          droppableContainer: a,
+          value: u
+        }
+      });
+    }
+  }
+  return i.sort(_t);
+};
+function qn(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), a = o - r, s = i - n;
+  if (r < o && n < i) {
+    const l = t.width * t.height, c = e.width * e.height, d = a * s, u = d / (l + c - d);
+    return Number(u.toFixed(4));
+  }
+  return 0;
+}
+const Jn = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = [];
+  for (const i of r) {
+    const {
+      id: a
+    } = i, s = n.get(a);
+    if (s) {
+      const l = qn(s, t);
+      l > 0 && o.push({
+        id: a,
+        data: {
+          droppableContainer: i,
+          value: l
+        }
+      });
+    }
+  }
+  return o.sort(Hn);
+};
+function Gn(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function en(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : V;
+}
+function Qn(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((a, s) => ({
+      ...a,
+      top: a.top + e * s.y,
+      bottom: a.bottom + e * s.y,
+      left: a.left + e * s.x,
+      right: a.right + e * s.x
+    }), {
+      ...n
+    });
+  };
+}
+const Zn = /* @__PURE__ */ Qn(1);
+function tn(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 _n(e, t, n) {
+  const r = tn(t);
+  if (!r)
+    return e;
+  const {
+    scaleX: o,
+    scaleY: i,
+    x: a,
+    y: s
+  } = r, l = e.left - a - (1 - o) * parseFloat(n), c = e.top - s - (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 er = {
+  ignoreTransform: !1
+};
+function Pe(e, t) {
+  t === void 0 && (t = er);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: c,
+      transformOrigin: d
+    } = F(e).getComputedStyle(e);
+    c && (n = _n(n, c, d));
+  }
+  const {
+    top: r,
+    left: o,
+    width: i,
+    height: a,
+    bottom: s,
+    right: l
+  } = n;
+  return {
+    top: r,
+    left: o,
+    width: i,
+    height: a,
+    bottom: s,
+    right: l
+  };
+}
+function Ft(e) {
+  return Pe(e, {
+    ignoreTransform: !0
+  });
+}
+function tr(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function nr(e, t) {
+  return t === void 0 && (t = F(e).getComputedStyle(e)), t.position === "fixed";
+}
+function rr(e, t) {
+  t === void 0 && (t = F(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 (ft(o) && o.scrollingElement != null && !n.includes(o.scrollingElement))
+      return n.push(o.scrollingElement), n;
+    if (!Le(o) || Jt(o) || n.includes(o))
+      return n;
+    const i = F(e).getComputedStyle(o);
+    return o !== e && rr(o, i) && n.push(o), nr(o, i) ? n : r(o.parentNode);
+  }
+  return e ? r(e) : n;
+}
+function nn(e) {
+  const [t] = gt(e, 1);
+  return t ?? null;
+}
+function it(e) {
+  return !qe || !e ? null : me(e) ? e : dt(e) ? ft(e) || e === we(e).scrollingElement ? window : Le(e) ? e : null : null;
+}
+function rn(e) {
+  return me(e) ? e.scrollX : e.scrollLeft;
+}
+function on(e) {
+  return me(e) ? e.scrollY : e.scrollTop;
+}
+function lt(e) {
+  return {
+    x: rn(e),
+    y: on(e)
+  };
+}
+var I;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(I || (I = {}));
+function sn(e) {
+  return !qe || !e ? !1 : e === document.scrollingElement;
+}
+function an(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = sn(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, a = e.scrollTop >= r.y, s = e.scrollLeft >= r.x;
+  return {
+    isTop: o,
+    isLeft: i,
+    isBottom: a,
+    isRight: s,
+    maxScroll: r,
+    minScroll: t
+  };
+}
+const or = {
+  x: 0.2,
+  y: 0.2
+};
+function ir(e, t, n, r, o) {
+  let {
+    top: i,
+    left: a,
+    right: s,
+    bottom: l
+  } = n;
+  r === void 0 && (r = 10), o === void 0 && (o = or);
+  const {
+    isTop: c,
+    isBottom: d,
+    isLeft: u,
+    isRight: h
+  } = an(e), f = {
+    x: 0,
+    y: 0
+  }, D = {
+    x: 0,
+    y: 0
+  }, g = {
+    height: t.height * o.y,
+    width: t.width * o.x
+  };
+  return !c && i <= t.top + g.height ? (f.y = I.Backward, D.y = r * Math.abs((t.top + g.height - i) / g.height)) : !d && l >= t.bottom - g.height && (f.y = I.Forward, D.y = r * Math.abs((t.bottom - g.height - l) / g.height)), !h && s >= t.right - g.width ? (f.x = I.Forward, D.x = r * Math.abs((t.right - g.width - s) / g.width)) : !u && a <= t.left + g.width && (f.x = I.Backward, D.x = r * Math.abs((t.left + g.width - a) / g.width)), {
+    direction: f,
+    speed: D
+  };
+}
+function sr(e) {
+  if (e === document.scrollingElement) {
+    const {
+      innerWidth: i,
+      innerHeight: a
+    } = window;
+    return {
+      top: 0,
+      left: 0,
+      right: i,
+      bottom: a,
+      width: i,
+      height: a
+    };
+  }
+  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 ln(e) {
+  return e.reduce((t, n) => ye(t, lt(n)), V);
+}
+function ar(e) {
+  return e.reduce((t, n) => t + rn(n), 0);
+}
+function lr(e) {
+  return e.reduce((t, n) => t + on(n), 0);
+}
+function cn(e, t) {
+  if (t === void 0 && (t = Pe), !e)
+    return;
+  const {
+    top: n,
+    left: r,
+    bottom: o,
+    right: i
+  } = t(e);
+  nn(e) && (o <= 0 || i <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const cr = [["x", ["left", "right"], ar], ["y", ["top", "bottom"], lr]];
+class vt {
+  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 = ln(r);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [i, a, s] of cr)
+      for (const l of a)
+        Object.defineProperty(this, l, {
+          get: () => {
+            const c = s(r), d = o[i] - c;
+            return this.rect[l] + d;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class Re {
+  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 ur(e) {
+  const {
+    EventTarget: t
+  } = F(e);
+  return e instanceof t ? e : we(e);
+}
+function st(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 W;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(W || (W = {}));
+function jt(e) {
+  e.preventDefault();
+}
+function dr(e) {
+  e.stopPropagation();
+}
+var x;
+(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";
+})(x || (x = {}));
+const un = {
+  start: [x.Space, x.Enter],
+  cancel: [x.Esc],
+  end: [x.Space, x.Enter, x.Tab]
+}, fr = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case x.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case x.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case x.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case x.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class dn {
+  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 Re(we(n)), this.windowListeners = new Re(F(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(W.Resize, this.handleCancel), this.windowListeners.add(W.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(W.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, r = t.node.current;
+    r && cn(r), n(V);
+  }
+  handleKeyDown(t) {
+    if (ht(t)) {
+      const {
+        active: n,
+        context: r,
+        options: o
+      } = this.props, {
+        keyboardCodes: i = un,
+        coordinateGetter: a = fr,
+        scrollBehavior: s = "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
+      } : V;
+      this.referenceCoordinates || (this.referenceCoordinates = d);
+      const u = a(t, {
+        active: n,
+        context: r.current,
+        currentCoordinates: d
+      });
+      if (u) {
+        const h = We(u, d), f = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: D
+        } = r.current;
+        for (const g of D) {
+          const v = t.code, {
+            isTop: y,
+            isRight: w,
+            isLeft: m,
+            isBottom: L,
+            maxScroll: C,
+            minScroll: S
+          } = an(g), p = sr(g), b = {
+            x: Math.min(v === x.Right ? p.right - p.width / 2 : p.right, Math.max(v === x.Right ? p.left : p.left + p.width / 2, u.x)),
+            y: Math.min(v === x.Down ? p.bottom - p.height / 2 : p.bottom, Math.max(v === x.Down ? p.top : p.top + p.height / 2, u.y))
+          }, O = v === x.Right && !w || v === x.Left && !m, P = v === x.Down && !L || v === x.Up && !y;
+          if (O && b.x !== u.x) {
+            const T = g.scrollLeft + h.x, G = v === x.Right && T <= C.x || v === x.Left && T >= S.x;
+            if (G && !h.y) {
+              g.scrollTo({
+                left: T,
+                behavior: s
+              });
+              return;
+            }
+            G ? f.x = g.scrollLeft - T : f.x = v === x.Right ? g.scrollLeft - C.x : g.scrollLeft - S.x, f.x && g.scrollBy({
+              left: -f.x,
+              behavior: s
+            });
+            break;
+          } else if (P && b.y !== u.y) {
+            const T = g.scrollTop + h.y, G = v === x.Down && T <= C.y || v === x.Up && T >= S.y;
+            if (G && !h.x) {
+              g.scrollTo({
+                top: T,
+                behavior: s
+              });
+              return;
+            }
+            G ? f.y = g.scrollTop - T : f.y = v === x.Down ? g.scrollTop - C.y : g.scrollTop - S.y, f.y && g.scrollBy({
+              top: -f.y,
+              behavior: s
+            });
+            break;
+          }
+        }
+        this.handleMove(t, ye(We(u, this.referenceCoordinates), f));
+      }
+    }
+  }
+  handleMove(t, n) {
+    const {
+      onMove: r
+    } = this.props;
+    t.preventDefault(), r(n);
+  }
+  handleEnd(t) {
+    const {
+      onEnd: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  handleCancel(t) {
+    const {
+      onCancel: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll();
+  }
+}
+dn.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: r = un,
+      onActivation: o
+    } = t, {
+      active: i
+    } = n;
+    const {
+      code: a
+    } = e.nativeEvent;
+    if (r.start.includes(a)) {
+      const s = i.activatorNode.current;
+      return s && e.target !== s ? !1 : (e.preventDefault(), o?.({
+        event: e.nativeEvent
+      }), !0);
+    }
+    return !1;
+  }
+}];
+function Xt(e) {
+  return !!(e && "distance" in e);
+}
+function Yt(e) {
+  return !!(e && "delay" in e);
+}
+class pt {
+  constructor(t, n, r) {
+    var o;
+    r === void 0 && (r = ur(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: a
+    } = i;
+    this.props = t, this.events = n, this.document = we(a), this.documentListeners = new Re(this.document), this.listeners = new Re(r), this.windowListeners = new Re(F(a)), this.initialCoordinates = (o = Ue(i)) != null ? o : V, 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(W.Resize, this.handleCancel), this.windowListeners.add(W.DragStart, jt), this.windowListeners.add(W.VisibilityChange, this.handleCancel), this.windowListeners.add(W.ContextMenu, jt), this.documentListeners.add(W.Keydown, this.handleKeydown), n) {
+      if (r != null && r({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (Yt(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay), this.handlePending(n);
+        return;
+      }
+      if (Xt(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(W.Click, dr, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(W.SelectionChange, this.removeTextSelection), n(t));
+  }
+  handleMove(t) {
+    var n;
+    const {
+      activated: r,
+      initialCoordinates: o,
+      props: i
+    } = this, {
+      onMove: a,
+      options: {
+        activationConstraint: s
+      }
+    } = i;
+    if (!o)
+      return;
+    const l = (n = Ue(t)) != null ? n : V, c = We(o, l);
+    if (!r && s) {
+      if (Xt(s)) {
+        if (s.tolerance != null && st(c, s.tolerance))
+          return this.handleCancel();
+        if (st(c, s.distance))
+          return this.handleStart();
+      }
+      if (Yt(s) && st(c, s.tolerance))
+        return this.handleCancel();
+      this.handlePending(s, c);
+      return;
+    }
+    t.cancelable && t.preventDefault(), a(l);
+  }
+  handleEnd() {
+    const {
+      onAbort: t,
+      onEnd: n
+    } = this.props;
+    this.detach(), this.activated || t(this.props.active), n();
+  }
+  handleCancel() {
+    const {
+      onAbort: t,
+      onCancel: n
+    } = this.props;
+    this.detach(), this.activated || t(this.props.active), n();
+  }
+  handleKeydown(t) {
+    t.code === x.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const hr = {
+  cancel: {
+    name: "pointercancel"
+  },
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class fn extends pt {
+  constructor(t) {
+    const {
+      event: n
+    } = t, r = we(n.target);
+    super(t, hr, r);
+  }
+}
+fn.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 gr = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var ct;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(ct || (ct = {}));
+class vr extends pt {
+  constructor(t) {
+    super(t, gr, we(t.event.target));
+  }
+}
+vr.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return n.button === ct.RightClick ? !1 : (r?.({
+      event: n
+    }), !0);
+  }
+}];
+const at = {
+  cancel: {
+    name: "touchcancel"
+  },
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class pr extends pt {
+  constructor(t) {
+    super(t, at);
+  }
+  static setup() {
+    return window.addEventListener(at.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(at.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+pr.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 Ee;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(Ee || (Ee = {}));
+var Ve;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(Ve || (Ve = {}));
+function br(e) {
+  let {
+    acceleration: t,
+    activator: n = Ee.Pointer,
+    canScroll: r,
+    draggingRect: o,
+    enabled: i,
+    interval: a = 5,
+    order: s = Ve.TreeOrder,
+    pointerCoordinates: l,
+    scrollableAncestors: c,
+    scrollableAncestorRects: d,
+    delta: u,
+    threshold: h
+  } = e;
+  const f = mr({
+    delta: u,
+    disabled: !i
+  }), [D, g] = Ln(), v = E({
+    x: 0,
+    y: 0
+  }), y = E({
+    x: 0,
+    y: 0
+  }), w = R(() => {
+    switch (n) {
+      case Ee.Pointer:
+        return l ? {
+          top: l.y,
+          bottom: l.y,
+          left: l.x,
+          right: l.x
+        } : null;
+      case Ee.DraggableRect:
+        return o;
+    }
+  }, [n, o, l]), m = E(null), L = B(() => {
+    const S = m.current;
+    if (!S)
+      return;
+    const p = v.current.x * y.current.x, b = v.current.y * y.current.y;
+    S.scrollBy(p, b);
+  }, []), C = R(() => s === Ve.TreeOrder ? [...c].reverse() : c, [s, c]);
+  A(
+    () => {
+      if (!i || !c.length || !w) {
+        g();
+        return;
+      }
+      for (const S of C) {
+        if (r?.(S) === !1)
+          continue;
+        const p = c.indexOf(S), b = d[p];
+        if (!b)
+          continue;
+        const {
+          direction: O,
+          speed: P
+        } = ir(S, b, w, t, h);
+        for (const T of ["x", "y"])
+          f[T][O[T]] || (P[T] = 0, O[T] = 0);
+        if (P.x > 0 || P.y > 0) {
+          g(), m.current = S, D(L, a), v.current = P, y.current = O;
+          return;
+        }
+      }
+      v.current = {
+        x: 0,
+        y: 0
+      }, y.current = {
+        x: 0,
+        y: 0
+      }, g();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      L,
+      r,
+      g,
+      i,
+      a,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(w),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(f),
+      D,
+      c,
+      C,
+      d,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(h)
+    ]
+  );
+}
+const yr = {
+  x: {
+    [I.Backward]: !1,
+    [I.Forward]: !1
+  },
+  y: {
+    [I.Backward]: !1,
+    [I.Forward]: !1
+  }
+};
+function mr(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const r = Ke(t);
+  return Ie((o) => {
+    if (n || !r || !o)
+      return yr;
+    const i = {
+      x: Math.sign(t.x - r.x),
+      y: Math.sign(t.y - r.y)
+    };
+    return {
+      x: {
+        [I.Backward]: o.x[I.Backward] || i.x === -1,
+        [I.Forward]: o.x[I.Forward] || i.x === 1
+      },
+      y: {
+        [I.Backward]: o.y[I.Backward] || i.y === -1,
+        [I.Forward]: o.y[I.Forward] || i.y === 1
+      }
+    };
+  }, [n, t, r]);
+}
+function wr(e, t) {
+  const n = t != null ? e.get(t) : void 0, r = n ? n.node.current : null;
+  return Ie((o) => {
+    var i;
+    return t == null ? null : (i = r ?? o) != null ? i : null;
+  }, [r, t]);
+}
+function Dr(e, t) {
+  return R(() => e.reduce((n, r) => {
+    const {
+      sensor: o
+    } = r, i = o.activators.map((a) => ({
+      eventName: a.eventName,
+      handler: t(a.handler, r)
+    }));
+    return [...n, ...i];
+  }, []), [e, t]);
+}
+var Te;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Te || (Te = {}));
+var ut;
+(function(e) {
+  e.Optimized = "optimized";
+})(ut || (ut = {}));
+const $t = /* @__PURE__ */ new Map();
+function xr(e, t) {
+  let {
+    dragging: n,
+    dependencies: r,
+    config: o
+  } = t;
+  const [i, a] = j(null), {
+    frequency: s,
+    measure: l,
+    strategy: c
+  } = o, d = E(e), u = v(), h = Oe(u), f = B(function(y) {
+    y === void 0 && (y = []), !h.current && a((w) => w === null ? y : w.concat(y.filter((m) => !w.includes(m))));
+  }, [h]), D = E(null), g = Ie((y) => {
+    if (u && !n)
+      return $t;
+    if (!y || y === $t || d.current !== e || i != null) {
+      const w = /* @__PURE__ */ new Map();
+      for (let m of e) {
+        if (!m)
+          continue;
+        if (i && i.length > 0 && !i.includes(m.id) && m.rect.current) {
+          w.set(m.id, m.rect.current);
+          continue;
+        }
+        const L = m.node.current, C = L ? new vt(l(L), L) : null;
+        m.rect.current = C, C && w.set(m.id, C);
+      }
+      return w;
+    }
+    return y;
+  }, [e, i, n, u, l]);
+  return A(() => {
+    d.current = e;
+  }, [e]), A(
+    () => {
+      u || f();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, u]
+  ), A(
+    () => {
+      i && i.length > 0 && a(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(i)]
+  ), A(
+    () => {
+      u || typeof s != "number" || D.current !== null || (D.current = setTimeout(() => {
+        f(), D.current = null;
+      }, s));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [s, u, f, ...r]
+  ), {
+    droppableRects: g,
+    measureDroppableContainers: f,
+    measuringScheduled: i != null
+  };
+  function v() {
+    switch (c) {
+      case Te.Always:
+        return !1;
+      case Te.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function bt(e, t) {
+  return Ie((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function Cr(e, t) {
+  return bt(e, t);
+}
+function Sr(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = Je(t), o = R(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: i
+    } = window;
+    return new i(r);
+  }, [r, n]);
+  return A(() => () => o?.disconnect(), [o]), o;
+}
+function Qe(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = Je(t), o = R(
+    () => {
+      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 A(() => () => o?.disconnect(), [o]), o;
+}
+function Rr(e) {
+  return new vt(Pe(e), e);
+}
+function Kt(e, t, n) {
+  t === void 0 && (t = Rr);
+  const [r, o] = j(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 a = Sr({
+    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;
+          }
+        }
+    }
+  }), s = Qe({
+    callback: i
+  });
+  return ee(() => {
+    i(), e ? (s?.observe(e), a?.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (s?.disconnect(), a?.disconnect());
+  }, [e]), r;
+}
+function Er(e) {
+  const t = bt(e);
+  return en(e, t);
+}
+const Wt = [];
+function Ar(e) {
+  const t = E(e), n = Ie((r) => e ? r && r !== Wt && e && t.current && e.parentNode === t.current.parentNode ? r : gt(e) : Wt, [e]);
+  return A(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function Or(e) {
+  const [t, n] = j(null), r = E(e), o = B((i) => {
+    const a = it(i.target);
+    a && n((s) => s ? (s.set(a, lt(a)), new Map(s)) : null);
+  }, []);
+  return A(() => {
+    const i = r.current;
+    if (e !== i) {
+      a(i);
+      const s = e.map((l) => {
+        const c = it(l);
+        return c ? (c.addEventListener("scroll", o, {
+          passive: !0
+        }), [c, lt(c)]) : null;
+      }).filter((l) => l != null);
+      n(s.length ? new Map(s) : null), r.current = e;
+    }
+    return () => {
+      a(e), a(i);
+    };
+    function a(s) {
+      s.forEach((l) => {
+        const c = it(l);
+        c?.removeEventListener("scroll", o);
+      });
+    }
+  }, [o, e]), R(() => e.length ? t ? Array.from(t.values()).reduce((i, a) => ye(i, a), V) : ln(e) : V, [e, t]);
+}
+function Ut(e, t) {
+  t === void 0 && (t = []);
+  const n = E(null);
+  return A(
+    () => {
+      n.current = null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), A(() => {
+    const r = e !== V;
+    r && !n.current && (n.current = e), !r && n.current && (n.current = null);
+  }, [e]), n.current ? We(e, n.current) : V;
+}
+function Nr(e) {
+  A(
+    () => {
+      if (!qe)
+        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 Tr(e, t) {
+  return R(() => e.reduce((n, r) => {
+    let {
+      eventName: o,
+      handler: i
+    } = r;
+    return n[o] = (a) => {
+      i(a, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function hn(e) {
+  return R(() => e ? tr(e) : null, [e]);
+}
+const Ht = [];
+function Mr(e, t) {
+  t === void 0 && (t = Pe);
+  const [n] = e, r = hn(n ? F(n) : null), [o, i] = j(Ht);
+  function a() {
+    i(() => e.length ? e.map((l) => sn(l) ? r : new vt(t(l), l)) : Ht);
+  }
+  const s = Qe({
+    callback: a
+  });
+  return ee(() => {
+    s?.disconnect(), a(), e.forEach((l) => s?.observe(l));
+  }, [e]), o;
+}
+function gn(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return Le(t) ? t : e;
+}
+function Lr(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, r] = j(null), o = B((c) => {
+    for (const {
+      target: d
+    } of c)
+      if (Le(d)) {
+        r((u) => {
+          const h = t(d);
+          return u ? {
+            ...u,
+            width: h.width,
+            height: h.height
+          } : h;
+        });
+        break;
+      }
+  }, [t]), i = Qe({
+    callback: o
+  }), a = B((c) => {
+    const d = gn(c);
+    i?.disconnect(), d && i?.observe(d), r(d ? t(d) : null);
+  }, [t, i]), [s, l] = $e(a);
+  return R(() => ({
+    nodeRef: s,
+    rect: n,
+    setRef: l
+  }), [n, s, l]);
+}
+const Ir = [{
+  sensor: fn,
+  options: {}
+}, {
+  sensor: dn,
+  options: {}
+}], Pr = {
+  current: {}
+}, Ye = {
+  draggable: {
+    measure: Ft
+  },
+  droppable: {
+    measure: Ft,
+    strategy: Te.WhileDragging,
+    frequency: ut.Optimized
+  },
+  dragOverlay: {
+    measure: Pe
+  }
+};
+class Ae 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 kr = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new Ae(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: He
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: Ye,
+  measureDroppableContainers: He,
+  windowRect: null,
+  measuringScheduled: !1
+}, vn = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: He,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: He
+}, ke = /* @__PURE__ */ Me(vn), pn = /* @__PURE__ */ Me(kr);
+function zr() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new Ae()
+    }
+  };
+}
+function Br(e, t) {
+  switch (t.type) {
+    case M.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case M.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 M.DragEnd:
+    case M.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case M.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: r
+      } = n, o = new Ae(e.droppable.containers);
+      return o.set(r, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: o
+        }
+      };
+    }
+    case M.SetDroppableDisabled: {
+      const {
+        id: n,
+        key: r,
+        disabled: o
+      } = t, i = e.droppable.containers.get(n);
+      if (!i || r !== i.key)
+        return e;
+      const a = new Ae(e.droppable.containers);
+      return a.set(n, {
+        ...i,
+        disabled: o
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: a
+        }
+      };
+    }
+    case M.UnregisterDroppable: {
+      const {
+        id: n,
+        key: r
+      } = t, o = e.droppable.containers.get(n);
+      if (!o || r !== o.key)
+        return e;
+      const i = new Ae(e.droppable.containers);
+      return i.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function Fr(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: r,
+    draggableNodes: o
+  } = fe(ke), i = Ke(r), a = Ke(n?.id);
+  return A(() => {
+    if (!t && !r && i && a != null) {
+      if (!ht(i) || document.activeElement === i.target)
+        return;
+      const s = o.get(a);
+      if (!s)
+        return;
+      const {
+        activatorNode: l,
+        node: c
+      } = s;
+      if (!l.current && !c.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const d of [l.current, c.current]) {
+          if (!d)
+            continue;
+          const u = kn(d);
+          if (u) {
+            u.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [r, t, o, a, i]), null;
+}
+function bn(e, t) {
+  let {
+    transform: n,
+    ...r
+  } = t;
+  return e != null && e.length ? e.reduce((o, i) => i({
+    transform: o,
+    ...r
+  }), n) : n;
+}
+function jr(e) {
+  return R(
+    () => ({
+      draggable: {
+        ...Ye.draggable,
+        ...e?.draggable
+      },
+      droppable: {
+        ...Ye.droppable,
+        ...e?.droppable
+      },
+      dragOverlay: {
+        ...Ye.dragOverlay,
+        ...e?.dragOverlay
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e?.draggable, e?.droppable, e?.dragOverlay]
+  );
+}
+function Xr(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: r,
+    config: o = !0
+  } = e;
+  const i = E(!1), {
+    x: a,
+    y: s
+  } = typeof o == "boolean" ? {
+    x: o,
+    y: o
+  } : o;
+  ee(() => {
+    if (!a && !s || !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 = en(d, r);
+    if (a || (u.x = 0), s || (u.y = 0), i.current = !0, Math.abs(u.x) > 0 || Math.abs(u.y) > 0) {
+      const h = nn(c);
+      h && h.scrollBy({
+        top: u.y,
+        left: u.x
+      });
+    }
+  }, [t, a, s, r, n]);
+}
+const Ze = /* @__PURE__ */ Me({
+  ...V,
+  scaleX: 1,
+  scaleY: 1
+});
+var ae;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(ae || (ae = {}));
+const fo = /* @__PURE__ */ An(function(t) {
+  var n, r, o, i;
+  let {
+    id: a,
+    accessibility: s,
+    autoScroll: l = !0,
+    children: c,
+    sensors: d = Ir,
+    collisionDetection: u = Jn,
+    measuring: h,
+    modifiers: f,
+    ...D
+  } = t;
+  const g = On(Br, void 0, zr), [v, y] = g, [w, m] = Yn(), [L, C] = j(ae.Uninitialized), S = L === ae.Initialized, {
+    draggable: {
+      active: p,
+      nodes: b,
+      translate: O
+    },
+    droppable: {
+      containers: P
+    }
+  } = v, T = p != null ? b.get(p) : null, G = E({
+    initial: null,
+    translated: null
+  }), Q = R(() => {
+    var z;
+    return p != null ? {
+      id: p,
+      // It's possible for the active node to unmount while dragging
+      data: (z = T?.data) != null ? z : Pr,
+      rect: G
+    } : null;
+  }, [p, T]), te = E(null), [yt, mt] = j(null), [Z, wt] = j(null), le = Oe(D, Object.values(D)), _e = Ge("DndDescribedBy", a), Dt = R(() => P.getEnabled(), [P]), ce = jr(h), {
+    droppableRects: he,
+    measureDroppableContainers: ze,
+    measuringScheduled: xt
+  } = xr(Dt, {
+    dragging: S,
+    dependencies: [O.x, O.y],
+    config: ce.droppable
+  }), U = wr(b, p), Ct = R(() => Z ? Ue(Z) : null, [Z]), St = Rn(), Rt = Cr(U, ce.draggable.measure);
+  Xr({
+    activeNode: p != null ? b.get(p) : null,
+    config: St.layoutShiftCompensation,
+    initialRect: Rt,
+    measure: ce.draggable.measure
+  });
+  const H = Kt(U, ce.draggable.measure, Rt), et = Kt(U ? U.parentElement : null), ue = E({
+    activatorEvent: null,
+    active: null,
+    activeNode: U,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: he,
+    draggableNodes: b,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: P,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), Et = P.getNodeFor((n = ue.current.over) == null ? void 0 : n.id), de = Lr({
+    measure: ce.dragOverlay.measure
+  }), Be = (r = de.nodeRef.current) != null ? r : U, ge = S ? (o = de.rect) != null ? o : H : null, At = !!(de.nodeRef.current && de.rect), Ot = Er(At ? null : H), tt = hn(Be ? F(Be) : null), ne = Ar(S ? Et ?? U : null), Fe = Mr(ne), je = bn(f, {
+    transform: {
+      x: O.x - Ot.x,
+      y: O.y - Ot.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: Z,
+    active: Q,
+    activeNodeRect: H,
+    containerNodeRect: et,
+    draggingNodeRect: ge,
+    over: ue.current.over,
+    overlayNodeRect: de.rect,
+    scrollableAncestors: ne,
+    scrollableAncestorRects: Fe,
+    windowRect: tt
+  }), Nt = Ct ? ye(Ct, O) : null, Tt = Or(ne), yn = Ut(Tt), mn = Ut(Tt, [H]), ve = ye(je, yn), pe = ge ? Zn(ge, je) : null, De = Q && pe ? u({
+    active: Q,
+    collisionRect: pe,
+    droppableRects: he,
+    droppableContainers: Dt,
+    pointerCoordinates: Nt
+  }) : null, Mt = Vn(De, "id"), [re, Lt] = j(null), wn = At ? je : ye(je, mn), Dn = Gn(wn, (i = re?.rect) != null ? i : null, H), nt = E(null), It = B(
+    (z, X) => {
+      let {
+        sensor: Y,
+        options: oe
+      } = X;
+      if (te.current == null)
+        return;
+      const K = b.get(te.current);
+      if (!K)
+        return;
+      const $ = z.nativeEvent, q = new Y({
+        active: te.current,
+        activeNode: K,
+        event: $,
+        options: oe,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: ue,
+        onAbort(k) {
+          if (!b.get(k))
+            return;
+          const {
+            onDragAbort: J
+          } = le.current, _ = {
+            id: k
+          };
+          J?.(_), w({
+            type: "onDragAbort",
+            event: _
+          });
+        },
+        onPending(k, ie, J, _) {
+          if (!b.get(k))
+            return;
+          const {
+            onDragPending: Ce
+          } = le.current, se = {
+            id: k,
+            constraint: ie,
+            initialCoordinates: J,
+            offset: _
+          };
+          Ce?.(se), w({
+            type: "onDragPending",
+            event: se
+          });
+        },
+        onStart(k) {
+          const ie = te.current;
+          if (ie == null)
+            return;
+          const J = b.get(ie);
+          if (!J)
+            return;
+          const {
+            onDragStart: _
+          } = le.current, xe = {
+            activatorEvent: $,
+            active: {
+              id: ie,
+              data: J.data,
+              rect: G
+            }
+          };
+          Xe(() => {
+            _?.(xe), C(ae.Initializing), y({
+              type: M.DragStart,
+              initialCoordinates: k,
+              active: ie
+            }), w({
+              type: "onDragStart",
+              event: xe
+            }), mt(nt.current), wt($);
+          });
+        },
+        onMove(k) {
+          y({
+            type: M.DragMove,
+            coordinates: k
+          });
+        },
+        onEnd: be(M.DragEnd),
+        onCancel: be(M.DragCancel)
+      });
+      nt.current = q;
+      function be(k) {
+        return async function() {
+          const {
+            active: J,
+            collisions: _,
+            over: xe,
+            scrollAdjustedTranslate: Ce
+          } = ue.current;
+          let se = null;
+          if (J && Ce) {
+            const {
+              cancelDrop: Se
+            } = le.current;
+            se = {
+              activatorEvent: $,
+              active: J,
+              collisions: _,
+              delta: Ce,
+              over: xe
+            }, k === M.DragEnd && typeof Se == "function" && await Promise.resolve(Se(se)) && (k = M.DragCancel);
+          }
+          te.current = null, Xe(() => {
+            y({
+              type: k
+            }), C(ae.Uninitialized), Lt(null), mt(null), wt(null), nt.current = null;
+            const Se = k === M.DragEnd ? "onDragEnd" : "onDragCancel";
+            if (se) {
+              const rt = le.current[Se];
+              rt?.(se), w({
+                type: Se,
+                event: se
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [b]
+  ), xn = B((z, X) => (Y, oe) => {
+    const K = Y.nativeEvent, $ = b.get(oe);
+    if (
+      // Another sensor is already instantiating
+      te.current !== null || // No active draggable
+      !$ || // Event has already been captured
+      K.dndKit || K.defaultPrevented
+    )
+      return;
+    const q = {
+      active: $
+    };
+    z(Y, X.options, q) === !0 && (K.dndKit = {
+      capturedBy: X.sensor
+    }, te.current = oe, It(Y, X));
+  }, [b, It]), Pt = Dr(d, xn);
+  Nr(d), ee(() => {
+    H && L === ae.Initializing && C(ae.Initialized);
+  }, [H, L]), A(
+    () => {
+      const {
+        onDragMove: z
+      } = le.current, {
+        active: X,
+        activatorEvent: Y,
+        collisions: oe,
+        over: K
+      } = ue.current;
+      if (!X || !Y)
+        return;
+      const $ = {
+        active: X,
+        activatorEvent: Y,
+        collisions: oe,
+        delta: {
+          x: ve.x,
+          y: ve.y
+        },
+        over: K
+      };
+      Xe(() => {
+        z?.($), w({
+          type: "onDragMove",
+          event: $
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [ve.x, ve.y]
+  ), A(
+    () => {
+      const {
+        active: z,
+        activatorEvent: X,
+        collisions: Y,
+        droppableContainers: oe,
+        scrollAdjustedTranslate: K
+      } = ue.current;
+      if (!z || te.current == null || !X || !K)
+        return;
+      const {
+        onDragOver: $
+      } = le.current, q = oe.get(Mt), be = q && q.rect.current ? {
+        id: q.id,
+        rect: q.rect.current,
+        data: q.data,
+        disabled: q.disabled
+      } : null, k = {
+        active: z,
+        activatorEvent: X,
+        collisions: Y,
+        delta: {
+          x: K.x,
+          y: K.y
+        },
+        over: be
+      };
+      Xe(() => {
+        Lt(be), $?.(k), w({
+          type: "onDragOver",
+          event: k
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [Mt]
+  ), ee(() => {
+    ue.current = {
+      activatorEvent: Z,
+      active: Q,
+      activeNode: U,
+      collisionRect: pe,
+      collisions: De,
+      droppableRects: he,
+      draggableNodes: b,
+      draggingNode: Be,
+      draggingNodeRect: ge,
+      droppableContainers: P,
+      over: re,
+      scrollableAncestors: ne,
+      scrollAdjustedTranslate: ve
+    }, G.current = {
+      initial: ge,
+      translated: pe
+    };
+  }, [Q, U, De, pe, b, Be, ge, he, P, re, ne, ve]), br({
+    ...St,
+    delta: O,
+    draggingRect: pe,
+    pointerCoordinates: Nt,
+    scrollableAncestors: ne,
+    scrollableAncestorRects: Fe
+  });
+  const Cn = R(() => ({
+    active: Q,
+    activeNode: U,
+    activeNodeRect: H,
+    activatorEvent: Z,
+    collisions: De,
+    containerNodeRect: et,
+    dragOverlay: de,
+    draggableNodes: b,
+    droppableContainers: P,
+    droppableRects: he,
+    over: re,
+    measureDroppableContainers: ze,
+    scrollableAncestors: ne,
+    scrollableAncestorRects: Fe,
+    measuringConfiguration: ce,
+    measuringScheduled: xt,
+    windowRect: tt
+  }), [Q, U, H, Z, De, et, de, b, P, he, re, ze, ne, Fe, ce, xt, tt]), Sn = R(() => ({
+    activatorEvent: Z,
+    activators: Pt,
+    active: Q,
+    activeNodeRect: H,
+    ariaDescribedById: {
+      draggable: _e
+    },
+    dispatch: y,
+    draggableNodes: b,
+    over: re,
+    measureDroppableContainers: ze
+  }), [Z, Pt, Q, H, y, _e, b, re, ze]);
+  return N.createElement(Qt.Provider, {
+    value: m
+  }, N.createElement(ke.Provider, {
+    value: Sn
+  }, N.createElement(pn.Provider, {
+    value: Cn
+  }, N.createElement(Ze.Provider, {
+    value: Dn
+  }, c)), N.createElement(Fr, {
+    disabled: s?.restoreFocus === !1
+  })), N.createElement(Wn, {
+    ...s,
+    hiddenTextDescribedById: _e
+  }));
+  function Rn() {
+    const z = yt?.autoScrollEnabled === !1, X = typeof l == "object" ? l.enabled === !1 : l === !1, Y = S && !z && !X;
+    return typeof l == "object" ? {
+      ...l,
+      enabled: Y
+    } : {
+      enabled: Y
+    };
+  }
+}), Yr = /* @__PURE__ */ Me(null), Vt = "button", $r = "Draggable";
+function ho(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: r = !1,
+    attributes: o
+  } = e;
+  const i = Ge($r), {
+    activators: a,
+    activatorEvent: s,
+    active: l,
+    activeNodeRect: c,
+    ariaDescribedById: d,
+    draggableNodes: u,
+    over: h
+  } = fe(ke), {
+    role: f = Vt,
+    roleDescription: D = "draggable",
+    tabIndex: g = 0
+  } = o ?? {}, v = l?.id === t, y = fe(v ? Ze : Yr), [w, m] = $e(), [L, C] = $e(), S = Tr(a, t), p = Oe(n);
+  ee(
+    () => (u.set(t, {
+      id: t,
+      key: i,
+      node: w,
+      activatorNode: L,
+      data: p
+    }), () => {
+      const O = u.get(t);
+      O && O.key === i && u.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [u, t]
+  );
+  const b = R(() => ({
+    role: f,
+    tabIndex: g,
+    "aria-disabled": r,
+    "aria-pressed": v && f === Vt ? !0 : void 0,
+    "aria-roledescription": D,
+    "aria-describedby": d.draggable
+  }), [r, f, g, v, D, d.draggable]);
+  return {
+    active: l,
+    activatorEvent: s,
+    activeNodeRect: c,
+    attributes: b,
+    isDragging: v,
+    listeners: r ? void 0 : S,
+    node: w,
+    over: h,
+    setNodeRef: m,
+    setActivatorNodeRef: C,
+    transform: y
+  };
+}
+function Kr() {
+  return fe(pn);
+}
+const Wr = "Droppable", Ur = {
+  timeout: 25
+};
+function go(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: r,
+    resizeObserverConfig: o
+  } = e;
+  const i = Ge(Wr), {
+    active: a,
+    dispatch: s,
+    over: l,
+    measureDroppableContainers: c
+  } = fe(ke), d = E({
+    disabled: n
+  }), u = E(!1), h = E(null), f = E(null), {
+    disabled: D,
+    updateMeasurementsFor: g,
+    timeout: v
+  } = {
+    ...Ur,
+    ...o
+  }, y = Oe(g ?? r), w = B(
+    () => {
+      if (!u.current) {
+        u.current = !0;
+        return;
+      }
+      f.current != null && clearTimeout(f.current), f.current = setTimeout(() => {
+        c(Array.isArray(y.current) ? y.current : [y.current]), f.current = null;
+      }, v);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [v]
+  ), m = Qe({
+    callback: w,
+    disabled: D || !a
+  }), L = B((b, O) => {
+    m && (O && (m.unobserve(O), u.current = !1), b && m.observe(b));
+  }, [m]), [C, S] = $e(L), p = Oe(t);
+  return A(() => {
+    !m || !C.current || (m.disconnect(), u.current = !1, m.observe(C.current));
+  }, [C, m]), A(
+    () => (s({
+      type: M.RegisterDroppable,
+      element: {
+        id: r,
+        key: i,
+        disabled: n,
+        node: C,
+        rect: h,
+        data: p
+      }
+    }), () => s({
+      type: M.UnregisterDroppable,
+      key: i,
+      id: r
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), A(() => {
+    n !== d.current.disabled && (s({
+      type: M.SetDroppableDisabled,
+      id: r,
+      key: i,
+      disabled: n
+    }), d.current.disabled = n);
+  }, [r, i, n, s]), {
+    active: a,
+    rect: h,
+    isOver: l?.id === r,
+    node: C,
+    over: l,
+    setNodeRef: S
+  };
+}
+function Hr(e) {
+  let {
+    animation: t,
+    children: n
+  } = e;
+  const [r, o] = j(null), [i, a] = j(null), s = Ke(n);
+  return !n && !r && s && o(s), ee(() => {
+    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]), N.createElement(N.Fragment, null, n, r ? Nn(r, {
+    ref: a
+  }) : null);
+}
+const Vr = {
+  x: 0,
+  y: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+function qr(e) {
+  let {
+    children: t
+  } = e;
+  return N.createElement(ke.Provider, {
+    value: vn
+  }, N.createElement(Ze.Provider, {
+    value: Vr
+  }, t));
+}
+const Jr = {
+  position: "fixed",
+  touchAction: "none"
+}, Gr = (e) => ht(e) ? "transform 250ms ease" : void 0, Qr = /* @__PURE__ */ Tn((e, t) => {
+  let {
+    as: n,
+    activatorEvent: r,
+    adjustScale: o,
+    children: i,
+    className: a,
+    rect: s,
+    style: l,
+    transform: c,
+    transition: d = Gr
+  } = e;
+  if (!s)
+    return null;
+  const u = o ? c : {
+    ...c,
+    scaleX: 1,
+    scaleY: 1
+  }, h = {
+    ...Jr,
+    width: s.width,
+    height: s.height,
+    top: s.top,
+    left: s.left,
+    transform: Ne.Transform.toString(u),
+    transformOrigin: o && r ? Un(r, s) : void 0,
+    transition: typeof d == "function" ? d(r) : d,
+    ...l
+  };
+  return N.createElement(n, {
+    className: a,
+    style: h,
+    ref: t
+  }, i);
+}), Zr = (e) => (t) => {
+  let {
+    active: n,
+    dragOverlay: r
+  } = t;
+  const o = {}, {
+    styles: i,
+    className: a
+  } = e;
+  if (i != null && i.active)
+    for (const [s, l] of Object.entries(i.active))
+      l !== void 0 && (o[s] = n.node.style.getPropertyValue(s), n.node.style.setProperty(s, l));
+  if (i != null && i.dragOverlay)
+    for (const [s, l] of Object.entries(i.dragOverlay))
+      l !== void 0 && r.node.style.setProperty(s, l);
+  return a != null && a.active && n.node.classList.add(a.active), a != null && a.dragOverlay && r.node.classList.add(a.dragOverlay), function() {
+    for (const [l, c] of Object.entries(o))
+      n.node.style.setProperty(l, c);
+    a != null && a.active && n.node.classList.remove(a.active);
+  };
+}, _r = (e) => {
+  let {
+    transform: {
+      initial: t,
+      final: n
+    }
+  } = e;
+  return [{
+    transform: Ne.Transform.toString(t)
+  }, {
+    transform: Ne.Transform.toString(n)
+  }];
+}, eo = {
+  duration: 250,
+  easing: "ease",
+  keyframes: _r,
+  sideEffects: /* @__PURE__ */ Zr({
+    styles: {
+      active: {
+        opacity: "0"
+      }
+    }
+  })
+};
+function to(e) {
+  let {
+    config: t,
+    draggableNodes: n,
+    droppableContainers: r,
+    measuringConfiguration: o
+  } = e;
+  return Je((i, a) => {
+    if (t === null)
+      return;
+    const s = n.get(i);
+    if (!s)
+      return;
+    const l = s.node.current;
+    if (!l)
+      return;
+    const c = gn(a);
+    if (!c)
+      return;
+    const {
+      transform: d
+    } = F(a).getComputedStyle(a), u = tn(d);
+    if (!u)
+      return;
+    const h = typeof t == "function" ? t : no(t);
+    return cn(l, o.draggable.measure), h({
+      active: {
+        id: i,
+        data: s.data,
+        node: l,
+        rect: o.draggable.measure(l)
+      },
+      draggableNodes: n,
+      dragOverlay: {
+        node: a,
+        rect: o.dragOverlay.measure(c)
+      },
+      droppableContainers: r,
+      measuringConfiguration: o,
+      transform: u
+    });
+  });
+}
+function no(e) {
+  const {
+    duration: t,
+    easing: n,
+    sideEffects: r,
+    keyframes: o
+  } = {
+    ...eo,
+    ...e
+  };
+  return (i) => {
+    let {
+      active: a,
+      dragOverlay: s,
+      transform: l,
+      ...c
+    } = i;
+    if (!t)
+      return;
+    const d = {
+      x: s.rect.left - a.rect.left,
+      y: s.rect.top - a.rect.top
+    }, u = {
+      scaleX: l.scaleX !== 1 ? a.rect.width * l.scaleX / s.rect.width : 1,
+      scaleY: l.scaleY !== 1 ? a.rect.height * l.scaleY / s.rect.height : 1
+    }, h = {
+      x: l.x - d.x,
+      y: l.y - d.y,
+      ...u
+    }, f = o({
+      ...c,
+      active: a,
+      dragOverlay: s,
+      transform: {
+        initial: l,
+        final: h
+      }
+    }), [D] = f, g = f[f.length - 1];
+    if (JSON.stringify(D) === JSON.stringify(g))
+      return;
+    const v = r?.({
+      active: a,
+      dragOverlay: s,
+      ...c
+    }), y = s.node.animate(f, {
+      duration: t,
+      easing: n,
+      fill: "forwards"
+    });
+    return new Promise((w) => {
+      y.onfinish = () => {
+        v?.(), w();
+      };
+    });
+  };
+}
+let qt = 0;
+function ro(e) {
+  return R(() => {
+    if (e != null)
+      return qt++, qt;
+  }, [e]);
+}
+const vo = /* @__PURE__ */ N.memo((e) => {
+  let {
+    adjustScale: t = !1,
+    children: n,
+    dropAnimation: r,
+    style: o,
+    transition: i,
+    modifiers: a,
+    wrapperElement: s = "div",
+    className: l,
+    zIndex: c = 999
+  } = e;
+  const {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: h,
+    containerNodeRect: f,
+    draggableNodes: D,
+    droppableContainers: g,
+    dragOverlay: v,
+    over: y,
+    measuringConfiguration: w,
+    scrollableAncestors: m,
+    scrollableAncestorRects: L,
+    windowRect: C
+  } = Kr(), S = fe(Ze), p = ro(u?.id), b = bn(a, {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: h,
+    containerNodeRect: f,
+    draggingNodeRect: v.rect,
+    over: y,
+    overlayNodeRect: v.rect,
+    scrollableAncestors: m,
+    scrollableAncestorRects: L,
+    transform: S,
+    windowRect: C
+  }), O = bt(h), P = to({
+    config: r,
+    draggableNodes: D,
+    droppableContainers: g,
+    measuringConfiguration: w
+  }), T = O ? v.setRef : void 0;
+  return N.createElement(qr, null, N.createElement(Hr, {
+    animation: P
+  }, u && p ? N.createElement(Qr, {
+    key: p,
+    id: u.id,
+    ref: T,
+    as: s,
+    activatorEvent: d,
+    adjustScale: t,
+    className: l,
+    transition: i,
+    rect: O,
+    style: {
+      zIndex: c,
+      ...o
+    },
+    transform: b
+  }, n) : null));
+});
+export {
+  Ne as C,
+  fo as D,
+  x as K,
+  Te as M,
+  fn as P,
+  pr as T,
+  Kr as a,
+  Ge as b,
+  ee as c,
+  ho as d,
+  so as e,
+  uo as f,
+  Pe as g,
+  Vn as h,
+  ht as i,
+  gt as j,
+  lo as k,
+  ao as l,
+  co as m,
+  vo as n,
+  dn as o,
+  We as s,
+  go as u
+};
+//# sourceMappingURL=core.esm-CKGHpLM_.mjs.map