@ck-ui/component-library 0.1.5 → 0.3.0

package/dist/components/Table/_helpers/ColumnManager/index.js

@@ -0,0 +1,2451 @@
+import { jsx as m, jsxs as E } from "react/jsx-runtime";
+import * as w from "react";
+import { createContext as Ge, memo as Ye, useEffect as k, useLayoutEffect as Xe, useState as Ee, useCallback as Ie, useMemo as b, isValidElement as We, cloneElement as ae, useContext as ze, useRef as Qe } from "react";
+import { CKButton as B } from "../../../CKButton/index.js";
+import { Typography as _ } from "../../../Typography/index.js";
+import { Switch as Ke } from "../../../Switch/index.js";
+import { S as Je } from "../../../../reset-icon-YxMt3Ozp.js";
+import { S as Ze } from "../../../../search-B_cup-NN.js";
+import et from "./ColumnConfig.js";
+import { COLUMN_ITEM_TYPE as ce } from "../../constants.js";
+import '../../../../assets/styles-BTZL03H2.css';/* empty css                          */
+import { mergeClasses as ue } from "../../../../utils/mergeClasses.js";
+import { g as tt } from "../../../../_commonjsHelpers-C6fGbg64.js";
+const we = Ge({
+  dragDropManager: void 0
+});
+function O(t) {
+  return "Minified Redux error #" + t + "; visit https://redux.js.org/Errors?code=" + t + " for the full message or use the non-minified dev environment for full errors. ";
+}
+var le = (function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})(), de = function() {
+  return Math.random().toString(36).substring(7).split("").join(".");
+}, ge = {
+  INIT: "@@redux/INIT" + de(),
+  REPLACE: "@@redux/REPLACE" + de()
+};
+function rt(t) {
+  if (typeof t != "object" || t === null) return !1;
+  for (var e = t; Object.getPrototypeOf(e) !== null; )
+    e = Object.getPrototypeOf(e);
+  return Object.getPrototypeOf(t) === e;
+}
+function nt(t) {
+  if (t === void 0) return "undefined";
+  if (t === null) return "null";
+  var e = typeof t;
+  switch (e) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "symbol":
+    case "function":
+      return e;
+  }
+  if (Array.isArray(t)) return "array";
+  if (ot(t)) return "date";
+  if (st(t)) return "error";
+  var r = it(t);
+  switch (r) {
+    case "Symbol":
+    case "Promise":
+    case "WeakMap":
+    case "WeakSet":
+    case "Map":
+    case "Set":
+      return r;
+  }
+  return e.slice(8, -1).toLowerCase().replace(/\s/g, "");
+}
+function it(t) {
+  return typeof t.constructor == "function" ? t.constructor.name : null;
+}
+function st(t) {
+  return t instanceof Error || typeof t.message == "string" && t.constructor && typeof t.constructor.stackTraceLimit == "number";
+}
+function ot(t) {
+  return t instanceof Date ? !0 : typeof t.toDateString == "function" && typeof t.getDate == "function" && typeof t.setDate == "function";
+}
+function N(t) {
+  var e = typeof t;
+  return process.env.NODE_ENV !== "production" && (e = nt(t)), e;
+}
+function Ce(t, e, r) {
+  var n;
+  if (typeof e == "function" && typeof r == "function" || typeof r == "function" && typeof arguments[3] == "function")
+    throw new Error(process.env.NODE_ENV === "production" ? O(0) : "It looks like you are passing several store enhancers to createStore(). This is not supported. Instead, compose them together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example.");
+  if (typeof e == "function" && typeof r > "u" && (r = e, e = void 0), typeof r < "u") {
+    if (typeof r != "function")
+      throw new Error(process.env.NODE_ENV === "production" ? O(1) : "Expected the enhancer to be a function. Instead, received: '" + N(r) + "'");
+    return r(Ce)(t, e);
+  }
+  if (typeof t != "function")
+    throw new Error(process.env.NODE_ENV === "production" ? O(2) : "Expected the root reducer to be a function. Instead, received: '" + N(t) + "'");
+  var i = t, s = e, o = [], a = o, c = !1;
+  function d() {
+    a === o && (a = o.slice());
+  }
+  function f() {
+    if (c)
+      throw new Error(process.env.NODE_ENV === "production" ? O(3) : "You may not call store.getState() while the reducer is executing. The reducer has already received the state as an argument. Pass it down from the top reducer instead of reading it from the store.");
+    return s;
+  }
+  function p(h) {
+    if (typeof h != "function")
+      throw new Error(process.env.NODE_ENV === "production" ? O(4) : "Expected the listener to be a function. Instead, received: '" + N(h) + "'");
+    if (c)
+      throw new Error(process.env.NODE_ENV === "production" ? O(5) : "You may not call store.subscribe() while the reducer is executing. If you would like to be notified after the store has been updated, subscribe from a component and invoke store.getState() in the callback to access the latest state. See https://redux.js.org/api/store#subscribelistener for more details.");
+    var v = !0;
+    return d(), a.push(h), function() {
+      if (v) {
+        if (c)
+          throw new Error(process.env.NODE_ENV === "production" ? O(6) : "You may not unsubscribe from a store listener while the reducer is executing. See https://redux.js.org/api/store#subscribelistener for more details.");
+        v = !1, d();
+        var S = a.indexOf(h);
+        a.splice(S, 1), o = null;
+      }
+    };
+  }
+  function g(h) {
+    if (!rt(h))
+      throw new Error(process.env.NODE_ENV === "production" ? O(7) : "Actions must be plain objects. Instead, the actual type was: '" + N(h) + "'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.");
+    if (typeof h.type > "u")
+      throw new Error(process.env.NODE_ENV === "production" ? O(8) : 'Actions may not have an undefined "type" property. You may have misspelled an action type string constant.');
+    if (c)
+      throw new Error(process.env.NODE_ENV === "production" ? O(9) : "Reducers may not dispatch actions.");
+    try {
+      c = !0, s = i(s, h);
+    } finally {
+      c = !1;
+    }
+    for (var v = o = a, y = 0; y < v.length; y++) {
+      var S = v[y];
+      S();
+    }
+    return h;
+  }
+  function u(h) {
+    if (typeof h != "function")
+      throw new Error(process.env.NODE_ENV === "production" ? O(10) : "Expected the nextReducer to be a function. Instead, received: '" + N(h));
+    i = h, g({
+      type: ge.REPLACE
+    });
+  }
+  function D() {
+    var h, v = p;
+    return h = {
+      /**
+       * The minimal observable subscription method.
+       * @param {Object} observer Any object that can be used as an observer.
+       * The observer object should have a `next` method.
+       * @returns {subscription} An object with an `unsubscribe` method that can
+       * be used to unsubscribe the observable from the store, and prevent further
+       * emission of values from the observable.
+       */
+      subscribe: function(S) {
+        if (typeof S != "object" || S === null)
+          throw new Error(process.env.NODE_ENV === "production" ? O(11) : "Expected the observer to be an object. Instead, received: '" + N(S) + "'");
+        function I() {
+          S.next && S.next(f());
+        }
+        I();
+        var F = v(I);
+        return {
+          unsubscribe: F
+        };
+      }
+    }, h[le] = function() {
+      return this;
+    }, h;
+  }
+  return g({
+    type: ge.INIT
+  }), n = {
+    dispatch: g,
+    subscribe: p,
+    getState: f,
+    replaceReducer: u
+  }, n[le] = D, n;
+}
+function l(t, e, ...r) {
+  if (at() && e === void 0)
+    throw new Error("invariant requires an error message argument");
+  if (!t) {
+    let n;
+    if (e === void 0)
+      n = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
+    else {
+      let i = 0;
+      n = new Error(e.replace(/%s/g, function() {
+        return r[i++];
+      })), n.name = "Invariant Violation";
+    }
+    throw n.framesToPop = 1, n;
+  }
+}
+function at() {
+  return typeof process < "u" && process.env.NODE_ENV === "production";
+}
+function ct(t, e, r) {
+  return e.split(".").reduce(
+    (n, i) => n && n[i] ? n[i] : r || null,
+    t
+  );
+}
+function ut(t, e) {
+  return t.filter(
+    (r) => r !== e
+  );
+}
+function Ne(t) {
+  return typeof t == "object";
+}
+function lt(t, e) {
+  const r = /* @__PURE__ */ new Map(), n = (s) => {
+    r.set(s, r.has(s) ? r.get(s) + 1 : 1);
+  };
+  t.forEach(n), e.forEach(n);
+  const i = [];
+  return r.forEach((s, o) => {
+    s === 1 && i.push(o);
+  }), i;
+}
+function dt(t, e) {
+  return t.filter(
+    (r) => e.indexOf(r) > -1
+  );
+}
+const ee = "dnd-core/INIT_COORDS", A = "dnd-core/BEGIN_DRAG", te = "dnd-core/PUBLISH_DRAG_SOURCE", H = "dnd-core/HOVER", j = "dnd-core/DROP", U = "dnd-core/END_DRAG";
+function fe(t, e) {
+  return {
+    type: ee,
+    payload: {
+      sourceClientOffset: e || null,
+      clientOffset: t || null
+    }
+  };
+}
+const gt = {
+  type: ee,
+  payload: {
+    clientOffset: null,
+    sourceClientOffset: null
+  }
+};
+function ft(t) {
+  return function(r = [], n = {
+    publishSource: !0
+  }) {
+    const { publishSource: i = !0, clientOffset: s, getSourceClientOffset: o } = n, a = t.getMonitor(), c = t.getRegistry();
+    t.dispatch(fe(s)), ht(r, a, c);
+    const d = vt(r, a);
+    if (d == null) {
+      t.dispatch(gt);
+      return;
+    }
+    let f = null;
+    if (s) {
+      if (!o)
+        throw new Error("getSourceClientOffset must be defined");
+      pt(o), f = o(d);
+    }
+    t.dispatch(fe(s, f));
+    const g = c.getSource(d).beginDrag(a, d);
+    if (g == null)
+      return;
+    mt(g), c.pinSource(d);
+    const u = c.getSourceType(d);
+    return {
+      type: A,
+      payload: {
+        itemType: u,
+        item: g,
+        sourceId: d,
+        clientOffset: s || null,
+        sourceClientOffset: f || null,
+        isSourcePublic: !!i
+      }
+    };
+  };
+}
+function ht(t, e, r) {
+  l(!e.isDragging(), "Cannot call beginDrag while dragging."), t.forEach(function(n) {
+    l(r.getSource(n), "Expected sourceIds to be registered.");
+  });
+}
+function pt(t) {
+  l(typeof t == "function", "When clientOffset is provided, getSourceClientOffset must be a function.");
+}
+function mt(t) {
+  l(Ne(t), "Item must be an object.");
+}
+function vt(t, e) {
+  let r = null;
+  for (let n = t.length - 1; n >= 0; n--)
+    if (e.canDragSource(t[n])) {
+      r = t[n];
+      break;
+    }
+  return r;
+}
+function Dt(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function yt(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      Dt(t, i, r[i]);
+    });
+  }
+  return t;
+}
+function St(t) {
+  return function(r = {}) {
+    const n = t.getMonitor(), i = t.getRegistry();
+    Ot(n), Et(n).forEach((o, a) => {
+      const c = Tt(o, a, i, n), d = {
+        type: j,
+        payload: {
+          dropResult: yt({}, r, c)
+        }
+      };
+      t.dispatch(d);
+    });
+  };
+}
+function Ot(t) {
+  l(t.isDragging(), "Cannot call drop while not dragging."), l(!t.didDrop(), "Cannot call drop twice during one drag operation.");
+}
+function Tt(t, e, r, n) {
+  const i = r.getTarget(t);
+  let s = i ? i.drop(n, t) : void 0;
+  return bt(s), typeof s > "u" && (s = e === 0 ? {} : n.getDropResult()), s;
+}
+function bt(t) {
+  l(typeof t > "u" || Ne(t), "Drop result must either be an object or undefined.");
+}
+function Et(t) {
+  const e = t.getTargetIds().filter(t.canDropOnTarget, t);
+  return e.reverse(), e;
+}
+function It(t) {
+  return function() {
+    const r = t.getMonitor(), n = t.getRegistry();
+    wt(r);
+    const i = r.getSourceId();
+    return i != null && (n.getSource(i, !0).endDrag(r, i), n.unpinSource()), {
+      type: U
+    };
+  };
+}
+function wt(t) {
+  l(t.isDragging(), "Cannot call endDrag while not dragging.");
+}
+function z(t, e) {
+  return e === null ? t === null : Array.isArray(t) ? t.some(
+    (r) => r === e
+  ) : t === e;
+}
+function Ct(t) {
+  return function(r, { clientOffset: n } = {}) {
+    Nt(r);
+    const i = r.slice(0), s = t.getMonitor(), o = t.getRegistry(), a = s.getItemType();
+    return xt(i, o, a), Pt(i, s, o), Rt(i, s, o), {
+      type: H,
+      payload: {
+        targetIds: i,
+        clientOffset: n || null
+      }
+    };
+  };
+}
+function Nt(t) {
+  l(Array.isArray(t), "Expected targetIds to be an array.");
+}
+function Pt(t, e, r) {
+  l(e.isDragging(), "Cannot call hover while not dragging."), l(!e.didDrop(), "Cannot call hover after drop.");
+  for (let n = 0; n < t.length; n++) {
+    const i = t[n];
+    l(t.lastIndexOf(i) === n, "Expected targetIds to be unique in the passed array.");
+    const s = r.getTarget(i);
+    l(s, "Expected targetIds to be registered.");
+  }
+}
+function xt(t, e, r) {
+  for (let n = t.length - 1; n >= 0; n--) {
+    const i = t[n], s = e.getTargetType(i);
+    z(s, r) || t.splice(n, 1);
+  }
+}
+function Rt(t, e, r) {
+  t.forEach(function(n) {
+    r.getTarget(n).hover(e, n);
+  });
+}
+function Mt(t) {
+  return function() {
+    if (t.getMonitor().isDragging())
+      return {
+        type: te
+      };
+  };
+}
+function _t(t) {
+  return {
+    beginDrag: ft(t),
+    publishDragSource: Mt(t),
+    hover: Ct(t),
+    drop: St(t),
+    endDrag: It(t)
+  };
+}
+class Lt {
+  receiveBackend(e) {
+    this.backend = e;
+  }
+  getMonitor() {
+    return this.monitor;
+  }
+  getBackend() {
+    return this.backend;
+  }
+  getRegistry() {
+    return this.monitor.registry;
+  }
+  getActions() {
+    const e = this, { dispatch: r } = this.store;
+    function n(s) {
+      return (...o) => {
+        const a = s.apply(e, o);
+        typeof a < "u" && r(a);
+      };
+    }
+    const i = _t(this);
+    return Object.keys(i).reduce((s, o) => {
+      const a = i[o];
+      return s[o] = n(a), s;
+    }, {});
+  }
+  dispatch(e) {
+    this.store.dispatch(e);
+  }
+  constructor(e, r) {
+    this.isSetUp = !1, this.handleRefCountChange = () => {
+      const n = this.store.getState().refCount > 0;
+      this.backend && (n && !this.isSetUp ? (this.backend.setup(), this.isSetUp = !0) : !n && this.isSetUp && (this.backend.teardown(), this.isSetUp = !1));
+    }, this.store = e, this.monitor = r, e.subscribe(this.handleRefCountChange);
+  }
+}
+function kt(t, e) {
+  return {
+    x: t.x + e.x,
+    y: t.y + e.y
+  };
+}
+function Pe(t, e) {
+  return {
+    x: t.x - e.x,
+    y: t.y - e.y
+  };
+}
+function At(t) {
+  const { clientOffset: e, initialClientOffset: r, initialSourceClientOffset: n } = t;
+  return !e || !r || !n ? null : Pe(kt(e, n), r);
+}
+function Ht(t) {
+  const { clientOffset: e, initialClientOffset: r } = t;
+  return !e || !r ? null : Pe(e, r);
+}
+const R = [], re = [];
+R.__IS_NONE__ = !0;
+re.__IS_ALL__ = !0;
+function jt(t, e) {
+  return t === R ? !1 : t === re || typeof e > "u" ? !0 : dt(e, t).length > 0;
+}
+class Ut {
+  subscribeToStateChange(e, r = {}) {
+    const { handlerIds: n } = r;
+    l(typeof e == "function", "listener must be a function."), l(typeof n > "u" || Array.isArray(n), "handlerIds, when specified, must be an array of strings.");
+    let i = this.store.getState().stateId;
+    const s = () => {
+      const o = this.store.getState(), a = o.stateId;
+      try {
+        a === i || a === i + 1 && !jt(o.dirtyHandlerIds, n) || e();
+      } finally {
+        i = a;
+      }
+    };
+    return this.store.subscribe(s);
+  }
+  subscribeToOffsetChange(e) {
+    l(typeof e == "function", "listener must be a function.");
+    let r = this.store.getState().dragOffset;
+    const n = () => {
+      const i = this.store.getState().dragOffset;
+      i !== r && (r = i, e());
+    };
+    return this.store.subscribe(n);
+  }
+  canDragSource(e) {
+    if (!e)
+      return !1;
+    const r = this.registry.getSource(e);
+    return l(r, `Expected to find a valid source. sourceId=${e}`), this.isDragging() ? !1 : r.canDrag(this, e);
+  }
+  canDropOnTarget(e) {
+    if (!e)
+      return !1;
+    const r = this.registry.getTarget(e);
+    if (l(r, `Expected to find a valid target. targetId=${e}`), !this.isDragging() || this.didDrop())
+      return !1;
+    const n = this.registry.getTargetType(e), i = this.getItemType();
+    return z(n, i) && r.canDrop(this, e);
+  }
+  isDragging() {
+    return !!this.getItemType();
+  }
+  isDraggingSource(e) {
+    if (!e)
+      return !1;
+    const r = this.registry.getSource(e, !0);
+    if (l(r, `Expected to find a valid source. sourceId=${e}`), !this.isDragging() || !this.isSourcePublic())
+      return !1;
+    const n = this.registry.getSourceType(e), i = this.getItemType();
+    return n !== i ? !1 : r.isDragging(this, e);
+  }
+  isOverTarget(e, r = {
+    shallow: !1
+  }) {
+    if (!e)
+      return !1;
+    const { shallow: n } = r;
+    if (!this.isDragging())
+      return !1;
+    const i = this.registry.getTargetType(e), s = this.getItemType();
+    if (s && !z(i, s))
+      return !1;
+    const o = this.getTargetIds();
+    if (!o.length)
+      return !1;
+    const a = o.indexOf(e);
+    return n ? a === o.length - 1 : a > -1;
+  }
+  getItemType() {
+    return this.store.getState().dragOperation.itemType;
+  }
+  getItem() {
+    return this.store.getState().dragOperation.item;
+  }
+  getSourceId() {
+    return this.store.getState().dragOperation.sourceId;
+  }
+  getTargetIds() {
+    return this.store.getState().dragOperation.targetIds;
+  }
+  getDropResult() {
+    return this.store.getState().dragOperation.dropResult;
+  }
+  didDrop() {
+    return this.store.getState().dragOperation.didDrop;
+  }
+  isSourcePublic() {
+    return !!this.store.getState().dragOperation.isSourcePublic;
+  }
+  getInitialClientOffset() {
+    return this.store.getState().dragOffset.initialClientOffset;
+  }
+  getInitialSourceClientOffset() {
+    return this.store.getState().dragOffset.initialSourceClientOffset;
+  }
+  getClientOffset() {
+    return this.store.getState().dragOffset.clientOffset;
+  }
+  getSourceClientOffset() {
+    return At(this.store.getState().dragOffset);
+  }
+  getDifferenceFromInitialOffset() {
+    return Ht(this.store.getState().dragOffset);
+  }
+  constructor(e, r) {
+    this.store = e, this.registry = r;
+  }
+}
+const he = typeof global < "u" ? global : self, xe = he.MutationObserver || he.WebKitMutationObserver;
+function Re(t) {
+  return function() {
+    const r = setTimeout(i, 0), n = setInterval(i, 50);
+    function i() {
+      clearTimeout(r), clearInterval(n), t();
+    }
+  };
+}
+function Vt(t) {
+  let e = 1;
+  const r = new xe(t), n = document.createTextNode("");
+  return r.observe(n, {
+    characterData: !0
+  }), function() {
+    e = -e, n.data = e;
+  };
+}
+const Ft = typeof xe == "function" ? (
+  // reliably everywhere they are implemented.
+  // They are implemented in all modern browsers.
+  //
+  // - Android 4-4.3
+  // - Chrome 26-34
+  // - Firefox 14-29
+  // - Internet Explorer 11
+  // - iPad Safari 6-7.1
+  // - iPhone Safari 7-7.1
+  // - Safari 6-7
+  Vt
+) : (
+  // task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
+  // 11-12, and in web workers in many engines.
+  // Although message channels yield to any queued rendering and IO tasks, they
+  // would be better than imposing the 4ms delay of timers.
+  // However, they do not work reliably in Internet Explorer or Safari.
+  // Internet Explorer 10 is the only browser that has setImmediate but does
+  // not have MutationObservers.
+  // Although setImmediate yields to the browser's renderer, it would be
+  // preferrable to falling back to setTimeout since it does not have
+  // the minimum 4ms penalty.
+  // Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
+  // Desktop to a lesser extent) that renders both setImmediate and
+  // MessageChannel useless for the purposes of ASAP.
+  // https://github.com/kriskowal/q/issues/396
+  // Timers are implemented universally.
+  // We fall back to timers in workers in most engines, and in foreground
+  // contexts in the following browsers.
+  // However, note that even this simple case requires nuances to operate in a
+  // broad spectrum of browsers.
+  //
+  // - Firefox 3-13
+  // - Internet Explorer 6-9
+  // - iPad Safari 4.3
+  // - Lynx 2.8.7
+  Re
+);
+class Bt {
+  // Use the fastest means possible to execute a task in its own turn, with
+  // priority over other events including IO, animation, reflow, and redraw
+  // events in browsers.
+  //
+  // An exception thrown by a task will permanently interrupt the processing of
+  // subsequent tasks. The higher level `asap` function ensures that if an
+  // exception is thrown by a task, that the task queue will continue flushing as
+  // soon as possible, but if you use `rawAsap` directly, you are responsible to
+  // either ensure that no exceptions are thrown from your task, or to manually
+  // call `rawAsap.requestFlush` if an exception is thrown.
+  enqueueTask(e) {
+    const { queue: r, requestFlush: n } = this;
+    r.length || (n(), this.flushing = !0), r[r.length] = e;
+  }
+  constructor() {
+    this.queue = [], this.pendingErrors = [], this.flushing = !1, this.index = 0, this.capacity = 1024, this.flush = () => {
+      const { queue: e } = this;
+      for (; this.index < e.length; ) {
+        const r = this.index;
+        if (this.index++, e[r].call(), this.index > this.capacity) {
+          for (let n = 0, i = e.length - this.index; n < i; n++)
+            e[n] = e[n + this.index];
+          e.length -= this.index, this.index = 0;
+        }
+      }
+      e.length = 0, this.index = 0, this.flushing = !1;
+    }, this.registerPendingError = (e) => {
+      this.pendingErrors.push(e), this.requestErrorThrow();
+    }, this.requestFlush = Ft(this.flush), this.requestErrorThrow = Re(() => {
+      if (this.pendingErrors.length)
+        throw this.pendingErrors.shift();
+    });
+  }
+}
+class qt {
+  call() {
+    try {
+      this.task && this.task();
+    } catch (e) {
+      this.onError(e);
+    } finally {
+      this.task = null, this.release(this);
+    }
+  }
+  constructor(e, r) {
+    this.onError = e, this.release = r, this.task = null;
+  }
+}
+class $t {
+  create(e) {
+    const r = this.freeTasks, n = r.length ? r.pop() : new qt(
+      this.onError,
+      (i) => r[r.length] = i
+    );
+    return n.task = e, n;
+  }
+  constructor(e) {
+    this.onError = e, this.freeTasks = [];
+  }
+}
+const Me = new Bt(), Gt = new $t(Me.registerPendingError);
+function Yt(t) {
+  Me.enqueueTask(Gt.create(t));
+}
+const ne = "dnd-core/ADD_SOURCE", ie = "dnd-core/ADD_TARGET", se = "dnd-core/REMOVE_SOURCE", V = "dnd-core/REMOVE_TARGET";
+function Xt(t) {
+  return {
+    type: ne,
+    payload: {
+      sourceId: t
+    }
+  };
+}
+function Wt(t) {
+  return {
+    type: ie,
+    payload: {
+      targetId: t
+    }
+  };
+}
+function zt(t) {
+  return {
+    type: se,
+    payload: {
+      sourceId: t
+    }
+  };
+}
+function Qt(t) {
+  return {
+    type: V,
+    payload: {
+      targetId: t
+    }
+  };
+}
+function Kt(t) {
+  l(typeof t.canDrag == "function", "Expected canDrag to be a function."), l(typeof t.beginDrag == "function", "Expected beginDrag to be a function."), l(typeof t.endDrag == "function", "Expected endDrag to be a function.");
+}
+function Jt(t) {
+  l(typeof t.canDrop == "function", "Expected canDrop to be a function."), l(typeof t.hover == "function", "Expected hover to be a function."), l(typeof t.drop == "function", "Expected beginDrag to be a function.");
+}
+function Q(t, e) {
+  if (e && Array.isArray(t)) {
+    t.forEach(
+      (r) => Q(r, !1)
+    );
+    return;
+  }
+  l(typeof t == "string" || typeof t == "symbol", e ? "Type can only be a string, a symbol, or an array of either." : "Type can only be a string or a symbol.");
+}
+var T;
+(function(t) {
+  t.SOURCE = "SOURCE", t.TARGET = "TARGET";
+})(T || (T = {}));
+let Zt = 0;
+function er() {
+  return Zt++;
+}
+function tr(t) {
+  const e = er().toString();
+  switch (t) {
+    case T.SOURCE:
+      return `S${e}`;
+    case T.TARGET:
+      return `T${e}`;
+    default:
+      throw new Error(`Unknown Handler Role: ${t}`);
+  }
+}
+function pe(t) {
+  switch (t[0]) {
+    case "S":
+      return T.SOURCE;
+    case "T":
+      return T.TARGET;
+    default:
+      throw new Error(`Cannot parse handler ID: ${t}`);
+  }
+}
+function me(t, e) {
+  const r = t.entries();
+  let n = !1;
+  do {
+    const { done: i, value: [, s] } = r.next();
+    if (s === e)
+      return !0;
+    n = !!i;
+  } while (!n);
+  return !1;
+}
+class rr {
+  addSource(e, r) {
+    Q(e), Kt(r);
+    const n = this.addHandler(T.SOURCE, e, r);
+    return this.store.dispatch(Xt(n)), n;
+  }
+  addTarget(e, r) {
+    Q(e, !0), Jt(r);
+    const n = this.addHandler(T.TARGET, e, r);
+    return this.store.dispatch(Wt(n)), n;
+  }
+  containsHandler(e) {
+    return me(this.dragSources, e) || me(this.dropTargets, e);
+  }
+  getSource(e, r = !1) {
+    return l(this.isSourceId(e), "Expected a valid source ID."), r && e === this.pinnedSourceId ? this.pinnedSource : this.dragSources.get(e);
+  }
+  getTarget(e) {
+    return l(this.isTargetId(e), "Expected a valid target ID."), this.dropTargets.get(e);
+  }
+  getSourceType(e) {
+    return l(this.isSourceId(e), "Expected a valid source ID."), this.types.get(e);
+  }
+  getTargetType(e) {
+    return l(this.isTargetId(e), "Expected a valid target ID."), this.types.get(e);
+  }
+  isSourceId(e) {
+    return pe(e) === T.SOURCE;
+  }
+  isTargetId(e) {
+    return pe(e) === T.TARGET;
+  }
+  removeSource(e) {
+    l(this.getSource(e), "Expected an existing source."), this.store.dispatch(zt(e)), Yt(() => {
+      this.dragSources.delete(e), this.types.delete(e);
+    });
+  }
+  removeTarget(e) {
+    l(this.getTarget(e), "Expected an existing target."), this.store.dispatch(Qt(e)), this.dropTargets.delete(e), this.types.delete(e);
+  }
+  pinSource(e) {
+    const r = this.getSource(e);
+    l(r, "Expected an existing source."), this.pinnedSourceId = e, this.pinnedSource = r;
+  }
+  unpinSource() {
+    l(this.pinnedSource, "No source is pinned at the time."), this.pinnedSourceId = null, this.pinnedSource = null;
+  }
+  addHandler(e, r, n) {
+    const i = tr(e);
+    return this.types.set(i, r), e === T.SOURCE ? this.dragSources.set(i, n) : e === T.TARGET && this.dropTargets.set(i, n), i;
+  }
+  constructor(e) {
+    this.types = /* @__PURE__ */ new Map(), this.dragSources = /* @__PURE__ */ new Map(), this.dropTargets = /* @__PURE__ */ new Map(), this.pinnedSourceId = null, this.pinnedSource = null, this.store = e;
+  }
+}
+const nr = (t, e) => t === e;
+function ir(t, e) {
+  return !t && !e ? !0 : !t || !e ? !1 : t.x === e.x && t.y === e.y;
+}
+function sr(t, e, r = nr) {
+  if (t.length !== e.length)
+    return !1;
+  for (let n = 0; n < t.length; ++n)
+    if (!r(t[n], e[n]))
+      return !1;
+  return !0;
+}
+function or(t = R, e) {
+  switch (e.type) {
+    case H:
+      break;
+    case ne:
+    case ie:
+    case V:
+    case se:
+      return R;
+    case A:
+    case te:
+    case U:
+    case j:
+    default:
+      return re;
+  }
+  const { targetIds: r = [], prevTargetIds: n = [] } = e.payload, i = lt(r, n);
+  if (!(i.length > 0 || !sr(r, n)))
+    return R;
+  const o = n[n.length - 1], a = r[r.length - 1];
+  return o !== a && (o && i.push(o), a && i.push(a)), i;
+}
+function ar(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function cr(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      ar(t, i, r[i]);
+    });
+  }
+  return t;
+}
+const ve = {
+  initialSourceClientOffset: null,
+  initialClientOffset: null,
+  clientOffset: null
+};
+function ur(t = ve, e) {
+  const { payload: r } = e;
+  switch (e.type) {
+    case ee:
+    case A:
+      return {
+        initialSourceClientOffset: r.sourceClientOffset,
+        initialClientOffset: r.clientOffset,
+        clientOffset: r.clientOffset
+      };
+    case H:
+      return ir(t.clientOffset, r.clientOffset) ? t : cr({}, t, {
+        clientOffset: r.clientOffset
+      });
+    case U:
+    case j:
+      return ve;
+    default:
+      return t;
+  }
+}
+function lr(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function P(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      lr(t, i, r[i]);
+    });
+  }
+  return t;
+}
+const dr = {
+  itemType: null,
+  item: null,
+  sourceId: null,
+  targetIds: [],
+  dropResult: null,
+  didDrop: !1,
+  isSourcePublic: null
+};
+function gr(t = dr, e) {
+  const { payload: r } = e;
+  switch (e.type) {
+    case A:
+      return P({}, t, {
+        itemType: r.itemType,
+        item: r.item,
+        sourceId: r.sourceId,
+        isSourcePublic: r.isSourcePublic,
+        dropResult: null,
+        didDrop: !1
+      });
+    case te:
+      return P({}, t, {
+        isSourcePublic: !0
+      });
+    case H:
+      return P({}, t, {
+        targetIds: r.targetIds
+      });
+    case V:
+      return t.targetIds.indexOf(r.targetId) === -1 ? t : P({}, t, {
+        targetIds: ut(t.targetIds, r.targetId)
+      });
+    case j:
+      return P({}, t, {
+        dropResult: r.dropResult,
+        didDrop: !0,
+        targetIds: []
+      });
+    case U:
+      return P({}, t, {
+        itemType: null,
+        item: null,
+        sourceId: null,
+        dropResult: null,
+        didDrop: !1,
+        isSourcePublic: null,
+        targetIds: []
+      });
+    default:
+      return t;
+  }
+}
+function fr(t = 0, e) {
+  switch (e.type) {
+    case ne:
+    case ie:
+      return t + 1;
+    case se:
+    case V:
+      return t - 1;
+    default:
+      return t;
+  }
+}
+function hr(t = 0) {
+  return t + 1;
+}
+function pr(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function mr(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      pr(t, i, r[i]);
+    });
+  }
+  return t;
+}
+function vr(t = {}, e) {
+  return {
+    dirtyHandlerIds: or(t.dirtyHandlerIds, {
+      type: e.type,
+      payload: mr({}, e.payload, {
+        prevTargetIds: ct(t, "dragOperation.targetIds", [])
+      })
+    }),
+    dragOffset: ur(t.dragOffset, e),
+    refCount: fr(t.refCount, e),
+    dragOperation: gr(t.dragOperation, e),
+    stateId: hr(t.stateId)
+  };
+}
+function Dr(t, e = void 0, r = {}, n = !1) {
+  const i = yr(n), s = new Ut(i, new rr(i)), o = new Lt(i, s), a = t(o, e, r);
+  return o.receiveBackend(a), o;
+}
+function yr(t) {
+  const e = typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION__;
+  return Ce(vr, t && e && e({
+    name: "dnd-core",
+    instanceId: "dnd-core"
+  }));
+}
+function Sr(t, e) {
+  if (t == null) return {};
+  var r = Or(t, e), n, i;
+  if (Object.getOwnPropertySymbols) {
+    var s = Object.getOwnPropertySymbols(t);
+    for (i = 0; i < s.length; i++)
+      n = s[i], !(e.indexOf(n) >= 0) && Object.prototype.propertyIsEnumerable.call(t, n) && (r[n] = t[n]);
+  }
+  return r;
+}
+function Or(t, e) {
+  if (t == null) return {};
+  var r = {}, n = Object.keys(t), i, s;
+  for (s = 0; s < n.length; s++)
+    i = n[s], !(e.indexOf(i) >= 0) && (r[i] = t[i]);
+  return r;
+}
+let De = 0;
+const L = /* @__PURE__ */ Symbol.for("__REACT_DND_CONTEXT_INSTANCE__");
+var Tr = /* @__PURE__ */ Ye(function(e) {
+  var { children: r } = e, n = Sr(e, [
+    "children"
+  ]);
+  const [i, s] = br(n);
+  return k(() => {
+    if (s) {
+      const o = _e();
+      return ++De, () => {
+        --De === 0 && (o[L] = null);
+      };
+    }
+  }, []), /* @__PURE__ */ m(we.Provider, {
+    value: i,
+    children: r
+  });
+});
+function br(t) {
+  if ("manager" in t)
+    return [
+      {
+        dragDropManager: t.manager
+      },
+      !1
+    ];
+  const e = Er(t.backend, t.context, t.options, t.debugMode), r = !t.context;
+  return [
+    e,
+    r
+  ];
+}
+function Er(t, e = _e(), r, n) {
+  const i = e;
+  return i[L] || (i[L] = {
+    dragDropManager: Dr(t, e, r, n)
+  }), i[L];
+}
+function _e() {
+  return typeof global < "u" ? global : window;
+}
+var q, ye;
+function Ir() {
+  return ye || (ye = 1, q = function t(e, r) {
+    if (e === r) return !0;
+    if (e && r && typeof e == "object" && typeof r == "object") {
+      if (e.constructor !== r.constructor) return !1;
+      var n, i, s;
+      if (Array.isArray(e)) {
+        if (n = e.length, n != r.length) return !1;
+        for (i = n; i-- !== 0; )
+          if (!t(e[i], r[i])) return !1;
+        return !0;
+      }
+      if (e.constructor === RegExp) return e.source === r.source && e.flags === r.flags;
+      if (e.valueOf !== Object.prototype.valueOf) return e.valueOf() === r.valueOf();
+      if (e.toString !== Object.prototype.toString) return e.toString() === r.toString();
+      if (s = Object.keys(e), n = s.length, n !== Object.keys(r).length) return !1;
+      for (i = n; i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(r, s[i])) return !1;
+      for (i = n; i-- !== 0; ) {
+        var o = s[i];
+        if (!t(e[o], r[o])) return !1;
+      }
+      return !0;
+    }
+    return e !== e && r !== r;
+  }), q;
+}
+var wr = Ir();
+const Cr = /* @__PURE__ */ tt(wr), C = typeof window < "u" ? Xe : k;
+function Nr(t, e, r) {
+  const [n, i] = Ee(
+    () => e(t)
+  ), s = Ie(() => {
+    const o = e(t);
+    Cr(n, o) || (i(o), r && r());
+  }, [
+    n,
+    t,
+    r
+  ]);
+  return C(s), [
+    n,
+    s
+  ];
+}
+function Pr(t, e, r) {
+  const [n, i] = Nr(t, e, r);
+  return C(function() {
+    const o = t.getHandlerId();
+    if (o != null)
+      return t.subscribeToStateChange(i, {
+        handlerIds: [
+          o
+        ]
+      });
+  }, [
+    t,
+    i
+  ]), n;
+}
+function Le(t, e, r) {
+  return Pr(
+    e,
+    t || (() => ({})),
+    () => r.reconnect()
+  );
+}
+function ke(t, e) {
+  const r = [];
+  return typeof t != "function" && r.push(t), b(() => typeof t == "function" ? t() : t, r);
+}
+function xr(t) {
+  return b(
+    () => t.hooks.dragSource(),
+    [
+      t
+    ]
+  );
+}
+function Rr(t) {
+  return b(
+    () => t.hooks.dragPreview(),
+    [
+      t
+    ]
+  );
+}
+let $ = !1, G = !1;
+class Mr {
+  receiveHandlerId(e) {
+    this.sourceId = e;
+  }
+  getHandlerId() {
+    return this.sourceId;
+  }
+  canDrag() {
+    l(!$, "You may not call monitor.canDrag() inside your canDrag() implementation. Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source-monitor");
+    try {
+      return $ = !0, this.internalMonitor.canDragSource(this.sourceId);
+    } finally {
+      $ = !1;
+    }
+  }
+  isDragging() {
+    if (!this.sourceId)
+      return !1;
+    l(!G, "You may not call monitor.isDragging() inside your isDragging() implementation. Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source-monitor");
+    try {
+      return G = !0, this.internalMonitor.isDraggingSource(this.sourceId);
+    } finally {
+      G = !1;
+    }
+  }
+  subscribeToStateChange(e, r) {
+    return this.internalMonitor.subscribeToStateChange(e, r);
+  }
+  isDraggingSource(e) {
+    return this.internalMonitor.isDraggingSource(e);
+  }
+  isOverTarget(e, r) {
+    return this.internalMonitor.isOverTarget(e, r);
+  }
+  getTargetIds() {
+    return this.internalMonitor.getTargetIds();
+  }
+  isSourcePublic() {
+    return this.internalMonitor.isSourcePublic();
+  }
+  getSourceId() {
+    return this.internalMonitor.getSourceId();
+  }
+  subscribeToOffsetChange(e) {
+    return this.internalMonitor.subscribeToOffsetChange(e);
+  }
+  canDragSource(e) {
+    return this.internalMonitor.canDragSource(e);
+  }
+  canDropOnTarget(e) {
+    return this.internalMonitor.canDropOnTarget(e);
+  }
+  getItemType() {
+    return this.internalMonitor.getItemType();
+  }
+  getItem() {
+    return this.internalMonitor.getItem();
+  }
+  getDropResult() {
+    return this.internalMonitor.getDropResult();
+  }
+  didDrop() {
+    return this.internalMonitor.didDrop();
+  }
+  getInitialClientOffset() {
+    return this.internalMonitor.getInitialClientOffset();
+  }
+  getInitialSourceClientOffset() {
+    return this.internalMonitor.getInitialSourceClientOffset();
+  }
+  getSourceClientOffset() {
+    return this.internalMonitor.getSourceClientOffset();
+  }
+  getClientOffset() {
+    return this.internalMonitor.getClientOffset();
+  }
+  getDifferenceFromInitialOffset() {
+    return this.internalMonitor.getDifferenceFromInitialOffset();
+  }
+  constructor(e) {
+    this.sourceId = null, this.internalMonitor = e.getMonitor();
+  }
+}
+let Y = !1;
+class _r {
+  receiveHandlerId(e) {
+    this.targetId = e;
+  }
+  getHandlerId() {
+    return this.targetId;
+  }
+  subscribeToStateChange(e, r) {
+    return this.internalMonitor.subscribeToStateChange(e, r);
+  }
+  canDrop() {
+    if (!this.targetId)
+      return !1;
+    l(!Y, "You may not call monitor.canDrop() inside your canDrop() implementation. Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target-monitor");
+    try {
+      return Y = !0, this.internalMonitor.canDropOnTarget(this.targetId);
+    } finally {
+      Y = !1;
+    }
+  }
+  isOver(e) {
+    return this.targetId ? this.internalMonitor.isOverTarget(this.targetId, e) : !1;
+  }
+  getItemType() {
+    return this.internalMonitor.getItemType();
+  }
+  getItem() {
+    return this.internalMonitor.getItem();
+  }
+  getDropResult() {
+    return this.internalMonitor.getDropResult();
+  }
+  didDrop() {
+    return this.internalMonitor.didDrop();
+  }
+  getInitialClientOffset() {
+    return this.internalMonitor.getInitialClientOffset();
+  }
+  getInitialSourceClientOffset() {
+    return this.internalMonitor.getInitialSourceClientOffset();
+  }
+  getSourceClientOffset() {
+    return this.internalMonitor.getSourceClientOffset();
+  }
+  getClientOffset() {
+    return this.internalMonitor.getClientOffset();
+  }
+  getDifferenceFromInitialOffset() {
+    return this.internalMonitor.getDifferenceFromInitialOffset();
+  }
+  constructor(e) {
+    this.targetId = null, this.internalMonitor = e.getMonitor();
+  }
+}
+function Lr(t, e, r) {
+  const n = r.getRegistry(), i = n.addTarget(t, e);
+  return [
+    i,
+    () => n.removeTarget(i)
+  ];
+}
+function kr(t, e, r) {
+  const n = r.getRegistry(), i = n.addSource(t, e);
+  return [
+    i,
+    () => n.removeSource(i)
+  ];
+}
+function K(t, e, r, n) {
+  let i;
+  if (i !== void 0)
+    return !!i;
+  if (t === e)
+    return !0;
+  if (typeof t != "object" || !t || typeof e != "object" || !e)
+    return !1;
+  const s = Object.keys(t), o = Object.keys(e);
+  if (s.length !== o.length)
+    return !1;
+  const a = Object.prototype.hasOwnProperty.bind(e);
+  for (let c = 0; c < s.length; c++) {
+    const d = s[c];
+    if (!a(d))
+      return !1;
+    const f = t[d], p = e[d];
+    if (i = void 0, i === !1 || i === void 0 && f !== p)
+      return !1;
+  }
+  return !0;
+}
+function J(t) {
+  return (
+    // eslint-disable-next-line no-prototype-builtins
+    t !== null && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current")
+  );
+}
+function Ar(t) {
+  if (typeof t.type == "string")
+    return;
+  const e = t.type.displayName || t.type.name || "the component";
+  throw new Error(`Only native element nodes can now be passed to React DnD connectors.You can either wrap ${e} into a <div>, or turn it into a drag source or a drop target itself.`);
+}
+function Hr(t) {
+  return (e = null, r = null) => {
+    if (!We(e)) {
+      const s = e;
+      return t(s, r), s;
+    }
+    const n = e;
+    return Ar(n), jr(n, r ? (s) => t(s, r) : t);
+  };
+}
+function Ae(t) {
+  const e = {};
+  return Object.keys(t).forEach((r) => {
+    const n = t[r];
+    if (r.endsWith("Ref"))
+      e[r] = t[r];
+    else {
+      const i = Hr(n);
+      e[r] = () => i;
+    }
+  }), e;
+}
+function Se(t, e) {
+  typeof t == "function" ? t(e) : t.current = e;
+}
+function jr(t, e) {
+  const r = t.ref;
+  return l(typeof r != "string", "Cannot connect React DnD to an element with an existing string ref. Please convert it to use a callback ref instead, or wrap it into a <span> or <div>. Read more: https://reactjs.org/docs/refs-and-the-dom.html#callback-refs"), r ? ae(t, {
+    ref: (n) => {
+      Se(r, n), Se(e, n);
+    }
+  }) : ae(t, {
+    ref: e
+  });
+}
+class Ur {
+  receiveHandlerId(e) {
+    this.handlerId !== e && (this.handlerId = e, this.reconnect());
+  }
+  get connectTarget() {
+    return this.dragSource;
+  }
+  get dragSourceOptions() {
+    return this.dragSourceOptionsInternal;
+  }
+  set dragSourceOptions(e) {
+    this.dragSourceOptionsInternal = e;
+  }
+  get dragPreviewOptions() {
+    return this.dragPreviewOptionsInternal;
+  }
+  set dragPreviewOptions(e) {
+    this.dragPreviewOptionsInternal = e;
+  }
+  reconnect() {
+    const e = this.reconnectDragSource();
+    this.reconnectDragPreview(e);
+  }
+  reconnectDragSource() {
+    const e = this.dragSource, r = this.didHandlerIdChange() || this.didConnectedDragSourceChange() || this.didDragSourceOptionsChange();
+    return r && this.disconnectDragSource(), this.handlerId ? e ? (r && (this.lastConnectedHandlerId = this.handlerId, this.lastConnectedDragSource = e, this.lastConnectedDragSourceOptions = this.dragSourceOptions, this.dragSourceUnsubscribe = this.backend.connectDragSource(this.handlerId, e, this.dragSourceOptions)), r) : (this.lastConnectedDragSource = e, r) : r;
+  }
+  reconnectDragPreview(e = !1) {
+    const r = this.dragPreview, n = e || this.didHandlerIdChange() || this.didConnectedDragPreviewChange() || this.didDragPreviewOptionsChange();
+    if (n && this.disconnectDragPreview(), !!this.handlerId) {
+      if (!r) {
+        this.lastConnectedDragPreview = r;
+        return;
+      }
+      n && (this.lastConnectedHandlerId = this.handlerId, this.lastConnectedDragPreview = r, this.lastConnectedDragPreviewOptions = this.dragPreviewOptions, this.dragPreviewUnsubscribe = this.backend.connectDragPreview(this.handlerId, r, this.dragPreviewOptions));
+    }
+  }
+  didHandlerIdChange() {
+    return this.lastConnectedHandlerId !== this.handlerId;
+  }
+  didConnectedDragSourceChange() {
+    return this.lastConnectedDragSource !== this.dragSource;
+  }
+  didConnectedDragPreviewChange() {
+    return this.lastConnectedDragPreview !== this.dragPreview;
+  }
+  didDragSourceOptionsChange() {
+    return !K(this.lastConnectedDragSourceOptions, this.dragSourceOptions);
+  }
+  didDragPreviewOptionsChange() {
+    return !K(this.lastConnectedDragPreviewOptions, this.dragPreviewOptions);
+  }
+  disconnectDragSource() {
+    this.dragSourceUnsubscribe && (this.dragSourceUnsubscribe(), this.dragSourceUnsubscribe = void 0);
+  }
+  disconnectDragPreview() {
+    this.dragPreviewUnsubscribe && (this.dragPreviewUnsubscribe(), this.dragPreviewUnsubscribe = void 0, this.dragPreviewNode = null, this.dragPreviewRef = null);
+  }
+  get dragSource() {
+    return this.dragSourceNode || this.dragSourceRef && this.dragSourceRef.current;
+  }
+  get dragPreview() {
+    return this.dragPreviewNode || this.dragPreviewRef && this.dragPreviewRef.current;
+  }
+  clearDragSource() {
+    this.dragSourceNode = null, this.dragSourceRef = null;
+  }
+  clearDragPreview() {
+    this.dragPreviewNode = null, this.dragPreviewRef = null;
+  }
+  constructor(e) {
+    this.hooks = Ae({
+      dragSource: (r, n) => {
+        this.clearDragSource(), this.dragSourceOptions = n || null, J(r) ? this.dragSourceRef = r : this.dragSourceNode = r, this.reconnectDragSource();
+      },
+      dragPreview: (r, n) => {
+        this.clearDragPreview(), this.dragPreviewOptions = n || null, J(r) ? this.dragPreviewRef = r : this.dragPreviewNode = r, this.reconnectDragPreview();
+      }
+    }), this.handlerId = null, this.dragSourceRef = null, this.dragSourceOptionsInternal = null, this.dragPreviewRef = null, this.dragPreviewOptionsInternal = null, this.lastConnectedHandlerId = null, this.lastConnectedDragSource = null, this.lastConnectedDragSourceOptions = null, this.lastConnectedDragPreview = null, this.lastConnectedDragPreviewOptions = null, this.backend = e;
+  }
+}
+class Vr {
+  get connectTarget() {
+    return this.dropTarget;
+  }
+  reconnect() {
+    const e = this.didHandlerIdChange() || this.didDropTargetChange() || this.didOptionsChange();
+    e && this.disconnectDropTarget();
+    const r = this.dropTarget;
+    if (this.handlerId) {
+      if (!r) {
+        this.lastConnectedDropTarget = r;
+        return;
+      }
+      e && (this.lastConnectedHandlerId = this.handlerId, this.lastConnectedDropTarget = r, this.lastConnectedDropTargetOptions = this.dropTargetOptions, this.unsubscribeDropTarget = this.backend.connectDropTarget(this.handlerId, r, this.dropTargetOptions));
+    }
+  }
+  receiveHandlerId(e) {
+    e !== this.handlerId && (this.handlerId = e, this.reconnect());
+  }
+  get dropTargetOptions() {
+    return this.dropTargetOptionsInternal;
+  }
+  set dropTargetOptions(e) {
+    this.dropTargetOptionsInternal = e;
+  }
+  didHandlerIdChange() {
+    return this.lastConnectedHandlerId !== this.handlerId;
+  }
+  didDropTargetChange() {
+    return this.lastConnectedDropTarget !== this.dropTarget;
+  }
+  didOptionsChange() {
+    return !K(this.lastConnectedDropTargetOptions, this.dropTargetOptions);
+  }
+  disconnectDropTarget() {
+    this.unsubscribeDropTarget && (this.unsubscribeDropTarget(), this.unsubscribeDropTarget = void 0);
+  }
+  get dropTarget() {
+    return this.dropTargetNode || this.dropTargetRef && this.dropTargetRef.current;
+  }
+  clearDropTarget() {
+    this.dropTargetRef = null, this.dropTargetNode = null;
+  }
+  constructor(e) {
+    this.hooks = Ae({
+      dropTarget: (r, n) => {
+        this.clearDropTarget(), this.dropTargetOptions = n, J(r) ? this.dropTargetRef = r : this.dropTargetNode = r, this.reconnect();
+      }
+    }), this.handlerId = null, this.dropTargetRef = null, this.dropTargetOptionsInternal = null, this.lastConnectedHandlerId = null, this.lastConnectedDropTarget = null, this.lastConnectedDropTargetOptions = null, this.backend = e;
+  }
+}
+function x() {
+  const { dragDropManager: t } = ze(we);
+  return l(t != null, "Expected drag drop context"), t;
+}
+function Fr(t, e) {
+  const r = x(), n = b(
+    () => new Ur(r.getBackend()),
+    [
+      r
+    ]
+  );
+  return C(() => (n.dragSourceOptions = t || null, n.reconnect(), () => n.disconnectDragSource()), [
+    n,
+    t
+  ]), C(() => (n.dragPreviewOptions = e || null, n.reconnect(), () => n.disconnectDragPreview()), [
+    n,
+    e
+  ]), n;
+}
+function Br() {
+  const t = x();
+  return b(
+    () => new Mr(t),
+    [
+      t
+    ]
+  );
+}
+class qr {
+  beginDrag() {
+    const e = this.spec, r = this.monitor;
+    let n = null;
+    return typeof e.item == "object" ? n = e.item : typeof e.item == "function" ? n = e.item(r) : n = {}, n ?? null;
+  }
+  canDrag() {
+    const e = this.spec, r = this.monitor;
+    return typeof e.canDrag == "boolean" ? e.canDrag : typeof e.canDrag == "function" ? e.canDrag(r) : !0;
+  }
+  isDragging(e, r) {
+    const n = this.spec, i = this.monitor, { isDragging: s } = n;
+    return s ? s(i) : r === e.getSourceId();
+  }
+  endDrag() {
+    const e = this.spec, r = this.monitor, n = this.connector, { end: i } = e;
+    i && i(r.getItem(), r), n.reconnect();
+  }
+  constructor(e, r, n) {
+    this.spec = e, this.monitor = r, this.connector = n;
+  }
+}
+function $r(t, e, r) {
+  const n = b(
+    () => new qr(t, e, r),
+    [
+      e,
+      r
+    ]
+  );
+  return k(() => {
+    n.spec = t;
+  }, [
+    t
+  ]), n;
+}
+function Gr(t) {
+  return b(() => {
+    const e = t.type;
+    return l(e != null, "spec.type must be defined"), e;
+  }, [
+    t
+  ]);
+}
+function Yr(t, e, r) {
+  const n = x(), i = $r(t, e, r), s = Gr(t);
+  C(function() {
+    if (s != null) {
+      const [a, c] = kr(s, i, n);
+      return e.receiveHandlerId(a), r.receiveHandlerId(a), c;
+    }
+  }, [
+    n,
+    e,
+    r,
+    i,
+    s
+  ]);
+}
+function Xr(t, e) {
+  const r = ke(t);
+  l(!r.begin, "useDrag::spec.begin was deprecated in v14. Replace spec.begin() with spec.item(). (see more here - https://react-dnd.github.io/react-dnd/docs/api/use-drag)");
+  const n = Br(), i = Fr(r.options, r.previewOptions);
+  return Yr(r, n, i), [
+    Le(r.collect, n, i),
+    xr(i),
+    Rr(i)
+  ];
+}
+function Wr(t) {
+  return b(
+    () => t.hooks.dropTarget(),
+    [
+      t
+    ]
+  );
+}
+function zr(t) {
+  const e = x(), r = b(
+    () => new Vr(e.getBackend()),
+    [
+      e
+    ]
+  );
+  return C(() => (r.dropTargetOptions = t || null, r.reconnect(), () => r.disconnectDropTarget()), [
+    t
+  ]), r;
+}
+function Qr() {
+  const t = x();
+  return b(
+    () => new _r(t),
+    [
+      t
+    ]
+  );
+}
+function Kr(t) {
+  const { accept: e } = t;
+  return b(() => (l(t.accept != null, "accept must be defined"), Array.isArray(e) ? e : [
+    e
+  ]), [
+    e
+  ]);
+}
+class Jr {
+  canDrop() {
+    const e = this.spec, r = this.monitor;
+    return e.canDrop ? e.canDrop(r.getItem(), r) : !0;
+  }
+  hover() {
+    const e = this.spec, r = this.monitor;
+    e.hover && e.hover(r.getItem(), r);
+  }
+  drop() {
+    const e = this.spec, r = this.monitor;
+    if (e.drop)
+      return e.drop(r.getItem(), r);
+  }
+  constructor(e, r) {
+    this.spec = e, this.monitor = r;
+  }
+}
+function Zr(t, e) {
+  const r = b(
+    () => new Jr(t, e),
+    [
+      e
+    ]
+  );
+  return k(() => {
+    r.spec = t;
+  }, [
+    t
+  ]), r;
+}
+function en(t, e, r) {
+  const n = x(), i = Zr(t, e), s = Kr(t);
+  C(function() {
+    const [a, c] = Lr(s, i, n);
+    return e.receiveHandlerId(a), r.receiveHandlerId(a), c;
+  }, [
+    n,
+    e,
+    i,
+    r,
+    s.map(
+      (o) => o.toString()
+    ).join("|")
+  ]);
+}
+function tn(t, e) {
+  const r = ke(t), n = Qr(), i = zr(r.options);
+  return en(r, n, i), [
+    Le(r.collect, n, i),
+    Wr(i)
+  ];
+}
+function He(t) {
+  let e = null;
+  return () => (e == null && (e = t()), e);
+}
+function rn(t, e) {
+  return t.filter(
+    (r) => r !== e
+  );
+}
+function nn(t, e) {
+  const r = /* @__PURE__ */ new Set(), n = (s) => r.add(s);
+  t.forEach(n), e.forEach(n);
+  const i = [];
+  return r.forEach(
+    (s) => i.push(s)
+  ), i;
+}
+class sn {
+  enter(e) {
+    const r = this.entered.length, n = (i) => this.isNodeInDocument(i) && (!i.contains || i.contains(e));
+    return this.entered = nn(this.entered.filter(n), [
+      e
+    ]), r === 0 && this.entered.length > 0;
+  }
+  leave(e) {
+    const r = this.entered.length;
+    return this.entered = rn(this.entered.filter(this.isNodeInDocument), e), r > 0 && this.entered.length === 0;
+  }
+  reset() {
+    this.entered = [];
+  }
+  constructor(e) {
+    this.entered = [], this.isNodeInDocument = e;
+  }
+}
+class on {
+  initializeExposedProperties() {
+    Object.keys(this.config.exposeProperties).forEach((e) => {
+      Object.defineProperty(this.item, e, {
+        configurable: !0,
+        enumerable: !0,
+        get() {
+          return console.warn(`Browser doesn't allow reading "${e}" until the drop event.`), null;
+        }
+      });
+    });
+  }
+  loadDataTransfer(e) {
+    if (e) {
+      const r = {};
+      Object.keys(this.config.exposeProperties).forEach((n) => {
+        const i = this.config.exposeProperties[n];
+        i != null && (r[n] = {
+          value: i(e, this.config.matchesTypes),
+          configurable: !0,
+          enumerable: !0
+        });
+      }), Object.defineProperties(this.item, r);
+    }
+  }
+  canDrag() {
+    return !0;
+  }
+  beginDrag() {
+    return this.item;
+  }
+  isDragging(e, r) {
+    return r === e.getSourceId();
+  }
+  endDrag() {
+  }
+  constructor(e) {
+    this.config = e, this.item = {}, this.initializeExposedProperties();
+  }
+}
+const je = "__NATIVE_FILE__", Ue = "__NATIVE_URL__", Ve = "__NATIVE_TEXT__", Fe = "__NATIVE_HTML__", Oe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FILE: je,
+  HTML: Fe,
+  TEXT: Ve,
+  URL: Ue
+}, Symbol.toStringTag, { value: "Module" }));
+function X(t, e, r) {
+  const n = e.reduce(
+    (i, s) => i || t.getData(s),
+    ""
+  );
+  return n ?? r;
+}
+const Z = {
+  [je]: {
+    exposeProperties: {
+      files: (t) => Array.prototype.slice.call(t.files),
+      items: (t) => t.items,
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Files"
+    ]
+  },
+  [Fe]: {
+    exposeProperties: {
+      html: (t, e) => X(t, e, ""),
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Html",
+      "text/html"
+    ]
+  },
+  [Ue]: {
+    exposeProperties: {
+      urls: (t, e) => X(t, e, "").split(`
+`),
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Url",
+      "text/uri-list"
+    ]
+  },
+  [Ve]: {
+    exposeProperties: {
+      text: (t, e) => X(t, e, ""),
+      dataTransfer: (t) => t
+    },
+    matchesTypes: [
+      "Text",
+      "text/plain"
+    ]
+  }
+};
+function an(t, e) {
+  const r = Z[t];
+  if (!r)
+    throw new Error(`native type ${t} has no configuration`);
+  const n = new on(r);
+  return n.loadDataTransfer(e), n;
+}
+function W(t) {
+  if (!t)
+    return null;
+  const e = Array.prototype.slice.call(t.types || []);
+  return Object.keys(Z).filter((r) => {
+    const n = Z[r];
+    return n?.matchesTypes ? n.matchesTypes.some(
+      (i) => e.indexOf(i) > -1
+    ) : !1;
+  })[0] || null;
+}
+const cn = He(
+  () => /firefox/i.test(navigator.userAgent)
+), Be = He(
+  () => !!window.safari
+);
+class Te {
+  interpolate(e) {
+    const { xs: r, ys: n, c1s: i, c2s: s, c3s: o } = this;
+    let a = r.length - 1;
+    if (e === r[a])
+      return n[a];
+    let c = 0, d = o.length - 1, f;
+    for (; c <= d; ) {
+      f = Math.floor(0.5 * (c + d));
+      const u = r[f];
+      if (u < e)
+        c = f + 1;
+      else if (u > e)
+        d = f - 1;
+      else
+        return n[f];
+    }
+    a = Math.max(0, d);
+    const p = e - r[a], g = p * p;
+    return n[a] + i[a] * p + s[a] * g + o[a] * p * g;
+  }
+  constructor(e, r) {
+    const { length: n } = e, i = [];
+    for (let u = 0; u < n; u++)
+      i.push(u);
+    i.sort(
+      (u, D) => e[u] < e[D] ? -1 : 1
+    );
+    const s = [], o = [];
+    let a, c;
+    for (let u = 0; u < n - 1; u++)
+      a = e[u + 1] - e[u], c = r[u + 1] - r[u], s.push(a), o.push(c / a);
+    const d = [
+      o[0]
+    ];
+    for (let u = 0; u < s.length - 1; u++) {
+      const D = o[u], h = o[u + 1];
+      if (D * h <= 0)
+        d.push(0);
+      else {
+        a = s[u];
+        const v = s[u + 1], y = a + v;
+        d.push(3 * y / ((y + v) / D + (y + a) / h));
+      }
+    }
+    d.push(o[o.length - 1]);
+    const f = [], p = [];
+    let g;
+    for (let u = 0; u < d.length - 1; u++) {
+      g = o[u];
+      const D = d[u], h = 1 / s[u], v = D + d[u + 1] - g - g;
+      f.push((g - D - v) * h), p.push(v * h * h);
+    }
+    this.xs = e, this.ys = r, this.c1s = d, this.c2s = f, this.c3s = p;
+  }
+}
+const un = 1;
+function qe(t) {
+  const e = t.nodeType === un ? t : t.parentElement;
+  if (!e)
+    return null;
+  const { top: r, left: n } = e.getBoundingClientRect();
+  return {
+    x: n,
+    y: r
+  };
+}
+function M(t) {
+  return {
+    x: t.clientX,
+    y: t.clientY
+  };
+}
+function ln(t) {
+  var e;
+  return t.nodeName === "IMG" && (cn() || !(!((e = document.documentElement) === null || e === void 0) && e.contains(t)));
+}
+function dn(t, e, r, n) {
+  let i = t ? e.width : r, s = t ? e.height : n;
+  return Be() && t && (s /= window.devicePixelRatio, i /= window.devicePixelRatio), {
+    dragPreviewWidth: i,
+    dragPreviewHeight: s
+  };
+}
+function gn(t, e, r, n, i) {
+  const s = ln(e), a = qe(s ? t : e), c = {
+    x: r.x - a.x,
+    y: r.y - a.y
+  }, { offsetWidth: d, offsetHeight: f } = t, { anchorX: p, anchorY: g } = n, { dragPreviewWidth: u, dragPreviewHeight: D } = dn(s, e, d, f), h = () => {
+    let oe = new Te([
+      0,
+      0.5,
+      1
+    ], [
+      // Dock to the top
+      c.y,
+      // Align at the center
+      c.y / f * D,
+      // Dock to the bottom
+      c.y + D - f
+    ]).interpolate(g);
+    return Be() && s && (oe += (window.devicePixelRatio - 1) * D), oe;
+  }, v = () => new Te([
+    0,
+    0.5,
+    1
+  ], [
+    // Dock to the left
+    c.x,
+    // Align at the center
+    c.x / d * u,
+    // Dock to the right
+    c.x + u - d
+  ]).interpolate(p), { offsetX: y, offsetY: S } = i, I = y === 0 || y, F = S === 0 || S;
+  return {
+    x: I ? y : v(),
+    y: F ? S : h()
+  };
+}
+class fn {
+  get window() {
+    if (this.globalContext)
+      return this.globalContext;
+    if (typeof window < "u")
+      return window;
+  }
+  get document() {
+    var e;
+    return !((e = this.globalContext) === null || e === void 0) && e.document ? this.globalContext.document : this.window ? this.window.document : void 0;
+  }
+  get rootElement() {
+    var e;
+    return ((e = this.optionsArgs) === null || e === void 0 ? void 0 : e.rootElement) || this.window;
+  }
+  constructor(e, r) {
+    this.ownerDocument = null, this.globalContext = e, this.optionsArgs = r;
+  }
+}
+function hn(t, e, r) {
+  return e in t ? Object.defineProperty(t, e, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[e] = r, t;
+}
+function be(t) {
+  for (var e = 1; e < arguments.length; e++) {
+    var r = arguments[e] != null ? arguments[e] : {}, n = Object.keys(r);
+    typeof Object.getOwnPropertySymbols == "function" && (n = n.concat(Object.getOwnPropertySymbols(r).filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    }))), n.forEach(function(i) {
+      hn(t, i, r[i]);
+    });
+  }
+  return t;
+}
+class pn {
+  /**
+  * Generate profiling statistics for the HTML5Backend.
+  */
+  profile() {
+    var e, r;
+    return {
+      sourcePreviewNodes: this.sourcePreviewNodes.size,
+      sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
+      sourceNodeOptions: this.sourceNodeOptions.size,
+      sourceNodes: this.sourceNodes.size,
+      dragStartSourceIds: ((e = this.dragStartSourceIds) === null || e === void 0 ? void 0 : e.length) || 0,
+      dropTargetIds: this.dropTargetIds.length,
+      dragEnterTargetIds: this.dragEnterTargetIds.length,
+      dragOverTargetIds: ((r = this.dragOverTargetIds) === null || r === void 0 ? void 0 : r.length) || 0
+    };
+  }
+  // public for test
+  get window() {
+    return this.options.window;
+  }
+  get document() {
+    return this.options.document;
+  }
+  /**
+  * Get the root element to use for event subscriptions
+  */
+  get rootElement() {
+    return this.options.rootElement;
+  }
+  setup() {
+    const e = this.rootElement;
+    if (e !== void 0) {
+      if (e.__isReactDndBackendSetUp)
+        throw new Error("Cannot have two HTML5 backends at the same time.");
+      e.__isReactDndBackendSetUp = !0, this.addEventListeners(e);
+    }
+  }
+  teardown() {
+    const e = this.rootElement;
+    if (e !== void 0 && (e.__isReactDndBackendSetUp = !1, this.removeEventListeners(this.rootElement), this.clearCurrentDragSourceNode(), this.asyncEndDragFrameId)) {
+      var r;
+      (r = this.window) === null || r === void 0 || r.cancelAnimationFrame(this.asyncEndDragFrameId);
+    }
+  }
+  connectDragPreview(e, r, n) {
+    return this.sourcePreviewNodeOptions.set(e, n), this.sourcePreviewNodes.set(e, r), () => {
+      this.sourcePreviewNodes.delete(e), this.sourcePreviewNodeOptions.delete(e);
+    };
+  }
+  connectDragSource(e, r, n) {
+    this.sourceNodes.set(e, r), this.sourceNodeOptions.set(e, n);
+    const i = (o) => this.handleDragStart(o, e), s = (o) => this.handleSelectStart(o);
+    return r.setAttribute("draggable", "true"), r.addEventListener("dragstart", i), r.addEventListener("selectstart", s), () => {
+      this.sourceNodes.delete(e), this.sourceNodeOptions.delete(e), r.removeEventListener("dragstart", i), r.removeEventListener("selectstart", s), r.setAttribute("draggable", "false");
+    };
+  }
+  connectDropTarget(e, r) {
+    const n = (o) => this.handleDragEnter(o, e), i = (o) => this.handleDragOver(o, e), s = (o) => this.handleDrop(o, e);
+    return r.addEventListener("dragenter", n), r.addEventListener("dragover", i), r.addEventListener("drop", s), () => {
+      r.removeEventListener("dragenter", n), r.removeEventListener("dragover", i), r.removeEventListener("drop", s);
+    };
+  }
+  addEventListeners(e) {
+    e.addEventListener && (e.addEventListener("dragstart", this.handleTopDragStart), e.addEventListener("dragstart", this.handleTopDragStartCapture, !0), e.addEventListener("dragend", this.handleTopDragEndCapture, !0), e.addEventListener("dragenter", this.handleTopDragEnter), e.addEventListener("dragenter", this.handleTopDragEnterCapture, !0), e.addEventListener("dragleave", this.handleTopDragLeaveCapture, !0), e.addEventListener("dragover", this.handleTopDragOver), e.addEventListener("dragover", this.handleTopDragOverCapture, !0), e.addEventListener("drop", this.handleTopDrop), e.addEventListener("drop", this.handleTopDropCapture, !0));
+  }
+  removeEventListeners(e) {
+    e.removeEventListener && (e.removeEventListener("dragstart", this.handleTopDragStart), e.removeEventListener("dragstart", this.handleTopDragStartCapture, !0), e.removeEventListener("dragend", this.handleTopDragEndCapture, !0), e.removeEventListener("dragenter", this.handleTopDragEnter), e.removeEventListener("dragenter", this.handleTopDragEnterCapture, !0), e.removeEventListener("dragleave", this.handleTopDragLeaveCapture, !0), e.removeEventListener("dragover", this.handleTopDragOver), e.removeEventListener("dragover", this.handleTopDragOverCapture, !0), e.removeEventListener("drop", this.handleTopDrop), e.removeEventListener("drop", this.handleTopDropCapture, !0));
+  }
+  getCurrentSourceNodeOptions() {
+    const e = this.monitor.getSourceId(), r = this.sourceNodeOptions.get(e);
+    return be({
+      dropEffect: this.altKeyPressed ? "copy" : "move"
+    }, r || {});
+  }
+  getCurrentDropEffect() {
+    return this.isDraggingNativeItem() ? "copy" : this.getCurrentSourceNodeOptions().dropEffect;
+  }
+  getCurrentSourcePreviewNodeOptions() {
+    const e = this.monitor.getSourceId(), r = this.sourcePreviewNodeOptions.get(e);
+    return be({
+      anchorX: 0.5,
+      anchorY: 0.5,
+      captureDraggingState: !1
+    }, r || {});
+  }
+  isDraggingNativeItem() {
+    const e = this.monitor.getItemType();
+    return Object.keys(Oe).some(
+      (r) => Oe[r] === e
+    );
+  }
+  beginDragNativeItem(e, r) {
+    this.clearCurrentDragSourceNode(), this.currentNativeSource = an(e, r), this.currentNativeHandle = this.registry.addSource(e, this.currentNativeSource), this.actions.beginDrag([
+      this.currentNativeHandle
+    ]);
+  }
+  setCurrentDragSourceNode(e) {
+    this.clearCurrentDragSourceNode(), this.currentDragSourceNode = e;
+    const r = 1e3;
+    this.mouseMoveTimeoutTimer = setTimeout(() => {
+      var n;
+      return (n = this.rootElement) === null || n === void 0 ? void 0 : n.addEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, !0);
+    }, r);
+  }
+  clearCurrentDragSourceNode() {
+    if (this.currentDragSourceNode) {
+      if (this.currentDragSourceNode = null, this.rootElement) {
+        var e;
+        (e = this.window) === null || e === void 0 || e.clearTimeout(this.mouseMoveTimeoutTimer || void 0), this.rootElement.removeEventListener("mousemove", this.endDragIfSourceWasRemovedFromDOM, !0);
+      }
+      return this.mouseMoveTimeoutTimer = null, !0;
+    }
+    return !1;
+  }
+  handleDragStart(e, r) {
+    e.defaultPrevented || (this.dragStartSourceIds || (this.dragStartSourceIds = []), this.dragStartSourceIds.unshift(r));
+  }
+  handleDragEnter(e, r) {
+    this.dragEnterTargetIds.unshift(r);
+  }
+  handleDragOver(e, r) {
+    this.dragOverTargetIds === null && (this.dragOverTargetIds = []), this.dragOverTargetIds.unshift(r);
+  }
+  handleDrop(e, r) {
+    this.dropTargetIds.unshift(r);
+  }
+  constructor(e, r, n) {
+    this.sourcePreviewNodes = /* @__PURE__ */ new Map(), this.sourcePreviewNodeOptions = /* @__PURE__ */ new Map(), this.sourceNodes = /* @__PURE__ */ new Map(), this.sourceNodeOptions = /* @__PURE__ */ new Map(), this.dragStartSourceIds = null, this.dropTargetIds = [], this.dragEnterTargetIds = [], this.currentNativeSource = null, this.currentNativeHandle = null, this.currentDragSourceNode = null, this.altKeyPressed = !1, this.mouseMoveTimeoutTimer = null, this.asyncEndDragFrameId = null, this.dragOverTargetIds = null, this.lastClientOffset = null, this.hoverRafId = null, this.getSourceClientOffset = (i) => {
+      const s = this.sourceNodes.get(i);
+      return s && qe(s) || null;
+    }, this.endDragNativeItem = () => {
+      this.isDraggingNativeItem() && (this.actions.endDrag(), this.currentNativeHandle && this.registry.removeSource(this.currentNativeHandle), this.currentNativeHandle = null, this.currentNativeSource = null);
+    }, this.isNodeInDocument = (i) => !!(i && this.document && this.document.body && this.document.body.contains(i)), this.endDragIfSourceWasRemovedFromDOM = () => {
+      const i = this.currentDragSourceNode;
+      i == null || this.isNodeInDocument(i) || (this.clearCurrentDragSourceNode() && this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover());
+    }, this.scheduleHover = (i) => {
+      this.hoverRafId === null && typeof requestAnimationFrame < "u" && (this.hoverRafId = requestAnimationFrame(() => {
+        this.monitor.isDragging() && this.actions.hover(i || [], {
+          clientOffset: this.lastClientOffset
+        }), this.hoverRafId = null;
+      }));
+    }, this.cancelHover = () => {
+      this.hoverRafId !== null && typeof cancelAnimationFrame < "u" && (cancelAnimationFrame(this.hoverRafId), this.hoverRafId = null);
+    }, this.handleTopDragStartCapture = () => {
+      this.clearCurrentDragSourceNode(), this.dragStartSourceIds = [];
+    }, this.handleTopDragStart = (i) => {
+      if (i.defaultPrevented)
+        return;
+      const { dragStartSourceIds: s } = this;
+      this.dragStartSourceIds = null;
+      const o = M(i);
+      this.monitor.isDragging() && (this.actions.endDrag(), this.cancelHover()), this.actions.beginDrag(s || [], {
+        publishSource: !1,
+        getSourceClientOffset: this.getSourceClientOffset,
+        clientOffset: o
+      });
+      const { dataTransfer: a } = i, c = W(a);
+      if (this.monitor.isDragging()) {
+        if (a && typeof a.setDragImage == "function") {
+          const f = this.monitor.getSourceId(), p = this.sourceNodes.get(f), g = this.sourcePreviewNodes.get(f) || p;
+          if (g) {
+            const { anchorX: u, anchorY: D, offsetX: h, offsetY: v } = this.getCurrentSourcePreviewNodeOptions(), I = gn(p, g, o, {
+              anchorX: u,
+              anchorY: D
+            }, {
+              offsetX: h,
+              offsetY: v
+            });
+            a.setDragImage(g, I.x, I.y);
+          }
+        }
+        try {
+          a?.setData("application/json", {});
+        } catch {
+        }
+        this.setCurrentDragSourceNode(i.target);
+        const { captureDraggingState: d } = this.getCurrentSourcePreviewNodeOptions();
+        d ? this.actions.publishDragSource() : setTimeout(
+          () => this.actions.publishDragSource(),
+          0
+        );
+      } else if (c)
+        this.beginDragNativeItem(c);
+      else {
+        if (a && !a.types && (i.target && !i.target.hasAttribute || !i.target.hasAttribute("draggable")))
+          return;
+        i.preventDefault();
+      }
+    }, this.handleTopDragEndCapture = () => {
+      this.clearCurrentDragSourceNode() && this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover();
+    }, this.handleTopDragEnterCapture = (i) => {
+      if (this.dragEnterTargetIds = [], this.isDraggingNativeItem()) {
+        var s;
+        (s = this.currentNativeSource) === null || s === void 0 || s.loadDataTransfer(i.dataTransfer);
+      }
+      if (!this.enterLeaveCounter.enter(i.target) || this.monitor.isDragging())
+        return;
+      const { dataTransfer: a } = i, c = W(a);
+      c && this.beginDragNativeItem(c, a);
+    }, this.handleTopDragEnter = (i) => {
+      const { dragEnterTargetIds: s } = this;
+      if (this.dragEnterTargetIds = [], !this.monitor.isDragging())
+        return;
+      this.altKeyPressed = i.altKey, s.length > 0 && this.actions.hover(s, {
+        clientOffset: M(i)
+      }), s.some(
+        (a) => this.monitor.canDropOnTarget(a)
+      ) && (i.preventDefault(), i.dataTransfer && (i.dataTransfer.dropEffect = this.getCurrentDropEffect()));
+    }, this.handleTopDragOverCapture = (i) => {
+      if (this.dragOverTargetIds = [], this.isDraggingNativeItem()) {
+        var s;
+        (s = this.currentNativeSource) === null || s === void 0 || s.loadDataTransfer(i.dataTransfer);
+      }
+    }, this.handleTopDragOver = (i) => {
+      const { dragOverTargetIds: s } = this;
+      if (this.dragOverTargetIds = [], !this.monitor.isDragging()) {
+        i.preventDefault(), i.dataTransfer && (i.dataTransfer.dropEffect = "none");
+        return;
+      }
+      this.altKeyPressed = i.altKey, this.lastClientOffset = M(i), this.scheduleHover(s), (s || []).some(
+        (a) => this.monitor.canDropOnTarget(a)
+      ) ? (i.preventDefault(), i.dataTransfer && (i.dataTransfer.dropEffect = this.getCurrentDropEffect())) : this.isDraggingNativeItem() ? i.preventDefault() : (i.preventDefault(), i.dataTransfer && (i.dataTransfer.dropEffect = "none"));
+    }, this.handleTopDragLeaveCapture = (i) => {
+      this.isDraggingNativeItem() && i.preventDefault(), this.enterLeaveCounter.leave(i.target) && (this.isDraggingNativeItem() && setTimeout(
+        () => this.endDragNativeItem(),
+        0
+      ), this.cancelHover());
+    }, this.handleTopDropCapture = (i) => {
+      if (this.dropTargetIds = [], this.isDraggingNativeItem()) {
+        var s;
+        i.preventDefault(), (s = this.currentNativeSource) === null || s === void 0 || s.loadDataTransfer(i.dataTransfer);
+      } else W(i.dataTransfer) && i.preventDefault();
+      this.enterLeaveCounter.reset();
+    }, this.handleTopDrop = (i) => {
+      const { dropTargetIds: s } = this;
+      this.dropTargetIds = [], this.actions.hover(s, {
+        clientOffset: M(i)
+      }), this.actions.drop({
+        dropEffect: this.getCurrentDropEffect()
+      }), this.isDraggingNativeItem() ? this.endDragNativeItem() : this.monitor.isDragging() && this.actions.endDrag(), this.cancelHover();
+    }, this.handleSelectStart = (i) => {
+      const s = i.target;
+      typeof s.dragDrop == "function" && (s.tagName === "INPUT" || s.tagName === "SELECT" || s.tagName === "TEXTAREA" || s.isContentEditable || (i.preventDefault(), s.dragDrop()));
+    }, this.options = new fn(r, n), this.actions = e.getActions(), this.monitor = e.getMonitor(), this.registry = e.getRegistry(), this.enterLeaveCounter = new sn(this.isNodeInDocument);
+  }
+}
+const mn = function(e, r, n) {
+  return new pn(e, r, n);
+}, vn = (t) => /* @__PURE__ */ w.createElement("svg", { width: 16, height: 16, viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...t }, /* @__PURE__ */ w.createElement("circle", { cx: 6, cy: 4, r: 1.25, fill: "#2B2B2B" }), /* @__PURE__ */ w.createElement("circle", { cx: 10, cy: 4, r: 1.25, fill: "#2B2B2B" }), /* @__PURE__ */ w.createElement("circle", { cx: 6, cy: 8, r: 1.25, fill: "#2B2B2B" }), /* @__PURE__ */ w.createElement("circle", { cx: 10, cy: 8, r: 1.25, fill: "#2B2B2B" }), /* @__PURE__ */ w.createElement("circle", { cx: 6, cy: 12, r: 1.25, fill: "#2B2B2B" }), /* @__PURE__ */ w.createElement("circle", { cx: 10, cy: 12, r: 1.25, fill: "#2B2B2B" }));
+function Dn({
+  column: t,
+  index: e,
+  moveListItem: r,
+  visibility: n,
+  onToggleVisibility: i
+}) {
+  const s = t.isDraggable !== !1, o = t.toogleVisibility !== !1 && t.toggleVisibility !== !1, a = Qe(null), [, c] = tn({
+    accept: ce,
+    hover(p) {
+      s && p.index !== e && (r(p.index, e), p.index = e);
+    }
+  }), [{ isDragging: d }, f] = Xr({
+    type: ce,
+    item: { index: e },
+    canDrag: s,
+    collect: (p) => ({
+      isDragging: p.isDragging()
+    })
+  });
+  return s ? f(c(a)) : c(a), /* @__PURE__ */ E(
+    "div",
+    {
+      ref: a,
+      className: ue(
+        "ckds-dragable-list-item flex items-center p-2 border-none rounded-md gap-1",
+        d ? "opacity-50" : "opacity-100"
+      ),
+      children: [
+        /* @__PURE__ */ m("div", { className: ue("ckds-drag-handle", s ? "cursor-move" : "opacity-30 cursor-not-allowed"), children: /* @__PURE__ */ m(vn, { className: "text-base-content" }) }),
+        /* @__PURE__ */ m(_, { variant: "body-sm", className: "text-base-content text-xs grow ml-2", children: t.header }),
+        /* @__PURE__ */ m(
+          Ke,
+          {
+            checked: n[t.accessorKey] !== !1,
+            onChange: () => i(t.accessorKey),
+            disabled: !o,
+            className: "mr-2"
+          }
+        )
+      ]
+    }
+  );
+}
+function Rn({
+  draftConfig: t,
+  setDraftConfig: e,
+  moveDraftColumn: r,
+  handleApplyPref: n,
+  setModalOpen: i,
+  handleResetToDefault: s,
+  isDefault: o,
+  isConfigChanged: a
+}) {
+  const [c, d] = Ee(""), f = Ie(
+    (g) => {
+      e((u) => ({
+        ...u,
+        columnVisibility: {
+          ...u.columnVisibility,
+          [g]: !(u.columnVisibility[g] ?? !0)
+        }
+      }));
+    },
+    [e]
+  ), p = t.columns.filter(
+    (g) => g.header.toLowerCase().includes(c.toLowerCase())
+  );
+  return /* @__PURE__ */ E(Tr, { backend: mn, children: [
+    /* @__PURE__ */ E("div", { className: "ckds-column-manager-wrapper", children: [
+      /* @__PURE__ */ E("div", { className: "flex items-center justify-between", children: [
+        /* @__PURE__ */ m(_, { variant: "body-lg", weight: "semibold", children: "Column Manager" }),
+        /* @__PURE__ */ m(
+          B,
+          {
+            onClick: s,
+            variant: "hyperlink",
+            disabled: o,
+            icons: { left: /* @__PURE__ */ m(Je, {}) },
+            label: "Reset to default"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ E("div", { className: "flex mt-6", children: [
+        /* @__PURE__ */ m(et, { draftConfig: t, setDraftConfig: e }),
+        /* @__PURE__ */ E("div", { className: "flex-1 ml-7", children: [
+          /* @__PURE__ */ m(_, { variant: "body-sm", weight: "medium", children: "Visible Columns" }),
+          /* @__PURE__ */ m(_, { variant: "body-xs", className: "text-base-400", children: "Toggle columns on/off and drag to reorder" }),
+          /* @__PURE__ */ m(
+            "div",
+            {
+              className: `pb-3 mt-4 ${p.length > 9 ? "ckds-search-border-bottom" : ""}`,
+              children: /* @__PURE__ */ E("div", { className: "ckds-search-input-wrapper", children: [
+                /* @__PURE__ */ m(Ze, {}),
+                /* @__PURE__ */ m(
+                  "input",
+                  {
+                    placeholder: "Search here",
+                    className: "ckds-table-search-input",
+                    value: c,
+                    onChange: (g) => d(g.target.value)
+                  }
+                )
+              ] })
+            }
+          ),
+          /* @__PURE__ */ m("div", { children: c && p.length === 0 ? /* @__PURE__ */ m("div", { className: "flex flex-1 items-center justify-center h-[318px]", children: /* @__PURE__ */ m("p", { className: "text-sm text-base-400", children: "No columns found" }) }) : /* @__PURE__ */ m("div", { className: "ckds-dragable-list ckds-custom-scrollbar", children: p.map((g, u) => /* @__PURE__ */ m(
+            Dn,
+            {
+              column: g,
+              index: u,
+              moveListItem: r,
+              visibility: t.columnVisibility,
+              onToggleVisibility: f
+            },
+            g.accessorKey
+          )) }) })
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ E("div", { className: "ckds-column-manager-footer", children: [
+      /* @__PURE__ */ m(
+        B,
+        {
+          onClick: () => i({ open: !1, type: "columnManager", activeOption: "" }),
+          variant: "secondary",
+          size: "large",
+          label: "Cancel"
+        }
+      ),
+      /* @__PURE__ */ m(
+        B,
+        {
+          onClick: n,
+          variant: "primary",
+          size: "large",
+          disabled: !a,
+          label: "Apply"
+        }
+      )
+    ] })
+  ] });
+}
+export {
+  Rn as default
+};