@mdspl/mds-shared-ui 0.1.0

package/dist/index.js

@@ -0,0 +1,4221 @@
+import F, { useLayoutEffect as kr, useEffect as L, useRef as M, useMemo as A, useCallback as G, useState as re, createContext as st, memo as Nr, useReducer as Lr, useContext as Ae, forwardRef as on, createElement as Kt } from "react";
+import { Menu as at, Checkbox as ke, IconButton as Ve, Portal as sn, Table as ve, HStack as ge, createListCollection as Mr, Select as le, Pagination as Ct, Box as Qe, Text as we, ButtonGroup as Pr, Slider as lt, VStack as et, Drawer as be, Tabs as It, Button as $t, CloseButton as zr } from "@chakra-ui/react";
+import { unstable_batchedUpdates as gt, createPortal as $r } from "react-dom";
+var pt = { exports: {} }, Ke = {};
+var Cn;
+function Vr() {
+  if (Cn) return Ke;
+  Cn = 1;
+  var e = /* @__PURE__ */ Symbol.for("react.transitional.element"), t = /* @__PURE__ */ Symbol.for("react.fragment");
+  function n(r, o, i) {
+    var s = null;
+    if (i !== void 0 && (s = "" + i), o.key !== void 0 && (s = "" + o.key), "key" in o) {
+      i = {};
+      for (var a in o)
+        a !== "key" && (i[a] = o[a]);
+    } else i = o;
+    return o = i.ref, {
+      $$typeof: e,
+      type: r,
+      key: s,
+      ref: o !== void 0 ? o : null,
+      props: i
+    };
+  }
+  return Ke.Fragment = t, Ke.jsx = n, Ke.jsxs = n, Ke;
+}
+var Ze = {};
+var En;
+function Fr() {
+  return En || (En = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(v) {
+      if (v == null) return null;
+      if (typeof v == "function")
+        return v.$$typeof === N ? null : v.displayName || v.name || null;
+      if (typeof v == "string") return v;
+      switch (v) {
+        case b:
+          return "Fragment";
+        case w:
+          return "Profiler";
+        case x:
+          return "StrictMode";
+        case S:
+          return "Suspense";
+        case R:
+          return "SuspenseList";
+        case $:
+          return "Activity";
+      }
+      if (typeof v == "object")
+        switch (typeof v.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), v.$$typeof) {
+          case g:
+            return "Portal";
+          case E:
+            return v.displayName || "Context";
+          case C:
+            return (v._context.displayName || "Context") + ".Consumer";
+          case O:
+            var y = v.render;
+            return v = v.displayName, v || (v = y.displayName || y.name || "", v = v !== "" ? "ForwardRef(" + v + ")" : "ForwardRef"), v;
+          case D:
+            return y = v.displayName || null, y !== null ? y : e(v.type) || "Memo";
+          case P:
+            y = v._payload, v = v._init;
+            try {
+              return e(v(y));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function t(v) {
+      return "" + v;
+    }
+    function n(v) {
+      try {
+        t(v);
+        var y = !1;
+      } catch {
+        y = !0;
+      }
+      if (y) {
+        y = console;
+        var T = y.error, k = typeof Symbol == "function" && Symbol.toStringTag && v[Symbol.toStringTag] || v.constructor.name || "Object";
+        return T.call(
+          y,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          k
+        ), t(v);
+      }
+    }
+    function r(v) {
+      if (v === b) return "<>";
+      if (typeof v == "object" && v !== null && v.$$typeof === P)
+        return "<...>";
+      try {
+        var y = e(v);
+        return y ? "<" + y + ">" : "<...>";
+      } catch {
+        return "<...>";
+      }
+    }
+    function o() {
+      var v = q.A;
+      return v === null ? null : v.getOwner();
+    }
+    function i() {
+      return Error("react-stack-top-frame");
+    }
+    function s(v) {
+      if (J.call(v, "key")) {
+        var y = Object.getOwnPropertyDescriptor(v, "key").get;
+        if (y && y.isReactWarning) return !1;
+      }
+      return v.key !== void 0;
+    }
+    function a(v, y) {
+      function T() {
+        je || (je = !0, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          y
+        ));
+      }
+      T.isReactWarning = !0, Object.defineProperty(v, "key", {
+        get: T,
+        configurable: !0
+      });
+    }
+    function c() {
+      var v = e(this.type);
+      return H[v] || (H[v] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), v = this.props.ref, v !== void 0 ? v : null;
+    }
+    function l(v, y, T, k, ue, Y) {
+      var z = T.ref;
+      return v = {
+        $$typeof: m,
+        type: v,
+        key: y,
+        props: T,
+        _owner: k
+      }, (z !== void 0 ? z : null) !== null ? Object.defineProperty(v, "ref", {
+        enumerable: !1,
+        get: c
+      }) : Object.defineProperty(v, "ref", { enumerable: !1, value: null }), v._store = {}, Object.defineProperty(v._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(v, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.defineProperty(v, "_debugStack", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: ue
+      }), Object.defineProperty(v, "_debugTask", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: Y
+      }), Object.freeze && (Object.freeze(v.props), Object.freeze(v)), v;
+    }
+    function h(v, y, T, k, ue, Y) {
+      var z = y.children;
+      if (z !== void 0)
+        if (k)
+          if (oe(z)) {
+            for (k = 0; k < z.length; k++)
+              f(z[k]);
+            Object.freeze && Object.freeze(z);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else f(z);
+      if (J.call(y, "key")) {
+        z = e(v);
+        var X = Object.keys(y).filter(function(I) {
+          return I !== "key";
+        });
+        k = 0 < X.length ? "{key: someKey, " + X.join(": ..., ") + ": ...}" : "{key: someKey}", Se[z + k] || (X = 0 < X.length ? "{" + X.join(": ..., ") + ": ...}" : "{}", console.error(
+          `A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`,
+          k,
+          z,
+          X,
+          z
+        ), Se[z + k] = !0);
+      }
+      if (z = null, T !== void 0 && (n(T), z = "" + T), s(y) && (n(y.key), z = "" + y.key), "key" in y) {
+        T = {};
+        for (var Q in y)
+          Q !== "key" && (T[Q] = y[Q]);
+      } else T = y;
+      return z && a(
+        T,
+        typeof v == "function" ? v.displayName || v.name || "Unknown" : v
+      ), l(
+        v,
+        z,
+        T,
+        o(),
+        ue,
+        Y
+      );
+    }
+    function f(v) {
+      p(v) ? v._store && (v._store.validated = 1) : typeof v == "object" && v !== null && v.$$typeof === P && (v._payload.status === "fulfilled" ? p(v._payload.value) && v._payload.value._store && (v._payload.value._store.validated = 1) : v._store && (v._store.validated = 1));
+    }
+    function p(v) {
+      return typeof v == "object" && v !== null && v.$$typeof === m;
+    }
+    var d = F, m = /* @__PURE__ */ Symbol.for("react.transitional.element"), g = /* @__PURE__ */ Symbol.for("react.portal"), b = /* @__PURE__ */ Symbol.for("react.fragment"), x = /* @__PURE__ */ Symbol.for("react.strict_mode"), w = /* @__PURE__ */ Symbol.for("react.profiler"), C = /* @__PURE__ */ Symbol.for("react.consumer"), E = /* @__PURE__ */ Symbol.for("react.context"), O = /* @__PURE__ */ Symbol.for("react.forward_ref"), S = /* @__PURE__ */ Symbol.for("react.suspense"), R = /* @__PURE__ */ Symbol.for("react.suspense_list"), D = /* @__PURE__ */ Symbol.for("react.memo"), P = /* @__PURE__ */ Symbol.for("react.lazy"), $ = /* @__PURE__ */ Symbol.for("react.activity"), N = /* @__PURE__ */ Symbol.for("react.client.reference"), q = d.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, J = Object.prototype.hasOwnProperty, oe = Array.isArray, me = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    d = {
+      react_stack_bottom_frame: function(v) {
+        return v();
+      }
+    };
+    var je, H = {}, Ie = d.react_stack_bottom_frame.bind(
+      d,
+      i
+    )(), ie = me(r(i)), Se = {};
+    Ze.Fragment = b, Ze.jsx = function(v, y, T) {
+      var k = 1e4 > q.recentlyCreatedOwnerStacks++;
+      return h(
+        v,
+        y,
+        T,
+        !1,
+        k ? Error("react-stack-top-frame") : Ie,
+        k ? me(r(v)) : ie
+      );
+    }, Ze.jsxs = function(v, y, T) {
+      var k = 1e4 > q.recentlyCreatedOwnerStacks++;
+      return h(
+        v,
+        y,
+        T,
+        !0,
+        k ? Error("react-stack-top-frame") : Ie,
+        k ? me(r(v)) : ie
+      );
+    };
+  })()), Ze;
+}
+var Dn;
+function Br() {
+  return Dn || (Dn = 1, process.env.NODE_ENV === "production" ? pt.exports = Vr() : pt.exports = Fr()), pt.exports;
+}
+var u = Br(), bt = { exports: {} }, Vt = {}, mt = { exports: {} }, Ft = {};
+var _n;
+function Wr() {
+  if (_n) return Ft;
+  _n = 1;
+  var e = F;
+  function t(f, p) {
+    return f === p && (f !== 0 || 1 / f === 1 / p) || f !== f && p !== p;
+  }
+  var n = typeof Object.is == "function" ? Object.is : t, r = e.useState, o = e.useEffect, i = e.useLayoutEffect, s = e.useDebugValue;
+  function a(f, p) {
+    var d = p(), m = r({ inst: { value: d, getSnapshot: p } }), g = m[0].inst, b = m[1];
+    return i(
+      function() {
+        g.value = d, g.getSnapshot = p, c(g) && b({ inst: g });
+      },
+      [f, d, p]
+    ), o(
+      function() {
+        return c(g) && b({ inst: g }), f(function() {
+          c(g) && b({ inst: g });
+        });
+      },
+      [f]
+    ), s(d), d;
+  }
+  function c(f) {
+    var p = f.getSnapshot;
+    f = f.value;
+    try {
+      var d = p();
+      return !n(f, d);
+    } catch {
+      return !0;
+    }
+  }
+  function l(f, p) {
+    return p();
+  }
+  var h = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? l : a;
+  return Ft.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : h, Ft;
+}
+var Bt = {};
+var On;
+function Hr() {
+  return On || (On = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(d, m) {
+      return d === m && (d !== 0 || 1 / d === 1 / m) || d !== d && m !== m;
+    }
+    function t(d, m) {
+      h || o.startTransition === void 0 || (h = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var g = m();
+      if (!f) {
+        var b = m();
+        i(g, b) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), f = !0);
+      }
+      b = s({
+        inst: { value: g, getSnapshot: m }
+      });
+      var x = b[0].inst, w = b[1];
+      return c(
+        function() {
+          x.value = g, x.getSnapshot = m, n(x) && w({ inst: x });
+        },
+        [d, g, m]
+      ), a(
+        function() {
+          return n(x) && w({ inst: x }), d(function() {
+            n(x) && w({ inst: x });
+          });
+        },
+        [d]
+      ), l(g), g;
+    }
+    function n(d) {
+      var m = d.getSnapshot;
+      d = d.value;
+      try {
+        var g = m();
+        return !i(d, g);
+      } catch {
+        return !0;
+      }
+    }
+    function r(d, m) {
+      return m();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var o = F, i = typeof Object.is == "function" ? Object.is : e, s = o.useState, a = o.useEffect, c = o.useLayoutEffect, l = o.useDebugValue, h = !1, f = !1, p = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : t;
+    Bt.useSyncExternalStore = o.useSyncExternalStore !== void 0 ? o.useSyncExternalStore : p, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Bt;
+}
+var Tn;
+function Xn() {
+  return Tn || (Tn = 1, process.env.NODE_ENV === "production" ? mt.exports = Wr() : mt.exports = Hr()), mt.exports;
+}
+var jn;
+function Yr() {
+  if (jn) return Vt;
+  jn = 1;
+  var e = F, t = Xn();
+  function n(l, h) {
+    return l === h && (l !== 0 || 1 / l === 1 / h) || l !== l && h !== h;
+  }
+  var r = typeof Object.is == "function" ? Object.is : n, o = t.useSyncExternalStore, i = e.useRef, s = e.useEffect, a = e.useMemo, c = e.useDebugValue;
+  return Vt.useSyncExternalStoreWithSelector = function(l, h, f, p, d) {
+    var m = i(null);
+    if (m.current === null) {
+      var g = { hasValue: !1, value: null };
+      m.current = g;
+    } else g = m.current;
+    m = a(
+      function() {
+        function x(S) {
+          if (!w) {
+            if (w = !0, C = S, S = p(S), d !== void 0 && g.hasValue) {
+              var R = g.value;
+              if (d(R, S))
+                return E = R;
+            }
+            return E = S;
+          }
+          if (R = E, r(C, S)) return R;
+          var D = p(S);
+          return d !== void 0 && d(R, D) ? (C = S, R) : (C = S, E = D);
+        }
+        var w = !1, C, E, O = f === void 0 ? null : f;
+        return [
+          function() {
+            return x(h());
+          },
+          O === null ? void 0 : function() {
+            return x(O());
+          }
+        ];
+      },
+      [h, f, p, d]
+    );
+    var b = o(l, m[0], m[1]);
+    return s(
+      function() {
+        g.hasValue = !0, g.value = b;
+      },
+      [b]
+    ), c(b), b;
+  }, Vt;
+}
+var Wt = {};
+var In;
+function Ur() {
+  return In || (In = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(l, h) {
+      return l === h && (l !== 0 || 1 / l === 1 / h) || l !== l && h !== h;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var t = F, n = Xn(), r = typeof Object.is == "function" ? Object.is : e, o = n.useSyncExternalStore, i = t.useRef, s = t.useEffect, a = t.useMemo, c = t.useDebugValue;
+    Wt.useSyncExternalStoreWithSelector = function(l, h, f, p, d) {
+      var m = i(null);
+      if (m.current === null) {
+        var g = { hasValue: !1, value: null };
+        m.current = g;
+      } else g = m.current;
+      m = a(
+        function() {
+          function x(S) {
+            if (!w) {
+              if (w = !0, C = S, S = p(S), d !== void 0 && g.hasValue) {
+                var R = g.value;
+                if (d(R, S))
+                  return E = R;
+              }
+              return E = S;
+            }
+            if (R = E, r(C, S))
+              return R;
+            var D = p(S);
+            return d !== void 0 && d(R, D) ? (C = S, R) : (C = S, E = D);
+          }
+          var w = !1, C, E, O = f === void 0 ? null : f;
+          return [
+            function() {
+              return x(h());
+            },
+            O === null ? void 0 : function() {
+              return x(O());
+            }
+          ];
+        },
+        [h, f, p, d]
+      );
+      var b = o(l, m[0], m[1]);
+      return s(
+        function() {
+          g.hasValue = !0, g.value = b;
+        },
+        [b]
+      ), c(b), b;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Wt;
+}
+var An;
+function Gr() {
+  return An || (An = 1, process.env.NODE_ENV === "production" ? bt.exports = Yr() : bt.exports = Ur()), bt.exports;
+}
+var qr = Gr();
+const Zt = /* @__PURE__ */ new WeakMap(), Xr = /* @__PURE__ */ new WeakMap(), Et = {
+  current: []
+};
+let Ht = !1;
+const xt = /* @__PURE__ */ new Set(), kn = /* @__PURE__ */ new Map();
+function Jn(e) {
+  for (const t of e) {
+    if (Et.current.includes(t))
+      continue;
+    Et.current.push(t), t.recompute();
+    const n = Xr.get(t);
+    if (n)
+      for (const r of n) {
+        const o = Zt.get(r);
+        o?.length && Jn(o);
+      }
+  }
+}
+function Jr(e) {
+  const t = {
+    prevVal: e.prevState,
+    currentVal: e.state
+  };
+  for (const n of e.listeners)
+    n(t);
+}
+function Kr(e) {
+  const t = {
+    prevVal: e.prevState,
+    currentVal: e.state
+  };
+  for (const n of e.listeners)
+    n(t);
+}
+function Zr(e) {
+  if (xt.add(e), !Ht)
+    try {
+      for (Ht = !0; xt.size > 0; ) {
+        const t = Array.from(xt);
+        xt.clear();
+        for (const n of t) {
+          const r = kn.get(n) ?? n.prevState;
+          n.prevState = r, Jr(n);
+        }
+        for (const n of t) {
+          const r = Zt.get(n);
+          r && (Et.current.push(n), Jn(r));
+        }
+        for (const n of t) {
+          const r = Zt.get(n);
+          if (r)
+            for (const o of r)
+              Kr(o);
+        }
+      }
+    } finally {
+      Ht = !1, Et.current = [], kn.clear();
+    }
+}
+function Qr(e) {
+  return typeof e == "function";
+}
+class Kn {
+  constructor(t, n) {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = (r) => {
+      var o, i;
+      this.listeners.add(r);
+      const s = (i = (o = this.options) == null ? void 0 : o.onSubscribe) == null ? void 0 : i.call(o, r, this);
+      return () => {
+        this.listeners.delete(r), s?.();
+      };
+    }, this.prevState = t, this.state = t, this.options = n;
+  }
+  setState(t) {
+    var n, r, o;
+    this.prevState = this.state, (n = this.options) != null && n.updateFn ? this.state = this.options.updateFn(this.prevState)(t) : Qr(t) ? this.state = t(this.prevState) : this.state = t, (o = (r = this.options) == null ? void 0 : r.onUpdate) == null || o.call(r), Zr(this);
+  }
+}
+function ct(e, t = (r) => r, n = {}) {
+  const r = n.equal ?? eo;
+  return qr.useSyncExternalStoreWithSelector(
+    e.subscribe,
+    () => e.state,
+    () => e.state,
+    t,
+    r
+  );
+}
+function eo(e, t) {
+  if (Object.is(e, t))
+    return !0;
+  if (typeof e != "object" || e === null || typeof t != "object" || t === null)
+    return !1;
+  if (e instanceof Map && t instanceof Map) {
+    if (e.size !== t.size) return !1;
+    for (const [r, o] of e)
+      if (!t.has(r) || !Object.is(o, t.get(r))) return !1;
+    return !0;
+  }
+  if (e instanceof Set && t instanceof Set) {
+    if (e.size !== t.size) return !1;
+    for (const r of e)
+      if (!t.has(r)) return !1;
+    return !0;
+  }
+  if (e instanceof Date && t instanceof Date)
+    return e.getTime() === t.getTime();
+  const n = Nn(e);
+  if (n.length !== Nn(t).length)
+    return !1;
+  for (let r = 0; r < n.length; r++)
+    if (!Object.prototype.hasOwnProperty.call(t, n[r]) || !Object.is(e[n[r]], t[n[r]]))
+      return !1;
+  return !0;
+}
+function Nn(e) {
+  return Object.keys(e).concat(
+    Object.getOwnPropertySymbols(e)
+  );
+}
+function to() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return A(
+    () => (r) => {
+      t.forEach((o) => o(r));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  );
+}
+const At = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
+function We(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 an(e) {
+  return "nodeType" in e;
+}
+function K(e) {
+  var t, n;
+  return e ? We(e) ? e : an(e) && (t = (n = e.ownerDocument) == null ? void 0 : n.defaultView) != null ? t : window : window;
+}
+function ln(e) {
+  const {
+    Document: t
+  } = K(e);
+  return e instanceof t;
+}
+function ut(e) {
+  return We(e) ? !1 : e instanceof K(e).HTMLElement;
+}
+function Zn(e) {
+  return e instanceof K(e).SVGElement;
+}
+function He(e) {
+  return e ? We(e) ? e.document : an(e) ? ln(e) ? e : ut(e) || Zn(e) ? e.ownerDocument : document : document : document;
+}
+const pe = At ? kr : L;
+function cn(e) {
+  const t = M(e);
+  return pe(() => {
+    t.current = e;
+  }), G(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 no() {
+  const e = M(null), t = G((r, o) => {
+    e.current = setInterval(r, o);
+  }, []), n = G(() => {
+    e.current !== null && (clearInterval(e.current), e.current = null);
+  }, []);
+  return [t, n];
+}
+function ot(e, t) {
+  t === void 0 && (t = [e]);
+  const n = M(e);
+  return pe(() => {
+    n.current !== e && (n.current = e);
+  }, t), n;
+}
+function dt(e, t) {
+  const n = M();
+  return A(
+    () => {
+      const r = e(n.current);
+      return n.current = r, r;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+function Dt(e) {
+  const t = cn(e), n = M(null), r = G(
+    (o) => {
+      o !== n.current && t?.(o, n.current), n.current = o;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [n, r];
+}
+function Qt(e) {
+  const t = M();
+  return L(() => {
+    t.current = e;
+  }, [e]), t.current;
+}
+let Yt = {};
+function ft(e, t) {
+  return A(() => {
+    if (t)
+      return t;
+    const n = Yt[e] == null ? 0 : Yt[e] + 1;
+    return Yt[e] = n, e + "-" + n;
+  }, [e, t]);
+}
+function Qn(e) {
+  return function(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    return r.reduce((i, s) => {
+      const a = Object.entries(s);
+      for (const [c, l] of a) {
+        const h = i[c];
+        h != null && (i[c] = h + e * l);
+      }
+      return i;
+    }, {
+      ...t
+    });
+  };
+}
+const Fe = /* @__PURE__ */ Qn(1), _t = /* @__PURE__ */ Qn(-1);
+function ro(e) {
+  return "clientX" in e && "clientY" in e;
+}
+function un(e) {
+  if (!e)
+    return !1;
+  const {
+    KeyboardEvent: t
+  } = K(e.target);
+  return t && e instanceof t;
+}
+function oo(e) {
+  if (!e)
+    return !1;
+  const {
+    TouchEvent: t
+  } = K(e.target);
+  return t && e instanceof t;
+}
+function en(e) {
+  if (oo(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 ro(e) ? {
+    x: e.clientX,
+    y: e.clientY
+  } : null;
+}
+const Be = /* @__PURE__ */ Object.freeze({
+  Translate: {
+    toString(e) {
+      if (!e)
+        return;
+      const {
+        x: t,
+        y: n
+      } = e;
+      return "translate3d(" + (t ? Math.round(t) : 0) + "px, " + (n ? Math.round(n) : 0) + "px, 0)";
+    }
+  },
+  Scale: {
+    toString(e) {
+      if (!e)
+        return;
+      const {
+        scaleX: t,
+        scaleY: n
+      } = e;
+      return "scaleX(" + t + ") scaleY(" + n + ")";
+    }
+  },
+  Transform: {
+    toString(e) {
+      if (e)
+        return [Be.Translate.toString(e), Be.Scale.toString(e)].join(" ");
+    }
+  },
+  Transition: {
+    toString(e) {
+      let {
+        property: t,
+        duration: n,
+        easing: r
+      } = e;
+      return t + " " + n + "ms " + r;
+    }
+  }
+}), Ln = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function io(e) {
+  return e.matches(Ln) ? e : e.querySelector(Ln);
+}
+const so = {
+  display: "none"
+};
+function ao(e) {
+  let {
+    id: t,
+    value: n
+  } = e;
+  return F.createElement("div", {
+    id: t,
+    style: so
+  }, n);
+}
+function lo(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 F.createElement("div", {
+    id: t,
+    style: o,
+    role: "status",
+    "aria-live": r,
+    "aria-atomic": !0
+  }, n);
+}
+function co() {
+  const [e, t] = re("");
+  return {
+    announce: G((r) => {
+      r != null && t(r);
+    }, []),
+    announcement: e
+  };
+}
+const er = /* @__PURE__ */ st(null);
+function uo(e) {
+  const t = Ae(er);
+  L(() => {
+    if (!t)
+      throw new Error("useDndMonitor must be used within a children of <DndContext>");
+    return t(e);
+  }, [e, t]);
+}
+function fo() {
+  const [e] = re(() => /* @__PURE__ */ new Set()), t = G((r) => (e.add(r), () => e.delete(r)), [e]);
+  return [G((r) => {
+    let {
+      type: o,
+      event: i
+    } = r;
+    e.forEach((s) => {
+      var a;
+      return (a = s[o]) == null ? void 0 : a.call(s, i);
+    });
+  }, [e]), t];
+}
+const ho = {
+  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.
+  `
+}, vo = {
+  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 go(e) {
+  let {
+    announcements: t = vo,
+    container: n,
+    hiddenTextDescribedById: r,
+    screenReaderInstructions: o = ho
+  } = e;
+  const {
+    announce: i,
+    announcement: s
+  } = co(), a = ft("DndLiveRegion"), [c, l] = re(!1);
+  if (L(() => {
+    l(!0);
+  }, []), uo(A(() => ({
+    onDragStart(f) {
+      let {
+        active: p
+      } = f;
+      i(t.onDragStart({
+        active: p
+      }));
+    },
+    onDragMove(f) {
+      let {
+        active: p,
+        over: d
+      } = f;
+      t.onDragMove && i(t.onDragMove({
+        active: p,
+        over: d
+      }));
+    },
+    onDragOver(f) {
+      let {
+        active: p,
+        over: d
+      } = f;
+      i(t.onDragOver({
+        active: p,
+        over: d
+      }));
+    },
+    onDragEnd(f) {
+      let {
+        active: p,
+        over: d
+      } = f;
+      i(t.onDragEnd({
+        active: p,
+        over: d
+      }));
+    },
+    onDragCancel(f) {
+      let {
+        active: p,
+        over: d
+      } = f;
+      i(t.onDragCancel({
+        active: p,
+        over: d
+      }));
+    }
+  }), [i, t])), !c)
+    return null;
+  const h = F.createElement(F.Fragment, null, F.createElement(ao, {
+    id: r,
+    value: o.draggable
+  }), F.createElement(lo, {
+    id: a,
+    announcement: s
+  }));
+  return n ? $r(h, n) : h;
+}
+var V;
+(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";
+})(V || (V = {}));
+function Ot() {
+}
+function po(e, t) {
+  return A(
+    () => ({
+      sensor: e,
+      options: {}
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  );
+}
+function bo() {
+  for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+    t[n] = arguments[n];
+  return A(
+    () => [...t].filter((r) => r != null),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...t]
+  );
+}
+const ce = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+function mo(e, t) {
+  return Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+}
+function xo(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return n - r;
+}
+function yo(e, t) {
+  let {
+    data: {
+      value: n
+    }
+  } = e, {
+    data: {
+      value: r
+    }
+  } = t;
+  return r - n;
+}
+function wo(e, t) {
+  if (!e || e.length === 0)
+    return null;
+  const [n] = e;
+  return n[t];
+}
+function Mn(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 tr = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = Mn(t, t.left, t.top), i = [];
+  for (const s of r) {
+    const {
+      id: a
+    } = s, c = n.get(a);
+    if (c) {
+      const l = mo(Mn(c), o);
+      i.push({
+        id: a,
+        data: {
+          droppableContainer: s,
+          value: l
+        }
+      });
+    }
+  }
+  return i.sort(xo);
+};
+function So(e, t) {
+  const n = Math.max(t.top, e.top), r = Math.max(t.left, e.left), o = Math.min(t.left + t.width, e.left + e.width), i = Math.min(t.top + t.height, e.top + e.height), s = o - r, a = i - n;
+  if (r < o && n < i) {
+    const c = t.width * t.height, l = e.width * e.height, h = s * a, f = h / (c + l - h);
+    return Number(f.toFixed(4));
+  }
+  return 0;
+}
+const Ro = (e) => {
+  let {
+    collisionRect: t,
+    droppableRects: n,
+    droppableContainers: r
+  } = e;
+  const o = [];
+  for (const i of r) {
+    const {
+      id: s
+    } = i, a = n.get(s);
+    if (a) {
+      const c = So(a, t);
+      c > 0 && o.push({
+        id: s,
+        data: {
+          droppableContainer: i,
+          value: c
+        }
+      });
+    }
+  }
+  return o.sort(yo);
+};
+function Co(e, t, n) {
+  return {
+    ...e,
+    scaleX: t && n ? t.width / n.width : 1,
+    scaleY: t && n ? t.height / n.height : 1
+  };
+}
+function nr(e, t) {
+  return e && t ? {
+    x: e.left - t.left,
+    y: e.top - t.top
+  } : ce;
+}
+function Eo(e) {
+  return function(n) {
+    for (var r = arguments.length, o = new Array(r > 1 ? r - 1 : 0), i = 1; i < r; i++)
+      o[i - 1] = arguments[i];
+    return o.reduce((s, a) => ({
+      ...s,
+      top: s.top + e * a.y,
+      bottom: s.bottom + e * a.y,
+      left: s.left + e * a.x,
+      right: s.right + e * a.x
+    }), {
+      ...n
+    });
+  };
+}
+const Do = /* @__PURE__ */ Eo(1);
+function _o(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 Oo(e, t, n) {
+  const r = _o(t);
+  if (!r)
+    return e;
+  const {
+    scaleX: o,
+    scaleY: i,
+    x: s,
+    y: a
+  } = r, c = e.left - s - (1 - o) * parseFloat(n), l = e.top - a - (1 - i) * parseFloat(n.slice(n.indexOf(" ") + 1)), h = o ? e.width / o : e.width, f = i ? e.height / i : e.height;
+  return {
+    width: h,
+    height: f,
+    top: l,
+    right: c + h,
+    bottom: l + f,
+    left: c
+  };
+}
+const To = {
+  ignoreTransform: !1
+};
+function Ye(e, t) {
+  t === void 0 && (t = To);
+  let n = e.getBoundingClientRect();
+  if (t.ignoreTransform) {
+    const {
+      transform: l,
+      transformOrigin: h
+    } = K(e).getComputedStyle(e);
+    l && (n = Oo(n, l, h));
+  }
+  const {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: c
+  } = n;
+  return {
+    top: r,
+    left: o,
+    width: i,
+    height: s,
+    bottom: a,
+    right: c
+  };
+}
+function Pn(e) {
+  return Ye(e, {
+    ignoreTransform: !0
+  });
+}
+function jo(e) {
+  const t = e.innerWidth, n = e.innerHeight;
+  return {
+    top: 0,
+    left: 0,
+    right: t,
+    bottom: n,
+    width: t,
+    height: n
+  };
+}
+function Io(e, t) {
+  return t === void 0 && (t = K(e).getComputedStyle(e)), t.position === "fixed";
+}
+function Ao(e, t) {
+  t === void 0 && (t = K(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 dn(e, t) {
+  const n = [];
+  function r(o) {
+    if (t != null && n.length >= t || !o)
+      return n;
+    if (ln(o) && o.scrollingElement != null && !n.includes(o.scrollingElement))
+      return n.push(o.scrollingElement), n;
+    if (!ut(o) || Zn(o) || n.includes(o))
+      return n;
+    const i = K(e).getComputedStyle(o);
+    return o !== e && Ao(o, i) && n.push(o), Io(o, i) ? n : r(o.parentNode);
+  }
+  return e ? r(e) : n;
+}
+function rr(e) {
+  const [t] = dn(e, 1);
+  return t ?? null;
+}
+function Ut(e) {
+  return !At || !e ? null : We(e) ? e : an(e) ? ln(e) || e === He(e).scrollingElement ? window : ut(e) ? e : null : null;
+}
+function or(e) {
+  return We(e) ? e.scrollX : e.scrollLeft;
+}
+function ir(e) {
+  return We(e) ? e.scrollY : e.scrollTop;
+}
+function tn(e) {
+  return {
+    x: or(e),
+    y: ir(e)
+  };
+}
+var B;
+(function(e) {
+  e[e.Forward = 1] = "Forward", e[e.Backward = -1] = "Backward";
+})(B || (B = {}));
+function sr(e) {
+  return !At || !e ? !1 : e === document.scrollingElement;
+}
+function ar(e) {
+  const t = {
+    x: 0,
+    y: 0
+  }, n = sr(e) ? {
+    height: window.innerHeight,
+    width: window.innerWidth
+  } : {
+    height: e.clientHeight,
+    width: e.clientWidth
+  }, r = {
+    x: e.scrollWidth - n.width,
+    y: e.scrollHeight - n.height
+  }, o = e.scrollTop <= t.y, i = e.scrollLeft <= t.x, s = e.scrollTop >= r.y, a = e.scrollLeft >= r.x;
+  return {
+    isTop: o,
+    isLeft: i,
+    isBottom: s,
+    isRight: a,
+    maxScroll: r,
+    minScroll: t
+  };
+}
+const ko = {
+  x: 0.2,
+  y: 0.2
+};
+function No(e, t, n, r, o) {
+  let {
+    top: i,
+    left: s,
+    right: a,
+    bottom: c
+  } = n;
+  r === void 0 && (r = 10), o === void 0 && (o = ko);
+  const {
+    isTop: l,
+    isBottom: h,
+    isLeft: f,
+    isRight: p
+  } = ar(e), d = {
+    x: 0,
+    y: 0
+  }, m = {
+    x: 0,
+    y: 0
+  }, g = {
+    height: t.height * o.y,
+    width: t.width * o.x
+  };
+  return !l && i <= t.top + g.height ? (d.y = B.Backward, m.y = r * Math.abs((t.top + g.height - i) / g.height)) : !h && c >= t.bottom - g.height && (d.y = B.Forward, m.y = r * Math.abs((t.bottom - g.height - c) / g.height)), !p && a >= t.right - g.width ? (d.x = B.Forward, m.x = r * Math.abs((t.right - g.width - a) / g.width)) : !f && s <= t.left + g.width && (d.x = B.Backward, m.x = r * Math.abs((t.left + g.width - s) / g.width)), {
+    direction: d,
+    speed: m
+  };
+}
+function Lo(e) {
+  if (e === document.scrollingElement) {
+    const {
+      innerWidth: i,
+      innerHeight: s
+    } = window;
+    return {
+      top: 0,
+      left: 0,
+      right: i,
+      bottom: s,
+      width: i,
+      height: s
+    };
+  }
+  const {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o
+  } = e.getBoundingClientRect();
+  return {
+    top: t,
+    left: n,
+    right: r,
+    bottom: o,
+    width: e.clientWidth,
+    height: e.clientHeight
+  };
+}
+function lr(e) {
+  return e.reduce((t, n) => Fe(t, tn(n)), ce);
+}
+function Mo(e) {
+  return e.reduce((t, n) => t + or(n), 0);
+}
+function Po(e) {
+  return e.reduce((t, n) => t + ir(n), 0);
+}
+function zo(e, t) {
+  if (t === void 0 && (t = Ye), !e)
+    return;
+  const {
+    top: n,
+    left: r,
+    bottom: o,
+    right: i
+  } = t(e);
+  rr(e) && (o <= 0 || i <= 0 || n >= window.innerHeight || r >= window.innerWidth) && e.scrollIntoView({
+    block: "center",
+    inline: "center"
+  });
+}
+const $o = [["x", ["left", "right"], Mo], ["y", ["top", "bottom"], Po]];
+class fn {
+  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 = dn(n), o = lr(r);
+    this.rect = {
+      ...t
+    }, this.width = t.width, this.height = t.height;
+    for (const [i, s, a] of $o)
+      for (const c of s)
+        Object.defineProperty(this, c, {
+          get: () => {
+            const l = a(r), h = o[i] - l;
+            return this.rect[c] + h;
+          },
+          enumerable: !0
+        });
+    Object.defineProperty(this, "rect", {
+      enumerable: !1
+    });
+  }
+}
+class tt {
+  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 Vo(e) {
+  const {
+    EventTarget: t
+  } = K(e);
+  return e instanceof t ? e : He(e);
+}
+function Gt(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 ae;
+(function(e) {
+  e.Click = "click", e.DragStart = "dragstart", e.Keydown = "keydown", e.ContextMenu = "contextmenu", e.Resize = "resize", e.SelectionChange = "selectionchange", e.VisibilityChange = "visibilitychange";
+})(ae || (ae = {}));
+function zn(e) {
+  e.preventDefault();
+}
+function Fo(e) {
+  e.stopPropagation();
+}
+var j;
+(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";
+})(j || (j = {}));
+const cr = {
+  start: [j.Space, j.Enter],
+  cancel: [j.Esc],
+  end: [j.Space, j.Enter, j.Tab]
+}, Bo = (e, t) => {
+  let {
+    currentCoordinates: n
+  } = t;
+  switch (e.code) {
+    case j.Right:
+      return {
+        ...n,
+        x: n.x + 25
+      };
+    case j.Left:
+      return {
+        ...n,
+        x: n.x - 25
+      };
+    case j.Down:
+      return {
+        ...n,
+        y: n.y + 25
+      };
+    case j.Up:
+      return {
+        ...n,
+        y: n.y - 25
+      };
+  }
+};
+class ur {
+  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 tt(He(n)), this.windowListeners = new tt(K(n)), this.handleKeyDown = this.handleKeyDown.bind(this), this.handleCancel = this.handleCancel.bind(this), this.attach();
+  }
+  attach() {
+    this.handleStart(), this.windowListeners.add(ae.Resize, this.handleCancel), this.windowListeners.add(ae.VisibilityChange, this.handleCancel), setTimeout(() => this.listeners.add(ae.Keydown, this.handleKeyDown));
+  }
+  handleStart() {
+    const {
+      activeNode: t,
+      onStart: n
+    } = this.props, r = t.node.current;
+    r && zo(r), n(ce);
+  }
+  handleKeyDown(t) {
+    if (un(t)) {
+      const {
+        active: n,
+        context: r,
+        options: o
+      } = this.props, {
+        keyboardCodes: i = cr,
+        coordinateGetter: s = Bo,
+        scrollBehavior: a = "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, h = l ? {
+        x: l.left,
+        y: l.top
+      } : ce;
+      this.referenceCoordinates || (this.referenceCoordinates = h);
+      const f = s(t, {
+        active: n,
+        context: r.current,
+        currentCoordinates: h
+      });
+      if (f) {
+        const p = _t(f, h), d = {
+          x: 0,
+          y: 0
+        }, {
+          scrollableAncestors: m
+        } = r.current;
+        for (const g of m) {
+          const b = t.code, {
+            isTop: x,
+            isRight: w,
+            isLeft: C,
+            isBottom: E,
+            maxScroll: O,
+            minScroll: S
+          } = ar(g), R = Lo(g), D = {
+            x: Math.min(b === j.Right ? R.right - R.width / 2 : R.right, Math.max(b === j.Right ? R.left : R.left + R.width / 2, f.x)),
+            y: Math.min(b === j.Down ? R.bottom - R.height / 2 : R.bottom, Math.max(b === j.Down ? R.top : R.top + R.height / 2, f.y))
+          }, P = b === j.Right && !w || b === j.Left && !C, $ = b === j.Down && !E || b === j.Up && !x;
+          if (P && D.x !== f.x) {
+            const N = g.scrollLeft + p.x, q = b === j.Right && N <= O.x || b === j.Left && N >= S.x;
+            if (q && !p.y) {
+              g.scrollTo({
+                left: N,
+                behavior: a
+              });
+              return;
+            }
+            q ? d.x = g.scrollLeft - N : d.x = b === j.Right ? g.scrollLeft - O.x : g.scrollLeft - S.x, d.x && g.scrollBy({
+              left: -d.x,
+              behavior: a
+            });
+            break;
+          } else if ($ && D.y !== f.y) {
+            const N = g.scrollTop + p.y, q = b === j.Down && N <= O.y || b === j.Up && N >= S.y;
+            if (q && !p.x) {
+              g.scrollTo({
+                top: N,
+                behavior: a
+              });
+              return;
+            }
+            q ? d.y = g.scrollTop - N : d.y = b === j.Down ? g.scrollTop - O.y : g.scrollTop - S.y, d.y && g.scrollBy({
+              top: -d.y,
+              behavior: a
+            });
+            break;
+          }
+        }
+        this.handleMove(t, Fe(_t(f, this.referenceCoordinates), d));
+      }
+    }
+  }
+  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();
+  }
+}
+ur.activators = [{
+  eventName: "onKeyDown",
+  handler: (e, t, n) => {
+    let {
+      keyboardCodes: r = cr,
+      onActivation: o
+    } = t, {
+      active: i
+    } = n;
+    const {
+      code: s
+    } = e.nativeEvent;
+    if (r.start.includes(s)) {
+      const a = i.activatorNode.current;
+      return a && e.target !== a ? !1 : (e.preventDefault(), o?.({
+        event: e.nativeEvent
+      }), !0);
+    }
+    return !1;
+  }
+}];
+function $n(e) {
+  return !!(e && "distance" in e);
+}
+function Vn(e) {
+  return !!(e && "delay" in e);
+}
+class hn {
+  constructor(t, n, r) {
+    var o;
+    r === void 0 && (r = Vo(t.event.target)), this.props = void 0, this.events = void 0, this.autoScrollEnabled = !0, this.document = void 0, this.activated = !1, this.initialCoordinates = void 0, this.timeoutId = null, this.listeners = void 0, this.documentListeners = void 0, this.windowListeners = void 0, this.props = t, this.events = n;
+    const {
+      event: i
+    } = t, {
+      target: s
+    } = i;
+    this.props = t, this.events = n, this.document = He(s), this.documentListeners = new tt(this.document), this.listeners = new tt(r), this.windowListeners = new tt(K(s)), this.initialCoordinates = (o = en(i)) != null ? o : ce, 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(ae.Resize, this.handleCancel), this.windowListeners.add(ae.DragStart, zn), this.windowListeners.add(ae.VisibilityChange, this.handleCancel), this.windowListeners.add(ae.ContextMenu, zn), this.documentListeners.add(ae.Keydown, this.handleKeydown), n) {
+      if (r != null && r({
+        event: this.props.event,
+        activeNode: this.props.activeNode,
+        options: this.props.options
+      }))
+        return this.handleStart();
+      if (Vn(n)) {
+        this.timeoutId = setTimeout(this.handleStart, n.delay), this.handlePending(n);
+        return;
+      }
+      if ($n(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(ae.Click, Fo, {
+      capture: !0
+    }), this.removeTextSelection(), this.documentListeners.add(ae.SelectionChange, this.removeTextSelection), n(t));
+  }
+  handleMove(t) {
+    var n;
+    const {
+      activated: r,
+      initialCoordinates: o,
+      props: i
+    } = this, {
+      onMove: s,
+      options: {
+        activationConstraint: a
+      }
+    } = i;
+    if (!o)
+      return;
+    const c = (n = en(t)) != null ? n : ce, l = _t(o, c);
+    if (!r && a) {
+      if ($n(a)) {
+        if (a.tolerance != null && Gt(l, a.tolerance))
+          return this.handleCancel();
+        if (Gt(l, a.distance))
+          return this.handleStart();
+      }
+      if (Vn(a) && Gt(l, a.tolerance))
+        return this.handleCancel();
+      this.handlePending(a, l);
+      return;
+    }
+    t.cancelable && t.preventDefault(), s(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 === j.Esc && this.handleCancel();
+  }
+  removeTextSelection() {
+    var t;
+    (t = this.document.getSelection()) == null || t.removeAllRanges();
+  }
+}
+const Wo = {
+  cancel: {
+    name: "pointercancel"
+  },
+  move: {
+    name: "pointermove"
+  },
+  end: {
+    name: "pointerup"
+  }
+};
+class vn extends hn {
+  constructor(t) {
+    const {
+      event: n
+    } = t, r = He(n.target);
+    super(t, Wo, r);
+  }
+}
+vn.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 Ho = {
+  move: {
+    name: "mousemove"
+  },
+  end: {
+    name: "mouseup"
+  }
+};
+var nn;
+(function(e) {
+  e[e.RightClick = 2] = "RightClick";
+})(nn || (nn = {}));
+class Yo extends hn {
+  constructor(t) {
+    super(t, Ho, He(t.event.target));
+  }
+}
+Yo.activators = [{
+  eventName: "onMouseDown",
+  handler: (e, t) => {
+    let {
+      nativeEvent: n
+    } = e, {
+      onActivation: r
+    } = t;
+    return n.button === nn.RightClick ? !1 : (r?.({
+      event: n
+    }), !0);
+  }
+}];
+const qt = {
+  cancel: {
+    name: "touchcancel"
+  },
+  move: {
+    name: "touchmove"
+  },
+  end: {
+    name: "touchend"
+  }
+};
+class Uo extends hn {
+  constructor(t) {
+    super(t, qt);
+  }
+  static setup() {
+    return window.addEventListener(qt.move.name, t, {
+      capture: !1,
+      passive: !1
+    }), function() {
+      window.removeEventListener(qt.move.name, t);
+    };
+    function t() {
+    }
+  }
+}
+Uo.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 nt;
+(function(e) {
+  e[e.Pointer = 0] = "Pointer", e[e.DraggableRect = 1] = "DraggableRect";
+})(nt || (nt = {}));
+var Tt;
+(function(e) {
+  e[e.TreeOrder = 0] = "TreeOrder", e[e.ReversedTreeOrder = 1] = "ReversedTreeOrder";
+})(Tt || (Tt = {}));
+function Go(e) {
+  let {
+    acceleration: t,
+    activator: n = nt.Pointer,
+    canScroll: r,
+    draggingRect: o,
+    enabled: i,
+    interval: s = 5,
+    order: a = Tt.TreeOrder,
+    pointerCoordinates: c,
+    scrollableAncestors: l,
+    scrollableAncestorRects: h,
+    delta: f,
+    threshold: p
+  } = e;
+  const d = Xo({
+    delta: f,
+    disabled: !i
+  }), [m, g] = no(), b = M({
+    x: 0,
+    y: 0
+  }), x = M({
+    x: 0,
+    y: 0
+  }), w = A(() => {
+    switch (n) {
+      case nt.Pointer:
+        return c ? {
+          top: c.y,
+          bottom: c.y,
+          left: c.x,
+          right: c.x
+        } : null;
+      case nt.DraggableRect:
+        return o;
+    }
+  }, [n, o, c]), C = M(null), E = G(() => {
+    const S = C.current;
+    if (!S)
+      return;
+    const R = b.current.x * x.current.x, D = b.current.y * x.current.y;
+    S.scrollBy(R, D);
+  }, []), O = A(() => a === Tt.TreeOrder ? [...l].reverse() : l, [a, l]);
+  L(
+    () => {
+      if (!i || !l.length || !w) {
+        g();
+        return;
+      }
+      for (const S of O) {
+        if (r?.(S) === !1)
+          continue;
+        const R = l.indexOf(S), D = h[R];
+        if (!D)
+          continue;
+        const {
+          direction: P,
+          speed: $
+        } = No(S, D, w, t, p);
+        for (const N of ["x", "y"])
+          d[N][P[N]] || ($[N] = 0, P[N] = 0);
+        if ($.x > 0 || $.y > 0) {
+          g(), C.current = S, m(E, s), b.current = $, x.current = P;
+          return;
+        }
+      }
+      b.current = {
+        x: 0,
+        y: 0
+      }, x.current = {
+        x: 0,
+        y: 0
+      }, g();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      E,
+      r,
+      g,
+      i,
+      s,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(w),
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(d),
+      m,
+      l,
+      O,
+      h,
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      JSON.stringify(p)
+    ]
+  );
+}
+const qo = {
+  x: {
+    [B.Backward]: !1,
+    [B.Forward]: !1
+  },
+  y: {
+    [B.Backward]: !1,
+    [B.Forward]: !1
+  }
+};
+function Xo(e) {
+  let {
+    delta: t,
+    disabled: n
+  } = e;
+  const r = Qt(t);
+  return dt((o) => {
+    if (n || !r || !o)
+      return qo;
+    const i = {
+      x: Math.sign(t.x - r.x),
+      y: Math.sign(t.y - r.y)
+    };
+    return {
+      x: {
+        [B.Backward]: o.x[B.Backward] || i.x === -1,
+        [B.Forward]: o.x[B.Forward] || i.x === 1
+      },
+      y: {
+        [B.Backward]: o.y[B.Backward] || i.y === -1,
+        [B.Forward]: o.y[B.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 dt((o) => {
+    var i;
+    return t == null ? null : (i = r ?? o) != null ? i : null;
+  }, [r, t]);
+}
+function Ko(e, t) {
+  return A(() => e.reduce((n, r) => {
+    const {
+      sensor: o
+    } = r, i = o.activators.map((s) => ({
+      eventName: s.eventName,
+      handler: t(s.handler, r)
+    }));
+    return [...n, ...i];
+  }, []), [e, t]);
+}
+var it;
+(function(e) {
+  e[e.Always = 0] = "Always", e[e.BeforeDragging = 1] = "BeforeDragging", e[e.WhileDragging = 2] = "WhileDragging";
+})(it || (it = {}));
+var rn;
+(function(e) {
+  e.Optimized = "optimized";
+})(rn || (rn = {}));
+const Fn = /* @__PURE__ */ new Map();
+function Zo(e, t) {
+  let {
+    dragging: n,
+    dependencies: r,
+    config: o
+  } = t;
+  const [i, s] = re(null), {
+    frequency: a,
+    measure: c,
+    strategy: l
+  } = o, h = M(e), f = b(), p = ot(f), d = G(function(x) {
+    x === void 0 && (x = []), !p.current && s((w) => w === null ? x : w.concat(x.filter((C) => !w.includes(C))));
+  }, [p]), m = M(null), g = dt((x) => {
+    if (f && !n)
+      return Fn;
+    if (!x || x === Fn || h.current !== e || i != null) {
+      const w = /* @__PURE__ */ new Map();
+      for (let C of e) {
+        if (!C)
+          continue;
+        if (i && i.length > 0 && !i.includes(C.id) && C.rect.current) {
+          w.set(C.id, C.rect.current);
+          continue;
+        }
+        const E = C.node.current, O = E ? new fn(c(E), E) : null;
+        C.rect.current = O, O && w.set(C.id, O);
+      }
+      return w;
+    }
+    return x;
+  }, [e, i, n, f, c]);
+  return L(() => {
+    h.current = e;
+  }, [e]), L(
+    () => {
+      f || d();
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n, f]
+  ), L(
+    () => {
+      i && i.length > 0 && s(null);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(i)]
+  ), L(
+    () => {
+      f || typeof a != "number" || m.current !== null || (m.current = setTimeout(() => {
+        d(), m.current = null;
+      }, a));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [a, f, d, ...r]
+  ), {
+    droppableRects: g,
+    measureDroppableContainers: d,
+    measuringScheduled: i != null
+  };
+  function b() {
+    switch (l) {
+      case it.Always:
+        return !1;
+      case it.BeforeDragging:
+        return n;
+      default:
+        return !n;
+    }
+  }
+}
+function dr(e, t) {
+  return dt((n) => e ? n || (typeof t == "function" ? t(e) : e) : null, [t, e]);
+}
+function Qo(e, t) {
+  return dr(e, t);
+}
+function ei(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = cn(t), o = A(() => {
+    if (n || typeof window > "u" || typeof window.MutationObserver > "u")
+      return;
+    const {
+      MutationObserver: i
+    } = window;
+    return new i(r);
+  }, [r, n]);
+  return L(() => () => o?.disconnect(), [o]), o;
+}
+function kt(e) {
+  let {
+    callback: t,
+    disabled: n
+  } = e;
+  const r = cn(t), o = A(
+    () => {
+      if (n || typeof window > "u" || typeof window.ResizeObserver > "u")
+        return;
+      const {
+        ResizeObserver: i
+      } = window;
+      return new i(r);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [n]
+  );
+  return L(() => () => o?.disconnect(), [o]), o;
+}
+function ti(e) {
+  return new fn(Ye(e), e);
+}
+function Bn(e, t, n) {
+  t === void 0 && (t = ti);
+  const [r, o] = re(null);
+  function i() {
+    o((c) => {
+      if (!e)
+        return null;
+      if (e.isConnected === !1) {
+        var l;
+        return (l = c ?? n) != null ? l : null;
+      }
+      const h = t(e);
+      return JSON.stringify(c) === JSON.stringify(h) ? c : h;
+    });
+  }
+  const s = ei({
+    callback(c) {
+      if (e)
+        for (const l of c) {
+          const {
+            type: h,
+            target: f
+          } = l;
+          if (h === "childList" && f instanceof HTMLElement && f.contains(e)) {
+            i();
+            break;
+          }
+        }
+    }
+  }), a = kt({
+    callback: i
+  });
+  return pe(() => {
+    i(), e ? (a?.observe(e), s?.observe(document.body, {
+      childList: !0,
+      subtree: !0
+    })) : (a?.disconnect(), s?.disconnect());
+  }, [e]), r;
+}
+function ni(e) {
+  const t = dr(e);
+  return nr(e, t);
+}
+const Wn = [];
+function ri(e) {
+  const t = M(e), n = dt((r) => e ? r && r !== Wn && e && t.current && e.parentNode === t.current.parentNode ? r : dn(e) : Wn, [e]);
+  return L(() => {
+    t.current = e;
+  }, [e]), n;
+}
+function oi(e) {
+  const [t, n] = re(null), r = M(e), o = G((i) => {
+    const s = Ut(i.target);
+    s && n((a) => a ? (a.set(s, tn(s)), new Map(a)) : null);
+  }, []);
+  return L(() => {
+    const i = r.current;
+    if (e !== i) {
+      s(i);
+      const a = e.map((c) => {
+        const l = Ut(c);
+        return l ? (l.addEventListener("scroll", o, {
+          passive: !0
+        }), [l, tn(l)]) : null;
+      }).filter((c) => c != null);
+      n(a.length ? new Map(a) : null), r.current = e;
+    }
+    return () => {
+      s(e), s(i);
+    };
+    function s(a) {
+      a.forEach((c) => {
+        const l = Ut(c);
+        l?.removeEventListener("scroll", o);
+      });
+    }
+  }, [o, e]), A(() => e.length ? t ? Array.from(t.values()).reduce((i, s) => Fe(i, s), ce) : lr(e) : ce, [e, t]);
+}
+function Hn(e, t) {
+  t === void 0 && (t = []);
+  const n = M(null);
+  return L(
+    () => {
+      n.current = null;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), L(() => {
+    const r = e !== ce;
+    r && !n.current && (n.current = e), !r && n.current && (n.current = null);
+  }, [e]), n.current ? _t(e, n.current) : ce;
+}
+function ii(e) {
+  L(
+    () => {
+      if (!At)
+        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 si(e, t) {
+  return A(() => e.reduce((n, r) => {
+    let {
+      eventName: o,
+      handler: i
+    } = r;
+    return n[o] = (s) => {
+      i(s, t);
+    }, n;
+  }, {}), [e, t]);
+}
+function fr(e) {
+  return A(() => e ? jo(e) : null, [e]);
+}
+const Yn = [];
+function ai(e, t) {
+  t === void 0 && (t = Ye);
+  const [n] = e, r = fr(n ? K(n) : null), [o, i] = re(Yn);
+  function s() {
+    i(() => e.length ? e.map((c) => sr(c) ? r : new fn(t(c), c)) : Yn);
+  }
+  const a = kt({
+    callback: s
+  });
+  return pe(() => {
+    a?.disconnect(), s(), e.forEach((c) => a?.observe(c));
+  }, [e]), o;
+}
+function li(e) {
+  if (!e)
+    return null;
+  if (e.children.length > 1)
+    return e;
+  const t = e.children[0];
+  return ut(t) ? t : e;
+}
+function ci(e) {
+  let {
+    measure: t
+  } = e;
+  const [n, r] = re(null), o = G((l) => {
+    for (const {
+      target: h
+    } of l)
+      if (ut(h)) {
+        r((f) => {
+          const p = t(h);
+          return f ? {
+            ...f,
+            width: p.width,
+            height: p.height
+          } : p;
+        });
+        break;
+      }
+  }, [t]), i = kt({
+    callback: o
+  }), s = G((l) => {
+    const h = li(l);
+    i?.disconnect(), h && i?.observe(h), r(h ? t(h) : null);
+  }, [t, i]), [a, c] = Dt(s);
+  return A(() => ({
+    nodeRef: a,
+    rect: n,
+    setRef: c
+  }), [n, a, c]);
+}
+const ui = [{
+  sensor: vn,
+  options: {}
+}, {
+  sensor: ur,
+  options: {}
+}], di = {
+  current: {}
+}, Rt = {
+  draggable: {
+    measure: Pn
+  },
+  droppable: {
+    measure: Pn,
+    strategy: it.WhileDragging,
+    frequency: rn.Optimized
+  },
+  dragOverlay: {
+    measure: Ye
+  }
+};
+class rt 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 fi = {
+  activatorEvent: null,
+  active: null,
+  activeNode: null,
+  activeNodeRect: null,
+  collisions: null,
+  containerNodeRect: null,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  droppableRects: /* @__PURE__ */ new Map(),
+  droppableContainers: /* @__PURE__ */ new rt(),
+  over: null,
+  dragOverlay: {
+    nodeRef: {
+      current: null
+    },
+    rect: null,
+    setRef: Ot
+  },
+  scrollableAncestors: [],
+  scrollableAncestorRects: [],
+  measuringConfiguration: Rt,
+  measureDroppableContainers: Ot,
+  windowRect: null,
+  measuringScheduled: !1
+}, hi = {
+  activatorEvent: null,
+  activators: [],
+  active: null,
+  activeNodeRect: null,
+  ariaDescribedById: {
+    draggable: ""
+  },
+  dispatch: Ot,
+  draggableNodes: /* @__PURE__ */ new Map(),
+  over: null,
+  measureDroppableContainers: Ot
+}, Nt = /* @__PURE__ */ st(hi), hr = /* @__PURE__ */ st(fi);
+function vi() {
+  return {
+    draggable: {
+      active: null,
+      initialCoordinates: {
+        x: 0,
+        y: 0
+      },
+      nodes: /* @__PURE__ */ new Map(),
+      translate: {
+        x: 0,
+        y: 0
+      }
+    },
+    droppable: {
+      containers: new rt()
+    }
+  };
+}
+function gi(e, t) {
+  switch (t.type) {
+    case V.DragStart:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          initialCoordinates: t.initialCoordinates,
+          active: t.active
+        }
+      };
+    case V.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 V.DragEnd:
+    case V.DragCancel:
+      return {
+        ...e,
+        draggable: {
+          ...e.draggable,
+          active: null,
+          initialCoordinates: {
+            x: 0,
+            y: 0
+          },
+          translate: {
+            x: 0,
+            y: 0
+          }
+        }
+      };
+    case V.RegisterDroppable: {
+      const {
+        element: n
+      } = t, {
+        id: r
+      } = n, o = new rt(e.droppable.containers);
+      return o.set(r, n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: o
+        }
+      };
+    }
+    case V.SetDroppableDisabled: {
+      const {
+        id: n,
+        key: r,
+        disabled: o
+      } = t, i = e.droppable.containers.get(n);
+      if (!i || r !== i.key)
+        return e;
+      const s = new rt(e.droppable.containers);
+      return s.set(n, {
+        ...i,
+        disabled: o
+      }), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: s
+        }
+      };
+    }
+    case V.UnregisterDroppable: {
+      const {
+        id: n,
+        key: r
+      } = t, o = e.droppable.containers.get(n);
+      if (!o || r !== o.key)
+        return e;
+      const i = new rt(e.droppable.containers);
+      return i.delete(n), {
+        ...e,
+        droppable: {
+          ...e.droppable,
+          containers: i
+        }
+      };
+    }
+    default:
+      return e;
+  }
+}
+function pi(e) {
+  let {
+    disabled: t
+  } = e;
+  const {
+    active: n,
+    activatorEvent: r,
+    draggableNodes: o
+  } = Ae(Nt), i = Qt(r), s = Qt(n?.id);
+  return L(() => {
+    if (!t && !r && i && s != null) {
+      if (!un(i) || document.activeElement === i.target)
+        return;
+      const a = o.get(s);
+      if (!a)
+        return;
+      const {
+        activatorNode: c,
+        node: l
+      } = a;
+      if (!c.current && !l.current)
+        return;
+      requestAnimationFrame(() => {
+        for (const h of [c.current, l.current]) {
+          if (!h)
+            continue;
+          const f = io(h);
+          if (f) {
+            f.focus();
+            break;
+          }
+        }
+      });
+    }
+  }, [r, t, o, s, i]), null;
+}
+function bi(e, t) {
+  let {
+    transform: n,
+    ...r
+  } = t;
+  return e != null && e.length ? e.reduce((o, i) => i({
+    transform: o,
+    ...r
+  }), n) : n;
+}
+function mi(e) {
+  return A(
+    () => ({
+      draggable: {
+        ...Rt.draggable,
+        ...e?.draggable
+      },
+      droppable: {
+        ...Rt.droppable,
+        ...e?.droppable
+      },
+      dragOverlay: {
+        ...Rt.dragOverlay,
+        ...e?.dragOverlay
+      }
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e?.draggable, e?.droppable, e?.dragOverlay]
+  );
+}
+function xi(e) {
+  let {
+    activeNode: t,
+    measure: n,
+    initialRect: r,
+    config: o = !0
+  } = e;
+  const i = M(!1), {
+    x: s,
+    y: a
+  } = typeof o == "boolean" ? {
+    x: o,
+    y: o
+  } : o;
+  pe(() => {
+    if (!s && !a || !t) {
+      i.current = !1;
+      return;
+    }
+    if (i.current || !r)
+      return;
+    const l = t?.node.current;
+    if (!l || l.isConnected === !1)
+      return;
+    const h = n(l), f = nr(h, r);
+    if (s || (f.x = 0), a || (f.y = 0), i.current = !0, Math.abs(f.x) > 0 || Math.abs(f.y) > 0) {
+      const p = rr(l);
+      p && p.scrollBy({
+        top: f.y,
+        left: f.x
+      });
+    }
+  }, [t, s, a, r, n]);
+}
+const vr = /* @__PURE__ */ st({
+  ...ce,
+  scaleX: 1,
+  scaleY: 1
+});
+var Oe;
+(function(e) {
+  e[e.Uninitialized = 0] = "Uninitialized", e[e.Initializing = 1] = "Initializing", e[e.Initialized = 2] = "Initialized";
+})(Oe || (Oe = {}));
+const gr = /* @__PURE__ */ Nr(function(t) {
+  var n, r, o, i;
+  let {
+    id: s,
+    accessibility: a,
+    autoScroll: c = !0,
+    children: l,
+    sensors: h = ui,
+    collisionDetection: f = Ro,
+    measuring: p,
+    modifiers: d,
+    ...m
+  } = t;
+  const g = Lr(gi, void 0, vi), [b, x] = g, [w, C] = fo(), [E, O] = re(Oe.Uninitialized), S = E === Oe.Initialized, {
+    draggable: {
+      active: R,
+      nodes: D,
+      translate: P
+    },
+    droppable: {
+      containers: $
+    }
+  } = b, N = R != null ? D.get(R) : null, q = M({
+    initial: null,
+    translated: null
+  }), J = A(() => {
+    var U;
+    return R != null ? {
+      id: R,
+      // It's possible for the active node to unmount while dragging
+      data: (U = N?.data) != null ? U : di,
+      rect: q
+    } : null;
+  }, [R, N]), oe = M(null), [me, je] = re(null), [H, Ie] = re(null), ie = ot(m, Object.values(m)), Se = ft("DndDescribedBy", s), v = A(() => $.getEnabled(), [$]), y = mi(p), {
+    droppableRects: T,
+    measureDroppableContainers: k,
+    measuringScheduled: ue
+  } = Zo(v, {
+    dragging: S,
+    dependencies: [P.x, P.y],
+    config: y.droppable
+  }), Y = Jo(D, R), z = A(() => H ? en(H) : null, [H]), X = Ar(), Q = Qo(Y, y.draggable.measure);
+  xi({
+    activeNode: R != null ? D.get(R) : null,
+    config: X.layoutShiftCompensation,
+    initialRect: Q,
+    measure: y.draggable.measure
+  });
+  const I = Bn(Y, y.draggable.measure, Q), Ue = Bn(Y ? Y.parentElement : null), de = M({
+    activatorEvent: null,
+    active: null,
+    activeNode: Y,
+    collisionRect: null,
+    collisions: null,
+    droppableRects: T,
+    draggableNodes: D,
+    draggingNode: null,
+    draggingNodeRect: null,
+    droppableContainers: $,
+    over: null,
+    scrollableAncestors: [],
+    scrollAdjustedTranslate: null
+  }), Ne = $.getNodeFor((n = de.current.over) == null ? void 0 : n.id), xe = ci({
+    measure: y.dragOverlay.measure
+  }), Le = (r = xe.nodeRef.current) != null ? r : Y, Me = S ? (o = xe.rect) != null ? o : I : null, pn = !!(xe.nodeRef.current && xe.rect), bn = ni(pn ? null : I), Mt = fr(Le ? K(Le) : null), Re = ri(S ? Ne ?? Y : null), ht = ai(Re), vt = bi(d, {
+    transform: {
+      x: P.x - bn.x,
+      y: P.y - bn.y,
+      scaleX: 1,
+      scaleY: 1
+    },
+    activatorEvent: H,
+    active: J,
+    activeNodeRect: I,
+    containerNodeRect: Ue,
+    draggingNodeRect: Me,
+    over: de.current.over,
+    overlayNodeRect: xe.rect,
+    scrollableAncestors: Re,
+    scrollableAncestorRects: ht,
+    windowRect: Mt
+  }), mn = z ? Fe(z, P) : null, xn = oi(Re), Er = Hn(xn), Dr = Hn(xn, [I]), Pe = Fe(vt, Er), ze = Me ? Do(Me, vt) : null, Ge = J && ze ? f({
+    active: J,
+    collisionRect: ze,
+    droppableRects: T,
+    droppableContainers: v,
+    pointerCoordinates: mn
+  }) : null, yn = wo(Ge, "id"), [Ce, wn] = re(null), _r = pn ? vt : Fe(vt, Dr), Or = Co(_r, (i = Ce?.rect) != null ? i : null, I), Pt = M(null), Sn = G(
+    (U, ee) => {
+      let {
+        sensor: te,
+        options: Ee
+      } = ee;
+      if (oe.current == null)
+        return;
+      const se = D.get(oe.current);
+      if (!se)
+        return;
+      const ne = U.nativeEvent, fe = new te({
+        active: oe.current,
+        activeNode: se,
+        event: ne,
+        options: Ee,
+        // Sensors need to be instantiated with refs for arguments that change over time
+        // otherwise they are frozen in time with the stale arguments
+        context: de,
+        onAbort(W) {
+          if (!D.get(W))
+            return;
+          const {
+            onDragAbort: he
+          } = ie.current, ye = {
+            id: W
+          };
+          he?.(ye), w({
+            type: "onDragAbort",
+            event: ye
+          });
+        },
+        onPending(W, De, he, ye) {
+          if (!D.get(W))
+            return;
+          const {
+            onDragPending: Xe
+          } = ie.current, _e = {
+            id: W,
+            constraint: De,
+            initialCoordinates: he,
+            offset: ye
+          };
+          Xe?.(_e), w({
+            type: "onDragPending",
+            event: _e
+          });
+        },
+        onStart(W) {
+          const De = oe.current;
+          if (De == null)
+            return;
+          const he = D.get(De);
+          if (!he)
+            return;
+          const {
+            onDragStart: ye
+          } = ie.current, qe = {
+            activatorEvent: ne,
+            active: {
+              id: De,
+              data: he.data,
+              rect: q
+            }
+          };
+          gt(() => {
+            ye?.(qe), O(Oe.Initializing), x({
+              type: V.DragStart,
+              initialCoordinates: W,
+              active: De
+            }), w({
+              type: "onDragStart",
+              event: qe
+            }), je(Pt.current), Ie(ne);
+          });
+        },
+        onMove(W) {
+          x({
+            type: V.DragMove,
+            coordinates: W
+          });
+        },
+        onEnd: $e(V.DragEnd),
+        onCancel: $e(V.DragCancel)
+      });
+      Pt.current = fe;
+      function $e(W) {
+        return async function() {
+          const {
+            active: he,
+            collisions: ye,
+            over: qe,
+            scrollAdjustedTranslate: Xe
+          } = de.current;
+          let _e = null;
+          if (he && Xe) {
+            const {
+              cancelDrop: Je
+            } = ie.current;
+            _e = {
+              activatorEvent: ne,
+              active: he,
+              collisions: ye,
+              delta: Xe,
+              over: qe
+            }, W === V.DragEnd && typeof Je == "function" && await Promise.resolve(Je(_e)) && (W = V.DragCancel);
+          }
+          oe.current = null, gt(() => {
+            x({
+              type: W
+            }), O(Oe.Uninitialized), wn(null), je(null), Ie(null), Pt.current = null;
+            const Je = W === V.DragEnd ? "onDragEnd" : "onDragCancel";
+            if (_e) {
+              const zt = ie.current[Je];
+              zt?.(_e), w({
+                type: Je,
+                event: _e
+              });
+            }
+          });
+        };
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [D]
+  ), Tr = G((U, ee) => (te, Ee) => {
+    const se = te.nativeEvent, ne = D.get(Ee);
+    if (
+      // Another sensor is already instantiating
+      oe.current !== null || // No active draggable
+      !ne || // Event has already been captured
+      se.dndKit || se.defaultPrevented
+    )
+      return;
+    const fe = {
+      active: ne
+    };
+    U(te, ee.options, fe) === !0 && (se.dndKit = {
+      capturedBy: ee.sensor
+    }, oe.current = Ee, Sn(te, ee));
+  }, [D, Sn]), Rn = Ko(h, Tr);
+  ii(h), pe(() => {
+    I && E === Oe.Initializing && O(Oe.Initialized);
+  }, [I, E]), L(
+    () => {
+      const {
+        onDragMove: U
+      } = ie.current, {
+        active: ee,
+        activatorEvent: te,
+        collisions: Ee,
+        over: se
+      } = de.current;
+      if (!ee || !te)
+        return;
+      const ne = {
+        active: ee,
+        activatorEvent: te,
+        collisions: Ee,
+        delta: {
+          x: Pe.x,
+          y: Pe.y
+        },
+        over: se
+      };
+      gt(() => {
+        U?.(ne), w({
+          type: "onDragMove",
+          event: ne
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [Pe.x, Pe.y]
+  ), L(
+    () => {
+      const {
+        active: U,
+        activatorEvent: ee,
+        collisions: te,
+        droppableContainers: Ee,
+        scrollAdjustedTranslate: se
+      } = de.current;
+      if (!U || oe.current == null || !ee || !se)
+        return;
+      const {
+        onDragOver: ne
+      } = ie.current, fe = Ee.get(yn), $e = fe && fe.rect.current ? {
+        id: fe.id,
+        rect: fe.rect.current,
+        data: fe.data,
+        disabled: fe.disabled
+      } : null, W = {
+        active: U,
+        activatorEvent: ee,
+        collisions: te,
+        delta: {
+          x: se.x,
+          y: se.y
+        },
+        over: $e
+      };
+      gt(() => {
+        wn($e), ne?.(W), w({
+          type: "onDragOver",
+          event: W
+        });
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [yn]
+  ), pe(() => {
+    de.current = {
+      activatorEvent: H,
+      active: J,
+      activeNode: Y,
+      collisionRect: ze,
+      collisions: Ge,
+      droppableRects: T,
+      draggableNodes: D,
+      draggingNode: Le,
+      draggingNodeRect: Me,
+      droppableContainers: $,
+      over: Ce,
+      scrollableAncestors: Re,
+      scrollAdjustedTranslate: Pe
+    }, q.current = {
+      initial: Me,
+      translated: ze
+    };
+  }, [J, Y, Ge, ze, D, Le, Me, T, $, Ce, Re, Pe]), Go({
+    ...X,
+    delta: P,
+    draggingRect: ze,
+    pointerCoordinates: mn,
+    scrollableAncestors: Re,
+    scrollableAncestorRects: ht
+  });
+  const jr = A(() => ({
+    active: J,
+    activeNode: Y,
+    activeNodeRect: I,
+    activatorEvent: H,
+    collisions: Ge,
+    containerNodeRect: Ue,
+    dragOverlay: xe,
+    draggableNodes: D,
+    droppableContainers: $,
+    droppableRects: T,
+    over: Ce,
+    measureDroppableContainers: k,
+    scrollableAncestors: Re,
+    scrollableAncestorRects: ht,
+    measuringConfiguration: y,
+    measuringScheduled: ue,
+    windowRect: Mt
+  }), [J, Y, I, H, Ge, Ue, xe, D, $, T, Ce, k, Re, ht, y, ue, Mt]), Ir = A(() => ({
+    activatorEvent: H,
+    activators: Rn,
+    active: J,
+    activeNodeRect: I,
+    ariaDescribedById: {
+      draggable: Se
+    },
+    dispatch: x,
+    draggableNodes: D,
+    over: Ce,
+    measureDroppableContainers: k
+  }), [H, Rn, J, I, x, Se, D, Ce, k]);
+  return F.createElement(er.Provider, {
+    value: C
+  }, F.createElement(Nt.Provider, {
+    value: Ir
+  }, F.createElement(hr.Provider, {
+    value: jr
+  }, F.createElement(vr.Provider, {
+    value: Or
+  }, l)), F.createElement(pi, {
+    disabled: a?.restoreFocus === !1
+  })), F.createElement(go, {
+    ...a,
+    hiddenTextDescribedById: Se
+  }));
+  function Ar() {
+    const U = me?.autoScrollEnabled === !1, ee = typeof c == "object" ? c.enabled === !1 : c === !1, te = S && !U && !ee;
+    return typeof c == "object" ? {
+      ...c,
+      enabled: te
+    } : {
+      enabled: te
+    };
+  }
+}), yi = /* @__PURE__ */ st(null), Un = "button", wi = "Draggable";
+function Si(e) {
+  let {
+    id: t,
+    data: n,
+    disabled: r = !1,
+    attributes: o
+  } = e;
+  const i = ft(wi), {
+    activators: s,
+    activatorEvent: a,
+    active: c,
+    activeNodeRect: l,
+    ariaDescribedById: h,
+    draggableNodes: f,
+    over: p
+  } = Ae(Nt), {
+    role: d = Un,
+    roleDescription: m = "draggable",
+    tabIndex: g = 0
+  } = o ?? {}, b = c?.id === t, x = Ae(b ? vr : yi), [w, C] = Dt(), [E, O] = Dt(), S = si(s, t), R = ot(n);
+  pe(
+    () => (f.set(t, {
+      id: t,
+      key: i,
+      node: w,
+      activatorNode: E,
+      data: R
+    }), () => {
+      const P = f.get(t);
+      P && P.key === i && f.delete(t);
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [f, t]
+  );
+  const D = A(() => ({
+    role: d,
+    tabIndex: g,
+    "aria-disabled": r,
+    "aria-pressed": b && d === Un ? !0 : void 0,
+    "aria-roledescription": m,
+    "aria-describedby": h.draggable
+  }), [r, d, g, b, m, h.draggable]);
+  return {
+    active: c,
+    activatorEvent: a,
+    activeNodeRect: l,
+    attributes: D,
+    isDragging: b,
+    listeners: r ? void 0 : S,
+    node: w,
+    over: p,
+    setNodeRef: C,
+    setActivatorNodeRef: O,
+    transform: x
+  };
+}
+function Ri() {
+  return Ae(hr);
+}
+const Ci = "Droppable", Ei = {
+  timeout: 25
+};
+function Di(e) {
+  let {
+    data: t,
+    disabled: n = !1,
+    id: r,
+    resizeObserverConfig: o
+  } = e;
+  const i = ft(Ci), {
+    active: s,
+    dispatch: a,
+    over: c,
+    measureDroppableContainers: l
+  } = Ae(Nt), h = M({
+    disabled: n
+  }), f = M(!1), p = M(null), d = M(null), {
+    disabled: m,
+    updateMeasurementsFor: g,
+    timeout: b
+  } = {
+    ...Ei,
+    ...o
+  }, x = ot(g ?? r), w = G(
+    () => {
+      if (!f.current) {
+        f.current = !0;
+        return;
+      }
+      d.current != null && clearTimeout(d.current), d.current = setTimeout(() => {
+        l(Array.isArray(x.current) ? x.current : [x.current]), d.current = null;
+      }, b);
+    },
+    //eslint-disable-next-line react-hooks/exhaustive-deps
+    [b]
+  ), C = kt({
+    callback: w,
+    disabled: m || !s
+  }), E = G((D, P) => {
+    C && (P && (C.unobserve(P), f.current = !1), D && C.observe(D));
+  }, [C]), [O, S] = Dt(E), R = ot(t);
+  return L(() => {
+    !C || !O.current || (C.disconnect(), f.current = !1, C.observe(O.current));
+  }, [O, C]), L(
+    () => (a({
+      type: V.RegisterDroppable,
+      element: {
+        id: r,
+        key: i,
+        disabled: n,
+        node: O,
+        rect: p,
+        data: R
+      }
+    }), () => a({
+      type: V.UnregisterDroppable,
+      key: i,
+      id: r
+    })),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), L(() => {
+    n !== h.current.disabled && (a({
+      type: V.SetDroppableDisabled,
+      id: r,
+      key: i,
+      disabled: n
+    }), h.current.disabled = n);
+  }, [r, i, n, a]), {
+    active: s,
+    rect: p,
+    isOver: c?.id === r,
+    node: O,
+    over: c,
+    setNodeRef: S
+  };
+}
+function Lt(e, t, n) {
+  const r = e.slice();
+  return r.splice(n < 0 ? r.length + n : n, 0, r.splice(t, 1)[0]), r;
+}
+function _i(e, t) {
+  return e.reduce((n, r, o) => {
+    const i = t.get(r);
+    return i && (n[o] = i), n;
+  }, Array(e.length));
+}
+function yt(e) {
+  return e !== null && e >= 0;
+}
+function Oi(e, t) {
+  if (e === t)
+    return !0;
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+function Ti(e) {
+  return typeof e == "boolean" ? {
+    draggable: e,
+    droppable: e
+  } : e;
+}
+const wt = {
+  scaleX: 1,
+  scaleY: 1
+}, ji = (e) => {
+  var t;
+  let {
+    rects: n,
+    activeNodeRect: r,
+    activeIndex: o,
+    overIndex: i,
+    index: s
+  } = e;
+  const a = (t = n[o]) != null ? t : r;
+  if (!a)
+    return null;
+  const c = Ii(n, s, o);
+  if (s === o) {
+    const l = n[i];
+    return l ? {
+      x: o < i ? l.left + l.width - (a.left + a.width) : l.left - a.left,
+      y: 0,
+      ...wt
+    } : null;
+  }
+  return s > o && s <= i ? {
+    x: -a.width - c,
+    y: 0,
+    ...wt
+  } : s < o && s >= i ? {
+    x: a.width + c,
+    y: 0,
+    ...wt
+  } : {
+    x: 0,
+    y: 0,
+    ...wt
+  };
+};
+function Ii(e, t, n) {
+  const r = e[t], o = e[t - 1], i = e[t + 1];
+  return !r || !o && !i ? 0 : n < t ? o ? r.left - (o.left + o.width) : i.left - (r.left + r.width) : i ? i.left - (r.left + r.width) : r.left - (o.left + o.width);
+}
+const pr = (e) => {
+  let {
+    rects: t,
+    activeIndex: n,
+    overIndex: r,
+    index: o
+  } = e;
+  const i = Lt(t, r, n), s = t[o], a = i[o];
+  return !a || !s ? null : {
+    x: a.left - s.left,
+    y: a.top - s.top,
+    scaleX: a.width / s.width,
+    scaleY: a.height / s.height
+  };
+}, St = {
+  scaleX: 1,
+  scaleY: 1
+}, Ai = (e) => {
+  var t;
+  let {
+    activeIndex: n,
+    activeNodeRect: r,
+    index: o,
+    rects: i,
+    overIndex: s
+  } = e;
+  const a = (t = i[n]) != null ? t : r;
+  if (!a)
+    return null;
+  if (o === n) {
+    const l = i[s];
+    return l ? {
+      x: 0,
+      y: n < s ? l.top + l.height - (a.top + a.height) : l.top - a.top,
+      ...St
+    } : null;
+  }
+  const c = ki(i, o, n);
+  return o > n && o <= s ? {
+    x: 0,
+    y: -a.height - c,
+    ...St
+  } : o < n && o >= s ? {
+    x: 0,
+    y: a.height + c,
+    ...St
+  } : {
+    x: 0,
+    y: 0,
+    ...St
+  };
+};
+function ki(e, t, n) {
+  const r = e[t], o = e[t - 1], i = e[t + 1];
+  return r ? n < t ? o ? r.top - (o.top + o.height) : i ? i.top - (r.top + r.height) : 0 : i ? i.top - (r.top + r.height) : o ? r.top - (o.top + o.height) : 0 : 0;
+}
+const br = "Sortable", mr = /* @__PURE__ */ F.createContext({
+  activeIndex: -1,
+  containerId: br,
+  disableTransforms: !1,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: !1,
+  sortedRects: [],
+  strategy: pr,
+  disabled: {
+    draggable: !1,
+    droppable: !1
+  }
+});
+function xr(e) {
+  let {
+    children: t,
+    id: n,
+    items: r,
+    strategy: o = pr,
+    disabled: i = !1
+  } = e;
+  const {
+    active: s,
+    dragOverlay: a,
+    droppableRects: c,
+    over: l,
+    measureDroppableContainers: h
+  } = Ri(), f = ft(br, n), p = a.rect !== null, d = A(() => r.map((S) => typeof S == "object" && "id" in S ? S.id : S), [r]), m = s != null, g = s ? d.indexOf(s.id) : -1, b = l ? d.indexOf(l.id) : -1, x = M(d), w = !Oi(d, x.current), C = b !== -1 && g === -1 || w, E = Ti(i);
+  pe(() => {
+    w && m && h(d);
+  }, [w, d, m, h]), L(() => {
+    x.current = d;
+  }, [d]);
+  const O = A(
+    () => ({
+      activeIndex: g,
+      containerId: f,
+      disabled: E,
+      disableTransforms: C,
+      items: d,
+      overIndex: b,
+      useDragOverlay: p,
+      sortedRects: _i(d, c),
+      strategy: o
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [g, f, E.draggable, E.droppable, C, d, b, c, p, o]
+  );
+  return F.createElement(mr.Provider, {
+    value: O
+  }, t);
+}
+const Ni = (e) => {
+  let {
+    id: t,
+    items: n,
+    activeIndex: r,
+    overIndex: o
+  } = e;
+  return Lt(n, r, o).indexOf(t);
+}, Li = (e) => {
+  let {
+    containerId: t,
+    isSorting: n,
+    wasDragging: r,
+    index: o,
+    items: i,
+    newIndex: s,
+    previousItems: a,
+    previousContainerId: c,
+    transition: l
+  } = e;
+  return !l || !r || a !== i && o === s ? !1 : n ? !0 : s !== o && t === c;
+}, Mi = {
+  duration: 200,
+  easing: "ease"
+}, yr = "transform", Pi = /* @__PURE__ */ Be.Transition.toString({
+  property: yr,
+  duration: 0,
+  easing: "linear"
+}), zi = {
+  roleDescription: "sortable"
+};
+function $i(e) {
+  let {
+    disabled: t,
+    index: n,
+    node: r,
+    rect: o
+  } = e;
+  const [i, s] = re(null), a = M(n);
+  return pe(() => {
+    if (!t && n !== a.current && r.current) {
+      const c = o.current;
+      if (c) {
+        const l = Ye(r.current, {
+          ignoreTransform: !0
+        }), h = {
+          x: c.left - l.left,
+          y: c.top - l.top,
+          scaleX: c.width / l.width,
+          scaleY: c.height / l.height
+        };
+        (h.x || h.y) && s(h);
+      }
+    }
+    n !== a.current && (a.current = n);
+  }, [t, n, r, o]), L(() => {
+    i && s(null);
+  }, [i]), i;
+}
+function wr(e) {
+  let {
+    animateLayoutChanges: t = Li,
+    attributes: n,
+    disabled: r,
+    data: o,
+    getNewIndex: i = Ni,
+    id: s,
+    strategy: a,
+    resizeObserverConfig: c,
+    transition: l = Mi
+  } = e;
+  const {
+    items: h,
+    containerId: f,
+    activeIndex: p,
+    disabled: d,
+    disableTransforms: m,
+    sortedRects: g,
+    overIndex: b,
+    useDragOverlay: x,
+    strategy: w
+  } = Ae(mr), C = Vi(r, d), E = h.indexOf(s), O = A(() => ({
+    sortable: {
+      containerId: f,
+      index: E,
+      items: h
+    },
+    ...o
+  }), [f, o, E, h]), S = A(() => h.slice(h.indexOf(s)), [h, s]), {
+    rect: R,
+    node: D,
+    isOver: P,
+    setNodeRef: $
+  } = Di({
+    id: s,
+    data: O,
+    disabled: C.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: S,
+      ...c
+    }
+  }), {
+    active: N,
+    activatorEvent: q,
+    activeNodeRect: J,
+    attributes: oe,
+    setNodeRef: me,
+    listeners: je,
+    isDragging: H,
+    over: Ie,
+    setActivatorNodeRef: ie,
+    transform: Se
+  } = Si({
+    id: s,
+    data: O,
+    attributes: {
+      ...zi,
+      ...n
+    },
+    disabled: C.draggable
+  }), v = to($, me), y = !!N, T = y && !m && yt(p) && yt(b), k = !x && H, ue = k && T ? Se : null, z = T ? ue ?? (a ?? w)({
+    rects: g,
+    activeNodeRect: J,
+    activeIndex: p,
+    overIndex: b,
+    index: E
+  }) : null, X = yt(p) && yt(b) ? i({
+    id: s,
+    items: h,
+    activeIndex: p,
+    overIndex: b
+  }) : E, Q = N?.id, I = M({
+    activeId: Q,
+    items: h,
+    newIndex: X,
+    containerId: f
+  }), Ue = h !== I.current.items, de = t({
+    active: N,
+    containerId: f,
+    isDragging: H,
+    isSorting: y,
+    id: s,
+    index: E,
+    items: h,
+    newIndex: I.current.newIndex,
+    previousItems: I.current.items,
+    previousContainerId: I.current.containerId,
+    transition: l,
+    wasDragging: I.current.activeId != null
+  }), Ne = $i({
+    disabled: !de,
+    index: E,
+    node: D,
+    rect: R
+  });
+  return L(() => {
+    y && I.current.newIndex !== X && (I.current.newIndex = X), f !== I.current.containerId && (I.current.containerId = f), h !== I.current.items && (I.current.items = h);
+  }, [y, X, f, h]), L(() => {
+    if (Q === I.current.activeId)
+      return;
+    if (Q != null && I.current.activeId == null) {
+      I.current.activeId = Q;
+      return;
+    }
+    const Le = setTimeout(() => {
+      I.current.activeId = Q;
+    }, 50);
+    return () => clearTimeout(Le);
+  }, [Q]), {
+    active: N,
+    activeIndex: p,
+    attributes: oe,
+    data: O,
+    rect: R,
+    index: E,
+    newIndex: X,
+    items: h,
+    isOver: P,
+    isSorting: y,
+    isDragging: H,
+    listeners: je,
+    node: D,
+    overIndex: b,
+    over: Ie,
+    setNodeRef: v,
+    setActivatorNodeRef: ie,
+    setDroppableNodeRef: $,
+    setDraggableNodeRef: me,
+    transform: Ne ?? z,
+    transition: xe()
+  };
+  function xe() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      Ne || // Or to prevent items jumping to back to their "new" position when items change
+      Ue && I.current.newIndex === E
+    )
+      return Pi;
+    if (!(k && !un(q) || !l) && (y || de))
+      return Be.Transition.toString({
+        ...l,
+        property: yr
+      });
+  }
+}
+function Vi(e, t) {
+  var n, r;
+  return typeof e == "boolean" ? {
+    draggable: e,
+    // Backwards compatibility
+    droppable: !1
+  } : {
+    draggable: (n = e?.draggable) != null ? n : t.draggable,
+    droppable: (r = e?.droppable) != null ? r : t.droppable
+  };
+}
+j.Down, j.Right, j.Up, j.Left;
+const Fi = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), Bi = (e) => e.replace(
+  /^([A-Z])|[\s-_]+(\w)/g,
+  (t, n, r) => r ? r.toUpperCase() : n.toLowerCase()
+), Gn = (e) => {
+  const t = Bi(e);
+  return t.charAt(0).toUpperCase() + t.slice(1);
+}, Sr = (...e) => e.filter((t, n, r) => !!t && t.trim() !== "" && r.indexOf(t) === n).join(" ").trim(), Wi = (e) => {
+  for (const t in e)
+    if (t.startsWith("aria-") || t === "role" || t === "title")
+      return !0;
+};
+var Hi = {
+  xmlns: "http://www.w3.org/2000/svg",
+  width: 24,
+  height: 24,
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  strokeWidth: 2,
+  strokeLinecap: "round",
+  strokeLinejoin: "round"
+};
+const Yi = on(
+  ({
+    color: e = "currentColor",
+    size: t = 24,
+    strokeWidth: n = 2,
+    absoluteStrokeWidth: r,
+    className: o = "",
+    children: i,
+    iconNode: s,
+    ...a
+  }, c) => Kt(
+    "svg",
+    {
+      ref: c,
+      ...Hi,
+      width: t,
+      height: t,
+      stroke: e,
+      strokeWidth: r ? Number(n) * 24 / Number(t) : n,
+      className: Sr("lucide", o),
+      ...!i && !Wi(a) && { "aria-hidden": "true" },
+      ...a
+    },
+    [
+      ...s.map(([l, h]) => Kt(l, h)),
+      ...Array.isArray(i) ? i : [i]
+    ]
+  )
+);
+const Z = (e, t) => {
+  const n = on(
+    ({ className: r, ...o }, i) => Kt(Yi, {
+      ref: i,
+      iconNode: t,
+      className: Sr(
+        `lucide-${Fi(Gn(e))}`,
+        `lucide-${e}`,
+        r
+      ),
+      ...o
+    })
+  );
+  return n.displayName = Gn(e), n;
+};
+const Ui = [
+  ["path", { d: "M12 5v14", key: "s699le" }],
+  ["path", { d: "m19 12-7 7-7-7", key: "1idqje" }]
+], Gi = Z("arrow-down", Ui);
+const qi = [
+  ["path", { d: "m21 16-4 4-4-4", key: "f6ql7i" }],
+  ["path", { d: "M17 20V4", key: "1ejh1v" }],
+  ["path", { d: "m3 8 4-4 4 4", key: "11wl7u" }],
+  ["path", { d: "M7 4v16", key: "1glfcx" }]
+], Xi = Z("arrow-up-down", qi);
+const Ji = [
+  ["path", { d: "m5 12 7-7 7 7", key: "hav0vg" }],
+  ["path", { d: "M12 19V5", key: "x0mq9r" }]
+], Ki = Z("arrow-up", Ji);
+const Zi = [
+  ["path", { d: "m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z", key: "1fy3hk" }]
+], Qi = Z("bookmark", Zi);
+const es = [["path", { d: "m15 18-6-6 6-6", key: "1wnfg3" }]], ts = Z("chevron-left", es);
+const ns = [["path", { d: "m9 18 6-6-6-6", key: "mthhwq" }]], rs = Z("chevron-right", ns);
+const os = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", key: "afitv7" }],
+  ["path", { d: "M12 3v18", key: "108xh3" }]
+], is = Z("columns-2", os);
+const ss = [
+  [
+    "path",
+    {
+      d: "M10 5a2 2 0 0 0-1.344.519l-6.328 5.74a1 1 0 0 0 0 1.481l6.328 5.741A2 2 0 0 0 10 19h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2z",
+      key: "1yo7s0"
+    }
+  ],
+  ["path", { d: "m12 9 6 6", key: "anjzzh" }],
+  ["path", { d: "m18 9-6 6", key: "1fp51s" }]
+], as = Z("delete", ss);
+const ls = [
+  [
+    "path",
+    {
+      d: "M10 20a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341L21.74 4.67A1 1 0 0 0 21 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14z",
+      key: "sc7q7i"
+    }
+  ]
+], cs = Z("funnel", ls);
+const us = [
+  ["circle", { cx: "9", cy: "12", r: "1", key: "1vctgf" }],
+  ["circle", { cx: "9", cy: "5", r: "1", key: "hp0tcf" }],
+  ["circle", { cx: "9", cy: "19", r: "1", key: "fkjjf6" }],
+  ["circle", { cx: "15", cy: "12", r: "1", key: "1tmaij" }],
+  ["circle", { cx: "15", cy: "5", r: "1", key: "19l28e" }],
+  ["circle", { cx: "15", cy: "19", r: "1", key: "f4zoj3" }]
+], ds = Z("grip-vertical", us);
+const fs = [
+  [
+    "path",
+    {
+      d: "M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z",
+      key: "1a8usu"
+    }
+  ]
+], hs = Z("pen", fs);
+const vs = [
+  [
+    "path",
+    {
+      d: "M9.671 4.136a2.34 2.34 0 0 1 4.659 0 2.34 2.34 0 0 0 3.319 1.915 2.34 2.34 0 0 1 2.33 4.033 2.34 2.34 0 0 0 0 3.831 2.34 2.34 0 0 1-2.33 4.033 2.34 2.34 0 0 0-3.319 1.915 2.34 2.34 0 0 1-4.659 0 2.34 2.34 0 0 0-3.32-1.915 2.34 2.34 0 0 1-2.33-4.033 2.34 2.34 0 0 0 0-3.831A2.34 2.34 0 0 1 6.35 6.051a2.34 2.34 0 0 0 3.319-1.915",
+      key: "1i5ecw"
+    }
+  ],
+  ["circle", { cx: "12", cy: "12", r: "3", key: "1v7zrd" }]
+], gs = Z("settings", vs);
+const ps = [
+  ["path", { d: "M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7", key: "1m0v6g" }],
+  [
+    "path",
+    {
+      d: "M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z",
+      key: "ohrbg2"
+    }
+  ]
+], bs = Z("square-pen", ps);
+const ms = [
+  ["path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6", key: "miytrc" }],
+  ["path", { d: "M3 6h18", key: "d0wm0j" }],
+  ["path", { d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2", key: "e791ji" }]
+], xs = Z("trash", ms);
+function _(e) {
+  return on((t, n) => {
+    const { children: r, ...o } = t;
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ u.jsx(e, { ref: n, ...o, children: r })
+    );
+  });
+}
+const Te = new Kn({
+  sortColumn: null,
+  sortDirection: "asc",
+  visibility: {},
+  // initially empty
+  columnOrder: [],
+  // initially empty
+  data: [],
+  sortebleColumns: []
+});
+function ys(e) {
+  Te.setState((t) => {
+    const n = e[0] ?? {}, r = Object.keys(n);
+    return {
+      ...t,
+      data: e,
+      columnOrder: r,
+      visibility: r.reduce((o, i) => ({ ...o, [i]: !0 }), {}),
+      sortebleColumns: r.map((o) => ({
+        id: o,
+        label: o,
+        sortable: !0
+      }))
+    };
+  });
+}
+const ws = _(at.Trigger), Ss = _(at.Positioner), Rs = _(at.Content), Cs = _(at.Item), Es = _(ke.Label), Ds = _(ke.HiddenInput), _s = _(ke.Control);
+function Os({ visibility: e, onToggle: t }) {
+  const { sortebleColumns: n } = ct(Te);
+  return /* @__PURE__ */ u.jsxs(at.Root, { closeOnSelect: !1, children: [
+    /* @__PURE__ */ u.jsx(ws, { asChild: !0, children: /* @__PURE__ */ u.jsx(Ve, { "aria-label": "Toggle columns", variant: "outline", size: "sm", ml: "1", children: /* @__PURE__ */ u.jsx(is, { size: 18 }) }) }),
+    /* @__PURE__ */ u.jsx(sn, { children: /* @__PURE__ */ u.jsx(Ss, { children: /* @__PURE__ */ u.jsx(Rs, { minW: "220px", children: n.map((r) => {
+      const o = !!e[r.id];
+      return /* @__PURE__ */ u.jsx(Cs, { value: r.id, closeOnSelect: !1, children: /* @__PURE__ */ u.jsxs(ke.Root, { checked: o, onCheckedChange: () => t(r.id), children: [
+        /* @__PURE__ */ u.jsx(Ds, {}),
+        /* @__PURE__ */ u.jsx(_s, {}),
+        /* @__PURE__ */ u.jsx(Es, { children: r.label })
+      ] }) }, r.id);
+    }) }) }) })
+  ] });
+}
+const Ts = (e) => {
+  Te.setState((t) => ({ ...t, columnOrder: e }));
+}, js = (e) => {
+  Te.setState((t) => ({
+    ...t,
+    visibility: { ...t.visibility, [e]: !t.visibility[e] }
+  }));
+};
+function Is(e) {
+  Te.setState((t) => t.sortColumn === e ? {
+    ...t,
+    sortDirection: t.sortDirection === "asc" ? "desc" : "asc"
+  } : {
+    ...t,
+    sortColumn: e,
+    sortDirection: "asc"
+  });
+}
+function As({
+  id: e,
+  children: t,
+  onClick: n,
+  cursor: r,
+  borderRight: o,
+  borderRightColor: i
+}) {
+  const { setNodeRef: s, attributes: a, listeners: c, transform: l, transition: h } = wr({ id: e });
+  return /* @__PURE__ */ u.jsx(
+    ve.ColumnHeader,
+    {
+      ref: s,
+      onClick: n,
+      w: e === "id" ? "80px" : void 0,
+      style: {
+        transform: Be.Transform.toString(l),
+        transition: h,
+        cursor: r,
+        borderRight: o,
+        borderRightColor: i
+      },
+      ...a,
+      children: /* @__PURE__ */ u.jsxs(ge, { justify: "space-between", children: [
+        t,
+        /* @__PURE__ */ u.jsx("span", { ...c, children: /* @__PURE__ */ u.jsx(ds, { size: 12 }) })
+      ] })
+    }
+  );
+}
+function ks() {
+  const { columnOrder: e, visibility: t, sortColumn: n, sortDirection: r, sortebleColumns: o } = ct(Te);
+  console.log(e, "fomr header");
+  const i = e.map((a) => o.find((c) => c.id === a)).filter((a) => t[a.id]), s = (a) => {
+    const { active: c, over: l } = a;
+    if (!l || c.id === l.id) return;
+    const h = e.indexOf(c.id), f = e.indexOf(l.id);
+    Ts(Lt(e, h, f));
+  };
+  return /* @__PURE__ */ u.jsx(ve.Header, { background: "gray.100", position: "sticky", top: 0, p: "0", children: /* @__PURE__ */ u.jsx(gr, { collisionDetection: tr, onDragEnd: s, children: /* @__PURE__ */ u.jsx(xr, { items: e, strategy: ji, children: /* @__PURE__ */ u.jsxs(ve.Row, { children: [
+    i.map((a, c) => {
+      const l = n === a?.id, h = c === i.length - 1;
+      return /* @__PURE__ */ u.jsx(
+        As,
+        {
+          id: a?.id,
+          onClick: () => a?.sortable && Is(a?.id),
+          cursor: a?.sortable ? "pointer" : "default",
+          borderRight: h ? void 0 : "2px solid",
+          children: /* @__PURE__ */ u.jsxs(
+            "span",
+            {
+              style: {
+                display: "flex",
+                alignItems: "center",
+                gap: 6,
+                userSelect: "none"
+              },
+              children: [
+                a?.label,
+                a?.sortable && (l ? r === "asc" ? /* @__PURE__ */ u.jsx(Ki, { size: 14 }) : /* @__PURE__ */ u.jsx(Gi, { size: 14 }) : /* @__PURE__ */ u.jsx(Xi, { size: 14, opacity: 0.4 }))
+              ]
+            }
+          )
+        },
+        a?.id
+      );
+    }),
+    /* @__PURE__ */ u.jsx(ve.ColumnHeader, { borderRight: "2px solid", borderRightColor: "gray.300", children: "Actions" }),
+    /* @__PURE__ */ u.jsx(ve.ColumnHeader, { boxSize: "0.5", children: /* @__PURE__ */ u.jsx(Os, { visibility: t, onToggle: js }) })
+  ] }) }) }) });
+}
+const qn = Mr({
+  items: [
+    { label: "10", value: "10" },
+    { label: "20", value: "20" },
+    { label: "50", value: "50" },
+    { label: "100", value: "100" }
+  ]
+}), Ns = _(le.Positioner), Ls = _(le.Content), Ms = _(le.Item), Ps = _(Ct.PrevTrigger), zs = _(Ct.NextTrigger), $s = _(le.HiddenSelect), Vs = _(le.Control), Fs = _(le.Trigger), Bs = _(le.ValueText), Ws = _(le.IndicatorGroup), Hs = _(le.Indicator);
+function Ys({
+  totalCount: e,
+  pageSize: t,
+  currentPage: n,
+  onPageChange: r,
+  onPageSizeChange: o,
+  siblingCount: i = 2
+}) {
+  return /* @__PURE__ */ u.jsx(Qe, { mt: 6, width: "100%", children: /* @__PURE__ */ u.jsxs(ge, { justify: "space-between", mx: "auto", flexWrap: "wrap", children: [
+    /* @__PURE__ */ u.jsxs(ge, { children: [
+      /* @__PURE__ */ u.jsx(we, { fontSize: "sm", color: "gray.600", _dark: { color: "gray.400" }, children: "Rows per page:" }),
+      /* @__PURE__ */ u.jsxs(
+        le.Root,
+        {
+          collection: qn,
+          size: "sm",
+          width: "60px",
+          onValueChange: (s) => o && o(Number(s.items[0].value)),
+          value: [String(t)],
+          children: [
+            /* @__PURE__ */ u.jsx($s, {}),
+            /* @__PURE__ */ u.jsxs(Vs, { children: [
+              /* @__PURE__ */ u.jsx(Fs, { children: /* @__PURE__ */ u.jsx(Bs, { placeholder: "" }) }),
+              /* @__PURE__ */ u.jsx(Ws, { children: /* @__PURE__ */ u.jsx(Hs, {}) })
+            ] }),
+            /* @__PURE__ */ u.jsx(sn, { children: /* @__PURE__ */ u.jsx(Ns, { children: /* @__PURE__ */ u.jsx(Ls, { children: qn.items.map((s) => /* @__PURE__ */ u.jsxs(Ms, { item: s.value, children: [
+              s.label,
+              /* @__PURE__ */ u.jsx(le.ItemIndicator, {})
+            ] }, s.value)) }) }) })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ u.jsx(
+      Ct.Root,
+      {
+        count: e,
+        pageSize: t,
+        page: n,
+        siblingCount: i,
+        onPageChange: (s) => r && r(s.page),
+        children: /* @__PURE__ */ u.jsxs(Pr, { size: "sm", variant: "ghost", children: [
+          /* @__PURE__ */ u.jsx(Ps, { asChild: !0, children: /* @__PURE__ */ u.jsx(Ve, { "aria-label": "Previous page", children: /* @__PURE__ */ u.jsx(ts, { size: 18 }) }) }),
+          /* @__PURE__ */ u.jsx(
+            Ct.Items,
+            {
+              render: (s) => /* @__PURE__ */ u.jsx(
+                Ve,
+                {
+                  variant: s.type === "page" && s.value === n ? "outline" : "ghost",
+                  "aria-current": s.type === "page" && s.value === n ? "page" : void 0,
+                  children: s.type === "page" ? s.value : "…"
+                },
+                s.value ?? s.type
+              )
+            }
+          ),
+          /* @__PURE__ */ u.jsx(zs, { asChild: !0, children: /* @__PURE__ */ u.jsx(Ve, { "aria-label": "Next page", children: /* @__PURE__ */ u.jsx(rs, { size: 18 }) }) })
+        ] })
+      }
+    )
+  ] }) });
+}
+function Us({
+  data: e = []
+}) {
+  const { columnOrder: t, visibility: n } = ct(Te);
+  return /* @__PURE__ */ u.jsx(ve.Body, { children: e.map((r) => /* @__PURE__ */ u.jsxs(ve.Row, { children: [
+    t.filter((o) => n[o]).map((o) => /* @__PURE__ */ u.jsx(ve.Cell, { children: r[o] }, o)),
+    /* @__PURE__ */ u.jsxs(ve.Cell, { textAlign: "center", display: "flex", gap: 2, children: [
+      /* @__PURE__ */ u.jsx(bs, { size: 16 }),
+      /* @__PURE__ */ u.jsx(xs, { size: 16 })
+    ] })
+  ] }, r.id)) });
+}
+function wa({
+  // headers,
+  data: e = [],
+  loading: t = !1,
+  emptyMessage: n = "No data",
+  actions: r,
+  showIndex: o = !0,
+  page: i = 0,
+  pageSize: s = 10,
+  hideHeaderList: a = {},
+  onPageChange: c,
+  onPageSizeChange: l,
+  density: h = "sm"
+}) {
+  A(() => {
+    ys(e);
+  }, [e]);
+  const { sortColumn: f, sortDirection: p, data: d } = ct(Te), m = A(() => {
+    const g = [...d];
+    f && g.sort(
+      (x, w) => p === "asc" ? String(x[f]).localeCompare(String(w[f])) : String(w[f]).localeCompare(String(x[f]))
+    );
+    const b = (i - 1) * s;
+    return g.slice(b, b + s);
+  }, [i, s, f, p]);
+  return /* @__PURE__ */ u.jsxs(Qe, { h: "100vh", display: "flex", flexDirection: "column", p: 2, pt: 2, children: [
+    /* @__PURE__ */ u.jsx(Qe, { flex: "1", overflow: "hidden", children: /* @__PURE__ */ u.jsx(Qe, { h: "100%", overflowY: "auto", border: "1px solid", borderColor: "gray.200", borderRadius: "md", children: /* @__PURE__ */ u.jsxs(ve.Root, { variant: "outline", w: "100%", size: h, children: [
+      /* @__PURE__ */ u.jsx(ks, {}),
+      /* @__PURE__ */ u.jsx(Us, { data: m })
+    ] }) }) }),
+    /* @__PURE__ */ u.jsx(Qe, { mt: 0.5, children: /* @__PURE__ */ u.jsx(
+      Ys,
+      {
+        totalCount: e.length,
+        pageSize: s,
+        currentPage: i,
+        onPageChange: c,
+        onPageSizeChange: (g) => {
+          l && l(g), i > 1 && c && c(1);
+        }
+      }
+    ) })
+  ] });
+}
+const Rr = (e) => `FILTER_PRESETS_${e ?? "default"}`;
+function Gs(e) {
+  try {
+    return JSON.parse(localStorage.getItem(Rr(e)) || "[]");
+  } catch {
+    return [];
+  }
+}
+const jt = new Kn({}), gn = (e) => {
+  const t = jt.state[e];
+  if (t) return t;
+  const n = Gs(e);
+  return jt.setState((r) => ({
+    ...r,
+    [e]: n
+  })), n;
+}, Cr = (e, t) => {
+  jt.setState((n) => ({
+    ...n,
+    [e]: t
+  })), localStorage.setItem(Rr(e), JSON.stringify(t));
+}, qs = (e, t) => {
+  const n = gn(e).filter((r) => r.id !== t);
+  Cr(e, n);
+}, Xs = (e, t) => {
+  const n = [t, ...gn(e)];
+  Cr(e, n);
+}, Js = _(ke.Root), Ks = _(ke.HiddenInput), Zs = _(ke.Control), Qs = _(lt.Root), ea = _(lt.Track), ta = _(lt.Range), na = _(lt.Thumbs), ra = _(lt.Control), oa = ({ filter: e, onVisibilityChange: t, onSizeChange: n }) => {
+  const { attributes: r, listeners: o, setNodeRef: i, transform: s, transition: a } = wr({
+    id: e.id
+  }), c = {
+    transform: Be.Transform.toString(s),
+    transition: a,
+    cursor: "grab"
+  };
+  return /* @__PURE__ */ u.jsxs(
+    et,
+    {
+      ref: i,
+      style: c,
+      align: "stretch",
+      border: "1px solid",
+      borderColor: "gray.200",
+      rounded: "md",
+      p: 3,
+      mb: 3,
+      ...r,
+      ...o,
+      children: [
+        /* @__PURE__ */ u.jsx(we, { fontWeight: "bold", children: e.label }),
+        /* @__PURE__ */ u.jsxs(ge, { justify: "space-between", children: [
+          /* @__PURE__ */ u.jsx(we, { fontSize: "sm", children: "Visible" }),
+          /* @__PURE__ */ u.jsxs(
+            Js,
+            {
+              checked: e.visible,
+              onCheckedChange: (l) => t && t(e.id, !!l),
+              size: "sm",
+              children: [
+                /* @__PURE__ */ u.jsx(Ks, {}),
+                /* @__PURE__ */ u.jsx(Zs, {})
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ u.jsxs(et, { align: "stretch", gap: 1, children: [
+          /* @__PURE__ */ u.jsx(we, { fontSize: "sm", children: "Size" }),
+          /* @__PURE__ */ u.jsx(
+            Qs,
+            {
+              width: "200px",
+              min: 1,
+              max: 5,
+              step: 0.5,
+              value: [e.size ?? 1],
+              onChange: (l) => n && n(e.id, l[0]),
+              children: /* @__PURE__ */ u.jsxs(ra, { children: [
+                /* @__PURE__ */ u.jsx(ea, { children: /* @__PURE__ */ u.jsx(ta, {}) }),
+                /* @__PURE__ */ u.jsx(na, {})
+              ] })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}, ia = _(be.Root), sa = _(be.Trigger), aa = _(be.Backdrop), la = _(be.Positioner), ca = _(be.Content), ua = _(be.Header), da = _(be.Title), fa = _(be.Body), ha = _(be.Footer), va = _(be.CloseTrigger), ga = _(It.Root), pa = _(It.List), Xt = _(It.Trigger), Jt = _(It.Content), ba = ({
+  filterDrawerSize: e = "sm",
+  onVisibilityChange: t,
+  onSizeChange: n,
+  onClear: r,
+  filters: o,
+  pageKey: i = "default",
+  currentFilters: s = {},
+  onLoadPreset: a,
+  activePresetName: c,
+  onReorder: l
+}) => {
+  const f = ct(jt)[i] ?? gn(i), p = () => {
+    const d = prompt("Preset name?");
+    d && Xs(i, {
+      id: crypto.randomUUID(),
+      name: d,
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      filters: s
+    });
+  };
+  return /* @__PURE__ */ u.jsx(ge, { wrap: "wrap", children: /* @__PURE__ */ u.jsxs(ia, { size: e, children: [
+    /* @__PURE__ */ u.jsx(sa, { asChild: !0, children: /* @__PURE__ */ u.jsxs(Ve, { "aria-label": "Open filters", variant: "outline", size: "xs", ml: 2, p: 2, children: [
+      /* @__PURE__ */ u.jsx(cs, { size: 16 }),
+      "Filters"
+    ] }) }),
+    /* @__PURE__ */ u.jsxs(sn, { children: [
+      /* @__PURE__ */ u.jsx(aa, {}),
+      /* @__PURE__ */ u.jsx(la, { children: /* @__PURE__ */ u.jsxs(ca, { children: [
+        /* @__PURE__ */ u.jsx(ua, { children: /* @__PURE__ */ u.jsx(da, { children: "Filters" }) }),
+        /* @__PURE__ */ u.jsx(fa, { overflowY: "auto", pt: 1, children: /* @__PURE__ */ u.jsxs(ga, { defaultValue: "view", children: [
+          /* @__PURE__ */ u.jsxs(pa, { mb: 4, children: [
+            /* @__PURE__ */ u.jsxs(Xt, { value: "view", children: [
+              /* @__PURE__ */ u.jsx(hs, { size: 16 }),
+              "Edit"
+            ] }),
+            /* @__PURE__ */ u.jsxs(Xt, { value: "settings", children: [
+              /* @__PURE__ */ u.jsx(gs, { size: 16 }),
+              "Settings"
+            ] }),
+            /* @__PURE__ */ u.jsxs(Xt, { value: "presets", children: [
+              /* @__PURE__ */ u.jsx(Qi, { size: 16 }),
+              "Presets"
+            ] })
+          ] }),
+          /* @__PURE__ */ u.jsx(Jt, { value: "view", children: o.filter((d) => d.visible).map((d) => /* @__PURE__ */ u.jsxs(
+            et,
+            {
+              align: "stretch",
+              border: "1px solid",
+              borderColor: "gray.200",
+              rounded: "md",
+              p: 3,
+              mb: 3,
+              children: [
+                /* @__PURE__ */ u.jsx(we, { fontWeight: "bold", children: d.label }),
+                d.customComponent
+              ]
+            },
+            d.id
+          )) }),
+          /* @__PURE__ */ u.jsx(Jt, { value: "settings", children: /* @__PURE__ */ u.jsx(
+            gr,
+            {
+              sensors: bo(po(vn)),
+              collisionDetection: tr,
+              onDragEnd: ({ active: d, over: m }) => {
+                if (!m || d.id === m.id) return;
+                const g = o.findIndex((w) => w.id === d.id), b = o.findIndex((w) => w.id === m.id), x = Lt(o, g, b);
+                console.log(x), l?.(x);
+              },
+              children: /* @__PURE__ */ u.jsx(
+                xr,
+                {
+                  items: o.map((d) => d.id),
+                  strategy: Ai,
+                  children: o.map((d) => /* @__PURE__ */ u.jsx(
+                    oa,
+                    {
+                      filter: d,
+                      onVisibilityChange: t,
+                      onSizeChange: n
+                    },
+                    d.id
+                  ))
+                }
+              )
+            }
+          ) }),
+          /* @__PURE__ */ u.jsx(Jt, { value: "presets", children: /* @__PURE__ */ u.jsxs(et, { align: "stretch", mb: 3, children: [
+            /* @__PURE__ */ u.jsx($t, { size: "sm", colorScheme: "blue", onClick: p, children: "Save Current Filters" }),
+            f.length === 0 && /* @__PURE__ */ u.jsx(we, { fontSize: "xs", color: "gray.500", children: "No presets saved yet." }),
+            f.map((d) => /* @__PURE__ */ u.jsxs(
+              ge,
+              {
+                justify: "space-between",
+                border: "1px solid",
+                borderColor: c === d.name ? "blue.300" : "gray.200",
+                rounded: "md",
+                p: 2,
+                children: [
+                  /* @__PURE__ */ u.jsxs(et, { align: "start", gap: 0, children: [
+                    /* @__PURE__ */ u.jsx(we, { fontWeight: "bold", fontSize: "sm", children: d.name }),
+                    /* @__PURE__ */ u.jsx(we, { fontSize: "xs", color: "gray.500", children: new Date(d.date).toLocaleDateString() })
+                  ] }),
+                  /* @__PURE__ */ u.jsxs(ge, { children: [
+                    /* @__PURE__ */ u.jsx(
+                      $t,
+                      {
+                        size: "xs",
+                        variant: "ghost",
+                        onClick: () => a?.(d.filters, d.name),
+                        children: "Load"
+                      }
+                    ),
+                    /* @__PURE__ */ u.jsx(
+                      Ve,
+                      {
+                        size: "xs",
+                        "aria-label": "Delete preset",
+                        variant: "ghost",
+                        onClick: () => qs(i, d.id),
+                        children: /* @__PURE__ */ u.jsx(as, { size: 14 })
+                      }
+                    )
+                  ] })
+                ]
+              },
+              d.id
+            ))
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ u.jsxs(ha, { justify: "space-between", children: [
+          /* @__PURE__ */ u.jsx(
+            $t,
+            {
+              size: "sm",
+              variant: "ghost",
+              colorScheme: "red",
+              onClick: () => r && r(),
+              children: "Clear All"
+            }
+          ),
+          /* @__PURE__ */ u.jsx(va, { asChild: !0, children: /* @__PURE__ */ u.jsx(zr, {}) })
+        ] })
+      ] }) })
+    ] })
+  ] }) });
+}, Sa = ({
+  title: e,
+  filters: t,
+  onVisibilityChange: n,
+  onReorder: r,
+  onSizeChange: o,
+  onClear: i,
+  maxToolbarUnits: s,
+  pageKey: a,
+  currentFilters: c,
+  onLoadPreset: l,
+  activePresetName: h,
+  filterDrawerSize: f = "sm"
+}) => /* @__PURE__ */ u.jsxs(ge, { wrap: "wrap", pl: 2, pr: 2, width: "100%", justify: "space-between", children: [
+  /* @__PURE__ */ u.jsx(we, { children: e }),
+  /* @__PURE__ */ u.jsxs(ge, { children: [
+    t.length > 0 && t.filter((p) => p.visible).map((p) => /* @__PURE__ */ u.jsx(ge, { children: p.customComponent }, p.id)),
+    /* @__PURE__ */ u.jsx(
+      ba,
+      {
+        filterDrawerSize: f,
+        onVisibilityChange: n ? (p, d) => n(p, d) : void 0,
+        onReorder: r,
+        onSizeChange: o ? (p, d) => o(p, d) : void 0,
+        onClear: i,
+        maxToolbarUnits: s,
+        pageKey: a,
+        filters: t,
+        currentFilters: c,
+        onLoadPreset: l,
+        activePresetName: h
+      }
+    )
+  ] })
+] }), Ra = (e, t) => {
+  localStorage.setItem(`FILTER_ORDER_${e}`, JSON.stringify(t));
+}, Ca = (e) => {
+  try {
+    return JSON.parse(localStorage.getItem(`FILTER_ORDER_${e}`) || "[]");
+  } catch {
+    return [];
+  }
+};
+export {
+  wa as DataTable,
+  Sa as Filters,
+  Xs as addPreset,
+  qs as deletePreset,
+  gn as getPresets,
+  Ca as loadOrder,
+  jt as presetStore,
+  Ra as saveOrder,
+  Cr as savePresets,
+  ys as setData,
+  Te as tableStore,
+  _ as withChildren
+};