ezux 1.1.4 → 1.1.8

package/dist/EzContextMenu-OaCDOB5a.js

@@ -0,0 +1,3500 @@
+import * as R from "react";
+import P, { useRef as N, useState as X, useEffect as E, useMemo as M, useCallback as V, useLayoutEffect as mr, createContext as je, memo as br, useReducer as xr, useContext as we, cloneElement as yr, forwardRef as wr } from "react";
+import { defaultRangeExtractor as Cr, elementScroll as Sr, useVirtualizer as qt } from "@tanstack/react-virtual";
+import { u as dn, c as le } from "./useInitCoreServices-J1k9YgF4.js";
+import { Virtualizer as Rr, elementScroll as Dr } from "@tanstack/virtual-core";
+import { g as Er, x as Mr, R as Nr, A as Ar, P as Or, b as Le, e as fn, f as Tr, h as zr, S as Ir, I as Pr, i as Lr, G as kr, l as _r, u as Br, m as Fr, j as $r, k as Vr, L as jr, n as Ur, o as Xr, p as Gr, q as Yr, r as Kr, s as Wr, C as Hr } from "./EzErrorBoundary-H8HQBTwU.js";
+import { unstable_batchedUpdates as Qe, createPortal as qr } from "react-dom";
+import { jsx as p, jsxs as se, Fragment as et } from "react/jsx-runtime";
+class Jr {
+  name = "VirtualizationService";
+  // In a real implementation, we might store multiple virtualizer instances mapped by ID
+  virtualizers = /* @__PURE__ */ new Map();
+  /**
+   * Creates and registers a new virtualizer instance.
+   * @param id Unique identifier for the virtualizer.
+   * @param options Configuration for the virtualizer.
+   * @returns The newly created virtualizer instance.
+   * @group Methods
+   */
+  createVirtualizer(t, n) {
+    const r = new Rr({
+      count: n.count,
+      getScrollElement: n.getScrollElement,
+      estimateSize: n.estimateSize,
+      overscan: n.overscan ?? 5,
+      horizontal: n.horizontal ?? !1,
+      scrollToFn: Dr,
+      observeElementRect: (o, i) => {
+        const a = o.scrollElement;
+        if (!a || a === window) return;
+        const s = new ResizeObserver((c) => {
+          i(c[0].contentRect);
+        });
+        return s.observe(a), () => s.disconnect();
+      },
+      observeElementOffset: (o, i) => {
+        const a = o.scrollElement;
+        if (!a) return;
+        const s = () => {
+          i(a === window ? window.scrollY : a.scrollTop, !0);
+        };
+        return a.addEventListener("scroll", s, { passive: !0 }), i(a === window ? window.scrollY : a.scrollTop, !1), () => a.removeEventListener("scroll", s);
+      }
+    });
+    return this.virtualizers.set(t, r), r;
+  }
+  /**
+   * Registers an existing virtualizer instance with the service.
+   * @param id Unique identifier for the virtualizer.
+   * @param virtualizer The virtualizer instance to register.
+   * @group Methods
+   */
+  registerVirtualizer(t, n) {
+    this.virtualizers.set(t, n);
+  }
+  /**
+   * Retrieves a registered virtualizer instance by its ID.
+   * @group Methods
+   */
+  getVirtualizer(t) {
+    return this.virtualizers.get(t);
+  }
+  cleanup() {
+    this.virtualizers.clear();
+  }
+}
+const ss = (e) => {
+  const {
+    rowCount: t,
+    rowHeight: n = 48,
+    overscanCount: r = 5,
+    enableRowVirtualization: o = !0,
+    columnCount: i = 0,
+    columnWidth: a = 150,
+    enableColumnVirtualization: s = !1,
+    scrollMargin: c = 0,
+    scrollPaddingStart: l = 0,
+    scrollPaddingEnd: d = 0,
+    progressiveRendering: u = !1,
+    prefetchDistance: f = 5,
+    adaptiveSizing: h = !1,
+    languageDirection: S = "ltr",
+    debug: g = !1,
+    customRangeExtractor: v,
+    onScroll: x,
+    onScrollStart: w,
+    onScrollStop: y
+  } = e, z = N(null), [C, A] = X(u ? 1 : r || f), b = N(null), m = N(null), O = N(!1), L = "lanugageDirection";
+  E(() => {
+    if (!u) return;
+    let I;
+    const B = () => {
+      A(1), clearTimeout(I), I = setTimeout(() => {
+        A(r || f);
+      }, 150);
+    }, de = z.current;
+    if (de)
+      return de.addEventListener("scroll", B, { passive: !0 }), () => {
+        de.removeEventListener("scroll", B), clearTimeout(I);
+      };
+  }, [u, r, f]);
+  const T = M(() => v || ((I) => {
+    const B = Cr(I);
+    return B.length === 0 && I.count > 0 ? [0] : B;
+  }), [v]), H = V(
+    (I, B, de) => {
+      Sr(I, B, de);
+    },
+    []
+  ), Q = M(() => ({
+    count: t,
+    getScrollElement: () => z.current,
+    estimateSize: typeof n == "function" ? n : () => n,
+    overscan: C,
+    scrollMargin: c,
+    scrollPaddingStart: l,
+    scrollPaddingEnd: d,
+    rangeExtractor: T,
+    scrollToFn: H,
+    [L]: S,
+    onChange: (I) => {
+      const B = I.scrollOffset ?? 0;
+      m.current !== null && cancelAnimationFrame(m.current), m.current = requestAnimationFrame(() => {
+        x?.(B), m.current = null;
+      }), I.isScrolling ? O.current || (O.current = !0, w?.()) : O.current && (O.current = !1, y?.());
+    }
+  }), [
+    t,
+    n,
+    C,
+    h,
+    c,
+    l,
+    d,
+    T,
+    H,
+    x,
+    w,
+    y
+  ]), k = qt(Q);
+  E(() => {
+    g && console.log("[DEBUG_VIRTUAL] Virtualizer instance changed");
+  }, [k, g]);
+  const Ke = dn(), Ce = M(() => Er(
+    Ke,
+    "VirtualizationService",
+    () => new Jr()
+  ), []);
+  E(() => {
+    e.id && Ce && Ce.registerVirtualizer(e.id, k);
+  }, [e.id, k, Ce]);
+  const Z = M(() => ({
+    horizontal: !0,
+    count: s && i ? i : 0,
+    getScrollElement: () => z.current,
+    estimateSize: typeof a == "function" ? a : () => a,
+    overscan: C,
+    rangeExtractor: T,
+    [L]: S
+  }), [s, i, a, C, T]), We = qt(Z), ee = s && i ? We : void 0;
+  E(() => () => {
+    b.current && clearTimeout(b.current), m.current !== null && cancelAnimationFrame(m.current);
+  }, []), E(() => {
+    g && process.env.NODE_ENV !== "production" && console.log("Virtualization Debug:", {
+      rowCount: t,
+      visibleRows: k.getVirtualItems().length,
+      activeOverscan: C,
+      scrollOffset: k.scrollOffset
+    });
+  }, [g, t, k, C]);
+  const Se = (I, B) => {
+    k.scrollToIndex(I, B);
+  };
+  return {
+    parentRef: z,
+    rowVirtualizer: k,
+    columnVirtualizer: ee,
+    scrollToIndex: Se,
+    scrollToRow: Se,
+    scrollToColumn: ee ? (I, B) => {
+      ee.scrollToIndex(I, B);
+    } : void 0,
+    getVirtualItems: () => k.getVirtualItems(),
+    scrollOffset: k.scrollOffset ?? 0
+  };
+};
+function as() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return M(
+    () => (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 Ae(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 Nt(e) {
+  return "nodeType" in e;
+}
+function G(e) {
+  var t, n;
+  return e ? Ae(e) ? e : Nt(e) && (t = (n = e.ownerDocument) == null ? void 0 : n.defaultView) != null ? t : window : window;
+}
+function At(e) {
+  const {
+    Document: t
+  } = G(e);
+  return e instanceof t;
+}
+function Ue(e) {
+  return Ae(e) ? !1 : e instanceof G(e).HTMLElement;
+}
+function hn(e) {
+  return e instanceof G(e).SVGElement;
+}
+function Oe(e) {
+  return e ? Ae(e) ? e.document : Nt(e) ? At(e) ? e : Ue(e) || hn(e) ? e.ownerDocument : document : document : document;
+}
+const ce = ut ? mr : E;
+function dt(e) {
+  const t = N(e);
+  return ce(() => {
+    t.current = e;
+  }), V(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 Qr() {
+  const e = N(null), t = V((r, o) => {
+    e.current = setInterval(r, o);
+  }, []), n = V(() => {
+    e.current !== null && (clearInterval(e.current), e.current = null);
+  }, []);
+  return [t, n];
+}
+function Fe(e, t) {
+  t === void 0 && (t = [e]);
+  const n = N(e);
+  return ce(() => {
+    n.current !== e && (n.current = e);
+  }, t), n;
+}
+function Xe(e, t) {
+  const n = N();
+  return M(
+    () => {
+      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 = N(null), r = V(
+    (o) => {
+      o !== n.current && t?.(o, n.current), n.current = o;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [n, r];
+}
+function it(e) {
+  const t = N();
+  return E(() => {
+    t.current = e;
+  }, [e]), t.current;
+}
+let yt = {};
+function ft(e, t) {
+  return M(() => {
+    if (t)
+      return t;
+    const n = yt[e] == null ? 0 : yt[e] + 1;
+    return yt[e] = n, e + "-" + n;
+  }, [e, t]);
+}
+function gn(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 [c, l] of s) {
+        const d = i[c];
+        d != null && (i[c] = d + e * l);
+      }
+      return i;
+    }, {
+      ...t
+    });
+  };
+}
+const Ne = /* @__PURE__ */ gn(1), st = /* @__PURE__ */ gn(-1);
+function Zr(e) {
+  return "clientX" in e && "clientY" in e;
+}
+function Ot(e) {
+  if (!e)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = G(e.target);
+  return t && e instanceof t;
+}
+function eo(e) {
+  if (!e)
+    return !1;
+  const {
+    TouchEvent: t
+  } = G(e.target);
+  return t && e instanceof t;
+}
+function at(e) {
+  if (eo(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 Zr(e) ? {
+    x: e.clientX,
+    y: e.clientY
+  } : null;
+}
+const $e = /* @__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 [$e.Translate.toString(e), $e.Scale.toString(e)].join(" ");
+    }
+  },
+  Transition: {
+    toString(e) {
+      let {
+        property: t,
+        duration: n,
+        easing: r
+      } = e;
+      return t + " " + n + "ms " + r;
+    }
+  }
+}), Jt = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function to(e) {
+  return e.matches(Jt) ? e : e.querySelector(Jt);
+}
+const no = {
+  display: "none"
+};
+function ro(e) {
+  let {
+    id: t,
+    value: n
+  } = e;
+  return P.createElement("div", {
+    id: t,
+    style: no
+  }, n);
+}
+function oo(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 P.createElement("div", {
+    id: t,
+    style: o,
+    role: "status",
+    "aria-live": r,
+    "aria-atomic": !0
+  }, n);
+}
+function io() {
+  const [e, t] = X("");
+  return {
+    announce: V((r) => {
+      r != null && t(r);
+    }, []),
+    announcement: e
+  };
+}
+const pn = /* @__PURE__ */ je(null);
+function so(e) {
+  const t = we(pn);
+  E(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function ao() {
+  const [e] = X(() => /* @__PURE__ */ new Set()), t = V((r) => (e.add(r), () => e.delete(r)), [e]);
+  return [V((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 co = {
+  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.
+  `
+}, lo = {
+  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 uo(e) {
+  let {
+    announcements: t = lo,
+    container: n,
+    hiddenTextDescribedById: r,
+    screenReaderInstructions: o = co
+  } = e;
+  const {
+    announce: i,
+    announcement: a
+  } = io(), s = ft("DndLiveRegion"), [c, l] = X(!1);
+  if (E(() => {
+    l(!0);
+  }, []), so(M(() => ({
+    onDragStart(u) {
+      let {
+        active: f
+      } = u;
+      i(t.onDragStart({
+        active: f
+      }));
+    },
+    onDragMove(u) {
+      let {
+        active: f,
+        over: h
+      } = u;
+      t.onDragMove && i(t.onDragMove({
+        active: f,
+        over: h
+      }));
+    },
+    onDragOver(u) {
+      let {
+        active: f,
+        over: h
+      } = u;
+      i(t.onDragOver({
+        active: f,
+        over: h
+      }));
+    },
+    onDragEnd(u) {
+      let {
+        active: f,
+        over: h
+      } = u;
+      i(t.onDragEnd({
+        active: f,
+        over: h
+      }));
+    },
+    onDragCancel(u) {
+      let {
+        active: f,
+        over: h
+      } = u;
+      i(t.onDragCancel({
+        active: f,
+        over: h
+      }));
+    }
+  }), [i, t])), !c)
+    return null;
+  const d = P.createElement(P.Fragment, null, P.createElement(ro, {
+    id: r,
+    value: o.draggable
+  }), P.createElement(oo, {
+    id: s,
+    announcement: a
+  }));
+  return n ? qr(d, n) : d;
+}
+var _;
+(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";
+})(_ || (_ = {}));
+function ct() {
+}
+function cs(e, t) {
+  return M(
+    () => ({
+      sensor: e,
+      options: t ?? {}
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  );
+}
+function ls() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return M(
+    () => [...t].filter((r) => r != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const re = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function Tt(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function fo(e, t) {
+  const n = at(e);
+  if (!n)
+    return "0 0";
+  const r = {
+    x: (n.x - t.left) / t.width * 100,
+    y: (n.y - t.top) / t.height * 100
+  };
+  return r.x + "% " + r.y + "%";
+}
+function zt(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return n - r;
+}
+function ho(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return r - n;
+}
+function Rt(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 go(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return n[t];
+}
+function Qt(e, t, n) {
+  return t === void 0 && (t = e.left), n === void 0 && (n = e.top), {
+    x: t + e.width * 0.5,
+    y: n + e.height * 0.5
+  };
+}
+const us = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Qt(t, t.left, t.top), i = [];
+  for (const a of r) {
+    const {
+      id: s
+    } = a, c = n.get(s);
+    if (c) {
+      const l = Tt(Qt(c), o);
+      i.push({
+        id: s,
+        data: {
+          droppableContainer: a,
+          value: l
+        }
+      });
+    }
+  }
+  return i.sort(zt);
+}, ds = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Rt(t), i = [];
+  for (const a of r) {
+    const {
+      id: s
+    } = a, c = n.get(s);
+    if (c) {
+      const l = Rt(c), d = o.reduce((f, h, S) => f + Tt(l[S], h), 0), u = Number((d / 4).toFixed(4));
+      i.push({
+        id: s,
+        data: {
+          droppableContainer: a,
+          value: u
+        }
+      });
+    }
+  }
+  return i.sort(zt);
+};
+function po(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 c = t.width * t.height, l = e.width * e.height, d = a * s, u = d / (c + l - d);
+    return Number(u.toFixed(4));
+  }
+  return 0;
+}
+const vo = (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 c = po(s, t);
+      c > 0 && o.push({
+        id: a,
+        data: {
+          droppableContainer: i,
+          value: c
+        }
+      });
+    }
+  }
+  return o.sort(ho);
+};
+function mo(e, t) {
+  const {
+    top: n,
+    left: r,
+    bottom: o,
+    right: i
+  } = t;
+  return n <= e.y && e.y <= o && r <= e.x && e.x <= i;
+}
+const fs = (e) => {
+  let {
+    droppableContainers: t,
+    droppableRects: n,
+    pointerCoordinates: r
+  } = e;
+  if (!r)
+    return [];
+  const o = [];
+  for (const i of t) {
+    const {
+      id: a
+    } = i, s = n.get(a);
+    if (s && mo(r, s)) {
+      const l = Rt(s).reduce((u, f) => u + Tt(r, f), 0), d = Number((l / 4).toFixed(4));
+      o.push({
+        id: a,
+        data: {
+          droppableContainer: i,
+          value: d
+        }
+      });
+    }
+  }
+  return o.sort(zt);
+};
+function bo(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function vn(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : re;
+}
+function xo(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 yo = /* @__PURE__ */ xo(1);
+function mn(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 wo(e, t, n) {
+  const r = mn(t);
+  if (!r)
+    return e;
+  const {
+    scaleX: o,
+    scaleY: i,
+    x: a,
+    y: s
+  } = r, c = e.left - a - (1 - o) * parseFloat(n), l = 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: l,
+    right: c + d,
+    bottom: l + u,
+    left: c
+  };
+}
+const Co = {
+  ignoreTransform: !1
+};
+function Ge(e, t) {
+  t === void 0 && (t = Co);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: l,
+      transformOrigin: d
+    } = G(e).getComputedStyle(e);
+    l && (n = wo(n, l, d));
+  }
+  const {
+    top: r,
+    left: o,
+    width: i,
+    height: a,
+    bottom: s,
+    right: c
+  } = n;
+  return {
+    top: r,
+    left: o,
+    width: i,
+    height: a,
+    bottom: s,
+    right: c
+  };
+}
+function Zt(e) {
+  return Ge(e, {
+    ignoreTransform: !0
+  });
+}
+function So(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function Ro(e, t) {
+  return t === void 0 && (t = G(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Do(e, t) {
+  t === void 0 && (t = G(e).getComputedStyle(e));
+  const n = /(auto|scroll|overlay)/;
+  return ["overflow", "overflowX", "overflowY"].some((o) => {
+    const i = t[o];
+    return typeof i == "string" ? n.test(i) : !1;
+  });
+}
+function It(e, t) {
+  const n = [];
+  function r(o) {
+    if (t != null && n.length >= t || !o)
+      return n;
+    if (At(o) && o.scrollingElement != null && !n.includes(o.scrollingElement))
+      return n.push(o.scrollingElement), n;
+    if (!Ue(o) || hn(o) || n.includes(o))
+      return n;
+    const i = G(e).getComputedStyle(o);
+    return o !== e && Do(o, i) && n.push(o), Ro(o, i) ? n : r(o.parentNode);
+  }
+  return e ? r(e) : n;
+}
+function bn(e) {
+  const [t] = It(e, 1);
+  return t ?? null;
+}
+function wt(e) {
+  return !ut || !e ? null : Ae(e) ? e : Nt(e) ? At(e) || e === Oe(e).scrollingElement ? window : Ue(e) ? e : null : null;
+}
+function xn(e) {
+  return Ae(e) ? e.scrollX : e.scrollLeft;
+}
+function yn(e) {
+  return Ae(e) ? e.scrollY : e.scrollTop;
+}
+function Dt(e) {
+  return {
+    x: xn(e),
+    y: yn(e)
+  };
+}
+var F;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(F || (F = {}));
+function wn(e) {
+  return !ut || !e ? !1 : e === document.scrollingElement;
+}
+function Cn(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = wn(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 Eo = {
+  x: 0.2,
+  y: 0.2
+};
+function Mo(e, t, n, r, o) {
+  let {
+    top: i,
+    left: a,
+    right: s,
+    bottom: c
+  } = n;
+  r === void 0 && (r = 10), o === void 0 && (o = Eo);
+  const {
+    isTop: l,
+    isBottom: d,
+    isLeft: u,
+    isRight: f
+  } = Cn(e), h = {
+    x: 0,
+    y: 0
+  }, S = {
+    x: 0,
+    y: 0
+  }, g = {
+    height: t.height * o.y,
+    width: t.width * o.x
+  };
+  return !l && i <= t.top + g.height ? (h.y = F.Backward, S.y = r * Math.abs((t.top + g.height - i) / g.height)) : !d && c >= t.bottom - g.height && (h.y = F.Forward, S.y = r * Math.abs((t.bottom - g.height - c) / g.height)), !f && s >= t.right - g.width ? (h.x = F.Forward, S.x = r * Math.abs((t.right - g.width - s) / g.width)) : !u && a <= t.left + g.width && (h.x = F.Backward, S.x = r * Math.abs((t.left + g.width - a) / g.width)), {
+    direction: h,
+    speed: S
+  };
+}
+function No(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 Sn(e) {
+  return e.reduce((t, n) => Ne(t, Dt(n)), re);
+}
+function Ao(e) {
+  return e.reduce((t, n) => t + xn(n), 0);
+}
+function Oo(e) {
+  return e.reduce((t, n) => t + yn(n), 0);
+}
+function Rn(e, t) {
+  if (t === void 0 && (t = Ge), !e)
+    return;
+  const {
+    top: n,
+    left: r,
+    bottom: o,
+    right: i
+  } = t(e);
+  bn(e) && (o <= 0 || i <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const To = [["x", ["left", "right"], Ao], ["y", ["top", "bottom"], Oo]];
+class Pt {
+  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 = It(n), o = Sn(r);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [i, a, s] of To)
+      for (const c of a)
+        Object.defineProperty(this, c, {
+          get: () => {
+            const l = s(r), d = o[i] - l;
+            return this.rect[c] + d;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class ke {
+  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 zo(e) {
+  const {
+    EventTarget: t
+  } = G(e);
+  return e instanceof t ? e : Oe(e);
+}
+function Ct(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 J;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(J || (J = {}));
+function en(e) {
+  e.preventDefault();
+}
+function Io(e) {
+  e.stopPropagation();
+}
+var D;
+(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";
+})(D || (D = {}));
+const Dn = {
+  start: [D.Space, D.Enter],
+  cancel: [D.Esc],
+  end: [D.Space, D.Enter, D.Tab]
+}, Po = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case D.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case D.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case D.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case D.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class En {
+  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 ke(Oe(n)), this.windowListeners = new ke(G(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(J.Resize, this.handleCancel), this.windowListeners.add(J.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(J.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, r = t.node.current;
+    r && Rn(r), n(re);
+  }
+  handleKeyDown(t) {
+    if (Ot(t)) {
+      const {
+        active: n,
+        context: r,
+        options: o
+      } = this.props, {
+        keyboardCodes: i = Dn,
+        coordinateGetter: a = Po,
+        scrollBehavior: s = "smooth"
+      } = o, {
+        code: c
+      } = t;
+      if (i.end.includes(c)) {
+        this.handleEnd(t);
+        return;
+      }
+      if (i.cancel.includes(c)) {
+        this.handleCancel(t);
+        return;
+      }
+      const {
+        collisionRect: l
+      } = r.current, d = l ? {
+        x: l.left,
+        y: l.top
+      } : re;
+      this.referenceCoordinates || (this.referenceCoordinates = d);
+      const u = a(t, {
+        active: n,
+        context: r.current,
+        currentCoordinates: d
+      });
+      if (u) {
+        const f = st(u, d), h = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: S
+        } = r.current;
+        for (const g of S) {
+          const v = t.code, {
+            isTop: x,
+            isRight: w,
+            isLeft: y,
+            isBottom: z,
+            maxScroll: C,
+            minScroll: A
+          } = Cn(g), b = No(g), m = {
+            x: Math.min(v === D.Right ? b.right - b.width / 2 : b.right, Math.max(v === D.Right ? b.left : b.left + b.width / 2, u.x)),
+            y: Math.min(v === D.Down ? b.bottom - b.height / 2 : b.bottom, Math.max(v === D.Down ? b.top : b.top + b.height / 2, u.y))
+          }, O = v === D.Right && !w || v === D.Left && !y, L = v === D.Down && !z || v === D.Up && !x;
+          if (O && m.x !== u.x) {
+            const T = g.scrollLeft + f.x, H = v === D.Right && T <= C.x || v === D.Left && T >= A.x;
+            if (H && !f.y) {
+              g.scrollTo({
+                left: T,
+                behavior: s
+              });
+              return;
+            }
+            H ? h.x = g.scrollLeft - T : h.x = v === D.Right ? g.scrollLeft - C.x : g.scrollLeft - A.x, h.x && g.scrollBy({
+              left: -h.x,
+              behavior: s
+            });
+            break;
+          } else if (L && m.y !== u.y) {
+            const T = g.scrollTop + f.y, H = v === D.Down && T <= C.y || v === D.Up && T >= A.y;
+            if (H && !f.x) {
+              g.scrollTo({
+                top: T,
+                behavior: s
+              });
+              return;
+            }
+            H ? h.y = g.scrollTop - T : h.y = v === D.Down ? g.scrollTop - C.y : g.scrollTop - A.y, h.y && g.scrollBy({
+              top: -h.y,
+              behavior: s
+            });
+            break;
+          }
+        }
+        this.handleMove(t, Ne(st(u, this.referenceCoordinates), h));
+      }
+    }
+  }
+  handleMove(t, n) {
+    const {
+      onMove: r
+    } = this.props;
+    t.preventDefault(), r(n);
+  }
+  handleEnd(t) {
+    const {
+      onEnd: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  handleCancel(t) {
+    const {
+      onCancel: n
+    } = this.props;
+    t.preventDefault(), this.detach(), n();
+  }
+  detach() {
+    this.listeners.removeAll(), this.windowListeners.removeAll();
+  }
+}
+En.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: r = Dn,
+      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 tn(e) {
+  return !!(e && "distance" in e);
+}
+function nn(e) {
+  return !!(e && "delay" in e);
+}
+class Lt {
+  constructor(t, n, r) {
+    var o;
+    r === void 0 && (r = zo(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 = Oe(a), this.documentListeners = new ke(this.document), this.listeners = new ke(r), this.windowListeners = new ke(G(a)), this.initialCoordinates = (o = at(i)) != null ? o : re, 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(J.Resize, this.handleCancel), this.windowListeners.add(J.DragStart, en), this.windowListeners.add(J.VisibilityChange, this.handleCancel), this.windowListeners.add(J.ContextMenu, en), this.documentListeners.add(J.Keydown, this.handleKeydown), n) {
+      if (r != null && r({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (nn(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay), this.handlePending(n);
+        return;
+      }
+      if (tn(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(J.Click, Io, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(J.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 c = (n = at(t)) != null ? n : re, l = st(o, c);
+    if (!r && s) {
+      if (tn(s)) {
+        if (s.tolerance != null && Ct(l, s.tolerance))
+          return this.handleCancel();
+        if (Ct(l, s.distance))
+          return this.handleStart();
+      }
+      if (nn(s) && Ct(l, s.tolerance))
+        return this.handleCancel();
+      this.handlePending(s, l);
+      return;
+    }
+    t.cancelable && t.preventDefault(), a(c);
+  }
+  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 === D.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const Lo = {
+  cancel: {
+    name: "pointercancel"
+  },
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class Mn extends Lt {
+  constructor(t) {
+    const {
+      event: n
+    } = t, r = Oe(n.target);
+    super(t, Lo, r);
+  }
+}
+Mn.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 ko = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var Et;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(Et || (Et = {}));
+class _o extends Lt {
+  constructor(t) {
+    super(t, ko, Oe(t.event.target));
+  }
+}
+_o.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return n.button === Et.RightClick ? !1 : (r?.({
+      event: n
+    }), !0);
+  }
+}];
+const St = {
+  cancel: {
+    name: "touchcancel"
+  },
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class Bo extends Lt {
+  constructor(t) {
+    super(t, St);
+  }
+  static setup() {
+    return window.addEventListener(St.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(St.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+Bo.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 _e;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(_e || (_e = {}));
+var lt;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(lt || (lt = {}));
+function Fo(e) {
+  let {
+    acceleration: t,
+    activator: n = _e.Pointer,
+    canScroll: r,
+    draggingRect: o,
+    enabled: i,
+    interval: a = 5,
+    order: s = lt.TreeOrder,
+    pointerCoordinates: c,
+    scrollableAncestors: l,
+    scrollableAncestorRects: d,
+    delta: u,
+    threshold: f
+  } = e;
+  const h = Vo({
+    delta: u,
+    disabled: !i
+  }), [S, g] = Qr(), v = N({
+    x: 0,
+    y: 0
+  }), x = N({
+    x: 0,
+    y: 0
+  }), w = M(() => {
+    switch (n) {
+      case _e.Pointer:
+        return c ? {
+          top: c.y,
+          bottom: c.y,
+          left: c.x,
+          right: c.x
+        } : null;
+      case _e.DraggableRect:
+        return o;
+    }
+  }, [n, o, c]), y = N(null), z = V(() => {
+    const A = y.current;
+    if (!A)
+      return;
+    const b = v.current.x * x.current.x, m = v.current.y * x.current.y;
+    A.scrollBy(b, m);
+  }, []), C = M(() => s === lt.TreeOrder ? [...l].reverse() : l, [s, l]);
+  E(
+    () => {
+      if (!i || !l.length || !w) {
+        g();
+        return;
+      }
+      for (const A of C) {
+        if (r?.(A) === !1)
+          continue;
+        const b = l.indexOf(A), m = d[b];
+        if (!m)
+          continue;
+        const {
+          direction: O,
+          speed: L
+        } = Mo(A, m, w, t, f);
+        for (const T of ["x", "y"])
+          h[T][O[T]] || (L[T] = 0, O[T] = 0);
+        if (L.x > 0 || L.y > 0) {
+          g(), y.current = A, S(z, a), v.current = L, x.current = O;
+          return;
+        }
+      }
+      v.current = {
+        x: 0,
+        y: 0
+      }, x.current = {
+        x: 0,
+        y: 0
+      }, g();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      z,
+      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(h),
+      S,
+      l,
+      C,
+      d,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(f)
+    ]
+  );
+}
+const $o = {
+  x: {
+    [F.Backward]: !1,
+    [F.Forward]: !1
+  },
+  y: {
+    [F.Backward]: !1,
+    [F.Forward]: !1
+  }
+};
+function Vo(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const r = it(t);
+  return Xe((o) => {
+    if (n || !r || !o)
+      return $o;
+    const i = {
+      x: Math.sign(t.x - r.x),
+      y: Math.sign(t.y - r.y)
+    };
+    return {
+      x: {
+        [F.Backward]: o.x[F.Backward] || i.x === -1,
+        [F.Forward]: o.x[F.Forward] || i.x === 1
+      },
+      y: {
+        [F.Backward]: o.y[F.Backward] || i.y === -1,
+        [F.Forward]: o.y[F.Forward] || i.y === 1
+      }
+    };
+  }, [n, t, r]);
+}
+function jo(e, t) {
+  const n = t != null ? e.get(t) : void 0, r = n ? n.node.current : null;
+  return Xe((o) => {
+    var i;
+    return t == null ? null : (i = r ?? o) != null ? i : null;
+  }, [r, t]);
+}
+function Uo(e, t) {
+  return M(() => 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 Ve;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(Ve || (Ve = {}));
+var Mt;
+(function(e) {
+  e.Optimized = "optimized";
+})(Mt || (Mt = {}));
+const rn = /* @__PURE__ */ new Map();
+function Xo(e, t) {
+  let {
+    dragging: n,
+    dependencies: r,
+    config: o
+  } = t;
+  const [i, a] = X(null), {
+    frequency: s,
+    measure: c,
+    strategy: l
+  } = o, d = N(e), u = v(), f = Fe(u), h = V(function(x) {
+    x === void 0 && (x = []), !f.current && a((w) => w === null ? x : w.concat(x.filter((y) => !w.includes(y))));
+  }, [f]), S = N(null), g = Xe((x) => {
+    if (u && !n)
+      return rn;
+    if (!x || x === rn || d.current !== e || i != null) {
+      const w = /* @__PURE__ */ new Map();
+      for (let y of e) {
+        if (!y)
+          continue;
+        if (i && i.length > 0 && !i.includes(y.id) && y.rect.current) {
+          w.set(y.id, y.rect.current);
+          continue;
+        }
+        const z = y.node.current, C = z ? new Pt(c(z), z) : null;
+        y.rect.current = C, C && w.set(y.id, C);
+      }
+      return w;
+    }
+    return x;
+  }, [e, i, n, u, c]);
+  return E(() => {
+    d.current = e;
+  }, [e]), E(
+    () => {
+      u || h();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, u]
+  ), E(
+    () => {
+      i && i.length > 0 && a(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(i)]
+  ), E(
+    () => {
+      u || typeof s != "number" || S.current !== null || (S.current = setTimeout(() => {
+        h(), S.current = null;
+      }, s));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [s, u, h, ...r]
+  ), {
+    droppableRects: g,
+    measureDroppableContainers: h,
+    measuringScheduled: i != null
+  };
+  function v() {
+    switch (l) {
+      case Ve.Always:
+        return !1;
+      case Ve.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function kt(e, t) {
+  return Xe((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function Go(e, t) {
+  return kt(e, t);
+}
+function Yo(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = dt(t), o = M(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: i
+    } = window;
+    return new i(r);
+  }, [r, n]);
+  return E(() => () => o?.disconnect(), [o]), o;
+}
+function ht(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = dt(t), o = M(
+    () => {
+      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 E(() => () => o?.disconnect(), [o]), o;
+}
+function Ko(e) {
+  return new Pt(Ge(e), e);
+}
+function on(e, t, n) {
+  t === void 0 && (t = Ko);
+  const [r, o] = X(null);
+  function i() {
+    o((c) => {
+      if (!e)
+        return null;
+      if (e.isConnected === !1) {
+        var l;
+        return (l = c ?? n) != null ? l : null;
+      }
+      const d = t(e);
+      return JSON.stringify(c) === JSON.stringify(d) ? c : d;
+    });
+  }
+  const a = Yo({
+    callback(c) {
+      if (e)
+        for (const l of c) {
+          const {
+            type: d,
+            target: u
+          } = l;
+          if (d === "childList" && u instanceof HTMLElement && u.contains(e)) {
+            i();
+            break;
+          }
+        }
+    }
+  }), s = ht({
+    callback: i
+  });
+  return ce(() => {
+    i(), e ? (s?.observe(e), a?.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (s?.disconnect(), a?.disconnect());
+  }, [e]), r;
+}
+function Wo(e) {
+  const t = kt(e);
+  return vn(e, t);
+}
+const sn = [];
+function Ho(e) {
+  const t = N(e), n = Xe((r) => e ? r && r !== sn && e && t.current && e.parentNode === t.current.parentNode ? r : It(e) : sn, [e]);
+  return E(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function qo(e) {
+  const [t, n] = X(null), r = N(e), o = V((i) => {
+    const a = wt(i.target);
+    a && n((s) => s ? (s.set(a, Dt(a)), new Map(s)) : null);
+  }, []);
+  return E(() => {
+    const i = r.current;
+    if (e !== i) {
+      a(i);
+      const s = e.map((c) => {
+        const l = wt(c);
+        return l ? (l.addEventListener("scroll", o, {
+          passive: !0
+        }), [l, Dt(l)]) : null;
+      }).filter((c) => c != null);
+      n(s.length ? new Map(s) : null), r.current = e;
+    }
+    return () => {
+      a(e), a(i);
+    };
+    function a(s) {
+      s.forEach((c) => {
+        const l = wt(c);
+        l?.removeEventListener("scroll", o);
+      });
+    }
+  }, [o, e]), M(() => e.length ? t ? Array.from(t.values()).reduce((i, a) => Ne(i, a), re) : Sn(e) : re, [e, t]);
+}
+function an(e, t) {
+  t === void 0 && (t = []);
+  const n = N(null);
+  return E(
+    () => {
+      n.current = null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), E(() => {
+    const r = e !== re;
+    r && !n.current && (n.current = e), !r && n.current && (n.current = null);
+  }, [e]), n.current ? st(e, n.current) : re;
+}
+function Jo(e) {
+  E(
+    () => {
+      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 Qo(e, t) {
+  return M(() => e.reduce((n, r) => {
+    let {
+      eventName: o,
+      handler: i
+    } = r;
+    return n[o] = (a) => {
+      i(a, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function Nn(e) {
+  return M(() => e ? So(e) : null, [e]);
+}
+const cn = [];
+function Zo(e, t) {
+  t === void 0 && (t = Ge);
+  const [n] = e, r = Nn(n ? G(n) : null), [o, i] = X(cn);
+  function a() {
+    i(() => e.length ? e.map((c) => wn(c) ? r : new Pt(t(c), c)) : cn);
+  }
+  const s = ht({
+    callback: a
+  });
+  return ce(() => {
+    s?.disconnect(), a(), e.forEach((c) => s?.observe(c));
+  }, [e]), o;
+}
+function An(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return Ue(t) ? t : e;
+}
+function ei(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, r] = X(null), o = V((l) => {
+    for (const {
+      target: d
+    } of l)
+      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
+  }), a = V((l) => {
+    const d = An(l);
+    i?.disconnect(), d && i?.observe(d), r(d ? t(d) : null);
+  }, [t, i]), [s, c] = ot(a);
+  return M(() => ({
+    nodeRef: s,
+    rect: n,
+    setRef: c
+  }), [n, s, c]);
+}
+const ti = [{
+  sensor: Mn,
+  options: {}
+}, {
+  sensor: En,
+  options: {}
+}], ni = {
+  current: {}
+}, tt = {
+  draggable: {
+    measure: Zt
+  },
+  droppable: {
+    measure: Zt,
+    strategy: Ve.WhileDragging,
+    frequency: Mt.Optimized
+  },
+  dragOverlay: {
+    measure: Ge
+  }
+};
+class Be 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 ri = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new Be(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: ct
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: tt,
+  measureDroppableContainers: ct,
+  windowRect: null,
+  measuringScheduled: !1
+}, On = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: ct,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: ct
+}, Ye = /* @__PURE__ */ je(On), Tn = /* @__PURE__ */ je(ri);
+function oi() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new Be()
+    }
+  };
+}
+function ii(e, t) {
+  switch (t.type) {
+    case _.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case _.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 _.DragEnd:
+    case _.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case _.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: r
+      } = n, o = new Be(e.droppable.containers);
+      return o.set(r, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: o
+        }
+      };
+    }
+    case _.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 Be(e.droppable.containers);
+      return a.set(n, {
+        ...i,
+        disabled: o
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: a
+        }
+      };
+    }
+    case _.UnregisterDroppable: {
+      const {
+        id: n,
+        key: r
+      } = t, o = e.droppable.containers.get(n);
+      if (!o || r !== o.key)
+        return e;
+      const i = new Be(e.droppable.containers);
+      return i.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function si(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: r,
+    draggableNodes: o
+  } = we(Ye), i = it(r), a = it(n?.id);
+  return E(() => {
+    if (!t && !r && i && a != null) {
+      if (!Ot(i) || document.activeElement === i.target)
+        return;
+      const s = o.get(a);
+      if (!s)
+        return;
+      const {
+        activatorNode: c,
+        node: l
+      } = s;
+      if (!c.current && !l.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const d of [c.current, l.current]) {
+          if (!d)
+            continue;
+          const u = to(d);
+          if (u) {
+            u.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [r, t, o, a, i]), null;
+}
+function zn(e, t) {
+  let {
+    transform: n,
+    ...r
+  } = t;
+  return e != null && e.length ? e.reduce((o, i) => i({
+    transform: o,
+    ...r
+  }), n) : n;
+}
+function ai(e) {
+  return M(
+    () => ({
+      draggable: {
+        ...tt.draggable,
+        ...e?.draggable
+      },
+      droppable: {
+        ...tt.droppable,
+        ...e?.droppable
+      },
+      dragOverlay: {
+        ...tt.dragOverlay,
+        ...e?.dragOverlay
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e?.draggable, e?.droppable, e?.dragOverlay]
+  );
+}
+function ci(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: r,
+    config: o = !0
+  } = e;
+  const i = N(!1), {
+    x: a,
+    y: s
+  } = typeof o == "boolean" ? {
+    x: o,
+    y: o
+  } : o;
+  ce(() => {
+    if (!a && !s || !t) {
+      i.current = !1;
+      return;
+    }
+    if (i.current || !r)
+      return;
+    const l = t?.node.current;
+    if (!l || l.isConnected === !1)
+      return;
+    const d = n(l), u = vn(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 f = bn(l);
+      f && f.scrollBy({
+        top: u.y,
+        left: u.x
+      });
+    }
+  }, [t, a, s, r, n]);
+}
+const gt = /* @__PURE__ */ je({
+  ...re,
+  scaleX: 1,
+  scaleY: 1
+});
+var me;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(me || (me = {}));
+const hs = /* @__PURE__ */ br(function(t) {
+  var n, r, o, i;
+  let {
+    id: a,
+    accessibility: s,
+    autoScroll: c = !0,
+    children: l,
+    sensors: d = ti,
+    collisionDetection: u = vo,
+    measuring: f,
+    modifiers: h,
+    ...S
+  } = t;
+  const g = xr(ii, void 0, oi), [v, x] = g, [w, y] = ao(), [z, C] = X(me.Uninitialized), A = z === me.Initialized, {
+    draggable: {
+      active: b,
+      nodes: m,
+      translate: O
+    },
+    droppable: {
+      containers: L
+    }
+  } = v, T = b != null ? m.get(b) : null, H = N({
+    initial: null,
+    translated: null
+  }), Q = M(() => {
+    var j;
+    return b != null ? {
+      id: b,
+      // It's possible for the active node to unmount while dragging
+      data: (j = T?.data) != null ? j : ni,
+      rect: H
+    } : null;
+  }, [b, T]), k = N(null), [Ke, Ce] = X(null), [Z, We] = X(null), ee = Fe(S, Object.values(S)), Se = ft("DndDescribedBy", a), pt = M(() => L.getEnabled(), [L]), ue = ai(f), {
+    droppableRects: I,
+    measureDroppableContainers: B,
+    measuringScheduled: de
+  } = Xo(pt, {
+    dragging: A,
+    dependencies: [O.x, O.y],
+    config: ue.droppable
+  }), te = jo(m, b), Bt = M(() => Z ? at(Z) : null, [Z]), Ft = vr(), $t = Go(te, ue.draggable.measure);
+  ci({
+    activeNode: b != null ? m.get(b) : null,
+    config: Ft.layoutShiftCompensation,
+    initialRect: $t,
+    measure: ue.draggable.measure
+  });
+  const ne = on(te, ue.draggable.measure, $t), vt = on(te ? te.parentElement : null), be = N({
+    activatorEvent: null,
+    active: null,
+    activeNode: te,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: I,
+    draggableNodes: m,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: L,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), Vt = L.getNodeFor((n = be.current.over) == null ? void 0 : n.id), xe = ei({
+    measure: ue.dragOverlay.measure
+  }), He = (r = xe.nodeRef.current) != null ? r : te, Re = A ? (o = xe.rect) != null ? o : ne : null, jt = !!(xe.nodeRef.current && xe.rect), Ut = Wo(jt ? null : ne), mt = Nn(He ? G(He) : null), fe = Ho(A ? Vt ?? te : null), qe = Zo(fe), Je = zn(h, {
+    transform: {
+      x: O.x - Ut.x,
+      y: O.y - Ut.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: Z,
+    active: Q,
+    activeNodeRect: ne,
+    containerNodeRect: vt,
+    draggingNodeRect: Re,
+    over: be.current.over,
+    overlayNodeRect: xe.rect,
+    scrollableAncestors: fe,
+    scrollableAncestorRects: qe,
+    windowRect: mt
+  }), Xt = Bt ? Ne(Bt, O) : null, Gt = qo(fe), lr = an(Gt), ur = an(Gt, [ne]), De = Ne(Je, lr), Ee = Re ? yo(Re, Je) : null, Te = Q && Ee ? u({
+    active: Q,
+    collisionRect: Ee,
+    droppableRects: I,
+    droppableContainers: pt,
+    pointerCoordinates: Xt
+  }) : null, Yt = go(Te, "id"), [he, Kt] = X(null), dr = jt ? Je : Ne(Je, ur), fr = bo(dr, (i = he?.rect) != null ? i : null, ne), bt = N(null), Wt = V(
+    (j, Y) => {
+      let {
+        sensor: K,
+        options: ge
+      } = Y;
+      if (k.current == null)
+        return;
+      const q = m.get(k.current);
+      if (!q)
+        return;
+      const W = j.nativeEvent, oe = new K({
+        active: k.current,
+        activeNode: q,
+        event: W,
+        options: ge,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: be,
+        onAbort($) {
+          if (!m.get($))
+            return;
+          const {
+            onDragAbort: ie
+          } = ee.current, ae = {
+            id: $
+          };
+          ie?.(ae), w({
+            type: "onDragAbort",
+            event: ae
+          });
+        },
+        onPending($, pe, ie, ae) {
+          if (!m.get($))
+            return;
+          const {
+            onDragPending: Ie
+          } = ee.current, ve = {
+            id: $,
+            constraint: pe,
+            initialCoordinates: ie,
+            offset: ae
+          };
+          Ie?.(ve), w({
+            type: "onDragPending",
+            event: ve
+          });
+        },
+        onStart($) {
+          const pe = k.current;
+          if (pe == null)
+            return;
+          const ie = m.get(pe);
+          if (!ie)
+            return;
+          const {
+            onDragStart: ae
+          } = ee.current, ze = {
+            activatorEvent: W,
+            active: {
+              id: pe,
+              data: ie.data,
+              rect: H
+            }
+          };
+          Qe(() => {
+            ae?.(ze), C(me.Initializing), x({
+              type: _.DragStart,
+              initialCoordinates: $,
+              active: pe
+            }), w({
+              type: "onDragStart",
+              event: ze
+            }), Ce(bt.current), We(W);
+          });
+        },
+        onMove($) {
+          x({
+            type: _.DragMove,
+            coordinates: $
+          });
+        },
+        onEnd: Me(_.DragEnd),
+        onCancel: Me(_.DragCancel)
+      });
+      bt.current = oe;
+      function Me($) {
+        return async function() {
+          const {
+            active: ie,
+            collisions: ae,
+            over: ze,
+            scrollAdjustedTranslate: Ie
+          } = be.current;
+          let ve = null;
+          if (ie && Ie) {
+            const {
+              cancelDrop: Pe
+            } = ee.current;
+            ve = {
+              activatorEvent: W,
+              active: ie,
+              collisions: ae,
+              delta: Ie,
+              over: ze
+            }, $ === _.DragEnd && typeof Pe == "function" && await Promise.resolve(Pe(ve)) && ($ = _.DragCancel);
+          }
+          k.current = null, Qe(() => {
+            x({
+              type: $
+            }), C(me.Uninitialized), Kt(null), Ce(null), We(null), bt.current = null;
+            const Pe = $ === _.DragEnd ? "onDragEnd" : "onDragCancel";
+            if (ve) {
+              const xt = ee.current[Pe];
+              xt?.(ve), w({
+                type: Pe,
+                event: ve
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [m]
+  ), hr = V((j, Y) => (K, ge) => {
+    const q = K.nativeEvent, W = m.get(ge);
+    if (
+      // Another sensor is already instantiating
+      k.current !== null || // No active draggable
+      !W || // Event has already been captured
+      q.dndKit || q.defaultPrevented
+    )
+      return;
+    const oe = {
+      active: W
+    };
+    j(K, Y.options, oe) === !0 && (q.dndKit = {
+      capturedBy: Y.sensor
+    }, k.current = ge, Wt(K, Y));
+  }, [m, Wt]), Ht = Uo(d, hr);
+  Jo(d), ce(() => {
+    ne && z === me.Initializing && C(me.Initialized);
+  }, [ne, z]), E(
+    () => {
+      const {
+        onDragMove: j
+      } = ee.current, {
+        active: Y,
+        activatorEvent: K,
+        collisions: ge,
+        over: q
+      } = be.current;
+      if (!Y || !K)
+        return;
+      const W = {
+        active: Y,
+        activatorEvent: K,
+        collisions: ge,
+        delta: {
+          x: De.x,
+          y: De.y
+        },
+        over: q
+      };
+      Qe(() => {
+        j?.(W), w({
+          type: "onDragMove",
+          event: W
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [De.x, De.y]
+  ), E(
+    () => {
+      const {
+        active: j,
+        activatorEvent: Y,
+        collisions: K,
+        droppableContainers: ge,
+        scrollAdjustedTranslate: q
+      } = be.current;
+      if (!j || k.current == null || !Y || !q)
+        return;
+      const {
+        onDragOver: W
+      } = ee.current, oe = ge.get(Yt), Me = oe && oe.rect.current ? {
+        id: oe.id,
+        rect: oe.rect.current,
+        data: oe.data,
+        disabled: oe.disabled
+      } : null, $ = {
+        active: j,
+        activatorEvent: Y,
+        collisions: K,
+        delta: {
+          x: q.x,
+          y: q.y
+        },
+        over: Me
+      };
+      Qe(() => {
+        Kt(Me), W?.($), w({
+          type: "onDragOver",
+          event: $
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [Yt]
+  ), ce(() => {
+    be.current = {
+      activatorEvent: Z,
+      active: Q,
+      activeNode: te,
+      collisionRect: Ee,
+      collisions: Te,
+      droppableRects: I,
+      draggableNodes: m,
+      draggingNode: He,
+      draggingNodeRect: Re,
+      droppableContainers: L,
+      over: he,
+      scrollableAncestors: fe,
+      scrollAdjustedTranslate: De
+    }, H.current = {
+      initial: Re,
+      translated: Ee
+    };
+  }, [Q, te, Te, Ee, m, He, Re, I, L, he, fe, De]), Fo({
+    ...Ft,
+    delta: O,
+    draggingRect: Ee,
+    pointerCoordinates: Xt,
+    scrollableAncestors: fe,
+    scrollableAncestorRects: qe
+  });
+  const gr = M(() => ({
+    active: Q,
+    activeNode: te,
+    activeNodeRect: ne,
+    activatorEvent: Z,
+    collisions: Te,
+    containerNodeRect: vt,
+    dragOverlay: xe,
+    draggableNodes: m,
+    droppableContainers: L,
+    droppableRects: I,
+    over: he,
+    measureDroppableContainers: B,
+    scrollableAncestors: fe,
+    scrollableAncestorRects: qe,
+    measuringConfiguration: ue,
+    measuringScheduled: de,
+    windowRect: mt
+  }), [Q, te, ne, Z, Te, vt, xe, m, L, I, he, B, fe, qe, ue, de, mt]), pr = M(() => ({
+    activatorEvent: Z,
+    activators: Ht,
+    active: Q,
+    activeNodeRect: ne,
+    ariaDescribedById: {
+      draggable: Se
+    },
+    dispatch: x,
+    draggableNodes: m,
+    over: he,
+    measureDroppableContainers: B
+  }), [Z, Ht, Q, ne, x, Se, m, he, B]);
+  return P.createElement(pn.Provider, {
+    value: y
+  }, P.createElement(Ye.Provider, {
+    value: pr
+  }, P.createElement(Tn.Provider, {
+    value: gr
+  }, P.createElement(gt.Provider, {
+    value: fr
+  }, l)), P.createElement(si, {
+    disabled: s?.restoreFocus === !1
+  })), P.createElement(uo, {
+    ...s,
+    hiddenTextDescribedById: Se
+  }));
+  function vr() {
+    const j = Ke?.autoScrollEnabled === !1, Y = typeof c == "object" ? c.enabled === !1 : c === !1, K = A && !j && !Y;
+    return typeof c == "object" ? {
+      ...c,
+      enabled: K
+    } : {
+      enabled: K
+    };
+  }
+}), li = /* @__PURE__ */ je(null), ln = "button", ui = "Draggable";
+function gs(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: r = !1,
+    attributes: o
+  } = e;
+  const i = ft(ui), {
+    activators: a,
+    activatorEvent: s,
+    active: c,
+    activeNodeRect: l,
+    ariaDescribedById: d,
+    draggableNodes: u,
+    over: f
+  } = we(Ye), {
+    role: h = ln,
+    roleDescription: S = "draggable",
+    tabIndex: g = 0
+  } = o ?? {}, v = c?.id === t, x = we(v ? gt : li), [w, y] = ot(), [z, C] = ot(), A = Qo(a, t), b = Fe(n);
+  ce(
+    () => (u.set(t, {
+      id: t,
+      key: i,
+      node: w,
+      activatorNode: z,
+      data: b
+    }), () => {
+      const O = u.get(t);
+      O && O.key === i && u.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [u, t]
+  );
+  const m = M(() => ({
+    role: h,
+    tabIndex: g,
+    "aria-disabled": r,
+    "aria-pressed": v && h === ln ? !0 : void 0,
+    "aria-roledescription": S,
+    "aria-describedby": d.draggable
+  }), [r, h, g, v, S, d.draggable]);
+  return {
+    active: c,
+    activatorEvent: s,
+    activeNodeRect: l,
+    attributes: m,
+    isDragging: v,
+    listeners: r ? void 0 : A,
+    node: w,
+    over: f,
+    setNodeRef: y,
+    setActivatorNodeRef: C,
+    transform: x
+  };
+}
+function di() {
+  return we(Tn);
+}
+const fi = "Droppable", hi = {
+  timeout: 25
+};
+function ps(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: r,
+    resizeObserverConfig: o
+  } = e;
+  const i = ft(fi), {
+    active: a,
+    dispatch: s,
+    over: c,
+    measureDroppableContainers: l
+  } = we(Ye), d = N({
+    disabled: n
+  }), u = N(!1), f = N(null), h = N(null), {
+    disabled: S,
+    updateMeasurementsFor: g,
+    timeout: v
+  } = {
+    ...hi,
+    ...o
+  }, x = Fe(g ?? r), w = V(
+    () => {
+      if (!u.current) {
+        u.current = !0;
+        return;
+      }
+      h.current != null && clearTimeout(h.current), h.current = setTimeout(() => {
+        l(Array.isArray(x.current) ? x.current : [x.current]), h.current = null;
+      }, v);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [v]
+  ), y = ht({
+    callback: w,
+    disabled: S || !a
+  }), z = V((m, O) => {
+    y && (O && (y.unobserve(O), u.current = !1), m && y.observe(m));
+  }, [y]), [C, A] = ot(z), b = Fe(t);
+  return E(() => {
+    !y || !C.current || (y.disconnect(), u.current = !1, y.observe(C.current));
+  }, [C, y]), E(
+    () => (s({
+      type: _.RegisterDroppable,
+      element: {
+        id: r,
+        key: i,
+        disabled: n,
+        node: C,
+        rect: f,
+        data: b
+      }
+    }), () => s({
+      type: _.UnregisterDroppable,
+      key: i,
+      id: r
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), E(() => {
+    n !== d.current.disabled && (s({
+      type: _.SetDroppableDisabled,
+      id: r,
+      key: i,
+      disabled: n
+    }), d.current.disabled = n);
+  }, [r, i, n, s]), {
+    active: a,
+    rect: f,
+    isOver: c?.id === r,
+    node: C,
+    over: c,
+    setNodeRef: A
+  };
+}
+function gi(e) {
+  let {
+    animation: t,
+    children: n
+  } = e;
+  const [r, o] = X(null), [i, a] = X(null), s = it(n);
+  return !n && !r && s && o(s), ce(() => {
+    if (!i)
+      return;
+    const c = r?.key, l = r?.props.id;
+    if (c == null || l == null) {
+      o(null);
+      return;
+    }
+    Promise.resolve(t(l, i)).then(() => {
+      o(null);
+    });
+  }, [t, r, i]), P.createElement(P.Fragment, null, n, r ? yr(r, {
+    ref: a
+  }) : null);
+}
+const pi = {
+  x: 0,
+  y: 0,
+  scaleX: 1,
+  scaleY: 1
+};
+function vi(e) {
+  let {
+    children: t
+  } = e;
+  return P.createElement(Ye.Provider, {
+    value: On
+  }, P.createElement(gt.Provider, {
+    value: pi
+  }, t));
+}
+const mi = {
+  position: "fixed",
+  touchAction: "none"
+}, bi = (e) => Ot(e) ? "transform 250ms ease" : void 0, xi = /* @__PURE__ */ wr((e, t) => {
+  let {
+    as: n,
+    activatorEvent: r,
+    adjustScale: o,
+    children: i,
+    className: a,
+    rect: s,
+    style: c,
+    transform: l,
+    transition: d = bi
+  } = e;
+  if (!s)
+    return null;
+  const u = o ? l : {
+    ...l,
+    scaleX: 1,
+    scaleY: 1
+  }, f = {
+    ...mi,
+    width: s.width,
+    height: s.height,
+    top: s.top,
+    left: s.left,
+    transform: $e.Transform.toString(u),
+    transformOrigin: o && r ? fo(r, s) : void 0,
+    transition: typeof d == "function" ? d(r) : d,
+    ...c
+  };
+  return P.createElement(n, {
+    className: a,
+    style: f,
+    ref: t
+  }, i);
+}), yi = (e) => (t) => {
+  let {
+    active: n,
+    dragOverlay: r
+  } = t;
+  const o = {}, {
+    styles: i,
+    className: a
+  } = e;
+  if (i != null && i.active)
+    for (const [s, c] of Object.entries(i.active))
+      c !== void 0 && (o[s] = n.node.style.getPropertyValue(s), n.node.style.setProperty(s, c));
+  if (i != null && i.dragOverlay)
+    for (const [s, c] of Object.entries(i.dragOverlay))
+      c !== void 0 && r.node.style.setProperty(s, c);
+  return a != null && a.active && n.node.classList.add(a.active), a != null && a.dragOverlay && r.node.classList.add(a.dragOverlay), function() {
+    for (const [c, l] of Object.entries(o))
+      n.node.style.setProperty(c, l);
+    a != null && a.active && n.node.classList.remove(a.active);
+  };
+}, wi = (e) => {
+  let {
+    transform: {
+      initial: t,
+      final: n
+    }
+  } = e;
+  return [{
+    transform: $e.Transform.toString(t)
+  }, {
+    transform: $e.Transform.toString(n)
+  }];
+}, Ci = {
+  duration: 250,
+  easing: "ease",
+  keyframes: wi,
+  sideEffects: /* @__PURE__ */ yi({
+    styles: {
+      active: {
+        opacity: "0"
+      }
+    }
+  })
+};
+function Si(e) {
+  let {
+    config: t,
+    draggableNodes: n,
+    droppableContainers: r,
+    measuringConfiguration: o
+  } = e;
+  return dt((i, a) => {
+    if (t === null)
+      return;
+    const s = n.get(i);
+    if (!s)
+      return;
+    const c = s.node.current;
+    if (!c)
+      return;
+    const l = An(a);
+    if (!l)
+      return;
+    const {
+      transform: d
+    } = G(a).getComputedStyle(a), u = mn(d);
+    if (!u)
+      return;
+    const f = typeof t == "function" ? t : Ri(t);
+    return Rn(c, o.draggable.measure), f({
+      active: {
+        id: i,
+        data: s.data,
+        node: c,
+        rect: o.draggable.measure(c)
+      },
+      draggableNodes: n,
+      dragOverlay: {
+        node: a,
+        rect: o.dragOverlay.measure(l)
+      },
+      droppableContainers: r,
+      measuringConfiguration: o,
+      transform: u
+    });
+  });
+}
+function Ri(e) {
+  const {
+    duration: t,
+    easing: n,
+    sideEffects: r,
+    keyframes: o
+  } = {
+    ...Ci,
+    ...e
+  };
+  return (i) => {
+    let {
+      active: a,
+      dragOverlay: s,
+      transform: c,
+      ...l
+    } = i;
+    if (!t)
+      return;
+    const d = {
+      x: s.rect.left - a.rect.left,
+      y: s.rect.top - a.rect.top
+    }, u = {
+      scaleX: c.scaleX !== 1 ? a.rect.width * c.scaleX / s.rect.width : 1,
+      scaleY: c.scaleY !== 1 ? a.rect.height * c.scaleY / s.rect.height : 1
+    }, f = {
+      x: c.x - d.x,
+      y: c.y - d.y,
+      ...u
+    }, h = o({
+      ...l,
+      active: a,
+      dragOverlay: s,
+      transform: {
+        initial: c,
+        final: f
+      }
+    }), [S] = h, g = h[h.length - 1];
+    if (JSON.stringify(S) === JSON.stringify(g))
+      return;
+    const v = r?.({
+      active: a,
+      dragOverlay: s,
+      ...l
+    }), x = s.node.animate(h, {
+      duration: t,
+      easing: n,
+      fill: "forwards"
+    });
+    return new Promise((w) => {
+      x.onfinish = () => {
+        v?.(), w();
+      };
+    });
+  };
+}
+let un = 0;
+function Di(e) {
+  return M(() => {
+    if (e != null)
+      return un++, un;
+  }, [e]);
+}
+const vs = /* @__PURE__ */ P.memo((e) => {
+  let {
+    adjustScale: t = !1,
+    children: n,
+    dropAnimation: r,
+    style: o,
+    transition: i,
+    modifiers: a,
+    wrapperElement: s = "div",
+    className: c,
+    zIndex: l = 999
+  } = e;
+  const {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: f,
+    containerNodeRect: h,
+    draggableNodes: S,
+    droppableContainers: g,
+    dragOverlay: v,
+    over: x,
+    measuringConfiguration: w,
+    scrollableAncestors: y,
+    scrollableAncestorRects: z,
+    windowRect: C
+  } = di(), A = we(gt), b = Di(u?.id), m = zn(a, {
+    activatorEvent: d,
+    active: u,
+    activeNodeRect: f,
+    containerNodeRect: h,
+    draggingNodeRect: v.rect,
+    over: x,
+    overlayNodeRect: v.rect,
+    scrollableAncestors: y,
+    scrollableAncestorRects: z,
+    transform: A,
+    windowRect: C
+  }), O = kt(f), L = Si({
+    config: r,
+    draggableNodes: S,
+    droppableContainers: g,
+    measuringConfiguration: w
+  }), T = O ? v.setRef : void 0;
+  return P.createElement(vi, null, P.createElement(gi, {
+    animation: L
+  }, u && b ? P.createElement(xi, {
+    key: b,
+    id: u.id,
+    ref: T,
+    as: s,
+    activatorEvent: d,
+    adjustScale: t,
+    className: c,
+    transition: i,
+    rect: O,
+    style: {
+      zIndex: l,
+      ...o
+    },
+    transform: m
+  }, n) : null));
+});
+var _t = "ContextMenu", [Ei] = Lr(_t, [
+  fn
+]), U = fn(), [Mi, In] = Ei(_t), Pn = (e) => {
+  const { __scopeContextMenu: t, children: n, onOpenChange: r, dir: o, modal: i = !0 } = e, [a, s] = R.useState(!1), c = U(t), l = Mr(r), d = R.useCallback(
+    (u) => {
+      s(u), l(u);
+    },
+    [l]
+  );
+  return /* @__PURE__ */ p(
+    Mi,
+    {
+      scope: t,
+      open: a,
+      onOpenChange: d,
+      modal: i,
+      children: /* @__PURE__ */ p(
+        Nr,
+        {
+          ...c,
+          dir: o,
+          open: a,
+          onOpenChange: d,
+          modal: i,
+          children: n
+        }
+      )
+    }
+  );
+};
+Pn.displayName = _t;
+var Ln = "ContextMenuTrigger", kn = R.forwardRef(
+  (e, t) => {
+    const { __scopeContextMenu: n, disabled: r = !1, ...o } = e, i = In(Ln, n), a = U(n), s = R.useRef({ x: 0, y: 0 }), c = R.useRef({
+      getBoundingClientRect: () => DOMRect.fromRect({ width: 0, height: 0, ...s.current })
+    }), l = R.useRef(0), d = R.useCallback(
+      () => window.clearTimeout(l.current),
+      []
+    ), u = (f) => {
+      s.current = { x: f.clientX, y: f.clientY }, i.onOpenChange(!0);
+    };
+    return R.useEffect(() => d, [d]), R.useEffect(() => {
+      r && d();
+    }, [r, d]), /* @__PURE__ */ se(et, { children: [
+      /* @__PURE__ */ p(Ar, { ...a, virtualRef: c }),
+      /* @__PURE__ */ p(
+        Or.span,
+        {
+          "data-state": i.open ? "open" : "closed",
+          "data-disabled": r ? "" : void 0,
+          ...o,
+          ref: t,
+          style: { WebkitTouchCallout: "none", ...e.style },
+          onContextMenu: r ? e.onContextMenu : Le(e.onContextMenu, (f) => {
+            d(), u(f), f.preventDefault();
+          }),
+          onPointerDown: r ? e.onPointerDown : Le(
+            e.onPointerDown,
+            Ze((f) => {
+              d(), l.current = window.setTimeout(() => u(f), 700);
+            })
+          ),
+          onPointerMove: r ? e.onPointerMove : Le(e.onPointerMove, Ze(d)),
+          onPointerCancel: r ? e.onPointerCancel : Le(e.onPointerCancel, Ze(d)),
+          onPointerUp: r ? e.onPointerUp : Le(e.onPointerUp, Ze(d))
+        }
+      )
+    ] });
+  }
+);
+kn.displayName = Ln;
+var Ni = "ContextMenuPortal", _n = (e) => {
+  const { __scopeContextMenu: t, ...n } = e, r = U(t);
+  return /* @__PURE__ */ p(Tr, { ...r, ...n });
+};
+_n.displayName = Ni;
+var Bn = "ContextMenuContent", Fn = R.forwardRef(
+  (e, t) => {
+    const { __scopeContextMenu: n, ...r } = e, o = In(Bn, n), i = U(n), a = R.useRef(!1);
+    return /* @__PURE__ */ p(
+      zr,
+      {
+        ...i,
+        ...r,
+        ref: t,
+        side: "right",
+        sideOffset: 2,
+        align: "start",
+        onCloseAutoFocus: (s) => {
+          e.onCloseAutoFocus?.(s), !s.defaultPrevented && a.current && s.preventDefault(), a.current = !1;
+        },
+        onInteractOutside: (s) => {
+          e.onInteractOutside?.(s), !s.defaultPrevented && !o.modal && (a.current = !0);
+        },
+        style: {
+          ...e.style,
+          "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+          "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+          "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+          "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+          "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+        }
+      }
+    );
+  }
+);
+Fn.displayName = Bn;
+var Ai = "ContextMenuGroup", $n = R.forwardRef(
+  (e, t) => {
+    const { __scopeContextMenu: n, ...r } = e, o = U(n);
+    return /* @__PURE__ */ p(kr, { ...o, ...r, ref: t });
+  }
+);
+$n.displayName = Ai;
+var Oi = "ContextMenuLabel", Vn = R.forwardRef(
+  (e, t) => {
+    const { __scopeContextMenu: n, ...r } = e, o = U(n);
+    return /* @__PURE__ */ p(jr, { ...o, ...r, ref: t });
+  }
+);
+Vn.displayName = Oi;
+var Ti = "ContextMenuItem", jn = R.forwardRef(
+  (e, t) => {
+    const { __scopeContextMenu: n, ...r } = e, o = U(n);
+    return /* @__PURE__ */ p(Pr, { ...o, ...r, ref: t });
+  }
+);
+jn.displayName = Ti;
+var zi = "ContextMenuCheckboxItem", Un = R.forwardRef((e, t) => {
+  const { __scopeContextMenu: n, ...r } = e, o = U(n);
+  return /* @__PURE__ */ p($r, { ...o, ...r, ref: t });
+});
+Un.displayName = zi;
+var Ii = "ContextMenuRadioGroup", Xn = R.forwardRef((e, t) => {
+  const { __scopeContextMenu: n, ...r } = e, o = U(n);
+  return /* @__PURE__ */ p(_r, { ...o, ...r, ref: t });
+});
+Xn.displayName = Ii;
+var Pi = "ContextMenuRadioItem", Gn = R.forwardRef((e, t) => {
+  const { __scopeContextMenu: n, ...r } = e, o = U(n);
+  return /* @__PURE__ */ p(Ur, { ...o, ...r, ref: t });
+});
+Gn.displayName = Pi;
+var Li = "ContextMenuItemIndicator", Yn = R.forwardRef((e, t) => {
+  const { __scopeContextMenu: n, ...r } = e, o = U(n);
+  return /* @__PURE__ */ p(Vr, { ...o, ...r, ref: t });
+});
+Yn.displayName = Li;
+var ki = "ContextMenuSeparator", Kn = R.forwardRef((e, t) => {
+  const { __scopeContextMenu: n, ...r } = e, o = U(n);
+  return /* @__PURE__ */ p(Ir, { ...o, ...r, ref: t });
+});
+Kn.displayName = ki;
+var _i = "ContextMenuArrow", Bi = R.forwardRef(
+  (e, t) => {
+    const { __scopeContextMenu: n, ...r } = e, o = U(n);
+    return /* @__PURE__ */ p(Yr, { ...o, ...r, ref: t });
+  }
+);
+Bi.displayName = _i;
+var Wn = "ContextMenuSub", Hn = (e) => {
+  const { __scopeContextMenu: t, children: n, onOpenChange: r, open: o, defaultOpen: i } = e, a = U(t), [s, c] = Br({
+    prop: o,
+    defaultProp: i ?? !1,
+    onChange: r,
+    caller: Wn
+  });
+  return /* @__PURE__ */ p(Fr, { ...a, open: s, onOpenChange: c, children: n });
+};
+Hn.displayName = Wn;
+var Fi = "ContextMenuSubTrigger", qn = R.forwardRef((e, t) => {
+  const { __scopeContextMenu: n, ...r } = e, o = U(n);
+  return /* @__PURE__ */ p(Gr, { ...o, ...r, ref: t });
+});
+qn.displayName = Fi;
+var $i = "ContextMenuSubContent", Jn = R.forwardRef((e, t) => {
+  const { __scopeContextMenu: n, ...r } = e, o = U(n);
+  return /* @__PURE__ */ p(
+    Xr,
+    {
+      ...o,
+      ...r,
+      ref: t,
+      style: {
+        ...e.style,
+        "--radix-context-menu-content-transform-origin": "var(--radix-popper-transform-origin)",
+        "--radix-context-menu-content-available-width": "var(--radix-popper-available-width)",
+        "--radix-context-menu-content-available-height": "var(--radix-popper-available-height)",
+        "--radix-context-menu-trigger-width": "var(--radix-popper-anchor-width)",
+        "--radix-context-menu-trigger-height": "var(--radix-popper-anchor-height)"
+      }
+    }
+  );
+});
+Jn.displayName = $i;
+function Ze(e) {
+  return (t) => t.pointerType !== "mouse" ? e(t) : void 0;
+}
+var Vi = Pn, ji = kn, Qn = _n, Zn = Fn, Ui = $n, er = Vn, tr = jn, nr = Un, Xi = Xn, rr = Gn, or = Yn, ir = Kn, Gi = Hn, sr = qn, ar = Jn;
+const Yi = Vi, Ki = ji, ms = Ui, bs = Qn, xs = Gi, ys = Xi, Wi = R.forwardRef(({ className: e, inset: t, children: n, ...r }, o) => /* @__PURE__ */ se(
+  sr,
+  {
+    ref: o,
+    className: le(
+      "flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-zinc-100 focus:text-zinc-900 data-[state=open]:bg-zinc-100 data-[state=open]:text-zinc-900 dark:focus:bg-zinc-800 dark:focus:text-zinc-50 dark:data-[state=open]:bg-zinc-800 dark:data-[state=open]:text-zinc-50",
+      t && "pl-8",
+      e
+    ),
+    ...r,
+    children: [
+      n,
+      /* @__PURE__ */ p(Hr, { className: "ml-auto h-4 w-4" })
+    ]
+  }
+));
+Wi.displayName = sr.displayName;
+const Hi = R.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ p(
+  ar,
+  {
+    ref: n,
+    className: le(
+      "z-50 min-w-[8rem] overflow-hidden rounded-md border border-zinc-200 bg-white p-1 text-zinc-950 shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 dark:border-zinc-800 dark:bg-zinc-950 dark:text-zinc-50",
+      e
+    ),
+    ...t
+  }
+));
+Hi.displayName = ar.displayName;
+const cr = R.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ p(Qn, { children: /* @__PURE__ */ p(
+  Zn,
+  {
+    ref: n,
+    className: le(
+      "z-50 min-w-[8rem] overflow-hidden rounded-md border border-zinc-200 bg-white p-1 text-zinc-950 shadow-md animate-in fade-in-80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 dark:border-zinc-800 dark:bg-zinc-950 dark:text-zinc-50",
+      e
+    ),
+    ...t
+  }
+) }));
+cr.displayName = Zn.displayName;
+const ye = R.forwardRef(({ className: e, inset: t, ...n }, r) => /* @__PURE__ */ p(
+  tr,
+  {
+    ref: r,
+    className: le(
+      "relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-zinc-100 focus:text-zinc-900 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 dark:focus:bg-zinc-800 dark:focus:text-zinc-50",
+      t && "pl-8",
+      e
+    ),
+    ...n
+  }
+));
+ye.displayName = tr.displayName;
+const qi = R.forwardRef(({ className: e, children: t, checked: n, ...r }, o) => /* @__PURE__ */ se(
+  nr,
+  {
+    ref: o,
+    className: le(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-zinc-100 focus:text-zinc-900 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 dark:focus:bg-zinc-800 dark:focus:text-zinc-50",
+      e
+    ),
+    checked: n,
+    ...r,
+    children: [
+      /* @__PURE__ */ p("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ p(or, { children: /* @__PURE__ */ p(Kr, { className: "h-4 w-4" }) }) }),
+      t
+    ]
+  }
+));
+qi.displayName = nr.displayName;
+const Ji = R.forwardRef(({ className: e, children: t, ...n }, r) => /* @__PURE__ */ se(
+  rr,
+  {
+    ref: r,
+    className: le(
+      "relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-zinc-100 focus:text-zinc-900 data-[disabled]:pointer-events-none data-[disabled]:opacity-50 dark:focus:bg-zinc-800 dark:focus:text-zinc-50",
+      e
+    ),
+    ...n,
+    children: [
+      /* @__PURE__ */ p("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: /* @__PURE__ */ p(or, { children: /* @__PURE__ */ p(Wr, { className: "h-2 w-2 fill-current" }) }) }),
+      t
+    ]
+  }
+));
+Ji.displayName = rr.displayName;
+const Qi = R.forwardRef(({ className: e, inset: t, ...n }, r) => /* @__PURE__ */ p(
+  er,
+  {
+    ref: r,
+    className: le(
+      "px-2 py-1.5 text-sm font-semibold text-zinc-950 dark:text-zinc-50",
+      t && "pl-8",
+      e
+    ),
+    ...n
+  }
+));
+Qi.displayName = er.displayName;
+const nt = R.forwardRef(({ className: e, ...t }, n) => /* @__PURE__ */ p(
+  ir,
+  {
+    ref: n,
+    className: le(
+      "-mx-1 my-1 h-px bg-zinc-200 dark:bg-zinc-800",
+      e
+    ),
+    ...t
+  }
+));
+nt.displayName = ir.displayName;
+const rt = ({
+  className: e,
+  ...t
+}) => /* @__PURE__ */ p(
+  "span",
+  {
+    className: le(
+      "ml-auto text-xs tracking-widest text-zinc-500 dark:text-zinc-400",
+      e
+    ),
+    ...t
+  }
+);
+rt.displayName = "ContextMenuShortcut";
+const ws = ({ row: e, data: t, contextId: n, children: r, enabled: o = !0, onAction: i }) => {
+  const a = dn();
+  if (!o)
+    return /* @__PURE__ */ p(et, { children: r });
+  const s = t || e?.original, l = (() => {
+    if (!n) return [];
+    const f = a.get("ContextMenuService");
+    return f ? f.getItems(n, s) : [];
+  })(), d = l.length > 0, u = (f) => {
+    i?.(f, s);
+  };
+  return /* @__PURE__ */ se(Yi, { children: [
+    /* @__PURE__ */ p(Ki, { asChild: !0, children: /* @__PURE__ */ p("span", { className: "contents", children: r }) }),
+    /* @__PURE__ */ p(cr, { className: "w-64", children: d ? l.map((f, h) => /* @__PURE__ */ p(P.Fragment, { children: f.isSeparator ? /* @__PURE__ */ p(nt, {}) : /* @__PURE__ */ se(
+      ye,
+      {
+        inset: !0,
+        onSelect: () => {
+          f.onClick ? f.onClick(s) : u(f.action);
+        },
+        disabled: f.disabled,
+        className: f.className,
+        children: [
+          f.label,
+          f.shortcut && /* @__PURE__ */ p(rt, { children: f.shortcut })
+        ]
+      }
+    ) }, f.id || h)) : (
+      /* Default EzTable Actions (Legacy Fallback) */
+      /* @__PURE__ */ se(et, { children: [
+        /* @__PURE__ */ se(ye, { inset: !0, onSelect: () => u("copy"), children: [
+          "Copy Data",
+          /* @__PURE__ */ p(rt, { children: "⌘C" })
+        ] }),
+        /* @__PURE__ */ p(nt, {}),
+        e && /* @__PURE__ */ se(et, { children: [
+          e.getIsPinned() !== "top" && /* @__PURE__ */ p(ye, { inset: !0, onSelect: () => u("pin-top"), children: "Pin to Top" }),
+          e.getIsPinned() !== "bottom" && /* @__PURE__ */ p(ye, { inset: !0, onSelect: () => u("pin-bottom"), children: "Pin to Bottom" }),
+          e.getIsPinned() && /* @__PURE__ */ p(ye, { inset: !0, onSelect: () => u("unpin"), children: "Unpin Row" }),
+          /* @__PURE__ */ p(nt, {})
+        ] }),
+        /* @__PURE__ */ se(ye, { inset: !0, className: "text-red-600 focus:text-red-600 focus:bg-red-50 dark:focus:bg-red-950/50", onSelect: () => u("delete"), children: [
+          "Delete Row",
+          /* @__PURE__ */ p(rt, { children: "⌘⌫" })
+        ] })
+      ] })
+    ) })
+  ] });
+};
+export {
+  nt as A,
+  rt as B,
+  $e as C,
+  hs as D,
+  ws as E,
+  xs as F,
+  Hi as G,
+  Wi as H,
+  Ki as I,
+  vs as J,
+  D as K,
+  fs as L,
+  Mn as P,
+  ft as a,
+  ce as b,
+  ps as c,
+  gs as d,
+  as as e,
+  ds as f,
+  go as g,
+  It as h,
+  Ot as i,
+  Ge as j,
+  ls as k,
+  cs as l,
+  us as m,
+  En as n,
+  ss as o,
+  Yi as p,
+  qi as q,
+  cr as r,
+  st as s,
+  ms as t,
+  di as u,
+  ye as v,
+  Qi as w,
+  bs as x,
+  ys as y,
+  Ji as z
+};